Month: July 2026

Of all the things in this process I had been quietly afraid of, rigging was at the top of the list. By quite a margin.

My only real previous experience with rigging a character was painful enough that it left a mark. Hours of work on a model that was significantly simpler than this one, with very little to show for it at the end. So going into this session I had a specific kind of low-grade anxiety about the whole thing. The kind where you keep putting off pressing play on the tutorial because you already know it’s going to be hard.

It was hard. But nowhere near as hard as last time, and that’s almost entirely down to having a clear method to follow.

How Patata School Approaches Rigging

The starting point is Rigify, which is a Blender add-on that comes bundled with the software but needs to be manually enabled in the preferences before you can use it. Once it’s active, you get access to the Rigify Basic Human Meta-Rig, which is essentially a preset skeleton built for humanoid characters. Instead of placing every bone from scratch, you start with something that already has the right structure and just adjust it to fit your specific model.

The process goes like this: add the meta-rig, scale it so it roughly matches the proportions of your character, and then apply the scale before doing anything else. Skipping that step causes all kinds of strange behavior later in the process, so it’s worth being careful about. Then you go through and reposition each bone so the joints sit exactly where they should on the model. Elbows, knees, shoulders, hips. The goal is to get the skeleton to match the character as precisely as possible.

Two things Patata School emphasized here that genuinely matter: first, make sure the bones are placed at the actual joint positions, not just roughly in the right area. The quality of the deformation later depends directly on this. Second, and this one is easy to overlook, bend the limbs very slightly before generating the rig. Just a small angle at the elbow and knee. This tells Blender which direction those joints are meant to bend, and without it the automatic weight painting can get confused and produce some deeply weird results.

Once the bones are positioned correctly you hit Generate Rig, which converts the meta-rig into a fully functional control rig with all the handles and constraints you’d expect. Then you parent the mesh to the rig using Automatic Weights, which attempts to figure out on its own which bones should influence which parts of the mesh.

Attaching the Hair

The hair isn’t part of the original body mesh, so it can’t just be parented with Automatic Weights like everything else. The approach here is a bit different. First you apply all transforms on the hair object, which is one of those steps that sounds boring but prevents a lot of confusing behavior down the line. Then instead of parenting directly, you add a Child Of constraint to the hair and set the head bone as the parent. This tells the hair to follow the head bone specifically whenever the rig moves.

The catch is that after setting this up the positioning usually shifts, because Blender is recalculating the relationship between the hair and its new parent. The fix is straightforward: hit Set Inverse in the Child Of constraint settings, which snaps everything back to where it should be. Once that’s done the hair moves cleanly with the head, exactly as it should.

The Part Where Things Got Funky

Automatic Weights is impressive and also not perfect. In my case it produced two specific problems that needed fixing.

The first one: my Grease Pencil eyes were stretching when I moved the head. Not a subtle stretch either, a full-on horror-movie distortion. The fix was to manually weight paint the eyes so they were fully and exclusively influenced by the head bone, removing any competing influence from surrounding bones that had crept in.

The second one was genuinely funny. My ears were moving with my arms. Not the head, the arms. I have no clear explanation for why the automatic weight process decided that’s what should happen, but it did. The fix here was simpler than I expected: I selected the ears in Object Mode, went into the vertex groups, found the ones corresponding to the upper arm bones, and deleted them. With those influences removed, the ears behaved correctly.

After sorting out the weights I also went back through the materials, because moving the character around revealed a few spots I’d missed in the previous session where faces either had no material assigned or had the wrong one. Small fixes, but worth doing properly before moving on.

And then everything worked. Genuinely worked, arms moving right, head moving right, ears staying where ears are supposed to stay. I was relieved in a way that probably says a lot about how the previous sessions had gone.

One Honest Note

The tutorial wasn’t completely step-by-step for every problem that came up. The instructor ran into different issues than I did when generating and applying the rig, which meant I had to go and research some of the fixes myself rather than just following along. A bit frustrating in the moment, but probably good practice for the reality of working in Blender independently, where you will constantly be troubleshooting things the tutorial didn’t cover.

Next up is actually setting up the stage my character will move around in. Before that though, a quick note: the next lecture in the Patata School course covers how to give your character weapons to hold and animate them accordingly. Interesting, but completely irrelevant to what I’m building here. I’m skipping it for now and will come back to it if I ever find myself working on a project where that’s actually useful.

See ya!

Okay, this was the session I’d been looking forward to since I started. Modelling was interesting, sculpting was a struggle, but giving my character actual color? That’s the kind of thing that makes it start to feel real.

And it delivered. This was by far the most enjoyable session so far.

A Few Things I Didn’t Know Blender Could Do

Right at the start of the tutorial I learned something completely unrelated to what we were actually doing, but useful enough that I want to write it down anyway. Blender has built-in presets for HDR maps. I had no idea. In the past I always downloaded them from Polyhaven whenever I needed one, which is fine, but knowing there are presets already sitting in Blender is the kind of thing that saves time on smaller projects where you just want to quickly preview how something looks under an HDR environment. Not needed for this project specifically, but definitely filing that away.

Color Space and Why It Actually Matters

Before touching any materials, Patata School explained something I’d never really thought about before: color space. By default, Blender uses AgX as its viewport color transform. AgX is designed to handle high dynamic range rendering in a more filmic, photorealistic way, which makes colors look richer and more complex. The thing is, for cel shading, that’s actually a problem. AgX processes and remaps colors in a way that can shift your shading tones away from what you actually set, which means the carefully chosen highlights, midtones and shadows you defined in your material don’t come out looking quite right in the viewport. Switching to Standard color space disables that processing and shows colors more directly as they are, which gives you much more predictable and accurate results when working with stylized, flat shading. I tested both and the difference was noticeable. Standard was clearly the right call here.

Setting Up the Cel Shading

This is where things got genuinely interesting. To achieve the cel shaded look, you build a material in the Shader Editor using a specific node setup. The core of it is a Color Ramp node, which lets you define exactly how light behaves across the surface of your model by setting distinct color stops for the highlight, midtone and shadow areas. Instead of a smooth gradient from light to dark like you’d get with a standard material, the Color Ramp lets you create sharp, defined bands of color, which is what gives cel shading its characteristic flat, illustrative look.

To drive that Color Ramp, you feed it the output of a Shader to RGB node, which converts the lighting information from Blender’s rendering engine into a color value that the Color Ramp can then remap. This is the part I’ll be honest about: I don’t fully understand why the Shader to RGB node works the way it does at a technical level. The tutorial explained it and I followed along, but some of the underlying logic is still a bit opaque to me. What I do understand is that without it, the Color Ramp has nothing to remap, so the whole setup falls apart. Sometimes you just have to accept that a thing works before you fully understand why it works.

Once the skin material was set up, the rest was straightforward. I duplicated the material, swapped the colors in the Color Ramp to match the other parts of the character, and assigned each material to the relevant faces on the model. The really practical upside of this approach is that every material has its own highlight, midtone and shadow colors that you can adjust independently. If you want the clothing to have a cooler shadow tone than the skin, you just change it in that material without affecting anything else.

One thing that saved me a lot of frustration: if you lose your face selection after assigning a material, you don’t have to reselect everything manually. There’s a Select button right in the material tab that reselects all faces assigned to that material instantly. I cannot count how many times in the past I did this the hard way without knowing that existed.

One Thing to Keep in Mind Going Forward

The session was mostly smooth, but one thing became clear pretty quickly: assigning materials to specific parts of a mesh is significantly easier when the mesh is clean and well-structured. Selecting the right faces in a chaotic or dense mesh is genuinely annoying, and my model was noticeably more complex than the one in the tutorial. Something I noticed a bit too late, and something I’ll think about much earlier next time.

But overall? Best session yet. The character is starting to look like something.

See ya!

Alright. Lesson two is done. And if lesson one took longer than expected, lesson two took longer than that.

I genuinely cannot pinpoint exactly why the hair gave me so much trouble. It wasn’t conceptually complicated, the process is pretty straightforward once you see it laid out. You start with basic geometric shapes, subdivide them until they’re rounder and softer, join everything together, apply the subdivision, and then smooth it all out with sculpting tools. Simple enough on paper. In practice I spent way more time on it than I’d like to admit, staring at lumps that refused to look like hair no matter what I did with them.

I think the honest answer is that sculpting just isn’t naturally where my head is at. Coming from a background in film and motion design, I’m used to working with footage, keyframes, timing. Things that move through time. Pushing and pulling geometry in 3D space with a brush is a completely different kind of spatial thinking, and apparently mine needs some work. That said, the process was still genuinely interesting, because up until this point I had absolutely no idea how you’d even approach creating a 3D object in a weird, organic shape. Now at least I have a method.

A Few Things That Actually Made Sense

One thing that clicked really nicely was the asymmetry tip. When you’re working in a simplified, stylized character style like this, perfectly symmetrical hair looks artificial and stiff. Adding small variations, a strand that goes slightly differently, a volume that’s a bit fuller on one side, makes the whole thing read as more natural even within an intentionally simple aesthetic. It’s a small detail but the difference is visible.

I also picked up a workflow trick I’m going to use constantly going forward: how to create a clean round shape from a cube. You loop cut the cube at specific points, then apply a subdivision surface, and you get something much smoother and rounder than you’d expect from the starting geometry. This is how Patata School approached the ears, and it works really well. A circle that actually sits cleanly in 3D space, built from a box. Genuinely useful to know.

The other thing worth noting is how to place symmetrical objects on a character that weren’t part of the original mirrored mesh. If you want to add something like ears after the fact and have them appear on both sides, the trick is to keep the point of origin at the center base of the character, move the object into position in edit mode rather than object mode, and then apply the mirror modifier. Because the origin is centered, the mirror lands exactly where you want it. Clean, no manual placement on the second side. Once I understood why it worked it made complete sense, but figuring it out in the moment would’ve taken me a while on my own.

The Grease Pencil Part Was Actually Fun

After everything I just described, getting to the face was a relief. Patata School uses Blender’s Grease Pencil tool to draw the facial features directly, eyes, mouth, a few hair strands, in a hand-drawn 2D style that sits on top of the 3D model. The result is this slightly goofy, dorky character that looks like it came out of a children’s illustration, and I mean that as a compliment.

I had a genuine laugh looking at what I produced. Preschool-level drawing, objectively. But it has personality, which matters more than technical precision at this stage.

One thing that helped a lot here: switching between Origin and Surface mode in the Grease Pencil settings. In Surface mode your strokes are applied directly to the surface of whatever object you’re drawing on, so the face actually sits on the body rather than floating in front of it. Makes the whole thing look much more cohesive.

The One Thing That’s Still Bothering Me

The body smoothing didn’t fully work out. There are a couple of visible dents along the mirror axis where the two halves of the mesh meet, and no matter how much I poked at them with the sculpting tools, I couldn’t get them to disappear cleanly. Eventually I just left it. Sometimes you have to accept that something isn’t perfect and keep moving. Spending another hour on a seam that might not even be visible in the final render isn’t a good use of time.

The hard part is done though. Next up is materials and color, which I’m genuinely looking forward to.

See ya!

Okay, so. First actual Blender session. Let’s talk about how that went.

The short version: not as smoothly as I’d hoped. The longer version is what this post is about.

I started with Patata School’s course on modelling, rigging and animating a character in Blender — specifically the modelling part, which is obviously the foundation everything else is built on. The idea was to follow along, pick up the workflow, and come out the other end with something I was reasonably happy with. And I did, eventually, come out with something I was reasonably happy with. It just took about three times longer than I expected, and my process looked nothing like what was shown on screen.

The Tutorial Speedrun Problem

Here’s the thing about tutorials: the person making them already knows how to do the thing. Which sounds obvious, but the implication of that is that they move fast. Very fast. The Patata School instructor basically speedran the modelling process — doing everything naturally, intuitively, without stopping to second-guess a single vertex placement. Which is great to watch. And completely useless to imitate in real time if you’ve never done this before.

About fifteen minutes in I abandoned the idea of following along step by step and switched strategies entirely. I freestyled it — using the techniques and tips they explained as a loose guide rather than trying to mirror every single move. Honestly? Probably the right call. Trying to pause, rewind, copy exactly, and keep up with commentary at the same time was already turning into a mess. Better to internalize the logic and apply it in my own way than to fall three steps behind and lose the thread completely.

The Actual Workflow (Which Was a Genuine Revelation)

The technique Patata School teaches for character modelling is, in retrospect, so obviously sensible that I’m mildly annoyed I didn’t figure it out myself earlier.

Step one: draw your character. Two views — front and side. Import both into Blender and place them on the X and Y axis as reference images. Then you model on top of them, using the drawings as a guide for proportions and silhouette. No guessing, no constantly rotating the camera to check if something looks right from a different angle. You just follow the drawing.

I once tried to model a character in Blender completely without tutorials, completely without any system, and it was genuinely painful. I had no idea what I was doing with the topology, no sense of the right workflow order, and it took me forever to get anywhere near something that looked like a character. So seeing this approach laid out clearly was a proper eye-opener — even if it sounds simple in description.

The actual modelling sequence goes: torso and head shape first (no hair at this stage), then one arm. Once one side is done, you delete the other half of the mesh and apply a mirror modifier, which duplicates everything symmetrically. Then you model the remaining leg on the mirrored version and you’re done with the base shape. Clean, logical, and dramatically easier than whatever approach I was taking the first time I tried this.

A few other things worth noting: Patata School strongly emphasized starting with simple, low-poly shapes and only adding a subdivision surface modifier once the foundation is solid. The reasoning is that trying to fix bad geometry after you’ve added a lot of subdivisions is a nightmare — far better to get the base right first and then let the subdivisions smooth everything out. They also use the Auto Smooth Shading option at a later stage to clean up the surface normals, which makes a noticeable difference to how the final mesh looks.

Oh, and a shortcut I didn’t know existed: Ctrl + 2 automatically applies a subdivision modifier at level 2. Genuinely useful, saved me several clicks.

Adjusted Expectations

By the end of the session my expectations for the final outcome had taken a fairly significant hit. Not because the tutorial was bad — it wasn’t, it was good — but because actually following a tutorial, pausing to take notes, rewinding to catch something you missed, and then trying to apply it yourself takes roughly ten times longer than just watching it through. What looks like a forty-minute process in the video is a four-hour afternoon in practice.

Which is fine. That’s how learning works. But I’d be lying if I said my mental image of a polished ten-second character animation with facial rigging and voice acting didn’t get slightly hazier by the end of it.

We’ll see how the next one goes.

See ya!

Fair warning: this post is a bit of a confession. Because finding a skill that actually made sense for me to learn this semester was harder than I expected, and the path I took to land on the one I eventually chose was not exactly a straight line.

Let me explain.

The brief was to learn a new practical skill over the course of the semester and document the process. Which sounds straightforward enough, until you actually sit down and try to figure out what that skill should be, and suddenly every option feels either too random or too disconnected from anything you’re already working on. I really wanted it to tie back to my research topic somehow because if I’m going to spend a significant chunk of time learning something, it might as well be useful beyond just checking a box.

The AI Detour (And Why I Dropped It)

My first thought was to look into AI tools – specifically generative AI techniques for character creation. It would’ve been topically relevant, there’s no shortage of tutorials, and the output would’ve been visually interesting. And I spent maybe two or three hours going down that road before I realized I genuinely just didn’t want to do it.

I’ll be honest: I’m not a fan of AI-generated imagery in general. That’s a whole separate conversation I probably owe a blog post at some point, but the short version is that it didn’t feel like learning something so much as learning how to prompt something else into doing the work. Which just wasn’t what I was looking for here. So I dropped it and went back to my original idea.

The Actual Plan: Blender

The original idea was 3D character animation in Blender – specifically learning enough to model, rig, and animate a character from scratch, or close to it.

Here’s the logic: my framework is essentially designed to identify patterns across sympathetic antagonists. What traits do they have in common? What does a character look like – in terms of personality profile, visual presence, symbolic meaning – when it scores high on all the right dimensions? At some point, the obvious next step is to try and create a character that fits that profile. Not just describe what such a character would look like theoretically, but actually build one.

My first instinct was to do this with live action. Find an actor, write a brief, have them portray the character I had in mind. But the more I thought about it, the more that approach fell apart. Getting the right performance out of someone is genuinely difficult. You’d be dependent on another person’s interpretation, their availability, their range. And the gap between what I imagined and what ended up on screen could easily be enormous. That felt like a variable I didn’t want in the equation.

3D sidesteps most of that. Every choice is mine. The character looks exactly as designed, moves exactly as animated, expresses exactly what I intend. It’s a more direct translation from concept to output.

There’s also a personal reason. In all the time I’ve spent learning about video, film, and motion design, 3D is the one area I’ve basically never touched. I’ve always worked with real-life footage and After Effects, and somehow 3D just never made it into the picture. This felt like the right moment to fix that.

Why Patata School

The platform I’m using is Patata School, which is run by Cabeza Patata – a Barcelona-based creative studio known for their distinctive 2D/3D hybrid aesthetic. The thing that sets their teaching apart is the approach: they call it podcast-style, meaning you’re not memorizing menus and keyboard shortcuts from the start. You’re creating something in the first few hours and learning the tools through the process of actually using them. For someone like me who learns much better by doing than by studying, that’s exactly the right format.

Their course library covers modelling, rigging, facial animation, Grease Pencil work, and a lot more. I found several courses that looked genuinely exciting – especially the ones that mix 2D aesthetics with 3D construction, which aligns well with the kind of stylized, expressive character I have in mind.

What I’m Actually Aiming For

Realistically? I want to end up with a short animation – around ten seconds, nothing cinematic – featuring a custom character with facial animation and voice acting (yes, I’m doing the voice myself, we’ll see how that goes).

Is that optimistic? Absolutely. But I’d rather aim for something concrete and land somewhere slightly short of it than aim for nothing and have nothing to show at the end. The posts going forward will track the actual progress: what I tried, what broke, what somehow worked, and how far I got by the end.

In the worst case I still learned Blender. That’s not a bad outcome.

See ya!

It’s been a really long time since I last wrote one of these posts. Honestly, I barely did any further research on my topic during the break, and I’m not going to pretend otherwise. But the time off wasn’t entirely wasted. In the context of Design & Research 2, I had to do a more structured reflection on the work I’ve already done – and that turned out to be surprisingly useful. Not because it revealed anything radically new, but because it gave me some distance. And distance, it turns out, is exactly what you need to notice the things that have been quietly bothering you for a while.

So before I move on to my plan for learning a new skill this semester, I want to take one more look at where my research actually stands – what I built, what I think works, and what I’d do differently if I were starting today.

What I’ve Built So Far

For anyone who hasn’t read the previous posts: I’ve been working on a systematic framework for analyzing fictional antagonists and antiheroes. The goal is to create a method that’s fast enough to scale across large numbers of characters and rigorous enough to produce results you can actually compare statistically.

The framework has four layers:

Observable Traits – the character as an artefact. Drawing from the ACIS framework by Linke and Prommer, this layer looks at what you can directly see and hear on screen: screentime, spoken dialogue, visual identity, movement, and physical presence. No outside context, no assumptions – only what the viewer actually experiences.

Personality Profile – the character as a represented being. This is the Big Five layer. I developed a custom 20-item coding sheet (4 items per trait, rated on a 1–7 scale) that lets me score any character on Extraversion, Agreeableness, Conscientiousness, Neuroticism, and Openness – purely from on-screen behavior. To make it trustworthy, I also built in a coder agreement check: two people code the same character independently, and we measure how closely their scores correlate. Anything above 0.70 is considered acceptable.

Symbolism & Motivation – what the character represents beyond their actions. A looser, more qualitative layer that captures the central symbol, lead motif, and thematic meaning the character carries. Harder to quantify, but important for explaining why a character resonates, not just how they behave.

Creation & Cultural Context – when and by who the character was made. Demographics of creators and directors, year of release, cultural background. This layer contextualizes everything else and helps explain effects like nostalgia or the influence of the specific era a character was born in.

The theoretical backbone behind all of this is Jens Eder’s Character Clock – though I consciously dropped the Symptom dimension to keep the analysis scalable. Covering all four of Eder’s dimensions in depth per character would take forever. I’d rather analyze 100 characters at a useful level of depth than analyze 5 at an impractical one.

What I’d Actually Change

Here’s the thing that’s been nagging at me since the reflection exercise: the scope is too narrow.

My entire research focus up to this point has been on villains – or more specifically, sympathetic villains. And when I actually look at what my framework does, I realize that framing never made much sense as a hard boundary. The coding sheet doesn’t know whether it’s rating a villain or an antihero. The ACIS-based observable traits layer doesn’t care. The Big Five certainly doesn’t. These tools work on any fictional character.

Restricting the framework to villains feels kind of arbitrary at this point. More than that: it actually limits the analytical value of the whole thing. One of the main goals was always to find out what makes a sympathetic villain different from a clear-cut hero or a straightforward one-dimensional antagonist. But if I only ever analyze the villains, I have nothing to compare them against. That’s a pretty obvious problem.

What I think makes more sense going forward is to broaden the scope to fictional antagonists and morally complex characters in general and then use the framework to actually compare them across the full spectrum. Heroes, antiheroes, villain protagonists, secondary antagonists, the whole range. The patterns only become interesting when you can see the contrast.

There’s also something I want to tighten up on the qualitative side. The Symbolism & Motivation layer is the weakest link in terms of consistency. Right now it’s mostly free-form notation, which makes it almost impossible to compare across characters in any structured way. I haven’t figured out the right solution yet – whether it should be a fixed set of categories, a tagging system, something else entirely – but it’s the one part of the framework that still feels unfinished.

And finally: the coder agreement is still untested in practice. I have the method, I know the threshold, but I haven’t actually run the test with a second coder on a real sample. That’s the most important thing to validate before I start building any kind of database seriously.

So that’s where things stand. A solid structure that needs a wider lens, a qualitative layer that needs more rigidity, and one empirical test that still needs to happen.

Next up: what I’m planning to learn this semester, why I chose it, and – more interestingly – what it actually has to do with all of this.

See ya!