* OBJLoader now parses line per line in the same way OBJMTLLoader does.
* No more reusing of the same vertices array.
* Both now create a Object3D when finding a "o" and a Mesh when finding a "g" (or "usemtl").
* I used to like the obj format.

Removed Vector* add() to addVectors() and addSelf() to add(). Same with sub, cross, min, max, lerp... Renamed Matrix* and Quaternion multiply() to multiplyMatrices(), multiplyQuaternions() and multiplySelf() to multiply(). See #2860.
Good thing we have a ton of examples to make sure nothing is broken. The unit tests also helped. However, I suspect I've left something unchanged.

Renamed .multiplyMatrix* to .applyMatrix* and .multiplyQuaternion to .applyQuaternion as suggested by @WestLangley in #2860.

Makes the code so much nicer imho...

Using classic "loader.load( url, callback )" API instead in OBJLoader, STLLoader, VTKLoader.

OBJMTLLoader is still having just the incorrect EventDispatcher API, but there the situation is more complicated.

ColladaLoader: added check for existence of diffuse/emissive properties before Material creation in Shader

ColladaLoader: added correct surface/sampler sid mapping to support surfaces with multiple textures (e.g. color + normals)

Maybe these should be toggleable, they are too slow for larger molecules.

It seems no matter which DOM elements are used for CSS 3D, you can't have more than couple hundreds without starting to hit a performance wall, even on desktop browsers ;S

Added VTK and STL models to scene loader example. Added optional callback parameter to VTKLoader and STLLoader load to be compatible with other loaders.

Work in progress. Not really sure how to best deal with different loaders using different APIs. We should unify them somehow. Still need to handle ColladaLoader, UTF8Loader and OBJMTLLoader, every one of them is different from the others.

Fixed jquery dependency in OBJMTLLoader. Fixed variable redeclaration in OBJLoader. Fixed unreachable code in GeometryExporter warnings.

This Closure compiling of JS files from the examples already starts to be useful ;)

Is not exactly the same beaviour. object.traverse also applied the callback to object.
But I think it's better like this, because now we can do object.traverse( function ( node ) { node.visible = false } ) and it will also take care of the parent. However, if this creates any problem we can revert the behaviour.
I also prefer this behaviour because the code is simpler/cleaner :P

The following examples where broken on mrdoob.github.com and when
viewed through a local python web server. file:// worked.

webgl_loader_collada.html
webgl_loader_collada_keyframe.html
webgl_loader_json_blender.html

Doing this in multiple steps not to confuse git.

This also adds compressed textures support to UTF8v2Loader.

Now with UTF8 + BufferGeometry + DDS we should have quite efficient and GPU friendly asset pipeline. One possible improvement would be using Rich Geldreich's Crunch compression instead of raw DDS for having smaller texture file sizes while downloading: http://code.google.com/p/crunch/

TODO: there seem to be some bug somewhere in our compressed texture pipeline (or in Chrome). I tried Ben's textures converted to DDS and I got boatload of GL warnings :S

Added support for compressed textures to Loader base class. Added compressed textures to JSON loader example.

Also moved "startsWith" and "trim" string shims from OBJMTLLoader into Three.js file and added "endsWith" string shim.

Downside of using compressed textures is that texture.flipY parameter doesn't work, so either textures or UVs need to be flipped somewhere else in the asset pipeline.

This is because WebGL doesn't have access to the content of compressed textures (similar to how automatic mipmaps generation doesn't work with compressed textures, so mipmaps need to be baked in DDS).

See discussion on WebGL mailing list here: https://www.khronos.org/webgl/public-mailing-list/archives/1209/msg00024.html

For the JSON loader OBJ example I just flipped images in Gimp (other option would be to keep images intact and flip UVs in the application after loading geometry).

For ben model this shrunk creation time 3x (190 ms vs 608 ms). Also memory footprint should be much smaller with BufferGeometry.

Also I think there was a bug with "max_backre" instead of "max_backref" in decompressMesh2 function.

Removed jquery dependencies from MTLLoader and OBJMTLLoader. Cleaned up code a bit, reformatted whitespace. Added example.

See #2399

Fix cloneObject to also copy source.useVertexTexture for SkinnedMesh.

Tweaked UTF8Loader while at it. Not sure what's this new Model() thing for...