Defaulting to 800 x 600 x 1.

This allows for API more compatible with WebGLRenderer (empty constructor followed by setSize).

Though for deferred renderer it's more efficient to specify width and height in the constructor (otherwise initial render targets are just going to be trashed immediately).

Make specular term multiplicative when specular color is zero.

At least till not finding out why OpenGL renderer got broken completely :S

We now have also AddOperation, which was just ignored.

It's a hybrid solution, cubemap pixels are fetched and blended in color pass based on deferred normals from normal pass.

This is because we'll be needing normals in the color pass.

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.

SceneLoader: setting visibility of implicitly created children to explicitly specified visibility in JSON.

This is for toggling visibility in hierarchy models loaded from OBJ, UTF8, etc. where in JSON there is just a root node.

Also hierarchy roots now get proper names (instead of those erroneous empties).

Because of deferred materials sharing and MeshFaceMaterials previous solution was causing disappearances of random parts.

There are still some disappearance glitches though if the scene includes some BufferGeometry objects. This was happening also before hiding transparent parts, so seems unrelated, more likely some bug in GL state handling for BufferGeometry rendering.

At least for now; later on these should be probably rendered in a separate forward renderer pass.

Phew, took ages to figure these out.

Renamed .deallocate() to .dispose() as discussed in #2760 and fdb737d0.

This gave me a hard time in a presentation where I was embeding the editor in one of the slides and it was stealing the focus...

Still unsure of whether to rename it to dispose instead.
I guess a problem of the world deallocate is that you're unsure wether it is dealocate or deallocate.

WebGLDeferredRenderer: syncing live light color, intensity, distance and visibility to deferred light proxy.

Still need to solve live material / lights parameters updates (only light position is dynamic for now).

This mirrors WebGLRenderer: when "antialias = true" FXAA is enabled, by default it's disabled.

Unlike WebGLRenderer though antialiasing can be enabled / disabled in runtime:

renderer.setAntialias( true );
renderer.setAntialias( false );

Lines do look pretty ugly with FXAA antialiasing though :S

Full-screen light proxies need to turn off depth testing. Instead stencil buffer now takes care of not touching background pixels.

Also matched specular term compositing to point lights.

Nevertheless these are very heavy in deferred shading because they need to touch every pixel.

Try to avoid using infinite distance PointLights, always specify some light.distance (smaller the better, more local light is cheaper it is).

It makes lights work when the camera is inside the light volume and somehow it's also 10% faster.

You just need to make sure camera far plane is far enough to encompass the whole light proxy, otherwise there are not lit slices of proxy sphere.

(I don't really understand why flipping the depth test works, originally depth test was supposed to be just disabled)

See #2624