To have lighting consistent with shadows when using target.

Before SpotLight was a weird mix of shadow casted from PointLight and light casted from DirectionalLight.

After shadow mapping fixes orthographic shadow projection finally started to work.

Work in progress. Still need to figure out some way to set up shadow camera automagically with respect to the actual camera (so that whole scene is shadowed when the camera moves). For the moment shadow camera needs to be handled manually (like for SpotLight).

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

Fixed bug where depth buffer is not cleared if last object rendered on previous render cycle disabled depth mask.

Shadows should be now done more correctly and also be a bit less fussy. Before RGBA encoded depth maps were getting messed up with blending (that's why everything was extremely sensitive to frustum size).

All examples with shadows had to be re-tweaked (shadows now behave differently).

Plus added "onUpdate" callback handling also for cube textures.

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.

Updated Closure compiler. Added more verbose compile warnings. Fixed all compile warnings. Started to fix runtime warnings in examples.

For verbose compile warnings to be practical I had to add externs and disable some warnings manually (there were tons of complains about "global this" and "cannot instantiate non-constructor"). Other solution would be to annotate explicitly constructors all over the code base.

(prompted by John Carmack's praise of static code analysis http://altdevblogaday.com/2011/12/24/static-code-analysis/)

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.

This exists also in Blender, useful for when you want to add shadows independent of lighting (it's cheaper to turn off SpotLight than to have it with 0 intensity).

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

As per @toji's "don't lie to WebGL about your format" recommendations in WebGL Camp 4 talk (http://media.tojicode.com/webglCamp4/#19).

Work in progress. For the moment works just with CTMLoader. Still not sure where some pieces of code would go.

Upsides:
	- initialization time cut down significantly (1.8 seconds => 0.7 seconds for CTM example)
	- much smaller GL buffers thanks to fully used indexing (Walt has 6x less vertices)
	- consequently much smaller memory footprint all around, both for main and GPU memories,
	  which means less swapping and better vertex caching

Downsides:
	- can't have anymore sharp per-face effects like flat shading (at least if mesh is not constructed in a way where each face has own vertices)
	- can't have multiple materials per mesh
	- no more easy manipulation of anything (for the moment actually no runtime manipulation at all, typed arrays are just thrown away, dynamic geometries code path not yet implemented)

As per Giles recommendation here http://learningwebgl.com/blog/?p=4379

This is optional, for now by default it's off, like it was before. It's up to application to update geometry bounding sphere if vertex positions change (like for meshes).

This should allow attaching of lights to objects. As a side effect, directional lights positions don't need to be normalized explicitly anymore.

Also changed viewport dimensions passed to render plugins to work with render targets with different dimensions than the screen framebuffer.

And fixed new dependencies in build script.

Also some bugfixes in ShadowMapPlugin and SpritePlugin.

Because TortoiseGit suddenly refuses to make single commit with added and changed files :/

Changed console error to return null and updated WebGLRenderer to handle null value. A valid matrix with no rotation and 0 scale will have a 0  determinant and does not need a normal matrix.

Work By: Erik Kitson

Also some refactoring in plugins.

Still not really satisfied with a solution, will need to handle somehow ordering of plugins (both among them and with respect to rest of rendering, this would be needed for example to be able to redo shadow maps as a plugin).

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

Still a bit dirty but less than it was before. Maybe also sprites could be pluginized.

Hope so. There is now just a single scene graph update per frame render (plus some extra one-shot updates if light cameras are auto-added to scene graph).

Also fixed RTT example - seems UV mapping for SphereGeometry is now rotated 180 degrees.

Too much caching can break things.

This is supposed to be more efficient as per Apple OpenGL ES recommendations:

http://developer.apple.com/library/ios/#documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/TechniquesForWorkingWithTextureData/TechniquesForWorkingWithTextureData.html

Also we have been generating mipmaps twice for render targets.

Proper IcosahedronGeometry next...