DAURES Clement - Rigging / Generalist - Entry 2024

Hi ! After an intense year practicing 3D, I would like to share with you what I have achieved over the last 10 months.

Here is a short summary:

- Dragon (rig project project)

- Droid (rig personal project)

- Lucanus Cervus (rig/lighting/comp project)

- The Hut (lighting comp project)

- Blue Bee (rig project to help a friend)

- Animal (lighting/comp project)

-Cartoon Car (rig project)

Hope you like it !

This collaborative project, undertaken independently with Ludovic Loureiro Carrico, Axel Revidon, Arthur Justeau, and Hugo Gerard, involved creating three animated shots featuring a realistic dragon. I focused on the rigging of the dragon.

Here is our final product : 

The challenge was to create assets that would translate well to animation and texturing stages, with enough deformation and possibilities to allow the animator to bring our little dragon to life, but also with excellent volume conservation to ensure that the displacements and textures do not break.

Here are some screenshots of the final shot : 

This was a new consideration for me, forcing me to think beyond the functionality of my rig, thinking of all the departments that would be working on it. I had never rigged before October 2023, and Axel and Ludovic came to talk to me about the dragon in November 2023. I immediately agreed to join them on the project, seeing what it could bring me in the long term, both socially and in terms of skills. I did a lot of research outside the classroom and learned a lot (from blendshapes, to ribbons, to UV pin (which, I learned at my own expense, creates matrix constraints and makes exporting alembic impossible, posing a problem for production) and, innocent but already a first challenge, arm stretch). It was the first time I'd embarked on such an ambitious project, only a month after I'd started rigging.

Even though this was my first foray into this world, I'm very proud of the result and of what my comrades managed to achieve in addition to my rig.

Here's the Dragon Rig showcase :

Before arriving at the above animated result with a clean rig, we had a lot of problems to adapt to throughout the production chain. I'll list the main ones here:

01 - Skinning

My first dive into the world of skinning [ In rigging, skinning is attaching the 3D model's surface (mesh, here our dragon) to the skeleton (bones) so the model moves realistically when the bones are animated ] was very long not because of the process and technique, but because of the model's polygon density. Axel didn't anticipate this step by keeping a lowPoly, so I had to skin a rather heavy version of the model, which took up a lot of my time.

02 - Blendshapes

When I received Axel's model, the dragon wasn't at the center of the world. Big mistake on my part, I didn't check this part. So I built my skeleton on the dragon and binded skin (an operation that wraps the mesh on the skeleton). I then placed it back in the center of the world and froze it. But the envelope of my skin at 0 remained in its original position. When the blendshapes stage arrived, I found myself with an offset on the blendshapes. A big problem that made me panic before correcting it by exporting the skin in an .xml file and recentering all my meshes in the center of the world before binding the skin again.

03- Jaw

This also falls into the Blendshape category, but as Axel had modeled the dragon with its mouth open, its shape was horrible when it closed its mouth. I had to make a corrective blendshape to allow the dragon to close its mouth, even if its mouth remains horrible when closed it limits the damage.

Here is a slide of before/after mouth blendshape : 

04 - Rig weight

With all the constraints and blendshapes applied to the dragon, the rig was rather heavy. The following problem (05 - Membrana) also forced me to add a mesh without wings with blendshapes.

So I had to try to maximize the optimization for Ludovic (Animator). So I created a toggle for all the blendshapes of the two meshes, controller visibility toggles as well as a third lowpoly model with the Zbrush remesher in order to make the rig much lighter and therefore animator friendly.

05 - Membrana

The membrane was our biggest problem by far (we almost gave up on the project with it). We had a major problem with clipping (faces passing over each other), making any hope of subsurface or even animation impossible.

Here are a few examples of the awful problem: 

Faced with this problem, I then asked Théo Murat, who had rigged a dragon on his end-of-study film, if he had a solution. Here is his response : “Put a delta mesh (deformer ) on your bodysuit and otherwise not much solution, apart from skin a little better and correct in alembic or other”. When I received this message, I was devastated. But by talking a little with him, I learned that we could try to simulate the wings. A month and a half from the deadline that my team and I had set for ourselves, here I found myself peeling the ncloth from top to bottom.

The first tests as you can see below, were not conclusive : 

But after many tries, I ended up having a convincing result, but the membrane was still too elastic.

Another problem posed us a problem, it was impossible to wrap (operation of projection of one mesh onto another) the poly of the wings and the dragon with wings on the highpoly, because it took the two scales and doubled in volume . The alternative solution I found (separate the membrana with thickness and the body) seemed to work until this:

When Axel activated the catmull-clark, the wings were no longer connected to the arm.

We therefore made the choice with the team to keep the basic model, I retouched the skin even more cleanly to limit penetration as much as possible, and Axel removed the subsurface of the wings. All this allowed Ludovic, paying attention to penetrations, to create this wonderful animation : 

Once the animation was done, Axel and Arthur set about producing a crazy image. Here are the 3 shots, with greyscale, rig, render and compositing passes :

Before to conclude, I would like to share with you some screen of the node graph of my dragon, automatising and making possible some features on the rig.

Conclusion :

In conclusion, this project is by far the one that taught me the most as a rigger, I discovered a lot of new concepts which will be a definite asset to me in the future. Thanks to him, I discovered teamwork on small productions, which turns out to be an experience and a way of organizing yourself that is very different from solo work.

I am now much more comfortable with teamwork and pipeline operation. It is thanks to this project that I was able to carry out the following project:

This droid is a model created by Matteo Michel. He posted his project on discord, and asked if anyone would be willing to rig it. After the dragon project (which is an organic rig), I jumped at the chance to make a mechanical rig.

This project is still in progress, I haven't finished rigging it yet. But here are some results we were able to achieve to the entry of 2024 :

I took this project as an opportunity to familiarize myself with matrix and its matrix constraints which allow more lighter and optimized rig. (I apologize but this is going to get a little technical and I will try to popularize what matrices are in our 3D space). 

Before this, I would like to thank Théo Murat who helped me to troubleshoot some mistakes with order plugging matrix, because matrix order are really important.

To put it simply, Maya uses 4x4 matrices to define the position, rotation, and scale of objects in the scene. These matrices are essentially grids of numbers that encode transformation information.

There are two main types of matrices in Maya:

Transformation Matrices: These define how an object is transformed in the scene. They include:

Local Matrix: Represents the object's transformation relative to its parent object.

World Matrix: Represents the object's final position and orientation in the entire scene, considering all parent transformations.

Inverse Matrices: These are used to "undo" the transformation of a matrix. For example, the inverse of a parent's world matrix is used to calculate a child object's local matrix.

Calculating Matrices:

Maya doesn't directly show the calculations, but it performs them based on the user's actions. Here's a general idea:

When you translate, rotate, or scale an object, Maya updates its local matrix.

To get the world matrix, Maya multiplies the local matrix of an object with the world matrices of all its parent objects, effectively accumulating transformations.

Inverse matrices are calculated using mathematical operations specific to 4x4 matrices.

To manipulate the matrix, we have many nodes. These nodes offer a versatile way to manipulate and combine transformations, enabling complex rigging and animation setups.

Maya offers a variety of matrix nodes, each serving a specific purpose:

Matrix Utility Nodes:

Add Matrix: Combines multiple input matrices into a single output matrix, representing the sum of their transformations.

Mult Matrix: Multiplies multiple input matrices, resulting in a combined transformation.

Inverse Matrix: Calculates the inverse of an input matrix, essentially "undoing" its transformation. Such as a “Reverse” node.

Pick Matrix : Allow to isolate Translate, Rotation, Scale or Shear on a Matrix

Hold Matrix : Allow to keep values from a matrix. (Can be done by compose matrix too)

Transform Operation Nodes:

Blend Matrix: Blends multiple input matrices based on weight values, allowing for smooth transitions between transformations (as an IK/FK switch for example).

Decompose Matrix: Extracts the translation, rotation, and scale components from an input matrix to give matrix compatibility with all native maya node Transform.

Compose Matrix: Combines separate translation, rotation, and scale values into a single output matrix.

AimMatrix is an Hybrid: combines aspects of transform and utility category

aimMatrix : Aims (or aligns) an object based on a target point or vector and another matrix defining the "up" direction.

Other Matrix Nodes:

Matrix from Euler: Converts Euler angles (rotation in degrees or radians) into a corresponding 4x4 matrix. (I haven’t used it yet)

Matrix from Quaternion: Converts a quaternion (rotation representation using a 4-element vector) into a 4x4 matrix. (I haven’t used it yet)

Now that we have the theory, it's quite simple to move on to practice. How to create a matrix point constraint ? Here is an example made on the droid rig

There, I wanted for the Ctrl_Hand_IK_Lt (The hand IK controller) to constraint in Point (only on translate) the IKRP_Arm_Lt (Inverse Kinematic Rotate Plane of the left arm). We take the World matrix of the Ctrl_Hand_IK_Lt to plug it into a pickMatrix node that isolate the translate of the controller and we plug the pickMatrix into a multMatrix (multMat_IKRP_Lt.matrixIn[0]). To undo the transformation of the IKRP_Arm_Lt, we plug the World Inverse Matrix of it parent in hierarchy, here grp_IKRP in the second input of the multMatrix (multMat_IKRP_Lt.matrixIn[1]). sumMatrix into the offset parent of the constrained object, and voilà, the pivot translation of the IKRP_Arm_Lt are matching the translation of Ctrl_Hand_IK_Lt

But this model does not preserve the offset of the constrained object. That’s why we use a holdMatrix or a composeMatrix that we plug into the worldMatrix of the constrained object first, then we unplug it to plug it in the “matrixIn[0]” of the multMatrix that will be plugged into the constrained object. The parent constrainer object in “matrixIn[1] and the parent object of the constrained object in “matrixIn[2]” 

All of this can be automatised by the script. Here’s a python script based on Théo Murat model script I rewrited to meet my needs.

With this, I could almost have easily built my entire rig with simple constraints. But in order to fully understand all the matrices and even if the script would have helped me a lot, I chose to do everything by hand. This allowed me to play with the matrices and make mistakes, to understand how everything worked. I still have a long way to go in the world of matrices, because they open up endless new possibilities. 

Here is a screenshot of the Node Graph of Constraints Controllers on the finger (without holdMatrix because there was no need to) : 

Once the simple constraints were made, all I had to do was add an IKFK switch. For this, I took the joints of my arm, which I duplicated and oriented so that I could create an IK Handle. So I had two chains of joints. One with zero translation and orient joint and the other oriented.

Once the IK Handle was created, all I had to do was vary my arm Sk_Hand between the worldMatrix of the controllers (oriented, since the joints match the transformations) and that of the arm joints with the IK_Handle with a blendMatrix Node.

Here is an overview of the node graph of the IK/FK Arms Droid Rig : 

I also played to create an auto rotation of the shoulder because his epaulet had to open at the same time as he opened his arm. And this model had to be compatible with the IKFK switch.

Here is a screen of the node graph :

To make it, I take the rotation in a condition node, which checked if the IK/Fk attribute was On or Off (0/1). So it only acted on the corresponding joint.

Then, I divide the value of the rotation with a calculation which corresponds to the movement of the shoulder, then I clamp to avoid any problem before reinjecting the value into a joint which manages the orientation of the shoulder on Z. Same technique for shoulder rotation, but on the X axis

I'm missing a few things to do on this rig (IK/FK on legs, Foot Roll, Global Scale) but here is a first version of the droid showcase rig

In conclusion, diving into Maya and the concept of matrices was a fantastic project! It's given me a solid foundation and a real hunger to push further. Now I'm excited to explore even more complex matrix applications to create some truly incredible and intricate rigs. 

Now I want to take you through the first school project (october 2023-december 2023) in lighting/rendering we were applied to: creating a realistic insect render. This project was a fantastic learning experience, pushing me to tackle new technical challenges at every stage.

The brief was simple: create a realistic insect render. However, the freedom to choose the insect offered a chance to explore. I opted for the stag beetle (Lucanus cervus) – a captivating choice due to its impressive size and those magnificent mandibles.

Here’s the final result : 

Modeling an organic object like this was a first for me. To ensure accuracy, I heavily relied on reference photos. I gathered high-resolution images from various angles, focusing on the intricate details of the stag beetle's anatomy.

Here are my references :

Once the search for references was completed, I started modeling. We needed a mesh suitable for deformation for the rig. I then worked on the texture of my insect

Here is the lookdev switch between modeling and texturing

I then added fur using xgen to my insect to make it more realistic.

At the same time as I was working on my lookdev, I built my environment for my final shot. To showcase the stag beetle, I wanted to create a natural environment. I opted for a forest scene, and here's where my skills in building environments came into play. I Modeled trees, sculpted realistic leaves and here was the first result

Awful isn’t it ? Plus I had a problem with my bump. So I started all over again, but the deadline was fast approaching. And I did a lot of iterations. Here is the main ones

After many tests, I started to have something rather interesting

But I wasn't satisfied, and I ended up taking megascan assets that I mixed together in order to have an interesting result, and here is the final result ( geometry | raw | maya render with blur | nuke comped image)

My final image was ready, but I chose to push the project further. With the dragon, I was comfortable with the idea of ​​rigging an insect, which is quite simple. Furthermore I didn't need a very complex rig, because I just wanted to bring my stag beetle to life

Here’s the rig showcase of my insect :

Once the rig done, I animated the insect and the camera. Then, the final stage involved rendering the animation and compositing it. To achieve the highest level of detail and realism, I delved deep into render layers. These layers allowed me to control specific aspects of the scene – lighting, shadows, depth of field – independently, giving me more creative control over the final image.

Here’s an overview of the nuke graph of my insect (I won’t go in detail into it) :

Finally, compositing brought everything together. This is where I merged the rendered animation with the forest environment, adding subtle effects like depth haze and color grading to create a cohesive and believable scene. Compositing opened a world of creative possibilities, allowing me to fine-tune the final image and truly bring the stag beetle to life.

Here are the render passes of my insect : 

To conclude, this project was a challenging but rewarding experience. I learned a tremendous amount about modeling organic objects, texturing, environment creation, animation, rendering, and compositing. Each stage presented its own technical hurdles, but overcoming them has significantly enhanced my 3D skillset.

Now I want to take you through the last school project in lighting/rendering we were applied to: creating a stylised Hut of a concept character. This project was also a fantastic learning experience, pushing me to tackle new technical challenges at every stage.

Here’s the final result :

The character I chose to represent through it hut was the following : 

Before to model anything, I went through a big preproduction project.

As my stag beetle, the process was simply the same, but stylised. Then I created everything from the modeling to the composting part.

You can find all the render passes below :

Thanks to the dragon project, I was able to create a ribbon-based bridge rig very quickly, giving me many possibilities. Here’s the showcase :

The Hut project was a fantastic learning experience in the realm of stylized modeling. It allowed me to delve deeper into modeling, but also in concept. I'm excited to take these newfound skills and continue exploring the creative possibilities of stylized art, in order to be able to create stylized models for rigging and animation

Matthis Ardiley and I are in the same promotions, and so we both had to create an insect. He chose a blue bee. Here’s the result of our collaboration : 

During the project, Matthis came to see me for a problem that he couldn't resolve on his insect rig and to ask me questions about the insect rig process. As he had helped me with a texture problem that I had, I offered to rig his insect for him. Here’s a screenshot of the insect and its rig.

Thanks to that, Matthis was able to animate it. And here is the final result with greyscale passes and controllers

As I had already rigged my Stag Beetle, it was simple. But it's always nice to do a favor for a friend.

The mule Deer was an interesting learning experience. This project involved creating a realistic quadruped with fur (to go deeper with X-Gen). I learned a lot about X-Gen techniques, making me realize that grooming is a profession in its own right. Even if my groom is not very handsome and if I didn’t rig it with Controllers, just a skinned skeleton, I still learned a lot of things.

Here’s the final result with the passes :

But why put this project here? In fact, he gave me a lot. I created the mesh on Zbrush, in digital sculpture. This familiarization with digital sculpture was a great help in creating the dragon blendshapes, even if the software is different, the technique is more or less the same. Here are some screenshots of my zbrush viewport

In addition, so that my model can be used in production, I thought about a deformable and clean topology for the future. 

Even if this was not the case on this project, I know that my deer can be used in a rig, perhaps for a future personal project. Thanks to this project, I learned a lot in terms of sculpture and retopology, my projects informed me about the needs in terms of deformation, I learned to have cleaner modeling than my old projects before

The cartoon Car rig means a lot to me. This project involved creating a complex rig for a car equipped with a functional mechanical arm. But why does it represent so much? This project is my first contact with the field of rigging, for which I immediately fell in love with the passion. Here’s the animated version of my rig :

In September 2023, we first began with the freedom to model a car in any style that appealed to us. This allowed for some creative expression at the outset.

I chose to make a coccinelle look-like car.

Here’s a turn of my model : 

As soon as the project started, I wanted to push my car rig further. I learned a lot during this project, such as the creation of simple constraints, the existence of joints and their orientation, the existence and importance of Offset groups, the great importance of order in the hierarchy, the attributes, the existence of deformers for the rig and even the creation of an IK/FK switch !

Here’s the rigging showcase of my car rig : 

But in addition to all that, I also learned to automate certain things like the roar of an engine or the rotation of a flashing light depending on the time. Here are some screenshots of my expression editor windows

With all these features, the rig allows for full animation control of both the car and the arm, for creative possibilities. Our teacher said us to animate it ourselves and to move everything to test the rig and I think it was one of the better pieces of advice of the year. I so produced this little animation to see if all was working well.

Here’s the result with render passes : 

Conclusion :

Looking back on this year, I've definitely learned a lot and improved my skills in many areas. It's been great to connect with people and have some positive social experiences too. Those interactions have made me even more interested in working on projects with others. I'm excited to see what kind of teamwork opportunities come up next! There's always more to learn, and I'm eager to keep collaborating and developing my abilities.