►
Description
Embark Studios software engineer Tomasz Stachowiak (@h3r2tic) explains how he combined Rust and C++ in the creation of the physx-rs open source project.
See all our open source projects and sign up for our newsletter at https://embark.dev
A
So
stimuli
is
the
the
contacts
between
rigid
bodies,
soft
bodies,
the
constraints
between
them
allows
things
like
character,
interactions
and
so
on,
and
we
needed
a
robust
solution
that
would
be
battle
tested
and
while
rust
quoits
exists,
we
went
for
something
that
has
shipped
in
many
successful
games,
which
is
Nvidia
PhysX
or
we
wanted
to
use
it.
But
we
didn't
really
know
how.
A
But
physics
is
pretty
great
because
it's
recently
got
open
source,
and
so
you
get
to
use
for
free,
a
library
which
helped
ship
many
games
in
the
past,
and
it
is
now
licensed
under
BSD
3
license
and
you
can
actually
get
it
in
open
source
as
on
github
sorry.
So
the
problem
is
it's
a
C++
SDK
and
it's
not
just
a
'suppose
plus
SDK,
it's
a
massive
one.
A
So,
according
to
Wikipedia,
the
project
has
been
on
for
around
18
years
and
during
those
18
years
it's
gotten
a
lot
of
functionality
and
in
terms
of
just
API
functions,
there's
two
thousand
public
ones
and
they
implement
a
lot
of
great
features.
So
they
exist
there
for
a
reason.
So
you
get
things
like
vehicle
controllers.
It
can
just
easily
assemble
things
out
of
wheels
and
components
and
steering
you
got
characters
in
clothes
and
even
a
special
remote
debugger.
A
So
you
can
just
connect
an
application
that
shows
you
all
the
internal
state
of
the
engine
to
running
application.
So
you
don't
need
to
implant
all
the
debugging
features
in
your
game,
and
that
is
pretty
great.
But
before
we
dive
into
that,
how
does
one
in
general
talk
to
something
compiled
in
a
different
language?
It's
actually
a
similar
situation
to
something
compiled
in
the
same
language
as
long
as
it
as
a
set
of
library.
A
A
So
there
is
a
thing
called
an
ABI
which
is
application,
binary
interface,
and
that
specifies
things
like
the
struck
layouts,
the
calling
convention
for
how
the
various
parameters
the
functions
are
passed
in
in
registers
or
pushed
onto
the
stack
and
a
bunch
of
other
things,
like
name
mangling
and
so
on,
and
the
C++
doesn't
really
have
a
ABI
I
mean
it
kind
of
does,
but
it's
only
like
the
facto
standard
on
each
platform.
So
in
practice,
what
happens
is
that
the
OS
/
compiler
vendors?
They
agree
on
a
specific
set
of
conventions.
A
That's
they
stick
to
and
then
in
practice
it
is
pretty
fun.
So
you
have
a
look
at
the
function
we
have
here,
which
just
takes
a
few
simple
parameters,
and
we
already
have
a
discrepancy
for
word:
that's
C
parameter
gets
passed
to
so
in
Windows.
It
comes
in
the
X
and
M
to
register
in
Linux
this
xmm
one
register,
so
that
is
out
of
fun
to
deal
with,
at
least
on
a
single
platform.
The
compilers
will
be
compatible
just
for
the
virtue
of
the
clang
people
and
GCC
people
agreeing
yeah.
A
We
should
do
the
same
thing,
because
otherwise
it's
insane
yet
still
sometimes
buggy
bugs
can
in
in
differences
between
those
calling
conventions,
and
then
some
flags
can
potentially
even
affect
that
ABI.
So,
for
example,
if
you
were
to
use
this
zette
PFLAG
on
on
the
Microsoft,
compiler
and
Windows,
you
get
something
which
is
completely
incompatible
with
anything
else
which
there's
written
on
Windows
and,
of
course,
you're
still
in
a
situation
where
Windows
and
Linux
are
incompatible
between
each
other.
So
how
would
we
talk
to
something
like
physics?
A
And
we
would
like
it
to
be
easy
to
maintain,
so
we
don't
have
to
patch
things
up
every
every
time
a
new
special,
a
standard
comes
out
or
a
new
version
of
the
physics.
As
the
cake
comes
out.
We
would
like
it
to
be
robust,
so
it
doesn't
break
on
some
platforms
like
we
don't
want
to
support
just
windows.
A
So
one
potential
possibility
is
to
add
the
support
for
the
C++
ABI
to
the
RUS
compiler,
but
that
unfortunately,
involves
making
the
rest
compiler
aware
of
a
whole
bunch
of
supposed
type
system,
things
and
keeping
truck
with
a
tent
and
judging
by
bugs,
which
exists
between
super
fast
compilers.
That
is
not
an
easy
task,
so
it's
not
really
a
reliable
option
for
now,
at
least
in
the
viable
one.
A
Now
I
tried
it
and,
unsurprisingly,
a
bunch
of
things
exploded
because
while
it
managed
to
translate
some
things
from
C++,
its
could
not
match
the
ABI,
which
is
kind
of
implementation,
specific
and
then
very
well
defined,
and
then
even
if
it
did
manage
to
support
one
platform.
Well,
it's
it's.
If
it
manages
to
output,
something
that
works
in
Windows,
they'll,
probably
break
in
Linux,
because
it
doesn't
support
that
ABI.
So
we
would
likely
need
to
have
specific
bindings
or
per
platform
per
compilers,
I.
A
Think
and
likely
still,
a
lot
of
compiler
supports
in
rust,
C,
so
another
great
option
hider.
So
in
practice,
what
is
recommended
is
and
even
recommend
recommended
by
the
creator
of
the
best
bus
is
that
you
create
a
stable,
C
layer,
and
then
you
talk
to
that
C
layer
and
while
C
doesn't
have
an
ABI
either
just
like
Super
Plus,
at
least
it's
a
pretty
old
old
language.
It
is
not
changing
very
fast.
It
is
not
going
to
go
anywhere.
So
in
practice
a
lot
of
languages
which
are
not
C
can
speak.
It's
including
rust.
A
So
you
just
have
a
few
declarations.
The
creations
instruct
and
specify
the
the
linkage
and
it
can
talk
to
C.
So
the
idea
would
be
to
create
a
stable
layer
for
physics
where
we
would
define
a
public
C
API,
and
that
would
just
redirect
all
the
calls
to
the
C++
layer.
And
then
we
will
talk
into
the
C
C
wrapper.
The
C
wrapper
just
redirects
things
to
C++
and
hopefully
everything
works.
A
So,
for
example,
here's
a
simple
structure
containing
an
integer
on
both
sides
and
there's
a
function
which
just
takes
this
truck
and
returns
it
immediately.
The
only
difference
between
it
is
that
the
one
on
the
right
has
a
constructor.
It's
not
even
defined
in
this
thing
and
when
you
look
at
the
compiled
code
from
for
those
functions,
it's
a
becomes
clear,
they're
not
compatible.
So,
even
though
we're
saying
oh,
this
is
an
extern
C
function
is
going
to
be
used
in
a
single
face.
A
You
actually
get
a
very
different
result
if
you
have
a
simple
plus
feature
in
one
of
those
trucks.
Luckily,
some
compilers
will
give
us
a
warning
and,
as
we
see
will
clang
will,
and
g
plus
plus
did
not
tell
me
that
something
is
wrong,
so
they
will
tell
you
you're
gonna
have
a
bad
time.
Those
functions
cannot
be
used
from
C,
but
let's
go
deeper.
Here's
a
very
similar
thing
where
you
still
have
a
struct
with
just
a
single
integer
and
in
here
the
function
does
not
return
it.
A
It
just
takes
the
integer
from
the
struct
and
returns
it
as
an
integer,
and
the
twist
here
is
the
struck
has
a
copy
constructor.
Instead
and
once
again
we
have
a
different
code
being
generated
and
even
a
pointer
being
accessed
on
the
right
side.
So
that'll
be
fun
because
if
you
called
it
unknowingly
you'll
just
get
a
crash.
Basically
and
all
the
compilers
have
tried
with
all
the
sets
of
flags
in
for
the
wlw
extra
pedantic
and
so
on.
They
they
said
this
was
cool.
A
If
you
ask
the
compilers
and
windows
you're
going
to
get
64
bytes
and
on
Linux,
72,
bytes
and
I
actually
ran
into
this
while
trying
to
create
this
layer
that
will
bind
the
physics
SDK
and,
at
that
point,
I'm
just
realized.
I
hit
the
wall
and
I
needed
to
somehow
deal
with
it.
So
we're
in
a
situation
where
we
can't
really
use
simple,
plus
types
in
the
C
wrapper.
A
Even
if
it's
a
simple
struct
like
a
vector
containing
X
Y
and
that
floats
because
that
already
contains
things
like
copy
constructors
and
regular
constructors,
it
will
break
the
the
ABI.
We
don't
even
know
the
sizes
of
structs,
so
imagine
taking
or
using
an
array
across
the
interface
where
you
don't
know
the
size
of
the
item.
So
you
have
need
to
have
some
kind
of
function
which
will
give
you
the
index
into
the
array
at
an
unknown
location.
And
then
even
then,
you
end
up
with
a
struct
that
you
don't
know
the
layout
of.
A
So
you
have
accessor
methods
to
get
the
specific
fields.
So
that
is
going
to
be
a
great
time
and
the
running
into
this
and
kind
of
giving
up
on
the
situation,
just
kind
of
gave
me
and
I
yeah,
maybe
there's
something
else.
We
can
do
why.
Why
bother
having
a
single,
stable
layer
where
you
can
have
a
layer,
a
pair
compiler
per
platform
first
set
of
compiler
flies.
So
you
get
a
wrapper,
you
get
a
wrapper.
Everyone
gets
a
wrapper
and
we
can
actually
generate
that
on
the
target
machine
that
we're
compelling
for
and
build.
A
That's
with
the
specific
flavor
of
the
C++
compiler
in
mind,
so
be
matching
everything.
And
then
we
end
up
in
a
situation
where
the
the
layouts
of
structs
and
the
ABI,
the
calling
convention
actually
are
very
well
defined,
the
dot
one
specific
set
of
things
and,
of
course,
to
support
all
the
different
compilers
and
sets
of
flags.
There
will
be
a
lot
of
work
and
I
didn't
want
to
do
that,
I'm
out
to
worry,
because
that
sounds
crazy,
so
instead
I
figure,
if
I,
can
just
ask
the
C++
compiler.
Where
are
the
things?
A
So
you
have
a
struct
or
class
on
the
left
side
and
you
can
write
a
simple
space
path
program
which
will
go
over
the
fields
inside
that's
struct
and
ask
what
is
your
offset
from
the
start
of
this
track?
What
what
is
the
size
of
the
field?
What
does
this
and
off
so
that
the
others
field
and
so
on?
And
you
can
write
this
program
once
and
it
will
reflect
and
provide
the
offsets
and
locations
of
the
layout
on
the
target
platform.
A
So
we
will
write
this
this
thing
once
and
then
just
run
it
on
every
single
target
platform.
It
will
generate
or
output
the
offsets
for
everything
inside
the
struct
and
that
will
create
a
little
bit
spoke
wrapper
for
whatever
the
supposed
last
compiler
thinks
that
the
layout
of
things
are,
and
from
from
that
information
we
can
actually
generate
the
matching
C
or
rasta
code.
A
So
this
is
already
a
basis
for
that
special
wrapper
for
every
single
person
and
platform
and
everything
and,
of
course,
writing
that
little
reflection,
snippet,
which
will
go
over
the
fields
and
ask
the
offsets,
will
be
a
lot
of
work
to
do
for
every
single
struct
inside
the
physics
SDK.
And
of
course
we
can
automate
things
if
there
is
something
which
can
give
us
information
about
the
C++
compiler,
and
that
is
the
lip
tooling.
A
From
clang
and
loop
till
link
is
a
really
cool
library
which
you
can
use
to
inspect
the
internal
states
of
the
compiler.
You
can
get
the
you
can
get
the
ast.
You
can
get
some
stuff
after
initial
passes
of
semantic
analysis,
so
you
can
get
the
list
of
trucks,
a
list
of
functions,
list
of
members
and
slice
trucks,
and
so
on
and
the
when
you
build
a
tool
like
this,
you
can
actually
make
it
work.
Just
like
clang
does
and
support
all
the
the
default
flags
that
it
works
with.
A
So,
for
example,
the
include
directories,
a
bunch
of
switches
and
preprocessor
definitions,
and
so
on.
So
you
do
it
by
creating
this
abstract,
syntax
tree
consumer
which
in
which
you
actually
basically
have
filters,
slash,
queries,
I,
guess,
and
you
say,
give
me
all
the
functions
that
start
with
the
P
X
prefix,
and
then
it
just
calls
your
handler
with
all
the
information
has
on
that's
function
and
in
there
you
can
go
deeper
and
and
Dickens
here.
What
is
this
field?
Oh?
Is
it
the
basic
field,
or
is
it
struck
field?
And
so
on?
A
You
can
just
going
to
recurse
and
get
all
the
information
about
the
stuff
that
you're
interested
in
and
then
from
there.
It
can
eventually
just
go
down
to
the
to
the
smallest
building
blocks
and
configure
up.
Oh,
it's!
It's
a
Bulls
I'll,
just
output,
a
rose
bowl,
it's
a
flow,
it
will
output
F
for
this
U
and
so
on.
A
So
with
this
two-way
connection
generates
and
that
little
reflection
snippets,
no,
they
had
in
this
life
use
a
few
slides
back
for
every
single
struct
in
the
suppose.
Class
code
base
in
practice
ends
up
being
a
bit
more
complicated
than
version,
but
it
is
essentially
a
sign
thing
for
every
single
field.
We
end
up
just
outputting
the
office
events
along.
A
So
even
though
it
uses
clang
and
somebody
might
run
the
generated
code
on
GCC,
it
will
still
be-
will
be
so
correct.
Now
this
was
structs
and
for
functions.
Actually,
the
story
is
much
simpler.
So
for
for
every
single
C++
function
that
we're
interested
in,
we
will
generate
a
single,
a
very
slim
C
function,
which
will
take,
which
will
just
pass
all
the
arguments
to
the
suppose
pass
code
and
then
pass
the
return
back
now.
We
need
to
be
really
careful
to
actually
enforce
that.
A
So
we
will
only
need
to
do
this
once
and
this
is
also
output
of
that
tool.
So,
with
those
building
blocks,
we
can
actually
get
the
full
flow
from
the
from
Rosco
in
this
bus
plus,
which
will
look
something
like
this.
So
between
rust
and
see
the
there's,
basically
no
work
being
done.
You
just
link
them
together
and
the
destructor
you
pass
into
the
the
layer
will
be
bit
and
then
identical
between
each
other
and
that's
just
free,
then,
between
C
and
C++,
it's
a
bit
more
complicated
because
we
have.
A
We
have
generated
c
structs,
which
are
a
bit
identical
with
the
c++,
but
the
type
system
does
not
understand
it,
so
everything
aligns,
but
those
are
just
four
and
bar
difference
trucks
at
the
type
system.
So
what
we
do
is
just
mem
copy,
the
all
the
fields
between
each
other
and
then
we
call
this
both
class
code.
We
get
the
the
result,
types
and
do
the
thing
in
Reverse
now
this
might
seem
like
some
overhead
at
the
mem
copy
level,
but
so
in
practice,
because
man
copy
is
an
intrinsic,
the
compiler
actually
understands.
That's.
A
You
are
just
copying
field
a
to
field,
a
in
the
other
struct
and
then
just
accessing
that.
So
it
knows,
doesn't
have
to
do
that.
So
in
practice
you
get
just
gets
optimized
out,
and
then
this
becomes
an
almost
your
overheads
layer,
so
using
those
those
tricks
we
managed
to
generates.
This
physics
is
great,
which
gives
this
lovely
example
of
a
balancing
bowl,
and
you
can
tell
that's
no
graphics.
A
Programmers
were
harmed
and
making
of
this
example,
it
is
lovely,
gives
you
access
to,
basically
all
the
the
public
functionality
of
the
SDK,
but
in
an
extremely
unsafe
and
an
organic
way.
So
whenever
you
have
things
like
inheritance,
you
have
to
like
cast
the
role
pointers
between
seemingly
unrelated
types,
because
Ross
doesn't
know
that
there
were
those
should
inherit
from
each
other.
So
it's
it's
it's
kind
of
ugly,
but
but
it
works
and
the
nice
little
side
effect
of
that
is.
A
It
is
a
generic
see
layer
as
well,
so
if,
for
example,
Lua
or
Pascal
or
Haskell,
or
something
they
want
to
use
physics,
they
can
just
use
the
same
generated,
C
layer
and
just
steal
it
from
here
and
so
about
this
machinery,
which
was
running
on
top
of
Clank
the
whole
dip.
Tooling
thing.
We
only
actually
need
to
run
it
whenever
we
updates
the
C++
SDK
for
physics
or
whenever
we
change
the
hole
generator
process.
It
is
not
fully
cross-platform
because
it
was
a
lot
of
work
to
otherwise
to
make
sure
it
works.
A
A
So
this
whole
pipeline
will
basically
generate
the
the
C
function,
wrappers
and
the
little
utility
that
will
provide
reflection
over
c
plus
plus
types,
and
we
put
those
things
into
crates
so
that
the
end-users
end-users
don't
need
to
worry
about
it
and
then,
on
the
end
user
side
they
just
grab.
This
great
continues
those
artifacts
and
just
pass
it
into
the
the
actual,
build
pipelines
up.
The
users
execute
so
as
a
part
of
that
they
will
actually
build
the
physics
SDK
from
source
using
the
C
make
and
CC
crates
inside
the
Builder
s.
A
So
the
entire
suppose
SDK
is
is
built
with
a
known
set
of
flags
and
a
known
compiler.
And
then
we
built
the
the
generated
wrapper
with
the
exact
same
sort
of
flags
having
reflected
onto
the
layouts
and
structs
of
everything.
So
we
have
kind
of
finished
building
the
the
wrapper
library
by
reusing
the
utility
and
we
just
glue
everything
together
and
we
have
a
working
rust
solution
and
that's
that
and
when
it
comes
to
using
well
there's
a
little
caveat
the
stuff.
A
A
It
is
a
right,
even
though
it
has
some
nasty
stuff
in
it,
but
we
don't
like
up
nasty
stuff,
so
we
went
and
built
a
safe
or
layer
on
top
of
that,
or
something
so
that
umber
clear
that
it's
gives
you
a
lot
of
economics
in
comparison.
It
provides
some
safety.
I
would
like
to
say
all
safety,
but
sin
in
practice.
Dealing
with
us
is
kind
of
complicated
and
we
basically
work
on
those
grades
when
we
need
more
features.
A
So
we
have
a
bunch
of
to
dues
to
clean
up
some
unsafe
stuff,
but
it
does
give
you
a
lot
of
stuff
and
it
doesn't
cover
all
the
functionality,
but
but
it's
fine
to
to
mix
and
match
between
the
nice
ergonomic
layers
and
the
unsafe
horribleness,
and
we
have
a
matching
example
of
offer
of
a
bouncing
ball.
But
this
thing
from
from
Linux
and
I'm
cold,
using
just
the
physics
it
is
lacking,
the
the
lovely
you
read
with
the
unsafe
on
the
side,
but
otherwise
it's
kind
of
similar.
A
It
doesn't
have
a
horrible
pointer
cast,
but
it
does
have
one
unsafe
because
we
need
live
to
use
a
row
pointer
one
place,
but
it's
not
better
and
because
we
love
open
source,
you
can
get
it
now
from
Chris
I/o
and
from
from
github
and
feel
free
to
play
with
it
experiment
with
some
physics
and
so
on.
So
it
is
out
there
so
having
covered
that's
a
one,
might
ask
what
do
we
do
with
this
longer
term?
A
So
it
will
take
a
while
to
to
get
to
that
level
when
it
comes
to
to
some
libraries
at
least
so
in
the
short
term.
Altezza
dent
lee
say:
let's
do
this,
and
this
is
a
at
least
a
viable
way
to
provide
a
binding
layer
or
glue
layer
between
rust
and
suppose
boss,
which
seems
at
least
so
far
to
be
robust
and
reliable.
We
haven't
seen
it
do
anything
and
expect
to
be
at
least
and-
and
please
don't
judge
me
by
the
code-
generator
I
was
learning
Clank
and
things
as
I
was
going.
A
It
is
a
bit
messy
messy
and
can
definitely
be
improved.
Maybe
some
stuff
can
be
merge
or
collaborates
with
a
bond
engine.
For
example,
we've
learned
a
lot
of
stuff
in
the
process
of
doing
that.
So
we
have
learned
that
binding,
rust
and
stuff
bus
is
not
that
difficult
if
you
use
the
right
tools.
So
if
you
use
cargo,
you
get
the
old
amazing
build
process
which
allows
you
to
do
things
like
building
you
suppose,
plus
software
and
then
extracting
libraries
and
and
also
the
crazy
stuff
and
with
clang
and
lip
tooling.
A
You
can
get
information
out
of
the
out
of
this
class
code
base
and
so
on.
So
it's
it's
not
that
difficult.
So
if
you're,
a
game
developer
for
example-
and
you
are
afraid
of
using
rust
because
you
fear
you
might
be
isolated
inside
the
ecosystem
because
most
of
the
stuff
in
game
dev
is
written
in
scenes
above
Plus
well,
you
can
know
that
there
is
a
way
to
actually
get
all
those
dependencies
into
rust.
So
potentially
it
is
an
enabler
for
people
who
would
otherwise
not
try
rust.
A
So
it's
not
all
evil
and
a
little
side
effect
of
of
this
setup
is,
is
actually
easier
to
integrate.
The
physics
as
he
came
to
rust
now,
then
it
is
inclusive
as
poss
because
and
Rossi
just
say,
physics,
equals
version
and
Snyder
cargo
tunnel
and
in
C++
you
would
probably
spend
well
if
you're
using
C
make
you
might
just
use
it.
But
if
you're,
using
anything
else,
you
might
spend
between
hours
to
days
integrating
the
C
make
stuff
into
your
proprietary.
A
Build
system,
I
actually
tried
untangling
the
C
make
build
scripts
from
physics
itself,
but
after
half
a
day,
I
gave
up
I
decided
that
the
logic
in
there
was
just
too
complicated.
So
you
just
use
it
like
this
and
probably
the
most
important
thing
I've
learned
making
versus
that's.
If
you
integrates
a
ton
of
superclass
code
into
your
otherwise
pure
rust
repository
you're,
not
going
to
be
popular
among
your
co-workers,
but
it
is
a
good
motivation
to
to
turn
the
whole
thing
into
uncrate,
an
open
source.
A
C
C
A
Redo
the
process
for
something
else,
yeah
that
depends
which
can
each
cases
one
might
run
into
so
the
development
of
this
was
basically
try
to
do
something
with
the
the
ast
or
information
we
have
and
from
Clank
run
into
a
wall,
then
Co.
What
kind
of
other
thing
that
they
add?
Oh
they
have
emails.
I
didn't
have
support
for
emails,
then
as
support
for
that
and
continue,
and
then
we
run
into
another
wall
and
so
on.
A
So
it
is
very
much
an
incremental
thing
and
I
did
take
some
shortcuts
specific
to
physics,
but
in
theory
one
could
extend
this
to
a
fairly
general
thing
and
support
a
decent
subset
of
C++.
I
could
imagine
issues
around
things
like
templates
and
I,
don't
know
lambdas
as
parameters
and
so
on
so
more
kind
of
abstract
features,
but
a
lot
of
libraries
are
written
using
a
subset
of
space
plus
at
least
at
the
interface
level.
So
maybe
it
would
not
be
too
crazy
to
have
good
coverage
cool.
D
So
you
mentioned
that
you
run
part
of
the
code
to
get
the
offsets
and
so
on
on
the
target,
which
could
be
a
limitation.
Did
you
find
the
clang
tooling
too,
limiting
to
get
this
limitation
I'm
not
familiar
with
a
club
to
get
this
information
I'm
not
familiar
with
a
clang
tooling,
but
I
mean
it's
just
a
limitation
because
you
cannot
cross
compile
that
easily
and
the
information
is
there
and
executable
somewhere.
A
If
there's
a
field
called
foo
insider
struct,
I'll
literally
write,
add
member
foo
of
set
of
foo
size
of
food,
so
you
just
generate
this,
this
Fame,
which
doesn't
care
about
layers
at
all,
and
then
this
is
basically
a
C++
program
that
you
run
on
the
targets
and
just
knowing
the
names
of
things
inside
the
structs
that
you
could
know
if
the
slots
had
actually
run
through
deflection
this.
You
just
run
this
small
thing
and
then
you're
done.
Okay,.
A
At
the
build
time
inside
cargo,
so
every
time
you
run
cargo,
it
is
potentially
going
to
run
that
and
practice
it
is
all
cached.
So
unless
you
actually
change
the
set
of
flags,
if
I
see
compilers
or
your
object
trades,
it
is
going
to
just
run
once,
but
in
theory
the
entire
pipeline
is
defined
inside
cargo,
except
the
the
clang
thing
with
the
lip,
the
wing.
D
A
What
suppose
plus
I
did
with
physics
I
did
not,
so
if
I
were
to
work
with
an
SDK
that
had
features
the
features
like
this
I
would
just
have
the
the
automatic
tool
which
uses
clang
actually
em.
It's
already
some
kind
of
wrapper
inside
I,
suppose
plus
sites
or
or
in
the
C
layer,
deal
with
the
move,
constructors
and
so
on
to
actually
well
not
use
them
in
the
just
like
in.
In
the
current
version,
we
generated
C
functions
that
don't
take
C++
inputs
at
all,
but
just
man
copying
stuff
rounds.
B
E
A
Have
a
look
at
SAP
engine
and
it
does
use
clang
as
well.
It
is
a
rough
project
and
it
uses
partial
client
bindings
I
tried
doing
the
same,
but
all
the
stuff
I
needed
wasn't
really
exposed
to
rust.
Yet
so
maybe
one
could
use
a
binding
generator
that
shouldn't
generate
a
clang
bindings
to
you.
You
can
use
that
in
rust.
So
that's
the
on
higher-level
I
wanted
to
avoid
making
something
which
is
too
general,
because
my
task
or
my
idea
is
to
to
point
physics
not
knowing
whether
that
actually
will
be
feasible.
A
So
I
just
went
all
in
what
is
the
quickest
way.
We
can
get
this
only
things
as
fast
as
the
k2
to
work
with
rust.
So
not
thinking
about
the
larger
picture
too
much,
but
now
having
finished
this,
there
is
a
bunch
of
techniques.
What
one
could
use
to
to
make
a
larger
is
a
more
wide,
partly
or
white,
but
part
of
the
deco
system
to
work
with
with
rust.