vfx 'n whatnot @andrehitsoy-blog - Tumblr Blog

Posts

Hi there,Really love the tutorial, i am working on the fish project where your tutorial has been very inspiring. However, i am new with the shader network thing. Plus the only compositing tool i have access is AfterFX.I wonder if there is any chances where i can have access to your tutorial files with network shader where i can explore.

Sure thing. Files are here

https://www.dropbox.com/s/fj1kugbz0fsyg05/textureSetup_v001.zip

31: 10 year anniversary

Woah, time flies. It's 10 years since I did my first professional job that aired on tv. I spent 8 weeks in July/August 2002 on creating this tv spot for Mr Lee Noodles.

It was done in LightWave and After Effects, and is one of the things I've done that I'm the most proud of regardless of bad deformations, texture stretching and burnt out sRGB renders :) .

30: textureTiler for Nuke

Here's a WIP texture tiler for Nuke.

Grab an area of any interesting texture or photography to extract a tileable (and tiled) texture of up to 8k with multiple settings.

Download Nuke Gizmo here. (For quick usage, just click on the link, copy code contents from page, paste in Nuke)

Docs:

Right click -> view image for full res:

#textures #nuke

29. algorithm 'n bass

I'll try to write a tutorial in how to make a fish (a largemouth bass) in Maya. I will also script a lot when rigging. Some level of math is involved. Algorithms. 'Algorithm 'n bass'... get it? :) I thought that was kinda neat...

Anyway, I just wanted to check out a couple of ideas, and there aren't many better ways of doing that, while having the possibility of getting feedback, than through writing a tutorial on a practical example.

So I want to present a way (among many) of setting up a multi layered fish rig, from inception to final render. The tutorial will include research, modelling, sculpting/texturing, rigging/ animating, lighting/shading and rendering and is divided into separate posts for each stage of production. Most of the stages/posts aren't finished yet, but I'll try to update them as soon as I can.

Here's a quick breakdown of the stages:

Modelling from reference

UV layout

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

I really hope to exchange some ideas, so feel free to comment, or send me a pm if you can tell me how to do it smarter or if you get any ideas that I would be smart to implement.

The files (Maya scenes/textures/Nuke scripts) will be available at the bottom, but also in each post.

------------------------------------------------------

Downloadables:

Mockup fish model for shader tests (.ma)

#rigging #fish #maya

28: fish: compositing

Compositing

Coming soon.

#nuke #fish

27: fish: lighting/rendering

Back to crowd/flocking/schooling or skip to compositing

Coming soon

#maya #mel #rendering #shadingEngine #fish

26: fish: scripting: crowd/flocking/schooling

Back to referencing or skip to Lighting/rendering

Coming soon

#dynamics #mel #particles #rigging #maya #fish

25: fish: scripting: referencing

Back to path progression or skip to Crowd/flocking/schooling

Coming soon.

#Referencing #mel #rigging #fish #maya

24: fish: rigging: path progression

Back to fins cloth setup or skip to referencing

#fish #maya #rigging

23: fish: rigging: fins cloth setup

Back to basic swim loop or skip to path progression

#rigging #fish #maya

22: fish: rigging: the base swim loop

In order to rig the fish for swimming (which will include animating the fish) we have to know some things about our fish. Different types of fish have different types of body, hence different types of swimming locomotion. The main purpose of the swimming body motion is to produce propulsion in an efficient and ergonomic way, and since anatomy differs from fish to fish, their swimming motion is vastly different also. Jeez, this is badly written.. I need some coffee... View these reference videos shamelessly embedded from youtube while the water is heating:

And unless you own a PETA t-shirt, you might want to watch this. Excellent reference!

Right, much better. Fish locomotion (sustained swimming) is generally divided into two groups, undulatory and oscillatory. "Divided" is not a good word, though, because they are more like two opposite extremes, with most fish falling somewhere in between. Oscillatory is where the propulsion comes from oscillating the median and pectoral fins with no or very little body/tail movement. Undulatory motions involve the wave-like motion passed along the propulsive structure (body and tail) Here's an illustration that shows the differences: Fresh water largemouth bass is an example of a fish with a carangiform body, where there's little side to side translation/rotation on the head and progressively more amplitude of the undulation the further down the body you go. Here are some very nice reference links. There's a lot to read, but even skimming through it greatly increased my basic understanding of how fish swim: Fish Locomotion Study at fisheriesmanagement.co.uk Fish Locomotion: Kinematics and Hydrodynamics of flexible foil-like fins Review of Fish Swimming Modes for Aquatic Locomotion

So having identified the type of motion the fish will need to perform, and also knowing roughly how our rig will work, we can try and plan ahead a little.

Basically, we will try and setup one rig for a basic swim loop and behaviour for thrusts, like twisting the body etc, and then feed that into a path following rig, all of which are automatically set up and populated given a path (dummy object anim, user created nurbs curve, or a particle simulation, where the velocity along the path will drive the speed and intensity of the swim cycle.

I've sketched out this flow chart for the rig (right click to view full size):

Last step of preparation is to prepare the Maya for some heavy rigging, which will speed the process up considerably. Set the menu mode to 'Animation' (unless you're only using the hotbox) and set up some hotkeys for the most frequently used windows. Here are mine, but use whatever feels natural to you. I will refer to these hotkeys, so unless you have specific hotkeys already, I'd recommend setting them up like this:

Graph Editor - Ctrl Alt 'g'

Script Editor - Ctrl Alt 's'

HyperGraph - Ctrl Alt 'h'

Expression Editor - Ctrl Alt 'e'

Connection Editor - Ctrl Alt 'c'

Now onto the first steps of rigging.

Just for the record, I've modeled the fish looking down along the positive Z-axis, so when I say translateX, I mean side-to-side, and translateZ means forwards/backwards. If you're following these steps, it might be a good idea to orient your fish in the same direction and freeze the transform before going further.

In the flow chart you see that we're creating some blendShapes for fish variations. Duplicate the fish a few times and name them descriptively, like bass_fat, bass_thin, bass_long depending on what variations you want to make. I usually like to keep a duplicate of the original fish mesh there as well, in case I screw up or want to tweak the original mesh later (inserting a blendshape at the front of the chain.

I have also started grouping my meshes to keep things tidy, which will be important down the line. How you organize your rig is up to you, but keep the structure in mind throughout the process, and it will be much easier to troubleshoot stuff later on. I have made 3 groups, one for geometry, one for the rig (with sub groups for swim_RIG, xform_RIG and skin_RIG) and one for the control objects and my outliner now looks like this:

I'll start with a fat one, as some fish are hungrier than others (hover to see selected verts and influence area). The white mesh is the original mesh, the blue is the blendShape mesh:

Next is the thin one:

Smaller face variant:

Tail size variation:

Anal fin size variation:

For the tail_waveUp and tail_waveDown meshes we will apply a sine deformer and animate it's translate Y attr for some fins floppyness. These meshes will be used as blendShapes later, so by painting the blendShape weights we'll isolate the effect to the fins.

Select the tail_waveUp mesh and create a sine deformer ( 'Create Deformers' -> 'Non-linear' -> 'Sine'). Name the sine deformer Handle 'tailWaveUpwards_sine' and parent it under your swim_RIG group (if you have one). Reset the sineHandle transform scale to 1 (for more intuitive wavelength and translate values). Set the Amplitude to something low, like 0.1 and the wavelength to 3.

Set rotate X to -20 so it slants backwards a bit and right click on the sine1's offset attribute and click 'Create Expression'. The expression window comes up and immediately set a name for your expression. I'll call it 'tailWaveUpwards_sineOffset_expr'.

Set the expression to:

sine1.offset = - frame / 5;

Press play and see if the motion of the waves looks plausible angle, wavelength and speed wise. Make adjustments if needed.

Now repeat for the tailWaveDownwards, leaving out the minus sign in the expression so it moves down instead of up, and parent both sineHandle transforms under the swim_RIG group:

Lastly, we have the dorsalSpines_down shape. If you watched the reference videos, you perhaps noticed that the spiny part of the dorsal fin is standing up or laying down depending on what "mode" the fish is in. To achieve this up and down motion, we'll create a blendShape, but to create the blendShape, we'll set up a mini rig to act as the modelling tool. Start by creating some joints along each of the modeled spines ('Skeleton' -> 'Joint Tool'). Anchor the top of the back with another joint chain.

Select the spine joints (except the roots) and select all the anchor joints. Shift select the mesh and skin it to the selected joints: 'Skin' -> 'Bind Skin' -> 'Smooth bind' (option box). Bind to: Selected joints, Closest in hierarchy with 'Max influences' set to 3. Now rotate the spine joint chains' root joints down so the spine rays lie flat on the back:

Delete the history of the mesh and pull some vertices to smooth the mesh at the base of the spiny fin (toggling on 'smooth mesh display' (3) might help).

Select our body variations meshes (except the tailWaveUp and -Down meshes) before also selecting the 'largeMouth_bass_swimGeo' and create a blendShape ('Create Deformer' -> 'BlendShape' optionbox. Set the name to 'bodyShapes', Origin to 'Local', and all three checkboxes to 'OFF'

Try them out and make any adjustments to the blendShape targets as you see fit.

Now, create a blendShape each for the tailWaveUpwards and tailWaveDownwards meshes. I called them tailWaveDownShapes and tailWaveUpShapes

Select the fish and either go to 'Edit Deformers' -> 'Paint Blend Shape Weights Tool' or RMB click on the fish and go to 'Paint' -> 'blendshape' -> 'tailWaveDownShapes - targetWeights'.

First set the 'Paint operation' to either Replace or Scale, set the 'Value' to 0 and click the 'Flood' button to set all weights to 0 (fish goes black).

Now use the 'Add operation', 'Value' 1, to roughly paint the tips of the bottom fins white. Checking the 'Clamp' checkboxes (both) may help produce predictable results. Next switch to 'Smooth' operation and make the weights nice and smooth.

Try and get both sides of the fins to have similar values, so we don't get inter penetrating polygons when they wiggle around.

Repeat for the 'tailWaveDownShapes - targetWeights' painting the dorsal fins and the top of the tail:

Turn on the blendShape and see how it looks.

Skeleton:

Let's start with a standard fish spine. First I'll google around for some reference:

Fish generally pivot their body around their neck, which is to say, when they turn, they seemingly turn their head in the desired direction by whipping their tail (not actually turning their neck). The effect, though, is that they pivot around their neck and propel forwards. So let us start the spine from the neck and draw a series of joints down along the body.

Now I'll duplicate this joint chain 2 times and append "_swim" to each of the joints in one of the duplicate hierarchies, and "_anim" to each of the joints in the other. To the original joints' names I append "_skin".

The "anim" ones we'll hook up to some FK anim controllers later to give the animator some straightforward FK level of control, the "swim" chain we'll animate the swim loop with, and the original one we'll skin the swim loop fish mesh with, weighing the influence of the swim loop anim using the master control (which we'll create later).

I strongly recommend naming the joints something descriptive. I chose to append 'J' (for 'Joint') to my anatomical description, followed by number and then variant ("swim" or "anim"):

This way, when you track down an expression, or crawl through the web of connections in the hyperGraph later, everything will be soo much clearer.

Hide the duplicate joint chains and start adding some spine rays/rigs to the spine:

Now I'll do the head joints, and I'll only do them in the "skin" hierarcy, to try and keep the rig as light as possible. We'll spawn the full fish rig using our script later, so I'm trying to keep in mind that there might be 20 or more of them swimming around in Maya in a given scene, and the goal is to make that happen and running in realtime.

The head is fairly rigid due to the skull, so I'll adjust the spine joints' position a bit (select joints, hit 'insert', now you can move them using the 'move pivot tool' without affecting the children. A joint is essentially just a pivot, so the effect is the same as moving them, except the children stay put).

NOTE: if you're adjusting your joints at this stage, remember to unhide and select the corresponding joints in the "anim" and "swim" chains as well. You want to keep them identical copies still.

Now activate the joints tool, and from the side view click on the swimMasterJ_skin joint to declare it as a parent for the joints we will create, and click somewhere further forward, between the gills. A joint will be created. Click at the tip of the nose to create another joint. Switch to the top view and create a joint just a little off the center. This will be our pivot for the upper lip bone. Switch back to the side view and create a joint at the corner of the mouth. From the top view move it along the x-axis until it sits at the corner of the mouth.

The lip joints will be driven using an IK chain, so now is a good time to adjust the local rotation axes, so let up select the newly created joints, and make sure the joints' x-axis points towards it's child joint (except for the headTipJ).

One way of checking is setting the rotation mode to 'gimbal' and check that the y-axis is controlling side to side rotation, the z-axis is up/down and the x-axis is 'roll', or 'bank'.

Another way is going into component mode ('F8'), activate the 'question mark' button to see the local rotation axes. In order to be able to actually rotate the local rotation axes around you have to set the rotation mode to 'local'.

Now, when the head joint is pointing toward the headTipJ, the headTipJ is pointing straight forward (since we'll mirror the lip joints we don't want to 'favor' one side), the left upper lip joint is pointiing back down toward the upperLipCornerJ joint, which in turn is aligned with the continuing line from the parent joint.

The time has come where we mirror the upper lip, so select the upperLipJ_L and bring up the 'Mirror Joint' options ('Skeleton' -> 'Mirror Joint' option box):

Set the 'Mirror Across' choice to 'YZ' since we're mirroring to the other side, choose 'behavior' and since I named my upper lip joint with a "_L" suffix I can search for "_L" and automatically rename the new mirrored joints "_R" instead.

Repeat for the jaw; Activate the 'Joint Tool', click on the head joint (our parent joint), create two jaw joints (one for the breathing loop, and one for FK animation control), a jaw tip and next to it, a lowerLipJ_L joint and last a lowerLipCornerJ_L joint. Orient the joints (select the first jaw joint, go to 'Skeleton' -> 'Orient Joints'), fix the orientation of the jaw tip, making it point its x-axis forward, and snap the lowerLipCornerJ_L to the position of the upperLipCornerJ_L joint.

Shortcuts:

Modeling from reference

UV layout

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

#rigging #fish #maya

21: fish: sculpting

Back to texturing or skip ahead to rigging the base swim loop.

Sculpting

Since the fish isn't very displaced and the base model pretty much covers all features of the fish, we can use the bump map we created and apply it as a displacement layer in Mudbox: "Maps" -> "Sculpt Using Map" -> "New Operation"

More info here.

Just make sure you have enough subdividions first.

Then all we need to tweak are the fins and touch up a bit along uv seams and the face, adding some small creases, scratches and sharpening up edges.

On to the first rigging part. Now the real fun begins!

Shortcuts:

Modeling from reference

UV layout

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

#sculpting #fish #maya #mudbox

20: fish: Shading/texturing

Back to UV layout or skip to sculpting.

Fish skin:

Creating photo real shaders and textures for a fish is surprisingly hard. Fish skin is very complex; It is multi layered, with the individual layers having different material properties such as transparency, bump, reflectivity, sub surface scattering and iridescence. The look of the fish also depends a lot on the lighting and whether the fish is swimming under the surface or if it is out of water.

Below is an illustration of a fish skin cross section. The outer layer is the Epidermis and it is almost totally transparent. It contains a lot of mucous glands which secretes out what we normally refer to as the 'slime coat'. When out of water it gives the fish its glossy reflectiveness and when in water it comes across as a transparent, but slightly milky, "film" of jelly that is more visible towards the edges.

The scales are embedded in the Dermis, which is located underneath the Epidermis, and are sheets made mainly out of calsium based salts and collagen. They are pretty much transparent. Underneath the scales the Dermis also contains the pigment cells that give the fish their color (diffuse texture) and it also contains guanine crystals, which give the fish their metallic or silvery luster and highly optimized light reflectivity and iridescence (to confuse predators and attract mating partners).

The iridescence is an important feature of fish skin. The effect as can be seen on soap bubbles, insect wings and exoskeletons, certain bird feathers (like crows and pigeons), cat eyes and certain minerals/gems, like opals or pearls. In fact, most materials inhibit a varying degree of iridescence. Certain textiles, such as silk and satin have iridescent qualities. Most metal surfaces, rusty and polished alike, feature a level of iridescence. Glass, especially after a couple too many rounds in the dish washer, often become iridescent. Clouds are iridescent, some more than others. In fact, the very air that surrounds us is iridescent. That is the reason the sunsets are red and the midday sky is blue. It is also the mechanics behind rainbows (hence cloud iridescence). Even human skin is iridescent.

Simply put, iridescence is light being reflected in different directions at different wavelengths causing hues to shift with viewing angle.

And under the Dermis we of course have muscles and skeleton binding tissue, which is slightly pinkish and transports a certain amount of light in form of sub surface scattering.

So, as you can see, fish skin is a very complex material with a sofisticated way of interacting with light. We have to make a simplified model of this and I am going to try and split up the layers into: 1 - Epidermis (transparent jelly film), 2 - scales (including iridescence), 3 - Dermis (pigments) and flesh (sub surface scattering):

So we have 4 different types of materials, all of them slightly transparent or translucent, and slightly refracting and blurring the layer underneath based on viewing angle (as the layers are thicker when viewed at an oblique angle). Oh, and also the iridescence.

This could have become a monster of a shader. Incredibly hard to tweak and also very slow to render (and re-render.. and re-render).

So we will tackle the final shader assembly in Nuke, utilizing certain passes, like incident angle, and split the shader up into one shader for each layer: jelly coating (epidermis), iridescence (scales), main textured shader (dermis) and sub surface scatter (subcutaneous flesh).

Shaders:

To set up the shaders I quickly mocked up this low res fish, so that we can try our shaders on a simpler shape (and not start worrying about details/misalignment in the textures). This is purely to concentrate on shading/look, and not on the model or textures. Download the scene file here.

From the reference images I had found, I set out to create some textures for the individual shaders. These are temporary textures used solely for look dev and testing:

For the muscles/flesh and the subsurface scattering I won't be using any textures (yet).

For the dermis and our fish color I found a nice reflection free reference photo, lowered the brightness of the highlights (since were adding them back with the scale shader), made a patch of bass skin tileable (I used the textureTiler for Nuke) and cloned a little bit here and a little bit there to break up the tiling. On separate layers I added variance and the gradient that makes fish dark along the back and bright on the belly (same concept of camouflage that they use for fighter air planes):

For the scale layer I desaturated the base color layer (without the gradient), "equlized" it (I used Gimp, but in Photoshop you might want to use 'Filter - Other - High Pass'), and burnt, dodged and adjusted the levels to get a texture that we will use a a mask for the guanine (iridescence) and whatever we find out later. I masked out the mouth and fins:

And another, with the gradient added, as fish are more silvery on the belly than on its back:

For the scales themselves, I will use a tinfoil normal map tiled a lot of times (20x10) as bump to get the iridescence in the reflective bits of the scales:

And last, but not least, I made a slightly grainy bump map to add some level of randomness (read: realism) to the smooth epidermis shader:

Now I make 3 mia_material_x_passes shaders and four render layers.

The first shader I call dermal_mat and I connect the dermal diffuse color texture to the diffuse slot. I then run the gamma correction script (or do it manually) to insert a gamma node set to 0.4555 after the file texture, bringing it to linear color space. I create a bump shader for the 'overall bump' slot and select the "equalized" scales map. Set the bump to a low value. I open up the 'Render View', go to the 'Display' menu, click on 'Color Management' and set the 'Input Profile' to 'Linear' (as the renders happen in linear colour space) and set the 'Output Profile' to 'sRGB (gamma corrected)'. I do a render and get this:

The second shader I call scales_mat and I set it to a dark diffuse color (insert values here). I plug the "equalized" scales map into the reflectivity slot (outColorR -> reflectivity). We want the scales to spread the reflections so I create an 'Invert' node and plug the outColorR of the scales map into the invert node's '.input' slot using the Connection Editor. I then turn down the glossiness value, enabling the glossy samples attribute slider and set samples to 32 before I connect 'scalesInvert.outputR' to the shader's glossiness slot (annoyingly disabling the samples slider again). I now create a bump shader in the 'overall bump' slot and I find the tinfoil map. I set the tiles to 20x10 (proportional to the dimentions of the fish) and set it to a fairly lowish value. But that's not all. We need to mask it by the scales map. If you've ever done node based compositing, you know that masks are basically images that gets used to multiply the values in another image, so we simply create a multiply/divide node and connect the tinfoil to input1, and the scale map to input2. Now I plug the tinfoilMult.outputX into the bump shader's 'value' plug (I'm using it as a bump, not a normal map).

Now, to achieve the iridescence, I create a ramp texture and delete the placement2d node that comes with it. Don't need it... Create some nice colours in a rainbow spectrum (and maybe add some noise) and create a sampler info node. Iridescence, as you recall, is the interference patterns of differently refracted wavelengths of light (separating the colors) and it changes with viewing angle. So we'll connect the facing ratio attribute of the sampler info node to the ramp's vcoordinates, letting the angle of the surface relatinve to the camera tell the ramp which color it should be at any surface point.

Now create a multiply/divide setup, multiplying the ramp with the scales map again, and connect the multiplyDivide node to the shaders specular color plug. Do a test render.

Next up is the third mia shader, the epidermis_mat. Simply make it very dark (insert values here) and give it a nice, subtle soft specular highlight. Plug the grainy epidermis bump map into it's 'overall bump' slot. Done. We'll do the rest in Nuke.

There is one more shader to set up; the sub surface scattering shader. Create a 'misss_fast_simple' mental ray shader and call it SSS_mat. Newer versions of Maya automatically adds the necessary nodes and connects them, but if you're working in an older version of Maya you also have to create a mentalRayTexture and a 'misss_fast_lmap_maya'. The mentalRayTexture goes into the SSS_material's lightmap slot and into the light map's lightmap slot.

Set the mentalRayTexture 'Writable' checkbox to 'ON' and create an expression for the width and height of the texture :

mentalrayTexture1.miWidth = defaultResolution.width * 2 mentalrayTexture1.miHeight = defaultResolution.height

And set it to 32 bits.

We'll add the subsurface scattering in Nuke, so this will be a utility shader. Therefore, we can set the 'Front SSS color' to GREEN (weight 0.2. radius 4) and the 'Back SSS color' to RED (weight 1, radius 10, depth 5). This means that we have front and back SSS in seperate channels as masks in Nuke, and the BLUE channel leaves us with nothing but that pesky specular highlight that is impossible to completely get rid of in the miSSS shader, which we can then subtract from the other two channels.

Textures:

We already have a nice reference photo that we can base our colour texture on. It is currently projected from the side, so we'll have to bake it down to our UVs and then retouch it in Photoshop.

There are mainly two things that we need to do to the colour texture. First, we need to retouch it, adding patches of texture from sharper and higher res photos. We also need to add more detailed texture along the center line of the fish because our reference photo is showing fresnel reflections and some epidermal scattering towards the silhouette.

I'll use Nuke to create the textures, but you can use whichever 2d painting software you've got access to, like Photoshop, or a 3d paint package like BodyPaint, Zbrush or Mari. For those of you that want to use Nuke for texturing you might want to check out my textureTiler for Nuke as it makes creating and editing non-periodically tiling textures quite easy (shameless self-plug here, but what the heck, it's my blog so I do as I please).

Oh well. Picking a couple of the large bass reference photos and running them through the textureTiler and patching together bits of this with bits of that we'll arrive at something like this:

Here's the colour map only:

I won't argue too much for using Nuke for texturing, BUT I will say that the node based non-destructive workflow (for masks, gridwarps and colour corrections) is a blessing.

Since I don't have a 3d paint package available I'll take care to apply a solid(ish) dark brown colour along the neck and back and a beige colour along the belly so the seam between the left and right side is as indistinguishable as possible.

Also, removing any specular highlights (and reflections/shadows.. any trace of directional lighting, really) from the photos used for textures is important, so that we don't get any 'stuck on' lighting effects on the fish.

And, since we're in Nuke, it's easy to apply grade nodes to the individual source images to non-destructively convert our colour map into a "flattened" contrast bump map, eliminating low frequency luminance differences while preserving the high frequency bump details:

If we create a 'noOp' node just before our 'write' node with an added pull down knob called "texture" with choices for, say 'COL', 'BMP', 'SPC', 'GLOSS' etc it is easy to quickly swith between each texture variant (again, non-destructively) by adding expressions on the grade nodes' disable knob.

So if I have 'ColorCorrect' nodes that only should be applied in the 'BMP' "mode", I'll add the expression :

![string equal [value parent.texture_chooser.texture] "BMP"]

which means that the node is disabled unless the texture chooser is set to 'BMP'.

Here's an openGL screen grab of what we have so far:

STAY TUNED! MORE TO COME!

Here's the Nuke script with reference images used. All read/write nodes are set o use relative paths, so hopefully it should work out of the box:

Dropbox TextureSetup ZIP

Shortcuts:

Modeling from reference

UV layout

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

#textures #maya #fish

19. fish: UV layout

Back to modeling or skip to texturing.

UV Layout

Now, before we can go onto texturing, or even sculpting, we really should unwrap our fish so that we have well laid out uvs.

There are UV layout tools in all 3d applications and there are even programs designed specifically for this task, but a fish is not the hardest thing to unwrap, so we'll do it using Maya's standard tool set.

Until now, I have only used a temporary planar UV projection from the side, which means that the side view photo I was modelling from worked well if I wanted to check what the model looked like with a fish texture while modelling.

Now that we will create proper textures we need to make sure that the uvs are properly laid out, preserving world space polygon area and are intuitive to paint on in Photoshop later.

Unwrapping geometry like this inevitably requires splitting up the mesh so that it can unfold without overlapping itself. We need to make sure that we put these UV border edges in places that are less likely to be seen or where features in the texture might help hide them. Ideally we will not introduce visible edges in the textures, but it is hard to avoid, so we take care when laying out the UVs anyway.

The most important border edge will be along the center of the fish, leaving us with a left and right half of fish. This we will take care of when mirroring the fish later, so we'll start now with splitting off the pelvic and pectoral fins.

Select an edge loop going around the base of the pelvic fin and in the 'Polygons' menu in the UV Texture Editor click on 'Cut UV Edges':

Now select some of the UVs of the fin and, from the 'Select' menu, click on 'Select shell'. Move the fin a bit to the left:

Next, select the upper innermost edge of the fin, from base down around to the bottom tip, and click 'Polygons' - 'Cut UV Edges':

Select the UVs of the fin, click 'Polygons' - 'Unfold' and move/align the unwrapped fin into a suitable UV area:

Repeat for the pectoral fin (cut base edge loop, move UVs away, cut edge of fin edge loop, unfold fin uvs, move/align):

Now, we have an area separating the head from the body where the gills are, and to prevent overlapping uvs here, you have multiple choices. I'm going to separate the head part from the body part so we get the half the inside of the gills on either part . I'll end up with a seam across the top of the head, but for Photoshop painting, a seam is better than distorted polygon areas. If you will be painting in a 3d paint software (BodyPaint, Mudbox, Zbrush or Mari) the distortion is less important and you might want to prevent unnecessary seams instead.

I'll select the edge running down the inside of the gills and cut them:

First, the fins were unfolded using the Maya unfold command, which takes care to remove stretching or distortion. We therefore need to squash the main fish uvs (which were initially normalized to 0 - 1 range) down to about half the height, so the fish and the fins have the same relative proportions (in case we're applying brush patterns or similar in PS later).

The second, more important reason for scaling down the height of the fish uvs, is that we'll mirror the fish afterward and we need space for the UVs of the other side.

Now I'll go ahead and unfold the inside of the gill, and also unwrap the edges of the head that are creeping around towards the center and the inside of the mouth:

And then, after some pulling and nudging and last but not least a round with the 'Tool' - 'Smooth UV Tool' (Unfolding shell by shell - world space), the half fish is unwrapped and ready for mirroring (right click - 'view image' for full res):

Btw, I'm using a uv template image to check the alignment and distortion of the uvs. There are several nice one for grabs on the internet. I'm frequently using two made by the very kind Arnaud Ceysson. You can get them from his Resource Page.

Make sure no geometry, especially the around the fins, is crossing over to -X and do a 'Mesh' - 'Mirror Geometry'. Set 'Merge mode' to 'Connect Border Edges' and pull the 'Merge Threshold' down to zero to prevent unnecessary merging of vertices :

Now, select your new half (including the connected polygon strip along the middle) and do an 'Extract' ('Separate extracted faces' ON).

Select the uvs of the mirrored mesh and move them up to the top half of the uv space.

Click 'Select shell border' (or otherwise select the uvs of the border connecting the mesh to the other half of the fish) and push the uvs out a bit so they don't occupy the same UV space as the neighboring edges. The 'Tool' - 'UV Smudge Tool' is great for this.

(right click - 'view image' for full res):

Now just combine the two meshes and merge vertices (looooow merging threshold). Voila! Now we have a UV layout that is both non-overlapping, intuitive to paint on and with minimal distortion.

Now, let's take a look at the fish textures and shaders

Shortcuts:

Modeling from reference

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

#uv #fish #maya

18. fish: modelling

Modeling

Back to overview or skip to UV layout

Long before rigging we need something to rig, so let's start by modeling a fish. I did some research on swimming fish (to find a fish that moves nicely, utilizes all fins when swimming, and is instantly recognizable as a fish) and decided to do a largemouth bass (Micropterus salmoides).

Set up your reference image in the background. I just created an image plane on my 'side' camera (camera shape node, attr editor: 'Environment' - 'Imageplane' - 'Create').

Start with a plane. Adjust the subdivisions settings until you're happy. We're only modeling one half (the left side) of the fish, so we'll keep the mesh flat for now, until we've put in enough details and lined the edges up with the reference. Only then will we bulge out the fish body. It is easier to work in 2d first and not have to consider and adjust the smoothness of the curvature of the fish after every nip 'n tug.

Throughout the modeling process there are really only a few tools you will need: 'Split Polygon Tool', 'Insert Edge Loop Tool', 'Spin Edges Tool' (ctrl-alt-left/right) and "Extrude' (for extruding out the fins). Pull vertices around to roughly line the edges up with the reference fish:

Subdivide when you need to go to the next level of detail and adjust the edge flow again:

These days, depending on the shot, most graphics card or renderers aren't too fussy about poly count, before or after displacement, so it is very easy to bocome "sloppy" when it comes to optimizing of the base mesh, even though the model still comes out great looking. I'm going to try and consider the limitations of hardware and try to model the fish in a way that provides a nice visual result (still and moving) as well as being optimized for a smooth workflow when dealing with a school of 100 fish.

There are four main concerns when laying out your edges/faces.

Detail/silhouette

Deformation

Displacement

Poly count

Detail/Silhouette: You want enough polys to nicely represent the fish before displacement. That means enough polys to get perceptively smooth edges and enough detail to break the silhouette from certain angles, showing features present on the surface (eyes, fins, lips, gills etc). Edge flow needs to follow ridges, creases, and corners in a parallel/perpendicular kind of way. edges diagonal to a ridge is less efficient at conveying that shape.

Deformation: The fish will be swimming, so we'll try to ensure that at least all things that needs to move (eyes, fins, mouth/lips, gills) are present and reading well. The edge flow needs, again, to flow in a parallel/perpendicular direction along the direction of deformation (e.g. bending). We also need the spacing of edges to be even across smooth areas (to avoid kinks and creases) and having the edges flowing along main muscle groups helps a lot. Also, when geometry is deforming we need to take care that we maintain an even grid-like wireframe in areas of deformation. Triangles and n-gons are deforming badly and often result in creasing and pinching. You will inevitably have to join edge loops together, but try to place the "knots", and any triangles you end up with, in either places that are hidden, or in relatively rigid non-deforming areas. To be honest, if the part is rigid, the edge flow, polygon distribution or amounts of vertices per face is totally irrelevant for deformation.

Displacement: To reach a satisfying level of displacement with as few subdivisions as possible we need to ensure that areas where we need small features that will be displaced have enough coverage of polygons, at least along the direction of elongated features (stripey features, like the bones in the fins), while keeping non-displaced areas (or where there will be larger, smoother displacements) sparsely covered with polygons.

Poly count: Overall, from a practical point of view, we want as few polys as possible.

Throughout the modeling process we should keep these things in mind and find a nice balance, or trade off, as they in a lot of cases contradict each other, between the need for dense and sparse polygons and the direction of edge flow.

Whoufh... enough rant. Let's get on with it. Try to add (or remove) edges to keep them flowing along/across the features for shape definition and displacement, and along the length of the tail for nice deformation:

Now we can select the vertices in the middle of the fish (as seen from the side), activate soft selection, set the falloff curve to a nice 'dome' shape and pull it out from the center. Select the fins and the border edges, activate the scale tool and go to pivot mode ('insert'), move the pivot to X=0 (the center of the whole fish as seen from the front) and let go of the pivot mode again ('insert'). Now scale the border edge back to X=0.

Do a bit of cleanup, making sure everything looks smooth and has the right curvature.

From now on, any changes from the side view (adjusting edges or vertices to make the line up with the reference) has to be checked in the perspective view so we don't mess up the curvature or smoothness of the fish.

The 'Slide Edge Tool' is great in that it slides the selected edge along the connecting perpendicular edges so it doesn't change the curvature much. You might also find my 'frameAlongNormal' script to be handy. It will align your perspective camera to look down at your selection along the average normal so you can adjust the mesh without changing the curvature much. Also, there's a setting on the move tool called 'Slide' which lets you slide the selection across the original surface, maintaining the original volume/shape (very handy with soft selection also):

Add details where needed. One important thing to keep in mind is what the fish will be doing when animated. An area that is important to get detailed enough is the lips and gills of the fish.

Fish have fairly thin bones in their body/fins, but their head is almost completely covered in bone plates. Even the lips contain bones:

As you can see, the bony parts of the lips stay fairly rigid when opening and closing its mouth and the skin between those parts gets stretched out. So add some edges between those parts so that we have enough when we get to the rigging/skinning stage:

After all the fins are modeled and the level of detail we need is reached, we can do a mirror to check the overall form. Offset the fish by a little in X so that we get an extra strip of polygons along the middle after mirroring:

That looks fine. Now undo the mirroring and let's go onto UV layout. Whaaat, undo?!? Yes, we need to lay out uvs for both sides, so we'll start with one and mirror after UV'ing.

Shortcuts:

UV layout

Texturing

Sculpting

Rigging: the base swim loop

Rigging: Fins cloth setup

Rigging: Path progression

Scripting: Referencing

Scripting: Crowd/flocking/schooling

Lighting/rendering

Compositing

#modeling #fish #maya

Wrath of the Titans

I spent some 8 months working on this movie, mostly shading/lighting Cyclops and I also worked on a labyrinth shot (where it breaks apart after Perseus... oh wait, I won't ruin the plot, so you'll have to find out for yourselves).

Anyway, it was a great show to work on, with so much to learn from so many incredibly talented people.

Nice article here for those interested.

#Wrath of the Titans #Framestore #Cyclops #maya #Renderman #Arnold

BBC's wonders of the solar system

I worked on BBC's 'Wonders of the Solar System' series at Prime Focus, a show that, in my opinion, turned out great and was a lot of fun to work on.

I just found out that it recently won 2011 Gold World Medal for 'Best special effects' at New York Festivals' 2011 television & film awards.

A lot of credit go to Simon Clarke, Stephen Waugh and Jon Keene and I'd also like to thank Sean Farrow, John Hasted, Christopher M. Anthony, Prodeep Ghosh, Goolzar Buchia, Karan Juara, Peter Forsythe and Sajeel Shukla for the good times and the collaborative effort.

It also brought home the first place in Televisual's Bulldog awards, for best special effects in the 'Digital and Physical Effects' category. Very cool.

It was also nominated in the 'Visual effects' category in 2011 Bafta awards. The Mill won, though, for their amazing work on 'Merlin'. Congrats to the talented people that worked on that.

#wonders of the solar system

Trending Blogs

Recently Viewed Blogs

vfx 'n whatnot