Add copyright notice to gl-fun.{cpp,h}
README: Clarify SDL_sound version
gl-fun.h: Fix KHR_debug function signatures
Graphics: Respect non-default initial window size
Window: Use bilinear filtering for drawing controls

See #44
Tilemap: Use vertex shader based autotile animation strategy

Previously, we would just stuff the entire tilemap vertex data
four times into the buffers, with only the autotile vertices
offset according to the animation frame. This meant we could
prepare the buffers once, and then just bind a different offset
for each animation frame without any shader changes, but it also
lead to a huge amount of data being duplicated (and blowing up
the buffer sizes).

The new method only requires one buffer, and instead animates by
recognizing vertices belonging to autotiles in a custom vertex
shader, which offsets them on the fly according to the animation
index.

With giant tilemaps, this method would turn out to be a little
less efficient, but considering the Tilemap is planned to be
rewritten to only hold the range of tiles visible on the screen
in its buffers, the on the fly offsetting will become neglient,
while at the same time the amount of data we have to send to the
GPU everytime the tilemap is updated is greatly reduced; so a
net win in the end.
Window: Fix contents not being drawn if no windowskin is set
Bitmap#blt: Clamp source rect to source bitmap bounds

RGSS allows the source rectangle in both `blt` and
`stretch_blt` to lie outside the source bitmap bounds
(treating the missing data as (0, 0, 0, 0)) and to be
inverted (in which case the blitted image is also inverted).

This commit only hanldes a corner case that
arises in the game "Last Scenario"; emulating the full
RGSS behavior is however desirable.
CMakeLists.txt: Add new file "tilemap.vert"
TileAtlas: Fix broken atlas generation

The stuff committed in 56226c40c6113bc2da19c6b17e23cfd9cdbb613b
was actually completely broken.. oops.
Tilemap: Rewrite to only process and render visible region

Previously, on creation, we would parse the entire map data,
translating it into and uploading vertices once, then rendering
the entire map on every draw (to keep the draw calls minimal).
This worked great for smaller and medium sized maps, but starting
with larger maps (200x200+) it doesn't scale as the GPUs vertex
processing/culling is overwhelmed by the amount of data each frame.

This rewrite instead changes the strategy to only processing and
uploading a small subregion of the map (the currently visible part)
and regenerating all buffers if this subregion changes. The amount
of data transferred is small enough that it can be done every frame
without causing lag.

The changes also have the convenient side effect that we no longer
require 32 bit indices in mkxp, easing the road to possible GLES2
support in the future.
Wrap IBO index type into one definition

Makes it easier to switch between types (eg. 32 -> 16 bit).
Bitmap#get_pixel: Use cached client side copy of pixels

A very simplistic optimization for games that create a
Bitmap and then only ever query pixels from it.
Tilemap: Fix map wrap around
Some RGSS2/RGSS3 compile fixes
Add meta path with fallback for EXT_unpack_subimage parameters
Add some comments
GLMeta: Add vertex array object support
Tilemap: Reduce a few unnecessary blits

No need to replicate static autotiles if we're not animating
at all.
Added some cmake deps