all ready so here we are back to process
and more constraints we basically need
to set up something that says okay so
you are you claim to be a cat deformable
and that's fine you might be but the
problem that we're gonna run into is we
might have a constraint that spans two
different deformable regions like we
want we want these regions to not be
able to break apart that's what we're
setting up now the thing is we can have
different regions and not break apart
like we have this whole you know thing
here or put it another way if I said how
about the cat or rig IDs so this whole
region here this whole original ID can't
break apart but we don't have to have it
attached to this one attached to this
one attached to this we don't need it to
be one huge thing that can't break apart
we just need to make sure that within an
original surface it doesn't break apart
so we might get constraints between two
deformable services but that doesn't
mean that it should be held together now
that we need to check for here we're
actually rather down here in our process
constraints thing so we could say if you
are a if you claim to be a cat
deformable and that's gonna happen you
know if we have points on two sides of
the same constraint and it gets promoted
to the primitive it'll just say okay
well the whole constraint is deformable
so you look it's like already if I said
hey show me all the cat deform the
weakest ones guys check it out see the
whole thing is connected to each other
everything is is connected as one long
cage here that's no good so we know we
have to do we want to see gaps between
these things once he gaps between the
surfaces where they're not hooked into
each other so I'm gonna say let's let's
find a way
where we can for every at for every one
of these lines of every one of these
constraints let's see if we can see if
the the actual pieces that are bound
together let's see if they're both from
the same cat or rigged ID group let's
see that they both have the same cat
original ID should be pretty easy to
check but we'll want to do is before we
before we promoted these things you know
we had cat or rig IDs per point each
point knew where they're from when we
did this that actually we'll get caught
up in that and getting minimum dand will
it'll get wrong so let's let's ask the
data as it existed before this happened
so hang with me as we go through this so
I'm going to say what was the original
ID 0 of point 0 because every every one
of these constraints is gonna have a
point zero and a point one so we'll say
well let's start this way
well SE trim point means for input 0
which is the main input the leftmost
input of course and input 1 will be this
input for input 0 for whatever the
current primitive that we're working on
right now give me the point number of
vertex 0 like give me the overall point
number of vertex 0 every prim remember
everyone is lines will have a vertex 0
and a vertex 1 0 1 0 1 everyone's gonna
have a 0 1 0 1 everywhere if we look at
it here in geometry spreadsheet and we
look at vertices you'll see 0 1 0 1 0 1
every single one of these lines has a 0
and a 1 because it has two points in it
or two vertices and I should say but we
want to know what is the actual point
number overall so that we can look at
this with all 22 508 points that it has
I want to look it up in that so check it
out so prim point of the zeroth input
the current primitive that we're working
on vertex zero that will return me the
point number that it is
now with that point number I'm gonna ask
the point and say hey point what was
your original ID now I know I called it
a rig IDs which is gonna keep screwing
me up but oh well so there you go so
this will work so this won't air out so
storing into ID zero and maybe even
better for now I'm just gonna actually
make it into an attribute just so we can
see that it's doing what we we want and
that's when we just need to change to
one so now everybody every primitive if
we just hi everybody and we'll just look
at this ID 0 and ID 1 these were
hopefully somewhere in here hopefully
they're not all 0 okay good the zeros
are happening because not everything is
a cat deformable in the first place
so if I do this and let's just look at
the ones at one so you can see a lot of
them most of them should be the same but
oh sure enough we have one here where
the ID is not the same so let's make a
little mental note of that 6 8 8 2 let's
take a look at 6 8 8 - the prisoner
number 6 8 8 - let's see what's up with
that I'm just gonna say pattern 6 8 8 k2
sleep not select so here he is so looked
at more abstractly it's very abstract
actually let's see let's try something
else let's look at the pieces here and
let's do that not doing anything
trying to see I want this to show up
like this it looks like yeah so this is
pretty good what we're seeing here is
with the original thing here and then
they'll typically this what instead
we're seeing a constraint that's
connecting the engine essentially to the
fuselage so the engine here on the right
fuselage there on the left so we don't
want this to be unbreakable we don't
want this to be a thing that even dents
we want this to just be a whatever it
can be a regular hard constraint so that
they're still held to each other but
they're not going to be one of the cool
exclusive deformable types so that's
what we're going for here so I'm going
to go back to doing it this way and say
inked ID 1 equals that so we have the 2
and we need to compare them just the way
that we just did it you know they're
eyeballs and the geometry spreadsheet
will say hey if I D 0 and B 0 is equal
to ID 1 then we'll do the thing that we
were just talking about where we go from
glue too hard to glue again otherwise
you are not a cat deform rule you were
released from service like so so now
when we get over here we should see that
happen whereas before when I said hey
this is our cat deformable x' where
everything was connected together now
hopefully I want to do this sure enough
they're no longer connected to each
other now we have these separate islands
of things and as is business products is
exactly what we wanted great so here we
don't need to say cat deformable equals
1 because it already is that so
implicitly we're kind of like yeah it is
it is 1 and you get to remain that but
we also want to say whatever you were
going to be you
now definitely gonna be a glue instead
under this scheme but you're gonna be a
glue where as soon as you were broken as
soon as the solver breaks you because
you've exceeded your strength it will
immediately and this is a also a
built-in type next constraint name this
is O'Reilly is recognized by the solver
it will immediately in the same time
step turn into a hard constraint which
is pretty cool
so because this is set here it will know
it will swap this text into here so it's
gonna be glue then it's gonna be hard
which will be allowed to bend and
Roenick lee and then well art we
ourselves are gonna go take this over to
the constraint solver and say but only
remain hard for a few frames then turn
back into a glue again so that's going
to be that's giving you take away from
it
now if it is one of these things also we
don't ever want these ones to be cluster
Abell they should be this glue to hard
thing so I'm gonna say else rather else
if for this guy that way it only does
clustering if it's not of a deformable
type so that's good let's see what else
do we need to do here