Tutorial Art Design: houdini

Articles by "houdini"

PROCEDURAL / Random Generative Modeling Technique, Pebbles and Star Fishes

Procedural awesomeness... in Blender.

Procedurality is a terminology and concept that I have interested in when I touch Computer Graphics, whether it is procedural animation, modeling, texturing or thinking.

Maybe that is because my big interest in interaction and game design when it comes to computer. Each level of game design is similar, but different.

Input --> Process / Algorithm --> Output

I also happened to grow up next to a biscuit factory, and so it is always interesting to see Marie Biscuits got made from dough into machine until it gets looking like Biscuits that is edible.

Not all biscuits looking exactly the same. Below are some examples of Biscuits and Snacks from Indonesia that explains the idea of proceduralism: (if you want to know where to buy this snacks, contact me personally or leave a comments)

If Australian foods and snacks:

Chips
Cereals
Jelly Worms

Enough about foods, but you get the idea: Product of nature or human made objects that has been touched by nature always has variations, even if it is based on a template.

It is not so much about "automating" the whole process, but more of idea of creating TOOLS that generates variations that might be random, but still within boundary of controls or matching a certain template.

Maybe there is a sense of "laziness" in Procedural Design, perhaps this is just part of nature. We don't like sameness, we like customization and variations, even just slightly.

Think of anything that is similar, yet different:

Jelly Beans
Bricks
Trees
Leaves
Clouds
Pop Corns
Cereals
etc

Blender seems to be growing into idea of very streamline production.

At the moment, Blender seems to be pushing the Procedural Material generation via Cycles.
http://cgcookie.com/blender/cgc-series/creating-an-uber-shader-in-cycles/
http://blenderartists.org/forum/showthread.php?283248-Ubershader-v4-0-New-Release-5-24-2013-Come-and-Get-It!

Wait! Did I say Cycles is procedural? Maybe Cycles OSL (Open Shading Language) is more true procedural:
http://www.openshading.com/blog/
http://blenderthings.blogspot.com.au/

Pardon me, I often get node-based system and procedural concept mixed up.

Node-Based and Procedural are kind of related to each other.

Node-Based is where one can simply connect a bunch of nodes to process input values and getting output values as desired.

While Proceduralism, in my understanding is a series of interconnected step by step instructions or algorithm which can give one the ability to modify and generate variations of different outputs by modifying a set of parameters and values, without having to recreate things from scratch each time or deleting history or other destructive process. Once a process baked, continue to the next.

I am hoping that Blender continues the Procedural and node based concept for Particles and Modeling (especially Particles workflow, it is high in my WISHLIST).

Blender Modeling should be fine as it is, with Dynamic Sculpting and the traditional workflow.

However, the truth is that Blender has some capabilities for procedural modeling via Modifier and Python and maybe Particles.

INSPIRING ARTIST IN PROCEDURALITY

Dolf Entoform
http://www.entoforms.com/scripts/
Shigeto Maeda: GMP - the Generative Modeling Project
http://www.youtube.com/watch?v=s0x5WnykR5Y

HOUDINI PROCEDURALITY VS BLENDER SEMI-PROCEDURALITY

Houdini is really one 3D package that is truly node based of everything. Maya is a little like that too. But if you want to understand node-based 3D workflow, learn Houdini. Their Apprentice version is free to download and use. Houdini is very powerful. Keep in mind that NOT everything is always better as node based. For simple things, node based can be overkill. Blender seems to be the perfect balance.

Recently, with my little knowledge of Python that I actually learned via Blender, I decided to refresh my knowledge in Houdini (as I would like to get serious into VFX). I want to take it to the next level.

Of course I like to incorporate some Blender to work together with Houdini. I still find many Blender features are much more practical, such as Blender Cycles and Compositing.

I was watching this old video by Ari Danesh for SideFX Houdini that explains about Procedural Modeling in Houdini:
http://www.sidefx.com/index.php?option=com_content&task=view&id=2166&Itemid=361

In that Houdini tutorial, Ari is showing a basic procedural modeling workflow in Houdini to generate random little stones (pebbles).

While watching that video, I figure that we could actually adapt the same procedural workflow of Houdini in Blender, up to certain extent.

BLENDER PROCEDURAL MODELING: Pebbles Generator

I will take you through few example cases and we will be looking at some potential techniques that you can later improve on your own. If you have been reading all Blender Sushi articles, you may find old techniques, but I like to push it further.

1. STEP ONE: Prepare Base Model or Template Model
Start with some kind of BASE MODEL and think HOW we can add VARIATIONS.

With pebbles, we could simple start with a Subdivided Cube which will give us some kind of round looking objects. We can flatten it a bit.

Box + Subsurface Modifier

2. STEP ONE: Add Variations
I applied the Subsurf Modifier and Smoothen the Shading of Pebble template. Next, we can use Displace Modifier to create variation. I use the default Cloud texture to displace the mesh.

The direction of displacement is using the Normal, but you could try other option. Including RGB as XYZ that could potentially give more variations. I assign an Empty as Texture Coordinate so that if the Empty being moved, the model will change slightly in shape (because of the procedural Cloud Texture itself).

TIPS: Smooth Modifier can be added on top of Displace Modifier to smoothen the Pebbles.

3. STEP THREE: Bake and Output the Variations

Once we are able to create variations that can be keyframed/animated (different variation on every frame), we can BAKE the variations.

We could actually try to keep all the connections and never actually do the baking, but often in production it is a much more efficient to bake or delete history of the procedural model, and then further process the baked model.

In Houdini, they have bgeo file format, kind of like an efficient way of Houdini storing objects outside of Houdini (can be Particles, Mesh).

With Blender, we just use the good old OBJ with Animated sequences. Yes, Blender can easily output Animated OBJ sequence via File - Export - OBJ (Animation ON).

I have animated the Empty for 100 frames (animated in Translation and Rotation, with Linear Interpolation) and then Export out as OBJ with Animation option checked. I saved the OBJ sequence inside a folder for easy organization.

4. STEP FOUR: Import the Baked Objects

We have 100 procedurally generated pebbles to be used in any Blender scenes. What do you like to do with it is totally up to you. You can use Blender Bullet Physics with the Pebbles. Or maybe use Blender Particles system to randomly place them in a certain shape.

But first, we need to import multiple OBJs, can we do that? We need Python script for this. Because by default, Blender will only import 1 OBJ at a time.

Importing Multiple OBJs using Python

I borrow the script from here:

http://blenderartists.org/forum/showthread.php?274214-How-to-import-multiple-objects-at-one-time

http://blenderscripting.blogspot.com.au/2012/03/importing-obj.html

Copy paste the script: (credited to McBuff, Blender Artist Member) - just in case if Blender Artist Forum is down.

##################

import bpy
import glob
import os

importDir = "C:/Users/Yourname/Desktop/pebbles_out"
print(importDir)

os.chdir(importDir)
for files in glob.glob("*.obj"):
print( files )
bpy.ops.import_scene.obj(filepath=files, filter_glob="*.obj;*.mtl", use_ngons=True, use_edges=True, use_smooth_groups=True, use_split_objects=True, use_split_groups=True, use_groups_as_vgroups=False, use_image_search=True, split_mode='ON', global_clamp_size=0, axis_forward='-Z', axis_up='Y')

for files in glob.glob("*.3ds"):
print( files )
bpy.ops.import_scene.autodesk_3ds(filepath=files, filter_glob="*.3ds", constrain_size=10, use_image_search=True,use_apply_transform=True,axis_forward='Y', axis_up='Z')

##################

NOTE: I will try to improve the Python script above so it handles PATH better to handle forward slash and backward slash.

Ok, in a new Blender scene file, we simply need to point the path to the folder with OBJs and run the script above to import all the OBJs in the folder, and this is what we get:

All the pebbles mesh are bunched up on top of each other. This is fine.

If you like to arrange them in a grid, you can use quick rough Python script like below:

##########

import bpy
'''
Arrange selected objects in specified grid space

'''

def arrangeIn2DGrid(width=10, height=10, spread=2):

# Get List of Selected Objects
myObjects = bpy.context.selected_objects

if(myObjects):
print('Please select some objects')

totalGrid = width * height

if(len(myObjects) > totalGrid):
print('You need to specify bigger grid for your objects')

coords = []

for x in range(0,width):
for z in range(0,height):
coords.append([x,z])

# For every object in list, place each one in order into provided coordinates
for number, object in enumerate(myObjects):
object.location = coords[number][0] * spread, coords[number][1] * spread , 0.0

arrangeIn2DGrid(spread = 2)

##########

NOTE: Make sure the Total of Width X Height is MORE than the Total number of Objects to be arranged in 2D grid. I wrote this quickly. Script can be improved.

With 100 variations, it is enough to tell our brain: they are bunch of random shape of stone Pebbles.

Further on:

Randomize the Color and Texture of each stone (choose Blender Render or Blender Cycles first, then try add Material variations)
Randomize the Size using Particles

We can group the Pebbles and use as Particle Instances. Do whatever you like with it. Maybe arrange the pebbles in a shape that makes you or the other half happy. Well, or use it in 3D production.

Snail made with Pebbles.

Alrightly, we can generate random variation of pebbles.

Now what? Use the same concept and workflow and do more procedural creation of your own!

Need more examples? Ok, continue on.

BLENDER PROCEDURAL MODELING: Starfish Generator

I will go through each step but slightly faster this time.

1. Create Starfish Base Template.

Couple of connected Edges
Skin Modifier
Smooth Modifier

2. Create Variation of Starfish

I will use multiple Hooks for the leg of starfish. You have learned this technique before. Hook is a way to modify Component level (Vertices) of mesh in Object level. You can animate and keyframe the Hook, so it is perfect for our purpose to model random Starfish.

Manually Hook the vertices if you like. Select a vertex, CTRL+H and hook to new object (Empty).

NOTE: I have to ask some Blender developers, I am curious on how we can actually "hook" the weight of each vertex to translate it into the Skin Modifier. There must be a way to do this.

The cool thing with this setup is that Skin Modifier will adjust and even modify the mesh slightly to generate random yet still maintain the form.

3. Bake and output the Startfish Variation

We can now export the OBJ sequence variations, but not forgetting to ANIMATE the Empty that control the shape of Starfish beforehand. That is the KEY to give variations.

Here we just manually animate the Empty. But in the future, we can use some other techniques to make it more procedural and with variations that is more random.

Let's arrange our Starfishes:

Many Star Fishes!

BLENDER MESH CACHE MODIFIER & MESHFOOT

You could also make each one of them ANIMATED if you use MDD export-import into the mesh. Blender has nice Mesh Cache Modifier that does the job.

In effect, it gives some kind of random Procedural Animation look. Well, maybe not 100% because we were manually animating them. But we can actually use Python to create procedural animation.

I have not yet explored the potential. Although I have been using Mesh Cache to export-import MDD animation from Maya and Houdini to Blender to use with Cycles Renderer.
https://vimeo.com/64965747

See how ATOM's Meshfoot can import OBJ, turn it into MDD data which can be read as cache. This is GREAT for procedural animation.

DAVID MILLER PROCEDURAL TECHNIQUE (Key: PyDrivers)

I have actually mentioned David Miller's procedural technique few times in the past, involving Blender Drivers and Python. It is quite advance, but easily applicable once understood. Not too complicated, this is really worth your time:

https://vimeo.com/40389198

David is cleverly use Python binding of drivers and use the number inside for drivers.

What does this mean? Whole heaps of possibility! Because Blender Drivers, although does not always update itself (dirty data), is quite powerful for procedurality. It is another key to add procedurality.

I borrowed (copy, paste) David Miller's script that bind Python function into Blender's Driver: (David, I hope you don't mind):

##########

# FULL CREDIT TO DAVID MILLER

import bpy

import random

# Random floating point number between lo and hi

def randf(lo, hi):

return random.uniform(lo,hi)

# Random integer from lo (inclusive) to hi (inclusive)

def randi(lo, hi):

return random.randint(lo, hi)

# Random values given mean and standard deviation

def gauss(mean, stdev):

return random.gauss(mean, stdev)

bpy.app.driver_namespace["randf"] = randf

bpy.app.driver_namespace["randi"] = randi

bpy.app.driver_namespace["gauss"] = gauss

##########

I always keep the above example code handy, whenever I need to give randomization to Drivers.

I actually wanted to write a post especially on PyDrivers, but I guess for now it is sufficient if you do your own research:

PyDriver + Auto-Update
http://blenderartists.org/forum/showthread.php?224923-Real-Time-pyDrivers

PyDriver Videos
https://www.youtube.com/watch?v=6v5gtbaDfHk
https://www.youtube.com/watch?v=HOeoVJYupQk

SHAPE KEYS + DRIVERS FOR PROCEDURAL MODELING

Limitation: Mesh needs to have same number of vertices and topology

Imagine you create some blend shapes or shape keys mesh. Each with Minimum and Maximum range of variations of shapes. You can then use Python to randomize the Shape Keys using Drivers (just like David Miller does). You will end up with unlimited procedural generative workflow.

Example below is a Cube with 3 Shape Keys that Scale in X, Y, and Z. I then assign Drivers with Python Binding ala David Miller above.

The Box will change procedurally for every frame changes.

It is a little bit more complicated than before, but also more robust! You need a little familiarity with:

Blender Drivers
Python
Blender Shape Keys

So, this is KEY on how you could do modeling procedurally in Blender. Always think of TEMPLATE and VARIATIONS.

MSMESHER FOR PROCEDURAL RANDOM DOODLE

How about try MSMesher Add-On to create random mesh?

https://vimeo.com/66995958

Well, basically, Blender does not have Mesher that generate mesh using Particles, yet, but there are some Add-On out there that cleverly does this function. Above is one recent Add-On.

I give it a go:

Something that looks like random Corgi Poo.

A real Particle Mesher is definitely something to look forward to in the future. When Blender got one, we can create a more interesting shapes. But you can do it today with this Add-On actually.

In the way, Skin Modifier is kind of doing Meshing for Polygon Edges, but using Particles we can get more interesting shapes. With Skin Modifier, you can create Procedural Maggots. Try it yourself.

BLENDER METABALLS BLOBS

To create random blobs, you can use Blender Metaballs Object that is instanced by Blender Particles and changing the Seed value or maybe scatter Particles that live only for 1 frame so that you get freshly generated Particles on each frame that will form a new blob shape for each frame.

PS: Notice the extra stray Blob on the generated mesh? That is the original Metaball object that got exported when I tried exporting the OBJ sequence of Metaball. Maybe there is an option to get rid of it, but that can be cleaned up.

Once cleaned up, we have some nice interesting randomly generated blobs. What do we do with these blobs? Anything. I wish I have some connections with 3D printer or manufacturing because even such blobs when made into product will look quite interesting.

I assign basic Emission material to each blobs:

The glowing blobs reminds me of Light Blobs Chairs that is on display at Sydney Vivid Festival 2013 (still going on now).

Glowing Blob Chair at Sydney Vivid Festival 2013.

LATTICE & SOFT BODY

Have you every tried using Lattice and Soft Body to randomly deform an object? Add Force to it as well and see what you could come up with.

Matrix of Generatively Modified Suzanne (using Lattice):

If the Lattice is more dense and the object is Remeshed with certain details, you can get more variations. You can always add Remesh Modifier, Reduce with Decimate Modifier, and also use Smooth Modifier to make sure the mesh toplogy is clean and no overlapping happening.

ADDON: Ivy Generator

You probably know this Ivy Generator Add-On that is inside Blender since a while back.

http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Curve/Ivy_Gen

What would be interesting is if maybe we use Python to randomly place seed and tell Blender to also export out the Ivy.

I was also reading this SIGGRAPH Paper PDF about proceduralism titled "METROPOLIS":

http://vladlen.info/publications/metropolis-procedural-modeling/

Check out the part where they use Voxelation to build something that is like Procedural Building. Blender has the Remesh Modifier which could be perfect for this. Especially when accompanied with the OSL Shading Language to maybe procedurally make city texture.

See also:
SUICIDATOR PROCEDURAL CITY GENERATOR
http://cgchan.com/suicidator/

FUTURE: Random Creature Generator

This is my proposal on how one could create Random Generative Creature in Blender.

I am thinking to create something like this in near future, but maybe you want to make one before me. Go for it. Use Skin Modifier, use Mirror Modifier, or try all kind of Blender Modifiers and Python to create random shapes that can be further used in Design or other production.

Generative Stick Figures quick test. I am sure you can do better.

Lastly, I am wondering a Python script that can change Geometry and update it every frame ... maybe I need to ask some Blender Developers. ---- the response I get: maybe too slow at the moment.

http://blenderartists.org/forum/showthread.php?245450-Real-Time-Python
http://www.blender.org/documentation/blender_python_api_2_60_6/bpy.app.handlers.html
http://learningblender3dsoftware.blogspot.com.au/2012/10/messing-around-with-prepost-handlers.html
http://blenderscripting.blogspot.com.au/2012/09/python-driven-animaion.html

So... I guess until PyNode happening, keep creative to discover and to invent Blender proceduralism.

http://www.noeol.de/attractors/

I might check PyDrivers and PyHandler stuff though...

BLENDER CURVE + ARRAY MODIFIER

Have I mentioned before that Blender Curve object has hidden ability? Yes, I did, many times in previous post.

You can actually create FEATHER, PIPE, GRASS, HOSE, TRUMPET or CHINESE FAN like below just by using a Curve, adjusting its Extrude, Feather Scale, in combination with Array Modifier to model a Chinese Fan.

I have tried similar concept both in Blender and Houdini:

http://houdoodles.blogspot.com.au/2013/06/modeling-procedural-chinese-fan.html

Houdini proceduralism is of course more robust, it was made like that. But I say, doing it in Blender with its Semi Proceduralism, just by following similar logic is equivalently interesting.

JUST FOR FUN:
You can also create umbrella just by using Blender Curves + Array Modifier. Very easy. remember just use Curve and Array Modifier. The cool thing with this method is that you can easily change the bracket/cage or the shape and adjust the number of rotation.

5 minutes Umbrella.

MAKE HUMAN + BLENDER SHAPEKEYS

Maybe try using Make Human for the Base Mesh and Shapes:

http://www.makehuman.org/

OTHER REFERENCES:
http://blenderpython.tumblr.com/post/49177760706/coil-tutorial

Take it further so that you could produce 3D printed generative models this way.

WISHLIST: custom 3D Printed Food and Chocolate, all in random variations, made in Blender.

PYTHON / Advanced Procedural Flipping Cards Effect

Thanks to Python and Blender, orchestrating and flipping many cards is a breeze.

While exploring and researching on NLA (Non Linear Animation) in Blender — which will actually be my next article topic — I stumbled on my old post on Flipping Card animation:
http://blendersushi.blogspot.com.au/2012/02/vfx-multilayers-triggering-of-effects.html

In the past, the setup of Flipping Cards thing was done manually.

Now, since we have a bit of knowledge of Python, I think we could improve the workflow of Flipping Cards and take it further.

FLIPPING CARDS CASE STUDY

This effect of Flipping Cards is actually a really good and fun exercise in thinking about Python programming, Blender and technical animation because it provides multiple layers of interesting problems that can and should be tackled using Python and some motion graphics thinking:
1. Many objects needs to be animated or orchestrated in a certain way.
2. Need a simple control.
3. It needs to be robust enough to give variations of flipping cards.
4. The texturing of both side of cards.

From my old article, we know that the trick here is to use these features in Blender:

Transformation Constraint
Vertex Groups
Displace Modifier
Dynamic Paint

We will use the same techniques, but with additional enhancement. We want to put all of them together in a nicest possible way.

PROBLEM 001: Placing Cards in a Grid

How to easily create multiple Cards in a grid?

There are many ways to do this in Blender, but the simplest way is to use Grid object.

You can also use:

Blender Particle Instancer to duplicate and place objects in grid
Using Python to create row and column of objects

IMPORTANT UPDATE 20130514:

SPECIAL PROBLEM: The Sorting of Cards (or Mesh Faces)
This is something that I just found out, but VERY IMPORTANT. Please read.

While going through all the process again, I figure out that the Sorting of Face Index is very important.

By default Blender Grid Face Index is NOT in Order.

You can see what I mean by going to Edit Mode, and back to Object mode and run the script below:

import bpy

'''
Check Active Face Index
'''

object = bpy.context.active_object

faces = object.data.polygons

#for face in faces:
#    print(face.select)

for i in range(len(faces)):
    #print(i, faces[i].select)
    if (faces[i].select == True):
        print(i)

You can also use Bartious Script to display the Index of Mesh Components:

https://sites.google.com/site/bartiuscrouch/scripts/index_visualizer_25

Although, unfortunately, above script is no longer existed somewhat but this forum leads to...
http://blenderartists.org/forum/showthread.php?180683-Index-Visualiser-for-Blender-2-5/page3

...an information that we can actually activate DEBUG mode that allows us to check Index (Indices) of Components:

bpy.app.debug = True

By activating that DEBUG via Python Consode, Blender can actually display Face and Vertex Index in Edit Mode by default. Which is neat, I only figure it out today.

While doing this below will give you a lot more informations that will give feedback for every bpy.ops you do on windows console:
bpy.app.debug_wm = True

Anyways, you must the Face Indices to have everything works correctly. You need to do this more importantly on the Grid of Cards.

A better and sorted, but still not 100% correct. Read below. The most correct sorting that will work with my script will have the number goes from 0 at top right corner and going down, and then continue on to the left.

Below is few methods to sort the card grid.

SOLUTION ONE:

Do Mesh Sorting before you continue with all the steps below.

When you are in Edit Mode, notice that you can select all Component, tap on Spacebar, and run "Sort Mesh Elements" function.

This does not always work the way you want it, so try multiple time from different 3D View angle, play around with the option from the Tool Bar (left side), eventually you get the right sorting.

This is key to make your mesh properly sorted.

The MOST correct sorting is like below:

This is really the MOST CORRECT and guarantee to work nicely with the Template object.

SOLUTION TWO: Use Houdini

Houdini is probably the best package out there to handle Component Level, simply by connecting nodes. It has this Sort SOP node that does the job.

Blender's own Component Sorting function does not always work properly, I tried many times. But occasionally you get it right.

Use Houdini instead. It allows you to import and export OBJ and sort the component easily.

SOLUTION THREE: Create the Grid by using Particles

Create the Grid of Cards using Particle and Instance on every Vertex. This way, you actually will end up with a correct face ordered TEMPLATE + GRID.

If you are still confused, feel free to leave comments below.

MY POINT IS:
Basically, the Face Indices of the Grid of Cards and Template object MUST be in order for you to get the proper Flip Card Effects.

PROBLEM 002: Separate Each Face

From the Grid object, we want to turn every face into row and column of cards. In Blender terminology, we like to simply separate every face component of the mesh.

How do we go about doing this in Blender?

Mark (Edge) Sharp
Edge Split Modifier

Go to Component Mode of your Grid (hit Tab), select all Edges (or Faces) and Mark Sharp.

Back to Object Mode (toggle by hitting Tab again), and Apply Edge Split Modifier.

Make sure you click on "Apply" button to confirm the modifier. Default setting is fine.

You can check now that each faces have been separated.

PROBLEM 003: Object Level Control for Every Face

In Blender, we know that there is a handy tool called Hook that is able to give the user Control over Component (Vertex, Edge, Face) in Object Mode.

That is exactly what we will use in here.

To give this a try, go to Edit Mode, select a Face, and CTRL+H to setup a Hook.

Now, back in Object Mode, you will see an Empty that controls the Face (you can do all kind of transformation, translate, rotate, scale):

For our purpose, we need to do this for every Face, here Python comes to the rescue.

BLENDER SUSHI SCRIPT: Hook Every Face of Mesh



## HOOK EVERY FACE OF MESH

import bpy

"""
Hook every selected Faces. This works best for object
with all faces separated.

Copyright (c) 2013 Jimmy Gunawan at Blender Sushi Blog
Name: hookEveryFace.py
Version: 001
Author: Jimmy Gunawan
Contact: blendersushi@gmail.com
Date Created: 2013.05.12

How to use the script:
    1. Select object which every face will be booked
    2. Run the script

"""

# Get current active object
object = bpy.context.active_object
object_name = object.name
print(object_name)


# Get all faces
faces = bpy.context.active_object.data.polygons

# This is less Pythonic but works.

for i in range(len(faces)):

    # Deselect Everything in Edit Mode
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action = 'DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')

    # Select a face
    bpy.context.active_object.data.polygons[i].select = True

    # Hook face to new object
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.object.hook_add_newob()

    # Reselect original object
    bpy.context.scene.objects.active = bpy.data.objects[object_name]


# Deselect everything in Edit Mode
bpy.ops.object.mode_set(mode = 'EDIT')
bpy.ops.mesh.select_all(action = 'DESELECT')
bpy.ops.object.mode_set(mode = 'OBJECT')

"""

# More Pythonic, but failed to work, I do not know why

for face in faces:

    # Deselect Everything in Edit Mode
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action = 'DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')

    # Select a face
    face.select = True

    # Hook face to new object
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.object.hook_add_newob()

    # Reselect original object
    bpy.context.scene.objects.active = bpy.data.objects[object_name]

    face.select = False

"""

Use the script above to set Hook on every face.

PROBLEM 004: Simple Control for Flipping of Many Objects

This is probably the trickiest part. However, we already know the solution from previous post: Vertex Group of another object can be referenced by Transformation Constraint.

What do we need? Another Object that will act as our Flip Cards Controller, let's name it "Template".

In our case, our Control Object is quite special, in which we will create Vertex Group for every Vertex of that mesh, this will be referenced by our Card Grid Objects via Transformation Constraint.

The "Template" Object

If we have 12 x 12 grid, our Template Object just need to be 11 x 11 grid, so that the Vertex Total Number will match to the number of Card Grids (Total Number of Faces).

Let's just create Grid with 1 less number in row and column, and name it "Template" object.

I made the "Template" object Display as Wire and to display All Edges.

Next, we need to assign Vertex Group for every Vertex of our Template object. For this, we also use Python script:

BLENDER SUSHI SCRIPT: Vertex Group Every Vertex



## Vertex Group Every Vertex





import bpy





'''


Assigning each and every vertex of a mesh into own Vertex Group


'''



# Specify Object to Create Group
obj = bpy.context.scene.objects.active

# Make Specified Object Active
# bpy.context.scene.objects.active = obj

# Accessing Vertex Groups Data
# obj.vertex_groups

# Get total vertex number
total_vertices = len (obj.data.vertices)

# Create Vertex Group based on total vertex number
for i in range(total_vertices):
    vg = obj.vertex_groups.new(name='groupy.%03d' % i)
    
    # Assign each Vertex to Vertex Group
    vg.add([i], 1, "ADD") # index, weight, operation


# http://www.blender.org/forum/viewtopic.php?t=25776&sid=a7610ca4988d2ad669308cc517d104c9

Select the "Template" object, and run the script, you should then end up with Vertex Group (VG) for every vertex of the "Template" mesh.

With my rough script above, I use a hardcoded name for the Vertex Group called "groupy.###", you can change this if you like.

PROBLEM 005: Power of many Transformation Constraint

Now that we have the "Template" Control ready, we simply need to connect it to our Flip Cards object.

Transformation Constraint is the man for this job and we need many Transformation Constraints, each for every Card and we tell Blender to reference Vertex Groups of "Template".

Transformation Constraint is interesting because it has plenty of options to set whether we like to: Translate, Rotate, or Scale the constrained object.

With our purpose we want it to Flip (Rotate) the constrained object, based on reference. As shown in my previous post, the setup for flip rotation using Transformation Constraint is like below:

FLIP EFFECT

I hard-coded the Python script below that will create multiple Transformation Constraints for our Flip Cards object that references the Vertex Groups of "Template" object, which will give the Flipping effect.

Watch this Transformation Constraint carefully and modify the script as you need.

If you setting up the Transformation Constraint like this, you get the Scale and Reveal kind of effect:

SCALE AND REVEAL EFFECT

The script below will give you Flip Effect in certain axis direction. Feel free to modify some of the number below to give you other kind of effects:

BLENDER SUSHI SCRIPT: Add Transformation Constraint to Selected Objects



import bpy

'''
Add Transformation Constraint for every selected objects
'''


objs = bpy.context.selected_objects

# Need a way to sort dictionary/reference via name
# I do a quick hack in here
# http://blenderartists.org/forum/showthread.php?194818-Python-Sort-Problem

newList = []

for num, obj in enumerate(objs):
    print (num,obj)
    newList.append(obj.name)

newList.sort()
#print(newList)

newObjs = []

for item in newList:
    newObjs.append(bpy.data.objects[item])
    
#print(newObjs)



for num, obj in enumerate(newObjs):
    
    # Make each object Active one at a time
    bpy.context.scene.objects.active = obj
    
    # Assign Transformation Constraints
    bpy.ops.object.constraint_add(type='TRANSFORM')
    
    current_constraint = bpy.context.object.constraints["Transformation"]
    
    # Assign Target Object
    current_constraint.target = bpy.data.objects["Template"]
    
    # Assign Vertex Group Target
    current_constraint.subtarget = "groupy.%03d" % num

    
    # Setup Attributes for Flip Effects
    current_constraint.from_max_z = 1
    current_constraint.map_to_y_from = 'Z'
    current_constraint.map_to = 'ROTATION'
    current_constraint.to_max_y = 180
    current_constraint.target_space = 'LOCAL'

We want to apply the script above to every EMPTY that is in fact controlling each Face of Flip Card.

You can Box Select every EMPTY objects, but you can also use Python script that I made to select all objects named "Empty*":

### HARD CODED SCRIPT TO QUICKLY SELECT EVERY EMPTY

import bpy

import fnmatch

# Get All Meshes Objects

objects = bpy.data.objects

## LIST COMPREHENSION STYLE

myListX = fnmatch.filter( [objects [i].name for i in range(len(objects ))] , 'Empty*')

for item in myListX:

bpy.data.objects[item].select = True

### HARD CODED SCRIPT TO QUICKLY MODIFY CONSTRAINT MODIFIER

import bpy

'''
Modify Transformation Constraint for every selected object
'''

objs = bpy.context.selected_objects

for num, obj in enumerate(objs):

# Make each object Active one at a time
bpy.context.scene.objects.active = obj

current_constraint = bpy.context.object.constraints["Transformation"]


# Setup Attributes for Scale Reveal

current_constraint.from_max_z = 1
current_constraint.map_to_x_from = 'Z'
current_constraint.map_to_y_from = 'Z'
current_constraint.map_to = 'SCALE'
current_constraint.to_min_x = 0
current_constraint.to_max_x = 1
current_constraint.to_min_y = 0
current_constraint.to_max_y = 1
current_constraint.to_min_z = 0
current_constraint.to_max_z = 1
current_constraint.target_space = 'LOCAL'

TIPS:

It would be nicer if we name every component of our Flip Card setup properly for future modification. Maybe we could also Group them.

Select every Empty objects in the scene and then apply Transformation Constraint script above.

WATCH OUT:

Be careful in matching the Row and Column of our "Template" object and the Flip Cards object. If the number is not sorted properly, we will not get the perfect Ripple of Flip Cards. Keep this in mind. Maybe I have to re-write the script to make sure this is taken care.

Ok, we are almost done here with the complex setup, but you see how every step is rather simple and Python helps a lot with the hard repetitive task.

If you move the Template object up and down in Z axis, the Flip Cards object will flips, but all at the same time. How do make this more irregular? Continue to the next step.

PROBLEM 006: Orchestrating Many Objects with Displace Modifier

Problem 006 is NOT really a problem anymore because we have gone through all the complex setup. Problem 006 is the most fun.

Simply apply Displace Modifier to our "Template" object, assign a Texture (Cloud, Image, Voronoi, Blend Ramp/Gradient, etc) and move the "Template" up and down in Z axis.

Depending on the Texture and how it affect the displacement of mesh, you will get different Ripple effect of the Flip Cards.

Using Cloud Texture for Displace Modifier

Using Blend (Ramp/Gradient) texture.

Using Marble (Stripes) texture

PROBLEM 007: Double Sided Material

For Double Sided Material, we can use Solidify Modifier. You get everything basically for free and easy to setup 3 Different Materials: Front Material, Rim Material, and Back Material.

The result can be seen right away:

If simple Material is what you need, your work is really pretty much done. You can use Blender Cycles to continue polishing the look.

However if you want to use proper UV and Texture, you have the last problem:

PROBLEM 008: UV and Texture for Scrambled Flip

Our Flip Cards object is only a single object. By having this, we can easily apply 3 materials using Solidify Modifier above.

We could apply a single UV Texture, but we actually need 2 UV Textures to make it work. Why? Because the other side of Texture is Scrambled.

I will give you an example with this photo of Dog (Woofy) and Cat texture on Front and Back side of the Flip Card object.

Firstly, do the UV Layout for the object. Hit TAB, tap U, select all Faces (tap A) and Spacebar "Unwrap" (this is the quickes way). That UV is fine for the normal Flip Cards, before being flipped.

I assign 2 Textures (Cat and Dog) to the Flip Cards.

FRONT: Dog (Woofy)
BACK: Cat

The Front looks fine:

Now we flip the cards....

But the Back is scrambled:

How do we fix and unscramble the texture?

I think, we could use multiple UV. However, for simplicity sake, we just provide Blender with pre-scrambled texture that will be unscrambled later.

What do I mean here is just to "Project" and render the pre-scrambled texture of the photo and use this for our purpose.

Now, when we flip the cards, the Texture is correct from this Front Camera Point of View.

PROBLEM 010: Multiple Texture Changing
We have Front and Back texture, but what if we want to change many textures? Not just 2 textures? The magic is in Keyframing the Texture Visibility ON and OFF:

Kind of hacky, but it works. You could probably setup Driver Control that make it easier for Animator to animate the flipping cards, which takes me to the last problem.

PROBLEM 010: Flip Cards Control Rig For Animator

How is the best way to pass this Flip Card setup for animator? This is one unsolved problem for this Flip Cards setup.

I would like to contain all the Empty and hide all kind of complex mechanical objects, and giving ability to move around the Flip Cards. So far, I am not sure how to do this. Because simply parenting the Empty which has Constrains does not actually work. Wonder if I could use Armature hierarchy.

PROBLEM 011: Python Script and GUI

One day I will create a nice GUI for this to help the setup and automate the whole steps. Or maybe you can do it yourself.

VIDEO TUTORIAL

I made a quick video tutorial that takes you through all the steps. I also added additional setup using Dynamic Paint.

I made few hickups during recording:

1. UV was not laid properly because I missed to select Faces, hence the Black appearance of Material. I did figure it out and fix it in the video.

2. I assigned Dynamic Paint to the wrong object. Supposedly for the "Template" object, and not the Flipcards object. However, I also fix this issue as you can see in the video.

3. You might notice that the Flipping Card ripple is not 100% perfect. This is because of the Sort Ordering of the Grid Face is not properly setup. I need to look into this further.

4. The back Texture is scrambled. This will happen, you need to "unscramble" it using a pre-rendered texture that is actually scrambled so that it looks correct when flipped. Got it?

Hope this is a useful technique for you! Maybe in near future we can use similar technique to trigger Crowds Wave kind of effects.

In next post, I like to cover NLA Action Animation together with this technique.

UPDATE 20130515

BLENDER SUSHI SCRIPT: Uber Flip Cards Effect



import bpy
import fnmatch

# HELPER FUNCTIONS

def hookEveryFace():
    ## HOOK EVERY FACE OF MESH


    """
    Hook every selected Faces. This works best for object
    with all faces separated.

    Copyright (c) 2013 Jimmy Gunawan at Blender Sushi Blog
    Name: hookEveryFace.py
    Version: 001
    Author: Jimmy Gunawan
    Contact: blendersushi@gmail.com
    Date Created: 2013.05.12

    How to use the script:
        1. Select object which every face will be booked
        2. Run the script

    """

    # Get current active object
    object = bpy.context.active_object
    object_name = object.name
    print(object_name)


    # Get all faces
    faces = bpy.context.active_object.data.polygons

    # This is less Pythonic but works.

    for i in range(len(faces)):

        # Deselect Everything in Edit Mode
        bpy.ops.object.mode_set(mode = 'EDIT')
        bpy.ops.mesh.select_all(action = 'DESELECT')
        bpy.ops.object.mode_set(mode = 'OBJECT')

        # Select a face
        bpy.context.active_object.data.polygons[i].select = True

        # Hook face to new object
        bpy.ops.object.mode_set(mode = 'EDIT')
        bpy.ops.object.hook_add_newob()

        # Reselect original object
        bpy.context.scene.objects.active = bpy.data.objects[object_name]


    # Deselect everything in Edit Mode
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action = 'DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')

    """

    # More Pythonic, but failed to work, I do not know why

    for face in faces:

        # Deselect Everything in Edit Mode
        bpy.ops.object.mode_set(mode = 'EDIT')
        bpy.ops.mesh.select_all(action = 'DESELECT')
        bpy.ops.object.mode_set(mode = 'OBJECT')

        # Select a face
        face.select = True

        # Hook face to new object
        bpy.ops.object.mode_set(mode = 'EDIT')
        bpy.ops.object.hook_add_newob()

        # Reselect original object
        bpy.context.scene.objects.active = bpy.data.objects[object_name]

        face.select = False

    """


def quickSeparateFace():
    # Select the mesh
    # Get current active object
    object = bpy.context.active_object
    object_name = object.name

    # Go to Edit Mode

    # Select Toggle All Faces
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action = 'SELECT')

    # Mark Sharp every Face
    bpy.ops.mesh.mark_sharp(clear=False)

    # Back to Object Mode
    bpy.ops.object.mode_set(mode = 'OBJECT')

    # Assign and Apply Edge Split Modifier
    bpy.ops.object.modifier_add(type='EDGE_SPLIT')
    bpy.ops.object.modifier_apply(apply_as='DATA', modifier="EdgeSplit")


def VGVertex():
    '''

    Assigning each and every vertex of a mesh into own Vertex Group

    '''


    # Specify Object to Create Group
    obj = bpy.context.scene.objects.active

    # Make Specified Object Active
    # bpy.context.scene.objects.active = obj

    # Accessing Vertex Groups Data
    # obj.vertex_groups

    # Get total vertex number
    total_vertices = len (obj.data.vertices)

    # Create Vertex Group based on total vertex number
    for i in range(total_vertices):
        vg = obj.vertex_groups.new(name='groupy.%03d' % i)

        # Assign each Vertex to Vertex Group
        vg.add([i], 1, "ADD") # index, weight, operation


    # http://www.blender.org/forum/viewtopic.php?t=25776&sid=a7610ca4988d2ad669308cc517d104c9



def getAllEmpty():
    # Get All Meshes Objects
    objects = bpy.data.objects

    ## LIST COMPREHENSION STYLE
    myListX = fnmatch.filter( [objects [i].name for i in range(len(objects ))] , 'Empty*')


    for item in myListX:
        bpy.data.objects[item].select = True

def constraintAllEmpty():
    '''
    Add Transformation Constraint for every selected objects
    '''


    objs = bpy.context.selected_objects

    # Need a way to sort dictionary/reference via name
    # I do a quick hack in here
    # http://blenderartists.org/forum/showthread.php?194818-Python-Sort-Problem

    newList = []

    for num, obj in enumerate(objs):
        print (num,obj)
        newList.append(obj.name)

    newList.sort()
    #print(newList)

    newObjs = []

    for item in newList:
        newObjs.append(bpy.data.objects[item])

    #print(newObjs)



    for num, obj in enumerate(newObjs):

        # Make each object Active one at a time
        bpy.context.scene.objects.active = obj

        # Assign Transformation Constraints
        bpy.ops.object.constraint_add(type='TRANSFORM')

        current_constraint = bpy.context.object.constraints["Transformation"]

        # Assign Target Object
        current_constraint.target = bpy.data.objects["Template"]

        # Assign Vertex Group Target
        current_constraint.subtarget = "groupy.%03d" % num


        # Setup Attributes for Flip Effects
        current_constraint.from_max_z = 1
        current_constraint.map_to_y_from = 'Z'
        current_constraint.map_to = 'ROTATION'
        current_constraint.to_max_y = 180
        current_constraint.target_space = 'LOCAL'


# FINAL CODE

# Ask User to select FlipCards Object, so it is active
user_grid = bpy.context.active_object

# Oops ... Hard Coded
user_template = bpy.data.objects['Template']

# Select FlipCards Object
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = user_grid

quickSeparateFace()
hookEveryFace()

# Select Template Object and do the VG for every vertex
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = user_template
VGVertex()

# Select Every Empty of FlipCards Object
bpy.ops.object.select_all(action='DESELECT')
getAllEmpty()
constraintAllEmpty()

I decided to put together all the Python scripts above into a single easy to use script. One click and all connection and setup done.

How to use:

Make sure you have a Mesh Grid of Cards which Faces Indices are SORTED correctly.
Also make sure that you also have the "Template" object, as specified and described above. Name it "Template" because the Script is slightly hard-coded for simplicity.
Next, you simply select the Flip Card Object and run the script.
Finally, just apply Displace Modifier that will control the Flip Card.
Have fun animating Flip Cards with Texture.

Remember it is more important to understand every steps first so that you can modify the script to your liking. You can create interesting variations using the same setup just by modifying the script for Transformation Constraint.

ANOTHER VIDEO DEMO WITH UBER FLIP CARD SCRIPT:

EXAMPLE BLEND FILE AT BLENDSWAP
http://www.blendswap.com/blends/view/68139

ADDENDUM: UV Project Modifier at Blender Cookie

You might also want to check Blender Cookie video tutorial with Gottfried Hofmann that shows Blender UV Project Modifier:

http://cgcookie.com/blender/2013/02/28/rigid-body-physics-create-falling-buttons-image/

Not directly related, but if you are using Blender Cycles and want a quick projection, it is recommended to watch the video and use the technique.

ADDENDUM: Sorting in Python

This might be something you may use to sort the index of mesh components (I have not tried it yet), but I was watching this Google Python class and I guess, this could be handy:

Nick Parlante's Class on Python Sorting: (at Google)

http://www.youtube.com/watch?v=EPYupizJYQI

# CUSTOM SORTING
>>> myList = ['aaaa', 'bb', 'ccc', 'd']
>>> myList
['aaaa', 'bb', 'ccc', 'd']

# sort the list using 'len'
>>> myList = sorted(e, key=len)
>>> myList
['d', 'bb', 'ccc', 'aaaa']

# create custom function to sort
def last(s): return s[-1]

>>> myList = sorted(e, key=last)
>>> myList
['aaaa', 'bb', 'ccc', 'd']

Thanks to Daniel Peterson for providing me with this flip card challenge!

Labels

Movies Post

Sports

Music

Business

Pictures

728x90 AdSpace

Travel

Fashion

Design

Movies

Recent Videos

Labels

Category

Slider

Recent Post

Games

Popular Posts

Pages

Find Us On Facebook

Links

About Me

Technology

Breaking News

BLENDER PROCEDURAL MODELING: Pebbles Generator

BLENDER PROCEDURAL MODELING: Starfish Generator

BLENDER MESH CACHE MODIFIER & MESHFOOT

DAVID MILLER PROCEDURAL TECHNIQUE (Key: PyDrivers)

SHAPE KEYS + DRIVERS FOR PROCEDURAL MODELING

MSMESHER FOR PROCEDURAL RANDOM DOODLE

BLENDER METABALLS BLOBS

LATTICE & SOFT BODY

ADDON: Ivy Generator

FUTURE: Random Creature Generator

BLENDER CURVE + ARRAY MODIFIER

MAKE HUMAN + BLENDER SHAPEKEYS

FLIPPING CARDS CASE STUDY

PROBLEM 001: Placing Cards in a Grid

IMPORTANT UPDATE 20130514:

PROBLEM 002: Separate Each Face

PROBLEM 003: Object Level Control for Every Face

BLENDER SUSHI SCRIPT: Hook Every Face of Mesh

PROBLEM 004: Simple Control for Flipping of Many Objects

BLENDER SUSHI SCRIPT: Vertex Group Every Vertex

PROBLEM 005: Power of many Transformation Constraint

BLENDER SUSHI SCRIPT: Add Transformation Constraint to Selected Objects

PROBLEM 006: Orchestrating Many Objects with Displace Modifier

PROBLEM 007: Double Sided Material

PROBLEM 008: UV and Texture for Scrambled Flip

PROBLEM 010: Multiple Texture Changing

PROBLEM 010: Flip Cards Control Rig For Animator

PROBLEM 011: Python Script and GUI

VIDEO TUTORIAL

UPDATE 20130515

BLENDER SUSHI SCRIPT: Uber Flip Cards Effect

MKRdezign

Contact Form