so my name is Curie I may be talking
about physics for I'm gonna try and
sling through this as quick as possible
just so we can hit the times and so
physics is a scalable robust a rigidbody
simulation and we've been developing
this for over a decade of continuous
development and it's basically become a
ubiquitous feature in the computer games
industry it offers a scalable and robust
cross-platform simulation engine that
can scale to simulate on basically
anything from a mobile phone to a games
console PC and even onto GPUs to
accelerate further it comes with a whole
host of things not just a runtime
simulation but also it provides logging
and profiling tools that will allow you
to kind of visualize capture the scenes
and scrub backwards and forwards in them
and kind of find out where where maybe
your performance problems or behavioral
problems originated from and you can
also export these into a serializable
format that you can transfer to us to be
able to look it at these and also to
create reproductions and in isolated
cases the rigid bodies in physics
basically offer a efficient and accurate
distance based contact generation and
it's got two different forms of ccd it's
got a suite based ccd and more recently
added speculative ccd which is a
distance based contact generation method
that then run through the solver it's
got support for a number of their joint
types common ones like spherical
revolute which is a hinge joint fixed
prismatic which are sliders and distance
joints and in addition it has support
for custom joint types as well so you
can define your own joints and we have
snippets to come with the SDK
demonstrating things like how to make a
pulley but you can go further than that
and that various things to it and it's
got fast and robust robust iterative
solver and which has been tried and
tested in numerous games and not only
that but it's been used in visual
effects in various other things as well
it's got an extremely efficient Essen
query system which supports raycast
sweeps and overlaps and in addition it's
got extensions that are built into it
and some of the key ones that are
interesting for game developers might be
vehicles and characters and and in
addition more recently it's it's
introduced a second interface so it's
got its classic
retained mode which we call which
involves populating scenes and
simulating those scenes but it's also
got an immediate mode which exposes
low-level functionality like contact
generation the constraint solver
integration etc and we talk about that a
little bit later as well and so physics
for compared to physics 3 introduced to
us almost an open-source BSD license it
was released in December last year and
and where that differs from what we've
done in the past is you no longer have a
EULA that you need to click through and
agree to and this allows gives you the
flexibility to include the source code
in your projects and potentially ship
the source code for those projects it
introduces TGS temporal gauss-seidel
which is our new more robust and
nonlinear rigid body solver we'll talk
about that all bit later and it also
introduces the new rigid body reduced
coordinate articulation implementation
which again we'll talk about a little
bit later it provides the goals of these
two things which is an improved solver
and the articulations and leverages what
physics did great already which is the
kind of performance and the scalability
and as a result it provides that kind of
game level performance and scalability
combined with now and the simulation
quality that you might need for
something more serious like robotics or
research work and this explore also
introduced a much more scalable broad
face and in the past we had two versions
we had a supermoon and we had MVP which
is multi box pruning
with MVP it was extremely scalable but
you had to define regions and with the
newer one you no longer need to find
regions and you get the same kind of
performance or in fact in some cases
better it's got an overall joint
simulate joint implementation which
makes it much more coherent to work with
and much easier to kind of configure the
joints in the way that you want and
there are significant optimizations and
there as well for complex multi shape
actors including and extensions in the
syncro system and in the in the
simulation side of things and and this
is just a subset of things there's a lot
of other things that were optimized and
improved and so the temporal
gauss-seidel solver as we mentioned is
our non-linear iterative solver and and
what it basically offers you is improve
robustness to ill-conditioned cases
and so the crook saw that is that it's
significantly faster converging it's
it's roughly quadratic converging rather
than linear or sub linear with PGs or
Jacobi or other commonly used a
real-time game solvers and as a result
of that it has a much better handling of
high mass ratios and and it also has
some nice little added bonuses with this
approach and one of them is gentle to
penetration and so classically to
implement gentle deep penetration what
you might do is have issues something
like split impulses where you solve on
the positional level with bias and you
solve on a velocity level without bias
and effectively what you do is you step
forward the state with the positional
state while you carry over the velocity
state and but the drawback with this if
you do a pure & Spell impulse approach
is that the convergence content it tends
to reduce significantly and this doesn't
happen with TDS you still get the great
convergence but you get this for free it
has improved drunk-drive handling and
namely because um well it's iterating
it's actually really ating errors in
calculating and any kind of them
numerical drift that it's performing
while it's simulating so it can correct
that to get you the right answers and
the final thing that's really cool about
it is it performs almost exactly the
same as the classical PGs solver which
is one of the fastest types of solvers
you can use and so we'll do a little
example
hopefully that's playing it is it's not
on my screen okay so um in this case
we've got it a pair of motorized a hinge
joints all set up to spin around on the
top we've got PGs struggling to kind of
keep things in line and going a bit off
on TGS it is a pretty much robust and
this is actually just using 16
iterations to do this it's an extremely
difficult challenging problem for a for
a maximal constraint solver but this
handles it correctly and we'll go into a
few more examples and so this next
example is again this is a heavy weight
on the end of a chain the bottom one is
TGS and the top one is PGS this is using
just four iterations so with four
iterations we have
128 - one last ratio the chain weighs
one unit and the thing that it's
swinging is 128 you can see a little bit
of stretching with tgs this disappears
if you give it a few moderations but we
just wanted to show this particular case
now the interesting thing is because of
the convergence rate on that we can go a
lot higher than 100 100 to 1 mass ratio
so if we take it to 10,000 - one last
ratio and you can actually solve this
and with the TGS solver with just 12
iterations it would take it over a
hundred iterations to solve with PGS
with a hundred to one mass ratio and at
ten thousand one it's actually requires
in excess of ten thousand iterations to
get the same result as 12 with tgs so
this is another case where it benefits
and which is simulating and smaller
things so we've shown a demo like this
before I have one physics three point
four shift which was am called a Kapler
demo and we had a number of bricks that
were kind of towered up to make some
kind of cylindrical Tower and that
simulated stabili with eight iterations
but the thing that you don't realize is
that the bricks themselves were about
two meters wide they were absolutely
enormous and and when you do that the
the problem becomes a little bit easier
because well the solvers can converge
there they're more tolerant to error mmm
and in addition to that the demo
actually also had a few little tweaks in
it it made use of a feature called
stabilization which which are just some
things to make it more stable
um and we also tweak-d inertia's on the
objects in that demo so we had a few
things to make it be really robust to
eight iterations in this case there's
none of those tricks at all and TGS is
able to handle that and there's no
swimming or any kind of issues when you
see them forming in the pile or when
they're stacked up and you can get the
same behavior out of this with the PGS
solver but it requires somewhere between
about 64 and 128 iterations to do it and
again this is just eight iterations with
TGS
so the last one that we're gonna show is
just a convergence graph that shows the
kind of differences between the two of
them and so what we have is at the top
we have the PGS solver trying to handle
this ten thousand one mass ratio
we're using 30 solver iterations in this
on both cases and the reason why were
using 30 is because that is enough that
the error that goes down when we're
calculating the error doesn't create the
graph it doesn't create graph that is so
big with the oscillation so why do it's
hard to kind of see any resolution on
TGS um but yeah but the TGS solver you
have a very small amount of oscillation
which which stamps away and goes away
after a small amount of time and then if
you run a few more iterations again the
the oscillation and earlier but
generally it converges and handles that
case really well reduce coordinate
articulations and so what we support
here is um a new feature for physics for
it's a hierarchical a kinematic tree
multi-body system when we define
something as being reduced coordinates
that sometimes in in robotics that's
termed generalized coordinates basically
it's a type of way of representing
joints that can be solved with
guaranteed zero error um our
implementation currently supports fixed
revolute spherical and prismatic joints
and their support for limits pv drive
controllers which can also be used to
create spring-like behaviour and as
joint friction which is computed from at
the joint load that's being carried out
that's called a transition force as
support for loop joints self collisions
and interactions with external bodies
and these are handled through the PGS or
TGS solver depending on which one you're
using it has support for inverse
dynamics as well for model-based control
so you can use this to compute and the
forces and stalks that would be required
the joint forces and joint talks would
be required to do things like counteract
gravity cataracts Coriolis to
centrifugal force or you know even
respond to collisions and and make you
know a robot or some kind of humor
eating balance and and it closely
matches analytical models who's being
validated both internally within our
team internally and NVIDIA within the
robotics team and then also externally
by some partner by some partners
robotics guys always they love to
validate things and make sure that
they're right and and it's got a deep
integration with TGS solver and that has
a nice in
result that we actually benefit from
improved simulation robustness in a lot
of cases with the articulations there
are some cases where you do to a
combining of a nonlinear effects with
the reduced coordinate articulations
with a linear approximate solver you can
end up in cases where it's very
difficult to solve and the tgs solver is
able to handle those cases a lot better
and so we got some examples here so the
first one is the physics warehouse demo
this audio and this is a fish this is
like kind of emily is semi
professionally voiced but unfortunately
we don't have audio here so I'll go over
the top and trends here so in here we
have Frankie robot picking up and bricks
and stacking them and which is just
showing a the accuracy of the
manipulation and the accuracy of the
drives to be able to do this
and that guy doesn't like it this was
like a running joke we had like the is
basically like the Two Ronnies or
something just fighting against each
other
so this wrote this scene demonstrates
both they're a careful manipulation
affair doors and the accuracy of the
doors
well you're not seeing there is that the
hinge is actually not a hinge it's a
it's something called a foxhole hinge
which has got about seven degrees of
freedom on each door because robotics
people really like accuracy and there's
over three hundred things inside that
cupboard it's interacting with them
pushing around in this case we have a
game of chess between on the right the
physics for reduced articulation solver
and on the Left we superimposed physics
three-point-four solver using air
maximal coordinates so as you can see
the one on the right can follow its
trajectory really well and the one on
the left really has some problems and
this shows the robustness of the of the
solver its solving and parallel
kinematics structures so in this case we
have an articulation and simulating this
is a lift and then here showing the mass
ratio handling so something that you've
seen before the TGS solver so that ball
there is a got a 1 to 1 to 1 ratio with
the mass of the ball that one has a 1 to
100 and then this final one has a 1 to
10,000 ratios as you can see this robot
really can't move this giant heavy ball
very much but it also shows the accuracy
of the collision detection that's
pinpoint accurate and so the next thing
we're gonna show hopefully it's not
gonna play that again is it ok is add
some reinforcement learning results so
in this case what we're gonna show is as
some results from my colleague down here
David who trained at you works at ETH
any trained animal to walk using our gym
environment and physics round-eyed only
did he trained it to walk but he trained
it's Pedro bus to disturbances and got
really good results and then we decided
to go a bit crazy and we filled the
world with about 50,000 rigid bodies
that are on the ground and trained it to
walk all over those
and it eventually trains to do that
pretty well and so that is physics for
that's what came out in December and now
the next stage that we are we talking
about is hair what's coming next
oh sorry no I have one more bit and then
it goes to her sorry so immediate mode
as we mentioned before it provides
direct access to the physics low-level
functionality so you get contact
generation constraint definitions
low-level rigidbody solver and it's
extremely low overhead by that we mean
it's overhead is basically zero so it's
ideally suited to some of the cases
where physics might like a larger engine
like physics may have struggled before
which would be and when simulating very
small and sets of bodies it but absolute
minimum latency as possible and fly
through this on the Left we have
retained mode which is the classical
physics you create a scene you add the
actors to it you simulate it and you
call fetch results that's your answer
immediate mode is much more data-driven
so in that you create your array of
rigidbody data you handled your arrays
of shapes or geometries and and you
explicitly do things like apply gravity
to them apply forces to them you
generate the contacts and you actually
choose which things you want to generate
contacts against you can create the
contact constraints or joint constraints
whatever you want to do you solve them
and you integrate the bodies all of this
just happens in this small little
dataset that you manage and it's
perfectly suited for things like
embedded simulations and then the final
thing that comes with physics for with
GPU rigid bodies so as mentioned this is
a hybrid CPU GPU rigid body simulations
so it means part of the pipeline runs on
the cpu pipeline runs on the GPU and
it's enabled on the scene with just a
single flag and you set up the scene you
tell to run GPU you need to initialize
Kuder as well which is one of the
function call and then what you're faced
with is exactly the same interface that
we use for CPU simulation exactly the
same set of features and hopefully
significantly faster performance and it
automatically handles all the transfer
of data between the host and device so
therefore you can interact
the simulation just like you would if it
was a CPU simulation there's no latency
and not worry about diem aying things
back or managing it all this is handled
by physics internally and as a result
it's designed for not just a visual
effect but also for scaling up your
interactive gameplay affecting
simulations and that really is the end
of me so I'll move over so I'm right and
so um thanks for my colleague here and
then he keep us an overview of all the
features in physical coil so today I'm
super exciting because I'm going to
describe in better
that's preset 4.1 oh I'm sorry I'm sorry
not but and and this piece of 0.1 has
been released in github on Wednesday so
please feel free to go to get up and
down low and pray around right because
anti is really me so I'm going to
shorten my content a lot so I'm going to
just fry a lot of stuff right
so in Pfister 4.1 we extend immediate
multi support articulation and TTS OA
also it has support for the interaction
between a decoration and teachers and
PJs so ah this way the application can
benefit from simulating small along
scenarios and also have a completely
full control of the scene simulation
pilot what attenti for all those a
decision to FISA retain mode secondly we
have implement to be you accelerated
articulations although this is an early
prototype stage it has been so large
performant game in large-scale scene so
I will show you some performance slice
later performance figures in addition of
course we have a sixth circuit
significantly optimized the CPU
articulation and specific fish lots of
perks on the way right so this is the
equation so on so in in physical coil we
have introduced at atticus over for
something internal joy limit joyce joyce
and joy frisian it's expo expose the
structure of the art equation so it
cancel or internal cancer in order n
time in visa 4.1 we extend this approach
to also support our content and new job
interrupt mr. started object started
richer bodies and we are going to we
will be extent this approach to support
a telemetry to both as well in the in
addition the self collision Lucho
implementation has been significantly
optimized so now we motorized the cost
of propagating in posts for multiple
lengths in the same articulation because
we extend the data case over to support
external content and joists and this
approach how the house the solar
converge on an answer that satisfy all
constraint affecting the art equation
also as a result this included behavior
of joy try and limit when there are
external constraints affecting the earth
equations also we improve the spherical
joy support this is still in progress
but we have in input several cases where
spherical joy did not function as
expected in viscid for coil and
furthermore we have a really low pass
approach to resort at the final issue in
in work and this will be addition right
so this is the exciting part this is the
one we are talking about the performance
improvements in this thing we have a
certain length training as an at
equation with additional joy to call the
loop HP offer children children
parenting within the at equation its
connect by spherical joy with notational
limit on all three axis and also with a
small amount more efficient and so we
some we similar like all the
transmission in there as well as can be
seen from the missile as I said for
point one integration solar
provide performance but it's around two
times faster than freezer 4.0 in this
case the physical one take approximately
six milliseconds to simulate a thousand
train while falling and a minute seconds
when they are in contact with the ground
however in physical coil is talk around
ten million seconds and sixteen minutes
seconds respectively as the capacity of
the articulation increases so if the
degree of freedom inside the that your
joy is increased and also the laying in
the same articulation increase the new
articulations of what will provide even
larger
improvement um yeah
Kia already talked about a good thing
about a medium oh so we extend the
immediate multi support at equations so
compare is a retain mode immediate mode
is a set of a simple API to allow you to
have a full control of the simulation PI
light in medium will provide direct
access to Joe Ling and joy properties
it's also provide direct access to at
equation forward eliminations if it
there are contact Ludo in the
articulation system at the a medium or
also a lot are access to the Lola or so
on to so content and new choice this
include ourself constraints consider
between different equations and also can
stretch in the art equation and the rich
bodies we have created really nice
asleep to show how to use the medium oh
please feel free to go to down low and
have a pray right and so I'm in this
slide we are sewing and just one
articulation and this is the perfect
case to use immediate mode this is
comparing the performance of a simple
arm driven by an arbitrary velocity it
is similar using post written mode and
immediate mode the retain most
simulation is so here using for workers
rest and zero works respectively as can
be seen there is significantly overhead
simulating using written mode for the
retain mode when it is using false red
to simulate the simulation in walks
kicking off lots of different tasks and
collect those tasks with at a strength
this task potentially jump each is read
causing unnecessary cache misses in
addition when a task is ready to excuse
it must a single it went to e to the
address rep to work rate and map
therefore in simple scene night days
just one articulation
motivating doesn't have at all on the
contrary it sat on overhead one single
however when simulating using zero
stress in FISA there will be no routine
is involved so the cache colon and
singularly singling issues are removed
however the performance is still
significantly slow
than immediate mo this is still to the
simulations to go in salute the normal
routine for example both prophase and
Ludlow phrase Shay interaction and
management so an integration also
fulfilling and prepare in synchrony data
etc however for immediate mo the user
can choose to enclose a significant part
of the rich body by line and just call
articulations over and the integration
in this scene so now we have a scene
half a 400 independent motorized hinge
articulation so when the same become
larger we can seen from the graph that
immediate mo a performance roughly much
zero threat mr. mo this is because the
overhead of simulating a scene become
relative small as the capacity of the
scene increase as there are four hundred
article a ship in simulate we can
leverage a multi threat to improve
performance immediate itself does not
support multi-threading however the
application can use a multi stress to
simulate multi articulation in immediate
mode in Paola's so using force wrap each
simulating a hundred of this a motorized
hinge allow us to get Lily perfect as
rascally as for retain mode it's a
support motifs are threatened however
it's assumed that the actor in the sink
and interact with each other so as such
it does not get perfect scowling
even in case like this scene where
Purvis scaling can be achieved we could
however a cheaper first scaling with
written mo in this scene by simulating
for independent scene
containing hundred articulation using
one's rep passing in this case the
average cost of articulation when
simulating using either either the sorry
idle immediate mo or written mo with the
serious threat it's approximately 15
microseconds so this is a pretty amazing
result this is the same performance that
was a tree with a single articulation
using immediate mode okay however now we
are showing a scene and four hundred
articulation is all
interacting with each others so in this
scene right we have 400 education all
falling into a pie on the ground we can
see from the graph that retainer we
suppose rests significantly
outperforming immediate Moe and Rita
Mauricio's right this is because when
the workload is not in the retina
we have heavily optimized our poor face
to curl curl away pairs and efficient us
island manager two separate simulation
into islands too pomo Patek cache
coherence in the solar and state
management to cache information between
frame to skip some computation for
example the contention and all of this
will help assessor a performance
furthermore retainment can leverage
motifs read by self in large island in
power multi thread at in collision
detection and integration as well as the
this simulation cannot be broken into
multiple independent simulations this is
not children to may use of a motivate
you when it's using a medium oh right
and not but not least is our GPU
articulations sorry I'm okay so this is
still in experimental feature however
the forward alum a power of the
activation has been completely implement
and well optimized in GPU and GPU as a
selection is enable on pressing paces in
reset in fisa 4.0 if the user wants to
use GPU visibility they were not
permitted like a decoration to the scene
therefore article articulation will only
support on CPU however in Vista 4.1
we have introduced support for pts over
with articulation on GPU we will add
support for the teachers in the near
future
although the chip GPU at equations
teacher is experimental we have done
some internal branch benchmark on some
large scale scenes even at this early
stage it has been so that GPU
articulation can provide a significant
performance applique compared to the cpu
implementations right so in this scene
we are using we comparing the
performance in CPU GPU and so in
seen the CPU spec it's I say one fine
night free okay and we using Chara in
here and the GPU is Titan we so the
green eye is the CPU simulation full
frame time is roughly around 14
milliseconds a purple line in this in
the graph is the GPU simulation full
frame time is around six milliseconds
the blue line is the time is techtube
actually similarly 2500 art equation on
the GPU la cantine overhead so that's
around too many seconds so it's a pretty
huge performant game we of course we
have the GPU its articulation its work
in progress and then we still have some
work to go at that but it's I'm not
going to go further because at the time
so any question police asked me after
after the presentation thanks okay
am I on again okay and so the final
stage of this is a little section called
beyond game vehicle physics and it was
another presenter that was originally
planned to present this but they
couldn't be here so I will do my best to
fill issues as best I can so physics
vehicles this is an extension library
for the PhysX SDK and it was written
originally for games the entire purpose
of it was simply to simplify adding
vehicles to your games so you didn't
need to have an expert in vehicle
dynamics to be able to add some fun
gameplay with vehicles into your game
and to be able to kind of introduce a
new gameplay feature however physics
vehicles are now actually being used in
part of their Nvidia Drive sim which is
our airsoft driving aircar training and
the questions the the arose from that
were basically would physics vehicles
something that was originally designed
for games actually be suitable for use
in something that's a non gaming
application and and the real question
behind that is exactly how I
is the physics vehicle model um so first
let's define what a physics vehicle is
and so it has an engine which is
basically a 1d rigidbody which has some
either user or manufacturer or whatever
defined hair drive torque curves and
some damping and end in resistance it
has a drivetrain and so the usual things
you'd expect clutch gearbox all that
type of stuff and it has suspension
system using spring dampers with wheels
that are connected which are 1d rigid
bodies they can only rotate around the
degree of freedom and the tire model has
longitudinal and lateral lateral slip
angles for sub forces as a nonlinear
response and and friction with with the
ground or surfaces that is driving on
and then in addition to that is the
three V rigid body which is the chassis
of the car and with that you can join
other things to it like side cars
trailers using physics joints in physics
rigid bodies and then all your collision
detection integration everything so that
portion of the simulation it uses
physics rigid body dynamics and
effectively what boils down to is a
number of forces and torques that are
applied through the through the rigid
body to make it behave like a vehicle
and so for validation and so as we
discussed before and the articulations
were heavily validated internally and
externally so as soon as you want to use
physics for something that isn't game or
visual effects it doesn't did the goal
of it isn't to look good but it's to
actually be somewhat accurate you have
to validate that model somehow and so we
were lucky enough to have received a
ground truth dataset provided by a
self-driving car team and from that we
set about trying to configure the
vehicle data so that it could closely
match the reference vehicle and once
we've done that then we've made attempts
to compare the simulation results and
now the example cases that we would dare
test in at the moment of fairly limited
and fairly simple but they're things
that we could we could we had available
from our current truce and we were able
to compare so we feel that these were
representative of fair what someone
might do in
be safe driving behaviors so things like
testing acceleration testing baking take
testing basic things like Lane changing
so this is the type of thing that like a
level two self-driving vehicle might
need to do and so the test methodology
we took driving input steering values of
value to the steering and the brake file
use and throttle values and they were
updated at 75 Hertz because that's what
we had our simulation was at was at 1
kilohertz so thousand Hertz air that was
to try and promote as higher-quality as
we could possibly get make sure there
was very little integration error in
there and then and this one's a bit
fuzzy we attempted to drive on the same
road geometry with the same friction
properties it's pretty hard to compare
that with reality but we did our best
and then we sampled the simulation State
so wheel rolling speed vehicle speed at
real-time frequencies in this case it
was at 60 Hertz which was how fast our
simulator was ticking and for the actual
rendering side anyway and then we plot
the trajectories in the maneuvers so at
the first one we've got is throttling
and braking so we rev the engine we
engage the clutch and we accelerate to
the top speed that the first gear can
possibly have and then at 30 seconds we
apply the brakes so the green line is
physics and the blue line is our
reference model and as you can see the
physics actually matches it very closely
for about the first seven seconds and
then once it gets past a little hump in
the torque curve it goes it accelerates
slightly faster than the reference but
it's very very close if you go looking
at the numbers which are centimeters per
second you're seeing that were we're
extremely Koch's then when we slammed on
the break the braking behavior is almost
exactly the same and so the top graph is
the vehicle speed in the bottom graph is
the wheel rolling speed which are
obviously very closely related and then
we looked at the lane change maneuver so
again the game here with the bar what we
did here was satrap the engine and grade
two clutch throttle forwards we began a
lane change maneuver at ten seconds and
we finished it at sixteen seconds so
what we've got is we've got again the
wheel rolling speed graph there so again
and in the run-up to to the lane change
maneuver
the velocity is fairly similar it
diverges again at about our seven eight
seconds which was where we where were
you know it's before and then when we do
this steering we can see that we both
end up in the same Lane and we're
roughly parallel to each other but it's
not quite in exactly the same position
and again that's because of this small
divergence here and but it's pretty
close it's impressively close and so
limitations okay well the first obvious
one is that that's only two cases and
they'd seem pretty easy but but it does
actually match those cases pretty well
in those describe air conditions we are
pretty convinced this wouldn't extend to
all maneuvers and there are obviously
simplifications to the drive model tire
model and things like that and when you
drive in a more extreme measure which
would be cases where for example the
tires might might slip if you're taking
you know hard steering and things like
that slamming brakes on then at those
points and the models are likely to
diverge but in cases of relatively safe
driving and the models might be
reasonably similar you can see that
there's some divergence and but in
reality if you're steering and then
steering again to move into lanes and
nobody does it by steering holding it
for four seconds then steering back and
correctly you it's a feedback loop and
the other restriction on this is it
assumes perfect driving conditions we
have no notion of whether of you know
moisture on the road or anything like
that and that would require a
significant amount of investment or
effort to try and approximate that in
some way but it's an interesting set of
results at least and so the last thing
is our question slide and we've included
a little demo and which is and this is a
vehicle that's made with our reduced
coordinate articulations and so as you
can see as we get in close you can see
all of the different parts it's got
Springs it's got calipers it's got
double wishbone suspension on both sides
and it's able to fully interact with not
only the static environment with all the
dynamic environment driving over things
having nice fizz expect but anyway so
while let's plane do we have any
questions no questions oh we do have a
question look at me and of a legal
licensing question we have an in-house
physics engine at my studio and you guys
are BSD license now right which is
awesome
are you aware of any patents or other
legal issues if we were to not take your
code directly but re-implement some of
the algorithms that you have like the
TGS solver I want to take this one Adam
is a low comparator so you have better
tossing I'll have my lawyer talk to your
lawyer track that when you have an
impulse impulses are propagated
throughout the articulated body right
and that doesn't resemble reality
because in reality the shock propagation
would be slower and this can give
certain artifacts did you fix that in
any way in the code how are you dealing
with those you're absolutely right that
there are issues with the reduced cord
in a model where when there is an
impulse applied and you like for example
a box on there attached to something
that because of the way that it rotates
through the whole system you end up with
something that goes off sometimes and in
a lot of cases with the PGS solver that
actually works fairly well yeah and with
the TGS offer it works a little bit
better primarily because of the way that
it handles that non-linearity but there
are obviously still some cases where
where this is not a solved problem so I
would not say in any way that this is
this is 100% solved I would say that
this is this is easily competitive with
whatever
one else does and I think we have some
advantages but but yeah I think one
thing lead to stress in here as well the
target photo reduce a quarter system
it's a robot right so when you're moving
the robot and then if he I mean you
touch the rule but you already know all
the joy and everything it's really Steve
you know you won't have the game pain
effect in reality yeah if you only have
like forces stretch forces then then
everything's fine but but like in games
you wanna yeah yeah yeah you want a
punch okay so you can have fun maybe you
know you stop state your system and then
you could some put some intercept
damping and then you also can have a one
treat for the gaming right it's a
manipulate your intercept answer there's
a lot of different locks a way you can
make it look good yes I mean when we so
so with the implementation that we
currently have and because it's targeted
towards the robotic side of things it
lacks a lot of the kind of things that
would be added into a gameplay version
which would generally involve kind of
manipulating the inertia based on
perceived loads and things like that but
you can actually do that that
information is available and you can do
it through the API it just doesn't do it
automatically for you now it may be the
case that if we get a lot of feedback
saying that hey we really want this and
that we can add in flags or modes to be
able to do that it's much more so it's
so it results these issues for game
developers but you can also do it
internally well it's actually if your
game gameplay scenario right I will just
recommend you use the TGI so it may it
may mean more science is a maximum
quality system right it's don't have all
this creep out Lou and your father can
control much easier so again the reduced
core delay is target for the robotic a
okay but that so my second question
would be what what's the time step for
the reduced coordinate system in the
demos you use the dropping and a sixty
hit yes yes it sweetie I mean you get
your hand on that it's a I mean it's
really fast but a we this one is the
first iteration no second iteration and
we have the sir iteration coming
medicine okay yeah thanks
since we are still using the facade
for so just wondering since a major
version change that's just wondering how
much is the API change or how much what
we need to do to do the upgrade and yeah
so classically if there was a big number
change with the physics API you would
expect this to be a complete oh my god I
have to re-implement I integration for
this in this case a large portion of the
big number change was to signal the fact
that this is now open-source bsd the
api's are actually very similar and I
can't guarantee that that would follow
on with the next major release because
we we anticipated there are some things
that we would make changes there but for
this particular release and the make the
may be the most challenging thing is
just simply there's been some moving
around of some libraries some of these
things actually benefit you a lot so now
because we support C make and we release
with C make you can actually build
statically and dynamically and while the
GPU component is always dynamic you can
build the the CPU component C the static
or dynamic and it will work with dynamic
GPU library okay so since we are also
doing the mobile my second question is I
saw there are some optimization by GPU
or PI SMT so I'm not word I'm not sure
whether all this or optimization also
works in mobile so it's a new or GPU
mobile GPU yeah and we don't support
mobile GPUs but we do support neon and
we do benchmark this and it is it is
faster with neon than without okay thank
you how much control do you have over a
simulation rates if you have a custom
threading model especially with like the
CPU or the CPU GPU hybridization could
you kind of elaborate I mean if we have
if we have a custom threading model and
arrangin we want to be able to change it
by a variable update race between how
frequently a simulation occurs how much
control to be half of that oh and so I
mean well you have full control I mean
you're calling simulate and you're
telling me is how much time to simulate
and then you work with the GPU harbor's
Asian it's the same thing it's the same
interface and we can also plug into your
into your threading models so we have a
task scheduler a task manager interface
that you can implement so you
not necessarily need to use like our
threads and spawn threads for us to work
with we can interface directly into
yours and then you can also combine that
with any kind of priority the priorities
locking as out of threads whatever
whatever works for you so that's
actually commonly how and larger
commercial engines would incorporate us
they wouldn't obviously let us kind of
go crazy and create our own threads and
then do whatever we want they want to
kind of sandboxes in the things that
they want us to do thank you oh I was
wondering if there are any current plans
to integrate into Unreal Engine so that
would partially be down to the guys at
Epic and but we do have integrations
internally in-house and so at GGC we
were showing several demos using the
Isaac SDK and that is actually an
physics for integration into unreal and
that mmm I believe the plan is yeah I
believe the plan is thank you
okay okay for questions thank you