bulled RBD: pieces with small masses fly off with large velocity. how

[anupamd]

Hi guys, I've seen some topics related to this but none of the suggestions have helped. so here goes

 

I have a relatively simple object (roughly a box), that im fracturing with voronoi fracture then pushing off to the side with a windforce.

The issues is some of the pieces that are really small are getting a really huge velocity. If I disable compute mass in the physical attributes, then it all works. 

So I have a feeling its because of very small masses that the problem is ocuring.

 

Is there a workable solution to this that does not involve deleting the small chunks before the sim?

 

if not: how does one go about identifying the small pieces for deletion prior to the sim?

 

Also here are things i've tried that did not work:

1. adding a drag force

2. more substeps,

3. double checking convexity in collision

4. shrinking down the  collisions slightly

 

 

Any help would be great, thanks!

 

[anupamd]

also I noticed a lot of guys using packed prims with a pointwrangle DOP to limit the velocities, problem is I cannot use packed prims for other reasons.

 

[Diego A Grimaldi]

Hey man, it'd be much easier if you could post a scene file but it sound like perhaps your collision geo is not as accurate as it should be.

 

Also you should easily be able to use packed primitives if you follow the right steps, it's fairly simple.

 

If you post your hip we could debug it.

[loudsubs]

Try a multi-solver setup with a pop wrangle. The rbd object in the first input, then bullet solver and pop wrangle in the second input (in that order).  Basically I like to clamp the length of whatever vector, then multiply that back to the normalized vector:

 

float speed = clamp(length(v@v), 0, 15);

v@v = normalize(v@v) * speed;

 

Also,  I've had times when the angular velocity (w) goes crazy and causes exploding pieces.  So the same code can be used to clamp w.

 

Think of each packed piece as just a point, but it gives you the rbd collisions.

[Rainroom]

Since you are not using packed primitives then one solution would be to use a motion node in the dop context and use dopfield() expression to clamp the velocity of the objects. The expression will be lengthy though.