Flakes is a general purpose nodular programming platform designed for non-programmers, artists, game designers, engineers and bad programmers such as myself. After a long time talking about it, I have something to display. This is not a release yet, but rather an official project announcement.
This is (will be) an add-on and not part of the main Blender distribution.
Flakes is a project name, and may change in the future. Do send me suggestions.
The video has all the info you need, so I won't repeat anything here.
Edit: Forgot that people watching the embedded version won't see vimeo description. Here are the screenshots mentioned in the video.
So, it's not the particle system everyone seems to want, but something a lot broader. I'm not trying to compete with any existing or future node or particle system. This is just my take on what node system should look like. After significant contemplation I've concluded that it is a lot easier to make this from scratch than try to contribute to some existing project. I think I have the right approach and I don't wish to make compromises about it.
Represents a statically typed, functional style programming language.
Very loosely coupled to Blender. Makes it very flexible and easy to implement and modify.
Computation is primarily done with fixed size/shape arrays (for now anyway).
Primarily designed for highly parallel programming.
==== Things to do ====
The following is listing of what I have done and what I will do. I'll update it as I go. It's fairly comprehensive list already, but not exhaustive. I'm mainly dumping these here to give a rough outline for all future development.
Base library. Many of these are already done:
add, subtract, multiply, divide, round, modulo, root, exponent, logarithm, sin, cos, tan
Array operations and accessors (multidimensional):
slice, concatenate, transpose, reshape, broadcast, sum, intersperse, map, map to slice, apply, fold(reduce), intercalate, filter, delimiter split, predicate split, head, tail, init
Linearly interpolated range (aka. Linspace), Perlin noise, random numbers(various distributions), point grid
multiply, inverse, determinant, norms, decompositions
Transform matrix ”primitives”:
rotation around axis, scaling, shearing, translation, direction to matrix
scalar product (dot product), cross product, normalize, matrix multiply, rotate around vector, scalar components to vector (and back), norms
group functions, group recursion, conditionals(if,case,select)
mesh access: vert locations, normals, faces, edges, wide variety of selection methods ; points to mesh ; points to strands ;
Simple group nodes:
Large collection of convenience functions for end users
Mid term ToDo:
better (actual) compiler
code cleanup and release
operator definitions: blender operations that can be added to menus and bound to keyboard shortcuts
generated GUI elements.
memory bridges to Blender particle system and mesh data (remove python bottlenecks)
complex data structures, unbound functions (for partial application), data lenses
disk cache (memory cache already done)
lazy evaluation (faster and saves a ton of memory and memory access)
infinite lazy lists/arrays
more interactivity (is more of none still none? )
Imperative hacks: for- and while-loop, in-place modifications
--It has proven quite bad practice to use these extensively with nodes, but they might be useful for some low level algorithms and for binding imperative libraries.
Long term ToDo:
BGL gui elements
OpenCL optimized for performance (initially it's not)
Eventstream and io system (Functional reactive programming)
Ability to bind arbitrary python libraries: eg. pygame, PyQt/PySide, scipy, django...
True JIT compilation.
Submit lots of patches to pynodes and Blender GUI api
...and frameworks: Ogre, BGE, Torque, webGL/webCL, PyGame
(Just some possibilities. Not going to do them all)
Here are some of the things that I will be using this system for. (To do whenever/if I feel like it (tomorrow or five years from now)). Not in any particular order. These are up for grabs. I'm very likely not going to do anywhere nearly all of them.
modifiers: better solidify, better mirror, slice, lathe, better bend, better path deform
cloth and soft body simulation. Good for skin folds, blubber, webbings and wing folds too.
numerical solvers, integrators, function plotters
Bezier paths and better access library for blender splines (most of the code already exists in polydrive)
larger library for matrix computation
hair simulation (basics done)
polygon hair generator (polydrive – partly done)
geomapper (polydrive – mostly done)
remesher (polydrive – partly done)
ropes/knots (polydrive - mostly done)
rigging tools: better armature, maybe muscle (also make them portable to games)
new primitives: tires, treads, ropes, helix, loft, walls, windows, stairs
raytracer for engineering applications
Possibilities are many and varied.