Not sure it's really correct, it's kinda hard to tell.

Also made stress test more fancy and heavy. It's interesting how antialiasing increases performance difference for more complex materials.

Also some shaders refactoring.

Still todo: doubleSided handling for reflections / refractions.

As per discussion in #1324

It seems to work, though not sure yet how to handle some things. Also for the moment it's implemented just for Lambert material.

Shadow cascades should be now a bit more under control.

Cascades can't be active together with multiple separate shadows, it's either one or the other. For this there is `renderer.shadowMapCascade` parameter.

Made colored shadow frustum debug visibility toggleable via `renderer.shadowMapDebug` parameter.

Fixed runaway globals in ShadowMapPlugin.

Fixed missing Gyroscope dependency in WebGL lib build.

Work-in-progress. Don't merge, it's still very rough and full of debug things.

Duh, had to read my own explanation of how matrices work ;).

This was redundant as viewMatrix uniform is the same thing.

This allows to have different shadow map parameters for different lights, also it's easier to access parameters for tweaking / debugging.

Changes:

renderer.shadowMapWidth    => spotLight.shadowMapWidth
renderer.shadowMapHeight   => spotLight.shadowMapHeight

renderer.shadowMapBias     => spotLight.shadowBias
renderer.shadowMapDarkness => spotLight.shadowDarkness

renderer.shadowCameraNear  => spotLight.shadowCameraNear
renderer.shadowCameraFar   => spotLight.shadowCameraFar
renderer.shadowCameraFov   => spotLight.shadowCameraFov

Also added new uniform type "v2v" for array of Vector2 (to support per-light sizes of shadow maps).

This is necessary for OpenGL where pow(0,0) is undefined and apparently can be negative, leading to negative specular light (in DirectX you just get zero).

Also refactored a bit regular Phong shader and refreshed Lee-Perry normal map example to be less zombie-like.

ATI OpenGL shader compiler doesn't seem to like texture access with UV coordinates generated in a loop.

Using boolean vector instead of "if ( expression && expression )".

This helps for hard shadows code path. There are still some problems with soft shadows code path, which still don't want to compile.

With a little twist - per color component mixing of regular and wrap-around lightings.

Work in progress. Still just experimenting. Probably will make some auto-adding of plugins.

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

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.

Added morph to rendering testbed.
Simplified shadowmap shader snippet gamma handling.

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

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

This feels more intuitive, otherwise ambiently lit textured surfaces look weird.

Turns out I had it right before after all: to get rid of artefacts it should be multiplied by diffuse term (instead of being patched by conditional).

Hopefully this fixes several problems:

- ambient component not modulated by scene ambient light
- specular component not getting light colors
- unnecessary opacity use in lighting calculations
- unnecessary vertex shader light computation for Phong
- unnecessary use of one varying in Phong