* Added a new primitive: ACOS. It's the arc cosine function.
* Fixed a bug where in generating points in a disc, if the vector to the center of the disc was parallel to the normal, the points would only be generated at the center.
* Added implementations for generating vectors within the remaining domains. Generating a vector within a plane results in an error due to the domain being unbounded.
* Removed the "blob" domain as it has no use outside of generating points, but this effect can be simulated by providing different random distributions to the generation routine. (Not implemented yet)
* Updated the README to reflect changes.

Changed the plane normal vector calculation. Also, got rid of the notion of particle state, and made it so that block parameters are passed through an environment that keeps track of particle state variable to IR variable mappings.

Finish up redoing translate.sml... Most of the compiler infrastructure stuff is done. Some of the utility functions (for intersection tests, etc) need to be fleshed out. I'm also not sure whether or not these changes will create sound IR code, but I guess that's what the checker is for anyway...

Introduced some new semantics to get ready to implement user defined state variables. I think the next step is to introduce a variety of options for generating rendering operations with state variables which will dictate which ones need to be specified in the emitter.

Implement an initial framework for supporting user defined state variables. There is no current interface to adding them to a particle system. In general, user defined state variables will be created by the emitter and will never be eliminated by UVE. Things to do are to add support for them on the CPU side (the GPU implementation should fall out of it), and to define actions in terms of which state variable they act upon. Then we will have a smaller set of core actions anyway.

Removed normalized flag from floating-point versions of vertex attribute buffer
calls and added enable/disable functions to BufferObj (these are redundant with
the GL structure, but it is useful to have all of the needed buffer object calls
in the same place)

Updated emitters to accept float domains with distributions in order to generate points. We use it to create smoke particles somewhat slower than we need to. We could improve upon the effect to add a quadratic filter along with the linear one.

* Changed the domain type to be polymorphic. Added a new range domain which is basically the analog to a box in one dimension. I still haven't been able to figure out how to properly integrate this with the emitter due to the nature of how we deal with creating particles.
* Updated the README
* Hacked the particle size generation to only generate particles in the range [0.5, 1.0] instead of [0.0, 1.0]

Updated the smoke animation to fix a lot of the bugs that I had after working on it from work. Most notably, from the last major fix, the things that are now working are:
- We use all of the textures in the texture list.
- There is proper alpha culling of dead particles in our textured quads.
- All of the various attribute buffers (color, size) are now properly passed to the shaders
- Fiddled with the emitter domain for the smoke so that the particles are moving in a wider arc.
Things that still need to be done:
- Figure out a way to limit the number of particles that are spawned per frame (to less than one)...

Implement a somewhat working version of the smoke animation. There are still a few more kinks that need to be worked out:
- The smoke textures need to be randomized per-particle, right now there is only one texture (the first in the list) that gets used for all particles.
- Need to be able to emit fewer than one particle per frame... This will be a bit trickier.
- There is an artifact where one quad, or perhaps all of the dead quads are being drawn at the emitter position. We may not be handling dead particles properly for the textured quads.
- Need to fiddle a bit with the emitter domain. Right now things are going too straight up. Perhaps an upside-down cone would be better than a cylinder.

Switched program representation to not be a list of blocks. Rather, we reference just one block and use the tree representation when doing our analysis. Hence we now have a much more robust system for error checking, etc. Hopefully this fixes the problem of having inconsistencies between our blocks.

Ugh, for now figure out which variables are which based on a naming convention. There's probably (read: definitely) a better way to do this by tagging each RETURN statement with the state variables that it returns.

Add a check to make sure that the referenced blocks are the same as the blocks in the list. Also, fix the block references after optimizing our program to adhere to the check. This will be useful when we analyze the program for code generation.

Added a new property to blocks: reference count. This new property is used in an optimization where we remove unused blocks from the program, and inline blocks that only have one reference count to reduce the amount of branching that we need to do.

Added a few primitives to handle a bit more lower level vector manipulation in order to expose a few more optimizations that we could perform in preparation for generating code for OpenCL. Most notably, we don't want to be doing things like calculating the dot product of basis vectors.
Also, added a new module for specialized optimizations on primitives which were made possible with the aforementioned newly added vector primitives.

Fix some formatting in the checker. I don't know why it's so hard for me to standardize my editors... Also, repurpose DISCARD to mean killing a particle so that we can possibly make some smarter optimizations. We can track non-state changes by seeing whether or not the particles change between the invocation of a block and leaving it.

Broke out the different optimizations into their own separate modules. The Optimizer now has more control over the order in which the optimizations are run, and the number of times each optimization is run.

Added a newline to our program output so that it looks a lot neater... Also, there was a bug with the way we were handling predicate combinators. We need to save off the continuation, and then handle the then/else statements separately, and finally come together in the end. This way we can prevent code from blowing up unnecessarily.

IR translation now returns a program datatype, which has the emitter block separated from the physics block, and also keeps track of the rendering operation requested. Also, added property fields for variables and blocks in order to track for UVE.

Restructured some of the particles code to better fit the idea that we have for how it's supposed to work. Also, I moved the runtime code for the old psys into the new runtime module. Our example doesn't work properly anymore, since the old particle action system doesn't have a mechanism for specifying branches, so the particles never die.

Implemented some simple optimizations: removing unused variables and constant folding. Also, realized that there's no need for the CONST stmt, since variables are either constants by construction or they get optimized into such.

Moved old particle system implementation into separate files, and updated the new ones to support our new version of particle systems. Unfortunately I don't know whether or not it compiles since we don't have any examples that use this new system.