[SOLVED] setLocalScale - Collision mesh

Newbie_Coder · November 15, 2022, 8:14am

Hi there,

Apparently setLocalScale only affects visual mesh, what about collision? Any ways to scale/update it without reloading model? Thanks

yaustar · November 15, 2022, 9:57am

I’ve not tried this myself but you could try:

Disable collision and rigidbody component
Set the scale of the entity
Enable collision and rigidbody component

That should remove and re-add the physics body to the world

Newbie_Coder · November 15, 2022, 10:05am

No effect unfortunately


      scale = otherEntity.getLocalScale();
      otherEntity.collision.enabled = false;
      otherEntity.rigidbody.enabled = false;  
      otherEntity.setLocalScale(scale.x + 0.05, scale.y + 0.05, scale.z + 0.05);
      otherEntity.collision.enabled = true;
      otherEntity.rigidbody.enabled = true;

LeXXik · November 15, 2022, 10:24am

You probably need to remove the cashed mesh in order for the engine to generate a new one with a new scale. So, after you disabled the components, and before you enable them, something like:

// when using render
for (const mesh of entity.collision.render.meshes) {
    delete this.app.systems.collision._triMeshCache[mesh.id];
}

// when using model
for (const instance of entity.collision.model.meshInstances) {
    delete this.app.systems.collision._triMeshCache[instance.mesh.id];
}

Newbie_Coder · November 15, 2022, 10:33am

Hi, no effect either

  scale = otherEntity.getLocalScale();
  otherEntity.collision.enabled = false;
  otherEntity.rigidbody.enabled = false;  
  otherEntity.setLocalScale(scale.x + 0.05, scale.y + 0.05, scale.z + 0.05);

  for (const instance of otherEntity.collision.model.meshInstances) {
  delete this.app.systems.collision._triMeshCache[instance.mesh.id];
  }

  otherEntity.collision.enabled = true;
  otherEntity.rigidbody.enabled = true;

Using debug draw

LeXXik · November 15, 2022, 10:38am

It should work. You need to debug and see why it doesn’t, if it doesn’t.
First, I’d check if it really doesn’t work by changing the scale to something much larger, e.g. multiply the current by 10 scale.x * 10. Perhaps 0.05 is not a noticeable change. I would also try to reset the cache completely, instead of only the affected mesh.

Newbie_Coder · November 15, 2022, 12:08pm

Couldn’t get it to work, tried deleting this.app.systems.collision._triMeshCache - no luck either
Here’s repro PlayCanvas 3D HTML5 Game Engine
KEY_PAGE_UP to increase scale/clear cache

Newbie_Coder · November 15, 2022, 5:04pm

Has to be something else than triMeshCache

Leonidas · November 15, 2022, 5:40pm

You may need in addition to destroy the shape in Ammo:

for (const mesh of entity.collision.render.meshes) {
    const shape = this.app.systems.collision._triMeshCache[mesh.id];
    Ammo.destroy(shape);
    delete this.app.systems.collision._triMeshCache[mesh.id];
}

github.com

playcanvas/engine/blob/96141aad3a19b4d3744a14c4f5198f4416a018d2/src/framework/components/collision/system.js#L792

      
        
                    ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w);
                    transform.setRotation(ammoQuat);
                    Ammo.destroy(ammoQuat);
                    Ammo.destroy(origin);
            
            
        return transform;
                }
            
            
    destroy() {
                    for (const key in this._triMeshCache) {
                        Ammo.destroy(this._triMeshCache[key]);
                    }
            
            
        this._triMeshCache = null;
            
            
        super.destroy();
                }
            }
            
            
Component._buildAccessors(CollisionComponent.prototype, _schema);

Newbie_Coder · November 15, 2022, 6:07pm

Leonidas:

for (const mesh of entity.collision.render.meshes) {
    const shape = this.app.systems.collision._triMeshCache[mesh.id];
    Ammo.destroy(shape);
    delete this.app.systems.collision._triMeshCache[mesh.id];
}

Have you tried this on render? Model throws errors

Isn’t it that Ammo.destroy(this._triMeshCache[key]); requires meshInstance key? As these are actually stored
Nevertheless, using ammo destroy with valid keys throwing ‘Error: Cannot destroy object. (Did you create it yourself?)’

Leonidas · November 15, 2022, 6:22pm

No it’s being actually used in the PlayCanvas engine, I’ve shared the link above.

The logic is it’s not enough to remove the JS reference, Ammo.js occupies a different memory chunk than the one used by regular JS data. So that Ammo.destroy() call is required to clean up that memory.

Now if that solves your problem or not I’m not quite sure. But definitely it shouldn’t give any error if the object is valid. Try using the JS debugger or the console to check that you are using it as expected.

Newbie_Coder · November 15, 2022, 6:29pm

for (const instance of otherEntity.collision.model.meshInstances) {

       const shape = this.app.systems.collision._triMeshCache[instance.mesh.id];

        Ammo.destroy(shape);

  delete this.app.systems.collision._triMeshCache[instance.mesh.id];

  }

RuntimeError: indirect call to null


for (const instance of otherEntity.collision.model.meshInstances) {

       const shape = this.app.systems.collision._triMeshCache[instance.key];

        Ammo.destroy(shape);

  delete this.app.systems.collision._triMeshCache[instance.mesh.id];

  }

TypeError: a is undefined

LeXXik · November 15, 2022, 11:17pm

It looks like it is not easy to change a scale of a collision mesh at runtime at the moment.

Before clearing the cache, you also want to destroy the reference stored in the collision component:

Ammo.destroy(otherEntity.collision.shape);
otherEntity.collision.shape = null;

Related issue:

github.com/playcanvas/engine

Multiple mesh colliders with different scales messes up the collision check.

opened 10:36AM - 24 Aug 20 UTC

Kangsi

### Description The collision check seems to be broken in the case where ther…e are entities using the same mesh collider, but different scales. In this example project (https://playcanvas.com/editor/scene/975942) I have 3 box mesh collider, with the scales 1.5, 1 and 0.5. Using a sphere collider above the boxes I can check the behaviour of these mesh colliders. ![image](https://user-images.githubusercontent.com/8733899/91034650-a1ae4880-e605-11ea-9df7-892e49fbd0f9.png) The colliders are visible and correct when the physics edit mode is toggled on. However, when you play this, the collision check is not correct. After some testing I conclude that the collision only works correctly on the entity last in the scene hierarchy. Here are the links, where you can see the collision behaviour. For each link below I changed the hierarchy order of the box entities, resulting in different behaviours. https://playcanv.as/b/59Qpu04R/ (box with scale 1 is the last entity) https://playcanv.as/b/DrIC5OsJ/ (box with scale 1.5 is the last entity) https://playcanv.as/b/MB2yaplo/ (box with scale 0.5 is the last entity)

Newbie_Coder · November 16, 2022, 6:44am

I can confirm it works as expected

    scale = otherEntity.getLocalScale();
    
    otherEntity.enabled = false;
    Ammo.destroy(otherEntity.collision.shape);
    otherEntity.collision.shape = null;
    otherEntity.setLocalScale(scale.x + 0.05, scale.y + 0.05, scale.z + 0.05);

  for (const instance of otherEntity.collision.model.meshInstances) {
  delete this.app.systems.collision._triMeshCache[instance.mesh.id];
  }

console.log(this.app.systems.collision._triMeshCache);
otherEntity.enabled = true;


}

Thank you folks

Charlie_Van_Norman · May 23, 2025, 9:30pm

Hi, I’m having issues with this solution. When I manually delete cached collision data in

for (const instance of otherEntity.collision.model.meshInstances) {
  delete this.app.systems.collision._triMeshCache[instance.mesh.id];
  } 

Ammo.destroy(otherEntity.collision.shape);

Ammo will randomly (!) throw errors, like this:

Uncaught TypeError: ha[L[((L[(e >> 2)] + 8) >> 2)]] is not a function
    at lh (ammo.js:32:24329)
    at Array.HA (ammo.js:36:38107)
    at Array.EA (ammo.js:32:119491)
    at Uj (ammo.js:34:38987)
    at x.addRigidBody (ammo.js:611:426)
    at RigidBodyComponentSystem.addBody (playcanvas.js:56507:27)
    at RigidBodyComponent.enableSimulation (playcanvas.js:56148:22)
    at set mask (playcanvas.js:56020:15)
    at template.js:117:24
    at Array.forEach (<anonymous>)

I believe what’s happening is other pieces of my game rely on the entity in question, and when its mesh cache is destroyed, sometimes those other pieces ask Ammo for information that I destroyed using this manual call. However, this should not happen if the Ammo deletion and re-creation of the mesh happens instantly — yet it does happen sometimes which leads me to believe that Playcanvas<>Ammo is calculating physics asynchronously (and non-deterministically) to save on performance.

The result is that this manual solution is a non-starter for my use case. I would need to disconnect each reference to that collider and pause the expectation for it to exist while this operation completes during an unknown time.

Is there any other way to scale a mesh collider without directly accessing Ammo mesh caches?

UPDATE: I’ve started a new thread here, and came up with an alternative solution which does not rely on calling Ammo.destroy (which was causing my bug) - https://forum.playcanvas.com/t/setlocalscale-collision-mesh-ammo-js-errors/40022/2

Charlie_Van_Norman · July 10, 2025, 9:50pm

Update2: My above solution still breaks Ammo nondeterministically (out of memory or null ref, “only sometimes”). This solution is working: Multiple Mesh Colliders of Different Scales don't behave properly · Issue #3062 · playcanvas/engine · GitHub

Igor · July 16, 2025, 11:45am

Here’s a snippet to solve the scaling issue for mesh colliders, no warranties/use-at-is:


(function () {
    const app = (pc.AppBase || pc.Application).getApplication();
    app.once('start', () => {

        pc.getScaleUniqueMeshId = (meshId, scale) => {
            const rawMeshId = Math.floor(meshId);
            const precision = 2; //decimal places, 1 means rounding to 0.1, 2 to ~0.01, 3 to ~0.001 etc.
            const roundingPower = Math.pow(10, precision);
            let x = Math.abs(scale.x * roundingPower);
            let y = Math.abs(scale.y * roundingPower);
            let z = Math.abs(scale.z * roundingPower);
            return Number(`${rawMeshId}.${x}${y}${z}`);
        };

        if (typeof Ammo === 'undefined' || !app.systems.collision.implementations.mesh) return console.log('[MeshCollisionSystemImpl] could not detect Ammo');

        const originalCreateAmmoMeshFunction = app.systems.collision.implementations.mesh.createAmmoMesh.toString();
        if (originalCreateAmmoMeshFunction.includes('mesh.id')) {
            const patchedCreateAmmoMeshFunction = originalCreateAmmoMeshFunction.replaceAll('mesh.id', 'pc.getScaleUniqueMeshId(mesh.id, scale)').replaceAll('SEMANTIC_POSITION', 'pc.SEMANTIC_POSITION');
            console.log('[PATCH] MeshCollisionSystemImpl has been patched to support mesh collider scaling');
            app.systems.collision.implementations.mesh.createAmmoMesh = new Function('return ' + patchedCreateAmmoMeshFunction)();
        } else {
            console.warn('[PATCH] Could not patch MeshCollisionSystemImpl: mesh.id is not used in this version of the engine');
        }
    })
})();