diff --git a/Makefile b/Makefile
index f12132a..647d980 100644
--- a/Makefile
+++ b/Makefile
@@ -11,7 +11,7 @@ CC      = $(PREFIX)-gcc
 CXX		= $(PREFIX)-g++
 AR      = $(PREFIX)-gcc-ar
 CFLAGS  = -g -Wl,-q,--no-enum-size-warning -fno-short-enums -fno-optimize-sibling-calls -O3 -fsingle-precision-constant -mfloat-abi=hard -ffast-math \
-	-DPSP2 -DNDEBUG -DRW_GL3 -DLIBRW_GLAD -DPSP2_USE_SHADER_COMPILER -Dmemcpy_neon=sceClibMemcpy
+	-DPSP2 -DRW_GL3 -DLIBRW_GLAD -DPSP2_USE_SHADER_COMPILER -Dmemcpy_neon=sceClibMemcpy
 CXXFLAGS = $(CFLAGS)
 ASFLAGS = $(CFLAGS)
 
diff --git a/src/base.cpp b/src/base.cpp
index f81050b..fae47da 100644
--- a/src/base.cpp
+++ b/src/base.cpp
@@ -19,12 +19,6 @@
 #include "rwobjects.h"
 #include "rwengine.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-extern "C"{
-#include <math_neon.h>
-};
-
 namespace rw {
 
 #define PLUGIN_ID 0
@@ -194,9 +188,6 @@ V3d::transformVectors(V3d *out, const V3d *in, int32 n, const Matrix *m)
 void
 RawMatrix::mult(RawMatrix *dst, RawMatrix *src1, RawMatrix *src2)
 {
-#ifdef PSP2
-	matmul4_neon((float*)&src1->right.x, (float*)&src2->right.x, (float*)&dst->right.x);
-#else
 	dst->right.x = src1->right.x*src2->right.x + src1->right.y*src2->up.x + src1->right.z*src2->at.x + src1->rightw*src2->pos.x;
 	dst->right.y = src1->right.x*src2->right.y + src1->right.y*src2->up.y + src1->right.z*src2->at.y + src1->rightw*src2->pos.y;
 	dst->right.z = src1->right.x*src2->right.z + src1->right.y*src2->up.z + src1->right.z*src2->at.z + src1->rightw*src2->pos.z;
@@ -213,7 +204,6 @@ RawMatrix::mult(RawMatrix *dst, RawMatrix *src1, RawMatrix *src2)
 	dst->pos.y   = src1->pos.x*src2->right.y   + src1->pos.y*src2->up.y   + src1->pos.z*src2->at.y + src1->posw*src2->pos.y;
 	dst->pos.z   = src1->pos.x*src2->right.z   + src1->pos.y*src2->up.z   + src1->pos.z*src2->at.z + src1->posw*src2->pos.z;
 	dst->posw    = src1->pos.x*src2->rightw    + src1->pos.y*src2->upw    + src1->pos.z*src2->atw  + src1->posw*src2->posw;
-#endif
 }
 
 void
@@ -675,7 +665,7 @@ correctPathCase(char *filename)
 		sofar[2] = '\0';
 		arg++;
 	}
-	while(dir = strtok(arg, PSEP_S)){
+	while((dir = strtok(arg, PSEP_S))){
 		arg = nil;
 		if(direct = opendir(sofar), dir == nil)
 			return;
@@ -769,8 +759,8 @@ Stream::write32(const void *data, uint32 length)
 	int32 n, len;
 	for(len = length >>= 2; len > 0; len -= 256){
 		n = len < 256 ? len : 256;
-		memcpy_neon(buf, src, n*4);
-		memLittle16(buf, n*4);
+		memcpy(buf, src, n*4);
+		memLittle32(buf, n*4);
 		write8(buf, n*4);
 		src += n*4;
 	}
@@ -789,7 +779,7 @@ Stream::write16(const void *data, uint32 length)
 	int32 n, len;
 	for(len = length >>= 1; len > 0; len -= 256){
 		n = len < 256 ? len : 256;
-		memcpy_neon(buf, src, n*2);
+		memcpy(buf, src, n*2);
 		memLittle16(buf, n*2);
 		write8(buf, n*2);
 		src += n*2;
@@ -934,7 +924,7 @@ StreamMemory::write8(const void *data, uint32 len)
 			l = this->capacity-this->position;
 		this->length = this->position+l;
 	}
-	memcpy_neon(&this->data[this->position], data, l);
+	memcpy(&this->data[this->position], data, l);
 	this->position += l;
 	if(len != l)
 		this->position = S_EOF;
@@ -949,7 +939,7 @@ StreamMemory::read8(void *data, uint32 len)
 	uint32 l = len;
 	if(this->position+l > this->length)
 		l = this->length-this->position;
-	memcpy_neon(data, &this->data[this->position], l);
+	memcpy(data, &this->data[this->position], l);
 	this->position += l;
 	if(len != l)
 		this->position = S_EOF;
@@ -1117,7 +1107,8 @@ uint8*
 getFileContents(const char *name, uint32 *len)
 {
 	FILE *cf = fopen(name, "rb");
-	assert(cf != nil);
+	if(cf == nil)
+		return nil;
 	fseek(cf, 0, SEEK_END);
 	*len = ftell(cf);
 	fseek(cf, 0, SEEK_SET);
diff --git a/src/base.err b/src/base.err
index 507b26c..2d413e8 100644
--- a/src/base.err
+++ b/src/base.err
@@ -19,4 +19,6 @@ ECODE(ERR_ENGINESTART,
 ECODE(ERR_INVRASTER,
       "Invalid raster format"),
 ECODE(ERR_NOTEXTURE,
-      "Could not create texture")
+      "Could not create texture"),
+ECODE(ERR_FORMAT_UNSUPPORTED,
+      "Unsupported raster format")
diff --git a/src/bmp.cpp b/src/bmp.cpp
index 6f9f8c7..f69e58d 100644
--- a/src/bmp.cpp
+++ b/src/bmp.cpp
@@ -247,7 +247,7 @@ writeBMP(Image *image, const char *filename)
 		for(int x = 0; x < image->width; x++){
 			switch(image->depth){
 			case 4:
-				file.writeU8((p[0]&0xF)<<4 | p[1]&0xF);
+				file.writeU8((p[0]&0xF)<<4 | (p[1]&0xF));
 				p += 2;
 				x++;
 				break;
diff --git a/src/charset.cpp b/src/charset.cpp
index 0d94be8..5188b80 100644
--- a/src/charset.cpp
+++ b/src/charset.cpp
@@ -128,8 +128,16 @@ Charset::flushBuffer(void)
 		rw::SetRenderState(rw::TEXTUREADDRESS, rw::Texture::WRAP);
 		rw::SetRenderState(rw::TEXTUREFILTER, rw::Texture::NEAREST);
 
+		uint32 cull = rw::GetRenderState(rw::CULLMODE);
+		uint32 ztest = rw::GetRenderState(rw::ZTESTENABLE);
+		rw::SetRenderState(rw::CULLMODE, rw::CULLNONE);
+		rw::SetRenderState(rw::ZTESTENABLE, 0);
+
 		im2d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST,
 			vertices, numChars*4, indices, numChars*6);
+
+		rw::SetRenderState(rw::CULLMODE, cull);
+		rw::SetRenderState(rw::ZTESTENABLE, ztest);
 	}
 
 	numChars = 0;
diff --git a/src/d3d/d3d.cpp b/src/d3d/d3d.cpp
index 1545934..f1f5f49 100644
--- a/src/d3d/d3d.cpp
+++ b/src/d3d/d3d.cpp
@@ -18,106 +18,7 @@
 namespace rw {
 namespace d3d {
 
-bool32 isP8supported = 1;
-
-#ifndef RW_D3D9
-#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
-            ((uint32)(uint8)(ch0) | ((uint32)(uint8)(ch1) << 8) |       \
-            ((uint32)(uint8)(ch2) << 16) | ((uint32)(uint8)(ch3) << 24 ))
-enum {
-	D3DFMT_UNKNOWN              =  0,
-
-	D3DFMT_R8G8B8               = 20,
-	D3DFMT_A8R8G8B8             = 21,
-	D3DFMT_X8R8G8B8             = 22,
-	D3DFMT_R5G6B5               = 23,
-	D3DFMT_X1R5G5B5             = 24,
-	D3DFMT_A1R5G5B5             = 25,
-	D3DFMT_A4R4G4B4             = 26,
-	D3DFMT_R3G3B2               = 27,
-	D3DFMT_A8                   = 28,
-	D3DFMT_A8R3G3B2             = 29,
-	D3DFMT_X4R4G4B4             = 30,
-	D3DFMT_A2B10G10R10          = 31,
-	D3DFMT_A8B8G8R8             = 32,
-	D3DFMT_X8B8G8R8             = 33,
-	D3DFMT_G16R16               = 34,
-	D3DFMT_A2R10G10B10          = 35,
-	D3DFMT_A16B16G16R16         = 36,
-
-	D3DFMT_A8P8                 = 40,
-	D3DFMT_P8                   = 41,
-
-	D3DFMT_L8                   = 50,
-	D3DFMT_A8L8                 = 51,
-	D3DFMT_A4L4                 = 52,
-
-	D3DFMT_V8U8                 = 60,
-	D3DFMT_L6V5U5               = 61,
-	D3DFMT_X8L8V8U8             = 62,
-	D3DFMT_Q8W8V8U8             = 63,
-	D3DFMT_V16U16               = 64,
-	D3DFMT_A2W10V10U10          = 67,
-
-	D3DFMT_UYVY                 = MAKEFOURCC('U', 'Y', 'V', 'Y'),
-	D3DFMT_R8G8_B8G8            = MAKEFOURCC('R', 'G', 'B', 'G'),
-	D3DFMT_YUY2                 = MAKEFOURCC('Y', 'U', 'Y', '2'),
-	D3DFMT_G8R8_G8B8            = MAKEFOURCC('G', 'R', 'G', 'B'),
-	D3DFMT_DXT1                 = MAKEFOURCC('D', 'X', 'T', '1'),
-	D3DFMT_DXT2                 = MAKEFOURCC('D', 'X', 'T', '2'),
-	D3DFMT_DXT3                 = MAKEFOURCC('D', 'X', 'T', '3'),
-	D3DFMT_DXT4                 = MAKEFOURCC('D', 'X', 'T', '4'),
-	D3DFMT_DXT5                 = MAKEFOURCC('D', 'X', 'T', '5'),
-
-	D3DFMT_D16_LOCKABLE         = 70,
-	D3DFMT_D32                  = 71,
-	D3DFMT_D15S1                = 73,
-	D3DFMT_D24S8                = 75,
-	D3DFMT_D24X8                = 77,
-	D3DFMT_D24X4S4              = 79,
-	D3DFMT_D16                  = 80,
-
-	D3DFMT_D32F_LOCKABLE        = 82,
-	D3DFMT_D24FS8               = 83,
-
-	// d3d9ex only
-	/* Z-Stencil formats valid for CPU access */
-	D3DFMT_D32_LOCKABLE         = 84,
-	D3DFMT_S8_LOCKABLE          = 85,
-
-	D3DFMT_L16                  = 81,
-
-	D3DFMT_VERTEXDATA           =100,
-	D3DFMT_INDEX16              =101,
-	D3DFMT_INDEX32              =102,
-
-	D3DFMT_Q16W16V16U16         =110,
-
-	D3DFMT_MULTI2_ARGB8         = MAKEFOURCC('M','E','T','1'),
-
-	// Floating point surface formats
-
-	// s10e5 formats (16-bits per channel)
-	D3DFMT_R16F                 = 111,
-	D3DFMT_G16R16F              = 112,
-	D3DFMT_A16B16G16R16F        = 113,
-
-	// IEEE s23e8 formats (32-bits per channel)
-	D3DFMT_R32F                 = 114,
-	D3DFMT_G32R32F              = 115,
-	D3DFMT_A32B32G32R32F        = 116,
-
-	D3DFMT_CxV8U8               = 117,
-
-	// d3d9ex only
-	// Monochrome 1 bit per pixel format
-	D3DFMT_A1                   = 118,
-	// 2.8 biased fixed point
-	D3DFMT_A2B10G10R10_XR_BIAS  = 119,
-	// Binary format indicating that the data has no inherent type
-	D3DFMT_BINARYBUFFER         = 199
-};
-#endif
+bool32 isP8supported = 1;	// set to 0 when actual d3d device is used
 
 // stolen from d3d8to9
 static uint32
@@ -306,11 +207,11 @@ unlockVertices(void *vertexBuffer)
 }
 
 void*
-createTexture(int32 width, int32 height, int32 numlevels, uint32 format)
+createTexture(int32 width, int32 height, int32 numlevels, uint32 usage, uint32 format)
 {
 #ifdef RW_D3D9
 	IDirect3DTexture9 *tex;
-	d3ddevice->CreateTexture(width, height, numlevels, 0,
+	d3ddevice->CreateTexture(width, height, numlevels, usage,
 	                      (D3DFORMAT)format, D3DPOOL_MANAGED, &tex, nil);
 	if(tex)
 		d3d9Globals.numTextures++;
@@ -377,7 +278,7 @@ struct RasterFormatInfo
 
 // indexed directly by RW format
 static RasterFormatInfo formatInfoRW[16] = {
-	{ 0, 0, 0},
+	{ 0, 0, 0, 0},
 	{ D3DFMT_A1R5G5B5, 16, 1, Raster::C1555 },
 	{ D3DFMT_R5G6B5,   16, 0, Raster::C565 },
 	{ D3DFMT_A4R4G4B4, 16, 1, Raster::C4444 },
@@ -444,7 +345,7 @@ findFormatInfoD3D(uint32 d3dformat)
 {
 	static RasterFormatInfo fake = { 0, 0, 0, 0 };
 	int i;
-	for(i = 0; i < nelem(formatInfoFull); i++)
+	for(i = 0; i < (int)nelem(formatInfoFull); i++)
 		if(formatInfoFull[i].d3dformat == d3dformat)
 			return &formatInfoFull[i];
 	return &fake;
@@ -492,7 +393,7 @@ rasterSetFormat(Raster *raster)
 	}
 
 
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 	if(raster->format & (Raster::PAL4 | Raster::PAL8)){
 		// TODO: do we even allow PAL4?
 		natras->format = D3DFMT_P8;
@@ -505,25 +406,28 @@ rasterSetFormat(Raster *raster)
 	natras->hasAlpha = formatInfoRW[(raster->format >> 8) & 0xF].hasAlpha;
 	raster->stride = raster->width*natras->bpp;
 
-	raster->pixels = nil;
-	raster->originalWidth = raster->width;
-	raster->originalHeight = raster->height;
-	raster->originalStride = raster->stride;
-	raster->originalPixels = raster->pixels;
+	natras->autogenMipmap = (raster->format & (Raster::MIPMAP|Raster::AUTOMIPMAP)) == (Raster::MIPMAP|Raster::AUTOMIPMAP);
 }
 
 static Raster*
 rasterCreateTexture(Raster *raster)
 {
 	int32 levels;
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 
 	if(natras->format == D3DFMT_P8)
 		natras->palette = (uint8*)rwNew(4*256, MEMDUR_EVENT | ID_DRIVER);
-	levels = Raster::calculateNumLevels(raster->width, raster->height);
+	if(natras->autogenMipmap)
+		levels = 0;
+	else if(raster->format & Raster::MIPMAP)
+		levels = Raster::calculateNumLevels(raster->width, raster->height);
+	else
+		levels = 1;
+
 	assert(natras->texture == nil);
 	natras->texture = createTexture(raster->width, raster->height,
-	                                raster->format & Raster::MIPMAP ? levels : 1,
+	                                levels,
+	                                natras->autogenMipmap ? D3DUSAGE_AUTOGENMIPMAP : 0,
 	                                natras->format);
 	if(natras->texture == nil){
 		RWERROR((ERR_NOTEXTURE));
@@ -543,13 +447,18 @@ rasterCreateCameraTexture(Raster *raster)
 	}
 
 	int32 levels;
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
-	levels = Raster::calculateNumLevels(raster->width, raster->height);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
+	if(natras->autogenMipmap)
+		levels = 0;
+	else if(raster->format & Raster::MIPMAP)
+		levels = Raster::calculateNumLevels(raster->width, raster->height);
+	else
+		levels = 1;
 
 	IDirect3DTexture9 *tex;
 	d3ddevice->CreateTexture(raster->width, raster->height,
-				raster->format & Raster::MIPMAP ? levels : 1,
-				D3DUSAGE_RENDERTARGET,
+				levels,
+				(natras->autogenMipmap ? D3DUSAGE_AUTOGENMIPMAP : 0) | D3DUSAGE_RENDERTARGET,
 				(D3DFORMAT)natras->format, D3DPOOL_DEFAULT, &tex, nil);
 	assert(natras->texture == nil);
 	natras->texture = tex;
@@ -565,11 +474,9 @@ rasterCreateCameraTexture(Raster *raster)
 static Raster*
 rasterCreateCamera(Raster *raster)
 {
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
-	raster->originalWidth = raster->width;
-	raster->originalHeight = raster->height;
-	raster->originalStride = raster->stride = 0;
-	raster->originalPixels = raster->pixels = nil;
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
+
+	natras->autogenMipmap = 0;
 
 	natras->format = d3d9Globals.present.BackBufferFormat;
 	raster->depth = findFormatDepth(natras->format);
@@ -581,11 +488,9 @@ rasterCreateCamera(Raster *raster)
 static Raster*
 rasterCreateZbuffer(Raster *raster)
 {
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
-	raster->originalWidth = raster->width;
-	raster->originalHeight = raster->height;
-	raster->originalStride = raster->stride = 0;
-	raster->originalPixels = raster->pixels = nil;
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
+
+	natras->autogenMipmap = 0;
 
 	// TODO: allow other formats
 	natras->format = d3d9Globals.present.AutoDepthStencilFormat;
@@ -617,39 +522,53 @@ rasterCreateZbuffer(Raster *raster)
 Raster*
 rasterCreate(Raster *raster)
 {
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
-
 	rasterSetFormat(raster);
 
+	Raster *ret = raster;
+
 	if(raster->width == 0 || raster->height == 0){
 		raster->flags |= Raster::DONTALLOCATE;
 		raster->stride = 0;
-		return raster;
+		goto ret;
 	}
 	if(raster->flags & Raster::DONTALLOCATE)
-		return raster;
+		goto ret;
 
 	switch(raster->type){
 	case Raster::NORMAL:
 	case Raster::TEXTURE:
-		return rasterCreateTexture(raster);
+		ret = rasterCreateTexture(raster);
+		break;
 
 #ifdef RW_D3D9
 	case Raster::CAMERATEXTURE:
-		return rasterCreateCameraTexture(raster);
+		ret = rasterCreateCameraTexture(raster);
+		break;
 	case Raster::ZBUFFER:
-		return rasterCreateZbuffer(raster);
+		ret = rasterCreateZbuffer(raster);
+		break;
 	case Raster::CAMERA:
-		return rasterCreateCamera(raster);
+		ret = rasterCreateCamera(raster);
+		break;
 #endif
+
+	default:
+		RWERROR((ERR_INVRASTER));
+		return nil;
 	}
-	return nil;
+
+ret:
+	raster->originalWidth = raster->width;
+	raster->originalHeight = raster->height;
+	raster->originalStride = raster->stride;
+	raster->originalPixels = raster->pixels;
+	return ret;
 }
 
 uint8*
 rasterLock(Raster *raster, int32 level, int32 lockMode)
 {
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 
 	// check if already locked
 	if(raster->privateFlags & (Raster::PRIVATELOCK_READ|Raster::PRIVATELOCK_WRITE))
@@ -660,7 +579,7 @@ rasterLock(Raster *raster, int32 level, int32 lockMode)
 	if(lockMode & Raster::LOCKREAD)
 		flags |= D3DLOCK_READONLY | D3DLOCK_NO_DIRTY_UPDATE;
 	IDirect3DTexture9 *tex = (IDirect3DTexture9*)natras->texture;
-	IDirect3DSurface9 *surf;
+	IDirect3DSurface9 *surf, *rt;
 	D3DLOCKED_RECT lr;
 
 	switch(raster->type){
@@ -668,7 +587,28 @@ rasterLock(Raster *raster, int32 level, int32 lockMode)
 	case Raster::TEXTURE: {
 		tex->GetSurfaceLevel(level, &surf);
 		natras->lockedSurf = surf;
-		surf->LockRect(&lr, 0, flags);
+		HRESULT res = surf->LockRect(&lr, 0, flags);
+		assert(res == D3D_OK);
+		break;
+		}
+
+	case Raster::CAMERATEXTURE:
+	case Raster::CAMERA: {
+		if(lockMode & Raster::PRIVATELOCK_WRITE)
+			assert(0 && "can't lock framebuffer for writing");
+		if(raster->type == Raster::CAMERA)
+			rt = d3d9Globals.defaultRenderTarget;
+		else
+			tex->GetSurfaceLevel(level, &rt);
+		D3DSURFACE_DESC desc;
+		rt->GetDesc(&desc);
+		HRESULT res = d3ddevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surf, nil);
+		if(res != D3D_OK)
+			return nil;
+		d3ddevice->GetRenderTargetData(rt, surf);
+		natras->lockedSurf = surf;
+		res = surf->LockRect(&lr, 0, flags);
+		assert(res == D3D_OK);
 		break;
 		}
 
@@ -682,22 +622,24 @@ rasterLock(Raster *raster, int32 level, int32 lockMode)
 	raster->stride = lr.Pitch;
 	if(raster->width == 0) raster->width = 1;
 	if(raster->height == 0) raster->height = 1;
-
+#else
+	RasterLevels *levels = (RasterLevels*)natras->texture;
+	raster->pixels = levels->levels[level].data;
+	raster->width = levels->levels[level].width;
+	raster->height = levels->levels[level].height;
+	raster->stride = raster->width*natras->bpp;
+#endif
 	if(lockMode & Raster::LOCKREAD) raster->privateFlags |= Raster::PRIVATELOCK_READ;
 	if(lockMode & Raster::LOCKWRITE) raster->privateFlags |= Raster::PRIVATELOCK_WRITE;
 
 	return raster->pixels;
-#else
-	RasterLevels *levels = (RasterLevels*)natras->texture;
-	return levels->levels[level].data;
-#endif
 }
 
 void
 rasterUnlock(Raster *raster, int32 level)
 {
 #if RW_D3D9
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 	IDirect3DSurface9 *surf = (IDirect3DSurface9*)natras->lockedSurf;
 	surf->UnlockRect();
 	surf->Release();
@@ -714,7 +656,7 @@ rasterUnlock(Raster *raster, int32 level)
 int32
 rasterNumLevels(Raster *raster)
 {
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 #ifdef RW_D3D9
 	IDirect3DTexture9 *tex = (IDirect3DTexture9*)natras->texture;
 	return tex->GetLevelCount();
@@ -799,44 +741,47 @@ rasterFromImage(Raster *raster, Image *image)
 		image = truecolimg;
 	}
 
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
+	int32 format = raster->format&(Raster::PAL8 | Raster::PAL4 | 0xF00);
 	switch(image->depth){
 	case 32:
-		if(raster->format == Raster::C8888)
+		if(format == Raster::C8888)
 			conv = conv_BGRA8888_from_RGBA8888;
-		else if(raster->format == Raster::C888)
+		else if(format == Raster::C888)
 			conv = conv_BGR888_from_RGB888;
 		else
 			goto err;
 		break;
 	case 24:
-		if(raster->format == Raster::C8888)
+		if(format == Raster::C8888)
 			conv = conv_BGRA8888_from_RGB888;
-		else if(raster->format == Raster::C888)
+		else if(format == Raster::C888)
 			conv = conv_BGR888_from_RGB888;
 		else
 			goto err;
 		break;
 	case 16:
-		if(raster->format == Raster::C1555)
+		if(format == Raster::C1555)
 			conv = conv_ARGB1555_from_ARGB1555;
 		else
 			goto err;
 		break;
 	case 8:
-		if(raster->format == (Raster::PAL8 | Raster::C8888))
+		if(format == (Raster::PAL8 | Raster::C8888))
 			conv = conv_8_from_8;
 		else
 			goto err;
 		break;
 	case 4:
-		if(raster->format == (Raster::PAL4 | Raster::C8888) ||
-		   raster->format == (Raster::PAL8 | Raster::C8888))
+		if(format == (Raster::PAL4 | Raster::C8888) ||
+		   format == (Raster::PAL8 | Raster::C8888))
 			conv = conv_8_from_8;
 		else
 			goto err;
+		break;
 	default:
 	err:
+fprintf(stderr, "%d %x\n", image->depth, format); fflush(stdout);
 		RWERROR((ERR_INVRASTER));
 		return 0;
 	}
@@ -857,7 +802,13 @@ rasterFromImage(Raster *raster, Image *image)
 		}
 	}
 
-	uint8 *pixels = raster->lock(0, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+	bool unlock = false;
+	if(raster->pixels == nil){
+		raster->lock(0, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+		unlock = true;
+	}
+
+	uint8 *pixels = raster->pixels;
 	assert(pixels);
 	uint8 *imgpixels = image->pixels;
 
@@ -875,7 +826,8 @@ rasterFromImage(Raster *raster, Image *image)
 		imgpixels += image->stride;
 		pixels += raster->stride;
 	}
-	raster->unlock(0);
+	if(unlock)
+		raster->unlock(0);
 
 	if(truecolimg)
 		truecolimg->destroy();
@@ -888,11 +840,23 @@ rasterToImage(Raster *raster)
 {
 	int32 depth;
 	Image *image;
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+
+	bool unlock = false;
+	if(raster->pixels == nil){
+		raster->lock(0, Raster::LOCKREAD);
+		unlock = true;
+	}
+
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 	if(natras->customFormat){
-		image = Image::create(raster->width, raster->height, 32);
+		int w = raster->width;
+		int h = raster->height;
+		// pixels are in the upper right corner
+		if(w < 4) w = 4;
+		if(h < 4) h = 4;
+		image = Image::create(w, h, 32);
 		image->allocate();
-		uint8 *pix = raster->lock(0, Raster::LOCKREAD);
+		uint8 *pix = raster->pixels;
 		switch(natras->format){
 		case D3DFMT_DXT1:
 			image->setPixelsDXT(1, pix);
@@ -906,11 +870,17 @@ rasterToImage(Raster *raster)
 			image->setPixelsDXT(5, pix);
 			break;
 		default:
-			raster->unlock(0);
 			image->destroy();
+			if(unlock)
+				raster->unlock(0);
 			return nil;
 		}
-		raster->unlock(0);
+		// fix it up again
+		image->width = raster->width;
+		image->height = raster->height;
+
+		if(unlock)
+			raster->unlock(0);
 		return image;
 	}
 
@@ -964,7 +934,7 @@ rasterToImage(Raster *raster)
 	}
 
 	uint8 *imgpixels = image->pixels;
-	uint8 *pixels = raster->lock(0, Raster::LOCKREAD);
+	uint8 *pixels = raster->pixels;
 
 	int x, y;
 	assert(image->width == raster->width);
@@ -980,17 +950,18 @@ rasterToImage(Raster *raster)
 		imgpixels += image->stride;
 		pixels += raster->stride;
 	}
-	raster->unlock(0);
-
 	image->compressPalette();
 
+	if(unlock)
+		raster->unlock(0);
+
 	return image;
 }
 
 int32
 getLevelSize(Raster *raster, int32 level)
 {
-	D3dRaster *ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *ras = GETD3DRASTEREXT(raster);
 #ifdef RW_D3D9
 	IDirect3DTexture9 *tex = (IDirect3DTexture9*)ras->texture;
 	D3DSURFACE_DESC desc;
@@ -1012,11 +983,19 @@ allocateDXT(Raster *raster, int32 dxt, int32 numLevels, bool32 hasAlpha)
 		0x34545844,	// DXT4
 		0x35545844,	// DXT5
 	};
-	D3dRaster *ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *ras = GETD3DRASTEREXT(raster);
 	ras->format = dxtMap[dxt-1];
 	ras->hasAlpha = hasAlpha;
+	ras->customFormat = 1;
+	if(ras->autogenMipmap)
+		numLevels = 0;
+	else if(raster->format & Raster::MIPMAP)
+		{}
+	else
+		numLevels = 1;
 	ras->texture = createTexture(raster->width, raster->height,
-	                             raster->format & Raster::MIPMAP ? numLevels : 1,
+	                             numLevels,
+	                             ras->autogenMipmap ? D3DUSAGE_AUTOGENMIPMAP : 0,
 	                             ras->format);
 	raster->flags &= ~Raster::DONTALLOCATE;
 }
@@ -1024,7 +1003,7 @@ allocateDXT(Raster *raster, int32 dxt, int32 numLevels, bool32 hasAlpha)
 void
 setPalette(Raster *raster, void *palette, int32 size)
 {
-	D3dRaster *ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *ras = GETD3DRASTEREXT(raster);
 	memcpy(ras->palette, palette, 4*size);
 }
 
diff --git a/src/d3d/d3d8.cpp b/src/d3d/d3d8.cpp
index 8932620..671948f 100644
--- a/src/d3d/d3d8.cpp
+++ b/src/d3d/d3d8.cpp
@@ -468,35 +468,61 @@ readAsImage(Stream *stream, int32 width, int32 height, int32 depth, int32 format
 		for(int32 i = 0; i < pallen; i++)
 			palette[i*4+3] = 0xFF;
 
-	// Only read one mipmap	
-	for(int32 i = 0; i < numLevels; i++){
-		uint32 size = stream->readU32();
-		if(i == 0){
-			data = rwNewT(uint8, size, MEMDUR_FUNCTION | ID_IMAGE);
-			stream->read8(data, size);
-		}else
-			stream->seek(size);
-	}
+	Raster *ras = nil;
 
-	if(format & (Raster::PAL4 | Raster::PAL8)){
-		uint8 *idx = data;
-		uint8 *pixels = img->pixels;
-		for(int y = 0; y < img->height; y++){
-			uint8 *line = pixels;
-			for(int x = 0; x < img->width; x++){
-				line[0] = palette[*idx*4+0];
-				line[1] = palette[*idx*4+1];
-				line[2] = palette[*idx*4+2];
-				line[3] = palette[*idx*4+3];
-				line += 4;
-				idx++;
-			}
-			pixels += img->stride;
+	for(int i = 0; i < numLevels; i++){
+		uint32 size = stream->readU32();
+
+		// don't read levels that don't exist
+		if(ras && i >= ras->getNumLevels()){
+			stream->seek(size);
+			continue;
 		}
+
+		// one allocation is enough, first level is largest
+		if(data == nil)
+			data = rwNewT(uint8, size, MEMDUR_FUNCTION | ID_IMAGE);
+		stream->read8(data, size);
+
+		if(ras){
+			ras->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+			img->width = ras->width;
+			img->height = ras->height;
+			img->stride = img->width*img->bpp;
+		}
+
+		if(format & (Raster::PAL4 | Raster::PAL8)){
+			uint8 *idx = data;
+			uint8 *pixels = img->pixels;
+			for(int y = 0; y < img->height; y++){
+				uint8 *line = pixels;
+				for(int x = 0; x < img->width; x++){
+					line[0] = palette[*idx*4+0];
+					line[1] = palette[*idx*4+1];
+					line[2] = palette[*idx*4+2];
+					if(img->bpp > 3)
+						line[3] = palette[*idx*4+3];
+					line += img->bpp;
+					idx++;
+				}
+				pixels += img->stride;
+			}
+		}
+
+		if(ras == nil){
+			// Important to have filled the image with data
+			int32 newformat;
+			Raster::imageFindRasterFormat(img, format&7, &width, &height, &depth, &newformat);
+			newformat |= format & (Raster::MIPMAP | Raster::AUTOMIPMAP);
+			ras = Raster::create(width, height, depth, newformat);
+			ras->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+		}
+
+		ras->setFromImage(img);
+		ras->unlock(i);
 	}
 
 	rwFree(data);
-	Raster *ras = Raster::createFromImage(img, PLATFORM_D3D8);
 	img->destroy();
 	return ras;
 }
@@ -545,13 +571,13 @@ readNativeTexture(Stream *stream)
 	Raster *raster;
 	D3dRaster *ras;
 	if(compression){
-		raster = Raster::create(width, height, depth, format | type | 0x80, PLATFORM_D3D8);
-		ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		raster = Raster::create(width, height, depth, format | type | Raster::DONTALLOCATE, PLATFORM_D3D8);
+		ras = GETD3DRASTEREXT(raster);
 		allocateDXT(raster, compression, numLevels, hasAlpha);
 		ras->customFormat = 1;
 	}else{
 		raster = Raster::create(width, height, depth, format | type, PLATFORM_D3D8);
-		ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		ras = GETD3DRASTEREXT(raster);
 	}
 	tex->raster = raster;
 
@@ -588,7 +614,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
 
 	// Raster
 	Raster *raster = tex->raster;
-	D3dRaster *ras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *ras = GETD3DRASTEREXT(raster);
 	int32 numLevels = raster->getNumLevels();
 	stream->writeI32(raster->format);
 	stream->writeI32(ras->hasAlpha);
diff --git a/src/d3d/d3d8render.cpp b/src/d3d/d3d8render.cpp
index b6eef0e..c5375cb 100644
--- a/src/d3d/d3d8render.cpp
+++ b/src/d3d/d3d8render.cpp
@@ -29,8 +29,8 @@ defaultRenderCB(Atomic *atomic, InstanceDataHeader *header)
 
 	d3d::lightingCB_Fix(atomic);
 
-	Geometry *geo = atomic->geometry;
-	d3d::setRenderState(D3DRS_LIGHTING, !!(geo->flags & rw::Geometry::LIGHT));
+	uint32 flags = atomic->geometry->flags;
+	d3d::setRenderState(D3DRS_LIGHTING, !!(flags & rw::Geometry::LIGHT));
 
 	Frame *f = atomic->getFrame();
 	convMatrix(&world, f->getLTM());
@@ -39,12 +39,12 @@ defaultRenderCB(Atomic *atomic, InstanceDataHeader *header)
 	InstanceData *inst = header->inst;
 	for(uint32 i = 0; i < header->numMeshes; i++){
 		d3d::setTexture(0, inst->material->texture);
-		d3d::setMaterial(inst->material->color, inst->material->surfaceProps);
+		d3d::setMaterial(flags, inst->material->color, inst->material->surfaceProps);
 
 
 		d3d::setRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
 		d3d::setRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
-		if(geo->flags & Geometry::PRELIT)
+		if(flags & Geometry::PRELIT)
 			d3d::setRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_COLOR1);
 		else
 			d3d::setRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
diff --git a/src/d3d/d3d9.cpp b/src/d3d/d3d9.cpp
index 3abe111..851397b 100644
--- a/src/d3d/d3d9.cpp
+++ b/src/d3d/d3d9.cpp
@@ -746,11 +746,12 @@ readNativeTexture(Stream *stream)
 		assert((flags & 2) == 0 && "Can't have cube maps yet");
 		raster = Raster::create(width, height, depth, format | type | Raster::DONTALLOCATE, PLATFORM_D3D9);
 		assert(raster);
-		ext = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		ext = GETD3DRASTEREXT(raster);
 		ext->format = d3dformat;
 		ext->hasAlpha = flags & 1;
 		ext->texture = createTexture(raster->width, raster->height,
 		                             raster->format & Raster::MIPMAP ? numLevels : 1,
+		                             0,
 		                             ext->format);
 		assert(ext->texture);
 		raster->flags &= ~Raster::DONTALLOCATE;
@@ -760,7 +761,7 @@ readNativeTexture(Stream *stream)
 	}else{
 		raster = Raster::create(width, height, depth, format | type, PLATFORM_D3D9);
 		assert(raster);
-		ext = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		ext = GETD3DRASTEREXT(raster);
 	}
 	tex->raster = raster;
 
@@ -799,7 +800,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
 
 	// Raster
 	Raster *raster = tex->raster;
-	D3dRaster *ext = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *ext = GETD3DRASTEREXT(raster);
 	int32 numLevels = raster->getNumLevels();
 	stream->writeI32(raster->format);
 	stream->writeU32(ext->format);
@@ -811,7 +812,9 @@ writeNativeTexture(Texture *tex, Stream *stream)
 	uint8 flags = 0;
 	if(ext->hasAlpha)
 		flags |= 1;
-	// no automipmapgen and cube supported yet
+	// no cube supported yet
+	if(ext->autogenMipmap)
+		flags |= 4;
 	if(ext->customFormat)
 		flags |= 8;
 	stream->writeU8(flags);
diff --git a/src/d3d/d3d9matfx.cpp b/src/d3d/d3d9matfx.cpp
index e85540d..d544e65 100644
--- a/src/d3d/d3d9matfx.cpp
+++ b/src/d3d/d3d9matfx.cpp
@@ -33,9 +33,10 @@ static void *matfx_env_tex_PS;
 enum
 {
 	VSLOC_texMat = VSLOC_afterLights,
+	VSLOC_colorClamp = VSLOC_texMat + 4,
+	VSLOC_envColor,
 
 	PSLOC_shininess = 1,
-	PSLOC_colorClamp = 2
 };
 
 void
@@ -79,14 +80,17 @@ uploadEnvMatrix(Frame *frame)
 		frame = engine->currentCamera->getFrame();
 
 	// cache the matrix across multiple meshes
-	if(frame == lastEnvFrame)
-		return;
-	lastEnvFrame = frame;
+// can't do it, frame matrix may change
+//	if(frame == lastEnvFrame)
+//		return;
+//	lastEnvFrame = frame;
 
 	RawMatrix envMtx, invMtx;
 	Matrix::invert(&invMat, frame->getLTM());
 	convMatrix(&invMtx, &invMat);
 	invMtx.pos.set(0.0f, 0.0f, 0.0f);
+	float uscale = fabs(normal2texcoord.right.x);
+	normal2texcoord.right.x = MatFX::envMapFlipU ? -uscale : uscale;
 	RawMatrix::mult(&envMtx, &invMtx, &normal2texcoord);
 	d3ddevice->SetVertexShaderConstantF(VSLOC_texMat, (float*)&envMtx, 4);
 }
@@ -117,10 +121,16 @@ matfxRender_EnvMap(InstanceDataHeader *header, InstanceData *inst, int32 lightBi
 	fxparams.disableFBA = env->fbAlpha ? 0.0f : 1.0f;
 	d3ddevice->SetPixelShaderConstantF(PSLOC_shininess, (float*)&fxparams, 1);
 	// This clamps the vertex color below. With it we can achieve both PC and PS2 style matfx
-	if(MatFX::modulateEnvMap)
-		d3ddevice->SetPixelShaderConstantF(PSLOC_colorClamp, zero, 1);
+	if(MatFX::envMapApplyLight)
+		d3ddevice->SetVertexShaderConstantF(VSLOC_colorClamp, zero, 1);
 	else
-		d3ddevice->SetPixelShaderConstantF(PSLOC_colorClamp, one, 1);
+		d3ddevice->SetVertexShaderConstantF(VSLOC_colorClamp, one, 1);
+	RGBAf envcol[4];
+	if(MatFX::envMapUseMatColor)
+		convColor(envcol, &m->color);
+	else
+		convColor(envcol, &MatFX::envMapColor);
+	d3ddevice->SetVertexShaderConstantF(VSLOC_envColor, (float*)&envcol, 1);
 
 	// Pick a shader
 	if((lightBits & VSLIGHT_MASK) == 0)
@@ -130,7 +140,7 @@ matfxRender_EnvMap(InstanceDataHeader *header, InstanceData *inst, int32 lightBi
 	else
 		setVertexShader(matfx_env_all_VS);
 
-	bool32 texAlpha = PLUGINOFFSET(D3dRaster, env->tex->raster, nativeRasterOffset)->hasAlpha;
+	bool32 texAlpha = GETD3DRASTEREXT(env->tex->raster)->hasAlpha;
 
 	if(inst->material->texture){
 		d3d::setTexture(0, m->texture);
@@ -149,6 +159,7 @@ void
 matfxRenderCB_Shader(Atomic *atomic, InstanceDataHeader *header)
 {
 	int vsBits;
+	uint32 flags = atomic->geometry->flags;
 	setStreamSource(0, (IDirect3DVertexBuffer9*)header->vertexStream[0].vertexBuffer,
 	                           0, header->vertexStream[0].stride);
 	setIndices((IDirect3DIndexBuffer9*)header->indexBuffer);
@@ -165,7 +176,7 @@ matfxRenderCB_Shader(Atomic *atomic, InstanceDataHeader *header)
 	for(uint32 i = 0; i < header->numMeshes; i++){
 		Material *m = inst->material;
 
-		setMaterial(m->color, m->surfaceProps);
+		setMaterial(flags, m->color, m->surfaceProps);
 
 		MatFX *matfx = MatFX::get(m);
 		if(matfx == nil)
diff --git a/src/d3d/d3d9render.cpp b/src/d3d/d3d9render.cpp
index 0460922..89d937f 100644
--- a/src/d3d/d3d9render.cpp
+++ b/src/d3d/d3d9render.cpp
@@ -145,6 +145,7 @@ void
 defaultRenderCB_Shader(Atomic *atomic, InstanceDataHeader *header)
 {
 	int vsBits;
+	uint32 flags = atomic->geometry->flags;
 	setStreamSource(0, header->vertexStream[0].vertexBuffer, 0, header->vertexStream[0].stride);
 	setIndices(header->indexBuffer);
 	setVertexDeclaration(header->vertexDeclaration);
@@ -166,7 +167,7 @@ defaultRenderCB_Shader(Atomic *atomic, InstanceDataHeader *header)
 
 		SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 255);
 
-		setMaterial(m->color, m->surfaceProps);
+		setMaterial(flags, m->color, m->surfaceProps);
 
 		if(m->texture){
 			d3d::setTexture(0, m->texture);
diff --git a/src/d3d/d3d9skin.cpp b/src/d3d/d3d9skin.cpp
index 23c234d..86c79ab 100644
--- a/src/d3d/d3d9skin.cpp
+++ b/src/d3d/d3d9skin.cpp
@@ -289,7 +289,7 @@ void
 skinRenderCB(Atomic *atomic, InstanceDataHeader *header)
 {
 	int vsBits;
-
+	uint32 flags = atomic->geometry->flags;
 	setStreamSource(0, (IDirect3DVertexBuffer9*)header->vertexStream[0].vertexBuffer,
 	                           0, header->vertexStream[0].stride);
 	setIndices((IDirect3DIndexBuffer9*)header->indexBuffer);
@@ -314,7 +314,7 @@ skinRenderCB(Atomic *atomic, InstanceDataHeader *header)
 
 		SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 255);
 
-		setMaterial(m->color, m->surfaceProps);
+		setMaterial(flags, m->color, m->surfaceProps);
 
 		if(inst->material->texture){
 			d3d::setTexture(0, m->texture);
diff --git a/src/d3d/d3ddevice.cpp b/src/d3d/d3ddevice.cpp
index 7849d37..1f39f18 100644
--- a/src/d3d/d3ddevice.cpp
+++ b/src/d3d/d3ddevice.cpp
@@ -63,6 +63,7 @@ struct RwRasterStateCache {
 	Texture::Addressing addressingU;
 	Texture::Addressing addressingV;
 	Texture::FilterMode filter;
+	int32 maxAniso;
 };
 
 #define MAXNUMSTAGES 8
@@ -77,6 +78,14 @@ struct RwStateCache {
 	uint32 fogenable;
 	RGBA fogcolor;
 	uint32 cullmode;
+	uint32 stencilenable;
+	uint32 stencilpass;
+	uint32 stencilfail;
+	uint32 stencilzfail;
+	uint32 stencilfunc;
+	uint32 stencilref;
+	uint32 stencilmask;
+	uint32 stencilwritemask;
 	uint32 alphafunc;
 	uint32 alpharef;
 
@@ -89,6 +98,7 @@ struct RwStateCache {
 static RwStateCache rwStateCache;
 
 void *constantVertexStream;
+static IDirect3DTexture9 *whiteTex;
 
 D3dShaderState d3dShaderState;
 
@@ -157,6 +167,30 @@ static uint32 blendMap[] = {
 	D3DBLEND_SRCALPHASAT
 };
 
+static uint32 stencilOpMap[] = {
+	D3DSTENCILOP_KEEP,	// actually invalid
+	D3DSTENCILOP_KEEP,
+	D3DSTENCILOP_ZERO,
+	D3DSTENCILOP_REPLACE,
+	D3DSTENCILOP_INCRSAT,
+	D3DSTENCILOP_DECRSAT,
+	D3DSTENCILOP_INVERT,
+	D3DSTENCILOP_INCR,
+	D3DSTENCILOP_DECR
+};
+
+static uint32 stencilFuncMap[] = {
+	D3DCMP_NEVER,	// actually invalid
+	D3DCMP_NEVER,
+	D3DCMP_LESS,
+	D3DCMP_EQUAL,
+	D3DCMP_LESSEQUAL,
+	D3DCMP_GREATER,
+	D3DCMP_NOTEQUAL,
+	D3DCMP_GREATEREQUAL,
+	D3DCMP_ALWAYS
+};
+
 static uint32 alphafuncMap[] = {
 	D3DCMP_ALWAYS,
 	D3DCMP_GREATEREQUAL,
@@ -170,12 +204,16 @@ static uint32 cullmodeMap[] = {
 	D3DCULL_CCW
 };
 
-// TODO: support mipmaps
-static uint32 filterConvMap_NoMIP[] = {
+static uint32 filterConvMap[] = {
 	0, D3DTEXF_POINT, D3DTEXF_LINEAR,
 	   D3DTEXF_POINT, D3DTEXF_LINEAR,
 	   D3DTEXF_POINT, D3DTEXF_LINEAR
 };
+static uint32 filterConvMap_MIP[] = {
+	0, D3DTEXF_NONE, D3DTEXF_NONE,
+	   D3DTEXF_POINT, D3DTEXF_POINT,
+	   D3DTEXF_LINEAR, D3DTEXF_LINEAR
+};
 static uint32 addressConvMap[] = {
 	0, D3DTADDRESS_WRAP, D3DTADDRESS_MIRROR,
 	D3DTADDRESS_CLAMP, D3DTADDRESS_BORDER
@@ -298,14 +336,18 @@ restoreD3d9Device(void)
 	for(i = 0; i < MAXNUMSTAGES; i++){
 		Raster *raster = rwStateCache.texstage[i].raster;
 		if(raster){
-			D3dRaster *d3draster = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+			D3dRaster *d3draster = GETD3DRASTEREXT(raster);
 			d3ddevice->SetTexture(i, (IDirect3DTexture9*)d3draster->texture);
 		}else
 			d3ddevice->SetTexture(i, nil);
 		setSamplerState(i, D3DSAMP_ADDRESSU, addressConvMap[rwStateCache.texstage[i].addressingU]);
 		setSamplerState(i, D3DSAMP_ADDRESSV, addressConvMap[rwStateCache.texstage[i].addressingV]);
-		setSamplerState(i, D3DSAMP_MAGFILTER, filterConvMap_NoMIP[rwStateCache.texstage[i].filter]);
-		setSamplerState(i, D3DSAMP_MINFILTER, filterConvMap_NoMIP[rwStateCache.texstage[i].filter]);
+		setSamplerState(i, D3DSAMP_MAGFILTER, filterConvMap[rwStateCache.texstage[i].filter]);
+		if(rwStateCache.texstage[i].maxAniso == 1)
+			setSamplerState(i, D3DSAMP_MINFILTER, filterConvMap[rwStateCache.texstage[i].filter]);
+		else
+			setSamplerState(i, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
+		setSamplerState(i, D3DSAMP_MIPFILTER, filterConvMap_MIP[rwStateCache.texstage[i].filter]);
 	}
 	for(s = 0; s < MAXNUMSTATES; s++)
 		if(validStates[s])
@@ -325,6 +367,24 @@ restoreD3d9Device(void)
 	d3ddevice->SetIndices(deviceCache.indices);
 	for(i = 0; i < MAXNUMSTREAMS; i++)
 		d3ddevice->SetStreamSource(i, deviceCache.vertexStreams[i].buffer, deviceCache.vertexStreams[i].offset, deviceCache.vertexStreams[i].stride);
+
+	// shader constants are zero now
+	d3dShaderState.fogDirty = true;
+	d3dShaderState.matColor.red = 0;
+	d3dShaderState.matColor.green = 0;
+	d3dShaderState.matColor.blue = 0;
+	d3dShaderState.matColor.alpha = 0;
+	d3dShaderState.surfProps.ambient = 0.0f;
+	d3dShaderState.surfProps.specular = 0.0f;
+	d3dShaderState.surfProps.diffuse = 0.0f;
+	d3dShaderState.extraSurfProp = 0.0f;
+	d3dShaderState.numDir = 0;
+	d3dShaderState.numPoint = 0;
+	d3dShaderState.numSpot = 0;
+	d3dShaderState.ambient.red = 0.0f;
+	d3dShaderState.ambient.green = 0.0f;
+	d3dShaderState.ambient.blue = 0.0f;
+	d3dShaderState.ambient.alpha = 0.0f;
 }
 
 void
@@ -332,7 +392,7 @@ evictD3D9Raster(Raster *raster)
 {
 	int i;
 	// Make sure we're not still referencing this raster
-	D3dRaster *natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+	D3dRaster *natras = GETD3DRASTEREXT(raster);
 	switch(raster->type){
 	case Raster::CAMERATEXTURE:
 		for(i = 0; i < MAXNUMRENDERTARGETS; i++)
@@ -406,11 +466,11 @@ setRasterStage(uint32 stage, Raster *raster)
 		if(raster){
 			assert(raster->platform == PLATFORM_D3D8 ||
 				raster->platform == PLATFORM_D3D9);
-			d3draster = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+			d3draster = GETD3DRASTEREXT(raster);
 			d3ddevice->SetTexture(stage, (IDirect3DTexture9*)d3draster->texture);
 			alpha = d3draster->hasAlpha;
 		}else{
-			d3ddevice->SetTexture(stage, nil);
+			d3ddevice->SetTexture(stage, whiteTex);
 			alpha = 0;
 		}
 		if(stage == 0){
@@ -426,13 +486,24 @@ setRasterStage(uint32 stage, Raster *raster)
 }
 
 static void
-setFilterMode(uint32 stage, int32 filter)
+setFilterMode(uint32 stage, int32 filter, int32 maxAniso = 1)
 {
-	// TODO: mip mapping
 	if(rwStateCache.texstage[stage].filter != (Texture::FilterMode)filter){
 		rwStateCache.texstage[stage].filter = (Texture::FilterMode)filter;
-		setSamplerState(stage, D3DSAMP_MAGFILTER, filterConvMap_NoMIP[filter]);
-		setSamplerState(stage, D3DSAMP_MINFILTER, filterConvMap_NoMIP[filter]);
+		setSamplerState(stage, D3DSAMP_MAGFILTER, filterConvMap[filter]);
+		if(maxAniso == 1)
+			setSamplerState(stage, D3DSAMP_MINFILTER, filterConvMap[filter]);
+		else
+			setSamplerState(stage, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
+		setSamplerState(stage, D3DSAMP_MIPFILTER, filterConvMap_MIP[filter]);
+	}
+	if(rwStateCache.texstage[stage].maxAniso != maxAniso){
+		rwStateCache.texstage[stage].maxAniso = maxAniso;
+		if(maxAniso == 1)
+			setSamplerState(stage, D3DSAMP_MINFILTER, filterConvMap[filter]);
+		else
+			setSamplerState(stage, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
+		setSamplerState(stage, D3DSAMP_MAXANISOTROPY, maxAniso);
 	}
 }
 
@@ -462,7 +533,7 @@ setTexture(uint32 stage, Texture *tex)
 		return;
 	}
 	if(tex->raster){
-		setFilterMode(stage, tex->getFilter());
+		setFilterMode(stage, tex->getFilter(), tex->getMaxAnisotropy());
 		setAddressU(stage, tex->getAddressU());
 		setAddressV(stage, tex->getAddressV());
 	}
@@ -517,7 +588,7 @@ setMaterial_fix(const RGBA &color, const SurfaceProperties &surfProps)
 
 
 void
-setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops)
+setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp)
 {
 	if(!equal(d3dShaderState.matColor, color)){
 		rw::RGBAf col;
@@ -528,14 +599,16 @@ setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops)
 
 	if(d3dShaderState.surfProps.ambient != surfaceprops.ambient ||
 	   d3dShaderState.surfProps.specular != surfaceprops.specular ||
-	   d3dShaderState.surfProps.diffuse != surfaceprops.diffuse){
+	   d3dShaderState.surfProps.diffuse != surfaceprops.diffuse ||
+	   d3dShaderState.extraSurfProp != extraSurfProp){
 		float surfProps[4];
 		surfProps[0] = surfaceprops.ambient;
 		surfProps[1] = surfaceprops.specular;
 		surfProps[2] = surfaceprops.diffuse;
-		surfProps[3] = 0.0f;
+		surfProps[3] = extraSurfProp;
 		d3ddevice->SetVertexShaderConstantF(VSLOC_surfProps, surfProps, 1);
 		d3dShaderState.surfProps = surfaceprops;
+		d3dShaderState.extraSurfProp = extraSurfProp;
 	}
 }
 
@@ -608,6 +681,56 @@ setRwRenderState(int32 state, void *pvalue)
 			setRenderState(D3DRS_CULLMODE, cullmodeMap[value]);
 		}
 		break;
+
+	case STENCILENABLE:
+		if(rwStateCache.stencilenable != bval){
+			rwStateCache.stencilenable = bval;
+			setRenderState(D3DRS_STENCILENABLE, bval);
+		}
+		break;
+	case STENCILFAIL:
+		if(rwStateCache.stencilfail != value){
+			rwStateCache.stencilfail = value;
+			setRenderState(D3DRS_STENCILFAIL, stencilOpMap[value]);
+		}
+		break;
+	case STENCILZFAIL:
+		if(rwStateCache.stencilzfail != value){
+			rwStateCache.stencilzfail = value;
+			setRenderState(D3DRS_STENCILZFAIL, stencilOpMap[value]);
+		}
+		break;
+	case STENCILPASS:
+		if(rwStateCache.stencilpass != value){
+			rwStateCache.stencilpass = value;
+			setRenderState(D3DRS_STENCILPASS, stencilOpMap[value]);
+		}
+		break;
+	case STENCILFUNCTION:
+		if(rwStateCache.stencilfunc != value){
+			rwStateCache.stencilfunc = value;
+			setRenderState(D3DRS_STENCILFUNC, stencilFuncMap[value]);
+		}
+		break;
+	case STENCILFUNCTIONREF:
+		if(rwStateCache.stencilref != value){
+			rwStateCache.stencilref = value;
+			setRenderState(D3DRS_STENCILREF, value);
+		}
+		break;
+	case STENCILFUNCTIONMASK:
+		if(rwStateCache.stencilmask != value){
+			rwStateCache.stencilmask = value;
+			setRenderState(D3DRS_STENCILMASK, value);
+		}
+		break;
+	case STENCILFUNCTIONWRITEMASK:
+		if(rwStateCache.stencilwritemask != value){
+			rwStateCache.stencilwritemask = value;
+			setRenderState(D3DRS_STENCILWRITEMASK, value);
+		}
+		break;
+
 	case ALPHATESTFUNC:
 		if(rwStateCache.alphafunc != value){
 			rwStateCache.alphafunc = value;
@@ -677,6 +800,32 @@ getRwRenderState(int32 state)
 	case CULLMODE:
 		val = rwStateCache.cullmode;
 		break;
+
+	case STENCILENABLE:
+		val = rwStateCache.stencilenable;
+		break;
+	case STENCILFAIL:
+		val = rwStateCache.stencilfail;
+		break;
+	case STENCILZFAIL:
+		val = rwStateCache.stencilzfail;
+		break;
+	case STENCILPASS:
+		val = rwStateCache.stencilpass;
+		break;
+	case STENCILFUNCTION:
+		val = rwStateCache.stencilfunc;
+		break;
+	case STENCILFUNCTIONREF:
+		val = rwStateCache.stencilref;
+		break;
+	case STENCILFUNCTIONMASK:
+		val = rwStateCache.stencilmask;
+		break;
+	case STENCILFUNCTIONWRITEMASK:
+		val = rwStateCache.stencilwritemask;
+		break;
+
 	case ALPHATESTFUNC:
 		val = rwStateCache.alphafunc;
 		break;
@@ -795,7 +944,10 @@ setRenderSurfaces(Camera *cam)
 	Raster *fbuf = cam->frameBuffer;
 	assert(fbuf);
 	{
-		D3dRaster *natras = PLUGINOFFSET(D3dRaster, fbuf, nativeRasterOffset);
+		if(fbuf->parent)
+			fbuf = fbuf->parent;
+
+		D3dRaster *natras = GETD3DRASTEREXT(fbuf);
 		assert(fbuf->type == Raster::CAMERA || fbuf->type == Raster::CAMERATEXTURE);
 		if(natras->texture == nil)
 			setRenderTarget(0, d3d9Globals.defaultRenderTarget);
@@ -810,7 +962,10 @@ setRenderSurfaces(Camera *cam)
 
 	Raster *zbuf = cam->zBuffer;
 	if(zbuf){
-		D3dRaster *natras = PLUGINOFFSET(D3dRaster, zbuf, nativeRasterOffset);
+		if(zbuf->parent)
+			zbuf = zbuf->parent;
+
+		D3dRaster *natras = GETD3DRASTEREXT(zbuf);
 		assert(zbuf->type == Raster::ZBUFFER);
 		setDepthSurface(natras->texture);
 	}else
@@ -818,6 +973,19 @@ setRenderSurfaces(Camera *cam)
 
 }
 
+static void
+setViewport(Raster *fb)
+{
+	D3DVIEWPORT9 vp;
+	vp.MinZ = 0.0f;
+	vp.MaxZ = 1.0f;
+	vp.X = fb->offsetX;
+	vp.Y = fb->offsetY;
+	vp.Width = fb->width;
+	vp.Height = fb->height;
+	d3ddevice->SetViewport(&vp);
+}
+
 static void
 beginUpdate(Camera *cam)
 {
@@ -897,23 +1065,14 @@ beginUpdate(Camera *cam)
 
 	setRenderSurfaces(cam);
 
-	D3DVIEWPORT9 vp;
-	vp.MinZ = 0.0f;
-	vp.MaxZ = 1.0f;
-	vp.X = cam->frameBuffer->offsetX;
-	vp.Y = cam->frameBuffer->offsetY;
-	vp.Width = cam->frameBuffer->width;
-	vp.Height = cam->frameBuffer->height;
-	d3ddevice->SetViewport(&vp);
+	setViewport(cam->frameBuffer);
 
-	// TODO: figure out when to call this
 	d3ddevice->BeginScene();
 }
 
 static void
 endUpdate(Camera *cam)
 {
-	// TODO: figure out when to call this
 	d3ddevice->EndScene();
 }
 
@@ -950,7 +1109,7 @@ releaseVidmemRasters(void)
 	D3dRaster *natras;
 	for(vmr = vidmemRasters; vmr; vmr = vmr->next){
 		raster = vmr->raster;
-		natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		natras = GETD3DRASTEREXT(raster);
 		switch(raster->type){
 		case Raster::CAMERATEXTURE:
 			destroyTexture(natras->texture);
@@ -976,11 +1135,11 @@ recreateVidmemRasters(void)
 	D3dRaster *natras;
 	for(vmr = vidmemRasters; vmr; vmr = vmr->next){
 		raster = vmr->raster;
-		natras = PLUGINOFFSET(D3dRaster, raster, nativeRasterOffset);
+		natras = GETD3DRASTEREXT(raster);
 		switch(raster->type){
 		case Raster::CAMERATEXTURE: {
 			int32 levels = Raster::calculateNumLevels(raster->width, raster->height);
-			IDirect3DTexture9 *tex;
+			IDirect3DTexture9 *tex = nil;
 			d3ddevice->CreateTexture(raster->width, raster->height,
 						raster->format & Raster::MIPMAP ? levels : 1,
 						D3DUSAGE_RENDERTARGET,
@@ -1158,12 +1317,13 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
 		mode |= D3DCLEAR_TARGET;
 	if(mode & Camera::CLEARZ)
 		mode |= D3DCLEAR_ZBUFFER;
+	if(mode & Camera::CLEARSTENCIL)
+		mode |= D3DCLEAR_STENCIL;
 	D3DCOLOR c = D3DCOLOR_RGBA(col->red, col->green, col->blue, col->alpha);
 
 	RECT r;
 	GetClientRect(d3d9Globals.window, &r);
 	BOOL icon = IsIconic(d3d9Globals.window);
-	Raster *ras = cam->frameBuffer;
 	if(!icon &&
 	   (r.right != d3d9Globals.present.BackBufferWidth || r.bottom != d3d9Globals.present.BackBufferHeight)){
 
@@ -1177,7 +1337,8 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
 
 	setRenderSurfaces(cam);
 
-	d3ddevice->Clear(0, 0, mode, c, 1.0f, 0);
+	setViewport(cam->frameBuffer);	// need to set this for the clear to work correctly
+	d3ddevice->Clear(0, nil, mode, c, 1.0f, 0);
 }
 
 static void
@@ -1216,8 +1377,8 @@ rasterRenderFast(Raster *raster, int32 x, int32 y)
 
 	Raster *src = raster;
 	Raster *dst = Raster::getCurrentContext();
-	D3dRaster *natdst = PLUGINOFFSET(D3dRaster, dst, nativeRasterOffset);
-	D3dRaster *natsrc = PLUGINOFFSET(D3dRaster, src, nativeRasterOffset);
+	D3dRaster *natdst = GETD3DRASTEREXT(dst);
+	D3dRaster *natsrc = GETD3DRASTEREXT(src);
 
 	switch(dst->type){
 	case Raster::CAMERATEXTURE:
@@ -1440,7 +1601,8 @@ startD3D(void)
 	d3d9Globals.present.BackBufferHeight           = height;
 	d3d9Globals.present.BackBufferFormat           = format;
 	d3d9Globals.present.BackBufferCount            = 1;
-	d3d9Globals.present.MultiSampleType            = D3DMULTISAMPLE_NONE;
+	d3d9Globals.present.MultiSampleType            = d3d9Globals.msLevel == 1 ?
+		D3DMULTISAMPLE_NONE : (D3DMULTISAMPLE_TYPE)d3d9Globals.msLevel;
 	d3d9Globals.present.MultiSampleQuality         = 0;
 	d3d9Globals.present.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
 	d3d9Globals.present.hDeviceWindow              = d3d9Globals.window;
@@ -1452,6 +1614,8 @@ startD3D(void)
 //	d3d9Globals.present.PresentationInterval       = D3DPRESENT_INTERVAL_ONE;
 	d3d9Globals.present.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
 
+	rw::d3d::isP8supported = 0;
+
 	assert(d3d::d3ddevice == nil);
 
 	BOOL icon = IsIconic(d3d9Globals.window);
@@ -1471,6 +1635,7 @@ initD3D(void)
 {
 	int32 s, t;
 
+	memset(&deviceCache, 0, sizeof(deviceCache));
 	d3ddevice->GetRenderTarget(0, &d3d9Globals.defaultRenderTarget);
 	d3d9Globals.defaultRenderTarget->Release();	// refcount increased by Get
 	deviceCache.renderTargets[0] = d3d9Globals.defaultRenderTarget;
@@ -1530,6 +1695,23 @@ initD3D(void)
 	rwStateCache.vertexAlpha = 0;
 	rwStateCache.textureAlpha = 0;
 
+	rwStateCache.stencilenable = 0;
+	d3ddevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
+	rwStateCache.stencilfail = STENCILKEEP;
+	d3ddevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
+	rwStateCache.stencilzfail = STENCILKEEP;
+	d3ddevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
+	rwStateCache.stencilpass = STENCILKEEP;
+	d3ddevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
+	rwStateCache.stencilfunc = STENCILALWAYS;
+	d3ddevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
+	rwStateCache.stencilref = 0;
+	d3ddevice->SetRenderState(D3DRS_STENCILREF, 0);
+	rwStateCache.stencilmask = 0xFFFFFFFF;
+	d3ddevice->SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF);
+	rwStateCache.stencilwritemask = 0xFFFFFFFF;
+	d3ddevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
+
 	setTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
 //	setTextureStageState(0, D3DTSS_CONSTANT, 0xFFFFFFFF);
 //	setTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
@@ -1684,6 +1866,17 @@ initD3D(void)
 		setAddressV(t, Texture::WRAP);
 	}
 
+	IDirect3DSurface9 *surf;
+	D3DLOCKED_RECT lr;
+	uint8 whitepixel[4] = {0xFF, 0xFF, 0xFF, 0xFF};
+	whiteTex = (IDirect3DTexture9*)createTexture(1, 1, 1, 0, D3DFMT_X8R8G8B8);
+	whiteTex->GetSurfaceLevel(0, &surf);
+	HRESULT res = surf->LockRect(&lr, 0, D3DLOCK_NOSYSLOCK);
+	assert(res == D3D_OK);
+	memcpy(lr.pBits, whitepixel, 4);
+	surf->UnlockRect();
+	surf->Release();
+
 	openIm2D();
 	openIm3D();
 
@@ -1696,6 +1889,9 @@ termD3D(void)
 	destroyVertexBuffer(constantVertexStream);
 	constantVertexStream = nil;
 
+	destroyTexture(whiteTex);
+	whiteTex = nil;
+
 	closeIm3D();
 	closeIm2D();
 
@@ -1778,6 +1974,26 @@ deviceSystem(DeviceReq req, void *arg, int32 n)
 		rwmode->depth = findFormatDepth(d3d9Globals.modes[n].mode.Format);
 		rwmode->flags = d3d9Globals.modes[n].flags;
 		return 1;
+	case DEVICEGETMAXMULTISAMPLINGLEVELS:
+		{
+			assert(d3d9Globals.d3d9 != nil);
+			uint32 level;
+			DWORD quality;
+			for (level = D3DMULTISAMPLE_16_SAMPLES; level > D3DMULTISAMPLE_NONMASKABLE; level--) {
+				if (SUCCEEDED(d3d9Globals.d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, d3d9Globals.startMode.mode.Format,
+				                                                           !(d3d9Globals.startMode.flags & VIDEOMODEEXCLUSIVE), (D3DMULTISAMPLE_TYPE)level,
+				                                                           &quality)))
+					return level;
+			}
+		}
+		return 1;
+	case DEVICEGETMULTISAMPLINGLEVELS:
+		if(d3d9Globals.msLevel == 0)
+			return 1;
+		return d3d9Globals.msLevel;
+	case DEVICESETMULTISAMPLINGLEVELS:
+		d3d9Globals.msLevel = (uint32)n;
+		return 1;
 	}
 	return 1;
 }
diff --git a/src/d3d/d3dimmed.cpp b/src/d3d/d3dimmed.cpp
index 7376591..331434b 100644
--- a/src/d3d/d3dimmed.cpp
+++ b/src/d3d/d3dimmed.cpp
@@ -43,7 +43,9 @@ void
 openIm2D(void)
 {
 	D3DVERTEXELEMENT9 elements[4] = {
-		{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0 },
+// can't get proper fog with this :(
+//		{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0 },
+		{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
 		{ 0, offsetof(Im2DVertex, color), D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
 		{ 0, offsetof(Im2DVertex, u), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
 		D3DDECL_END()
@@ -99,6 +101,20 @@ im2DRenderTriangle(void *vertices, int32 numVertices, int32 vert1, int32 vert2,
 	im2DRenderPrimitive(PRIMTYPETRILIST, tmpprimbuf, 3);
 }
 
+void
+im2DSetXform(void)
+{
+	float xform[4];
+	Camera *cam;
+	cam = (Camera*)engine->currentCamera;
+	xform[0] = 2.0f/cam->frameBuffer->width;
+	xform[1] = -2.0f/cam->frameBuffer->height;
+	xform[2] = -1.0f;
+	xform[3] = 1.0f;
+	// TODO: should cache this...
+	d3ddevice->SetVertexShaderConstantF(VSLOC_afterLights, xform, 1);
+}
+
 void
 im2DRenderPrimitive(PrimitiveType primType, void *vertices, int32 numVertices)
 {
@@ -113,6 +129,9 @@ im2DRenderPrimitive(PrimitiveType primType, void *vertices, int32 numVertices)
 	setStreamSource(0, im2dvertbuf, 0, sizeof(Im2DVertex));
 	setVertexDeclaration(im2ddecl);
 
+	im2DSetXform();
+
+	setVertexShader(im2d_VS);
 	if(im2dOverridePS)
 		setPixelShader(im2dOverridePS);
 	else if(engine->device.getRenderState(TEXTURERASTER))
@@ -167,6 +186,9 @@ im2DRenderIndexedPrimitive(PrimitiveType primType,
 	setIndices(im2dindbuf);
 	setVertexDeclaration(im2ddecl);
 
+	im2DSetXform();
+
+	setVertexShader(im2d_VS);
 	if(im2dOverridePS)
 		setPixelShader(im2dOverridePS);
 	else if(engine->device.getRenderState(TEXTURERASTER))
diff --git a/src/d3d/d3drender.cpp b/src/d3d/d3drender.cpp
index 2820a46..86b7edc 100644
--- a/src/d3d/d3drender.cpp
+++ b/src/d3d/d3drender.cpp
@@ -27,6 +27,7 @@ void *default_amb_dir_VS;
 void *default_all_VS;
 void *default_PS;
 void *default_tex_PS;
+void *im2d_VS;
 void *im2d_PS;
 void *im2d_tex_PS;
 
@@ -66,6 +67,12 @@ createDefaultShaders(void)
 		assert(default_tex_PS);
 	}
 
+	{
+		static
+#include "shaders/im2d_VS.h"
+		im2d_VS = createVertexShader((void*)VS_NAME);
+		assert(im2d_VS);
+	}
 	{
 		static
 #include "shaders/im2d_PS.h"
@@ -95,6 +102,8 @@ destroyDefaultShaders(void)
 	destroyPixelShader(default_tex_PS);
 	default_tex_PS = nil;
 
+	destroyVertexShader(im2d_VS);
+	im2d_VS = nil;
 	destroyPixelShader(im2d_PS);
 	im2d_PS = nil;
 	destroyPixelShader(im2d_tex_PS);
diff --git a/src/d3d/rwd3d.h b/src/d3d/rwd3d.h
index 8a55467..4ce29be 100644
--- a/src/d3d/rwd3d.h
+++ b/src/d3d/rwd3d.h
@@ -64,15 +64,17 @@ struct Im3DVertex
 struct Im2DVertex
 {
 	float32 x, y, z;
-	float32 q;
+	//float32 q;	// recipz no longer used because we have a vertex stage now
+	float32 w;
 	uint32 color;
 	float32 u, v;
 
 	void setScreenX(float32 x) { this->x = x; }
 	void setScreenY(float32 y) { this->y = y; }
 	void setScreenZ(float32 z) { this->z = z; }
-	void setCameraZ(float32 z) { }
-	void setRecipCameraZ(float32 recipz) { this->q = recipz; }
+	void setCameraZ(float32 z) { this->w = z; }
+//	void setRecipCameraZ(float32 recipz) { this->q = recipz; }
+	void setRecipCameraZ(float32 recipz) { this->w = 1.0f/recipz; }
 	void setColor(uint8 r, uint8 g, uint8 b, uint8 a) { this->color = COLOR_ARGB(a, r, g, b); }
 	void setU(float32 u, float recipZ) { this->u = u; }
 	void setV(float32 v, float recipZ) { this->v = v; }
@@ -80,8 +82,10 @@ struct Im2DVertex
 	float getScreenX(void) { return this->x; }
 	float getScreenY(void) { return this->y; }
 	float getScreenZ(void) { return this->z; }
-	float getCameraZ(void) { return 1.0f/this->q; }
-	float getRecipCameraZ(void) { return this->q; }
+//	float getCameraZ(void) { return 1.0f/this->q; }
+//	float getRecipCameraZ(void) { return this->q; }
+	float getCameraZ(void) { return this->w; }
+	float getRecipCameraZ(void) { return 1.0f/this->w; }
 	RGBA getColor(void) { return makeRGBA(this->color>>16 & 0xFF, this->color>>8 & 0xFF,
 		this->color & 0xFF, this->color>>24 & 0xFF); }
 	float getU(void) { return this->u; }
@@ -89,6 +93,105 @@ struct Im2DVertex
 };
 
 #else
+#ifndef MAKEFOURCC
+#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
+            ((uint32)(uint8)(ch0) | ((uint32)(uint8)(ch1) << 8) |       \
+            ((uint32)(uint8)(ch2) << 16) | ((uint32)(uint8)(ch3) << 24 ))
+#endif
+enum {
+	D3DFMT_UNKNOWN              =  0,
+
+	D3DFMT_R8G8B8               = 20,
+	D3DFMT_A8R8G8B8             = 21,
+	D3DFMT_X8R8G8B8             = 22,
+	D3DFMT_R5G6B5               = 23,
+	D3DFMT_X1R5G5B5             = 24,
+	D3DFMT_A1R5G5B5             = 25,
+	D3DFMT_A4R4G4B4             = 26,
+	D3DFMT_R3G3B2               = 27,
+	D3DFMT_A8                   = 28,
+	D3DFMT_A8R3G3B2             = 29,
+	D3DFMT_X4R4G4B4             = 30,
+	D3DFMT_A2B10G10R10          = 31,
+	D3DFMT_A8B8G8R8             = 32,
+	D3DFMT_X8B8G8R8             = 33,
+	D3DFMT_G16R16               = 34,
+	D3DFMT_A2R10G10B10          = 35,
+	D3DFMT_A16B16G16R16         = 36,
+
+	D3DFMT_A8P8                 = 40,
+	D3DFMT_P8                   = 41,
+
+	D3DFMT_L8                   = 50,
+	D3DFMT_A8L8                 = 51,
+	D3DFMT_A4L4                 = 52,
+
+	D3DFMT_V8U8                 = 60,
+	D3DFMT_L6V5U5               = 61,
+	D3DFMT_X8L8V8U8             = 62,
+	D3DFMT_Q8W8V8U8             = 63,
+	D3DFMT_V16U16               = 64,
+	D3DFMT_A2W10V10U10          = 67,
+
+	D3DFMT_UYVY                 = MAKEFOURCC('U', 'Y', 'V', 'Y'),
+	D3DFMT_R8G8_B8G8            = MAKEFOURCC('R', 'G', 'B', 'G'),
+	D3DFMT_YUY2                 = MAKEFOURCC('Y', 'U', 'Y', '2'),
+	D3DFMT_G8R8_G8B8            = MAKEFOURCC('G', 'R', 'G', 'B'),
+	D3DFMT_DXT1                 = MAKEFOURCC('D', 'X', 'T', '1'),
+	D3DFMT_DXT2                 = MAKEFOURCC('D', 'X', 'T', '2'),
+	D3DFMT_DXT3                 = MAKEFOURCC('D', 'X', 'T', '3'),
+	D3DFMT_DXT4                 = MAKEFOURCC('D', 'X', 'T', '4'),
+	D3DFMT_DXT5                 = MAKEFOURCC('D', 'X', 'T', '5'),
+
+	D3DFMT_D16_LOCKABLE         = 70,
+	D3DFMT_D32                  = 71,
+	D3DFMT_D15S1                = 73,
+	D3DFMT_D24S8                = 75,
+	D3DFMT_D24X8                = 77,
+	D3DFMT_D24X4S4              = 79,
+	D3DFMT_D16                  = 80,
+
+	D3DFMT_D32F_LOCKABLE        = 82,
+	D3DFMT_D24FS8               = 83,
+
+	// d3d9ex only
+	/* Z-Stencil formats valid for CPU access */
+	D3DFMT_D32_LOCKABLE         = 84,
+	D3DFMT_S8_LOCKABLE          = 85,
+
+	D3DFMT_L16                  = 81,
+
+	D3DFMT_VERTEXDATA           =100,
+	D3DFMT_INDEX16              =101,
+	D3DFMT_INDEX32              =102,
+
+	D3DFMT_Q16W16V16U16         =110,
+
+	D3DFMT_MULTI2_ARGB8         = MAKEFOURCC('M','E','T','1'),
+
+	// Floating point surface formats
+
+	// s10e5 formats (16-bits per channel)
+	D3DFMT_R16F                 = 111,
+	D3DFMT_G16R16F              = 112,
+	D3DFMT_A16B16G16R16F        = 113,
+
+	// IEEE s23e8 formats (32-bits per channel)
+	D3DFMT_R32F                 = 114,
+	D3DFMT_G32R32F              = 115,
+	D3DFMT_A32B32G32R32F        = 116,
+
+	D3DFMT_CxV8U8               = 117,
+
+	// d3d9ex only
+	// Monochrome 1 bit per pixel format
+	D3DFMT_A1                   = 118,
+	// 2.8 biased fixed point
+	D3DFMT_A2B10G10R10_XR_BIAS  = 119,
+	// Binary format indicating that the data has no inherent type
+	D3DFMT_BINARYBUFFER         = 199
+};
+
 enum {
 	D3DLOCK_NOSYSLOCK     =  0,  // ignored
 	D3DPOOL_MANAGED       =  0,  // ignored
@@ -135,6 +238,9 @@ enum {
 	D3DDECLUSAGE_FOG,           // 11
 	D3DDECLUSAGE_DEPTH,         // 12
 	D3DDECLUSAGE_SAMPLE         // 13
+	,
+
+	D3DUSAGE_AUTOGENMIPMAP = 0x400
 };
 #endif
 
@@ -150,7 +256,7 @@ void destroyVertexBuffer(void *vertexBuffer);
 uint8 *lockVertices(void *vertexBuffer, uint32 offset, uint32 size, uint32 flags);
 void unlockVertices(void *vertexBuffer);
 
-void *createTexture(int32 width, int32 height, int32 levels, uint32 format);
+void *createTexture(int32 width, int32 height, int32 levels, uint32 usage, uint32 format);
 void destroyTexture(void *texture);
 uint8 *lockTexture(void *texture, int32 level);
 void unlockTexture(void *texture, int32 level);
@@ -164,8 +270,9 @@ struct D3dRaster
 	void *lockedSurf;
 	uint32 format;
 	uint32 bpp;	// bytes per pixel
-	bool32 hasAlpha;
-	bool32 customFormat;
+	bool hasAlpha;
+	bool customFormat;
+	bool autogenMipmap;
 };
 
 int32 getLevelSize(Raster *raster, int32 level);
@@ -175,6 +282,7 @@ void setTexels(Raster *raster, void *texels, int32 level);
 
 extern int32 nativeRasterOffset;
 void registerNativeRaster(void);
+#define GETD3DRASTEREXT(raster) PLUGINOFFSET(rw::d3d::D3dRaster, raster, rw::d3d::nativeRasterOffset)
 
 // Rendering
 
@@ -187,7 +295,15 @@ void getSamplerState(uint32 stage, uint32 type, uint32 *value);
 void flushCache(void);
 
 void setTexture(uint32 stage, Texture *tex);
-void setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops);
+void setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp = 0.0f);
+inline void setMaterial(uint32 flags, const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp = 0.0f)
+{
+	static RGBA white = { 255, 255, 255, 255 };
+	if(flags & Geometry::MODULATE)
+		setMaterial(color, surfaceprops, extraSurfProp);
+	else
+		setMaterial(white, surfaceprops, extraSurfProp);
+}
 
 void setVertexShader(void *vs);
 void setPixelShader(void *ps);
@@ -226,6 +342,7 @@ struct D3dShaderState
 	} fogData, fogDisable;
 	RGBA matColor;
 	SurfaceProperties surfProps;
+	float extraSurfProp;
 	float lightOffset[3];
 	int32 numDir, numPoint, numSpot;
 	RGBAf ambient;
@@ -272,6 +389,8 @@ int32 lightingCB_Shader(Atomic *atomic);
 // for VS
 void uploadMatrices(void);	// no world transform
 void uploadMatrices(Matrix *worldMat);
+void setAmbient(const RGBAf &color);
+void setNumLights(int numDir, int numPoint, int numSpot);
 int32 uploadLights(WorldLights *lightData);	// called by lightingCB_Shader
 
 extern void *im2dOverridePS;
@@ -281,6 +400,7 @@ extern void *default_amb_dir_VS;
 extern void *default_all_VS;
 extern void *default_PS;
 extern void *default_tex_PS;
+extern void *im2d_VS;
 extern void *im2d_PS;
 extern void *im2d_tex_PS;
 void createDefaultShaders(void);
diff --git a/src/d3d/rwd3d9.h b/src/d3d/rwd3d9.h
index ea3c0e4..03eccd5 100644
--- a/src/d3d/rwd3d9.h
+++ b/src/d3d/rwd3d9.h
@@ -94,6 +94,7 @@ ObjPipeline *makeDefaultPipeline(void);
 void initSkin(void);
 void uploadSkinMatrices(Atomic *atomic);
 void skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance);
+void skinRenderCB(Atomic *atomic, InstanceDataHeader *header);
 ObjPipeline *makeSkinPipeline(void);
 
 // MatFX plugin
diff --git a/src/d3d/rwd3dimpl.h b/src/d3d/rwd3dimpl.h
index caa6fc1..82f8a13 100644
--- a/src/d3d/rwd3dimpl.h
+++ b/src/d3d/rwd3dimpl.h
@@ -35,6 +35,8 @@ struct D3d9Globals
 	int numModes;
 	int currentMode;
 	DisplayMode startMode;
+	
+	uint32 msLevel;
 
 	D3DPRESENT_PARAMETERS present;
 
diff --git a/src/d3d/rwxbox.h b/src/d3d/rwxbox.h
index fef8284..1abebe1 100644
--- a/src/d3d/rwxbox.h
+++ b/src/d3d/rwxbox.h
@@ -84,7 +84,9 @@ struct XboxRaster
 	void *texture;
 	void *palette;
 	uint32 format;
-	bool32 hasAlpha;
+	uint32 bpp;	// bytes per pixel
+	bool hasAlpha;
+	bool customFormat;
 	bool32 unknownFlag;
 };
 
@@ -92,6 +94,7 @@ int32 getLevelSize(Raster *raster, int32 level);
 
 extern int32 nativeRasterOffset;
 void registerNativeRaster(void);
+#define GETXBOXRASTEREXT(raster) PLUGINOFFSET(rw::xbox::XboxRaster, raster, rw::xbox::nativeRasterOffset)
 
 Texture *readNativeTexture(Stream *stream);
 void writeNativeTexture(Texture *tex, Stream *stream);
diff --git a/src/d3d/shaders/im2d_PS.h b/src/d3d/shaders/im2d_PS.h
index 0a5c28d..71f8b28 100644
--- a/src/d3d/shaders/im2d_PS.h
+++ b/src/d3d/shaders/im2d_PS.h
@@ -4,22 +4,47 @@
 //
 //   fxc /nologo /T ps_2_0 /Fh im2d_PS.h im2d_PS.hlsl
 //
-    ps_2_0
-    dcl v0
-    mov oC0, v0
+//
+// Parameters:
+//
+//   float4 fogColor;
+//
+//
+// Registers:
+//
+//   Name         Reg   Size
+//   ------------ ----- ----
+//   fogColor     c0       1
+//
 
-// approximately 1 instruction slot used
+    ps_2_0
+    dcl t0.xyz
+    dcl v0
+    add r0.xyz, v0, -c0
+    mad r0.xyz, t0.z, r0, c0
+    mov r0.w, v0.w
+    mov oC0, r0
+
+// approximately 4 instruction slots used
 #endif
 
 const BYTE g_ps20_main[] =
 {
       0,   2, 255, 255, 254, 255, 
-     22,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0,  35,   0, 
+     34,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0,  83,   0, 
       0,   0,   0,   2, 255, 255, 
-      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-     28,   0,   0,   0, 112, 115, 
+     76,   0,   0,   0,  48,   0, 
+      0,   0,   2,   0,   0,   0, 
+      1,   0,   2,   0,  60,   0, 
+      0,   0,   0,   0,   0,   0, 
+    102, 111, 103,  67, 111, 108, 
+    111, 114,   0, 171, 171, 171, 
+      1,   0,   3,   0,   1,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 112, 115, 
      95,  50,  95,  48,   0,  77, 
     105,  99, 114, 111, 115, 111, 
     102, 116,  32,  40,  82,  41, 
@@ -29,9 +54,19 @@ const BYTE g_ps20_main[] =
     108, 101, 114,  32,  57,  46, 
      50,  57,  46,  57,  53,  50, 
      46,  51,  49,  49,  49,   0, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,   7, 176, 
      31,   0,   0,   2,   0,   0, 
       0, 128,   0,   0,  15, 144, 
+      2,   0,   0,   3,   0,   0, 
+      7, 128,   0,   0, 228, 144, 
+      0,   0, 228, 161,   4,   0, 
+      0,   4,   0,   0,   7, 128, 
+      0,   0, 170, 176,   0,   0, 
+    228, 128,   0,   0, 228, 160, 
+      1,   0,   0,   2,   0,   0, 
+      8, 128,   0,   0, 255, 144, 
       1,   0,   0,   2,   0,   8, 
-     15, 128,   0,   0, 228, 144, 
+     15, 128,   0,   0, 228, 128, 
     255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/im2d_PS.hlsl b/src/d3d/shaders/im2d_PS.hlsl
index a076531..eaf279d 100644
--- a/src/d3d/shaders/im2d_PS.hlsl
+++ b/src/d3d/shaders/im2d_PS.hlsl
@@ -1,11 +1,12 @@
 struct VS_out {
 	float4 Position		: POSITION;
-	float2 TexCoord0	: TEXCOORD0;
+	float3 TexCoord0	: TEXCOORD0;
 	float4 Color		: COLOR0;
 };
 
 sampler2D tex0 : register(s0);
 
+float4 fogColor : register(c0);
 
 float4 main(VS_out input) : COLOR
 {
@@ -13,5 +14,6 @@ float4 main(VS_out input) : COLOR
 #ifdef TEX
 	color *= tex2D(tex0, input.TexCoord0.xy);
 #endif
+	color.rgb = lerp(fogColor.rgb, color.rgb, input.TexCoord0.z);
 	return color;
 }
diff --git a/src/d3d/shaders/im2d_VS.h b/src/d3d/shaders/im2d_VS.h
new file mode 100644
index 0000000..bc36b1f
--- /dev/null
+++ b/src/d3d/shaders/im2d_VS.h
@@ -0,0 +1,107 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111
+//
+//   fxc /nologo /T vs_2_0 /Fh im2d_VS.h im2d_VS.hlsl
+//
+//
+// Parameters:
+//
+//   float4 fogData;
+//   float4 xform;
+//
+//
+// Registers:
+//
+//   Name         Reg   Size
+//   ------------ ----- ----
+//   fogData      c14      1
+//   xform        c41      1
+//
+
+    vs_2_0
+    def c0, 1, 0, 0, 0
+    dcl_position v0
+    dcl_texcoord v1
+    dcl_color v2
+    add r0.x, v0.w, -c14.y
+    mul r0.x, r0.x, c14.z
+    max r0.x, r0.x, c14.w
+    min oT0.z, r0.x, c0.x
+    mad r0.xy, v0, c41, c41.zwzw
+    mov r0.z, v0.z
+    mul oPos.xyz, r0, v0.w
+    mov oPos.w, v0.w
+    mov oT0.xy, v1
+    mov oD0, v2
+
+// approximately 10 instruction slots used
+#endif
+
+const BYTE g_vs20_main[] =
+{
+      0,   2, 254, 255, 254, 255, 
+     40,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 105,   0, 
+      0,   0,   0,   2, 254, 255, 
+      2,   0,   0,   0,  28,   0, 
+      0,   0,   0,   1,   0,   0, 
+     98,   0,   0,   0,  68,   0, 
+      0,   0,   2,   0,  14,   0, 
+      1,   0,  58,   0,  76,   0, 
+      0,   0,   0,   0,   0,   0, 
+     92,   0,   0,   0,   2,   0, 
+     41,   0,   1,   0, 166,   0, 
+     76,   0,   0,   0,   0,   0, 
+      0,   0, 102, 111, 103,  68, 
+     97, 116,  97,   0,   1,   0, 
+      3,   0,   1,   0,   4,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0, 120, 102, 111, 114, 
+    109,   0, 118, 115,  95,  50, 
+     95,  48,   0,  77, 105,  99, 
+    114, 111, 115, 111, 102, 116, 
+     32,  40,  82,  41,  32,  72, 
+     76,  83,  76,  32,  83, 104, 
+     97, 100, 101, 114,  32,  67, 
+    111, 109, 112, 105, 108, 101, 
+    114,  32,  57,  46,  50,  57, 
+     46,  57,  53,  50,  46,  51, 
+     49,  49,  49,   0, 171, 171, 
+     81,   0,   0,   5,   0,   0, 
+     15, 160,   0,   0, 128,  63, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,  15, 144, 
+     31,   0,   0,   2,   5,   0, 
+      0, 128,   1,   0,  15, 144, 
+     31,   0,   0,   2,  10,   0, 
+      0, 128,   2,   0,  15, 144, 
+      2,   0,   0,   3,   0,   0, 
+      1, 128,   0,   0, 255, 144, 
+     14,   0,  85, 161,   5,   0, 
+      0,   3,   0,   0,   1, 128, 
+      0,   0,   0, 128,  14,   0, 
+    170, 160,  11,   0,   0,   3, 
+      0,   0,   1, 128,   0,   0, 
+      0, 128,  14,   0, 255, 160, 
+     10,   0,   0,   3,   0,   0, 
+      4, 224,   0,   0,   0, 128, 
+      0,   0,   0, 160,   4,   0, 
+      0,   4,   0,   0,   3, 128, 
+      0,   0, 228, 144,  41,   0, 
+    228, 160,  41,   0, 238, 160, 
+      1,   0,   0,   2,   0,   0, 
+      4, 128,   0,   0, 170, 144, 
+      5,   0,   0,   3,   0,   0, 
+      7, 192,   0,   0, 228, 128, 
+      0,   0, 255, 144,   1,   0, 
+      0,   2,   0,   0,   8, 192, 
+      0,   0, 255, 144,   1,   0, 
+      0,   2,   0,   0,   3, 224, 
+      1,   0, 228, 144,   1,   0, 
+      0,   2,   0,   0,  15, 208, 
+      2,   0, 228, 144, 255, 255, 
+      0,   0
+};
diff --git a/src/d3d/shaders/im2d_VS.hlsl b/src/d3d/shaders/im2d_VS.hlsl
new file mode 100644
index 0000000..20cf3ce
--- /dev/null
+++ b/src/d3d/shaders/im2d_VS.hlsl
@@ -0,0 +1,30 @@
+#include "standardConstants.h"
+
+struct VS_in
+{
+	float4 Position		: POSITION;
+	float2 TexCoord		: TEXCOORD0;
+	float4 Color		: COLOR0;
+};
+
+struct VS_out {
+	float4 Position		: POSITION;
+	float3 TexCoord0	: TEXCOORD0;
+	float4 Color		: COLOR0;
+};
+
+float4 xform : register(c41);
+
+VS_out main(in VS_in input)
+{
+	VS_out output;
+
+	output.Position = input.Position;
+	output.Position.xy = output.Position.xy * xform.xy + xform.zw;
+	output.TexCoord0.z = clamp((output.Position.w - fogEnd)*fogRange, fogDisable, 1.0);
+	output.Position.xyz *= output.Position.w;
+	output.Color = input.Color;
+	output.TexCoord0.xy = input.TexCoord;
+
+	return output;
+}
diff --git a/src/d3d/shaders/im2d_tex_PS.h b/src/d3d/shaders/im2d_tex_PS.h
index 194db9e..a91888b 100644
--- a/src/d3d/shaders/im2d_tex_PS.h
+++ b/src/d3d/shaders/im2d_tex_PS.h
@@ -7,6 +7,7 @@
 //
 // Parameters:
 //
+//   float4 fogColor;
 //   sampler2D tex0;
 //
 //
@@ -14,31 +15,42 @@
 //
 //   Name         Reg   Size
 //   ------------ ----- ----
+//   fogColor     c0       1
 //   tex0         s0       1
 //
 
     ps_2_0
-    dcl t0.xy
+    dcl t0.xyz
     dcl v0
     dcl_2d s0
     texld r0, t0, s0
-    mul r0, r0, v0
-    mov oC0, r0
+    mad r0.xyz, v0, r0, -c0
+    mul r1.w, r0.w, v0.w
+    mad r1.xyz, t0.z, r0, c0
+    mov oC0, r1
 
-// approximately 3 instruction slots used (1 texture, 2 arithmetic)
+// approximately 5 instruction slots used (1 texture, 4 arithmetic)
 #endif
 
 const BYTE g_ps20_main[] =
 {
       0,   2, 255, 255, 254, 255, 
-     33,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0,  79,   0, 
+     45,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 127,   0, 
       0,   0,   0,   2, 255, 255, 
-      1,   0,   0,   0,  28,   0, 
+      2,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-     72,   0,   0,   0,  48,   0, 
-      0,   0,   3,   0,   0,   0, 
-      1,   0,   2,   0,  56,   0, 
+    120,   0,   0,   0,  68,   0, 
+      0,   0,   2,   0,   0,   0, 
+      1,   0,   2,   0,  80,   0, 
+      0,   0,   0,   0,   0,   0, 
+     96,   0,   0,   0,   3,   0, 
+      0,   0,   1,   0,   2,   0, 
+    104,   0,   0,   0,   0,   0, 
+      0,   0, 102, 111, 103,  67, 
+    111, 108, 111, 114,   0, 171, 
+    171, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
     116, 101, 120,  48,   0, 171, 
     171, 171,   4,   0,  12,   0, 
@@ -55,17 +67,23 @@ const BYTE g_ps20_main[] =
      53,  50,  46,  51,  49,  49, 
      49,   0,  31,   0,   0,   2, 
       0,   0,   0, 128,   0,   0, 
-      3, 176,  31,   0,   0,   2, 
+      7, 176,  31,   0,   0,   2, 
       0,   0,   0, 128,   0,   0, 
      15, 144,  31,   0,   0,   2, 
       0,   0,   0, 144,   0,   8, 
      15, 160,  66,   0,   0,   3, 
       0,   0,  15, 128,   0,   0, 
     228, 176,   0,   8, 228, 160, 
-      5,   0,   0,   3,   0,   0, 
-     15, 128,   0,   0, 228, 128, 
-      0,   0, 228, 144,   1,   0, 
-      0,   2,   0,   8,  15, 128, 
-      0,   0, 228, 128, 255, 255, 
-      0,   0
+      4,   0,   0,   4,   0,   0, 
+      7, 128,   0,   0, 228, 144, 
+      0,   0, 228, 128,   0,   0, 
+    228, 161,   5,   0,   0,   3, 
+      1,   0,   8, 128,   0,   0, 
+    255, 128,   0,   0, 255, 144, 
+      4,   0,   0,   4,   1,   0, 
+      7, 128,   0,   0, 170, 176, 
+      0,   0, 228, 128,   0,   0, 
+    228, 160,   1,   0,   0,   2, 
+      0,   8,  15, 128,   1,   0, 
+    228, 128, 255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/lighting.h b/src/d3d/shaders/lighting.h
index 2591c81..4b08196 100644
--- a/src/d3d/shaders/lighting.h
+++ b/src/d3d/shaders/lighting.h
@@ -11,7 +11,7 @@ float3 DoDirLight(Light L, float3 N)
 	return l*L.color.xyz;
 }
 
-float3 DoDirLightSpec(Light L, float3 N, float3 V, float power))
+float3 DoDirLightSpec(Light L, float3 N, float3 V, float power)
 {
 	return pow(saturate(dot(N, normalize(V + -L.direction.xyz))), power)*L.color.xyz;
 }
diff --git a/src/d3d/shaders/make_default.cmd b/src/d3d/shaders/make_default.cmd
index 6a533fe..bc44429 100644
--- a/src/d3d/shaders/make_default.cmd
+++ b/src/d3d/shaders/make_default.cmd
@@ -6,5 +6,6 @@
 "%DXSDK_DIR%\utilities\bin\x86\fxc.exe" /nologo /T ps_2_0 /Fh default_PS.h default_PS.hlsl
 "%DXSDK_DIR%\utilities\bin\x86\fxc.exe" /nologo /T ps_2_0 /DTEX /Fh default_tex_PS.h default_PS.hlsl
 
+"%DXSDK_DIR%\utilities\bin\x86\fxc.exe" /nologo /T vs_2_0 /Fh im2d_VS.h im2d_VS.hlsl
 "%DXSDK_DIR%\utilities\bin\x86\fxc.exe" /nologo /T ps_2_0 /Fh im2d_PS.h im2d_PS.hlsl
 "%DXSDK_DIR%\utilities\bin\x86\fxc.exe" /nologo /T ps_2_0 /DTEX /Fh im2d_tex_PS.h im2d_PS.hlsl
diff --git a/src/d3d/shaders/matfx_env_PS.h b/src/d3d/shaders/matfx_env_PS.h
index 558ccdc..e39a1f5 100644
--- a/src/d3d/shaders/matfx_env_PS.h
+++ b/src/d3d/shaders/matfx_env_PS.h
@@ -7,7 +7,6 @@
 //
 // Parameters:
 //
-//   float4 colorClamp;
 //   sampler2D envTex;
 //   float4 fogColor;
 //   float4 fxparams;
@@ -19,7 +18,6 @@
 //   ------------ ----- ----
 //   fogColor     c0       1
 //   fxparams     c1       1
-//   colorClamp   c2       1
 //   envTex       s1       1
 //
 
@@ -27,10 +25,10 @@
     dcl t0.xyz
     dcl t1.xy
     dcl v0
+    dcl v1.xyz
     dcl_2d s1
     texld r0, t1, s1
-    max r1.xyz, v0, c2
-    mul r1.xyz, r1, c1.x
+    mul r1.xyz, v1, c1.x
     mul r0.xyz, r0, r1
     mul r0.xyz, r0, t0.z
     max r0.w, v0.w, c1.y
@@ -41,91 +39,86 @@
     mov r0.w, v0.w
     mov oC0, r0
 
-// approximately 12 instruction slots used (1 texture, 11 arithmetic)
+// approximately 11 instruction slots used (1 texture, 10 arithmetic)
 #endif
 
 const BYTE g_ps20_main[] =
 {
       0,   2, 255, 255, 254, 255, 
-     60,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0, 185,   0, 
+     53,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 156,   0, 
       0,   0,   0,   2, 255, 255, 
-      4,   0,   0,   0,  28,   0, 
+      3,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-    178,   0,   0,   0, 108,   0, 
-      0,   0,   2,   0,   2,   0, 
-      1,   0,  10,   0, 120,   0, 
+    149,   0,   0,   0,  88,   0, 
+      0,   0,   3,   0,   1,   0, 
+      1,   0,   6,   0,  96,   0, 
       0,   0,   0,   0,   0,   0, 
-    136,   0,   0,   0,   3,   0, 
-      1,   0,   1,   0,   6,   0, 
-    144,   0,   0,   0,   0,   0, 
-      0,   0, 160,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      2,   0, 120,   0,   0,   0, 
-      0,   0,   0,   0, 169,   0, 
-      0,   0,   2,   0,   1,   0, 
-      1,   0,   6,   0, 120,   0, 
-      0,   0,   0,   0,   0,   0, 
-     99, 111, 108, 111, 114,  67, 
-    108,  97, 109, 112,   0, 171, 
-      1,   0,   3,   0,   1,   0, 
-      4,   0,   1,   0,   0,   0, 
+    112,   0,   0,   0,   2,   0, 
+      0,   0,   1,   0,   2,   0, 
+    124,   0,   0,   0,   0,   0, 
+      0,   0, 140,   0,   0,   0, 
+      2,   0,   1,   0,   1,   0, 
+      6,   0, 124,   0,   0,   0, 
       0,   0,   0,   0, 101, 110, 
     118,  84, 101, 120,   0, 171, 
       4,   0,  12,   0,   1,   0, 
       1,   0,   1,   0,   0,   0, 
       0,   0,   0,   0, 102, 111, 
     103,  67, 111, 108, 111, 114, 
-      0, 102, 120, 112,  97, 114, 
-     97, 109, 115,   0, 112, 115, 
-     95,  50,  95,  48,   0,  77, 
-    105,  99, 114, 111, 115, 111, 
-    102, 116,  32,  40,  82,  41, 
-     32,  72,  76,  83,  76,  32, 
-     83, 104,  97, 100, 101, 114, 
-     32,  67, 111, 109, 112, 105, 
-    108, 101, 114,  32,  57,  46, 
-     50,  57,  46,  57,  53,  50, 
-     46,  51,  49,  49,  49,   0, 
-    171, 171,  31,   0,   0,   2, 
-      0,   0,   0, 128,   0,   0, 
-      7, 176,  31,   0,   0,   2, 
-      0,   0,   0, 128,   1,   0, 
-      3, 176,  31,   0,   0,   2, 
-      0,   0,   0, 128,   0,   0, 
-     15, 144,  31,   0,   0,   2, 
-      0,   0,   0, 144,   1,   8, 
-     15, 160,  66,   0,   0,   3, 
-      0,   0,  15, 128,   1,   0, 
-    228, 176,   1,   8, 228, 160, 
-     11,   0,   0,   3,   1,   0, 
-      7, 128,   0,   0, 228, 144, 
-      2,   0, 228, 160,   5,   0, 
-      0,   3,   1,   0,   7, 128, 
-      1,   0, 228, 128,   1,   0, 
-      0, 160,   5,   0,   0,   3, 
-      0,   0,   7, 128,   0,   0, 
-    228, 128,   1,   0, 228, 128, 
+      0, 171, 171, 171,   1,   0, 
+      3,   0,   1,   0,   4,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0, 102, 120, 112,  97, 
+    114,  97, 109, 115,   0, 112, 
+    115,  95,  50,  95,  48,   0, 
+     77, 105,  99, 114, 111, 115, 
+    111, 102, 116,  32,  40,  82, 
+     41,  32,  72,  76,  83,  76, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  67, 111, 109, 112, 
+    105, 108, 101, 114,  32,  57, 
+     46,  50,  57,  46,  57,  53, 
+     50,  46,  51,  49,  49,  49, 
+      0, 171, 171, 171,  31,   0, 
+      0,   2,   0,   0,   0, 128, 
+      0,   0,   7, 176,  31,   0, 
+      0,   2,   0,   0,   0, 128, 
+      1,   0,   3, 176,  31,   0, 
+      0,   2,   0,   0,   0, 128, 
+      0,   0,  15, 144,  31,   0, 
+      0,   2,   0,   0,   0, 128, 
+      1,   0,   7, 144,  31,   0, 
+      0,   2,   0,   0,   0, 144, 
+      1,   8,  15, 160,  66,   0, 
+      0,   3,   0,   0,  15, 128, 
+      1,   0, 228, 176,   1,   8, 
+    228, 160,   5,   0,   0,   3, 
+      1,   0,   7, 128,   1,   0, 
+    228, 144,   1,   0,   0, 160, 
       5,   0,   0,   3,   0,   0, 
       7, 128,   0,   0, 228, 128, 
-      0,   0, 170, 176,  11,   0, 
-      0,   3,   0,   0,   8, 128, 
-      0,   0, 255, 144,   1,   0, 
-     85, 160,   5,   0,   0,   3, 
-      0,   0,   7, 128,   0,   0, 
-    255, 128,   0,   0, 228, 128, 
-      2,   0,   0,   3,   1,   0, 
-      7, 128,   0,   0, 228, 144, 
-      0,   0, 228, 161,   4,   0, 
-      0,   4,   1,   0,   7, 128, 
-      0,   0, 170, 176,   1,   0, 
-    228, 128,   0,   0, 228, 160, 
-      4,   0,   0,   4,   0,   0, 
-      7, 128,   1,   0, 228, 128, 
-      0,   0, 255, 144,   0,   0, 
-    228, 128,   1,   0,   0,   2, 
+      1,   0, 228, 128,   5,   0, 
+      0,   3,   0,   0,   7, 128, 
+      0,   0, 228, 128,   0,   0, 
+    170, 176,  11,   0,   0,   3, 
       0,   0,   8, 128,   0,   0, 
-    255, 144,   1,   0,   0,   2, 
-      0,   8,  15, 128,   0,   0, 
-    228, 128, 255, 255,   0,   0
+    255, 144,   1,   0,  85, 160, 
+      5,   0,   0,   3,   0,   0, 
+      7, 128,   0,   0, 255, 128, 
+      0,   0, 228, 128,   2,   0, 
+      0,   3,   1,   0,   7, 128, 
+      0,   0, 228, 144,   0,   0, 
+    228, 161,   4,   0,   0,   4, 
+      1,   0,   7, 128,   0,   0, 
+    170, 176,   1,   0, 228, 128, 
+      0,   0, 228, 160,   4,   0, 
+      0,   4,   0,   0,   7, 128, 
+      1,   0, 228, 128,   0,   0, 
+    255, 144,   0,   0, 228, 128, 
+      1,   0,   0,   2,   0,   0, 
+      8, 128,   0,   0, 255, 144, 
+      1,   0,   0,   2,   0,   8, 
+     15, 128,   0,   0, 228, 128, 
+    255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/matfx_env_PS.hlsl b/src/d3d/shaders/matfx_env_PS.hlsl
index ccdd5cd..eb5187d 100644
--- a/src/d3d/shaders/matfx_env_PS.hlsl
+++ b/src/d3d/shaders/matfx_env_PS.hlsl
@@ -3,6 +3,7 @@ struct VS_out {
 	float3 TexCoord0	: TEXCOORD0;
 	float2 TexCoord1	: TEXCOORD1;
 	float4 Color		: COLOR0;
+	float4 EnvColor		: COLOR1;
 };
 
 sampler2D diffTex : register(s0);
@@ -11,7 +12,6 @@ sampler2D envTex : register(s1);
 float4 fogColor : register(c0);
 
 float4 fxparams : register(c1);
-float4 colorClamp : register(c2);
 
 #define shininess (fxparams.x)
 #define disableFBA (fxparams.y)
@@ -19,12 +19,11 @@ float4 colorClamp : register(c2);
 float4 main(VS_out input) : COLOR
 {
 	float4 pass1 = input.Color;
-	float4 envColor = max(pass1, colorClamp);
 #ifdef TEX
 	pass1 *= tex2D(diffTex, input.TexCoord0.xy);
 #endif
 
-	float4 pass2 = envColor*shininess*tex2D(envTex, input.TexCoord1.xy);
+	float4 pass2 = input.EnvColor*shininess*tex2D(envTex, input.TexCoord1.xy);
 
 	pass1.rgb = lerp(fogColor.rgb, pass1.rgb, input.TexCoord0.z);
 	pass2.rgb = lerp(float3(0.0, 0.0, 0.0), pass2.rgb, input.TexCoord0.z);
diff --git a/src/d3d/shaders/matfx_env_VS.hlsl b/src/d3d/shaders/matfx_env_VS.hlsl
index 73179ab..31b674c 100644
--- a/src/d3d/shaders/matfx_env_VS.hlsl
+++ b/src/d3d/shaders/matfx_env_VS.hlsl
@@ -1,6 +1,8 @@
 #include "standardConstants.h"
 
 float4x4	texMat	: register(c41);
+float4		colorClamp : register(c45);
+float4		envColor : register(c46);
 
 struct VS_in
 {
@@ -15,6 +17,7 @@ struct VS_out {
 	float3 TexCoord0	: TEXCOORD0;	// also fog
 	float2 TexCoord1	: TEXCOORD1;
 	float4 Color		: COLOR0;
+	float4 EnvColor		: COLOR1;
 };
 
 
@@ -47,6 +50,7 @@ VS_out main(in VS_in input)
 #endif
 	// PS2 clamps before material color
 	output.Color = clamp(output.Color, 0.0, 1.0);
+	output.EnvColor = max(output.Color, colorClamp) * envColor;
 	output.Color *= matCol;
 
 	output.TexCoord0.z = clamp((output.Position.w - fogEnd)*fogRange, fogDisable, 1.0);
diff --git a/src/d3d/shaders/matfx_env_all_VS.h b/src/d3d/shaders/matfx_env_all_VS.h
index c049dae..65e1c15 100644
--- a/src/d3d/shaders/matfx_env_all_VS.h
+++ b/src/d3d/shaders/matfx_env_all_VS.h
@@ -9,7 +9,9 @@
 // Parameters:
 //
 //   float4 ambientLight;
+//   float4 colorClamp;
 //   float4x4 combinedMat;
+//   float4 envColor;
 //   int4 firstLight;
 //   float4 fogData;
 //   
@@ -48,6 +50,8 @@
 //   firstLight     c16      1
 //   lights         c17     24
 //   texMat         c41      4
+//   colorClamp     c45      1
+//   envColor       c46      1
 //
 
     vs_2_0
@@ -141,79 +145,91 @@
     mad r0.xy, c41, r1.x, r0
     mad r0.xy, c43, r1.z, r0
     add oT1.xy, r0, c44
+    max r1, r2, c45
+    mul oD1, r1, c46
     add r0.x, r0.w, -c14.y
     mul r0.x, r0.x, c14.z
     max r0.x, r0.x, c14.w
     min oT0.z, r0.x, c11.z
     mov oT0.xy, v2
 
-// approximately 99 instruction slots used
+// approximately 101 instruction slots used
 #endif
 
 const BYTE g_vs20_main[] =
 {
       0,   2, 254, 255, 254, 255, 
-    165,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0,  94,   2, 
+    180,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 154,   2, 
       0,   0,   0,   2, 254, 255, 
-     13,   0,   0,   0,  28,   0, 
+     15,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-     87,   2,   0,   0,  32,   1, 
+    147,   2,   0,   0,  72,   1, 
       0,   0,   2,   0,  15,   0, 
-      1,   0,  62,   0,  48,   1, 
+      1,   0,  62,   0,  88,   1, 
       0,   0,   0,   0,   0,   0, 
-     64,   1,   0,   0,   2,   0, 
-      0,   0,   4,   0,   2,   0, 
-     76,   1,   0,   0,   0,   0, 
-      0,   0,  92,   1,   0,   0, 
-      2,   0,  16,   0,   1,   0, 
-     66,   0, 104,   1,   0,   0, 
-      0,   0,   0,   0, 120,   1, 
-      0,   0,   2,   0,  14,   0, 
-      1,   0,  58,   0,  48,   1, 
+    104,   1,   0,   0,   2,   0, 
+     45,   0,   1,   0, 182,   0, 
+     88,   1,   0,   0,   0,   0, 
+      0,   0, 115,   1,   0,   0, 
+      2,   0,   0,   0,   4,   0, 
+      2,   0, 128,   1,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   2,   0,  46,   0, 
+      1,   0, 186,   0,  88,   1, 
       0,   0,   0,   0,   0,   0, 
-    128,   1,   0,   0,   2,   0, 
-     17,   0,  24,   0,  70,   0, 
-    204,   1,   0,   0,   0,   0, 
-      0,   0, 220,   1,   0,   0, 
-      2,   0,  12,   0,   1,   0, 
-     50,   0,  48,   1,   0,   0, 
-      0,   0,   0,   0, 227,   1, 
-      0,   0,   2,   0,   8,   0, 
-      3,   0,  34,   0, 240,   1, 
+    153,   1,   0,   0,   2,   0, 
+     16,   0,   1,   0,  66,   0, 
+    164,   1,   0,   0,   0,   0, 
+      0,   0, 180,   1,   0,   0, 
+      2,   0,  14,   0,   1,   0, 
+     58,   0,  88,   1,   0,   0, 
+      0,   0,   0,   0, 188,   1, 
+      0,   0,   2,   0,  17,   0, 
+     24,   0,  70,   0,   8,   2, 
       0,   0,   0,   0,   0,   0, 
-      0,   2,   0,   0,   1,   0, 
-      0,   0,   1,   0,   2,   0, 
-     16,   2,   0,   0,   0,   0, 
-      0,   0,  32,   2,   0,   0, 
-      1,   0,   1,   0,   1,   0, 
-      6,   0,  16,   2,   0,   0, 
-      0,   0,   0,   0,  47,   2, 
-      0,   0,   1,   0,   2,   0, 
-      1,   0,  10,   0,  16,   2, 
+     24,   2,   0,   0,   2,   0, 
+     12,   0,   1,   0,  50,   0, 
+     88,   1,   0,   0,   0,   0, 
+      0,   0,  31,   2,   0,   0, 
+      2,   0,   8,   0,   3,   0, 
+     34,   0,  44,   2,   0,   0, 
+      0,   0,   0,   0,  60,   2, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   2,   0,  76,   2, 
       0,   0,   0,   0,   0,   0, 
-     61,   2,   0,   0,   2,   0, 
-     13,   0,   1,   0,  54,   0, 
-     48,   1,   0,   0,   0,   0, 
-      0,   0,  71,   2,   0,   0, 
-      2,   0,  41,   0,   4,   0, 
-    166,   0,  76,   1,   0,   0, 
-      0,   0,   0,   0,  78,   2, 
-      0,   0,   2,   0,   4,   0, 
-      4,   0,  18,   0,  76,   1, 
+     92,   2,   0,   0,   1,   0, 
+      1,   0,   1,   0,   6,   0, 
+     76,   2,   0,   0,   0,   0, 
+      0,   0, 107,   2,   0,   0, 
+      1,   0,   2,   0,   1,   0, 
+     10,   0,  76,   2,   0,   0, 
+      0,   0,   0,   0, 121,   2, 
+      0,   0,   2,   0,  13,   0, 
+      1,   0,  54,   0,  88,   1, 
       0,   0,   0,   0,   0,   0, 
-     97, 109,  98, 105, 101, 110, 
-    116,  76, 105, 103, 104, 116, 
-      0, 171, 171, 171,   1,   0, 
-      3,   0,   1,   0,   4,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  99, 111, 109,  98, 
-    105, 110, 101, 100,  77,  97, 
-    116,   0,   3,   0,   3,   0, 
-      4,   0,   4,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-    102, 105, 114, 115, 116,  76, 
+    131,   2,   0,   0,   2,   0, 
+     41,   0,   4,   0, 166,   0, 
+    128,   1,   0,   0,   0,   0, 
+      0,   0, 138,   2,   0,   0, 
+      2,   0,   4,   0,   4,   0, 
+     18,   0, 128,   1,   0,   0, 
+      0,   0,   0,   0,  97, 109, 
+     98, 105, 101, 110, 116,  76, 
     105, 103, 104, 116,   0, 171, 
+    171, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+     99, 111, 108, 111, 114,  67, 
+    108,  97, 109, 112,   0,  99, 
+    111, 109,  98, 105, 110, 101, 
+    100,  77,  97, 116,   0, 171, 
+      3,   0,   3,   0,   4,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 101, 110, 
+    118,  67, 111, 108, 111, 114, 
+      0, 102, 105, 114, 115, 116, 
+     76, 105, 103, 104, 116,   0, 
       1,   0,   2,   0,   1,   0, 
       4,   0,   1,   0,   0,   0, 
       0,   0,   0,   0, 102, 111, 
@@ -226,13 +242,13 @@ const BYTE g_vs20_main[] =
       0,   0, 112, 111, 115, 105, 
     116, 105, 111, 110,   0, 100, 
     105, 114, 101,  99, 116, 105, 
-    111, 110,   0, 171, 135,   1, 
-      0,   0, 144,   1,   0,   0, 
-    160,   1,   0,   0, 144,   1, 
-      0,   0, 169,   1,   0,   0, 
-    144,   1,   0,   0,   5,   0, 
+    111, 110,   0, 171, 195,   1, 
+      0,   0, 204,   1,   0,   0, 
+    220,   1,   0,   0, 204,   1, 
+      0,   0, 229,   1,   0,   0, 
+    204,   1,   0,   0,   5,   0, 
       0,   0,   1,   0,  12,   0, 
-      8,   0,   3,   0, 180,   1, 
+      8,   0,   3,   0, 240,   1, 
       0,   0, 109,  97, 116,  67, 
     111, 108,   0, 110, 111, 114, 
     109,  97, 108,  77,  97, 116, 
@@ -497,18 +513,23 @@ const BYTE g_vs20_main[] =
       0,   0, 228, 128,   2,   0, 
       0,   3,   1,   0,   3, 224, 
       0,   0, 228, 128,  44,   0, 
-    228, 160,   2,   0,   0,   3, 
-      0,   0,   1, 128,   0,   0, 
-    255, 128,  14,   0,  85, 161, 
-      5,   0,   0,   3,   0,   0, 
-      1, 128,   0,   0,   0, 128, 
-     14,   0, 170, 160,  11,   0, 
+    228, 160,  11,   0,   0,   3, 
+      1,   0,  15, 128,   2,   0, 
+    228, 128,  45,   0, 228, 160, 
+      5,   0,   0,   3,   1,   0, 
+     15, 208,   1,   0, 228, 128, 
+     46,   0, 228, 160,   2,   0, 
       0,   3,   0,   0,   1, 128, 
-      0,   0,   0, 128,  14,   0, 
-    255, 160,  10,   0,   0,   3, 
-      0,   0,   4, 224,   0,   0, 
-      0, 128,  11,   0, 170, 160, 
-      1,   0,   0,   2,   0,   0, 
-      3, 224,   2,   0, 228, 144, 
-    255, 255,   0,   0
+      0,   0, 255, 128,  14,   0, 
+     85, 161,   5,   0,   0,   3, 
+      0,   0,   1, 128,   0,   0, 
+      0, 128,  14,   0, 170, 160, 
+     11,   0,   0,   3,   0,   0, 
+      1, 128,   0,   0,   0, 128, 
+     14,   0, 255, 160,  10,   0, 
+      0,   3,   0,   0,   4, 224, 
+      0,   0,   0, 128,  11,   0, 
+    170, 160,   1,   0,   0,   2, 
+      0,   0,   3, 224,   2,   0, 
+    228, 144, 255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/matfx_env_amb_VS.h b/src/d3d/shaders/matfx_env_amb_VS.h
index c6314fb..0367d5e 100644
--- a/src/d3d/shaders/matfx_env_amb_VS.h
+++ b/src/d3d/shaders/matfx_env_amb_VS.h
@@ -8,7 +8,9 @@
 // Parameters:
 //
 //   float4 ambientLight;
+//   float4 colorClamp;
 //   float4x4 combinedMat;
+//   float4 envColor;
 //   float4 fogData;
 //   float4 matCol;
 //   float3x3 normalMat;
@@ -27,6 +29,8 @@
 //   fogData      c14      1
 //   ambientLight c15      1
 //   texMat       c41      4
+//   colorClamp   c45      1
+//   envColor     c46      1
 //
 
     vs_2_0
@@ -47,7 +51,9 @@
     mov r0.w, v3.w
     max r0, r0, c4.x
     min r0, r0, c4.y
+    max r1, r0, c45
     mul oD0, r0, c12
+    mul oD1, r1, c46
     mul r0, v0.y, c1
     mad r0, c0, v0.x, r0
     mad r0, c2, v0.z, r0
@@ -59,56 +65,66 @@
     min oT0.z, r0.x, c4.y
     mov oT0.xy, v2
 
-// approximately 23 instruction slots used
+// approximately 25 instruction slots used
 #endif
 
 const BYTE g_vs20_main[] =
 {
       0,   2, 254, 255, 254, 255, 
-     88,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0,  40,   1, 
+    103,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 100,   1, 
       0,   0,   0,   2, 254, 255, 
-      7,   0,   0,   0,  28,   0, 
+      9,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-     33,   1,   0,   0, 168,   0, 
+     93,   1,   0,   0, 208,   0, 
       0,   0,   2,   0,  15,   0, 
-      1,   0,  62,   0, 184,   0, 
+      1,   0,  62,   0, 224,   0, 
       0,   0,   0,   0,   0,   0, 
-    200,   0,   0,   0,   2,   0, 
-      0,   0,   4,   0,   2,   0, 
-    212,   0,   0,   0,   0,   0, 
-      0,   0, 228,   0,   0,   0, 
-      2,   0,  14,   0,   1,   0, 
-     58,   0, 184,   0,   0,   0, 
-      0,   0,   0,   0, 236,   0, 
-      0,   0,   2,   0,  12,   0, 
-      1,   0,  50,   0, 184,   0, 
+    240,   0,   0,   0,   2,   0, 
+     45,   0,   1,   0, 182,   0, 
+    224,   0,   0,   0,   0,   0, 
+      0,   0, 251,   0,   0,   0, 
+      2,   0,   0,   0,   4,   0, 
+      2,   0,   8,   1,   0,   0, 
+      0,   0,   0,   0,  24,   1, 
+      0,   0,   2,   0,  46,   0, 
+      1,   0, 186,   0, 224,   0, 
       0,   0,   0,   0,   0,   0, 
-    243,   0,   0,   0,   2,   0, 
-      8,   0,   3,   0,  34,   0, 
-      0,   1,   0,   0,   0,   0, 
-      0,   0,  16,   1,   0,   0, 
-      2,   0,  13,   0,   1,   0, 
-     54,   0, 184,   0,   0,   0, 
-      0,   0,   0,   0,  26,   1, 
-      0,   0,   2,   0,  41,   0, 
-      4,   0, 166,   0, 212,   0, 
+     33,   1,   0,   0,   2,   0, 
+     14,   0,   1,   0,  58,   0, 
+    224,   0,   0,   0,   0,   0, 
+      0,   0,  41,   1,   0,   0, 
+      2,   0,  12,   0,   1,   0, 
+     50,   0, 224,   0,   0,   0, 
+      0,   0,   0,   0,  48,   1, 
+      0,   0,   2,   0,   8,   0, 
+      3,   0,  34,   0,  60,   1, 
       0,   0,   0,   0,   0,   0, 
-     97, 109,  98, 105, 101, 110, 
-    116,  76, 105, 103, 104, 116, 
-      0, 171, 171, 171,   1,   0, 
-      3,   0,   1,   0,   4,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  99, 111, 109,  98, 
-    105, 110, 101, 100,  77,  97, 
-    116,   0,   3,   0,   3,   0, 
-      4,   0,   4,   0,   1,   0, 
+     76,   1,   0,   0,   2,   0, 
+     13,   0,   1,   0,  54,   0, 
+    224,   0,   0,   0,   0,   0, 
+      0,   0,  86,   1,   0,   0, 
+      2,   0,  41,   0,   4,   0, 
+    166,   0,   8,   1,   0,   0, 
+      0,   0,   0,   0,  97, 109, 
+     98, 105, 101, 110, 116,  76, 
+    105, 103, 104, 116,   0, 171, 
+    171, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
-    102, 111, 103,  68,  97, 116, 
-     97,   0, 109,  97, 116,  67, 
-    111, 108,   0, 110, 111, 114, 
-    109,  97, 108,  77,  97, 116, 
-      0, 171, 171, 171,   3,   0, 
+     99, 111, 108, 111, 114,  67, 
+    108,  97, 109, 112,   0,  99, 
+    111, 109,  98, 105, 110, 101, 
+    100,  77,  97, 116,   0, 171, 
+      3,   0,   3,   0,   4,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 101, 110, 
+    118,  67, 111, 108, 111, 114, 
+      0, 102, 111, 103,  68,  97, 
+    116,  97,   0, 109,  97, 116, 
+     67, 111, 108,   0, 110, 111, 
+    114, 109,  97, 108,  77,  97, 
+    116,   0, 171, 171,   3,   0, 
       3,   0,   3,   0,   3,   0, 
       1,   0,   0,   0,   0,   0, 
       0,   0, 115, 117, 114, 102, 
@@ -170,35 +186,40 @@ const BYTE g_vs20_main[] =
       0, 160,  10,   0,   0,   3, 
       0,   0,  15, 128,   0,   0, 
     228, 128,   4,   0,  85, 160, 
+     11,   0,   0,   3,   1,   0, 
+     15, 128,   0,   0, 228, 128, 
+     45,   0, 228, 160,   5,   0, 
+      0,   3,   0,   0,  15, 208, 
+      0,   0, 228, 128,  12,   0, 
+    228, 160,   5,   0,   0,   3, 
+      1,   0,  15, 208,   1,   0, 
+    228, 128,  46,   0, 228, 160, 
       5,   0,   0,   3,   0,   0, 
-     15, 208,   0,   0, 228, 128, 
-     12,   0, 228, 160,   5,   0, 
-      0,   3,   0,   0,  15, 128, 
-      0,   0,  85, 144,   1,   0, 
-    228, 160,   4,   0,   0,   4, 
-      0,   0,  15, 128,   0,   0, 
-    228, 160,   0,   0,   0, 144, 
-      0,   0, 228, 128,   4,   0, 
+     15, 128,   0,   0,  85, 144, 
+      1,   0, 228, 160,   4,   0, 
       0,   4,   0,   0,  15, 128, 
-      2,   0, 228, 160,   0,   0, 
-    170, 144,   0,   0, 228, 128, 
+      0,   0, 228, 160,   0,   0, 
+      0, 144,   0,   0, 228, 128, 
       4,   0,   0,   4,   0,   0, 
-     15, 128,   3,   0, 228, 160, 
-      0,   0, 255, 144,   0,   0, 
-    228, 128,   2,   0,   0,   3, 
-      1,   0,   1, 128,   0,   0, 
-    255, 128,  14,   0,  85, 161, 
-      1,   0,   0,   2,   0,   0, 
-     15, 192,   0,   0, 228, 128, 
-      5,   0,   0,   3,   0,   0, 
-      1, 128,   1,   0,   0, 128, 
-     14,   0, 170, 160,  11,   0, 
-      0,   3,   0,   0,   1, 128, 
-      0,   0,   0, 128,  14,   0, 
-    255, 160,  10,   0,   0,   3, 
-      0,   0,   4, 224,   0,   0, 
-      0, 128,   4,   0,  85, 160, 
-      1,   0,   0,   2,   0,   0, 
-      3, 224,   2,   0, 228, 144, 
-    255, 255,   0,   0
+     15, 128,   2,   0, 228, 160, 
+      0,   0, 170, 144,   0,   0, 
+    228, 128,   4,   0,   0,   4, 
+      0,   0,  15, 128,   3,   0, 
+    228, 160,   0,   0, 255, 144, 
+      0,   0, 228, 128,   2,   0, 
+      0,   3,   1,   0,   1, 128, 
+      0,   0, 255, 128,  14,   0, 
+     85, 161,   1,   0,   0,   2, 
+      0,   0,  15, 192,   0,   0, 
+    228, 128,   5,   0,   0,   3, 
+      0,   0,   1, 128,   1,   0, 
+      0, 128,  14,   0, 170, 160, 
+     11,   0,   0,   3,   0,   0, 
+      1, 128,   0,   0,   0, 128, 
+     14,   0, 255, 160,  10,   0, 
+      0,   3,   0,   0,   4, 224, 
+      0,   0,   0, 128,   4,   0, 
+     85, 160,   1,   0,   0,   2, 
+      0,   0,   3, 224,   2,   0, 
+    228, 144, 255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/matfx_env_amb_dir_VS.h b/src/d3d/shaders/matfx_env_amb_dir_VS.h
index 98d537a..b93e572 100644
--- a/src/d3d/shaders/matfx_env_amb_dir_VS.h
+++ b/src/d3d/shaders/matfx_env_amb_dir_VS.h
@@ -9,7 +9,9 @@
 // Parameters:
 //
 //   float4 ambientLight;
+//   float4 colorClamp;
 //   float4x4 combinedMat;
+//   float4 envColor;
 //   int4 firstLight;
 //   float4 fogData;
 //   
@@ -42,6 +44,8 @@
 //   firstLight   c16      1
 //   lights       c17     24
 //   texMat       c41      4
+//   colorClamp   c45      1
+//   envColor     c46      1
 //
 
     vs_2_0
@@ -76,73 +80,85 @@
     max r1, r2, c4.x
     min r1, r1, c4.z
     mul oD0, r1, c12
-    mul r1.xy, r0.y, c42
-    mad r0.xy, c41, r0.x, r1
+    mul r2.xy, r0.y, c42
+    mad r0.xy, c41, r0.x, r2
     mad r0.xy, c43, r0.z, r0
     add oT1.xy, r0, c44
+    max r1, r1, c45
+    mul oD1, r1, c46
     add r0.x, r0.w, -c14.y
     mul r0.x, r0.x, c14.z
     max r0.x, r0.x, c14.w
     min oT0.z, r0.x, c4.z
     mov oT0.xy, v2
 
-// approximately 38 instruction slots used
+// approximately 40 instruction slots used
 #endif
 
 const BYTE g_vs20_main[] =
 {
       0,   2, 254, 255, 254, 255, 
-    141,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0, 252,   1, 
+    156,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0,  56,   2, 
       0,   0,   0,   2, 254, 255, 
-     10,   0,   0,   0,  28,   0, 
+     12,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-    245,   1,   0,   0, 228,   0, 
+     49,   2,   0,   0,  12,   1, 
       0,   0,   2,   0,  15,   0, 
-      1,   0,  62,   0, 244,   0, 
+      1,   0,  62,   0,  28,   1, 
       0,   0,   0,   0,   0,   0, 
-      4,   1,   0,   0,   2,   0, 
-      0,   0,   4,   0,   2,   0, 
-     16,   1,   0,   0,   0,   0, 
-      0,   0,  32,   1,   0,   0, 
-      2,   0,  16,   0,   1,   0, 
-     66,   0,  44,   1,   0,   0, 
-      0,   0,   0,   0,  60,   1, 
-      0,   0,   2,   0,  14,   0, 
-      1,   0,  58,   0, 244,   0, 
+     44,   1,   0,   0,   2,   0, 
+     45,   0,   1,   0, 182,   0, 
+     28,   1,   0,   0,   0,   0, 
+      0,   0,  55,   1,   0,   0, 
+      2,   0,   0,   0,   4,   0, 
+      2,   0,  68,   1,   0,   0, 
+      0,   0,   0,   0,  84,   1, 
+      0,   0,   2,   0,  46,   0, 
+      1,   0, 186,   0,  28,   1, 
       0,   0,   0,   0,   0,   0, 
-     68,   1,   0,   0,   2,   0, 
-     17,   0,  24,   0,  70,   0, 
-    144,   1,   0,   0,   0,   0, 
-      0,   0, 160,   1,   0,   0, 
-      2,   0,  12,   0,   1,   0, 
-     50,   0, 244,   0,   0,   0, 
-      0,   0,   0,   0, 167,   1, 
-      0,   0,   2,   0,   8,   0, 
-      3,   0,  34,   0, 180,   1, 
+     93,   1,   0,   0,   2,   0, 
+     16,   0,   1,   0,  66,   0, 
+    104,   1,   0,   0,   0,   0, 
+      0,   0, 120,   1,   0,   0, 
+      2,   0,  14,   0,   1,   0, 
+     58,   0,  28,   1,   0,   0, 
+      0,   0,   0,   0, 128,   1, 
+      0,   0,   2,   0,  17,   0, 
+     24,   0,  70,   0, 204,   1, 
       0,   0,   0,   0,   0,   0, 
-    196,   1,   0,   0,   1,   0, 
-      0,   0,   1,   0,   2,   0, 
-    212,   1,   0,   0,   0,   0, 
-      0,   0, 228,   1,   0,   0, 
-      2,   0,  13,   0,   1,   0, 
-     54,   0, 244,   0,   0,   0, 
-      0,   0,   0,   0, 238,   1, 
-      0,   0,   2,   0,  41,   0, 
-      4,   0, 166,   0,  16,   1, 
+    220,   1,   0,   0,   2,   0, 
+     12,   0,   1,   0,  50,   0, 
+     28,   1,   0,   0,   0,   0, 
+      0,   0, 227,   1,   0,   0, 
+      2,   0,   8,   0,   3,   0, 
+     34,   0, 240,   1,   0,   0, 
+      0,   0,   0,   0,   0,   2, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   2,   0,  16,   2, 
       0,   0,   0,   0,   0,   0, 
-     97, 109,  98, 105, 101, 110, 
-    116,  76, 105, 103, 104, 116, 
-      0, 171, 171, 171,   1,   0, 
-      3,   0,   1,   0,   4,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  99, 111, 109,  98, 
-    105, 110, 101, 100,  77,  97, 
-    116,   0,   3,   0,   3,   0, 
-      4,   0,   4,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-    102, 105, 114, 115, 116,  76, 
+     32,   2,   0,   0,   2,   0, 
+     13,   0,   1,   0,  54,   0, 
+     28,   1,   0,   0,   0,   0, 
+      0,   0,  42,   2,   0,   0, 
+      2,   0,  41,   0,   4,   0, 
+    166,   0,  68,   1,   0,   0, 
+      0,   0,   0,   0,  97, 109, 
+     98, 105, 101, 110, 116,  76, 
     105, 103, 104, 116,   0, 171, 
+    171, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+     99, 111, 108, 111, 114,  67, 
+    108,  97, 109, 112,   0,  99, 
+    111, 109,  98, 105, 110, 101, 
+    100,  77,  97, 116,   0, 171, 
+      3,   0,   3,   0,   4,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 101, 110, 
+    118,  67, 111, 108, 111, 114, 
+      0, 102, 105, 114, 115, 116, 
+     76, 105, 103, 104, 116,   0, 
       1,   0,   2,   0,   1,   0, 
       4,   0,   1,   0,   0,   0, 
       0,   0,   0,   0, 102, 111, 
@@ -155,13 +171,13 @@ const BYTE g_vs20_main[] =
       0,   0, 112, 111, 115, 105, 
     116, 105, 111, 110,   0, 100, 
     105, 114, 101,  99, 116, 105, 
-    111, 110,   0, 171,  75,   1, 
-      0,   0,  84,   1,   0,   0, 
-    100,   1,   0,   0,  84,   1, 
-      0,   0, 109,   1,   0,   0, 
-     84,   1,   0,   0,   5,   0, 
+    111, 110,   0, 171, 135,   1, 
+      0,   0, 144,   1,   0,   0, 
+    160,   1,   0,   0, 144,   1, 
+      0,   0, 169,   1,   0,   0, 
+    144,   1,   0,   0,   5,   0, 
       0,   0,   1,   0,  12,   0, 
-      8,   0,   3,   0, 120,   1, 
+      8,   0,   3,   0, 180,   1, 
       0,   0, 109,  97, 116,  67, 
     111, 108,   0, 110, 111, 114, 
     109,  97, 108,  77,  97, 116, 
@@ -267,29 +283,34 @@ const BYTE g_vs20_main[] =
       0,   3,   0,   0,  15, 208, 
       1,   0, 228, 128,  12,   0, 
     228, 160,   5,   0,   0,   3, 
-      1,   0,   3, 128,   0,   0, 
+      2,   0,   3, 128,   0,   0, 
      85, 128,  42,   0, 228, 160, 
       4,   0,   0,   4,   0,   0, 
       3, 128,  41,   0, 228, 160, 
-      0,   0,   0, 128,   1,   0, 
+      0,   0,   0, 128,   2,   0, 
     228, 128,   4,   0,   0,   4, 
       0,   0,   3, 128,  43,   0, 
     228, 160,   0,   0, 170, 128, 
       0,   0, 228, 128,   2,   0, 
       0,   3,   1,   0,   3, 224, 
       0,   0, 228, 128,  44,   0, 
-    228, 160,   2,   0,   0,   3, 
-      0,   0,   1, 128,   0,   0, 
-    255, 128,  14,   0,  85, 161, 
-      5,   0,   0,   3,   0,   0, 
-      1, 128,   0,   0,   0, 128, 
-     14,   0, 170, 160,  11,   0, 
+    228, 160,  11,   0,   0,   3, 
+      1,   0,  15, 128,   1,   0, 
+    228, 128,  45,   0, 228, 160, 
+      5,   0,   0,   3,   1,   0, 
+     15, 208,   1,   0, 228, 128, 
+     46,   0, 228, 160,   2,   0, 
       0,   3,   0,   0,   1, 128, 
-      0,   0,   0, 128,  14,   0, 
-    255, 160,  10,   0,   0,   3, 
-      0,   0,   4, 224,   0,   0, 
-      0, 128,   4,   0, 170, 160, 
-      1,   0,   0,   2,   0,   0, 
-      3, 224,   2,   0, 228, 144, 
-    255, 255,   0,   0
+      0,   0, 255, 128,  14,   0, 
+     85, 161,   5,   0,   0,   3, 
+      0,   0,   1, 128,   0,   0, 
+      0, 128,  14,   0, 170, 160, 
+     11,   0,   0,   3,   0,   0, 
+      1, 128,   0,   0,   0, 128, 
+     14,   0, 255, 160,  10,   0, 
+      0,   3,   0,   0,   4, 224, 
+      0,   0,   0, 128,   4,   0, 
+    170, 160,   1,   0,   0,   2, 
+      0,   0,   3, 224,   2,   0, 
+    228, 144, 255, 255,   0,   0
 };
diff --git a/src/d3d/shaders/matfx_env_tex_PS.h b/src/d3d/shaders/matfx_env_tex_PS.h
index 3a2d442..e2e7429 100644
--- a/src/d3d/shaders/matfx_env_tex_PS.h
+++ b/src/d3d/shaders/matfx_env_tex_PS.h
@@ -7,7 +7,6 @@
 //
 // Parameters:
 //
-//   float4 colorClamp;
 //   sampler2D diffTex;
 //   sampler2D envTex;
 //   float4 fogColor;
@@ -20,7 +19,6 @@
 //   ------------ ----- ----
 //   fogColor     c0       1
 //   fxparams     c1       1
-//   colorClamp   c2       1
 //   diffTex      s0       1
 //   envTex       s1       1
 //
@@ -29,12 +27,12 @@
     dcl t0.xyz
     dcl t1.xy
     dcl v0
+    dcl v1.xyz
     dcl_2d s0
     dcl_2d s1
     texld r0, t1, s1
     texld r1, t0, s0
-    max r2.xyz, v0, c2
-    mul r2.xyz, r2, c1.x
+    mul r2.xyz, v1, c1.x
     mul r0.xyz, r0, r2
     mul r0.xyz, r0, t0.z
     mul r2.w, r1.w, v0.w
@@ -45,38 +43,30 @@
     mad r2.xyz, r1, r2.w, r0
     mov oC0, r2
 
-// approximately 13 instruction slots used (2 texture, 11 arithmetic)
+// approximately 12 instruction slots used (2 texture, 10 arithmetic)
 #endif
 
 const BYTE g_ps20_main[] =
 {
       0,   2, 255, 255, 254, 255, 
-     71,   0,  67,  84,  65,  66, 
-     28,   0,   0,   0, 229,   0, 
+     64,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0, 200,   0, 
       0,   0,   0,   2, 255, 255, 
-      5,   0,   0,   0,  28,   0, 
+      4,   0,   0,   0,  28,   0, 
       0,   0,   0,   1,   0,   0, 
-    222,   0,   0,   0, 128,   0, 
-      0,   0,   2,   0,   2,   0, 
-      1,   0,  10,   0, 140,   0, 
+    193,   0,   0,   0, 108,   0, 
+      0,   0,   3,   0,   0,   0, 
+      1,   0,   2,   0, 116,   0, 
       0,   0,   0,   0,   0,   0, 
-    156,   0,   0,   0,   3,   0, 
-      0,   0,   1,   0,   2,   0, 
-    164,   0,   0,   0,   0,   0, 
-      0,   0, 180,   0,   0,   0, 
-      3,   0,   1,   0,   1,   0, 
-      6,   0, 188,   0,   0,   0, 
-      0,   0,   0,   0, 204,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   2,   0, 140,   0, 
-      0,   0,   0,   0,   0,   0, 
-    213,   0,   0,   0,   2,   0, 
+    132,   0,   0,   0,   3,   0, 
       1,   0,   1,   0,   6,   0, 
     140,   0,   0,   0,   0,   0, 
-      0,   0,  99, 111, 108, 111, 
-    114,  67, 108,  97, 109, 112, 
-      0, 171,   1,   0,   3,   0, 
-      1,   0,   4,   0,   1,   0, 
+      0,   0, 156,   0,   0,   0, 
+      2,   0,   0,   0,   1,   0, 
+      2,   0, 168,   0,   0,   0, 
+      0,   0,   0,   0, 184,   0, 
+      0,   0,   2,   0,   1,   0, 
+      1,   0,   6,   0, 168,   0, 
       0,   0,   0,   0,   0,   0, 
     100, 105, 102, 102,  84, 101, 
     120,   0,   4,   0,  12,   0, 
@@ -87,63 +77,65 @@ const BYTE g_ps20_main[] =
       1,   0,   1,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
     102, 111, 103,  67, 111, 108, 
-    111, 114,   0, 102, 120, 112, 
-     97, 114,  97, 109, 115,   0, 
-    112, 115,  95,  50,  95,  48, 
-      0,  77, 105,  99, 114, 111, 
-    115, 111, 102, 116,  32,  40, 
-     82,  41,  32,  72,  76,  83, 
-     76,  32,  83, 104,  97, 100, 
-    101, 114,  32,  67, 111, 109, 
-    112, 105, 108, 101, 114,  32, 
-     57,  46,  50,  57,  46,  57, 
-     53,  50,  46,  51,  49,  49, 
-     49,   0, 171, 171,  31,   0, 
-      0,   2,   0,   0,   0, 128, 
-      0,   0,   7, 176,  31,   0, 
-      0,   2,   0,   0,   0, 128, 
-      1,   0,   3, 176,  31,   0, 
-      0,   2,   0,   0,   0, 128, 
-      0,   0,  15, 144,  31,   0, 
-      0,   2,   0,   0,   0, 144, 
-      0,   8,  15, 160,  31,   0, 
-      0,   2,   0,   0,   0, 144, 
-      1,   8,  15, 160,  66,   0, 
-      0,   3,   0,   0,  15, 128, 
-      1,   0, 228, 176,   1,   8, 
-    228, 160,  66,   0,   0,   3, 
-      1,   0,  15, 128,   0,   0, 
-    228, 176,   0,   8, 228, 160, 
-     11,   0,   0,   3,   2,   0, 
-      7, 128,   0,   0, 228, 144, 
-      2,   0, 228, 160,   5,   0, 
-      0,   3,   2,   0,   7, 128, 
-      2,   0, 228, 128,   1,   0, 
-      0, 160,   5,   0,   0,   3, 
-      0,   0,   7, 128,   0,   0, 
-    228, 128,   2,   0, 228, 128, 
+    111, 114,   0, 171, 171, 171, 
+      1,   0,   3,   0,   1,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 102, 120, 
+    112,  97, 114,  97, 109, 115, 
+      0, 112, 115,  95,  50,  95, 
+     48,   0,  77, 105,  99, 114, 
+    111, 115, 111, 102, 116,  32, 
+     40,  82,  41,  32,  72,  76, 
+     83,  76,  32,  83, 104,  97, 
+    100, 101, 114,  32,  67, 111, 
+    109, 112, 105, 108, 101, 114, 
+     32,  57,  46,  50,  57,  46, 
+     57,  53,  50,  46,  51,  49, 
+     49,  49,   0, 171, 171, 171, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,   7, 176, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   1,   0,   3, 176, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,  15, 144, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   1,   0,   7, 144, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   0,   8,  15, 160, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   1,   8,  15, 160, 
+     66,   0,   0,   3,   0,   0, 
+     15, 128,   1,   0, 228, 176, 
+      1,   8, 228, 160,  66,   0, 
+      0,   3,   1,   0,  15, 128, 
+      0,   0, 228, 176,   0,   8, 
+    228, 160,   5,   0,   0,   3, 
+      2,   0,   7, 128,   1,   0, 
+    228, 144,   1,   0,   0, 160, 
       5,   0,   0,   3,   0,   0, 
       7, 128,   0,   0, 228, 128, 
-      0,   0, 170, 176,   5,   0, 
-      0,   3,   2,   0,   8, 128, 
-      1,   0, 255, 128,   0,   0, 
-    255, 144,   4,   0,   0,   4, 
-      1,   0,   7, 128,   0,   0, 
-    228, 144,   1,   0, 228, 128, 
-      0,   0, 228, 161,   4,   0, 
-      0,   4,   1,   0,   7, 128, 
-      0,   0, 170, 176,   1,   0, 
-    228, 128,   0,   0, 228, 160, 
-     11,   0,   0,   3,   0,   0, 
-      8, 128,   2,   0, 255, 128, 
-      1,   0,  85, 160,   5,   0, 
+      2,   0, 228, 128,   5,   0, 
       0,   3,   0,   0,   7, 128, 
-      0,   0, 255, 128,   0,   0, 
-    228, 128,   4,   0,   0,   4, 
-      2,   0,   7, 128,   1,   0, 
-    228, 128,   2,   0, 255, 128, 
-      0,   0, 228, 128,   1,   0, 
-      0,   2,   0,   8,  15, 128, 
-      2,   0, 228, 128, 255, 255, 
-      0,   0
+      0,   0, 228, 128,   0,   0, 
+    170, 176,   5,   0,   0,   3, 
+      2,   0,   8, 128,   1,   0, 
+    255, 128,   0,   0, 255, 144, 
+      4,   0,   0,   4,   1,   0, 
+      7, 128,   0,   0, 228, 144, 
+      1,   0, 228, 128,   0,   0, 
+    228, 161,   4,   0,   0,   4, 
+      1,   0,   7, 128,   0,   0, 
+    170, 176,   1,   0, 228, 128, 
+      0,   0, 228, 160,  11,   0, 
+      0,   3,   0,   0,   8, 128, 
+      2,   0, 255, 128,   1,   0, 
+     85, 160,   5,   0,   0,   3, 
+      0,   0,   7, 128,   0,   0, 
+    255, 128,   0,   0, 228, 128, 
+      4,   0,   0,   4,   2,   0, 
+      7, 128,   1,   0, 228, 128, 
+      2,   0, 255, 128,   0,   0, 
+    228, 128,   1,   0,   0,   2, 
+      0,   8,  15, 128,   2,   0, 
+    228, 128, 255, 255,   0,   0
 };
diff --git a/src/d3d/xbox.cpp b/src/d3d/xbox.cpp
index 35c065e..62fab0c 100644
--- a/src/d3d/xbox.cpp
+++ b/src/d3d/xbox.cpp
@@ -522,97 +522,137 @@ createTexture(int32 width, int32 height, int32 numlevels, uint32 format)
 	return levels;
 }
 
+struct RasterFormatInfo
+{
+	uint32 d3dformat;
+	int32 depth;
+	bool32 hasAlpha;
+	uint32 rwFormat;
+};
+
+// indexed directly by RW format
+static RasterFormatInfo formatInfoRW[16] = {
+	{ 0, 0, 0, 0},
+	{ D3DFMT_A1R5G5B5, 16, 1, Raster::C1555 },
+	{ D3DFMT_R5G6B5,   16, 0, Raster::C565 },
+	{ D3DFMT_A4R4G4B4, 16, 1, Raster::C4444 },
+	{ D3DFMT_L8,        8, 0, Raster::LUM8 },
+	{ D3DFMT_A8R8G8B8, 32, 1, Raster::C8888 },
+	{ D3DFMT_X8R8G8B8, 32, 0, Raster::C888 },
+	{ D3DFMT_UNKNOWN,  16, 0, Raster::D16 },
+	{ D3DFMT_UNKNOWN,  32, 0, Raster::D24 },
+	{ D3DFMT_UNKNOWN,  32, 0, Raster::D32 },
+	{ D3DFMT_X1R5G5B5, 16, 0, Raster::C555 }
+};
+
+static void
+rasterSetFormat(Raster *raster)
+{
+	assert(raster->format != 0);	// no default yet
+
+	XboxRaster *natras = GETXBOXRASTEREXT(raster);
+	if(raster->format & (Raster::PAL4 | Raster::PAL8)){
+		natras->format = D3DFMT_P8;
+		raster->depth = 8;
+	}else{
+		natras->format = formatInfoRW[(raster->format >> 8) & 0xF].d3dformat;
+		raster->depth = formatInfoRW[(raster->format >> 8) & 0xF].depth;
+	}
+	natras->bpp = raster->depth/8;
+	natras->hasAlpha =  formatInfoRW[(raster->format >> 8) & 0xF].hasAlpha;
+	raster->stride = raster->width&natras->bpp;
+}
+
+static Raster*
+rasterCreateTexture(Raster *raster)
+{
+	XboxRaster *natras = GETXBOXRASTEREXT(raster);
+	int32 levels;
+
+	if(natras->format == D3DFMT_P8)
+		natras->palette = (uint8*)rwNew(4*256, MEMDUR_EVENT | ID_DRIVER);
+	levels = Raster::calculateNumLevels(raster->width, raster->height);
+	assert(natras->texture == nil);
+	natras->texture = createTexture(raster->width, raster->height,
+	                                raster->format & Raster::MIPMAP ? levels : 1,
+	                                natras->format);
+	if(natras->texture == nil){
+		RWERROR((ERR_NOTEXTURE));
+		return nil;
+	}
+	return raster;
+}
+
 Raster*
 rasterCreate(Raster *raster)
 {
-	static uint32 formatMap[] = {
-		D3DFMT_UNKNOWN,
-		D3DFMT_A1R5G5B5,
-		D3DFMT_R5G6B5,
-		D3DFMT_A4R4G4B4,
-		D3DFMT_L8,
-		D3DFMT_A8R8G8B8,
-		D3DFMT_X8R8G8B8,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN,
-		D3DFMT_X1R5G5B5,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN,
-		D3DFMT_UNKNOWN
-	};
-	static bool32 alphaMap[] = {
-		0,
-		1,
-		0,
-		1,
-		0,
-		1,
-		0,
-		0, 0, 0,
-		0,
-		0, 0, 0, 0, 0
-	};
+	rasterSetFormat(raster);
 
-	XboxRaster *natras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
-	uint32 format;
-	int32 levels;
+	Raster *ret = raster;
 
 	// Dummy to use as subraster
 	if(raster->width == 0 || raster->height == 0){
 		raster->flags |= Raster::DONTALLOCATE;
 		raster->stride = 0;
-		return raster;
+		goto ret;
 	}
+	if(raster->flags & Raster::DONTALLOCATE)
+		goto ret;
 
 	switch(raster->type){
 	case Raster::NORMAL:
 	case Raster::TEXTURE:
-		if(raster->flags & Raster::DONTALLOCATE)
-			return raster;
-		if(raster->format & (Raster::PAL4 | Raster::PAL8)){
-			format = D3DFMT_P8;
-			natras->palette = (uint8*)rwNew(4*256, MEMDUR_EVENT | ID_DRIVER);
-		}else
-			format = formatMap[(raster->format >> 8) & 0xF];
-		natras->format = 0;
-		natras->hasAlpha = alphaMap[(raster->format >> 8) & 0xF];
-		levels = Raster::calculateNumLevels(raster->width, raster->height);
-		natras->texture = createTexture(raster->width, raster->height,
-		                                raster->format & Raster::MIPMAP ? levels : 1,
-		                                format);
-		if(natras->texture == nil){
-			RWERROR((ERR_NOTEXTURE));
-			return nil;
-		}
-		return raster;
+		ret = rasterCreateTexture(raster);
+		break;
+	default:
+		RWERROR((ERR_INVRASTER));
+		return nil;
 	}
-	// unsupported
-	return nil;
+
+ret:
+	raster->originalWidth = raster->width;
+	raster->originalHeight = raster->height;
+	raster->originalStride = raster->stride;
+	raster->originalPixels = raster->pixels;
+	return ret;
 }
 
 uint8*
 rasterLock(Raster *raster, int32 level, int32 lockMode)
 {
-	// TODO?
-	(void)lockMode;
+	XboxRaster *natras = GETXBOXRASTEREXT(raster);
+
+	// check if already locked
+	if(raster->privateFlags & (Raster::PRIVATELOCK_READ|Raster::PRIVATELOCK_WRITE))
+		return nil;
 
-	XboxRaster *natras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
 	RasterLevels *levels = (RasterLevels*)natras->texture;
-	return levels->levels[level].data;
+	raster->pixels = levels->levels[level].data;
+	raster->width = levels->levels[level].width;
+	raster->height = levels->levels[level].height;
+	raster->stride = raster->width*natras->bpp;
+
+	if(lockMode & Raster::LOCKREAD) raster->privateFlags |= Raster::PRIVATELOCK_READ;
+	if(lockMode & Raster::LOCKWRITE) raster->privateFlags |= Raster::PRIVATELOCK_WRITE;
+
+	return raster->pixels;
 }
 
 void
-rasterUnlock(Raster*, int32)
+rasterUnlock(Raster *raster, int32 level)
 {
+	raster->width = raster->originalWidth;
+	raster->height = raster->originalHeight;
+	raster->stride = raster->originalStride;
+	raster->pixels = raster->originalPixels;
+
+	raster->privateFlags &= ~(Raster::PRIVATELOCK_READ|Raster::PRIVATELOCK_WRITE);
 }
 
 int32
 rasterNumLevels(Raster *raster)
 {
-	XboxRaster *natras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
+	XboxRaster *natras = GETXBOXRASTEREXT(raster);
 	RasterLevels *levels = (RasterLevels*)natras->texture;
 	return levels->numlevels;
 }
@@ -656,12 +696,23 @@ rasterToImage(Raster *raster)
 {
 	int32 depth;
 	Image *image;
-	XboxRaster *natras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
 
-	if(natras->format){
-		image = Image::create(raster->width, raster->height, 32);
+	bool unlock = false;
+	if(raster->pixels == nil){
+		raster->lock(0, Raster::LOCKREAD);
+		unlock = true;
+	}
+
+	XboxRaster *natras = GETXBOXRASTEREXT(raster);
+	if(natras->customFormat){
+		int w = raster->width;
+		int h = raster->height;
+		// pixels are in the upper right corner
+		if(w < 4) w = 4;
+		if(h < 4) h = 4;
+		image = Image::create(w, h, 32);
 		image->allocate();
-		uint8 *pix = raster->lock(0, Raster::LOCKREAD);
+		uint8 *pix = raster->pixels;
 		switch(natras->format){
 		case D3DFMT_DXT1:
 			image->setPixelsDXT(1, pix);
@@ -677,11 +728,17 @@ rasterToImage(Raster *raster)
 			break;
 		default:
 			assert(0 && "unknown format");
-			raster->unlock(0);
 			image->destroy();
+			if(unlock)
+				raster->unlock(0);
 			return nil;
 		}
-		raster->unlock(0);
+		// fix it up again
+		image->width = raster->width;
+		image->height = raster->height;
+
+		if(unlock)
+			raster->unlock(0);
 		return image;
 	}
 
@@ -714,48 +771,51 @@ rasterToImage(Raster *raster)
 		pallength = 256;
 	}
 
-	uint8 *in, *out;
 	image = Image::create(raster->width, raster->height, depth);
 	image->allocate();
 
 	if(pallength){
-		out = image->palette;
-		in = (uint8*)natras->palette;
+		uint8 *out = image->palette;
+		uint8 *in = (uint8*)natras->palette;
+		// bytes are BGRA unlike regular d3d!
 		for(int32 i = 0; i < pallength; i++){
-			out[0] = in[2];
-			out[1] = in[1];
-			out[2] = in[0];
-			out[3] = in[3];
+			conv_BGRA8888_from_RGBA8888(out, in);
 			in += 4;
 			out += 4;
 		}
 	}
 
-	out = image->pixels;
-	in = raster->lock(0, Raster::LOCKREAD);
+	uint8 *imgpixels = image->pixels;
+	uint8 *pixels = raster->pixels;
 
-	unswizzle(out, in, image->width, image->height, depth < 8 ? 1 : depth/8);
+	// NB:
+	assert(image->bpp == (int)natras->bpp);
+	assert(image->stride == raster->stride);
+	unswizzle(imgpixels, pixels, image->width, image->height, image->bpp);
 	// Fix RGB order
-	// TODO: stride
 	uint8 tmp;
 	if(depth > 8)
-		for(int32 y = 0; y < image->height; y++)
-			for(int32 x = 0; x < image->width; x++)
+		for(int32 y = 0; y < image->height; y++){
+			uint8 *imgrow = imgpixels;
+		//	uint8 *rasrow = pixels;
+			for(int32 x = 0; x < image->width; x++){
 				switch(raster->format & 0xF00){
 				case Raster::C8888:
-					tmp = out[0];
-					out[0] = out[2];
-					out[2] = tmp;
-					out += 4;
-					break;
 				case Raster::C888:
-					tmp = out[0];
-					out[0] = out[2];
-					out[2] = tmp;
-					out += 3;
+					tmp = imgrow[0];
+					imgrow[0] = imgrow[2];
+					imgrow[2] = tmp;
+					imgrow += image->bpp;
 					break;
 				}
-	raster->unlock(0);
+			}
+			imgpixels += image->stride;
+		//	pixels += raster->stride;
+		}
+	image->compressPalette();
+
+	if(unlock)
+		raster->unlock(0);
 
 	return image;
 }
@@ -763,7 +823,7 @@ rasterToImage(Raster *raster)
 int32
 getLevelSize(Raster *raster, int32 level)
 {
-	XboxRaster *ras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
+	XboxRaster *ras = GETXBOXRASTEREXT(raster);
 	RasterLevels *levels = (RasterLevels*)ras->texture;
 	return levels->levels[level].size;
 }
@@ -776,6 +836,7 @@ createNativeRaster(void *object, int32 offset, int32)
 	raster->palette = nil;
 	raster->format = 0;
 	raster->hasAlpha = 0;
+	raster->customFormat = 0;
 	raster->unknownFlag = 0;
 	return object;
 }
@@ -822,8 +883,8 @@ readNativeTexture(Stream *stream)
 		RWERROR((ERR_PLATFORM, platform));
 		return nil;
 	}
-	if(version < 0x34001){
-		RWERROR((ERR_VERSION, version));
+	if(vers < 0x34001){
+		RWERROR((ERR_VERSION, vers));
 		return nil;
 	}
 	Texture *tex = Texture::create(nil);
@@ -836,6 +897,9 @@ readNativeTexture(Stream *stream)
 	stream->read8(tex->name, 32);
 	stream->read8(tex->mask, 32);
 
+//if(strcmp(tex->name, "bluallu") == 0)
+//__debugbreak();
+
 	// Raster
 	int32 format = stream->readI32();
 	bool32 hasAlpha = stream->readI16();
@@ -853,16 +917,17 @@ readNativeTexture(Stream *stream)
 	Raster *raster;
 	if(compression){
 		raster = Raster::create(width, height, depth, format | type | Raster::DONTALLOCATE, PLATFORM_XBOX);
-		XboxRaster *ras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
+		XboxRaster *ras = GETXBOXRASTEREXT(raster);
 		ras->format = compression;
 		ras->hasAlpha = hasAlpha;
 		ras->texture = createTexture(raster->width, raster->height,
 	                                     raster->format & Raster::MIPMAP ? numLevels : 1,
 	                                     ras->format);
+		ras->customFormat = 1;
 		raster->flags &= ~Raster::DONTALLOCATE;
 	}else
 		raster = Raster::create(width, height, depth, format | type, PLATFORM_XBOX);
-	XboxRaster *ras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
+	XboxRaster *ras = GETXBOXRASTEREXT(raster);
 	tex->raster = raster;
 
 	if(raster->format & Raster::PAL4)
@@ -892,7 +957,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
 
 	// Raster
 	Raster *raster = tex->raster;
-	XboxRaster *ras = PLUGINOFFSET(XboxRaster, raster, nativeRasterOffset);
+	XboxRaster *ras = GETXBOXRASTEREXT(raster);
 	int32 numLevels = raster->getNumLevels();
 	stream->writeI32(raster->format);
 	stream->writeI16(ras->hasAlpha);
diff --git a/src/engine.cpp b/src/engine.cpp
index 7ad6afd..74dae02 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <assert.h>
 #include <new>
 
@@ -17,7 +18,6 @@
 #include "gl/rwgl3.h"
 #include "gl/rwwdgl.h"
 
-
 #define PLUGIN_ID 0
 
 // on windows
@@ -126,6 +126,15 @@ free_managed(void *p)
 	free(mem->origPtr);
 }
 
+void
+printleaks(void)
+{
+	FORLIST(lnk, allocations){
+		MemoryBlock *mem = LLLinkGetData(lnk, MemoryBlock, inAllocList);
+		printf("sz %zu hint %X\n   %s\n", mem->sz, mem->hint, mem->codeline);
+	}
+}
+
 // TODO: make the debug out configurable
 void *mustmalloc_h(size_t sz, uint32 hint)
 {
@@ -148,11 +157,34 @@ void *mustrealloc_h(void *p, size_t sz, uint32 hint)
 	return nil;
 }
 
-//#define TRACK_ALLOCATIONS
+char *strdup_LOC(const char *s, uint32 hint, const char *here) {
+	char *t;
+	size_t sz = strlen(s)+1;
+	t = (char*)malloc_LOC(sz, hint, here);
+	if(t)
+		memcpy(t, s, sz);
+	return t;
+}
+
+MemoryFunctions defaultMemfuncs = {
+	malloc_h,
+	realloc_h,
+	free,
+	nil,
+	nil
+};
+
+MemoryFunctions managedMemfuncs = {
+	malloc_managed,
+	realloc_managed,
+	free_managed,
+	nil,
+	nil
+};
 
 // This function mainly registers engine plugins
 bool32
-Engine::init(void)
+Engine::init(MemoryFunctions *memfuncs)
 {
 	if(engine || Engine::state != Dead){
 		RWERROR((ERR_ENGINEINIT));
@@ -162,19 +194,15 @@ Engine::init(void)
 	totalMemoryAllocated = 0;
 	allocations.init();
 
-	// TODO: make this an argument
-#ifdef TRACK_ALLOCATIONS
-	memfuncs.rwmalloc = malloc_managed;
-	memfuncs.rwrealloc = realloc_managed;
-	memfuncs.rwfree = free_managed;
-#else
-	memfuncs.rwmalloc = malloc_h;
-	memfuncs.rwrealloc = realloc_h;
-	memfuncs.rwfree = free;
-#endif
+	if(memfuncs)
+		Engine::memfuncs = *memfuncs;
+	else
+		Engine::memfuncs = defaultMemfuncs;
 
-	memfuncs.rwmustmalloc = mustmalloc_h;
-	memfuncs.rwmustrealloc = mustrealloc_h;
+	if(Engine::memfuncs.rwmustmalloc == nil)
+		Engine::memfuncs.rwmustmalloc = mustmalloc_h;
+	if(Engine::memfuncs.rwmustrealloc == nil)
+		Engine::memfuncs.rwmustrealloc = mustrealloc_h;
 
 	PluginList::open();
 
@@ -304,13 +332,6 @@ Engine::term(void)
 	// TODO: maybe reset more stuff here?
 	d3d::nativeRasterOffset = 0;
 
-#ifdef TRACK_ALLOCATIONS
-	FORLIST(lnk, allocations){
-		MemoryBlock *mem = LLLinkGetData(lnk, MemoryBlock, inAllocList);
-		printf("sz %d hint %X\n   %s\n", mem->sz, mem->hint, mem->codeline);
-	}
-#endif
-
 	Engine::state = Dead;
 }
 
@@ -403,6 +424,25 @@ Engine::getVideoModeInfo(VideoMode *info, int32 mode)
 }
 
 
+uint32
+Engine::getMaxMultiSamplingLevels(void)
+{
+	return engine->device.system(DEVICEGETMAXMULTISAMPLINGLEVELS, nil, 0);
+}
+
+uint32
+Engine::getMultiSamplingLevels(void)
+{
+	return engine->device.system(DEVICEGETMULTISAMPLINGLEVELS, nil, 0);
+}
+
+bool32
+Engine::setMultiSamplingLevels(uint32 levels)
+{
+	return engine->device.system(DEVICESETMULTISAMPLINGLEVELS, nil, levels);
+}
+
+
 namespace null {
 
 void beginUpdate(Camera*) { }
@@ -497,6 +537,7 @@ deviceSystem(DeviceReq req, void *arg0, int32 n)
 		return 0;
 	case DEVICEGETSUBSSYSTEMINFO:
 		return 0;
+	default: break;
 	}
 	return 1;
 }
diff --git a/src/geometry.cpp b/src/geometry.cpp
index e1cb50b..5d31c34 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -11,9 +11,6 @@
 #include "rwobjects.h"
 #include "rwengine.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
 #define PLUGIN_ID ID_GEOMETRY
 
 namespace rw {
@@ -475,7 +472,7 @@ Geometry::generateTriangles(int8 *adc)
 		int32 matid = this->matList.findIndex(m->material);
 		if(header->flags == MeshHeader::TRISTRIP)
 			for(uint32 j = 0; j < m->numIndices-2; j++){
-				if(adc && adcbits[j+2] ||
+				if((adc && adcbits[j+2]) ||
 				   isDegenerate(&m->indices[j]))
 					continue;
 				tri->v[0] = m->indices[j+0];
@@ -619,7 +616,7 @@ Geometry::correctTristripWinding(void)
 	rwFree(header);
 	// Now allocate indices and copy them
 	this->allocateMeshes(newhead->numMeshes, newhead->totalIndices, 0);
-	memcpy_neon(this->meshHeader->getMeshes()->indices, indices, this->meshHeader->totalIndices*2);
+	memcpy(this->meshHeader->getMeshes()->indices, indices, this->meshHeader->totalIndices*2);
 	rwFree(indices);
 }
 
@@ -674,7 +671,7 @@ Geometry::removeUnusedMaterials(void)
 	for(uint32 i = 0; i < mh->numMeshes; i++){
 		if(m[i].numIndices <= 0)
 			continue;
-		memcpy_neon(newm->indices, m[i].indices,
+		memcpy(newm->indices, m[i].indices,
 		       m[i].numIndices*sizeof(*m[i].indices));
 		newm++;
 	}
@@ -934,7 +931,10 @@ Material::streamRead(Stream *stream)
 		RWERROR((ERR_CHUNK, "STRUCT"));
 		return nil;
 	}
-	stream->read32(&buf, sizeof(buf));
+	stream->read8(&buf, sizeof(buf));
+	RGBA col = buf.color;
+	memNative32(&buf, sizeof(buf));
+	buf.color = col;
 	Material *mat = Material::create();
 	if(mat == nil)
 		return nil;
@@ -976,7 +976,9 @@ Material::streamWrite(Stream *stream)
 	buf.flags = 0;
 	buf.unused = 0;
 	buf.textured = this->texture != nil;
-	stream->write32(&buf, sizeof(buf));
+	memLittle32(&buf, sizeof(buf));
+	buf.color = this->color;
+	stream->write8(&buf, sizeof(buf));
 
 	if(rw::version >= 0x30400){
 		float32 surfaceProps[3];
diff --git a/src/gl/gl3.cpp b/src/gl/gl3.cpp
index 1fe6995..b876fc9 100644
--- a/src/gl/gl3.cpp
+++ b/src/gl/gl3.cpp
@@ -9,6 +9,7 @@
 #include "../rwpipeline.h"
 #include "../rwobjects.h"
 #include "../rwengine.h"
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
 
@@ -32,6 +33,7 @@ driverOpen(void *o, int32, int32)
 	engine->driver[PLATFORM_GL3]->rasterNumLevels    = rasterNumLevels;
 	engine->driver[PLATFORM_GL3]->imageFindRasterFormat = imageFindRasterFormat;
 	engine->driver[PLATFORM_GL3]->rasterFromImage    = rasterFromImage;
+	engine->driver[PLATFORM_GL3]->rasterToImage      = rasterToImage;
 
 	return o;
 }
diff --git a/src/gl/gl3device.cpp b/src/gl/gl3device.cpp
index 6a118a3..8445e10 100644
--- a/src/gl/gl3device.cpp
+++ b/src/gl/gl3device.cpp
@@ -2,10 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-#include <vitashark.h>
-extern "C"{
-#include <math_neon.h>
-};
+
 #include "../rwbase.h"
 #include "../rwerror.h"
 #include "../rwplg.h"
@@ -14,55 +11,21 @@ extern "C"{
 #include "../rwpipeline.h"
 #include "../rwobjects.h"
 #ifdef RW_OPENGL
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
 #include "rwgl3impl.h"
 
-#include "psp2_shaders.h"
-
 #define PLUGIN_ID 0
 
-uint16_t *gIndicesIm2DPtr[2];
-uint16_t *gIndicesIm3DPtr[2];
-float *gVertexBufferIm2DPtr[2];
-float *gVertexBufferIm3DPtr[2];
-
-uint16_t *gConstIndices;
-float *gVertexBufferIm2D;
-float *gVertexBufferIm3D;
-uint16_t *gIndicesIm2D;
-uint16_t *gIndicesIm3D;
-uint8_t ImIdx = 0;
-
 namespace rw {
 namespace gl3 {
-#ifndef LIBRW_SDL2
-struct DisplayMode
-{
-	int32 depth;
-	uint32 flags;
-};
-#endif
 
-struct GlGlobals
-{
-#ifdef LIBRW_SDL2
-	SDL_Window *window;
-	SDL_GLContext glcontext;
-#else
-	int numMonitors;
-	int currentMonitor;
+GlGlobals glGlobals;
 
-	DisplayMode *modes;
-	int numModes;
-	int currentMode;
-#endif
-	int presentWidth, presentHeight;
-
-	// for opening the window
-	int winWidth, winHeight;
-	const char *winTitle;
-} glGlobals;
+Gl3Caps gl3Caps;
+// terrible hack for GLES
+bool32 needToReadBackTextures;
 
 int32   alphaFunc;
 float32 alphaRef;
@@ -104,18 +67,45 @@ struct UniformObject
 	RGBAf lightColor[MAX_LIGHTS];
 };
 
-struct GLShaderState
-{
-	RGBA matColor;
-	SurfaceProperties surfProps;
-};
+const char *shaderDecl120 =
+"#version 120\n"
+"#define GL2\n"
+"#define texture texture2D\n"
+"#define VSIN(index) attribute\n"
+"#define VSOUT varying\n"
+"#define FSIN varying\n"
+"#define FRAGCOLOR(c) (gl_FragColor = c)\n";
+const char *shaderDecl330 =
+"#version 330\n"
+"#define VSIN(index) layout(location = index) in\n"
+"#define VSOUT out\n"
+"#define FSIN in\n"
+"#define FRAGCOLOR(c) (fragColor = c)\n";
+const char *shaderDecl100es =
+"#version 100\n"
+"#define GL2\n"
+"#define texture texture2D\n"
+"#define VSIN(index) attribute\n"
+"#define VSOUT varying\n"
+"#define FSIN varying\n"
+"#define FRAGCOLOR(c) (gl_FragColor = c)\n"
+"precision highp float;\n"
+"precision highp int;\n";
+const char *shaderDecl310es =
+"#version 310 es\n"
+"#define VSIN(index) layout(location = index) in\n"
+"#define VSOUT out\n"
+"#define FSIN in\n"
+"#define FRAGCOLOR(c) (fragColor = c)\n"
+"precision highp float;\n"
+"precision highp int;\n";
+
+const char *shaderDecl;
 
 // this needs a define in the shaders as well!
 //#define RW_GL_USE_UBOS
 
-#ifndef RW_GLES2
 static GLuint vao;
-#endif
 #ifdef RW_GL_USE_UBOS
 static GLuint ubo_state, ubo_scene, ubo_object;
 #endif
@@ -123,20 +113,16 @@ static GLuint whitetex;
 static UniformState uniformState;
 static UniformScene uniformScene;
 static UniformObject uniformObject;
-static GLShaderState shaderState;
 
 #ifndef RW_GL_USE_UBOS
 // State
 int32 u_alphaRef;
 int32 u_fogData;
-//int32 u_fogStart;
-//int32 u_fogEnd;
-//int32 u_fogRange;
-//int32 u_fogDisable;
 int32 u_fogColor;
 
 // Scene
-int32 u_wvp;
+int32 u_proj;
+int32 u_view;
 
 // Object
 int32 u_world;
@@ -150,9 +136,10 @@ int32 u_lightColor;
 int32 u_matColor;
 int32 u_surfProps;
 
-Shader *defaultShader;
+Shader *defaultShader, *defaultShader_noAT;
+Shader *defaultShader_fullLight, *defaultShader_fullLight_noAT;
 
-//static bool32 stateDirty = 1;
+static bool32 stateDirty = 1;
 static bool32 sceneDirty = 1;
 static bool32 objectDirty = 1;
 
@@ -239,7 +226,7 @@ struct GlState {
 
 	bool32 cullEnable;
 	uint32 cullFace;
-	
+
 	bool32 stencilEnable;
 	// glStencilFunc
 	uint32 stencilFunc;
@@ -298,6 +285,8 @@ static uint32 stencilFuncMap[] = {
 	GL_ALWAYS
 };
 
+static float maxAnisotropy;
+
 /*
  * GL state cache
  */
@@ -352,7 +341,7 @@ flushGlRenderState(void)
 		oldGlState.depthMask = curGlState.depthMask;
 		glDepthMask(oldGlState.depthMask);
 	}
-	
+
 	if(oldGlState.stencilEnable != curGlState.stencilEnable){
 		oldGlState.stencilEnable = curGlState.stencilEnable;
 		(oldGlState.stencilEnable ? glEnable : glDisable)(GL_STENCIL_TEST);
@@ -405,6 +394,8 @@ getAlphaBlend(void)
 	return rwStateCache.blendEnable;
 }
 
+bool32 getAlphaTest(void) { return rwStateCache.alphaTestEnable; }
+
 static void
 setDepthTest(bool32 enable)
 {
@@ -446,7 +437,7 @@ setAlphaTest(bool32 enable)
 		if(alphaFunc != shaderfunc){
 			alphaFunc = shaderfunc;
 			uniformStateDirty[RWGL_ALPHAFUNC] = true;
-			//stateDirty = 1;
+			stateDirty = 1;
 		}
 	}
 }
@@ -461,7 +452,7 @@ setAlphaTestFunction(uint32 function)
 		if(alphaFunc != shaderfunc){
 			alphaFunc = shaderfunc;
 			uniformStateDirty[RWGL_ALPHAFUNC] = true;
-			//stateDirty = 1;
+			stateDirty = 1;
 		}
 	}
 }
@@ -491,43 +482,45 @@ uint32
 bindTexture(uint32 texid)
 {
 	uint32 prev = boundTexture[activeTexture];
-	boundTexture[activeTexture] = texid;
-	glBindTexture(GL_TEXTURE_2D, texid);
+	if(prev != texid){
+		boundTexture[activeTexture] = texid;
+		glBindTexture(GL_TEXTURE_2D, texid);
+	}
 	return prev;
 }
 
 void
 bindFramebuffer(uint32 fbo)
 {
-	//glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-	//if(currentFramebuffer != fbo){
-	//	glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+	if(currentFramebuffer != fbo){
+		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 		currentFramebuffer = fbo;
-	//}
+	}
 }
 
-// TODO: support mipmaps
-#ifdef PSP2_MIPMAPS
-static GLint filterConvMap_NoMIP[] = {
-	0, GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR,
-	   GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR,
-	   GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR
-};
-#else
 static GLint filterConvMap_NoMIP[] = {
 	0, GL_NEAREST, GL_LINEAR,
 	   GL_NEAREST, GL_LINEAR,
 	   GL_NEAREST, GL_LINEAR
 };
-#endif
+static GLint filterConvMap_MIP[] = {
+	0, GL_NEAREST, GL_LINEAR,
+	   GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST,
+	   GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR
+};
 
 static GLint addressConvMap[] = {
 	0, GL_REPEAT, GL_MIRRORED_REPEAT,
+#ifdef PSP2
+	// vitaGL has no border clamp, gxm only does clamp/repeat/mirror
 	GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE
+#else
+	GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER
+#endif
 };
 
 static void
-setFilterMode(uint32 stage, int32 filter)
+setFilterMode(uint32 stage, int32 filter, int32 maxAniso = 1)
 {
 	if(rwStateCache.texstage[stage].filter != (Texture::FilterMode)filter){
 		rwStateCache.texstage[stage].filter = (Texture::FilterMode)filter;
@@ -535,11 +528,27 @@ setFilterMode(uint32 stage, int32 filter)
 		if(raster){
 			Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, rwStateCache.texstage[stage].raster, nativeRasterOffset);
 			if(natras->filterMode != filter){
-				setActiveTexture(stage);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_NoMIP[filter]);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+				// FILTERNONE(0) maps to GL enum 0, which glTexParameteri rejects
+				// (GL_INVALID_ENUM). Unfiltered particle rasters hit this on every bind
+				// - hundreds/frame during heavy particles, each spamming the error log.
+				// Skip the call for 0 but still record the mode so we don't re-enter.
+				if(filter){
+					setActiveTexture(stage);
+					if(natras->autogenMipmap || natras->numLevels > 1){
+						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_MIP[filter]);
+						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+					}else{
+						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_NoMIP[filter]);
+						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+					}
+				}
 				natras->filterMode = filter;
 			}
+			if(natras->maxAnisotropy != maxAniso){
+				setActiveTexture(stage);
+				glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)maxAniso);
+				natras->maxAnisotropy = maxAniso;
+			}
 		}
 	}
 }
@@ -553,8 +562,10 @@ setAddressU(uint32 stage, int32 addressing)
 		if(raster){
 			Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
 			if(natras->addressU == addressing){
-				setActiveTexture(stage);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, addressConvMap[addressing]);
+				if(addressing){	// index 0 maps to GL enum 0 -> GL_INVALID_ENUM spam
+					setActiveTexture(stage);
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, addressConvMap[addressing]);
+				}
 				natras->addressU = addressing;
 			}
 		}
@@ -570,8 +581,10 @@ setAddressV(uint32 stage, int32 addressing)
 		if(raster){
 			Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, rwStateCache.texstage[stage].raster, nativeRasterOffset);
 			if(natras->addressV == addressing){
-				setActiveTexture(stage);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, addressConvMap[addressing]);
+				if(addressing){	// index 0 maps to GL enum 0 -> GL_INVALID_ENUM spam
+					setActiveTexture(stage);
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, addressConvMap[addressing]);
+				}
 				natras->addressV = addressing;
 			}
 		}
@@ -622,14 +635,18 @@ setRasterStage(uint32 stage, Raster *raster)
 		if(raster){
 			assert(raster->platform == PLATFORM_GL3);
 			Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
-			if (natras->texid < 0 || natras->texid > 0xFFFF) bindTexture(whitetex);
-			else bindTexture(natras->texid);
+			bindTexture(natras->texid);
 			uint32 filter = rwStateCache.texstage[stage].filter;
 			uint32 addrU = rwStateCache.texstage[stage].addressingU;
 			uint32 addrV = rwStateCache.texstage[stage].addressingV;
 			if(natras->filterMode != filter){
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_NoMIP[filter]);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+				if(natras->autogenMipmap || natras->numLevels > 1){
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_MIP[filter]);
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+				}else{
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterConvMap_NoMIP[filter]);
+					glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterConvMap_NoMIP[filter]);
+				}
 				natras->filterMode = filter;
 			}
 			if(natras->addressU != addrU){
@@ -658,6 +675,18 @@ setRasterStage(uint32 stage, Raster *raster)
 	}
 }
 
+void
+evictRaster(Raster *raster)
+{
+	int i;
+	for(i = 0; i < MAXNUMSTAGES; i++){
+		//assert(rwStateCache.texstage[i].raster != raster);
+		if(rwStateCache.texstage[i].raster != raster)
+			continue;
+		setRasterStage(i, nil);
+	}
+}
+
 void
 setTexture(int32 stage, Texture *tex)
 {
@@ -666,7 +695,7 @@ setTexture(int32 stage, Texture *tex)
 		return;
 	}
 	setRasterStageOnly(stage, tex->raster);
-	setFilterMode(stage, tex->getFilter());
+	setFilterMode(stage, tex->getFilter(), tex->getMaxAnisotropy());
 	setAddressU(stage, tex->getAddressU());
 	setAddressV(stage, tex->getAddressV());
 }
@@ -717,7 +746,7 @@ setRenderState(int32 state, void *pvalue)
 		if(rwStateCache.fogEnable != value){
 			rwStateCache.fogEnable = value;
 			uniformStateDirty[RWGL_FOG] = true;
-			//stateDirty = 1;
+			stateDirty = 1;
 		}
 		break;
 	case FOGCOLOR:
@@ -729,7 +758,7 @@ setRenderState(int32 state, void *pvalue)
 		c.alpha = value>>24;
 		convColor(&uniformState.fogColor, &c);
 		uniformStateDirty[RWGL_FOGCOLOR] = true;
-		//stateDirty = 1;
+		stateDirty = 1;
 		break;
 	case CULLMODE:
 		if(rwStateCache.cullmode != value){
@@ -742,7 +771,7 @@ setRenderState(int32 state, void *pvalue)
 			}
 		}
 		break;
-		
+
 	case STENCILENABLE:
 		if(rwStateCache.stencilenable != value){
 			rwStateCache.stencilenable = value;
@@ -792,7 +821,6 @@ setRenderState(int32 state, void *pvalue)
 		}
 		break;
 
-
 	case ALPHATESTFUNC:
 		setAlphaTestFunction(value);
 		break;
@@ -800,7 +828,7 @@ setRenderState(int32 state, void *pvalue)
 		if(alphaRef != value/255.0f){
 			alphaRef = value/255.0f;
 			uniformStateDirty[RWGL_ALPHAREF] = true;
-//			stateDirty = 1;
+			stateDirty = 1;
 		}
 		break;
 	case GSALPHATEST:
@@ -860,7 +888,7 @@ getRenderState(int32 state)
 	case CULLMODE:
 		val = rwStateCache.cullmode;
 		break;
-		
+
 	case STENCILENABLE:
 		val = rwStateCache.stencilenable;
 		break;
@@ -917,13 +945,13 @@ resetRenderState(void)
 	uniformState.fogColor = { 1.0f, 1.0f, 1.0f, 1.0f };
 	rwStateCache.gsalpha = 0;
 	rwStateCache.gsalpharef = 128;
-//	stateDirty = 1;
+	stateDirty = 1;
 
 	rwStateCache.vertexAlpha = 0;
 	rwStateCache.textureAlpha = 0;
 	rwStateCache.alphaTestEnable = 0;
 
-	memset(&oldGlState, 0xFF, sizeof(oldGlState));
+	memset(&oldGlState, 0xFE, sizeof(oldGlState));
 
 	rwStateCache.blendEnable = 0;
 	setGlRenderState(RWGL_BLEND, false);
@@ -942,7 +970,7 @@ resetRenderState(void)
 	rwStateCache.cullmode = CULLNONE;
 	setGlRenderState(RWGL_CULL, false);
 	setGlRenderState(RWGL_CULLFACE, GL_BACK);
-	
+
 	rwStateCache.stencilenable = 0;
 	setGlRenderState(RWGL_STENCIL, GL_FALSE);
 	rwStateCache.stencilfail = STENCILKEEP;
@@ -972,6 +1000,7 @@ void
 setWorldMatrix(Matrix *mat)
 {
 	convMatrix(&uniformObject.world, mat);
+	setUniform(u_world, &uniformObject.world);
 	objectDirty = 1;
 }
 
@@ -991,17 +1020,16 @@ setLights(WorldLights *lightData)
 
 	n = 0;
 	for(i = 0; i < lightData->numDirectionals && i < 8; i++){
+		if(n >= MAX_LIGHTS) break;
 		l = lightData->directionals[i];
 		uniformObject.lightParams[n].type = 1.0f;
 		uniformObject.lightColor[n] = l->color;
-		memcpy_neon(&uniformObject.lightDirection[n], &l->getFrame()->getLTM()->at, sizeof(V3d));
-		bits |= VSLIGHT_POINT;
+		memcpy(&uniformObject.lightDirection[n], &l->getFrame()->getLTM()->at, sizeof(V3d));
+		bits |= VSLIGHT_DIRECT;
 		n++;
-		if(n >= MAX_LIGHTS)
-			goto out;
 	}
 
-	for(i = 0; i < lightData->numLocals; i++){
+	for(i = 0; i < lightData->numLocals && n < MAX_LIGHTS; i++){
 		Light *l = lightData->locals[i];
 
 		switch(l->getType()){
@@ -1009,11 +1037,9 @@ setLights(WorldLights *lightData)
 			uniformObject.lightParams[n].type = 2.0f;
 			uniformObject.lightParams[n].radius = l->radius;
 			uniformObject.lightColor[n] = l->color;
-			memcpy_neon(&uniformObject.lightPosition[n], &l->getFrame()->getLTM()->pos, sizeof(V3d));
+			memcpy(&uniformObject.lightPosition[n], &l->getFrame()->getLTM()->pos, sizeof(V3d));
 			bits |= VSLIGHT_POINT;
 			n++;
-			if(n >= MAX_LIGHTS)
-				goto out;
 			break;
 		case Light::SPOT:
 		case Light::SOFTSPOT:
@@ -1021,8 +1047,8 @@ setLights(WorldLights *lightData)
 			uniformObject.lightParams[n].minusCosAngle = l->minusCosAngle;
 			uniformObject.lightParams[n].radius = l->radius;
 			uniformObject.lightColor[n] = l->color;
-			memcpy_neon(&uniformObject.lightPosition[n], &l->getFrame()->getLTM()->pos, sizeof(V3d));
-			memcpy_neon(&uniformObject.lightDirection[n], &l->getFrame()->getLTM()->at, sizeof(V3d));
+			memcpy(&uniformObject.lightPosition[n], &l->getFrame()->getLTM()->pos, sizeof(V3d));
+			memcpy(&uniformObject.lightDirection[n], &l->getFrame()->getLTM()->at, sizeof(V3d));
 			// lower bound of falloff
 			if(l->getType() == Light::SOFTSPOT)
 				uniformObject.lightParams[n].hardSpot = 0.0f;
@@ -1030,14 +1056,24 @@ setLights(WorldLights *lightData)
 				uniformObject.lightParams[n].hardSpot = 1.0f;
 			bits |= VSLIGHT_SPOT;
 			n++;
-			if(n >= MAX_LIGHTS)
-				goto out;
 			break;
 		}
 	}
 
-	uniformObject.lightParams[n].type = 0.0f;
-out:
+	// Terminator only if there's room; the shader also stops at MAX_LIGHTS.
+	if(n < MAX_LIGHTS)
+		uniformObject.lightParams[n].type = 0.0f;
+
+	// Always upload. The original code jumped past these setUniform calls once the
+	// light array filled (goto out), leaving the shader with stale light data - so
+	// a scene with 8+ lights (e.g. a night cutscene lit by many point lights) got
+	// the previous object's lighting or none, and rendered black.
+	setUniform(u_ambLight, &uniformObject.ambLight);
+	setUniform(u_lightParams, uniformObject.lightParams);
+	setUniform(u_lightPosition, uniformObject.lightPosition);
+	setUniform(u_lightDirection, uniformObject.lightDirection);
+	setUniform(u_lightColor, uniformObject.lightColor);
+
 	objectDirty = 1;
 	return bits;
 }
@@ -1045,43 +1081,34 @@ out:
 void
 setProjectionMatrix(float32 *mat)
 {
-	memcpy_neon(&uniformScene.proj, mat, 64);
+	memcpy(&uniformScene.proj, mat, 64);
+	setUniform(u_proj, uniformScene.proj);
 	sceneDirty = 1;
 }
 
 void
 setViewMatrix(float32 *mat)
 {
-	memcpy_neon(&uniformScene.view, mat, 64);
+	memcpy(&uniformScene.view, mat, 64);
+	setUniform(u_view, uniformScene.view);
 	sceneDirty = 1;
 }
 
 Shader *lastShaderUploaded;
 
-#define U(i) currentShader->uniformLocations[i]
-
-rw::RGBAf matColorCache;
-float surfPropsCache[4];
-
 void
-setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops)
+setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp)
 {
-	//bool force = lastShaderUploaded != currentShader;
-	//if(force || !equal(shaderState.matColor, color)){
-		convColor(&matColorCache, &color);
-		shaderState.matColor = color;
-	//}
+	rw::RGBAf col;
+	convColor(&col, &color);
+	setUniform(u_matColor, &col);
 
-	//if(force ||
-	//   shaderState.surfProps.ambient != surfaceprops.ambient ||
-	//   shaderState.surfProps.specular != surfaceprops.specular ||
-	//   shaderState.surfProps.diffuse != surfaceprops.diffuse){
-		surfPropsCache[0] = surfaceprops.ambient;
-		surfPropsCache[1] = surfaceprops.specular;
-		surfPropsCache[2] = surfaceprops.diffuse;
-		surfPropsCache[3] = 0.0f;
-		shaderState.surfProps = surfaceprops;
-	//}
+	float surfProps[4];
+	surfProps[0] = surfaceprops.ambient;
+	surfProps[1] = surfaceprops.specular;
+	surfProps[2] = surfaceprops.diffuse;
+	surfProps[3] = extraSurfProp;
+	setUniform(u_surfProps, surfProps);
 }
 
 void
@@ -1089,98 +1116,112 @@ flushCache(void)
 {
 	flushGlRenderState();
 
-	glUniform4fv(U(u_matColor), 1, &matColorCache.red);
-	glUniform4fv(U(u_surfProps), 1, surfPropsCache);
-		
-	// TODO: this is probably a stupid way to do it without UBOs
-	if(lastShaderUploaded != currentShader){
-		lastShaderUploaded = currentShader;
-		objectDirty = 1;
-		sceneDirty = 1;
-		//stateDirty = 1;
+#ifndef RW_GL_USE_UBOS
 
-		int i;
-		for(i = 0; i < RWGL_NUM_STATES; i++)
-			uniformStateDirty[i] = true;
-	}
-	
-	if(sceneDirty){
-		float wv[16], wvp[16];
-		matmul4_neon((float *)uniformScene.view, (float *)&uniformObject.world, (float *)wv);
-		matmul4_neon((float *)uniformScene.proj, (float *)wv, (float *)wvp);
-		glUniformMatrix4fv(U(u_wvp), 1, 0, (float*)wvp);
+	// what's this doing here??
+	uniformState.fogDisable = rwStateCache.fogEnable ? 0.0f : 1.0f;
+	uniformState.fogStart = rwStateCache.fogStart;
+	uniformState.fogEnd = rwStateCache.fogEnd;
+	uniformState.fogRange = 1.0f/(rwStateCache.fogStart - rwStateCache.fogEnd);
+
+	if(uniformStateDirty[RWGL_ALPHAFUNC] || uniformStateDirty[RWGL_ALPHAREF]){
+		float alphaTest[4];
+		switch(alphaFunc){
+		case ALPHAALWAYS:
+		default:
+			alphaTest[0] = -1000.0f;
+			alphaTest[1] = 1000.0f;
+			break;
+		case ALPHAGREATEREQUAL:
+			alphaTest[0] = alphaRef;
+			alphaTest[1] = 1000.0f;
+			break;
+		case ALPHALESS:
+			alphaTest[0] = -1000.0f;
+			alphaTest[1] = alphaRef;
+			break;
+		}
+		setUniform(u_alphaRef, alphaTest);
+		uniformStateDirty[RWGL_ALPHAFUNC] = false;
+		uniformStateDirty[RWGL_ALPHAREF] = false;
 	}
 
+	if(uniformStateDirty[RWGL_FOG] ||
+	   uniformStateDirty[RWGL_FOGSTART] ||
+	   uniformStateDirty[RWGL_FOGEND]){
+		float fogData[4] = {
+			uniformState.fogStart,
+			uniformState.fogEnd,
+			uniformState.fogRange,
+			uniformState.fogDisable
+		};
+		setUniform(u_fogData, fogData);
+		uniformStateDirty[RWGL_FOG] = false;
+		uniformStateDirty[RWGL_FOGSTART] = false;
+		uniformStateDirty[RWGL_FOGEND] = false;
+	}
+
+	if(uniformStateDirty[RWGL_FOGCOLOR]){
+		setUniform(u_fogColor, &uniformState.fogColor);
+		uniformStateDirty[RWGL_FOGCOLOR] = false;
+	}
+
+#else
 	if(objectDirty){
-		glUniformMatrix4fv(U(u_world), 1, 0, (float*)&uniformObject.world);
-		
-		glUniform4fv(U(u_ambLight), 1, (float*)&uniformObject.ambLight);
-		glUniform4fv(U(u_lightParams), MAX_LIGHTS, (float*)uniformObject.lightParams);
-		//glUniform4fv(U(u_lightPosition), MAX_LIGHTS, (float*)uniformObject.lightPosition);
-		glUniform4fv(U(u_lightDirection), MAX_LIGHTS, (float*)uniformObject.lightDirection);
-		glUniform4fv(U(u_lightColor), MAX_LIGHTS, (float*)uniformObject.lightColor);
+		glBindBuffer(GL_UNIFORM_BUFFER, ubo_object);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformObject), nil, GL_STREAM_DRAW);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformObject), &uniformObject, GL_STREAM_DRAW);
 		objectDirty = 0;
 	}
-
-//	if(stateDirty){
-
+	if(sceneDirty){
+		glBindBuffer(GL_UNIFORM_BUFFER, ubo_scene);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformScene), nil, GL_STREAM_DRAW);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformScene), &uniformScene, GL_STREAM_DRAW);
+		sceneDirty = 0;
+	}
+	if(stateDirty){
+		switch(alphaFunc){
+		case ALPHAALWAYS:
+		default:
+			uniformState.alphaRefLow = -1000.0f;
+			uniformState.alphaRefHigh = 1000.0f;
+			break;
+		case ALPHAGREATEREQUAL:
+			uniformState.alphaRefLow = alphaRef;
+			uniformState.alphaRefHigh = 1000.0f;
+			break;
+		case ALPHALESS:
+			uniformState.alphaRefLow = -1000.0f;
+			uniformState.alphaRefHigh = alphaRef;
+			break;
+		}
 		uniformState.fogDisable = rwStateCache.fogEnable ? 0.0f : 1.0f;
 		uniformState.fogStart = rwStateCache.fogStart;
 		uniformState.fogEnd = rwStateCache.fogEnd;
-		uniformState.fogRange = 1.0f / (rwStateCache.fogStart - rwStateCache.fogEnd);
-
-		if(uniformStateDirty[RWGL_ALPHAFUNC] || uniformStateDirty[RWGL_ALPHAREF]){
-			switch(alphaFunc){
-			case ALPHAALWAYS:
-			default:
-				glUniform2f(U(u_alphaRef), -1000.0f, 1000.0f);
-				break;
-			case ALPHAGREATEREQUAL:
-				glUniform2f(U(u_alphaRef), alphaRef, 1000.0f);
-				break;
-			case ALPHALESS:
-				glUniform2f(U(u_alphaRef), -1000.0f, alphaRef);
-				break;
-			}
-			uniformStateDirty[RWGL_ALPHAFUNC] = false;
-			uniformStateDirty[RWGL_ALPHAREF] = false;
-		}
-
-		if(uniformStateDirty[RWGL_FOG] ||
-		   uniformStateDirty[RWGL_FOGSTART] ||
-		   uniformStateDirty[RWGL_FOGEND]){
-			float fogData[4] = {
-				uniformState.fogStart,
-				uniformState.fogEnd,
-				uniformState.fogRange,
-				uniformState.fogDisable
-			};
-			glUniform4fv(U(u_fogData), 1, fogData);
-			uniformStateDirty[RWGL_FOG] = false;
-			uniformStateDirty[RWGL_FOGSTART] = false;
-			uniformStateDirty[RWGL_FOGEND] = false;
-		}
-
-		if(uniformStateDirty[RWGL_FOGCOLOR]){
-			glUniform4fv(U(u_fogColor), 1, (float*)&uniformState.fogColor);
-			uniformStateDirty[RWGL_FOGCOLOR] = false;
-		}
+		uniformState.fogRange = 1.0f/(rwStateCache.fogStart - rwStateCache.fogEnd);
+		glBindBuffer(GL_UNIFORM_BUFFER, ubo_state);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformState), nil, GL_STREAM_DRAW);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformState), &uniformState, GL_STREAM_DRAW);
+		stateDirty = 0;
+	}
+#endif
+	flushUniforms();
 }
 
 static void
 setFrameBuffer(Camera *cam)
 {
-	Raster *fbuf = cam->frameBuffer;
-	Raster *zbuf = cam->zBuffer;
+	Raster *fbuf = cam->frameBuffer->parent;
+	Raster *zbuf = cam->zBuffer->parent;
 	assert(fbuf);
 
 	Gl3Raster *natfb = PLUGINOFFSET(Gl3Raster, fbuf, nativeRasterOffset);
-	//Gl3Raster *natzb = PLUGINOFFSET(Gl3Raster, zbuf, nativeRasterOffset);
+	Gl3Raster *natzb = PLUGINOFFSET(Gl3Raster, zbuf, nativeRasterOffset);
 	assert(fbuf->type == Raster::CAMERA || fbuf->type == Raster::CAMERATEXTURE);
 
 	// Have to make sure depth buffer is attached to FB's fbo
 	bindFramebuffer(natfb->fbo);
-	/*if(zbuf){
+	if(zbuf){
 		if(natfb->fboMate == zbuf){
 			// all good
 			assert(natzb->fboMate == fbuf);
@@ -1190,22 +1231,76 @@ setFrameBuffer(Camera *cam)
 				Gl3Raster *oldfb = PLUGINOFFSET(Gl3Raster, natzb->fboMate, nativeRasterOffset);
 				if(oldfb->fbo){
 					bindFramebuffer(oldfb->fbo);
-					glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+					glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
 					bindFramebuffer(natfb->fbo);
 				}
 				oldfb->fboMate = nil;
 			}
 			natfb->fboMate = zbuf;
 			natzb->fboMate = fbuf;
-			if(natfb->fbo)
-				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, natzb->texid, 0);
+			if(natfb->fbo){
+				if(gl3Caps.gles)
+					glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, natzb->texid);
+				else
+					glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, natzb->texid, 0);
+			}
 		}
 	}else{
 		// remove z-buffer
 		if(natfb->fboMate && natfb->fbo)
-			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
 		natfb->fboMate = nil;
-	}*/
+	}
+}
+
+static Rect
+getFramebufferRect(Raster *frameBuffer)
+{
+	Rect r;
+	Raster *fb = frameBuffer->parent;
+	if(fb->type == Raster::CAMERA){
+#ifdef LIBRW_SDL2
+		SDL_GetWindowSize(glGlobals.window, &r.w, &r.h);
+#elif defined(PSP2)
+		// The display is whatever vglInitExtended set up, i.e. the one video mode.
+		// Not winWidth/winHeight: those keep the defaults the game had at engine
+		// open time, before it picked a video mode, and would shrink the viewport.
+		r.w = glGlobals.modes[glGlobals.currentMode].mode.width;
+		r.h = glGlobals.modes[glGlobals.currentMode].mode.height;
+#else
+		glfwGetFramebufferSize(glGlobals.window, &r.w, &r.h);
+#endif
+	}else{
+		r.w = fb->width;
+		r.h = fb->height;
+	}
+	r.x = 0;
+	r.y = 0;
+
+	// Got a subraster
+	if(frameBuffer != fb){
+		r.x = frameBuffer->offsetX;
+		// GL y offset is from bottom
+		r.y = r.h - frameBuffer->height - frameBuffer->offsetY;
+		r.w = frameBuffer->width;
+		r.h = frameBuffer->height;
+	}
+
+	return r;
+}
+
+static void
+setViewport(Raster *frameBuffer)
+{
+	Rect r = getFramebufferRect(frameBuffer);
+	if(r.w != glGlobals.presentWidth || r.h != glGlobals.presentHeight ||
+	   r.x != glGlobals.presentOffX || r.y != glGlobals.presentOffY){
+		glViewport(r.x, r.y, r.w, r.h);
+		glGlobals.presentWidth = r.w;
+		glGlobals.presentHeight = r.h;
+		glGlobals.presentOffX = r.x;
+		glGlobals.presentOffY = r.y;
+	}
 }
 
 static void
@@ -1233,7 +1328,7 @@ beginUpdate(Camera *cam)
 	view[13] =  inv.pos.y;
 	view[14] =  inv.pos.z;
 	view[15] =  1.0f;
-	memcpy_neon(&cam->devView, &view, sizeof(RawMatrix));
+	memcpy(&cam->devView, &view, sizeof(RawMatrix));
 	setViewMatrix(view);
 
 	// Projection Matrix
@@ -1262,56 +1357,32 @@ beginUpdate(Camera *cam)
 		proj[14] = -2.0f*cam->nearPlane*cam->farPlane*invz;
 		proj[15] = 0.0f;
 	}else{
-		proj[10] = -(cam->farPlane+cam->nearPlane)*invz;
+		proj[10] = 2.0f*invz;
 		proj[11] = 0.0f;
 
-		proj[14] = 2.0f*invz;
+		proj[14] = -(cam->farPlane+cam->nearPlane)*invz;
 		proj[15] = 1.0f;
 	}
-	memcpy_neon(&cam->devProj, &proj, sizeof(RawMatrix));
+	memcpy(&cam->devProj, &proj, sizeof(RawMatrix));
 	setProjectionMatrix(proj);
 
 	if(rwStateCache.fogStart != cam->fogPlane){
 		rwStateCache.fogStart = cam->fogPlane;
 		uniformStateDirty[RWGL_FOGSTART] = true;
-		//stateDirty = 1;
+		stateDirty = 1;
 	}
 	if(rwStateCache.fogEnd != cam->farPlane){
 		rwStateCache.fogEnd = cam->farPlane;
 		uniformStateDirty[RWGL_FOGEND] = true;
-		//stateDirty = 1;
+		stateDirty = 1;
 	}
 
 	setFrameBuffer(cam);
 
-	ImIdx = (ImIdx + 1) % 2;
-	gVertexBufferIm2D = gVertexBufferIm2DPtr[ImIdx];
-	gVertexBufferIm3D = gVertexBufferIm3DPtr[ImIdx];
-	gIndicesIm2D = gIndicesIm2DPtr[ImIdx];
-	gIndicesIm3D = gIndicesIm3DPtr[ImIdx];
-	
-	int w, h;
-	if(cam->frameBuffer->type == Raster::CAMERA){
-#ifdef LIBRW_SDL2
-		SDL_GetWindowSize(glGlobals.window, &w, &h);
-#else
-		w = 960;
-		h = 544;
-#endif
-	}else{
-		w = cam->frameBuffer->width;
-		h = cam->frameBuffer->height;
-	}
-
-	if(w != glGlobals.presentWidth || h != glGlobals.presentHeight){
-		glViewport(0, 0, w, h);
-		glGlobals.presentWidth = w;
-		glGlobals.presentHeight = h;
-	}
+	setViewport(cam->frameBuffer);
 }
 
-static
-void
+static void
 endUpdate(Camera *cam)
 {
 }
@@ -1319,8 +1390,19 @@ endUpdate(Camera *cam)
 static void
 clearCamera(Camera *cam, RGBA *col, uint32 mode)
 {
-	/*RGBAf colf;
-	int mask;
+	RGBAf colf;
+	GLbitfield mask;
+
+	setFrameBuffer(cam);
+
+	// make sure we're only clearing the part of the framebuffer
+	// that is subrastered
+	bool setScissor = cam->frameBuffer != cam->frameBuffer->parent;
+	if(setScissor){
+		Rect r = getFramebufferRect(cam->frameBuffer);
+		glScissor(r.x, r.y, r.w, r.h);
+		glEnable(GL_SCISSOR_TEST);
+	}
 
 	convColor(&colf, col);
 	glClearColor(colf.red, colf.green, colf.blue, colf.alpha);
@@ -1329,24 +1411,41 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
 		mask |= GL_COLOR_BUFFER_BIT;
 	if(mode & Camera::CLEARZ)
 		mask |= GL_DEPTH_BUFFER_BIT;
+	if(mode & Camera::CLEARSTENCIL)
+		mask |= GL_STENCIL_BUFFER_BIT;
 	glDepthMask(GL_TRUE);
-	glClear((GLbitfield)mask);
-	glDepthMask(rwStateCache.zwrite);*/
+	glClear(mask);
+	glDepthMask(rwStateCache.zwrite);
+
+	if(setScissor)
+		glDisable(GL_SCISSOR_TEST);
 }
 
 static void
 showRaster(Raster *raster, uint32 flags)
 {
-	// TODO: do this properly!
+//	glViewport(raster->offsetX, raster->offsetY,
+//		raster->width, raster->height);
+
 #ifdef LIBRW_SDL2
+	if(flags & Raster::FLIPWAITVSYNCH)
+		SDL_GL_SetSwapInterval(1);
+	else
+		SDL_GL_SetSwapInterval(0);
 	SDL_GL_SwapWindow(glGlobals.window);
-#else
+#elif defined(PSP2)
 	if(flags & Raster::FLIPWAITVSYNCH)
 		vglWaitVblankStart(GL_TRUE);
 	else
 		vglWaitVblankStart(GL_FALSE);
-#endif
 	vglSwapBuffers(GL_FALSE);
+#else
+	if(flags & Raster::FLIPWAITVSYNCH)
+		glfwSwapInterval(1);
+	else
+		glfwSwapInterval(0);
+	glfwSwapBuffers(glGlobals.window);
+#endif
 }
 
 static bool32
@@ -1363,22 +1462,28 @@ rasterRenderFast(Raster *raster, int32 x, int32 y)
 	case Raster::CAMERATEXTURE:
 		switch(src->type){
 		case Raster::CAMERA:
+#ifdef PSP2
+			// vitaGL implements glCopyTexSubImage2D as a glReadPixels round-trip,
+			// which mangles alpha and stalls the GPU (see raster lock notes). Use a
+			// real GPU framebuffer blit instead: src is the display (CAMERA, fbo 0),
+			// dst a CAMERATEXTURE with its own fbo. Placement mirrors the copytex
+			// version so the colour-filter UVs (POT-padded, Y-flipped) stay valid.
+			glBindFramebuffer(GL_READ_FRAMEBUFFER, natsrc->fbo);
+			glBindFramebuffer(GL_DRAW_FRAMEBUFFER, natdst->fbo);
+			glBlitFramebuffer(0, 0, src->width, src->height,
+				x, (dst->height-src->height)-y, x+src->width, dst->height-y,
+				GL_COLOR_BUFFER_BIT, GL_NEAREST);
+			// Re-sync the real binding with librw's cache (blit bound read+draw raw).
+			glBindFramebuffer(GL_FRAMEBUFFER, currentFramebuffer);
+			return 1;
+#else
 			setActiveTexture(0);
 			glBindTexture(GL_TEXTURE_2D, natdst->texid);
-			SceDisplayFrameBuf pParam;
-			pParam.size = sizeof(SceDisplayFrameBuf);
-			sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
-			sceGxmTransferCopy(960, 544, 0, SCE_GXM_COLOR_MASK_A,
-				SCE_GXM_TRANSFER_COLORKEY_NONE,
-				SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR,
-				SCE_GXM_TRANSFER_LINEAR,
-				pParam.base, 0, 0, 960 * 4,
-				SCE_GXM_TRANSFER_FORMAT_U8U8U8_BGR,
-				SCE_GXM_TRANSFER_LINEAR,
-				(uint8_t*)vglGetTexDataPointer(GL_TEXTURE_2D) + (dst->height - 1) * dst->stride, 0, 0, -dst->stride,
-				NULL, SCE_GXM_TRANSFER_FRAGMENT_SYNC, NULL);
+			glCopyTexSubImage2D(GL_TEXTURE_2D, 0, x, (dst->height-src->height)-y,
+				0, 0, src->width, src->height);
 			glBindTexture(GL_TEXTURE_2D, boundTexture[0]);
 			return 1;
+#endif
 		}
 		break;
 	}
@@ -1386,99 +1491,251 @@ rasterRenderFast(Raster *raster, int32 x, int32 y)
 }
 
 #ifdef LIBRW_SDL2
+
+static void
+addVideoMode(int displayIndex, int modeIndex)
+{
+	int i;
+	SDL_DisplayMode mode;
+
+	SDL_GetDisplayMode(displayIndex, modeIndex, &mode);
+
+	for(i = 1; i < glGlobals.numModes; i++){
+		if(glGlobals.modes[i].mode.w == mode.w &&
+		   glGlobals.modes[i].mode.h == mode.h &&
+		   glGlobals.modes[i].mode.format == mode.format){
+			// had this mode already, remember highest refresh rate
+			if(mode.refresh_rate > glGlobals.modes[i].mode.refresh_rate)
+				glGlobals.modes[i].mode.refresh_rate = mode.refresh_rate;
+			return;
+		}
+	}
+
+	// none found, add
+	glGlobals.modes[glGlobals.numModes].mode = mode;
+	glGlobals.modes[glGlobals.numModes].flags = VIDEOMODEEXCLUSIVE;
+	glGlobals.numModes++;
+}
+
+static void
+makeVideoModeList(int displayIndex)
+{
+	int i, num, depth;
+
+	num = SDL_GetNumDisplayModes(displayIndex);
+	rwFree(glGlobals.modes);
+	glGlobals.modes = rwNewT(DisplayMode, num+1, ID_DRIVER | MEMDUR_EVENT);
+
+	SDL_GetCurrentDisplayMode(displayIndex, &glGlobals.modes[0].mode);
+	glGlobals.modes[0].flags = 0;
+	glGlobals.numModes = 1;
+
+	for(i = 0; i < num; i++)
+		addVideoMode(displayIndex, i);
+
+	for(i = 0; i < glGlobals.numModes; i++){
+		depth = SDL_BITSPERPIXEL(glGlobals.modes[i].mode.format);
+		// set depth to power of two
+		for(glGlobals.modes[i].depth = 1; glGlobals.modes[i].depth < depth; glGlobals.modes[i].depth <<= 1);
+	}
+}
+
 static int
 openSDL2(EngineOpenParams *openparams)
 {
-	if (!openparams){
-		RWERROR((ERR_GENERAL, "openparams invalid"));
-		return 0;
-	}
+	glGlobals.winWidth = openparams->width;
+	glGlobals.winHeight = openparams->height;
+	glGlobals.winTitle = openparams->windowtitle;
+	glGlobals.pWindow = openparams->window;
 
-	GLenum status;
-	SDL_Window *win;
-	SDL_GLContext ctx;
+	memset(&gl3Caps, 0, sizeof(gl3Caps));
 
 	/* Init SDL */
 	if(SDL_InitSubSystem(SDL_INIT_VIDEO)){
-		RWERROR((ERR_ENGINEOPEN, SDL_GetError()));
+		RWERROR((ERR_GENERAL, SDL_GetError()));
 		return 0;
 	}
-	SDL_ClearHints();
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
 
-	int flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL;
-	if (openparams->fullscreen)
-		flags |= SDL_WINDOW_FULLSCREEN;
-	win = SDL_CreateWindow(openparams->windowtitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, openparams->width, openparams->height, flags);
-	if(win == nil){
-		RWERROR((ERR_ENGINEOPEN, SDL_GetError()));
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
-		return 0;
-	}
-	ctx = SDL_GL_CreateContext(win);
+	makeVideoModeList(0);
 
-#ifndef LIBRW_GLAD
-	/* Init GLEW */
-	glewExperimental = GL_TRUE;
-	status = glewInit();
-	if(status != GLEW_OK){
-        	RWERROR((ERR_ENGINEOPEN, glewGetErrorString(status)));
-        	SDL_GL_DeleteContext(ctx);
-        	SDL_DestroyWindow(win);
-        	SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        	return 0;
-	}
-	if(!GLEW_VERSION_3_3){
-		RWERROR((ERR_VERSION, "OpenGL 3.3 needed"));
-		SDL_GL_DeleteContext(ctx);
-		SDL_DestroyWindow(win);
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
-		return 0;
-	}
-#else
-	if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) {
-        	RWERROR((ERR_ENGINEOPEN, "gladLoadGLLoader failed"));
-        	SDL_GL_DeleteContext(ctx);
-        	SDL_DestroyWindow(win);
-        	SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        	return 0;
-	}
-	if(!GLAD_GL_VERSION_3_3) {
-		RWERROR((ERR_VERSION, "OpenGL 3.3 needed"));
-		SDL_GL_DeleteContext(ctx);
-		SDL_DestroyWindow(win);
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
-		return 0;
-	}
-#endif
-	glGlobals.window = win;
-	glGlobals.glcontext = ctx;
-	*openparams->window = win;
 	return 1;
 }
 
 static int
 closeSDL2(void)
+{
+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	return 1;
+}
+
+static struct {
+	int gl;
+	int major, minor;
+} profiles[] = {
+	{ SDL_GL_CONTEXT_PROFILE_CORE, 3, 3 },
+	{ SDL_GL_CONTEXT_PROFILE_CORE, 2, 1 },
+	{ SDL_GL_CONTEXT_PROFILE_ES, 3, 1 },
+	{ SDL_GL_CONTEXT_PROFILE_ES, 2, 0 },
+	{ 0, 0, 0 },
+};
+
+static int
+startSDL2(void)
+{
+	SDL_Window *win;
+	SDL_GLContext ctx;
+	DisplayMode *mode;
+
+	mode = &glGlobals.modes[glGlobals.currentMode];
+
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, glGlobals.numSamples);
+
+	int i;
+	for(i = 0; profiles[i].gl; i++){
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profiles[i].gl);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, profiles[i].major);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, profiles[i].minor);
+
+		if(mode->flags & VIDEOMODEEXCLUSIVE) {
+			win = SDL_CreateWindow(glGlobals.winTitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->mode.w, mode->mode.h, SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN);
+			if (win)
+				SDL_SetWindowDisplayMode(win, &mode->mode);
+		} else {
+			win = SDL_CreateWindow(glGlobals.winTitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, glGlobals.winWidth, glGlobals.winHeight, SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
+			if (win)
+				SDL_SetWindowDisplayMode(win, NULL);
+		}
+		if(win){
+			gl3Caps.gles = profiles[i].gl == SDL_GL_CONTEXT_PROFILE_ES;
+			gl3Caps.glversion = profiles[i].major*10 + profiles[i].minor;
+			break;
+		}
+	}
+	if(win == nil){
+		RWERROR((ERR_GENERAL, SDL_GetError()));
+		return 0;
+	}
+	ctx = SDL_GL_CreateContext(win);
+
+	if (!((gl3Caps.gles ? gladLoadGLES2Loader : gladLoadGLLoader) ((GLADloadproc) SDL_GL_GetProcAddress, gl3Caps.glversion)) ) {
+		RWERROR((ERR_GENERAL, "gladLoadGLLoader failed"));
+		SDL_GL_DeleteContext(ctx);
+		SDL_DestroyWindow(win);
+		return 0;
+	}
+
+	printf("OpenGL version: %s\n", glGetString(GL_VERSION));
+
+	glGlobals.window = win;
+	glGlobals.glcontext = ctx;
+	*glGlobals.pWindow = win;
+	glGlobals.presentWidth = 0;
+	glGlobals.presentHeight = 0;
+	glGlobals.presentOffX = 0;
+	glGlobals.presentOffY = 0;
+	return 1;
+}
+
+static int
+stopSDL2(void)
 {
 	SDL_GL_DeleteContext(glGlobals.glcontext);
 	SDL_DestroyWindow(glGlobals.window);
-	SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	return 1;
+}
+#elif defined(PSP2)
+
+static void
+makeVideoModeList(void)
+{
+	rwFree(glGlobals.modes);
+	glGlobals.modes = rwNewT(DisplayMode, 1, ID_DRIVER | MEMDUR_EVENT);
+	glGlobals.modes[0].mode.width = 960;
+	glGlobals.modes[0].mode.height = 544;
+	glGlobals.modes[0].mode.redBits = 8;
+	glGlobals.modes[0].mode.greenBits = 8;
+	glGlobals.modes[0].mode.blueBits = 8;
+	glGlobals.modes[0].mode.refreshRate = 60;
+	glGlobals.modes[0].depth = 32;
+	// Must be exclusive: the game only accepts a fullscreen mode here and bails
+	// out of device selection if it finds none.
+	glGlobals.modes[0].flags = VIDEOMODEEXCLUSIVE;
+	glGlobals.numModes = 1;
+	glGlobals.currentMode = 0;
+}
+
+static int
+openGLFW(EngineOpenParams *openparams)
+{
+	glGlobals.winWidth = openparams->width;
+	glGlobals.winHeight = openparams->height;
+	glGlobals.winTitle = openparams->windowtitle;
+
+	memset(&gl3Caps, 0, sizeof(gl3Caps));
+
+#ifdef PSP2_USE_SHADER_COMPILER
+	vglSetupRuntimeShaderCompiler(SHARK_OPT_UNSAFE, SHARK_ENABLE, SHARK_ENABLE, SHARK_ENABLE);
+#endif
+	vglInitExtended(0, 960, 544, 0x800000, SCE_GXM_MULTISAMPLE_4X);
+
+	makeVideoModeList();
+
+	return 1;
+}
+
+static int
+closeGLFW(void)
+{
+	return 1;
+}
+
+static int
+startGLFW(void)
+{
+	// vitaGL is up already, nothing to create.
+	// It exposes a GLES2-ish feature set, so pick the ES shader dialect.
+	gl3Caps.gles = 1;
+	gl3Caps.glversion = 20;
+	glGlobals.presentWidth = 0;
+	glGlobals.presentHeight = 0;
+	glGlobals.presentOffX = 0;
+	glGlobals.presentOffY = 0;
+	return 1;
+}
+
+static int
+stopGLFW(void)
+{
 	return 1;
 }
 #else
 
 static void
-addVideoMode(/*const GLFWvidmode *mode*/)
+addVideoMode(const GLFWvidmode *mode)
 {
+	int i;
+
+	for(i = 1; i < glGlobals.numModes; i++){
+		if(glGlobals.modes[i].mode.width == mode->width &&
+		   glGlobals.modes[i].mode.height == mode->height &&
+		   glGlobals.modes[i].mode.redBits == mode->redBits &&
+		   glGlobals.modes[i].mode.greenBits == mode->greenBits &&
+		   glGlobals.modes[i].mode.blueBits == mode->blueBits){
+			// had this mode already, remember highest refresh rate
+			if(mode->refreshRate > glGlobals.modes[i].mode.refreshRate)
+				glGlobals.modes[i].mode.refreshRate = mode->refreshRate;
+			return;
+		}
+	}
+
+	// none found, add
+	glGlobals.modes[glGlobals.numModes].mode = *mode;
+	glGlobals.modes[glGlobals.numModes].flags = VIDEOMODEEXCLUSIVE;
+	glGlobals.numModes++;
 }
 
 static void
 makeVideoModeList(void)
-#ifndef PSP2
 {
 	int i, num;
 	const GLFWvidmode *modes;
@@ -1502,11 +1759,6 @@ makeVideoModeList(void)
 		for(glGlobals.modes[i].depth = 1; glGlobals.modes[i].depth < num; glGlobals.modes[i].depth <<= 1);
 	}
 }
-#else
-// stub video modes manually: 544p
-{
-}
-#endif
 
 static int
 openGLFW(EngineOpenParams *openparams)
@@ -1514,30 +1766,18 @@ openGLFW(EngineOpenParams *openparams)
 	glGlobals.winWidth = openparams->width;
 	glGlobals.winHeight = openparams->height;
 	glGlobals.winTitle = openparams->windowtitle;
+	glGlobals.pWindow = openparams->window;
 
-	gVertexBufferIm2DPtr[0] = (float*)malloc(0x500000);
-	gVertexBufferIm2DPtr[1] = (float*)malloc(0x500000);
-	gVertexBufferIm3DPtr[0] = (float*)malloc(0x1800000);
-	gVertexBufferIm3DPtr[1] = (float*)malloc(0x1800000);
-	gIndicesIm2DPtr[0]   = (uint16_t*)malloc(0x600000);
-	gIndicesIm2DPtr[1]   = (uint16_t*)malloc(0x600000);
-	gIndicesIm3DPtr[0]   = (uint16_t*)malloc(0x1800000);
-	gIndicesIm3DPtr[1]   = (uint16_t*)malloc(0x1800000);
+	memset(&gl3Caps, 0, sizeof(gl3Caps));
 
-	gConstIndices = (uint16_t*)malloc(sizeof(uint16_t) * 0xFFFF);
-	
-	gVertexBufferIm2D = gVertexBufferIm2DPtr[0];
-	gVertexBufferIm3D = gVertexBufferIm3DPtr[0];
-	gIndicesIm2D = gIndicesIm2DPtr[0];
-	gIndicesIm3D = gIndicesIm3DPtr[0];
-	
-	for (uint16_t i = 0; i < 0xFFFF; i++) {
-		gConstIndices[i] = i;
+	/* Init GLFW */
+	if(!glfwInit()){
+		RWERROR((ERR_GENERAL, "glfwInit() failed"));
+		return 0;
 	}
-#ifdef PSP2_USE_SHADER_COMPILER
-	vglSetupRuntimeShaderCompiler(SHARK_OPT_UNSAFE, SHARK_ENABLE, SHARK_ENABLE, SHARK_ENABLE);
-#endif
-	vglInitExtended(0, 960, 544, 0x800000, SCE_GXM_MULTISAMPLE_4X);
+
+	glGlobals.monitor = glfwGetMonitors(&glGlobals.numMonitors)[0];
+
 	makeVideoModeList();
 
 	return 1;
@@ -1546,6 +1786,7 @@ openGLFW(EngineOpenParams *openparams)
 static int
 closeGLFW(void)
 {
+	glfwTerminate();
 	return 1;
 }
 
@@ -1555,26 +1796,80 @@ glfwerr(int error, const char *desc)
 	fprintf(stderr, "GLFW Error: %s\n", desc);
 }
 
+static struct {
+	int gl;
+	int major, minor;
+} profiles[] = {
+	{ GLFW_OPENGL_API, 3, 3 },
+	{ GLFW_OPENGL_API, 2, 1 },
+	{ GLFW_OPENGL_ES_API, 3, 1 },
+	{ GLFW_OPENGL_ES_API, 2, 0 },
+	{ 0, 0, 0 },
+};
+
 static int
 startGLFW(void)
 {
-	GLenum status;
+	GLFWwindow *win;
+	DisplayMode *mode;
 
-	printf("version %s\n", glGetString(GL_VERSION));
+	mode = &glGlobals.modes[glGlobals.currentMode];
 
-	printf("GL_VENDOR: %s\n", glGetString(GL_VENDOR));
-	printf("GL_RENDERER: %s\n", glGetString(GL_RENDERER));
-	printf("GL_VERSION: %s\n", glGetString(GL_VERSION));
-	printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));
+	glfwSetErrorCallback(glfwerr);
+	glfwWindowHint(GLFW_RED_BITS, mode->mode.redBits);
+	glfwWindowHint(GLFW_GREEN_BITS, mode->mode.greenBits);
+	glfwWindowHint(GLFW_BLUE_BITS, mode->mode.blueBits);
+	glfwWindowHint(GLFW_REFRESH_RATE, mode->mode.refreshRate);
+	
+	// GLX will round up to 2x or 4x if you ask for multisampling on with 1 sample
+	// So only apply the SAMPLES hint if we actually want multisampling
+	if (glGlobals.numSamples > 1)
+		glfwWindowHint(GLFW_SAMPLES, glGlobals.numSamples);
 
+	int i;
+	for(i = 0; profiles[i].gl; i++){
+		glfwWindowHint(GLFW_CLIENT_API, profiles[i].gl);
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, profiles[i].major);
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, profiles[i].minor);
+
+		if(mode->flags & VIDEOMODEEXCLUSIVE)
+			win = glfwCreateWindow(mode->mode.width, mode->mode.height, glGlobals.winTitle, glGlobals.monitor, nil);
+		else
+			win = glfwCreateWindow(glGlobals.winWidth, glGlobals.winHeight, glGlobals.winTitle, nil, nil);
+		if(win){
+			gl3Caps.gles = profiles[i].gl == GLFW_OPENGL_ES_API;
+			gl3Caps.glversion = profiles[i].major*10 + profiles[i].minor;
+			break;
+		}
+	}
+	if(win == nil){
+		RWERROR((ERR_GENERAL, "glfwCreateWindow() failed"));
+		return 0;
+	}
+	glfwMakeContextCurrent(win);
+
+	/* Init GLAD */
+	if (!((gl3Caps.gles ? gladLoadGLES2Loader : gladLoadGLLoader) ((GLADloadproc) glfwGetProcAddress, gl3Caps.glversion)) ) {
+		RWERROR((ERR_GENERAL, "gladLoadGLLoader failed"));
+		glfwDestroyWindow(win);
+		return 0;
+	}
+
+	printf("OpenGL version: %s\n", glGetString(GL_VERSION));
+
+	glGlobals.window = win;
+	*glGlobals.pWindow = win;
 	glGlobals.presentWidth = 0;
 	glGlobals.presentHeight = 0;
+	glGlobals.presentOffX = 0;
+	glGlobals.presentOffY = 0;
 	return 1;
 }
 
 static int
 stopGLFW(void)
 {
+	glfwDestroyWindow(glGlobals.window);
 	return 1;
 }
 #endif
@@ -1582,34 +1877,78 @@ stopGLFW(void)
 static int
 initOpenGL(void)
 {
+/*
+	// this only works from 3.0 onward,
+	// but luckily GLAD has already taken care of extensions for us
+	int numExt;
+	glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
+	for(int i = 0; i < numExt; i++){
+		const char *ext = (const char*)glGetStringi(GL_EXTENSIONS, i);
+		if(ext == nil)
+			continue;	// apparently that can happen...
+		if(strcmp(ext, "GL_EXT_texture_compression_s3tc") == 0)
+			gl3Caps.dxtSupported = true;
+		else if(strcmp(ext, "GL_KHR_texture_compression_astc_ldr") == 0)
+			gl3Caps.astcSupported = true;
+//		printf("%d %s\n", i, ext);
+	}
+*/
+#ifdef PSP2
+	// False on purpose: glCompressedTexImage2D corrupts vitaGL's heap, so librw must
+	// not hand it pre-compressed data. Textures are decompressed by the Image path,
+	// then given a DXT internalFormat (see rasterCreateTexture) so vitaGL compresses
+	// them into VRAM itself; the conversion pass reads that compressed form back out
+	// through vglGetTexDataPointer and stores it in txd.img, so at run time textures
+	// are just memcpy'd into texture memory - no decompress, no compress, no stalls.
+	gl3Caps.dxtSupported = false;
+	gl3Caps.astcSupported = false;
+	gl3Caps.maxAnisotropy = 1.0f;
+#else
+	gl3Caps.dxtSupported = !!GLAD_GL_EXT_texture_compression_s3tc;
+	gl3Caps.astcSupported = !!GLAD_GL_KHR_texture_compression_astc_ldr;
+
+	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl3Caps.maxAnisotropy);
+#endif
+
+	if(gl3Caps.gles){
+		if(gl3Caps.glversion >= 30)
+			shaderDecl = shaderDecl310es;
+		else
+			shaderDecl = shaderDecl100es;
+	}else{
+		if(gl3Caps.glversion >= 30)
+			shaderDecl = shaderDecl330;
+		else
+			shaderDecl = shaderDecl120;
+	}
+
 #ifndef RW_GL_USE_UBOS
-	u_alphaRef = registerUniform("u_alphaRef");
-	u_fogData = registerUniform("u_fogData");
-//	u_fogStart = registerUniform("u_fogStart");
-//	u_fogEnd = registerUniform("u_fogEnd");
-//	u_fogRange = registerUniform("u_fogRange");
-//	u_fogDisable = registerUniform("u_fogDisable");
-	u_fogColor = registerUniform("u_fogColor");
-	u_wvp = registerUniform("u_wvp");
-	u_world = registerUniform("u_world");
-	u_ambLight = registerUniform("u_ambLight");
-	u_lightParams = registerUniform("u_lightParams");
-	u_lightPosition = registerUniform("u_lightPosition");
-	u_lightDirection = registerUniform("u_lightDirection");
-	u_lightColor = registerUniform("u_lightColor");
+	u_alphaRef = registerUniform("u_alphaRef", UNIFORM_VEC4);
+	u_fogData = registerUniform("u_fogData", UNIFORM_VEC4);
+	u_fogColor = registerUniform("u_fogColor", UNIFORM_VEC4);
+	u_proj = registerUniform("u_proj", UNIFORM_MAT4);
+	u_view = registerUniform("u_view", UNIFORM_MAT4);
+	u_world = registerUniform("u_world", UNIFORM_MAT4);
+	u_ambLight = registerUniform("u_ambLight", UNIFORM_VEC4);
+	u_lightParams = registerUniform("u_lightParams", UNIFORM_VEC4, MAX_LIGHTS);
+	u_lightPosition = registerUniform("u_lightPosition", UNIFORM_VEC4, MAX_LIGHTS);
+	u_lightDirection = registerUniform("u_lightDirection", UNIFORM_VEC4, MAX_LIGHTS);
+	u_lightColor = registerUniform("u_lightColor", UNIFORM_VEC4, MAX_LIGHTS);
 	lastShaderUploaded = nil;
 #else
 	registerBlock("Scene");
 	registerBlock("Object");
 	registerBlock("State");
 #endif
-	u_matColor = registerUniform("u_matColor");
-	u_surfProps = registerUniform("u_surfProps");
+	u_matColor = registerUniform("u_matColor", UNIFORM_VEC4);
+	u_surfProps = registerUniform("u_surfProps", UNIFORM_VEC4);
 
-	//glClearColor(0.25, 0.25, 0.25, 1.0);
+	// for im2d
+	registerUniform("u_xform", UNIFORM_VEC4);
+
+	glClearColor(0.25, 0.25, 0.25, 1.0);
 
 	byte whitepixel[4] = {0xFF, 0xFF, 0xFF, 0xFF};
-
 	glGenTextures(1, &whitetex);
 	glBindTexture(GL_TEXTURE_2D, whitetex);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -1620,23 +1959,53 @@ initOpenGL(void)
 	             0, GL_RGBA, GL_UNSIGNED_BYTE, &whitepixel);
 
 	resetRenderState();
-#ifdef PSP2_USE_SHADER_COMPILER	
-#ifdef RW_GLES2
-#include "gl2_shaders/default_vs_gl2.inc"
-#include "gl2_shaders/simple_fs_gl2.inc"
-#else
-#include "shaders/default_vs_gl3.inc"
-#include "shaders/simple_fs_gl3.inc"
-#endif
-	const char *vs[] = { header_vert_src, default_vert_src, nil };
-	const char *fs[] = { header_frag_src, simple_frag_src, nil };
-	defaultShader = Shader::create(vs, fs, false);
-#else
-	const char *vs[] = { (const char*)default_v, (const char*)&size_default_v, nil };
-	const char *fs[] = { (const char*)simple_f, (const char*)&size_simple_f, nil };
-	defaultShader = Shader::create(vs, fs, false);
+
+	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
+
+	if(gl3Caps.glversion >= 30){
+		glGenVertexArrays(1, &vao);
+		glBindVertexArray(vao);
+	}
+
+#ifdef RW_GL_USE_UBOS
+	glGenBuffers(1, &ubo_state);
+	glBindBuffer(GL_UNIFORM_BUFFER, ubo_state);
+	glBindBufferBase(GL_UNIFORM_BUFFER, gl3::findBlock("State"), ubo_state);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformState), &uniformState,
+	             GL_STREAM_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	glGenBuffers(1, &ubo_scene);
+	glBindBuffer(GL_UNIFORM_BUFFER, ubo_scene);
+	glBindBufferBase(GL_UNIFORM_BUFFER, gl3::findBlock("Scene"), ubo_scene);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformScene), &uniformScene,
+	             GL_STREAM_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	glGenBuffers(1, &ubo_object);
+	glBindBuffer(GL_UNIFORM_BUFFER, ubo_object);
+	glBindBufferBase(GL_UNIFORM_BUFFER, gl3::findBlock("Object"), ubo_object);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformObject), &uniformObject,
+	             GL_STREAM_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
 #endif
+
+#include "shaders/default_vs_gl.inc"
+#include "shaders/simple_fs_gl.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, default_vert_src, nil };
+	const char *vs_fullLight[] = { shaderDecl, "#define DIRECTIONALS\n#define POINTLIGHTS\n#define SPOTLIGHTS\n", header_vert_src, default_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, simple_frag_src, nil };
+	const char *fs_noAT[] = { shaderDecl, "#define NO_ALPHATEST\n", header_frag_src, simple_frag_src, nil };
+
+	defaultShader = Shader::create(vs, fs);
 	assert(defaultShader);
+	defaultShader_noAT = Shader::create(vs, fs_noAT);
+	assert(defaultShader_noAT);
+
+	defaultShader_fullLight = Shader::create(vs_fullLight, fs);
+	assert(defaultShader_fullLight);
+	defaultShader_fullLight_noAT = Shader::create(vs_fullLight, fs_noAT);
+	assert(defaultShader_fullLight_noAT);
 
 	openIm2D();
 	openIm3D();
@@ -1649,6 +2018,19 @@ termOpenGL(void)
 {
 	closeIm3D();
 	closeIm2D();
+
+	defaultShader->destroy();
+	defaultShader = nil;
+	defaultShader_noAT->destroy();
+	defaultShader_noAT = nil;
+	defaultShader_fullLight->destroy();
+	defaultShader_fullLight = nil;
+	defaultShader_fullLight_noAT->destroy();
+	defaultShader_fullLight_noAT = nil;
+
+	glDeleteTextures(1, &whitetex);
+	whitetex = 0;
+
 	return 1;
 }
 
@@ -1662,6 +2044,8 @@ finalizeOpenGL(void)
 static int
 deviceSystemSDL2(DeviceReq req, void *arg, int32 n)
 {
+	VideoMode *rwmode;
+
 	switch(req){
 	case DEVICEOPEN:
 		return openSDL2((EngineOpenParams*)arg);
@@ -1669,12 +2053,50 @@ deviceSystemSDL2(DeviceReq req, void *arg, int32 n)
 		return closeSDL2();
 
 	case DEVICEINIT:
-		return initOpenGL();
+		return startSDL2() && initOpenGL();
 	case DEVICETERM:
-		return termOpenGL();
+		return termOpenGL() && stopSDL2();
 
-	// TODO: implement subsystems and video modes
+	case DEVICEFINALIZE:
+		return finalizeOpenGL();
 
+	// TODO: implement subsystems
+
+	case DEVICEGETNUMVIDEOMODES:
+		return glGlobals.numModes;
+
+	case DEVICEGETCURRENTVIDEOMODE:
+		return glGlobals.currentMode;
+
+	case DEVICESETVIDEOMODE:
+		if(n >= glGlobals.numModes)
+			return 0;
+		glGlobals.currentMode = n;
+		return 1;
+
+	case DEVICEGETVIDEOMODEINFO:
+		rwmode = (VideoMode*)arg;
+		rwmode->width = glGlobals.modes[n].mode.w;
+		rwmode->height = glGlobals.modes[n].mode.h;
+		rwmode->depth = glGlobals.modes[n].depth;
+		rwmode->flags = glGlobals.modes[n].flags;
+		return 1;
+
+	case DEVICEGETMAXMULTISAMPLINGLEVELS:
+		{
+			GLint maxSamples;
+			glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
+			if(maxSamples == 0)
+				return 1;
+			return maxSamples;
+		}
+	case DEVICEGETMULTISAMPLINGLEVELS:
+		if(glGlobals.numSamples == 0)
+			return 1;
+		return glGlobals.numSamples;
+	case DEVICESETMULTISAMPLINGLEVELS:
+		glGlobals.numSamples = (uint32)n;
+		return 1;
 	default:
 		assert(0 && "not implemented");
 		return 0;
@@ -1687,6 +2109,9 @@ deviceSystemSDL2(DeviceReq req, void *arg, int32 n)
 static int
 deviceSystemGLFW(DeviceReq req, void *arg, int32 n)
 {
+#ifndef PSP2
+	GLFWmonitor **monitors;
+#endif
 	VideoMode *rwmode;
 
 	switch(req){
@@ -1704,6 +2129,8 @@ deviceSystemGLFW(DeviceReq req, void *arg, int32 n)
 		return finalizeOpenGL();
 
 
+#ifdef PSP2
+	// only one "monitor" on Vita
 	case DEVICEGETNUMSUBSYSTEMS:
 		return 1;
 
@@ -1711,30 +2138,75 @@ deviceSystemGLFW(DeviceReq req, void *arg, int32 n)
 		return 0;
 
 	case DEVICESETSUBSYSTEM:
+		return n == 0;
+
+	case DEVICEGETSUBSSYSTEMINFO:
+		strncpy(((SubSystemInfo*)arg)->name, "PS Vita", sizeof(SubSystemInfo::name));
+		return 1;
+#else
+	case DEVICEGETNUMSUBSYSTEMS:
+		return glGlobals.numMonitors;
+
+	case DEVICEGETCURRENTSUBSYSTEM:
+		return glGlobals.currentMonitor;
+
+	case DEVICESETSUBSYSTEM:
+		monitors = glfwGetMonitors(&glGlobals.numMonitors);
+		if(n >= glGlobals.numMonitors)
+			return 0;
+		glGlobals.currentMonitor = n;
+		glGlobals.monitor = monitors[glGlobals.currentMonitor];
 		return 1;
 
 	case DEVICEGETSUBSSYSTEMINFO:
-		strncpy(((SubSystemInfo*)arg)->name, "PSVita Screen Stub", sizeof(SubSystemInfo::name));
+		monitors = glfwGetMonitors(&glGlobals.numMonitors);
+		if(n >= glGlobals.numMonitors)
+			return 0;
+		strncpy(((SubSystemInfo*)arg)->name, glfwGetMonitorName(monitors[n]), sizeof(SubSystemInfo::name));
 		return 1;
+#endif
 
 
 	case DEVICEGETNUMVIDEOMODES:
-		return 1;
+		return glGlobals.numModes;
 
 	case DEVICEGETCURRENTVIDEOMODE:
-		return 0;
+		return glGlobals.currentMode;
 
 	case DEVICESETVIDEOMODE:
+		if(n >= glGlobals.numModes)
+			return 0;
+		glGlobals.currentMode = n;
 		return 1;
 
 	case DEVICEGETVIDEOMODEINFO:
 		rwmode = (VideoMode*)arg;
-		rwmode->width = 960;
-		rwmode->height = 544;
-		rwmode->depth = 32;
-		rwmode->flags = VIDEOMODEEXCLUSIVE;
+		rwmode->width = glGlobals.modes[n].mode.width;
+		rwmode->height = glGlobals.modes[n].mode.height;
+		rwmode->depth = glGlobals.modes[n].depth;
+		rwmode->flags = glGlobals.modes[n].flags;
 		return 1;
 
+	case DEVICEGETMAXMULTISAMPLINGLEVELS:
+		{
+#ifdef PSP2
+			// MSAA is fixed at vglInitExtended() time, can't be changed
+			return 1;
+#else
+			GLint maxSamples;
+			glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
+			if(maxSamples == 0)
+				return 1;
+			return maxSamples;
+#endif
+		}
+	case DEVICEGETMULTISAMPLINGLEVELS:
+		if(glGlobals.numSamples == 0)
+			return 1;
+		return glGlobals.numSamples;
+	case DEVICESETMULTISAMPLINGLEVELS:
+		glGlobals.numSamples = (uint32)n;
+		return 1;
 	default:
 		assert(0 && "not implemented");
 		return 0;
@@ -1771,5 +2243,13 @@ Device renderdevice = {
 }
 }
 
+#else
+// urgh, probably should get rid of that eventually
+#include "rwgl3.h"
+namespace rw {
+namespace gl3 { 
+Gl3Caps gl3Caps;
+bool32 needToReadBackTextures;
+}
+}
 #endif
-
diff --git a/src/gl/gl3immed.cpp b/src/gl/gl3immed.cpp
index 0fb404f..16967dc 100644
--- a/src/gl/gl3immed.cpp
+++ b/src/gl/gl3immed.cpp
@@ -15,17 +15,14 @@
 #include "rwgl3impl.h"
 #include "rwgl3shader.h"
 
-#include "psp2_shaders.h"
-
-extern float *gVertexBufferIm2D;
-extern uint16_t *gIndicesIm2D;
-extern float *gVertexBufferIm3D;
-extern uint16_t *gIndicesIm3D;
-extern uint16_t *gConstIndices;
-
 namespace rw {
 namespace gl3 {
 
+uint32 im2DVbo, im2DIbo;
+#ifdef RW_GL_USE_VAOS
+uint32 im2DVao;
+#endif
+
 Shader *im2dOverrideShader;
 
 static int32 u_xform;
@@ -46,7 +43,7 @@ static AttribDesc im2dattribDesc[3] = {
 static int primTypeMap[] = {
 	GL_POINTS,	// invalid
 	GL_LINES,
-	GL_LINES,//_STRIP,
+	GL_LINE_STRIP,
 	GL_TRIANGLES,
 	GL_TRIANGLE_STRIP,
 	GL_TRIANGLE_FAN,
@@ -56,29 +53,39 @@ static int primTypeMap[] = {
 void
 openIm2D(void)
 {
-	u_xform = registerUniform("u_xform");
-#ifdef PSP2_USE_SHADER_COMPILER
-#ifdef RW_GLES2
-#include "gl2_shaders/im2d_gl2.inc"
-#include "gl2_shaders/simple_fs_gl2.inc"
-#else
-#include "shaders/im2d_gl3.inc"
-#include "shaders/simple_fs_gl3.inc"
-#endif
-	const char *vs[] = { header_vert_src, im2d_vert_src, nil };
-	const char *fs[] = { header_frag_src, simple_frag_src, nil };
-	im2dShader = Shader::create(vs, fs, true);
-#else
-	const char *vs[] = { (const char*)im2d_v, (const char*)&size_im2d_v, nil };
-	const char *fs[] = { (const char*)simple_f, (const char*)&size_simple_f, nil };
-	im2dShader = Shader::create(vs, fs, true);
-#endif
+	// must already be registered by device. we just need the value
+	u_xform = registerUniform("u_xform", UNIFORM_VEC4);
+
+#include "shaders/im2d_gl.inc"
+#include "shaders/simple_fs_gl.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, im2d_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, simple_frag_src, nil };
+	im2dShader = Shader::create(vs, fs);
 	assert(im2dShader);
+
+	glGenBuffers(1, &im2DIbo);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, im2DIbo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, STARTINDICES*2, nil, GL_STREAM_DRAW);
+
+	glGenBuffers(1, &im2DVbo);
+	glBindBuffer(GL_ARRAY_BUFFER, im2DVbo);
+	glBufferData(GL_ARRAY_BUFFER, STARTVERTICES*sizeof(Im2DVertex), nil, GL_STREAM_DRAW);
+
+#ifdef RW_GL_USE_VAOS
+	glGenVertexArrays(1, &im2DVao);
+	glBindVertexArray(im2DVao);
+	setAttribPointers(im2dattribDesc, 3);
+#endif
 }
 
 void
 closeIm2D(void)
 {
+	glDeleteBuffers(1, &im2DIbo);
+	glDeleteBuffers(1, &im2DVbo);
+#ifdef RW_GL_USE_VAOS
+	glDeleteVertexArrays(1, &im2DVao);
+#endif
 	im2dShader->destroy();
 	im2dShader = nil;
 }
@@ -105,32 +112,58 @@ im2DRenderTriangle(void *vertices, int32 numVertices, int32 vert1, int32 vert2,
 }
 
 void
-im2DRenderPrimitive(PrimitiveType primType, void *vertices, int32 numVertices)
+im2DSetXform(void)
 {
 	GLfloat xform[4];
 	Camera *cam;
 	cam = (Camera*)engine->currentCamera;
-	
 	xform[0] = 2.0f/cam->frameBuffer->width;
 	xform[1] = -2.0f/cam->frameBuffer->height;
 	xform[2] = -1.0f;
 	xform[3] = 1.0f;
+	setUniform(u_xform, xform);
+//	glUniform4fv(currentShader->uniformLocations[u_xform], 1, xform);
+}
+
+void
+im2DRenderPrimitive(PrimitiveType primType, void *vertices, int32 numVertices)
+{
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(im2DVao);
+#endif
+
+	glBindBuffer(GL_ARRAY_BUFFER, im2DVbo);
+#if defined(__SWITCH__) || defined(PSP2)
+	// Orphan with exactly the size we need, in one call that also uploads.
+	// The stock path orphans the whole STARTVERTICES buffer (~240KB) on every
+	// single 2D draw - even a 4-vertex sprite - and hundreds of those per frame
+	// exhaust nouveau's buffer allocator. It then hands back a buffer with no
+	// backing store and glBufferSubData memcpy's into null (Data Abort at 0).
+	// vitaGL behaves the same way: those orphans come out of its memory pools,
+	// which both costs most of the frame time and churns the allocator.
+	// Orphaning itself must stay: without it the GPU may still be reading the
+	// buffer we overwrite, which mixes geometry between draws.
+	glBufferData(GL_ARRAY_BUFFER, numVertices*sizeof(Im2DVertex), vertices, GL_STREAM_DRAW);
+#else
+	glBufferData(GL_ARRAY_BUFFER, STARTVERTICES*sizeof(Im2DVertex), nil, GL_STREAM_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices*sizeof(Im2DVertex), vertices);
+#endif
 
 	if(im2dOverrideShader)
 		im2dOverrideShader->use();
 	else
 		im2dShader->use();
+#ifndef RW_GL_USE_VAOS
+	setAttribPointers(im2dattribDesc, 3);
+#endif
+
+	im2DSetXform();
 
 	flushCache();
-	glUniform4fv(currentShader->uniformLocations[u_xform], 1, xform);
-	
-	memcpy_neon(gVertexBufferIm2D, vertices, numVertices*sizeof(Im2DVertex));
-	vglVertexAttribPointerMapped(0, gVertexBufferIm2D);
-	vglIndexPointerMapped(gConstIndices);
-	gVertexBufferIm2D += numVertices*(sizeof(Im2DVertex)/sizeof(float));
-	
-	vglDrawObjects(primTypeMap[primType], numVertices);
-	
+	glDrawArrays(primTypeMap[primType], 0, numVertices);
+#ifndef RW_GL_USE_VAOS
+	disableAttribPointers(im2dattribDesc, 3);
+#endif
 }
 
 void
@@ -138,32 +171,42 @@ im2DRenderIndexedPrimitive(PrimitiveType primType,
 	void *vertices, int32 numVertices,
 	void *indices, int32 numIndices)
 {
-	GLfloat xform[4];
-	Camera *cam;
-	cam = (Camera*)engine->currentCamera;
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(im2DVao);
+#endif
 
-	xform[0] = 2.0f/cam->frameBuffer->width;
-	xform[1] = -2.0f/cam->frameBuffer->height;
-	xform[2] = -1.0f;
-	xform[3] = 1.0f;
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, im2DIbo);
+#if defined(__SWITCH__) || defined(PSP2)
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices*2, indices, GL_STREAM_DRAW);
+#else
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, STARTINDICES*2, nil, GL_STREAM_DRAW);
+	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, numIndices*2, indices);
+#endif
+
+	glBindBuffer(GL_ARRAY_BUFFER, im2DVbo);
+#if defined(__SWITCH__) || defined(PSP2)
+	glBufferData(GL_ARRAY_BUFFER, numVertices*sizeof(Im2DVertex), vertices, GL_STREAM_DRAW);
+#else
+	glBufferData(GL_ARRAY_BUFFER, STARTVERTICES*sizeof(Im2DVertex), nil, GL_STREAM_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices*sizeof(Im2DVertex), vertices);
+#endif
 
 	if(im2dOverrideShader)
 		im2dOverrideShader->use();
 	else
 		im2dShader->use();
+#ifndef RW_GL_USE_VAOS
+	setAttribPointers(im2dattribDesc, 3);
+#endif
+
+	im2DSetXform();
 
 	flushCache();
-	glUniform4fv(currentShader->uniformLocations[u_xform], 1, xform);
-	
-	memcpy_neon(gIndicesIm2D, indices, numIndices * 2);
-	vglIndexPointerMapped(gIndicesIm2D);
-	gIndicesIm2D += numIndices;
-	
-	memcpy_neon(gVertexBufferIm2D, vertices, numVertices*sizeof(Im2DVertex));
-	vglVertexAttribPointerMapped(0, gVertexBufferIm2D);
-	gVertexBufferIm2D += numVertices*(sizeof(Im2DVertex)/sizeof(float));
-		
-	vglDrawObjects(primTypeMap[primType], numIndices);
+	glDrawElements(primTypeMap[primType], numIndices,
+	               GL_UNSIGNED_SHORT, nil);
+#ifndef RW_GL_USE_VAOS
+	disableAttribPointers(im2dattribDesc, 3);
+#endif
 }
 
 
@@ -188,28 +231,36 @@ static int32 num3DVertices;	// not actually needed here
 void
 openIm3D(void)
 {
-#ifdef PSP2_USE_SHADER_COMPILER
-#ifdef RW_GLES2
-#include "gl2_shaders/im3d_gl2.inc"
-#include "gl2_shaders/simple_fs_gl2.inc"
-#else
-#include "shaders/im3d_gl3.inc"
-#include "shaders/simple_fs_gl3.inc"
-#endif
-	const char *vs[] = { header_vert_src, im3d_vert_src, nil };
-	const char *fs[] = { header_frag_src, simple_frag_src, nil };
-	im3dShader = Shader::create(vs, fs, false);
-#else
-	const char *vs[] = { (const char*)im3d_v, (const char*)&size_im3d_v, nil };
-	const char *fs[] = { (const char*)simple_f, (const char*)&size_simple_f, nil };
-	im3dShader = Shader::create(vs, fs, false);
-#endif
+#include "shaders/im3d_gl.inc"
+#include "shaders/simple_fs_gl.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, im3d_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, simple_frag_src, nil };
+	im3dShader = Shader::create(vs, fs);
 	assert(im3dShader);
+
+	glGenBuffers(1, &im3DIbo);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, im3DIbo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, STARTINDICES*2, nil, GL_STREAM_DRAW);
+
+	glGenBuffers(1, &im3DVbo);
+	glBindBuffer(GL_ARRAY_BUFFER, im3DVbo);
+	glBufferData(GL_ARRAY_BUFFER, STARTVERTICES*sizeof(Im3DVertex), nil, GL_STREAM_DRAW);
+
+#ifdef RW_GL_USE_VAOS
+	glGenVertexArrays(1, &im3DVao);
+	glBindVertexArray(im3DVao);
+	setAttribPointers(im3dattribDesc, 3);
+#endif
 }
 
 void
 closeIm3D(void)
 {
+	glDeleteBuffers(1, &im3DIbo);
+	glDeleteBuffers(1, &im3DVbo);
+#ifdef RW_GL_USE_VAOS
+	glDeleteVertexArrays(1, &im3DVao);
+#endif
 	im3dShader->destroy();
 	im3dShader = nil;
 }
@@ -228,10 +279,19 @@ im3DTransform(void *vertices, int32 numVertices, Matrix *world, uint32 flags)
 	if((flags & im3d::VERTEXUV) == 0)
 		SetRenderStatePtr(TEXTURERASTER, nil);
 
-	memcpy_neon(gVertexBufferIm3D, vertices, numVertices*sizeof(Im3DVertex));
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(im2DVao);
+#endif
 
+	glBindBuffer(GL_ARRAY_BUFFER, im3DVbo);
+#if defined(__SWITCH__) || defined(PSP2)
+	glBufferData(GL_ARRAY_BUFFER, numVertices*sizeof(Im3DVertex), vertices, GL_STREAM_DRAW);
+#else
+	glBufferData(GL_ARRAY_BUFFER, STARTVERTICES*sizeof(Im3DVertex), nil, GL_STREAM_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices*sizeof(Im3DVertex), vertices);
+#endif
 #ifndef RW_GL_USE_VAOS
-	//setAttribPointers(im3dattribDesc, 3);
+	setAttribPointers(im3dattribDesc, 3);
 #endif
 	num3DVertices = numVertices;
 }
@@ -239,23 +299,26 @@ im3DTransform(void *vertices, int32 numVertices, Matrix *world, uint32 flags)
 void
 im3DRenderPrimitive(PrimitiveType primType)
 {
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, im3DIbo);
+
 	flushCache();
-	vglIndexPointerMapped(gConstIndices);
-	vglVertexAttribPointerMapped(0, gVertexBufferIm3D);
-	gVertexBufferIm3D += num3DVertices*(sizeof(Im3DVertex)/sizeof(float));
-	vglDrawObjects(primTypeMap[primType], num3DVertices);
+	glDrawArrays(primTypeMap[primType], 0, num3DVertices);
 }
 
 void
 im3DRenderIndexedPrimitive(PrimitiveType primType, void *indices, int32 numIndices)
 {
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, im3DIbo);
+#if defined(__SWITCH__) || defined(PSP2)
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices*2, indices, GL_STREAM_DRAW);
+#else
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, STARTINDICES*2, nil, GL_STREAM_DRAW);
+	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, numIndices*2, indices);
+#endif
+
 	flushCache();
-	memcpy_neon(gIndicesIm3D, indices, numIndices * 2);
-	vglIndexPointerMapped(gIndicesIm3D);
-	vglVertexAttribPointerMapped(0, gVertexBufferIm3D);
-	gVertexBufferIm3D += num3DVertices*(sizeof(Im3DVertex)/sizeof(float));
-	gIndicesIm3D += numIndices;
-	vglDrawObjects(primTypeMap[primType], numIndices);
+	glDrawElements(primTypeMap[primType], numIndices,
+	               GL_UNSIGNED_SHORT, nil);
 }
 
 void
diff --git a/src/gl/gl3matfx.cpp b/src/gl/gl3matfx.cpp
index bd47dcf..06b01c1 100644
--- a/src/gl/gl3matfx.cpp
+++ b/src/gl/gl3matfx.cpp
@@ -12,40 +12,48 @@
 #include "../rwobjects.h"
 #include "../rwanim.h"
 #include "../rwplugins.h"
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
 #include "rwgl3plg.h"
 
 #include "rwgl3impl.h"
 
-#include "psp2_shaders.h"
-
 namespace rw {
 namespace gl3 {
 
 #ifdef RW_OPENGL
 
-#define U(i) currentShader->uniformLocations[i]
-
-static Shader *envShader;
+static Shader *envShader, *envShader_noAT;
+static Shader *envShader_fullLight, *envShader_fullLight_noAT;
 static int32 u_texMatrix;
 static int32 u_fxparams;
 static int32 u_colorClamp;
+static int32 u_envColor;
 
 void
-matfxDefaultRender(InstanceDataHeader *header, InstanceData *inst)
+matfxDefaultRender(InstanceDataHeader *header, InstanceData *inst, int32 vsBits, uint32 flags)
 {
-	Material *m = inst->material;
+	Material *m;
+	m = inst->material;
+
+	setMaterial(flags, m->color, m->surfaceProps);
 
-	defaultShader->use();
-	
-	rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
-	
 	setTexture(0, m->texture);
-	
-	setMaterial(m->color, m->surfaceProps);
-	
-	flushCache();
+
+	rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
+
+	if((vsBits & VSLIGHT_MASK) == 0){
+		if(getAlphaTest())
+			defaultShader->use();
+		else
+			defaultShader_noAT->use();
+	}else{
+		if(getAlphaTest())
+			defaultShader_fullLight->use();
+		else
+			defaultShader_fullLight_noAT->use();
+	}
 
 	drawInst(header, inst);
 }
@@ -68,55 +76,73 @@ uploadEnvMatrix(Frame *frame)
 
 	// cache the matrix across multiple meshes
 	static RawMatrix envMtx;
-	if(frame != lastEnvFrame){
-		lastEnvFrame = frame;
+// can't do it, frame matrix may change
+//	if(frame != lastEnvFrame){
+//		lastEnvFrame = frame;
+	{
 
 		RawMatrix invMtx;
 		Matrix::invert(&invMat, frame->getLTM());
 		convMatrix(&invMtx, &invMat);
 		invMtx.pos.set(0.0f, 0.0f, 0.0f);
+		float uscale = fabs(normal2texcoord.right.x);
+		normal2texcoord.right.x = MatFX::envMapFlipU ? -uscale : uscale;
 		RawMatrix::mult(&envMtx, &invMtx, &normal2texcoord);
 	}
-	glUniformMatrix4fv(U(u_texMatrix), 1, GL_FALSE, (float*)&envMtx);
+	setUniform(u_texMatrix, &envMtx);
 }
 
 void
-matfxEnvRender(InstanceDataHeader *header, InstanceData *inst, MatFX::Env *env)
+matfxEnvRender(InstanceDataHeader *header, InstanceData *inst, int32 vsBits, uint32 flags, MatFX::Env *env)
 {
 	Material *m;
 	m = inst->material;
 
 	if(env->tex == nil || env->coefficient == 0.0f){
-		matfxDefaultRender(header, inst);
+		matfxDefaultRender(header, inst, vsBits, flags);
 		return;
 	}
 
-	envShader->use();
-	
-	rw::SetRenderState(VERTEXALPHA, 1);
-	rw::SetRenderState(SRCBLEND, BLENDONE);
-	
 	setTexture(0, m->texture);
 	setTexture(1, env->tex);
-	
-	setMaterial(m->color, m->surfaceProps);
-	
-	flushCache();
-
 	uploadEnvMatrix(env->frame);
 
-	float fxparams[2];
+	setMaterial(flags, m->color, m->surfaceProps);
+
+	float fxparams[4];
 	fxparams[0] = env->coefficient;
 	fxparams[1] = env->fbAlpha ? 0.0f : 1.0f;
+	fxparams[2] = fxparams[3] = 0.0f;
 
-	glUniform2fv(U(u_fxparams), 1, fxparams);
+	setUniform(u_fxparams, fxparams);
 	static float zero[4];
 	static float one[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
 	// This clamps the vertex color below. With it we can achieve both PC and PS2 style matfx
-	if(MatFX::modulateEnvMap)
-		glUniform4fv(U(u_colorClamp), 1, zero);
+	if(MatFX::envMapApplyLight)
+		setUniform(u_colorClamp, zero);
 	else
-		glUniform4fv(U(u_colorClamp), 1, one);
+		setUniform(u_colorClamp, one);
+	RGBAf envcol[4];
+	if(MatFX::envMapUseMatColor)
+		convColor(envcol, &m->color);
+	else
+		convColor(envcol, &MatFX::envMapColor);
+	setUniform(u_envColor, envcol);
+
+	rw::SetRenderState(VERTEXALPHA, 1);
+	rw::SetRenderState(SRCBLEND, BLENDONE);
+
+	if((vsBits & VSLIGHT_MASK) == 0){
+		if(getAlphaTest())
+			envShader->use();
+		else
+			envShader_noAT->use();
+	}else{
+		if(getAlphaTest())
+			envShader_fullLight->use();
+		else
+			envShader_fullLight_noAT->use();
+	}
 
 	drawInst(header, inst);
 
@@ -126,10 +152,11 @@ matfxEnvRender(InstanceDataHeader *header, InstanceData *inst, MatFX::Env *env)
 void
 matfxRenderCB(Atomic *atomic, InstanceDataHeader *header)
 {
+	uint32 flags = atomic->geometry->flags;
 	setWorldMatrix(atomic->getFrame()->getLTM());
-	lightingCB(atomic);
+	int32 vsBits = lightingCB(atomic);
 
-	setAttribPointers(header->attribDesc, header->numAttribs);
+	setupVertexInput(header);
 
 	lastEnvFrame = nil;
 
@@ -140,20 +167,18 @@ matfxRenderCB(Atomic *atomic, InstanceDataHeader *header)
 		MatFX *matfx = MatFX::get(inst->material);
 
 		if(matfx == nil)
-			matfxDefaultRender(header, inst);
+			matfxDefaultRender(header, inst, vsBits, flags);
 		else switch(matfx->type){
 		case MatFX::ENVMAP:
-			matfxEnvRender(header, inst, &matfx->fx[0].env);
+			matfxEnvRender(header, inst, vsBits, flags, &matfx->fx[0].env);
 			break;
 		default:
-			matfxDefaultRender(header, inst);
+			matfxDefaultRender(header, inst, vsBits, flags);
 			break;
 		}
 		inst++;
 	}
-#ifndef RW_GL_USE_VAOS
-	disableAttribPointers(header->attribDesc, header->numAttribs);
-#endif
+	teardownVertexInput(header);
 }
 
 ObjPipeline*
@@ -172,21 +197,22 @@ static void*
 matfxOpen(void *o, int32, int32)
 {
 	matFXGlobals.pipelines[PLATFORM_GL3] = makeMatFXPipeline();
-#ifdef PSP2_USE_SHADER_COMPILER
-#ifdef RW_GLES2
-#include "gl2_shaders/matfx_gl2.inc"
-#else
-#include "shaders/matfx_gl3.inc"
-#endif
-	const char *vs[] = { header_vert_src, matfx_env_vert_src, nil };
-	const char *fs[] = { header_frag_src, matfx_env_frag_src, nil };
-	envShader = Shader::create(vs, fs, false);
-#else
-	const char *vs[] = { (const char*)matfx_env_v, (const char*)&size_matfx_env_v, nil };
-	const char *fs[] = { (const char*)matfx_env_f, (const char*)&size_matfx_env_f, nil };
-	envShader = Shader::create(vs, fs, false);
-#endif
+
+#include "shaders/matfx_gl.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, matfx_env_vert_src, nil };
+	const char *vs_fullLight[] = { shaderDecl, "#define DIRECTIONALS\n#define POINTLIGHTS\n#define SPOTLIGHTS\n", header_vert_src, matfx_env_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, matfx_env_frag_src, nil };
+	const char *fs_noAT[] = { shaderDecl, "#define NO_ALPHATEST\n", header_frag_src, matfx_env_frag_src, nil };
+
+	envShader = Shader::create(vs, fs);
 	assert(envShader);
+	envShader_noAT = Shader::create(vs, fs_noAT);
+	assert(envShader_noAT);
+
+	envShader_fullLight = Shader::create(vs_fullLight, fs);
+	assert(envShader_fullLight);
+	envShader_fullLight_noAT = Shader::create(vs_fullLight, fs_noAT);
+	assert(envShader_fullLight_noAT);
 
 	return o;
 }
@@ -199,6 +225,12 @@ matfxClose(void *o, int32, int32)
 
 	envShader->destroy();
 	envShader = nil;
+	envShader_noAT->destroy();
+	envShader_noAT = nil;
+	envShader_fullLight->destroy();
+	envShader_fullLight = nil;
+	envShader_fullLight_noAT->destroy();
+	envShader_fullLight_noAT = nil;
 
 	return o;
 }
@@ -206,9 +238,10 @@ matfxClose(void *o, int32, int32)
 void
 initMatFX(void)
 {
-	u_texMatrix = registerUniform("u_texMatrix");
-	u_fxparams = registerUniform("u_fxparams");
-	u_colorClamp = registerUniform("u_colorClamp");
+	u_texMatrix = registerUniform("u_texMatrix", UNIFORM_MAT4);
+	u_fxparams = registerUniform("u_fxparams", UNIFORM_VEC4);
+	u_colorClamp = registerUniform("u_colorClamp", UNIFORM_VEC4);
+	u_envColor = registerUniform("u_envColor", UNIFORM_VEC4);
 
 	Driver::registerPlugin(PLATFORM_GL3, 0, ID_MATFX,
 	                       matfxOpen, matfxClose);
diff --git a/src/gl/gl3pipe.cpp b/src/gl/gl3pipe.cpp
index bb2d1ae..4df0b7c 100644
--- a/src/gl/gl3pipe.cpp
+++ b/src/gl/gl3pipe.cpp
@@ -9,6 +9,7 @@
 #include "../rwpipeline.h"
 #include "../rwobjects.h"
 #include "../rwengine.h"
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
 
@@ -27,7 +28,11 @@ freeInstanceData(Geometry *geometry)
 		return;
 	InstanceDataHeader *header = (InstanceDataHeader*)geometry->instData;
 	geometry->instData = nil;
-
+	glDeleteBuffers(1, &header->ibo);
+	glDeleteBuffers(1, &header->vbo);
+#ifdef RW_GL_USE_VAOS
+	glDeleteBuffers(1, &header->vao);
+#endif
 	rwFree(header->indexBuffer);
 	rwFree(header->vertexBuffer);
 	rwFree(header->attribDesc);
@@ -70,7 +75,7 @@ instanceMesh(rw::ObjPipeline *rwpipe, Geometry *geo)
 		inst->vertexAlpha = 0;
 		inst->program = 0;
 		inst->offset = offset;
-		memcpy_neon((uint8*)header->indexBuffer + inst->offset,
+		memcpy((uint8*)header->indexBuffer + inst->offset,
 		       mesh->indices, inst->numIndex*2);
 		offset += inst->numIndex*2;
 		mesh++;
@@ -83,6 +88,15 @@ instanceMesh(rw::ObjPipeline *rwpipe, Geometry *geo)
 	header->ibo = 0;
 	header->vbo = 0;
 
+#ifdef RW_GL_USE_VAOS
+	glGenVertexArrays(1, &header->vao);
+	glBindVertexArray(header->vao);
+#endif
+	glGenBuffers(1, &header->ibo);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, header->ibo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, header->totalNumIndex*2,
+			header->indexBuffer, GL_STATIC_DRAW);
+
 	return header;
 }
 
@@ -188,9 +202,9 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 			a->type = GL_FLOAT;
 			a->normalized = GL_FALSE;
 			a->offset = stride;
+			stride += 12;
 			a++;
 		}
-		stride += 12;
 
 		// Prelighting
 		if(isPrelit){
@@ -199,37 +213,34 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 			a->type = GL_UNSIGNED_BYTE;
 			a->normalized = GL_TRUE;
 			a->offset = stride;
+			stride += 4;
 			a++;
 		}
-		stride += 4;
-		
-		if (geo->numTexCoordSets <= 0) stride += 8;
-		else {
-			// Texture coordinates
-			for(int32 n = 0; n < geo->numTexCoordSets; n++){
-				a->index = ATTRIB_TEXCOORDS0+n;
-				a->size = 2;
-				a->type = GL_FLOAT;
-				a->normalized = GL_FALSE;
-				a->offset = stride;
-				stride += 8;
-				a++;
-			}
+
+		// Texture coordinates
+		for(int32 n = 0; n < geo->numTexCoordSets; n++){
+			a->index = ATTRIB_TEXCOORDS0+n;
+			a->size = 2;
+			a->type = GL_FLOAT;
+			a->normalized = GL_FALSE;
+			a->offset = stride;
+			stride += 8;
+			a++;
 		}
 
 		header->numAttribs = a - tmpAttribs;
 		for(a = tmpAttribs; a != &tmpAttribs[header->numAttribs]; a++)
 			a->stride = stride;
 		header->attribDesc = rwNewT(AttribDesc, header->numAttribs, MEMDUR_EVENT | ID_GEOMETRY);
-		memcpy_neon(header->attribDesc, tmpAttribs,
+		memcpy(header->attribDesc, tmpAttribs,
 		       header->numAttribs*sizeof(AttribDesc));
 
 		//
 		// Allocate vertex buffer
 		//
 		header->vertexBuffer = rwNewT(uint8, header->totalNumVertex*stride, MEMDUR_EVENT | ID_GEOMETRY);
-		//assert(header->vbo == 0);
-		//glGenBuffers(1, &header->vbo);
+		assert(header->vbo == 0);
+		glGenBuffers(1, &header->vbo);
 	}
 
 	attribs = header->attribDesc;
@@ -238,7 +249,7 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 	// Fill vertex buffer
 	//
 
-	uint8 *verts = (uint8*)header->vertexBuffer;
+	uint8 *verts = header->vertexBuffer;
 
 	// Positions
 	if(!reinstance || geo->lockedSinceInst&Geometry::LOCKVERTICES){
@@ -256,11 +267,6 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 		instV3d(VERT_FLOAT3, verts + a->offset,
 			geo->morphTargets[0].normals,
 			header->totalNumVertex, a->stride);
-	} else if (!hasNormals) {
-		for (int i = 0; i < header->totalNumVertex; i++) {
-			float *verts_f = (float*)&verts[12 + i * 36];
-			verts_f[0] = verts_f[1] = verts_f[2] = 0;
-		}
 	}
 
 	// Prelighting
@@ -277,13 +283,6 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 				inst->numVertices, a->stride);
 			inst++;
 		}
-	} else if (!isPrelit) {
-		for (int i = 0; i < header->totalNumVertex; i++) {
-			verts[24 + i * 36] = 0;
-			verts[25 + i * 36] = 0;
-			verts[26 + i * 36] = 0;
-			verts[27 + i * 36] = 255;
-		}
 	}
 
 	// Texture coordinates
@@ -296,6 +295,18 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 				header->totalNumVertex, a->stride);
 		}
 	}
+
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(header->vao);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, header->ibo);
+#endif
+	glBindBuffer(GL_ARRAY_BUFFER, header->vbo);
+	glBufferData(GL_ARRAY_BUFFER, header->totalNumVertex*attribs[0].stride,
+	             header->vertexBuffer, GL_STATIC_DRAW);
+#ifdef RW_GL_USE_VAOS
+	setAttribPointers(header->attribDesc, header->numAttribs);
+	glBindVertexArray(0);
+#endif
 }
 
 void
diff --git a/src/gl/gl3raster.cpp b/src/gl/gl3raster.cpp
index ae2c8f6..9d2a2dd 100644
--- a/src/gl/gl3raster.cpp
+++ b/src/gl/gl3raster.cpp
@@ -9,8 +9,10 @@
 #include "../rwpipeline.h"
 #include "../rwobjects.h"
 #include "../rwengine.h"
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
+#include "rwgl3impl.h"
 
 #define PLUGIN_ID ID_DRIVER
 
@@ -19,16 +21,93 @@ namespace gl3 {
 
 int32 nativeRasterOffset;
 
-#define RW_GLES
+#ifdef PSP2
+static int
+nextPo2(int v)
+{
+	int p = 1;
+	while(p < v)
+		p <<= 1;
+	return p;
+}
+
+// Bytes vitaGL actually keeps in texture memory for one compressed level.
+// It rounds both dimensions up to a power of two and stores the blocks swizzled,
+// so the linear ceil(w/4)*ceil(h/4) size is only right for POT textures. We read
+// this back with vglGetTexDataPointer and write it straight back later, so the
+// number just has to describe the same bytes both ways - padding included.
+static uint32
+dxtStorageSize(int w, int h, int blockBytes)
+{
+	return (nextPo2(w)/4) * (nextPo2(h)/4) * blockBytes;
+}
+#endif
+
+static uint32
+getLevelSize(Raster *raster, int32 level)
+{
+	int i;
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
+
+	int w = raster->originalWidth;
+	int h = raster->originalHeight;
+	int s = raster->originalStride;
+	int minDim = 1;
+	int blockBytes = 0;
 
 #ifdef RW_OPENGL
+	switch(natras->internalFormat){
+	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		minDim = 4;
+		blockBytes = 8;
+		break;
+	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		minDim = 4;
+		blockBytes = 16;
+		break;
+	}
+#endif
+
+	for(i = 0; i < level; i++){
+		if(w > minDim){
+			w /= 2;
+			s /= 2;
+		}
+		if(h > minDim)
+			h /= 2;
+	}
+
+	if(blockBytes){
+#ifdef PSP2
+		// Vita: the level is whatever vitaGL keeps in texture memory, since that is
+		// what we read back into txd.img and memcpy back in at run time.
+		if(w < 4) w = 4;
+		if(h < 4) h = 4;
+		return dxtStorageSize(w, h, blockBytes);
+#else
+		return ((w+3)/4) * ((h+3)/4) * blockBytes;
+#endif
+	}
+
+	return s*h;
+}
+
+#ifdef RW_OPENGL
+
 static Raster*
 rasterCreateTexture(Raster *raster)
 {
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	if(raster->format & (Raster::PAL4 | Raster::PAL8)){
+		RWERROR((ERR_NOTEXTURE));
+		return nil;
+	}
+
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 	switch(raster->format & 0xF00){
 	case Raster::C8888:
-		natras->internalFormat = GL_RGBA;
+		natras->internalFormat = GL_RGBA8;
 		natras->format = GL_RGBA;
 		natras->type = GL_UNSIGNED_BYTE;
 		natras->hasAlpha = 1;
@@ -36,7 +115,7 @@ rasterCreateTexture(Raster *raster)
 		raster->depth = 32;
 		break;
 	case Raster::C888:
-		natras->internalFormat = GL_RGB;
+		natras->internalFormat = GL_RGB8;
 		natras->format = GL_RGB;
 		natras->type = GL_UNSIGNED_BYTE;
 		natras->hasAlpha = 0;
@@ -44,7 +123,7 @@ rasterCreateTexture(Raster *raster)
 		raster->depth = 24;
 		break;
 	case Raster::C1555:
-		natras->internalFormat = GL_RGBA;
+		natras->internalFormat = GL_RGB5_A1;
 		natras->format = GL_RGBA;
 		natras->type = GL_UNSIGNED_SHORT_5_5_5_1;
 		natras->hasAlpha = 1;
@@ -56,29 +135,76 @@ rasterCreateTexture(Raster *raster)
 		return nil;
 	}
 
-#ifdef RW_GLES
-	// glReadPixels only supports GL_RGBA
-	natras->internalFormat = GL_RGBA;
-	natras->format = GL_RGBA;
-	natras->type = GL_UNSIGNED_BYTE;
-	natras->bpp = 4;
-#endif
-
-#ifndef PSP2_NO_DXT_TEXTURES
-	if (raster->width >= 4 && raster->height >= 4)
-		natras->internalFormat = natras->hasAlpha ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+#ifndef PSP2
+	if(gl3Caps.gles){
+		// glReadPixels only supports GL_RGBA
+		natras->internalFormat = GL_RGBA8;
+		natras->format = GL_RGBA;
+		natras->type = GL_UNSIGNED_BYTE;
+		natras->bpp = 4;
+	}
+#else
+	// gl3Caps.gles is 1 on Vita only to select the GLSL ES shader dialect; the
+	// texture side is not GLES, so don't blanket-force RGBA8 the way that path
+	// does - master never did on PSP2, and it doubles every 16bpp texture,
+	// exhausting vitaGL's texture memory across a full TXD set.
+	// The one format we must promote is C888: GXM has no 24bpp texture format,
+	// so vitaGL's GL_RGB/GL_UNSIGNED_BYTE upload takes a broken fast-store path
+	// and corrupts the heap. Opaque 888 -> RGBA8 (the alpha byte is just pad).
+	// C1555/C8888 stay native (16bpp / 32bpp), both handled by vitaGL directly.
+	if(natras->format == GL_RGB){
+		natras->internalFormat = GL_RGBA8;
+		natras->format = GL_RGBA;
+		natras->type = GL_UNSIGNED_BYTE;
+		natras->bpp = 4;
+	}
+	// Keep the native source format/type/bpp above, but hand the texture a DXT
+	// internalFormat so vitaGL compresses it into VRAM on upload. This is master's
+	// approach and it is what keeps the frame rate up: VRAM stays 4-8x smaller, and
+	// the conversion pass reads this compressed form back out for txd.img, so at run
+	// time textures are a plain memcpy instead of a decompress + recompress.
+	if(raster->width >= 4 && raster->height >= 4)
+		natras->internalFormat = natras->hasAlpha ?
+			GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
 #endif
 
 	raster->stride = raster->width*natras->bpp;
 
+#ifdef PSP2
+	// Single level, like master. vitaGL's compressed mip chain reallocates per level
+	// and we would have to round-trip every one of them through texture memory.
+	natras->numLevels = 1;
+	natras->autogenMipmap = 0;
+#else
+	if(raster->format & Raster::MIPMAP){
+		int w = raster->width;
+		int h = raster->height;
+		natras->numLevels = 1;
+		while(w != 1 || h != 1){
+			natras->numLevels++;
+			if(w > 1) w /= 2;
+			if(h > 1) h /= 2;
+		}
+	}
+	natras->autogenMipmap = (raster->format & (Raster::MIPMAP|Raster::AUTOMIPMAP)) == (Raster::MIPMAP|Raster::AUTOMIPMAP);
+	if(natras->autogenMipmap)
+		natras->numLevels = 1;
+#endif
+
 	glGenTextures(1, &natras->texid);
 	uint32 prev = bindTexture(natras->texid);
 	glTexImage2D(GL_TEXTURE_2D, 0, natras->internalFormat,
 	             raster->width, raster->height,
 	             0, natras->format, natras->type, nil);
+	// TODO: allocate other levels...probably
+#ifndef PSP2
+	// vitaGL has no GL_TEXTURE_MAX_LEVEL, it tracks the level count itself
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, natras->numLevels-1);
+#endif
 	natras->filterMode = 0;
 	natras->addressU = 0;
 	natras->addressV = 0;
+	natras->maxAnisotropy = 1;
 
 	bindTexture(prev);
 	return raster;
@@ -93,10 +219,10 @@ rasterCreateCameraTexture(Raster *raster)
 	}
 
 	// TODO: figure out what the backbuffer is and use that as a default
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 	switch(raster->format & 0xF00){
 	case Raster::C8888:
-		natras->internalFormat = GL_RGBA;
+		natras->internalFormat = GL_RGBA8;
 		natras->format = GL_RGBA;
 		natras->type = GL_UNSIGNED_BYTE;
 		natras->hasAlpha = 1;
@@ -104,30 +230,34 @@ rasterCreateCameraTexture(Raster *raster)
 		break;
 	case Raster::C888:
 	default:
-		natras->internalFormat = GL_RGB;
+		natras->internalFormat = GL_RGB8;
 		natras->format = GL_RGB;
 		natras->type = GL_UNSIGNED_BYTE;
 		natras->hasAlpha = 0;
 		natras->bpp = 3;
 		break;
 	case Raster::C1555:
-		natras->internalFormat = GL_RGBA;
+		natras->internalFormat = GL_RGB5_A1;
 		natras->format = GL_RGBA;
 		natras->type = GL_UNSIGNED_SHORT_5_5_5_1;
 		natras->hasAlpha = 1;
 		natras->bpp = 2;
 		break;
 	}
-	
-#ifdef RW_GLES
-	natras->internalFormat = GL_RGB;
-	natras->format = GL_RGB;
-	natras->type = GL_UNSIGNED_BYTE;
-	natras->bpp = 3;
-#endif
+
+	// i don't remember why this was once here...
+	if(gl3Caps.gles){
+		// glReadPixels only supports GL_RGBA
+//		natras->internalFormat = GL_RGBA8;
+//		natras->format = GL_RGBA;
+//		natras->type = GL_UNSIGNED_BYTE;
+//		natras->bpp = 4;
+	}
 
 	raster->stride = raster->width*natras->bpp;
 
+	natras->autogenMipmap = (raster->format & (Raster::MIPMAP|Raster::AUTOMIPMAP)) == (Raster::MIPMAP|Raster::AUTOMIPMAP);
+
 	glGenTextures(1, &natras->texid);
 	uint32 prev = bindTexture(natras->texid);
 	glTexImage2D(GL_TEXTURE_2D, 0, natras->internalFormat,
@@ -136,14 +266,15 @@ rasterCreateCameraTexture(Raster *raster)
 	natras->filterMode = 0;
 	natras->addressU = 0;
 	natras->addressV = 0;
+	natras->maxAnisotropy = 1;
 
 	bindTexture(prev);
 
 
-	/*glGenFramebuffers(1, &natras->fbo);
+	glGenFramebuffers(1, &natras->fbo);
 	bindFramebuffer(natras->fbo);
-	glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, natras->texid, 0);
-	bindFramebuffer(0);*/
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, natras->texid, 0);
+	bindFramebuffer(0);
 	natras->fboMate = nil;
 
 	return raster;
@@ -152,13 +283,19 @@ rasterCreateCameraTexture(Raster *raster)
 static Raster*
 rasterCreateCamera(Raster *raster)
 {
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 
 	// TODO: set/check width, height, depth, format?
-	raster->originalWidth = raster->width;
-	raster->originalHeight = raster->height;
-	raster->stride = 0;
-	raster->pixels = nil;
+
+	// used for locking right now
+	raster->format = Raster::C888;
+	natras->internalFormat = GL_RGB8;
+	natras->format = GL_RGB;
+	natras->type = GL_UNSIGNED_BYTE;
+	natras->hasAlpha = 0;
+	natras->bpp = 3;
+
+	natras->autogenMipmap = 0;
 
 	natras->texid = 0;
 	natras->fbo = 0;
@@ -170,37 +307,152 @@ rasterCreateCamera(Raster *raster)
 static Raster*
 rasterCreateZbuffer(Raster *raster)
 {
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 
-	// TODO: set/check width, height, depth, format?
-	raster->originalWidth = raster->width;
-	raster->originalHeight = raster->height;
-	raster->stride = 0;
-	raster->pixels = nil;
+	if(gl3Caps.gles){
+		// have to use RBO on GLES!!
+		glGenRenderbuffers(1, &natras->texid);
+		glBindRenderbuffer(GL_RENDERBUFFER, natras->texid);
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, raster->width, raster->height);
+	}else{
+#ifdef PSP2
+		// unreachable: gl3Caps.gles is always 1 on Vita, so we always take the
+		// RBO path above. vitaGL has neither GL_DEPTH_STENCIL nor
+		// GL_UNSIGNED_INT_24_8, i.e. no depth textures at all.
+		assert(0 && "no depth textures on Vita");
+#else
+		// TODO: set/check width, height, depth, format?
+		natras->internalFormat = GL_DEPTH_STENCIL;
+		natras->format = GL_DEPTH_STENCIL;
+		natras->type = GL_UNSIGNED_INT_24_8;
 
-	/*natras->internalFormat = GL_DEPTH_COMPONENT;
-	natras->format = GL_DEPTH_COMPONENT;
-	natras->type = GL_UNSIGNED_BYTE;
+		natras->autogenMipmap = 0;
 
-	glGenTextures(1, &natras->texid);
-	uint32 prev = bindTexture(natras->texid);
-	glTexImage2D(GL_TEXTURE_2D, 0, natras->internalFormat,
-	             raster->width, raster->height,
-	             0, natras->format, natras->type, nil);
-	natras->filterMode = 0;
-	natras->addressU = 0;
-	natras->addressV = 0;
-
-	bindTexture(prev);
+		glGenTextures(1, &natras->texid);
+		uint32 prev = bindTexture(natras->texid);
+		glTexImage2D(GL_TEXTURE_2D, 0, natras->internalFormat,
+			     raster->width, raster->height,
+			     0, natras->format, natras->type, nil);
+		natras->filterMode = 0;
+		natras->addressU = 0;
+		natras->addressV = 0;
+		natras->maxAnisotropy = 1;
 
+		bindTexture(prev);
+#endif
+	}
 	natras->fbo = 0;
-	natras->fboMate = nil; */
+	natras->fboMate = nil;
 
 	return raster;
 }
 
+
 #endif
 
+
+void
+allocateDXT(Raster *raster, int32 dxt, int32 numLevels, bool32 hasAlpha)
+{
+#ifdef RW_OPENGL
+	assert(raster->type == Raster::TEXTURE);
+
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
+	switch(dxt){
+	case 1:
+		if(hasAlpha){
+			natras->internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+			natras->format = GL_RGBA;
+		}else{
+			natras->internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+			natras->format = GL_RGB;
+		}
+		// bogus, but stride*height should be the size of the image
+		// 4x4 in 8 bytes
+		raster->stride = raster->width/2;
+		break;
+	case 3:
+		natras->internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+		natras->format = GL_RGBA;
+		// 4x4 in 16 bytes
+		raster->stride = raster->width;
+		break;
+	case 5:
+		natras->internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+		natras->format = GL_RGBA;
+		// 4x4 in 16 bytes
+		raster->stride = raster->width;
+		break;
+	default:
+		assert(0 && "invalid DXT format");
+	}
+	natras->type = GL_UNSIGNED_BYTE;
+	natras->hasAlpha = hasAlpha;
+	natras->bpp = 2;
+	raster->depth = 16;
+
+	natras->isCompressed = 1;
+	if(raster->format & Raster::MIPMAP)
+		natras->numLevels = numLevels;
+	natras->autogenMipmap = (raster->format & (Raster::MIPMAP|Raster::AUTOMIPMAP)) == (Raster::MIPMAP|Raster::AUTOMIPMAP);
+	if(natras->autogenMipmap)
+		natras->numLevels = 1;
+
+	glGenTextures(1, &natras->texid);
+	uint32 prev = bindTexture(natras->texid);
+#if !defined(__SWITCH__) && !defined(PSP2)
+	glTexImage2D(GL_TEXTURE_2D, 0, natras->internalFormat,
+	             raster->width, raster->height,
+	             0, natras->format, natras->type, nil);
+#else
+	// Skip this level-0 allocation. rasterUnlock's glCompressedTexImage2D
+	// allocates+uploads level 0 anyway, so pre-allocating here just wastes a
+	// driver call per texture (~0.5ms each on nouveau).
+	// On PSP2 it is worse than wasteful: vitaGL reads a compressed
+	// internalFormat in glTexImage2D as "compress this RGBA for me", allocates a
+	// scratch buffer and then runs dxt_compress over it, uninitialized, because
+	// it tests that buffer for null rather than the caller's (null) pixels.
+#endif
+	// TODO: allocate other levels...probably
+#ifndef PSP2
+	// vitaGL has no GL_TEXTURE_MAX_LEVEL, it tracks the level count itself
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, natras->numLevels-1);
+#endif
+	natras->filterMode = 0;
+	natras->addressU = 0;
+	natras->addressV = 0;
+	natras->maxAnisotropy = 1;
+
+	bindTexture(prev);
+
+	raster->originalStride = raster->stride;
+
+	if(gl3Caps.gles && needToReadBackTextures){
+		// Uh oh, need to keep a copy in cpu memory
+		int32 i;
+		int32 size = 0;
+		for(i = 0; i < natras->numLevels; i++)
+			size += getLevelSize(raster, i);
+		uint8 *data = (uint8*)rwNew(sizeof(RasterLevels)+sizeof(RasterLevels::Level)*(natras->numLevels-1)+size,
+			MEMDUR_EVENT | ID_DRIVER);
+		RasterLevels *levels = (RasterLevels*)data;
+		data += sizeof(RasterLevels)+sizeof(RasterLevels::Level)*(natras->numLevels-1);
+		levels->numlevels = natras->numLevels;
+		levels->format = 0;	// not needed
+		for(i = 0; i < natras->numLevels; i++){
+			levels->levels[i].data = data;
+			levels->levels[i].size = getLevelSize(raster, i);
+			levels->levels[i].width = 0;	// we don't need those here, maybe later...
+			levels->levels[i].height = 0;
+			data += levels->levels[i].size;
+		}
+		natras->backingStore = levels;
+	}
+
+	raster->flags &= ~Raster::DONTALLOCATE;
+#endif
+}
+
 /*
 { 0, 0, 0 },
 { 16, 4, GL_RGBA },	// 1555
@@ -230,80 +482,160 @@ GL_RGB5
 Raster*
 rasterCreate(Raster *raster)
 {
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
+
+	natras->isCompressed = 0;
+	natras->hasAlpha = 0;
+	natras->numLevels = 1;
+
+	Raster *ret = raster;
+
 	if(raster->width == 0 || raster->height == 0){
 		raster->flags |= Raster::DONTALLOCATE;
 		raster->stride = 0;
-		return raster;
+		goto ret;
 	}
 	if(raster->flags & Raster::DONTALLOCATE)
-		return raster;
+		goto ret;
 
 	switch(raster->type){
 #ifdef RW_OPENGL
 	case Raster::NORMAL:
 	case Raster::TEXTURE:
-		return rasterCreateTexture(raster);
+		ret = rasterCreateTexture(raster);
+		break;
 	case Raster::CAMERATEXTURE:
-		return rasterCreateCameraTexture(raster);
+		ret = rasterCreateCameraTexture(raster);
+		break;
 	case Raster::ZBUFFER:
-		return rasterCreateZbuffer(raster);
+		ret = rasterCreateZbuffer(raster);
+		break;
 	case Raster::CAMERA:
-		return rasterCreateCamera(raster);
+		ret = rasterCreateCamera(raster);
+		break;
 #endif
 
 	default:
 		RWERROR((ERR_INVRASTER));
 		return nil;
 	}
-}
 
-#define MEM_ALIGN(x, a) (((x) + ((a)-1)) & ~((a)-1))
+ret:
+	raster->originalWidth = raster->width;
+	raster->originalHeight = raster->height;
+	raster->originalStride = raster->stride;
+	raster->originalPixels = raster->pixels;
+	return ret;
+}
 
 uint8*
 rasterLock(Raster *raster, int32 level, int32 lockMode)
 {
 #ifdef RW_OPENGL
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras GETGL3RASTEREXT(raster);
 	uint8 *px;
+	uint32 allocSz;
+	int i;
+	int minDim;
 
 	assert(raster->privateFlags == 0);
 
-	switch(raster->type & 0xF00){
+	switch(raster->type){
 	case Raster::NORMAL:
 	case Raster::TEXTURE:
 	case Raster::CAMERATEXTURE:
-		px = (uint8*)rwMalloc(raster->stride*raster->height, MEMDUR_EVENT | ID_DRIVER);
-		memset(px, 0, raster->stride*raster->height);
+		// Must stay the true w>>level: the conversion pass feeds each mip level's
+		// image into an already-locked raster and asserts the two agree. (Clamping
+		// to a 4x4 DXT block here is not needed - PSP2 keeps numLevels at 1, so only
+		// level 0 is ever uploaded.)
+		minDim = 1;
+		for(i = 0; i < level; i++){
+			if(raster->width > minDim){
+				raster->width /= 2;
+				raster->stride /= 2;
+			}
+			if(raster->height > minDim)
+				raster->height /= 2;
+		}
+
+		allocSz = getLevelSize(raster, level);
+#ifdef PSP2
+		// The buffer carries either form: the compressed level we read back out of
+		// texture memory, or the uncompressed pixels setFromImage writes into it on
+		// the way in. getLevelSize() reports the compressed size, so take whichever
+		// is larger.
+		{
+			uint32 uncompressedSz = raster->stride * raster->height;
+			if(uncompressedSz > allocSz)
+				allocSz = uncompressedSz;
+		}
+#endif
+		px = (uint8*)rwMalloc(allocSz, MEMDUR_EVENT | ID_DRIVER);
 		assert(raster->pixels == nil);
 		raster->pixels = px;
 
 		if(lockMode & Raster::LOCKREAD || !(lockMode & Raster::LOCKNOFETCH)){
+#ifdef PSP2
+			// Read the compressed level straight out of vitaGL's texture memory -
+			// exactly the bytes it keeps there, padding and swizzle included, so that
+			// writing them back later reproduces the same texture. This is what lets
+			// txd.img hold DXT (~188MB) without ever calling glCompressedTexImage2D.
 			uint32 prev = bindTexture(natras->texid);
-			int y = 0;
 			uint8_t *p = (uint8_t*)vglGetTexDataPointer(GL_TEXTURE_2D);
-#ifdef PSP2_NO_DXT_TEXTURES
-			uint32_t internal_stride = MEM_ALIGN(raster->width, 8) * natras->bpp;
-			while (y < raster->height) {
-				memcpy_neon(px, p, raster->stride);
-				p += internal_stride;
-				y++;
-			}		
-#else
-			if (raster->width < 4 || raster->height < 4) {
-				uint32_t internal_stride = MEM_ALIGN(raster->width, 8) * natras->bpp;
-				while (y < raster->height) {
-					memcpy_neon(px, p, raster->stride);
-					p += internal_stride;
-					y++;
-				}	
-			} else memcpy_neon(px, p, natras->hasAlpha ? (raster->width * raster->height) : (raster->width * raster->height / 2));
-#endif
+			memcpy_neon(px, p, getLevelSize(raster, level));
 			bindTexture(prev);
+#else
+			if(natras->isCompressed){
+				if(natras->backingStore){
+					assert(level < natras->backingStore->numlevels);
+					assert(allocSz >= natras->backingStore->levels[level].size);
+					memcpy(px, natras->backingStore->levels[level].data, allocSz);
+				}else{
+					// GLES is losing here
+					uint32 prev = bindTexture(natras->texid);
+					glGetCompressedTexImage(GL_TEXTURE_2D, level, px);
+					bindTexture(prev);
+				}
+			}else if(gl3Caps.gles){
+				GLuint fbo;
+				glGenFramebuffers(1, &fbo);
+				bindFramebuffer(fbo);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, natras->texid, 0);
+				GLenum e = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+assert(natras->format == GL_RGBA);
+				glReadPixels(0, 0, raster->width, raster->height, natras->format, natras->type, px);
+//e = glGetError(); printf("GL err4 %x (%x)\n", e, natras->format);
+				bindFramebuffer(0);
+				glDeleteFramebuffers(1, &fbo);
+			}else{
+				uint32 prev = bindTexture(natras->texid);
+				glPixelStorei(GL_PACK_ALIGNMENT, 1);
+				glGetTexImage(GL_TEXTURE_2D, level, natras->format, natras->type, px);
+				bindTexture(prev);
+			}
+#endif
 		}
 
 		raster->privateFlags = lockMode;
 		break;
 
+	case Raster::CAMERA:
+		if(lockMode & Raster::PRIVATELOCK_WRITE)
+			assert(0 && "can't lock framebuffer for writing");
+		raster->width = glGlobals.presentWidth;
+		raster->height = glGlobals.presentHeight;
+		raster->stride = raster->width*natras->bpp;
+		assert(natras->bpp == 3);
+		allocSz = raster->height*raster->stride;
+		px = (uint8*)rwMalloc(allocSz, MEMDUR_EVENT | ID_DRIVER);
+		assert(raster->pixels == nil);
+		raster->pixels = px;
+		glReadBuffer(GL_BACK);
+		glReadPixels(0, 0, raster->width, raster->height, GL_RGB, GL_UNSIGNED_BYTE, px);
+
+		raster->privateFlags = lockMode;
+		break;
+
 	default:
 		assert(0 && "cannot lock this type of raster yet");
 		return nil;
@@ -319,37 +651,76 @@ void
 rasterUnlock(Raster *raster, int32 level)
 {
 #ifdef RW_OPENGL
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 
 	assert(raster->pixels);
 
-	if(raster->privateFlags & Raster::LOCKWRITE){
-		uint32 prev = bindTexture(natras->texid);
-		if (raster->privateFlags & Raster::LOCKRAW) {
-			void *p = vglGetTexDataPointer(GL_TEXTURE_2D);
-			memcpy_neon(p, raster->pixels, natras->hasAlpha ? (raster->width * raster->height) : (raster->width * raster->height / 2));
-		} else {	
-			glTexImage2D(GL_TEXTURE_2D, level, natras->internalFormat,
-					raster->width, raster->height,
-					0, natras->format, natras->type, raster->pixels);
-#ifdef PSP2_MIPMAPS
-			glGenerateMipmap(GL_TEXTURE_2D);
+	switch(raster->type){
+	case Raster::NORMAL:
+	case Raster::TEXTURE:
+	case Raster::CAMERATEXTURE:
+		if(raster->privateFlags & Raster::LOCKWRITE){
+			uint32 prev = bindTexture(natras->texid);
+#ifdef PSP2
+			if(raster->privateFlags & Raster::LOCKRAW){
+				// Already-compressed bytes straight from txd.img: drop them into
+				// texture memory as-is. No decompress, no recompress, no driver call
+				// per texture - this is what keeps streaming free of frame drops.
+				void *p = vglGetTexDataPointer(GL_TEXTURE_2D);
+				memcpy_neon(p, raster->pixels, getLevelSize(raster, level));
+			}else{
+				// Uncompressed pixels (conversion pass): vitaGL compresses them into
+				// VRAM because internalFormat is DXT.
+				// (No glPixelStorei(GL_UNPACK_ALIGNMENT): vitaGL rejects it with
+				// GL_INVALID_ENUM - it is already a no-op here, and only spammed the
+				// error log during streaming. Removing it changes nothing.)
+				glTexImage2D(GL_TEXTURE_2D, level, natras->internalFormat,
+					     raster->width, raster->height,
+					     0, natras->format, natras->type, raster->pixels);
+			}
+#else
+			if(natras->isCompressed){
+				glCompressedTexImage2D(GL_TEXTURE_2D, level, natras->internalFormat,
+					raster->width, raster->height, 0,
+					getLevelSize(raster, level),
+					raster->pixels);
+				if(natras->backingStore){
+					assert(level < natras->backingStore->numlevels);
+					memcpy(natras->backingStore->levels[level].data, raster->pixels,
+						natras->backingStore->levels[level].size);
+				}
+			}else{
+				glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+				glTexImage2D(GL_TEXTURE_2D, level, natras->internalFormat,
+					     raster->width, raster->height,
+					     0, natras->format, natras->type, raster->pixels);
+			}
+			if(level == 0 && natras->autogenMipmap)
+				glGenerateMipmap(GL_TEXTURE_2D);
 #endif
+			bindTexture(prev);
 		}
-		bindTexture(prev);
+		break;
+
+	case Raster::CAMERA:
+		// TODO: write?
+		break;
 	}
 
 	rwFree(raster->pixels);
 	raster->pixels = nil;
-	raster->privateFlags = 0;
 #endif
+	raster->width = raster->originalWidth;
+	raster->height = raster->originalHeight;
+	raster->stride = raster->originalStride;
+	raster->pixels = raster->originalPixels;
+	raster->privateFlags = 0;
 }
 
 int32
-rasterNumLevels(Raster*)
+rasterNumLevels(Raster *raster)
 {
-	// TODO
-	return 1;
+	return GETGL3RASTEREXT(raster)->numLevels;
 }
 
 // Almost the same as d3d9 and ps2 function
@@ -424,41 +795,37 @@ rasterFromImage(Raster *raster, Image *image)
 		image = truecolimg;
 	}
 
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
+	int32 format = raster->format&0xF00;
+	assert(!natras->isCompressed);
 	switch(image->depth){
 	case 32:
-#ifdef RW_GLES
-		conv = conv_RGBA8888_from_RGBA8888;
-#else
-		if(raster->format == Raster::C8888)
+		if(gl3Caps.gles)
 			conv = conv_RGBA8888_from_RGBA8888;
-		else if(raster->format == Raster::C888)
+		else if(format == Raster::C8888)
+			conv = conv_RGBA8888_from_RGBA8888;
+		else if(format == Raster::C888)
 			conv = conv_RGB888_from_RGB888;
 		else
 			goto err;
-#endif
 		break;
 	case 24:
-#ifdef RW_GLES
-		conv = conv_RGBA8888_from_RGB888;
-#else
-		if(raster->format == Raster::C8888)
+		if(gl3Caps.gles)
 			conv = conv_RGBA8888_from_RGB888;
-		else if(raster->format == Raster::C888)
+		else if(format == Raster::C8888)
+			conv = conv_RGBA8888_from_RGB888;
+		else if(format == Raster::C888)
 			conv = conv_RGB888_from_RGB888;
 		else
 			goto err;
-#endif
 		break;
 	case 16:
-#ifdef RW_GLES
-		conv = conv_RGBA8888_from_ARGB1555;
-#else
-		if(raster->format == Raster::C1555)
+		if(gl3Caps.gles)
+			conv = conv_RGBA8888_from_ARGB1555;
+		else if(format == Raster::C1555)
 			conv = conv_RGBA5551_from_ARGB1555;
 		else
 			goto err;
-#endif
 		break;
 
 	case 8:
@@ -471,7 +838,13 @@ rasterFromImage(Raster *raster, Image *image)
 
 	natras->hasAlpha = image->hasAlpha();
 
-	uint8 *pixels = raster->lock(0, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+	bool unlock = false;
+	if(raster->pixels == nil){
+		raster->lock(0, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+		unlock = true;
+	}
+
+	uint8 *pixels = raster->pixels;
 	assert(pixels);
 	uint8 *imgpixels = image->pixels + (image->height-1)*image->stride;
 
@@ -489,7 +862,8 @@ rasterFromImage(Raster *raster, Image *image)
 		imgpixels -= image->stride;
 		pixels += raster->stride;
 	}
-	raster->unlock(0);
+	if(unlock)
+		raster->unlock(0);
 
 	if(truecolimg)
 		truecolimg->destroy();
@@ -497,6 +871,83 @@ rasterFromImage(Raster *raster, Image *image)
 	return 1;
 }
 
+Image*
+rasterToImage(Raster *raster)
+{
+	int32 depth;
+	Image *image;
+
+	bool unlock = false;
+	if(raster->pixels == nil){
+		raster->lock(0, Raster::LOCKREAD);
+		unlock = true;
+	}
+
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
+	if(natras->isCompressed){
+		// TODO
+		RWERROR((ERR_INVRASTER));
+		return nil;
+	}
+
+	void (*conv)(uint8 *out, uint8 *in) = nil;
+	switch(raster->format & 0xF00){
+	case Raster::C1555:
+		depth = 16;
+		conv = conv_ARGB1555_from_RGBA5551;
+		break;
+	case Raster::C8888:
+		depth = 32;
+		conv = conv_RGBA8888_from_RGBA8888;
+		break;
+	case Raster::C888:
+		depth = 24;
+		conv = conv_RGB888_from_RGB888;
+		break;
+
+	default:
+	case Raster::C555:
+	case Raster::C565:
+	case Raster::C4444:
+	case Raster::LUM8:
+		RWERROR((ERR_INVRASTER));
+		return nil;
+	}
+
+	if(raster->format & Raster::PAL4 ||
+	   raster->format & Raster::PAL8){
+		RWERROR((ERR_INVRASTER));
+		return nil;
+	}
+		
+	uint8 *in, *out;
+	image = Image::create(raster->width, raster->height, depth);
+	image->allocate();
+
+	uint8 *imgpixels = image->pixels + (image->height-1)*image->stride;
+	uint8 *pixels = raster->pixels;
+
+	int x, y;
+	assert(image->width == raster->width);
+	assert(image->height == raster->height);
+	for(y = 0; y < image->height; y++){
+		uint8 *imgrow = imgpixels;
+		uint8 *rasrow = pixels;
+		for(x = 0; x < image->width; x++){
+			conv(imgrow, rasrow);
+			imgrow += image->bpp;
+			rasrow += natras->bpp;
+		}
+		imgpixels -= image->stride;
+		pixels += raster->stride;
+	}
+
+	if(unlock)
+		raster->unlock(0);
+
+	return image;
+}
+
 static void*
 createNativeRaster(void *object, int32 offset, int32)
 {
@@ -504,15 +955,19 @@ createNativeRaster(void *object, int32 offset, int32)
 	ras->texid = 0;
 	ras->fbo = 0;
 	ras->fboMate = nil;
+	ras->backingStore = nil;
 	return object;
 }
 
+void evictRaster(Raster *raster);
+
 static void*
 destroyNativeRaster(void *object, int32 offset, int32)
 {
 	Raster *raster = (Raster*)object;
 	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, object, offset);
 #ifdef RW_OPENGL
+	evictRaster(raster);
 	switch(raster->type){
 	case Raster::NORMAL:
 	case Raster::TEXTURE:
@@ -522,7 +977,7 @@ destroyNativeRaster(void *object, int32 offset, int32)
 	case Raster::CAMERATEXTURE:
 		if(natras->fboMate){
 			// Break apart from currently associated zbuffer
-			Gl3Raster *zras = PLUGINOFFSET(Gl3Raster, natras->fboMate, offset);
+			Gl3Raster *zras = GETGL3RASTEREXT(natras->fboMate);
 			zras->fboMate = nil;
 			natras->fboMate = nil;
 		}
@@ -533,22 +988,33 @@ destroyNativeRaster(void *object, int32 offset, int32)
 	case Raster::ZBUFFER:
 		if(natras->fboMate){
 			// Detatch from FBO we may be attached to
-			Gl3Raster *oldfb = PLUGINOFFSET(Gl3Raster, natras->fboMate, nativeRasterOffset);
+			Gl3Raster *oldfb = GETGL3RASTEREXT(natras->fboMate);
 			if(oldfb->fbo){
 				bindFramebuffer(oldfb->fbo);
-				//glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 0, 0);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
 			}
 			oldfb->fboMate = nil;
 		}
-		glDeleteTextures(1, &natras->texid);
+		if(gl3Caps.gles)
+			glDeleteRenderbuffers(1, &natras->texid);
+		else
+			glDeleteTextures(1, &natras->texid);
 		break;
 
 	case Raster::CAMERA:
+		if(natras->fboMate){
+			// Break apart from currently associated zbuffer
+			Gl3Raster *zras = GETGL3RASTEREXT(natras->fboMate);
+			zras->fboMate = nil;
+			natras->fboMate = nil;
+		}
 		break;
 	}
 	natras->texid = 0;
 	natras->fbo = 0;
 
+	free(natras->backingStore);
+
 #endif
 	return object;
 }
@@ -560,25 +1026,10 @@ copyNativeRaster(void *dst, void *, int32 offset, int32)
 	d->texid = 0;
 	d->fbo = 0;
 	d->fboMate = nil;
+	d->backingStore = nil;
 	return dst;
 }
 
-static uint32
-getLevelSize(Raster *raster, int32 level)
-{
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
-#ifdef PSP2_NO_DXT_TEXTURES
-	uint32 size = raster->stride * raster->height;
-#else
-	uint32 size;
-	if (raster->width < 4 || raster->height < 4) size = raster->stride * raster->height;
-	else size = natras->hasAlpha ? (raster->width*raster->height) : (raster->width*raster->height / 2);
-#endif
-	while(level--)
-		size /= 4;
-	return size;
-}
-
 Texture*
 readNativeTexture(Stream *stream)
 {
@@ -608,29 +1059,75 @@ readNativeTexture(Stream *stream)
 	int32 depth = stream->readI32();
 	int32 numLevels = stream->readI32();
 
+	// Native raster
+	int32 subplatform = stream->readI32();
+	int32 flags = stream->readI32();
+	int32 compression = stream->readI32();
+
+	if(subplatform != gl3Caps.gles){
+		tex->destroy();
+		RWERROR((ERR_PLATFORM, platform));
+		return nil;
+	}
+
 	Raster *raster;
 	Gl3Raster *natras;
-	raster = Raster::create(width, height, depth, format | Raster::TEXTURE, PLATFORM_GL3);
+	if(flags & 2){
+		if(!gl3Caps.dxtSupported){
+			tex->destroy();
+			RWERROR((ERR_FORMAT_UNSUPPORTED));
+			return nil;
+		}
+		raster = Raster::create(width, height, depth, format | Raster::TEXTURE | Raster::DONTALLOCATE, PLATFORM_GL3);
+		allocateDXT(raster, compression, numLevels, flags & 1);
+	}else{
+		raster = Raster::create(width, height, depth, format | Raster::TEXTURE, PLATFORM_GL3);
+	}
 	assert(raster);
-	natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	natras = GETGL3RASTEREXT(raster);
 	tex->raster = raster;
 
+	int32 uploadLevels = numLevels;
+#ifdef __SWITCH__
+	// switch-mesa/nouveau charges a fixed ~0.7ms per texture-upload driver call
+	// regardless of data size. A txd's long tail of tiny mip levels (each an
+	// 8-16 byte block) then dominates load time and causes streaming hitches.
+	// Upload only the largest RW_SWITCH_TEX_MAXLEVELS level(s); bump this if
+	// distant-texture aliasing becomes noticeable.
+	#ifndef RW_SWITCH_TEX_MAXLEVELS
+	#define RW_SWITCH_TEX_MAXLEVELS 1
+	#endif
+	if(uploadLevels > RW_SWITCH_TEX_MAXLEVELS)
+		uploadLevels = RW_SWITCH_TEX_MAXLEVELS;
+#endif
+
 	uint32 size;
 	uint8 *data;
 	for(int32 i = 0; i < numLevels; i++){
 		size = stream->readU32();
-		if(i < raster->getNumLevels()){
-#ifdef PSP2_NO_DXT_TEXTURES
-			data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
-#else
-			if (raster->width < 4 || raster->height < 4) data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
-			else data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH|Raster::LOCKRAW);
-#endif
-			stream->read8(data, size);
-			raster->unlock(i);
-		}else
+		if(i >= uploadLevels){
+			// skipped level: consume its bytes, don't upload
 			stream->seek(size);
+			continue;
+		}
+#ifdef PSP2
+		// txd.img holds the compressed form vitaGL keeps in texture memory, so load
+		// it raw - rasterUnlock memcpy's it back without touching the compressor.
+		data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH|Raster::LOCKRAW);
+#else
+		data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+#endif
+		stream->read8(data, size);
+		raster->unlock(i);
 	}
+#ifdef __SWITCH__
+	if(uploadLevels < numLevels){
+		// cap the sampled mip level so undefined higher levels aren't read
+		uint32 prev = bindTexture(natras->texid);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, uploadLevels-1);
+		bindTexture(prev);
+	}
+#endif
 	return tex;
 }
 
@@ -638,7 +1135,7 @@ void
 writeNativeTexture(Texture *tex, Stream *stream)
 {
 	Raster *raster = tex->raster;
-	Gl3Raster *natras = PLUGINOFFSET(Gl3Raster, raster, nativeRasterOffset);
+	Gl3Raster *natras = GETGL3RASTEREXT(raster);
 
 	int32 chunksize = getSizeNativeTexture(tex);
 	writeChunkHeader(stream, ID_STRUCT, chunksize-12);
@@ -650,13 +1147,41 @@ writeNativeTexture(Texture *tex, Stream *stream)
 	stream->write8(tex->mask, 32);
 
 	// Raster
-	int32 numLevels = raster->getNumLevels();
+	int32 numLevels = natras->numLevels;
 	stream->writeI32(raster->format);
 	stream->writeI32(raster->width);
 	stream->writeI32(raster->height);
 	stream->writeI32(raster->depth);
 	stream->writeI32(numLevels);
-	// TODO: compression? auto mipmaps?
+
+	// Native raster
+	int32 flags = 0;
+	int32 compression = 0;
+	if(natras->hasAlpha)
+		flags |= 1;
+	if(natras->isCompressed){
+		flags |= 2;
+		switch(natras->internalFormat){
+#ifdef RW_OPENGL
+		case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+			compression = 1;
+			break;
+		case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+			compression = 3;
+			break;
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+			compression = 5;
+			break;
+#endif
+		default:
+			assert(0 && "unknown compression");
+		}
+	}
+	stream->writeI32(gl3Caps.gles);
+	stream->writeI32(flags);
+	stream->writeI32(compression);
+	// TODO: auto mipmaps?
 
 	uint32 size;
 	uint8 *data;
@@ -672,7 +1197,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
 uint32
 getSizeNativeTexture(Texture *tex)
 {
-	uint32 size = 12 + 72 + 20;
+	uint32 size = 12 + 72 + 32;
 	int32 levels = tex->raster->getNumLevels();
 	for(int32 i = 0; i < levels; i++)
 		size += 4 + getLevelSize(tex->raster, i);
diff --git a/src/gl/gl3render.cpp b/src/gl/gl3render.cpp
index ffbc2a6..97724be 100644
--- a/src/gl/gl3render.cpp
+++ b/src/gl/gl3render.cpp
@@ -23,9 +23,9 @@ namespace gl3 {
 void
 drawInst_simple(InstanceDataHeader *header, InstanceData *inst)
 {
-	vglIndexPointerMapped((uint8_t*)header->indexBuffer + inst->offset);
-	vglVertexAttribPointerMapped(0, header->vertexBuffer);
-	vglDrawObjects(header->primType, inst->numIndex);
+	flushCache();
+	glDrawElements(header->primType, inst->numIndex,
+	               GL_UNSIGNED_SHORT, (void*)(uintptr)inst->offset);
 }
 
 // Emulate PS2 GS alpha test FB_ONLY case: failed alpha writes to frame- but not to depth buffer
@@ -74,15 +74,58 @@ drawInst(InstanceDataHeader *header, InstanceData *inst)
 void
 setAttribPointers(AttribDesc *attribDescs, int32 numAttribs)
 {
-	//vglVertexAttribPointerMapped(0, gVertexBuffer);
+	AttribDesc *a;
+#ifdef PSP2
+	// Geometry without PRELIT has no colour array (see instancing), so in_color
+	// falls back to the constant vertex attribute. GL defines that as (0,0,0,1),
+	// but vitaGL leaves it zeroed - alpha included - so anything unlit came out
+	// with alpha 0: car bodies vanished (only their matfx specular survived, and
+	// only while the alpha test let it through) and 3D markers never appeared.
+	// Set the spec's default explicitly, then let a real array override it below.
+	bool hasColor = false;
+	for(a = attribDescs; a != &attribDescs[numAttribs]; a++)
+		if(a->index == ATTRIB_COLOR){
+			hasColor = true;
+			break;
+		}
+	if(!hasColor){
+		glDisableVertexAttribArray(ATTRIB_COLOR);
+		glVertexAttrib4f(ATTRIB_COLOR, 0.0f, 0.0f, 0.0f, 1.0f);
+	}
+#endif
+	for(a = attribDescs; a != &attribDescs[numAttribs]; a++){
+		glEnableVertexAttribArray(a->index);
+		glVertexAttribPointer(a->index, a->size, a->type, a->normalized,
+		                      a->stride, (void*)(uint64)a->offset);
+	}
 }
 
 void
 disableAttribPointers(AttribDesc *attribDescs, int32 numAttribs)
 {
-	/*AttribDesc *a;
+	AttribDesc *a;
 	for(a = attribDescs; a != &attribDescs[numAttribs]; a++)
-		glDisableVertexAttribArray(a->index);*/
+		glDisableVertexAttribArray(a->index);
+}
+
+void
+setupVertexInput(InstanceDataHeader *header)
+{
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(header->vao);
+#else
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, header->ibo);
+	glBindBuffer(GL_ARRAY_BUFFER, header->vbo);
+	setAttribPointers(header->attribDesc, header->numAttribs);
+#endif
+}
+
+void
+teardownVertexInput(InstanceDataHeader *header)
+{
+#ifndef RW_GL_USE_VAOS
+	disableAttribPointers(header->attribDesc, header->numAttribs);
+#endif
 }
 
 int32
@@ -110,40 +153,45 @@ lightingCB(Atomic *atomic)
 	}
 }
 
-#define U(i) currentShader->uniformLocations[i]
-
 void
 defaultRenderCB(Atomic *atomic, InstanceDataHeader *header)
 {
 	Material *m;
 
+	uint32 flags = atomic->geometry->flags;
 	setWorldMatrix(atomic->getFrame()->getLTM());
-	lightingCB(atomic);
+	int32 vsBits = lightingCB(atomic);
 
-	setAttribPointers(header->attribDesc, header->numAttribs);
+	setupVertexInput(header);
 
 	InstanceData *inst = header->inst;
 	int32 n = header->numMeshes;
 
-	defaultShader->use();
-
 	while(n--){
 		m = inst->material;
 
-		rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
-		
+		setMaterial(flags, m->color, m->surfaceProps);
+
 		setTexture(0, m->texture);
-		
-		setMaterial(m->color, m->surfaceProps);
-		
-		flushCache();
+
+		rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
+
+		if((vsBits & VSLIGHT_MASK) == 0){
+			if(getAlphaTest())
+				defaultShader->use();
+			else
+				defaultShader_noAT->use();
+		}else{
+			if(getAlphaTest())
+				defaultShader_fullLight->use();
+			else
+				defaultShader_fullLight_noAT->use();
+		}
 
 		drawInst(header, inst);
 		inst++;
 	}
-#ifndef RW_GL_USE_VAOS
-	disableAttribPointers(header->attribDesc, header->numAttribs);
-#endif
+	teardownVertexInput(header);
 }
 
 
diff --git a/src/gl/gl3shader.cpp b/src/gl/gl3shader.cpp
index 973bead..2be7383 100644
--- a/src/gl/gl3shader.cpp
+++ b/src/gl/gl3shader.cpp
@@ -16,30 +16,60 @@
 namespace rw {
 namespace gl3 {
 
-#ifdef PSP2_USE_SHADER_COMPILER
-#ifdef RW_GLES2
-#include "gl2_shaders/header_vs.inc"
-#include "gl2_shaders/header_fs.inc"
-#else
 #include "shaders/header_vs.inc"
 #include "shaders/header_fs.inc"
-#endif
-#endif
 
 UniformRegistry uniformRegistry;
+static char nameBuffer[(MAX_UNIFORMS + MAX_BLOCKS)*32];	// static because memory system isn't up yet when we register
+static uint32 nameBufPtr;
+static float uniformData[512*4];	// seems enough
+static uint32 dataPtr;
+
+static int uniformTypesize[] = {
+	0, 4, 4, 16
+};
+
+static char*
+shader_strdup(const char *name)
+{
+	size_t len = strlen(name)+1;
+	char *s = &nameBuffer[nameBufPtr];
+	nameBufPtr += len;
+	assert(nameBufPtr <= nelem(nameBuffer));
+	memcpy(s, name, len);
+	return s;
+}
 
 int32
-registerUniform(const char *name)
+registerUniform(const char *name, UniformType type, int32 num)
 {
 	int i;
 	i = findUniform(name);
-	if(i >= 0) return i;
+	if(i >= 0){
+		Uniform *u = &uniformRegistry.uniforms[i];
+		assert(u->type == type);
+		assert(u->num == num);
+		return i;
+	}
 	// TODO: print error
 	if(uniformRegistry.numUniforms+1 >= MAX_UNIFORMS){
 		assert(0 && "no space for uniform");
 		return -1;
 	}
-	uniformRegistry.uniformNames[uniformRegistry.numUniforms] = strdup(name);
+	Uniform *u = &uniformRegistry.uniforms[uniformRegistry.numUniforms];
+	u->name = shader_strdup(name);
+	u->type = type;
+	u->serialNum = 0;
+	if(type == UNIFORM_NA){
+		u->num = 0;
+		u->data = nil;
+	}else{
+		u->num = num;
+		u->data = &uniformData[dataPtr];
+		dataPtr += uniformTypesize[type]*num;
+		assert(dataPtr <= nelem(uniformData));
+	}
+	
 	return uniformRegistry.numUniforms++;
 }
 
@@ -48,7 +78,7 @@ findUniform(const char *name)
 {
 	int i;
 	for(i = 0; i < uniformRegistry.numUniforms; i++)
-		if(strcmp(name, uniformRegistry.uniformNames[i]) == 0)
+		if(strcmp(name, uniformRegistry.uniforms[i].name) == 0)
 			return i;
 	return -1;
 }
@@ -62,7 +92,7 @@ registerBlock(const char *name)
 	// TODO: print error
 	if(uniformRegistry.numBlocks+1 >= MAX_BLOCKS)
 		return -1;
-	uniformRegistry.blockNames[uniformRegistry.numBlocks] = strdup(name);
+	uniformRegistry.blockNames[uniformRegistry.numBlocks] = shader_strdup(name);
 	return uniformRegistry.numBlocks++;
 }
 
@@ -76,6 +106,51 @@ findBlock(const char *name)
 	return -1;
 }
 
+void
+setUniform(int32 id, void *data)
+{
+	Uniform *u = &uniformRegistry.uniforms[id];
+	assert(u->type != UNIFORM_NA);
+	if(memcmp(u->data, data, uniformTypesize[u->type]*u->num * sizeof(float)) != 0){
+		memcpy(u->data, data, uniformTypesize[u->type]*u->num * sizeof(float));
+		//u->dirty = true;
+		u->serialNum++;
+	}
+}
+
+void
+flushUniforms(void)
+{
+	for(int i = 0; i < uniformRegistry.numUniforms; i++){
+		// this is bad!
+		if(i >= currentShader->numUniforms){
+			printf("trying to set uniform %d %s that doesn't exist!\n", i, uniformRegistry.uniforms[i].name);
+			continue;
+		}
+
+		int32 loc = currentShader->uniformLocations[i];
+		if(loc == -1)
+			continue;
+
+		Uniform *u = &uniformRegistry.uniforms[i];
+		if(currentShader->serialNums[i] != u->serialNum)
+			switch(u->type){
+			case UNIFORM_NA:
+				break;
+			case UNIFORM_VEC4:
+				glUniform4fv(loc, u->num, (GLfloat*)u->data);
+				break;
+			case UNIFORM_IVEC4:
+				glUniform4iv(loc, u->num, (GLint*)u->data);
+				break;
+			case UNIFORM_MAT4:
+				glUniformMatrix4fv(loc, u->num, GL_FALSE, (GLfloat*)u->data);
+				break;
+			}
+		currentShader->serialNums[i] = u->serialNum;
+	}
+}
+
 Shader *currentShader;
 
 static void
@@ -100,36 +175,18 @@ printShaderSource(const char **src)
 	}
 }
 
-char shader_source_buffer[16 * 1024];
-
 static int
 compileshader(GLenum type, const char **src, GLuint *shader)
 {
-#ifdef PSP2_USE_SHADER_COMPILER
-	// vitaGL treats GL_VERTEX_SHADER/GL_FRAGMENT_SHADER as GLSL and runs its
-	// translator over the source; the shaders below are Cg, so ask for the
-	// Cg frontend explicitly.
-	GLenum shdrtype = type == GL_VERTEX_SHADER ?
-	                  GL_CG_VERTEX_SHADER_EXT : GL_CG_FRAGMENT_SHADER_EXT;
-#else
-	GLenum shdrtype = type;
-#endif
-	GLint shdr = glCreateShader(shdrtype);
-#ifdef PSP2_USE_SHADER_COMPILER	
 	GLint n;
-	GLint success;
+	GLint shdr, success;
 	GLint len;
 	char *log;
-	
-	shader_source_buffer[0] = 0;
-	
-	for(n = 0; src[n]; n++) {
-		sprintf(shader_source_buffer, "%s%s", shader_source_buffer, src[n]);
-	}
-	
-	const char *_src = (const char*)shader_source_buffer;
-	
-	glShaderSource(shdr, 1, &_src, nil);
+
+	for(n = 0; src[n]; n++);
+
+	shdr = glCreateShader(type);
+	glShaderSource(shdr, n, src, nil);
 	glCompileShader(shdr);
 	glGetShaderiv(shdr, GL_COMPILE_STATUS, &success);
 	if(!success){
@@ -145,16 +202,10 @@ compileshader(GLenum type, const char **src, GLuint *shader)
 	}
 	*shader = shdr;
 	return 0;
-#else
-	unsigned int size = *((unsigned int*)src[1]);
-	glShaderBinary(1, (const uint32_t*)&shdr, 0, src[0], size - 1);
-	*shader = shdr;
-	return 0;
-#endif
 }
 
 static int
-linkprogram(GLint vs, GLint fs, GLuint *program, bool is_2d)
+linkprogram(GLint vs, GLint fs, GLuint *program)
 {
 	GLint prog, success;
 	GLint len;
@@ -162,26 +213,40 @@ linkprogram(GLint vs, GLint fs, GLuint *program, bool is_2d)
 
 	prog = glCreateProgram();
 
+	// Attach before binding attribute locations. GL allows either order, but
+	// vitaGL's glBindAttribLocation dereferences the program's vertex shader
+	// right away, so binding first would hit a null pointer there.
 	glAttachShader(prog, vs);
 	glAttachShader(prog, fs);
 
-	int stride = 0;
-	int pos_size = is_2d ? 4 : 3;
-	stride += vglBindPackedAttribLocation(prog, "in_pos"    , pos_size, GL_FLOAT,         stride, stride + sizeof(float) * pos_size) * (sizeof(float) * pos_size);
-	stride += vglBindPackedAttribLocation(prog, "in_normal" ,        3, GL_FLOAT,         stride, stride + sizeof(float) * 3) * (sizeof(float) * 3);
-	stride += vglBindPackedAttribLocation(prog, "in_color"  ,        4, GL_UNSIGNED_BYTE, stride, stride + 4) * 4;
-	stride += vglBindPackedAttribLocation(prog, "in_tex0"   ,        2, GL_FLOAT,         stride, stride + sizeof(float) * 2) * (sizeof(float) * 2);
-	stride += vglBindPackedAttribLocation(prog, "in_weights",        4, GL_FLOAT,         stride, stride + sizeof(float) * 4) * (sizeof(float) * 4);
-	          vglBindPackedAttribLocation(prog, "in_indices",        4, GL_UNSIGNED_BYTE, stride, stride + 4);
+	if(gl3Caps.glversion < 30){
+		// TODO: perhaps just do this always and get rid of the layout stuff?
+		glBindAttribLocation(prog, ATTRIB_POS, "in_pos");
+		glBindAttribLocation(prog, ATTRIB_NORMAL, "in_normal");
+		glBindAttribLocation(prog, ATTRIB_COLOR, "in_color");
+		glBindAttribLocation(prog, ATTRIB_WEIGHTS, "in_weights");
+		glBindAttribLocation(prog, ATTRIB_INDICES, "in_indices");
+		glBindAttribLocation(prog, ATTRIB_TEXCOORDS0, "in_tex0");
+		glBindAttribLocation(prog, ATTRIB_TEXCOORDS1, "in_tex1");
+	}
 
 	glLinkProgram(prog);
-
+	glGetProgramiv(prog, GL_LINK_STATUS, &success);
+	if(!success){
+		fprintf(stderr, "Error in program\n");
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &len);
+		log = (char*)rwMalloc(len, MEMDUR_FUNCTION);
+		glGetProgramInfoLog(prog, len, nil, log);
+		fprintf(stderr, "%s\n", log);
+		rwFree(log);
+		return 1;
+	}
 	*program = prog;
 	return 0;
 }
 
 Shader*
-Shader::create(const char **vsrc, const char **fsrc, bool is_2d)
+Shader::create(const char **vsrc, const char **fsrc)
 {
 	GLuint vs, fs, program;
 	int i;
@@ -197,10 +262,11 @@ Shader::create(const char **vsrc, const char **fsrc, bool is_2d)
 		return nil;
 	}
 
-	fail = linkprogram(vs, fs, &program, is_2d);
+	fail = linkprogram(vs, fs, &program);
+
+	glDeleteShader(vs);
+	glDeleteShader(fs);
 	if(fail){
-		glDeleteShader(fs);
-		glDeleteShader(vs);
 		return nil;
 	}
 
@@ -233,15 +299,34 @@ Shader::create(const char **vsrc, const char **fsrc, bool is_2d)
 	printf("\n");
 #endif
 
+	// set uniform block binding
+	for(i = 0; i < uniformRegistry.numBlocks; i++){
+		int idx = glGetUniformBlockIndex(program,
+		                                 uniformRegistry.blockNames[i]);
+		if(idx >= 0)
+			glUniformBlockBinding(program, idx, i);
+	}
+
 	// query uniform locations
 	sh->program = program;
+	sh->numUniforms = uniformRegistry.numUniforms;
 	sh->uniformLocations = rwNewT(GLint, uniformRegistry.numUniforms, MEMDUR_EVENT | ID_DRIVER);
-	for(i = 0; i < uniformRegistry.numUniforms; i++)
+	sh->serialNums = rwNewT(uint32, uniformRegistry.numUniforms, MEMDUR_EVENT | ID_DRIVER);
+	for(i = 0; i < uniformRegistry.numUniforms; i++){
 		sh->uniformLocations[i] = glGetUniformLocation(program,
-			uniformRegistry.uniformNames[i]);
+			uniformRegistry.uniforms[i].name);
+		sh->serialNums[i] = ~0;	// let's hope this means dirty
+	}
 
 	// set samplers
 	glUseProgram(program);
+	char name[64];
+	GLint loc;
+	for(i = 0; i < 4; i++){
+		sprintf(name, "tex%d", i);
+		loc = glGetUniformLocation(program, name);
+		glUniform1i(loc, i);
+	}
 
 	// reset program
 	if(currentShader)
@@ -253,10 +338,10 @@ Shader::create(const char **vsrc, const char **fsrc, bool is_2d)
 void
 Shader::use(void)
 {
-	//if(currentShader != this){
+	if(currentShader != this){
 		glUseProgram(this->program);
 		currentShader = this;
-	//}
+	}
 }
 
 void
@@ -264,6 +349,7 @@ Shader::destroy(void)
 {
 	glDeleteProgram(this->program);
 	rwFree(this->uniformLocations);
+	rwFree(this->serialNums);
 	rwFree(this);
 }
 
diff --git a/src/gl/gl3skin.cpp b/src/gl/gl3skin.cpp
index 24e180f..6b69bbd 100644
--- a/src/gl/gl3skin.cpp
+++ b/src/gl/gl3skin.cpp
@@ -12,22 +12,20 @@
 #include "../rwobjects.h"
 #include "../rwanim.h"
 #include "../rwplugins.h"
+
 #include "rwgl3.h"
 #include "rwgl3shader.h"
 #include "rwgl3plg.h"
 
 #include "rwgl3impl.h"
 
-#include "psp2_shaders.h"
-
 namespace rw {
 namespace gl3 {
 
 #ifdef RW_OPENGL
 
-#define U(i) currentShader->uniformLocations[i]
-
-static Shader *skinShader;
+static Shader *skinShader, *skinShader_noAT;
+static Shader *skinShader_fullLight, *skinShader_fullLight_noAT;
 static int32 u_boneMatrices;
 
 void
@@ -65,10 +63,10 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 			a->type = GL_FLOAT;
 			a->normalized = GL_FALSE;
 			a->offset = stride;
+			stride += 12;
 			a++;
 		}
-		stride += 12;
-		
+
 		// Prelighting
 		if(isPrelit){
 			a->index = ATTRIB_COLOR;
@@ -76,9 +74,9 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 			a->type = GL_UNSIGNED_BYTE;
 			a->normalized = GL_TRUE;
 			a->offset = stride;
+			stride += 4;
 			a++;
 		}
-		stride += 4;
 
 		// Texture coordinates
 		for(int32 n = 0; n < geo->numTexCoordSets; n++){
@@ -113,15 +111,15 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 		for(a = tmpAttribs; a != &tmpAttribs[header->numAttribs]; a++)
 			a->stride = stride;
 		header->attribDesc = rwNewT(AttribDesc, header->numAttribs, MEMDUR_EVENT | ID_GEOMETRY);
-		memcpy_neon(header->attribDesc, tmpAttribs,
+		memcpy(header->attribDesc, tmpAttribs,
 		       header->numAttribs*sizeof(AttribDesc));
 
 		//
 		// Allocate vertex buffer
 		//
 		header->vertexBuffer = rwNewT(uint8, header->totalNumVertex*stride, MEMDUR_EVENT | ID_GEOMETRY);
-		//assert(header->vbo == 0);
-		//glGenBuffers(1, &header->vbo);
+		assert(header->vbo == 0);
+		glGenBuffers(1, &header->vbo);
 	}
 
 	Skin *skin = Skin::get(geo);
@@ -131,7 +129,7 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 	// Fill vertex buffer
 	//
 
-	uint8 *verts = (uint8*)header->vertexBuffer;
+	uint8 *verts = header->vertexBuffer;
 
 	// Positions
 	if(!reinstance || geo->lockedSinceInst&Geometry::LOCKVERTICES){
@@ -149,11 +147,6 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 		instV3d(VERT_FLOAT3, verts + a->offset,
 			geo->morphTargets[0].normals,
 			header->totalNumVertex, a->stride);
-	} else if (!hasNormals) {
-		for (int i = 0; i < header->totalNumVertex; i++) {
-			float *verts_f = (float*)&verts[12 + i * 56];
-			verts_f[0] = verts_f[1] = verts_f[2] = 0.0f;
-		}
 	}
 
 	// Prelighting
@@ -163,13 +156,6 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 		instColor(VERT_RGBA, verts + a->offset,
 			  geo->colors,
 			  header->totalNumVertex, a->stride);
-	} else if (!isPrelit) {
-		for (int i = 0; i < header->totalNumVertex; i++) {
-			verts[24 + i * 56] = 0;
-			verts[25 + i * 56] = 0;
-			verts[26 + i * 56] = 0;
-			verts[27 + i * 56] = 255;
-		}
 	}
 
 	// Texture coordinates
@@ -202,6 +188,18 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header, bool32 reinstance)
 			  (RGBA*)skin->indices,
 			  header->totalNumVertex, a->stride);
 	}
+
+#ifdef RW_GL_USE_VAOS
+	glBindVertexArray(header->vao);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, header->ibo);
+#endif
+	glBindBuffer(GL_ARRAY_BUFFER, header->vbo);
+	glBufferData(GL_ARRAY_BUFFER, header->totalNumVertex*attribs[0].stride,
+	             header->vertexBuffer, GL_STATIC_DRAW);
+#ifdef RW_GL_USE_VAOS
+	setAttribPointers(header->attribDesc, header->numAttribs);
+	glBindVertexArray(0);
+#endif
 }
 
 void
@@ -247,8 +245,7 @@ uploadSkinMatrices(Atomic *a)
 			m++;
 		}
 	}
-	glUniformMatrix4fv(U(u_boneMatrices), 64, GL_FALSE,
-	                   (GLfloat*)skinMatrices);
+	setUniform(u_boneMatrices, skinMatrices);
 }
 
 void
@@ -256,58 +253,65 @@ skinRenderCB(Atomic *atomic, InstanceDataHeader *header)
 {
 	Material *m;
 
+	uint32 flags = atomic->geometry->flags;
 	setWorldMatrix(atomic->getFrame()->getLTM());
-	lightingCB(atomic);
+	int32 vsBits = lightingCB(atomic);
 
-	setAttribPointers(header->attribDesc, header->numAttribs);
+	setupVertexInput(header);
 
 	InstanceData *inst = header->inst;
 	int32 n = header->numMeshes;
 
-	skinShader->use();
+	uploadSkinMatrices(atomic);
 
 	while(n--){
 		m = inst->material;
-		
-		rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
-		
+
+		setMaterial(flags, m->color, m->surfaceProps);
+
 		setTexture(0, m->texture);
-		
-		setMaterial(m->color, m->surfaceProps);
-		
-		flushCache();
-		
-		uploadSkinMatrices(atomic);
-		
+
+		rw::SetRenderState(VERTEXALPHA, inst->vertexAlpha || m->color.alpha != 0xFF);
+
+		if((vsBits & VSLIGHT_MASK) == 0){
+			if(getAlphaTest())
+				skinShader->use();
+			else
+				skinShader_noAT->use();
+		}else{
+			if(getAlphaTest())
+				skinShader_fullLight->use();
+			else
+				skinShader_fullLight_noAT->use();
+		}
+
 		drawInst(header, inst);
 		inst++;
 	}
-#ifndef RW_GL_USE_VAOS
-	disableAttribPointers(header->attribDesc, header->numAttribs);
-#endif
+	teardownVertexInput(header);
 }
 
 static void*
 skinOpen(void *o, int32, int32)
 {
 	skinGlobals.pipelines[PLATFORM_GL3] = makeSkinPipeline();
-#ifdef PSP2_USE_SHADER_COMPILER	
-#ifdef RW_GLES2
-#include "gl2_shaders/simple_fs_gl2.inc"
-#include "gl2_shaders/skin_gl2.inc"
-#else
-#include "shaders/simple_fs_gl3.inc"
-#include "shaders/skin_gl3.inc"
-#endif
-	const char *vs[] = { header_vert_src, skin_vert_src, nil };
-	const char *fs[] = { header_frag_src, simple_frag_src, nil };
-	skinShader = Shader::create(vs, fs, false);
-#else
-	const char *vs[] = { (const char*)skin_v, (const char*)&size_skin_v, nil };
-	const char *fs[] = { (const char*)simple_f, (const char*)&size_simple_f, nil };
-	skinShader = Shader::create(vs, fs, false);
-#endif
+
+#include "shaders/simple_fs_gl.inc"
+#include "shaders/skin_gl.inc"
+	const char *vs[] = { shaderDecl, header_vert_src, skin_vert_src, nil };
+	const char *vs_fullLight[] = { shaderDecl, "#define DIRECTIONALS\n#define POINTLIGHTS\n#define SPOTLIGHTS\n", header_vert_src, skin_vert_src, nil };
+	const char *fs[] = { shaderDecl, header_frag_src, simple_frag_src, nil };
+	const char *fs_noAT[] = { shaderDecl, "#define NO_ALPHATEST\n", header_frag_src, simple_frag_src, nil };
+
+	skinShader = Shader::create(vs, fs);
 	assert(skinShader);
+	skinShader_noAT = Shader::create(vs, fs_noAT);
+	assert(skinShader_noAT);
+
+	skinShader_fullLight = Shader::create(vs_fullLight, fs);
+	assert(skinShader_fullLight);
+	skinShader_fullLight_noAT = Shader::create(vs_fullLight, fs_noAT);
+	assert(skinShader_fullLight_noAT);
 
 	return o;
 }
@@ -320,6 +324,12 @@ skinClose(void *o, int32, int32)
 
 	skinShader->destroy();
 	skinShader = nil;
+	skinShader_noAT->destroy();
+	skinShader_noAT = nil;
+	skinShader_fullLight->destroy();
+	skinShader_fullLight = nil;
+	skinShader_fullLight_noAT->destroy();
+	skinShader_fullLight_noAT = nil;
 
 	return o;
 }
@@ -327,7 +337,7 @@ skinClose(void *o, int32, int32)
 void
 initSkin(void)
 {
-	u_boneMatrices = registerUniform("u_boneMatrices");
+	u_boneMatrices = registerUniform("u_boneMatrices", UNIFORM_MAT4, 64);
 
 	Driver::registerPlugin(PLATFORM_GL3, 0, ID_SKIN,
 	                       skinOpen, skinClose);
diff --git a/src/gl/glad/glad.c b/src/gl/glad/glad.c
new file mode 100644
index 0000000..05161d1
--- /dev/null
+++ b/src/gl/glad/glad.c
@@ -0,0 +1,1590 @@
+/*
+
+    OpenGL, OpenGL ES loader generated by glad 0.1.34 on Wed Feb 17 15:35:25 2021.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.3, gles2=3.1
+    Profile: core
+    Extensions:
+        GL_EXT_framebuffer_object,
+        GL_EXT_texture_compression_s3tc,
+        GL_EXT_texture_filter_anisotropic,
+        GL_KHR_debug,
+        GL_KHR_texture_compression_astc_ldr
+    Loader: False
+    Local files: False
+    Omit khrplatform: False
+    Reproducible: False
+
+    Commandline:
+        --profile="core" --api="gl=3.3,gles2=3.1" --generator="c" --spec="gl" --no-loader --extensions="GL_EXT_framebuffer_object,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug,GL_KHR_texture_compression_astc_ldr"
+    Online:
+        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.1&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug&extensions=GL_KHR_texture_compression_astc_ldr
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "glad.h"
+
+struct gladGLversionStruct GLVersion = { 0, 0 };
+
+static int requested_major_version;
+static int requested_minor_version;
+
+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define _GLAD_IS_SOME_NEW_VERSION 1
+#endif
+
+static int max_loaded_major;
+static int max_loaded_minor;
+
+static const char *exts = NULL;
+static int num_exts_i = 0;
+static char **exts_i = NULL;
+
+static int get_exts(void) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        exts = (const char *)glGetString(GL_EXTENSIONS);
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        unsigned int index;
+
+        num_exts_i = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i));
+        }
+
+        if (exts_i == NULL) {
+            return 0;
+        }
+
+        for(index = 0; index < (unsigned)num_exts_i; index++) {
+            const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index);
+            size_t len = strlen(gl_str_tmp);
+
+            char *local_str = (char*)malloc((len+1) * sizeof(char));
+            if(local_str != NULL) {
+                memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char));
+            }
+            exts_i[index] = local_str;
+        }
+    }
+#endif
+    return 1;
+}
+
+static void free_exts(void) {
+    if (exts_i != NULL) {
+        int index;
+        for(index = 0; index < num_exts_i; index++) {
+            free((char *)exts_i[index]);
+        }
+        free((void *)exts_i);
+        exts_i = NULL;
+    }
+}
+
+static int has_ext(const char *ext) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        const char *extensions;
+        const char *loc;
+        const char *terminator;
+        extensions = exts;
+        if(extensions == NULL || ext == NULL) {
+            return 0;
+        }
+
+        while(1) {
+            loc = strstr(extensions, ext);
+            if(loc == NULL) {
+                return 0;
+            }
+
+            terminator = loc + strlen(ext);
+            if((loc == extensions || *(loc - 1) == ' ') &&
+                (*terminator == ' ' || *terminator == '\0')) {
+                return 1;
+            }
+            extensions = terminator;
+        }
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        int index;
+        if(exts_i == NULL) return 0;
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+
+            if(exts_i[index] != NULL && strcmp(e, ext) == 0) {
+                return 1;
+            }
+        }
+    }
+#endif
+
+    return 0;
+}
+int GLAD_GL_VERSION_1_0 = 0;
+int GLAD_GL_VERSION_1_1 = 0;
+int GLAD_GL_VERSION_1_2 = 0;
+int GLAD_GL_VERSION_1_3 = 0;
+int GLAD_GL_VERSION_1_4 = 0;
+int GLAD_GL_VERSION_1_5 = 0;
+int GLAD_GL_VERSION_2_0 = 0;
+int GLAD_GL_VERSION_2_1 = 0;
+int GLAD_GL_VERSION_3_0 = 0;
+int GLAD_GL_VERSION_3_1 = 0;
+int GLAD_GL_VERSION_3_2 = 0;
+int GLAD_GL_VERSION_3_3 = 0;
+int GLAD_GL_ES_VERSION_2_0 = 0;
+int GLAD_GL_ES_VERSION_3_0 = 0;
+int GLAD_GL_ES_VERSION_3_1 = 0;
+PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram = NULL;
+PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL;
+PFNGLATTACHSHADERPROC glad_glAttachShader = NULL;
+PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL;
+PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL;
+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL;
+PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL;
+PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL;
+PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL;
+PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL;
+PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL;
+PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL;
+PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL;
+PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture = NULL;
+PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline = NULL;
+PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL;
+PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL;
+PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL;
+PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback = NULL;
+PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL;
+PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer = NULL;
+PFNGLBLENDCOLORPROC glad_glBlendColor = NULL;
+PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL;
+PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL;
+PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL;
+PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL;
+PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL;
+PFNGLBUFFERDATAPROC glad_glBufferData = NULL;
+PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL;
+PFNGLCLAMPCOLORPROC glad_glClampColor = NULL;
+PFNGLCLEARPROC glad_glClear = NULL;
+PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL;
+PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL;
+PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL;
+PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL;
+PFNGLCLEARCOLORPROC glad_glClearColor = NULL;
+PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL;
+PFNGLCLEARDEPTHFPROC glad_glClearDepthf = NULL;
+PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL;
+PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL;
+PFNGLCOLORMASKPROC glad_glColorMask = NULL;
+PFNGLCOLORMASKIPROC glad_glColorMaski = NULL;
+PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL;
+PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL;
+PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL;
+PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL;
+PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL;
+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL;
+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL;
+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL;
+PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL;
+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL;
+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL;
+PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL;
+PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL;
+PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL;
+PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL;
+PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL;
+PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL;
+PFNGLCREATESHADERPROC glad_glCreateShader = NULL;
+PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv = NULL;
+PFNGLCULLFACEPROC glad_glCullFace = NULL;
+PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL;
+PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL;
+PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL;
+PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines = NULL;
+PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL;
+PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL;
+PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL;
+PFNGLDELETESHADERPROC glad_glDeleteShader = NULL;
+PFNGLDELETESYNCPROC glad_glDeleteSync = NULL;
+PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL;
+PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks = NULL;
+PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL;
+PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL;
+PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
+PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
+PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL;
+PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
+PFNGLDISABLEPROC glad_glDisable = NULL;
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL;
+PFNGLDISABLEIPROC glad_glDisablei = NULL;
+PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute = NULL;
+PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect = NULL;
+PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL;
+PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect = NULL;
+PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL;
+PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL;
+PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL;
+PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL;
+PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL;
+PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect = NULL;
+PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL;
+PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL;
+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL;
+PFNGLENABLEPROC glad_glEnable = NULL;
+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL;
+PFNGLENABLEIPROC glad_glEnablei = NULL;
+PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL;
+PFNGLENDQUERYPROC glad_glEndQuery = NULL;
+PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL;
+PFNGLFENCESYNCPROC glad_glFenceSync = NULL;
+PFNGLFINISHPROC glad_glFinish = NULL;
+PFNGLFLUSHPROC glad_glFlush = NULL;
+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL;
+PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri = NULL;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL;
+PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL;
+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL;
+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL;
+PFNGLFRONTFACEPROC glad_glFrontFace = NULL;
+PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL;
+PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL;
+PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines = NULL;
+PFNGLGENQUERIESPROC glad_glGenQueries = NULL;
+PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL;
+PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL;
+PFNGLGENTEXTURESPROC glad_glGenTextures = NULL;
+PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks = NULL;
+PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL;
+PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL;
+PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL;
+PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL;
+PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL;
+PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL;
+PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL;
+PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL;
+PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL;
+PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL;
+PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL;
+PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL;
+PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL;
+PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL;
+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL;
+PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL;
+PFNGLGETERRORPROC glad_glGetError = NULL;
+PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;
+PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL;
+PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;
+PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv = NULL;
+PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL;
+PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL;
+PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL;
+PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL;
+PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ = NULL;
+PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL;
+PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary = NULL;
+PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL;
+PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv = NULL;
+PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog = NULL;
+PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv = NULL;
+PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex = NULL;
+PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation = NULL;
+PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName = NULL;
+PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv = NULL;
+PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL;
+PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL;
+PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL;
+PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL;
+PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL;
+PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL;
+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL;
+PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL;
+PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL;
+PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL;
+PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL;
+PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL;
+PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat = NULL;
+PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL;
+PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL;
+PFNGLGETSTRINGPROC glad_glGetString = NULL;
+PFNGLGETSTRINGIPROC glad_glGetStringi = NULL;
+PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;
+PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;
+PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL;
+PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL;
+PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL;
+PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL;
+PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL;
+PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL;
+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL;
+PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL;
+PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL;
+PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL;
+PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL;
+PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL;
+PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL;
+PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL;
+PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL;
+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL;
+PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL;
+PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL;
+PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL;
+PFNGLHINTPROC glad_glHint = NULL;
+PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer = NULL;
+PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer = NULL;
+PFNGLISBUFFERPROC glad_glIsBuffer = NULL;
+PFNGLISENABLEDPROC glad_glIsEnabled = NULL;
+PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL;
+PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL;
+PFNGLISPROGRAMPROC glad_glIsProgram = NULL;
+PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline = NULL;
+PFNGLISQUERYPROC glad_glIsQuery = NULL;
+PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL;
+PFNGLISSAMPLERPROC glad_glIsSampler = NULL;
+PFNGLISSHADERPROC glad_glIsShader = NULL;
+PFNGLISSYNCPROC glad_glIsSync = NULL;
+PFNGLISTEXTUREPROC glad_glIsTexture = NULL;
+PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback = NULL;
+PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL;
+PFNGLLINEWIDTHPROC glad_glLineWidth = NULL;
+PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL;
+PFNGLLOGICOPPROC glad_glLogicOp = NULL;
+PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL;
+PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL;
+PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier = NULL;
+PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion = NULL;
+PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL;
+PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL;
+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL;
+PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL;
+PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL;
+PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL;
+PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL;
+PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL;
+PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL;
+PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL;
+PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL;
+PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL;
+PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL;
+PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback = NULL;
+PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL;
+PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL;
+PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL;
+PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL;
+PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL;
+PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL;
+PFNGLPOINTSIZEPROC glad_glPointSize = NULL;
+PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL;
+PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL;
+PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL;
+PFNGLPROGRAMBINARYPROC glad_glProgramBinary = NULL;
+PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri = NULL;
+PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f = NULL;
+PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv = NULL;
+PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i = NULL;
+PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv = NULL;
+PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui = NULL;
+PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv = NULL;
+PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f = NULL;
+PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv = NULL;
+PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i = NULL;
+PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv = NULL;
+PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui = NULL;
+PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv = NULL;
+PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f = NULL;
+PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv = NULL;
+PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i = NULL;
+PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv = NULL;
+PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui = NULL;
+PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv = NULL;
+PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f = NULL;
+PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv = NULL;
+PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i = NULL;
+PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv = NULL;
+PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui = NULL;
+PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv = NULL;
+PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv = NULL;
+PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL;
+PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL;
+PFNGLREADBUFFERPROC glad_glReadBuffer = NULL;
+PFNGLREADPIXELSPROC glad_glReadPixels = NULL;
+PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler = NULL;
+PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL;
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL;
+PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback = NULL;
+PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL;
+PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL;
+PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL;
+PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL;
+PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL;
+PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL;
+PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL;
+PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL;
+PFNGLSCISSORPROC glad_glScissor = NULL;
+PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL;
+PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL;
+PFNGLSHADERBINARYPROC glad_glShaderBinary = NULL;
+PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL;
+PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL;
+PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL;
+PFNGLSTENCILMASKPROC glad_glStencilMask = NULL;
+PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL;
+PFNGLSTENCILOPPROC glad_glStencilOp = NULL;
+PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL;
+PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL;
+PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL;
+PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL;
+PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL;
+PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL;
+PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL;
+PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL;
+PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL;
+PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL;
+PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL;
+PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL;
+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL;
+PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL;
+PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL;
+PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL;
+PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL;
+PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL;
+PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL;
+PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL;
+PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D = NULL;
+PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample = NULL;
+PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D = NULL;
+PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL;
+PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL;
+PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL;
+PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL;
+PFNGLUNIFORM1FPROC glad_glUniform1f = NULL;
+PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL;
+PFNGLUNIFORM1IPROC glad_glUniform1i = NULL;
+PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL;
+PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL;
+PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL;
+PFNGLUNIFORM2FPROC glad_glUniform2f = NULL;
+PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL;
+PFNGLUNIFORM2IPROC glad_glUniform2i = NULL;
+PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL;
+PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL;
+PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL;
+PFNGLUNIFORM3FPROC glad_glUniform3f = NULL;
+PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL;
+PFNGLUNIFORM3IPROC glad_glUniform3i = NULL;
+PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL;
+PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL;
+PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL;
+PFNGLUNIFORM4FPROC glad_glUniform4f = NULL;
+PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL;
+PFNGLUNIFORM4IPROC glad_glUniform4i = NULL;
+PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL;
+PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL;
+PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL;
+PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL;
+PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL;
+PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL;
+PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL;
+PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL;
+PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL;
+PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL;
+PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL;
+PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL;
+PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL;
+PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL;
+PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL;
+PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages = NULL;
+PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL;
+PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline = NULL;
+PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL;
+PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL;
+PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL;
+PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL;
+PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL;
+PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL;
+PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL;
+PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL;
+PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL;
+PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL;
+PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL;
+PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL;
+PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL;
+PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL;
+PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL;
+PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL;
+PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL;
+PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL;
+PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL;
+PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL;
+PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL;
+PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL;
+PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL;
+PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL;
+PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL;
+PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL;
+PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL;
+PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL;
+PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL;
+PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL;
+PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL;
+PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL;
+PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL;
+PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL;
+PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL;
+PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL;
+PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding = NULL;
+PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL;
+PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat = NULL;
+PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL;
+PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL;
+PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL;
+PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL;
+PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL;
+PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL;
+PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL;
+PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL;
+PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL;
+PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL;
+PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL;
+PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL;
+PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL;
+PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL;
+PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL;
+PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL;
+PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL;
+PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL;
+PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL;
+PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL;
+PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat = NULL;
+PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL;
+PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL;
+PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL;
+PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL;
+PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL;
+PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL;
+PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL;
+PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL;
+PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL;
+PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL;
+PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor = NULL;
+PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL;
+PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL;
+PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL;
+PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL;
+PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL;
+PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL;
+PFNGLVIEWPORTPROC glad_glViewport = NULL;
+PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
+int GLAD_GL_EXT_framebuffer_object = 0;
+int GLAD_GL_EXT_texture_compression_s3tc = 0;
+int GLAD_GL_EXT_texture_filter_anisotropic = 0;
+int GLAD_GL_KHR_debug = 0;
+int GLAD_GL_KHR_texture_compression_astc_ldr = 0;
+PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL;
+PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL;
+PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL;
+PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog = NULL;
+PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup = NULL;
+PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup = NULL;
+PFNGLOBJECTLABELPROC glad_glObjectLabel = NULL;
+PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel = NULL;
+PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel = NULL;
+PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel = NULL;
+PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL;
+PFNGLDEBUGMESSAGECONTROLKHRPROC glad_glDebugMessageControlKHR = NULL;
+PFNGLDEBUGMESSAGEINSERTKHRPROC glad_glDebugMessageInsertKHR = NULL;
+PFNGLDEBUGMESSAGECALLBACKKHRPROC glad_glDebugMessageCallbackKHR = NULL;
+PFNGLGETDEBUGMESSAGELOGKHRPROC glad_glGetDebugMessageLogKHR = NULL;
+PFNGLPUSHDEBUGGROUPKHRPROC glad_glPushDebugGroupKHR = NULL;
+PFNGLPOPDEBUGGROUPKHRPROC glad_glPopDebugGroupKHR = NULL;
+PFNGLOBJECTLABELKHRPROC glad_glObjectLabelKHR = NULL;
+PFNGLGETOBJECTLABELKHRPROC glad_glGetObjectLabelKHR = NULL;
+PFNGLOBJECTPTRLABELKHRPROC glad_glObjectPtrLabelKHR = NULL;
+PFNGLGETOBJECTPTRLABELKHRPROC glad_glGetObjectPtrLabelKHR = NULL;
+PFNGLGETPOINTERVKHRPROC glad_glGetPointervKHR = NULL;
+static void load_GL_VERSION_1_0(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_0) return;
+	glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
+	glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
+	glad_glHint = (PFNGLHINTPROC)load("glHint");
+	glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth");
+	glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize");
+	glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode");
+	glad_glScissor = (PFNGLSCISSORPROC)load("glScissor");
+	glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf");
+	glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv");
+	glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri");
+	glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv");
+	glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D");
+	glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D");
+	glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer");
+	glad_glClear = (PFNGLCLEARPROC)load("glClear");
+	glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor");
+	glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil");
+	glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth");
+	glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask");
+	glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask");
+	glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask");
+	glad_glDisable = (PFNGLDISABLEPROC)load("glDisable");
+	glad_glEnable = (PFNGLENABLEPROC)load("glEnable");
+	glad_glFinish = (PFNGLFINISHPROC)load("glFinish");
+	glad_glFlush = (PFNGLFLUSHPROC)load("glFlush");
+	glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc");
+	glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp");
+	glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc");
+	glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp");
+	glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc");
+	glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref");
+	glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei");
+	glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer");
+	glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels");
+	glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv");
+	glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev");
+	glad_glGetError = (PFNGLGETERRORPROC)load("glGetError");
+	glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv");
+	glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv");
+	glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
+	glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage");
+	glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv");
+	glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv");
+	glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv");
+	glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv");
+	glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled");
+	glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange");
+	glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
+}
+static void load_GL_VERSION_1_1(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_1) return;
+	glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
+	glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
+	glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
+	glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D");
+	glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D");
+	glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D");
+	glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D");
+	glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D");
+	glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D");
+	glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture");
+	glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures");
+	glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures");
+	glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
+}
+static void load_GL_VERSION_1_2(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_2) return;
+	glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
+	glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
+	glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
+	glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
+}
+static void load_GL_VERSION_1_3(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_3) return;
+	glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
+	glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
+	glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
+	glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
+	glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D");
+	glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
+	glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
+	glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D");
+	glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
+}
+static void load_GL_VERSION_1_4(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_4) return;
+	glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
+	glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
+	glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
+	glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf");
+	glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv");
+	glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri");
+	glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv");
+	glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor");
+	glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
+}
+static void load_GL_VERSION_1_5(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_1_5) return;
+	glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
+	glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
+	glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
+	glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery");
+	glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery");
+	glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv");
+	glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv");
+	glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv");
+	glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer");
+	glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers");
+	glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers");
+	glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer");
+	glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData");
+	glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData");
+	glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData");
+	glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer");
+	glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer");
+	glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv");
+	glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
+}
+static void load_GL_VERSION_2_0(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_2_0) return;
+	glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
+	glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
+	glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
+	glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate");
+	glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate");
+	glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader");
+	glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation");
+	glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader");
+	glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram");
+	glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader");
+	glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram");
+	glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader");
+	glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader");
+	glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray");
+	glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray");
+	glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib");
+	glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform");
+	glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders");
+	glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation");
+	glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv");
+	glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog");
+	glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv");
+	glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog");
+	glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource");
+	glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation");
+	glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv");
+	glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv");
+	glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv");
+	glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv");
+	glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv");
+	glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv");
+	glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram");
+	glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader");
+	glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram");
+	glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource");
+	glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram");
+	glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f");
+	glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f");
+	glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f");
+	glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f");
+	glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i");
+	glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i");
+	glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i");
+	glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i");
+	glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv");
+	glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv");
+	glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv");
+	glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv");
+	glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv");
+	glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv");
+	glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv");
+	glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv");
+	glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv");
+	glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv");
+	glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv");
+	glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram");
+	glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d");
+	glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv");
+	glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f");
+	glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv");
+	glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s");
+	glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv");
+	glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d");
+	glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv");
+	glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f");
+	glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv");
+	glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s");
+	glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv");
+	glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d");
+	glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv");
+	glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f");
+	glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv");
+	glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s");
+	glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv");
+	glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv");
+	glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv");
+	glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv");
+	glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub");
+	glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv");
+	glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv");
+	glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv");
+	glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv");
+	glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d");
+	glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv");
+	glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f");
+	glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv");
+	glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv");
+	glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s");
+	glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv");
+	glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv");
+	glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv");
+	glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv");
+	glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
+}
+static void load_GL_VERSION_2_1(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_2_1) return;
+	glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
+	glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
+	glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
+	glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv");
+	glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv");
+	glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
+}
+static void load_GL_VERSION_3_0(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_3_0) return;
+	glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
+	glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
+	glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
+	glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei");
+	glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei");
+	glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi");
+	glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback");
+	glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback");
+	glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
+	glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
+	glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings");
+	glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying");
+	glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor");
+	glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender");
+	glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender");
+	glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer");
+	glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv");
+	glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv");
+	glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i");
+	glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i");
+	glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i");
+	glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i");
+	glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui");
+	glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui");
+	glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui");
+	glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui");
+	glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv");
+	glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv");
+	glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv");
+	glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv");
+	glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv");
+	glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv");
+	glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv");
+	glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv");
+	glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv");
+	glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv");
+	glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv");
+	glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv");
+	glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv");
+	glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation");
+	glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation");
+	glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui");
+	glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui");
+	glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui");
+	glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui");
+	glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv");
+	glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv");
+	glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv");
+	glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv");
+	glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv");
+	glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv");
+	glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv");
+	glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv");
+	glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv");
+	glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv");
+	glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv");
+	glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi");
+	glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi");
+	glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer");
+	glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer");
+	glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers");
+	glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers");
+	glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage");
+	glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv");
+	glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer");
+	glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer");
+	glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers");
+	glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers");
+	glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus");
+	glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D");
+	glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
+	glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D");
+	glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
+	glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
+	glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
+	glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
+	glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
+	glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
+	glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
+	glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
+	glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray");
+	glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays");
+	glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays");
+	glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
+}
+static void load_GL_VERSION_3_1(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_3_1) return;
+	glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
+	glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
+	glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
+	glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex");
+	glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData");
+	glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices");
+	glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv");
+	glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName");
+	glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex");
+	glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv");
+	glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName");
+	glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding");
+	glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
+	glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
+	glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
+}
+static void load_GL_VERSION_3_2(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_3_2) return;
+	glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
+	glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
+	glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
+	glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
+	glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex");
+	glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
+	glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync");
+	glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync");
+	glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync");
+	glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync");
+	glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v");
+	glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv");
+	glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v");
+	glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v");
+	glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture");
+	glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample");
+	glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample");
+	glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv");
+	glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
+}
+static void load_GL_VERSION_3_3(GLADloadproc load) {
+	if(!GLAD_GL_VERSION_3_3) return;
+	glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed");
+	glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex");
+	glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
+	glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers");
+	glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler");
+	glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler");
+	glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri");
+	glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv");
+	glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf");
+	glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv");
+	glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv");
+	glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv");
+	glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv");
+	glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv");
+	glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv");
+	glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv");
+	glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter");
+	glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v");
+	glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v");
+	glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor");
+	glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui");
+	glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv");
+	glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui");
+	glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv");
+	glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui");
+	glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv");
+	glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui");
+	glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv");
+	glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui");
+	glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv");
+	glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui");
+	glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv");
+	glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui");
+	glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv");
+	glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui");
+	glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv");
+	glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui");
+	glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv");
+	glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui");
+	glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv");
+	glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui");
+	glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv");
+	glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui");
+	glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv");
+	glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui");
+	glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv");
+	glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui");
+	glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv");
+	glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui");
+	glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv");
+	glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui");
+	glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv");
+	glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui");
+	glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv");
+	glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui");
+	glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv");
+	glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui");
+	glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv");
+}
+static void load_GL_EXT_framebuffer_object(GLADloadproc load) {
+	if(!GLAD_GL_EXT_framebuffer_object || GLAD_GL_VERSION_3_0) return;
+	glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbufferEXT");
+	glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbufferEXT");
+	glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffersEXT");
+	glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffersEXT");
+	glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorageEXT");
+	glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameterivEXT");
+	glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebufferEXT");
+	glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebufferEXT");
+	glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffersEXT");
+	glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffersEXT");
+	glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatusEXT");
+	glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1DEXT");
+	glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2DEXT");
+	glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3DEXT");
+	glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbufferEXT");
+	glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameterivEXT");
+	glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmapEXT");
+}
+static void load_GL_KHR_debug(GLADloadproc load) {
+	if(!GLAD_GL_KHR_debug) return;
+	glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl");
+	glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)load("glDebugMessageInsert");
+	glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)load("glDebugMessageCallback");
+	glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)load("glGetDebugMessageLog");
+	glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)load("glPushDebugGroup");
+	glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)load("glPopDebugGroup");
+	glad_glObjectLabel = (PFNGLOBJECTLABELPROC)load("glObjectLabel");
+	glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)load("glGetObjectLabel");
+	glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)load("glObjectPtrLabel");
+	glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)load("glGetObjectPtrLabel");
+	glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
+	glad_glDebugMessageControlKHR = (PFNGLDEBUGMESSAGECONTROLKHRPROC)load("glDebugMessageControlKHR");
+	glad_glDebugMessageInsertKHR = (PFNGLDEBUGMESSAGEINSERTKHRPROC)load("glDebugMessageInsertKHR");
+	glad_glDebugMessageCallbackKHR = (PFNGLDEBUGMESSAGECALLBACKKHRPROC)load("glDebugMessageCallbackKHR");
+	glad_glGetDebugMessageLogKHR = (PFNGLGETDEBUGMESSAGELOGKHRPROC)load("glGetDebugMessageLogKHR");
+	glad_glPushDebugGroupKHR = (PFNGLPUSHDEBUGGROUPKHRPROC)load("glPushDebugGroupKHR");
+	glad_glPopDebugGroupKHR = (PFNGLPOPDEBUGGROUPKHRPROC)load("glPopDebugGroupKHR");
+	glad_glObjectLabelKHR = (PFNGLOBJECTLABELKHRPROC)load("glObjectLabelKHR");
+	glad_glGetObjectLabelKHR = (PFNGLGETOBJECTLABELKHRPROC)load("glGetObjectLabelKHR");
+	glad_glObjectPtrLabelKHR = (PFNGLOBJECTPTRLABELKHRPROC)load("glObjectPtrLabelKHR");
+	glad_glGetObjectPtrLabelKHR = (PFNGLGETOBJECTPTRLABELKHRPROC)load("glGetObjectPtrLabelKHR");
+	glad_glGetPointervKHR = (PFNGLGETPOINTERVKHRPROC)load("glGetPointervKHR");
+}
+static int find_extensionsGL(void) {
+	if (!get_exts()) return 0;
+	GLAD_GL_EXT_framebuffer_object = has_ext("GL_EXT_framebuffer_object");
+	GLAD_GL_EXT_texture_compression_s3tc = has_ext("GL_EXT_texture_compression_s3tc");
+	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
+	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
+	GLAD_GL_KHR_texture_compression_astc_ldr = has_ext("GL_KHR_texture_compression_astc_ldr");
+	free_exts();
+	return 1;
+}
+
+static void find_coreGL(void) {
+
+    /* Thank you @elmindreda
+     * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
+     * https://github.com/glfw/glfw/blob/master/src/context.c#L36
+     */
+    int i, major, minor;
+
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+
+    version = (const char*) glGetString(GL_VERSION);
+    if (!version) return;
+
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+/* PR #18 */
+#ifdef _MSC_VER
+    sscanf_s(version, "%d.%d", &major, &minor);
+#else
+    sscanf(version, "%d.%d", &major, &minor);
+#endif
+
+	if(major > requested_major_version) {
+		major = requested_major_version;
+	}
+
+	if(major == requested_major_version && minor > requested_minor_version) {
+		minor = requested_minor_version;
+	}
+
+    GLVersion.major = major; GLVersion.minor = minor;
+    max_loaded_major = major; max_loaded_minor = minor;
+	GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+	GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
+	GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
+	GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
+	GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
+	GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
+	GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
+	GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
+	GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
+	GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
+	GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
+	GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3;
+	if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) {
+		max_loaded_major = 3;
+		max_loaded_minor = 3;
+	}
+}
+
+int gladLoadGLLoader(GLADloadproc load, int requestedVersion) {
+	requested_major_version = requestedVersion / 10;
+	requested_minor_version = requestedVersion % 10;
+	GLVersion.major = 0; GLVersion.minor = 0;
+	glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
+	if(glGetString == NULL) return 0;
+	if(glGetString(GL_VERSION) == NULL) return 0;
+	find_coreGL();
+	load_GL_VERSION_1_0(load);
+	load_GL_VERSION_1_1(load);
+	load_GL_VERSION_1_2(load);
+	load_GL_VERSION_1_3(load);
+	load_GL_VERSION_1_4(load);
+	load_GL_VERSION_1_5(load);
+	load_GL_VERSION_2_0(load);
+	load_GL_VERSION_2_1(load);
+	load_GL_VERSION_3_0(load);
+	load_GL_VERSION_3_1(load);
+	load_GL_VERSION_3_2(load);
+	load_GL_VERSION_3_3(load);
+
+	if (!find_extensionsGL()) return 0;
+	load_GL_EXT_framebuffer_object(load);
+	load_GL_KHR_debug(load);
+	return GLVersion.major != 0 || GLVersion.minor != 0;
+}
+
+static void load_GL_ES_VERSION_2_0(GLADloadproc load) {
+	if(!GLAD_GL_ES_VERSION_2_0) return;
+	glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
+	glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader");
+	glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation");
+	glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer");
+	glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer");
+	glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer");
+	glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture");
+	glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor");
+	glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
+	glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
+	glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc");
+	glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
+	glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData");
+	glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData");
+	glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus");
+	glad_glClear = (PFNGLCLEARPROC)load("glClear");
+	glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor");
+	glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC)load("glClearDepthf");
+	glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil");
+	glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask");
+	glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader");
+	glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
+	glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
+	glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D");
+	glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D");
+	glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram");
+	glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader");
+	glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
+	glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers");
+	glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers");
+	glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram");
+	glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers");
+	glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader");
+	glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures");
+	glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc");
+	glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask");
+	glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC)load("glDepthRangef");
+	glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader");
+	glad_glDisable = (PFNGLDISABLEPROC)load("glDisable");
+	glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray");
+	glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
+	glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
+	glad_glEnable = (PFNGLENABLEPROC)load("glEnable");
+	glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray");
+	glad_glFinish = (PFNGLFINISHPROC)load("glFinish");
+	glad_glFlush = (PFNGLFLUSHPROC)load("glFlush");
+	glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
+	glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
+	glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
+	glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers");
+	glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
+	glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers");
+	glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers");
+	glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures");
+	glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib");
+	glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform");
+	glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders");
+	glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation");
+	glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv");
+	glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv");
+	glad_glGetError = (PFNGLGETERRORPROC)load("glGetError");
+	glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv");
+	glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
+	glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv");
+	glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv");
+	glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog");
+	glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv");
+	glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv");
+	glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog");
+	glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat");
+	glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource");
+	glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
+	glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv");
+	glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv");
+	glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv");
+	glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv");
+	glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation");
+	glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv");
+	glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv");
+	glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv");
+	glad_glHint = (PFNGLHINTPROC)load("glHint");
+	glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer");
+	glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled");
+	glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer");
+	glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram");
+	glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer");
+	glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader");
+	glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
+	glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth");
+	glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram");
+	glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei");
+	glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
+	glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels");
+	glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler");
+	glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage");
+	glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
+	glad_glScissor = (PFNGLSCISSORPROC)load("glScissor");
+	glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary");
+	glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource");
+	glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc");
+	glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate");
+	glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask");
+	glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate");
+	glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp");
+	glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
+	glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D");
+	glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf");
+	glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv");
+	glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri");
+	glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv");
+	glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D");
+	glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f");
+	glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv");
+	glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i");
+	glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv");
+	glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f");
+	glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv");
+	glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i");
+	glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv");
+	glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f");
+	glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv");
+	glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i");
+	glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv");
+	glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f");
+	glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv");
+	glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i");
+	glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv");
+	glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv");
+	glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv");
+	glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv");
+	glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram");
+	glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram");
+	glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f");
+	glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv");
+	glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f");
+	glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv");
+	glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f");
+	glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv");
+	glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f");
+	glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv");
+	glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
+	glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
+}
+static void load_GL_ES_VERSION_3_0(GLADloadproc load) {
+	if(!GLAD_GL_ES_VERSION_3_0) return;
+	glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer");
+	glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
+	glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
+	glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
+	glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
+	glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
+	glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
+	glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
+	glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
+	glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
+	glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery");
+	glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery");
+	glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv");
+	glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv");
+	glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer");
+	glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
+	glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
+	glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
+	glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
+	glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
+	glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv");
+	glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv");
+	glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
+	glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
+	glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
+	glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
+	glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
+	glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
+	glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray");
+	glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays");
+	glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays");
+	glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
+	glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
+	glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback");
+	glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback");
+	glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
+	glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
+	glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings");
+	glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying");
+	glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer");
+	glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv");
+	glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv");
+	glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i");
+	glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui");
+	glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv");
+	glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv");
+	glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv");
+	glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation");
+	glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui");
+	glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui");
+	glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui");
+	glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui");
+	glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv");
+	glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv");
+	glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv");
+	glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv");
+	glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv");
+	glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv");
+	glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv");
+	glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi");
+	glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi");
+	glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData");
+	glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices");
+	glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv");
+	glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex");
+	glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv");
+	glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName");
+	glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding");
+	glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
+	glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
+	glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
+	glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync");
+	glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync");
+	glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync");
+	glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync");
+	glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v");
+	glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv");
+	glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v");
+	glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v");
+	glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
+	glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers");
+	glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler");
+	glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler");
+	glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri");
+	glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv");
+	glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf");
+	glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv");
+	glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv");
+	glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv");
+	glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor");
+	glad_glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)load("glBindTransformFeedback");
+	glad_glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)load("glDeleteTransformFeedbacks");
+	glad_glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)load("glGenTransformFeedbacks");
+	glad_glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)load("glIsTransformFeedback");
+	glad_glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)load("glPauseTransformFeedback");
+	glad_glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)load("glResumeTransformFeedback");
+	glad_glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)load("glGetProgramBinary");
+	glad_glProgramBinary = (PFNGLPROGRAMBINARYPROC)load("glProgramBinary");
+	glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri");
+	glad_glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)load("glInvalidateFramebuffer");
+	glad_glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)load("glInvalidateSubFramebuffer");
+	glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D");
+	glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D");
+	glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ");
+}
+static void load_GL_ES_VERSION_3_1(GLADloadproc load) {
+	if(!GLAD_GL_ES_VERSION_3_1) return;
+	glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute");
+	glad_glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)load("glDispatchComputeIndirect");
+	glad_glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)load("glDrawArraysIndirect");
+	glad_glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)load("glDrawElementsIndirect");
+	glad_glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)load("glFramebufferParameteri");
+	glad_glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)load("glGetFramebufferParameteriv");
+	glad_glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)load("glGetProgramInterfaceiv");
+	glad_glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)load("glGetProgramResourceIndex");
+	glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName");
+	glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv");
+	glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation");
+	glad_glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)load("glUseProgramStages");
+	glad_glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)load("glActiveShaderProgram");
+	glad_glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)load("glCreateShaderProgramv");
+	glad_glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)load("glBindProgramPipeline");
+	glad_glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)load("glDeleteProgramPipelines");
+	glad_glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)load("glGenProgramPipelines");
+	glad_glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)load("glIsProgramPipeline");
+	glad_glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)load("glGetProgramPipelineiv");
+	glad_glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)load("glProgramUniform1i");
+	glad_glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)load("glProgramUniform2i");
+	glad_glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)load("glProgramUniform3i");
+	glad_glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)load("glProgramUniform4i");
+	glad_glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)load("glProgramUniform1ui");
+	glad_glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)load("glProgramUniform2ui");
+	glad_glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)load("glProgramUniform3ui");
+	glad_glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)load("glProgramUniform4ui");
+	glad_glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)load("glProgramUniform1f");
+	glad_glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)load("glProgramUniform2f");
+	glad_glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)load("glProgramUniform3f");
+	glad_glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)load("glProgramUniform4f");
+	glad_glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)load("glProgramUniform1iv");
+	glad_glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)load("glProgramUniform2iv");
+	glad_glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)load("glProgramUniform3iv");
+	glad_glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)load("glProgramUniform4iv");
+	glad_glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)load("glProgramUniform1uiv");
+	glad_glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)load("glProgramUniform2uiv");
+	glad_glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)load("glProgramUniform3uiv");
+	glad_glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)load("glProgramUniform4uiv");
+	glad_glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)load("glProgramUniform1fv");
+	glad_glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)load("glProgramUniform2fv");
+	glad_glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)load("glProgramUniform3fv");
+	glad_glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)load("glProgramUniform4fv");
+	glad_glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)load("glProgramUniformMatrix2fv");
+	glad_glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)load("glProgramUniformMatrix3fv");
+	glad_glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)load("glProgramUniformMatrix4fv");
+	glad_glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)load("glProgramUniformMatrix2x3fv");
+	glad_glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)load("glProgramUniformMatrix3x2fv");
+	glad_glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)load("glProgramUniformMatrix2x4fv");
+	glad_glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)load("glProgramUniformMatrix4x2fv");
+	glad_glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)load("glProgramUniformMatrix3x4fv");
+	glad_glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)load("glProgramUniformMatrix4x3fv");
+	glad_glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)load("glValidateProgramPipeline");
+	glad_glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)load("glGetProgramPipelineInfoLog");
+	glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture");
+	glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
+	glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier");
+	glad_glMemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC)load("glMemoryBarrierByRegion");
+	glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample");
+	glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv");
+	glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
+	glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv");
+	glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv");
+	glad_glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)load("glBindVertexBuffer");
+	glad_glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)load("glVertexAttribFormat");
+	glad_glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)load("glVertexAttribIFormat");
+	glad_glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)load("glVertexAttribBinding");
+	glad_glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)load("glVertexBindingDivisor");
+}
+static int find_extensionsGLES2(void) {
+	if (!get_exts()) return 0;
+	GLAD_GL_EXT_texture_compression_s3tc = has_ext("GL_EXT_texture_compression_s3tc");
+	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
+	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
+	GLAD_GL_KHR_texture_compression_astc_ldr = has_ext("GL_KHR_texture_compression_astc_ldr");
+	free_exts();
+	return 1;
+}
+
+static void find_coreGLES2(void) {
+
+    /* Thank you @elmindreda
+     * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
+     * https://github.com/glfw/glfw/blob/master/src/context.c#L36
+     */
+    int i, major, minor;
+
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+
+    version = (const char*) glGetString(GL_VERSION);
+    if (!version) return;
+
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+/* PR #18 */
+#ifdef _MSC_VER
+    sscanf_s(version, "%d.%d", &major, &minor);
+#else
+    sscanf(version, "%d.%d", &major, &minor);
+#endif
+
+	if(major > requested_major_version) {
+		major = requested_major_version;
+	}
+
+	if(major == requested_major_version && minor > requested_minor_version) {
+		minor = requested_minor_version;
+	}
+
+    GLVersion.major = major; GLVersion.minor = minor;
+    max_loaded_major = major; max_loaded_minor = minor;
+	GLAD_GL_ES_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
+	GLAD_GL_ES_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
+	GLAD_GL_ES_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
+	if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 1)) {
+		max_loaded_major = 3;
+		max_loaded_minor = 1;
+	}
+}
+
+int gladLoadGLES2Loader(GLADloadproc load, int requestedVersion) {
+	requested_major_version = requestedVersion / 10;
+	requested_minor_version = requestedVersion % 10;
+	GLVersion.major = 0; GLVersion.minor = 0;
+	glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
+	if(glGetString == NULL) return 0;
+	if(glGetString(GL_VERSION) == NULL) return 0;
+	find_coreGLES2();
+	load_GL_ES_VERSION_2_0(load);
+	load_GL_ES_VERSION_3_0(load);
+	load_GL_ES_VERSION_3_1(load);
+
+	if (!find_extensionsGLES2()) return 0;
+	load_GL_KHR_debug(load);
+	return GLVersion.major != 0 || GLVersion.minor != 0;
+}
diff --git a/src/gl/glad/glad.h b/src/gl/glad/glad.h
new file mode 100644
index 0000000..8f785d5
--- /dev/null
+++ b/src/gl/glad/glad.h
@@ -0,0 +1,2808 @@
+/*
+
+    OpenGL, OpenGL ES loader generated by glad 0.1.34 on Wed Feb 17 15:35:25 2021.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.3, gles2=3.1
+    Profile: core
+    Extensions:
+        GL_EXT_framebuffer_object,
+        GL_EXT_texture_compression_s3tc,
+        GL_EXT_texture_filter_anisotropic,
+        GL_KHR_debug,
+        GL_KHR_texture_compression_astc_ldr
+    Loader: False
+    Local files: False
+    Omit khrplatform: False
+    Reproducible: False
+
+    Commandline:
+        --profile="core" --api="gl=3.3,gles2=3.1" --generator="c" --spec="gl" --no-loader --extensions="GL_EXT_framebuffer_object,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug,GL_KHR_texture_compression_astc_ldr"
+    Online:
+        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.1&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug&extensions=GL_KHR_texture_compression_astc_ldr
+*/
+
+
+#ifndef __glad_h_
+#define __glad_h_
+
+#ifdef __gl_h_
+#error OpenGL header already included, remove this include, glad already provides it
+#endif
+#define __gl_h_
+
+#ifdef __gl2_h_
+#error OpenGL ES 2 header already included, remove this include, glad already provides it
+#endif
+#define __gl2_h_
+
+#ifdef __gl3_h_
+#error OpenGL ES 3 header already included, remove this include, glad already provides it
+#endif
+#define __gl3_h_
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define APIENTRY __stdcall
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY APIENTRY
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct gladGLversionStruct {
+    int major;
+    int minor;
+};
+
+typedef void* (* GLADloadproc)(const char *name);
+
+#ifndef GLAPI
+# if defined(GLAD_GLAPI_EXPORT)
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#   if defined(GLAD_GLAPI_EXPORT_BUILD)
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllexport)) extern
+#    else
+#     define GLAPI __declspec(dllexport) extern
+#    endif
+#   else
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllimport)) extern
+#    else
+#     define GLAPI __declspec(dllimport) extern
+#    endif
+#   endif
+#  elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
+#   define GLAPI __attribute__ ((visibility ("default"))) extern
+#  else
+#   define GLAPI extern
+#  endif
+# else
+#  define GLAPI extern
+# endif
+#endif
+
+GLAPI struct gladGLversionStruct GLVersion;
+GLAPI int gladLoadGLLoader(GLADloadproc, int requestedVersion);
+
+GLAPI int gladLoadGLES2Loader(GLADloadproc, int requestedVersion);
+
+#include "khrplatform.h"
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef void GLvoid;
+typedef khronos_int8_t GLbyte;
+typedef khronos_uint8_t GLubyte;
+typedef khronos_int16_t GLshort;
+typedef khronos_uint16_t GLushort;
+typedef int GLint;
+typedef unsigned int GLuint;
+typedef khronos_int32_t GLclampx;
+typedef int GLsizei;
+typedef khronos_float_t GLfloat;
+typedef khronos_float_t GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void *GLeglClientBufferEXT;
+typedef void *GLeglImageOES;
+typedef char GLchar;
+typedef char GLcharARB;
+#ifdef __APPLE__
+typedef void *GLhandleARB;
+#else
+typedef unsigned int GLhandleARB;
+#endif
+typedef khronos_uint16_t GLhalf;
+typedef khronos_uint16_t GLhalfARB;
+typedef khronos_int32_t GLfixed;
+typedef khronos_intptr_t GLintptr;
+typedef khronos_intptr_t GLintptrARB;
+typedef khronos_ssize_t GLsizeiptr;
+typedef khronos_ssize_t GLsizeiptrARB;
+typedef khronos_int64_t GLint64;
+typedef khronos_int64_t GLint64EXT;
+typedef khronos_uint64_t GLuint64;
+typedef khronos_uint64_t GLuint64EXT;
+typedef struct __GLsync *GLsync;
+struct _cl_context;
+struct _cl_event;
+typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
+typedef unsigned short GLhalfNV;
+typedef GLintptr GLvdpauSurfaceNV;
+typedef void (APIENTRY *GLVULKANPROCNV)(void);
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_FALSE 0
+#define GL_TRUE 1
+#define GL_POINTS 0x0000
+#define GL_LINES 0x0001
+#define GL_LINE_LOOP 0x0002
+#define GL_LINE_STRIP 0x0003
+#define GL_TRIANGLES 0x0004
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_NEVER 0x0200
+#define GL_LESS 0x0201
+#define GL_EQUAL 0x0202
+#define GL_LEQUAL 0x0203
+#define GL_GREATER 0x0204
+#define GL_NOTEQUAL 0x0205
+#define GL_GEQUAL 0x0206
+#define GL_ALWAYS 0x0207
+#define GL_ZERO 0
+#define GL_ONE 1
+#define GL_SRC_COLOR 0x0300
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_SRC_ALPHA 0x0302
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_DST_ALPHA 0x0304
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_DST_COLOR 0x0306
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_NONE 0
+#define GL_FRONT_LEFT 0x0400
+#define GL_FRONT_RIGHT 0x0401
+#define GL_BACK_LEFT 0x0402
+#define GL_BACK_RIGHT 0x0403
+#define GL_FRONT 0x0404
+#define GL_BACK 0x0405
+#define GL_LEFT 0x0406
+#define GL_RIGHT 0x0407
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_NO_ERROR 0
+#define GL_INVALID_ENUM 0x0500
+#define GL_INVALID_VALUE 0x0501
+#define GL_INVALID_OPERATION 0x0502
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_CW 0x0900
+#define GL_CCW 0x0901
+#define GL_POINT_SIZE 0x0B11
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_LINE_SMOOTH 0x0B20
+#define GL_LINE_WIDTH 0x0B21
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_POLYGON_MODE 0x0B40
+#define GL_POLYGON_SMOOTH 0x0B41
+#define GL_CULL_FACE 0x0B44
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_FRONT_FACE 0x0B46
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_DEPTH_TEST 0x0B71
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_STENCIL_TEST 0x0B90
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_STENCIL_REF 0x0B97
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_VIEWPORT 0x0BA2
+#define GL_DITHER 0x0BD0
+#define GL_BLEND_DST 0x0BE0
+#define GL_BLEND_SRC 0x0BE1
+#define GL_BLEND 0x0BE2
+#define GL_LOGIC_OP_MODE 0x0BF0
+#define GL_DRAW_BUFFER 0x0C01
+#define GL_READ_BUFFER 0x0C02
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_DOUBLEBUFFER 0x0C32
+#define GL_STEREO 0x0C33
+#define GL_LINE_SMOOTH_HINT 0x0C52
+#define GL_POLYGON_SMOOTH_HINT 0x0C53
+#define GL_UNPACK_SWAP_BYTES 0x0CF0
+#define GL_UNPACK_LSB_FIRST 0x0CF1
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_PACK_SWAP_BYTES 0x0D00
+#define GL_PACK_LSB_FIRST 0x0D01
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_TEXTURE_1D 0x0DE0
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_TEXTURE_WIDTH 0x1000
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#define GL_DONT_CARE 0x1100
+#define GL_FASTEST 0x1101
+#define GL_NICEST 0x1102
+#define GL_BYTE 0x1400
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_SHORT 0x1402
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_INT 0x1404
+#define GL_UNSIGNED_INT 0x1405
+#define GL_FLOAT 0x1406
+#define GL_CLEAR 0x1500
+#define GL_AND 0x1501
+#define GL_AND_REVERSE 0x1502
+#define GL_COPY 0x1503
+#define GL_AND_INVERTED 0x1504
+#define GL_NOOP 0x1505
+#define GL_XOR 0x1506
+#define GL_OR 0x1507
+#define GL_NOR 0x1508
+#define GL_EQUIV 0x1509
+#define GL_INVERT 0x150A
+#define GL_OR_REVERSE 0x150B
+#define GL_COPY_INVERTED 0x150C
+#define GL_OR_INVERTED 0x150D
+#define GL_NAND 0x150E
+#define GL_SET 0x150F
+#define GL_TEXTURE 0x1702
+#define GL_COLOR 0x1800
+#define GL_DEPTH 0x1801
+#define GL_STENCIL 0x1802
+#define GL_STENCIL_INDEX 0x1901
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_RED 0x1903
+#define GL_GREEN 0x1904
+#define GL_BLUE 0x1905
+#define GL_ALPHA 0x1906
+#define GL_RGB 0x1907
+#define GL_RGBA 0x1908
+#define GL_POINT 0x1B00
+#define GL_LINE 0x1B01
+#define GL_FILL 0x1B02
+#define GL_KEEP 0x1E00
+#define GL_REPLACE 0x1E01
+#define GL_INCR 0x1E02
+#define GL_DECR 0x1E03
+#define GL_VENDOR 0x1F00
+#define GL_RENDERER 0x1F01
+#define GL_VERSION 0x1F02
+#define GL_EXTENSIONS 0x1F03
+#define GL_NEAREST 0x2600
+#define GL_LINEAR 0x2601
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_REPEAT 0x2901
+#define GL_COLOR_LOGIC_OP 0x0BF2
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_POLYGON_OFFSET_POINT 0x2A01
+#define GL_POLYGON_OFFSET_LINE 0x2A02
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_TEXTURE_BINDING_1D 0x8068
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_TEXTURE_RED_SIZE 0x805C
+#define GL_TEXTURE_GREEN_SIZE 0x805D
+#define GL_TEXTURE_BLUE_SIZE 0x805E
+#define GL_TEXTURE_ALPHA_SIZE 0x805F
+#define GL_DOUBLE 0x140A
+#define GL_PROXY_TEXTURE_1D 0x8063
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_R3_G3_B2 0x2A10
+#define GL_RGB4 0x804F
+#define GL_RGB5 0x8050
+#define GL_RGB8 0x8051
+#define GL_RGB10 0x8052
+#define GL_RGB12 0x8053
+#define GL_RGB16 0x8054
+#define GL_RGBA2 0x8055
+#define GL_RGBA4 0x8056
+#define GL_RGB5_A1 0x8057
+#define GL_RGBA8 0x8058
+#define GL_RGB10_A2 0x8059
+#define GL_RGBA12 0x805A
+#define GL_RGBA16 0x805B
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_PACK_SKIP_IMAGES 0x806B
+#define GL_PACK_IMAGE_HEIGHT 0x806C
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_TEXTURE_3D 0x806F
+#define GL_PROXY_TEXTURE_3D 0x8070
+#define GL_TEXTURE_DEPTH 0x8071
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_BGR 0x80E0
+#define GL_BGRA 0x80E1
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+#define GL_TEXTURE0 0x84C0
+#define GL_TEXTURE1 0x84C1
+#define GL_TEXTURE2 0x84C2
+#define GL_TEXTURE3 0x84C3
+#define GL_TEXTURE4 0x84C4
+#define GL_TEXTURE5 0x84C5
+#define GL_TEXTURE6 0x84C6
+#define GL_TEXTURE7 0x84C7
+#define GL_TEXTURE8 0x84C8
+#define GL_TEXTURE9 0x84C9
+#define GL_TEXTURE10 0x84CA
+#define GL_TEXTURE11 0x84CB
+#define GL_TEXTURE12 0x84CC
+#define GL_TEXTURE13 0x84CD
+#define GL_TEXTURE14 0x84CE
+#define GL_TEXTURE15 0x84CF
+#define GL_TEXTURE16 0x84D0
+#define GL_TEXTURE17 0x84D1
+#define GL_TEXTURE18 0x84D2
+#define GL_TEXTURE19 0x84D3
+#define GL_TEXTURE20 0x84D4
+#define GL_TEXTURE21 0x84D5
+#define GL_TEXTURE22 0x84D6
+#define GL_TEXTURE23 0x84D7
+#define GL_TEXTURE24 0x84D8
+#define GL_TEXTURE25 0x84D9
+#define GL_TEXTURE26 0x84DA
+#define GL_TEXTURE27 0x84DB
+#define GL_TEXTURE28 0x84DC
+#define GL_TEXTURE29 0x84DD
+#define GL_TEXTURE30 0x84DE
+#define GL_TEXTURE31 0x84DF
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_MULTISAMPLE 0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_SAMPLES 0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_COMPRESSED_RGB 0x84ED
+#define GL_COMPRESSED_RGBA 0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
+#define GL_TEXTURE_COMPRESSED 0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_CLAMP_TO_BORDER 0x812D
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_DEPTH_COMPONENT32 0x81A7
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_TEXTURE_LOD_BIAS 0x8501
+#define GL_INCR_WRAP 0x8507
+#define GL_DECR_WRAP 0x8508
+#define GL_TEXTURE_DEPTH_SIZE 0x884A
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_BLEND_COLOR 0x8005
+#define GL_BLEND_EQUATION 0x8009
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+#define GL_FUNC_ADD 0x8006
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_MIN 0x8007
+#define GL_MAX 0x8008
+#define GL_BUFFER_SIZE 0x8764
+#define GL_BUFFER_USAGE 0x8765
+#define GL_QUERY_COUNTER_BITS 0x8864
+#define GL_CURRENT_QUERY 0x8865
+#define GL_QUERY_RESULT 0x8866
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_READ_ONLY 0x88B8
+#define GL_WRITE_ONLY 0x88B9
+#define GL_READ_WRITE 0x88BA
+#define GL_BUFFER_ACCESS 0x88BB
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_STREAM_DRAW 0x88E0
+#define GL_STREAM_READ 0x88E1
+#define GL_STREAM_COPY 0x88E2
+#define GL_STATIC_DRAW 0x88E4
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_COPY 0x88E6
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_SAMPLES_PASSED 0x8914
+#define GL_SRC1_ALPHA 0x8589
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_BLEND_EQUATION_ALPHA 0x883D
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_MAX_VARYING_FLOATS 0x8B4B
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_INT_VEC2 0x8B53
+#define GL_INT_VEC3 0x8B54
+#define GL_INT_VEC4 0x8B55
+#define GL_BOOL 0x8B56
+#define GL_BOOL_VEC2 0x8B57
+#define GL_BOOL_VEC3 0x8B58
+#define GL_BOOL_VEC4 0x8B59
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_SAMPLER_1D 0x8B5D
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_SAMPLER_1D_SHADOW 0x8B61
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_DELETE_STATUS 0x8B80
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_LINK_STATUS 0x8B82
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
+#define GL_LOWER_LEFT 0x8CA1
+#define GL_UPPER_LEFT 0x8CA2
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_SRGB 0x8C40
+#define GL_SRGB8 0x8C41
+#define GL_SRGB_ALPHA 0x8C42
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_COMPRESSED_SRGB 0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_CLIP_DISTANCE0 0x3000
+#define GL_CLIP_DISTANCE1 0x3001
+#define GL_CLIP_DISTANCE2 0x3002
+#define GL_CLIP_DISTANCE3 0x3003
+#define GL_CLIP_DISTANCE4 0x3004
+#define GL_CLIP_DISTANCE5 0x3005
+#define GL_CLIP_DISTANCE6 0x3006
+#define GL_CLIP_DISTANCE7 0x3007
+#define GL_MAX_CLIP_DISTANCES 0x0D32
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_CONTEXT_FLAGS 0x821E
+#define GL_COMPRESSED_RED 0x8225
+#define GL_COMPRESSED_RG 0x8226
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_RGBA16F 0x881A
+#define GL_RGB16F 0x881B
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_CLAMP_READ_COLOR 0x891C
+#define GL_FIXED_ONLY 0x891D
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_TEXTURE_1D_ARRAY 0x8C18
+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_RGB9_E5 0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_TEXTURE_SHARED_SIZE 0x8C3F
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_PRIMITIVES_GENERATED 0x8C87
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_RGBA32UI 0x8D70
+#define GL_RGB32UI 0x8D71
+#define GL_RGBA16UI 0x8D76
+#define GL_RGB16UI 0x8D77
+#define GL_RGBA8UI 0x8D7C
+#define GL_RGB8UI 0x8D7D
+#define GL_RGBA32I 0x8D82
+#define GL_RGB32I 0x8D83
+#define GL_RGBA16I 0x8D88
+#define GL_RGB16I 0x8D89
+#define GL_RGBA8I 0x8D8E
+#define GL_RGB8I 0x8D8F
+#define GL_RED_INTEGER 0x8D94
+#define GL_GREEN_INTEGER 0x8D95
+#define GL_BLUE_INTEGER 0x8D96
+#define GL_RGB_INTEGER 0x8D98
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_BGR_INTEGER 0x8D9A
+#define GL_BGRA_INTEGER 0x8D9B
+#define GL_SAMPLER_1D_ARRAY 0x8DC0
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_INT_SAMPLER_1D 0x8DC9
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_QUERY_WAIT 0x8E13
+#define GL_QUERY_NO_WAIT 0x8E14
+#define GL_QUERY_BY_REGION_WAIT 0x8E15
+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_TEXTURE_STENCIL_SIZE 0x88F1
+#define GL_TEXTURE_RED_TYPE 0x8C10
+#define GL_TEXTURE_GREEN_TYPE 0x8C11
+#define GL_TEXTURE_BLUE_TYPE 0x8C12
+#define GL_TEXTURE_ALPHA_TYPE 0x8C13
+#define GL_TEXTURE_DEPTH_TYPE 0x8C16
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_COLOR_ATTACHMENT16 0x8CF0
+#define GL_COLOR_ATTACHMENT17 0x8CF1
+#define GL_COLOR_ATTACHMENT18 0x8CF2
+#define GL_COLOR_ATTACHMENT19 0x8CF3
+#define GL_COLOR_ATTACHMENT20 0x8CF4
+#define GL_COLOR_ATTACHMENT21 0x8CF5
+#define GL_COLOR_ATTACHMENT22 0x8CF6
+#define GL_COLOR_ATTACHMENT23 0x8CF7
+#define GL_COLOR_ATTACHMENT24 0x8CF8
+#define GL_COLOR_ATTACHMENT25 0x8CF9
+#define GL_COLOR_ATTACHMENT26 0x8CFA
+#define GL_COLOR_ATTACHMENT27 0x8CFB
+#define GL_COLOR_ATTACHMENT28 0x8CFC
+#define GL_COLOR_ATTACHMENT29 0x8CFD
+#define GL_COLOR_ATTACHMENT30 0x8CFE
+#define GL_COLOR_ATTACHMENT31 0x8CFF
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_RENDERBUFFER 0x8D41
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_STENCIL_INDEX1 0x8D46
+#define GL_STENCIL_INDEX4 0x8D47
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_STENCIL_INDEX16 0x8D49
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_FRAMEBUFFER_SRGB 0x8DB9
+#define GL_HALF_FLOAT 0x140B
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define GL_RG 0x8227
+#define GL_RG_INTEGER 0x8228
+#define GL_R8 0x8229
+#define GL_R16 0x822A
+#define GL_RG8 0x822B
+#define GL_RG16 0x822C
+#define GL_R16F 0x822D
+#define GL_R32F 0x822E
+#define GL_RG16F 0x822F
+#define GL_RG32F 0x8230
+#define GL_R8I 0x8231
+#define GL_R8UI 0x8232
+#define GL_R16I 0x8233
+#define GL_R16UI 0x8234
+#define GL_R32I 0x8235
+#define GL_R32UI 0x8236
+#define GL_RG8I 0x8237
+#define GL_RG8UI 0x8238
+#define GL_RG16I 0x8239
+#define GL_RG16UI 0x823A
+#define GL_RG32I 0x823B
+#define GL_RG32UI 0x823C
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_R16_SNORM 0x8F98
+#define GL_RG16_SNORM 0x8F99
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFF
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_PROGRAM_POINT_SIZE 0x8642
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_DEPTH_CLAMP 0x864F
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_PROVOKING_VERTEX 0x8E4F
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_OBJECT_TYPE 0x9112
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_UNSIGNALED 0x9118
+#define GL_SIGNALED 0x9119
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_WAIT_FAILED 0x911D
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_SRC1_COLOR 0x88F9
+#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
+#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_RGB10_A2UI 0x906F
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#define GL_TIME_ELAPSED 0x88BF
+#define GL_TIMESTAMP 0x8E28
+#define GL_INT_2_10_10_10_REV 0x8D9F
+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
+#define GL_RED_BITS 0x0D52
+#define GL_GREEN_BITS 0x0D53
+#define GL_BLUE_BITS 0x0D54
+#define GL_ALPHA_BITS 0x0D55
+#define GL_DEPTH_BITS 0x0D56
+#define GL_STENCIL_BITS 0x0D57
+#define GL_GENERATE_MIPMAP_HINT 0x8192
+#define GL_FIXED 0x140C
+#define GL_LUMINANCE 0x1909
+#define GL_LUMINANCE_ALPHA 0x190A
+#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
+#define GL_MAX_VARYING_VECTORS 0x8DFC
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+#define GL_SHADER_COMPILER 0x8DFA
+#define GL_SHADER_BINARY_FORMATS 0x8DF8
+#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9
+#define GL_LOW_FLOAT 0x8DF0
+#define GL_MEDIUM_FLOAT 0x8DF1
+#define GL_HIGH_FLOAT 0x8DF2
+#define GL_LOW_INT 0x8DF3
+#define GL_MEDIUM_INT 0x8DF4
+#define GL_HIGH_INT 0x8DF5
+#define GL_RGB565 0x8D62
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9
+#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
+#define GL_COPY_READ_BUFFER_BINDING 0x8F36
+#define GL_COPY_WRITE_BUFFER_BINDING 0x8F37
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
+#define GL_TRANSFORM_FEEDBACK 0x8E22
+#define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23
+#define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
+#define GL_PROGRAM_BINARY_LENGTH 0x8741
+#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
+#define GL_PROGRAM_BINARY_FORMATS 0x87FF
+#define GL_COMPRESSED_R11_EAC 0x9270
+#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
+#define GL_COMPRESSED_RG11_EAC 0x9272
+#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
+#define GL_COMPRESSED_RGB8_ETC2 0x9274
+#define GL_COMPRESSED_SRGB8_ETC2 0x9275
+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
+#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
+#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
+#define GL_MAX_ELEMENT_INDEX 0x8D6B
+#define GL_NUM_SAMPLE_COUNTS 0x9380
+#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
+#define GL_COMPUTE_SHADER 0x91B9
+#define GL_MAX_COMPUTE_UNIFORM_BLOCKS 0x91BB
+#define GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS 0x91BC
+#define GL_MAX_COMPUTE_IMAGE_UNIFORMS 0x91BD
+#define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE 0x8262
+#define GL_MAX_COMPUTE_UNIFORM_COMPONENTS 0x8263
+#define GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS 0x8264
+#define GL_MAX_COMPUTE_ATOMIC_COUNTERS 0x8265
+#define GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS 0x8266
+#define GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS 0x90EB
+#define GL_MAX_COMPUTE_WORK_GROUP_COUNT 0x91BE
+#define GL_MAX_COMPUTE_WORK_GROUP_SIZE 0x91BF
+#define GL_COMPUTE_WORK_GROUP_SIZE 0x8267
+#define GL_DISPATCH_INDIRECT_BUFFER 0x90EE
+#define GL_DISPATCH_INDIRECT_BUFFER_BINDING 0x90EF
+#define GL_COMPUTE_SHADER_BIT 0x00000020
+#define GL_DRAW_INDIRECT_BUFFER 0x8F3F
+#define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43
+#define GL_MAX_UNIFORM_LOCATIONS 0x826E
+#define GL_FRAMEBUFFER_DEFAULT_WIDTH 0x9310
+#define GL_FRAMEBUFFER_DEFAULT_HEIGHT 0x9311
+#define GL_FRAMEBUFFER_DEFAULT_SAMPLES 0x9313
+#define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS 0x9314
+#define GL_MAX_FRAMEBUFFER_WIDTH 0x9315
+#define GL_MAX_FRAMEBUFFER_HEIGHT 0x9316
+#define GL_MAX_FRAMEBUFFER_SAMPLES 0x9318
+#define GL_UNIFORM 0x92E1
+#define GL_UNIFORM_BLOCK 0x92E2
+#define GL_PROGRAM_INPUT 0x92E3
+#define GL_PROGRAM_OUTPUT 0x92E4
+#define GL_BUFFER_VARIABLE 0x92E5
+#define GL_SHADER_STORAGE_BLOCK 0x92E6
+#define GL_ATOMIC_COUNTER_BUFFER 0x92C0
+#define GL_TRANSFORM_FEEDBACK_VARYING 0x92F4
+#define GL_ACTIVE_RESOURCES 0x92F5
+#define GL_MAX_NAME_LENGTH 0x92F6
+#define GL_MAX_NUM_ACTIVE_VARIABLES 0x92F7
+#define GL_NAME_LENGTH 0x92F9
+#define GL_TYPE 0x92FA
+#define GL_ARRAY_SIZE 0x92FB
+#define GL_OFFSET 0x92FC
+#define GL_BLOCK_INDEX 0x92FD
+#define GL_ARRAY_STRIDE 0x92FE
+#define GL_MATRIX_STRIDE 0x92FF
+#define GL_IS_ROW_MAJOR 0x9300
+#define GL_ATOMIC_COUNTER_BUFFER_INDEX 0x9301
+#define GL_BUFFER_BINDING 0x9302
+#define GL_BUFFER_DATA_SIZE 0x9303
+#define GL_NUM_ACTIVE_VARIABLES 0x9304
+#define GL_ACTIVE_VARIABLES 0x9305
+#define GL_REFERENCED_BY_VERTEX_SHADER 0x9306
+#define GL_REFERENCED_BY_FRAGMENT_SHADER 0x930A
+#define GL_REFERENCED_BY_COMPUTE_SHADER 0x930B
+#define GL_TOP_LEVEL_ARRAY_SIZE 0x930C
+#define GL_TOP_LEVEL_ARRAY_STRIDE 0x930D
+#define GL_LOCATION 0x930E
+#define GL_VERTEX_SHADER_BIT 0x00000001
+#define GL_FRAGMENT_SHADER_BIT 0x00000002
+#define GL_ALL_SHADER_BITS 0xFFFFFFFF
+#define GL_PROGRAM_SEPARABLE 0x8258
+#define GL_ACTIVE_PROGRAM 0x8259
+#define GL_PROGRAM_PIPELINE_BINDING 0x825A
+#define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1
+#define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2
+#define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3
+#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC
+#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0
+#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1
+#define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2
+#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6
+#define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7
+#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8
+#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC
+#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9
+#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB
+#define GL_MAX_IMAGE_UNITS 0x8F38
+#define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA
+#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE
+#define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF
+#define GL_IMAGE_BINDING_NAME 0x8F3A
+#define GL_IMAGE_BINDING_LEVEL 0x8F3B
+#define GL_IMAGE_BINDING_LAYERED 0x8F3C
+#define GL_IMAGE_BINDING_LAYER 0x8F3D
+#define GL_IMAGE_BINDING_ACCESS 0x8F3E
+#define GL_IMAGE_BINDING_FORMAT 0x906E
+#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001
+#define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002
+#define GL_UNIFORM_BARRIER_BIT 0x00000004
+#define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008
+#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020
+#define GL_COMMAND_BARRIER_BIT 0x00000040
+#define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080
+#define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100
+#define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200
+#define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400
+#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800
+#define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000
+#define GL_ALL_BARRIER_BITS 0xFFFFFFFF
+#define GL_IMAGE_2D 0x904D
+#define GL_IMAGE_3D 0x904E
+#define GL_IMAGE_CUBE 0x9050
+#define GL_IMAGE_2D_ARRAY 0x9053
+#define GL_INT_IMAGE_2D 0x9058
+#define GL_INT_IMAGE_3D 0x9059
+#define GL_INT_IMAGE_CUBE 0x905B
+#define GL_INT_IMAGE_2D_ARRAY 0x905E
+#define GL_UNSIGNED_INT_IMAGE_2D 0x9063
+#define GL_UNSIGNED_INT_IMAGE_3D 0x9064
+#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066
+#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069
+#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7
+#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8
+#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9
+#define GL_SHADER_STORAGE_BUFFER 0x90D2
+#define GL_SHADER_STORAGE_BUFFER_BINDING 0x90D3
+#define GL_SHADER_STORAGE_BUFFER_START 0x90D4
+#define GL_SHADER_STORAGE_BUFFER_SIZE 0x90D5
+#define GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS 0x90D6
+#define GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS 0x90DA
+#define GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS 0x90DB
+#define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS 0x90DC
+#define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS 0x90DD
+#define GL_MAX_SHADER_STORAGE_BLOCK_SIZE 0x90DE
+#define GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT 0x90DF
+#define GL_SHADER_STORAGE_BARRIER_BIT 0x00002000
+#define GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES 0x8F39
+#define GL_DEPTH_STENCIL_TEXTURE_MODE 0x90EA
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F
+#define GL_VERTEX_ATTRIB_BINDING 0x82D4
+#define GL_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D5
+#define GL_VERTEX_BINDING_DIVISOR 0x82D6
+#define GL_VERTEX_BINDING_OFFSET 0x82D7
+#define GL_VERTEX_BINDING_STRIDE 0x82D8
+#define GL_VERTEX_BINDING_BUFFER 0x8F4F
+#define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9
+#define GL_MAX_VERTEX_ATTRIB_BINDINGS 0x82DA
+#define GL_MAX_VERTEX_ATTRIB_STRIDE 0x82E5
+#ifndef GL_VERSION_1_0
+#define GL_VERSION_1_0 1
+GLAPI int GLAD_GL_VERSION_1_0;
+typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode);
+GLAPI PFNGLCULLFACEPROC glad_glCullFace;
+#define glCullFace glad_glCullFace
+typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode);
+GLAPI PFNGLFRONTFACEPROC glad_glFrontFace;
+#define glFrontFace glad_glFrontFace
+typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode);
+GLAPI PFNGLHINTPROC glad_glHint;
+#define glHint glad_glHint
+typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width);
+GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth;
+#define glLineWidth glad_glLineWidth
+typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size);
+GLAPI PFNGLPOINTSIZEPROC glad_glPointSize;
+#define glPointSize glad_glPointSize
+typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);
+GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode;
+#define glPolygonMode glad_glPolygonMode
+typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI PFNGLSCISSORPROC glad_glScissor;
+#define glScissor glad_glScissor
+typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
+GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
+#define glTexParameterf glad_glTexParameterf
+typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
+GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
+#define glTexParameterfv glad_glTexParameterfv
+typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
+#define glTexParameteri glad_glTexParameteri
+typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params);
+GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
+#define glTexParameteriv glad_glTexParameteriv
+typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
+#define glTexImage1D glad_glTexImage1D
+typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
+#define glTexImage2D glad_glTexImage2D
+typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf);
+GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
+#define glDrawBuffer glad_glDrawBuffer
+typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask);
+GLAPI PFNGLCLEARPROC glad_glClear;
+#define glClear glad_glClear
+typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI PFNGLCLEARCOLORPROC glad_glClearColor;
+#define glClearColor glad_glClearColor
+typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s);
+GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil;
+#define glClearStencil glad_glClearStencil
+typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth);
+GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth;
+#define glClearDepth glad_glClearDepth
+typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask);
+GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask;
+#define glStencilMask glad_glStencilMask
+typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+GLAPI PFNGLCOLORMASKPROC glad_glColorMask;
+#define glColorMask glad_glColorMask
+typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag);
+GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask;
+#define glDepthMask glad_glDepthMask
+typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap);
+GLAPI PFNGLDISABLEPROC glad_glDisable;
+#define glDisable glad_glDisable
+typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap);
+GLAPI PFNGLENABLEPROC glad_glEnable;
+#define glEnable glad_glEnable
+typedef void (APIENTRYP PFNGLFINISHPROC)(void);
+GLAPI PFNGLFINISHPROC glad_glFinish;
+#define glFinish glad_glFinish
+typedef void (APIENTRYP PFNGLFLUSHPROC)(void);
+GLAPI PFNGLFLUSHPROC glad_glFlush;
+#define glFlush glad_glFlush
+typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
+GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc;
+#define glBlendFunc glad_glBlendFunc
+typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode);
+GLAPI PFNGLLOGICOPPROC glad_glLogicOp;
+#define glLogicOp glad_glLogicOp
+typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
+GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc;
+#define glStencilFunc glad_glStencilFunc
+typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
+GLAPI PFNGLSTENCILOPPROC glad_glStencilOp;
+#define glStencilOp glad_glStencilOp
+typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func);
+GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc;
+#define glDepthFunc glad_glDepthFunc
+typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);
+GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref;
+#define glPixelStoref glad_glPixelStoref
+typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
+GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei;
+#define glPixelStorei glad_glPixelStorei
+typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src);
+GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer;
+#define glReadBuffer glad_glReadBuffer
+typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+GLAPI PFNGLREADPIXELSPROC glad_glReadPixels;
+#define glReadPixels glad_glReadPixels
+typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data);
+GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
+#define glGetBooleanv glad_glGetBooleanv
+typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data);
+GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev;
+#define glGetDoublev glad_glGetDoublev
+typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void);
+GLAPI PFNGLGETERRORPROC glad_glGetError;
+#define glGetError glad_glGetError
+typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data);
+GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv;
+#define glGetFloatv glad_glGetFloatv
+typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data);
+GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv;
+#define glGetIntegerv glad_glGetIntegerv
+typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name);
+GLAPI PFNGLGETSTRINGPROC glad_glGetString;
+#define glGetString glad_glGetString
+typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
+GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
+#define glGetTexImage glad_glGetTexImage
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
+#define glGetTexParameterfv glad_glGetTexParameterfv
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
+#define glGetTexParameteriv glad_glGetTexParameteriv
+typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
+#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv
+typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params);
+GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
+#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv
+typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap);
+GLAPI PFNGLISENABLEDPROC glad_glIsEnabled;
+#define glIsEnabled glad_glIsEnabled
+typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);
+GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange;
+#define glDepthRange glad_glDepthRange
+typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI PFNGLVIEWPORTPROC glad_glViewport;
+#define glViewport glad_glViewport
+#endif
+#ifndef GL_VERSION_1_1
+#define GL_VERSION_1_1 1
+GLAPI int GLAD_GL_VERSION_1_1;
+typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
+GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays;
+#define glDrawArrays glad_glDrawArrays
+typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices);
+GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements;
+#define glDrawElements glad_glDrawElements
+typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
+GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
+#define glPolygonOffset glad_glPolygonOffset
+typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
+#define glCopyTexImage1D glad_glCopyTexImage1D
+typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
+#define glCopyTexImage2D glad_glCopyTexImage2D
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+#define glCopyTexSubImage1D glad_glCopyTexSubImage1D
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
+#define glCopyTexSubImage2D glad_glCopyTexSubImage2D
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
+#define glTexSubImage1D glad_glTexSubImage1D
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
+#define glTexSubImage2D glad_glTexSubImage2D
+typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
+GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture;
+#define glBindTexture glad_glBindTexture
+typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures);
+GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
+#define glDeleteTextures glad_glDeleteTextures
+typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures);
+GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures;
+#define glGenTextures glad_glGenTextures
+typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture);
+GLAPI PFNGLISTEXTUREPROC glad_glIsTexture;
+#define glIsTexture glad_glIsTexture
+#endif
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+GLAPI int GLAD_GL_VERSION_1_2;
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
+GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
+#define glDrawRangeElements glad_glDrawRangeElements
+typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
+#define glTexImage3D glad_glTexImage3D
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
+#define glTexSubImage3D glad_glTexSubImage3D
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+#define glCopyTexSubImage3D glad_glCopyTexSubImage3D
+#endif
+#ifndef GL_VERSION_1_3
+#define GL_VERSION_1_3 1
+GLAPI int GLAD_GL_VERSION_1_3;
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture);
+GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
+#define glActiveTexture glad_glActiveTexture
+typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
+GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
+#define glSampleCoverage glad_glSampleCoverage
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
+#define glCompressedTexImage3D glad_glCompressedTexImage3D
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
+#define glCompressedTexImage2D glad_glCompressedTexImage2D
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
+#define glCompressedTexImage1D glad_glCompressedTexImage1D
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
+#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
+#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
+#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img);
+GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
+#define glGetCompressedTexImage glad_glGetCompressedTexImage
+#endif
+#ifndef GL_VERSION_1_4
+#define GL_VERSION_1_4 1
+GLAPI int GLAD_GL_VERSION_1_4;
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
+#define glBlendFuncSeparate glad_glBlendFuncSeparate
+typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
+GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
+#define glMultiDrawArrays glad_glMultiDrawArrays
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount);
+GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
+#define glMultiDrawElements glad_glMultiDrawElements
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);
+GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
+#define glPointParameterf glad_glPointParameterf
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params);
+GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+#define glPointParameterfv glad_glPointParameterfv
+typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);
+GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
+#define glPointParameteri glad_glPointParameteri
+typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params);
+GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
+#define glPointParameteriv glad_glPointParameteriv
+typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor;
+#define glBlendColor glad_glBlendColor
+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode);
+GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
+#define glBlendEquation glad_glBlendEquation
+#endif
+#ifndef GL_VERSION_1_5
+#define GL_VERSION_1_5 1
+GLAPI int GLAD_GL_VERSION_1_5;
+typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids);
+GLAPI PFNGLGENQUERIESPROC glad_glGenQueries;
+#define glGenQueries glad_glGenQueries
+typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids);
+GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
+#define glDeleteQueries glad_glDeleteQueries
+typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id);
+GLAPI PFNGLISQUERYPROC glad_glIsQuery;
+#define glIsQuery glad_glIsQuery
+typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);
+GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery;
+#define glBeginQuery glad_glBeginQuery
+typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target);
+GLAPI PFNGLENDQUERYPROC glad_glEndQuery;
+#define glEndQuery glad_glEndQuery
+typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv;
+#define glGetQueryiv glad_glGetQueryiv
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params);
+GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
+#define glGetQueryObjectiv glad_glGetQueryObjectiv
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params);
+GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
+#define glGetQueryObjectuiv glad_glGetQueryObjectuiv
+typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
+GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer;
+#define glBindBuffer glad_glBindBuffer
+typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers);
+GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
+#define glDeleteBuffers glad_glDeleteBuffers
+typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers);
+GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers;
+#define glGenBuffers glad_glGenBuffers
+typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer);
+GLAPI PFNGLISBUFFERPROC glad_glIsBuffer;
+#define glIsBuffer glad_glIsBuffer
+typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+GLAPI PFNGLBUFFERDATAPROC glad_glBufferData;
+#define glBufferData glad_glBufferData
+typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
+GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
+#define glBufferSubData glad_glBufferSubData
+typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
+GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
+#define glGetBufferSubData glad_glGetBufferSubData
+typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);
+GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer;
+#define glMapBuffer glad_glMapBuffer
+typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target);
+GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
+#define glUnmapBuffer glad_glUnmapBuffer
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
+#define glGetBufferParameteriv glad_glGetBufferParameteriv
+typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params);
+GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
+#define glGetBufferPointerv glad_glGetBufferPointerv
+#endif
+#ifndef GL_VERSION_2_0
+#define GL_VERSION_2_0 1
+GLAPI int GLAD_GL_VERSION_2_0;
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
+GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
+#define glBlendEquationSeparate glad_glBlendEquationSeparate
+typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs);
+GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
+#define glDrawBuffers glad_glDrawBuffers
+typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
+#define glStencilOpSeparate glad_glStencilOpSeparate
+typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
+GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
+#define glStencilFuncSeparate glad_glStencilFuncSeparate
+typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
+GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
+#define glStencilMaskSeparate glad_glStencilMaskSeparate
+typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
+GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader;
+#define glAttachShader glad_glAttachShader
+typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name);
+GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
+#define glBindAttribLocation glad_glBindAttribLocation
+typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader);
+GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader;
+#define glCompileShader glad_glCompileShader
+typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void);
+GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
+#define glCreateProgram glad_glCreateProgram
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type);
+GLAPI PFNGLCREATESHADERPROC glad_glCreateShader;
+#define glCreateShader glad_glCreateShader
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program);
+GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
+#define glDeleteProgram glad_glDeleteProgram
+typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader);
+GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader;
+#define glDeleteShader glad_glDeleteShader
+typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
+GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader;
+#define glDetachShader glad_glDetachShader
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
+#define glDisableVertexAttribArray glad_glDisableVertexAttribArray
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
+#define glEnableVertexAttribArray glad_glEnableVertexAttribArray
+typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
+#define glGetActiveAttrib glad_glGetActiveAttrib
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
+#define glGetActiveUniform glad_glGetActiveUniform
+typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
+#define glGetAttachedShaders glad_glGetAttachedShaders
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name);
+GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
+#define glGetAttribLocation glad_glGetAttribLocation
+typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params);
+GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
+#define glGetProgramiv glad_glGetProgramiv
+typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
+#define glGetProgramInfoLog glad_glGetProgramInfoLog
+typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params);
+GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv;
+#define glGetShaderiv glad_glGetShaderiv
+typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
+#define glGetShaderInfoLog glad_glGetShaderInfoLog
+typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+#define glGetShaderSource glad_glGetShaderSource
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name);
+GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
+#define glGetUniformLocation glad_glGetUniformLocation
+typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params);
+GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
+#define glGetUniformfv glad_glGetUniformfv
+typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params);
+GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
+#define glGetUniformiv glad_glGetUniformiv
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params);
+GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
+#define glGetVertexAttribdv glad_glGetVertexAttribdv
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
+#define glGetVertexAttribfv glad_glGetVertexAttribfv
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params);
+GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
+#define glGetVertexAttribiv glad_glGetVertexAttribiv
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer);
+GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
+#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program);
+GLAPI PFNGLISPROGRAMPROC glad_glIsProgram;
+#define glIsProgram glad_glIsProgram
+typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader);
+GLAPI PFNGLISSHADERPROC glad_glIsShader;
+#define glIsShader glad_glIsShader
+typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program);
+GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram;
+#define glLinkProgram glad_glLinkProgram
+typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource;
+#define glShaderSource glad_glShaderSource
+typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program);
+GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram;
+#define glUseProgram glad_glUseProgram
+typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
+GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f;
+#define glUniform1f glad_glUniform1f
+typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
+GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f;
+#define glUniform2f glad_glUniform2f
+typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f;
+#define glUniform3f glad_glUniform3f
+typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f;
+#define glUniform4f glad_glUniform4f
+typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
+GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i;
+#define glUniform1i glad_glUniform1i
+typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
+GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i;
+#define glUniform2i glad_glUniform2i
+typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i;
+#define glUniform3i glad_glUniform3i
+typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i;
+#define glUniform4i glad_glUniform4i
+typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv;
+#define glUniform1fv glad_glUniform1fv
+typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv;
+#define glUniform2fv glad_glUniform2fv
+typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv;
+#define glUniform3fv glad_glUniform3fv
+typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv;
+#define glUniform4fv glad_glUniform4fv
+typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv;
+#define glUniform1iv glad_glUniform1iv
+typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv;
+#define glUniform2iv glad_glUniform2iv
+typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv;
+#define glUniform3iv glad_glUniform3iv
+typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv;
+#define glUniform4iv glad_glUniform4iv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
+#define glUniformMatrix2fv glad_glUniformMatrix2fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
+#define glUniformMatrix3fv glad_glUniformMatrix3fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
+#define glUniformMatrix4fv glad_glUniformMatrix4fv
+typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program);
+GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
+#define glValidateProgram glad_glValidateProgram
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);
+GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
+#define glVertexAttrib1d glad_glVertexAttrib1d
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v);
+GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
+#define glVertexAttrib1dv glad_glVertexAttrib1dv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
+GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
+#define glVertexAttrib1f glad_glVertexAttrib1f
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v);
+GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
+#define glVertexAttrib1fv glad_glVertexAttrib1fv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);
+GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
+#define glVertexAttrib1s glad_glVertexAttrib1s
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
+#define glVertexAttrib1sv glad_glVertexAttrib1sv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);
+GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
+#define glVertexAttrib2d glad_glVertexAttrib2d
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v);
+GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
+#define glVertexAttrib2dv glad_glVertexAttrib2dv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
+GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
+#define glVertexAttrib2f glad_glVertexAttrib2f
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v);
+GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+#define glVertexAttrib2fv glad_glVertexAttrib2fv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);
+GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
+#define glVertexAttrib2s glad_glVertexAttrib2s
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
+#define glVertexAttrib2sv glad_glVertexAttrib2sv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
+#define glVertexAttrib3d glad_glVertexAttrib3d
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v);
+GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
+#define glVertexAttrib3dv glad_glVertexAttrib3dv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
+#define glVertexAttrib3f glad_glVertexAttrib3f
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v);
+GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+#define glVertexAttrib3fv glad_glVertexAttrib3fv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
+GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
+#define glVertexAttrib3s glad_glVertexAttrib3s
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
+#define glVertexAttrib3sv glad_glVertexAttrib3sv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v);
+GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
+#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
+#define glVertexAttrib4Niv glad_glVertexAttrib4Niv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
+#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
+#define glVertexAttrib4Nub glad_glVertexAttrib4Nub
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v);
+GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
+#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
+#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v);
+GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
+#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v);
+GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
+#define glVertexAttrib4bv glad_glVertexAttrib4bv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
+#define glVertexAttrib4d glad_glVertexAttrib4d
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v);
+GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
+#define glVertexAttrib4dv glad_glVertexAttrib4dv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
+#define glVertexAttrib4f glad_glVertexAttrib4f
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v);
+GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
+#define glVertexAttrib4fv glad_glVertexAttrib4fv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
+#define glVertexAttrib4iv glad_glVertexAttrib4iv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
+#define glVertexAttrib4s glad_glVertexAttrib4s
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
+#define glVertexAttrib4sv glad_glVertexAttrib4sv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v);
+GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
+#define glVertexAttrib4ubv glad_glVertexAttrib4ubv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
+#define glVertexAttrib4uiv glad_glVertexAttrib4uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v);
+GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
+#define glVertexAttrib4usv glad_glVertexAttrib4usv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
+#define glVertexAttribPointer glad_glVertexAttribPointer
+#endif
+#ifndef GL_VERSION_2_1
+#define GL_VERSION_2_1 1
+GLAPI int GLAD_GL_VERSION_2_1;
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
+#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
+#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
+#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
+#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
+#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
+#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv
+#endif
+#ifndef GL_VERSION_3_0
+#define GL_VERSION_3_0 1
+GLAPI int GLAD_GL_VERSION_3_0;
+typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski;
+#define glColorMaski glad_glColorMaski
+typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data);
+GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
+#define glGetBooleani_v glad_glGetBooleani_v
+typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data);
+GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
+#define glGetIntegeri_v glad_glGetIntegeri_v
+typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index);
+GLAPI PFNGLENABLEIPROC glad_glEnablei;
+#define glEnablei glad_glEnablei
+typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index);
+GLAPI PFNGLDISABLEIPROC glad_glDisablei;
+#define glDisablei glad_glDisablei
+typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index);
+GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi;
+#define glIsEnabledi glad_glIsEnabledi
+typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);
+GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
+#define glBeginTransformFeedback glad_glBeginTransformFeedback
+typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void);
+GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
+#define glEndTransformFeedback glad_glEndTransformFeedback
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
+#define glBindBufferRange glad_glBindBufferRange
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);
+GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
+#define glBindBufferBase glad_glBindBufferBase
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
+GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
+#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying
+typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);
+GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor;
+#define glClampColor glad_glClampColor
+typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);
+GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
+#define glBeginConditionalRender glad_glBeginConditionalRender
+typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void);
+GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
+#define glEndConditionalRender glad_glEndConditionalRender
+typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
+#define glVertexAttribIPointer glad_glVertexAttribIPointer
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params);
+GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
+#define glGetVertexAttribIiv glad_glGetVertexAttribIiv
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params);
+GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
+#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);
+GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
+#define glVertexAttribI1i glad_glVertexAttribI1i
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);
+GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
+#define glVertexAttribI2i glad_glVertexAttribI2i
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);
+GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
+#define glVertexAttribI3i glad_glVertexAttribI3i
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
+#define glVertexAttribI4i glad_glVertexAttribI4i
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);
+GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
+#define glVertexAttribI1ui glad_glVertexAttribI1ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);
+GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
+#define glVertexAttribI2ui glad_glVertexAttribI2ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
+GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
+#define glVertexAttribI3ui glad_glVertexAttribI3ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
+#define glVertexAttribI4ui glad_glVertexAttribI4ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
+#define glVertexAttribI1iv glad_glVertexAttribI1iv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
+#define glVertexAttribI2iv glad_glVertexAttribI2iv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
+#define glVertexAttribI3iv glad_glVertexAttribI3iv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v);
+GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
+#define glVertexAttribI4iv glad_glVertexAttribI4iv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
+#define glVertexAttribI1uiv glad_glVertexAttribI1uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
+#define glVertexAttribI2uiv glad_glVertexAttribI2uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
+#define glVertexAttribI3uiv glad_glVertexAttribI3uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v);
+GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
+#define glVertexAttribI4uiv glad_glVertexAttribI4uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v);
+GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
+#define glVertexAttribI4bv glad_glVertexAttribI4bv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v);
+GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
+#define glVertexAttribI4sv glad_glVertexAttribI4sv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v);
+GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
+#define glVertexAttribI4ubv glad_glVertexAttribI4ubv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v);
+GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
+#define glVertexAttribI4usv glad_glVertexAttribI4usv
+typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params);
+GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
+#define glGetUniformuiv glad_glGetUniformuiv
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name);
+GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
+#define glBindFragDataLocation glad_glBindFragDataLocation
+typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name);
+GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
+#define glGetFragDataLocation glad_glGetFragDataLocation
+typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
+GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui;
+#define glUniform1ui glad_glUniform1ui
+typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);
+GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui;
+#define glUniform2ui glad_glUniform2ui
+typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui;
+#define glUniform3ui glad_glUniform3ui
+typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui;
+#define glUniform4ui glad_glUniform4ui
+typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
+#define glUniform1uiv glad_glUniform1uiv
+typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
+#define glUniform2uiv glad_glUniform2uiv
+typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
+#define glUniform3uiv glad_glUniform3uiv
+typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
+#define glUniform4uiv glad_glUniform4uiv
+typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params);
+GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
+#define glTexParameterIiv glad_glTexParameterIiv
+typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params);
+GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
+#define glTexParameterIuiv glad_glTexParameterIuiv
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
+#define glGetTexParameterIiv glad_glGetTexParameterIiv
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params);
+GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
+#define glGetTexParameterIuiv glad_glGetTexParameterIuiv
+typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value);
+GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
+#define glClearBufferiv glad_glClearBufferiv
+typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value);
+GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+#define glClearBufferuiv glad_glClearBufferuiv
+typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
+#define glClearBufferfv glad_glClearBufferfv
+typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
+#define glClearBufferfi glad_glClearBufferfi
+typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
+GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi;
+#define glGetStringi glad_glGetStringi
+typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
+GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
+#define glIsRenderbuffer glad_glIsRenderbuffer
+typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
+GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
+#define glBindRenderbuffer glad_glBindRenderbuffer
+typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers);
+GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
+#define glDeleteRenderbuffers glad_glDeleteRenderbuffers
+typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers);
+GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
+#define glGenRenderbuffers glad_glGenRenderbuffers
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
+#define glRenderbufferStorage glad_glRenderbufferStorage
+typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
+#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv
+typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
+GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+#define glIsFramebuffer glad_glIsFramebuffer
+typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
+GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
+#define glBindFramebuffer glad_glBindFramebuffer
+typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers);
+GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
+#define glDeleteFramebuffers glad_glDeleteFramebuffers
+typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers);
+GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
+#define glGenFramebuffers glad_glGenFramebuffers
+typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
+GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
+#define glCheckFramebufferStatus glad_glCheckFramebufferStatus
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
+#define glFramebufferTexture1D glad_glFramebufferTexture1D
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
+#define glFramebufferTexture2D glad_glFramebufferTexture2D
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
+#define glFramebufferTexture3D glad_glFramebufferTexture3D
+typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
+#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
+GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
+#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv
+typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target);
+GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
+#define glGenerateMipmap glad_glGenerateMipmap
+typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
+#define glBlitFramebuffer glad_glBlitFramebuffer
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
+#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
+#define glFramebufferTextureLayer glad_glFramebufferTextureLayer
+typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
+#define glMapBufferRange glad_glMapBufferRange
+typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);
+GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
+#define glFlushMappedBufferRange glad_glFlushMappedBufferRange
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array);
+GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
+#define glBindVertexArray glad_glBindVertexArray
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays);
+GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
+#define glDeleteVertexArrays glad_glDeleteVertexArrays
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays);
+GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
+#define glGenVertexArrays glad_glGenVertexArrays
+typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array);
+GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+#define glIsVertexArray glad_glIsVertexArray
+#endif
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+GLAPI int GLAD_GL_VERSION_3_1;
+typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
+#define glDrawArraysInstanced glad_glDrawArraysInstanced
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
+GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
+#define glDrawElementsInstanced glad_glDrawElementsInstanced
+typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);
+GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer;
+#define glTexBuffer glad_glTexBuffer
+typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);
+GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
+#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex
+typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
+#define glCopyBufferSubData glad_glCopyBufferSubData
+typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
+GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
+#define glGetUniformIndices glad_glGetUniformIndices
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
+#define glGetActiveUniformsiv glad_glGetActiveUniformsiv
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
+#define glGetActiveUniformName glad_glGetActiveUniformName
+typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName);
+GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
+#define glGetUniformBlockIndex glad_glGetUniformBlockIndex
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
+#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
+#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName
+typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
+#define glUniformBlockBinding glad_glUniformBlockBinding
+#endif
+#ifndef GL_VERSION_3_2
+#define GL_VERSION_3_2 1
+GLAPI int GLAD_GL_VERSION_3_2;
+typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
+#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
+#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
+GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
+#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex);
+GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
+#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex
+typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode);
+GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
+#define glProvokingVertex glad_glProvokingVertex
+typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);
+GLAPI PFNGLFENCESYNCPROC glad_glFenceSync;
+#define glFenceSync glad_glFenceSync
+typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync);
+GLAPI PFNGLISSYNCPROC glad_glIsSync;
+#define glIsSync glad_glIsSync
+typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync);
+GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync;
+#define glDeleteSync glad_glDeleteSync
+typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
+#define glClientWaitSync glad_glClientWaitSync
+typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+GLAPI PFNGLWAITSYNCPROC glad_glWaitSync;
+#define glWaitSync glad_glWaitSync
+typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data);
+GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
+#define glGetInteger64v glad_glGetInteger64v
+typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values);
+GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv;
+#define glGetSynciv glad_glGetSynciv
+typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data);
+GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
+#define glGetInteger64i_v glad_glGetInteger64i_v
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params);
+GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
+#define glGetBufferParameteri64v glad_glGetBufferParameteri64v
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
+#define glFramebufferTexture glad_glFramebufferTexture
+typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
+#define glTexImage2DMultisample glad_glTexImage2DMultisample
+typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
+#define glTexImage3DMultisample glad_glTexImage3DMultisample
+typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val);
+GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
+#define glGetMultisamplefv glad_glGetMultisamplefv
+typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);
+GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
+#define glSampleMaski glad_glSampleMaski
+#endif
+#ifndef GL_VERSION_3_3
+#define GL_VERSION_3_3 1
+GLAPI int GLAD_GL_VERSION_3_3;
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
+GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
+#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed
+typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name);
+GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
+#define glGetFragDataIndex glad_glGetFragDataIndex
+typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers);
+GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers;
+#define glGenSamplers glad_glGenSamplers
+typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers);
+GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
+#define glDeleteSamplers glad_glDeleteSamplers
+typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler);
+GLAPI PFNGLISSAMPLERPROC glad_glIsSampler;
+#define glIsSampler glad_glIsSampler
+typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler);
+GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler;
+#define glBindSampler glad_glBindSampler
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param);
+GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
+#define glSamplerParameteri glad_glSamplerParameteri
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
+GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
+#define glSamplerParameteriv glad_glSamplerParameteriv
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param);
+GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
+#define glSamplerParameterf glad_glSamplerParameterf
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param);
+GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
+#define glSamplerParameterfv glad_glSamplerParameterfv
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
+GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
+#define glSamplerParameterIiv glad_glSamplerParameterIiv
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param);
+GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
+#define glSamplerParameterIuiv glad_glSamplerParameterIuiv
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params);
+GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
+#define glGetSamplerParameteriv glad_glGetSamplerParameteriv
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params);
+GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
+#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
+#define glGetSamplerParameterfv glad_glGetSamplerParameterfv
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params);
+GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
+#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv
+typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target);
+GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
+#define glQueryCounter glad_glQueryCounter
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params);
+GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
+#define glGetQueryObjecti64v glad_glGetQueryObjecti64v
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params);
+GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
+#define glGetQueryObjectui64v glad_glGetQueryObjectui64v
+typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor);
+GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
+#define glVertexAttribDivisor glad_glVertexAttribDivisor
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
+#define glVertexAttribP1ui glad_glVertexAttribP1ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
+#define glVertexAttribP1uiv glad_glVertexAttribP1uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
+#define glVertexAttribP2ui glad_glVertexAttribP2ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
+#define glVertexAttribP2uiv glad_glVertexAttribP2uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
+#define glVertexAttribP3ui glad_glVertexAttribP3ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
+#define glVertexAttribP3uiv glad_glVertexAttribP3uiv
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
+#define glVertexAttribP4ui glad_glVertexAttribP4ui
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
+#define glVertexAttribP4uiv glad_glVertexAttribP4uiv
+typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value);
+GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
+#define glVertexP2ui glad_glVertexP2ui
+typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value);
+GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
+#define glVertexP2uiv glad_glVertexP2uiv
+typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value);
+GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
+#define glVertexP3ui glad_glVertexP3ui
+typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value);
+GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
+#define glVertexP3uiv glad_glVertexP3uiv
+typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value);
+GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
+#define glVertexP4ui glad_glVertexP4ui
+typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value);
+GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
+#define glVertexP4uiv glad_glVertexP4uiv
+typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords);
+GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
+#define glTexCoordP1ui glad_glTexCoordP1ui
+typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords);
+GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
+#define glTexCoordP1uiv glad_glTexCoordP1uiv
+typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords);
+GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
+#define glTexCoordP2ui glad_glTexCoordP2ui
+typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords);
+GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
+#define glTexCoordP2uiv glad_glTexCoordP2uiv
+typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords);
+GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
+#define glTexCoordP3ui glad_glTexCoordP3ui
+typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords);
+GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
+#define glTexCoordP3uiv glad_glTexCoordP3uiv
+typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords);
+GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
+#define glTexCoordP4ui glad_glTexCoordP4ui
+typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords);
+GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
+#define glTexCoordP4uiv glad_glTexCoordP4uiv
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords);
+GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
+#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
+#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords);
+GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
+#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
+#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords);
+GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
+#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
+#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords);
+GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
+#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
+#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv
+typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords);
+GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui;
+#define glNormalP3ui glad_glNormalP3ui
+typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords);
+GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
+#define glNormalP3uiv glad_glNormalP3uiv
+typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color);
+GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui;
+#define glColorP3ui glad_glColorP3ui
+typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color);
+GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
+#define glColorP3uiv glad_glColorP3uiv
+typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color);
+GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui;
+#define glColorP4ui glad_glColorP4ui
+typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color);
+GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
+#define glColorP4uiv glad_glColorP4uiv
+typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color);
+GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
+#define glSecondaryColorP3ui glad_glSecondaryColorP3ui
+typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color);
+GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
+#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv
+#endif
+#ifndef GL_ES_VERSION_2_0
+#define GL_ES_VERSION_2_0 1
+GLAPI int GLAD_GL_ES_VERSION_2_0;
+typedef void (APIENTRYP PFNGLCLEARDEPTHFPROC)(GLfloat d);
+GLAPI PFNGLCLEARDEPTHFPROC glad_glClearDepthf;
+#define glClearDepthf glad_glClearDepthf
+typedef void (APIENTRYP PFNGLDEPTHRANGEFPROC)(GLfloat n, GLfloat f);
+GLAPI PFNGLDEPTHRANGEFPROC glad_glDepthRangef;
+#define glDepthRangef glad_glDepthRangef
+typedef void (APIENTRYP PFNGLGETSHADERPRECISIONFORMATPROC)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+GLAPI PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat;
+#define glGetShaderPrecisionFormat glad_glGetShaderPrecisionFormat
+typedef void (APIENTRYP PFNGLRELEASESHADERCOMPILERPROC)(void);
+GLAPI PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler;
+#define glReleaseShaderCompiler glad_glReleaseShaderCompiler
+typedef void (APIENTRYP PFNGLSHADERBINARYPROC)(GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length);
+GLAPI PFNGLSHADERBINARYPROC glad_glShaderBinary;
+#define glShaderBinary glad_glShaderBinary
+#endif
+#ifndef GL_ES_VERSION_3_0
+#define GL_ES_VERSION_3_0 1
+GLAPI int GLAD_GL_ES_VERSION_3_0;
+typedef void (APIENTRYP PFNGLBINDTRANSFORMFEEDBACKPROC)(GLenum target, GLuint id);
+GLAPI PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback;
+#define glBindTransformFeedback glad_glBindTransformFeedback
+typedef void (APIENTRYP PFNGLDELETETRANSFORMFEEDBACKSPROC)(GLsizei n, const GLuint *ids);
+GLAPI PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks;
+#define glDeleteTransformFeedbacks glad_glDeleteTransformFeedbacks
+typedef void (APIENTRYP PFNGLGENTRANSFORMFEEDBACKSPROC)(GLsizei n, GLuint *ids);
+GLAPI PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks;
+#define glGenTransformFeedbacks glad_glGenTransformFeedbacks
+typedef GLboolean (APIENTRYP PFNGLISTRANSFORMFEEDBACKPROC)(GLuint id);
+GLAPI PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback;
+#define glIsTransformFeedback glad_glIsTransformFeedback
+typedef void (APIENTRYP PFNGLPAUSETRANSFORMFEEDBACKPROC)(void);
+GLAPI PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback;
+#define glPauseTransformFeedback glad_glPauseTransformFeedback
+typedef void (APIENTRYP PFNGLRESUMETRANSFORMFEEDBACKPROC)(void);
+GLAPI PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback;
+#define glResumeTransformFeedback glad_glResumeTransformFeedback
+typedef void (APIENTRYP PFNGLGETPROGRAMBINARYPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
+GLAPI PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary;
+#define glGetProgramBinary glad_glGetProgramBinary
+typedef void (APIENTRYP PFNGLPROGRAMBINARYPROC)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
+GLAPI PFNGLPROGRAMBINARYPROC glad_glProgramBinary;
+#define glProgramBinary glad_glProgramBinary
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERIPROC)(GLuint program, GLenum pname, GLint value);
+GLAPI PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri;
+#define glProgramParameteri glad_glProgramParameteri
+typedef void (APIENTRYP PFNGLINVALIDATEFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
+GLAPI PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer;
+#define glInvalidateFramebuffer glad_glInvalidateFramebuffer
+typedef void (APIENTRYP PFNGLINVALIDATESUBFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer;
+#define glInvalidateSubFramebuffer glad_glInvalidateSubFramebuffer
+typedef void (APIENTRYP PFNGLTEXSTORAGE2DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D;
+#define glTexStorage2D glad_glTexStorage2D
+typedef void (APIENTRYP PFNGLTEXSTORAGE3DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+GLAPI PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D;
+#define glTexStorage3D glad_glTexStorage3D
+typedef void (APIENTRYP PFNGLGETINTERNALFORMATIVPROC)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint *params);
+GLAPI PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
+#define glGetInternalformativ glad_glGetInternalformativ
+#endif
+#ifndef GL_ES_VERSION_3_1
+#define GL_ES_VERSION_3_1 1
+GLAPI int GLAD_GL_ES_VERSION_3_1;
+typedef void (APIENTRYP PFNGLDISPATCHCOMPUTEPROC)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
+GLAPI PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute;
+#define glDispatchCompute glad_glDispatchCompute
+typedef void (APIENTRYP PFNGLDISPATCHCOMPUTEINDIRECTPROC)(GLintptr indirect);
+GLAPI PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect;
+#define glDispatchComputeIndirect glad_glDispatchComputeIndirect
+typedef void (APIENTRYP PFNGLDRAWARRAYSINDIRECTPROC)(GLenum mode, const void *indirect);
+GLAPI PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect;
+#define glDrawArraysIndirect glad_glDrawArraysIndirect
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINDIRECTPROC)(GLenum mode, GLenum type, const void *indirect);
+GLAPI PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect;
+#define glDrawElementsIndirect glad_glDrawElementsIndirect
+typedef void (APIENTRYP PFNGLFRAMEBUFFERPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+GLAPI PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri;
+#define glFramebufferParameteri glad_glFramebufferParameteri
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv;
+#define glGetFramebufferParameteriv glad_glGetFramebufferParameteriv
+typedef void (APIENTRYP PFNGLGETPROGRAMINTERFACEIVPROC)(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
+GLAPI PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv;
+#define glGetProgramInterfaceiv glad_glGetProgramInterfaceiv
+typedef GLuint (APIENTRYP PFNGLGETPROGRAMRESOURCEINDEXPROC)(GLuint program, GLenum programInterface, const GLchar *name);
+GLAPI PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex;
+#define glGetProgramResourceIndex glad_glGetProgramResourceIndex
+typedef void (APIENTRYP PFNGLGETPROGRAMRESOURCENAMEPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
+GLAPI PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName;
+#define glGetProgramResourceName glad_glGetProgramResourceName
+typedef void (APIENTRYP PFNGLGETPROGRAMRESOURCEIVPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei count, GLsizei *length, GLint *params);
+GLAPI PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv;
+#define glGetProgramResourceiv glad_glGetProgramResourceiv
+typedef GLint (APIENTRYP PFNGLGETPROGRAMRESOURCELOCATIONPROC)(GLuint program, GLenum programInterface, const GLchar *name);
+GLAPI PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation;
+#define glGetProgramResourceLocation glad_glGetProgramResourceLocation
+typedef void (APIENTRYP PFNGLUSEPROGRAMSTAGESPROC)(GLuint pipeline, GLbitfield stages, GLuint program);
+GLAPI PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages;
+#define glUseProgramStages glad_glUseProgramStages
+typedef void (APIENTRYP PFNGLACTIVESHADERPROGRAMPROC)(GLuint pipeline, GLuint program);
+GLAPI PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram;
+#define glActiveShaderProgram glad_glActiveShaderProgram
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROGRAMVPROC)(GLenum type, GLsizei count, const GLchar *const*strings);
+GLAPI PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv;
+#define glCreateShaderProgramv glad_glCreateShaderProgramv
+typedef void (APIENTRYP PFNGLBINDPROGRAMPIPELINEPROC)(GLuint pipeline);
+GLAPI PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline;
+#define glBindProgramPipeline glad_glBindProgramPipeline
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPIPELINESPROC)(GLsizei n, const GLuint *pipelines);
+GLAPI PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines;
+#define glDeleteProgramPipelines glad_glDeleteProgramPipelines
+typedef void (APIENTRYP PFNGLGENPROGRAMPIPELINESPROC)(GLsizei n, GLuint *pipelines);
+GLAPI PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines;
+#define glGenProgramPipelines glad_glGenProgramPipelines
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMPIPELINEPROC)(GLuint pipeline);
+GLAPI PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline;
+#define glIsProgramPipeline glad_glIsProgramPipeline
+typedef void (APIENTRYP PFNGLGETPROGRAMPIPELINEIVPROC)(GLuint pipeline, GLenum pname, GLint *params);
+GLAPI PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv;
+#define glGetProgramPipelineiv glad_glGetProgramPipelineiv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IPROC)(GLuint program, GLint location, GLint v0);
+GLAPI PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i;
+#define glProgramUniform1i glad_glProgramUniform1i
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IPROC)(GLuint program, GLint location, GLint v0, GLint v1);
+GLAPI PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i;
+#define glProgramUniform2i glad_glProgramUniform2i
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i;
+#define glProgramUniform3i glad_glProgramUniform3i
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i;
+#define glProgramUniform4i glad_glProgramUniform4i
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIPROC)(GLuint program, GLint location, GLuint v0);
+GLAPI PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui;
+#define glProgramUniform1ui glad_glProgramUniform1ui
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1);
+GLAPI PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui;
+#define glProgramUniform2ui glad_glProgramUniform2ui
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui;
+#define glProgramUniform3ui glad_glProgramUniform3ui
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui;
+#define glProgramUniform4ui glad_glProgramUniform4ui
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FPROC)(GLuint program, GLint location, GLfloat v0);
+GLAPI PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f;
+#define glProgramUniform1f glad_glProgramUniform1f
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
+GLAPI PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f;
+#define glProgramUniform2f glad_glProgramUniform2f
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f;
+#define glProgramUniform3f glad_glProgramUniform3f
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f;
+#define glProgramUniform4f glad_glProgramUniform4f
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv;
+#define glProgramUniform1iv glad_glProgramUniform1iv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv;
+#define glProgramUniform2iv glad_glProgramUniform2iv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv;
+#define glProgramUniform3iv glad_glProgramUniform3iv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv;
+#define glProgramUniform4iv glad_glProgramUniform4iv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv;
+#define glProgramUniform1uiv glad_glProgramUniform1uiv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv;
+#define glProgramUniform2uiv glad_glProgramUniform2uiv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv;
+#define glProgramUniform3uiv glad_glProgramUniform3uiv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv;
+#define glProgramUniform4uiv glad_glProgramUniform4uiv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv;
+#define glProgramUniform1fv glad_glProgramUniform1fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv;
+#define glProgramUniform2fv glad_glProgramUniform2fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv;
+#define glProgramUniform3fv glad_glProgramUniform3fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv;
+#define glProgramUniform4fv glad_glProgramUniform4fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv;
+#define glProgramUniformMatrix2fv glad_glProgramUniformMatrix2fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv;
+#define glProgramUniformMatrix3fv glad_glProgramUniformMatrix3fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv;
+#define glProgramUniformMatrix4fv glad_glProgramUniformMatrix4fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv;
+#define glProgramUniformMatrix2x3fv glad_glProgramUniformMatrix2x3fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv;
+#define glProgramUniformMatrix3x2fv glad_glProgramUniformMatrix3x2fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv;
+#define glProgramUniformMatrix2x4fv glad_glProgramUniformMatrix2x4fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv;
+#define glProgramUniformMatrix4x2fv glad_glProgramUniformMatrix4x2fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv;
+#define glProgramUniformMatrix3x4fv glad_glProgramUniformMatrix3x4fv
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv;
+#define glProgramUniformMatrix4x3fv glad_glProgramUniformMatrix4x3fv
+typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPIPELINEPROC)(GLuint pipeline);
+GLAPI PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline;
+#define glValidateProgramPipeline glad_glValidateProgramPipeline
+typedef void (APIENTRYP PFNGLGETPROGRAMPIPELINEINFOLOGPROC)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog;
+#define glGetProgramPipelineInfoLog glad_glGetProgramPipelineInfoLog
+typedef void (APIENTRYP PFNGLBINDIMAGETEXTUREPROC)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
+GLAPI PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture;
+#define glBindImageTexture glad_glBindImageTexture
+typedef void (APIENTRYP PFNGLMEMORYBARRIERPROC)(GLbitfield barriers);
+GLAPI PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier;
+#define glMemoryBarrier glad_glMemoryBarrier
+typedef void (APIENTRYP PFNGLMEMORYBARRIERBYREGIONPROC)(GLbitfield barriers);
+GLAPI PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion;
+#define glMemoryBarrierByRegion glad_glMemoryBarrierByRegion
+typedef void (APIENTRYP PFNGLTEXSTORAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+GLAPI PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample;
+#define glTexStorage2DMultisample glad_glTexStorage2DMultisample
+typedef void (APIENTRYP PFNGLBINDVERTEXBUFFERPROC)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
+GLAPI PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer;
+#define glBindVertexBuffer glad_glBindVertexBuffer
+typedef void (APIENTRYP PFNGLVERTEXATTRIBFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
+GLAPI PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat;
+#define glVertexAttribFormat glad_glVertexAttribFormat
+typedef void (APIENTRYP PFNGLVERTEXATTRIBIFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+GLAPI PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat;
+#define glVertexAttribIFormat glad_glVertexAttribIFormat
+typedef void (APIENTRYP PFNGLVERTEXATTRIBBINDINGPROC)(GLuint attribindex, GLuint bindingindex);
+GLAPI PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding;
+#define glVertexAttribBinding glad_glVertexAttribBinding
+typedef void (APIENTRYP PFNGLVERTEXBINDINGDIVISORPROC)(GLuint bindingindex, GLuint divisor);
+GLAPI PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor;
+#define glVertexBindingDivisor glad_glVertexBindingDivisor
+#endif
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION 0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM 0x8245
+#define GL_DEBUG_SOURCE_API 0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249
+#define GL_DEBUG_SOURCE_APPLICATION 0x824A
+#define GL_DEBUG_SOURCE_OTHER 0x824B
+#define GL_DEBUG_TYPE_ERROR 0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E
+#define GL_DEBUG_TYPE_PORTABILITY 0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE 0x8250
+#define GL_DEBUG_TYPE_OTHER 0x8251
+#define GL_DEBUG_TYPE_MARKER 0x8268
+#define GL_DEBUG_TYPE_PUSH_GROUP 0x8269
+#define GL_DEBUG_TYPE_POP_GROUP 0x826A
+#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B
+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C
+#define GL_DEBUG_GROUP_STACK_DEPTH 0x826D
+#define GL_BUFFER 0x82E0
+#define GL_SHADER 0x82E1
+#define GL_PROGRAM 0x82E2
+#define GL_VERTEX_ARRAY 0x8074
+#define GL_QUERY 0x82E3
+#define GL_PROGRAM_PIPELINE 0x82E4
+#define GL_SAMPLER 0x82E6
+#define GL_MAX_LABEL_LENGTH 0x82E8
+#define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144
+#define GL_DEBUG_LOGGED_MESSAGES 0x9145
+#define GL_DEBUG_SEVERITY_HIGH 0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM 0x9147
+#define GL_DEBUG_SEVERITY_LOW 0x9148
+#define GL_DEBUG_OUTPUT 0x92E0
+#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
+#define GL_STACK_OVERFLOW 0x0503
+#define GL_STACK_UNDERFLOW 0x0504
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR 0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION_KHR 0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM_KHR 0x8245
+#define GL_DEBUG_SOURCE_API_KHR 0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR 0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER_KHR 0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY_KHR 0x8249
+#define GL_DEBUG_SOURCE_APPLICATION_KHR 0x824A
+#define GL_DEBUG_SOURCE_OTHER_KHR 0x824B
+#define GL_DEBUG_TYPE_ERROR_KHR 0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR 0x824E
+#define GL_DEBUG_TYPE_PORTABILITY_KHR 0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE_KHR 0x8250
+#define GL_DEBUG_TYPE_OTHER_KHR 0x8251
+#define GL_DEBUG_TYPE_MARKER_KHR 0x8268
+#define GL_DEBUG_TYPE_PUSH_GROUP_KHR 0x8269
+#define GL_DEBUG_TYPE_POP_GROUP_KHR 0x826A
+#define GL_DEBUG_SEVERITY_NOTIFICATION_KHR 0x826B
+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR 0x826C
+#define GL_DEBUG_GROUP_STACK_DEPTH_KHR 0x826D
+#define GL_BUFFER_KHR 0x82E0
+#define GL_SHADER_KHR 0x82E1
+#define GL_PROGRAM_KHR 0x82E2
+#define GL_VERTEX_ARRAY_KHR 0x8074
+#define GL_QUERY_KHR 0x82E3
+#define GL_PROGRAM_PIPELINE_KHR 0x82E4
+#define GL_SAMPLER_KHR 0x82E6
+#define GL_MAX_LABEL_LENGTH_KHR 0x82E8
+#define GL_MAX_DEBUG_MESSAGE_LENGTH_KHR 0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES_KHR 0x9144
+#define GL_DEBUG_LOGGED_MESSAGES_KHR 0x9145
+#define GL_DEBUG_SEVERITY_HIGH_KHR 0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM_KHR 0x9147
+#define GL_DEBUG_SEVERITY_LOW_KHR 0x9148
+#define GL_DEBUG_OUTPUT_KHR 0x92E0
+#define GL_CONTEXT_FLAG_DEBUG_BIT_KHR 0x00000002
+#define GL_STACK_OVERFLOW_KHR 0x0503
+#define GL_STACK_UNDERFLOW_KHR 0x0504
+#define GL_DISPLAY_LIST 0x82E7
+#define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0
+#define GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1
+#define GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2
+#define GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3
+#define GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4
+#define GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5
+#define GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6
+#define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7
+#define GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8
+#define GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9
+#define GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA
+#define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB
+#define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC
+#define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD
+#ifndef GL_EXT_framebuffer_object
+#define GL_EXT_framebuffer_object 1
+GLAPI int GLAD_GL_EXT_framebuffer_object;
+#endif
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_EXT_texture_compression_s3tc 1
+GLAPI int GLAD_GL_EXT_texture_compression_s3tc;
+#endif
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
+#endif
+#ifndef GL_KHR_debug
+#define GL_KHR_debug 1
+GLAPI int GLAD_GL_KHR_debug;
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECONTROLPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+GLAPI PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl;
+#define glDebugMessageControl glad_glDebugMessageControl
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+GLAPI PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert;
+#define glDebugMessageInsert glad_glDebugMessageInsert
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKPROC)(GLDEBUGPROC callback, const void *userParam);
+GLAPI PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback;
+#define glDebugMessageCallback glad_glDebugMessageCallback
+typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGPROC)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+GLAPI PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog;
+#define glGetDebugMessageLog glad_glGetDebugMessageLog
+typedef void (APIENTRYP PFNGLPUSHDEBUGGROUPPROC)(GLenum source, GLuint id, GLsizei length, const GLchar *message);
+GLAPI PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup;
+#define glPushDebugGroup glad_glPushDebugGroup
+typedef void (APIENTRYP PFNGLPOPDEBUGGROUPPROC)(void);
+GLAPI PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup;
+#define glPopDebugGroup glad_glPopDebugGroup
+typedef void (APIENTRYP PFNGLOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
+GLAPI PFNGLOBJECTLABELPROC glad_glObjectLabel;
+#define glObjectLabel glad_glObjectLabel
+typedef void (APIENTRYP PFNGLGETOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
+GLAPI PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel;
+#define glGetObjectLabel glad_glGetObjectLabel
+typedef void (APIENTRYP PFNGLOBJECTPTRLABELPROC)(const void *ptr, GLsizei length, const GLchar *label);
+GLAPI PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel;
+#define glObjectPtrLabel glad_glObjectPtrLabel
+typedef void (APIENTRYP PFNGLGETOBJECTPTRLABELPROC)(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
+GLAPI PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel;
+#define glGetObjectPtrLabel glad_glGetObjectPtrLabel
+typedef void (APIENTRYP PFNGLGETPOINTERVPROC)(GLenum pname, void **params);
+GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv;
+#define glGetPointerv glad_glGetPointerv
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECONTROLKHRPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+GLAPI PFNGLDEBUGMESSAGECONTROLKHRPROC glad_glDebugMessageControlKHR;
+#define glDebugMessageControlKHR glad_glDebugMessageControlKHR
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTKHRPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+GLAPI PFNGLDEBUGMESSAGEINSERTKHRPROC glad_glDebugMessageInsertKHR;
+#define glDebugMessageInsertKHR glad_glDebugMessageInsertKHR
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKKHRPROC)(GLDEBUGPROCKHR callback, const void *userParam);
+GLAPI PFNGLDEBUGMESSAGECALLBACKKHRPROC glad_glDebugMessageCallbackKHR;
+#define glDebugMessageCallbackKHR glad_glDebugMessageCallbackKHR
+typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGKHRPROC)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+GLAPI PFNGLGETDEBUGMESSAGELOGKHRPROC glad_glGetDebugMessageLogKHR;
+#define glGetDebugMessageLogKHR glad_glGetDebugMessageLogKHR
+typedef void (APIENTRYP PFNGLPUSHDEBUGGROUPKHRPROC)(GLenum source, GLuint id, GLsizei length, const GLchar *message);
+GLAPI PFNGLPUSHDEBUGGROUPKHRPROC glad_glPushDebugGroupKHR;
+#define glPushDebugGroupKHR glad_glPushDebugGroupKHR
+typedef void (APIENTRYP PFNGLPOPDEBUGGROUPKHRPROC)(void);
+GLAPI PFNGLPOPDEBUGGROUPKHRPROC glad_glPopDebugGroupKHR;
+#define glPopDebugGroupKHR glad_glPopDebugGroupKHR
+typedef void (APIENTRYP PFNGLOBJECTLABELKHRPROC)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
+GLAPI PFNGLOBJECTLABELKHRPROC glad_glObjectLabelKHR;
+#define glObjectLabelKHR glad_glObjectLabelKHR
+typedef void (APIENTRYP PFNGLGETOBJECTLABELKHRPROC)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
+GLAPI PFNGLGETOBJECTLABELKHRPROC glad_glGetObjectLabelKHR;
+#define glGetObjectLabelKHR glad_glGetObjectLabelKHR
+typedef void (APIENTRYP PFNGLOBJECTPTRLABELKHRPROC)(const void *ptr, GLsizei length, const GLchar *label);
+GLAPI PFNGLOBJECTPTRLABELKHRPROC glad_glObjectPtrLabelKHR;
+#define glObjectPtrLabelKHR glad_glObjectPtrLabelKHR
+typedef void (APIENTRYP PFNGLGETOBJECTPTRLABELKHRPROC)(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
+GLAPI PFNGLGETOBJECTPTRLABELKHRPROC glad_glGetObjectPtrLabelKHR;
+#define glGetObjectPtrLabelKHR glad_glGetObjectPtrLabelKHR
+typedef void (APIENTRYP PFNGLGETPOINTERVKHRPROC)(GLenum pname, void **params);
+GLAPI PFNGLGETPOINTERVKHRPROC glad_glGetPointervKHR;
+#define glGetPointervKHR glad_glGetPointervKHR
+#endif
+#ifndef GL_KHR_texture_compression_astc_ldr
+#define GL_KHR_texture_compression_astc_ldr 1
+GLAPI int GLAD_GL_KHR_texture_compression_astc_ldr;
+#endif
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_EXT_texture_compression_s3tc 1
+GLAPI int GLAD_GL_EXT_texture_compression_s3tc;
+#endif
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
+#endif
+#ifndef GL_KHR_debug
+#define GL_KHR_debug 1
+GLAPI int GLAD_GL_KHR_debug;
+#endif
+#ifndef GL_KHR_texture_compression_astc_ldr
+#define GL_KHR_texture_compression_astc_ldr 1
+GLAPI int GLAD_GL_KHR_texture_compression_astc_ldr;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/gl/glad/khrplatform.h b/src/gl/glad/khrplatform.h
new file mode 100644
index 0000000..dd22d92
--- /dev/null
+++ b/src/gl/glad/khrplatform.h
@@ -0,0 +1,290 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
diff --git a/src/gl/rwgl3.h b/src/gl/rwgl3.h
index ccaba26..7296144 100644
--- a/src/gl/rwgl3.h
+++ b/src/gl/rwgl3.h
@@ -1,19 +1,10 @@
 #ifdef RW_GL3
-
-#ifdef __SWITCH__ // switch must be included early for some defines that are needed later on for opengl stuff
-#include <switch.h>
-#endif
-
 #ifdef PSP2
+// Vita uses vitaGL as its GL implementation; no glad/GLFW/SDL windowing here.
 #include <vitasdk.h>
 #include <vitaGL.h>
 #else
-#ifndef LIBRW_GLAD
-#include <GL/glew.h>
-#else
-#include <glad/glad.h>
-#endif
-
+#include "glad/glad.h"
 #ifdef LIBRW_SDL2
 #include <SDL.h>
 #else
@@ -60,18 +51,16 @@ enum AttribIndices
 	ATTRIB_POS = 0,
 	ATTRIB_NORMAL,
 	ATTRIB_COLOR,
+	ATTRIB_WEIGHTS,
+	ATTRIB_INDICES,
 	ATTRIB_TEXCOORDS0,
 	ATTRIB_TEXCOORDS1,
-#ifndef RW_GLES2
 	ATTRIB_TEXCOORDS2,
 	ATTRIB_TEXCOORDS3,
 	ATTRIB_TEXCOORDS4,
 	ATTRIB_TEXCOORDS5,
 	ATTRIB_TEXCOORDS6,
 	ATTRIB_TEXCOORDS7,
-#endif
-	ATTRIB_WEIGHTS,
-	ATTRIB_INDICES
 };
 
 // default uniform indices
@@ -114,7 +103,8 @@ struct InstanceDataHeader : rw::InstanceDataHeader
 
 struct Shader;
 
-extern Shader *defaultShader;
+extern Shader *defaultShader, *defaultShader_noAT;
+extern Shader *defaultShader_fullLight, *defaultShader_fullLight_noAT;
 
 struct Im3DVertex
 {
@@ -147,8 +137,9 @@ struct Im2DVertex
 	void setScreenX(float32 x) { this->x = x; }
 	void setScreenY(float32 y) { this->y = y; }
 	void setScreenZ(float32 z) { this->z = z; }
+	// This is a bit unefficient but we have to counteract GL's divide, so multiply
 	void setCameraZ(float32 z) { this->w = z; }
-	void setRecipCameraZ(float32 recipz) { }
+	void setRecipCameraZ(float32 recipz) { this->w = 1.0f/recipz; }
 	void setColor(uint8 r, uint8 g, uint8 b, uint8 a) {
 		this->r = r; this->g = g; this->b = b; this->a = a; }
 	void setU(float32 u, float recipz) { this->u = u; }
@@ -166,6 +157,8 @@ struct Im2DVertex
 
 void setAttribPointers(AttribDesc *attribDescs, int32 numAttribs);
 void disableAttribPointers(AttribDesc *attribDescs, int32 numAttribs);
+void setupVertexInput(InstanceDataHeader *header);
+void teardownVertexInput(InstanceDataHeader *header);
 
 // Render state
 
@@ -197,11 +190,21 @@ int32 setLights(WorldLights *lightData);
 
 // per Mesh
 void setTexture(int32 n, Texture *tex);
-void setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops);
+void setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp = 0.0f);
+inline void setMaterial(uint32 flags, const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp = 0.0f)
+{
+	static RGBA white = { 255, 255, 255, 255 };
+	if(flags & Geometry::MODULATE)
+		setMaterial(color, surfaceprops, extraSurfProp);
+	else
+		setMaterial(white, surfaceprops, extraSurfProp);
+}
 
 void setAlphaBlend(bool32 enable);
 bool32 getAlphaBlend(void);
 
+bool32 getAlphaTest(void);
+
 void bindFramebuffer(uint32 fbo);
 uint32 bindTexture(uint32 texid);
 
@@ -238,8 +241,6 @@ ObjPipeline *makeDefaultPipeline(void);
 
 // Native Texture and Raster
 
-extern int32 nativeRasterOffset;
-
 struct Gl3Raster
 {
 	// arguments to glTexImage2D
@@ -250,21 +251,44 @@ struct Gl3Raster
 	// texture object
 	uint32 texid;
 
-	bool32 hasAlpha;
+	bool isCompressed;
+	bool hasAlpha;
+	bool autogenMipmap;
+	int8 numLevels;
 	// cached filtermode and addressing
 	uint8 filterMode;
 	uint8 addressU;
 	uint8 addressV;
+	int32 maxAnisotropy;
 
 	uint32 fbo;		// used for camera texture only!
 	Raster *fboMate;	// color or zbuffer raster mate of this one
+	RasterLevels *backingStore;	// if we can't read back GPU memory but have to
 };
 
+struct Gl3Caps
+{
+	int gles;
+	int glversion;
+	bool dxtSupported;
+	bool astcSupported;	// not used yet
+	float maxAnisotropy;
+};
+extern Gl3Caps gl3Caps;
+// GLES can't read back textures very nicely.
+// In most cases that's not an issue, but when it is,
+// this has to be set before the texture is filled:
+extern bool32 needToReadBackTextures;
+
+void allocateDXT(Raster *raster, int32 dxt, int32 numLevels, bool32 hasAlpha);
+
 Texture *readNativeTexture(Stream *stream);
 void writeNativeTexture(Texture *tex, Stream *stream);
 uint32 getSizeNativeTexture(Texture *tex);
 
+extern int32 nativeRasterOffset;
 void registerNativeRaster(void);
+#define GETGL3RASTEREXT(raster) PLUGINOFFSET(Gl3Raster, raster, rw::gl3::nativeRasterOffset)
 
 }
 }
diff --git a/src/gl/rwgl3impl.h b/src/gl/rwgl3impl.h
index 8c5e428..613313b 100644
--- a/src/gl/rwgl3impl.h
+++ b/src/gl/rwgl3impl.h
@@ -21,6 +21,54 @@ void im3DTransform(void *vertices, int32 numVertices, Matrix *world, uint32 flag
 void im3DRenderPrimitive(PrimitiveType primType);
 void im3DRenderIndexedPrimitive(PrimitiveType primType, void *indices, int32 numIndices);
 void im3DEnd(void);
+
+struct DisplayMode
+{
+#ifdef LIBRW_SDL2
+	SDL_DisplayMode mode;
+#elif defined(PSP2)
+	// there is only one mode on Vita, but keep the shape of GLFWvidmode
+	// so the generic code below compiles unchanged
+	struct {
+		int width, height;
+		int redBits, greenBits, blueBits;
+		int refreshRate;
+	} mode;
+#else
+	GLFWvidmode mode;
+#endif
+	int32 depth;
+	uint32 flags;
+};
+
+struct GlGlobals
+{
+#ifdef LIBRW_SDL2
+	SDL_Window **pWindow;
+	SDL_Window *window;
+	SDL_GLContext glcontext;
+#elif !defined(PSP2)
+	GLFWwindow **pWindow;
+	GLFWwindow *window;
+
+	GLFWmonitor *monitor;
+	int numMonitors;
+	int currentMonitor;
+#endif
+
+	DisplayMode *modes;
+	int numModes;
+	int currentMode;
+	int presentWidth, presentHeight;
+	int presentOffX, presentOffY;
+
+	// for opening the window
+	int winWidth, winHeight;
+	const char *winTitle;
+	uint32 numSamples;
+};
+
+extern GlGlobals glGlobals;
 #endif
 
 Raster *rasterCreate(Raster *raster);
@@ -30,6 +78,7 @@ int32 rasterNumLevels(Raster*);
 bool32 imageFindRasterFormat(Image *img, int32 type,
 	int32 *width, int32 *height, int32 *depth, int32 *format);
 bool32 rasterFromImage(Raster *raster, Image *image);
+Image *rasterToImage(Raster *raster);
 
 }
 }
diff --git a/src/gl/rwgl3shader.h b/src/gl/rwgl3shader.h
index aef9180..890f12b 100644
--- a/src/gl/rwgl3shader.h
+++ b/src/gl/rwgl3shader.h
@@ -9,20 +9,41 @@ enum {
 	MAX_BLOCKS = 20
 };
 
+enum UniformType
+{
+	UNIFORM_NA,	// managed by the user
+	UNIFORM_VEC4,
+	UNIFORM_IVEC4,
+	UNIFORM_MAT4
+};
+
+struct Uniform
+{
+	char *name;
+	UniformType type;
+	//bool dirty;
+	uint32 serialNum;
+	int32 num;
+	void *data;
+};
+
 struct UniformRegistry
 {
 	int32 numUniforms;
-	char *uniformNames[MAX_UNIFORMS];
+	Uniform uniforms[MAX_UNIFORMS];
 
 	int32 numBlocks;
 	char *blockNames[MAX_BLOCKS];
 };
 
-int32 registerUniform(const char *name);
+int32 registerUniform(const char *name, UniformType type = UNIFORM_NA, int32 num = 1);
 int32 findUniform(const char *name);
 int32 registerBlock(const char *name);
 int32 findBlock(const char *name);
 
+void setUniform(int32 id, void *data);
+void flushUniforms(void);
+
 extern UniformRegistry uniformRegistry;
 
 struct Shader
@@ -30,8 +51,10 @@ struct Shader
 	GLuint program;
 	// same number of elements as UniformRegistry::numUniforms
 	GLint *uniformLocations;
+	uint32 *serialNums;
+	int32 numUniforms;	// just to be sure!
 
-	static Shader *create(const char **vsrc, const char **fsrc, bool is_2d);
+	static Shader *create(const char **vsrc, const char **fsrc);
 //	static Shader *fromFiles(const char *vs, const char *fs);
 //	static Shader *fromStrings(const char *vsrc, const char *fsrc);
 	void use(void);
diff --git a/src/gl/rwwdgl.h b/src/gl/rwwdgl.h
index af49ae2..b336ba3 100644
--- a/src/gl/rwwdgl.h
+++ b/src/gl/rwwdgl.h
@@ -32,6 +32,7 @@ struct InstanceDataHeader : rw::InstanceDataHeader
 };
 
 // only RW_OPENGL
+void uploadGeo(Geometry *geo);
 void setAttribPointers(InstanceDataHeader *inst);
 
 void packattrib(uint8 *dst, float32 *src, AttribDesc *a, float32 scale);
diff --git a/src/gl/shaders/Makefile b/src/gl/shaders/Makefile
index 2301a95..6471f17 100644
--- a/src/gl/shaders/Makefile
+++ b/src/gl/shaders/Makefile
@@ -1,4 +1,4 @@
-all: header_vs.inc header_fs.inc im2d_gl3.inc im3d_gl3.inc default_vs_gl3.inc simple_fs_gl3.inc matfx_gl3.inc skin_gl3.inc
+all: header_vs.inc header_fs.inc im2d_gl.inc im3d_gl.inc default_vs_gl.inc simple_fs_gl.inc matfx_gl.inc skin_gl.inc
 
 header_vs.inc: header.vert
 	(echo 'const char *header_vert_src =';\
@@ -10,36 +10,36 @@ header_fs.inc: header.frag
 	 sed 's/..*/"&\\n"/' header.frag;\
 	 echo ';') >header_fs.inc
 
-im2d_gl3.inc: im2d.vert
+im2d_gl.inc: im2d.vert
 	(echo 'const char *im2d_vert_src =';\
 	 sed 's/..*/"&\\n"/' im2d.vert;\
-	 echo ';') >im2d_gl3.inc
+	 echo ';') >im2d_gl.inc
 
-im3d_gl3.inc: im3d.vert
+im3d_gl.inc: im3d.vert
 	(echo 'const char *im3d_vert_src =';\
 	 sed 's/..*/"&\\n"/' im3d.vert;\
-	 echo ';') >im3d_gl3.inc
+	 echo ';') >im3d_gl.inc
 
-default_vs_gl3.inc: default.vert
+default_vs_gl.inc: default.vert
 	(echo 'const char *default_vert_src =';\
 	 sed 's/..*/"&\\n"/' default.vert;\
-	 echo ';') >default_vs_gl3.inc
+	 echo ';') >default_vs_gl.inc
 
-simple_fs_gl3.inc: simple.frag
+simple_fs_gl.inc: simple.frag
 	(echo 'const char *simple_frag_src =';\
 	 sed 's/..*/"&\\n"/' simple.frag;\
-	 echo ';') >simple_fs_gl3.inc
+	 echo ';') >simple_fs_gl.inc
 
-matfx_gl3.inc: matfx_env.frag matfx_env.vert
+matfx_gl.inc: matfx_env.frag matfx_env.vert
 	(echo 'const char *matfx_env_vert_src =';\
 	 sed 's/..*/"&\\n"/' matfx_env.vert;\
 	 echo ';';\
 	 echo 'const char *matfx_env_frag_src =';\
 	 sed 's/..*/"&\\n"/' matfx_env.frag;\
-	 echo ';') >matfx_gl3.inc
+	 echo ';') >matfx_gl.inc
 
-skin_gl3.inc: skin.vert
+skin_gl.inc: skin.vert
 	(echo 'const char *skin_vert_src =';\
 	 sed 's/..*/"&\\n"/' skin.vert;\
-	 echo ';') >skin_gl3.inc
+	 echo ';') >skin_gl.inc
 
diff --git a/src/gl/shaders/default.vert b/src/gl/shaders/default.vert
index fa14fad..8e3fad7 100644
--- a/src/gl/shaders/default.vert
+++ b/src/gl/shaders/default.vert
@@ -1,44 +1,23 @@
-void main(
-	float3 in_pos,
-	float3 in_normal,
-	fixed4 in_color,
-	half2 in_tex0,
-	uniform float4x4 u_wvp,
-	uniform float4x4 u_world,
-	uniform half4 u_ambLight,
-	uniform half4 u_surfProps,
-	uniform half4 u_fogData,
-	uniform half4 u_matColor,
-	uniform half4 u_lightParams[MAX_LIGHTS],
-	uniform half4 u_lightDirection[MAX_LIGHTS],
-	uniform half4 u_lightColor[MAX_LIGHTS],
-	half4 out v_color : COLOR0,
-	half2 out v_tex0 : TEXCOORD0,
-	fixed out v_fog : FOG,
-	float4 out gl_Position : POSITION
-) {
-	gl_Position = mul(float4(in_pos, 1.0), u_wvp);
-	float3 Normal = mul(in_normal, float3x3(u_world));
+VSIN(ATTRIB_POS)	vec3 in_pos;
+
+VSOUT vec4 v_color;
+VSOUT vec2 v_tex0;
+VSOUT float v_fog;
+
+void
+main(void)
+{
+	vec4 Vertex = u_world * vec4(in_pos, 1.0);
+	gl_Position = u_proj * u_view * Vertex;
+	vec3 Normal = mat3(u_world) * in_normal;
 
 	v_tex0 = in_tex0;
 
 	v_color = in_color;
 	v_color.rgb += u_ambLight.rgb*surfAmbient;
-	
-	half3 color = half3(0.0, 0.0, 0.0);
-	for(int i = 0; i < MAX_LIGHTS; i++){
-		if(u_lightParams[i].x == 0.0)
-			break;
-		if(u_lightParams[i].x == 1.0){
-			// direct
-			fixed l = max(0.0, dot(Normal, -u_lightDirection[i].xyz));
-			color += l*u_lightColor[i].rgb;
-		}
-	}
-	
-	v_color.rgb += color*surfDiffuse;
+	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;
 	v_color = clamp(v_color, 0.0, 1.0);
 	v_color *= u_matColor;
 
-	v_fog = DoFog(gl_Position.w, u_fogData);
+	v_fog = DoFog(gl_Position.w);
 }
diff --git a/src/gl/shaders/default_vs_gl.inc b/src/gl/shaders/default_vs_gl.inc
new file mode 100644
index 0000000..6e3d6c4
--- /dev/null
+++ b/src/gl/shaders/default_vs_gl.inc
@@ -0,0 +1,25 @@
+const char *default_vert_src =
+"VSIN(ATTRIB_POS)	vec3 in_pos;\n"
+
+"VSOUT vec4 v_color;\n"
+"VSOUT vec2 v_tex0;\n"
+"VSOUT float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 Vertex = u_world * vec4(in_pos, 1.0);\n"
+"	gl_Position = u_proj * u_view * Vertex;\n"
+"	vec3 Normal = mat3(u_world) * in_normal;\n"
+
+"	v_tex0 = in_tex0;\n"
+
+"	v_color = in_color;\n"
+"	v_color.rgb += u_ambLight.rgb*surfAmbient;\n"
+"	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;\n"
+"	v_color = clamp(v_color, 0.0, 1.0);\n"
+"	v_color *= u_matColor;\n"
+
+"	v_fog = DoFog(gl_Position.w);\n"
+"}\n"
+;
diff --git a/src/gl/shaders/header.frag b/src/gl/shaders/header.frag
index 5bc249b..ba50165 100644
--- a/src/gl/shaders/header.frag
+++ b/src/gl/shaders/header.frag
@@ -1,10 +1,30 @@
+#ifdef USE_UBOS
+layout(std140) uniform State
+{
+	vec2 u_alphaRef;
+	vec4  u_fogData;
+	vec4  u_fogColor;
+};
+#else
+uniform vec4 u_alphaRef;
+
+uniform vec4  u_fogData;
+uniform vec4  u_fogColor;
+#endif
+
 #define u_fogStart (u_fogData.x)
 #define u_fogEnd (u_fogData.y)
 #define u_fogRange (u_fogData.z)
 #define u_fogDisable (u_fogData.w)
 
-void DoAlphaTest(float a, half2 u_alphaRef)
+#ifndef GL2
+out vec4 fragColor;
+#endif
+
+void DoAlphaTest(float a)
 {
+#ifndef NO_ALPHATEST
 	if(a < u_alphaRef.x || a >= u_alphaRef.y)
 		discard;
+#endif
 }
diff --git a/src/gl/shaders/header.vert b/src/gl/shaders/header.vert
index 9b86596..bb9881f 100644
--- a/src/gl/shaders/header.vert
+++ b/src/gl/shaders/header.vert
@@ -1,15 +1,128 @@
+
+//#define DIRECTIONALS
+//#define POINTLIGHTS
+//#define SPOTLIGHTS
+
+#define ATTRIB_POS	0
+#define ATTRIB_NORMAL	1
+#define ATTRIB_COLOR	2
+#define ATTRIB_WEIGHTS	3
+#define ATTRIB_INDICES	4
+#define ATTRIB_TEXCOORDS0	5
+#define ATTRIB_TEXCOORDS1	6
+
+
+VSIN(ATTRIB_NORMAL)	vec3 in_normal;
+VSIN(ATTRIB_COLOR)	vec4 in_color;
+VSIN(ATTRIB_WEIGHTS)	vec4 in_weights;
+VSIN(ATTRIB_INDICES)	vec4 in_indices;
+VSIN(ATTRIB_TEXCOORDS0)	vec2 in_tex0;
+VSIN(ATTRIB_TEXCOORDS1)	vec2 in_tex1;
+
+
+#ifdef USE_UBOS
+layout(std140) uniform State
+{
+	vec2 u_alphaRef;
+	vec4  u_fogData;
+	vec4  u_fogColor;
+};
+#else
+uniform vec4 u_alphaRef;
+uniform vec4  u_fogData;
+uniform vec4  u_fogColor;
+#endif
+
 #define u_fogStart (u_fogData.x)
 #define u_fogEnd (u_fogData.y)
 #define u_fogRange (u_fogData.z)
 #define u_fogDisable (u_fogData.w)
 
+#ifdef USE_UBOS
+layout(std140) uniform Scene
+{
+	mat4 u_proj;
+	mat4 u_view;
+};
+#else
+uniform mat4 u_proj;
+uniform mat4 u_view;
+#endif
+
 #define MAX_LIGHTS 8
 
+#ifdef USE_UBOS
+layout(std140) uniform Object
+{
+	mat4  u_world;
+	vec4  u_ambLight;
+	vec4 u_lightParams[MAX_LIGHTS];	// type, radius, minusCosAngle, hardSpot
+	vec4 u_lightPosition[MAX_LIGHTS];
+	vec4 u_lightDirection[MAX_LIGHTS];
+	vec4 u_lightColor[MAX_LIGHTS];
+};
+#else
+uniform mat4 u_world;
+uniform vec4 u_ambLight;
+uniform vec4 u_lightParams[MAX_LIGHTS];	// type, radius, minusCosAngle, hardSpot
+uniform vec4 u_lightPosition[MAX_LIGHTS];
+uniform vec4 u_lightDirection[MAX_LIGHTS];
+uniform vec4 u_lightColor[MAX_LIGHTS];
+#endif
+
+uniform vec4 u_matColor;
+uniform vec4 u_surfProps;	// amb, spec, diff, extra
+
 #define surfAmbient (u_surfProps.x)
 #define surfSpecular (u_surfProps.y)
 #define surfDiffuse (u_surfProps.z)
 
-fixed DoFog(float w, half4 u_fogData)
+vec3 DoDynamicLight(vec3 V, vec3 N)
+{
+	vec3 color = vec3(0.0, 0.0, 0.0);
+	for(int i = 0; i < MAX_LIGHTS; i++){
+		if(u_lightParams[i].x == 0.0)
+			break;
+#ifdef DIRECTIONALS
+		if(u_lightParams[i].x == 1.0){
+			// direct
+			float l = max(0.0, dot(N, -u_lightDirection[i].xyz));
+			color += l*u_lightColor[i].rgb;
+		}else
+#endif
+#ifdef POINTLIGHTS
+		if(u_lightParams[i].x == 2.0){
+			// point
+			vec3 dir = V - u_lightPosition[i].xyz;
+			float dist = length(dir);
+			float atten = max(0.0, (1.0 - dist/u_lightParams[i].y));
+			float l = max(0.0, dot(N, -normalize(dir)));
+			color += l*u_lightColor[i].rgb*atten;
+		}else
+#endif
+#ifdef SPOTLIGHTS
+		if(u_lightParams[i].x == 3.0){
+			// spot
+			vec3 dir = V - u_lightPosition[i].xyz;
+			float dist = length(dir);
+			float atten = max(0.0, (1.0 - dist/u_lightParams[i].y));
+			dir /= dist;
+			float l = max(0.0, dot(N, -dir));
+			float pcos = dot(dir, u_lightDirection[i].xyz);	// cos to point
+			float ccos = -u_lightParams[i].z;
+			float falloff = (pcos-ccos)/(1.0-ccos);
+			if(falloff < 0.0)	// outside of cone
+				l = 0.0;
+			l *= max(falloff, u_lightParams[i].w);
+			return l*u_lightColor[i].rgb*atten;
+		}else
+#endif
+			;
+	}
+	return color;
+}
+
+float DoFog(float w)
 {
 	return clamp((w - u_fogEnd)*u_fogRange, u_fogDisable, 1.0);
 }
diff --git a/src/gl/shaders/header_fs.inc b/src/gl/shaders/header_fs.inc
index 3f52a3d..802bb4f 100644
--- a/src/gl/shaders/header_fs.inc
+++ b/src/gl/shaders/header_fs.inc
@@ -1,12 +1,32 @@
 const char *header_frag_src =
+"#ifdef USE_UBOS\n"
+"layout(std140) uniform State\n"
+"{\n"
+"	vec2 u_alphaRef;\n"
+"	vec4  u_fogData;\n"
+"	vec4  u_fogColor;\n"
+"};\n"
+"#else\n"
+"uniform vec4 u_alphaRef;\n"
+
+"uniform vec4  u_fogData;\n"
+"uniform vec4  u_fogColor;\n"
+"#endif\n"
+
 "#define u_fogStart (u_fogData.x)\n"
 "#define u_fogEnd (u_fogData.y)\n"
 "#define u_fogRange (u_fogData.z)\n"
 "#define u_fogDisable (u_fogData.w)\n"
 
-"void DoAlphaTest(float a, half2 u_alphaRef)\n"
+"#ifndef GL2\n"
+"out vec4 fragColor;\n"
+"#endif\n"
+
+"void DoAlphaTest(float a)\n"
 "{\n"
+"#ifndef NO_ALPHATEST\n"
 "	if(a < u_alphaRef.x || a >= u_alphaRef.y)\n"
 "		discard;\n"
+"#endif\n"
 "}\n"
 ;
diff --git a/src/gl/shaders/header_vs.inc b/src/gl/shaders/header_vs.inc
index 381dd5b..ffa4683 100644
--- a/src/gl/shaders/header_vs.inc
+++ b/src/gl/shaders/header_vs.inc
@@ -1,16 +1,129 @@
 const char *header_vert_src =
+
+"//#define DIRECTIONALS\n"
+"//#define POINTLIGHTS\n"
+"//#define SPOTLIGHTS\n"
+
+"#define ATTRIB_POS	0\n"
+"#define ATTRIB_NORMAL	1\n"
+"#define ATTRIB_COLOR	2\n"
+"#define ATTRIB_WEIGHTS	3\n"
+"#define ATTRIB_INDICES	4\n"
+"#define ATTRIB_TEXCOORDS0	5\n"
+"#define ATTRIB_TEXCOORDS1	6\n"
+
+
+"VSIN(ATTRIB_NORMAL)	vec3 in_normal;\n"
+"VSIN(ATTRIB_COLOR)	vec4 in_color;\n"
+"VSIN(ATTRIB_WEIGHTS)	vec4 in_weights;\n"
+"VSIN(ATTRIB_INDICES)	vec4 in_indices;\n"
+"VSIN(ATTRIB_TEXCOORDS0)	vec2 in_tex0;\n"
+"VSIN(ATTRIB_TEXCOORDS1)	vec2 in_tex1;\n"
+
+
+"#ifdef USE_UBOS\n"
+"layout(std140) uniform State\n"
+"{\n"
+"	vec2 u_alphaRef;\n"
+"	vec4  u_fogData;\n"
+"	vec4  u_fogColor;\n"
+"};\n"
+"#else\n"
+"uniform vec4 u_alphaRef;\n"
+"uniform vec4  u_fogData;\n"
+"uniform vec4  u_fogColor;\n"
+"#endif\n"
+
 "#define u_fogStart (u_fogData.x)\n"
 "#define u_fogEnd (u_fogData.y)\n"
 "#define u_fogRange (u_fogData.z)\n"
 "#define u_fogDisable (u_fogData.w)\n"
 
+"#ifdef USE_UBOS\n"
+"layout(std140) uniform Scene\n"
+"{\n"
+"	mat4 u_proj;\n"
+"	mat4 u_view;\n"
+"};\n"
+"#else\n"
+"uniform mat4 u_proj;\n"
+"uniform mat4 u_view;\n"
+"#endif\n"
+
 "#define MAX_LIGHTS 8\n"
 
+"#ifdef USE_UBOS\n"
+"layout(std140) uniform Object\n"
+"{\n"
+"	mat4  u_world;\n"
+"	vec4  u_ambLight;\n"
+"	vec4 u_lightParams[MAX_LIGHTS];	// type, radius, minusCosAngle, hardSpot\n"
+"	vec4 u_lightPosition[MAX_LIGHTS];\n"
+"	vec4 u_lightDirection[MAX_LIGHTS];\n"
+"	vec4 u_lightColor[MAX_LIGHTS];\n"
+"};\n"
+"#else\n"
+"uniform mat4 u_world;\n"
+"uniform vec4 u_ambLight;\n"
+"uniform vec4 u_lightParams[MAX_LIGHTS];	// type, radius, minusCosAngle, hardSpot\n"
+"uniform vec4 u_lightPosition[MAX_LIGHTS];\n"
+"uniform vec4 u_lightDirection[MAX_LIGHTS];\n"
+"uniform vec4 u_lightColor[MAX_LIGHTS];\n"
+"#endif\n"
+
+"uniform vec4 u_matColor;\n"
+"uniform vec4 u_surfProps;	// amb, spec, diff, extra\n"
+
 "#define surfAmbient (u_surfProps.x)\n"
 "#define surfSpecular (u_surfProps.y)\n"
 "#define surfDiffuse (u_surfProps.z)\n"
 
-"fixed DoFog(float w, half4 u_fogData)\n"
+"vec3 DoDynamicLight(vec3 V, vec3 N)\n"
+"{\n"
+"	vec3 color = vec3(0.0, 0.0, 0.0);\n"
+"	for(int i = 0; i < MAX_LIGHTS; i++){\n"
+"		if(u_lightParams[i].x == 0.0)\n"
+"			break;\n"
+"#ifdef DIRECTIONALS\n"
+"		if(u_lightParams[i].x == 1.0){\n"
+"			// direct\n"
+"			float l = max(0.0, dot(N, -u_lightDirection[i].xyz));\n"
+"			color += l*u_lightColor[i].rgb;\n"
+"		}else\n"
+"#endif\n"
+"#ifdef POINTLIGHTS\n"
+"		if(u_lightParams[i].x == 2.0){\n"
+"			// point\n"
+"			vec3 dir = V - u_lightPosition[i].xyz;\n"
+"			float dist = length(dir);\n"
+"			float atten = max(0.0, (1.0 - dist/u_lightParams[i].y));\n"
+"			float l = max(0.0, dot(N, -normalize(dir)));\n"
+"			color += l*u_lightColor[i].rgb*atten;\n"
+"		}else\n"
+"#endif\n"
+"#ifdef SPOTLIGHTS\n"
+"		if(u_lightParams[i].x == 3.0){\n"
+"			// spot\n"
+"			vec3 dir = V - u_lightPosition[i].xyz;\n"
+"			float dist = length(dir);\n"
+"			float atten = max(0.0, (1.0 - dist/u_lightParams[i].y));\n"
+"			dir /= dist;\n"
+"			float l = max(0.0, dot(N, -dir));\n"
+"			float pcos = dot(dir, u_lightDirection[i].xyz);	// cos to point\n"
+"			float ccos = -u_lightParams[i].z;\n"
+"			float falloff = (pcos-ccos)/(1.0-ccos);\n"
+"			if(falloff < 0.0)	// outside of cone\n"
+"				l = 0.0;\n"
+"			l *= max(falloff, u_lightParams[i].w);\n"
+"			return l*u_lightColor[i].rgb*atten;\n"
+"		}else\n"
+"#endif\n"
+"			;\n"
+"	}\n"
+"	return color;\n"
+"}\n"
+
+"float DoFog(float w)\n"
 "{\n"
 "	return clamp((w - u_fogEnd)*u_fogRange, u_fogDisable, 1.0);\n"
 "}\n"
diff --git a/src/gl/shaders/im2d.vert b/src/gl/shaders/im2d.vert
index 6cb139f..cdb9da8 100644
--- a/src/gl/shaders/im2d.vert
+++ b/src/gl/shaders/im2d.vert
@@ -1,18 +1,17 @@
-void main(
-	float4 in_pos,
-	half4 in_color,
-	half2 in_tex0,
-	uniform half4 u_fogData,
-	uniform float4 u_xform,
-	half4 out v_color : COLOR0,
-	half2 out v_tex0 : TEXCOORD0,
-	fixed out v_fog : FOG,
-	float4 out gl_Position : POSITION
-) {
+uniform vec4 u_xform;
+
+VSIN(ATTRIB_POS)	vec4 in_pos;
+
+VSOUT vec4 v_color;
+VSOUT vec2 v_tex0;
+VSOUT float v_fog;
+
+void
+main(void)
+{
 	gl_Position = in_pos;
-	gl_Position.w = 1.0;
 	gl_Position.xy = gl_Position.xy * u_xform.xy + u_xform.zw;
-	v_fog = DoFog(gl_Position.z, u_fogData);
+	v_fog = DoFog(gl_Position.w);
 	gl_Position.xyz *= gl_Position.w;
 	v_color = in_color;
 	v_tex0 = in_tex0;
diff --git a/src/gl/shaders/im2d_gl.inc b/src/gl/shaders/im2d_gl.inc
new file mode 100644
index 0000000..4e1d631
--- /dev/null
+++ b/src/gl/shaders/im2d_gl.inc
@@ -0,0 +1,20 @@
+const char *im2d_vert_src =
+"uniform vec4 u_xform;\n"
+
+"VSIN(ATTRIB_POS)	vec4 in_pos;\n"
+
+"VSOUT vec4 v_color;\n"
+"VSOUT vec2 v_tex0;\n"
+"VSOUT float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	gl_Position = in_pos;\n"
+"	gl_Position.xy = gl_Position.xy * u_xform.xy + u_xform.zw;\n"
+"	v_fog = DoFog(gl_Position.w);\n"
+"	gl_Position.xyz *= gl_Position.w;\n"
+"	v_color = in_color;\n"
+"	v_tex0 = in_tex0;\n"
+"}\n"
+;
diff --git a/src/gl/shaders/im3d.vert b/src/gl/shaders/im3d.vert
index cfc1411..7088352 100644
--- a/src/gl/shaders/im3d.vert
+++ b/src/gl/shaders/im3d.vert
@@ -1,17 +1,16 @@
-void main(
-	float3 in_pos,
-	half4 in_color,
-	half2 in_tex0,
-	uniform half4 u_fogData,
-	uniform float4x4 u_wvp,
-	uniform float4x4 u_world,
-	half4 out v_color : COLOR0,
-	half2 out v_tex0 : TEXCOORD0,
-	fixed out v_fog : FOG,
-	float4 out gl_Position : POSITION
-) {
-	gl_Position = mul(float4(in_pos, 1.0), u_wvp);
+VSIN(ATTRIB_POS)	vec3 in_pos;
+
+VSOUT vec4 v_color;
+VSOUT vec2 v_tex0;
+VSOUT float v_fog;
+
+void
+main(void)
+{
+	vec4 Vertex = u_world * vec4(in_pos, 1.0);
+	vec4 CamVertex = u_view * Vertex;
+	gl_Position = u_proj * CamVertex;
 	v_color = in_color;
 	v_tex0 = in_tex0;
-	v_fog = DoFog(gl_Position.w, u_fogData);
+	v_fog = DoFog(gl_Position.w);
 }
diff --git a/src/gl/shaders/im3d_gl.inc b/src/gl/shaders/im3d_gl.inc
new file mode 100644
index 0000000..389589b
--- /dev/null
+++ b/src/gl/shaders/im3d_gl.inc
@@ -0,0 +1,18 @@
+const char *im3d_vert_src =
+"VSIN(ATTRIB_POS)	vec3 in_pos;\n"
+
+"VSOUT vec4 v_color;\n"
+"VSOUT vec2 v_tex0;\n"
+"VSOUT float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 Vertex = u_world * vec4(in_pos, 1.0);\n"
+"	vec4 CamVertex = u_view * Vertex;\n"
+"	gl_Position = u_proj * CamVertex;\n"
+"	v_color = in_color;\n"
+"	v_tex0 = in_tex0;\n"
+"	v_fog = DoFog(gl_Position.w);\n"
+"}\n"
+;
diff --git a/src/gl/shaders/matfx_env.frag b/src/gl/shaders/matfx_env.frag
index 7825fef..0ef20d1 100644
--- a/src/gl/shaders/matfx_env.frag
+++ b/src/gl/shaders/matfx_env.frag
@@ -1,33 +1,34 @@
+uniform sampler2D tex0;
+uniform sampler2D tex1;
+
+uniform vec4 u_fxparams;
+
 #define shininess (u_fxparams.x)
 #define disableFBA (u_fxparams.y)
 
-float4 main(
-	half4 v_color : COLOR0,
-	half2 v_tex0 : TEXCOORD0,
-	half2 v_tex1 : TEXCOORD1,
-	fixed v_fog : FOG,
-	uniform half4 u_fogColor,
-	uniform half2 u_alphaRef,
-	uniform half4 u_colorClamp,
-	uniform half2 u_fxparams,
-	uniform sampler2D tex0 : TEXUNIT0,
-	uniform sampler2D tex1 : TEXUNIT1
-) {
-	half4 pass1 = v_color;
-	half4 envColor = max(pass1, u_colorClamp);
-	pass1 *= tex2D(tex0, half2(v_tex0.x, 1.0-v_tex0.y));
+FSIN vec4 v_color;
+FSIN vec4 v_envColor;
+FSIN vec2 v_tex0;
+FSIN vec2 v_tex1;
+FSIN float v_fog;
 
-	half4 pass2 = envColor*shininess*tex2D(tex1, half2(v_tex1.x, 1.0-v_tex1.y));
+void
+main(void)
+{
+	vec4 pass1 = v_color;
+	pass1 *= texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));
 
-	pass1.rgb = lerp(u_fogColor.rgb, pass1.rgb, v_fog);
-	pass2.rgb = lerp(half3(0.0, 0.0, 0.0), pass2.rgb, v_fog);
-	
-	half fba = max(pass1.a, disableFBA);
-	float4 color;
+	vec4 pass2 = v_envColor*shininess*texture(tex1, vec2(v_tex1.x, 1.0-v_tex1.y));
+
+	pass1.rgb = mix(u_fogColor.rgb, pass1.rgb, v_fog);
+	pass2.rgb = mix(vec3(0.0, 0.0, 0.0), pass2.rgb, v_fog);
+
+	float fba = max(pass1.a, disableFBA);
+	vec4 color;
 	color.rgb = pass1.rgb*pass1.a + pass2.rgb*fba;
 	color.a = pass1.a;
 
-	DoAlphaTest(color.a, u_alphaRef);
-	
-	return color;
+	DoAlphaTest(color.a);
+
+	FRAGCOLOR(color);
 }
diff --git a/src/gl/shaders/matfx_env.vert b/src/gl/shaders/matfx_env.vert
index 00e2c59..580a49f 100644
--- a/src/gl/shaders/matfx_env.vert
+++ b/src/gl/shaders/matfx_env.vert
@@ -1,47 +1,31 @@
-void main(
-	float3 in_pos,
-	float3 in_normal,
-	fixed4 in_color,
-	half2 in_tex0,
-	uniform float4x4 u_wvp,
-	uniform float4x4 u_world,
-	uniform float4x4 u_texMatrix,
-	uniform half4 u_ambLight,
-	uniform half4 u_surfProps,
-	uniform half4 u_fogData,
-	uniform half4 u_matColor,
-	uniform half4 u_lightParams[MAX_LIGHTS],
-	uniform half4 u_lightDirection[MAX_LIGHTS],
-	uniform half4 u_lightColor[MAX_LIGHTS],
-	half4 out v_color : COLOR0,
-	half2 out v_tex0 : TEXCOORD0,
-	half2 out v_tex1 : TEXCOORD1,
-	fixed out v_fog : FOG,
-	float4 out gl_Position : POSITION
-) {
-	gl_Position = mul(float4(in_pos, 1.0), u_wvp);
-	float3 Normal = mul(in_normal, float3x3(u_world));
+uniform mat4 u_texMatrix;
+uniform vec4 u_colorClamp;
+uniform vec4 u_envColor;
+
+VSIN(ATTRIB_POS)	vec3 in_pos;
+
+VSOUT vec4 v_color;
+VSOUT vec4 v_envColor;
+VSOUT vec2 v_tex0;
+VSOUT vec2 v_tex1;
+VSOUT float v_fog;
+
+void
+main(void)
+{
+	vec4 Vertex = u_world * vec4(in_pos, 1.0);
+	gl_Position = u_proj * u_view * Vertex;
+	vec3 Normal = mat3(u_world) * in_normal;
 
 	v_tex0 = in_tex0;
-	v_tex1 = (mul(float4(Normal, 1.0), u_texMatrix)).xy;
+	v_tex1 = (u_texMatrix * vec4(Normal, 1.0)).xy;
 
 	v_color = in_color;
 	v_color.rgb += u_ambLight.rgb*surfAmbient;
-	
-	half3 color = float3(0.0, 0.0, 0.0);
-	for(int i = 0; i < MAX_LIGHTS; i++){
-		if(u_lightParams[i].x == 0.0)
-			break;
-		if(u_lightParams[i].x == 1.0){
-			// direct
-			fixed l = max(0.0, dot(Normal, -u_lightDirection[i].xyz));
-			color += l*u_lightColor[i].rgb;
-		}
-	}
-	
-	v_color.rgb += color*surfDiffuse;
+	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;
 	v_color = clamp(v_color, 0.0, 1.0);
+	v_envColor = max(v_color, u_colorClamp) * u_envColor;
 	v_color *= u_matColor;
 
-	v_fog = DoFog(gl_Position.w, u_fogData);
+	v_fog = DoFog(gl_Position.w);
 }
diff --git a/src/gl/shaders/matfx_gl.inc b/src/gl/shaders/matfx_gl.inc
new file mode 100644
index 0000000..329ee31
--- /dev/null
+++ b/src/gl/shaders/matfx_gl.inc
@@ -0,0 +1,69 @@
+const char *matfx_env_vert_src =
+"uniform mat4 u_texMatrix;\n"
+"uniform vec4 u_colorClamp;\n"
+"uniform vec4 u_envColor;\n"
+"\n"
+"VSIN(ATTRIB_POS)	vec3 in_pos;\n"
+"\n"
+"VSOUT vec4 v_color;\n"
+"VSOUT vec4 v_envColor;\n"
+"VSOUT vec2 v_tex0;\n"
+"VSOUT vec2 v_tex1;\n"
+"VSOUT float v_fog;\n"
+"\n"
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 Vertex = u_world * vec4(in_pos, 1.0);\n"
+"	gl_Position = u_proj * u_view * Vertex;\n"
+"	vec3 Normal = mat3(u_world) * in_normal;\n"
+"\n"
+"	v_tex0 = in_tex0;\n"
+"	v_tex1 = (u_texMatrix * vec4(Normal, 1.0)).xy;\n"
+"\n"
+"	v_color = in_color;\n"
+"	v_color.rgb += u_ambLight.rgb*surfAmbient;\n"
+"	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;\n"
+"	v_color = clamp(v_color, 0.0, 1.0);\n"
+"	v_envColor = max(v_color, u_colorClamp) * u_envColor;\n"
+"	v_color *= u_matColor;\n"
+"\n"
+"	v_fog = DoFog(gl_Position.w);\n"
+"}\n"
+;
+const char *matfx_env_frag_src =
+"uniform sampler2D tex0;\n"
+"uniform sampler2D tex1;\n"
+"\n"
+"uniform vec4 u_fxparams;\n"
+"\n"
+"#define shininess (u_fxparams.x)\n"
+"#define disableFBA (u_fxparams.y)\n"
+"\n"
+"FSIN vec4 v_color;\n"
+"FSIN vec4 v_envColor;\n"
+"FSIN vec2 v_tex0;\n"
+"FSIN vec2 v_tex1;\n"
+"FSIN float v_fog;\n"
+"\n"
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 pass1 = v_color;\n"
+"	pass1 *= texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));\n"
+"\n"
+"	vec4 pass2 = v_envColor*shininess*texture(tex1, vec2(v_tex1.x, 1.0-v_tex1.y));\n"
+"\n"
+"	pass1.rgb = mix(u_fogColor.rgb, pass1.rgb, v_fog);\n"
+"	pass2.rgb = mix(vec3(0.0, 0.0, 0.0), pass2.rgb, v_fog);\n"
+"\n"
+"	float fba = max(pass1.a, disableFBA);\n"
+"	vec4 color;\n"
+"	color.rgb = pass1.rgb*pass1.a + pass2.rgb*fba;\n"
+"	color.a = pass1.a;\n"
+"\n"
+"	DoAlphaTest(color.a);\n"
+"\n"
+"	FRAGCOLOR(color);\n"
+"}\n"
+;
diff --git a/src/gl/shaders/simple.frag b/src/gl/shaders/simple.frag
index 98279ff..32b2afb 100644
--- a/src/gl/shaders/simple.frag
+++ b/src/gl/shaders/simple.frag
@@ -1,15 +1,15 @@
-float4 main(
-	half4 v_color : COLOR0,
-	half2 v_tex0 : TEXCOORD0,
-	fixed v_fog : FOG,
-	uniform half4 u_fogColor,
-	uniform half2 u_alphaRef,
-	uniform sampler2D tex0
-) {
-	half4 color = v_color*tex2D(tex0, half2(v_tex0.x, 1.0-v_tex0.y));
-	color.rgb = lerp(u_fogColor.rgb, color.rgb, v_fog);
-	DoAlphaTest(color.a, u_alphaRef);
-	
-	return color;
+uniform sampler2D tex0;
+
+FSIN vec4 v_color;
+FSIN vec2 v_tex0;
+FSIN float v_fog;
+
+void
+main(void)
+{
+	vec4 color = v_color*texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));
+	color.rgb = mix(u_fogColor.rgb, color.rgb, v_fog);
+	DoAlphaTest(color.a);
+	FRAGCOLOR(color);
 }
 
diff --git a/src/gl/shaders/simple_fs_gl.inc b/src/gl/shaders/simple_fs_gl.inc
new file mode 100644
index 0000000..a9216ca
--- /dev/null
+++ b/src/gl/shaders/simple_fs_gl.inc
@@ -0,0 +1,17 @@
+const char *simple_frag_src =
+"uniform sampler2D tex0;\n"
+
+"FSIN vec4 v_color;\n"
+"FSIN vec2 v_tex0;\n"
+"FSIN float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec4 color = v_color*texture(tex0, vec2(v_tex0.x, 1.0-v_tex0.y));\n"
+"	color.rgb = mix(u_fogColor.rgb, color.rgb, v_fog);\n"
+"	DoAlphaTest(color.a);\n"
+"	FRAGCOLOR(color);\n"
+"}\n"
+
+;
diff --git a/src/gl/shaders/skin.vert b/src/gl/shaders/skin.vert
index 1df8a5b..7408542 100644
--- a/src/gl/shaders/skin.vert
+++ b/src/gl/shaders/skin.vert
@@ -1,55 +1,32 @@
-void main(
-	float3 in_pos,
-	float3 in_normal,
-	fixed4 in_color,
-	half2 in_tex0,
-	float4 in_weights,
-	float4 in_indices,
-	uniform float4x4 u_wvp,
-	uniform float4x4 u_world,
-	uniform half4 u_ambLight,
-	uniform half4 u_surfProps,
-	uniform half4 u_fogData,
-	uniform half4 u_matColor,
-	uniform half4 u_lightParams[MAX_LIGHTS],
-	uniform half4 u_lightDirection[MAX_LIGHTS],
-	uniform half4 u_lightColor[MAX_LIGHTS],
-	uniform float4x4 u_boneMatrices[64],
-	half4 out v_color : COLOR0,
-	half2 out v_tex0 : TEXCOORD0,
-	fixed out v_fog : FOG,
-	float4 out gl_Position : POSITION
-) {
-	float4x4 Skin = u_boneMatrices[(int)(in_indices.x * 255)] * in_weights.x
-		+ u_boneMatrices[(int)(in_indices.y * 255)] * in_weights.y
-		+ u_boneMatrices[(int)(in_indices.z * 255)] * in_weights.z
-		+ u_boneMatrices[(int)(in_indices.w * 255)] * in_weights.w;
-		
-	float3 SkinVertex = (mul(float4(in_pos, 1.f), Skin)).xyz;
-	float3 SkinNormal = (mul(float4(in_normal, 0.f), Skin)).xyz;
-	
-	gl_Position = mul(float4(SkinVertex, 1.0), u_wvp);
-	float3 Normal = mul(SkinNormal, float3x3(u_world));
+uniform mat4 u_boneMatrices[64];
+
+VSIN(ATTRIB_POS)	vec3 in_pos;
+
+VSOUT vec4 v_color;
+VSOUT vec2 v_tex0;
+VSOUT float v_fog;
+
+void
+main(void)
+{
+	vec3 SkinVertex = vec3(0.0, 0.0, 0.0);
+	vec3 SkinNormal = vec3(0.0, 0.0, 0.0);
+	for(int i = 0; i < 4; i++){
+		SkinVertex += (u_boneMatrices[int(in_indices[i])] * vec4(in_pos, 1.0)).xyz * in_weights[i];
+		SkinNormal += (mat3(u_boneMatrices[int(in_indices[i])]) * in_normal) * in_weights[i];
+	}
+
+	vec4 Vertex = u_world * vec4(SkinVertex, 1.0);
+	gl_Position = u_proj * u_view * Vertex;
+	vec3 Normal = mat3(u_world) * SkinNormal;
 
 	v_tex0 = in_tex0;
 
 	v_color = in_color;
 	v_color.rgb += u_ambLight.rgb*surfAmbient;
-	
-	half3 color = half3(0.0, 0.0, 0.0);
-	for(int i = 0; i < MAX_LIGHTS; i++){
-		if(u_lightParams[i].x == 0.0)
-			break;
-		if(u_lightParams[i].x == 1.0){
-			// direct
-			fixed l = max(0.0, dot(Normal, -u_lightDirection[i].xyz));
-			color += l*u_lightColor[i].rgb;
-		}
-	}
-	
-	v_color.rgb += color*surfDiffuse;
+	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;
 	v_color = clamp(v_color, 0.0, 1.0);
 	v_color *= u_matColor;
 
-	v_fog = DoFog(gl_Position.z, u_fogData);
+	v_fog = DoFog(gl_Position.z);
 }
diff --git a/src/gl/shaders/skin_gl.inc b/src/gl/shaders/skin_gl.inc
new file mode 100644
index 0000000..7d1268e
--- /dev/null
+++ b/src/gl/shaders/skin_gl.inc
@@ -0,0 +1,34 @@
+const char *skin_vert_src =
+"uniform mat4 u_boneMatrices[64];\n"
+
+"VSIN(ATTRIB_POS)	vec3 in_pos;\n"
+
+"VSOUT vec4 v_color;\n"
+"VSOUT vec2 v_tex0;\n"
+"VSOUT float v_fog;\n"
+
+"void\n"
+"main(void)\n"
+"{\n"
+"	vec3 SkinVertex = vec3(0.0, 0.0, 0.0);\n"
+"	vec3 SkinNormal = vec3(0.0, 0.0, 0.0);\n"
+"	for(int i = 0; i < 4; i++){\n"
+"		SkinVertex += (u_boneMatrices[int(in_indices[i])] * vec4(in_pos, 1.0)).xyz * in_weights[i];\n"
+"		SkinNormal += (mat3(u_boneMatrices[int(in_indices[i])]) * in_normal) * in_weights[i];\n"
+"	}\n"
+
+"	vec4 Vertex = u_world * vec4(SkinVertex, 1.0);\n"
+"	gl_Position = u_proj * u_view * Vertex;\n"
+"	vec3 Normal = mat3(u_world) * SkinNormal;\n"
+
+"	v_tex0 = in_tex0;\n"
+
+"	v_color = in_color;\n"
+"	v_color.rgb += u_ambLight.rgb*surfAmbient;\n"
+"	v_color.rgb += DoDynamicLight(Vertex.xyz, Normal)*surfDiffuse;\n"
+"	v_color = clamp(v_color, 0.0, 1.0);\n"
+"	v_color *= u_matColor;\n"
+
+"	v_fog = DoFog(gl_Position.z);\n"
+"}\n"
+;
diff --git a/src/gl/wdgl.cpp b/src/gl/wdgl.cpp
index 43ae467..14b772c 100644
--- a/src/gl/wdgl.cpp
+++ b/src/gl/wdgl.cpp
@@ -13,16 +13,12 @@
 #include "../rwplugins.h"
 #include "rwwdgl.h"
 
+#ifdef RW_OPENGL
 #ifdef PSP2
 #include <vitasdk.h>
 #include <vitaGL.h>
 #else
-#ifdef RW_OPENGL
-#ifndef LIBRW_GLAD
-#include <GL/glew.h>
-#else
-#include <glad/glad.h>
-#endif
+#include "glad/glad.h"
 #endif
 #endif
 
@@ -86,6 +82,50 @@ printAttribInfo(AttribDesc *attribs, int n)
 }
 */
 
+#ifdef RW_OPENGL
+void
+uploadGeo(Geometry *geo)
+{
+	InstanceDataHeader *inst = (InstanceDataHeader*)geo->instData;
+	MeshHeader *meshHeader = geo->meshHeader;
+
+	glGenBuffers(1, &inst->vbo);
+	glBindBuffer(GL_ARRAY_BUFFER, inst->vbo);
+	glBufferData(GL_ARRAY_BUFFER, inst->dataSize,
+	             inst->data, GL_STATIC_DRAW);
+
+	glGenBuffers(1, &inst->ibo);
+	glBindBuffer(GL_ARRAY_BUFFER, inst->ibo);
+	glBufferData(GL_ARRAY_BUFFER, meshHeader->totalIndices*2,
+	             0, GL_STATIC_DRAW);
+	GLintptr offset = 0;
+	for(uint32 i = 0; i < meshHeader->numMeshes; i++){
+		Mesh *mesh = &meshHeader->getMeshes()[i];
+		glBufferSubData(GL_ARRAY_BUFFER, offset, mesh->numIndices*2,
+		                mesh->indices);
+		offset += mesh->numIndices*2;
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+void
+setAttribPointers(InstanceDataHeader *inst)
+{
+	static GLenum attribType[] = {
+		GL_FLOAT,
+		GL_BYTE, GL_UNSIGNED_BYTE,
+		GL_SHORT, GL_UNSIGNED_SHORT
+	};
+	for(int32 i = 0; i < inst->numAttribs; i++){
+		AttribDesc *a = &inst->attribs[i];
+		glEnableVertexAttribArray(a->index);
+		glVertexAttribPointer(a->index, a->size, attribType[a->type],
+		                      a->normalized, a->stride,
+		                      (void*)(uint64)a->offset);
+	}
+}
+#endif
+
 void
 packattrib(uint8 *dst, float32 *src, AttribDesc *a, float32 scale=1.0f)
 {
@@ -95,7 +135,7 @@ packattrib(uint8 *dst, float32 *src, AttribDesc *a, float32 scale=1.0f)
 
 	switch(a->type){
 	case 0:	// float
-		memcpy_neon(dst, src, a->size*4);
+		memcpy(dst, src, a->size*4);
 		break;
 
 	// TODO: maybe have loop inside if?
@@ -149,7 +189,7 @@ unpackattrib(float *dst, uint8 *src, AttribDesc *a, float32 scale=1.0f)
 
 	switch(a->type){
 	case 0:	// float
-		memcpy_neon(dst, src, a->size*4);
+		memcpy(dst, src, a->size*4);
 		break;
 
 	// TODO: maybe have loop inside if?
@@ -616,7 +656,7 @@ skinUninstanceCB(Geometry *geo)
 	uint8 *data = skin->data;
 	float *invMats = skin->inverseMatrices;
 	skin->init(skin->numBones, skin->numBones, geo->numVertices);
-	memcpy_neon(skin->inverseMatrices, invMats, skin->numBones*64);
+	memcpy(skin->inverseMatrices, invMats, skin->numBones*64);
 	rwFree(data);
 
 	uint8 *p;
@@ -798,7 +838,12 @@ Texture::upload(void)
 
 	static GLenum wrap[] = {
 		0, GL_REPEAT, GL_MIRRORED_REPEAT,
+#ifdef PSP2
+		// vitaGL has no border clamp, gxm only does clamp/repeat/mirror
 		GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE
+#else
+		GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER
+#endif
 	};
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
 		wrap[(this->filterAddressing >> 8) & 0xF]);
@@ -807,7 +852,7 @@ Texture::upload(void)
 
 	switch(r->format & 0xF00){
 	case Raster::C8888:
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, r->width, r->height,
+		glTexImage2D(GL_TEXTURE_2D, 0, 4, r->width, r->height,
 		             0, GL_RGBA, GL_UNSIGNED_BYTE, r->pixels);
 		break;
 	default:
diff --git a/src/hanim.cpp b/src/hanim.cpp
index 3f1ecb6..6bc7c5e 100644
--- a/src/hanim.cpp
+++ b/src/hanim.cpp
@@ -307,7 +307,7 @@ getSizeHAnim(void *object, int32 offset, int32)
 {
 	HAnimData *hanim = PLUGINOFFSET(HAnimData, object, offset);
 	if(!hAnimDoStream ||
-	   version >= 0x35000 && hanim->id == -1 && hanim->hierarchy == nil)
+	   (version >= 0x35000 && hanim->id == -1 && hanim->hierarchy == nil))
 		return 0;
 	if(hanim->hierarchy)
 		return 12 + 8 + hanim->hierarchy->numNodes*12;
@@ -408,6 +408,7 @@ registerHAnimPlugin(void)
 	Frame::registerPluginStream(ID_HANIM,
 	                            readHAnim,
 	                            writeHAnim,
-	                            getSizeHAnim);}
+	                            getSizeHAnim);
+}
 
 }
diff --git a/src/image.cpp b/src/image.cpp
index 6c97ab8..1124374 100644
--- a/src/image.cpp
+++ b/src/image.cpp
@@ -17,9 +17,6 @@
 
 #define PLUGIN_ID ID_IMAGE
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
 namespace rw {
 
 int32 Image::numAllocated;
@@ -114,6 +111,15 @@ Image::setPixels(uint8 *pixels)
 	this->flags |= 1;
 }
 
+// The DXT decoders below read 16/32/64-bit words straight out of the
+// compressed block with pointer casts. That is fine on x86 but faults on ARM:
+// the block data is not guaranteed 8-byte aligned (e.g. the 64-bit alpha word
+// sits at a +2 offset in DXT5), and an unaligned ldrd is a data abort. Read
+// through memcpy, which the compiler lowers to alignment-safe access.
+static inline uint16 rdU16(const uint8 *p){ uint16 v; memcpy(&v, p, sizeof(v)); return v; }
+static inline uint32 rdU32(const uint8 *p){ uint32 v; memcpy(&v, p, sizeof(v)); return v; }
+static inline uint64 rdU64(const uint8 *p){ uint64 v; memcpy(&v, p, sizeof(v)); return v; }
+
 void
 decompressDXT1(uint8 *adst, int32 w, int32 h, uint8 *src)
 {
@@ -125,8 +131,8 @@ decompressDXT1(uint8 *adst, int32 w, int32 h, uint8 *src)
 	uint8 (*dst)[4] = (uint8(*)[4])adst;
 	for(int32 j = 0; j < w*h/2; j += 8){
 		/* calculate colors */
-		uint32 col0 = *((uint16*)&src[j+0]);
-		uint32 col1 = *((uint16*)&src[j+2]);
+		uint32 col0 = rdU16(&src[j+0]);
+		uint32 col1 = rdU16(&src[j+2]);
 		c[0][0] = ((col0>>11) & 0x1F)*0xFF/0x1F;
 		c[0][1] = ((col0>> 5) & 0x3F)*0xFF/0x3F;
 		c[0][2] = ( col0      & 0x1F)*0xFF/0x1F;
@@ -159,15 +165,15 @@ decompressDXT1(uint8 *adst, int32 w, int32 h, uint8 *src)
 		}
 
 		/* make index list */
-		uint32 indices = *((uint32*)&src[j+4]);
+		uint32 indices = rdU32(&src[j+4]);
 		for(int32 k = 0; k < 16; k++){
 			idx[k] = indices & 0x3;
 			indices >>= 2;
 		}
 
 		/* write bytes */
-		for(uint32 k = 0; k < 4; k++)
-			for(uint32 l = 0; l < 4; l++){
+		for(uint32 l = 0; l < 4; l++)
+			for(uint32 k = 0; k < 4; k++){
 				dst[(y+l)*w + x+k][0] = c[idx[l*4+k]][0];
 				dst[(y+l)*w + x+k][1] = c[idx[l*4+k]][1];
 				dst[(y+l)*w + x+k][2] = c[idx[l*4+k]][2];
@@ -193,8 +199,8 @@ decompressDXT3(uint8 *adst, int32 w, int32 h, uint8 *src)
 	uint8 (*dst)[4] = (uint8(*)[4])adst;
 	for(int32 j = 0; j < w*h; j += 16){
 		/* calculate colors */
-		uint32 col0 = *((uint16*)&src[j+8]);
-		uint32 col1 = *((uint16*)&src[j+10]);
+		uint32 col0 = rdU16(&src[j+8]);
+		uint32 col1 = rdU16(&src[j+10]);
 		c[0][0] = ((col0>>11) & 0x1F)*0xFF/0x1F;
 		c[0][1] = ((col0>> 5) & 0x3F)*0xFF/0x3F;
 		c[0][2] = ( col0      & 0x1F)*0xFF/0x1F;
@@ -212,20 +218,20 @@ decompressDXT3(uint8 *adst, int32 w, int32 h, uint8 *src)
 		c[3][2] = (1*c[0][2] + 2*c[1][2])/3;
 
 		/* make index list */
-		uint32 indices = *((uint32*)&src[j+12]);
+		uint32 indices = rdU32(&src[j+12]);
 		for(int32 k = 0; k < 16; k++){
 			idx[k] = indices & 0x3;
 			indices >>= 2;
 		}
-		uint64 alphas = *((uint64*)&src[j+0]);
+		uint64 alphas = rdU64(&src[j+0]);
 		for(int32 k = 0; k < 16; k++){
 			a[k] = (alphas & 0xF)*17;
 			alphas >>= 4;
 		}
 
 		/* write bytes */
-		for(uint32 k = 0; k < 4; k++)
-			for(uint32 l = 0; l < 4; l++){
+		for(uint32 l = 0; l < 4; l++)
+			for(uint32 k = 0; k < 4; k++){
 				dst[(y+l)*w + x+k][0] = c[idx[l*4+k]][0];
 				dst[(y+l)*w + x+k][1] = c[idx[l*4+k]][1];
 				dst[(y+l)*w + x+k][2] = c[idx[l*4+k]][2];
@@ -252,8 +258,8 @@ decompressDXT5(uint8 *adst, int32 w, int32 h, uint8 *src)
 	uint8 (*dst)[4] = (uint8(*)[4])adst;
 	for(int32 j = 0; j < w*h; j += 16){
 		/* calculate colors */
-		uint32 col0 = *((uint16*)&src[j+8]);
-		uint32 col1 = *((uint16*)&src[j+10]);
+		uint32 col0 = rdU16(&src[j+8]);
+		uint32 col1 = rdU16(&src[j+10]);
 		c[0][0] = ((col0>>11) & 0x1F)*0xFF/0x1F;
 		c[0][1] = ((col0>> 5) & 0x3F)*0xFF/0x3F;
 		c[0][2] = ( col0      & 0x1F)*0xFF/0x1F;
@@ -298,21 +304,21 @@ decompressDXT5(uint8 *adst, int32 w, int32 h, uint8 *src)
 		}
 
 		/* make index list */
-		uint32 indices = *((uint32*)&src[j+12]);
+		uint32 indices = rdU32(&src[j+12]);
 		for(int32 k = 0; k < 16; k++){
 			idx[k] = indices & 0x3;
 			indices >>= 2;
 		}
 		// only 6 indices
-		uint64 alphas = *((uint64*)&src[j+2]);
+		uint64 alphas = rdU64(&src[j+2]);
 		for(int32 k = 0; k < 16; k++){
 			aidx[k] = alphas & 0x7;
 			alphas >>= 3;
 		}
 
 		/* write bytes */
-		for(uint32 k = 0; k < 4; k++)
-			for(uint32 l = 0; l < 4; l++){
+		for(uint32 l = 0; l < 4; l++)
+			for(uint32 k = 0; k < 4; k++){
 				dst[(y+l)*w + x+k][0] = c[idx[l*4+k]][0];
 				dst[(y+l)*w + x+k][1] = c[idx[l*4+k]][1];
 				dst[(y+l)*w + x+k][2] = c[idx[l*4+k]][2];
@@ -326,6 +332,226 @@ decompressDXT5(uint8 *adst, int32 w, int32 h, uint8 *src)
 	}
 }
 
+// not strictly image but related
+
+// flip a DXT 2-bit block
+static void
+flipBlock(uint8 *dst, uint8 *src)
+{
+	// color
+	dst[0] = src[0];
+	dst[1] = src[1];
+	dst[2] = src[2];
+	dst[3] = src[3];
+	// bits
+	dst[4] = src[7];
+	dst[5] = src[6];
+	dst[6] = src[5];
+	dst[7] = src[4];
+}
+
+// flip top 2 rows of a DXT 2-bit block
+static void
+flipBlock_half(uint8 *dst, uint8 *src)
+{
+	// color
+	dst[0] = src[0];
+	dst[1] = src[1];
+	dst[2] = src[2];
+	dst[3] = src[3];
+	// bits
+	dst[4] = src[5];
+	dst[5] = src[4];
+	dst[6] = src[6];
+	dst[7] = src[7];
+}
+
+// flip a DXT3 4-bit alpha block
+static void
+flipAlphaBlock3(uint8 *dst, uint8 *src)
+{
+	dst[6] = src[0];
+	dst[7] = src[1];
+	dst[4] = src[2];
+	dst[5] = src[3];
+	dst[2] = src[4];
+	dst[3] = src[5];
+	dst[0] = src[6];
+	dst[1] = src[7];
+}
+
+// flip top 2 rows of a DXT3 4-bit alpha block
+static void
+flipAlphaBlock3_half(uint8 *dst, uint8 *src)
+{
+	dst[0] = src[2];
+	dst[1] = src[3];
+	dst[2] = src[0];
+	dst[3] = src[1];
+	dst[4] = src[4];
+	dst[5] = src[5];
+	dst[6] = src[6];
+	dst[7] = src[7];
+}
+
+// flip a DXT5 3-bit alpha block
+static void
+flipAlphaBlock5(uint8 *dst, uint8 *src)
+{
+	// color
+	dst[0] = src[0];
+	dst[1] = src[1];
+	// bits
+	uint64 bits = rdU64(&src[2]);
+	uint64 flipbits = 0;
+	for(int i = 0; i < 4; i++){
+		flipbits <<= 12;
+		flipbits |= bits & 0xFFF;
+		bits >>= 12;
+	}
+	memcpy(dst+2, &flipbits, 6);
+}
+
+// flip top 2 rows of a DXT5 3-bit alpha block
+static void
+flipAlphaBlock5_half(uint8 *dst, uint8 *src)
+{
+	// color
+	dst[0] = src[0];
+	dst[1] = src[1];
+	// bits
+	uint64 bits = rdU64(&src[2]);
+	uint64 flipbits = bits & 0xFFFFFF000000;
+	flipbits |= (bits>>12) & 0xFFF;
+	flipbits |= (bits<<12) & 0xFFF000;
+	memcpy(dst+2, &flipbits, 6);
+}
+
+void
+flipDXT1(uint8 *dst, uint8 *src, uint32 width, uint32 height)
+{
+	int x, y;
+	int bw = (width+3)/4;
+	int bh = (height+3)/4;
+	if(height < 4){
+		// used pixels are always at the top
+		// so don't swap the full 4 rows
+		if(height == 2){
+			uint8 *s = src;
+			uint8 *d = dst;
+			for(x = 0; x < bw; x++){
+				flipBlock_half(dst, src);
+				s += 8;
+				d += 8;
+			}
+		}else
+			memcpy(dst, src, 8*bw);
+		return;
+	}
+	dst += 8*bw*bh;
+	for(y = 0; y < bh; y++){
+		dst -= 8*bw;
+		uint8 *s = src;
+		uint8 *d = dst;
+		for(x = 0; x < bw; x++){
+			flipBlock(d, s);
+			s += 8;
+			d += 8;
+		}
+		src += 8*bw;
+	}
+}
+
+void
+flipDXT3(uint8 *dst, uint8 *src, uint32 width, uint32 height)
+{
+	int x, y;
+	int bw = (width+3)/4;
+	int bh = (height+3)/4;
+	if(height < 4){
+		// used pixels are always at the top
+		// so don't swap the full 4 rows
+		if(height == 2){
+			uint8 *s = src;
+			uint8 *d = dst;
+			for(x = 0; x < bw; x++){
+				flipAlphaBlock3_half(d, s);
+				flipBlock_half(d+8, s+8);
+				s += 16;
+				d += 16;
+			}
+		}else
+			memcpy(dst, src, 16*bw);
+		return;
+	}
+	dst += 16*bw*bh;
+	for(y = 0; y < bh; y++){
+		dst -= 16*bw;
+		uint8 *s = src;
+		uint8 *d = dst;
+		for(x = 0; x < bw; x++){
+			flipAlphaBlock3(d, s);
+			flipBlock(d+8, s+8);
+			s += 16;
+			d += 16;
+		}
+		src += 16*bw;
+	}
+}
+
+void
+flipDXT5(uint8 *dst, uint8 *src, uint32 width, uint32 height)
+{
+	int x, y;
+	int bw = (width+3)/4;
+	int bh = (height+3)/4;
+	if(height < 4){
+		// used pixels are always at the top
+		// so don't swap the full 4 rows
+		if(height == 2){
+			uint8 *s = src;
+			uint8 *d = dst;
+			for(x = 0; x < bw; x++){
+				flipAlphaBlock5_half(d, s);
+				flipBlock_half(d+8, s+8);
+				s += 16;
+				d += 16;
+			}
+		}else
+			memcpy(dst, src, 16*bw);
+		return;
+	}
+	dst += 16*bw*bh;
+	for(y = 0; y < bh; y++){
+		dst -= 16*bw;
+		uint8 *s = src;
+		uint8 *d = dst;
+		for(x = 0; x < bw; x++){
+			flipAlphaBlock5(d, s);
+			flipBlock(d+8, s+8);
+			s += 16;
+			d += 16;
+		}
+		src += 16*bw;
+	}
+}
+
+void
+flipDXT(int32 type, uint8 *dst, uint8 *src, uint32 width, uint32 height)
+{
+	switch(type){
+	case 1:
+		flipDXT1(dst, src, width, height);
+		break;
+	case 3:
+		flipDXT3(dst, src, width, height);
+		break;
+	case 5:
+		flipDXT5(dst, src, width, height);
+		break;
+	}
+}
+
 void
 Image::setPixelsDXT(int32 type, uint8 *pixels)
 {
@@ -479,7 +705,7 @@ Image::palettize(int32 depth)
 	this->palette = nil;
 	this->setPixels(newpixels);
 	this->allocate();
-	memcpy_neon(this->palette, colors, 4*(1<<depth));
+	memcpy(this->palette, colors, 4*(1<<depth));
 
 	quant.destroy();
 }
@@ -677,17 +903,6 @@ Image::extractMask(void)
 	return img;
 }
 
-static char*
-rwstrdup(const char *s)
-{
-	char *t;
-	size_t len = strlen(s)+1;
-	t = (char*)rwMalloc(len, MEMDUR_EVENT);
-	if(t)
-		memcpy_neon(t, s, len);
-	return t;
-}
-
 void
 Image::setSearchPath(const char *path)
 {
@@ -696,7 +911,7 @@ Image::setSearchPath(const char *path)
 	rwFree(g->searchPaths);
 	g->numSearchPaths = 0;
 	if(path)
-		g->searchPaths = p = rwstrdup(path);
+		g->searchPaths = p = rwStrdup(path, MEMDUR_EVENT);
 	else{
 		g->searchPaths = nil;
 		return;
@@ -729,7 +944,7 @@ Image::getFilename(const char *name)
 	char *s, *p = g->searchPaths;
 	size_t len = strlen(name)+1;
 	if(g->numSearchPaths == 0){
-		s = rwstrdup(name);
+		s = rwStrdup(name, MEMDUR_EVENT);
 		makePath(s);
 		f = fopen(s, "rb");
 		if(f){
@@ -819,9 +1034,9 @@ bool32
 Image::registerFileFormat(const char *ext, fileRead read, fileWrite write)
 {
 	ImageGlobals *g = PLUGINOFFSET(ImageGlobals, engine, imageModuleOffset);
-	if(g->numFileFormats >= nelem(g->fileFormats))
+	if(g->numFileFormats >= (int)nelem(g->fileFormats))
 		return 0;
-	g->fileFormats[g->numFileFormats].extension = rwstrdup(ext);
+	g->fileFormats[g->numFileFormats].extension = rwStrdup(ext, MEMDUR_EVENT);
 	g->fileFormats[g->numFileFormats].read = read;
 	g->fileFormats[g->numFileFormats].write = write;
 	g->numFileFormats++;
diff --git a/src/lodepng/lodepng.cpp b/src/lodepng/lodepng.cpp
index e21afdb..ee8cf33 100644
--- a/src/lodepng/lodepng.cpp
+++ b/src/lodepng/lodepng.cpp
@@ -27,8 +27,7 @@ freely, subject to the following restrictions:
 The manual and changelog are in the header file "lodepng.h"
 Rename this file to lodepng.cpp to use it for C++, or to lodepng.c to use it for C.
 */
-#include <vitasdk.h>
-#include <vitaGL.h>
+
 #include "lodepng.h"
 
 #ifdef LODEPNG_COMPILE_DISK
@@ -118,7 +117,7 @@ void lodepng_free(void* ptr);
 where a full C library is not available. The compiler can recognize them and compile
 to something as fast. */
 
-/*static void lodepng_memcpy(void* LODEPNG_RESTRICT dst,
+static void lodepng_memcpy(void* LODEPNG_RESTRICT dst,
                            const void* LODEPNG_RESTRICT src, size_t size) {
   size_t i;
   for(i = 0; i < size; i++) ((char*)dst)[i] = ((const char*)src)[i];
@@ -130,17 +129,14 @@ static void lodepng_memset(void* LODEPNG_RESTRICT dst,
   for(i = 0; i < num; i++) ((char*)dst)[i] = (char)value;
 }
 
- does not check memory out of bounds, do not use on untrusted data
+/* does not check memory out of bounds, do not use on untrusted data */
 static size_t lodepng_strlen(const char* a) {
   const char* orig = a;
-  /* avoid warning about unused function in case of disabled COMPILE... macros
+  /* avoid warning about unused function in case of disabled COMPILE... macros */
   (void)(&lodepng_strlen);
   while(*a) a++;
   return (size_t)(a - orig);
-}*/
-#define lodepng_memcpy memcpy_neon
-#define lodepng_memset memset
-#define lodepng_strlen strlen
+}
 
 #define LODEPNG_MAX(a, b) (((a) > (b)) ? (a) : (b))
 #define LODEPNG_MIN(a, b) (((a) < (b)) ? (a) : (b))
diff --git a/src/matfx.cpp b/src/matfx.cpp
index cb79d1b..c143fc1 100644
--- a/src/matfx.cpp
+++ b/src/matfx.cpp
@@ -24,7 +24,11 @@
 
 namespace rw {
 
-bool32 MatFX::modulateEnvMap;
+bool32 MatFX::envMapFlipU;
+bool32 MatFX::envMapApplyLight;
+bool32 MatFX::envMapUseMatColor;
+RGBA MatFX::envMapColor = { 255, 255, 255, 255 };
+
 
 // Atomic
 
@@ -69,7 +73,7 @@ getSizeAtomicMatFX(void *object, int32 offset, int32)
 
 // Material
 
-MatFXGlobals matFXGlobals = { 0, 0, { nil } };
+MatFXGlobals matFXGlobals = { 0, 0, { nil }, nil };
 
 // TODO: Frames and Matrices?
 static void
@@ -375,7 +379,7 @@ copyMaterialMatFX(void *dst, void *src, int32 offset, int32)
 		return dst;
 	MatFX *dstfx = rwNewT(MatFX, 1, MEMDUR_EVENT | ID_MATFX);
 	*PLUGINOFFSET(MatFX*, dst, offset) = dstfx;
-	memcpy_neon(dstfx, srcfx, sizeof(MatFX));
+	memcpy(dstfx, srcfx, sizeof(MatFX));
 	for(int i = 0; i < 2; i++)
 		switch(dstfx->fx[i].type){
 		case MatFX::BUMPMAP:
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index 3464df3..6284f68 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -9,9 +9,6 @@
 #include "rwobjects.h"
 #include "rwengine.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
 #define COLOR_ARGB(a,r,g,b) \
     ((uint32)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
 
@@ -73,7 +70,7 @@ instV4d(int type, uint8 *dst, V4d *src, uint32 numVertices, uint32 stride)
 {
 	if(type == VERT_FLOAT4)
 		for(uint32 i = 0; i < numVertices; i++){
-			memcpy_neon(dst, src, 16);
+			memcpy(dst, src, 16);
 			dst += stride;
 			src++;
 		}
@@ -86,7 +83,7 @@ instV3d(int type, uint8 *dst, V3d *src, uint32 numVertices, uint32 stride)
 {
 	if(type == VERT_FLOAT3)
 		for(uint32 i = 0; i < numVertices; i++){
-			memcpy_neon(dst, src, 12);
+			memcpy(dst, src, 12);
 			dst += stride;
 			src++;
 		}
@@ -108,7 +105,7 @@ uninstV3d(int type, V3d *dst, uint8 *src, uint32 numVertices, uint32 stride)
 {
 	if(type == VERT_FLOAT3)
 		for(uint32 i = 0; i < numVertices; i++){
-			memcpy_neon(dst, src, 12);
+			memcpy(dst, src, 12);
 			src += stride;
 			dst++;
 		}
@@ -138,7 +135,7 @@ instTexCoords(int type, uint8 *dst, TexCoords *src, uint32 numVertices, uint32 s
 {
 	assert(type == VERT_FLOAT2);
 	for(uint32 i = 0; i < numVertices; i++){
-		memcpy_neon(dst, src, 8);
+		memcpy(dst, src, 8);
 		dst += stride;
 		src++;
 	}
@@ -149,7 +146,7 @@ uninstTexCoords(int type, TexCoords *dst, uint8 *src, uint32 numVertices, uint32
 {
 	assert(type == VERT_FLOAT2);
 	for(uint32 i = 0; i < numVertices; i++){
-		memcpy_neon(dst, src, 8);
+		memcpy(dst, src, 8);
 		src += stride;
 		dst++;
 	}
diff --git a/src/plg.cpp b/src/plg.cpp
index 4c757c8..c5c3782 100644
--- a/src/plg.cpp
+++ b/src/plg.cpp
@@ -95,6 +95,13 @@ PluginList::streamRead(Stream *stream, void *object)
 cont:
 		length -= header.length;
 	}
+
+	// now the always callbacks
+	FORLIST(lnk, this->plugins){
+		Plugin *p = PLG(lnk);
+		if(p->alwaysCallback)
+			p->alwaysCallback(object, p->offset, p->size);
+	}
 	return true;
 }
 
@@ -176,6 +183,7 @@ PluginList::registerPlugin(int32 size, uint32 id,
 	p->write = nil;
 	p->getSize = nil;
 	p->rightsCallback = nil;
+	p->alwaysCallback = nil;
 	p->parentList = this;
 	this->plugins.add(&p->inParentList);
 	allPlugins.add(&p->inGlobalList);
@@ -211,6 +219,19 @@ PluginList::setStreamRightsCallback(uint32 id, RightsCallback cb)
 	return -1;
 }
 
+int32
+PluginList::setStreamAlwaysCallback(uint32 id, AlwaysCallback cb)
+{
+	FORLIST(lnk, this->plugins){
+		Plugin *p = PLG(lnk);
+		if(p->id == id){
+			p->alwaysCallback = cb;
+			return p->offset;
+		}
+	}
+	return -1;
+}
+
 int32
 PluginList::getPluginOffset(uint32 id)
 {
diff --git a/src/png.cpp b/src/png.cpp
index c653e41..45aa102 100644
--- a/src/png.cpp
+++ b/src/png.cpp
@@ -12,14 +12,6 @@
 
 #include "lodepng/lodepng.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
-#ifdef _WIN32
-/* srsly? */
-#define strdup _strdup
-#endif
-
 #define PLUGIN_ID 0
 
 namespace rw {
@@ -28,7 +20,7 @@ namespace rw {
 Image*
 readPNG(const char *filename)
 {
-	Image *image;
+	Image *image = nil;
 	uint32 length;
 	uint8 *data = getFileContents(filename, &length);
 	assert(data != nil);
@@ -49,20 +41,20 @@ readPNG(const char *filename)
 	if(state.info_raw.bitdepth == 4 && state.info_raw.colortype == LCT_PALETTE){
 		image = Image::create(w, h, 4);
 		image->allocate();
-		memcpy_neon(image->palette, state.info_raw.palette, state.info_raw.palettesize*4);
+		memcpy(image->palette, state.info_raw.palette, state.info_raw.palettesize*4);
 		expandPal4_BE(image->pixels, image->stride, raw, w/2, w, h);
 	}else if(state.info_raw.bitdepth == 8){
 		switch(state.info_raw.colortype){
 		case LCT_PALETTE:
 			image = Image::create(w, h, state.info_raw.palettesize <= 16 ? 4 : 8);
 			image->allocate();
-			memcpy_neon(image->palette, state.info_raw.palette, state.info_raw.palettesize*4);
-			memcpy_neon(image->pixels, raw, w*h);
+			memcpy(image->palette, state.info_raw.palette, state.info_raw.palettesize*4);
+			memcpy(image->pixels, raw, w*h);
 			break;
 		case LCT_RGB:
 			image = Image::create(w, h, 24);
 			image->allocate();
-			memcpy_neon(image->pixels, raw, w*h*3);
+			memcpy(image->pixels, raw, w*h*3);
 			break;
 		default:
 			// Second try: just load as 32 bit
@@ -77,7 +69,7 @@ readPNG(const char *filename)
 		case LCT_RGBA:
 			image = Image::create(w, h, 32);
 			image->allocate();
-			memcpy_neon(image->pixels, raw, w*h*4);
+			memcpy(image->pixels, raw, w*h*4);
 			break;
 		}
 	}
diff --git a/src/ps2/ps2.cpp b/src/ps2/ps2.cpp
index dbbcd0a..bd0f54b 100644
--- a/src/ps2/ps2.cpp
+++ b/src/ps2/ps2.cpp
@@ -588,13 +588,14 @@ getInstMeshInfo(MatPipeline *pipe, Geometry *g, Mesh *m)
 	im.numBrokenAttribs = 0;
 	im.vertexSize = 0;
 	for(uint i = 0; i < nelem(pipe->attribs); i++)
-		if(a = pipe->attribs[i])
+		if((a = pipe->attribs[i])) {
 			if(a->attrib & AT_RW)
 				im.numBrokenAttribs++;
 			else{
 				im.vertexSize += attribSize(a->attrib);
 				im.numAttribs++;
 			}
+		}
 	if(g->meshHeader->flags == MeshHeader::TRISTRIP){
 		im.numBatches = (m->numIndices-2) / (pipe->triStripCount-2);
 		im.batchVertCount = pipe->triStripCount;
@@ -758,13 +759,14 @@ MatPipeline::collectData(Geometry *g, InstanceData *inst, Mesh *m, uint8 *data[]
 	uint8 *raw = rwNewT(uint8, im.vertexSize*m->numIndices, MEMDUR_EVENT | ID_GEOMETRY);
 	uint8 *dp = raw;
 	for(uint i = 0; i < nelem(this->attribs); i++)
-		if(a = this->attribs[i])
+		if((a = this->attribs[i])) {
 			if(a->attrib & AT_RW){
 				data[i] = inst->data + im.attribPos[i]*0x10;
 			}else{
 				data[i] = dp;
 				dp += m->numIndices*attribSize(a->attrib);
 			}
+		}
 
 	uint8 *datap[nelem(this->attribs)];
 	memcpy(datap, data, sizeof(datap));
@@ -965,8 +967,8 @@ void
 genericPreCB(MatPipeline *pipe, Geometry *geo)
 {
 	PipeAttribute *a;
-	for(int32 i = 0; i < nelem(pipe->attribs); i++)
-		if(a = pipe->attribs[i])
+	for(int32 i = 0; i < (int)nelem(pipe->attribs); i++)
+		if((a = pipe->attribs[i]))
 			if(a == &attribXYZW){
 				allocateADC(geo);
 				break;
@@ -988,8 +990,8 @@ genericUninstanceCB(MatPipeline *pipe, Geometry *geo, uint32 flags[], Mesh *mesh
 		skin = Skin::get(geo);
 
 	PipeAttribute *a;
-	for(int32 i = 0; i < nelem(pipe->attribs); i++)
-		if(a = pipe->attribs[i]){
+	for(int32 i = 0; i < (int)nelem(pipe->attribs); i++)
+		if((a = pipe->attribs[i])){
 			if(a == &attribXYZ) xyz = (float32*)data[i];
 			else if(a == &attribXYZW) xyzw = (float32*)data[i];
 			else if(a == &attribUV) uv = (float32*)data[i];
diff --git a/src/ps2/ps2raster.cpp b/src/ps2/ps2raster.cpp
index 5258bdb..2b76b8b 100644
--- a/src/ps2/ps2raster.cpp
+++ b/src/ps2/ps2raster.cpp
@@ -76,7 +76,7 @@ transferMinSize(int32 psm, int32 flags, int32 *minw, int32 *minh)
 	}
 }
 
-#define PS2ALIGN(x,a) ((x) + (a)-1 & ~((a)-1))
+#define ALIGN(x,a) ((x) + (a)-1 & ~((a)-1))
 #define ALIGN16(x) ((x) + 0xF & ~0xF)
 #define ALIGN64(x) ((x) + 0x3F & ~0x3F)
 #define NSIZE(dim,pagedim) (((dim) + (pagedim)-1)/(pagedim))
@@ -129,8 +129,8 @@ getRasterFormat(Raster *raster)
 		}
 		raster->depth = cameraZDepth;
 		if(pixelformat){
-			if(raster->depth == 16 && pixelformat != Raster::D16 ||
-			   raster->depth == 32 && pixelformat != Raster::D32){
+			if((raster->depth == 16 && pixelformat != Raster::D16) ||
+			   (raster->depth == 32 && pixelformat != Raster::D32)){
 				RWERROR((ERR_INVRASTER));
 				return 0;
 			}
@@ -668,29 +668,29 @@ calcOffsets(int32 width_Px, int32 height_Px, int32 psm, uint64 *bufferBase_B, ui
 		case PSMT4HL:
 		case PSMT4HH:
 			// ABCDE -> CADBE
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMCT32[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMCT32[bufferBase_B[n]&0x1F];
 			break;
 		case PSMT4:
 		case PSMCT16:
 			// ABCDE -> ADBEC
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMCT16[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMCT16[bufferBase_B[n]&0x1F];
 			break;
 		case PSMCT16S:
 			// ABCDE -> DBAEC
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMCT16S[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMCT16S[bufferBase_B[n]&0x1F];
 			break;
 		case PSMZ32:
 		case PSMZ24:
 			// ABCDE -> ~C~ADBE
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMZ32[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMZ32[bufferBase_B[n]&0x1F];
 			break;
 		case PSMZ16:
 			// ABCDE -> ~A~DBEC
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMZ16[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMZ16[bufferBase_B[n]&0x1F];
 			break;
 		case PSMZ16S:
 			// ABCDE -> ~D~BAEC
-			bufferBase_B[n] = bufferBase_B[n]&~0x1F | (uint64)blockmap_PSMZ16S[bufferBase_B[n]&0x1F];
+			bufferBase_B[n] = (bufferBase_B[n]&~0x1F) | (uint64)blockmap_PSMZ16S[bufferBase_B[n]&0x1F];
 			break;
 		default: break;
 		}
@@ -712,24 +712,24 @@ calcOffsets(int32 width_Px, int32 height_Px, int32 psm, uint64 *bufferBase_B, ui
 	case PSMT8H:
 	case PSMT4HL:
 	case PSMT4HH:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMCT32[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMCT32[paletteBase_B&0x1F];
 		break;
 	case PSMT4:
 	case PSMCT16:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMCT16[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMCT16[paletteBase_B&0x1F];
 		break;
 	case PSMCT16S:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMCT16S[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMCT16S[paletteBase_B&0x1F];
 		break;
 	case PSMZ32:
 	case PSMZ24:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMZ32[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMZ32[paletteBase_B&0x1F];
 		break;
 	case PSMZ16:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMZ16[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMZ16[paletteBase_B&0x1F];
 		break;
 	case PSMZ16S:
-		paletteBase_B = paletteBase_B&~0x1F | (uint64)blockmap_PSMZ16S[paletteBase_B&0x1F];
+		paletteBase_B = (paletteBase_B&~0x1F) | (uint64)blockmap_PSMZ16S[paletteBase_B&0x1F];
 		break;
 	default: break;
 	}
@@ -792,7 +792,7 @@ rasterCreateTexture(Raster *raster)
 	int32 palettePagewidth, palettePageheight;
 
 
-	Ps2Raster *ras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *ras = GETPS2RASTEREXT(raster);
 	pixelformat = raster->format & 0xF00;
 	palformat = raster->format & 0x6000;
 	width = raster->width;
@@ -915,8 +915,8 @@ rasterCreateTexture(Raster *raster)
 
 			// If buffer width changes, align next address to page
 			if(bufferWidth[n] != lastBufferWidth){
-				nPagW = ((width >> n-1) + pageWidth-1)/pageWidth;
-				nPagH = ((height >> n-1) + pageHeight-1)/pageHeight;
+				nPagW = ((width >> (n-1)) + pageWidth-1)/pageWidth;
+				nPagH = ((height >> (n-1)) + pageHeight-1)/pageHeight;
 				nextaddress = (lastaddress + nPagW*nPagH*WD2PG) & ~(WD2PG-1);
 			}
 			lastBufferWidth = bufferWidth[n];
@@ -1052,8 +1052,8 @@ rasterCreateTexture(Raster *raster)
 			ras->flags |= Ps2Raster::SWIZZLED8;
 			if(cpsm == PSMCT32 && bufferWidth[numLevels-1] == 2){	// one page
 				// unswizzle the starting block of the last buffer and palette
-				uint32 bufbase_B = bufferBase[numLevels-1]&~0x1F | (uint64)blockmaprev_PSMCT32[bufferBase[numLevels-1]&0x1F];
-				uint32 palbase_B = ras->paletteBase&~0x1F | (uint64)blockmaprev_PSMCT32[ras->paletteBase&0x1F];
+				uint32 bufbase_B = (bufferBase[numLevels-1]&~0x1F) | (uint64)blockmaprev_PSMCT32[bufferBase[numLevels-1]&0x1F];
+				uint32 palbase_B = (ras->paletteBase&~0x1F) | (uint64)blockmaprev_PSMCT32[ras->paletteBase&0x1F];
 				// find start of page of last level (16,16 are PSMT8 block dimensions)
 				uint32 page_B = bufbase_B - 8*(dsay/16) - dsax/16;
 				// find palette DSAX/Y (in PSMCT32!)
@@ -1072,8 +1072,8 @@ rasterCreateTexture(Raster *raster)
 				// Looks like they wanted to swizzle palettes too...
 				if(cpsm == PSMCT16){
 					// unswizzle the starting block of the last buffer and palette
-					uint32 bufbase_B = bufferBase[numLevels-1]&~0x1F | (uint64)blockmaprev_PSMCT16[bufferBase[numLevels-1]&0x1F];
-					uint32 palbase_B = ras->paletteBase&~0x1F | (uint64)blockmaprev_PSMCT16[ras->paletteBase&0x1F];
+					uint32 bufbase_B = (bufferBase[numLevels-1]&~0x1F) | (uint64)blockmaprev_PSMCT16[bufferBase[numLevels-1]&0x1F];
+					uint32 palbase_B = (ras->paletteBase&~0x1F) | (uint64)blockmaprev_PSMCT16[ras->paletteBase&0x1F];
 					// find start of page of last level (32,16 are PSMT4 block dimensions)
 					uint32 page_B = bufbase_B - 4*(dsay/32) - dsax/16;
 					// find palette DSAX/Y (in PSMCT16!)
@@ -1121,9 +1121,9 @@ rasterCreateTexture(Raster *raster)
 		}
 		// What happens here?
 		if(ras->paletteSize && paltrxpos == 0)
-			ras->dataSize = PS2ALIGN(ras->pixelSize,128) + PS2ALIGN(ras->paletteSize,64) + extrasize + 0x70;
+			ras->dataSize = ALIGN(ras->pixelSize,128) + ALIGN(ras->paletteSize,64) + extrasize + 0x70;
 		else
-			ras->dataSize = PS2ALIGN(ras->paletteSize+ras->pixelSize,64) + extrasize + 0x70;
+			ras->dataSize = ALIGN(ras->paletteSize+ras->pixelSize,64) + extrasize + 0x70;
 		uint8 *data = (uint8*)mallocalign(ras->dataSize, 0x40);
 		uint32 *xferchain = (uint32*)(data + 0x10);
 		assert(data);
@@ -1131,10 +1131,10 @@ rasterCreateTexture(Raster *raster)
 		Ps2Raster::PixelPtr *pp = (Ps2Raster::PixelPtr*)data;
 		pp->numTransfers = numTransfers;
 		pp->numTotalTransfers = numTransfers;
-		pp->pixels = (uint8*)PS2ALIGN((uintptr)data + extrasize, 128);
+		pp->pixels = (uint8*)ALIGN((uintptr)data + extrasize, 128);
 		raster->pixels = (uint8*)pp;
 		if(ras->paletteSize)
-			raster->palette = pp->pixels + PS2ALIGN(ras->pixelSize, 128) + 0x50;
+			raster->palette = pp->pixels + ALIGN(ras->pixelSize, 128) + 0x50;
 		uint32 *p = (uint32*)pp->pixels;
 		w = raster->width;
 		h = raster->height;
@@ -1149,8 +1149,8 @@ rasterCreateTexture(Raster *raster)
 			*p++ = 0;
 
 			// TRXPOS
-			if(ras->flags & Ps2Raster::SWIZZLED8 && psm == PSMT8 ||
-			   ras->flags & Ps2Raster::SWIZZLED4 && psm == PSMT4){
+			if((ras->flags & Ps2Raster::SWIZZLED8 && psm == PSMT8) ||
+			   (ras->flags & Ps2Raster::SWIZZLED4 && psm == PSMT4)){
 				*p++ = 0;	// SSAX/Y is always 0
 				*p++ = (trxpos_hi[n] & ~0x10001)/2;	// divide both DSAX/Y by 2
 			}else{
@@ -1161,8 +1161,8 @@ rasterCreateTexture(Raster *raster)
 			*p++ = 0;
 
 			// TRXREG
-			if(ras->flags & Ps2Raster::SWIZZLED8 && psm == PSMT8 ||
-			   ras->flags & Ps2Raster::SWIZZLED4 && psm == PSMT4){
+			if((ras->flags & Ps2Raster::SWIZZLED8 && psm == PSMT8) ||
+			   (ras->flags & Ps2Raster::SWIZZLED4 && psm == PSMT4)){
 				*p++ = mipw/2;
 				*p++ = miph/2;
 			}else{
@@ -1361,10 +1361,10 @@ swizzle(uint32 x, uint32 y, uint32 logw)
 
 	uint32 nx, ny, n;
 	x ^= (Y(1)^Y(2))<<2;
-	nx = x&7 | (x>>1)&~7;
-	ny = y&1 | (y>>1)&~1;
+	nx = (x&7) | ((x>>1)&~7);
+	ny = (y&1) | ((y>>1)&~1);
 	n = Y(1) | X(3)<<1;
-	return n | nx<<2 | ny<<logw-1+2;
+	return n | nx<<2 | ny<<(logw-1+2);
 }
 
 void
@@ -1375,7 +1375,7 @@ unswizzleRaster(Raster *raster)
 	int32 x, y, w, h;
 	int32 i;
 	int32 logw;
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 	uint8 *px;
 
 	if((raster->format & (Raster::PAL4|Raster::PAL8)) == 0)
@@ -1388,17 +1388,17 @@ unswizzleRaster(Raster *raster)
 	px = raster->pixels;
 	logw = 0;
 	for(i = 1; i < w; i *= 2) logw++;
-	mask = (1<<logw+2)-1;
+	mask = (1<<(logw+2))-1;
 
 	if(raster->format & Raster::PAL4 && natras->flags & Ps2Raster::SWIZZLED4){
 		for(y = 0; y < h; y += 4){
-			memcpy(tmpbuf, &px[y<<logw-1], 2*w);
+			memcpy(tmpbuf, &px[y<<(logw-1)], 2*w);
 			for(i = 0; i < 4; i++)
 				for(x = 0; x < w; x++){
-					uint32 a = (y+i<<logw)+x;
+					uint32 a = ((y+i)<<logw)+x;
 					uint32 s = swizzle(x, y+i, logw)&mask;
 					uint8 c = s & 1 ? tmpbuf[s>>1] >> 4 : tmpbuf[s>>1] & 0xF;
-					px[a>>1] = a & 1 ? px[a>>1]&0xF | c<<4 : px[a>>1]&0xF0 | c;
+					px[a>>1] = a & 1 ? (px[a>>1]&0xF) | c<<4 : (px[a>>1]&0xF0) | c;
 				}
 		}
 	}else if(raster->format & Raster::PAL8 && natras->flags & Ps2Raster::SWIZZLED8){
@@ -1406,7 +1406,7 @@ unswizzleRaster(Raster *raster)
 			memcpy(tmpbuf, &px[y<<logw], 4*w);
 			for(i = 0; i < 4; i++)
 				for(x = 0; x < w; x++){
-					uint32 a = (y+i<<logw)+x;
+					uint32 a = ((y+i)<<logw)+x;
 					uint32 s = swizzle(x, y+i, logw)&mask;
 					px[a] = tmpbuf[s];
 				}
@@ -1422,7 +1422,7 @@ swizzleRaster(Raster *raster)
 	int32 x, y, w, h;
 	int32 i;
 	int32 logw;
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 	uint8 *px;
 
 	if((raster->format & (Raster::PAL4|Raster::PAL8)) == 0)
@@ -1435,24 +1435,24 @@ swizzleRaster(Raster *raster)
 	px = raster->pixels;
 	logw = 0;
 	for(i = 1; i < raster->width; i *= 2) logw++;
-	mask = (1<<logw+2)-1;
+	mask = (1<<(logw+2))-1;
 
 	if(raster->format & Raster::PAL4 && natras->flags & Ps2Raster::SWIZZLED4){
 		for(y = 0; y < h; y += 4){
 			for(i = 0; i < 4; i++)
 				for(x = 0; x < w; x++){
-					uint32 a = (y+i<<logw)+x;
+					uint32 a = ((y+i)<<logw)+x;
 					uint32 s = swizzle(x, y+i, logw)&mask;
 					uint8 c = a & 1 ? px[a>>1] >> 4 : px[a>>1] & 0xF;
-					tmpbuf[s>>1] = s & 1 ? tmpbuf[s>>1]&0xF | c<<4 : tmpbuf[s>>1]&0xF0 | c;
+					tmpbuf[s>>1] = s & 1 ? (tmpbuf[s>>1]&0xF) | c<<4 : (tmpbuf[s>>1]&0xF0) | c;
 				}
-			memcpy(&px[y<<logw-1], tmpbuf, 2*w);
+			memcpy(&px[y<<(logw-1)], tmpbuf, 2*w);
 		}
 	}else if(raster->format & Raster::PAL8 && natras->flags & Ps2Raster::SWIZZLED8){
 		for(y = 0; y < h; y += 4){
 			for(i = 0; i < 4; i++)
 				for(x = 0; x < w; x++){
-					uint32 a = (y+i<<logw)+x;
+					uint32 a = ((y+i)<<logw)+x;
 					uint32 s = swizzle(x, y+i, logw)&mask;
 					tmpbuf[s] = px[a];
 				}
@@ -1464,7 +1464,7 @@ swizzleRaster(Raster *raster)
 uint8*
 rasterLock(Raster *raster, int32 level, int32 lockMode)
 {
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 	assert(raster->depth != 24);
 
 	if(level > 0){
@@ -1490,7 +1490,7 @@ rasterLock(Raster *raster, int32 level, int32 lockMode)
 void
 rasterUnlock(Raster *raster, int32 level)
 {
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 	if(raster->format & (Raster::PAL4 | Raster::PAL8))
 		swizzleRaster(raster);
 
@@ -1615,7 +1615,7 @@ imageFindRasterFormat(Image *img, int32 type,
 bool32
 rasterFromImage(Raster *raster, Image *image)
 {
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 
 	int32 pallength = 0;
 	switch(image->depth){
@@ -1708,7 +1708,7 @@ rasterToImage(Raster *raster)
 {
 	Image *image;
 	int depth;
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 
 	int32 rasterFormat = raster->format & 0xF00;
 	switch(rasterFormat){
@@ -1812,7 +1812,7 @@ rasterToImage(Raster *raster)
 int32
 rasterNumLevels(Raster *raster)
 {
-	Ps2Raster *ras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *ras = GETPS2RASTEREXT(raster);
 	if(raster->pixels == nil) return 0;
 	if(raster->format & Raster::MIPMAP)
 		return MAXLEVEL(ras)+1;
@@ -1822,7 +1822,7 @@ rasterNumLevels(Raster *raster)
 static void*
 createNativeRaster(void *object, int32 offset, int32)
 {
-	Ps2Raster *raster = PLUGINOFFSET(Ps2Raster, object, offset);
+	Ps2Raster *raster = GETPS2RASTEREXT(object);
 	raster->tex0 = 0;
 	raster->paletteBase = 0;
 	raster->kl = defaultMipMapKL;
@@ -1843,7 +1843,7 @@ createNativeRaster(void *object, int32 offset, int32)
 static void*
 destroyNativeRaster(void *object, int32 offset, int32)
 {
-	Ps2Raster *raster = PLUGINOFFSET(Ps2Raster, object, offset);
+	Ps2Raster *raster = GETPS2RASTEREXT(object);
 	freealign(raster->data);
 	return object;
 }
@@ -1851,8 +1851,8 @@ destroyNativeRaster(void *object, int32 offset, int32)
 static void*
 copyNativeRaster(void *dst, void *src, int32 offset, int32)
 {
-	Ps2Raster *dstraster = PLUGINOFFSET(Ps2Raster, dst, offset);
-	Ps2Raster *srcraster = PLUGINOFFSET(Ps2Raster, src, offset);
+	Ps2Raster *dstraster = GETPS2RASTEREXT(dst);
+	Ps2Raster *srcraster = GETPS2RASTEREXT(src);
 	*dstraster = *srcraster;
 	return dst;
 }
@@ -1864,7 +1864,7 @@ readMipmap(Stream *stream, int32, void *object, int32 offset, int32)
 	Texture *tex = (Texture*)object;
 	if(tex->raster == nil)
 		return stream;
-	Ps2Raster *raster = PLUGINOFFSET(Ps2Raster, tex->raster, offset);
+	Ps2Raster *raster = GETPS2RASTEREXT(tex->raster);
 	raster->kl = val;
 	return stream;
 }
@@ -1877,7 +1877,7 @@ writeMipmap(Stream *stream, int32, void *object, int32 offset, int32)
 		stream->writeI32(defaultMipMapKL);
 		return stream;
 	}
-	Ps2Raster *raster = PLUGINOFFSET(Ps2Raster, tex->raster, offset);
+	Ps2Raster *raster = GETPS2RASTEREXT(tex->raster);
 	stream->writeI32(raster->kl);
 	return stream;
 }
@@ -1904,7 +1904,7 @@ registerNativeRaster(void)
 void
 printTEX0(uint64 tex0)
 {
-	printf("%016llX ", tex0);
+	printf("%016lX ", tex0);
 	uint32 tbp0 = tex0 & 0x3FFF; tex0 >>= 14;
 	uint32 tbw = tex0 & 0x3F; tex0 >>= 6;
 	uint32 psm = tex0 & 0x3F; tex0 >>= 6;
@@ -1924,7 +1924,7 @@ printTEX0(uint64 tex0)
 void
 printTEX1(uint64 tex1)
 {
-	printf("%016llX ", tex1);
+	printf("%016lX ", tex1);
 	uint32 lcm = tex1 & 0x1; tex1 >>= 2;
 	uint32 mxl = tex1 & 0x7; tex1 >>= 3;
 	uint32 mmag = tex1 & 0x1; tex1 >>= 1;
@@ -1947,7 +1947,7 @@ calcTEX1(Raster *raster, uint64 *tex1, int32 filter)
 		LINEAR_MIPMAP_NEAREST,
 		LINEAR_MIPMAP_LINEAR,
 	};
-	Ps2Raster *natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *natras = GETPS2RASTEREXT(raster);
 	uint64 t1 = natras->tex1low;
 	uint64 k = natras->kl & 0xFFF;
 	uint64 l = (natras->kl >> 12) & 0x3;
@@ -2071,7 +2071,7 @@ streamExt.mipmapVal);
 	noNewStyleRasters = 0;
 	rw::version = oldversion;
 	tex->raster = raster;
-	natras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	natras = GETPS2RASTEREXT(raster);
 //printf("%X %X\n", natras->paletteBase, natras->tex1low);
 //	printf("%08X%08X %08X%08X %08X%08X\n",
 //	       (uint32)natras->tex0, (uint32)(natras->tex0>>32),
@@ -2176,7 +2176,7 @@ void
 writeNativeTexture(Texture *tex, Stream *stream)
 {
 	Raster *raster = tex->raster;
-	Ps2Raster *ras = PLUGINOFFSET(Ps2Raster, raster, nativeRasterOffset);
+	Ps2Raster *ras = GETPS2RASTEREXT(raster);
 	writeChunkHeader(stream, ID_STRUCT, 8);
 	stream->writeU32(FOURCC_PS2);
 	stream->writeU32(tex->filterAddressing);
@@ -2229,7 +2229,7 @@ getSizeNativeTexture(Texture *tex)
 	size += 12 + strlen(tex->mask)+4 & ~3;
 	size += 12;
 	size += 12 + 64;
-	Ps2Raster *ras = PLUGINOFFSET(Ps2Raster, tex->raster, nativeRasterOffset);
+	Ps2Raster *ras = GETPS2RASTEREXT(tex->raster);
 	size += 12 + ras->pixelSize + ras->paletteSize;
 	return size;
 }
diff --git a/src/ps2/rwps2.h b/src/ps2/rwps2.h
index e8c779b..899bb86 100644
--- a/src/ps2/rwps2.h
+++ b/src/ps2/rwps2.h
@@ -248,6 +248,7 @@ struct Ps2Raster
 
 extern int32 nativeRasterOffset;
 void registerNativeRaster(void);
+#define GETPS2RASTEREXT(raster) PLUGINOFFSET(rw::ps2::Ps2Raster, raster, rw::ps2::nativeRasterOffset)
 
 Texture *readNativeTexture(Stream *stream);
 void writeNativeTexture(Texture *tex, Stream *stream);
diff --git a/src/raster.cpp b/src/raster.cpp
index 183ec6b..c7ebffe 100644
--- a/src/raster.cpp
+++ b/src/raster.cpp
@@ -10,10 +10,11 @@
 #include "rwobjects.h"
 #include "rwengine.h"
 //#include "ps2/rwps2.h"
-//#include "d3d/rwd3d.h"
-//#include "d3d/rwxbox.h"
+#include "d3d/rwd3d.h"
+#include "d3d/rwxbox.h"
 //#include "d3d/rwd3d8.h"
 //#include "d3d/rwd3d9.h"
+#include "gl/rwgl3.h"
 
 #define PLUGIN_ID 0
 
@@ -36,7 +37,7 @@ rasterOpen(void *object, int32 offset, int32 size)
 	int i;
 	rasterModuleOffset = offset;
 	RASTERGLOBAL(sp) = -1;
-	for(i = 0; i < nelem(RASTERGLOBAL(stack)); i++)
+	for(i = 0; i < (int)nelem(RASTERGLOBAL(stack)); i++)
 		RASTERGLOBAL(stack)[i] = nil;
 	return object;
 }
@@ -71,6 +72,7 @@ Raster::create(int32 width, int32 height, int32 depth, int32 format, int32 platf
 	raster->width = width;
 	raster->height = height;
 	raster->depth = depth;
+	raster->stride = 0;
 	raster->pixels = raster->palette = nil;
 	s_plglist.construct(raster);
 
@@ -85,8 +87,8 @@ Raster::subRaster(Raster *parent, Rect *r)
 		return;
 	this->width = r->w;
 	this->height = r->h;
-	this->offsetX += r->x;
-	this->offsetY += r->y;
+	this->offsetX = parent->offsetX + r->x;
+	this->offsetY = parent->offsetY + r->y;
 	this->parent = parent->parent;
 }
 
@@ -293,19 +295,31 @@ conv_RGBA5551_from_ARGB1555(uint8 *out, uint8 *in)
 	uint32 r, g, b, a;
 	a = (in[1]>>7) & 1;
 	r = (in[1]>>2) & 0x1F;
-	g = (in[1]&3)<<3 | (in[0]>>5)&7;
+	g = (in[1]&3)<<3 | ((in[0]>>5)&7);
 	b = in[0] & 0x1F;
 	out[0] = a | b<<1 | g<<6;
 	out[1] = g>>2 | r<<3;
 }
 
+void
+conv_ARGB1555_from_RGBA5551(uint8 *out, uint8 *in)
+{
+	uint32 r, g, b, a;
+	a = in[0] & 1;
+	b = (in[0]>>1) & 0x1F;
+	g = (in[1]&7)<<2 | ((in[0]>>6)&3);
+	r = (in[1]>>3) & 0x1F;
+	out[0] = b | g<<5;
+	out[1] = g>>3 | r<<2 | a<<7;
+}
+
 void
 conv_RGBA8888_from_ARGB1555(uint8 *out, uint8 *in)
 {
 	uint32 r, g, b, a;
 	a = (in[1]>>7) & 1;
 	r = (in[1]>>2) & 0x1F;
-	g = (in[1]&3)<<3 | (in[0]>>5)&7;
+	g = (in[1]&3)<<3 | ((in[0]>>5)&7);
 	b = in[0] & 0x1F;
 	out[0] = r*0xFF/0x1f;
 	out[1] = g*0xFF/0x1f;
@@ -319,8 +333,8 @@ conv_ABGR1555_from_ARGB1555(uint8 *out, uint8 *in)
 	uint32 r, b;
 	r = (in[1]>>2) & 0x1F;
 	b = in[0] & 0x1F;
-	out[1] = in[1]&0x83 | b<<2;
-	out[0] = in[0]&0xE0 | r;
+	out[1] = (in[1]&0x83) | b<<2;
+	out[0] = (in[0]&0xE0) | r;
 }
 
 void
@@ -371,4 +385,175 @@ copyPal8(uint8 *dst, uint32 dststride, uint8 *src, uint32 srcstride, int32 w, in
 }
 
 
+
+// Platform conversion
+
+static rw::Raster*
+xbox_to_d3d(rw::Raster *ras)
+{
+	using namespace rw;
+
+	int dxt = 0;
+	xbox::XboxRaster *xboxras = GETXBOXRASTEREXT(ras);
+	if(xboxras->customFormat){
+		switch(xboxras->format){
+		case xbox::D3DFMT_DXT1: dxt = 1; break;
+		case xbox::D3DFMT_DXT3: dxt = 3; break;
+		case xbox::D3DFMT_DXT5: dxt = 5; break;
+		}
+	}
+	if(dxt == 0)
+		return nil;
+
+	Raster *newras = Raster::create(ras->width, ras->height, ras->depth,
+		                        ras->format | Raster::TEXTURE | Raster::DONTALLOCATE);
+	int numLevels = ras->getNumLevels();
+	d3d::allocateDXT(newras, dxt, numLevels, xboxras->hasAlpha);
+	for(int i = 0; i < numLevels; i++){
+		uint8 *srcpx = ras->lock(i, Raster::LOCKREAD);
+	//	uint8 *dstpx = newras->lock(i, Raster::LOCKWRITE | Raster::LOCKNOFETCH);
+		d3d::setTexels(newras, srcpx, i);
+	//	flipDXT(dxt, dstpx, srcpx, ras->width, ras->height);
+		ras->unlock(i);
+	//	newras->unlock(i);
+	}
+
+	return newras;
+}
+
+static rw::Raster*
+d3d_to_gl3(rw::Raster *ras)
+{
+#ifdef RW_GL3
+	using namespace rw;
+
+	if(!gl3::gl3Caps.dxtSupported)
+		return nil;
+
+	int dxt = 0;
+	d3d::D3dRaster *d3dras = GETD3DRASTEREXT(ras);
+	if(d3dras->customFormat){
+		switch(d3dras->format){
+		case d3d::D3DFMT_DXT1: dxt = 1; break;
+		case d3d::D3DFMT_DXT3: dxt = 3; break;
+		case d3d::D3DFMT_DXT5: dxt = 5; break;
+		}
+	}
+	if(dxt == 0)
+		return nil;
+
+	Raster *newras = Raster::create(ras->width, ras->height, ras->depth,
+		                        ras->format | Raster::TEXTURE | Raster::DONTALLOCATE);
+	int numLevels = ras->getNumLevels();
+	gl3::allocateDXT(newras, dxt, numLevels, d3dras->hasAlpha);
+	for(int i = 0; i < numLevels; i++){
+		uint8 *srcpx = ras->lock(i, Raster::LOCKREAD);
+		uint8 *dstpx = newras->lock(i, Raster::LOCKWRITE | Raster::LOCKNOFETCH);
+		flipDXT(dxt, dstpx, srcpx, ras->width, ras->height);
+		ras->unlock(i);
+		newras->unlock(i);
+	}
+
+	return newras;
+#else
+	return nil;
+#endif
+}
+
+static rw::Raster*
+xbox_to_gl3(rw::Raster *ras)
+{
+#ifdef RW_GL3
+	using namespace rw;
+
+	int dxt = 0;
+	xbox::XboxRaster *xboxras = GETXBOXRASTEREXT(ras);
+	if(xboxras->customFormat){
+		switch(xboxras->format){
+		case xbox::D3DFMT_DXT1: dxt = 1; break;
+		case xbox::D3DFMT_DXT3: dxt = 3; break;
+		case xbox::D3DFMT_DXT5: dxt = 5; break;
+		}
+	}
+	if(dxt == 0)
+		return nil;
+
+	Raster *newras = Raster::create(ras->width, ras->height, ras->depth,
+		                        ras->format | Raster::TEXTURE | Raster::DONTALLOCATE);
+	int numLevels = ras->getNumLevels();
+	gl3::allocateDXT(newras, dxt, numLevels, xboxras->hasAlpha);
+	for(int i = 0; i < numLevels; i++){
+		uint8 *srcpx = ras->lock(i, Raster::LOCKREAD);
+		uint8 *dstpx = newras->lock(i, Raster::LOCKWRITE | Raster::LOCKNOFETCH);
+		flipDXT(dxt, dstpx, srcpx, ras->width, ras->height);
+		ras->unlock(i);
+		newras->unlock(i);
+	}
+
+	return newras;
+#else
+	return nil;
+#endif
+}
+
+rw::Raster*
+Raster::convertTexToCurrentPlatform(rw::Raster *ras)
+{
+	using namespace rw;
+
+	if(ras->platform == rw::platform)
+		return ras;
+	// compatible platforms
+	if((ras->platform == PLATFORM_D3D8 && rw::platform == PLATFORM_D3D9) ||
+	   (ras->platform == PLATFORM_D3D9 && rw::platform == PLATFORM_D3D8))
+		return ras;
+
+	// special cased conversion for DXT
+	if((ras->platform == PLATFORM_D3D8 || ras->platform == PLATFORM_D3D9) && rw::platform == PLATFORM_GL3){
+		Raster *newras = d3d_to_gl3(ras);
+		if(newras){
+			ras->destroy();
+			return newras;
+		}
+	}else if(ras->platform == PLATFORM_XBOX && (rw::platform == PLATFORM_D3D9 || rw::platform == PLATFORM_D3D8)){
+		Raster *newras = xbox_to_d3d(ras);
+		if(newras){
+			ras->destroy();
+			return newras;
+		}
+	}else if(ras->platform == PLATFORM_XBOX && rw::platform == PLATFORM_GL3){
+		Raster *newras = xbox_to_gl3(ras);
+		if(newras){
+			ras->destroy();
+			return newras;
+		}
+	}
+
+	// fall back to going through Image directly
+	int32 width, height, depth, format;
+	Image *img = ras->toImage();
+	// TODO: maybe don't *always* do this?
+	img->unpalettize();
+	Raster::imageFindRasterFormat(img, Raster::TEXTURE, &width, &height, &depth, &format);
+	format |= ras->format & (Raster::MIPMAP | Raster::AUTOMIPMAP);
+	Raster *newras = Raster::create(width, height, depth, format);
+	newras->setFromImage(img);
+	img->destroy();
+	int numLevels = ras->getNumLevels();
+	for(int i = 1; i < numLevels; i++){
+		ras->lock(i, Raster::LOCKREAD);
+		img = ras->toImage();
+		// TODO: maybe don't *always* do this?
+		img->unpalettize();
+		newras->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
+		newras->setFromImage(img);
+		newras->unlock(i);
+		ras->unlock(i);
+	}
+	ras->destroy();
+	ras = newras;
+	return ras;
+}
+
+
 }
diff --git a/src/render.cpp b/src/render.cpp
index 814f682..6822c24 100644
--- a/src/render.cpp
+++ b/src/render.cpp
@@ -3,6 +3,7 @@
 #include "rwbase.h"
 #include "rwplg.h"
 #include "rwengine.h"
+#include "rwrender.h"
 
 namespace rw {
 
@@ -57,6 +58,23 @@ Transform(void *vertices, int32 numVertices, Matrix *world, uint32 flags)
 	engine->device.im3DTransform(vertices, numVertices, world, flags);
 }
 void
+RenderLine(int32 vert1, int32 vert2)
+{
+	int16 indices[2];
+	indices[0] = vert1;
+	indices[1] = vert2;
+	RenderIndexedPrimitive(rw::PRIMTYPELINELIST, indices, 2);
+}
+void
+RenderTriangle(int32 vert1, int32 vert2, int32 vert3)
+{
+	int16 indices[3];
+	indices[0] = vert1;
+	indices[1] = vert2;
+	indices[2] = vert3;
+	RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indices, 3);
+}
+void
 RenderPrimitive(PrimitiveType primType)
 {
 	engine->device.im3DRenderPrimitive(primType);
diff --git a/src/rwbase.h b/src/rwbase.h
index 5cac88f..13891ca 100644
--- a/src/rwbase.h
+++ b/src/rwbase.h
@@ -5,9 +5,7 @@
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
-extern "C"{
-#include <math_neon.h>
-};
+
 // TODO: clean up the opengl defines
 //       and figure out what we even want here...
 #ifdef RW_GL3
@@ -242,7 +240,7 @@ inline V3d add(const V3d &a, const V3d &b) { return makeV3d(a.x+b.x, a.y+b.y, a.
 inline V3d sub(const V3d &a, const V3d &b) { return makeV3d(a.x-b.x, a.y-b.y, a.z-b.z); }
 inline V3d scale(const V3d &a, float32 r) { return makeV3d(a.x*r, a.y*r, a.z*r); }
 inline float32 length(const V3d &v) { return sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); }
-inline V3d normalize(const V3d &v) { V3d r; normalize3_neon((float*)&v.x, &r.x); return r; }
+inline V3d normalize(const V3d &v) { return scale(v, 1.0f/length(v)); }
 inline V3d setlength(const V3d &v, float32 l) { return scale(v, l/length(v)); }
 V3d cross(const V3d &a, const V3d &b);
 inline float32 dot(const V3d &a, const V3d &b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
@@ -275,15 +273,12 @@ struct Quat
 	float32 x, y, z, w;
 
 	static Quat rotation(float32 angle, const V3d &axis){
-		float cs[2];
-		sincosf_c(angle/2.0f, cs);
-		return makeQuat(cs[1], scale(normalize(axis), cs[0]));
-		}
+		return makeQuat(cosf(angle/2.0f), scale(normalize(axis), sinf(angle/2.0f))); }
 	void set(float32 w, float32 x, float32 y, float32 z){
 		this->w = w; this->x = x; this->y = y; this->z = z; }
 	V3d vec(void){ return makeV3d(x, y, z); }
 
-	Quat *rotate(const V3d *axis, float32 angle, CombineOp op);
+	Quat *rotate(const V3d *axis, float32 angle, CombineOp op = rw::COMBINEPOSTCONCAT);
 };
 
 inline Quat makeQuat(float32 w, float32 x, float32 y, float32 z) { Quat q = { x, y, z, w }; return q; }
@@ -291,10 +286,10 @@ inline Quat makeQuat(float32 w, const V3d &vec) { Quat q = { vec.x, vec.y, vec.z
 inline Quat add(const Quat &q, const Quat &p) { return makeQuat(q.w+p.w, q.x+p.x, q.y+p.y, q.z+p.z); }
 inline Quat sub(const Quat &q, const Quat &p) { return makeQuat(q.w-p.w, q.x-p.x, q.y-p.y, q.z-p.z); }
 inline Quat negate(const Quat &q) { return makeQuat(-q.w, -q.x, -q.y, -q.z); }
-inline float32 dot(const Quat &q, const Quat &p) { return dot4_neon((float*)&q.x, (float*)&p.x); }
+inline float32 dot(const Quat &q, const Quat &p) { return q.w*p.w + q.x*p.x + q.y*p.y + q.z*p.z; }
 inline Quat scale(const Quat &q, float32 r) { return makeQuat(q.w*r, q.x*r, q.y*r, q.z*r); }
 inline float32 length(const Quat &q) { return sqrtf(q.w*q.w + q.x*q.x + q.y*q.y + q.z*q.z); }
-inline Quat normalize(const Quat &q) { float r[4]; normalize4_neon((float*)&q.x, r); return makeQuat(r[0], r[1], r[2], r[3]); }
+inline Quat normalize(const Quat &q) { return scale(q, 1.0f/length(q)); }
 inline Quat conj(const Quat &q) { return makeQuat(q.w, -q.x, -q.y, -q.z); }
 Quat mult(const Quat &q, const Quat &p);
 inline V3d rotate(const V3d &v, const Quat &q) { return mult(mult(q, makeQuat(0.0f, v)), conj(q)).vec(); }
@@ -310,8 +305,9 @@ struct RawMatrix
 	V3d at;
 	float32 atw;
 	V3d pos;
-	float32 posw;;
+	float32 posw;
 
+	// NB: this is dst = src2*src1, i.e. src1 is applied first, then src2
 	static void mult(RawMatrix *dst, RawMatrix *src1, RawMatrix *src2);
 	static void transpose(RawMatrix *dst, RawMatrix *src);
 	static void setIdentity(RawMatrix *dst);
@@ -351,11 +347,11 @@ struct Matrix
 	static Matrix *mult(Matrix *dst, const Matrix *src1, const Matrix *src2);
 	static Matrix *invert(Matrix *dst, const Matrix *src);
 	static Matrix *transpose(Matrix *dst, const Matrix *src);
-	Matrix *rotate(const V3d *axis, float32 angle, CombineOp op);
-	Matrix *rotate(const Quat &q, CombineOp op);
-	Matrix *translate(const V3d *translation, CombineOp op);
-	Matrix *scale(const V3d *scl, CombineOp op);
-	Matrix *transform(const Matrix *mat, CombineOp op);
+	Matrix *rotate(const V3d *axis, float32 angle, CombineOp op = rw::COMBINEPOSTCONCAT);
+	Matrix *rotate(const Quat &q, CombineOp op = rw::COMBINEPOSTCONCAT);
+	Matrix *translate(const V3d *translation, CombineOp op = rw::COMBINEPOSTCONCAT);
+	Matrix *scale(const V3d *scl, CombineOp op = rw::COMBINEPOSTCONCAT);
+	Matrix *transform(const Matrix *mat, CombineOp op = rw::COMBINEPOSTCONCAT);
 	Quat getRotation(void);
 	void lookAt(const V3d &dir, const V3d &up);
 
@@ -491,11 +487,12 @@ public:
 
 class StreamMemory : public Stream
 {
+public:
 	uint8 *data;
 	uint32 length;
 	uint32 capacity;
 	uint32 position;
-public:
+
 	void close(void);
 	uint32 write8(const void *data, uint32 length);
 	uint32 read8(void *data, uint32 length);
@@ -512,8 +509,9 @@ public:
 
 class StreamFile : public Stream
 {
-	FILE *file;
 public:
+	FILE *file;
+
 	StreamFile(void) { file = nil; }
 	void close(void);
 	uint32 write8(const void *data, uint32 length);
@@ -597,6 +595,7 @@ enum PluginID
 	ID_HANIM         = MAKEPLUGINID(VEND_CRITERIONTK, 0x1E),
 	ID_USERDATA      = MAKEPLUGINID(VEND_CRITERIONTK, 0x1F),
 	ID_MATFX         = MAKEPLUGINID(VEND_CRITERIONTK, 0x20),
+	ID_ANISOT        = MAKEPLUGINID(VEND_CRITERIONTK, 0x27),
 	ID_PDS           = MAKEPLUGINID(VEND_CRITERIONTK, 0x31),
 	ID_ADC           = MAKEPLUGINID(VEND_CRITERIONTK, 0x34),
 	ID_UVANIMATION   = MAKEPLUGINID(VEND_CRITERIONTK, 0x35),
diff --git a/src/rwengine.h b/src/rwengine.h
index d09de11..a84aa3a 100644
--- a/src/rwengine.h
+++ b/src/rwengine.h
@@ -27,7 +27,13 @@ enum DeviceReq
 	DEVICEGETNUMVIDEOMODES,
 	DEVICEGETCURRENTVIDEOMODE,
 	DEVICESETVIDEOMODE,
-	DEVICEGETVIDEOMODEINFO
+	DEVICEGETVIDEOMODEINFO,
+
+	// Multisampling
+	DEVICEGETMAXMULTISAMPLINGLEVELS,
+	DEVICEGETMULTISAMPLINGLEVELS,
+	DEVICESETMULTISAMPLINGLEVELS,
+
 };
 
 typedef int DeviceSystem(DeviceReq req, void *arg, int32 n);
@@ -159,7 +165,7 @@ struct Engine
 	static MemoryFunctions memfuncs;
 	static State state;
 
-	static bool32 init(void);
+	static bool32 init(MemoryFunctions *memfuncs = nil);
 	static bool32 open(EngineOpenParams*);
 	static bool32 start(void);
 	static void term(void);
@@ -176,6 +182,9 @@ struct Engine
 	static bool32 setVideoMode(int32 mode);
 	static VideoMode *getVideoModeInfo(VideoMode *info, int32 mode);
 
+	static uint32 getMaxMultiSamplingLevels(void);
+	static uint32 getMultiSamplingLevels(void);
+	static bool32 setMultiSamplingLevels(uint32 levels);
 
 	static PluginList s_plglist;
 	static int32 registerPlugin(int32 size, uint32 id,
@@ -197,6 +206,8 @@ inline void *realloc_LOC(void *p, size_t sz, uint32 hint, const char *here) { al
 inline void *mustmalloc_LOC(size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwmustmalloc(sz,hint); }
 inline void *mustrealloc_LOC(void *p, size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwmustrealloc(p,sz,hint); }
 
+char *strdup_LOC(const char *s, uint32 hint, const char *here);
+
 #define rwMalloc(s, h) rw::malloc_LOC(s,h,RWHERE)
 #define rwMallocT(t, s, h) (t*)rw::malloc_LOC((s)*sizeof(t),h,RWHERE)
 #define rwRealloc(p, s, h) rw::realloc_LOC(p,s,h,RWHERE)
@@ -206,6 +217,11 @@ inline void *mustrealloc_LOC(void *p, size_t sz, uint32 hint, const char *here)
 #define rwNewT(t, s, h) (t*)rw::mustmalloc_LOC((s)*sizeof(t),h,RWHERE)
 #define rwResize(p, s, h) rw::mustrealloc_LOC(p,s,h,RWHERE)
 #define rwResizeT(t, p, s, h) (t*)rw::mustrealloc_LOC(p,(s)*sizeof(t),h,RWHERE)
+#define rwStrdup(s, h) rw::strdup_LOC(s,h,RWHERE)
+
+extern MemoryFunctions defaultMemfuncs;
+extern MemoryFunctions managedMemfuncs;
+void printleaks(void);	// when using managed mem funcs
 
 namespace null {
 	void beginUpdate(Camera*);
diff --git a/src/rwerror.h b/src/rwerror.h
index 8c78f56..2575626 100644
--- a/src/rwerror.h
+++ b/src/rwerror.h
@@ -17,8 +17,8 @@ char *dbgsprint(uint32 code, ...);
 	rw::Error _e;                   \
 	_e.plugin = PLUGIN_ID;      \
 	_e.code = _ERRORCODE ecode; \
-	printf("%s:%d: ", __FILE__, __LINE__); \
-	printf("%s\n", rw::dbgsprint ecode);       \
+	fprintf(stderr, "%s:%d: ", __FILE__, __LINE__); \
+	fprintf(stderr, "%s\n", rw::dbgsprint ecode);       \
 	rw::setError(&_e);              \
 }while(0)
 
diff --git a/src/rwobjects.h b/src/rwobjects.h
index 32ee631..5cd833f 100644
--- a/src/rwobjects.h
+++ b/src/rwobjects.h
@@ -70,10 +70,10 @@ struct Frame
 	bool32 dirty(void) const {
 		return !!(this->root->object.privateFlags & HIERARCHYSYNC); }
 	Matrix *getLTM(void);
-	void rotate(const V3d *axis, float32 angle, CombineOp op);
-	void translate(const V3d *trans, CombineOp op);
-	void scale(const V3d *scale, CombineOp op);
-	void transform(const Matrix *mat, CombineOp op);
+	void rotate(const V3d *axis, float32 angle, CombineOp op = rw::COMBINEPOSTCONCAT);
+	void translate(const V3d *trans, CombineOp op = rw::COMBINEPOSTCONCAT);
+	void scale(const V3d *scale, CombineOp op = rw::COMBINEPOSTCONCAT);
+	void transform(const Matrix *mat, CombineOp op = rw::COMBINEPOSTCONCAT);
 	void updateObjects(void);
 
 
@@ -268,6 +268,7 @@ struct Raster
 	static Raster *getCurrentContext(void);
 	bool32 renderFast(int32 x, int32 y);
 
+	static Raster *convertTexToCurrentPlatform(Raster *ras);
 #ifndef RWPUBLIC
 	static void registerModule(void);
 #endif
@@ -323,6 +324,7 @@ void conv_BGR888_from_RGB888(uint8 *out, uint8 *in);
 void conv_ARGB1555_from_ARGB1555(uint8 *out, uint8 *in);
 void conv_ARGB1555_from_RGB555(uint8 *out, uint8 *in);
 void conv_RGBA5551_from_ARGB1555(uint8 *out, uint8 *in);
+void conv_ARGB1555_from_RGBA5551(uint8 *out, uint8 *in);
 void conv_RGBA8888_from_ARGB1555(uint8 *out, uint8 *in);
 void conv_ABGR1555_from_ARGB1555(uint8 *out, uint8 *in);
 inline void conv_8_from_8(uint8 *out, uint8 *in) { *out = *in; }
@@ -337,6 +339,7 @@ void expandPal4_BE(uint8 *dst, uint32 dststride, uint8 *src, uint32 srcstride, i
 void compressPal4_BE(uint8 *dst, uint32 dststride, uint8 *src, uint32 srcstride, int32 w, int32 h);
 void copyPal8(uint8 *dst, uint32 dststride, uint8 *src, uint32 srcstride, int32 w, int32 h);
 
+void flipDXT(int32 type, uint8 *dst, uint8 *src, uint32 width, uint32 height);
 
 
 #define IGNORERASTERIMP 0
@@ -348,9 +351,9 @@ struct Texture
 	enum FilterMode {
 		NEAREST = 1,
 		LINEAR,
-		MIPNEAREST,
+		MIPNEAREST,	// one mipmap
 		MIPLINEAR,
-		LINEARMIPNEAREST,
+		LINEARMIPNEAREST,	// mipmap interpolated
 		LINEARMIPLINEAR
 	};
 	enum Addressing {
@@ -401,11 +404,18 @@ struct Texture
 	static bool32 getMipmapping(void);
 	static bool32 getAutoMipmapping(void);
 
+	void setMaxAnisotropy(int32 maxaniso);	// only if plugin is attached
+	int32 getMaxAnisotropy(void);
+
 #ifndef RWPUBLIC
 	static void registerModule(void);
 #endif
 };
 
+extern int32 anisotOffset;
+#define GETANISOTROPYEXT(texture) PLUGINOFFSET(int32, texture, rw::anisotOffset)
+void registerAnisotropyPlugin(void);
+int32 getMaxSupportedMaxAnisotropy(void);
 
 struct SurfaceProperties
 {
@@ -723,7 +733,7 @@ struct Camera
 	PLUGINBASE
 	enum { ID = 4 };
 	enum { PERSPECTIVE = 1, PARALLEL };
-	enum { CLEARIMAGE = 0x1, CLEARZ = 0x2};
+	enum { CLEARIMAGE = 0x1, CLEARZ = 0x2, CLEARSTENCIL = 0x4 };
 	// return value of frustumTestSphere
 	enum { SPHEREOUTSIDE, SPHEREBOUNDARY, SPHEREINSIDE };
 
@@ -746,7 +756,7 @@ struct Camera
 	Raster *frameBuffer;
 	Raster *zBuffer;
 
-	// Device dependant view and projection matrices
+	// Device dependent view and projection matrices
 	// optional
 	RawMatrix devView;
 	RawMatrix devProj;
@@ -850,7 +860,7 @@ struct World
 
 	static int32 numAllocated;
 
-	static World *create(void);
+	static World *create(BBox *bbox = nil);	// TODO: should probably make this non-optional
 	void destroy(void);
 	void addLight(Light *light);
 	void removeLight(Light *light);
diff --git a/src/rwplg.h b/src/rwplg.h
index 69e0f5c..ad2116a 100644
--- a/src/rwplg.h
+++ b/src/rwplg.h
@@ -10,6 +10,7 @@ typedef Stream *(*StreamRead)(Stream *stream, int32 length, void *object, int32
 typedef Stream *(*StreamWrite)(Stream *stream, int32 length, void *object, int32 offset, int32 size);
 typedef int32 (*StreamGetSize)(void *object, int32 offset, int32 size);
 typedef void (*RightsCallback)(void *object, int32 offset, int32 size, uint32 data);
+typedef void (*AlwaysCallback)(void *object, int32 offset, int32 size);
 
 struct PluginList
 {
@@ -38,6 +39,7 @@ struct PluginList
 		Constructor, Destructor, CopyConstructor);
 	int32 registerStream(uint32 id, StreamRead, StreamWrite, StreamGetSize);
 	int32 setStreamRightsCallback(uint32 id, RightsCallback cb);
+	int32 setStreamAlwaysCallback(uint32 id, AlwaysCallback cb);
 	int32 getPluginOffset(uint32 id);
 };
 
@@ -53,6 +55,7 @@ struct Plugin
 	StreamWrite write;
 	StreamGetSize getSize;
 	RightsCallback rightsCallback;
+	AlwaysCallback alwaysCallback;
 	PluginList *parentList;
 	LLLink inParentList;
 	LLLink inGlobalList;
@@ -71,6 +74,9 @@ struct Plugin
 	static int32 setStreamRightsCallback(uint32 id, RightsCallback cb){	    \
 		return s_plglist.setStreamRightsCallback(id, cb);		    \
 	}									    \
+	static int32 setStreamAlwaysCallback(uint32 id, AlwaysCallback cb){	    \
+		return s_plglist.setStreamAlwaysCallback(id, cb);		    \
+	}									    \
 	static int32 getPluginOffset(uint32 id){				    \
 		return s_plglist.getPluginOffset(id);				    \
 	}
diff --git a/src/rwplugins.h b/src/rwplugins.h
index 326d4af..51696b6 100644
--- a/src/rwplugins.h
+++ b/src/rwplugins.h
@@ -160,7 +160,10 @@ struct MatFX
 	static void disableEffects(Atomic *atomic);
 	static bool32 getEffects(Atomic *atomic);
 
-	static bool32 modulateEnvMap;
+	static bool32 envMapFlipU;	// PS2 does this for some reason
+	static bool32 envMapApplyLight;	// modulate env map by lighting
+	static bool32 envMapUseMatColor;	// modulate env map by material color
+	static RGBA envMapColor;	// if !envMapUseMatColor, use this
 };
 
 struct MatFXGlobals
@@ -218,6 +221,7 @@ struct Skin
 
 	uint8 *data;	// only used by delete
 	void *platformData; // a place to store platform specific stuff
+	bool32 legacyType;	// old skin attached to atomic, needed for always CB
 
 	void init(int32 numBones, int32 numUsedBones, int32 numVertices);
 	void findNumWeights(int32 numVertices);
diff --git a/src/rwrender.h b/src/rwrender.h
index 02373ab..200837a 100644
--- a/src/rwrender.h
+++ b/src/rwrender.h
@@ -20,6 +20,7 @@ enum RenderState
 	// TODO:
 	// fog type, density ?
 	// ? shademode
+
 	STENCILENABLE,
 	STENCILFAIL,
 	STENCILZFAIL,
@@ -126,6 +127,8 @@ enum TransformFlags
 };
 
 void Transform(void *vertices, int32 numVertices, Matrix *world, uint32 flags);
+void RenderLine(int32 vert1, int32 vert2);
+void RenderTriangle(int32 vert1, int32 vert2, int32 vert3);
 void RenderPrimitive(PrimitiveType primType);
 void RenderIndexedPrimitive(PrimitiveType primType, void *indices, int32 numIndices);
 void End(void);
diff --git a/src/skin.cpp b/src/skin.cpp
index 2e703e3..abaa548 100644
--- a/src/skin.cpp
+++ b/src/skin.cpp
@@ -24,7 +24,7 @@
 
 namespace rw {
 
-SkinGlobals skinGlobals = { 0, 0, { nil } };
+SkinGlobals skinGlobals = { 0, 0, { nil }, nil };
 
 static void*
 createSkin(void *object, int32 offset, int32)
@@ -64,11 +64,11 @@ copySkin(void *dst, void *src, int32 offset, int32)
 	assert(0 && "can't copy skin yet");
 	dstskin->init(srcskin->numBones, srcskin->numUsedBones,
 	              geometry->numVertices);
-	memcpy_neon(dstskin->usedBones, srcskin->usedBones, srcskin->numUsedBones);
-	memcpy_neon(dstskin->inverseMatrices, srcskin->inverseMatrices,
+	memcpy(dstskin->usedBones, srcskin->usedBones, srcskin->numUsedBones);
+	memcpy(dstskin->inverseMatrices, srcskin->inverseMatrices,
 	       srcskin->numBones*64);
-	memcpy_neon(dstskin->indices, srcskin->indices, geometry->numVertices*4);
-	memcpy_neon(dstskin->weights, srcskin->weights, geometry->numVertices*16);
+	memcpy(dstskin->indices, srcskin->indices, geometry->numVertices*4);
+	memcpy(dstskin->weights, srcskin->weights, geometry->numVertices*16);
 	return dst;
 }
 
@@ -265,6 +265,7 @@ readSkinLegacy(Stream *stream, int32 len, void *object, int32, int32)
 	Skin *skin = rwNewT(Skin, 1, MEMDUR_EVENT | ID_SKIN);
 	*PLUGINOFFSET(Skin*, geometry, skinGlobals.geoOffset) = skin;
 	skin->init(numBones, numBones, numVertices);
+	skin->legacyType = 1;
 	skin->numWeights = 4;
 
 	stream->read8(skin->indices, numVertices*4);
@@ -307,6 +308,17 @@ skinRights(void *object, int32, int32, uint32)
 	Skin::setPipeline((Atomic*)object, 1);
 }
 
+static void
+skinAlways(void *object, int32, int32)
+{
+	Atomic *atomic = (Atomic*)object;
+	Geometry *geo = atomic->geometry;
+	if(geo == nil) return;
+	Skin *skin = Skin::get(geo);
+	if(skin == nil) return;
+	Skin::setPipeline((Atomic*)object, 1);
+}
+
 static void*
 createSkinAtm(void *object, int32 offset, int32)
 {
@@ -373,6 +385,7 @@ registerSkinPlugin(void)
 	skinGlobals.atomicOffset = o;
 	Atomic::registerPluginStream(ID_SKIN, readSkinLegacy, nil, nil);
 	Atomic::setStreamRightsCallback(ID_SKIN, skinRights);
+	Atomic::setStreamAlwaysCallback(ID_SKIN, skinAlways);
 }
 
 void
@@ -417,6 +430,7 @@ Skin::init(int32 numBones, int32 numUsedBones, int32 numVertices)
 	this->rle = nil;
 
 	this->platformData = nil;
+	this->legacyType = 0;
 }
 
 
diff --git a/src/texture.cpp b/src/texture.cpp
index fcd9597..958ae08 100644
--- a/src/texture.cpp
+++ b/src/texture.cpp
@@ -3,6 +3,7 @@
 #include <string.h>
 #include <assert.h>
 
+#define WITH_D3D
 #include "rwbase.h"
 #include "rwerror.h"
 #include "rwplg.h"
@@ -14,6 +15,7 @@
 #include "d3d/rwxbox.h"
 #include "d3d/rwd3d8.h"
 #include "d3d/rwd3d9.h"
+#include "d3d/rwd3dimpl.h"
 #include "gl/rwgl3.h"
 
 #define PLUGIN_ID 0
@@ -517,4 +519,78 @@ Texture::streamGetSizeNative(void)
 	return 0;
 }
 
+
+
+int32 anisotOffset;
+
+static void*
+createAnisot(void *object, int32 offset, int32)
+{
+	*GETANISOTROPYEXT(object) = 1;
+	return object;
+}
+
+static void*
+copyAnisot(void *dst, void *src, int32 offset, int32)
+{
+	*GETANISOTROPYEXT(dst) = *GETANISOTROPYEXT(src);
+	return dst;
+}
+
+static Stream*
+readAnisot(Stream *stream, int32, void *object, int32 offset, int32)
+{
+	*GETANISOTROPYEXT(object) = stream->readI32();
+	return stream;
+}
+
+static Stream*
+writeAnisot(Stream *stream, int32, void *object, int32 offset, int32)
+{
+	stream->writeI32(*GETANISOTROPYEXT(object));
+	return stream;
+}
+
+static int32
+getSizeAnisot(void *object, int32 offset, int32)
+{
+	if(*GETANISOTROPYEXT(object) == 1)
+		return 0;
+	return sizeof(int32);
+}
+
+void
+registerAnisotropyPlugin(void)
+{
+	anisotOffset = Texture::registerPlugin(sizeof(int32), ID_ANISOT, createAnisot, nil, copyAnisot);
+	Texture::registerPluginStream(ID_ANISOT, readAnisot, writeAnisot, getSizeAnisot);
+}
+
+void
+Texture::setMaxAnisotropy(int32 maxaniso)
+{
+	if(anisotOffset > 0)
+		*GETANISOTROPYEXT(this) = maxaniso;
+}
+
+int32
+Texture::getMaxAnisotropy(void)
+{
+	if(anisotOffset > 0)
+		return *GETANISOTROPYEXT(this);
+	return 1;
+}
+
+int32
+getMaxSupportedMaxAnisotropy(void)
+{
+#ifdef RW_D3D9
+	return d3d::d3d9Globals.caps.MaxAnisotropy;
+#endif
+#ifdef RW_GL3
+	return (int32)gl3::gl3Caps.maxAnisotropy;
+#endif
+	return 1;
+}
+
 }
diff --git a/src/tristrip.cpp b/src/tristrip.cpp
index b050b1d..bd9123f 100644
--- a/src/tristrip.cpp
+++ b/src/tristrip.cpp
@@ -11,9 +11,6 @@
 #include "rwobjects.h"
 #include "rwengine.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
 #define PLUGIN_ID 2
 
 namespace rw {
@@ -612,7 +609,7 @@ printSmesh(&smesh);
 		md[i].numIndices = ms[i].numIndices;
 		md[i].indices = indices;
 		indices += md[i].numIndices;
-		memcpy_neon(md[i].indices, ms[i].indices, md[i].numIndices*sizeof(uint16));
+		memcpy(md[i].indices, ms[i].indices, md[i].numIndices*sizeof(uint16));
 		rwFree(ms[i].indices);
 	}
 	rwFree(header);
@@ -658,9 +655,9 @@ trace("%d %d %d\n", a, b, c);
 			for(k = 0; k < geo->numTriangles; k++){
 				t = &geo->triangles[k];
 				if(seen[k] || t->matId != m) continue;
-				if(t->v[0] == a && t->v[1] == b && t->v[2] == c ||
-				   t->v[1] == a && t->v[2] == b && t->v[0] == c ||
-				   t->v[2] == a && t->v[0] == b && t->v[1] == c){
+				if((t->v[0] == a && t->v[1] == b && t->v[2] == c) ||
+				   (t->v[1] == a && t->v[2] == b && t->v[0] == c) ||
+				   (t->v[2] == a && t->v[0] == b && t->v[1] == c)){
 					seen[k] = 1;
 					goto found;
 				}
diff --git a/src/userdata.cpp b/src/userdata.cpp
index ea59255..e17a3d5 100644
--- a/src/userdata.cpp
+++ b/src/userdata.cpp
@@ -11,9 +11,6 @@
 #include "rwengine.h"
 #include "rwuserdata.h"
 
-#include <vitasdk.h>
-#include <vitaGL.h>
-
 #define PLUGIN_ID ID_USERDATA
 
 namespace rw {
@@ -93,11 +90,11 @@ copyUserData(void *dst, void *src, int32 offset, int32)
 		switch(srca->datatype){
 		case USERDATAINT:
 			dsta->data = (int32*)udMalloc(sizeof(int32)*dsta->numElements);
-			memcpy_neon(dsta->data, srca->data, sizeof(int32)*dsta->numElements);
+			memcpy(dsta->data, srca->data, sizeof(int32)*dsta->numElements);
 			break;
 		case USERDATAFLOAT:
 			dsta->data = (float32*)udMalloc(sizeof(float32)*dsta->numElements);
-			memcpy_neon(dsta->data, srca->data, sizeof(float32)*dsta->numElements);
+			memcpy(dsta->data, srca->data, sizeof(float32)*dsta->numElements);
 			break;
 		case USERDATASTRING:
 			dststrar = (char**)udMalloc(sizeof(char*)*dsta->numElements);
@@ -244,7 +241,7 @@ UserDataExtension::add(const char *name, int32 datatype, int32 numElements)
 	a = (UserDataArray*)udMalloc((this->numArrays+1)*sizeof(UserDataArray));
 	if(a == nil)
 		return -1;
-	memcpy_neon(a, this->arrays, this->numArrays*sizeof(UserDataArray));
+	memcpy(a, this->arrays, this->numArrays*sizeof(UserDataArray));
 	rwFree(this->arrays);
 	this->arrays = a;
 	i = this->numArrays++;
diff --git a/src/world.cpp b/src/world.cpp
index 447eebc..6432b37 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -19,7 +19,7 @@ int32 World::numAllocated = 0;
 PluginList World::s_plglist(sizeof(World));
 
 World*
-World::create(void)
+World::create(BBox *bbox)
 {
 	World *world = (World*)rwMalloc(s_plglist.size, MEMDUR_EVENT | ID_WORLD);
 	if(world == nil){