Archive for the “TD” Category

I don’t update this enough. Life does that sometimes.

Lately, I’ve been toying around with streaming via to help educate folks about rigging in CINEMA 4D. I just work on stuff I want to work on and people can come and ask questions and I can demonstrate stuff. I’ve done 2 of them now. This second one produced a couple of nifty little things I can share with the community.

The first is a skateboard rig(As me rigging a skateboard was the idea for rigging improv I did). The model came from Valentine Bertrand’s skateboard rig for Maya. So all credit goes there, not to me. You can download the skateboard rig and play around with it from here: CINEMA 4D  Skateboard Rig  It was rigged in R16, but it should probably work in older versions as well.

The second thing the night brought was a simple script I wrote to demonstrate some python for people watching. It’s nothing special but it might be useful to people. It’s commented to hell too so it should be easy to understand what’s going on. It basically takes whatever you have selected, and for each object selected, it will create a circle spline, and constrain the selected object to the circle spline. You can get the script here: CreateControlsForSelectedObjects

Comments No Comments »

Ever since it’s announcement and release, C4D R13 has both astounded and confounded users. The videos showcasing the new Character tools have impressed many people, but they are quite complicated an not easy to just pick up. Even though marketing videos have suggested otherwise(I still maintain using the Character Object is easy, but making your own templates is still quite difficult). So I wanted to make a simple introduction to the system for users. In the coming weeks there will be a much more in depth tutorial series on Cineversity where you will created a biped template(based on the Taquito character), but here’s something to help new users try and get into the new system, so let’s begin:

To start, download the starting project file. Now, when you open it, it’s a very simple scene file, but this scene should hopefully help you understand this system. Now, in order for you to use this with the Character Object, you need to create a template. A template is simply a scene file stored in your preferences>library>characters folder. If you have a file in that folder, you will be able to see it in the Character Object, however, by default, that folder doesn’t exist. There’s a very easy way to create it, though. So with the file open, choose Character>Character Builder>Save Character Template As. Choose to save the file as “SimpleChar”.


If you were to go into a new scene file, and choose Character>Character to create a Character Object, if you looked in the template drop down list, you would see a template called “SimpleChar”, but it won’t do anything yet. In order for you to be able to do anything(ie build the rig) you need to do 2 things:

1. Define the Character
2. Create at least one Component.

Components are basically chunks, or pieces of a rig. Typically, you think of them as a Spine, or Limb, or whatever. In order to actually create these components, they need to be inside of a character hierarchy. Now, a character Hierarchy means that it needs to be a child of an object with a Component Tag set to be a Character. So let’s set that up.

In the template file, locate the “Simple_char” null object, right+click on it and choose “Character Tags>Character Component”.

So this is the heart and sole of this system. The Component tag is a complicated beast. It is what allows you to define all sorts of stuff in your template. You can specify the Character , Components, Controllers, and more. It’s also pretty damn daunting to look at because it has so many tabs. But back our template…

With the Component Tag selected, go into the Tag tab. This tab is where you specify what this object is. So since we are trying to specify our Character, we want to set the Type to be “Character”. Now, once you do that, a lot of the tabs actually will disappear making this much less complex. So let’s continue to define our Character.

You can set the Character type to whatever you want, these essentially just define what Icon the Character Object uses, and the internal size to use(for instance, if you have Auto Size turned on and you are building a Biped it tries to make it about 6 feet tall). We can leave it set to None in this case.


Now, there’s the ability to specify a name. Whatever you have set here is what will be listed in the Character Object’s template list. So we could actually override using the template’s file name here. Now, if the Name is left blank, it will use the name of the object with the Character Tag. In this case, if I left it blank, the template would be called “Simple_Char”. We are going to do that.  Just leave it blank. So that’s all we have to do for setting up our Character. Let’s save our progress by going and choosing “Character>Character Builder>Save Character Template”.

Now we still can’t build anything because we haven’t specified any components to create. So let’s do that now. The way this is going to work is we will create a Root Component which will be the overall container for all subsequent component(you see something like this in the Adv. Biped template). So locate the null called “Root”. Right click on this object and create another Component tag.

A quick look at the types…We have lots of types, but really the best way to look at them is in groups. You have the Anatomical Group(None, Pelvis, Limb, Spine, Hand, Foot, Digit, Head, Tail, Wing, and Custom), the Helper Group(Controller, Component, and Group), and then the Character group, which is just the Character type.


In order to actually build anything in the Character Object, you need to have Anatomical types. They are the ones that actually show up as buttons in the Character Object. So the anatomical types are the ones that can be built. The Helper types, help with the creation of anatomical types. They let you specify objects that maybe are in separate hierarchies but need to be placed in a specific way, or specify what is a controller.

So since we need to build our Root, so it needs to be an Anatomical type. In this case, we will set it to be a Custom type. Now like I said before, I don’t actually have to specify a name, unless you want to. So I will just leave it all blank. Now you may notice a Main Controller slot. This is a it misleading. Many components have many controllers. How do you decide which is “Main”? The fact is, you don’t need to worry about it. What this setting ACTUALLY does, is it tells the Character Object what to select when you switch into Animate mode, with this component selected. If it’s blank it will use the object with the tag.

So for our example, you should just put the Root_con+ in there. That’ all we need to worry about for the Tag tab. Save your work through the Character>Character Builder>Save Character Template, and go into a new scene. Create a Character Object, select the Simple_char template, and you should now see a button that says “Root”. When you click the Button it should bring in our Controller. Now let’s move on.

The next tab is the Insertion tab. This is a pretty powerful tab. Ignoring the Default Insert, and Bone Insert options, the major focus is the Parent Components group. This is where you specify both WHEN a component can be created, and WHERE a component gets placed. So click the Add Button to create a new Insertion rule. With it selected, you see a couple of options “Parent” and “Insert”.

The Parent parameter controls WHEN the component can be created. There’s options like Any, Only, Type, Character, and more. So if you have it set to Only, you’re saying “This component can ONLY be created if the selected component matches the Component field. This allows you to say that you can only add Arms and legs to the Spine Component and not any sooner. For this case though, Set the Parent type to be “Character” This way, this component can only be created if the Character Object itself is selected.

The Insert parameter controls WHERE the component gets inserted into the scene. This allows you to have the component be made a child of a particular object, or gives you control on making your component exist before or after something else in the Object Manager. Four example We are going to leave it to From Parent. It just means that in this case it will be inserted under the Character object.

The Mirroring tab lets you define what planes components should mirror across, and which components should mirror. Our template has no mirroring, so we will ignore it here.

The Include tab defines which objects should be brought in when our component is created. Naturally, it looks down the component hierarchy(that is the object with the Component tag applied) and tries to bring them all in. But when you have broken hierarchies you might need to specify things manually. For our component, Just drag the “Root” null into the Objects list, and click the little icon to include the hierarchy. This way it will include both the Root null and the Root_con+ controller.

The Next tab is the Selection tab. This is where you specify the Component Selection Objects that can be keyframed. The good rule of thumb is if you animate a particular object put it into the list here. For this particular component, place the Root_con+ object into the Objects list.

The Bind tab is next, and this is where you specify which joints should be bound to a mesh when you switch to the Bind Mode in the Character Object. For this particular component, there are no joints, so this can be skipped.

Then we hit the Adjustments tab. This is where you specify how to adjust your rig. You specify what objects become handles(the circles in adjust mode), and how objects should follow the handles so you can easily resize your rig. Due to the simplicity of this component, we just need to focus on the Handles group. Drag the Root_con+ into the handles list as this will allow you to adjust the psr of the Root_con+ controller, so you can adjust it to be placed anywhere else. We don’t need to set up any Adjustment rules because we dont need to do anything to the Root null.

Hotspots tab lets you specify hotspots(which are the buttons in the Character Object’s Hotspots tab). This also can be used for setting up a Visual Selector targets as well. For this component, just click Add once, and place the Root_con+ into the link field.

The rest of the tabs, we don’t need to mess with(though if you want your template to work with CMotion via the add walk button, you would specify that in the Walk Tab, but I’m not going to go into that now). If you save the template as you had before, and in a new scene build your root component you should notice a few things. First, if you’ve built a Root component, you cannot build another one unless you re-select the Character Object. Second, if you switch to Adjust mode you should see 1 handle. If you go to Animate Mode in the Character Object, then select the Hotspots tab, you should see that theres one button for Root_con+.

So that’s it for our Root component. We’re done with it and ready to move on to the next(and final) component.

Back in the template file, locate the null called “Spine”. Add a component tag to the Spine null, and set the type to be a Spine. As for the Main controller, choose Joint.1_con+.

If you go to the Insertion tab, add an adjustment rule. Set the Parent type to be Only, and then drop the Root null object into the Component slot. Then set the Insert parameter to be “Last child”. Then Drag the Root object into the Object field. This is basically saying that you can ONLY create the Spine component if the Root component is selected, and that when you build it, it will be inserted as the last child of the Root null.

Now, go to the Include tab, drop in the Spine null, and the Joint.1_con+ into the object list, and turn on the hierarchy icon for both. Save your template, and build the spine component in a new scene. Now, initially everything looks great. But if you switch to full hierarchy, you’ll see that the Joint.1_con+ and Joint.2_con+ are not placed anywhere specifically. And let’s say you want them to be a child of the Root_con+ object, so as you move that controller the other controllers follow along. But because they are in a separate hierarchy, how can we control where they go independently from where our joints get inserted?

The answer lies in some of the helper types. Now, because these are controllers, we should add component tag to all of them and set the type to be Controller. You’ll see the icon change, and the number of tabs changes, but the important thing is that we can sepcify new insertion rules for these. Now, because one controller is already a child of the other, we can just set up the insertion rules just on the parent and the child will follow. So for the Controller tag on the Joint.1_con+ object, create a new Insertion rule. Set the Parent to be Only and drag the Root null object into the Component slot just like we did on the component itself. For Insert, say First Child, and this time drag in the Root_con+.


Save and check this out, and you should see those controllers are now properly inserted under our Root_con+ controller which is what we wanted.

So continuing on, we can skip Mirroring. and move on to the Selection Tab. All we need to do is drag the Joint.1_con+ object in, and we can turn on the hierarchy icon. Then move to the Bind Tab. In the Bind tab, you simply need to drag Joint.1 in and turn on hierarchy and then you are set.

Now, I’ll make a note here…Typically, you never want/need to bind the end/tip joints. It’s not very good practice. So why wouldn’t you simply select Joint.1 and Joint.2 manually and not turn on the hierarchy icon? Well you can do that and that would be A-OK, however, this system has the ability to insert joints into a hierarchy, so doing it the manual way would not let the newly inserted joints get bound, which is not good! So I find it better to just properly name tip joints(with a _tip suffix) and include the hierarchy as a whole. Now if you won’t be inserting joints you can pick either method, but I just figured people should know to be aware of it.

Now, everything should be pretty well set except the ability to adjust this new component. So what we need to do is go into the Adjustments tab, and add the Joint.1 joint into the Handles group, and turn on the hierarchy. This will make it so all of our Joints are our handles. Now, save your template, and build your template in a new scene. Now jump into Adjust mode and you should see handles for each of the joints in the scene. However if you tried to adjust them, you would probably get a mess when you leave Adjust mode. THIS IS BAD. You want your adjustments to stay put when you leave adjustment mode. So let’s fix this.


The reason for this, is because our joints are constrained to the 2 controllers we have. When we adjust those handles, we are changing the joints position and rotation, but not the controllers themselves. So what happens is we’ve made these adjustments, and then when you exit adjust mode, all the expressions inside of the scene become active again. Since our controllers haven’t changed, what that means is our joints will actually snap to match the controller’s rotation. So to fix this, you need to create some adjustment rules so the controllers follow along during adjustment.

Back in the template, go into the Adjustments tab. And make sure the Objects group is unfolded. Click the Add button to Add a new Adjustment rule. Adjustment rules, are basically constraints. So there’s a Link slot and a To field. You basically are saying “Link this object To that object”. Typically you want to try to link to your handles. So Joint.1_con+ should follow Joint.1, and Joint.2_con+  should follow Joint.2.

So put the Joint.1_con+ object into the Link field, and Joint.1 joint into the To field. For this the default settings are fine. We want it to match the PSR of the handle. Once you’ve done that, add another rule, and linke Joint.2_con+ to Joint.2.

When you save the template, build it, and adjust the handles, you should find your adjustments stay put when you exit adjust mode. Thats good! That means we are all set on the Adjustments front.


That means we have just one more thing left to do and that is to set up the hotspots. So go into the Hotspots tab and add 2 targets. Then for each target, link to one of your two controllers. Save, and you’re done! Thats the gist of using this system to create your own templates. Have fun and I can’t wait to see what templates others can come up with.

The final file can be found here

Comments No Comments »

Life has been busy. Last week, MAXON announced CINEMA 4D Release 13. It’s probably the best version of CINEMA I’ve ever been a part of, and I have been a part of it since R8. It’s also the most involved I’ve been in a beta really. There’s just a great bunch of tools out there, the Physical Render makes some really sexy renders, as does the new SSS shader. There’s a bunch of stuff, but since I don’t render, it doesn’t appeal to me. But MAXON made a shit ton of improvements to both Character rigging and Character Animation.

For character animation they’ve implemented a lot of little things, F-Curve updating in the viewport as you adjust it, local axis manipulation(ie selecting all the joints of a finger, and rotating to make it curl), as well as locking or even limiting axes while animating(so you can only rotate on Y, or only move and not rotate an object).

For rigging, they gave you the Character Object and Component tag, which I have been a part of since…gosh a while ago. The system is, in my opinion the most flexible system out there. Others may prove me wrong, someone mentioned Biped and CAT in Max and the CDK in XSI, the former 2 i believe are not as flexible but again, I might be wrong and if I am, please lemme know with some examples, but hold your thoughts til the end of this, please.

This system is those two objects i mentioned above. Well, one object, one tag. Basically you have a template file stored in your library. This can either be one that came with the app that you shouldn’t touch, or a custom one you create yourself. In this template file you use the Component tag to define and control everything.

The Character Object then reads these template files, and based on the Component tag setting allows you to create “components”. The Components represent elements of your rig, spine, legs, arms, hands, etc. The Component tag dictates when and where a component can be created. So you can go nuts and make it possible to add arms to your head, or make it more restrictive so it behaves more naturally, it’s really up to the template designer(me I prefer the latter the majority of the time).

windowHere you can see the Object Manager showing the Character Object as well as 2 components that have been built. The Attributes Manager below lists the template as well as components that can be created.

Once you’ve built your components, you then can then switch to Adjust mode, which will simplify your viewport to these circles that are handles. You can just click and drag to move the handles to match the appropriate parts of your mesh.

window-1On the left is the rig when you switch to adjust mode. The right shows the rig adjusted to the character

Then, you switch to the Bind tab, drop the objects you want to be bound, and because the Component tag has it all set up, it knows which joints to weight, so if you are using something like an IK/FK Blend with 3 chains, it knows which chain to bind properly, because the template designer set it up. The Adjusting is really quite insane, that it knows how to handle such complicated setups. The rig in the pictures for instance uses IK/FK Blend for Arms, Spine, and Legs, as well as a Bendy/Rubber Hose type setup for the arms and Legs, SplineIK for the Spine, FK Arm orientation(ie to follow the collar or remain independent), Head Orientation(follow the Head or Neck), footroll and all sorts of stuff. To adjust before you’d have to disable tags, remove goals in some instances, find all the joints move them all, make sure they all match, put the goals back in, and turn expressions back on. For such a process to be simplifies to those simple circles is mind blowing, and when I switch out of Adjust mode, the rig is correct and ready to go!

This is all, like I said, handled by the Component tag, which is a complex beast. Making your own template takes time, it takes patience, and some know how. But it’s also fairly intuitive. Tabs, are pretty well named to know what things do(for the most part). You have control over where things get inserted(Insertion Tab) what elements from the template get included when a component is created(Include), what joints get bound(Bind), and setting up your Adjustment rules so the rig can be adjusted properly(Adjustments).

But like I said, I think the true power of this system is its flexibility. Yeah it can make just about any rig you want(It comes with bipeds, quadrupeds, bird rig, fish rig, etc.) but you can make your own rigs. I have a face rig I have been working on in my spare time for instance.

Big deal, so do other systems right? Yes, they do, and like those other systems, if the template is set up properly you can mix and match these templates to create a mythical creature of some kind. If you want a good example of this check out Chris Korns 2011 Siggraph video. His lobster creature is badass.

The nice thing is as I make changes to templates, they update, much like an Xref would(those are new too by the way). For example, The Ottoman project, I’ve been making a template for us to use on it. The idea being, we have 1 template I have to adjust, and all of our main characters would be updated when I make changes. In terms of rigging, I honestly don’t plan on NOT using this. I am now looking at making sure I am always trying to use this system, because I think it is amazing, and for people who have wanted to do Character animation but struggle learning Rigging, this helps tremendously. I lowers the learning curve to just needing to know how to do weight painting, which while a time consuming and sometimes difficult to get looking good, is not a tough thing to understand HOW to do it as opposed to like setting up proper forearm twists and up vectors and all that stuff that I’ve been learning over the last 4 years….you lucky bastards…you’re welcome. ;)

But this system isn’t limited to just characters and or rigs which is why I think it’s incredibly powerful. Using the same objects(Component Tag and Character Object) I can create lots of custom presets. For instance I can easily set it up so I have buildings for components, so I can quickly make a city, or trees, or pipe systems. Check out this Pipeworks example video. Note the custom icons to make it look real professional ;)

With the Component Tag having python it just opens possibilities. I could script an entire rig so it doesnt have anything in the template file except the code. I don’t even have to use multiple components, I could do a 1 click rig button that will make the whole rig both sides(did I mention it does all the mirroring for me?)

I just see so many possibilities with this system, not just as an autorigger which it does a damn fine job of, but also as a method for creating preset rigs and elements for other developers. For instance, Nick Campbell could port his HDR Light Kit over to use this system, I could make a library of Trees, that you can pick the ones you want. I just see this versatile thing being like an open canvas that I’ve already begun exploring ways to create more things like the pipeworks example.

This is my favorite feature of R13, and there’s A LOT for me to love in it. You’ll find out more in other posts I’m sure, but I just wanted to share about this, because I’ve been working on it for a couple of years now, and because something I created with this system comes with the new release, I’m like a proud papa. Expect some tutorials covering those two objects once R13 is out on Cineversity.

For an excellent list of some of the new smaller features that might go under the radar, I suggest checking out Sebastien Florand’s blog:

For some Video demos of the new tools check out Siggraph rewind videos below. The ones pertaining to what I’m talking about are Sebastien Florand, Chris Broeska, and Chris Korn. Click the Videos tab to the left of where it says Chat:

Comments No Comments »

I’ve been diving into Python a lot lately, just because there are things you just want to be able to do yourself. I’ve been talking to a buddy of mine, Charles Wardlaw who is the TD overseer of the Ottoman, and works at March Entertainment. He sometimes challenges me with Python exercies, and sometimes I ask him for ideas(which he offers and they become challenges.)

So between bugging him and Rick, I have been learning a lot of Python in CINEMA 4D. Charles gives me a lot of the theory side of things as well as the standpoint of him being a TD and an Animator he knows how he’d like some scripts to behave, while Rick helps me with SDK stuff in CINEMA. He’s been programming in COFFEE so he knows where to look to find stuff and how to do things. He too is getting into Python. So I usually try to find something and if I have no luck I ask Rick and he usually has a solution.

Which leads me to these useful snippets. Initially the idea was how to copy animation from some objects to other objects. This was originally based on hierarchy(it has now changed) so I needed a way to basically go through an entire hierarchy and perform some action on the object and all it’s children.

def GoDownHierarchy(obj):
if obj is None: return
#Actions can go here
print (obj.GetName())
#End Actions
if (obj.GetDown()):
if (obj.GetNext()):

Now unfortunately, wordpress is kind of killing the necessary tabbing for this to work. But allow me to try to explain what’s going on a bit.

So the first line, def GoDownHierarchy(obj): is just defining our function in Python, no biggie, and it’s also saying when you call this function it needs argument, in this case it’s going to need some kind of object. The next line, if obj is None: return is just a simple check that if you don’t pass an object, nothing happens. Without this, if you passed the function without an object, it should error out I think. After that check, you can put your actions in there. In this case, I’m simply printing out the names of the objects in the hierarchy, nothing fancy.

So after the action we have another if statement: if (obj.GetDown()): This is basically checking to see if there is there is an object as a child of the current object. If there is, it goes to the next line: GoDownHierarchy(obj.GetDown()) This line basically runs the function again. So if the code gets to this line, it goes all the way back to the 3rd line of this code and performs the action again on the object that is a child of the current obj. So effectively when it hits that line, it running the function and passing a new object(obj.GetDown()) to run the function. Then it does this again and again until there is no longer a child and the if (obj.GetDown()): line is FALSE. If it is false, it goes to another if statement if (obj.GetNext()): This line is checking to see if there is a Sibling of the last obj passed to the function. If it is TRUE it will run GoDownHierarchy(obj.GetNext()) which like before it is passing obj,GetNext() into the GoDownHierarchy Function which then causes it to go through the GetDown() conditions(the if statements) so it will go down that hierarchy as well.

So here’s an example of how it works. Here’s an example of my OM. You can see I have Cube 2 selected.


I run the script and I get this in the console:


Note that it didn’t get the numbers 1,14, 15, or 16, because they are not siblings or children.If I took 14 and 15(which also takes 16) and made them a child of 1, this would make them siblings, would this make them be included? Well, that depends. If the siblings are ABOVE the selected object, they won’t be printed. If they are below the selected object, then yes, it will work. Easy Peasy right?

Now, what if you want to actually go UP the hierarchy? For instance, what if you need to find the top root of a selected object? Well that’s easy, you can take this same code, you just have to make 2 little changes. Here’s the Code:

def GoUpHierarchy(obj):
if obj is None: return
#Actions can go here
print (obj.GetName())
#End Actions
if (obj.GetUp()):
if (obj.GetPred()):

So obviously if you’re going to go up your hierarchy you don’t want it named “GoDownHierarchy”. So You’ll see each reference to the function’s name has been changed to “GoUpHierarchy”. Besides that, you need to make some changes. Instead of GetDown() you need to use GetUp(), and instead of GetNext() you gotta use GetPred(). That’s it! Easy cheese!

Comments 4 Comments »