Bouncy ball in RealityKit - game

Regarding restitution

Even in the last video here: https://stepinto.vision/example-code/collisions-physics-physics-material/ bounce of the ball is very unnatural - stops after 3-4 bounces.

That is because I never set the restitution to a max value. The wood base in that example has a restitution of 1, but the highest value I used on the ball was 0.7.

Energy Loss: Despite restitution = 1.0 (perfect elasticity), the ball loses ~20-30% energy per bounce

You could set the restitution to 1.0 on both the balls AND the surface(s) they are bouncing on. This won't necessarily be realistic. The balls will essentially bounce infinitely. You'll have to slightly adjust the restitution on one or both of the entity types to make them feel a bit more natural.

Of course, a lot will also depend on your mass and friction values.

You might find it helpful to look at "SwiftShot" physics. It was sample code demonstrating a game like ping-pong for WWDC 2018.

Hi @mike3, thank you for your question!

One variable you can check is linearDamping on the moving entity's PhysicsBodyComponent. This value simulates drag forces (friction with the air) and slows down objects over time as they move in space. By default, this does have a small non-zero value, which means your physics object is likely slowing down a bit over time, which might appear as unexpected energy loss in a bounce.

Additionally, the physical size of your objects can affect the physics simulation. I would not expect to see any issue with objects using real world scales (around 1 meter), but very small or very large objects may start to behave unexpectedly. Please file a bug report using Feedback Assistant and include as much info as possible if you think you are experiencing incorrect physics behavior.

Unfortunately it didn't help much. I've made sample project: https://github.com/michaello/BouncyBall-visionOS/

No matter what I do, i'll get 6 bounces at most. This is not how table tennis ball would behave, on 6th bounce it would keep to, let's say, 10 or 11 bounces. Here's yt video of me running it in simulator with different parameters.

https://www.youtube.com/watch?v=rqWXI8_qTME

I can add pulses artificially but it's getting unmaintainable when i introduce side walls for bouncing.

Thank you for your video @mike3 , I think I understand what is going on. It appears that the physics entities are "sleeping" earlier than expected. This is an optimization the physics engine makes when physics bodies are no longer moving or moving very little. Of course, in your video this sleeping behavior appears broken and for that reason I recommend filing a bug report using Feedback Assistant so that we can get a better understanding of how developers like yourself are encountering this issue.

Because physics entities sleep when their properties are only changing by small values, one thing you could do that may help is increase the size of the physics bodies and colliders, and then place them all under a container entity that you scale down to fit your volume. This way your entities are simulated at a larger scale but visually they remain the same size (Note: the forces you use might need to be increased to move the entities over larger distances in the same amount of time). Check out Handling different-sized objects in physics simulations for more information.

Thank you! The scale workaround sounds interesting, but I'm having difficulty determining the exact implementation approach within my repository structure. I would greatly appreciate your guidance on implementing this solution in code I shared (https://github.com/michaello/BouncyBall-visionOS/). Specifically I'm uncertain about

1. Where in my current entity hierarchy I should introduce the container entity for scaling
2. Whether all physics entities (ball, ground, walls) need to be scaled equally, or if only the ball requires this treatment
3. The recommended scale factor to use (10x, 100x?) to prevent premature sleeping
4. How to properly adjust the initial velocity and gravity values to maintain the same visual behavior at the larger simulation scale

If you could point me toward specific code changes or provide a small example of the container/scaling setup, it would help a lot! I can't find any sample code on internet for it so it's difficult for me to test your suggestion.

Thanks for following up @mike3 ! I took a look at your code and I was able to use the scale approach to eliminate the sleeping issues. The code changes are a bit involved and I don't think I could share an entire diff here, but I'll do my best to explain what I did.

First I created a value to use for our scale, and made it a static let on your PhysicsManager object:

static let worldScale: Float = 100.0;

Then I created a new entity, I'll call it physicsRoot, as a var on your PhysicsManager:

var physicsRoot: Entity?

I initialized it at the start of your setupPhysicsScene function like this:

private func setupPhysicsScene(_ content: RealityViewContent) {
    var physicsSimulation = PhysicsSimulationComponent()
    // You can use PhysicsSimulationComponent to customize gravity in your physics simulations.
    physicsSimulation.gravity = .init(x: 0.0, y: -9.8 * PhysicsManager.worldScale, z: 0.0)
    let physicsRoot = Entity(components: [
        physicsSimulation,
        Transform(scale: SIMD3<Float>.init(repeating: 1.0 / PhysicsManager.worldScale), rotation: .init(), translation: .init()),
    ])
    physicsRoot.name = "Physics Root"
    content.add(physicsRoot)
    appModel.physicsManager.physicsRoot = physicsRoot

When you create your ball and ground entities, remember to scale their shapes and positions too! For example, the ground:

let ground = ModelEntity(
    mesh: .generateBox(width: 0.5 * PhysicsManager.worldScale, height: 0.02 * PhysicsManager.worldScale, depth: 0.5 * PhysicsManager.worldScale),
    materials: [SimpleMaterial(color: .gray, isMetallic: false)]
)
ground.position = [0, -0.01, 0] * PhysicsManager.worldScale

// ...

// Remember to have the ground be descended from the physicsRoot Entity, don't add it directly to the content anymore!
ground.setParent(physicsRoot)

One more thing, I notice you are using generateCollisionShapes(recursive: ) to generate the collision component for the ball. This won't work as you expect, since the collision shape your sample is currently generating is a cube. Instead, you can generate a sphere shape and set the collision component directly:

private func createBall(radius: Float) -> ModelEntity {
    let ballShape = ShapeResource.generateSphere(radius: radius * PhysicsManager.worldScale)
    let ball = ModelEntity(
        mesh: MeshResource(shape: ballShape),
        materials: [SimpleMaterial(color: .systemBlue, isMetallic: true)],
    )
    ball.components.set(CollisionComponent(shapes: [ballShape], isStatic: false))

So answering your questions:

1. It should be a single container entity that all of your current entities go under. Put a PhysicsSimulationComponent on this entity so you can control gravity. Right now you are adding your objects to the RealityViewContent object directly, so instead create this new container entity and add it to the content, then instead of adding your other physics entities to content, add them to the scene using setParent(_ ) with the container entity as the parent.
2. Everything needs to be initialized with scaled-up values (although some entities like directional lights are unaffected by scale), and then the physicsRoot is scaled down inversely so the objects are still rendered at their original size. So instead of simulating something like a basketball, you are literally simulating a ball the size of a building.
3. I used 100 for the scale at first. 10 also seems to work for your sample project, but I think developers should experiment to determine what works best for them.
4. I am not a physics expert, but it seems that forces are directly proportional. So if your scene is 100x larger, make gravity and all other forces 100x larger as well.

Thank you for your questions!

Hello sir, thank you for the detailed answer. I've applied your suggested changes here: https://github.com/michaello/BouncyBall-visionOS/commit/13dbf8ade99de3f93da6812eccc1f77db5f24221

However, I'm still experiencing two physics issues:

1. Ball isn't bouncy enough - Even with restitution = 1.0 and the scaled simulation, the ball loses energy quickly and doesn't maintain realistic bouncing behavior
2. Infinite bouncing with low damping - When linearDamping < 0.7, the ball bounces indefinitely without losing height, suggesting the scaling might be preventing the physics engine from properly detecting when motion should stop

Have you encountered similar issues with the scaled physics approach? Should I be adjusting other parameters like mass or exploring different scale factors? The ball seems stuck between "not bouncy enough" and "too bouncy" depending on damping values.

Example: https://youtube.com/shorts/sLlqGcA3cKc