From what I have read, it seems that most people have an ultimate Zen moment with Lisp that makes the universe seem to fall into order (or, so says Eric S. Raymond). My journey with Lisp so far hasn’t been like that. Instead, it has been a number of smaller “Aha!” moments. In fact, I just had one today. Maybe my big Zen moment will come later. I guess I’ll just need to keep learning and see where the Lisp journey takes me.

I had the opportunity to attend SIGGRAPH this year as a representative of MetaPipe. For as fun as it was to meet with representatives of various software and cloud companies, I am happy to be able to get my nose back to the grindstone on MetaPipe. I’m extremely excited about the tech we are working on for the service and I can’t wait to get it to the point where we can start demoing it publicly to get everyone’s feedback. We started a lot of converstaions at SIGGRAPH with various companies that we feel fairly confident will turn into more concrete agreements in the near future.

Houdini has a nice little function in Python in the hou namespace called hscript. You can pass in a string for an hscript command. It passes back out a tuple with stdout and stderr strings. This is dandy, but it would be nice to call hscript commands with (in essence) Python syntax. So I made a little class that does just that.

class HscriptWrapper(object):
    commands = hou.hscript('help')[0]
    commands = frozenset(commands.split())

    def __getattr__(self, attr):
        if attr not in self.commands:
            raise AttributeError('No hscript command by name "%s"' % attr)
        # cache for future calls
        self.__dict__[attr] = rattr = self._command_factory(attr)
        return rattr

    def _command_factory(self, attr):
        def cmd(*args, **kwargs):
            fmt = '{cmd} {flags} {args}'
            hsargs = ' '.join(args)
            hsflags = []
            for k, v in kwargs.items():
                if isinstance(v, bool) and v is True:
                    hsflags.append('-' + k)
                else:
                    hsflags.append('-{0} {1}'.format(k, v))
            hsflags = ' '.join(hsflags)
            hscmd = fmt.format(cmd=attr, flags=hsflags, args=hsargs)
            return hou.hscript(hscmd)
        cmd.__name__ = attr
        cmd.__doc__ = hou.hscript('help {}'.format(attr))[0]
        return cmd

To use it, create an instance of the HscriptWrapper class, then access hscript commands as attributes of the instance. The returned attribute is a callable function that takes positional and keyword arguments.

I am generally pretty sad with the number of free tutorials about Houdini rigging. Thus, I have started a series of them on youtube. They aren’t polished or even really planned out before hand. Really, they are little more than just stream of consciousness, but they have information, which is the important part. If you are interested in certain topics relating to Houdini rigging, post a comment and let me know what you want me to cover next.

Hi y’all. I found this video (UPDATE: previously linked video was an old flash player embed and no longer exists) and it got me to thinking about special effects and how we perceive them. Even though everyone in the studio audience had undoubtedly seen blockbuster films with eye fooling special effects, they went wild for this performance of a rather simple concept. Don’t misunderstand me; what they are doing is extremely difficult. However, something is often more impressive to us when we can understand the effort put into it.