Blender 3D: Blending Into Python/OrphanScripts

From Wikibooks, open books for an open world
Jump to: navigation, search

Orphan Scripts[edit]

Hi, post unmaintained scripts here.

Be wary of malicious code, especially the OS module, check in the history every so often for edits to see nobody's doing bad stuff.

Currently there are two scripts here in need of nice mothers or fathers.

This script is a simple L system that allows you to use pre-defined meshes. It DOES work in 2.43 and could possibly be a building generator (with some work).

#
# =====================
# README
# =====================
#
# this is a simple L-system that uses pre-made mesh elemental blocks
#
# source blocks are in a different layer - press tilde (`) in 3d view
# to see them all
#
# a new mesh is created every time; edge creases are carried over from
# source meshes to allow subsurf work
#
# this system uses the turtle concept with pushable/poppable state,
# just like most other L-systems
# however, the "drawing" operation here is to place a pre-made mesh
# instead the usual plant-oriented stuff
# as a result, this should be pretty well suitable for Discombobulator
# style work such as generating lots of small detail
#
# turtle instructions and any other tokens are XML-like tags
# instead of single characters; they can also contain an arbitrary
# argument string
# rewriting rules are actually defined as functions to allow
# procedural flexibility
#
# things left to do really depend on what the actual use is
# some ideas include using lists instead of strings for arbitrary
# argument data (may help with speed); supplying environment
# info to the rule function (for queries, like in some advanced
# L-systems out there) as well as the current model info
# for true Discombobulator-style detail generation there has
# to be a mode to populate the axiom (initial state) with
# existing model faces
#
# of course, more code cleanup is in order
#
 
import sys
import re
 
import Blender
from Blender import Mathutils
from Blender import NMesh
 
substrate = '<LimbArray>'#'<twist:90><turn:90><LimbArray>'
 
# custom characters and their translations
custom = [ \
	('<Stem>', '<add:Stem><offset:0.5,0,0>'), \
	('<Joint2>', '<add:Joint2Start><offset:0.2,0,0><pitch:-30_0><add:Joint2Middle><turn:-20_20><add:Joint2End><offset:0.2,0,0>') \
	]
 
print "growing..."
 
# force recompile of ruleset
if 'ruleset' in sys.modules: del sys.modules['ruleset']
import ruleset
 
rules = [ (re.compile('<' + name + '(?::([^>]+))?>'), getattr(ruleset, name)) for name in dir(ruleset) ]
 
# do the matching
for stage in range(20):
 
	curPos = 0
 
	while True:
		newPos, newEnd = None, None
		newStr = None
		for regex, func in rules:
			match = regex.search(substrate, curPos)
			if match != None:
				if newPos == None or newPos > match.start():
					newPos = match.start()
					newEnd = match.end()
					newStr = func(match.group(1))
 
		if newPos == None: break
 
		substrate = substrate[:newPos] + newStr + substrate[newEnd:]
		curPos += len(newStr)
 
# translate custom chars
for char, repl in custom:
	substrate = re.sub(char, repl, substrate)
 
print "interpreting..."
 
# interpret the result
class StackFrame:
 
	# prev is the parent frame
	def __init__(self, prev=None):
		self.prev = prev
		if prev != None:
			self.matrix = prev.matrix
		else:
			self.matrix = Mathutils.Matrix()
			self.matrix.identity()
			self.matrix.resize4x4()
 
	# modifications
	def rotate(self, axis, angle):
		rot = Mathutils.RotationMatrix(angle, 4, axis)
		self.matrix = rot * self.matrix
 
	def offset(self, xyz):
		tra = Mathutils.TranslationMatrix(Mathutils.Vector(xyz))
		self.matrix = tra * self.matrix
 
	def scale(self, ratio):
		sca = Mathutils.Matrix( \
			[ ratio, 0, 0, 0 ], \
			[ 0, ratio, 0, 0 ], \
			[ 0, 0, ratio, 0 ], \
			[ 0, 0, 0, 1 ])
		self.matrix = sca * self.matrix
 
	# raises exception if no parent
	def getPrev(self):
		if self.prev == None:
			raise Exception, "no parent frames"
		return self.prev
 
	# appends current mesh to given one
	# does NOT change position
	def addMesh(self, meshObj, dest):
		mesh = meshObj.getData()
 
		vertBase = len(dest.verts)
		for v in mesh.verts:
			vec = Mathutils.Vector(v.co[0], v.co[1], v.co[2], 1)
			vec = vec*self.matrix
			cv = NMesh.Vert(vec.x, vec.y, vec.z)
			dest.verts.append(cv)
 
		for f in mesh.faces:
			cf = NMesh.Face([ dest.verts[v.index + vertBase] for v in f.v ])
			dest.addFace(cf)
 
		if mesh.edges != None:
			for e in mesh.edges:
				v1, v2 = e.v1, e.v2
				nv1, nv2 = dest.verts[v1.index + vertBase], dest.verts[v2.index + vertBase]
				ne = dest.addEdge(nv1, nv2)
				ne.crease = e.crease
		#dest.update()
 
 
 
# create result mesh
mesh = NMesh.New()
#mesh.addEdgesData() # for things like creases
 
# do the dew
frame = StackFrame()
 
# parses and interprets a string of type
# X:Y_Z (randomly choose either X or something between Y and Z)
def number(str):
	import random
	choices = str.split(':')
	choice = random.choice(choices)
	limits = choice.split('_', 2)
	if len(limits) == 2:
		return random.uniform(float(limits[0]), float(limits[1]))
	return float(limits[0])
 
instrMatch = re.compile(r"""
	<
		(?P<instr1>
			\w+
		)
		(?:
			:
			(?P<arg>
				[^>]+
			)
		)?
	>
	|
	(?P<instr2>
		[\[\]]
	)
	""", re.VERBOSE)
curPos = 0
while True:
	match = instrMatch.search(substrate, curPos)
	if match == None: break
 
	curPos = match.end()
 
	# collect instruction
	instr = match.group('instr1')
	if instr == None: instr = match.group('instr2')
 
	arg = match.group('arg')
 
	# do the dew
	if instr == "[":
		frame = StackFrame(frame)
	elif instr == "]":
		frame = frame.getPrev()
	elif instr == "offset":
		frame.offset([ number(a) for a in arg.split(',', 3) ])
	elif instr == "turn":
		frame.rotate("z", number(arg))
	elif instr == "pitch":
		frame.rotate("y", number(arg))
	elif instr == "twist":
		frame.rotate("x", number(arg))
	elif instr == "scale":
		frame.scale(number(arg))
	elif instr == "add":
		frame.addMesh(Blender.Object.Get(arg), mesh)
 
NMesh.PutRaw(mesh, "Result", 1, 1)


This script apparently WONT work in blender 2.43, updates welcome.

# Jamesk's Walk-o-matic version 0.49.9 (MODIFIED)
# for Blender 2.25 and a fully installed Python 2.0 [required]
# CHANGES FOR BLENDER 2.36 GENERALLY MARKED '#MDR:' ...
# Badly coded changes for Blender 2.43 by TwinStripe :) ! Appears to perform more passes but produces the same results!?!
 
# SET/CHECK THE PARAMETERS BELOW BEFORE EXECUTING THE SCRIPT.
# Make sure to select your proxy object, then run the script with ALT+P.
# Please consult the documentation for a full description of the parameters.
# ...Aaaaand check the console window for any messages.
 
# GENERAL SETTINGS:
FF = FIRST_FRAME = 1        # begin evaluating at this frame
LF = LAST_FRAME = 850       # stop evaluating after this frame
 
HS = HEEL_SEPARATION = 3.0  # desired distance between heel targets (in Blender Units)
MT = MOVE_TIME = 8.0        # number of frames/cycle a foot is moving
MSD = MOVE_STOP_DELAY = 0   # any value above zero will prolong the time a foot stays in the air.
HEEL_TO_FLAT_DISTANCE = 1   # desired distance between a heel target and its associated foot look-at-target
FLAT_TO_TLAT_DISTANCE = 0.5 # desired distance between a foot look-at-target and its associated toe look-at-target
 
AL = ALWAYS_LIFT = 0             # set to zero to prevent feet moving up/down when proxy has speed 0
CTD = C_TARG_DISTANCE = 2.0      # how far above proxy to place center target
LA = LIFT_AXIS = 'local'         # lift feet along global Z or local proxy Z?
CTDLA = CTD_LIFT_AXIS = 'global' # raise center target along global Z or local proxy Z?
 
# NAMES FOR THE EMPTIES:
HEEL_LEFT, HEEL_RIGHT = 'heel.ikt.left', 'heel.ikt.right' 
FLAT_LEFT, FLAT_RIGHT = 'foot.lat.left', 'foot.lat.right' 
TLAT_LEFT, TLAT_RIGHT = 'toe.lat.left', 'toe.lat.right'  
TARGET_CENTRE = 'target.centre'                    
 
# LIFT ENVELOPE SETTINGS:
LP = LIFT_PEAK = 0.5        # how far to lift above proxy initially 
FLATLP = FLAT_LIFT_PEAK = 0.2 # how far to lift foot look-at-target above proxy initially
TLATLP = TLAT_LIFT_PEAK = 0.2 # how far to lift toe look-at-target above proxy initially
LPT = LIFT_PEAK_TIME = 0.2  # time to reach lift-peak. (relative to movetime)
 
MP = MID_PEAK = 0.4         # how far from proxy after lift-peak
FLATMP = FLAT_MID_PEAK = 0.4 # how far to lift foot look-at-target
TLATMP = TLAT_MID_PEAK = 0.4 # how far to lift toe look-at-target
MPT = MID_PEAK_TIME = 0.5   # time to reach mid-peak (relative to movetime)
 
FP = FINAL_PEAK = 0.5       # how far from proxy before setting down again
FLATFP = FLAT_FINAL_PEAK = 0.7 # how far to lift foot look-at-target
TLATFP = TLAT_FINAL_PEAK = 0.9 # how far to lift toe look-at-target
FPT = FINAL_PEAK_TIME = 0.8 # time to reach final_peak (relative to - you guessed it - movetime)
 
 
#
# Concept and coding by James Kaufeldt a.k.a. Jamesk 
# Made in Sweden, november 2002
# Contact: james.k@home.se
#
# Special thanx to
# - [d0pamine] and [theeth] for some hints regarding vector math.
# - Martin [Strubi] Strubel from whom I borrowed the "normalize" function,
#   len3(x), dist3(x,y) and sub3(x,y) funcs found in his "vect.py" utility module.
# - [eeshlo] for pointing out how simple it was to give names to the empties.
#
# ---------------------------------------------------------------------------------------
# EDITABLE SECTION ENDS HERE!
#
# NO USER DEFINABLE VALUES BEYOND THIS POINT!
# ---------------------------------------------------------------------------------------
#
#
#
#
 
LT = MT
CT = MT + LT  
 
from Blender import Object, Scene, Window, Ipo
from Blender.Scene import Render
from Blender.Window import Types
import sys, math
 
proxy = Object.GetSelected()
 
status = 'UNDEFINED ERROR'
Layer = 0
print
print '----------------------------------'
print 'W A L K - O - M A T I C   V 0.49.9'
print '----------------------------------'
print
# make sure that there's an actual walker proxy to use:
if proxy == []:
    print 'No proxy indicated, terminating...'
    status = 'NO PROXY OBJECT SELECTED'
if proxy != []:
    proxy = proxy[0]
    print 'Proxy in use: \t',proxy
    Layer = proxy.Layer
    print ' in Layer',Layer
    status = 'OK'
sys.stdout.flush()
 
scene = Scene.GetCurrent()
 
# make sure there's a scene to use (should always be one, but wth...)
if scene == []:
    print 'No scene available, terminating...'
    status = 'NO CURRENT SCENE AVAILABLE'
if scene != []:
    print 'Target scene: \t',scene
sys.stdout.flush()
 
# some generally useful functions below:
def normalize(v):
    r = math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2])
    return (v[0]/r, v[1]/r, v[2]/r)
 
def len3(x):
    return math.sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2])
 
def sub3(x, y):
    return ((x[0] - y[0]), (x[1] - y[1]), (x[2] - y[2]))
 
def dist3(x, y):
    return len3(sub3(x, y))
 
def moveAlong(origpos, distance, vector):
    newpos = [0,0,0]
    newpos[0] = origpos[0]+distance*vector[0]
    newpos[1] = origpos[1]+distance*vector[1]
    newpos[2] = origpos[2]+distance*vector[2]
    return newpos
 
def invertVector(v):
    return (-v[0], -v[1], -v[2])
 
#MDR:
def selectFrame(f):
    f = int(f)
    if scene.getRenderingContext().currentFrame() != f:
       scene.getRenderingContext().currentFrame(f)
       Window.Redraw(Window.Types.VIEW3D)
 
# MDR:
# Conversion routine:  try to get an object, return None if it's not there.
#   Just like Blender used to do.  The easiest way to accomplish this is to
#   allow the exception to occur, and catch it.
 
def TryGetObject(v):
  try:
    return Object.Get(v)
  except:
    return None
 
 
def getOffset(origin, frame, xdir, xdist, forward):
    # origin: the point to offset           frame: framenumber
    # xdir:  1 = positive offset along X, -1 = negative offset
    # xdist: how much to offset
    selectFrame(frame)
    loc = origin.getMatrix()[3]
    loc = moveAlong(loc, forward, normalize(origin.getMatrix()[1]))
    direction = normalize(origin.getMatrix()[0])
    if xdir == -1:
        direction = invertVector(direction)
    return moveAlong(loc, xdist, direction)
 
def getLiftAxisOffset(origin, frame, liftaxis, liftdist):
    # origin: the point to offset             frame: framenumber
    # liftaxis: 'global' or 'local' lifting   liftdist: the amount of lift    
    selectFrame(frame)
    loc = origin.getMatrix()[3]
    direction = normalize(origin.getMatrix()[2])
    if liftaxis=='global':
        direction = [0,0,1.0]
    return moveAlong(loc, liftdist, direction)
 
def getElevation(origin, frame, axis, zdist, xdir, xdist, forward):
    # origin: the point to offset     frame: framenumber
    # axis: 'local' or 'global'       zdist: how much to elevate
    # xdir: the X offset              xdist: the distance to offset along X
    loc = getOffset(origin, frame, xdir, xdist, forward)
    if axis=='local':
        direction = normalize(origin.getMatrix()[2])
        return moveAlong(loc, zdist, direction)
    if axis=='global':
        direction = [0, 0, 1.0]
        return moveAlong(loc, zdist, direction)
 
def writeCurvePoint(ipo, frame, point):
    # ipo: the IPOblock to use           frame: at what frame
    # point: the 3D coordinate to write
    xc = ipo.getCurve('LocX')
    yc = ipo.getCurve('LocY')
    zc = ipo.getCurve('LocZ')
    for idx, c in enumerate([xc,yc,zc]):
        c.addBezier((frame, point[idx]))
        c.update()
 
def makeIPO(name, ipol, expol):
    # name: desired name for this IPOblock    ipol: type of interpolation
    # expol: type of extrapolation
    ipo = Ipo.New('Object', name)
    xc = ipo.addCurve('LocX')
    yc = ipo.addCurve('LocY')
    zc = ipo.addCurve('LocZ')
    for curve in [xc, yc, zc]:
        curve.setInterpolation(ipol)
        curve.setExtrapolation(expol)
    return ipo
 
def move(ipo, origin, destination, startframe, framespan, proxob, xdir, xdist, forward):
    # ipo - what ipo to write points to                 origin - the location (3Dpoint) to start at
    # destination - the location to end up at           startframe - frame to set the first curvepoint at
    # framespan - total number of frames for the move   proxob - the proxy/reference object
    # xdir - pos or neg offset along proxy X-axis       xdist - how much to offset along proxy X-axis
    writeCurvePoint(ipo, startframe, origin)
 
    if AL==1 or origin!=destination:
        # Write curvepoints for LiftPeak and LiftPeakTime:
        # Pretty hackish formulae for proxyTime here... But they do work, so wtf...
        lpProxyTime = startframe + (LPT*framespan*2)-framespan*0.25
        lpRealTime = startframe+(framespan+MSD)*LPT
        lpLocation = getElevation(proxob, lpProxyTime, LA, LP, xdir, xdist, forward)
        writeCurvePoint(ipo, lpRealTime, lpLocation)
        # Write curvepoints for MidPeak and MidPeakTime:
        mpProxyTime = startframe + (MPT*framespan*2)-framespan*0.25
        mpRealTime = startframe+(framespan+MSD)*MPT
        mpLocation = getElevation(proxob, mpProxyTime, LA, MP, xdir, xdist, forward)
        writeCurvePoint(ipo, mpRealTime, mpLocation)
        # Write curvepoints for FinalPeak and FinalPeakTime:
        fpProxyTime = startframe + (FPT*framespan*2)-framespan*0.25
        fpRealTime = startframe+(framespan+MSD)*FPT
        fpLocation = getElevation(proxob, fpProxyTime, LA, FP, xdir, xdist, forward)
        writeCurvePoint(ipo, fpRealTime, fpLocation)
 
    writeCurvePoint(ipo, startframe+framespan+MSD, destination)
    return (startframe+framespan, destination)
 
def hold(ipo, location, startframe, framespan):
    # ipo - what ipo to write points to                 # location - the position (3Dpoint) to hold at
    # startframe - the first frame in the hold sequence # framespan - total number of frames to hold
    writeCurvePoint(ipo, startframe+MSD, location)
    writeCurvePoint(ipo, startframe+framespan, location)
    return (startframe+framespan, location)
 
def recalculator(assignedTargets, targ1, targ2, basetarg):
    # rewrites some globals based on the current arrangement of the empties:
    loc1 = targ1.getLocation()
    loc2 = targ2.getLocation()
    loc3 = basetarg.getLocation()
    # HEEL_SEPARATION:
    if assignedTargets=='heels':
        print 'Default heel empties found. Recalculating:'
        global HS
        HS = dist3(loc1, loc2)
        print 'HEEL_SEPARATION set to',HS
    if assignedTargets=='flats':
        print 'Default foot look-at targets found. Reusing.'
        global HEEL_TO_FLAT_DISTANCE
        HEEL_TO_FLAT_DISTANCE = dist3(loc2, loc3)
        print 'HEEL_TO_FLAT_DISTANCE set to', HEEL_TO_FLAT_DISTANCE
    if assignedTargets=='tlats':
        print 'Default toe look-at targets found. Reusing.'
        global FLAT_TO_TLAT_DISTANCE
        FLAT_TO_TLAT_DISTANCE = dist3(loc2, loc3)
        print 'FLAT_TO_TLAT_DISTANCE set to',FLAT_TO_TLAT_DISTANCE
 
 
def doIt(forwardOffset, addCenter, whatsUp, firstName, secondName):
    print
    print 'Currently processing:',whatsUp
    # Start building the IPO for the right foot:
    ffootipo = makeIPO('rfoot', 'Linear', 'Constant')
    cpf = currentProxyFrame = FF
 
    # make first step (only half as far as the others):
    ffootloc = getOffset(proxy, cpf, 1, HS/2, forwardOffset)
    ffootframe = cpf
    targetloc = getOffset(proxy, cpf+MT, 1, HS/2, forwardOffset)
    ffootframe, ffootloc = move(ffootipo, ffootloc, targetloc, ffootframe, MT/2,proxy, 1, HS/2, forwardOffset)
    ffootframe, ffootloc = hold(ffootipo, ffootloc, ffootframe, LT)
 
    # now make the rest of the steps (full length):
    while True:
        cpf += CT
        targetloc = getOffset(proxy, cpf+MT, 1, HS/2, forwardOffset)
        ffootframe, ffootloc = move(ffootipo, ffootloc, targetloc, ffootframe, MT,proxy, 1, HS/2, forwardOffset)
        ffootframe, ffootloc = hold(ffootipo, ffootloc, ffootframe, LT)
        if cpf>LF:
            break
 
    # Then we'll build the IPO for the left foot:
    sfootipo = makeIPO('lfoot', 'Linear', 'Constant')
    cpf = currentProxyFrame = FF
 
    # this one starts in hold-mode (waits for right foot to finish)
    sfootloc = getOffset(proxy, cpf, -1, HS/2, forwardOffset)
    sfootframe = cpf
    sfootframe, sfootloc = hold(sfootipo, sfootloc, cpf, MT/2)
 
    while True:
        cpf += CT
        targetloc = getOffset(proxy, cpf, -1, HS/2, forwardOffset)
        sfootframe, sfootloc = move(sfootipo, sfootloc, targetloc, sfootframe, MT,proxy, -1, HS/2, forwardOffset)
        sfootframe, sfootloc = hold(sfootipo, sfootloc, sfootframe, LT)
        if cpf>LF:
            break
 
    if addCenter:
        # And to finish it off, let's put something in the middle of this:
        # This will simply add a third target floating above the proxy.
        # It will respect the specified lift axis, hence useful as parent for an armature
        ctargetipo = makeIPO('center', 'Linear', 'Constant')
        for cframe in range(FF, LF):
            targetloc = getLiftAxisOffset(proxy, cframe, CTDLA, CTD)
            writeCurvePoint(ctargetipo, cframe, targetloc)
 
    # Finished. Add or reuse empties and link them to their respective IPOblocks.
    leftikt = TryGetObject(firstName)
    leftnew = False
    if leftikt==None:
        leftikt = Object.New('Empty')
        leftnew = True
 
    rightikt = TryGetObject(secondName)
    rightnew = False
    if rightikt==None:
        rightikt = Object.New('Empty')
        rightnew = True
    leftikt.name = firstName
    rightikt.name = secondName
    print 'Targets',leftikt,rightikt
    if addCenter:
        centertarget = TryGetObject(TARGET_CENTRE)
        centernew = False
        if centertarget==None:
            centertarget = Object.New('Empty')
            centernew = True
        centertarget.name = TARGET_CENTRE
        print 'Centertarget',centertarget
        centertarget.Layer = Layer
        if centernew: 
			scene.link(centertarget)
 
	    #MDR: 'SetIPO' was 'link'...
        centertarget.setIpo(ctargetipo)
    leftikt.Layer = Layer
    rightikt.Layer = Layer
    if leftnew: 
		scene.link(leftikt)
    if rightnew: 
		scene.link(rightikt)
 
	#MDR: Ditto... 'setIpo' was 'link'...
    leftikt.setIpo(sfootipo)
    rightikt.setIpo(ffootipo)
    print whatsUp,'IPO:s',sfootipo,ffootipo
    print '---------------------------------------------------------'
    sys.stdout.flush()
 
 
 
#########################################
# if everything's OK, let's get to work #
#########################################
if status=='OK':
    currentUserFrame = scene.getRenderingContext().currentFrame()
 
    # grab any walkomat empties left in the scene:
    oldleftheel =TryGetObject(HEEL_LEFT)
    oldrightheel =TryGetObject(HEEL_RIGHT)
 
    oldleftflat =TryGetObject(FLAT_LEFT)
    oldrightflat =TryGetObject(FLAT_RIGHT)
 
    oldlefttlat =TryGetObject(TLAT_LEFT)
    oldrighttlat=TryGetObject(TLAT_RIGHT)
 
    emptyipo = makeIPO('emptydummy', 'Linear', 'Constant')
 
    # recalculate if there were any such empties:
    if oldleftheel!=None and oldrightheel!=None:
        # assign an empty IPO first to clear any anim:
        # why isn't there some 'unlink' function somewhere???
        #
        # MDR: These 'setIpo' calls were 'link' ....
        #
        oldleftheel.setIpo(emptyipo)
        oldrightheel.setIpo(emptyipo)
        recalculator('heels', oldleftheel, oldrightheel, oldrightheel)
 
    if oldleftflat!=None and oldrightflat!=None:
        oldleftflat.setIpo(emptyipo)
        oldrightflat.setIpo(emptyipo)
        recalculator('flats', oldleftflat, oldrightflat, oldrightheel)
 
    if oldlefttlat!=None and oldrighttlat!=None:
        oldlefttlat.setIpo(emptyipo)
        oldrighttlat.setIpo(emptyipo)
        recalculator('tlats', oldlefttlat, oldrighttlat, oldrightflat)
 
    # first pass, heel targets:
    doIt(0, 1, 'Heel targets', HEEL_LEFT, HEEL_RIGHT)
 
    #second pass, foot look-at targets:
    LP = FLATLP
    MP = FLATMP
    FP = FLATFP
    doIt(HEEL_TO_FLAT_DISTANCE, 0, 'Foot look-at targets', FLAT_LEFT, FLAT_RIGHT)
 
    #third pass, toe look-at targets:
    LP = TLATLP
    MP = TLATMP
    FP = TLATFP
    doIt(HEEL_TO_FLAT_DISTANCE+FLAT_TO_TLAT_DISTANCE, 0, 'Toe look-at targets', TLAT_LEFT, TLAT_RIGHT)
 
    # At last, as a friendly gesture, restore the frame to whatever the user
    # was looking at before running the script, and refresh the screens:  
    scene.getRenderingContext().currentFrame(currentUserFrame)
    Window.RedrawAll()
    print 'Processing completed.'
    print 'Thank you for using Walk-O-Matic :D'
    sys.stdout.flush()
 
 
###################################################
# if things are not right, print some dying words:#
###################################################
if status!='OK':
    print ''
    print 'Walk-o-matic is sadly forced to report that'
    print 'it could not go to work properly.'
    print 'Cause of termination: ',status
    print 'Please consult the documentation regarding proper use.'
    sys.stdout.flush()