Gah, that was painful. Obvious solution with object.lookAt doesn't work, forward facing direction (heading and attitude) is fine, but banking gets messed up:( Tried many fixes, none worked, so I just resorted to simple rotation around Y-axis based on direction vector.

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...

Animation.js - fixed scale bugs and removed flattenToArrayOffset
AnimationHandler.js - fixed so keyframes at same time is removed
Matrix4.lookAt - fixed so it handles situations where z === up and where eye === target
SkinnedMesh.update - added flattenToArrayOffset in end of update

Minor tweaks.

- Wrong in last commit, now the inversion of position is removed

- 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

I don't remember when was the last time I used them. Current Web Developer Tools do this already for you.

Color::updateRGBA ⟶ Color::updateRGB

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

Thanks to @mikaelemtinger ;)

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

- removed unnecessary normal matrix computation in hierarchies (this is already done in renderer)
- removed unnecessary enabling of attribute arrays in every frame (it's enough to do it when shader program is created)
- depth test is now only set if it changed

- 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.

Just one hardcoded shader for the moment. Everything needs to get cleaned / bugfixed / optimized.

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

Small optimizations: skipped flattening in 3x3 matrix inversion and uploading camera position uniform only for materials where it's used.

This should affect only use cases with lots of animated objects (unlike current performance tests where object matrices are not updated).

WebGLRenderer now as fast as WebGLRenderer2.

https://github.com/mrdoob/three.js/pull/97

* memory and speed optimizations in Matrix4.makeInvert3x3() (moved Matrix4.m33 to WebGLRenderer._m33 since it is
  only used there and only for a single Matrix4)

* memory and speed optimizations in Matrix4.makeInvert3x3() (moved Matrix4.m33 to WebGLRenderer._m33 since it is
  only used there and only for a single Matrix4)

added Matrix4 "setter" functions: setTranslation, setScale, setRotX, setRotY, setRotZ, setRotAxis; to be used in optimizing Object3D.updateMatrix.

slight speedup in Matrix4.rotationAngleAxisMatrix by cutting down object lookups and redundant multiplications