Here are some concise steps to downloading, editing, and building the source of Micheal Comet’s poseDeformer yourself.  I’m not supplying the link to the source but you should do a quick search to find it.  If you weren’t aware of this awesome plugin dig in to figure out what it does by reading all about it and actually look into the code!  There are also download links out there that have the plugin completely compiled for you on Windows up till 2014.  To really learn, try building it from just the source and then undo from last to first the steps to setup the environment to see what happens when a project fails and actually read the debug output to try and make the connections yourself.

Windows 7 SDK:

1. Download and install the Windows Software Development Kit version 7.1. Visual C++ 2010 Express does not include a 64 bit compiler, but the SDK does. A link to the SDK:http://msdn.microsoft.com/en-us/windowsserver/bb980924.aspx

 

Maze mas grande, por favor!

un maze mas pequeno por favor!

I made a command line file for use in the terminal and moved the code to a mazeLib.py. Why? Now I can type the command

minegenerator

in a terminal and build the maze like that or I can build and improve upon the Maze object that lives in mazeLib and debug it from an interactive terminal! I’m on my laptop and ssh’d into my pi so I needed a better debugging setup.

Create the two files below, chdir to /home/pi/mcpi/api/python/mcpi. You need to run code from here to work automatically. IMPORTANT, chmod the mazegenerator file you create to be executable by doing

chmod 777 mazegenerator

The two files that need to go in /home/pi/mcpi/api/python/mcpi :

mazegenerator (note: do not use a file extension)

#! /usr/bin/python
# Commandline maze generator for Minecraft Pi edition.
# @author: Jonas Avrin cghijinks@gmail.com

import sys
import traceback
import mazeLib

def main():
    '''Create a maze instance.'''
    m = mazeLib.Maze(sizex=10, sizey=10, max_wall_len=1, verbose=True)
    m.clear()
    m.initMaze()
    m.generate()

if __name__ == '__main__':
    try:
        result = main()
    except KeyboardInterrupt:
        print "Bye"
        sys.exit(1)
    if result:
        sys.exit(0)
    elif '--debug' in sys.argv:
        print traceback.sys.exc_info()
    else:
        sys.exit(1)

mineLib.py

'''
Created on Feb 18, 2013
@originalAuthor: Dave Finch
@author: Jonas Avrin cghijinks@gmail.com
'''
import minecraft
import block
import random
from random import randint as rand

class Maze(object):
    ''''''
    def __init__(self, **kwargs):
        self.verbose = kwargs.setdefault('verbose', False)
        # Connect to minecraft  
        self.mc = self.connect()
        self.maze = []
        self.spl = []

        # Define the X and Y size of the maze including the outer walls.
        self.sizex = kwargs.get('sizex', None)
        self.sizey = kwargs.get('sizey', None)
        self.dimms = ()
        if self.sizex and self.sizey:
            self.dimms = (self.sizex, self.sizey)
        else:
            self.sizex = kwargs.setdefault('sizex', 21)
            self.sizey = kwargs.setdefault('sizey', 21)
        if self.verbose:
            print '# MAZE DIMMS #\n' \
                + 'sizex: %d sizey: %d:' % (self.sizex, self.sizey)

        # Set maximum length of wall
        self.max_wall_len = kwargs.setdefault('max_wall_len', 1)
        # Find position of player and set base of maze 3 blocks lower.
        self.ppos = self.mc.player.getPos()
        self.ppos.y -= 3

    @property
    def dimms(self):
        return self.sizex, self.sizey

    @dimms.setter
    def dimms(self, val):
        if not isinstance(val, tuple):
            raise TypeError('Dimensions value type must be a tuple(x, y)')
        for v in val:
            if not self.isodd(v):
                self.sizex, self.sizey = [v + 1 for v in val]
            else:
                self.sizex, self.sizey = [v for v in val]

    def isodd(self, num):
            return num & 1 and True or False

    def create(self):
        # Create an empty maze.
        self.clear()
        self.initMaze()

    @staticmethod
    def connect():
        # Connect to Minecraft.
        try:
            mc = minecraft.Minecraft.create()
            return mc
        except:
            raise RuntimeError('Minecraft unavailable.')

    def clear(self):
        # Clear an area for the maze.
        for x in xrange(0, self.sizex - 1):
            for z in xrange(self.sizey - 1):
                self.mc.setBlock(self.ppos.x + x, self.ppos.y, self.ppos.z + z,
                                 block.STONE)
                for y in xrange(1, 6):
                    self.mc.setBlock(self.ppos.x + x, self.ppos.y + y,
                                     self.ppos.z + z, block.AIR)

    # Create a function to initialize the maze.
    def initMaze(self):
        # print player position
        if self.verbose:
            print 'player pos: %r' % self.ppos

        # Create a 2 dimensional array.
        self.maze = [[0] * self.sizey for x in xrange(self.sizex)]

        # print the maze
        if self.verbose:
            colsize = 0
            for m in self.maze:
                print ''.join(('%-*s' % (colsize + 3, i) for i in m))

        # Create four walls around the maze.
        # 1=wall, 0=walkway.
        for x in xrange(0, self.sizex):
            self.maze[x][0] = self.maze[x][self.sizey - 1] = 1
            self.makeWall(self.ppos.x + x, self.ppos.z + 0)
            self.makeWall(self.ppos.x + x, self.ppos.z + self.sizey - 1)
        for y in xrange(0, self.sizey):
            self.maze[0][y] = self.maze[self.sizex - 1][y] = 1
            self.makeWall(self.ppos.x, self.ppos.z + y)
            self.makeWall(self.ppos.x + self.sizex - 1, self.ppos.z + y)

        # Make every other cell a starting point.
        # 2=starting point.
        # Also create a list of these points to speed up the main loop.
        for y in xrange(2, self.sizey - 1, 2):
            for x in xrange(2, self.sizex - 2, 2):
                self.maze[x][y] = 2
                self.spl.append((x, y))

        # print the initialized maze
        if self.verbose:
            colsize = 0
            print 'maze initialized: \n'
            for m in self.maze:
                print ''.join(('%-*s' % (colsize + 3, i) for i in m))

            print '\n', 'rand spl: %r' % self.spl

        # Shuffle the list of points and we can choose a random point by
        # simply "popping" it off the list.
        random.shuffle(self.spl)
        if self.verbose:
            print 'rand spl: %r' % self.spl

    # Create a function for picking a random direction.
    def randDir(self):
        r = rand(0, 3)
        # Up.
        if r == 0:
            rv = (0, -1)
        # Down.
        if r == 1:
            rv = (0, 1)
        # Left.
        if r == 2:
            rv = (-1, 0)
        # Right.
        if r == 3:
            rv = (1, 0)
        return rv

    def generate(self):
        # Loop until we have no more starting points (2's in the empty maze)
        while filter(lambda x: 2 in x, self.maze):
            # Get the X and Y values of the first point in our randomized list.
            rx = self.spl[0][0]
            ry = self.spl[0][1]
            # Pop the first entry in the list, this deletes it,
            # the rest move down.
            self.spl.pop(0)
            # Check to see if our chosen point is still a valid starting point.
            ud = False
            if self.maze[rx][ry] == 2:
                ud = True
                # Pick a random wall length up to the maximum.
                rc = rand(0, self.max_wall_len)
                # Pick a random direction.
                rd = self.randDir()
                fc = rd
                loop = True
                while loop:
                    # Look in each direction, if the current wall being built
                    # is stuck inside itself start again.
                    if (self.maze[rx][ry - 2] == 3 and
                       self.maze[rx][ry + 2] == 3 and
                       self.maze[rx - 2][ry] == 3 and
                       self.maze[rx + 2][ry] == 3):
                        #
                        # Code to clear maze area required
                        #
                        self.initMaze(self.sizex, self.sizey)
                        break
                    # Look ahead to see if we're okay to go in this direction.
                    cx = rx + (rd[0] * 2)
                    cy = ry + (rd[1] * 2)
                    nc = self.maze[cx][cy]
                    if nc != 3:
                        for i in xrange(0, 2):
                            self.maze[rx][ry] = 3
                            self.makeWall(self.ppos.x + rx, self.ppos.z + ry)
                            rx += rd[0]
                            ry += rd[1]
                    # .....if not choose another direction.
                    else:
                        rd = self.randDir()
                    # If we hit an existing wall break out of the loop.
                    if nc == 1:
                        loop = False
                    # Update our wall length counter.
                    # When this hits zero pick another direction.
                    # This also makes sure the new direction
                    # isn't the same as the current one.
                    rc -= 1
                    if rc <= 0:                         rc = rand(0, self.max_wall_len)                         dd = rd                         de = (fc[0] * -1, fc[1] * -1)                         while dd == rd or rd == de:                             rd = self.randDir()             # The latest wall has been built so             # change all 3's (new wall) to 1's (existing wall)             if ud:                 for x in xrange(0, self.sizex):                     for y in xrange(0, self.sizey):                         if self.maze[x][y] == 3:                             self.maze[x][y] = 1     def makeWall(self, x, z):         self.mc.setBlock(x, self.ppos.y, z, block.STONE)         self.mc.setBlock(x, self.ppos.y + 1, z, block.STONE)         self.mc.setBlock(x, self.ppos.y + 2, z, block.STONE) 

I tried to make a couple improvements by adding in some parameters to control the width, height, max wall size, and turning verbose on and off. Here’s an example of what you can do: In the /home/pi/mcpi/api/python/mcpi directory launch python by typing python and just look at my terminal below to get an idea.

pi@raspberrypi ~/mcpi/api/python/mcpi $ python Python 2.7.3 (default, Jan 13 2013, 11:20:46) [GCC 4.6.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import mazeLib
>>> m=mazeLib.Maze(sizex=10, sizey=10, max_wall_len=1)
>>> m.dimms
(11, 11)
>>> m.create()
>>> m.verbose = True
>>> m.create()
player pos: Vec3(9.91611,0.99797,36.0579)
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
maze initialized:

1  1  1  1  1  1  1  1  1  1  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  1  1  1  1  1  1  1  1  1  1

rand spl: [(2, 6), (8, 2), (6, 2), (2, 8), (6, 4), (8, 4), (8, 6), (4, 4), (2, 2), (6, 8), (4, 8), (6, 6), (8, 8), (4, 6), (2, 4), (4, 2), (2, 2), (4, 2), (6, 2), (8, 2), (2, 4), (4, 4), (6, 4), (8, 4), (2, 6), (4, 6), (6, 6), (8, 6), (2, 8), (4, 8), (6, 8), (8, 8)]
rand spl: [(8, 4), (8, 2), (4, 4), (4, 2), (8, 2), (6, 4), (4, 8), (2, 8), (2, 2), (4, 8), (4, 6), (2, 8), (4, 2), (6, 6), (2, 6), (8, 4), (8, 6), (4, 4), (8, 8), (6, 2), (6, 8), (2, 4), (6, 6), (8, 6), (2, 6), (6, 4), (6, 2), (2, 4), (2, 2), (6, 8), (4, 6), (8, 8)]
>>> m.generate()

Further Explanation:

• Instance of Maze is created with some custom sizing. You can call it with no arguments and it still works with some built in defaults.

>>> m=mazeLib.Maze(sizex=10, sizey=10, max_wall_len=1)

• The Maze object has a computed attribute called dimms, short for dimensions

>>> m.dimms

• Change the dimms attribute by setting it with another tuple or query it

>>> m.dimms
(11, 11)
m.dimms = (20, 20)
>>> m.dimms
(21, 21)

Q: Why is this spitting out 21 instead of 20?

A: The computed attribute checks to see if the number given is even and spits out an odd number. Quick explanation is that it makes it cleaner to do some computations with other functions to actually generate the maze and may help later when extending the object, I’m not sure on that part yet.

• This is a method that can be called that just makes it easier to create the maze by combining some of the functions that do the actual building. It initializes it but doesn’t do the generating algorithm to actually fill in the maze.

>>> m.create()

• Turn verbose on/off interactively for debugging purposes.

>>> m.verbose = True

• The create method is being called with verbose on. Notice, the formatted printing to better visualize what’s happening with the 2d array.

>>> m.create()
player pos: Vec3(9.91611,0.99797,36.0579)
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
maze initialized:

1  1  1  1  1  1  1  1  1  1  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  0  2  0  2  0  2  0  2  0  1
1  0  0  0  0  0  0  0  0  0  1
1  1  1  1  1  1  1  1  1  1  1

rand spl: [(2, 6), (8, 2), (6, 2), (2, 8), (6, 4), (8, 4), (8, 6), (4, 4), (2, 2), (6, 8), (4, 8), (6, 6), (8, 8), (4, 6), (2, 4), (4, 2), (2, 2), (4, 2), (6, 2), (8, 2), (2, 4), (4, 4), (6, 4), (8, 4), (2, 6), (4, 6), (6, 6), (8, 6), (2, 8), (4, 8), (6, 8), (8, 8)]
rand spl: [(8, 4), (8, 2), (4, 4), (4, 2), (8, 2), (6, 4), (4, 8), (2, 8), (2, 2), (4, 8), (4, 6), (2, 8), (4, 2), (6, 6), (2, 6), (8, 4), (8, 6), (4, 4), (8, 8), (6, 2), (6, 8), (2, 4), (6, 6), (8, 6), (2, 6), (6, 4), (6, 2), (2, 4), (2, 2), (6, 8), (4, 6), (8, 8)]

• Turn verbose back off:

>>> m.verbose = False

• Generate the maze interior (run the algorithm to make the maze).

>>> m.generate()

That’s it! I hope that explains what I did and hopefully it looks a bit cleaner and gives you some alternatives to how you can run scripts in minecraft. I am a bit perplexed as to how thrown together some of the scripts are out there, have a look at PEP8 people! It sounds nit-picky but one of the most important ideas Python was written with is the idea of legible code. That’s not to say the original wasn’t legible, now it’s just more legible!  I know, I know, I’m asking too much of the internets.

Have fun debugging and extending the maze! I know I will.
I was having a look at some other maze algorithms like random walk as alternative methods. A 3D maze would be outstanding as well!

Some other experiments:

minecraftPi digital clock

Gettin’ down with some minesweeper.

 

The Setup

• Windows 7 PC running Cygwin with XWin
• RaspberryPi running Raspbian — Debian Wheezy for RPi
• Arduino powered with an old Linksys modem DC adaptor
• Additional software: ssh, sftp, winSCP, Processing, Arduino, VICE
• All software is free and open-source
• All hardware is open-source and very cheap or salvaged!

RaspberryPi with Arduino, 2 Hearts beating in just one LED.

Side view

RPi with Arduino making woopie on a breadboard

First Raspi met my LG HDTV and had an all too brief tryst because it had eyes for the Arduino and to be independent.  Unfortunately, she lost her head but she now is mated with her one true love at last!  She loves Arduino because he listens and is receptive but also can be independent and detach and do things all on his own.  Raspi also percieves his understated minimal personality and looks make him all the more dashing and handsome, along with his deep Italian accent.  He doesn’t care that she doesn’t have a head because he also is without a head.

I got inspiration for that little vignette from a post a French blogger wrote: Francois http://raspberry-python.blogspot.com, Links are down below.

Break it down, yeah

Alright, all kidding aside, I’m really happy I had a little time to put this together finally.  Running a headless RPi was the first goal which was easily achievable with the latest Wheezy distro and ssh.  The configuration of the RPi was a breeze and the capability of ssh to always be turned on while booting of the device was a cinch.  Also, for administering and file transfer, some people out there rely on PuTTY and WinSCP a lot.  I tend to want to keep it simple and just use Cygwin terminal.

The benefit of operating in headless mode on the RPi is that the availability of the TV is no longer an issue.  I live in a small apartment and don’t have the luxury of having multiple TVs or monitors.  I can sit along side the wifey and play with the RPi and Arduino from my laptop while we both watch Netflix or Hulu on the PS3.

I can for instance play with Commodore 64 emulator from my wireless laptop on the couch or in the sanctuary of the bedroom.  VICE is the C64 emulator which comes included in the latest Wheezy distro packages and it was shocking how easy it was to install and get a game running.  There are some complicated setup processes online that took a while for me to read through and figure out really what is the simplest way but it really was simple after I distilled all of that information.

Running headless isn’t a completely awesome experience mind you if you are running some complicated visual tasks.  It is great for administering the Pi and for the sheer joy of being able to forward the display to my Windows machine.  For working on Arduino I can sacrifice a bit of time for the convenience of doing it from the comfort of just about anywhere!  Another beauty is that Arduino can separate and become independent of Pi after the code is compiled and uploaded, FUN!

What’s next

I can’t wait for Minecraft RPi edition to be out!  Being able to code along side of Minecraft is going to be a wonderful learning experience, not to mention I won’t have to spend hours and hours building stages by hand if I don’t want to.

Also, getting OpenVPN to work with RPi would be a grand achievement.  I had it on an old computer acting as my “always on” server in the attic, but sadly I had to abandon that idea because of the unpredictability of climate control up there.  Recently, water shorted out an extension in the only ceiling power outlet causing it to explode and melt the plug!  Thankfully, the system was not turned on and the plug was only powering a light bulb.

If anyone wants I will do a video of exactly what I did to set it all up but you can get all the information from these sources and figure it out yourself too.

Those mini arcade cabinets I’m seeing are quite attractive too, never mind their impracticality.  Of course Python power usage and PyGame are essential to get started with on the Pi.

Sources

• OpenVPN - Tutorial on how to get OpenVPN working, still need to work out kinks
• RPi configuration - Getting up and running with the Pi
• Raspbian - General information about the distro
• Raspbian faq - needed to set up proper apt sources.list, installations won’t work otherwise
• RPi Quick Start Guide - Start here for RPi
• Elinux.org RPi Hub - Central source of information during or after setting up the Pi
• Elinux.org RPi Tutorials - Good place to start learning what to do with RPi
• Minecraft Pi Edition - OMG!  I can wait for this.
• Getting Started: Arduino on Linux - Get started with Arduino on the Pi
• Cygwin: X faq - General troubleshooting X11 problems
• Cygwin: Troubleshoot display forwarding - Comes in handy when you can’t figure out why display isn’t forwarding correctly to your ssh client — in my case an Apple laptop with Win7 x64 and Cygwin.
• Framboise a la mode arduino - Installing Processing and Arduino on Wheezy
• RPi VICE C64 Emulator - How to install VICE on RPi, just ignore that it is running on virtual box and setup your apt sources.list with the link above.
• Mojang – Makers of Minecraft
• RPi Mini Arcade Cabinet!

 

Felix Baumgartner Red Bull Stratos Space Jump Oct 14 2012

Picking up where we left off in Phase I, the following simple environment variables were created on Windows using a .bat script:

PYTHONPATH
MAYA_SCRIPT_PATH
MAYA_PLUGIN_PATH
XBMLANGPATH
PATH

The significance of these variables are briefly outlined in the previous post, but most of the time they are the most essential paths to hook tool libraries into Maya.  Remember this is going off the main idea or maxim outlined earlier in Phase I, we are concerned with expanding Maya’s default libraries with our own which live externally and independently from the installation directory.

The purpose for other paths that are setup in the config script are a little obscured but will be more apparent in subsequent posts including this one.  Take a look at the ROOT paths that were setup.  The main idea is to set up the base directories and create variables out of them to then append only the most necessary child directories relative to the ROOT dirs.  This allows for flexibility and the changing of the fewest variables possible when libraries change location on the system.

It is important to organize a directory structure that makes sense for you production that lives under these ROOT dirs and remains constant.  So choose carefully how you wish to organize libraries not only for the sake of consistency, but so that editing the config script is kept simple.  After trial and error, you’ll figure out what best suits your production but if you want an example, use this, as it has worked very well for me:

• myMayaLib-01

1. bin
2. icons
3. mel
4. plug-ins
5. python

• myMayaLib-02

1. bin
2. icons
3. mel
4. plug-ins
5. python
6. startup

The first example is meant to be a basic structure for a lib that supports mel, python and plug-ins.  The second adds the startup directory where startup userSetup.mel and or userSetup.py files can exists.  A little easter egg here: You can use multiple userSetup.mel and .py files that live in child folders to initialize tools upon startup and if downloaded script packages have a userSetup then those can be used too.  This isn’t typical, but it is possible.  As an example, Red9 employs a userSetup to initialize it’s tools.  If this script is in the search path during startup Maya will use it to initialize the Red9 tools suite the way the author intended.  Further customization is available, but I’ll leave it at that, just food for thought.

That’s it for now, it’s a short piece, but future posts will continue adding value to this subject by fleshing out subsequent Maya configuration phases, throwing in little tidbits on further advancement of Maya customization.  By the end, at least there will be somewhere on the ‘net where people can find some useful information about this.

 

How do you tame the beast that is your ever growing collection of mel, cpp/python plug-ins, and python scripts?

Curate a library of cross-platform, multi-language extensions!

Teach yourself how to setup a proper library of Maya tools by following the steps outlined here. This is by no means the only way to do it. [edit: This is strictly for learning purposes and not intended for production use, but by all means apply what you learn to your specific production needs at your discretion!] It can get as sophisticated as time permits and as your production demands. To put it simply, this is a great starting place for people wanting to learn some of the basics of how to manipulate your Maya environment. The techniques described are simple, however this isn’t a Maya beginner task so I assume the reader knows a bit about scripting, how to use a shell or command line, and other Maya internals of course. I am willing to break it down in further posts of course. There is a lot of information to go over so this topic will be have to be continued in a series of posts.

Surfers Dane Gudauskas, Alex Parker and Keith Malloy normally carve up the golden beaches of sunny California but made the trip to the Arctic, where temperatures as low as just 2-3C, after hearing about the smooth waves.

The Scripting Environment Simplified

The maxim:  Portability and Modularity are paramount – Maximize efficiency and time spent working on tools (the fun artistic stuff) and to iterate, iterate, iterate.  See altdevblogaday’s post on iteration to catch my meaning.

Environment Configuration

• Set a few key environment variables using a config script, in this case windows batch file.  One root location for a Maya extensions repository. Starts Maya in batch, mayapy, prompt, or UI mode.
• Allow freedom to change physical locations, and from linux to windows, at any time with little setup time.  It’s as simple as setting the root variable in the config script.
• .environment file and/or [maya][startupVer]_[config]_[x64].bat

Hook into Maya

• userSetup .mel and .py, the only script file(s) you need to use to extend Maya with your libraries.
• Python – ‘batteries included’ os modules for library management
• Python – cross-platform, just works without additional scripting.
• Mel – find environment variables from mel to generate script search paths.
• Mel – is not as cross-platform friendly.  Different system calls on different platforms, but the rest just works.

Integration and Expansion

• Use downloaded custom tools along side of your tools and work tools and store them all under one root, possibly shared, directory.
• Development is continual process independent of location.
• Personal SVN – versioning and access of repository from file system or the cloud.
• Symlinks and Link Shell Extension to help integrate into any system with little worry about syncing on different file systems, and problems/pitfalls that go along with using them.

Eclipse/External IDE, Remote Debugging

• Eclipse – A great cross platform IDE with capabilities of communication with Maya remotely, and I know of one big studio that uses it.
• Eclipse – Can be tricky to set up i.e. auto-complete, intellisense, etc. Luckily there is the internet!
• Python – The necessity to learn first how Python runs modules.
• Guides on internet are more prevalent and more professionals are adopting.
• Eclipse – Has built-in and extendable SVN tools for syncing with different users or just backing up to a local repository.
• Eclipse – Even has local history, so going back to a version of a script from a couple of days ago super easy.

Benefits Restated

• Feel savvy and sophisticated.
• Knowing how Maya startup works makes scripts and plug-ins more portable even working along side sophisticated Maya environments without fear of corruption of network environment.
• Migrate Maya versions much more easily.  Run multiple Maya instances.  Upgrade tools quicker with each successive version.

Future Plans

• Python Wing IDE I’m no longer supporting licensed IDE’s
• Breakdown of library into packs based on artistic discipline or task. Why? Why do we do anything, to cut down on cost! It gets expensive and inefficient in multiple ways to run Maya with tons of additions.
• To expand on the previous point, extend one set of environment startup settings into separate configuration settings for different Maya versions, modes, or projects.

Maya DOS Cmd Shell Configuration Script

Step 1: In general terms, initialize the environment. There are more than several cocktails to use when doing this, but the simplest is a shell script. Other more sophisticated ways might entail creating configurations using Python, Perl, or other scripting language of choice. Additionally, these scripts can act in concert with wrapping the Maya executable, but here the basics will get it started.

The process I will use is employing the windows .bat file. Here is an example to startup Maya in UI mode, which is probably what most people are interested in. Don’t worry if it seems long, I will break it down piece by piece later on. It’s the same script repeated, but the difference is Maya is being executed in different modes.

@echo on
c:
cd \
rem \\-----Lib Root
set ROOT=B:\Portable_Library\dev
rem \\-----Scripting root directory containing startup configs
set JAROOT=%ROOT%\jaMayaLib-dev_0
rem \\-----Mel scripts (supports multiple paths to external libs)
set MELROOT=%JAROOT%\mel;%ROOT%\jaTools-dev_0\mel
rem \\-----Python scripts (supports multiple paths to external libs)
set PYROOT=%JAROOT%\python\jaMayaLib;%ROOT%\jaTools-dev_0\python;%ROOT%\cgmTools-dev_0\python;%ROOT%\pymel-1.0.3
rem \\-----Plug-ins
set PLUGINS=%JAROOT%\plug-ins
rem \\-----Icons
set ICONS=%JAROOT%\icons
rem \\-----Startup configs
set STARTUPROOT=%JAROOT%\startup\%COMPUTERNAME%
rem \\-----IDE path
set ECLIPSE=C:\Program Files\eclipse
rem \\-----Maya installation
set MAYA=C:\Program Files\Autodesk\Maya2012
rem \\-----Maya executable
set MAYABIN=%MAYA%\bin
rem \\-----Add userSetup.mel and jaUtils paths to usersetup paths
set MAYA_SCRIPT_PATH=%STARTUPROOT%;%MELROOT%
rem \\-----Additional Maya Plug-ins
set PLUGINS=%PLUGINS%;%MAYA%/devkit/plug-ins/scripted
rem \\-----Put Maya on the PATH
set PATH=%PATH%;%MAYABIN%
rem \\-----userSetup.py and python paths
set PYTHONPATH=%PYTHONPATH%;%STARTUPROOT%;%PYROOT%;%MAYA%\Python\Lib\site-packages;%ECLIPSE%\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc
rem \\-----Startup maya!-----// 
maya

 
Same script essentially but launch maya in BATCH mode (non-interface, non-interactive)
 

@echo on
c:
cd \
rem \\-----Lib Root
set ROOT=B:\Portable_Library\dev
rem \\-----Scripting root directory containing startup configs
set JAROOT=%ROOT%\jaMayaLib-dev_0
rem \\-----Mel scripts (supports multiple paths to external libs)
set MELROOT=%JAROOT%\mel;%ROOT%\jaTools-dev_0\mel
rem \\-----Python scripts (supports multiple paths to external libs)
set PYROOT=%JAROOT%\python\jaMayaLib;%ROOT%\jaTools-dev_0\python;%ROOT%\cgmTools-dev_0\python;%ROOT%\pymel-1.0.3
rem \\-----Plug-ins
set PLUGINS=%JAROOT%\plug-ins
rem \\-----Icons
set ICONS=%JAROOT%\icons
rem \\-----Startup configs
set STARTUPROOT=%JAROOT%\startup\%COMPUTERNAME%
rem \\-----IDE path
set ECLIPSE=C:\Program Files\eclipse
rem \\-----Maya installation
set MAYA=C:\Program Files\Autodesk\Maya2012
rem \\-----Maya executable
set MAYABIN=%MAYA%\bin
rem \\-----Add userSetup.mel and jaUtils paths to usersetup paths
set MAYA_SCRIPT_PATH=%STARTUPROOT%;%MELROOT%
rem \\-----Additional Maya Plug-ins
set PLUGINS=%PLUGINS%;%MAYA%/devkit/plug-ins/scripted
rem \\-----Put Maya on the PATH
set PATH=%PATH%;%MAYABIN%
rem \\-----userSetup.py and python paths
set PYTHONPATH=%PYTHONPATH%;%STARTUPROOT%;%PYROOT%;%MAYA%\Python\Lib\site-packages;%ECLIPSE%\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc
rem \\-----Startup maya!-----// 
maya -prompt

 
Same script essentially but launch maya in BATCH -prompt mode (non-interface, interactive)
 

c:
cd \
rem \\-----Lib Root
set ROOT=B:\Portable_Library\dev
rem \\-----Scripting root directory containing startup configs
set JAROOT=%ROOT%\jaMayaLib-dev_0
rem \\-----Mel scripts (supports multiple paths to external libs)
set MELROOT=%JAROOT%\mel;%ROOT%\jaTools-dev_0\mel
rem \\-----Python scripts (supports multiple paths to external libs)
set PYROOT=%JAROOT%\python\jaMayaLib;%ROOT%\jaTools-dev_0\python;%ROOT%\cgmTools-dev_0\python;%ROOT%\pymel-1.0.3
rem \\-----Plug-ins
set PLUGINS=%JAROOT%\plug-ins
rem \\-----Icons
set ICONS=%JAROOT%\icons
rem \\-----Startup configs
set STARTUPROOT=%JAROOT%\startup\%COMPUTERNAME%
rem \\-----IDE path
set ECLIPSE=C:\Program Files\eclipse
rem \\-----Maya installation
set MAYA=C:\Program Files\Autodesk\Maya2012
rem \\-----Maya executable
set MAYABIN=%MAYA%\bin
rem \\-----Add userSetup.mel and jaUtils paths to usersetup paths
set MAYA_SCRIPT_PATH=%STARTUPROOT%;%MELROOT%
rem \\-----Additional Maya Plug-ins
set PLUGINS=%PLUGINS%;%MAYA%/devkit/plug-ins/scripted
rem \\-----Put Maya on the PATH
set PATH=%PATH%;%MAYABIN%
rem \\-----userSetup.py and python paths
set PYTHONPATH=%PYTHONPATH%;%STARTUPROOT%;%PYROOT%;%MAYA%\Python\Lib\site-packages;%ECLIPSE%\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc
rem \\-----Startup maya!-----// 
mayabatch
pause

 
Same script essentially but launch maya in MAYAPY interactive mode (python)
 

c:
cd \
rem \\-----Lib Root
set ROOT=B:\Portable_Library\dev
rem \\-----Scripting root directory containing startup configs
set JAROOT=%ROOT%\jaMayaLib-dev_0
rem \\-----Mel scripts (supports multiple paths to external libs)
set MELROOT=%JAROOT%\mel;%ROOT%\jaTools-dev_0\mel
rem \\-----Python scripts (supports multiple paths to external libs)
set PYROOT=%JAROOT%\python\jaMayaLib;%ROOT%\jaTools-dev_0\python;%ROOT%\cgmTools-dev_0\python;%ROOT%\pymel-1.0.3
rem \\-----Plug-ins
set PLUGINS=%JAROOT%\plug-ins
rem \\-----Icons
set ICONS=%JAROOT%\icons
rem \\-----Startup configs
set STARTUPROOT=%JAROOT%\startup\%COMPUTERNAME%
rem \\-----IDE path
set ECLIPSE=C:\Program Files\eclipse
rem \\-----Maya installation
set MAYA=C:\Program Files\Autodesk\Maya2012
rem \\-----Maya executable
set MAYABIN=%MAYA%\bin
rem \\-----Add userSetup.mel and jaUtils paths to usersetup paths
set MAYA_SCRIPT_PATH=%STARTUPROOT%;%MELROOT%
rem \\-----Additional Maya Plug-ins
set PLUGINS=%PLUGINS%;%MAYA%/devkit/plug-ins/scripted
rem \\-----Put Maya on the PATH
set PATH=%PATH%;%MAYABIN%
rem \\-----userSetup.py and python paths
set PYTHONPATH=%PYTHONPATH%;%STARTUPROOT%;%PYROOT%;%MAYA%\Python\Lib\site-packages;%ECLIPSE%\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc
rem \\-----set MAYA_LOCATION when running mayapy
set MAYA_LOCATION=%MAYA%
rem \\-----Startup maya!-----//
mayapy

The main Maya environment paths you should be concerned with setting up if you are just starting out are:

PYTHONPATH
MAYA_SCRIPT_PATH
MAYA_PLUGIN_PATH
XBMLANGPATH
PATH

If you don’t know what environment variables are used for or why these variables are significant, take a look at the Maya documentation and search for environment variables to get a better idea.

In Windows shell commands, ‘rem’ at the beginning of a line is a commented line. So everything after ‘rem’ is code that will not be run but acts as a comment or description of what’s happening. Here the layman armed with this knowledge can read through the code and get an idea of what’s happening by just reading the commented lines. In this tutorial of sorts, I will cover the ‘why’ of most things that are being done, the ‘what’ should be clearly outlined in the commented lines.

Briefly speaking, in this code ‘set‘ is being used to set temporary environment variables. Here the use of non-permanent variables is simply to keep the Windows environment cleaner and provide the ability to create multiple versions, or configurations, to initialize Maya. The variables’ significance isn’t readily apparent at this point, but they all are important. Environment variables are widely used to set certain constants in production environments. From these few constant, relatively unchanging variables, we have enough containers of information for Maya to get started and the scripting environment, or libraries, to be initialized.

More on that, the significance of the variables described in the above scripts, and the next step in the outline in a future post! I’ve ran out of beer!

 

Say you have an environment variable named PYROOT with a lis of a few paths where python libs are stored. Use python’s site module to add your lib directories as site directories like this:

import os
import site
PYTHONPATHS = []
if os.environ.has_key('PYROOT'):
	if os.pathsep in os.environ.get('PYROOT'):
		for p in str.split(os.environ.get('PYROOT'), os.pathsep):
			PYTHONPATHS.append(p)
	else:
		PYTHONPATHS.append(os.environ.get('PYROOT'))


if len(PYTHONPATHS):
	for j in PYTHONPATHS:
		site.addsitedir(j)

This quick script works cross-platform using os.pathsep to test for environment variable separators ‘;’ (win) and ‘:’ (linux) and using that to split the PYROOT string variable appending each of the paths to the PYTHONPATHS buffer list. By using the site.addsitedir module, python will treat these directories as normal site-package directories with all the built-in abilities to customize such as sitecustomize module and .pth files. If subdirectories are already organized into packages using __init__.py then they are already ready to be used and imported into Maya right away, or else if the directory has a .py file and no __init__.py just add an empty one.

To add your custom user site-packages directory just append the lines of code or create a new userSetup.py and make sure it is on your PYTHONPATH when you start up, previously explained here, or just put it in any one of the default maya scripts areas.

 

Some fruits of my labors over the past months.  I’ve learned so much and I can’t wait to share more stuff about my experience so far working on this great sequel as a tech anim.

 

It’s been long enough. The intention to get back to blogging, probably the most enriching things that the internet can be used for, is not as easy as it the benefit would lead one to believe. It is often the hardest these sort of things in life that have the greatest benefit that go without being utilized, but that changes now with the mother of all instigators, New Years Day.

What’s the topic of the year that is a continuation and solidification of growing interest in the previous year? What else, the ubiquitous topic across the blog-o-sphere; filtering, utilizing and leveraging the mind-numbingly viral growth of open source hardware and software, DIY, Hacktivism, Public Domain, and Creative Commons information to engage in gratuitous amounts of geekery, life/career hacking.

Expect expositions in 2012 on topics in addition to the aforementioned and the regular posts on 3d animation and tech art ranging in this list of interests:

Linux
C-Shell Scripting
Python
Arduino
Use of hobby as a way of making money
Dynamic DNS
Game Dev
Futurism
Virtual Computing

Hopefully shedding some light on some of the fundamentals will blaze trails for others that are interested to get started in the most noble of activities of the modern era, one that is being affected by movements like SOPA; developing and sharing software and media and artist entrepreneurialism.

 

How I've felt for so long about working in VFX/Anim industry.

My first project

Done!  After a few weeks of back and forth and interviews I finally landed the job of my dreams, well, for the time being.  Blue Sky has always been on the radar as a potential and it’s finally a reality.  It’s everything I could ask for in an employer and more.

Don’t think that it’s going to stop me from being active on my blog though, quite the opposite!  Well, maybe the first month or two starting now there will be a pause, but after that it will increase.  I’m super excited to learn and share knowledge with people and stay really connected and dedicated to innovating personal and industry wide workflows, tech, and of course animation.  Technical animation and tech art to be specific is what I’ll be working on in the coming months, same as usual.

Thanks to everyone that’s been involved in the process of landing this, you know who you are!  I don’t think they know yet what a valuable asset they just acquired but soon they will find out just how serious I am about the work I do and how inspired I can be!