Tutorial Art Design: trigger

Articles by "trigger"

OSC / Scratching Blender

In this post, I will talk about random stuff that is not necessarily related to Blender, however, it is in line toward my interest in understanding Blender Game Engine (BGE) and Game Programming with Python.

Or at least the concept of interaction between languages and programs and the real-world mechanic.

MANY LANGUAGES => MANY MACHINES

In recent months, I have been dealing with some programming languages:

Python
Processing
ChucK
Scratch

I am also experimenting a little bit with the Raspberry Pi computing (Linux OS, small cheap affordable computer, but can be powerful).

I have not touched much of Arduino board yet, but maybe eventually I am heading toward that direction.

-----------------------------------------------------------------------------------------------------
UPDATE 2014.03.17:
I finally did get encounter with Arduino board and I learned that programming for Arduino is similar to Processing, except that we have more direct connection I/O (input and output) with this hardware microcontroller, which is cool!

Thanks to Powerhouse Museum and Thinker1 Arduino board, I am actually learning some basic foundations. James Oliver is the guy to ask about Thinker1, he is a teacher at ThinkSpace and really good at explaining things.

Anyways, I learn that since Arduino speak like Processing, we could use Processing language to load OSC related library, or you could also use the "serial". Serial is kind of the data being passed from hardware that the computer can then listen to. Arduino board like Thinker1 has Potentiometer (knob) and Button INPUT.

So, if it is in Blender, we could use Python that listen to "serial", if we want Arduino board to control whatever we want in Blender. Or, we could use OSC to control the Arduino board (LED, sound, etc).
-----------------------------------------------------------------------------------------------------

Now, one thing cool about Raspberry Pi is its portability (it is also economic). And moreover, inside the small computer, it has built in Python and Scratch program. It is not capable of running Blender yet, because of the system limitation, maybe in the near future?

All those are not directly related to Blender. However, it is about to get a little bit more interesting once one figure out how to bridge and link all of them together.

Imagine:
- Controlling LED light(s) using Blender
- Controlling Robots motion using Blender.
- Home automation using Blender (if you really want to) --- of course, nowadays is more popular for people to control anything using their smartphone touch or voice assistant like SIRI. But nothing can stop us to use Blender Game interface to control the outside world :)

Well, the above example is probably a bit out of reach, but not impossible! Try something easier first:
- Triggering procedural sound in ChucK using Blender.
- Controlling Blender Game Engine objects, using arbitrary controller
- Using Blender simulation to control real world robot and object.

Again, since I am not from programming, computer science or electronic engineering background, all these are new discovery. I have been always curious on how one program can talk to another program, or how one machine can control another machine. So, if you never program before, we are on the same boat!

Do not be afraid with programming.

Saying that, bridging virtual to real world seems to be something that needs to be explored more and it is going to be a lot easier, only if everyone got the access and tools to do so. Very exciting areas to explore but there are some challenges, no doubt!

BABY STEPS, BABY TALKS

I am very new to OSC (Open Sound Controller) and actually to MIDI controller. Kind of heard about them but not until today that I am really using it.

I am really just a baby in this area. In fact, I feel like in the "kindergarten". However, I remember John Maeda said something like this:
"I’d rather be green and growing than ripe and ready to rot"
http://scholarlykitchen.sspnet.org/2009/09/23/john-maeda-and-the-art-of-staying-green-and-growing/

(John Maeda is one of my hero inspiration.)

With OSC setup, we could use it to control not only sound, but passing the data to drive other things. As much as I am excited when little thing works (and failed), this kind of Bridging stuff can be a bit complicated to setup. But not impossible, just need to follow the steps.

This video kind of talk about OSC in easy to understand manner.
https://www.youtube.com/watch?v=jQD1S27f3dU

I really started with Processing, ChucK, and Scratch as a test bed since those programs already have easy way to use the OSC protocol.

So, the first few steps, I manage to do this "TALK" between apps:
1. iPad => MIDI Controller => Processing => visual trigger
2. iPad => MIDI Controller => ChucK => sound trigger
3. iPad => TouchOSC app => Scratch => trigger some animation, action, sound

I don't need to get into details of all those, but basically, it is quite interesting when we are able to TRIGGER ACTION from and within app and external hardware/controller.

Scratch is the easiest to implement and execute. There are 2 versions of Scratch: 1.4 and newer 2.0. I use the older one:
http://scratch.mit.edu/scratch_1.4/

So, I will use both SCRATCH and BLENDER to help us understand this whole OSC business.

This is one of my inspirator: "How BGE and Scratch can inline"
http://www.youtube.com/watch?v=nCFVJYpz_vk

With Blender, I am sure someone out there is already doing some works related to OSC and automation. And since Blender speaks Python, there must be Python library we can use.

For most of these experimentation, I realized how often we still need to be dependent on someone else's code (more experienced coder) and previous research.

I guess this is totally fine, we really do not need to unnecessary re-invent the wheel, as long we give credits back to the coder and understand what is happening to then use it for our own goal and usage. This is indirect collaboration and totally cool.

BRIDGING BGE, PYTHON and OSC

We know that Blender speaks Python 3.3 and BGE (Blender Game Engine) can do real-time and dynamic value changing and triggering things. So... this is exactly the topic and keyword I use when researching using Google. A little bit advanced topic, we need to tackle it step by step.

THE CHALLENGE:
Make Blender to talk to Scratch using Python.
http://wiki.scratch.mit.edu/wiki/Remote_Sensor_Connections

BLENDER PYTHON => OSC => SCRATCH
(not yet BGE, but eventually go that way).

Let's see how this journey actually goes...

1. Scratch bridge via OSC:
Scratch has built in Remote Sensor and this means, as long we can create OSC bridge from external, we can trigger things inside Scratch, easily.
http://www.kasperkamperman.com/blog/scratch-osc-bridge/

I tried using iPad TouchOSC app following the above method and it works. The "Scratch OSC Bridge" program, which is created in Processing (Java) by KasperKamperman is a handy little helper.

2. Scratch can communicate via Python 2 and 3 and OSC (indirect method)
We always need to be aware of the Python Library we use, to make sure the version will work with Blender Python 3.3.

Scratch and Python 2.7
http://wiki.scratch.mit.edu/wiki/Communicating_to_Scratch_via_Python_with_a_GUI

Scratch and Python 3.3 (didn't work as smoothly)

http://wiki.scratch.mit.edu/wiki/Communicating_to_Scratch_via_Python_3.x

I thought that I could just copy paste and use the Python 3.3 script inside Blender to send message to Scratch. Somehow, it failed.

So, I am using a different Python Library, luckily below works, otherwise I am stucked.

4. Python scripting can help with OSC sending and receiving stuff.
Python is really the ULTIMATE KEY here, when we want to talk to and from Blender to the outside app or external hardware. OSC is also the SECOND KEY. We want to be able to send message to specific ADDRESS and PORT.

Dealga McArdle (Blender Scripting blog master) gave me a really nice hint: Try Python OSC Library for Python 3.3.
https://pypi.python.org/pypi/python-osc#downloads

>> INSTALLING 3RD PARTY EXTERNAL PYTHON PACKAGE AND MODULE
I have probably touched this topic at some point, but just to refresh again. If you want to bring in 3rd party Python Library from outside to be used inside Blender, simply place it here:
C:\Program Files\Blender Foundation\Blender\2.69\python\lib\site-packages

So, remember: site-packages is the folder where you want to put outside Python script.

Restart Blender, and then Blender can then source and import the Python library (module) as needed.
from blah import blah

So, I tried and I manage to make Blender talks to Scratch, receiving OSC Path and Message.

Thanks Dealga for example code, this is the original code (I think Dealga is playing with Pure Data or ChucK)
https://gist.github.com/zeffii/7264092

EXAMPLE CODE: (Blender talk to Scratch to randomly move the cat in X and Y)
import time
import random
from pythonosc import osc_message_builder
from pythonosc import udp_client

tick_duration = 0.1

ip = "127.0.0.1"
port = 8000
client = udp_client.UDPClient(ip, port)
osc_msg = osc_message_builder.OscMessageBuilder

for j in range(50):
value_a = random.randrange(-240,240)
value_b = random.randrange(-180,180)
value_c = 3

message_out_list = [value_a, value_b, value_c]

msg = osc_msg(address = "/BLAH")
for i in message_out_list:
msg.add_arg(i)

print(message_out_list)
msg = msg.build()
client.send(msg)
time.sleep(tick_duration)

print("-" * 50)

SCRATCH CONTROLLING ROBOT...

If Scratch ables to control Robot, Blender can too...
http://www.dexterindustries.com/BrickPi/program-it/scratch/
http://www.dexterindustries.com/BrickPi/

Python...

http://www.dexterindustries.com/BrickPi/program-it/python/

If there is Python, we can probably control it using Blender Game Engine (BGE).

Something like this:

http://www.surreal.asturnazari.es/node/178

But how?

TO BE CONTINUED .....

LINKS

Blender and Scratch
http://www.youtube.com/watch?v=nCFVJYpz_vk

Blender BGE Python Tutorial
Kris Occhipinti
http://www.youtube.com/watch?v=g6CjnC1T0lA

http://www.surreal.asturnazari.es/node/178

PureData and Blender: (In French language)
http://wiki.labomedia.org/index.php/Communication_entre_Pure-data_et_Blender_en_OSC

For Older Blender (but still nice to read)
http://www.local-guru.net/blog/2009/3/8/using-the-blendergameengine-as-osc-client

Scratch OSC and BrickPi
http://www.dexterindustries.com/BrickPi/program-it/scratch/

BGE
http://www.youtube.com/user/metalx1000?feature=watch
http://www.cgmasters.net/free-tutorials/python-scripting/
http://www.tutorialsforblender3d.com/BGE_Python/Sensors/Touch/TouchSensor_useMaterial.html

PROCEDURAL / Particle Pointilism with Dynamic Paint x PyDriver and PyHandler

This writing is a case study or research note while I am exploring Blender Dynamic Paint, PyDriver and PyHandler to create tool that does Particle Pointilism Art.

It is not a complex task, but does require a little bit of logic and understanding on how data may flow. The end result may not be something that is productive or polished, however, this one is a good example of procedural thinking.

FIRST TEST: Mario Mushroom Pointilism based on Mario Mushroom Pixel Art.

VISUAL DIAGRAM: Particle Pointilism with DP

I started by sketching diagram. The actual sketch is a lot rougher than below.

CONCEPT + IDEA

To be able to convert an IMAGE/PHOTOGRAPH into Pointilism Art that utilizes Blender Dynamic Paint and Particles.

PROBLEM

I believe the current Blender Particle has "limited" ability in term of data being carried on per particle basis. Although Blender Particle can emit Particles with RGB Color that seems to correspond to the objet Emitter UV Image Texture RGB Value, we cannot really easily query per Particle RGB color.
Dynamic Paint + Particle Color does not directly read UV Image Texture RGB Value. However, the color can be updated during animation and it assign that color to paint on canvas.

SOLUTION

Creating some kind of setup so that we can "sample" Pixel RGB Color (U and V) by referencing object position in 3D (X and Y).

STEP 1: Function to Track Object Position

import bpy

import math as math

ob = bpy.data.objects['ReferenceCube']

# If Reference Cube transform is different to actual pixel
# use ratio multiplication

ratio = 1

# HELPER FUNCTIONS: Get Cube Position

def getCubePosition():

x = ob.location[0]

y = ob.location[1]

print('X Position:', x)

print('Y Position:', y)

print('Pixel X Position:', math.floor(x / ratio))

print('Pixel Y Position:', math.floor(y / ratio))

return( math.floor(x/ratio),math.floor(y/ratio) )

myPos = getCubePosition()

Test the code and see if it is working:

Here I am tracking the X and Y position of an object called "ReferenceCube", which is a Float (decimal number) value and I know I will need to convert those value into Integer for Image Pixel Color on UV space. The RETURN value of this function is the final Integer value needed to sample Pixel Color.

ON SCREEN TEXT VALUE VIEWER (OPTIONAL)

I think it would be nice if we are able to see and visualize DATA VALUE changing while we are modifying object in real time or during timeline playback (if not real time).

I will attempt to do that using Text Object and Python PyHandler.

Below is an example of script that does it, providing we pass on value into the BODY of Text Object(s). Before running the script below, create a few Text Objects, give it a specific name to reference. I am using Text Object with name "floatXpos", "floatYpos", "xpos_text", and "ypos_text". But the name can be anything. I hard-coded the name of object to track just for simplicity.

# UPDATE TEXT

def updateText(scene):

ob = bpy.data.objects['ReferenceCube']

x = ob.location[0]

y = ob.location[1]

myPos = getCubePosition()

fxpost = bpy.data.objects["floatXpos"]

fxpost.data.body = str(x)

fypost = bpy.data.objects["floatYpos"]

fypost.data.body = str(y)

xpost = bpy.data.objects["xpos_text"]

xpost.data.body = str(myPos[0])

ypost = bpy.data.objects["ypos_text"]

ypost.data.body = str(myPos[1])

### SET PYDRIVER

frame = bpy.context.scene.frame_current

### SET PYHANDLER

bpy.app.handlers.frame_change_pre.append(updateText)

The PyHandler code in here is calling that helper function above that updates the Text object BODY value whenever one scrubs on the timeline and/or change the frame number by running the playback. This is totally fine for our purpose. We do not really need to see real-time update the text all the time.

This is the first time I use PyHandler and from my understanding, whatever assigned to PyHandler will get called when certain EVENT is happening.

Real Time Update Using PyDriver

Alternatively, if we like to see a Real-Time value update, we can use PyDriver.

The simplest way I could think of is to create Custom Properties (set of Key and Value) that gets updated whenever there is changes happening.

Script goes something like below:

import bpy, math

ob = bpy.data.objects['ReferenceCube']

# If Reference Cube transform is different to actual pixel

# use ratio multiplication

ratio = 1

# HELPER FUNCTIONS: Get Cube Position

def getCubePosition():

print('-'*50)

x = ob.location[0]

y = ob.location[1]

print('X Position:', x)

print('Y Position:', y)

print('Pixel X Position:', math.floor(x / ratio))

print('Pixel Y Position:', math.floor(y / ratio))

return( math.floor(x/ratio),math.floor(y/ratio) )

myPos = getCubePosition()

def floatXposVal():

ob = bpy.data.objects['ReferenceCube']

x = ob.location[0]

return x

def floatYposVal():

ob = bpy.data.objects['ReferenceCube']

y = ob.location[1]

return y

def xpos_text():

xpos = myPos[0]

return xpos

def ypos_text():

ypos = myPos[0]

return ypos

bpy.app.driver_namespace['floatXposVal'] = floatXposVal

bpy.app.driver_namespace['floatYposVal'] = floatYposVal

bpy.app.driver_namespace['xpos_text'] = xpos_text

bpy.app.driver_namespace['ypos_text'] = ypos_text

We are using PyDriver here. And the advantage of PyDriver is we can see the value updating in real time, whenever there is a changes. In some occassion, we need to force the update of PyDriver, but in this case, it will work nicely.

STEP 2: Function to Get RGB value based on X and Y

Next, we need another helper function that simply query and get RGB value based on specified Image. We have seen a usage of such function in here:

http://blendersushi.blogspot.com.au/2013/03/python-pixel-art-in-blender.html

I will simplify the function so that it will simply query RGB value based on user specified X and Y value. The X and Y value will come from the Reference Cube position in 3D, as we have planned.

The code looks like this:

# HELPER FUNCTIONS: Get RGB value

D = bpy.data

test_file = 'mushroom.png'

img = D.images[test_file]

pixels = list(img.pixels)

grouped_list = [pixels[ipx:ipx+4] for ipx in range(0, len(pixels), 4)]

# Get width and height of image (in pixel)

width = img.size[0]

height = img.size[1]

def getPixelColor(x=0, y=0):

r = grouped_list[x + y * width][0]

g = grouped_list[x + y * width][1]

b = grouped_list[x + y * width][2]

# a = grouped_list[x + y * width][3]

print(r,g,b)

return (r,g,b)

# TEST GET PIXEL FUNCTION

# getPixelColor(4,6) # x,y

STEP 3: Set RGB value to Material Color of Reference Cube

Here, I will create PyDriver setup that query the RGB value in realtime and let it pass on the value into the RGB color. This color will then get pass on into Particle and Dynamic Paint automatically.

# SET DIFFUSE COLOR OF REFERENCE CUBE MATERIAL

name = 'PixelSampling_MAT' # reference cube material name

MAT = bpy.data.materials[name]

def setPixelColor(rgb):

print ("set color of material to pixel RGB value")

MAT.diffuse_color = rgb

def valueR():

myPos = getCubePosition()

rgb = getPixelColor(myPos[0], myPos[1])

return rgb[0]

def valueG():

myPos = getCubePosition()

rgb = getPixelColor(myPos[0], myPos[1])

return rgb[1]

def valueB():

myPos = getCubePosition()

rgb = getPixelColor(myPos[0], myPos[1])

return rgb[2]

bpy.app.driver_namespace['valueR'] = valueR

bpy.app.driver_namespace['valueG'] = valueG

bpy.app.driver_namespace['valueB'] = valueB

STEP 4: Setup Dynamic Paint BRUSH and CANVAS

We are done with the coding actually.

All below procedure should happens and updates automatically:

When Cube is repositioned in 3D, particularly the X and Y location, we are tracking it.
The X and Y will correspond to the Pixel RGB color based on Image Texture we have specified.
If Cube is around position X and Y, let say X=1.42343 and Y=3.432523, then the Material Diffuse Color of the Cube will change to match the pixel position X=1 and Y=3.

All we have to do is to setup the Cube as BRUSH and create a Plane or something as Canvas.

Run the simulation and there we go, we have procedural POINTILISM ART machine in Blender. With little tweak, we could actually paint using the REFERENCE CUBE itself, Dot by Dot.

Remember that the Reference Cube can be any object and so we can have any shape of stamp, converting tiny square pixels into other shapes, when everything goes to plan.

All and all, at least you are learning some codes that can help you to drive value with another value. PyDriver and PyHandler are two things you want to explore.

The way I see PyDriver and PyHandler is like this:

If the value can be animated and can be assigned with Drivers, you can modify it using PyDriver.
If the value is sort of hidden (like Text object BODY data), you can access and modify it using PyHandler. I heard that PyHandler can create Modifier "on-the-fly".

BLENDER SUSHI SCRIPT: Pointillism Art (rough script with lots of hardcoded thing, needs clean up)


import bpy
import math as math

print('-' * 40)

ob = bpy.data.objects['SamplerCube']

# If Cube Transform is different to actual pixel
ratio = 1

# HELPER FUNCTIONS: Get Cube Position
def getCubePosition():
    x = ob.location[0]
    y = ob.location[1]

    print('X Position:', x)
    print('Y Position:', y)
    print('Pixel X Position:', math.floor(x / ratio))
    print('Pixel Y Position:', math.floor(y / ratio))
    
    return( math.floor(x/ratio),math.floor(y/ratio) )

myPos = getCubePosition()

# HELPER FUNCTIONS: Get RGB value

D = bpy.data

test_file = 'mushroom.png'
img = D.images[test_file]
pixels = list(img.pixels)
grouped_list = [pixels[ipx:ipx+4] for ipx in range(0, len(pixels), 4)]

# Get width and height of image (in pixel)
width = img.size[0]
height = img.size[1]

def getPixelColor(x=0, y=0):
    r = grouped_list[x + y * width][0]
    g = grouped_list[x + y * width][1]
    b = grouped_list[x + y * width][2]
    # a = grouped_list[x + y * width][3]
    print(r,g,b)
    return (r,g,b)

# TEST GET PIXEL FUNCTION
# getPixelColor(4,6) # x,y

# SET DIFFUSE COLOR OF REFERENCE CUBE MATERIAL
name = 'PixelSampling_MAT' #material name
MAT = bpy.data.materials[name]

def setPixelColor(rgb):
    print ("set color of material to pixel RGB value")
    MAT.diffuse_color = rgb


def valueR():
    myPos = getCubePosition()
    rgb = getPixelColor(myPos[0], myPos[1])
    return rgb[0]

def valueG():
    myPos = getCubePosition()
    rgb = getPixelColor(myPos[0], myPos[1])
    return rgb[1]

def valueB():
    myPos = getCubePosition()
    rgb = getPixelColor(myPos[0], myPos[1])
    return rgb[2]


# UPDATE TEXT
def updateText(scene):
    ob = bpy.data.objects['SamplerCube']
    x = ob.location[0]
    y = ob.location[1]
    myPos = getCubePosition()
    fxpost = bpy.data.objects["floatXpos"]
    fxpost.data.body = str(x)
    
    fypost = bpy.data.objects["floatYpos"]
    fypost.data.body = str(y)
    
    xpost = bpy.data.objects["xpos_text"]
    xpost.data.body = str(myPos[0])
    ypost = bpy.data.objects["ypos_text"]
    ypost.data.body = str(myPos[1])
    
    rgb = getPixelColor(myPos[0], myPos[1])
    rgbt = bpy.data.objects["rgbValue_text"]
    rgbt.data.body = str(rgb)

### SET PYDRIVER
frame = bpy.context.scene.frame_current

bpy.app.driver_namespace['valueR'] = valueR
bpy.app.driver_namespace['valueG'] = valueG
bpy.app.driver_namespace['valueB'] = valueB

### SET PYHANDLER
bpy.app.handlers.frame_change_pre.append(updateText)

NOTE:

I do not know how Blender would handle large image. So far, I tested with 16 x 16 Mario Mushroom Pixel Art. I will give it a try with a larger image after I post this blog. Maybe it will crash or simply running really slowly on the machine.

However, all goes well and sometimes you got lucky, and Blender does magic one again.

TON (2013)

1024x1024 Pixels, 2500 Samples, 3 hours calculation, 3 x DP Brush in Torus Shape.

*Original photo of Ton is from the Internet, which is cropped and resized to 512x512 pixels. Copyright belong to photographer.

STEVE (2013)

1024x1024 Pixels, 2800 Samples, 3 hours calculation, 3 x DP Brush in Torus Shape.

STEVE JOB (2013).
Based from that famous photograph by ....

Below is a more detailed version, using Apple logo as dynamic Ink Stamping, instead of regular spherical dots. The point of every dots are procedurally spread across the image.

2048x2048, 4400 Samples, over 10 hours.

INSPIRATION: William Betts Surveillance Art (pixel art using CCTV image)

As part of the Creator Project, this artist is recycling CCTV image and create a setup that actually paint a giant canvas, dot by dot (like the old dot matrix printer). Quite clever.

http://thecreatorsproject.vice.com/blog/cctv-footage-as-art-the-work-of-william-betts

INSPIRATION: Street Art in Germany
Was Blender ever made for this kind of Art creation? Don't know, keep experimenting.
http://youtu.be/fhL3XgkMiMk

PYTHON / NLA (Non Linear Animation) with Python

In this article, I am sharing my research and notes on Blender NLA (Non Linear Animation) and write on how we could also use Python to orchestrate the animation of MANY objects in context of NLA.

NOTE: It comes to my own surprise that I only found out about the POWER of Blender NLA just recently.

NLA INTRO

I would start by reading these:
http://wiki.blender.org/index.php/Doc:2.6/Manual/Animation/Editors/NLA
http://aligorith.blogspot.com.au/2010/10/clarifying-animation-workflow-in.html

In short, I am seeing NLA as a way to non-linearly edit normal Animation(s) keyframes into a Strip of Action(s) just like any non-linear editor. A single Action animation can be offset, sliced, blended in time.

NLA workflow is great for Game Animation where one may reuse animations (Idle, Walk, Run) or to specifically trigger an Action Animation based on Event.

On top of that, I believe NLA is also useful for LOOPING kind of animation, usually for musical score that has beats and loops. Not only that, NLA has tremendous potential to create a lot of interesting "wave motion" animation effects.

Keep in mind that NLA is NOT complex NOR super technical, in fact I think Blender NLA is pretty intuitive and very simple to use.

I have not looked at NLA thoroughly, but I believe there are few different NLA types:

NLA for normal object transformation
NLA for Armature
NLA for Materials
etc

I am not yet 100% understand how NLA data block works in relation to each other, but I will touch on the basic first. For example, I am wondering whether it is possible to "drive" Material animation using Actions of Transform, apparently cannot. I am guessing we need Blender Drivers for that.

NLA BASIC

Let's do a little experiment.

1. MANUAL ANIMATION

Create a simple animation of a block going from position A to position B. Maybe just an animation of a Cube going from original position and go up few units in Z axis.

Single keyframe Position of Cube in Z axis at frame 1.
Move the frame in timeline, lift up the Cube in Z axis, and keyframe at frame 20.

2. SWITCH TO NLA EDITOR

Next, we like to switch panel to NLA Editor. I usually do this inside Blender Animation layout. But feel free to modify your current layout so you can get to NLA Editor panel.

3. NLA EDITOR

Now, we are ready to turn the animation into Strip. You simple click on tiny Snowflake button to freeze the animation and work in NLA kind of way.

By doing the freeze, we now get Strip named "CubeAction". NLA Track is also automatically created.

4. EDIT THE ACTION STRIP

To Edit the action like normal, we can apparently do that quickly by hitting TAB while selecting the Action Strip:

We hit TAB again to go out from the Action Edit Mode.

5. APPLY ACTION STRIP TO OTHER OBJECT aka INCLUDE SELECTED OBJECTS

Next, let say we want to apply the same animation to other object. Firstly, I created a few other objects.

What we need to do next is to create NLA track for the objects. But as you may notice we don't have any listing of new objects. We need to Include Selected Objects inside NLA first, before we are able to add NLA Tracks and Action Strips.

Handy Shorcuts:

Shift+A while hovering on the NLA left panel to add NLA Track
Shift+A while hovering on the NLA right panel to add Action.
X to quickly delete NLA Track
Ctrl+LMB click on the name of object to quickly rename the object name inside NLA

5. EDITING ACTIONS STRIPS IN NLA CONTEXT

Next thing you probably want to explore yourself is how you can edit and modify the strip inside NLA Editor. There are a lot of interesting NLE features that I did not even think that they are existed before, such as: Trimming, Muting, Splitting, Holding, Retiming, Combo-ing and Layering animations.

What I am even more interested is how we can use Python to actually do some automation inside NLE that we may want to know especially when we are doing Motion Graphics type of work.

STUDY: FLIP ANIMATION WITH NLA AND PYTHON

This found video at Eibriel blog is a good inspiration for what we are trying to do:
http://www.eibriel.com/2012/01/30/working-with-blender-python-nla/

Some times ago, I created a complex setup using Dynamic Paint to trigger flipping animation:
http://blendersushi.blogspot.com.au/2012/02/vfx-multilayers-triggering-of-effects.html

Last time on my blog post, I did the same thing using Python to set it up.

Now we are revisiting the idea once more, using NLA. Setting up repeating tasks is a breeze with Python scripting. Although it does require some hours of R&D.

Let's try to achieve the flipping animation of many objects using Python and NLA.

We basically need to "propagate" a single animation into many objects, with certain OFFSET value. Because a single repeating animation that starts and ends at the same time is kind of boring. While many same animation with offset is usually slightly more interesting.

Our animation in this case is just a flipping object, very simple. And we like to do that for many objects. The process will be like this:

1. Create a flipping animation, freeze and turn it into NLA Action Strip. This animation can be applied using any object. We just care about the Action.
2. Create some bunch objects that we like to flip.
3. Use Python to "copy" those Actions.

NOTE:
Before running the script below, you want to make sure that you have "Include Selected Objects" inside NLA Editor. Read "INCLUDE SELECTED OBJECT" topic above.

BLENDER SUSHI SCRIPT: Apply Action To Many Objects With Frame Offset


import bpy

# Initial setup
ACTION = "CubeAction" # Specify name of action to be copied here
START = 1 # Action Strip will be propagated starting with this frame number
OFFSET = 10 # How much frame offset
NEWTRACK = "MyTrack01" # Name of new NLA track for every object

# http://blenderartists.org/forum/showthread.php?233608-activate-NLA-track

sce = bpy.context.scene    # get the scene 
rig = bpy.context.active_object

objs = bpy.context.selected_objects

# get name to make active
names = []
for obj in objs:
    names.append(obj.name)

# reverse order of selected objects
names.reverse()
    
# For every ACTIVE OBJECT

for i, name in enumerate(names):
    bpy.context.scene.objects.active = bpy.data.objects[name]
    rig = bpy.context.active_object

    #get or create a new track called MyTrack 
    
    if NEWTRACK in rig.animation_data.nla_tracks:
        NLATrack = rig.animation_data.nla_tracks[NEWTRACK]
    else:
        NLATrack= rig.animation_data.nla_tracks.new()
        NLATrack.name = NEWTRACK   
        
    action = bpy.data.actions[ACTION]   # your action
    
    #sce.frame_set(frame=1) 
    
    startframe = START + OFFSET * i 
    actionstartframe = 1
    
    MyNLAStrip = NLATrack.strips.new("MyStripName",start=startframe,action=action)

VIDEO DEMO

Here is an example how you can use the script above:

That simple script should show you a simple implementation of Python inside NLA. This one works only for Transform (Translate, Rotate, Scale). If you like to do the same thing on other context like Materials, Shapekeys, etc, keep reading.

NLA ACTION SCRIPT IN OTHER OBJECT TYPE CONTEXT

Further on in my curiosity toward the data flow in NLA and how we can access the data using Python, I also did a quick look and study on Shape Keys and Materials in context of NLA.

I dig and test inside Python Console and started to see some kind of interesting data pattern.

MATERIAL ---> NLA
bpy.data.materials[MATERIALNAME].animation_data.nla_tracks.new()
bpy.data.materials['Material.001'].animation_data.nla_tracks['NlaTrack'].select = True
bpy.data.materials['Material.001'].animation_data.nla_tracks['NlaTrack'].select = False

SHAPE KEYS ---> NLA
# Create new NLA Track
bpy.data.shape_keys[KEY].animation_data.nla_tracks.new()

# Change the Frame Start and End Example
bpy.data.shape_keys[KEY].animation_data.nla_tracks[NLATRACK].strips[KEYACTION].frame_start = 1

bpy.data.shape_keys[KEY].animation_data.nla_tracks[NLATRACK].strips[KEYACTION].frame_end = 40

So if it is for Armature or for other Object Type, we can access and modify the Action Data just like above.

This is actually a new revelation for me in term of my understanding of Python Object Oriented Programming (OOP) in Blender and how the data is really stored inside Blender.

With this knowledge, we could actually further improve the script above to work on existing Strip Animation Data. So, instead of just assigning Strip, we can simply Query the current Script and maybe:

Randomize
Offset
Add, Combine, and Mix Strip with other actions.

A slight modifiaction from above script if this was for Object Material:

BLENDER SUSHI SCRIPT: Propagate Speificed Action To Selected Object Materials


import bpy

# Initial setup
ACTION = "MaterialAction" # Specify name of action to be copied here
START = 1 # Action Strip will be propagated starting with this frame number
OFFSET = 10 # How much frame offset
NEWTRACK = "MyTrack01" # Name of new NLA track for every object

# Get Active Material for every selected objects

objs = bpy.context.selected_objects

# Get Materials name, sort them in a list, and activate Animation Data for each one of them
mat = []
mat_names = []

for obj in objs:
    # Query Material of every object
    mat.append(obj.data.materials)
    mat_names.append(obj.data.materials[0].name)
    
    # Sort Animation Name
    mat_names.sort()
    mat_names.reverse()
    
    # Create Animation Data    
    obj.data.materials[0].animation_data_create()  

# Get Object to make active
names = []
for obj in objs:
    names.append(obj.name)

# reverse order of selected objects
names.reverse()
    
# For every ACTIVE OBJECT

for i, name in enumerate(names):
    bpy.context.scene.objects.active = bpy.data.objects[name]
    rig = bpy.context.active_object.data.materials[0]

    #get or create a new track called MyTrack 
    
    if NEWTRACK in rig.animation_data.nla_tracks:
        NLATrack = rig.animation_data.nla_tracks[NEWTRACK]
    else:
        NLATrack= rig.animation_data.nla_tracks.new()
        NLATrack.name = NEWTRACK   
        
    action = bpy.data.actions[ACTION]   # your action
    
    #sce.frame_set(frame=1) 
    
    startframe = START + OFFSET * i 
    actionstartframe = 1
    
    MyNLAStrip = NLATrack.strips.new("MyStripName",start=startframe,action=action)

NOTE:
Notice that in this second script, we improve the code slightly so that we don't have to do "Include Selected Objects" thingy. We just simply run the script and it is accessing the Material, add Animation Action from the back door.

What you need to take care is the name of specified Material Action that you would like to propagate to every Object's Material. So you need to make sure you know the name of Action. In the script, I hardcoded "MaterialAction" as the action to be "copied" to every Material.

RENAMING ACTION EXAMPLE
bpy.data.actions['Material.004Action'].name = "MaterialAction"

MORE THAN JUST DOMINO EFFECT

At this moment, all we get with the script above is this DOMINO EFFECT where one action leads to another action and all the actions are the same. What would be nice is is we could create a condition where the action only happens when triggered by a certain condition, or another action.

I really like the idea of "triggering" of actions based on distance approximation, for example. Something that Dynamic Paint does it well for Vertex Weighting.

Maybe I can do something like this:
1. Query some kind of STATE or CONDITION that Blender can write out or save in memory.
2. Based from that query, we then apply second code that will BORN NLA animation at that certain point.

I am sure that this can be done easily in BGE (Blender Game Engine) environment. At some point, I have to find out the relations between BGE and the normal Blender animation environment and hook them together.

OTHER REFERENCES

http://blenderartists.org/forum/showthread.php?248442-NLA-Editor-Make-a-strip-active
http://blenderartists.org/forum/showthread.php?233608-activate-NLA-track
http://blenderartists.org/forum/showthread.php?225783-How-do-I-emulate-the-quot-Snowflake-button-quot-in-the-NLA-in-python-code
https://sites.google.com/site/makehumandocs/blender-export-and-mhx/mocap-tool/combining-actions-in-nla-editor

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

MANY LANGUAGES => MANY MACHINES

BABY STEPS, BABY TALKS

BRIDGING BGE, PYTHON and OSC

SCRATCH CONTROLLING ROBOT...

LINKS

VISUAL DIAGRAM: Particle Pointilism with DP

CONCEPT + IDEA

PROBLEM

SOLUTION

STEP 1: Function to Track Object Position

STEP 2: Function to Get RGB value based on X and Y

STEP 3: Set RGB value to Material Color of Reference Cube

STEP 4: Setup Dynamic Paint BRUSH and CANVAS

BLENDER SUSHI SCRIPT: Pointillism Art (rough script with lots of hardcoded thing, needs clean up)

TON (2013)

STEVE (2013)

1024x1024 Pixels, 2800 Samples, 3 hours calculation, 3 x DP Brush in Torus Shape.

NLA INTRO

NLA BASIC

STUDY: FLIP ANIMATION WITH NLA AND PYTHON

BLENDER SUSHI SCRIPT: Apply Action To Many Objects With Frame Offset

VIDEO DEMO

NLA ACTION SCRIPT IN OTHER OBJECT TYPE CONTEXT

BLENDER SUSHI SCRIPT: Propagate Speificed Action To Selected Object Materials

MORE THAN JUST DOMINO EFFECT

OTHER REFERENCES

MKRdezign

Contact Form