This is to be able to skip redundant updates in multipass rendering (like for shadow maps or dynamic cube maps).

Also reshuffled initWebGLObjects calls to have just a single update in a basic scenario of shadow map pass followed by scene render.

Still need to solve somehow potential redundant updates in EffectComposer (which can mix multiple scenes).

Just for the sake of consistency, when object properties are not involved performance difference is negligible.

These little buggers were costing 3.35% of the total time in performance test.

Noticeable difference: can't anymore assign Material references to faces directly - "face.materials" became "face.materialIndex". Materials have to go to "geometry.materials" array (to which "face.materialIndex" points). This is necessary to allow run-time changing of face materials (this indirection used to be done by arrays).

Some casualties:

- multi-materials example, this functionality isn't possible anymore
- had to simplify LOD Text examples as LODs don't handle groups (used to fake multi-materials)
- multi-materials sphere in materials example can't have faces with undefined materials (this may be fixable I guess, when there'll be some real use-case)
- scene format still has materials arrays, only the last material will be used (except when there are face materials, then materials from JSON will be used, as before)

Other renderers and their corresponding examples were not touched yet.

WebGLRenderer still needs some prettification, some things don't make sense anymore without arrays, code can be cleaned up further.

Do not use for anything, this is just snapshot of a test in progress. I solved quite a few issues, but many things are still clumsy and broken.

New per-pixel Phong code is enabled by setting `perPixel` parameter in Phong material.

This version is able to light single untesselated quad correctly.

Also it doesn't have point lights number limitation caused by varyings, all lights pass just through uniforms.

Performance wise it seems surprisingly quite similar to old version (stress test is ~6 fps faster with new version, though I guess for different use cases / GPUs it can differ).

Metal makes specular term multiplicative (default is additive). This is to be able to have textured materials that do not have diffuse color, just a specular one, to get metallic look (additive specular gives plastic look).

Removed diffuse color influence on ambient term in Phong. This was causing texture disappearance when diffuse color was black.

Made Lambert more similar to Phong: now it also has ambient color parameter. Before ambient light was affecting Lambert as if ambient color was always 0xffffff.

This is not supposed to be "proper" solution (for example this doesn't solve removing of objects), but at least some WebGL examples are working now.

Apparently iterating over object properties is dangerous even if that code path is not executed.

Stress-testing particles buffers setting showed 60% performance increase (in Chrome) even when there were no custom attributes (and thus custom attributes handling code behind "if ( customAttributes )" was never executed).

I suspect this may be caused by some V8 optimization heuristics.

This is for being able to render shadowmap just once per frame - all dynamic cubemap faces and full scene can share the same shadowmap (at least until we don't have camera-specific fine-tuned shadowmaps).

Do not merge, this is very experimental, not sure about correctness, also tons of unsolved things.

Turns out before all cube texture faces shared a single depth buffer.

Last cube face still missing.

Before lighting was messed up in dynamically generated cube maps.

Dynamic cube maps need to have flip uniforms (flipEnvMap / tFlip) set to 1, static cube maps to -1 (default).

For standard materials this is handled automatically, it's just something to be aware of when using cube maps in custom ShaderMaterials (dynamic and static cube maps have different cube face orientations, dynamic ones are correct, static ones need flipped x-axis in lookup vector).

There is still mystery of disappearing last cube face (negative-Z) and weirdly clipped objects in cars demo (works ok in simpler test).

Now `Camera` can use inherited `update()`

* Added `scene.ambientColor` and `Scene` now ignores `AmbientLights` (transferring hex for temporal backwards compatibility)
* CanvasRenderer and SVGRenderer using `scene.ambientColor`. Tried to update `WebGLRenderer` too, but the method in question doesn't seem to have access to the scene :S
* Removed `scene.origin` and updated examples that used it.
* Improved subdivision example

Removed _gl.clear call from WebGLRenderer's .setSize().

Implemented .autoClearColor .autoClearDepth .autoClearStencil as per @alteredq's suggestion at #587.

* Camera.useTarget is now false by default. Updated some of the examples. I tried to remove target altogether (and use lookAt every frame), but I found that WebGLRenderer's ShadowMaps uses a camera with target. Will try again at some point.
* Object3D.lookAt now checks if it's a Camera and does the inverted view.
* Quaternion glitch reported at #595
* Added .name to Material
* WebGLRenderer .clear() to .clear( color, depth, stencil ). All of them true by default.

Added "lower level" immediate rendering functionality. The existing mechanism requires modification of the WebGLRenderer for different objects. The new implementation leaves the current MarchingCubes immediate renderer intact but checks for existence of a immediateRenderCallback member function of the object. If found, that object is added to the scene.__webglObjectsImmediate array. The program, webgl context, and frustum are currently passed into the callback, putting al rendering responsibility at the implementing object. This may break the Three.js abstraction somewhat, but allows "power users" to do some funky webgl stuff while still relying on the Three.js framework for the rest of the scene...

Finally 60 fps on 5,000 monkeys ;)

All examples should work.

Should not refresh anything if material doesn't change for several objects in a row (in a single frame).

Hope this didn't break something, I remember this being tricky. Went through examples and they seem to work ok, gained some fps in performance test.

Also disabled sorting in depth-of-field example for some more fps gain.

Still didn't figure out the original reason for recent fps drop in performance / dof examples :/

Similarly like for geometry groups, iterating over object properties turned out to be bottleneck for some use cases: gained 5-10 fps in depth-of-field example (which btw for some reason got slower recently).

Problem was that objects could be added to WebGLRenderer's internal render list only once (because of `webglInit` flag).

Now there are two separate internal states (`webglInit` and `webglActive`) so that object can be initialized just once (expensive operation) but added / removed from the scene many times (cheap operation).