Open Season 2
Posted by Luke Olson in RealFlow, Work on May 17, 2009
These are images from work I did on Open Season 2 while working with Reel FX in Dallas. Most of the work was done in Maya and RealFlow. There’s a lot of talented artists that worked on the show and it was a great experience. While I was there I worked on integrating RealFlow into their pipeline, training artists, and Python scripts to accelerate the workflow (multithreaded meshing, Qube! submissions, asset synchronization).
Multithreaded Meshing Process Updated
Posted by Luke Olson in Python, RealFlow on February 14, 2009
The new meshing script for RealFlow 4 works with 64-bit Windows and Linux and is now Python 3.0 which is not reverse compatible with Python 2.X (oh noes!). Download the script from Next Limit’s scripting site:
If working on a system that doesn’t already have Python 3.0 or newer it can be downloaded from the Python site:
My contact and directions are in the head of the script. There’s also a video to show how it works on Linux and Windows. The Linux portion of the video also shows how to install Python 3.0 from source since it can be a little tricky for new users (Windows is double click installer, no need to video that). Heads up on the video, I suggest right click to download since its about 40MB.
Summer 2008 Reel
Posted by Luke Olson in RealFlow, Reel on August 28, 2008
In the last year I’ve done some exciting work. Feature film, commercials, and amusement park rides. The first part of the video is some R&D and the second half is renders from projects. Both are MP4 videos with H.264 compression, Quicktime can play them or any other H.264 capable player. Enjoy!
- lukeOlson2008.mp4 (37.8 MB)
- lukeOlson2008_low.mp4 (10.7 MB)
Collision Based Emitter Swap
Posted by Luke Olson in Python, RealFlow on July 18, 2008
Scripting in RealFlow 4 makes many things possible. I see a lot of users looking for a way to change particle behavior based on collision with an object in the scene. This can be done using a event script to move particles from one emitter to another based on collisions. Exclusive links can be setup on the emitters to control the behavior of each fluid. One emitter will be the before collision and one emitter will be after the collision.
When a particle collides with the object its velocity and position are stored, the particle gets removed, and a new particle is born in the other emitter in the same place and velocity as the old particle. See the scene file and script download for an example. Note the speed of zero on the second emitter.
Meshing Script Revisions
Posted by Luke Olson in Python, RealFlow on July 11, 2008
The multithreaded meshing script for RF4 I wrote before solved a problem but created some by itself. Often times when meshing with multiple threads the memory usage would exceed the systems memory and eventually crash or get killed by the user. To prevent that problem the second version will have automatic memory throttling based on the memory and processors in the system (automatically detected). The user can specify reserve memory and processors so the system can be used for other tasks while meshing. Other new features will include progress information, specify license type, command line help, command line flags, and elapsed time overall and per mesh.
Unfortunately due to the increasing complexity of the script, I won’t be writing a Windows port of the script. Depending on where things go with future versions of RealFlow and built in meshing tools, I may add a network daemon that allows automatic meshing between multiple machines on a network. Farm management software can be used to perform this task already, but small shops and freelancers don’t usually have access to farm management software. I’ll post updates and progress made on the new script.
The Mini Cooper
Posted by Luke Olson in RealFlow on May 6, 2008
My final project in school in a sequence of a Mini Cooper. The car is formed from fluid, leaves a trail, and then splashes apart at the end of the sequence. I approached the problem many ways, but relied on some scripting to get the final result. An emitter generates particles in a fixed location in front of the car, and upon collision with the car the particles are transferred to another set of particles. Only the second set of particles are visible in the renders so the fluid appears to come from the surface of the car instead of out in front of the car. See the video below in 720P as a Quicktime file.
Realwave To Particles
Posted by Luke Olson in Python, RealFlow on April 29, 2008
Realwaves have particle layers which allow them to be meshed with other fluids, but the particle layers have some limitations. I made a script that converts faces and/or vertices to particles from a simulated Realwave. Now a “particle layer” can be a post process and not interfere with simulations, and meshes for the Realwave can be generated with multiple threads. Download it below, my contact and instructions are in the script.
- waveParticles.rfs (hosted by Next Limit)
Multithreaded Meshing
Posted by Luke Olson in Python, RealFlow on April 29, 2008
Generating meshes in RealFlow 4 is a single threaded process. Understandably though, from a programming point of view I can imagine this to be very complicated to break into a multithreaded process. So to get that extra bang out of multiple CPU’s and RealFlow I’ve created a script that can utilize all processors in a machine to generate meshes.
There are some scripts out there that already perform this task, but they have some limitations that I didn’t like. The most popular method is to break a frame sequence into a set of frame ranges. For 100 frames and 4 threads, each thread would take 25% of the frames (1-25, 26-50, 51-75, and 76-100). Though if meshes are more complex at the end of the sequence then the work load is not distributed evenly and the last set will take considerably longer than the first three. Instead of being 4 times faster than a single thread, now it’s only 3-2 times faster or worse.
To avoid this bottleneck this script opens an instance of RealFlow without a GUI and meshes a single frame of the frame range and then closes that instance of RealFlow. Then repeats the process for the next frame that isn’t meshed. There can be any number of concurrent threads running, 2, 4, 5, 16, 40, it doesn’t matter. Since the frame sequence isn’t divided before the work begins, the work is distributed evenly as the job processes.
See the screen shots for the script in action. Also download below, currently only for Linux. Directions and contact information are in the script. If you are interested in a Windows port contact me or leave a comment here.
- multiThreadedMeshProcess.py (hosted by Next Limit)
Basement Flood
Posted by Luke Olson in RealFlow on April 29, 2008
I’ve been working on a project to flood a basement in RealFlow. This is the first phase of the project where I’ve setup the objects in the scene and the fluid dynamics. The next step of the project is to setup shaders and lighting for the fluids in Maya. The meshes were generated using a Python script I wrote to take advantage of more than one thread. Any number of threads can be specified and the frames are meshed one at a time in each independent thread. More on that later!
See the animations for the mesh and the particles. Videos are 720P with Quicktime H.264 compression.