[ODE] Question about variable step size and collision detection

[Per Bull Holmen]

--- Christoph Beyer <boernerb at web.de> skrev:

> 
> My first idea would be to use very small stepsize
> like 0.0001 (fixed or
> unfixed)
> so that small and fast objects are collided
> correctly.
> Maybe using ODE with doubles instead of singles.
> If you have no performance problems this seems to me
> the easiest way.
> But if you have problems with performance, this is
> not very efficient.

I don't have any performance problems, cause I haven't
started implementing it yet... :) I just wanted to
figure out the best tools in advance. I want the game
to run on minimal configurations, because 2D games
can. But I realize that 2D games have requirements
that 3D games don't. You see more precisely what is
happening, because things don't get obscured because
of camera angles etc. This means that when colliding
objects penetrate each others, it will be all too
visible - 2D graphics must be pixel perfect.

Calculating the next position and rotation for each
object, taking into account a velocity vector, torque,
forces applied to it etc, I probably can do on my own
(at least satisfactory for my game). Precise,
bulletproof collision detection I can too, though I'd
like not having to, cause it will be complex.
Collision response, taking into account rotation,
uneven distribution of mass etc... especially when
there are restrictions of freedom, hinges etc (which
there will be much of), I can NOT do.

I was wondering if any of you have an idea how the
following two solutions might work:

1) Bullet physics engine, which has very sophisticated
collision detection, can according to their developer
be used together with ODE's dynamics. This sounds like
a great solution, but I have a feeling it still won't
let me avoid object penetration during impact. Any
experience or knowledge about using the two together
is welcome.

2) Is it possible to use ODE in a more low level kind
of way? Then I could move the objects around myself
according to speed, direction, torque etc. Whenever a
collision is detected, I might call ODE to make it
compute the collision response. I'm worried about that
type of solution cause I think I've read that ODE
discourages to manipulate the objects positions on
your own (not sure though). Is this true? Also, if I
just call ODE's dWorldQuickStep() function to have
this done, I'm actually making guesses about how the
engine is implemented (which isn't the proper OO way
do to something): I'm guessing that it only takes the
objects present position and collision info into
account, and not for instance previous positions and
previous calculations done by ODE's dWorldQuickStep()
or similar functions. Is it possible, or not, to use
ODE this way?

Id like to avoid the very-small-timestep approach
because it would be inefficient, and though it might
work on my rather new IntelMac, it might not work on
older machines.

Per


	
	
		
_________________________________________________________
Alt i én. Få Yahoo! Mail med adressekartotek, kalender og
notisblokk. http://no.mail.yahoo.com