How Bounding Shapes works in FXGL?

[LifeDrainingCoding]

Here's an example: This screenshot shows Bounding Shapes of the entities with blue lines (Enabled via developer menu). You see that bounding shape doesn't match view? .

I assume that happens b'cuz Circle view starting constructing from the center point and BoundingShape.circle starting point is top-left. I wonder WHY circle bounding shape constructs from the top-left of the starting point and view Circle (that one extends Node) where starting point is the center of the view citcle?

Alright, that's not the main case and can be easily fixed but that is annoying. The main case is why BoundingShape.circle() isn't responsible for collision? Why View component serve that role? And bounding shapes just phases freely through other bounding shapes even with collidable components that's has boolean property is true.

On the screenshot below you can clearly see that bounding shape completly phases freely through other bounding shape and only the center of circle view that is red preventing them from escaping to out of bounds.

To prove that i'm not yapping for no reason here's my entity with circle bounding shape and circle view , and you can easily test that on your own.

public class Marble extends Entity {

    protected boolean isShooting =false;
    protected PhysicsComponent physics;
    protected BodyDef bodyDef;
    protected FixtureDef fixtureDef;
    protected ViewComponent view;
    protected BoundingBoxComponent bbox;
    protected TimerComponent timer = new TimerComponent();
    protected double radius, mass,area , density = 0;

    public Marble(SpawnData data) {
        super();
        setX(data.getX());
        setY(data.getY());
        setType(TypeOf.MARBLE_TYPE);
        radius = data.get(RADIUS);
        mass = data.get(MASS);

        bodyDef = new BodyDef();
        bodyDef.setUserData(UUID.randomUUID().toString());
        fixtureDef = new FixtureDef();
        fixtureDef.setFriction(0.1f);
        fixtureDef.setRestitution(0.1f);
        updateMassRelated(0);

        view = getComponent(ViewComponent.class);

        physics = new PhysicsComponent();
        physics.setBodyDef(bodyDef);
        physics.setFixtureDef(fixtureDef);
        physics.setBodyType(BodyType.DYNAMIC);

        bbox = getBoundingBoxComponent();
        updateBody();

        addComponent(new CollidableComponent(true));
        addComponent(physics);
        addComponent(timer);
    }



    public void setRadius(double radius) {
        this.radius = radius;

        updateMassRelated(density);
        updateBody();
    }

    public double getRadius() {
        return radius;
    }

    public void setMass(double mass) {
        this.mass = mass;

        updateMassRelated(density);
    }

    public void setDensity(double density) {
        updateMassRelated(density);
    }

   public String getUID(){
        return ((String) bodyDef.getUserData());
   }

    /*This should be calculated automatically when changing mass\area\density in FXGL,
         but we have to do it manually */
    public void updateMassRelated(double density){
        area = Math.PI * radius * radius;

        //checking if density was changed, if not recalc density, if yes then calc mass
        if (this.density == 0 || Double.compare(this.density, density) == 0) {
            this.density = mass/area;
        }else {
            mass = density*area;
            this.density = density;
        }

        fixtureDef.setDensity((float) this.density);
    }

    public void updateBody(){


//        List<Point2D> points = new ArrayList<>();
//        int vertices = 15;
//        double cx = circle.getCenterX();
//        double cy = circle.getCenterY();
//        for (int i = 0; i < vertices; i++) {
//            double angle = 2*Math.PI*i/vertices;
//            double x  = cx + (Math.cos(angle)*radius);
//            double y = cy + (Math.sin(angle)*radius);
//            points.add(new Point2D(x, y));
//        }

        view.clearChildren();
        Circle circle = new Circle(radius, Color.RED);
        view.addChild(circle, false);
        bbox.clearHitBoxes();
        HitBox hitBox = new HitBox(BoundingShape.circle( radius));
        bbox.addHitBox(hitBox);



        setupTimer();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Marble marble) {
            if (marble.getUID().equals(getUID())) {
                return true;
            }
        }
        return super.equals(obj);
    }
    public void startShooting(){
        if (!isShooting){
            isShooting = true;
           setupTimer();
        }

    }

    public void  shoot(){
//        if (isActive()) {
//
//            double x, y;
//            SpawnData spawnData =   new SpawnData(0, 0);
//            spawnData.put(OWNER, this);
//            Bullet bullet = new Bullet(spawnData);
//            x = radius * Math.cos(bullet.getRadiansDirection())+getX();
//            y = radius * Math.sin(bullet.getRadiansDirection())+getY();
//            bullet.setPosition(x, y);
//
//            FXGL.getGameWorld().addEntity(bullet);
//        }
    }
    private void setupTimer(){
        timer.clear();
        timer.runAtInterval(this::shoot, Duration.millis(1500*(FXGLTest.DEFAULT_RADIUS / Math.pow(radius, 1.4))));
    }
}

Alright after fixing that local origin of bounding box (just substract it by radius): HitBox hitBox = new HitBox(new Point2D(-radius, -radius),BoundingShape.circle( radius)); and we have bounding circle that mathces the view circle. And the most funny thing is that this fixed issue with bounding shapes that 'phases' through other bounding shape(Actually not). I suppose that is debug renderer issue , so when entity spins it shows that bounding shape that's anchored on the top left origin is also spinning BUT actually it doesn't spins at all as it shows by enabling that option on the screenshot:

That's was fun way to define why debug renderer is partially lying to me.