Cleaned up old GL code.

Removed commented-out stuff:
• GLKView calls glViewport for us before every frame; we don't need to touch it.
• glScissor is unnecessary; the default is effectively the entire viewport.
• Retina half-scale modelviewMatrix call.  Don't need it (yet).
• Direct glMatrixMode/glLoadIdentity/glOrtho/glScale setup calls.  Handled by the GLKBaseEffect transform set.
• light0 calls.  No lighting here.
• Push/PopMatrix stuff.
• Extra unnecessary prepareToDraw calls.
• glColor4f calls.
• A lot left-over vertex stuff in setUpGL.
• A lot left-over vertex stuff in glkView:drawInRect:.

Clean-up:
• Moved prepareToDraw to the end of setUpGL.
UIColor extension w/ UIColorValues and accessors

Created UIColor+SDTAdditions with:
• UIColorValues struct, a pure-data storage type for HSBA, RGBA, or WA (white/alpha) color values.
• get…Values accessors methods for HSBA, RGBA, and WA.

Added to project and prefix file.
Now nearly matching the CoreGraphics version.

It's surprisingly fast (60 FPS with plenty of head room) even though it's drawing quite a few polys (256 slices for some of the bigger circles) and is unnecessarily repetitive (reloading vertex data onto the card on every draw).  Performance oddly drags on the iOS Simulator though.

After some clean-up, minor fixes, and addition of missing border (and _maybe_ that BG texture), we should be able to call this refactor complete.  It is a bit sloppy and repetitive right now (intentionally to an extent, in order to properly understand what we need where before wrapping up in models).

Bringing SceneViewControllerForGLK and SceneForGLK up to speed:
• UIResponder touch-handling methods (touchesBegan:withEvent:, touchesMoved:withEvent:, touchesEnded:withEvent:, touchesCancelled:withEvent:) and state vars (_startTouchPosition and _prevTouchPosition) copied to SceneViewControllerForGLK from SceneViewControllerForCG.
	» These should also probably be in SceneViewControllerUtil.  I'm starting to really loathe this disjoint inheritance.
• SceneForGLK#drawContentLayerWithin:forView: fleshed out with focus-shifting transformation code (and arena draw call), akin to SceneForCG's equivalent.
	• Minor clean-up in SceneForCG#drawContentLayerWithin:forView: of renaming `theViewFocus_px` to just `viewFocus_px`.

VisRep GL drawing:
• Added glDrawUsing: to all the VisReps (Arena, Background, InsideRing, OutsideRing, and Ring).
	• ArenaVisRep#glDrawUsing: has call-outs to the other VisReps, like cgDrawWithin: (but with modelview resets before each).
	• BackgroundVisRep#glDrawUsing fills, but does not apply the texture (yet, or maybe not ever since the style may be changing soon).
	• InsideRingVisRep#glDrawUsing & OutsideRingVisRep#glDrawUsing fill their circles, but do not border them (yet).
	• OutsideRingVisRep#glDrawUsing 
• Renamed ArenaVisRep#drawWithin: to cgDrawWithin:.  I'm not sure how I missed this.
• Added lazy-init static-indefinitely-stored accessors using MemoizedVarInitializerForVerticeData to do the math and create the vertices, akin to the existing accessors for BezierPaths.
	» Still a lot of repeated code between classes (VerticeData struct, vertex calculation code, maybe some other stuff).  Ugg.
	• These methods are all (currently) copies or minor modifications of the circle and ring calculation methods createCircleVertices: and createRingVertices:hole: in SceneForGLK.
• static consts set up in each class for repeated stuff like sliceCount and oversizeRatio.

Overall clean-up and refactorings:
• `VerticeData` struct changed to more-common `_VerticeData` naming with typedef to `VerticeData`.
• `assemblyMode` GLenum added to VerticeData, intended for the glDrawArrays mode arg (GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP, etc.).
• Using UIColorValues4 and accessors to simplify the process of color-grabbing for `baseEffect.constantColor`.
• Caching GLKBaseEffect in a baseEffect local var where repeatedly used.  Not sure why I wasn't doing this.
• Switched to a model of storing the modelview matrix outside of the draw method and restoring afterwards, rather than saving and restoring inside the draw method.
	» Although this is against the typical clean-up-after-yourself approach, it bit me hard once already when I missed a closing restore.  This way is much safer and saner.
	» Unfortunately, this may be a little less performant, since the restore happens regardless of changes to the matrix.  However, GLKBaseEffect may be making this negligible by only talking to GL with the end-result matrices in the call to prepareToDraw (this is likely the intent.)
	» Discovered this methodology via Apple docs/code, I believe.
• Switched naming from using `ModelviewMatrix` (such as `saveModelviewMatrix`) to just `Modelview` (`savedModelview`), or in some tightly-scoped instances just `modelview`.
	» It's easier, and AFAICDetermine it's non-ambiguous.
Added view focus to overlay text.

In both pixels and inches!
Fixed centering of view/perspective.

• Now centered on 0×0 rather than 0×0 being in the corner.
• Circle is now created at the world center, 0×0, rather than 0×-5.5.

Minor:
• Using intermediate change-only CGAffineTransforms for better understandability.
• outsideCirclePath and insideCirclePath accessors: `boundingRect` separated off for easier debugging.
Set starting view focus to (0, 7)

View focus is stored in inches (to correlate with ring size constants), and converted to pixels during construction.  It probably doesn't need to be reiterated, but this is messy and should be elegantly whisked away sooner or later.
Minor: Coordinates written with ‘,’ instead of ‘×’

I don't know why I was thinking “by” for coords.  It really only makes sense for sizes.

Changed in comments and drawViewFocusCoordsOnLine:within:.  drawViewFocusCoordsOnLine:within: is also using thin space between numbers and units now (http://en.wikipedia.org/wiki/Space_%28punctuation%29#Spaces_and_unit_symbols).
Merge branch 'master' into refactor/re-gl-ize

Conflicts in:
	App/ArenaVisRep.m
	App/SceneView.m
Which have evolved into:
	App/SceneForCG.m
	App/SceneForGLK.m
	App/VisReps/InsideRingVisRep.m
	App/VisReps/OutsideRingVisRep.m
	App/VisReps/RingVisRep.m

Resolved by moving the changes into the new locations.  This makes the CG drawing work as it does on master, but not GLK without further changes/additions.
GLK positioning now matching merged-in CG positioning
Rotated the calculation for each ring by half-a-slice

This makes the circles look just a little nicer near the pixel-aligned edges (top, right, bottom, left) at a minor cost of a little more roughness at the 45°-aligned edges (TR, BR, BL, TL).

As a result:
• Removed simple calculations for ring top-inner and top-outer and circle top-point (leaving center-point as-is), as the first couple of points also need trig now.
• Slice-calc loops now start `sliceI` at -1 instead of 0, so that we calculate those first points (I know, weird math).
• And of course, half the slice's angular delta subtracted as a part of each point's angle calculation.
Added AGLKit, from Erik M. Buck's Learning OpenGL ES For iOS

There are some good stuff in here that it's a wonder why Apple hasn't implemented/exposed themselves.

Added the whole shebang to the project file (for now).  The .fsh and .vsh shader files are bundled in, rather than trying to compile them.
Consistified formatting of AGLKit.

Modified the code style to match the rest of this project:
• Tab indentation (previously 1-to-4-space indentation).
• Triple comments preceding documentable elements (structs, classes, functions, etc.)
• 65-character line breaking eliminated in comments; instead wrapped to sentence boundaries (which I find easiest to quickly read).
• Fixed typos in comments and function names.
• Removed whitespace at the end of lines (non-blank lines; excluding blank indentation-keep lines).
• `#pragma mark`s where sectional comments were.
• Replaced the header comments that had only the filename redundantly stated with a comment with @author and @source info.
	» Using `// ` instead of `/// ` for these because — if I were a comment parsing program — it seems easier to differentiate between a header comment and a first-element-prefix comment if element-prefix comments have to have 3 /-es and this does not.
• Balanced brackets and parentheses (some closing elements were hanging, functional-style).
• Weird semicolons after the method implementation name-line removed.
	» It's too bad Obj-C isn't as picky as C++.
• Converted hanging comments on arguments to @param doc comments.
• Single blank line at the end of each file.
• A space after control structures before the opening parenthesis (unlike functions).
• Brackets same-lined when used with small scopes.
• Comments that were on opening bracket lines moved to their own line, either after or before depending on context.
• Brackets removed when there's only one line.
• 65-(or less)-char line-broken code changed to one-line or indented with balanced brackets.
• Note: Space after @property before opening parenthesis retained.
	» This is inconsistent with the rest of the project, but I need to fix that.  A space after seems to be the defacto standard, despite looking unusual for a C-based language.
• Property attribute order consistified (atomicity, then data ownership, then r/w qualifiers).
	• Changed `strong` and `weak` to `retain` and `assign`.  The old terms are forwards-compatible, but the new ones are not backwards-compatible.
• Added spaces around math operators.
	» `*` looks like a pointer, `/` looks like a path, `-` looks like a hyphen.  It's just confusing without some room.
• Flipped some backwards (IMHO) conditionals to check the variable against the constant, not the constant against the variable.
• Added missing `[super dealloc]` calls.
• More spacing in general between things, 2 between distinct large elements or groups of similar elements, 3 between largely different things or often-nearly-full-file-size blocks.
	• Except 0 space between some methods interface lines that were wrapped before.
• and some other minor stuff
Zapped unwanted Unicode+FFFC chars

Somehow an object replacement character (U+FFFC) snuck into the file-header `@source` line.  Zapped
GL drawing switched over to use VBOs.

Runs smoothly on the iOS Sim now.  I'm not sure if border drawing is working everywhere though (could be a transformation/matrix issue).

Vertex Wrangling:
• SceneForGLK, InsideRingVisRep, OutsideRingVisRep, and RingVisRep set up with loadVertices method which alloc/inits AGLKVertexAttribArrayBuffer(s) for the circles and rings necessary.
	• …AssemblyMode and …VertexCount instance vars set up for each shape and the VerticeData dropped after initialization.  I'm not sure I like this, but it works for now.
	• Individual circle and ring drawing code replaced with calls to AGLKVertexAttribArrayBuffer #prepareToDrawWithAttrib:numberOfCoordinates:attribOffset:shouldEnable: and drawArrayWithMode:startVertexIndex:numberOfVertices:.
• Border drawing added to those that didn't have it.
	• Also, 2 borders (inner and outer) added for RingVisRep, unlike the rest.  I think the CG code needs this change as well.
	• Uses of blackColor and whiteColor changed to accessors, since the former don't convert nicely into RGB.
• Previously-repeated circle and ring mesh gen code moved into VerticeData.h/.m, along with the VerticeData struct.
	• VerticeData.h/.m added to project file.
	• Removed …VerticeData readonly accessors and static storage vars in favor of create…Vertices methods.

Load/Unload:
• Scene now has load and unload methods which now create and destroy the VisRep tree (ArenaVisRep).  Also tracks load state and ensures unload in dealloc.
	• SceneForGLK hooks into these and loads/unloads Vertices.
• SceneViewController…s now call Scene#load and Scene#unload from viewDidLoad and viewDidUnload following setUpGL and tearDownGL (respectively).
• The didReceiveMemoryWarning teardown logic was somewhat redundant in SceneViewControllerForGLK; now calling only unloadView since tearDownGL (by way of unloadView and viewDidUnload) takes care of everything.


Clean-up:
• UIColor#get…ValuesAsGLKVector4 methods added and drawing-code color sets simplified
• UIColor#get…Values methods now initialize the values to 0 rather than leaving them as junk if it couldn't be initialized.
• Many (but not all) instances of “Edge” in variable/method names replaces with “Border”.
	» Edge sounds like the very edge of something while border is something that has thickness and its own edges.

Minor:
• Changed Scene's usage of screenPPIRetinaDisregarded to its instance method (`self.screenPPIRetinaDisregarded`) instead of using SceneUtil directly.
• Now always putting a space between a block/block type's return type and the `^…` or `(^…`.
• Added OPTION_GL_FLUSH_AND_FINISH_AFTER_EVERY_DRAW which enables blocks of code after every draw call (also added) that call glFlush and glFinish.
	» This may not have any effect on iOS.  But it still could come in handy, and it shouldn't pose any real maintainability issues.
• Comment grammer fix.
• viewWill/didUnload iOS 5 comment moved from function-doc to the call point in SceneViewControllerFor…#unloadView.
Fixes and minor additions to AGLKit lib.

• AGLKPointParticleEffect and AGLKTextureLoader were missing releases after alloc/initing their AGLKVertexAttribArrayBuffers.  Added an autorelease to each.
• In AGLKVertexAttribArrayBuffer, function-doc comments moved from the implementation to the interface and fleshed out considerably, especially regard the scope of values that are passed through to GL (with info from the GL API).
• `#version 100` added to each shader because I like things to be specific (and because I discovered this in the GLSL ES docs and just had to try it out).
Changed VisReps to take PPI on init

This fixes the geometry of the borders that weren't drawing (they were, but with infinite values due to a divide-by-zero, which was messing things up).

• init methods converted over to initWithPPI:
• public PPI properties set to readonly
	• private non-readonly PPI properties added
• ArenaVisRep#setPPI removed
• isPPIValid changed to a C function
	• changed to check for infinite/NaN values as well
	• removed from draw calls to setPPI (since it's set during init now)

Also:
• All instances of PPI changed to uppercase.  This makes things simpler.
VerticeData createCircle/RingVertices functions renamed

VerticeData's createCircleVertices function renamed to VerticeDataCreateCircle and createRingVertices to VerticeDataCreateRing, for consistency with Core Foundations naming.
Fixed CoreGraphics drawing

SceneViewControllerForCG: 
• startDisplayLink was getting called before the Scene (and VisReps) were loaded, and was causing crashes in drawViewFocusCoordsOnLine: due to bad data (derived from arenaVis.PPI).  Now startDisplayLink gets called last in viewDidLoad and first in viewDidUnload.
• Removed super calls in viewWill/DidLoad/Unload, like SceneViewControllerForGLK.
• Moved `[self.scene load]` from viewWillUnload to viewDidLoad.  Oops.
• Added empty viewWillLoad method (wasn't there previously).

Other stuff:
• Added initForGLWithPPI: methods to all the VisReps that does loadVertices, in contrast with initWithPPI: which (now) does not, so that CG can init these without calling GL stuff.
	» This is a horrible hack that defeats the purpose of the VisReps and is only a temporary patch.
	• As a result, SceneForGLK has to re-create arenaVis in its load method.  Yuck.
• Now setting the appropriate lineWidth on all UIBezierPaths.
	» Though there seems not to be a inside/center/outside alignment for strokes, unlike the Adobe Illustrator drawing style I had in mind when writing the GL code.  Hmmp.

Minor:
• AppDelegate now using a local with a type of `UIViewController <SceneViewControllerProtocol> *` so it's one less spot (2 now) that needs to be changed between `GLK` and `CG` when testing like this.
Inside-aligned strokes in CG (matching GL)

Using CGContext clipping and stroke width doubling to draw an inside-aligned path for RingVisRep, InsideRingVisRep, and OutsideRingVisRep, per the tip at http://stackoverflow.com/questions/2488115/how-to-set-up-a-user-quartz2d-coordinate-system-with-scaling-that-avoids-fuzzy-d#answer-2488796 .
Fixed measured FPS not being accurate

It wasn't updating the mostRecentIndex (and thus always updating the same entry) because the SceneViewControllerRecentIntervalInfo was being passed to storeInterval:updatingRecentIntervalInfo: by value, instead of by pointer in order to be modified.  Oops.