Changed so objects added in sceneB in sceneA.addChild( sceneB ) actually propagates all the way up to sceneA, so they become rendered.

Added .name and .getChildByName( "objectName", doRecurse ) to Object3D. Added so scene-loader fills in .name property.

Added FlyCamera (thanks to James Baicoianu). Added specular map to normal map shader. Added WebGL Earth FlyCamera demo.

Changed normal map shader to multiply specular component with diffuse weighting as specular highlights were appearing in the dark parts.

Changed camera look speed in minecraft and terrain demos, they were too fast - I guess as everything got faster with antialiasing off.

Reenabled antialiasing in few demos where it was too ugly without (basically anything with lines and without postprocessing).

Fixed again spurious invisible characters in empaempa's code (which are breaking everything and are hard to hunt as they look like spaces).

Added translate( distance, axis ), translateX( distance ), translateY( distance ) and translateZ( distance ) methods to Object3D.
Camera3D translate method overrides Object3D's one. NoFly parameter removed (this should be handled from outside I think).

Object3D::lookAt works! (and Vector3.setRotationFromMatrix too!)

Next: Object3D::translate...

Mergable: WebGLRenderer.js: changed so camera.matrixWorldInverse is used instead of camera.matrixWorld.

- Changed so it sets an ordinary matrix. Also removed inversion of position, which broke A LOT of the examples.

WebGLRenderer:
- Using camera.matrixWorldInverse instead of camera.matrixWorld
- Changed frustum check to camera.frustumContains( object );
- Moved cameraInverse * matrixWorld to vertex shader (needs testing!) (note: normals not fixed yet!)

Object3D.addChild:
- Recurses up through hierarchy until reaches scene and adds itself to scene.objects/sounds/lights

Camera:
- Changed inverseMatrix -> matrixWorldInverse

Yet more reformating.

Object3D::globalMatrix ⟶ Object3D::matrixWorld

Added hierarchy examples.

Fixed matrix rotation in Projector (not fully done yet, need to implement herarchies still)

Messing with Cube example (exploring rotations).

There don't seem to be any effects on performance (though I'm not sure this was actually used in any example/test code path - so far quaternions are used just for animation interpolation and even there they were always dirty, and also just updated during JIT baking).

Also some more code cleanup - no need for Mesh to have own "update" as now it was exactly the same as its parent Object3D.

I need to look at this objectMatrix::extractRotationMatrix() thing. I don't think this works like that... isn't the scale applied to the rotation in the matrix?

Object3D::matrixNeedsToUpdate ⟶ Object3D::matrixNeedsUpdate

Figured out why Canvas/SVG wasn't rendering... someone changed camera.near/far to camera.zNear/zFar :P

It provides a lean way how to render TRIANGLE_STRIP primitives: needs just n+2 vertices for n triangles (one Ribbon = one strip). There are no faces, no indices, everything is rendered in one simple drawArray call.

Vertex colors are supported, normals not yet.

- getters/setters are no more in Vector3
  - object hierarchies thus don't use "isDirty"
  - this was completely killing performance for anything that was touching a lot of Vector3 like creation of meshes and dynamic buffers
  - even without this, performance of hierarchies went up (a lot)

- objects do not get passed renderer anymore
  - camera was almost also removed, but this is useful for LOD (though there may be some cleaner way to do this?)

- material ids are now unified, this makes "geometry.sortFacesByMaterial" faster (thus scene init / GUI blocking is shorter)

- all WebGL examples should work now (render-to-texture has weird lights and in some camera control feels different)

- CanvasRender still broken, despite many efforts :(
   - currently only points and lines work, faces don't show up. I think this may need assistance from mrdoob.

Otherwise things are very much work in progress, expect everything to be broken.

Work in progress.

As with static objects, faster with OpenGL (34 -> 38 fps) and slower with ANGLE (30 -> 27 fps).

Optimized Object3D.updateMatrix to (1) cut down where possible on new Matrix4 allocation, (2) only compute
rotation/scale matrices if needed (if no rotation, no need t compute); and (3) no longer require
storage of translationMatrix or scaleMatrix (1 per object). Uses a single tmpMatrix instead.

The most tangible practical effect is that demos with multiple Lucys / Walts are now initialized much faster ;).

Reuse is achieved mostly by moving mesh chunks / VBOs (formerly called materialFaceGroups) from Mesh into Geometry.

This means sorting of geometry by face materials + breaking large geometries into chunks now has to be done after construction of geometry.

It becomes a step in the usual sequence:

    geometry.computeNormals();
    geometry.computeCentroids();
    geometry.sortFacesByMaterial();

If geometry is constructed programmatically (e.g. with GeometryUtils.merge), this has to be called afterwards.

Also of note: single geometry cannot be reused both for flat and smooth shading, as only one stream of normals is baked into VBO.

* `CanvasRenderer` and `SVGRenderer` basic lighting support (`*ColorStroke`/`*ColorFill` only)
* `Renderer` > `Projector`. `CanvasRenderer`, `SVGRenderer` and `DOMRenderer` do not extend anymore
* Interactivity base code (hdi folder). To be refactored... ([mindlapse](http://github.com/mindlapse))
* Added `computeCentroids` method to `Geometry`
* Included `Stats.js` directly in the `/examples` folder to avoid the need of internet for playing around