Merge remote-tracking branch 'origin/gles3' into gles3-on-master

Various merge conflicts have been fixed manually and some mistakes
might have been made - time will tell :)

.gitignore

@@ -8,6 +8,7 @@ platform/osx/logo.h
 platform/windows/logo.h
 platform/x11/logo.h
 drivers/gles2/shaders/*.h
+drivers/gles3/shaders/*.h
 modules/register_module_types.cpp
 core/version.h
 core/method_bind.inc

SConstruct

@@ -348,6 +348,9 @@ if selected_platform in platform_list:
 
     if (env['verbose'] == 'no'):
         methods.no_verbose(sys, env)
+        
+    if (True): # FIXME: detect GLES3
+        env.Append( BUILDERS = { 'GLES3_GLSL' : env.Builder(action = methods.build_gles3_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
 
     Export('env')
 

bin/tests/test_detailer.cpp

@@ -1,217 +0,0 @@
-/*************************************************************************/
-/*  test_detailer.cpp                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "test_detailer.h"
-#include "servers/visual_server.h"
-#include "os/main_loop.h"
-#include "math_funcs.h"
-#include "print_string.h"
-#include "geometry.h"
-#include "quick_hull.h"
-namespace TestMultiMesh {
-
-
-class TestMainLoop : public MainLoop {
-
-	RID instance;
-	RID camera;
-	RID viewport;
-	RID light;
-	RID mesh;
-	RID scenario;
-
-#define MULTIMESH_COUNT 1500
-
-	float ofs_x,ofs_y;
-	bool quit;
-public:
-
-
-	virtual void _update_qh() {
-
-		VisualServer *vs=VisualServer::get_singleton();
-		Vector<Vector3> vts;
-/*
-
-		static const int s = 20;
-		for(int i=0;i<s;i++) {
-			Matrix3 rot(Vector3(0,1,0),i*Math_PI/s);
-
-			for(int j=0;j<s;j++) {
-				Vector3 v;
-				v.x=Math::sin(j*Math_PI*2/s);
-				v.y=Math::cos(j*Math_PI*2/s);
-
-				vts.push_back( rot.xform(v*2 ) );
-			}
-		}*/
-		/*
-		Math::seed(0);
-		for(int i=0;i<50;i++) {
-
-			vts.push_back( Vector3(Math::randf()*2-1.0,Math::randf()*2-1.0,Math::randf()*2-1.0).normalized()*2);
-		}*/
-		/*
-		vts.push_back(Vector3(0,0,1));
-		vts.push_back(Vector3(0,0,-1));
-		vts.push_back(Vector3(0,1,0));
-		vts.push_back(Vector3(0,-1,0));
-		vts.push_back(Vector3(1,0,0));
-		vts.push_back(Vector3(-1,0,0));*/
-/*
-		vts.push_back(Vector3(1,1,1));
-		vts.push_back(Vector3(1,-1,1));
-		vts.push_back(Vector3(-1,1,1));
-		vts.push_back(Vector3(-1,-1,1));
-		vts.push_back(Vector3(1,1,-1));
-		vts.push_back(Vector3(1,-1,-1));
-		vts.push_back(Vector3(-1,1,-1));
-		vts.push_back(Vector3(-1,-1,-1));
-*/
-
-
-		DVector<Plane> convex_planes = Geometry::build_cylinder_planes(0.5,0.7,4,Vector3::AXIS_Z);
-		Geometry::MeshData convex_data = Geometry::build_convex_mesh(convex_planes);
-		vts=convex_data.vertices;
-
-		Geometry::MeshData md;
-		Error err = QuickHull::build(vts,md);
-		print_line("ERR: "+itos(err));
-
-		vs->mesh_remove_surface(mesh,0);
-		vs->mesh_add_surface_from_mesh_data(mesh,md);
-
-
-
-		//vs->scenario_set_debug(scenario,VS::SCENARIO_DEBUG_WIREFRAME);
-
-		/*
-		RID sm = vs->shader_create();
-		//vs->shader_set_fragment_code(sm,"OUT_ALPHA=mod(TIME,1);");
-		//vs->shader_set_vertex_code(sm,"OUT_VERTEX=IN_VERTEX*mod(TIME,1);");
-		vs->shader_set_fragment_code(sm,"OUT_DIFFUSE=vec3(1,0,1);OUT_GLOW=abs(sin(TIME));");
-		RID tcmat = vs->mesh_surface_get_material(test_cube,0);
-		vs->material_set_shader(tcmat,sm);
-		*/
-
-	}
-
-	virtual void input_event(const InputEvent& p_event) {
-
-		if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&4) {
-
-			ofs_x+=p_event.mouse_motion.relative_y/200.0;
-			ofs_y+=p_event.mouse_motion.relative_x/200.0;
-		}
-		if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index==1) {
-
-			QuickHull::debug_stop_after++;
-			_update_qh();
-		}
-		if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index==2) {
-
-			if (QuickHull::debug_stop_after>0)
-				QuickHull::debug_stop_after--;
-			_update_qh();
-		}
-
-
-	}
-
-	virtual void request_quit() {
-
-		quit=true;
-	}
-
-
-
-	virtual void init() {
-
-		VisualServer *vs=VisualServer::get_singleton();
-
-
-		mesh = vs->mesh_create();
-
-		scenario = vs->scenario_create();
-
-		QuickHull::debug_stop_after=0;
-		_update_qh();
-
-		instance = vs->instance_create2(mesh,scenario);
-
-		camera = vs->camera_create();
-
-
-		vs->camera_set_perspective( camera, 60.0,0.1, 100.0 );
-		viewport = vs->viewport_create();
-		vs->viewport_attach_camera( viewport, camera );
-		vs->viewport_attach_to_screen(viewport);
-		vs->viewport_set_scenario( viewport, scenario );
-
-		vs->camera_set_transform(camera, Transform( Matrix3(), Vector3(0,0,2 ) ) );
-
-		RID lightaux = vs->light_create( VisualServer::LIGHT_DIRECTIONAL );
-		//vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_AMBIENT, Color(0.3,0.3,0.3) );
-		light = vs->instance_create2( lightaux,scenario );
-		vs->instance_set_transform(light,Transform(Matrix3(Vector3(0.1,0.4,0.7).normalized(),0.9)));
-
-		ofs_x=0;
-		ofs_y=0;
-		quit=false;
-	}
-
-	virtual bool idle(float p_time) {
-		return false;
-	}
-
-	virtual bool iteration(float p_time) {
-
-		VisualServer *vs=VisualServer::get_singleton();
-
-		Transform tr_camera;
-		tr_camera.rotate( Vector3(0,1,0), ofs_y );
-		tr_camera.rotate( Vector3(1,0,0),ofs_x );
-		tr_camera.translate(0,0,10);
-
-		vs->camera_set_transform( camera, tr_camera );
-
-		return quit;
-	}
-	virtual void finish() {
-
-	}
-
-};
-
-MainLoop* test() {
-
-	return memnew(TestMainLoop);
-
-}
-
-}

bin/tests/test_detailer.h

@@ -1,44 +0,0 @@
-/*************************************************************************/
-/*  test_detailer.h                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#ifndef TEST_MULTIMESH_H
-#define TEST_MULTIMESH_H
-
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-#include "os/main_loop.h"
-
-namespace TestMultiMesh {
-
-MainLoop* test();
-
-}
-
-
-#endif

bin/tests/test_gui.cpp

@@ -370,7 +370,7 @@ public:
 		tabc->set_size( Point2( 180,250 ) );
 
 
-		Ref<ImageTexture> text = memnew( ImageTexture );
+		/*Ref<ImageTexture> text = memnew( ImageTexture );
 		text->load("test_data/concave.png");
 
 		Sprite* sprite = memnew(Sprite);
@@ -383,7 +383,7 @@ public:
 		sprite->set_texture(text);
 		sprite->add_child(sprite2);
 		sprite2->set_pos(Point2(50, 50));
-		sprite2->show();
+		sprite2->show();*/
 	}
 
 

bin/tests/test_main.cpp

@@ -37,13 +37,10 @@
 #include "test_gui.h"
 #include "test_render.h"
 #include "test_sound.h"
-#include "test_misc.h"
 #include "test_physics.h"
 #include "test_physics_2d.h"
-#include "test_python.h"
+
 #include "test_io.h"
-#include "test_particles.h"
-#include "test_detailer.h"
 #include "test_shader_lang.h"
 #include "test_gdscript.h"
 #include "test_image.h"
@@ -56,7 +53,6 @@ const char ** tests_get_names()  {
 		"containers",
 		"math",
 		"render",
-		"particles",
 		"multimesh",
 		"gui",
 		"io",
@@ -96,11 +92,6 @@ MainLoop* test_main(String p_test,const List<String>& p_args) {
 		return TestPhysics2D::test();
 	}
 
-  	if (p_test=="misc") {
-
-		return TestMisc::test();
-	}
-
 	if (p_test=="render") {
 
 		return TestRender::test();
@@ -123,16 +114,6 @@ MainLoop* test_main(String p_test,const List<String>& p_args) {
 		return TestIO::test();
 	}
 
-	if (p_test=="particles") {
-
-		return TestParticles::test();
-	}
-
-	if (p_test=="multimesh") {
-
-		return TestMultiMesh::test();
-	}
-
 	if (p_test=="shaderlang") {
 
 		return TestShaderLang::test();
@@ -163,19 +144,6 @@ MainLoop* test_main(String p_test,const List<String>& p_args) {
 		return TestImage::test();
 	}
 
-	if (p_test=="detailer") {
-
-		return TestMultiMesh::test();
-	}
-
-#ifdef PYTHON_ENABLED
-
-	if (p_test=="python") {
-
-		return TestPython::test();
-	}
-#endif
-
 	return NULL;
 }
 

bin/tests/test_misc.cpp

@@ -1,499 +0,0 @@
-/*************************************************************************/
-/*  test_misc.cpp                                                        */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "test_misc.h"
-#include "servers/visual_server.h"
-#include "os/main_loop.h"
-#include "math_funcs.h"
-#include "print_string.h"
-
-
-namespace TestMisc {
-
-struct ConvexTestResult
-{
-
-	Vector3 edgeA[2];
-	Vector3 edgeB[2];
-	bool valid;
-	Vector3 contactA;
-	Vector3 contactB;
-	Vector3 contactNormal;
-	float depth;
-
-	/*
-	Vector3 contactA;
-	Vector3 contactB;
-	Vector3 contactNormal;
-	Vector3 contactX;
-	Vector3 contactY;
-	Vector3 edgeA[2];
-	Vector3 edgeB[2];
-	float depth;
-	bool valid;
-	bool isEdgeEdge;
-	bool needTransform;
-	neBool ComputerEdgeContactPoint(ConvexTestResult & res);
-	neBool ComputerEdgeContactPoint2(float & au, float & bu);
-	void Reverse()
-	{
-		neSwap(contactA, contactB);
-		contactNormal *= -1.0f;
-	}*/
-	bool ComputerEdgeContactPoint2(float & au, float & bu);
-};
-
-
-
-bool ConvexTestResult::ComputerEdgeContactPoint2(float & au, float & bu)
-{
-	float d1343, d4321, d1321, d4343, d2121;
-	float numer, denom;
-
-	Vector3 p13;
-	Vector3 p43;
-	Vector3 p21;
-	Vector3 diff;
-
-	p13 = (edgeA[0]) - (edgeB[0]);
-	p43 = (edgeB[1]) - (edgeB[0]);
-
-	if ( p43.length_squared() < CMP_EPSILON2 )
-	{
-		valid = false;
-		goto ComputerEdgeContactPoint2_Exit;
-	}
-
-	p21 = (edgeA[1]) - (edgeA[0]);
-
-	if ( p21.length_squared()<CMP_EPSILON2 )
-	{
-		valid = false;
-		goto ComputerEdgeContactPoint2_Exit;
-	}
-
-	d1343 = p13.dot(p43);
-	d4321 = p43.dot(p21);
-	d1321 = p13.dot(p21);
-	d4343 = p43.dot(p43);
-	d2121 = p21.dot(p21);
-
-	denom = d2121 * d4343 - d4321 * d4321;
-
-	if (ABS(denom) < CMP_EPSILON)
-	{
-		valid = false;
-
-		goto ComputerEdgeContactPoint2_Exit;
-	}
-
-	numer = d1343 * d4321 - d1321 * d4343;
-	au = numer / denom;
-	bu = (d1343 + d4321 * (au)) / d4343;
-
-	if (au < 0.0f || au >= 1.0f)
-	{
-		valid = false;
-	}
-	else if (bu < 0.0f || bu >= 1.0f)
-	{
-		valid = false;
-	}
-	else
-	{
-		valid = true;
-	}
-	{
-		Vector3 tmpv;
-
-		tmpv = p21 * au;
-		contactA = (edgeA[0]) + tmpv;
-
-		tmpv = p43 * bu;
-		contactB = (edgeB[0]) + tmpv;
-	}
-
-	diff = contactA - contactB;
-
-	depth = Math::sqrt(diff.dot(diff));
-
-	return true;
-
-ComputerEdgeContactPoint2_Exit:
-
-	return false;
-}
-
-struct neCollisionResult {
-
-	float depth;
-	bool penetrate;
-	Matrix3 collisionFrame;
-	Vector3 contactA;
-	Vector3 contactB;
-};
-
-
-struct TConvex {
-
-	float radius;
-	float half_height;
-	float CylinderRadius() const { return radius; }
-	float CylinderHalfHeight() const { return half_height; }
-};
-
-float GetDistanceFromLine2(Vector3 v, Vector3 & project, const Vector3 & pointA, const Vector3 & pointB)
-{
-	Vector3 ba = pointB - pointA;
-
-	float len = ba.length();
-
-	if (len<CMP_EPSILON)
-		ba=Vector3();
-	else
-		ba *= 1.0f / len;
-
-	Vector3 pa = v - pointA;
-
-	float k = pa.dot(ba);
-
-	project = pointA + ba * k;
-
-	Vector3 diff = v - project;
-
-	return diff.length();
-}
-
-void TestCylinderVertEdge(neCollisionResult & result, Vector3 & edgeA1, Vector3 & edgeA2, Vector3 & vertB,
-						  TConvex & cA, TConvex & cB, Transform & transA, Transform & transB, bool flip)
-{
-	Vector3 project;
-
-	float dist = GetDistanceFromLine2(vertB,project, edgeA1, edgeA2);
-
-	float depth = cA.CylinderRadius() + cB.CylinderRadius() - dist;
-
-	if (depth <= 0.0f)
-		return;
-
-	if (depth <= result.depth)
-		return;
-
-	result.penetrate = true;
-
-	result.depth = depth;
-
-	if (!flip)
-	{
-		result.collisionFrame.set_axis(2,(project - vertB).normalized());
-
-		result.contactA = project - result.collisionFrame.get_axis(2) * cA.CylinderRadius();
-
-		result.contactB = vertB + result.collisionFrame.get_axis(2) * cB.CylinderRadius();
-	}
-	else
-	{
-
-		result.collisionFrame.set_axis(2,(vertB - project).normalized());
-
-		result.contactA = vertB - result.collisionFrame.get_axis(2) * cB.CylinderRadius();
-
-		result.contactB = project + result.collisionFrame.get_axis(2) * cA.CylinderRadius();
-	}
-}
-
-void TestCylinderVertVert(neCollisionResult & result, Vector3 & vertA, Vector3 & vertB,
-						  TConvex & cA, TConvex & cB, Transform & transA, Transform & transB)
-{
-	Vector3 diff = vertA - vertB;
-
-	float dist = diff.length();
-
-	float depth = cA.CylinderRadius() + cB.CylinderRadius() - dist;
-
-	if (depth <= 0.0f)
-		return;
-
-	if (depth <= result.depth)
-		return;
-
-	result.penetrate = true;
-
-	result.depth = depth;
-
-	result.collisionFrame.set_axis(2, diff * (1.0f / dist));
-
-	result.contactA = vertA - result.collisionFrame.get_axis(2) * cA.CylinderRadius();
-
-	result.contactB = vertB + result.collisionFrame.get_axis(2) * cB.CylinderRadius();
-}
-
-void Cylinder2CylinderTest(neCollisionResult & result, TConvex & cA, Transform & transA, TConvex & cB, Transform & transB)
-{
-	result.penetrate = false;
-
-	Vector3 dir = transA.basis.get_axis(1).cross(transB.basis.get_axis(1));
-
-	float len = dir.length();
-
-//	bool isParallel = len<CMP_EPSILON;
-
-//	int doVertCheck = 0;
-
-	ConvexTestResult cr;
-
-	cr.edgeA[0] = transA.origin + transA.basis.get_axis(1) * cA.CylinderHalfHeight();
-	cr.edgeA[1] = transA.origin - transA.basis.get_axis(1) * cA.CylinderHalfHeight();
-	cr.edgeB[0] = transB.origin + transB.basis.get_axis(1) * cB.CylinderHalfHeight();
-	cr.edgeB[1] = transB.origin - transB.basis.get_axis(1) * cB.CylinderHalfHeight();
-
-//	float dot = transA.basis.get_axis(1).dot(transB.basis.get_axis(1));
-
-	if (len>CMP_EPSILON)
-	{
-		float au, bu;
-
-		cr.ComputerEdgeContactPoint2(au, bu);
-
-		if (cr.valid)
-		{
-			float depth = cA.CylinderRadius() + cB.CylinderRadius() - cr.depth;
-
-			if (depth <= 0.0f)
-				return;
-
-			result.depth = depth;
-
-			result.penetrate = true;
-
-			result.collisionFrame.set_axis(2, (cr.contactA - cr.contactB)*(1.0f / cr.depth));
-
-			result.contactA = cr.contactA - result.collisionFrame.get_axis(2) * cA.CylinderRadius();
-
-			result.contactB = cr.contactB + result.collisionFrame.get_axis(2) * cB.CylinderRadius();
-
-			return;
-		}
-	}
-	result.depth = -1.0e6f;
-
-	int i;
-
-	for (i = 0; i < 2; i++)
-	{
-		//project onto edge b
-
-		Vector3 diff = cr.edgeA[i] - cr.edgeB[1];
-
-		float dot = diff.dot(transB.basis.get_axis(1));
-
-		if (dot < 0.0f)
-		{
-			TestCylinderVertVert(result, cr.edgeA[i], cr.edgeB[1], cA, cB, transA, transB);
-		}
-		else if (dot > (2.0f * cB.CylinderHalfHeight()))
-		{
-			TestCylinderVertVert(result, cr.edgeA[i], cr.edgeB[0], cA, cB, transA, transB);
-		}
-		else
-		{
-			TestCylinderVertEdge(result, cr.edgeB[0], cr.edgeB[1], cr.edgeA[i], cB, cA, transB, transA, true);
-		}
-	}
-	for (i = 0; i < 2; i++)
-	{
-		//project onto edge b
-
-		Vector3 diff = cr.edgeB[i] - cr.edgeA[1];
-
-		float dot = diff.dot(transA.basis.get_axis(1));
-
-		if (dot < 0.0f)
-		{
-			TestCylinderVertVert(result, cr.edgeB[i], cr.edgeA[1], cA, cB, transA, transB);
-		}
-		else if (dot > (2.0f * cB.CylinderHalfHeight()))
-		{
-			TestCylinderVertVert(result, cr.edgeB[i], cr.edgeA[0], cA, cB, transA, transB);
-		}
-		else
-		{
-			TestCylinderVertEdge(result, cr.edgeA[0], cr.edgeA[1], cr.edgeB[i], cA, cB, transA, transB, false);
-		}
-	}
-}
-
-
-class TestMainLoop : public MainLoop {
-
-	RID meshA;
-	RID meshB;
-	RID poly;
-	RID instance;
-	RID camera;
-	RID viewport;
-	RID boxA;
-	RID boxB;
-	RID scenario;
-
-	Transform rot_a;
-	Transform rot_b;
-
-	bool quit;
-public:
-	virtual void input_event(const InputEvent& p_event) {
-
-		if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) {
-
-			rot_b.origin.y+=-p_event.mouse_motion.relative_y/100.0;
-			rot_b.origin.x+=p_event.mouse_motion.relative_x/100.0;
-		}
-		if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&BUTTON_MASK_MIDDLE) {
-
-			//rot_b.origin.x+=-p_event.mouse_motion.relative_y/100.0;
-			rot_b.origin.z+=p_event.mouse_motion.relative_x/100.0;
-		}
-		if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&BUTTON_MASK_RIGHT) {
-
-			float rot_x=-p_event.mouse_motion.relative_y/100.0;
-			float rot_y=p_event.mouse_motion.relative_x/100.0;
-			rot_b.basis = rot_b.basis * Matrix3(Vector3(1,0,0),rot_x) * Matrix3(Vector3(0,1,0),rot_y);
-		}
-
-	}
-	virtual void request_quit() {
-
-		quit=true;
-	}
-	virtual void init() {
-
-		VisualServer *vs=VisualServer::get_singleton();
-
-		camera = vs->camera_create();
-
-		viewport = vs->viewport_create();
-		vs->viewport_attach_to_screen(viewport);
-		vs->viewport_attach_camera( viewport, camera );
-		vs->camera_set_transform(camera, Transform( Matrix3(), Vector3(0,0,3 ) ) );
-
-		/* CONVEX SHAPE */
-
-		DVector<Plane> cylinder_planes = Geometry::build_cylinder_planes(0.5,2,9,Vector3::AXIS_Y);
-		RID cylinder_material = vs->fixed_material_create();
-		vs->fixed_material_set_param( cylinder_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(0.8,0.2,0.9));
-		vs->material_set_flag( cylinder_material, VisualServer::MATERIAL_FLAG_ONTOP,true);
-		//vs->material_set_flag( cylinder_material, VisualServer::MATERIAL_FLAG_WIREFRAME,true);
-		vs->material_set_flag( cylinder_material, VisualServer::MATERIAL_FLAG_DOUBLE_SIDED,true);
-		vs->material_set_flag( cylinder_material, VisualServer::MATERIAL_FLAG_UNSHADED,true);
-
-		RID cylinder_mesh = vs->mesh_create();
-		Geometry::MeshData cylinder_data = Geometry::build_convex_mesh(cylinder_planes);
-		vs->mesh_add_surface_from_mesh_data(cylinder_mesh,cylinder_data);
-		vs->mesh_surface_set_material( cylinder_mesh, 0, cylinder_material );
-
-		meshA=vs->instance_create2(cylinder_mesh,scenario);
-		meshB=vs->instance_create2(cylinder_mesh,scenario);
-		boxA=vs->instance_create2(vs->get_test_cube(),scenario);
-		boxB=vs->instance_create2(vs->get_test_cube(),scenario);
-
-		/*
-		RID lightaux = vs->light_create( VisualServer::LIGHT_OMNI );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_RADIUS, 80 );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_ATTENUATION, 1 );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_ENERGY, 1.5 );
-		light = vs->instance_create2( lightaux );
-		*/
-		RID lightaux = vs->light_create( VisualServer::LIGHT_DIRECTIONAL );
-		//vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_AMBIENT, Color(0.0,0.0,0.0) );
-		//vs->light_set_shadow( lightaux, true );
-		vs->instance_create2( lightaux,scenario );
-
-		//rot_a=Transform(Matrix3(Vector3(1,0,0),Math_PI/2.0),Vector3());
-		rot_b=Transform(Matrix3(),Vector3(2,0,0));
-
-		//rot_x=0;
-		//rot_y=0;
-		quit=false;
-	}
-	virtual bool idle(float p_time) {
-
-		VisualServer *vs=VisualServer::get_singleton();
-
-		vs->instance_set_transform(meshA,rot_a);
-		vs->instance_set_transform(meshB,rot_b);
-
-
-		neCollisionResult res;
-		TConvex a;
-		a.radius=0.5;
-		a.half_height=1;
-		Cylinder2CylinderTest(res,a,rot_a,a,rot_b);
-		if (res.penetrate) {
-
-			Matrix3 scale;
-			scale.scale(Vector3(0.1,0.1,0.1));
-			vs->instance_set_transform(boxA,Transform(scale,res.contactA));
-			vs->instance_set_transform(boxB,Transform(scale,res.contactB));
-			print_line("depth: "+rtos(res.depth));
-		} else  {
-
-			Matrix3 scale;
-			scale.scale(Vector3());
-			vs->instance_set_transform(boxA,Transform(scale,res.contactA));
-			vs->instance_set_transform(boxB,Transform(scale,res.contactB));
-
-		}
-		print_line("collided: "+itos(res.penetrate));
-
-		return false;
-	}
-
-
-	virtual bool iteration(float p_time) {
-
-
-
-		return quit;
-	}
-	virtual void finish() {
-
-	}
-
-};
-
-
-MainLoop* test() {
-
-	return memnew( TestMainLoop );
-
-}
-
-}
-
-
-

bin/tests/test_misc.h

@@ -1,40 +0,0 @@
-/*************************************************************************/
-/*  test_misc.h                                                          */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#ifndef TEST_MISC_H
-#define TEST_MISC_H
-
-#include "os/main_loop.h"
-
-namespace TestMisc {
-
-MainLoop* test();
-
-}
-
-#endif

bin/tests/test_particles.cpp

@@ -1,121 +0,0 @@
-/*************************************************************************/
-/*  test_particles.cpp                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "test_particles.h"
-#include "servers/visual_server.h"
-#include "os/main_loop.h"
-#include "math_funcs.h"
-#include "print_string.h"
-
-namespace TestParticles {
-
-
-class TestMainLoop : public MainLoop {
-
-	RID particles;
-	RID instance;
-	RID camera;
-	RID viewport;
-	RID light;
-	RID scenario;
-
-	struct InstanceInfo {
-
-		RID instance;
-		Transform base;
-		Vector3 rot_axis;
-	};
-
-	List<InstanceInfo> instances;
-
-	float ofs;
-	bool quit;
-public:
-	virtual void input_event(const InputEvent& p_event) {
-
-
-	}
-	virtual void request_quit() {
-
-		quit=true;
-	}
-	virtual void init() {
-
-		VisualServer *vs=VisualServer::get_singleton();
-		particles = vs->particles_create();
-		vs->particles_set_amount(particles,1000);
-
-		instance = vs->instance_create2(particles,scenario);
-
-
-		camera = vs->camera_create();
-
-// 		vs->camera_set_perspective( camera, 60.0,0.1, 100.0 );
-		viewport = vs->viewport_create();
-		vs->viewport_attach_camera( viewport, camera );
-		vs->camera_set_transform(camera, Transform( Matrix3(), Vector3(0,0,20 ) ) );
-		/*
-		RID lightaux = vs->light_create( VisualServer::LIGHT_OMNI );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_RADIUS, 80 );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_ATTENUATION, 1 );
-		vs->light_set_var( lightaux, VisualServer::LIGHT_VAR_ENERGY, 1.5 );
-		light = vs->instance_create2( lightaux );
-		*/
-		RID lightaux = vs->light_create( VisualServer::LIGHT_DIRECTIONAL );
-	//	vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_AMBIENT, Color(0.0,0.0,0.0) );
-		light = vs->instance_create2( lightaux, scenario );
-
-		ofs=0;
-		quit=false;
-	}
-	virtual bool idle(float p_time) {
-		return false;
-	}
-
-
-	virtual bool iteration(float p_time) {
-
-//		VisualServer *vs=VisualServer::get_singleton();
-
-		ofs+=p_time;
-		return quit;
-	}
-	virtual void finish() {
-
-	}
-
-};
-
-
-MainLoop* test() {
-
-	return memnew( TestMainLoop );
-
-}
-
-}

bin/tests/test_particles.h

@@ -1,43 +0,0 @@
-/*************************************************************************/
-/*  test_particles.h                                                     */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#ifndef TEST_PARTICLES_H
-#define TEST_PARTICLES_H
-
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-#include "os/main_loop.h"
-
-namespace TestParticles {
-
-MainLoop* test();
-
-}
-
-#endif

bin/tests/test_physics.cpp

@@ -138,10 +138,6 @@ protected:
 
 		/* SPHERE SHAPE */
 		RID sphere_mesh = vs->make_sphere_mesh(10,20,0.5);
-		RID sphere_material = vs->fixed_material_create();
-		//vs->material_set_flag( sphere_material, VisualServer::MATERIAL_FLAG_WIREFRAME, true );
-		vs->fixed_material_set_param( sphere_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(0.7,0.8,3.0) );
-		vs->mesh_surface_set_material( sphere_mesh, 0, sphere_material );
 		type_mesh_map[PhysicsServer::SHAPE_SPHERE]=sphere_mesh;
 
 		RID sphere_shape=ps->shape_create(PhysicsServer::SHAPE_SPHERE);
@@ -151,12 +147,9 @@ protected:
 		/* BOX SHAPE */
 
 		DVector<Plane> box_planes = Geometry::build_box_planes(Vector3(0.5,0.5,0.5));
-		RID box_material = vs->fixed_material_create();
-		vs->fixed_material_set_param( box_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(1.0,0.2,0.2) );
 		RID box_mesh = vs->mesh_create();
 		Geometry::MeshData box_data = Geometry::build_convex_mesh(box_planes);
 		vs->mesh_add_surface_from_mesh_data(box_mesh,box_data);
-		vs->mesh_surface_set_material( box_mesh, 0, box_material );
 		type_mesh_map[PhysicsServer::SHAPE_BOX]=box_mesh;
 
 		RID box_shape=ps->shape_create(PhysicsServer::SHAPE_BOX);
@@ -167,13 +160,11 @@ protected:
 		/* CAPSULE SHAPE */
 
 		DVector<Plane> capsule_planes = Geometry::build_capsule_planes(0.5,0.7,12,Vector3::AXIS_Z);
-		RID capsule_material = vs->fixed_material_create();
-		vs->fixed_material_set_param( capsule_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(0.3,0.4,1.0) );
 
 		RID capsule_mesh = vs->mesh_create();
 		Geometry::MeshData capsule_data = Geometry::build_convex_mesh(capsule_planes);
 		vs->mesh_add_surface_from_mesh_data(capsule_mesh,capsule_data);
-		vs->mesh_surface_set_material( capsule_mesh, 0, capsule_material );
+
 		type_mesh_map[PhysicsServer::SHAPE_CAPSULE]=capsule_mesh;
 
 		RID capsule_shape=ps->shape_create(PhysicsServer::SHAPE_CAPSULE);
@@ -186,14 +177,12 @@ protected:
 		/* CONVEX SHAPE */
 
 		DVector<Plane> convex_planes = Geometry::build_cylinder_planes(0.5,0.7,5,Vector3::AXIS_Z);
-		RID convex_material = vs->fixed_material_create();
-		vs->fixed_material_set_param( convex_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(0.8,0.2,0.9));
 
 		RID convex_mesh = vs->mesh_create();
 		Geometry::MeshData convex_data = Geometry::build_convex_mesh(convex_planes);
 		QuickHull::build(convex_data.vertices,convex_data);
 		vs->mesh_add_surface_from_mesh_data(convex_mesh,convex_data);
-		vs->mesh_surface_set_material( convex_mesh, 0, convex_material );
+
 		type_mesh_map[PhysicsServer::SHAPE_CONVEX_POLYGON]=convex_mesh;
 
 		RID convex_shape=ps->shape_create(PhysicsServer::SHAPE_CONVEX_POLYGON);
@@ -223,11 +212,9 @@ protected:
 		d.resize(VS::ARRAY_MAX);
 		d[VS::ARRAY_VERTEX]=p_faces;
 		d[VS::ARRAY_NORMAL]=normals;
-		vs->mesh_add_surface(trimesh_mesh, VS::PRIMITIVE_TRIANGLES, d );
-		RID trimesh_mat = vs->fixed_material_create();
-		vs->fixed_material_set_param( trimesh_mat, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(1.0,0.5,0.8));
+		vs->mesh_add_surface_from_arrays(trimesh_mesh, VS::PRIMITIVE_TRIANGLES, d );
 		//vs->material_set_flag( trimesh_mat, VisualServer::MATERIAL_FLAG_UNSHADED,true);
-		vs->mesh_surface_set_material( trimesh_mesh, 0, trimesh_mat );
+
 
 		RID triins = vs->instance_create2(trimesh_mesh,scenario);
 
@@ -464,7 +451,7 @@ public:
 	}
 	virtual bool iteration(float p_time) {
 
-		if (mover) {
+		if (mover.is_valid()) {
 			static float joy_speed = 10;
 			PhysicsServer * ps = PhysicsServer::get_singleton();
 			Transform t = ps->body_get_state(mover,PhysicsServer::BODY_STATE_TRANSFORM);
@@ -548,15 +535,10 @@ public:
 
 
 		DVector<Plane> capsule_planes = Geometry::build_capsule_planes(0.5,1,12,5,Vector3::AXIS_Y);
-		RID capsule_material = vs->fixed_material_create();
-
-		vs->fixed_material_set_param( capsule_material, VisualServer::FIXED_MATERIAL_PARAM_DIFFUSE, Color(1,1,1) );
-
 
 		RID capsule_mesh = vs->mesh_create();
 		Geometry::MeshData capsule_data = Geometry::build_convex_mesh(capsule_planes);
 		vs->mesh_add_surface_from_mesh_data(capsule_mesh,capsule_data);
-		vs->mesh_surface_set_material( capsule_mesh, 0, capsule_material );
 		type_mesh_map[PhysicsServer::SHAPE_CAPSULE]=capsule_mesh;
 
 		RID capsule_shape=ps->shape_create(PhysicsServer::SHAPE_CAPSULE);

bin/tests/test_physics_2d.cpp

@@ -85,7 +85,7 @@ class TestPhysics2DMainLoop : public MainLoop {
 				}
 			}
 
-			Image image(32,2,0,Image::FORMAT_GRAYSCALE_ALPHA,pixels);
+			Image image(32,2,0,Image::FORMAT_LA8,pixels);
 
 			body_shape_data[Physics2DServer::SHAPE_SEGMENT].image=vs->texture_create_from_image(image);
 
@@ -113,7 +113,7 @@ class TestPhysics2DMainLoop : public MainLoop {
 				}
 			}
 
-			Image image(32,32,0,Image::FORMAT_GRAYSCALE_ALPHA,pixels);
+			Image image(32,32,0,Image::FORMAT_LA8,pixels);
 
 			body_shape_data[Physics2DServer::SHAPE_CIRCLE].image=vs->texture_create_from_image(image);
 
@@ -141,7 +141,7 @@ class TestPhysics2DMainLoop : public MainLoop {
 				}
 			}
 
-			Image image(32,32,0,Image::FORMAT_GRAYSCALE_ALPHA,pixels);
+			Image image(32,32,0,Image::FORMAT_LA8,pixels);
 
 			body_shape_data[Physics2DServer::SHAPE_RECTANGLE].image=vs->texture_create_from_image(image);
 
@@ -173,7 +173,7 @@ class TestPhysics2DMainLoop : public MainLoop {
 				}
 			}
 
-			Image image(32,64,0,Image::FORMAT_GRAYSCALE_ALPHA,pixels);
+			Image image(32,64,0,Image::FORMAT_LA8,pixels);
 
 			body_shape_data[Physics2DServer::SHAPE_CAPSULE].image=vs->texture_create_from_image(image);
 
@@ -381,7 +381,7 @@ public:
 			RID vp = vs->viewport_create();
 			canvas = vs->canvas_create();
 			vs->viewport_attach_canvas(vp,canvas);
-			vs->viewport_attach_to_screen(vp);
+			vs->viewport_attach_to_screen(vp,Rect2(Vector2(),OS::get_singleton()->get_window_size()));
 			Matrix32 smaller;
 			//smaller.scale(Vector2(0.6,0.6));
 			//smaller.elements[2]=Vector2(100,0);

bin/tests/test_python.cpp

@@ -1,56 +0,0 @@
-/*************************************************************************/
-/*  test_python.cpp                                                      */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "test_python.h"
-
-#ifdef PYTHON_ENABLED
-
-#include "Python.h"
-#include "print_string.h"
-
-namespace TestPython {
-
-void test() {
-
-	print_line("testing python");
-	PyRun_SimpleString("import engine\n");
-	PyRun_SimpleString("def test(self):\n\tprint(\"noway\")\n");
-	PyRun_SimpleString("a=engine.ObjectPtr()\n");
-	PyRun_SimpleString("a.noway(22,'hello')\n");
-	PyRun_SimpleString("a.normalize()\n");
-	PyRun_SimpleString("class Moch(engine.ObjectPtr):\n\tdef mooch(self):\n\t\tprint('muchi')\n");
-	PyRun_SimpleString("b=Moch();\n");
-	PyRun_SimpleString("b.mooch();\n");
-	PyRun_SimpleString("b.meis();\n");
-
-
-}
-
-}
-
-#endif

bin/tests/test_python.h

@@ -1,43 +0,0 @@
-/*************************************************************************/
-/*  test_python.h                                                        */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#ifndef TEST_PYTHON_H
-#define TEST_PYTHON_H
-
-#ifdef PYTHON_ENABLED
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-namespace TestPython {
-
-void test();
-
-}
-
-#endif
-#endif

bin/tests/test_render.cpp

@@ -173,7 +173,10 @@ public:
 // 		vs->camera_set_perspective( camera, 60.0,0.1, 100.0 );
 
 		viewport = vs->viewport_create();
-		vs->viewport_attach_to_screen(viewport);
+		Size2i screen_size = OS::get_singleton()->get_window_size();
+		vs->viewport_set_size(viewport,screen_size.x,screen_size.y);
+		vs->viewport_attach_to_screen(viewport,Rect2(Vector2(),screen_size));
+		vs->viewport_set_active(viewport,true);
 		vs->viewport_attach_camera( viewport, camera );
 		vs->viewport_set_scenario( viewport, scenario );
 		vs->camera_set_transform(camera, Transform( Matrix3(), Vector3(0,3,30 ) ) );
@@ -192,7 +195,7 @@ public:
 		//*
 		lightaux = vs->light_create( VisualServer::LIGHT_DIRECTIONAL );
 		//vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_AMBIENT, Color(0.0,0.0,0.0) );
-		vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_DIFFUSE, Color(1.0,1.0,1.0) );
+		vs->light_set_color( lightaux,  Color(1.0,1.0,1.0) );
 		//vs->light_set_shadow( lightaux, true );
 		light = vs->instance_create2( lightaux, scenario );
 		Transform lla;
@@ -205,8 +208,8 @@ public:
 		//*
 		lightaux = vs->light_create( VisualServer::LIGHT_OMNI );
 //		vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_AMBIENT, Color(0.0,0.0,1.0) );
-		vs->light_set_color( lightaux, VisualServer::LIGHT_COLOR_DIFFUSE, Color(1.0,1.0,0.0) );
-		vs->light_set_param( lightaux, VisualServer::LIGHT_PARAM_RADIUS, 4 );
+		vs->light_set_color( lightaux,  Color(1.0,1.0,0.0) );
+		vs->light_set_param( lightaux, VisualServer::LIGHT_PARAM_RANGE, 4 );
 		vs->light_set_param( lightaux, VisualServer::LIGHT_PARAM_ENERGY, 8 );
 		//vs->light_set_shadow( lightaux, true );
 		//light = vs->instance_create( lightaux );

bin/tests/test_shader_lang.cpp

@@ -37,7 +37,7 @@
 #include "scene/gui/text_edit.h"
 #include "print_string.h"
 #include "servers/visual/shader_language.h"
-#include "drivers/gles2/shader_compiler_gles2.h"
+//#include "drivers/gles2/shader_compiler_gles2.h"
 
 
 typedef ShaderLanguage SL;
@@ -57,50 +57,54 @@ static String _mktab(int p_level) {
 
 static String _typestr(SL::DataType p_type) {
 
-	switch(p_type) {
+	return ShaderLanguage::get_datatype_name(p_type);
+
+	return "";
+}
+
+
+static String _prestr(SL::DataPrecision p_pres) {
 
-		case SL::TYPE_VOID: return "void";
-		case SL::TYPE_BOOL: return "bool";
-		case SL::TYPE_FLOAT: return "float";
-		case SL::TYPE_VEC2: return "vec2";
-		case SL::TYPE_VEC3: return "vec3";
-		case SL::TYPE_VEC4: return "vec4";
-		case SL::TYPE_MAT3: return "mat3";
-		case SL::TYPE_MAT4: return "mat4";
-		case SL::TYPE_TEXTURE: return "texture";
-		case SL::TYPE_CUBEMAP: return "cubemap";
-		default: {}
-	}
 
+	switch(p_pres) {
+		case SL::PRECISION_LOWP: return "lowp ";
+		case SL::PRECISION_MEDIUMP: return "mediump ";
+		case SL::PRECISION_HIGHP: return "highp ";
+		case SL::PRECISION_DEFAULT: return "";
+	}
 	return "";
 }
 
+
 static String _opstr(SL::Operator p_op) {
 
-	switch(p_op) {
-		case SL::OP_ASSIGN: return "=";
-		case SL::OP_ADD: return "+";
-		case SL::OP_SUB: return "-";
-		case SL::OP_MUL: return "*";
-		case SL::OP_DIV: return "/";
-		case SL::OP_ASSIGN_ADD: return "+=";
-		case SL::OP_ASSIGN_SUB: return "-=";
-		case SL::OP_ASSIGN_MUL: return "*=";
-		case SL::OP_ASSIGN_DIV: return "/=";
-		case SL::OP_NEG: return "-";
-		case SL::OP_NOT: return "!";
-		case SL::OP_CMP_EQ: return "==";
-		case SL::OP_CMP_NEQ: return "!=";
-		case SL::OP_CMP_LEQ: return "<=";
-		case SL::OP_CMP_GEQ: return ">=";
-		case SL::OP_CMP_LESS: return "<";
-		case SL::OP_CMP_GREATER: return ">";
-		case SL::OP_CMP_OR: return "||";
-		case SL::OP_CMP_AND: return "&&";
-		default: return "";
-	}
+	return ShaderLanguage::get_operator_text(p_op);
 
-	return "";
+
+}
+
+
+static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value>& p_values) {
+
+	switch(p_type) {
+		case SL::TYPE_BOOL:  return p_values[0].boolean?"true":"false";
+		case SL::TYPE_BVEC2:  return String()+"bvec2("+(p_values[0].boolean?"true":"false")+(p_values[1].boolean?"true":"false")+")";
+		case SL::TYPE_BVEC3:  return String()+"bvec3("+(p_values[0].boolean?"true":"false")+","+(p_values[1].boolean?"true":"false")+","+(p_values[2].boolean?"true":"false")+")";
+		case SL::TYPE_BVEC4:  return String()+"bvec4("+(p_values[0].boolean?"true":"false")+","+(p_values[1].boolean?"true":"false")+","+(p_values[2].boolean?"true":"false")+","+(p_values[3].boolean?"true":"false")+")";
+		case SL::TYPE_INT:  return rtos(p_values[0].sint);
+		case SL::TYPE_IVEC2:  return String()+"ivec2("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+")";
+		case SL::TYPE_IVEC3:  return String()+"ivec3("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+","+rtos(p_values[2].sint)+")";
+		case SL::TYPE_IVEC4:  return String()+"ivec4("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+","+rtos(p_values[2].sint)+","+rtos(p_values[3].sint)+")";
+		case SL::TYPE_UINT:  return rtos(p_values[0].real);
+		case SL::TYPE_UVEC2:  return String()+"uvec2("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+")";
+		case SL::TYPE_UVEC3:  return String()+"uvec3("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+")";
+		case SL::TYPE_UVEC4:  return String()+"uvec4("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+","+rtos(p_values[3].real)+")";
+		case SL::TYPE_FLOAT:  return rtos(p_values[0].real);
+		case SL::TYPE_VEC2:  return String()+"vec2("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+")";
+		case SL::TYPE_VEC3:  return String()+"vec3("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+")";
+		case SL::TYPE_VEC4:  return String()+"vec4("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+","+rtos(p_values[3].real)+")";
+		default: ERR_FAIL_V(String());
+	}
 }
 
 static String dump_node_code(SL::Node *p_node,int p_level) {
@@ -109,18 +113,48 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 
 	switch(p_node->type) {
 
-		case SL::Node::TYPE_PROGRAM: {
+		case SL::Node::TYPE_SHADER: {
 
-			SL::ProgramNode *pnode=(SL::ProgramNode*)p_node;
+			SL::ShaderNode *pnode=(SL::ShaderNode*)p_node;
 
-			for(Map<StringName,SL::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+			for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
 
 				String ucode="uniform ";
-				ucode+=_typestr(E->get().type)+"="+String(E->get().default_value)+"\n";
-				code+=ucode;
+				ucode+=_prestr(E->get().precission);
+				ucode+=_typestr(E->get().type);
+				ucode+=" "+String(E->key());
+
+				if (E->get().default_value.size()) {
+					ucode+=" = "+get_constant_text(E->get().type,E->get().default_value);
+				}
+
+				static const char*hint_name[SL::ShaderNode::Uniform::HINT_MAX]={
+					"",
+					"color",
+					"range",
+					"albedo",
+					"normal",
+					"black",
+					"white"
+				};
+
+				if (E->get().hint)
+					ucode+=" : "+String(hint_name[E->get().hint]);
+
+				code+=ucode+"\n";
 
 			}
 
+			for(Map<StringName,SL::ShaderNode::Varying>::Element *E=pnode->varyings.front();E;E=E->next()) {
+
+				String vcode="varying ";
+				vcode+=_prestr(E->get().precission);
+				vcode+=_typestr(E->get().type);
+				vcode+=" "+String(E->key());
+
+				code+=vcode+"\n";
+
+			}
 			for(int i=0;i<pnode->functions.size();i++) {
 
 				SL::FunctionNode *fnode=pnode->functions[i].function;
@@ -131,16 +165,15 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 
 					if (i>0)
 						header+=", ";
-					header+=_typestr(fnode->arguments[i].type)+" "+fnode->arguments[i].name;
+					header+=_prestr(fnode->arguments[i].precision)+_typestr(fnode->arguments[i].type)+" "+fnode->arguments[i].name;
 				}
 
-				header+=") {\n";
+				header+=")\n";
 				code+=header;
 				code+=dump_node_code(fnode->body,p_level+1);
-				code+="}\n";
 			}
 
-			code+=dump_node_code(pnode->body,p_level);
+			//code+=dump_node_code(pnode->body,p_level);
 		} break;
 		case SL::Node::TYPE_FUNCTION: {
 
@@ -149,15 +182,23 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 			SL::BlockNode *bnode=(SL::BlockNode*)p_node;
 
 			//variables
-			for(Map<StringName,SL::DataType>::Element *E=bnode->variables.front();E;E=E->next()) {
+			code+=_mktab(p_level-1)+"{\n";
+			for(Map<StringName,SL::BlockNode::Variable>::Element *E=bnode->variables.front();E;E=E->next()) {
 
-				code+=_mktab(p_level)+_typestr(E->value())+" "+E->key()+";\n";
+				code+=_mktab(p_level)+_prestr(E->get().precision)+_typestr(E->get().type)+" "+E->key()+";\n";
 			}
 
 			for(int i=0;i<bnode->statements.size();i++) {
 
-				code+=_mktab(p_level)+dump_node_code(bnode->statements[i],p_level)+";\n";
+				String scode = dump_node_code(bnode->statements[i],p_level);
+
+				if (bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW || bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW) {
+					code+=scode; //use directly
+				} else {
+					code+=_mktab(p_level)+scode+";\n";
+				}
 			}
+			code+=_mktab(p_level-1)+"}\n";
 
 
 		} break;
@@ -168,18 +209,7 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 		} break;
 		case SL::Node::TYPE_CONSTANT: {
 			SL::ConstantNode *cnode=(SL::ConstantNode*)p_node;
-			switch(cnode->datatype) {
-
-
-				case SL::TYPE_BOOL: code=cnode->value.operator bool()?"true":"false"; break;
-				case SL::TYPE_FLOAT: code=cnode->value; break;
-				case SL::TYPE_VEC2: { Vector2 v = cnode->value; code="vec2("+rtos(v.x)+", "+rtos(v.y)+")"; } break;
-				case SL::TYPE_VEC3: { Vector3 v = cnode->value; code="vec3("+rtos(v.x)+", "+rtos(v.y)+", "+rtos(v.z)+")"; } break;
-				case SL::TYPE_VEC4: { Plane v = cnode->value; code="vec4("+rtos(v.normal.x)+", "+rtos(v.normal.y)+", "+rtos(v.normal.z)+", "+rtos(v.d)+")"; } break;
-				case SL::TYPE_MAT3: { Matrix3 x = cnode->value; code="mat3( vec3("+rtos(x.get_axis(0).x)+", "+rtos(x.get_axis(0).y)+", "+rtos(x.get_axis(0).z)+"), vec3("+rtos(x.get_axis(1).x)+", "+rtos(x.get_axis(1).y)+", "+rtos(x.get_axis(1).z)+"), vec3("+rtos(x.get_axis(2).x)+", "+rtos(x.get_axis(2).y)+", "+rtos(x.get_axis(2).z)+"))"; } break;
-				case SL::TYPE_MAT4: { Transform x = cnode->value; code="mat4( vec3("+rtos(x.basis.get_axis(0).x)+", "+rtos(x.basis.get_axis(0).y)+", "+rtos(x.basis.get_axis(0).z)+"), vec3("+rtos(x.basis.get_axis(1).x)+", "+rtos(x.basis.get_axis(1).y)+", "+rtos(x.basis.get_axis(1).z)+"), vec3("+rtos(x.basis.get_axis(2).x)+", "+rtos(x.basis.get_axis(2).y)+", "+rtos(x.basis.get_axis(2).z)+"), vec3("+rtos(x.origin.x)+", "+rtos(x.origin.y)+", "+rtos(x.origin.z)+"))"; } break;
-				default: code="<error: "+Variant::get_type_name(cnode->value.get_type())+" ("+itos(cnode->datatype)+">";
-			}
+			return get_constant_text(cnode->datatype,cnode->values);
 
 		} break;
 		case SL::Node::TYPE_OPERATOR: {
@@ -193,28 +223,25 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 				case SL::OP_ASSIGN_SUB:
 				case SL::OP_ASSIGN_MUL:
 				case SL::OP_ASSIGN_DIV:
+				case SL::OP_ASSIGN_SHIFT_LEFT:
+				case SL::OP_ASSIGN_SHIFT_RIGHT:
+				case SL::OP_ASSIGN_MOD:
+				case SL::OP_ASSIGN_BIT_AND:
+				case SL::OP_ASSIGN_BIT_OR:
+				case SL::OP_ASSIGN_BIT_XOR:
 					code=dump_node_code(onode->arguments[0],p_level)+_opstr(onode->op)+dump_node_code(onode->arguments[1],p_level);
 					break;
-
-				case SL::OP_ADD:
-				case SL::OP_SUB:
-				case SL::OP_MUL:
-				case SL::OP_DIV:
-				case SL::OP_CMP_EQ:
-				case SL::OP_CMP_NEQ:
-				case SL::OP_CMP_LEQ:
-				case SL::OP_CMP_GEQ:
-				case SL::OP_CMP_LESS:
-				case SL::OP_CMP_GREATER:
-				case SL::OP_CMP_OR:
-				case SL::OP_CMP_AND:
-
-					code="("+dump_node_code(onode->arguments[0],p_level)+_opstr(onode->op)+dump_node_code(onode->arguments[1],p_level)+")";
-					break;
-				case SL::OP_NEG:
+				case SL::OP_BIT_INVERT:
+				case SL::OP_NEGATE:
 				case SL::OP_NOT:
+				case SL::OP_DECREMENT:
+				case SL::OP_INCREMENT:
 					code=_opstr(onode->op)+dump_node_code(onode->arguments[0],p_level);
 					break;
+				case SL::OP_POST_DECREMENT:
+				case SL::OP_POST_INCREMENT:
+					code=dump_node_code(onode->arguments[0],p_level)+_opstr(onode->op);
+					break;
 				case SL::OP_CALL:
 				case SL::OP_CONSTRUCT:
 					code=dump_node_code(onode->arguments[0],p_level)+"(";
@@ -225,7 +252,12 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 					}
 					code+=")";
 					break;
-				default: {}
+				default: {
+
+					code="("+dump_node_code(onode->arguments[0],p_level)+_opstr(onode->op)+dump_node_code(onode->arguments[1],p_level)+")";
+					break;
+
+				}
 			}
 
 		} break;
@@ -233,20 +265,19 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 			SL::ControlFlowNode *cfnode=(SL::ControlFlowNode*)p_node;
 			if (cfnode->flow_op==SL::FLOW_OP_IF) {
 
-				code+="if ("+dump_node_code(cfnode->statements[0],p_level)+") {\n";
-				code+=dump_node_code(cfnode->statements[1],p_level+1);
-				if (cfnode->statements.size()==3) {
+				code+=_mktab(p_level)+"if ("+dump_node_code(cfnode->expressions[0],p_level)+")\n";
+				code+=dump_node_code(cfnode->blocks[0],p_level+1);
+				if (cfnode->blocks.size()==2) {
 
-					code+="} else {\n";
-					code+=dump_node_code(cfnode->statements[2],p_level+1);
+					code+=_mktab(p_level)+"else\n";
+					code+=dump_node_code(cfnode->blocks[1],p_level+1);
 				}
 
-				code+="}\n";
 
 			} else if (cfnode->flow_op==SL::FLOW_OP_RETURN) {
 
-				if (cfnode->statements.size()) {
-					code="return "+dump_node_code(cfnode->statements[0],p_level);
+				if (cfnode->blocks.size()) {
+					code="return "+dump_node_code(cfnode->blocks[0],p_level);
 				} else {
 					code="return";
 				}
@@ -264,16 +295,14 @@ static String dump_node_code(SL::Node *p_node,int p_level) {
 
 }
 
-static Error recreate_code(void *p_str,SL::ProgramNode *p_program) {
+static Error recreate_code(void *p_str,SL::ShaderNode *p_program) {
+
 
-	print_line("recr");
 	String *str=(String*)p_str;
 
 	*str=dump_node_code(p_program,0);
 
 	return OK;
-
-
 }
 
 
@@ -283,6 +312,7 @@ MainLoop* test() {
 
 	if (cmdlargs.empty()) {
 		//try editor!
+		print_line("usage: godot -test shader_lang <shader>");
 		return NULL;
 	}
 
@@ -303,38 +333,29 @@ MainLoop* test() {
 		code+=c;
 	}
 
-	int errline;
-	int errcol;
-	String error;
-	print_line(SL::lex_debug(code));
-	Error err = SL::compile(code,ShaderLanguage::SHADER_MATERIAL_FRAGMENT,NULL,NULL,&error,&errline,&errcol);
+	SL sl;
+	print_line("tokens:\n\n"+sl.token_debug(code));
 
-	if (err) {
+	Map<StringName,Map<StringName,SL::DataType> > dt;
+	dt["fragment"]["ALBEDO"]=SL::TYPE_VEC3;
 
-		print_line("Error: "+itos(errline)+":"+itos(errcol)+" "+error);
-		return NULL;
-	}
+	Set<String> rm;
+	rm.insert("popo");
 
-	print_line("Compile OK! - pretty printing");
+	Error err = sl.compile(code,dt,rm);
 
-	String rcode;
-	err = SL::compile(code,ShaderLanguage::SHADER_MATERIAL_FRAGMENT,recreate_code,&rcode,&error,&errline,&errcol);
+	if (err) {
 
-	if (!err) {
-		print_line(rcode);
+		print_line("Error at line: "+rtos(sl.get_error_line())+": "+sl.get_error_text());
+		return NULL;
+	} else {
+		String code;
+		recreate_code(&code,sl.get_shader());
+		print_line("code:\n\n"+code);
 	}
 
-	ShaderCompilerGLES2 comp;
-	String codeline,globalsline;
-	SL::VarInfo vi;
-	vi.name="mongs";
-	vi.type=SL::TYPE_VEC3;
-
-
-	ShaderCompilerGLES2::Flags fl;
-	comp.compile(code,ShaderLanguage::SHADER_MATERIAL_FRAGMENT,codeline,globalsline,fl);
-
 	return NULL;
 }
 
+
 }

core/error_macros.h

@@ -49,7 +49,8 @@
 enum ErrorHandlerType {
 	ERR_HANDLER_ERROR,
 	ERR_HANDLER_WARNING,
-	ERR_HANDLER_SCRIPT
+	ERR_HANDLER_SCRIPT,
+	ERR_HANDLER_SHADER,
 };
 
 typedef void (*ErrorHandlerFunc)(void*,const char*,const char*,int p_line,const char *, const char *,ErrorHandlerType p_type);

core/globals.cpp

@@ -658,37 +658,37 @@ static Variant _decode_variant(const String& p_string) {
 		String format=params[0].strip_edges();
 
 		Image::Format imgformat;
-
+/*
 		if (format=="grayscale") {
-			imgformat=Image::FORMAT_GRAYSCALE;
+			imgformat=Image::FORMAT_L8;
 		} else if (format=="intensity") {
 			imgformat=Image::FORMAT_INTENSITY;
 		} else if (format=="grayscale_alpha") {
-			imgformat=Image::FORMAT_GRAYSCALE_ALPHA;
+			imgformat=Image::FORMAT_LA8;
 		} else if (format=="rgb") {
-			imgformat=Image::FORMAT_RGB;
+			imgformat=Image::FORMAT_RGB8;
 		} else if (format=="rgba") {
-			imgformat=Image::FORMAT_RGBA;
+			imgformat=Image::FORMAT_RGBA8;
 		} else if (format=="indexed") {
 			imgformat=Image::FORMAT_INDEXED;
 		} else if (format=="indexed_alpha") {
 			imgformat=Image::FORMAT_INDEXED_ALPHA;
 		} else if (format=="bc1") {
-			imgformat=Image::FORMAT_BC1;
+			imgformat=Image::FORMAT_DXT1;
 		} else if (format=="bc2") {
-			imgformat=Image::FORMAT_BC2;
+			imgformat=Image::FORMAT_DXT3;
 		} else if (format=="bc3") {
-			imgformat=Image::FORMAT_BC3;
+			imgformat=Image::FORMAT_DXT5;
 		} else if (format=="bc4") {
-			imgformat=Image::FORMAT_BC4;
+			imgformat=Image::FORMAT_ATI1;
 		} else if (format=="bc5") {
-			imgformat=Image::FORMAT_BC5;
+			imgformat=Image::FORMAT_ATI2;
 		} else if (format=="custom") {
 			imgformat=Image::FORMAT_CUSTOM;
 		} else {
 
 			ERR_FAIL_V( Image() );
-		}
+		}*/
 
 		int mipmaps=params[1].to_int();
 		int w=params[2].to_int();
@@ -975,26 +975,30 @@ static String _encode_variant(const Variant& p_variant) {
 			if (!img.empty()) {
 
 				String format;
+
+				/*
 				switch(img.get_format()) {
 
-					case Image::FORMAT_GRAYSCALE: format="grayscale"; break;
+					case Image::FORMAT_L8: format="grayscale"; break;
 					case Image::FORMAT_INTENSITY: format="intensity"; break;
-					case Image::FORMAT_GRAYSCALE_ALPHA: format="grayscale_alpha"; break;
-					case Image::FORMAT_RGB: format="rgb"; break;
-					case Image::FORMAT_RGBA: format="rgba"; break;
+					case Image::FORMAT_LA8: format="grayscale_alpha"; break;
+					case Image::FORMAT_RGB8: format="rgb"; break;
+					case Image::FORMAT_RGBA8: format="rgba"; break;
 					case Image::FORMAT_INDEXED : format="indexed"; break;
 					case Image::FORMAT_INDEXED_ALPHA: format="indexed_alpha"; break;
-					case Image::FORMAT_BC1: format="bc1"; break;
-					case Image::FORMAT_BC2: format="bc2"; break;
-					case Image::FORMAT_BC3: format="bc3"; break;
-					case Image::FORMAT_BC4: format="bc4"; break;
-					case Image::FORMAT_BC5: format="bc5"; break;
+					case Image::FORMAT_DXT1: format="bc1"; break;
+					case Image::FORMAT_DXT3: format="bc2"; break;
+					case Image::FORMAT_DXT5: format="bc3"; break;
+					case Image::FORMAT_ATI1: format="bc4"; break;
+					case Image::FORMAT_ATI2: format="bc5"; break;
 					case Image::FORMAT_CUSTOM: format="custom custom_size="+itos(img.get_data().size())+""; break;
 					default: {}
 				}
 
+				*/
+
 				str+=format+", ";
-				str+=itos(img.get_mipmaps())+", ";
+				str+=itos(img.has_mipmaps())+", ";
 				str+=itos(img.get_width())+", ";
 				str+=itos(img.get_height())+", ";
 				DVector<uint8_t> data = img.get_data();
@@ -1400,6 +1404,7 @@ void Globals::set_custom_property_info(const String& p_prop,const PropertyInfo&
 
 	ERR_FAIL_COND(!props.has(p_prop));
 	custom_prop_info[p_prop]=p_info;
+	custom_prop_info[p_prop].name=p_prop;
 
 }
 

core/image.h

@@ -55,35 +55,44 @@ public:
 	static SavePNGFunc save_png_func;
 
 	enum Format {
-		FORMAT_GRAYSCALE, ///< one byte per pixel, 0-255
-		FORMAT_INTENSITY, ///< one byte per pixel, 0-255
-		FORMAT_GRAYSCALE_ALPHA, ///< two bytes per pixel, 0-255. alpha 0-255
-		FORMAT_RGB, ///< one byte R, one byte G, one byte B
-		FORMAT_RGBA, ///< one byte R, one byte G, one byte B, one byte A
-		FORMAT_INDEXED, ///< index byte 0-256, and after image end, 256*3 bytes of palette
-		FORMAT_INDEXED_ALPHA, ///< index byte 0-256, and after image end, 256*4 bytes of palette (alpha)
-		FORMAT_YUV_422,
-		FORMAT_YUV_444,
-		FORMAT_BC1, // DXT1
-		FORMAT_BC2, // DXT3
-		FORMAT_BC3, // DXT5
-		FORMAT_BC4, // ATI1
-		FORMAT_BC5, // ATI2
-		FORMAT_PVRTC2,
-		FORMAT_PVRTC2_ALPHA,
-		FORMAT_PVRTC4,
-		FORMAT_PVRTC4_ALPHA,
-		FORMAT_ETC, // regular ETC, no transparency
-		FORMAT_ATC,
-		FORMAT_ATC_ALPHA_EXPLICIT,
-		FORMAT_ATC_ALPHA_INTERPOLATED,
-		/*FORMAT_ETC2_R, for the future..
-		FORMAT_ETC2_RG,
-		FORMAT_ETC2_RGB,
-		FORMAT_ETC2_RGBA1,
-		FORMAT_ETC2_RGBA,*/
-		FORMAT_CUSTOM,
 
+		FORMAT_L8, //luminance
+		FORMAT_LA8, //luminance-alpha
+		FORMAT_R8,
+		FORMAT_RG8,
+		FORMAT_RGB8,
+		FORMAT_RGBA8,
+		FORMAT_RGB565, //16 bit
+		FORMAT_RGBA4444,
+		FORMAT_RGBA5551,
+		FORMAT_RF, //float
+		FORMAT_RGF,
+		FORMAT_RGBF,
+		FORMAT_RGBAF,
+		FORMAT_RH, //half float
+		FORMAT_RGH,
+		FORMAT_RGBH,
+		FORMAT_RGBAH,
+		FORMAT_DXT1, //s3tc bc1
+		FORMAT_DXT3, //bc2
+		FORMAT_DXT5, //bc3
+		FORMAT_ATI1, //bc4
+		FORMAT_ATI2, //bc5
+		FORMAT_BPTC_RGBA, //btpc bc6h
+		FORMAT_BPTC_RGBF, //float /
+		FORMAT_BPTC_RGBFU, //unsigned float
+		FORMAT_PVRTC2, //pvrtc
+		FORMAT_PVRTC2A,
+		FORMAT_PVRTC4,
+		FORMAT_PVRTC4A,
+		FORMAT_ETC, //etc1
+		FORMAT_ETC2_R11, //etc2
+		FORMAT_ETC2_R11S, //signed, NOT srgb.
+		FORMAT_ETC2_RG11,
+		FORMAT_ETC2_RG11S,
+		FORMAT_ETC2_RGB8,
+		FORMAT_ETC2_RGBA8,
+		FORMAT_ETC2_RGB8A1,
 		FORMAT_MAX
 	};
 
@@ -96,15 +105,21 @@ public:
 		/* INTERPOLATE GAUSS */
 	};
 
+	//some functions provided by something else
+
 	static Image (*_png_mem_loader_func)(const uint8_t* p_png,int p_size);
 	static Image (*_jpg_mem_loader_func)(const uint8_t* p_png,int p_size);
+
 	static void (*_image_compress_bc_func)(Image *);
 	static void (*_image_compress_pvrtc2_func)(Image *);
 	static void (*_image_compress_pvrtc4_func)(Image *);
 	static void (*_image_compress_etc_func)(Image *);
+	static void (*_image_compress_etc2_func)(Image *);
+
 	static void (*_image_decompress_pvrtc)(Image *);
 	static void (*_image_decompress_bc)(Image *);
 	static void (*_image_decompress_etc)(Image *);
+	static void (*_image_decompress_etc2)(Image *);
 
 	Error _decompress_bc();
 
@@ -114,92 +129,19 @@ public:
 	static Image (*lossless_unpacker)(const DVector<uint8_t>& p_buffer);
 private:
 
-	//internal byte based color
-	struct BColor {
-		union {
-			uint8_t col[4];
-			struct {
-				uint8_t r,g,b,a;
-			};
-		};
-
-		bool operator==(const BColor& p_color) const { for(int i=0;i<4;i++) {if (col[i]!=p_color.col[i]) return false; } return true; }
-		_FORCE_INLINE_ uint8_t gray() const { return (uint16_t(col[0])+uint16_t(col[1])+uint16_t(col[2]))/3; }
-		_FORCE_INLINE_ BColor() {}
-		BColor(uint8_t p_r,uint8_t p_g,uint8_t p_b,uint8_t p_a=255) { col[0]=p_r; col[1]=p_g; col[2]=p_b; col[3]=p_a; }
-	};
-
-	//median cut classes
-
-	struct BColorPos {
-
-		uint32_t index;
-		BColor color;
-		struct SortR {
-
-			bool operator()(const BColorPos& ca, const BColorPos& cb) const { return ca.color.r < cb.color.r; }
-		};
-
-		struct SortG {
-
-			bool operator()(const BColorPos& ca, const BColorPos& cb) const { return ca.color.g < cb.color.g; }
-		};
-
-		struct SortB {
-
-			bool operator()(const BColorPos& ca, const BColorPos& cb) const { return ca.color.b < cb.color.b; }
-		};
-
-		struct SortA {
-
-			bool operator()(const BColorPos& ca, const BColorPos& cb) const { return ca.color.a < cb.color.a; }
-		};
-	};
-
-	struct SPTree {
-
-		bool leaf;
-		uint8_t split_plane;
-		uint8_t split_value;
-		union {
-			int left;
-			int color;
-		};
-		int right;
-		SPTree() { leaf=true; left=-1; right=-1;}
-	};
-
-	struct MCBlock {
-
-		BColorPos min_color,max_color;
-		BColorPos *colors;
-		int sp_idx;
-		int color_count;
-		int get_longest_axis_index() const;
-		int get_longest_axis_length() const;
-		bool operator<(const MCBlock& p_block) const;
-		void shrink();
-		MCBlock();
-		MCBlock(BColorPos *p_colors,int p_color_count);
-	};
-
 	Format format;
 	DVector<uint8_t> data;
-	int width,height,mipmaps;
-
-
+	int width,height;
+	bool mipmaps;
 
-	_FORCE_INLINE_ BColor _get_pixel(int p_x,int p_y,const unsigned char *p_data,int p_data_size) const;
-	_FORCE_INLINE_ BColor _get_pixelw(int p_x,int p_y,int p_width,const unsigned char *p_data,int p_data_size) const;
-	_FORCE_INLINE_ void _put_pixelw(int p_x,int p_y, int p_width, const BColor& p_color, unsigned char *p_data);
-	_FORCE_INLINE_ void _put_pixel(int p_x,int p_y, const BColor& p_color, unsigned char *p_data);
 	_FORCE_INLINE_ void _get_mipmap_offset_and_size(int p_mipmap,int &r_offset, int &r_width, int &r_height) const; //get where the mipmap begins in data
-	_FORCE_INLINE_ static void _get_format_min_data_size(Format p_format,int &r_w, int &r_h);
 
 	static int _get_dst_image_size(int p_width, int p_height, Format p_format,int &r_mipmaps,int p_mipmaps=-1);
 	bool _can_modify(Format p_format) const;
 
 
+	_FORCE_INLINE_ void _put_pixelb(int p_x,int p_y, uint32_t p_pixelsize,uint8_t *p_dst,const uint8_t *p_src);
+	_FORCE_INLINE_ void _get_pixelb(int p_x,int p_y,  uint32_t p_pixelsize,const uint8_t *p_src,uint8_t *p_dst);
 
 public:
 
@@ -207,20 +149,11 @@ public:
 
 	int get_width() const; ///< Get image width
 	int get_height() const; ///< Get image height
-	int get_mipmaps() const;
-
-	/**
-	 * Get a pixel from the image. for grayscale or indexed formats, use Color::gray to obtain the actual
-	 * value.
-	 */
-	Color get_pixel(int p_x,int p_y,int p_mipmap=0) const;
-	/**
-	 * Set a pixel into the image. for grayscale or indexed formats, a suitable Color constructor.
-	 */
-	void put_pixel(int p_x,int p_y, const Color& p_color,int p_mipmap=0); /* alpha and index are averaged */
+	bool has_mipmaps() const;
+	int get_mipmap_count() const;
 
 	/**
-	 * Convert the image to another format, as close as it can be done.
+	 * Convert the image to another format, conversion only to raw byte format
 	 */
 	void convert( Format p_new_format );
 
@@ -259,25 +192,21 @@ public:
 
 	void flip_x();
 	void flip_y();
+
 	/**
 	 * Generate a mipmap to an image (creates an image 1/4 the size, with averaging of 4->1)
 	 */
-	Error generate_mipmaps(int p_amount=-1,bool p_keep_existing=false);
+	Error generate_mipmaps(bool p_keep_existing=false);
 
 	void clear_mipmaps();
 
 
-	/**
-	 * Generate a normal map from a grayscale image
-	 */
-
-	void make_normalmap(float p_height_scale=1.0);
 
 	/**
 	 * Create a new image of a given size and format. Current image will be lost
 	 */
 	void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
-	void create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
+	void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
 
 	void create( const char ** p_xpm );
 	/**
@@ -301,7 +230,7 @@ public:
 	/**
 	 * import an image of a specific size and format from a pointer
 	 */
-	Image(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
+	Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const DVector<uint8_t>& p_data);
 
 	enum AlphaMode {
 		ALPHA_NONE,
@@ -312,32 +241,27 @@ public:
 	AlphaMode detect_alpha() const;
 	bool is_invisible() const;
 
-	void put_indexed_pixel(int p_x, int p_y, uint8_t p_idx,int p_mipmap=0);
-	uint8_t get_indexed_pixel(int p_x, int p_y,int p_mipmap=0) const;
-	void set_pallete(const DVector<uint8_t>& p_data);
-
 
 	static int get_format_pixel_size(Format p_format);
 	static int get_format_pixel_rshift(Format p_format);
-	static int get_format_pallete_size(Format p_format);
+	static void get_format_min_pixel_size(Format p_format,int &r_w, int &r_h);
+
 	static int get_image_data_size(int p_width, int p_height, Format p_format,int p_mipmaps=0);
 	static int get_image_required_mipmaps(int p_width, int p_height, Format p_format);
 
 
-
-
 	bool operator==(const Image& p_image) const;
 
-	void quantize();
-
 	enum CompressMode {
-		COMPRESS_BC,
+		COMPRESS_16BIT,
+		COMPRESS_S3TC,
 		COMPRESS_PVRTC2,
 		COMPRESS_PVRTC4,
-		COMPRESS_ETC
+		COMPRESS_ETC,
+		COMPRESS_ETC2
 	};
 
-	Error compress(CompressMode p_mode=COMPRESS_BC);
+	Error compress(CompressMode p_mode=COMPRESS_S3TC);
 	Image compressed(int p_mode); /* from the Image::CompressMode enum */
 	Error decompress();
 	Image decompressed() const;
@@ -349,8 +273,6 @@ public:
 	void normalmap_to_xy();
 
 	void blit_rect(const Image& p_src, const Rect2& p_src_rect,const Point2& p_dest);
-	void brush_transfer(const Image& p_src, const Image& p_brush, const Point2& p_dest);
-	Image brushed(const Image& p_src, const Image& p_brush, const Point2& p_dest) const;
 
 	Rect2 get_used_rect() const;
 	Image get_rect(const Rect2& p_area) const;

core/image_quantize.cpp

@@ -1,365 +0,0 @@
-/*************************************************************************/
-/*  image_quantize.cpp                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is 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 Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS 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     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-#include "image.h"
-#include <stdio.h>
-#include "print_string.h"
-#ifdef TOOLS_ENABLED
-#include "set.h"
-#include "sort.h"
-#include "os/os.h"
-
-//#define QUANTIZE_SPEED_OVER_QUALITY
-
-
-Image::MCBlock::MCBlock() {
-
-
-}
-
-Image::MCBlock::MCBlock(BColorPos *p_colors,int p_color_count) {
-
-	colors=p_colors;
-	color_count=p_color_count;
-	min_color.color=BColor(255,255,255,255);
-	max_color.color=BColor(0,0,0,0);
-	shrink();
-}
-
-int Image::MCBlock::get_longest_axis_index() const {
-
-	int max_dist=-1;
-	int max_index=0;
-
-	for(int i=0;i<4;i++) {
-
-		int d = max_color.color.col[i]-min_color.color.col[i];
-		if (d>max_dist) {
-			max_index=i;
-			max_dist=d;
-		}
-	}
-
-	return max_index;
-}
-int Image::MCBlock::get_longest_axis_length() const {
-
-	int max_dist=-1;
-
-	for(int i=0;i<4;i++) {
-
-		int d = max_color.color.col[i]-min_color.color.col[i];
-		if (d>max_dist) {
-			max_dist=d;
-		}
-	}
-
-	return max_dist;
-}
-
-bool Image::MCBlock::operator<(const MCBlock& p_block) const {
-
-	int alen = get_longest_axis_length();
-	int blen = p_block.get_longest_axis_length();
-	if (alen==blen) {
-
-		return colors < p_block.colors;
-	} else
-		return alen < blen;
-
-}
-
-void Image::MCBlock::shrink() {
-
-	min_color=colors[0];
-	max_color=colors[0];
-
-	for(int i=1;i<color_count;i++) {
-
-		for(int j=0;j<4;j++) {
-
-			min_color.color.col[j]=MIN(min_color.color.col[j],colors[i].color.col[j]);
-			max_color.color.col[j]=MAX(max_color.color.col[j],colors[i].color.col[j]);
-		}
-	}
-}
-
-
-
-
-void Image::quantize() {
-
-	bool has_alpha = detect_alpha()!=ALPHA_NONE;
-
-	bool quantize_fast=OS::get_singleton()->has_environment("QUANTIZE_FAST");
-
-	convert(FORMAT_RGBA);
-
-	ERR_FAIL_COND( format!=FORMAT_RGBA );
-
-	DVector<uint8_t> indexed_data;
-
-
-	{
-		int color_count = data.size()/4;
-
-		ERR_FAIL_COND(color_count==0);
-
-		Set<MCBlock> block_queue;
-
-		DVector<BColorPos> data_colors;
-		data_colors.resize(color_count);
-
-		DVector<BColorPos>::Write dcw=data_colors.write();
-
-		DVector<uint8_t>::Read dr = data.read();
-		const BColor * drptr=(const BColor*)&dr[0];
-		BColorPos *bcptr=&dcw[0];
-
-
-
-		{
-			for(int i=0;i<color_count;i++) {
-
-				//uint32_t data_ofs=i<<2;
-				bcptr[i].color=drptr[i];//BColor(drptr[data_ofs+0],drptr[data_ofs+1],drptr[data_ofs+2],drptr[data_ofs+3]);
-				bcptr[i].index=i;
-			}
-
-		}
-
-		//printf("color count: %i\n",color_count);
-		/*
-		for(int i=0;i<color_count;i++) {
-
-			BColor bc = ((BColor*)&wb[0])[i];
-			printf("%i - %i,%i,%i,%i\n",i,bc.r,bc.g,bc.b,bc.a);
-		}*/
-
-		MCBlock initial_block((BColorPos*)&dcw[0],color_count);
-
-		block_queue.insert(initial_block);
-
-		while( block_queue.size() < 256 && block_queue.back()->get().color_count > 1 ) {
-
-			MCBlock longest = block_queue.back()->get();
-			//printf("longest: %i (%i)\n",longest.get_longest_axis_index(),longest.get_longest_axis_length());
-
-			block_queue.erase(block_queue.back());
-
-			BColorPos *first = longest.colors;
-			BColorPos *median = longest.colors + (longest.color_count+1)/2;
-			BColorPos *end = longest.colors + longest.color_count;
-
-#if 0
-			int lai =longest.get_longest_axis_index();
-			switch(lai) {
-#if 0
-				case 0: { SortArray<BColorPos,BColorPos::SortR> sort; sort.sort(first,end-first); } break;
-				case 1: { SortArray<BColorPos,BColorPos::SortG> sort; sort.sort(first,end-first); } break;
-				case 2: { SortArray<BColorPos,BColorPos::SortB> sort; sort.sort(first,end-first); } break;
-				case 3: { SortArray<BColorPos,BColorPos::SortA> sort; sort.sort(first,end-first); } break;
-#else
-				case 0: { SortArray<BColorPos,BColorPos::SortR> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 1: { SortArray<BColorPos,BColorPos::SortG> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 2: { SortArray<BColorPos,BColorPos::SortB> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 3: { SortArray<BColorPos,BColorPos::SortA> sort; sort.nth_element(0,end-first,median-first,first); } break;
-#endif
-
-			}
-
-			//avoid same color from being split in 2
-			//search forward and flip
-			BColorPos *median_end=median;
-			BColorPos *p=median_end+1;
-
-			while(p!=end) {
-				if (median_end->color==p->color) {
-					SWAP(*(median_end+1),*p);
-					median_end++;
-				}
-				p++;
-			}
-
-			//search backward and flip
-			BColorPos *median_begin=median;
-			p=median_begin-1;
-
-			while(p!=(first-1)) {
-				if (median_begin->color==p->color) {
-					SWAP(*(median_begin-1),*p);
-					median_begin--;
-				}
-				p--;
-			}
-
-
-			if (first < median_begin) {
-				median=median_begin;
-			} else if (median_end < end-1) {
-				median=median_end+1;
-			} else {
-				break; //shouldn't have arrived here, since it means all pixels are equal, but wathever
-			}
-
-			MCBlock left(first,median-first);
-			MCBlock right(median,end-median);
-
-			block_queue.insert(left);
-			block_queue.insert(right);
-
-#else
-			switch(longest.get_longest_axis_index()) {
-				case 0: { SortArray<BColorPos,BColorPos::SortR> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 1: { SortArray<BColorPos,BColorPos::SortG> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 2: { SortArray<BColorPos,BColorPos::SortB> sort; sort.nth_element(0,end-first,median-first,first); } break;
-				case 3: { SortArray<BColorPos,BColorPos::SortA> sort; sort.nth_element(0,end-first,median-first,first); } break;
-
-			}
-
-			MCBlock left(first,median-first);
-			MCBlock right(median,end-median);
-
-			block_queue.insert(left);
-			block_queue.insert(right);
-
-
-#endif
-
-
-		}
-
-		while(block_queue.size() > 256) {
-
-			block_queue.erase(block_queue.front());// erase least significant
-		}
-
-		int res_colors=0;
-
-		int comp_size = (has_alpha?4:3);
-		indexed_data.resize(color_count + 256*comp_size);
-
-		DVector<uint8_t>::Write iw = indexed_data.write();
-		uint8_t *iwptr=&iw[0];
-		BColor pallete[256];
-
-	//	print_line("applying quantization - res colors "+itos(block_queue.size()));
-
-		while(block_queue.size()) {
-
-			const MCBlock &b = block_queue.back()->get();
-
-			uint64_t sum[4]={0,0,0,0};
-
-			for(int i=0;i<b.color_count;i++) {
-
-				sum[0]+=b.colors[i].color.col[0];
-				sum[1]+=b.colors[i].color.col[1];
-				sum[2]+=b.colors[i].color.col[2];
-				sum[3]+=b.colors[i].color.col[3];
-			}
-
-			BColor c( sum[0]/b.color_count, sum[1]/b.color_count, sum[2]/b.color_count, sum[3]/b.color_count );
-
-
-
-			//printf(" %i: %i,%i,%i,%i out of %i\n",res_colors,c.r,c.g,c.b,c.a,b.color_count);
-
-
-
-			for(int i=0;i<comp_size;i++) {
-				iwptr[ color_count + res_colors * comp_size + i ] = c.col[i];
-			}
-
-			if (quantize_fast) {
-				for(int i=0;i<b.color_count;i++) {
-					iwptr[b.colors[i].index]=res_colors;
-				}
-			} else {
-
-				pallete[res_colors]=c;
-			}
-
-
-			res_colors++;
-
-			block_queue.erase(block_queue.back());
-
-		}
-
-
-		if (!quantize_fast) {
-
-			for(int i=0;i<color_count;i++) {
-
-				const BColor &c=drptr[i];
-				uint8_t best_dist_idx=0;
-				uint32_t dist=0xFFFFFFFF;
-
-				for(int j=0;j<res_colors;j++) {
-
-					const BColor &pc=pallete[j];
-					uint32_t d = 0;
-					{ int16_t v = (int16_t)c.r-(int16_t)pc.r; d+=v*v; }
-					{ int16_t v = (int16_t)c.g-(int16_t)pc.g; d+=v*v; }
-					{ int16_t v = (int16_t)c.b-(int16_t)pc.b; d+=v*v; }
-					{ int16_t v = (int16_t)c.a-(int16_t)pc.a; d+=v*v; }
-
-					if (d<=dist) {
-						best_dist_idx=j;
-						dist=d;
-					}
-				}
-
-
-				iwptr[ i ] = best_dist_idx;
-
-			}
-		}
-
-		//iw = DVector<uint8_t>::Write();
-		//dr = DVector<uint8_t>::Read();
-		//wb = DVector<uint8_t>::Write();
-	}
-
-	print_line(itos(indexed_data.size()));
-	data=indexed_data;
-	format=has_alpha?FORMAT_INDEXED_ALPHA:FORMAT_INDEXED;
-
-
-} //do none
-
-
-
-#else
-
-
-void Image::quantize() {} //do none
-
-
-#endif

core/io/marshalls.cpp

@@ -1060,7 +1060,7 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
 			if (buf) {
 
 				encode_uint32(image.get_format(),&buf[0]);
-				encode_uint32(image.get_mipmaps(),&buf[4]);
+				encode_uint32(image.has_mipmaps(),&buf[4]);
 				encode_uint32(image.get_width(),&buf[8]);
 				encode_uint32(image.get_height(),&buf[12]);
 				int ds=data.size();

core/io/resource_format_binary.cpp

@@ -74,29 +74,6 @@ enum {
 	IMAGE_ENCODING_LOSSLESS=2,
 	IMAGE_ENCODING_LOSSY=3,
 
-	IMAGE_FORMAT_GRAYSCALE=0,
-	IMAGE_FORMAT_INTENSITY=1,
-	IMAGE_FORMAT_GRAYSCALE_ALPHA=2,
-	IMAGE_FORMAT_RGB=3,
-	IMAGE_FORMAT_RGBA=4,
-	IMAGE_FORMAT_INDEXED=5,
-	IMAGE_FORMAT_INDEXED_ALPHA=6,
-	IMAGE_FORMAT_BC1=7,
-	IMAGE_FORMAT_BC2=8,
-	IMAGE_FORMAT_BC3=9,
-	IMAGE_FORMAT_BC4=10,
-	IMAGE_FORMAT_BC5=11,
-	IMAGE_FORMAT_PVRTC2=12,
-	IMAGE_FORMAT_PVRTC2_ALPHA=13,
-	IMAGE_FORMAT_PVRTC4=14,
-	IMAGE_FORMAT_PVRTC4_ALPHA=15,
-	IMAGE_FORMAT_ETC=16,
-	IMAGE_FORMAT_ATC=17,
-	IMAGE_FORMAT_ATC_ALPHA_EXPLICIT=18,
-	IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED=19,
-	IMAGE_FORMAT_CUSTOM=30,
-
-
 	OBJECT_EMPTY=0,
 	OBJECT_EXTERNAL_RESOURCE=1,
 	OBJECT_INTERNAL_RESOURCE=2,
@@ -269,38 +246,22 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v)  {
 				uint32_t height = f->get_32();
 				uint32_t mipmaps = f->get_32();
 				uint32_t format = f->get_32();
-				Image::Format fmt;
-				switch(format) {
-
-					case IMAGE_FORMAT_GRAYSCALE: { fmt=Image::FORMAT_GRAYSCALE; } break;
-					case IMAGE_FORMAT_INTENSITY: { fmt=Image::FORMAT_INTENSITY; } break;
-					case IMAGE_FORMAT_GRAYSCALE_ALPHA: { fmt=Image::FORMAT_GRAYSCALE_ALPHA; } break;
-					case IMAGE_FORMAT_RGB: { fmt=Image::FORMAT_RGB; } break;
-					case IMAGE_FORMAT_RGBA: { fmt=Image::FORMAT_RGBA; } break;
-					case IMAGE_FORMAT_INDEXED: { fmt=Image::FORMAT_INDEXED; } break;
-					case IMAGE_FORMAT_INDEXED_ALPHA: { fmt=Image::FORMAT_INDEXED_ALPHA; } break;
-					case IMAGE_FORMAT_BC1: { fmt=Image::FORMAT_BC1; } break;
-					case IMAGE_FORMAT_BC2: { fmt=Image::FORMAT_BC2; } break;
-					case IMAGE_FORMAT_BC3: { fmt=Image::FORMAT_BC3; } break;
-					case IMAGE_FORMAT_BC4: { fmt=Image::FORMAT_BC4; } break;
-					case IMAGE_FORMAT_BC5: { fmt=Image::FORMAT_BC5; } break;
-					case IMAGE_FORMAT_PVRTC2: { fmt=Image::FORMAT_PVRTC2; } break;
-					case IMAGE_FORMAT_PVRTC2_ALPHA: { fmt=Image::FORMAT_PVRTC2_ALPHA; } break;
-					case IMAGE_FORMAT_PVRTC4: { fmt=Image::FORMAT_PVRTC4; } break;
-					case IMAGE_FORMAT_PVRTC4_ALPHA: { fmt=Image::FORMAT_PVRTC4_ALPHA; } break;
-					case IMAGE_FORMAT_ETC: { fmt=Image::FORMAT_ETC; } break;
-					case IMAGE_FORMAT_ATC: { fmt=Image::FORMAT_ATC; } break;
-					case IMAGE_FORMAT_ATC_ALPHA_EXPLICIT: { fmt=Image::FORMAT_ATC_ALPHA_EXPLICIT; } break;
-					case IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED: { fmt=Image::FORMAT_ATC_ALPHA_INTERPOLATED; } break;
-					case IMAGE_FORMAT_CUSTOM: { fmt=Image::FORMAT_CUSTOM; } break;
-					default: {
-
-						ERR_FAIL_V(ERR_FILE_CORRUPT);
-					}
+				const uint32_t format_version_shift=24;
+				const uint32_t format_version_mask=format_version_shift-1;
+
+				uint32_t format_version = format>>format_version_shift;
+
+				const uint32_t current_version = 0;
+				if (format_version>current_version) {
 
+					ERR_PRINT("Format version for encoded binary image is too new");
+					return ERR_PARSE_ERROR;
 				}
 
 
+				Image::Format fmt=Image::Format(format&format_version_mask); //if format changes, we can add a compatibility bit on top
+
+
 				uint32_t datalen = f->get_32();
 
 				DVector<uint8_t> imgdata;
@@ -1599,7 +1560,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property,
 			int encoding=IMAGE_ENCODING_RAW;
 			float quality=0.7;
 
-			if (val.get_format() <= Image::FORMAT_INDEXED_ALPHA) {
+			if (!val.is_compressed()) {
 				//can only compress uncompressed stuff
 
 				if (p_hint.hint==PROPERTY_HINT_IMAGE_COMPRESS_LOSSY && Image::lossy_packer) {
@@ -1621,33 +1582,8 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property,
 
 				f->store_32(val.get_width());
 				f->store_32(val.get_height());
-				f->store_32(val.get_mipmaps());
-				switch(val.get_format()) {
-
-					case Image::FORMAT_GRAYSCALE: f->store_32(IMAGE_FORMAT_GRAYSCALE ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
-					case Image::FORMAT_INTENSITY: f->store_32(IMAGE_FORMAT_INTENSITY ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
-					case Image::FORMAT_GRAYSCALE_ALPHA: f->store_32(IMAGE_FORMAT_GRAYSCALE_ALPHA ); break; ///< two bytes per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255. alpha 0-255
-					case Image::FORMAT_RGB: f->store_32(IMAGE_FORMAT_RGB ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B
-					case Image::FORMAT_RGBA: f->store_32(IMAGE_FORMAT_RGBA ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B: f->store_32(IMAGE_FORMAT_ ); break; one byte A
-					case Image::FORMAT_INDEXED: f->store_32(IMAGE_FORMAT_INDEXED ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*3 bytes of palette
-					case Image::FORMAT_INDEXED_ALPHA: f->store_32(IMAGE_FORMAT_INDEXED_ALPHA ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*4 bytes of palette (alpha)
-					case Image::FORMAT_BC1: f->store_32(IMAGE_FORMAT_BC1 ); break; // DXT1
-					case Image::FORMAT_BC2: f->store_32(IMAGE_FORMAT_BC2 ); break; // DXT3
-					case Image::FORMAT_BC3: f->store_32(IMAGE_FORMAT_BC3 ); break; // DXT5
-					case Image::FORMAT_BC4: f->store_32(IMAGE_FORMAT_BC4 ); break; // ATI1
-					case Image::FORMAT_BC5: f->store_32(IMAGE_FORMAT_BC5 ); break; // ATI2
-					case Image::FORMAT_PVRTC2: f->store_32(IMAGE_FORMAT_PVRTC2 ); break;
-					case Image::FORMAT_PVRTC2_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC2_ALPHA ); break;
-					case Image::FORMAT_PVRTC4: f->store_32(IMAGE_FORMAT_PVRTC4 ); break;
-					case Image::FORMAT_PVRTC4_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC4_ALPHA ); break;
-					case Image::FORMAT_ETC: f->store_32(IMAGE_FORMAT_ETC); break;
-					case Image::FORMAT_ATC: f->store_32(IMAGE_FORMAT_ATC); break;
-					case Image::FORMAT_ATC_ALPHA_EXPLICIT: f->store_32(IMAGE_FORMAT_ATC_ALPHA_EXPLICIT); break;
-					case Image::FORMAT_ATC_ALPHA_INTERPOLATED: f->store_32(IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED); break;
-					case Image::FORMAT_CUSTOM: f->store_32(IMAGE_FORMAT_CUSTOM ); break;
-					default: {}
-
-				}
+				f->store_32(val.has_mipmaps());
+				f->store_32(val.get_format()); //if format changes we can add a compatibility version bit
 
 				int dlen = val.get_data().size();
 				f->store_32(dlen);

core/io/resource_format_xml.cpp

@@ -553,39 +553,39 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name)
 
 			Image::Format imgformat;
 
-
+/*
 			if (format=="grayscale") {
-				imgformat=Image::FORMAT_GRAYSCALE;
+				imgformat=Image::FORMAT_L8;
 			} else if (format=="intensity") {
 				imgformat=Image::FORMAT_INTENSITY;
 			} else if (format=="grayscale_alpha") {
-				imgformat=Image::FORMAT_GRAYSCALE_ALPHA;
+				imgformat=Image::FORMAT_LA8;
 			} else if (format=="rgb") {
-				imgformat=Image::FORMAT_RGB;
+				imgformat=Image::FORMAT_RGB8;
 			} else if (format=="rgba") {
-				imgformat=Image::FORMAT_RGBA;
+				imgformat=Image::FORMAT_RGBA8;
 			} else if (format=="indexed") {
 				imgformat=Image::FORMAT_INDEXED;
 			} else if (format=="indexed_alpha") {
 				imgformat=Image::FORMAT_INDEXED_ALPHA;
 			} else if (format=="bc1") {
-				imgformat=Image::FORMAT_BC1;
+				imgformat=Image::FORMAT_DXT1;
 			} else if (format=="bc2") {
-				imgformat=Image::FORMAT_BC2;
+				imgformat=Image::FORMAT_DXT3;
 			} else if (format=="bc3") {
-				imgformat=Image::FORMAT_BC3;
+				imgformat=Image::FORMAT_DXT5;
 			} else if (format=="bc4") {
-				imgformat=Image::FORMAT_BC4;
+				imgformat=Image::FORMAT_ATI1;
 			} else if (format=="bc5") {
-				imgformat=Image::FORMAT_BC5;
+				imgformat=Image::FORMAT_ATI2;
 			} else if (format=="pvrtc2") {
 				imgformat=Image::FORMAT_PVRTC2;
 			} else if (format=="pvrtc2a") {
-				imgformat=Image::FORMAT_PVRTC2_ALPHA;
+				imgformat=Image::FORMAT_PVRTC2A;
 			} else if (format=="pvrtc4") {
 				imgformat=Image::FORMAT_PVRTC4;
 			} else if (format=="pvrtc4a") {
-				imgformat=Image::FORMAT_PVRTC4_ALPHA;
+				imgformat=Image::FORMAT_PVRTC4A;
 			} else if (format=="etc") {
 				imgformat=Image::FORMAT_ETC;
 			} else if (format=="atc") {
@@ -599,7 +599,7 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name)
 			} else {
 
 				ERR_FAIL_V( ERR_FILE_CORRUPT );
-			}
+			}*/
 
 
 			int datasize;
@@ -614,13 +614,6 @@ Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name)
 				return OK;
 			};
 
-			if (imgformat==Image::FORMAT_CUSTOM) {
-
-				datasize=custom_size;
-			} else {
-
-				datasize = Image::get_image_data_size(h,w,imgformat,mipmaps);
-			}
 
 			if (datasize==0) {
 				//r_v = Image(w, h, imgformat);
@@ -2186,33 +2179,33 @@ void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const V
 			params+="encoding=\"raw\"";
 			params+=" width=\""+itos(img.get_width())+"\"";
 			params+=" height=\""+itos(img.get_height())+"\"";
-			params+=" mipmaps=\""+itos(img.get_mipmaps())+"\"";
-
+			params+=" mipmaps=\""+itos(img.has_mipmaps())+"\"";
+/*
 			switch(img.get_format()) {
 
-				case Image::FORMAT_GRAYSCALE: params+=" format=\"grayscale\""; break;
+				case Image::FORMAT_L8: params+=" format=\"grayscale\""; break;
 				case Image::FORMAT_INTENSITY: params+=" format=\"intensity\""; break;
-				case Image::FORMAT_GRAYSCALE_ALPHA: params+=" format=\"grayscale_alpha\""; break;
-				case Image::FORMAT_RGB: params+=" format=\"rgb\""; break;
-				case Image::FORMAT_RGBA: params+=" format=\"rgba\""; break;
+				case Image::FORMAT_LA8: params+=" format=\"grayscale_alpha\""; break;
+				case Image::FORMAT_RGB8: params+=" format=\"rgb\""; break;
+				case Image::FORMAT_RGBA8: params+=" format=\"rgba\""; break;
 				case Image::FORMAT_INDEXED : params+=" format=\"indexed\""; break;
 				case Image::FORMAT_INDEXED_ALPHA: params+=" format=\"indexed_alpha\""; break;
-				case Image::FORMAT_BC1: params+=" format=\"bc1\""; break;
-				case Image::FORMAT_BC2: params+=" format=\"bc2\""; break;
-				case Image::FORMAT_BC3: params+=" format=\"bc3\""; break;
-				case Image::FORMAT_BC4: params+=" format=\"bc4\""; break;
-				case Image::FORMAT_BC5: params+=" format=\"bc5\""; break;
+				case Image::FORMAT_DXT1: params+=" format=\"bc1\""; break;
+				case Image::FORMAT_DXT3: params+=" format=\"bc2\""; break;
+				case Image::FORMAT_DXT5: params+=" format=\"bc3\""; break;
+				case Image::FORMAT_ATI1: params+=" format=\"bc4\""; break;
+				case Image::FORMAT_ATI2: params+=" format=\"bc5\""; break;
 				case Image::FORMAT_PVRTC2: params+=" format=\"pvrtc2\""; break;
-				case Image::FORMAT_PVRTC2_ALPHA: params+=" format=\"pvrtc2a\""; break;
+				case Image::FORMAT_PVRTC2A: params+=" format=\"pvrtc2a\""; break;
 				case Image::FORMAT_PVRTC4: params+=" format=\"pvrtc4\""; break;
-				case Image::FORMAT_PVRTC4_ALPHA: params+=" format=\"pvrtc4a\""; break;
+				case Image::FORMAT_PVRTC4A: params+=" format=\"pvrtc4a\""; break;
 				case Image::FORMAT_ETC: params+=" format=\"etc\""; break;
 				case Image::FORMAT_ATC: params+=" format=\"atc\""; break;
 				case Image::FORMAT_ATC_ALPHA_EXPLICIT: params+=" format=\"atcae\""; break;
 				case Image::FORMAT_ATC_ALPHA_INTERPOLATED: params+=" format=\"atcai\""; break;
 				case Image::FORMAT_CUSTOM: params+=" format=\"custom\" custom_size=\""+itos(img.get_data().size())+"\""; break;
 				default: {}
-			}
+			}*/
 		} break;
 		case Variant::NODE_PATH:		type="node_path"; break;
 		case Variant::OBJECT:	{

core/math/camera_matrix.cpp

@@ -54,7 +54,7 @@ void CameraMatrix::set_zero() {
 }
 
 
-Plane CameraMatrix::xform4(const Plane& p_vec4) {
+Plane CameraMatrix::xform4(const Plane& p_vec4) const {
 
 	Plane ret;
 
@@ -495,6 +495,28 @@ void CameraMatrix::set_light_bias() {
 
 }
 
+void CameraMatrix::set_light_atlas_rect(const Rect2& p_rect) {
+
+	float *m=&matrix[0][0];
+
+	m[0]=p_rect.size.width,
+	m[1]=0.0,
+	m[2]=0.0,
+	m[3]=0.0,
+	m[4]=0.0,
+	m[5]=p_rect.size.height,
+	m[6]=0.0,
+	m[7]=0.0,
+	m[8]=0.0,
+	m[9]=0.0,
+	m[10]=1.0,
+	m[11]=0.0,
+	m[12]=p_rect.pos.x,
+	m[13]=p_rect.pos.y,
+	m[14]=0.0,
+	m[15]=1.0;
+}
+
 CameraMatrix::operator String() const {
 
 	String str;
@@ -512,6 +534,15 @@ float CameraMatrix::get_aspect() const {
 	return w/h;
 }
 
+int CameraMatrix::get_pixels_per_meter(int p_for_pixel_width) const {
+
+
+	Vector3 result = xform(Vector3(1,0,-1));
+
+	return int((result.x * 0.5 + 0.5) * p_for_pixel_width);
+
+}
+
 float CameraMatrix::get_fov() const {
 	const float * matrix = (const float*)this->matrix;
 

core/math/camera_matrix.h

@@ -30,6 +30,7 @@
 #define CAMERA_MATRIX_H
 
 #include "transform.h"
+#include "math_2d.h"
 /**
 	@author Juan Linietsky <[email protected]>
 */
@@ -53,6 +54,7 @@ struct CameraMatrix {
 	void set_identity();
 	void set_zero();
 	void set_light_bias();
+	void set_light_atlas_rect(const Rect2& p_rect);
 	void set_perspective(float p_fovy_degrees, float p_aspect, float p_z_near, float p_z_far,bool p_flip_fov=false);
 	void set_orthogonal(float p_left, float p_right, float p_bottom, float p_top,  float p_znear, float p_zfar);
 	void set_orthogonal(float p_size, float p_aspect, float p_znear, float p_zfar,bool p_flip_fov=false);
@@ -78,13 +80,14 @@ struct CameraMatrix {
 
 	CameraMatrix operator*(const CameraMatrix& p_matrix) const;
 
-	Plane xform4(const Plane& p_vec4);
+	Plane xform4(const Plane& p_vec4) const;
 	_FORCE_INLINE_ Vector3 xform(const Vector3& p_vec3) const;
 
 	operator String() const;
 
 	void scale_translate_to_fit(const AABB& p_aabb);
 	void make_scale(const Vector3 &p_scale);
+	int get_pixels_per_meter(int p_for_pixel_width) const;
 	operator Transform() const;
 
 	CameraMatrix();

core/math/math_funcs.h

@@ -175,6 +175,108 @@ public:
 	static double log(double x);
 	static double exp(double x);
 
+
+	static _FORCE_INLINE_ uint32_t halfbits_to_floatbits(uint16_t h)
+	{
+	    uint16_t h_exp, h_sig;
+	    uint32_t f_sgn, f_exp, f_sig;
+
+	    h_exp = (h&0x7c00u);
+	    f_sgn = ((uint32_t)h&0x8000u) << 16;
+	    switch (h_exp) {
+		case 0x0000u: /* 0 or subnormal */
+		    h_sig = (h&0x03ffu);
+		    /* Signed zero */
+		    if (h_sig == 0) {
+			return f_sgn;
+		    }
+		    /* Subnormal */
+		    h_sig <<= 1;
+		    while ((h_sig&0x0400u) == 0) {
+			h_sig <<= 1;
+			h_exp++;
+		    }
+		    f_exp = ((uint32_t)(127 - 15 - h_exp)) << 23;
+		    f_sig = ((uint32_t)(h_sig&0x03ffu)) << 13;
+		    return f_sgn + f_exp + f_sig;
+		case 0x7c00u: /* inf or NaN */
+		    /* All-ones exponent and a copy of the significand */
+		    return f_sgn + 0x7f800000u + (((uint32_t)(h&0x03ffu)) << 13);
+		default: /* normalized */
+		    /* Just need to adjust the exponent and shift */
+		    return f_sgn + (((uint32_t)(h&0x7fffu) + 0x1c000u) << 13);
+	    }
+	}
+
+	static _FORCE_INLINE_ float halfptr_to_float(const uint16_t *h) {
+
+		union {
+			uint32_t u32;
+			float f32;
+		} u;
+
+		u.u32=halfbits_to_floatbits(*h);
+		return u.f32;
+	}
+
+	static _FORCE_INLINE_ uint16_t make_half_float(float f) {
+
+	    union {
+	       float fv;
+	       uint32_t ui;
+	    } ci;
+	    ci.fv=f;
+
+	    uint32_t    x = ci.ui;
+	    uint32_t    sign = (unsigned short)(x >> 31);
+	    uint32_t    mantissa;
+	    uint32_t    exp;
+	    uint16_t          hf;
+
+	    // get mantissa
+	    mantissa = x & ((1 << 23) - 1);
+	    // get exponent bits
+	    exp = x & (0xFF << 23);
+	    if (exp >= 0x47800000)
+	    {
+		// check if the original single precision float number is a NaN
+		if (mantissa && (exp == (0xFF << 23)))
+		{
+		    // we have a single precision NaN
+		    mantissa = (1 << 23) - 1;
+		}
+		else
+		{
+		    // 16-bit half-float representation stores number as Inf
+		    mantissa = 0;
+		}
+		hf = (((uint16_t)sign) << 15) | (uint16_t)((0x1F << 10)) |
+		      (uint16_t)(mantissa >> 13);
+	    }
+	    // check if exponent is <= -15
+	    else if (exp <= 0x38000000)
+	    {
+
+		/*// store a denorm half-float value or zero
+		exp = (0x38000000 - exp) >> 23;
+		mantissa >>= (14 + exp);
+
+		hf = (((uint16_t)sign) << 15) | (uint16_t)(mantissa);
+		*/
+		hf=0; //denormals do not work for 3D, convert to zero
+	    }
+	    else
+	    {
+		hf = (((uint16_t)sign) << 15) |
+		      (uint16_t)((exp - 0x38000000) >> 13) |
+		      (uint16_t)(mantissa >> 13);
+	    }
+
+	    return hf;
+	}
+
+
+
 };
 
 

core/os/os.cpp

@@ -68,6 +68,7 @@ void OS::print_error(const char* p_function,const char* p_file,int p_line,const
 		case ERR_ERROR: err_type="**ERROR**"; break;
 		case ERR_WARNING: err_type="**WARNING**"; break;
 		case ERR_SCRIPT: err_type="**SCRIPT ERROR**"; break;
+		case ERR_SHADER: err_type="**SHADER ERROR**"; break;
 	}
 
 	if (p_rationale && *p_rationale)

core/os/os.h

@@ -120,7 +120,8 @@ public:
 	enum ErrorType {
 		ERR_ERROR,
 		ERR_WARNING,
-		ERR_SCRIPT
+		ERR_SCRIPT,
+		ERR_SHADER
 	};
 
 	virtual void print_error(const char* p_function,const char* p_file,int p_line,const char *p_code,const char*p_rationale,ErrorType p_type=ERR_ERROR);

core/pair.h

@@ -34,6 +34,9 @@ struct Pair {
 
 	F first;
 	S second;
+
+	Pair() {}
+	Pair( F p_first,  S p_second) { first=p_first; second=p_second; }
 };
 
 #endif // PAIR_H

core/rid.cpp

@@ -28,18 +28,16 @@
 /*************************************************************************/
 #include "rid.h"
 
-static SafeRefCount current_id;
 
 
-void RID_OwnerBase::init_rid() {
+RID_Data::~RID_Data() {
 
-	current_id.init(1);
 }
 
-ID RID_OwnerBase::new_ID() {
 
+SafeRefCount RID_OwnerBase::refcount;
 
-	ID id = current_id.refval();
-	return id;
-}
+void RID_OwnerBase::init_rid() {
 
+	refcount.init();
+}

core/rid.h

@@ -33,183 +33,197 @@
 #include "safe_refcount.h"
 #include "typedefs.h"
 #include "os/memory.h"
-#include "hash_map.h"
+#include "set.h"
 #include "list.h"
 
 /**
 	@author Juan Linietsky <[email protected]>
 */
 
+
 class RID_OwnerBase;
 
-typedef uint32_t ID;
+class RID_Data {
+
+friend class RID_OwnerBase;
+
+#ifndef DEBUG_ENABLED
+	RID_OwnerBase *_owner;
+#endif
+	uint32_t _id;
+public:
+	_FORCE_INLINE_ uint32_t get_id() const { return _id; }
+
+	virtual ~RID_Data();
+};
+
 
 class RID {
 friend class RID_OwnerBase;
-	ID _id;
-	RID_OwnerBase *owner;
+
+	mutable RID_Data *_data;
+
 public:
 
-	_FORCE_INLINE_ ID get_id() const { return _id; }
-	bool operator==(const RID& p_rid) const {
+	_FORCE_INLINE_ RID_Data *get_data() const { return _data; }
+
+	_FORCE_INLINE_ bool operator==(const RID& p_rid) const {
 
-		return _id==p_rid._id;
+		return _data==p_rid._data;
 	}
 	_FORCE_INLINE_ bool operator<(const RID& p_rid) const {
 
-		return _id < p_rid._id;
+		return _data < p_rid._data;
 	}
 	_FORCE_INLINE_ bool operator<=(const RID& p_rid) const {
 
-		return _id <= p_rid._id;
+		return _data <= p_rid._data;
 	}
 	_FORCE_INLINE_ bool operator>(const RID& p_rid) const {
 
-		return _id > p_rid._id;
+		return _data > p_rid._data;
 	}
-	bool operator!=(const RID& p_rid) const {
+	_FORCE_INLINE_ bool operator!=(const RID& p_rid) const {
 
-		return _id!=p_rid._id;
+		return _data!=p_rid._data;
 	}
-	_FORCE_INLINE_ bool is_valid() const { return _id>0; }
+	_FORCE_INLINE_ bool is_valid() const { return _data!=NULL; }
 
-	operator const void*() const {
-		return is_valid() ? this : 0;
-	};
+	_FORCE_INLINE_ uint32_t get_id() const { return _data?_data->get_id():0; }
 
 	_FORCE_INLINE_ RID() {
-		_id = 0;
-		owner=0;
+		_data=NULL;
 	}
+
 };
 
 
 class RID_OwnerBase {
 protected:
-friend class RID;
-	void set_id(RID& p_rid, ID p_id) const { p_rid._id=p_id; }
-	void set_ownage(RID& p_rid) const { p_rid.owner=const_cast<RID_OwnerBase*>(this); }
-	ID new_ID();
+
+	static SafeRefCount refcount;
+	_FORCE_INLINE_ void _set_data(RID& p_rid, RID_Data* p_data) {
+		p_rid._data=p_data;
+		refcount.ref();
+		p_data->_id=refcount.get();
+#ifndef DEBUG_ENABLED
+		p_data->_owner=this;
+#endif
+	}
+
+#ifndef DEBUG_ENABLED
+
+	_FORCE_INLINE_ bool _is_owner(RID& p_rid) const {
+
+		return this==p_rid._owner;
+
+	}
+
+	_FORCE_INLINE_ void _remove_owner(RID& p_rid) {
+
+		return p_rid._owner=NULL;
+
+	}
+#
+#endif
+
+
 public:
 
-	virtual bool owns(const RID& p_rid) const=0;
-	virtual void get_owned_list(List<RID> *p_owned) const=0;
 
-	static void init_rid();
+	virtual void get_owned_list(List<RID> *p_owned)=0;
 
+	static void init_rid();
 	virtual ~RID_OwnerBase() {}
 };
 
-template<class T,bool thread_safe=false>
+template<class T>
 class RID_Owner : public RID_OwnerBase {
 public:
-
-	typedef void (*ReleaseNotifyFunc)(void*user,T *p_data);
-private:
-
-	Mutex *mutex;
-	mutable HashMap<ID,T*> id_map;
-
+#ifdef DEBUG_ENABLED
+	mutable Set<RID_Data*> id_map;
+#endif
 public:
 
-	RID make_rid(T * p_data) {
+	_FORCE_INLINE_ RID make_rid(T * p_data) {
 
-		if (thread_safe) {
-			mutex->lock();
-		}
 
-		ID id = new_ID();
-		id_map[id]=p_data;
 		RID rid;
-		set_id(rid,id);
-		set_ownage(rid);
+		_set_data(rid,p_data);
 
-		if (thread_safe) {
-			mutex->unlock();
-		}
+#ifdef DEBUG_ENABLED
+		id_map.insert(p_data)	;
+#endif
 
 		return rid;
 	}
 
 	_FORCE_INLINE_ T * get(const RID& p_rid) {
 
-		if (thread_safe) {
-			mutex->lock();
-		}
-
-		T**elem = id_map.getptr(p_rid.get_id());
+#ifdef DEBUG_ENABLED
 
-		if (thread_safe) {
-			mutex->unlock();
-		}
-
-		ERR_FAIL_COND_V(!elem,NULL);
-
-		return *elem;
+		ERR_FAIL_COND_V(!p_rid.is_valid(),NULL);
+		ERR_FAIL_COND_V(!id_map.has(p_rid.get_data()),NULL);
+#endif
+		return static_cast<T*>(p_rid.get_data());
 
 	}
 
-	virtual bool owns(const RID& p_rid) const {
+	_FORCE_INLINE_ T * getornull(const RID& p_rid) {
 
-		if (thread_safe) {
-			mutex->lock();
-		}
-
-		T**elem = id_map.getptr(p_rid.get_id());
+#ifdef DEBUG_ENABLED
 
-		if (thread_safe) {
-			mutex->lock();
+		if (p_rid.get_data()) {
+			ERR_FAIL_COND_V(!id_map.has(p_rid.get_data()),NULL);
 		}
+#endif
+		return static_cast<T*>(p_rid.get_data());
 
-		return elem!=NULL;
 	}
 
-	virtual void free(RID p_rid) {
 
-		if (thread_safe) {
-			mutex->lock();
-		}
-		ERR_FAIL_COND(!owns(p_rid));
-		id_map.erase(p_rid.get_id());
-	}
-	virtual void get_owned_list(List<RID> *p_owned) const {
-
-		if (thread_safe) {
-			mutex->lock();
-		}
+	_FORCE_INLINE_ T * getptr(const RID& p_rid) {
 
-		const ID*id=NULL;
-		while((id=id_map.next(id))) {
+		return static_cast<T*>(p_rid.get_data());
 
-			RID rid;
-			set_id(rid,*id);
-			set_ownage(rid);
-			p_owned->push_back(rid);
+	}
 
-		}
 
-		if (thread_safe) {
-			mutex->lock();
-		}
+	_FORCE_INLINE_ bool owns(const RID& p_rid) const {
 
+		if (p_rid.get_data()==NULL)
+			return false;
+#ifdef DEBUG_ENABLED
+		return id_map.has(p_rid.get_data());
+#else
+		return _is_owner(p_rid);
+#endif
 	}
-	RID_Owner() {
 
-		if (thread_safe) {
-
-			mutex = Mutex::create();
-		}
+	void free(RID p_rid) {
 
+#ifdef DEBUG_ENABLED
+		id_map.erase(p_rid.get_data());
+#else
+		_remove_owner(p_rid);
+#endif
 	}
 
+	void get_owned_list(List<RID> *p_owned) {
+
 
-	~RID_Owner() {
 
-		if (thread_safe) {
+#ifdef DEBUG_ENABLED
 
-			memdelete(mutex);
+		for (typename Set<RID_Data*>::Element *E=id_map.front();E;E=E->next()) {
+			RID r;
+			_set_data(r,static_cast<T*>(E->get()));
+			p_owned->push_back(r);
 		}
+#endif
+
 	}
+
 };
 
 

core/ustring.cpp

@@ -612,6 +612,8 @@ String String::get_slicec(CharType p_splitter, int p_slice) const {
 			if (p_slice==count) {
 
 				return substr(prev,i-prev);
+			} else if (c[i]==0) {
+				return String();
 			} else {
 				count++;
 				prev=i+1;

core/variant_call.cpp

@@ -619,13 +619,9 @@ static void _call_##m_type##_##m_method(Variant& r_ret,Variant& p_self,const Var
 	VCALL_PTR0R(Image,get_width);
 	VCALL_PTR0R(Image,get_height);
 	VCALL_PTR0R(Image,empty);
-	VCALL_PTR3R(Image,get_pixel);
-	VCALL_PTR4(Image, put_pixel);
 	VCALL_PTR0R(Image,get_used_rect);
-	VCALL_PTR3R(Image,brushed);
 	VCALL_PTR1R(Image,load);
 	VCALL_PTR1R(Image,save_png);
-	VCALL_PTR3(Image,brush_transfer);
 	VCALL_PTR1R(Image,get_rect);
 	VCALL_PTR1R(Image,compressed);
 	VCALL_PTR0R(Image,decompressed);
@@ -1528,12 +1524,8 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl
 	ADDFUNC0(IMAGE, INT, Image, get_width, varray());
 	ADDFUNC0(IMAGE, INT, Image, get_height, varray());
 	ADDFUNC0(IMAGE, BOOL, Image, empty, varray());
-	ADDFUNC3(IMAGE, COLOR, Image, get_pixel, INT, "x", INT, "y", INT, "mipmap_level", varray(0));
-	ADDFUNC4(IMAGE, NIL, Image, put_pixel, INT, "x", INT, "y", COLOR, "color", INT, "mipmap_level", varray(0));
-	ADDFUNC3(IMAGE, IMAGE, Image, brushed, IMAGE, "src", IMAGE, "brush", VECTOR2, "pos", varray(0));
 	ADDFUNC1(IMAGE, INT, Image, load, STRING, "path", varray(0));
 	ADDFUNC1(IMAGE, INT, Image, save_png, STRING, "path", varray(0));
-	ADDFUNC3(IMAGE, NIL, Image, brush_transfer, IMAGE, "src", IMAGE, "brush", VECTOR2, "pos", varray(0));
 	ADDFUNC0(IMAGE, RECT2, Image, get_used_rect, varray(0));
 	ADDFUNC1(IMAGE, IMAGE, Image, get_rect, RECT2, "area", varray(0));
 	ADDFUNC1(IMAGE, IMAGE, Image, compressed, INT, "format", varray(0));
@@ -1792,34 +1784,53 @@ _VariantCall::addfunc(Variant::m_vtype,Variant::m_ret,_SCS(#m_method),VCALL(m_cl
 	_VariantCall::add_constant(Variant::INPUT_EVENT,"ACTION",InputEvent::ACTION);
 
 
-	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_BC",Image::COMPRESS_BC);
+	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_16BIT",Image::COMPRESS_16BIT);
+	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_S3TC",Image::COMPRESS_S3TC);
 	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_PVRTC2",Image::COMPRESS_PVRTC2);
 	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_PVRTC4",Image::COMPRESS_PVRTC4);
 	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_ETC",Image::COMPRESS_ETC);
-
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_GRAYSCALE",Image::FORMAT_GRAYSCALE);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_INTENSITY",Image::FORMAT_INTENSITY);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_GRAYSCALE_ALPHA",Image::FORMAT_GRAYSCALE_ALPHA);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGB",Image::FORMAT_RGB);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBA",Image::FORMAT_RGBA);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_INDEXED",Image::FORMAT_INDEXED);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_INDEXED_ALPHA",Image::FORMAT_INDEXED_ALPHA);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_YUV_422",Image::FORMAT_YUV_422);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_YUV_444",Image::FORMAT_YUV_444);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BC1",Image::FORMAT_BC1);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BC2",Image::FORMAT_BC2);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BC3",Image::FORMAT_BC3);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BC4",Image::FORMAT_BC4);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BC5",Image::FORMAT_BC5);
+	_VariantCall::add_constant(Variant::IMAGE,"COMPRESS_ETC2",Image::COMPRESS_ETC2);
+
+
+
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_L8",Image::FORMAT_L8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_LA8",Image::FORMAT_LA8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_R8",Image::FORMAT_R8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RG8",Image::FORMAT_RG8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGB8",Image::FORMAT_RGB8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBA8",Image::FORMAT_RGBA8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGB565",Image::FORMAT_RGB565);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBA4444",Image::FORMAT_RGBA4444);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBA5551",Image::FORMAT_DXT1);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RF",Image::FORMAT_RF);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGF",Image::FORMAT_RGF);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBF",Image::FORMAT_RGBF);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBAF",Image::FORMAT_RGBAF);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RH",Image::FORMAT_RH);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGH",Image::FORMAT_RGH);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBH",Image::FORMAT_RGBH);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_RGBAH",Image::FORMAT_RGBAH);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_DXT1",Image::FORMAT_DXT1);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_DXT3",Image::FORMAT_DXT3);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_DXT5",Image::FORMAT_DXT5);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ATI1",Image::FORMAT_ATI1);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ATI2",Image::FORMAT_ATI2);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BPTC_RGBA",Image::FORMAT_BPTC_RGBA);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BPTC_RGBF",Image::FORMAT_BPTC_RGBF);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_BPTC_RGBFU",Image::FORMAT_BPTC_RGBFU);
 	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC2",Image::FORMAT_PVRTC2);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC2_ALPHA",Image::FORMAT_PVRTC2_ALPHA);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC2A",Image::FORMAT_PVRTC2A);
 	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC4",Image::FORMAT_PVRTC4);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC4_ALPHA",Image::FORMAT_PVRTC4_ALPHA);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_PVRTC4A",Image::FORMAT_PVRTC4A);
 	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC",Image::FORMAT_ETC);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ATC",Image::FORMAT_ATC);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ATC_ALPHA_EXPLICIT",Image::FORMAT_ATC_ALPHA_EXPLICIT);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ATC_ALPHA_INTERPOLATED",Image::FORMAT_ATC_ALPHA_INTERPOLATED);
-	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_CUSTOM",Image::FORMAT_CUSTOM);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_R11",Image::FORMAT_ETC2_R11);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_R11S",Image::FORMAT_ETC2_R11S);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_RG11",Image::FORMAT_ETC2_RG11);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_RG11S",Image::FORMAT_ETC2_RG11S);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_RGB8",Image::FORMAT_ETC2_RGB8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_RGBA8",Image::FORMAT_ETC2_RGBA8);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_ETC2_RGB8A1",Image::FORMAT_ETC2_RGB8A1);
+	_VariantCall::add_constant(Variant::IMAGE,"FORMAT_MAX",Image::FORMAT_MAX);
 
 	_VariantCall::add_constant(Variant::IMAGE,"INTERPOLATE_NEAREST",Image::INTERPOLATE_NEAREST);
 	_VariantCall::add_constant(Variant::IMAGE,"INTERPOLATE_BILINEAR",Image::INTERPOLATE_BILINEAR);

core/variant_parser.cpp

@@ -755,8 +755,17 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in
 			}
 
 			get_token(p_stream,token,line,r_err_str);
-			if (token.type!=TK_NUMBER) {
-				r_err_str="Expected number (mipmaps)";
+
+			bool has_mipmaps=false;
+
+			if (token.type==TK_NUMBER) {
+				has_mipmaps=bool(token.value);
+			} else if (token.type==TK_IDENTIFIER && String(token.value)=="true") {
+				has_mipmaps=true;
+			} else if (token.type==TK_IDENTIFIER && String(token.value)=="false") {
+				has_mipmaps=false;
+			} else {
+				r_err_str="Expected number/true/false (mipmaps)";
 				return ERR_PARSE_ERROR;
 			}
 
@@ -778,32 +787,18 @@ Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,in
 
 			String sformat=token.value;
 
-			Image::Format format;
-
-			if (sformat=="GRAYSCALE") format=Image::FORMAT_GRAYSCALE;
-			else if (sformat=="INTENSITY") format=Image::FORMAT_INTENSITY;
-			else if (sformat=="GRAYSCALE_ALPHA") format=Image::FORMAT_GRAYSCALE_ALPHA;
-			else if (sformat=="RGB") format=Image::FORMAT_RGB;
-			else if (sformat=="RGBA") format=Image::FORMAT_RGBA;
-			else if (sformat=="INDEXED") format=Image::FORMAT_INDEXED;
-			else if (sformat=="INDEXED_ALPHA") format=Image::FORMAT_INDEXED_ALPHA;
-			else if (sformat=="BC1") format=Image::FORMAT_BC1;
-			else if (sformat=="BC2") format=Image::FORMAT_BC2;
-			else if (sformat=="BC3") format=Image::FORMAT_BC3;
-			else if (sformat=="BC4") format=Image::FORMAT_BC4;
-			else if (sformat=="BC5") format=Image::FORMAT_BC5;
-			else if (sformat=="PVRTC2") format=Image::FORMAT_PVRTC2;
-			else if (sformat=="PVRTC2_ALPHA") format=Image::FORMAT_PVRTC2_ALPHA;
-			else if (sformat=="PVRTC4") format=Image::FORMAT_PVRTC4;
-			else if (sformat=="PVRTC4_ALPHA") format=Image::FORMAT_PVRTC4_ALPHA;
-			else if (sformat=="ATC") format=Image::FORMAT_ATC;
-			else if (sformat=="ATC_ALPHA_EXPLICIT") format=Image::FORMAT_ATC_ALPHA_EXPLICIT;
-			else if (sformat=="ATC_ALPHA_INTERPOLATED") format=Image::FORMAT_ATC_ALPHA_INTERPOLATED;
-			else if (sformat=="CUSTOM") format=Image::FORMAT_CUSTOM;
-			else {
-				r_err_str="Invalid image format: '"+sformat+"'";
+			Image::Format format=Image::FORMAT_MAX;
+
+			for(int i=0;i<Image::FORMAT_MAX;i++) {
+				if (Image::get_format_name(format)==sformat) {
+					format=Image::Format(i);
+				}
+			}
+
+			if (format==Image::FORMAT_MAX) {
+				r_err_str="Unknown image format: "+String(sformat);
 				return ERR_PARSE_ERROR;
-			};
+			}
 
 			int len = Image::get_image_data_size(width,height,format,mipmaps);
 
@@ -1986,35 +1981,8 @@ Error VariantWriter::write(const Variant& p_variant, StoreStringFunc p_store_str
 			String imgstr="Image( ";
 			imgstr+=itos(img.get_width());
 			imgstr+=", "+itos(img.get_height());
-			imgstr+=", "+itos(img.get_mipmaps());
-			imgstr+=", ";
-
-			switch(img.get_format()) {
-
-				case Image::FORMAT_GRAYSCALE: imgstr+="GRAYSCALE"; break;
-				case Image::FORMAT_INTENSITY: imgstr+="INTENSITY"; break;
-				case Image::FORMAT_GRAYSCALE_ALPHA: imgstr+="GRAYSCALE_ALPHA"; break;
-				case Image::FORMAT_RGB: imgstr+="RGB"; break;
-				case Image::FORMAT_RGBA: imgstr+="RGBA"; break;
-				case Image::FORMAT_INDEXED : imgstr+="INDEXED"; break;
-				case Image::FORMAT_INDEXED_ALPHA: imgstr+="INDEXED_ALPHA"; break;
-				case Image::FORMAT_BC1: imgstr+="BC1"; break;
-				case Image::FORMAT_BC2: imgstr+="BC2"; break;
-				case Image::FORMAT_BC3: imgstr+="BC3"; break;
-				case Image::FORMAT_BC4: imgstr+="BC4"; break;
-				case Image::FORMAT_BC5: imgstr+="BC5"; break;
-				case Image::FORMAT_PVRTC2: imgstr+="PVRTC2"; break;
-				case Image::FORMAT_PVRTC2_ALPHA: imgstr+="PVRTC2_ALPHA"; break;
-				case Image::FORMAT_PVRTC4: imgstr+="PVRTC4"; break;
-				case Image::FORMAT_PVRTC4_ALPHA: imgstr+="PVRTC4_ALPHA"; break;
-				case Image::FORMAT_ETC: imgstr+="ETC"; break;
-				case Image::FORMAT_ATC: imgstr+="ATC"; break;
-				case Image::FORMAT_ATC_ALPHA_EXPLICIT: imgstr+="ATC_ALPHA_EXPLICIT"; break;
-				case Image::FORMAT_ATC_ALPHA_INTERPOLATED: imgstr+="ATC_ALPHA_INTERPOLATED"; break;
-				case Image::FORMAT_CUSTOM: imgstr+="CUSTOM"; break;
-				default: {}
-			}
-
+			imgstr+=", "+String(img.has_mipmaps()?"true":"false");
+			imgstr+=", "+Image::get_format_name(img.get_format());
 
 			String s;
 

doc/base/classes.xml

@@ -13448,12 +13448,12 @@
 		</theme_item>
 	</theme_items>
 </class>
-<class name="FixedMaterial" inherits="Material" category="Core">
+<class name="FixedSpatialMaterial" inherits="Material" category="Core">
 	<brief_description>
 		Simple Material with a fixed parameter set.
 	</brief_description>
 	<description>
-		FixedMaterial is a simple type of material [Resource], which contains a fixed amount of parameters. It is the only type of material supported in fixed-pipeline devices and APIs. It is also an often a better alternative to [ShaderMaterial] for most simple use cases.
+		FixedSpatialMaterial is a simple type of material [Resource], which contains a fixed amount of parameters. It is the only type of material supported in fixed-pipeline devices and APIs. It is also an often a better alternative to [ShaderMaterial] for most simple use cases.
 	</description>
 	<methods>
 		<method name="get_fixed_flag" qualifiers="const">
@@ -16342,15 +16342,15 @@
 		</constant>
 		<constant name="COMPRESS_ETC" value="3">
 		</constant>
-		<constant name="FORMAT_GRAYSCALE" value="0">
+		<constant name="FORMAT_L8" value="0">
 		</constant>
 		<constant name="FORMAT_INTENSITY" value="1">
 		</constant>
-		<constant name="FORMAT_GRAYSCALE_ALPHA" value="2">
+		<constant name="FORMAT_LA8" value="2">
 		</constant>
-		<constant name="FORMAT_RGB" value="3">
+		<constant name="FORMAT_RGB8" value="3">
 		</constant>
-		<constant name="FORMAT_RGBA" value="4">
+		<constant name="FORMAT_RGBA8" value="4">
 		</constant>
 		<constant name="FORMAT_INDEXED" value="5">
 		</constant>
@@ -16360,23 +16360,23 @@
 		</constant>
 		<constant name="FORMAT_YUV_444" value="8">
 		</constant>
-		<constant name="FORMAT_BC1" value="9">
+		<constant name="FORMAT_DXT1" value="9">
 		</constant>
-		<constant name="FORMAT_BC2" value="10">
+		<constant name="FORMAT_DXT3" value="10">
 		</constant>
-		<constant name="FORMAT_BC3" value="11">
+		<constant name="FORMAT_DXT5" value="11">
 		</constant>
-		<constant name="FORMAT_BC4" value="12">
+		<constant name="FORMAT_ATI1" value="12">
 		</constant>
-		<constant name="FORMAT_BC5" value="13">
+		<constant name="FORMAT_ATI2" value="13">
 		</constant>
 		<constant name="FORMAT_PVRTC2" value="14">
 		</constant>
-		<constant name="FORMAT_PVRTC2_ALPHA" value="15">
+		<constant name="FORMAT_PVRTC2A" value="15">
 		</constant>
 		<constant name="FORMAT_PVRTC4" value="16">
 		</constant>
-		<constant name="FORMAT_PVRTC4_ALPHA" value="17">
+		<constant name="FORMAT_PVRTC4A" value="17">
 		</constant>
 		<constant name="FORMAT_ETC" value="18">
 		</constant>

drivers/SCsub

@@ -20,7 +20,7 @@ if (env["xaudio2"] == "yes"):
     SConscript("xaudio2/SCsub")
 
 # Graphics drivers
-SConscript('gles2/SCsub')
+SConscript('gles3/SCsub')
 SConscript('gl_context/SCsub')
 
 # Core dependencies

drivers/gl_context/KHR/khrplatform.h

@@ -0,0 +1,285 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2009 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.
+ *
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ *
+ * 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 sending them to the public Khronos Bugzilla
+ * (http://khronos.org/bugzilla) by filing a bug against product
+ * "Khronos (general)" component "Registry".
+ *
+ * A predefined template which fills in some of the bug fields can be
+ * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
+ * must create a Bugzilla login first.
+ *
+ *
+ * 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;
+ */
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   include <sys/cdefs.h>
+#   define KHRONOS_APICALL __attribute__((visibility("default"))) __NDK_FPABI__
+#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_ */

drivers/gl_context/SCsub

@@ -3,8 +3,11 @@
 Import('env')
 
 if (env["platform"] in ["haiku", "osx", "windows", "x11"]):
+    # FIXME: Dead code, now using GLAD
+    """
     # Thirdparty source files
     if (env['builtin_glew'] != 'no'):  # builtin
+
         thirdparty_dir = "#thirdparty/glew/"
         thirdparty_sources = [
             "glew.c",
@@ -16,6 +19,12 @@ if (env["platform"] in ["haiku", "osx", "windows", "x11"]):
         env.Append(CPPPATH=[thirdparty_dir])
 
     env.Append(CPPFLAGS=['-DGLEW_ENABLED'])
+    """
+
+    env.add_source_files(env.drivers_sources,"glad.c")
+    env.Append(CPPFLAGS = ['-DGLAD_ENABLED'])
+    env.Append(CPPFLAGS = ['-DGLES_OVER_GL'])
+    env.Append(CPPPATH = ['.'])
 
 # Godot source files
 env.add_source_files(env.drivers_sources, "*.cpp")

drivers/gl_context/glad.c

@@ -0,0 +1,1818 @@
+/*
+
+    OpenGL loader generated by glad 0.1.12a0 on Tue Nov 22 23:00:43 2016.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.3
+    Profile: compatibility
+    Extensions:
+        GL_ARB_debug_output
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="GL_ARB_debug_output"
+    Online:
+        http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D3.3&extensions=GL_ARB_debug_output
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/glad.h>
+
+static void* get_proc(const char *namez);
+
+#ifdef _WIN32
+#include <windows.h>
+static HMODULE libGL;
+
+typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+
+static
+int open_gl(void) {
+    libGL = LoadLibraryW(L"opengl32.dll");
+    if(libGL != NULL) {
+        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
+                libGL, "wglGetProcAddress");
+        return gladGetProcAddressPtr != NULL;
+    }
+
+    return 0;
+}
+
+static
+void close_gl(void) {
+    if(libGL != NULL) {
+        FreeLibrary(libGL);
+        libGL = NULL;
+    }
+}
+#else
+#include <dlfcn.h>
+static void* libGL;
+
+#ifndef __APPLE__
+typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+#endif
+
+static
+int open_gl(void) {
+#ifdef __APPLE__
+    static const char *NAMES[] = {
+        "../Frameworks/OpenGL.framework/OpenGL",
+        "/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+    };
+#else
+    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
+#endif
+
+    unsigned int index = 0;
+    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
+        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
+
+        if(libGL != NULL) {
+#ifdef __APPLE__
+            return 1;
+#else
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
+                "glXGetProcAddressARB");
+            return gladGetProcAddressPtr != NULL;
+#endif
+        }
+    }
+
+    return 0;
+}
+
+static
+void close_gl() {
+    if(libGL != NULL) {
+        dlclose(libGL);
+        libGL = NULL;
+    }
+}
+#endif
+
+static
+void* get_proc(const char *namez) {
+    void* result = NULL;
+    if(libGL == NULL) return NULL;
+
+#ifndef __APPLE__
+    if(gladGetProcAddressPtr != NULL) {
+        result = gladGetProcAddressPtr(namez);
+    }
+#endif
+    if(result == NULL) {
+#ifdef _WIN32
+        result = (void*)GetProcAddress(libGL, namez);
+#else
+        result = dlsym(libGL, namez);
+#endif
+    }
+
+    return result;
+}
+
+int gladLoadGL(void) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadGLLoader(&get_proc);
+        close_gl();
+    }
+
+    return status;
+}
+
+struct gladGLversionStruct GLVersion;
+
+#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 const 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 {
+        int index;
+
+        num_exts_i = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (const char **)realloc((void *)exts_i, num_exts_i * sizeof *exts_i);
+        }
+
+        if (exts_i == NULL) {
+            return 0;
+        }
+
+        for(index = 0; index < num_exts_i; index++) {
+            exts_i[index] = (const char*)glGetStringi(GL_EXTENSIONS, index);
+        }
+    }
+#endif
+    return 1;
+}
+
+static void free_exts(void) {
+    if (exts_i != NULL) {
+        free((char **)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;
+
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+
+            if(strcmp(e, ext) == 0) {
+                return 1;
+            }
+        }
+    }
+#endif
+
+    return 0;
+}
+int GLAD_GL_VERSION_1_0;
+int GLAD_GL_VERSION_1_1;
+int GLAD_GL_VERSION_1_2;
+int GLAD_GL_VERSION_1_3;
+int GLAD_GL_VERSION_1_4;
+int GLAD_GL_VERSION_1_5;
+int GLAD_GL_VERSION_2_0;
+int GLAD_GL_VERSION_2_1;
+int GLAD_GL_VERSION_3_0;
+int GLAD_GL_VERSION_3_1;
+int GLAD_GL_VERSION_3_2;
+int GLAD_GL_VERSION_3_3;
+PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
+PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
+PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
+PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
+PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
+PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
+PFNGLVERTEX2FVPROC glad_glVertex2fv;
+PFNGLINDEXIPROC glad_glIndexi;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
+PFNGLRECTDVPROC glad_glRectdv;
+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
+PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
+PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
+PFNGLINDEXDPROC glad_glIndexd;
+PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
+PFNGLINDEXFPROC glad_glIndexf;
+PFNGLBINDSAMPLERPROC glad_glBindSampler;
+PFNGLLINEWIDTHPROC glad_glLineWidth;
+PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
+PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
+PFNGLGETMAPFVPROC glad_glGetMapfv;
+PFNGLINDEXSPROC glad_glIndexs;
+PFNGLCOMPILESHADERPROC glad_glCompileShader;
+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
+PFNGLINDEXFVPROC glad_glIndexfv;
+PFNGLFOGIVPROC glad_glFogiv;
+PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
+PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
+PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
+PFNGLCOLOR4UIPROC glad_glColor4ui;
+PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
+PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
+PFNGLFOGFVPROC glad_glFogfv;
+PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
+PFNGLENABLEIPROC glad_glEnablei;
+PFNGLVERTEX4IVPROC glad_glVertex4iv;
+PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
+PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
+PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
+PFNGLCREATESHADERPROC glad_glCreateShader;
+PFNGLISBUFFERPROC glad_glIsBuffer;
+PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
+PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
+PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
+PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
+PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
+PFNGLVERTEX4FVPROC glad_glVertex4fv;
+PFNGLBINDTEXTUREPROC glad_glBindTexture;
+PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
+PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
+PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
+PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
+PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
+PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
+PFNGLPOINTSIZEPROC glad_glPointSize;
+PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
+PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
+PFNGLCOLOR4BVPROC glad_glColor4bv;
+PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
+PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
+PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
+PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
+PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
+PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
+PFNGLCOLOR3BPROC glad_glColor3b;
+PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
+PFNGLEDGEFLAGPROC glad_glEdgeFlag;
+PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
+PFNGLVERTEX3DPROC glad_glVertex3d;
+PFNGLVERTEX3FPROC glad_glVertex3f;
+PFNGLVERTEX3IPROC glad_glVertex3i;
+PFNGLCOLOR3IPROC glad_glColor3i;
+PFNGLUNIFORM3FPROC glad_glUniform3f;
+PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
+PFNGLCOLOR3SPROC glad_glColor3s;
+PFNGLVERTEX3SPROC glad_glVertex3s;
+PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
+PFNGLCOLORMASKIPROC glad_glColorMaski;
+PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
+PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
+PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
+PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
+PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
+PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
+PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
+PFNGLVERTEX2IVPROC glad_glVertex2iv;
+PFNGLCOLOR3SVPROC glad_glColor3sv;
+PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
+PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
+PFNGLNORMALPOINTERPROC glad_glNormalPointer;
+PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
+PFNGLVERTEX4SVPROC glad_glVertex4sv;
+PFNGLPASSTHROUGHPROC glad_glPassThrough;
+PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
+PFNGLFOGIPROC glad_glFogi;
+PFNGLBEGINPROC glad_glBegin;
+PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
+PFNGLCOLOR3UBVPROC glad_glColor3ubv;
+PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
+PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
+PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
+PFNGLDRAWARRAYSPROC glad_glDrawArrays;
+PFNGLUNIFORM1UIPROC glad_glUniform1ui;
+PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
+PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
+PFNGLLIGHTFVPROC glad_glLightfv;
+PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
+PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
+PFNGLCLEARPROC glad_glClear;
+PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
+PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
+PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
+PFNGLISENABLEDPROC glad_glIsEnabled;
+PFNGLSTENCILOPPROC glad_glStencilOp;
+PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
+PFNGLTRANSLATEFPROC glad_glTranslatef;
+PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
+PFNGLTRANSLATEDPROC glad_glTranslated;
+PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
+PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
+PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
+PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
+PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
+PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
+PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
+PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
+PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
+PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
+PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
+PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
+PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
+PFNGLINDEXSVPROC glad_glIndexsv;
+PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
+PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
+PFNGLVERTEX3IVPROC glad_glVertex3iv;
+PFNGLBITMAPPROC glad_glBitmap;
+PFNGLMATERIALIPROC glad_glMateriali;
+PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
+PFNGLGETQUERYIVPROC glad_glGetQueryiv;
+PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
+PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
+PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
+PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
+PFNGLMATERIALFPROC glad_glMaterialf;
+PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
+PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
+PFNGLISSHADERPROC glad_glIsShader;
+PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
+PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
+PFNGLVERTEX3DVPROC glad_glVertex3dv;
+PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
+PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
+PFNGLENABLEPROC glad_glEnable;
+PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
+PFNGLCOLOR4FVPROC glad_glColor4fv;
+PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
+PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
+PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
+PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
+PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
+PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
+PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
+PFNGLTEXGENFPROC glad_glTexGenf;
+PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
+PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
+PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
+PFNGLGETPOINTERVPROC glad_glGetPointerv;
+PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
+PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
+PFNGLNORMAL3FVPROC glad_glNormal3fv;
+PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
+PFNGLDEPTHRANGEPROC glad_glDepthRange;
+PFNGLFRUSTUMPROC glad_glFrustum;
+PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
+PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
+PFNGLPUSHMATRIXPROC glad_glPushMatrix;
+PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
+PFNGLORTHOPROC glad_glOrtho;
+PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
+PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
+PFNGLCLEARINDEXPROC glad_glClearIndex;
+PFNGLMAP1DPROC glad_glMap1d;
+PFNGLMAP1FPROC glad_glMap1f;
+PFNGLFLUSHPROC glad_glFlush;
+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
+PFNGLINDEXIVPROC glad_glIndexiv;
+PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
+PFNGLPIXELZOOMPROC glad_glPixelZoom;
+PFNGLFENCESYNCPROC glad_glFenceSync;
+PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
+PFNGLCOLORP3UIPROC glad_glColorP3ui;
+PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
+PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
+PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
+PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
+PFNGLLIGHTIPROC glad_glLighti;
+PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
+PFNGLLIGHTFPROC glad_glLightf;
+PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
+PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
+PFNGLGENSAMPLERSPROC glad_glGenSamplers;
+PFNGLCLAMPCOLORPROC glad_glClampColor;
+PFNGLUNIFORM4IVPROC glad_glUniform4iv;
+PFNGLCLEARSTENCILPROC glad_glClearStencil;
+PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
+PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
+PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
+PFNGLGENTEXTURESPROC glad_glGenTextures;
+PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
+PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
+PFNGLINDEXPOINTERPROC glad_glIndexPointer;
+PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
+PFNGLISSYNCPROC glad_glIsSync;
+PFNGLVERTEX2FPROC glad_glVertex2f;
+PFNGLVERTEX2DPROC glad_glVertex2d;
+PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
+PFNGLUNIFORM2IPROC glad_glUniform2i;
+PFNGLMAPGRID2DPROC glad_glMapGrid2d;
+PFNGLMAPGRID2FPROC glad_glMapGrid2f;
+PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
+PFNGLVERTEX2IPROC glad_glVertex2i;
+PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
+PFNGLVERTEX2SPROC glad_glVertex2s;
+PFNGLNORMAL3BVPROC glad_glNormal3bv;
+PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
+PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
+PFNGLVERTEX3SVPROC glad_glVertex3sv;
+PFNGLGENQUERIESPROC glad_glGenQueries;
+PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
+PFNGLTEXENVFPROC glad_glTexEnvf;
+PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
+PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
+PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
+PFNGLFOGCOORDDPROC glad_glFogCoordd;
+PFNGLFOGCOORDFPROC glad_glFogCoordf;
+PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
+PFNGLTEXENVIPROC glad_glTexEnvi;
+PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
+PFNGLISENABLEDIPROC glad_glIsEnabledi;
+PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
+PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
+PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
+PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
+PFNGLUNIFORM2IVPROC glad_glUniform2iv;
+PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
+PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
+PFNGLMATRIXMODEPROC glad_glMatrixMode;
+PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
+PFNGLGETMAPIVPROC glad_glGetMapiv;
+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
+PFNGLGETSHADERIVPROC glad_glGetShaderiv;
+PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
+PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
+PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
+PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
+PFNGLCALLLISTPROC glad_glCallList;
+PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
+PFNGLGETDOUBLEVPROC glad_glGetDoublev;
+PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
+PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
+PFNGLLIGHTMODELFPROC glad_glLightModelf;
+PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
+PFNGLVERTEX2SVPROC glad_glVertex2sv;
+PFNGLLIGHTMODELIPROC glad_glLightModeli;
+PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
+PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
+PFNGLUNIFORM3FVPROC glad_glUniform3fv;
+PFNGLPIXELSTOREIPROC glad_glPixelStorei;
+PFNGLCALLLISTSPROC glad_glCallLists;
+PFNGLMAPBUFFERPROC glad_glMapBuffer;
+PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
+PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
+PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
+PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
+PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
+PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
+PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
+PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
+PFNGLDELETESYNCPROC glad_glDeleteSync;
+PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
+PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
+PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
+PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
+PFNGLUNIFORM3IVPROC glad_glUniform3iv;
+PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
+PFNGLPOLYGONMODEPROC glad_glPolygonMode;
+PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
+PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
+PFNGLISLISTPROC glad_glIsList;
+PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
+PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
+PFNGLCOLOR4SPROC glad_glColor4s;
+PFNGLUSEPROGRAMPROC glad_glUseProgram;
+PFNGLLINESTIPPLEPROC glad_glLineStipple;
+PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
+PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
+PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
+PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
+PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
+PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
+PFNGLCOLOR4BPROC glad_glColor4b;
+PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
+PFNGLCOLOR4FPROC glad_glColor4f;
+PFNGLCOLOR4DPROC glad_glColor4d;
+PFNGLCOLOR4IPROC glad_glColor4i;
+PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
+PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
+PFNGLVERTEX2DVPROC glad_glVertex2dv;
+PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
+PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
+PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
+PFNGLFINISHPROC glad_glFinish;
+PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
+PFNGLDELETESHADERPROC glad_glDeleteShader;
+PFNGLDRAWELEMENTSPROC glad_glDrawElements;
+PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
+PFNGLGETMAPDVPROC glad_glGetMapdv;
+PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
+PFNGLMATERIALFVPROC glad_glMaterialfv;
+PFNGLVIEWPORTPROC glad_glViewport;
+PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
+PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
+PFNGLINDEXDVPROC glad_glIndexdv;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
+PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
+PFNGLCLEARDEPTHPROC glad_glClearDepth;
+PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
+PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
+PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
+PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+PFNGLTEXBUFFERPROC glad_glTexBuffer;
+PFNGLPOPNAMEPROC glad_glPopName;
+PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
+PFNGLPIXELSTOREFPROC glad_glPixelStoref;
+PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
+PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
+PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
+PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
+PFNGLRECTIPROC glad_glRecti;
+PFNGLCOLOR4UBPROC glad_glColor4ub;
+PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
+PFNGLRECTFPROC glad_glRectf;
+PFNGLRECTDPROC glad_glRectd;
+PFNGLNORMAL3SVPROC glad_glNormal3sv;
+PFNGLNEWLISTPROC glad_glNewList;
+PFNGLCOLOR4USPROC glad_glColor4us;
+PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
+PFNGLLINKPROGRAMPROC glad_glLinkProgram;
+PFNGLHINTPROC glad_glHint;
+PFNGLRECTSPROC glad_glRects;
+PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
+PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
+PFNGLGETSTRINGPROC glad_glGetString;
+PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
+PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
+PFNGLDETACHSHADERPROC glad_glDetachShader;
+PFNGLSCALEFPROC glad_glScalef;
+PFNGLENDQUERYPROC glad_glEndQuery;
+PFNGLSCALEDPROC glad_glScaled;
+PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
+PFNGLCOPYPIXELSPROC glad_glCopyPixels;
+PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
+PFNGLPOPATTRIBPROC glad_glPopAttrib;
+PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
+PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
+PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
+PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
+PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
+PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
+PFNGLINITNAMESPROC glad_glInitNames;
+PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
+PFNGLCOLOR3DVPROC glad_glColor3dv;
+PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
+PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
+PFNGLWAITSYNCPROC glad_glWaitSync;
+PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
+PFNGLCOLORMATERIALPROC glad_glColorMaterial;
+PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
+PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
+PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
+PFNGLUNIFORM1FPROC glad_glUniform1f;
+PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
+PFNGLRENDERMODEPROC glad_glRenderMode;
+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
+PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
+PFNGLUNIFORM1IPROC glad_glUniform1i;
+PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
+PFNGLUNIFORM3IPROC glad_glUniform3i;
+PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
+PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
+PFNGLDISABLEPROC glad_glDisable;
+PFNGLLOGICOPPROC glad_glLogicOp;
+PFNGLEVALPOINT2PROC glad_glEvalPoint2;
+PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
+PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
+PFNGLUNIFORM4UIPROC glad_glUniform4ui;
+PFNGLCOLOR3FPROC glad_glColor3f;
+PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
+PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
+PFNGLRECTFVPROC glad_glRectfv;
+PFNGLCULLFACEPROC glad_glCullFace;
+PFNGLGETLIGHTFVPROC glad_glGetLightfv;
+PFNGLCOLOR3DPROC glad_glColor3d;
+PFNGLTEXGENDPROC glad_glTexGend;
+PFNGLTEXGENIPROC glad_glTexGeni;
+PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
+PFNGLGETSTRINGIPROC glad_glGetStringi;
+PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
+PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
+PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
+PFNGLATTACHSHADERPROC glad_glAttachShader;
+PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
+PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
+PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
+PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
+PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
+PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
+PFNGLTEXGENIVPROC glad_glTexGeniv;
+PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
+PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
+PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
+PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
+PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
+PFNGLNORMALP3UIPROC glad_glNormalP3ui;
+PFNGLTEXENVFVPROC glad_glTexEnvfv;
+PFNGLREADBUFFERPROC glad_glReadBuffer;
+PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
+PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
+PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
+PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
+PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
+PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
+PFNGLDELETELISTSPROC glad_glDeleteLists;
+PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
+PFNGLVERTEX4DVPROC glad_glVertex4dv;
+PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
+PFNGLPOPMATRIXPROC glad_glPopMatrix;
+PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
+PFNGLCOLOR4IVPROC glad_glColor4iv;
+PFNGLINDEXUBVPROC glad_glIndexubv;
+PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
+PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
+PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
+PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
+PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
+PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
+PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
+PFNGLVERTEX3FVPROC glad_glVertex3fv;
+PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
+PFNGLMATERIALIVPROC glad_glMaterialiv;
+PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
+PFNGLISPROGRAMPROC glad_glIsProgram;
+PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
+PFNGLVERTEX4SPROC glad_glVertex4s;
+PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
+PFNGLNORMAL3DVPROC glad_glNormal3dv;
+PFNGLUNIFORM4IPROC glad_glUniform4i;
+PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
+PFNGLROTATEDPROC glad_glRotated;
+PFNGLROTATEFPROC glad_glRotatef;
+PFNGLVERTEX4IPROC glad_glVertex4i;
+PFNGLREADPIXELSPROC glad_glReadPixels;
+PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
+PFNGLLOADNAMEPROC glad_glLoadName;
+PFNGLUNIFORM4FPROC glad_glUniform4f;
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
+PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
+PFNGLSHADEMODELPROC glad_glShadeModel;
+PFNGLMAPGRID1DPROC glad_glMapGrid1d;
+PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
+PFNGLMAPGRID1FPROC glad_glMapGrid1f;
+PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
+PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
+PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
+PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
+PFNGLALPHAFUNCPROC glad_glAlphaFunc;
+PFNGLUNIFORM1IVPROC glad_glUniform1iv;
+PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
+PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
+PFNGLSTENCILFUNCPROC glad_glStencilFunc;
+PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
+PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
+PFNGLCOLOR4UIVPROC glad_glColor4uiv;
+PFNGLRECTIVPROC glad_glRectiv;
+PFNGLCOLORP4UIPROC glad_glColorP4ui;
+PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
+PFNGLEVALMESH2PROC glad_glEvalMesh2;
+PFNGLEVALMESH1PROC glad_glEvalMesh1;
+PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
+PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
+PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
+PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
+PFNGLCOLOR4UBVPROC glad_glColor4ubv;
+PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
+PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
+PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
+PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
+PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
+PFNGLTEXENVIVPROC glad_glTexEnviv;
+PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
+PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
+PFNGLGENBUFFERSPROC glad_glGenBuffers;
+PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
+PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
+PFNGLPUSHATTRIBPROC glad_glPushAttrib;
+PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
+PFNGLBLENDFUNCPROC glad_glBlendFunc;
+PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
+PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
+PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+PFNGLLIGHTIVPROC glad_glLightiv;
+PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
+PFNGLTEXGENFVPROC glad_glTexGenfv;
+PFNGLENDPROC glad_glEnd;
+PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
+PFNGLSCISSORPROC glad_glScissor;
+PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
+PFNGLCLIPPLANEPROC glad_glClipPlane;
+PFNGLPUSHNAMEPROC glad_glPushName;
+PFNGLTEXGENDVPROC glad_glTexGendv;
+PFNGLINDEXUBPROC glad_glIndexub;
+PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
+PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
+PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
+PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
+PFNGLCLEARCOLORPROC glad_glClearColor;
+PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
+PFNGLNORMAL3SPROC glad_glNormal3s;
+PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
+PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
+PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
+PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
+PFNGLBLENDCOLORPROC glad_glBlendColor;
+PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
+PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
+PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
+PFNGLUNIFORM3UIPROC glad_glUniform3ui;
+PFNGLCOLOR4DVPROC glad_glColor4dv;
+PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
+PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+PFNGLUNIFORM2FVPROC glad_glUniform2fv;
+PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
+PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
+PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
+PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
+PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
+PFNGLNORMAL3IVPROC glad_glNormal3iv;
+PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
+PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
+PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
+PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
+PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
+PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
+PFNGLCOLOR3USPROC glad_glColor3us;
+PFNGLCOLOR3UIVPROC glad_glColor3uiv;
+PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
+PFNGLGETLIGHTIVPROC glad_glGetLightiv;
+PFNGLDEPTHFUNCPROC glad_glDepthFunc;
+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
+PFNGLLISTBASEPROC glad_glListBase;
+PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
+PFNGLCOLOR3UBPROC glad_glColor3ub;
+PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
+PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
+PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
+PFNGLCOLOR3UIPROC glad_glColor3ui;
+PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
+PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
+PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
+PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
+PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
+PFNGLCOLORMASKPROC glad_glColorMask;
+PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
+PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
+PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
+PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
+PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
+PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
+PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
+PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
+PFNGLCOLOR4SVPROC glad_glColor4sv;
+PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
+PFNGLFOGFPROC glad_glFogf;
+PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
+PFNGLISSAMPLERPROC glad_glIsSampler;
+PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
+PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
+PFNGLCOLOR3IVPROC glad_glColor3iv;
+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
+PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
+PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
+PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
+PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
+PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
+PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
+PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
+PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
+PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
+PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
+PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
+PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
+PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
+PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
+PFNGLGENLISTSPROC glad_glGenLists;
+PFNGLCOLOR3BVPROC glad_glColor3bv;
+PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
+PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
+PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
+PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
+PFNGLENDLISTPROC glad_glEndList;
+PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
+PFNGLUNIFORM2UIPROC glad_glUniform2ui;
+PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
+PFNGLCOLOR3USVPROC glad_glColor3usv;
+PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
+PFNGLDISABLEIPROC glad_glDisablei;
+PFNGLINDEXMASKPROC glad_glIndexMask;
+PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
+PFNGLSHADERSOURCEPROC glad_glShaderSource;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
+PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
+PFNGLCLEARACCUMPROC glad_glClearAccum;
+PFNGLGETSYNCIVPROC glad_glGetSynciv;
+PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
+PFNGLUNIFORM2FPROC glad_glUniform2f;
+PFNGLBEGINQUERYPROC glad_glBeginQuery;
+PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
+PFNGLBINDBUFFERPROC glad_glBindBuffer;
+PFNGLMAP2DPROC glad_glMap2d;
+PFNGLMAP2FPROC glad_glMap2f;
+PFNGLVERTEX4DPROC glad_glVertex4d;
+PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
+PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
+PFNGLBUFFERDATAPROC glad_glBufferData;
+PFNGLEVALPOINT1PROC glad_glEvalPoint1;
+PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
+PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
+PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
+PFNGLGETERRORPROC glad_glGetError;
+PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
+PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
+PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
+PFNGLGETFLOATVPROC glad_glGetFloatv;
+PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
+PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
+PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
+PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
+PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
+PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
+PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
+PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
+PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
+PFNGLGETINTEGERVPROC glad_glGetIntegerv;
+PFNGLACCUMPROC glad_glAccum;
+PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
+PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
+PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
+PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
+PFNGLISQUERYPROC glad_glIsQuery;
+PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
+PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
+PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
+PFNGLSTENCILMASKPROC glad_glStencilMask;
+PFNGLDRAWPIXELSPROC glad_glDrawPixels;
+PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
+PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
+PFNGLISTEXTUREPROC glad_glIsTexture;
+PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
+PFNGLUNIFORM1FVPROC glad_glUniform1fv;
+PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
+PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
+PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
+PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
+PFNGLVERTEX4FPROC glad_glVertex4f;
+PFNGLRECTSVPROC glad_glRectsv;
+PFNGLCOLOR4USVPROC glad_glColor4usv;
+PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
+PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
+PFNGLNORMAL3IPROC glad_glNormal3i;
+PFNGLNORMAL3FPROC glad_glNormal3f;
+PFNGLNORMAL3DPROC glad_glNormal3d;
+PFNGLNORMAL3BPROC glad_glNormal3b;
+PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
+PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
+PFNGLARRAYELEMENTPROC glad_glArrayElement;
+PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
+PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
+PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
+PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
+PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
+PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
+PFNGLDEPTHMASKPROC glad_glDepthMask;
+PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
+PFNGLCOLOR3FVPROC glad_glColor3fv;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
+PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
+PFNGLUNIFORM4FVPROC glad_glUniform4fv;
+PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
+PFNGLCOLORPOINTERPROC glad_glColorPointer;
+PFNGLFRONTFACEPROC glad_glFrontFace;
+PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
+PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+int GLAD_GL_ARB_debug_output;
+PFNGLDEBUGMESSAGECONTROLARBPROC glad_glDebugMessageControlARB;
+PFNGLDEBUGMESSAGEINSERTARBPROC glad_glDebugMessageInsertARB;
+PFNGLDEBUGMESSAGECALLBACKARBPROC glad_glDebugMessageCallbackARB;
+PFNGLGETDEBUGMESSAGELOGARBPROC glad_glGetDebugMessageLogARB;
+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");
+	glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList");
+	glad_glEndList = (PFNGLENDLISTPROC)load("glEndList");
+	glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList");
+	glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists");
+	glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists");
+	glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists");
+	glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase");
+	glad_glBegin = (PFNGLBEGINPROC)load("glBegin");
+	glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap");
+	glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b");
+	glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv");
+	glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d");
+	glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv");
+	glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f");
+	glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv");
+	glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i");
+	glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv");
+	glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s");
+	glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv");
+	glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub");
+	glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv");
+	glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui");
+	glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv");
+	glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us");
+	glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv");
+	glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b");
+	glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv");
+	glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d");
+	glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv");
+	glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f");
+	glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv");
+	glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i");
+	glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv");
+	glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s");
+	glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv");
+	glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub");
+	glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv");
+	glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui");
+	glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv");
+	glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us");
+	glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv");
+	glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag");
+	glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv");
+	glad_glEnd = (PFNGLENDPROC)load("glEnd");
+	glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd");
+	glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv");
+	glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf");
+	glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv");
+	glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi");
+	glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv");
+	glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs");
+	glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv");
+	glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b");
+	glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv");
+	glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d");
+	glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv");
+	glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f");
+	glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv");
+	glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i");
+	glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv");
+	glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s");
+	glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv");
+	glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d");
+	glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv");
+	glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f");
+	glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv");
+	glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i");
+	glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv");
+	glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s");
+	glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv");
+	glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d");
+	glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv");
+	glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f");
+	glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv");
+	glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i");
+	glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv");
+	glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s");
+	glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv");
+	glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d");
+	glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv");
+	glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f");
+	glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv");
+	glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i");
+	glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv");
+	glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s");
+	glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv");
+	glad_glRectd = (PFNGLRECTDPROC)load("glRectd");
+	glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv");
+	glad_glRectf = (PFNGLRECTFPROC)load("glRectf");
+	glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv");
+	glad_glRecti = (PFNGLRECTIPROC)load("glRecti");
+	glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv");
+	glad_glRects = (PFNGLRECTSPROC)load("glRects");
+	glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv");
+	glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d");
+	glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv");
+	glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f");
+	glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv");
+	glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i");
+	glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv");
+	glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s");
+	glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv");
+	glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d");
+	glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv");
+	glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f");
+	glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv");
+	glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i");
+	glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv");
+	glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s");
+	glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv");
+	glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d");
+	glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv");
+	glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f");
+	glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv");
+	glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i");
+	glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv");
+	glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s");
+	glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv");
+	glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d");
+	glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv");
+	glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f");
+	glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv");
+	glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i");
+	glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv");
+	glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s");
+	glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv");
+	glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d");
+	glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv");
+	glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f");
+	glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv");
+	glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i");
+	glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv");
+	glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s");
+	glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv");
+	glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d");
+	glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv");
+	glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f");
+	glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv");
+	glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i");
+	glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv");
+	glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s");
+	glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv");
+	glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d");
+	glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv");
+	glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f");
+	glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv");
+	glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i");
+	glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv");
+	glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s");
+	glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv");
+	glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane");
+	glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial");
+	glad_glFogf = (PFNGLFOGFPROC)load("glFogf");
+	glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv");
+	glad_glFogi = (PFNGLFOGIPROC)load("glFogi");
+	glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv");
+	glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf");
+	glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv");
+	glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti");
+	glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv");
+	glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf");
+	glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv");
+	glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli");
+	glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv");
+	glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple");
+	glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf");
+	glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv");
+	glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali");
+	glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv");
+	glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple");
+	glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel");
+	glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf");
+	glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv");
+	glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi");
+	glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv");
+	glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend");
+	glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv");
+	glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf");
+	glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv");
+	glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni");
+	glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv");
+	glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer");
+	glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer");
+	glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode");
+	glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames");
+	glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName");
+	glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough");
+	glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName");
+	glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName");
+	glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum");
+	glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex");
+	glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask");
+	glad_glAccum = (PFNGLACCUMPROC)load("glAccum");
+	glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib");
+	glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib");
+	glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d");
+	glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f");
+	glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d");
+	glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f");
+	glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d");
+	glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f");
+	glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d");
+	glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f");
+	glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d");
+	glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv");
+	glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f");
+	glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv");
+	glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d");
+	glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv");
+	glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f");
+	glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv");
+	glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1");
+	glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1");
+	glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2");
+	glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2");
+	glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc");
+	glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom");
+	glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf");
+	glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi");
+	glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv");
+	glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv");
+	glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv");
+	glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels");
+	glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels");
+	glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane");
+	glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv");
+	glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv");
+	glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv");
+	glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv");
+	glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv");
+	glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv");
+	glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv");
+	glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv");
+	glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv");
+	glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv");
+	glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple");
+	glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv");
+	glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv");
+	glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv");
+	glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv");
+	glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv");
+	glad_glIsList = (PFNGLISLISTPROC)load("glIsList");
+	glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum");
+	glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity");
+	glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf");
+	glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd");
+	glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode");
+	glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf");
+	glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd");
+	glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho");
+	glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix");
+	glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix");
+	glad_glRotated = (PFNGLROTATEDPROC)load("glRotated");
+	glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef");
+	glad_glScaled = (PFNGLSCALEDPROC)load("glScaled");
+	glad_glScalef = (PFNGLSCALEFPROC)load("glScalef");
+	glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated");
+	glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef");
+}
+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_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
+	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");
+	glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement");
+	glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer");
+	glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState");
+	glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer");
+	glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState");
+	glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer");
+	glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays");
+	glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer");
+	glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer");
+	glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer");
+	glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident");
+	glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures");
+	glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub");
+	glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv");
+	glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib");
+	glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib");
+}
+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");
+	glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture");
+	glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d");
+	glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv");
+	glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f");
+	glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv");
+	glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i");
+	glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv");
+	glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s");
+	glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv");
+	glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d");
+	glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv");
+	glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f");
+	glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv");
+	glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i");
+	glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv");
+	glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s");
+	glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv");
+	glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d");
+	glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv");
+	glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f");
+	glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv");
+	glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i");
+	glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv");
+	glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s");
+	glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv");
+	glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d");
+	glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv");
+	glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f");
+	glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv");
+	glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i");
+	glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv");
+	glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s");
+	glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv");
+	glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf");
+	glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd");
+	glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf");
+	glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd");
+}
+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_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf");
+	glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv");
+	glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd");
+	glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv");
+	glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer");
+	glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b");
+	glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv");
+	glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d");
+	glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv");
+	glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f");
+	glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv");
+	glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i");
+	glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv");
+	glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s");
+	glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv");
+	glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub");
+	glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv");
+	glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui");
+	glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv");
+	glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us");
+	glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv");
+	glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer");
+	glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d");
+	glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv");
+	glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f");
+	glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv");
+	glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i");
+	glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv");
+	glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s");
+	glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv");
+	glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d");
+	glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv");
+	glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f");
+	glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv");
+	glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i");
+	glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv");
+	glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s");
+	glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv");
+	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_ARB_debug_output(GLADloadproc load) {
+	if(!GLAD_GL_ARB_debug_output) return;
+	glad_glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)load("glDebugMessageControlARB");
+	glad_glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)load("glDebugMessageInsertARB");
+	glad_glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)load("glDebugMessageCallbackARB");
+	glad_glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)load("glGetDebugMessageLogARB");
+}
+static int find_extensionsGL(void) {
+	if (!get_exts()) return 0;
+	GLAD_GL_ARB_debug_output = has_ext("GL_ARB_debug_output");
+	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
+
+    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) {
+	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_ARB_debug_output(load);
+	return GLVersion.major != 0 || GLVersion.minor != 0;
+}
+

drivers/gl_context/glad/glad.h

@@ -0,0 +1,3681 @@
+/*
+
+    OpenGL loader generated by glad 0.1.12a0 on Tue Nov 22 23:00:43 2016.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.3
+    Profile: compatibility
+    Extensions:
+        GL_ARB_debug_output
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="GL_ARB_debug_output"
+    Online:
+        http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D3.3&extensions=GL_ARB_debug_output
+*/
+
+
+#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_
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP 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 gladLoadGL(void);
+
+GLAPI int gladLoadGLLoader(GLADloadproc);
+
+#include <stddef.h>
+#include <gl_context/KHR/khrplatform.h>
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glxext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GL_EXT_timer_query extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef void GLvoid;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLclampx;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef int GLsizei;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void *GLeglImageOES;
+typedef char GLchar;
+typedef char GLcharARB;
+#ifdef __APPLE__
+typedef void *GLhandleARB;
+#else
+typedef unsigned int GLhandleARB;
+#endif
+typedef unsigned short GLhalfARB;
+typedef unsigned short GLhalf;
+typedef GLint GLfixed;
+typedef ptrdiff_t GLintptr;
+typedef ptrdiff_t GLsizeiptr;
+typedef int64_t GLint64;
+typedef uint64_t GLuint64;
+typedef ptrdiff_t GLintptrARB;
+typedef ptrdiff_t GLsizeiptrARB;
+typedef int64_t GLint64EXT;
+typedef 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;
+#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_QUADS 0x0007
+#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_COLOR_LOGIC_OP 0x0BF2
+#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_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_WIDTH 0x1000
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#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_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_DOUBLE 0x140A
+#define GL_STACK_OVERFLOW 0x0503
+#define GL_STACK_UNDERFLOW 0x0504
+#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_PROXY_TEXTURE_1D 0x8063
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_REPEAT 0x2901
+#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_CURRENT_BIT 0x00000001
+#define GL_POINT_BIT 0x00000002
+#define GL_LINE_BIT 0x00000004
+#define GL_POLYGON_BIT 0x00000008
+#define GL_POLYGON_STIPPLE_BIT 0x00000010
+#define GL_PIXEL_MODE_BIT 0x00000020
+#define GL_LIGHTING_BIT 0x00000040
+#define GL_FOG_BIT 0x00000080
+#define GL_ACCUM_BUFFER_BIT 0x00000200
+#define GL_VIEWPORT_BIT 0x00000800
+#define GL_TRANSFORM_BIT 0x00001000
+#define GL_ENABLE_BIT 0x00002000
+#define GL_HINT_BIT 0x00008000
+#define GL_EVAL_BIT 0x00010000
+#define GL_LIST_BIT 0x00020000
+#define GL_TEXTURE_BIT 0x00040000
+#define GL_SCISSOR_BIT 0x00080000
+#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF
+#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
+#define GL_QUAD_STRIP 0x0008
+#define GL_POLYGON 0x0009
+#define GL_ACCUM 0x0100
+#define GL_LOAD 0x0101
+#define GL_RETURN 0x0102
+#define GL_MULT 0x0103
+#define GL_ADD 0x0104
+#define GL_AUX0 0x0409
+#define GL_AUX1 0x040A
+#define GL_AUX2 0x040B
+#define GL_AUX3 0x040C
+#define GL_2D 0x0600
+#define GL_3D 0x0601
+#define GL_3D_COLOR 0x0602
+#define GL_3D_COLOR_TEXTURE 0x0603
+#define GL_4D_COLOR_TEXTURE 0x0604
+#define GL_PASS_THROUGH_TOKEN 0x0700
+#define GL_POINT_TOKEN 0x0701
+#define GL_LINE_TOKEN 0x0702
+#define GL_POLYGON_TOKEN 0x0703
+#define GL_BITMAP_TOKEN 0x0704
+#define GL_DRAW_PIXEL_TOKEN 0x0705
+#define GL_COPY_PIXEL_TOKEN 0x0706
+#define GL_LINE_RESET_TOKEN 0x0707
+#define GL_EXP 0x0800
+#define GL_EXP2 0x0801
+#define GL_COEFF 0x0A00
+#define GL_ORDER 0x0A01
+#define GL_DOMAIN 0x0A02
+#define GL_PIXEL_MAP_I_TO_I 0x0C70
+#define GL_PIXEL_MAP_S_TO_S 0x0C71
+#define GL_PIXEL_MAP_I_TO_R 0x0C72
+#define GL_PIXEL_MAP_I_TO_G 0x0C73
+#define GL_PIXEL_MAP_I_TO_B 0x0C74
+#define GL_PIXEL_MAP_I_TO_A 0x0C75
+#define GL_PIXEL_MAP_R_TO_R 0x0C76
+#define GL_PIXEL_MAP_G_TO_G 0x0C77
+#define GL_PIXEL_MAP_B_TO_B 0x0C78
+#define GL_PIXEL_MAP_A_TO_A 0x0C79
+#define GL_VERTEX_ARRAY_POINTER 0x808E
+#define GL_NORMAL_ARRAY_POINTER 0x808F
+#define GL_COLOR_ARRAY_POINTER 0x8090
+#define GL_INDEX_ARRAY_POINTER 0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093
+#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0
+#define GL_SELECTION_BUFFER_POINTER 0x0DF3
+#define GL_CURRENT_COLOR 0x0B00
+#define GL_CURRENT_INDEX 0x0B01
+#define GL_CURRENT_NORMAL 0x0B02
+#define GL_CURRENT_TEXTURE_COORDS 0x0B03
+#define GL_CURRENT_RASTER_COLOR 0x0B04
+#define GL_CURRENT_RASTER_INDEX 0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
+#define GL_CURRENT_RASTER_POSITION 0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
+#define GL_CURRENT_RASTER_DISTANCE 0x0B09
+#define GL_POINT_SMOOTH 0x0B10
+#define GL_LINE_STIPPLE 0x0B24
+#define GL_LINE_STIPPLE_PATTERN 0x0B25
+#define GL_LINE_STIPPLE_REPEAT 0x0B26
+#define GL_LIST_MODE 0x0B30
+#define GL_MAX_LIST_NESTING 0x0B31
+#define GL_LIST_BASE 0x0B32
+#define GL_LIST_INDEX 0x0B33
+#define GL_POLYGON_STIPPLE 0x0B42
+#define GL_EDGE_FLAG 0x0B43
+#define GL_LIGHTING 0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
+#define GL_LIGHT_MODEL_AMBIENT 0x0B53
+#define GL_SHADE_MODEL 0x0B54
+#define GL_COLOR_MATERIAL_FACE 0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
+#define GL_COLOR_MATERIAL 0x0B57
+#define GL_FOG 0x0B60
+#define GL_FOG_INDEX 0x0B61
+#define GL_FOG_DENSITY 0x0B62
+#define GL_FOG_START 0x0B63
+#define GL_FOG_END 0x0B64
+#define GL_FOG_MODE 0x0B65
+#define GL_FOG_COLOR 0x0B66
+#define GL_ACCUM_CLEAR_VALUE 0x0B80
+#define GL_MATRIX_MODE 0x0BA0
+#define GL_NORMALIZE 0x0BA1
+#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
+#define GL_PROJECTION_STACK_DEPTH 0x0BA4
+#define GL_TEXTURE_STACK_DEPTH 0x0BA5
+#define GL_MODELVIEW_MATRIX 0x0BA6
+#define GL_PROJECTION_MATRIX 0x0BA7
+#define GL_TEXTURE_MATRIX 0x0BA8
+#define GL_ATTRIB_STACK_DEPTH 0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
+#define GL_ALPHA_TEST 0x0BC0
+#define GL_ALPHA_TEST_FUNC 0x0BC1
+#define GL_ALPHA_TEST_REF 0x0BC2
+#define GL_INDEX_LOGIC_OP 0x0BF1
+#define GL_LOGIC_OP 0x0BF1
+#define GL_AUX_BUFFERS 0x0C00
+#define GL_INDEX_CLEAR_VALUE 0x0C20
+#define GL_INDEX_WRITEMASK 0x0C21
+#define GL_INDEX_MODE 0x0C30
+#define GL_RGBA_MODE 0x0C31
+#define GL_RENDER_MODE 0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
+#define GL_POINT_SMOOTH_HINT 0x0C51
+#define GL_FOG_HINT 0x0C54
+#define GL_TEXTURE_GEN_S 0x0C60
+#define GL_TEXTURE_GEN_T 0x0C61
+#define GL_TEXTURE_GEN_R 0x0C62
+#define GL_TEXTURE_GEN_Q 0x0C63
+#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9
+#define GL_MAP_COLOR 0x0D10
+#define GL_MAP_STENCIL 0x0D11
+#define GL_INDEX_SHIFT 0x0D12
+#define GL_INDEX_OFFSET 0x0D13
+#define GL_RED_SCALE 0x0D14
+#define GL_RED_BIAS 0x0D15
+#define GL_ZOOM_X 0x0D16
+#define GL_ZOOM_Y 0x0D17
+#define GL_GREEN_SCALE 0x0D18
+#define GL_GREEN_BIAS 0x0D19
+#define GL_BLUE_SCALE 0x0D1A
+#define GL_BLUE_BIAS 0x0D1B
+#define GL_ALPHA_SCALE 0x0D1C
+#define GL_ALPHA_BIAS 0x0D1D
+#define GL_DEPTH_SCALE 0x0D1E
+#define GL_DEPTH_BIAS 0x0D1F
+#define GL_MAX_EVAL_ORDER 0x0D30
+#define GL_MAX_LIGHTS 0x0D31
+#define GL_MAX_CLIP_PLANES 0x0D32
+#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
+#define GL_MAX_NAME_STACK_DEPTH 0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
+#define GL_INDEX_BITS 0x0D51
+#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_ACCUM_RED_BITS 0x0D58
+#define GL_ACCUM_GREEN_BITS 0x0D59
+#define GL_ACCUM_BLUE_BITS 0x0D5A
+#define GL_ACCUM_ALPHA_BITS 0x0D5B
+#define GL_NAME_STACK_DEPTH 0x0D70
+#define GL_AUTO_NORMAL 0x0D80
+#define GL_MAP1_COLOR_4 0x0D90
+#define GL_MAP1_INDEX 0x0D91
+#define GL_MAP1_NORMAL 0x0D92
+#define GL_MAP1_TEXTURE_COORD_1 0x0D93
+#define GL_MAP1_TEXTURE_COORD_2 0x0D94
+#define GL_MAP1_TEXTURE_COORD_3 0x0D95
+#define GL_MAP1_TEXTURE_COORD_4 0x0D96
+#define GL_MAP1_VERTEX_3 0x0D97
+#define GL_MAP1_VERTEX_4 0x0D98
+#define GL_MAP2_COLOR_4 0x0DB0
+#define GL_MAP2_INDEX 0x0DB1
+#define GL_MAP2_NORMAL 0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1 0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2 0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3 0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4 0x0DB6
+#define GL_MAP2_VERTEX_3 0x0DB7
+#define GL_MAP2_VERTEX_4 0x0DB8
+#define GL_MAP1_GRID_DOMAIN 0x0DD0
+#define GL_MAP1_GRID_SEGMENTS 0x0DD1
+#define GL_MAP2_GRID_DOMAIN 0x0DD2
+#define GL_MAP2_GRID_SEGMENTS 0x0DD3
+#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
+#define GL_SELECTION_BUFFER_SIZE 0x0DF4
+#define GL_VERTEX_ARRAY 0x8074
+#define GL_NORMAL_ARRAY 0x8075
+#define GL_COLOR_ARRAY 0x8076
+#define GL_INDEX_ARRAY 0x8077
+#define GL_TEXTURE_COORD_ARRAY 0x8078
+#define GL_EDGE_FLAG_ARRAY 0x8079
+#define GL_VERTEX_ARRAY_SIZE 0x807A
+#define GL_VERTEX_ARRAY_TYPE 0x807B
+#define GL_VERTEX_ARRAY_STRIDE 0x807C
+#define GL_NORMAL_ARRAY_TYPE 0x807E
+#define GL_NORMAL_ARRAY_STRIDE 0x807F
+#define GL_COLOR_ARRAY_SIZE 0x8081
+#define GL_COLOR_ARRAY_TYPE 0x8082
+#define GL_COLOR_ARRAY_STRIDE 0x8083
+#define GL_INDEX_ARRAY_TYPE 0x8085
+#define GL_INDEX_ARRAY_STRIDE 0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C
+#define GL_TEXTURE_COMPONENTS 0x1003
+#define GL_TEXTURE_BORDER 0x1005
+#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
+#define GL_TEXTURE_INTENSITY_SIZE 0x8061
+#define GL_TEXTURE_PRIORITY 0x8066
+#define GL_TEXTURE_RESIDENT 0x8067
+#define GL_AMBIENT 0x1200
+#define GL_DIFFUSE 0x1201
+#define GL_SPECULAR 0x1202
+#define GL_POSITION 0x1203
+#define GL_SPOT_DIRECTION 0x1204
+#define GL_SPOT_EXPONENT 0x1205
+#define GL_SPOT_CUTOFF 0x1206
+#define GL_CONSTANT_ATTENUATION 0x1207
+#define GL_LINEAR_ATTENUATION 0x1208
+#define GL_QUADRATIC_ATTENUATION 0x1209
+#define GL_COMPILE 0x1300
+#define GL_COMPILE_AND_EXECUTE 0x1301
+#define GL_2_BYTES 0x1407
+#define GL_3_BYTES 0x1408
+#define GL_4_BYTES 0x1409
+#define GL_EMISSION 0x1600
+#define GL_SHININESS 0x1601
+#define GL_AMBIENT_AND_DIFFUSE 0x1602
+#define GL_COLOR_INDEXES 0x1603
+#define GL_MODELVIEW 0x1700
+#define GL_PROJECTION 0x1701
+#define GL_COLOR_INDEX 0x1900
+#define GL_LUMINANCE 0x1909
+#define GL_LUMINANCE_ALPHA 0x190A
+#define GL_BITMAP 0x1A00
+#define GL_RENDER 0x1C00
+#define GL_FEEDBACK 0x1C01
+#define GL_SELECT 0x1C02
+#define GL_FLAT 0x1D00
+#define GL_SMOOTH 0x1D01
+#define GL_S 0x2000
+#define GL_T 0x2001
+#define GL_R 0x2002
+#define GL_Q 0x2003
+#define GL_MODULATE 0x2100
+#define GL_DECAL 0x2101
+#define GL_TEXTURE_ENV_MODE 0x2200
+#define GL_TEXTURE_ENV_COLOR 0x2201
+#define GL_TEXTURE_ENV 0x2300
+#define GL_EYE_LINEAR 0x2400
+#define GL_OBJECT_LINEAR 0x2401
+#define GL_SPHERE_MAP 0x2402
+#define GL_TEXTURE_GEN_MODE 0x2500
+#define GL_OBJECT_PLANE 0x2501
+#define GL_EYE_PLANE 0x2502
+#define GL_CLAMP 0x2900
+#define GL_ALPHA4 0x803B
+#define GL_ALPHA8 0x803C
+#define GL_ALPHA12 0x803D
+#define GL_ALPHA16 0x803E
+#define GL_LUMINANCE4 0x803F
+#define GL_LUMINANCE8 0x8040
+#define GL_LUMINANCE12 0x8041
+#define GL_LUMINANCE16 0x8042
+#define GL_LUMINANCE4_ALPHA4 0x8043
+#define GL_LUMINANCE6_ALPHA2 0x8044
+#define GL_LUMINANCE8_ALPHA8 0x8045
+#define GL_LUMINANCE12_ALPHA4 0x8046
+#define GL_LUMINANCE12_ALPHA12 0x8047
+#define GL_LUMINANCE16_ALPHA16 0x8048
+#define GL_INTENSITY 0x8049
+#define GL_INTENSITY4 0x804A
+#define GL_INTENSITY8 0x804B
+#define GL_INTENSITY12 0x804C
+#define GL_INTENSITY16 0x804D
+#define GL_V2F 0x2A20
+#define GL_V3F 0x2A21
+#define GL_C4UB_V2F 0x2A22
+#define GL_C4UB_V3F 0x2A23
+#define GL_C3F_V3F 0x2A24
+#define GL_N3F_V3F 0x2A25
+#define GL_C4F_N3F_V3F 0x2A26
+#define GL_T2F_V3F 0x2A27
+#define GL_T4F_V4F 0x2A28
+#define GL_T2F_C4UB_V3F 0x2A29
+#define GL_T2F_C3F_V3F 0x2A2A
+#define GL_T2F_N3F_V3F 0x2A2B
+#define GL_T2F_C4F_N3F_V3F 0x2A2C
+#define GL_T4F_C4F_N3F_V4F 0x2A2D
+#define GL_CLIP_PLANE0 0x3000
+#define GL_CLIP_PLANE1 0x3001
+#define GL_CLIP_PLANE2 0x3002
+#define GL_CLIP_PLANE3 0x3003
+#define GL_CLIP_PLANE4 0x3004
+#define GL_CLIP_PLANE5 0x3005
+#define GL_LIGHT0 0x4000
+#define GL_LIGHT1 0x4001
+#define GL_LIGHT2 0x4002
+#define GL_LIGHT3 0x4003
+#define GL_LIGHT4 0x4004
+#define GL_LIGHT5 0x4005
+#define GL_LIGHT6 0x4006
+#define GL_LIGHT7 0x4007
+#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_RESCALE_NORMAL 0x803A
+#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
+#define GL_SINGLE_COLOR 0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
+#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_CLIENT_ACTIVE_TEXTURE 0x84E1
+#define GL_MAX_TEXTURE_UNITS 0x84E2
+#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6
+#define GL_MULTISAMPLE_BIT 0x20000000
+#define GL_NORMAL_MAP 0x8511
+#define GL_REFLECTION_MAP 0x8512
+#define GL_COMPRESSED_ALPHA 0x84E9
+#define GL_COMPRESSED_LUMINANCE 0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
+#define GL_COMPRESSED_INTENSITY 0x84EC
+#define GL_COMBINE 0x8570
+#define GL_COMBINE_RGB 0x8571
+#define GL_COMBINE_ALPHA 0x8572
+#define GL_SOURCE0_RGB 0x8580
+#define GL_SOURCE1_RGB 0x8581
+#define GL_SOURCE2_RGB 0x8582
+#define GL_SOURCE0_ALPHA 0x8588
+#define GL_SOURCE1_ALPHA 0x8589
+#define GL_SOURCE2_ALPHA 0x858A
+#define GL_OPERAND0_RGB 0x8590
+#define GL_OPERAND1_RGB 0x8591
+#define GL_OPERAND2_RGB 0x8592
+#define GL_OPERAND0_ALPHA 0x8598
+#define GL_OPERAND1_ALPHA 0x8599
+#define GL_OPERAND2_ALPHA 0x859A
+#define GL_RGB_SCALE 0x8573
+#define GL_ADD_SIGNED 0x8574
+#define GL_INTERPOLATE 0x8575
+#define GL_SUBTRACT 0x84E7
+#define GL_CONSTANT 0x8576
+#define GL_PRIMARY_COLOR 0x8577
+#define GL_PREVIOUS 0x8578
+#define GL_DOT3_RGB 0x86AE
+#define GL_DOT3_RGBA 0x86AF
+#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_POINT_SIZE_MIN 0x8126
+#define GL_POINT_SIZE_MAX 0x8127
+#define GL_POINT_DISTANCE_ATTENUATION 0x8129
+#define GL_GENERATE_MIPMAP 0x8191
+#define GL_GENERATE_MIPMAP_HINT 0x8192
+#define GL_FOG_COORDINATE_SOURCE 0x8450
+#define GL_FOG_COORDINATE 0x8451
+#define GL_FRAGMENT_DEPTH 0x8452
+#define GL_CURRENT_FOG_COORDINATE 0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456
+#define GL_FOG_COORDINATE_ARRAY 0x8457
+#define GL_COLOR_SUM 0x8458
+#define GL_CURRENT_SECONDARY_COLOR 0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D
+#define GL_SECONDARY_COLOR_ARRAY 0x845E
+#define GL_TEXTURE_FILTER_CONTROL 0x8500
+#define GL_DEPTH_TEXTURE_MODE 0x884B
+#define GL_COMPARE_R_TO_TEXTURE 0x884E
+#define GL_FUNC_ADD 0x8006
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_MIN 0x8007
+#define GL_MAX 0x8008
+#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_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_VERTEX_ARRAY_BUFFER_BINDING 0x8896
+#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897
+#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898
+#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E
+#define GL_FOG_COORD_SRC 0x8450
+#define GL_FOG_COORD 0x8451
+#define GL_CURRENT_FOG_COORD 0x8453
+#define GL_FOG_COORD_ARRAY_TYPE 0x8454
+#define GL_FOG_COORD_ARRAY_STRIDE 0x8455
+#define GL_FOG_COORD_ARRAY_POINTER 0x8456
+#define GL_FOG_COORD_ARRAY 0x8457
+#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D
+#define GL_SRC0_RGB 0x8580
+#define GL_SRC1_RGB 0x8581
+#define GL_SRC2_RGB 0x8582
+#define GL_SRC0_ALPHA 0x8588
+#define GL_SRC2_ALPHA 0x858A
+#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_VERTEX_PROGRAM_TWO_SIDE 0x8643
+#define GL_POINT_SPRITE 0x8861
+#define GL_COORD_REPLACE 0x8862
+#define GL_MAX_TEXTURE_COORDS 0x8871
+#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_CURRENT_RASTER_SECONDARY_COLOR 0x845F
+#define GL_SLUMINANCE_ALPHA 0x8C44
+#define GL_SLUMINANCE8_ALPHA8 0x8C45
+#define GL_SLUMINANCE 0x8C46
+#define GL_SLUMINANCE8 0x8C47
+#define GL_COMPRESSED_SLUMINANCE 0x8C4A
+#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B
+#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_INDEX 0x8222
+#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14
+#define GL_TEXTURE_INTENSITY_TYPE 0x8C15
+#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_CLAMP_VERTEX_COLOR 0x891A
+#define GL_CLAMP_FRAGMENT_COLOR 0x891B
+#define GL_ALPHA_INTEGER 0x8D97
+#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
+#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)();
+GLAPI PFNGLFINISHPROC glad_glFinish;
+#define glFinish glad_glFinish
+typedef void (APIENTRYP PFNGLFLUSHPROC)();
+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)();
+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 near, GLdouble far);
+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
+typedef void (APIENTRYP PFNGLNEWLISTPROC)(GLuint list, GLenum mode);
+GLAPI PFNGLNEWLISTPROC glad_glNewList;
+#define glNewList glad_glNewList
+typedef void (APIENTRYP PFNGLENDLISTPROC)();
+GLAPI PFNGLENDLISTPROC glad_glEndList;
+#define glEndList glad_glEndList
+typedef void (APIENTRYP PFNGLCALLLISTPROC)(GLuint list);
+GLAPI PFNGLCALLLISTPROC glad_glCallList;
+#define glCallList glad_glCallList
+typedef void (APIENTRYP PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void *lists);
+GLAPI PFNGLCALLLISTSPROC glad_glCallLists;
+#define glCallLists glad_glCallLists
+typedef void (APIENTRYP PFNGLDELETELISTSPROC)(GLuint list, GLsizei range);
+GLAPI PFNGLDELETELISTSPROC glad_glDeleteLists;
+#define glDeleteLists glad_glDeleteLists
+typedef GLuint (APIENTRYP PFNGLGENLISTSPROC)(GLsizei range);
+GLAPI PFNGLGENLISTSPROC glad_glGenLists;
+#define glGenLists glad_glGenLists
+typedef void (APIENTRYP PFNGLLISTBASEPROC)(GLuint base);
+GLAPI PFNGLLISTBASEPROC glad_glListBase;
+#define glListBase glad_glListBase
+typedef void (APIENTRYP PFNGLBEGINPROC)(GLenum mode);
+GLAPI PFNGLBEGINPROC glad_glBegin;
+#define glBegin glad_glBegin
+typedef void (APIENTRYP PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+GLAPI PFNGLBITMAPPROC glad_glBitmap;
+#define glBitmap glad_glBitmap
+typedef void (APIENTRYP PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
+GLAPI PFNGLCOLOR3BPROC glad_glColor3b;
+#define glColor3b glad_glColor3b
+typedef void (APIENTRYP PFNGLCOLOR3BVPROC)(const GLbyte *v);
+GLAPI PFNGLCOLOR3BVPROC glad_glColor3bv;
+#define glColor3bv glad_glColor3bv
+typedef void (APIENTRYP PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
+GLAPI PFNGLCOLOR3DPROC glad_glColor3d;
+#define glColor3d glad_glColor3d
+typedef void (APIENTRYP PFNGLCOLOR3DVPROC)(const GLdouble *v);
+GLAPI PFNGLCOLOR3DVPROC glad_glColor3dv;
+#define glColor3dv glad_glColor3dv
+typedef void (APIENTRYP PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
+GLAPI PFNGLCOLOR3FPROC glad_glColor3f;
+#define glColor3f glad_glColor3f
+typedef void (APIENTRYP PFNGLCOLOR3FVPROC)(const GLfloat *v);
+GLAPI PFNGLCOLOR3FVPROC glad_glColor3fv;
+#define glColor3fv glad_glColor3fv
+typedef void (APIENTRYP PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue);
+GLAPI PFNGLCOLOR3IPROC glad_glColor3i;
+#define glColor3i glad_glColor3i
+typedef void (APIENTRYP PFNGLCOLOR3IVPROC)(const GLint *v);
+GLAPI PFNGLCOLOR3IVPROC glad_glColor3iv;
+#define glColor3iv glad_glColor3iv
+typedef void (APIENTRYP PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
+GLAPI PFNGLCOLOR3SPROC glad_glColor3s;
+#define glColor3s glad_glColor3s
+typedef void (APIENTRYP PFNGLCOLOR3SVPROC)(const GLshort *v);
+GLAPI PFNGLCOLOR3SVPROC glad_glColor3sv;
+#define glColor3sv glad_glColor3sv
+typedef void (APIENTRYP PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
+GLAPI PFNGLCOLOR3UBPROC glad_glColor3ub;
+#define glColor3ub glad_glColor3ub
+typedef void (APIENTRYP PFNGLCOLOR3UBVPROC)(const GLubyte *v);
+GLAPI PFNGLCOLOR3UBVPROC glad_glColor3ubv;
+#define glColor3ubv glad_glColor3ubv
+typedef void (APIENTRYP PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
+GLAPI PFNGLCOLOR3UIPROC glad_glColor3ui;
+#define glColor3ui glad_glColor3ui
+typedef void (APIENTRYP PFNGLCOLOR3UIVPROC)(const GLuint *v);
+GLAPI PFNGLCOLOR3UIVPROC glad_glColor3uiv;
+#define glColor3uiv glad_glColor3uiv
+typedef void (APIENTRYP PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
+GLAPI PFNGLCOLOR3USPROC glad_glColor3us;
+#define glColor3us glad_glColor3us
+typedef void (APIENTRYP PFNGLCOLOR3USVPROC)(const GLushort *v);
+GLAPI PFNGLCOLOR3USVPROC glad_glColor3usv;
+#define glColor3usv glad_glColor3usv
+typedef void (APIENTRYP PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+GLAPI PFNGLCOLOR4BPROC glad_glColor4b;
+#define glColor4b glad_glColor4b
+typedef void (APIENTRYP PFNGLCOLOR4BVPROC)(const GLbyte *v);
+GLAPI PFNGLCOLOR4BVPROC glad_glColor4bv;
+#define glColor4bv glad_glColor4bv
+typedef void (APIENTRYP PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+GLAPI PFNGLCOLOR4DPROC glad_glColor4d;
+#define glColor4d glad_glColor4d
+typedef void (APIENTRYP PFNGLCOLOR4DVPROC)(const GLdouble *v);
+GLAPI PFNGLCOLOR4DVPROC glad_glColor4dv;
+#define glColor4dv glad_glColor4dv
+typedef void (APIENTRYP PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI PFNGLCOLOR4FPROC glad_glColor4f;
+#define glColor4f glad_glColor4f
+typedef void (APIENTRYP PFNGLCOLOR4FVPROC)(const GLfloat *v);
+GLAPI PFNGLCOLOR4FVPROC glad_glColor4fv;
+#define glColor4fv glad_glColor4fv
+typedef void (APIENTRYP PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha);
+GLAPI PFNGLCOLOR4IPROC glad_glColor4i;
+#define glColor4i glad_glColor4i
+typedef void (APIENTRYP PFNGLCOLOR4IVPROC)(const GLint *v);
+GLAPI PFNGLCOLOR4IVPROC glad_glColor4iv;
+#define glColor4iv glad_glColor4iv
+typedef void (APIENTRYP PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+GLAPI PFNGLCOLOR4SPROC glad_glColor4s;
+#define glColor4s glad_glColor4s
+typedef void (APIENTRYP PFNGLCOLOR4SVPROC)(const GLshort *v);
+GLAPI PFNGLCOLOR4SVPROC glad_glColor4sv;
+#define glColor4sv glad_glColor4sv
+typedef void (APIENTRYP PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+GLAPI PFNGLCOLOR4UBPROC glad_glColor4ub;
+#define glColor4ub glad_glColor4ub
+typedef void (APIENTRYP PFNGLCOLOR4UBVPROC)(const GLubyte *v);
+GLAPI PFNGLCOLOR4UBVPROC glad_glColor4ubv;
+#define glColor4ubv glad_glColor4ubv
+typedef void (APIENTRYP PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+GLAPI PFNGLCOLOR4UIPROC glad_glColor4ui;
+#define glColor4ui glad_glColor4ui
+typedef void (APIENTRYP PFNGLCOLOR4UIVPROC)(const GLuint *v);
+GLAPI PFNGLCOLOR4UIVPROC glad_glColor4uiv;
+#define glColor4uiv glad_glColor4uiv
+typedef void (APIENTRYP PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+GLAPI PFNGLCOLOR4USPROC glad_glColor4us;
+#define glColor4us glad_glColor4us
+typedef void (APIENTRYP PFNGLCOLOR4USVPROC)(const GLushort *v);
+GLAPI PFNGLCOLOR4USVPROC glad_glColor4usv;
+#define glColor4usv glad_glColor4usv
+typedef void (APIENTRYP PFNGLEDGEFLAGPROC)(GLboolean flag);
+GLAPI PFNGLEDGEFLAGPROC glad_glEdgeFlag;
+#define glEdgeFlag glad_glEdgeFlag
+typedef void (APIENTRYP PFNGLEDGEFLAGVPROC)(const GLboolean *flag);
+GLAPI PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
+#define glEdgeFlagv glad_glEdgeFlagv
+typedef void (APIENTRYP PFNGLENDPROC)();
+GLAPI PFNGLENDPROC glad_glEnd;
+#define glEnd glad_glEnd
+typedef void (APIENTRYP PFNGLINDEXDPROC)(GLdouble c);
+GLAPI PFNGLINDEXDPROC glad_glIndexd;
+#define glIndexd glad_glIndexd
+typedef void (APIENTRYP PFNGLINDEXDVPROC)(const GLdouble *c);
+GLAPI PFNGLINDEXDVPROC glad_glIndexdv;
+#define glIndexdv glad_glIndexdv
+typedef void (APIENTRYP PFNGLINDEXFPROC)(GLfloat c);
+GLAPI PFNGLINDEXFPROC glad_glIndexf;
+#define glIndexf glad_glIndexf
+typedef void (APIENTRYP PFNGLINDEXFVPROC)(const GLfloat *c);
+GLAPI PFNGLINDEXFVPROC glad_glIndexfv;
+#define glIndexfv glad_glIndexfv
+typedef void (APIENTRYP PFNGLINDEXIPROC)(GLint c);
+GLAPI PFNGLINDEXIPROC glad_glIndexi;
+#define glIndexi glad_glIndexi
+typedef void (APIENTRYP PFNGLINDEXIVPROC)(const GLint *c);
+GLAPI PFNGLINDEXIVPROC glad_glIndexiv;
+#define glIndexiv glad_glIndexiv
+typedef void (APIENTRYP PFNGLINDEXSPROC)(GLshort c);
+GLAPI PFNGLINDEXSPROC glad_glIndexs;
+#define glIndexs glad_glIndexs
+typedef void (APIENTRYP PFNGLINDEXSVPROC)(const GLshort *c);
+GLAPI PFNGLINDEXSVPROC glad_glIndexsv;
+#define glIndexsv glad_glIndexsv
+typedef void (APIENTRYP PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz);
+GLAPI PFNGLNORMAL3BPROC glad_glNormal3b;
+#define glNormal3b glad_glNormal3b
+typedef void (APIENTRYP PFNGLNORMAL3BVPROC)(const GLbyte *v);
+GLAPI PFNGLNORMAL3BVPROC glad_glNormal3bv;
+#define glNormal3bv glad_glNormal3bv
+typedef void (APIENTRYP PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz);
+GLAPI PFNGLNORMAL3DPROC glad_glNormal3d;
+#define glNormal3d glad_glNormal3d
+typedef void (APIENTRYP PFNGLNORMAL3DVPROC)(const GLdouble *v);
+GLAPI PFNGLNORMAL3DVPROC glad_glNormal3dv;
+#define glNormal3dv glad_glNormal3dv
+typedef void (APIENTRYP PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz);
+GLAPI PFNGLNORMAL3FPROC glad_glNormal3f;
+#define glNormal3f glad_glNormal3f
+typedef void (APIENTRYP PFNGLNORMAL3FVPROC)(const GLfloat *v);
+GLAPI PFNGLNORMAL3FVPROC glad_glNormal3fv;
+#define glNormal3fv glad_glNormal3fv
+typedef void (APIENTRYP PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz);
+GLAPI PFNGLNORMAL3IPROC glad_glNormal3i;
+#define glNormal3i glad_glNormal3i
+typedef void (APIENTRYP PFNGLNORMAL3IVPROC)(const GLint *v);
+GLAPI PFNGLNORMAL3IVPROC glad_glNormal3iv;
+#define glNormal3iv glad_glNormal3iv
+typedef void (APIENTRYP PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz);
+GLAPI PFNGLNORMAL3SPROC glad_glNormal3s;
+#define glNormal3s glad_glNormal3s
+typedef void (APIENTRYP PFNGLNORMAL3SVPROC)(const GLshort *v);
+GLAPI PFNGLNORMAL3SVPROC glad_glNormal3sv;
+#define glNormal3sv glad_glNormal3sv
+typedef void (APIENTRYP PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y);
+GLAPI PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
+#define glRasterPos2d glad_glRasterPos2d
+typedef void (APIENTRYP PFNGLRASTERPOS2DVPROC)(const GLdouble *v);
+GLAPI PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
+#define glRasterPos2dv glad_glRasterPos2dv
+typedef void (APIENTRYP PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y);
+GLAPI PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
+#define glRasterPos2f glad_glRasterPos2f
+typedef void (APIENTRYP PFNGLRASTERPOS2FVPROC)(const GLfloat *v);
+GLAPI PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
+#define glRasterPos2fv glad_glRasterPos2fv
+typedef void (APIENTRYP PFNGLRASTERPOS2IPROC)(GLint x, GLint y);
+GLAPI PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
+#define glRasterPos2i glad_glRasterPos2i
+typedef void (APIENTRYP PFNGLRASTERPOS2IVPROC)(const GLint *v);
+GLAPI PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
+#define glRasterPos2iv glad_glRasterPos2iv
+typedef void (APIENTRYP PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y);
+GLAPI PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
+#define glRasterPos2s glad_glRasterPos2s
+typedef void (APIENTRYP PFNGLRASTERPOS2SVPROC)(const GLshort *v);
+GLAPI PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
+#define glRasterPos2sv glad_glRasterPos2sv
+typedef void (APIENTRYP PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
+#define glRasterPos3d glad_glRasterPos3d
+typedef void (APIENTRYP PFNGLRASTERPOS3DVPROC)(const GLdouble *v);
+GLAPI PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
+#define glRasterPos3dv glad_glRasterPos3dv
+typedef void (APIENTRYP PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
+#define glRasterPos3f glad_glRasterPos3f
+typedef void (APIENTRYP PFNGLRASTERPOS3FVPROC)(const GLfloat *v);
+GLAPI PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
+#define glRasterPos3fv glad_glRasterPos3fv
+typedef void (APIENTRYP PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z);
+GLAPI PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
+#define glRasterPos3i glad_glRasterPos3i
+typedef void (APIENTRYP PFNGLRASTERPOS3IVPROC)(const GLint *v);
+GLAPI PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
+#define glRasterPos3iv glad_glRasterPos3iv
+typedef void (APIENTRYP PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z);
+GLAPI PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
+#define glRasterPos3s glad_glRasterPos3s
+typedef void (APIENTRYP PFNGLRASTERPOS3SVPROC)(const GLshort *v);
+GLAPI PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
+#define glRasterPos3sv glad_glRasterPos3sv
+typedef void (APIENTRYP PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
+#define glRasterPos4d glad_glRasterPos4d
+typedef void (APIENTRYP PFNGLRASTERPOS4DVPROC)(const GLdouble *v);
+GLAPI PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
+#define glRasterPos4dv glad_glRasterPos4dv
+typedef void (APIENTRYP PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
+#define glRasterPos4f glad_glRasterPos4f
+typedef void (APIENTRYP PFNGLRASTERPOS4FVPROC)(const GLfloat *v);
+GLAPI PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
+#define glRasterPos4fv glad_glRasterPos4fv
+typedef void (APIENTRYP PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w);
+GLAPI PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
+#define glRasterPos4i glad_glRasterPos4i
+typedef void (APIENTRYP PFNGLRASTERPOS4IVPROC)(const GLint *v);
+GLAPI PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
+#define glRasterPos4iv glad_glRasterPos4iv
+typedef void (APIENTRYP PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
+#define glRasterPos4s glad_glRasterPos4s
+typedef void (APIENTRYP PFNGLRASTERPOS4SVPROC)(const GLshort *v);
+GLAPI PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
+#define glRasterPos4sv glad_glRasterPos4sv
+typedef void (APIENTRYP PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+GLAPI PFNGLRECTDPROC glad_glRectd;
+#define glRectd glad_glRectd
+typedef void (APIENTRYP PFNGLRECTDVPROC)(const GLdouble *v1, const GLdouble *v2);
+GLAPI PFNGLRECTDVPROC glad_glRectdv;
+#define glRectdv glad_glRectdv
+typedef void (APIENTRYP PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+GLAPI PFNGLRECTFPROC glad_glRectf;
+#define glRectf glad_glRectf
+typedef void (APIENTRYP PFNGLRECTFVPROC)(const GLfloat *v1, const GLfloat *v2);
+GLAPI PFNGLRECTFVPROC glad_glRectfv;
+#define glRectfv glad_glRectfv
+typedef void (APIENTRYP PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2);
+GLAPI PFNGLRECTIPROC glad_glRecti;
+#define glRecti glad_glRecti
+typedef void (APIENTRYP PFNGLRECTIVPROC)(const GLint *v1, const GLint *v2);
+GLAPI PFNGLRECTIVPROC glad_glRectiv;
+#define glRectiv glad_glRectiv
+typedef void (APIENTRYP PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+GLAPI PFNGLRECTSPROC glad_glRects;
+#define glRects glad_glRects
+typedef void (APIENTRYP PFNGLRECTSVPROC)(const GLshort *v1, const GLshort *v2);
+GLAPI PFNGLRECTSVPROC glad_glRectsv;
+#define glRectsv glad_glRectsv
+typedef void (APIENTRYP PFNGLTEXCOORD1DPROC)(GLdouble s);
+GLAPI PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
+#define glTexCoord1d glad_glTexCoord1d
+typedef void (APIENTRYP PFNGLTEXCOORD1DVPROC)(const GLdouble *v);
+GLAPI PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
+#define glTexCoord1dv glad_glTexCoord1dv
+typedef void (APIENTRYP PFNGLTEXCOORD1FPROC)(GLfloat s);
+GLAPI PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
+#define glTexCoord1f glad_glTexCoord1f
+typedef void (APIENTRYP PFNGLTEXCOORD1FVPROC)(const GLfloat *v);
+GLAPI PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
+#define glTexCoord1fv glad_glTexCoord1fv
+typedef void (APIENTRYP PFNGLTEXCOORD1IPROC)(GLint s);
+GLAPI PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
+#define glTexCoord1i glad_glTexCoord1i
+typedef void (APIENTRYP PFNGLTEXCOORD1IVPROC)(const GLint *v);
+GLAPI PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
+#define glTexCoord1iv glad_glTexCoord1iv
+typedef void (APIENTRYP PFNGLTEXCOORD1SPROC)(GLshort s);
+GLAPI PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
+#define glTexCoord1s glad_glTexCoord1s
+typedef void (APIENTRYP PFNGLTEXCOORD1SVPROC)(const GLshort *v);
+GLAPI PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
+#define glTexCoord1sv glad_glTexCoord1sv
+typedef void (APIENTRYP PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t);
+GLAPI PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
+#define glTexCoord2d glad_glTexCoord2d
+typedef void (APIENTRYP PFNGLTEXCOORD2DVPROC)(const GLdouble *v);
+GLAPI PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
+#define glTexCoord2dv glad_glTexCoord2dv
+typedef void (APIENTRYP PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t);
+GLAPI PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
+#define glTexCoord2f glad_glTexCoord2f
+typedef void (APIENTRYP PFNGLTEXCOORD2FVPROC)(const GLfloat *v);
+GLAPI PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
+#define glTexCoord2fv glad_glTexCoord2fv
+typedef void (APIENTRYP PFNGLTEXCOORD2IPROC)(GLint s, GLint t);
+GLAPI PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
+#define glTexCoord2i glad_glTexCoord2i
+typedef void (APIENTRYP PFNGLTEXCOORD2IVPROC)(const GLint *v);
+GLAPI PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
+#define glTexCoord2iv glad_glTexCoord2iv
+typedef void (APIENTRYP PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t);
+GLAPI PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
+#define glTexCoord2s glad_glTexCoord2s
+typedef void (APIENTRYP PFNGLTEXCOORD2SVPROC)(const GLshort *v);
+GLAPI PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
+#define glTexCoord2sv glad_glTexCoord2sv
+typedef void (APIENTRYP PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r);
+GLAPI PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
+#define glTexCoord3d glad_glTexCoord3d
+typedef void (APIENTRYP PFNGLTEXCOORD3DVPROC)(const GLdouble *v);
+GLAPI PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
+#define glTexCoord3dv glad_glTexCoord3dv
+typedef void (APIENTRYP PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r);
+GLAPI PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
+#define glTexCoord3f glad_glTexCoord3f
+typedef void (APIENTRYP PFNGLTEXCOORD3FVPROC)(const GLfloat *v);
+GLAPI PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
+#define glTexCoord3fv glad_glTexCoord3fv
+typedef void (APIENTRYP PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r);
+GLAPI PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
+#define glTexCoord3i glad_glTexCoord3i
+typedef void (APIENTRYP PFNGLTEXCOORD3IVPROC)(const GLint *v);
+GLAPI PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
+#define glTexCoord3iv glad_glTexCoord3iv
+typedef void (APIENTRYP PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r);
+GLAPI PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
+#define glTexCoord3s glad_glTexCoord3s
+typedef void (APIENTRYP PFNGLTEXCOORD3SVPROC)(const GLshort *v);
+GLAPI PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
+#define glTexCoord3sv glad_glTexCoord3sv
+typedef void (APIENTRYP PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
+#define glTexCoord4d glad_glTexCoord4d
+typedef void (APIENTRYP PFNGLTEXCOORD4DVPROC)(const GLdouble *v);
+GLAPI PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
+#define glTexCoord4dv glad_glTexCoord4dv
+typedef void (APIENTRYP PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
+#define glTexCoord4f glad_glTexCoord4f
+typedef void (APIENTRYP PFNGLTEXCOORD4FVPROC)(const GLfloat *v);
+GLAPI PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
+#define glTexCoord4fv glad_glTexCoord4fv
+typedef void (APIENTRYP PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q);
+GLAPI PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
+#define glTexCoord4i glad_glTexCoord4i
+typedef void (APIENTRYP PFNGLTEXCOORD4IVPROC)(const GLint *v);
+GLAPI PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
+#define glTexCoord4iv glad_glTexCoord4iv
+typedef void (APIENTRYP PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
+#define glTexCoord4s glad_glTexCoord4s
+typedef void (APIENTRYP PFNGLTEXCOORD4SVPROC)(const GLshort *v);
+GLAPI PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
+#define glTexCoord4sv glad_glTexCoord4sv
+typedef void (APIENTRYP PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y);
+GLAPI PFNGLVERTEX2DPROC glad_glVertex2d;
+#define glVertex2d glad_glVertex2d
+typedef void (APIENTRYP PFNGLVERTEX2DVPROC)(const GLdouble *v);
+GLAPI PFNGLVERTEX2DVPROC glad_glVertex2dv;
+#define glVertex2dv glad_glVertex2dv
+typedef void (APIENTRYP PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y);
+GLAPI PFNGLVERTEX2FPROC glad_glVertex2f;
+#define glVertex2f glad_glVertex2f
+typedef void (APIENTRYP PFNGLVERTEX2FVPROC)(const GLfloat *v);
+GLAPI PFNGLVERTEX2FVPROC glad_glVertex2fv;
+#define glVertex2fv glad_glVertex2fv
+typedef void (APIENTRYP PFNGLVERTEX2IPROC)(GLint x, GLint y);
+GLAPI PFNGLVERTEX2IPROC glad_glVertex2i;
+#define glVertex2i glad_glVertex2i
+typedef void (APIENTRYP PFNGLVERTEX2IVPROC)(const GLint *v);
+GLAPI PFNGLVERTEX2IVPROC glad_glVertex2iv;
+#define glVertex2iv glad_glVertex2iv
+typedef void (APIENTRYP PFNGLVERTEX2SPROC)(GLshort x, GLshort y);
+GLAPI PFNGLVERTEX2SPROC glad_glVertex2s;
+#define glVertex2s glad_glVertex2s
+typedef void (APIENTRYP PFNGLVERTEX2SVPROC)(const GLshort *v);
+GLAPI PFNGLVERTEX2SVPROC glad_glVertex2sv;
+#define glVertex2sv glad_glVertex2sv
+typedef void (APIENTRYP PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLVERTEX3DPROC glad_glVertex3d;
+#define glVertex3d glad_glVertex3d
+typedef void (APIENTRYP PFNGLVERTEX3DVPROC)(const GLdouble *v);
+GLAPI PFNGLVERTEX3DVPROC glad_glVertex3dv;
+#define glVertex3dv glad_glVertex3dv
+typedef void (APIENTRYP PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLVERTEX3FPROC glad_glVertex3f;
+#define glVertex3f glad_glVertex3f
+typedef void (APIENTRYP PFNGLVERTEX3FVPROC)(const GLfloat *v);
+GLAPI PFNGLVERTEX3FVPROC glad_glVertex3fv;
+#define glVertex3fv glad_glVertex3fv
+typedef void (APIENTRYP PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z);
+GLAPI PFNGLVERTEX3IPROC glad_glVertex3i;
+#define glVertex3i glad_glVertex3i
+typedef void (APIENTRYP PFNGLVERTEX3IVPROC)(const GLint *v);
+GLAPI PFNGLVERTEX3IVPROC glad_glVertex3iv;
+#define glVertex3iv glad_glVertex3iv
+typedef void (APIENTRYP PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z);
+GLAPI PFNGLVERTEX3SPROC glad_glVertex3s;
+#define glVertex3s glad_glVertex3s
+typedef void (APIENTRYP PFNGLVERTEX3SVPROC)(const GLshort *v);
+GLAPI PFNGLVERTEX3SVPROC glad_glVertex3sv;
+#define glVertex3sv glad_glVertex3sv
+typedef void (APIENTRYP PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI PFNGLVERTEX4DPROC glad_glVertex4d;
+#define glVertex4d glad_glVertex4d
+typedef void (APIENTRYP PFNGLVERTEX4DVPROC)(const GLdouble *v);
+GLAPI PFNGLVERTEX4DVPROC glad_glVertex4dv;
+#define glVertex4dv glad_glVertex4dv
+typedef void (APIENTRYP PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI PFNGLVERTEX4FPROC glad_glVertex4f;
+#define glVertex4f glad_glVertex4f
+typedef void (APIENTRYP PFNGLVERTEX4FVPROC)(const GLfloat *v);
+GLAPI PFNGLVERTEX4FVPROC glad_glVertex4fv;
+#define glVertex4fv glad_glVertex4fv
+typedef void (APIENTRYP PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w);
+GLAPI PFNGLVERTEX4IPROC glad_glVertex4i;
+#define glVertex4i glad_glVertex4i
+typedef void (APIENTRYP PFNGLVERTEX4IVPROC)(const GLint *v);
+GLAPI PFNGLVERTEX4IVPROC glad_glVertex4iv;
+#define glVertex4iv glad_glVertex4iv
+typedef void (APIENTRYP PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI PFNGLVERTEX4SPROC glad_glVertex4s;
+#define glVertex4s glad_glVertex4s
+typedef void (APIENTRYP PFNGLVERTEX4SVPROC)(const GLshort *v);
+GLAPI PFNGLVERTEX4SVPROC glad_glVertex4sv;
+#define glVertex4sv glad_glVertex4sv
+typedef void (APIENTRYP PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble *equation);
+GLAPI PFNGLCLIPPLANEPROC glad_glClipPlane;
+#define glClipPlane glad_glClipPlane
+typedef void (APIENTRYP PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode);
+GLAPI PFNGLCOLORMATERIALPROC glad_glColorMaterial;
+#define glColorMaterial glad_glColorMaterial
+typedef void (APIENTRYP PFNGLFOGFPROC)(GLenum pname, GLfloat param);
+GLAPI PFNGLFOGFPROC glad_glFogf;
+#define glFogf glad_glFogf
+typedef void (APIENTRYP PFNGLFOGFVPROC)(GLenum pname, const GLfloat *params);
+GLAPI PFNGLFOGFVPROC glad_glFogfv;
+#define glFogfv glad_glFogfv
+typedef void (APIENTRYP PFNGLFOGIPROC)(GLenum pname, GLint param);
+GLAPI PFNGLFOGIPROC glad_glFogi;
+#define glFogi glad_glFogi
+typedef void (APIENTRYP PFNGLFOGIVPROC)(GLenum pname, const GLint *params);
+GLAPI PFNGLFOGIVPROC glad_glFogiv;
+#define glFogiv glad_glFogiv
+typedef void (APIENTRYP PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param);
+GLAPI PFNGLLIGHTFPROC glad_glLightf;
+#define glLightf glad_glLightf
+typedef void (APIENTRYP PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat *params);
+GLAPI PFNGLLIGHTFVPROC glad_glLightfv;
+#define glLightfv glad_glLightfv
+typedef void (APIENTRYP PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param);
+GLAPI PFNGLLIGHTIPROC glad_glLighti;
+#define glLighti glad_glLighti
+typedef void (APIENTRYP PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint *params);
+GLAPI PFNGLLIGHTIVPROC glad_glLightiv;
+#define glLightiv glad_glLightiv
+typedef void (APIENTRYP PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param);
+GLAPI PFNGLLIGHTMODELFPROC glad_glLightModelf;
+#define glLightModelf glad_glLightModelf
+typedef void (APIENTRYP PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat *params);
+GLAPI PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
+#define glLightModelfv glad_glLightModelfv
+typedef void (APIENTRYP PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param);
+GLAPI PFNGLLIGHTMODELIPROC glad_glLightModeli;
+#define glLightModeli glad_glLightModeli
+typedef void (APIENTRYP PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint *params);
+GLAPI PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
+#define glLightModeliv glad_glLightModeliv
+typedef void (APIENTRYP PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern);
+GLAPI PFNGLLINESTIPPLEPROC glad_glLineStipple;
+#define glLineStipple glad_glLineStipple
+typedef void (APIENTRYP PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param);
+GLAPI PFNGLMATERIALFPROC glad_glMaterialf;
+#define glMaterialf glad_glMaterialf
+typedef void (APIENTRYP PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat *params);
+GLAPI PFNGLMATERIALFVPROC glad_glMaterialfv;
+#define glMaterialfv glad_glMaterialfv
+typedef void (APIENTRYP PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param);
+GLAPI PFNGLMATERIALIPROC glad_glMateriali;
+#define glMateriali glad_glMateriali
+typedef void (APIENTRYP PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint *params);
+GLAPI PFNGLMATERIALIVPROC glad_glMaterialiv;
+#define glMaterialiv glad_glMaterialiv
+typedef void (APIENTRYP PFNGLPOLYGONSTIPPLEPROC)(const GLubyte *mask);
+GLAPI PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
+#define glPolygonStipple glad_glPolygonStipple
+typedef void (APIENTRYP PFNGLSHADEMODELPROC)(GLenum mode);
+GLAPI PFNGLSHADEMODELPROC glad_glShadeModel;
+#define glShadeModel glad_glShadeModel
+typedef void (APIENTRYP PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param);
+GLAPI PFNGLTEXENVFPROC glad_glTexEnvf;
+#define glTexEnvf glad_glTexEnvf
+typedef void (APIENTRYP PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
+GLAPI PFNGLTEXENVFVPROC glad_glTexEnvfv;
+#define glTexEnvfv glad_glTexEnvfv
+typedef void (APIENTRYP PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
+GLAPI PFNGLTEXENVIPROC glad_glTexEnvi;
+#define glTexEnvi glad_glTexEnvi
+typedef void (APIENTRYP PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint *params);
+GLAPI PFNGLTEXENVIVPROC glad_glTexEnviv;
+#define glTexEnviv glad_glTexEnviv
+typedef void (APIENTRYP PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param);
+GLAPI PFNGLTEXGENDPROC glad_glTexGend;
+#define glTexGend glad_glTexGend
+typedef void (APIENTRYP PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble *params);
+GLAPI PFNGLTEXGENDVPROC glad_glTexGendv;
+#define glTexGendv glad_glTexGendv
+typedef void (APIENTRYP PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param);
+GLAPI PFNGLTEXGENFPROC glad_glTexGenf;
+#define glTexGenf glad_glTexGenf
+typedef void (APIENTRYP PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat *params);
+GLAPI PFNGLTEXGENFVPROC glad_glTexGenfv;
+#define glTexGenfv glad_glTexGenfv
+typedef void (APIENTRYP PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param);
+GLAPI PFNGLTEXGENIPROC glad_glTexGeni;
+#define glTexGeni glad_glTexGeni
+typedef void (APIENTRYP PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint *params);
+GLAPI PFNGLTEXGENIVPROC glad_glTexGeniv;
+#define glTexGeniv glad_glTexGeniv
+typedef void (APIENTRYP PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat *buffer);
+GLAPI PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
+#define glFeedbackBuffer glad_glFeedbackBuffer
+typedef void (APIENTRYP PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint *buffer);
+GLAPI PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
+#define glSelectBuffer glad_glSelectBuffer
+typedef GLint (APIENTRYP PFNGLRENDERMODEPROC)(GLenum mode);
+GLAPI PFNGLRENDERMODEPROC glad_glRenderMode;
+#define glRenderMode glad_glRenderMode
+typedef void (APIENTRYP PFNGLINITNAMESPROC)();
+GLAPI PFNGLINITNAMESPROC glad_glInitNames;
+#define glInitNames glad_glInitNames
+typedef void (APIENTRYP PFNGLLOADNAMEPROC)(GLuint name);
+GLAPI PFNGLLOADNAMEPROC glad_glLoadName;
+#define glLoadName glad_glLoadName
+typedef void (APIENTRYP PFNGLPASSTHROUGHPROC)(GLfloat token);
+GLAPI PFNGLPASSTHROUGHPROC glad_glPassThrough;
+#define glPassThrough glad_glPassThrough
+typedef void (APIENTRYP PFNGLPOPNAMEPROC)();
+GLAPI PFNGLPOPNAMEPROC glad_glPopName;
+#define glPopName glad_glPopName
+typedef void (APIENTRYP PFNGLPUSHNAMEPROC)(GLuint name);
+GLAPI PFNGLPUSHNAMEPROC glad_glPushName;
+#define glPushName glad_glPushName
+typedef void (APIENTRYP PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI PFNGLCLEARACCUMPROC glad_glClearAccum;
+#define glClearAccum glad_glClearAccum
+typedef void (APIENTRYP PFNGLCLEARINDEXPROC)(GLfloat c);
+GLAPI PFNGLCLEARINDEXPROC glad_glClearIndex;
+#define glClearIndex glad_glClearIndex
+typedef void (APIENTRYP PFNGLINDEXMASKPROC)(GLuint mask);
+GLAPI PFNGLINDEXMASKPROC glad_glIndexMask;
+#define glIndexMask glad_glIndexMask
+typedef void (APIENTRYP PFNGLACCUMPROC)(GLenum op, GLfloat value);
+GLAPI PFNGLACCUMPROC glad_glAccum;
+#define glAccum glad_glAccum
+typedef void (APIENTRYP PFNGLPOPATTRIBPROC)();
+GLAPI PFNGLPOPATTRIBPROC glad_glPopAttrib;
+#define glPopAttrib glad_glPopAttrib
+typedef void (APIENTRYP PFNGLPUSHATTRIBPROC)(GLbitfield mask);
+GLAPI PFNGLPUSHATTRIBPROC glad_glPushAttrib;
+#define glPushAttrib glad_glPushAttrib
+typedef void (APIENTRYP PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+GLAPI PFNGLMAP1DPROC glad_glMap1d;
+#define glMap1d glad_glMap1d
+typedef void (APIENTRYP PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+GLAPI PFNGLMAP1FPROC glad_glMap1f;
+#define glMap1f glad_glMap1f
+typedef void (APIENTRYP PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+GLAPI PFNGLMAP2DPROC glad_glMap2d;
+#define glMap2d glad_glMap2d
+typedef void (APIENTRYP PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+GLAPI PFNGLMAP2FPROC glad_glMap2f;
+#define glMap2f glad_glMap2f
+typedef void (APIENTRYP PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2);
+GLAPI PFNGLMAPGRID1DPROC glad_glMapGrid1d;
+#define glMapGrid1d glad_glMapGrid1d
+typedef void (APIENTRYP PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2);
+GLAPI PFNGLMAPGRID1FPROC glad_glMapGrid1f;
+#define glMapGrid1f glad_glMapGrid1f
+typedef void (APIENTRYP PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+GLAPI PFNGLMAPGRID2DPROC glad_glMapGrid2d;
+#define glMapGrid2d glad_glMapGrid2d
+typedef void (APIENTRYP PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+GLAPI PFNGLMAPGRID2FPROC glad_glMapGrid2f;
+#define glMapGrid2f glad_glMapGrid2f
+typedef void (APIENTRYP PFNGLEVALCOORD1DPROC)(GLdouble u);
+GLAPI PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
+#define glEvalCoord1d glad_glEvalCoord1d
+typedef void (APIENTRYP PFNGLEVALCOORD1DVPROC)(const GLdouble *u);
+GLAPI PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
+#define glEvalCoord1dv glad_glEvalCoord1dv
+typedef void (APIENTRYP PFNGLEVALCOORD1FPROC)(GLfloat u);
+GLAPI PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
+#define glEvalCoord1f glad_glEvalCoord1f
+typedef void (APIENTRYP PFNGLEVALCOORD1FVPROC)(const GLfloat *u);
+GLAPI PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
+#define glEvalCoord1fv glad_glEvalCoord1fv
+typedef void (APIENTRYP PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v);
+GLAPI PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
+#define glEvalCoord2d glad_glEvalCoord2d
+typedef void (APIENTRYP PFNGLEVALCOORD2DVPROC)(const GLdouble *u);
+GLAPI PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
+#define glEvalCoord2dv glad_glEvalCoord2dv
+typedef void (APIENTRYP PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v);
+GLAPI PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
+#define glEvalCoord2f glad_glEvalCoord2f
+typedef void (APIENTRYP PFNGLEVALCOORD2FVPROC)(const GLfloat *u);
+GLAPI PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
+#define glEvalCoord2fv glad_glEvalCoord2fv
+typedef void (APIENTRYP PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2);
+GLAPI PFNGLEVALMESH1PROC glad_glEvalMesh1;
+#define glEvalMesh1 glad_glEvalMesh1
+typedef void (APIENTRYP PFNGLEVALPOINT1PROC)(GLint i);
+GLAPI PFNGLEVALPOINT1PROC glad_glEvalPoint1;
+#define glEvalPoint1 glad_glEvalPoint1
+typedef void (APIENTRYP PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+GLAPI PFNGLEVALMESH2PROC glad_glEvalMesh2;
+#define glEvalMesh2 glad_glEvalMesh2
+typedef void (APIENTRYP PFNGLEVALPOINT2PROC)(GLint i, GLint j);
+GLAPI PFNGLEVALPOINT2PROC glad_glEvalPoint2;
+#define glEvalPoint2 glad_glEvalPoint2
+typedef void (APIENTRYP PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref);
+GLAPI PFNGLALPHAFUNCPROC glad_glAlphaFunc;
+#define glAlphaFunc glad_glAlphaFunc
+typedef void (APIENTRYP PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor);
+GLAPI PFNGLPIXELZOOMPROC glad_glPixelZoom;
+#define glPixelZoom glad_glPixelZoom
+typedef void (APIENTRYP PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param);
+GLAPI PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
+#define glPixelTransferf glad_glPixelTransferf
+typedef void (APIENTRYP PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param);
+GLAPI PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
+#define glPixelTransferi glad_glPixelTransferi
+typedef void (APIENTRYP PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat *values);
+GLAPI PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
+#define glPixelMapfv glad_glPixelMapfv
+typedef void (APIENTRYP PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint *values);
+GLAPI PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
+#define glPixelMapuiv glad_glPixelMapuiv
+typedef void (APIENTRYP PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort *values);
+GLAPI PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
+#define glPixelMapusv glad_glPixelMapusv
+typedef void (APIENTRYP PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+GLAPI PFNGLCOPYPIXELSPROC glad_glCopyPixels;
+#define glCopyPixels glad_glCopyPixels
+typedef void (APIENTRYP PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+GLAPI PFNGLDRAWPIXELSPROC glad_glDrawPixels;
+#define glDrawPixels glad_glDrawPixels
+typedef void (APIENTRYP PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble *equation);
+GLAPI PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
+#define glGetClipPlane glad_glGetClipPlane
+typedef void (APIENTRYP PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETLIGHTFVPROC glad_glGetLightfv;
+#define glGetLightfv glad_glGetLightfv
+typedef void (APIENTRYP PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint *params);
+GLAPI PFNGLGETLIGHTIVPROC glad_glGetLightiv;
+#define glGetLightiv glad_glGetLightiv
+typedef void (APIENTRYP PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble *v);
+GLAPI PFNGLGETMAPDVPROC glad_glGetMapdv;
+#define glGetMapdv glad_glGetMapdv
+typedef void (APIENTRYP PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat *v);
+GLAPI PFNGLGETMAPFVPROC glad_glGetMapfv;
+#define glGetMapfv glad_glGetMapfv
+typedef void (APIENTRYP PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint *v);
+GLAPI PFNGLGETMAPIVPROC glad_glGetMapiv;
+#define glGetMapiv glad_glGetMapiv
+typedef void (APIENTRYP PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
+#define glGetMaterialfv glad_glGetMaterialfv
+typedef void (APIENTRYP PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint *params);
+GLAPI PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
+#define glGetMaterialiv glad_glGetMaterialiv
+typedef void (APIENTRYP PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat *values);
+GLAPI PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
+#define glGetPixelMapfv glad_glGetPixelMapfv
+typedef void (APIENTRYP PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint *values);
+GLAPI PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
+#define glGetPixelMapuiv glad_glGetPixelMapuiv
+typedef void (APIENTRYP PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort *values);
+GLAPI PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
+#define glGetPixelMapusv glad_glGetPixelMapusv
+typedef void (APIENTRYP PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte *mask);
+GLAPI PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
+#define glGetPolygonStipple glad_glGetPolygonStipple
+typedef void (APIENTRYP PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
+#define glGetTexEnvfv glad_glGetTexEnvfv
+typedef void (APIENTRYP PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint *params);
+GLAPI PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
+#define glGetTexEnviv glad_glGetTexEnviv
+typedef void (APIENTRYP PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble *params);
+GLAPI PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
+#define glGetTexGendv glad_glGetTexGendv
+typedef void (APIENTRYP PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat *params);
+GLAPI PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
+#define glGetTexGenfv glad_glGetTexGenfv
+typedef void (APIENTRYP PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint *params);
+GLAPI PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
+#define glGetTexGeniv glad_glGetTexGeniv
+typedef GLboolean (APIENTRYP PFNGLISLISTPROC)(GLuint list);
+GLAPI PFNGLISLISTPROC glad_glIsList;
+#define glIsList glad_glIsList
+typedef void (APIENTRYP PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI PFNGLFRUSTUMPROC glad_glFrustum;
+#define glFrustum glad_glFrustum
+typedef void (APIENTRYP PFNGLLOADIDENTITYPROC)();
+GLAPI PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
+#define glLoadIdentity glad_glLoadIdentity
+typedef void (APIENTRYP PFNGLLOADMATRIXFPROC)(const GLfloat *m);
+GLAPI PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
+#define glLoadMatrixf glad_glLoadMatrixf
+typedef void (APIENTRYP PFNGLLOADMATRIXDPROC)(const GLdouble *m);
+GLAPI PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
+#define glLoadMatrixd glad_glLoadMatrixd
+typedef void (APIENTRYP PFNGLMATRIXMODEPROC)(GLenum mode);
+GLAPI PFNGLMATRIXMODEPROC glad_glMatrixMode;
+#define glMatrixMode glad_glMatrixMode
+typedef void (APIENTRYP PFNGLMULTMATRIXFPROC)(const GLfloat *m);
+GLAPI PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
+#define glMultMatrixf glad_glMultMatrixf
+typedef void (APIENTRYP PFNGLMULTMATRIXDPROC)(const GLdouble *m);
+GLAPI PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
+#define glMultMatrixd glad_glMultMatrixd
+typedef void (APIENTRYP PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI PFNGLORTHOPROC glad_glOrtho;
+#define glOrtho glad_glOrtho
+typedef void (APIENTRYP PFNGLPOPMATRIXPROC)();
+GLAPI PFNGLPOPMATRIXPROC glad_glPopMatrix;
+#define glPopMatrix glad_glPopMatrix
+typedef void (APIENTRYP PFNGLPUSHMATRIXPROC)();
+GLAPI PFNGLPUSHMATRIXPROC glad_glPushMatrix;
+#define glPushMatrix glad_glPushMatrix
+typedef void (APIENTRYP PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLROTATEDPROC glad_glRotated;
+#define glRotated glad_glRotated
+typedef void (APIENTRYP PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLROTATEFPROC glad_glRotatef;
+#define glRotatef glad_glRotatef
+typedef void (APIENTRYP PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLSCALEDPROC glad_glScaled;
+#define glScaled glad_glScaled
+typedef void (APIENTRYP PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLSCALEFPROC glad_glScalef;
+#define glScalef glad_glScalef
+typedef void (APIENTRYP PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLTRANSLATEDPROC glad_glTranslated;
+#define glTranslated glad_glTranslated
+typedef void (APIENTRYP PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLTRANSLATEFPROC glad_glTranslatef;
+#define glTranslatef glad_glTranslatef
+#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 PFNGLGETPOINTERVPROC)(GLenum pname, void **params);
+GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv;
+#define glGetPointerv glad_glGetPointerv
+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
+typedef void (APIENTRYP PFNGLARRAYELEMENTPROC)(GLint i);
+GLAPI PFNGLARRAYELEMENTPROC glad_glArrayElement;
+#define glArrayElement glad_glArrayElement
+typedef void (APIENTRYP PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLCOLORPOINTERPROC glad_glColorPointer;
+#define glColorPointer glad_glColorPointer
+typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC)(GLenum array);
+GLAPI PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
+#define glDisableClientState glad_glDisableClientState
+typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void *pointer);
+GLAPI PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
+#define glEdgeFlagPointer glad_glEdgeFlagPointer
+typedef void (APIENTRYP PFNGLENABLECLIENTSTATEPROC)(GLenum array);
+GLAPI PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
+#define glEnableClientState glad_glEnableClientState
+typedef void (APIENTRYP PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLINDEXPOINTERPROC glad_glIndexPointer;
+#define glIndexPointer glad_glIndexPointer
+typedef void (APIENTRYP PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void *pointer);
+GLAPI PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
+#define glInterleavedArrays glad_glInterleavedArrays
+typedef void (APIENTRYP PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLNORMALPOINTERPROC glad_glNormalPointer;
+#define glNormalPointer glad_glNormalPointer
+typedef void (APIENTRYP PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
+#define glTexCoordPointer glad_glTexCoordPointer
+typedef void (APIENTRYP PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
+#define glVertexPointer glad_glVertexPointer
+typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint *textures, GLboolean *residences);
+GLAPI PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
+#define glAreTexturesResident glad_glAreTexturesResident
+typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint *textures, const GLfloat *priorities);
+GLAPI PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
+#define glPrioritizeTextures glad_glPrioritizeTextures
+typedef void (APIENTRYP PFNGLINDEXUBPROC)(GLubyte c);
+GLAPI PFNGLINDEXUBPROC glad_glIndexub;
+#define glIndexub glad_glIndexub
+typedef void (APIENTRYP PFNGLINDEXUBVPROC)(const GLubyte *c);
+GLAPI PFNGLINDEXUBVPROC glad_glIndexubv;
+#define glIndexubv glad_glIndexubv
+typedef void (APIENTRYP PFNGLPOPCLIENTATTRIBPROC)();
+GLAPI PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
+#define glPopClientAttrib glad_glPopClientAttrib
+typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask);
+GLAPI PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
+#define glPushClientAttrib glad_glPushClientAttrib
+#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
+typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture);
+GLAPI PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
+#define glClientActiveTexture glad_glClientActiveTexture
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s);
+GLAPI PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
+#define glMultiTexCoord1d glad_glMultiTexCoord1d
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble *v);
+GLAPI PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
+#define glMultiTexCoord1dv glad_glMultiTexCoord1dv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s);
+GLAPI PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
+#define glMultiTexCoord1f glad_glMultiTexCoord1f
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat *v);
+GLAPI PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
+#define glMultiTexCoord1fv glad_glMultiTexCoord1fv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s);
+GLAPI PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
+#define glMultiTexCoord1i glad_glMultiTexCoord1i
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint *v);
+GLAPI PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
+#define glMultiTexCoord1iv glad_glMultiTexCoord1iv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s);
+GLAPI PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
+#define glMultiTexCoord1s glad_glMultiTexCoord1s
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort *v);
+GLAPI PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
+#define glMultiTexCoord1sv glad_glMultiTexCoord1sv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t);
+GLAPI PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
+#define glMultiTexCoord2d glad_glMultiTexCoord2d
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble *v);
+GLAPI PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
+#define glMultiTexCoord2dv glad_glMultiTexCoord2dv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t);
+GLAPI PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
+#define glMultiTexCoord2f glad_glMultiTexCoord2f
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat *v);
+GLAPI PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
+#define glMultiTexCoord2fv glad_glMultiTexCoord2fv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t);
+GLAPI PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
+#define glMultiTexCoord2i glad_glMultiTexCoord2i
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint *v);
+GLAPI PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
+#define glMultiTexCoord2iv glad_glMultiTexCoord2iv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t);
+GLAPI PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
+#define glMultiTexCoord2s glad_glMultiTexCoord2s
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort *v);
+GLAPI PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
+#define glMultiTexCoord2sv glad_glMultiTexCoord2sv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
+GLAPI PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
+#define glMultiTexCoord3d glad_glMultiTexCoord3d
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble *v);
+GLAPI PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
+#define glMultiTexCoord3dv glad_glMultiTexCoord3dv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
+GLAPI PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
+#define glMultiTexCoord3f glad_glMultiTexCoord3f
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat *v);
+GLAPI PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
+#define glMultiTexCoord3fv glad_glMultiTexCoord3fv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r);
+GLAPI PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
+#define glMultiTexCoord3i glad_glMultiTexCoord3i
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint *v);
+GLAPI PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
+#define glMultiTexCoord3iv glad_glMultiTexCoord3iv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r);
+GLAPI PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
+#define glMultiTexCoord3s glad_glMultiTexCoord3s
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort *v);
+GLAPI PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
+#define glMultiTexCoord3sv glad_glMultiTexCoord3sv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
+#define glMultiTexCoord4d glad_glMultiTexCoord4d
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble *v);
+GLAPI PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
+#define glMultiTexCoord4dv glad_glMultiTexCoord4dv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
+#define glMultiTexCoord4f glad_glMultiTexCoord4f
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat *v);
+GLAPI PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
+#define glMultiTexCoord4fv glad_glMultiTexCoord4fv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q);
+GLAPI PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
+#define glMultiTexCoord4i glad_glMultiTexCoord4i
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint *v);
+GLAPI PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
+#define glMultiTexCoord4iv glad_glMultiTexCoord4iv
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
+#define glMultiTexCoord4s glad_glMultiTexCoord4s
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort *v);
+GLAPI PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
+#define glMultiTexCoord4sv glad_glMultiTexCoord4sv
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat *m);
+GLAPI PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
+#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble *m);
+GLAPI PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
+#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat *m);
+GLAPI PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
+#define glMultTransposeMatrixf glad_glMultTransposeMatrixf
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble *m);
+GLAPI PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
+#define glMultTransposeMatrixd glad_glMultTransposeMatrixd
+#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 PFNGLFOGCOORDFPROC)(GLfloat coord);
+GLAPI PFNGLFOGCOORDFPROC glad_glFogCoordf;
+#define glFogCoordf glad_glFogCoordf
+typedef void (APIENTRYP PFNGLFOGCOORDFVPROC)(const GLfloat *coord);
+GLAPI PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
+#define glFogCoordfv glad_glFogCoordfv
+typedef void (APIENTRYP PFNGLFOGCOORDDPROC)(GLdouble coord);
+GLAPI PFNGLFOGCOORDDPROC glad_glFogCoordd;
+#define glFogCoordd glad_glFogCoordd
+typedef void (APIENTRYP PFNGLFOGCOORDDVPROC)(const GLdouble *coord);
+GLAPI PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
+#define glFogCoorddv glad_glFogCoorddv
+typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
+#define glFogCoordPointer glad_glFogCoordPointer
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
+GLAPI PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
+#define glSecondaryColor3b glad_glSecondaryColor3b
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte *v);
+GLAPI PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
+#define glSecondaryColor3bv glad_glSecondaryColor3bv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
+GLAPI PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
+#define glSecondaryColor3d glad_glSecondaryColor3d
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble *v);
+GLAPI PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
+#define glSecondaryColor3dv glad_glSecondaryColor3dv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
+GLAPI PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
+#define glSecondaryColor3f glad_glSecondaryColor3f
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat *v);
+GLAPI PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
+#define glSecondaryColor3fv glad_glSecondaryColor3fv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue);
+GLAPI PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
+#define glSecondaryColor3i glad_glSecondaryColor3i
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC)(const GLint *v);
+GLAPI PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
+#define glSecondaryColor3iv glad_glSecondaryColor3iv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
+GLAPI PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
+#define glSecondaryColor3s glad_glSecondaryColor3s
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC)(const GLshort *v);
+GLAPI PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
+#define glSecondaryColor3sv glad_glSecondaryColor3sv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
+GLAPI PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
+#define glSecondaryColor3ub glad_glSecondaryColor3ub
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte *v);
+GLAPI PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
+#define glSecondaryColor3ubv glad_glSecondaryColor3ubv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
+GLAPI PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
+#define glSecondaryColor3ui glad_glSecondaryColor3ui
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint *v);
+GLAPI PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
+#define glSecondaryColor3uiv glad_glSecondaryColor3uiv
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
+GLAPI PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
+#define glSecondaryColor3us glad_glSecondaryColor3us
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC)(const GLushort *v);
+GLAPI PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
+#define glSecondaryColor3usv glad_glSecondaryColor3usv
+typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+GLAPI PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
+#define glSecondaryColorPointer glad_glSecondaryColorPointer
+typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y);
+GLAPI PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
+#define glWindowPos2d glad_glWindowPos2d
+typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC)(const GLdouble *v);
+GLAPI PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
+#define glWindowPos2dv glad_glWindowPos2dv
+typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y);
+GLAPI PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
+#define glWindowPos2f glad_glWindowPos2f
+typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC)(const GLfloat *v);
+GLAPI PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
+#define glWindowPos2fv glad_glWindowPos2fv
+typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC)(GLint x, GLint y);
+GLAPI PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
+#define glWindowPos2i glad_glWindowPos2i
+typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC)(const GLint *v);
+GLAPI PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
+#define glWindowPos2iv glad_glWindowPos2iv
+typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y);
+GLAPI PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
+#define glWindowPos2s glad_glWindowPos2s
+typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC)(const GLshort *v);
+GLAPI PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
+#define glWindowPos2sv glad_glWindowPos2sv
+typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+GLAPI PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
+#define glWindowPos3d glad_glWindowPos3d
+typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC)(const GLdouble *v);
+GLAPI PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
+#define glWindowPos3dv glad_glWindowPos3dv
+typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+GLAPI PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
+#define glWindowPos3f glad_glWindowPos3f
+typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC)(const GLfloat *v);
+GLAPI PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
+#define glWindowPos3fv glad_glWindowPos3fv
+typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z);
+GLAPI PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
+#define glWindowPos3i glad_glWindowPos3i
+typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC)(const GLint *v);
+GLAPI PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
+#define glWindowPos3iv glad_glWindowPos3iv
+typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z);
+GLAPI PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
+#define glWindowPos3s glad_glWindowPos3s
+typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC)(const GLshort *v);
+GLAPI PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
+#define glWindowPos3sv glad_glWindowPos3sv
+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)();
+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)();
+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)();
+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 bufSize, 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
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION_ARB 0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM_ARB 0x8245
+#define GL_DEBUG_SOURCE_API_ARB 0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY_ARB 0x8249
+#define GL_DEBUG_SOURCE_APPLICATION_ARB 0x824A
+#define GL_DEBUG_SOURCE_OTHER_ARB 0x824B
+#define GL_DEBUG_TYPE_ERROR_ARB 0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E
+#define GL_DEBUG_TYPE_PORTABILITY_ARB 0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE_ARB 0x8250
+#define GL_DEBUG_TYPE_OTHER_ARB 0x8251
+#define GL_MAX_DEBUG_MESSAGE_LENGTH_ARB 0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES_ARB 0x9144
+#define GL_DEBUG_LOGGED_MESSAGES_ARB 0x9145
+#define GL_DEBUG_SEVERITY_HIGH_ARB 0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM_ARB 0x9147
+#define GL_DEBUG_SEVERITY_LOW_ARB 0x9148
+#ifndef GL_ARB_debug_output
+#define GL_ARB_debug_output 1
+GLAPI int GLAD_GL_ARB_debug_output;
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECONTROLARBPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+GLAPI PFNGLDEBUGMESSAGECONTROLARBPROC glad_glDebugMessageControlARB;
+#define glDebugMessageControlARB glad_glDebugMessageControlARB
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTARBPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+GLAPI PFNGLDEBUGMESSAGEINSERTARBPROC glad_glDebugMessageInsertARB;
+#define glDebugMessageInsertARB glad_glDebugMessageInsertARB
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKARBPROC)(GLDEBUGPROCARB callback, const void *userParam);
+GLAPI PFNGLDEBUGMESSAGECALLBACKARBPROC glad_glDebugMessageCallbackARB;
+#define glDebugMessageCallbackARB glad_glDebugMessageCallbackARB
+typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGARBPROC)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+GLAPI PFNGLGETDEBUGMESSAGELOGARBPROC glad_glGetDebugMessageLogARB;
+#define glGetDebugMessageLogARB glad_glGetDebugMessageLogARB
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

drivers/gles2/rasterizer_gles2.cpp

@@ -376,7 +376,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 
 	switch(p_format) {
 
-		case Image::FORMAT_GRAYSCALE: {
+		case Image::FORMAT_L8: {
 			r_gl_components=1;
 			r_gl_format=GL_LUMINANCE;
 			r_gl_internal_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_SLUMINANCE_NV:GL_LUMINANCE;
@@ -385,15 +385,15 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 		case Image::FORMAT_INTENSITY: {
 
 			if (!image.empty())
-				image.convert(Image::FORMAT_RGBA);
+				image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=4;
 			r_gl_format=GL_RGBA;
 			r_gl_internal_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_ALPHA_EXT:GL_RGBA;
 			r_has_alpha_cache=true;
 		} break;
-		case Image::FORMAT_GRAYSCALE_ALPHA: {
+		case Image::FORMAT_LA8: {
 
-			//image.convert(Image::FORMAT_RGBA);
+			//image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=2;
 			r_gl_format=GL_LUMINANCE_ALPHA;
 			r_gl_internal_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_SLUMINANCE_ALPHA_NV:GL_LUMINANCE_ALPHA;
@@ -403,7 +403,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 		case Image::FORMAT_INDEXED: {
 
 			if (!image.empty())
-				image.convert(Image::FORMAT_RGB);
+				image.convert(Image::FORMAT_RGB8);
 			r_gl_components=3;
 			r_gl_format=GL_RGB;
 			r_gl_internal_format=(srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_GL_SRGB_EXT:GL_RGB;
@@ -413,7 +413,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 		case Image::FORMAT_INDEXED_ALPHA: {
 
 			if (!image.empty())
-				image.convert(Image::FORMAT_RGBA);
+				image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=4;
 
 			if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
@@ -432,7 +432,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			r_has_alpha_cache=true;
 
 		} break;
-		case Image::FORMAT_RGB: {
+		case Image::FORMAT_RGB8: {
 
 			r_gl_components=3;
 
@@ -450,7 +450,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 				r_gl_internal_format=GL_RGB;
 			}
 		} break;
-		case Image::FORMAT_RGBA: {
+		case Image::FORMAT_RGBA8: {
 
 			r_gl_components=4;
 			if (p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
@@ -470,7 +470,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 
 			r_has_alpha_cache=true;
 		} break;
-		case Image::FORMAT_BC1: {
+		case Image::FORMAT_DXT1: {
 
 			if (!s3tc_supported || (!s3tc_srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
 
@@ -501,7 +501,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			};
 
 		} break;
-		case Image::FORMAT_BC2: {
+		case Image::FORMAT_DXT3: {
 
 			if (!s3tc_supported || (!s3tc_srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
 
@@ -533,7 +533,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			};
 
 		} break;
-		case Image::FORMAT_BC3: {
+		case Image::FORMAT_DXT5: {
 
 			if (!s3tc_supported || (!s3tc_srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
 
@@ -564,7 +564,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			};
 
 		} break;
-		case Image::FORMAT_BC4: {
+		case Image::FORMAT_ATI1: {
 
 			if (!latc_supported) {
 
@@ -595,7 +595,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			};
 
 		} break;
-		case Image::FORMAT_BC5: {
+		case Image::FORMAT_ATI2: {
 
 			if (!latc_supported ) {
 
@@ -657,7 +657,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			}
 
 		} break;
-		case Image::FORMAT_PVRTC2_ALPHA: {
+		case Image::FORMAT_PVRTC2A: {
 
 			if (!pvr_supported || (!pvr_srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
 
@@ -719,7 +719,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 			}
 
 		} break;
-		case Image::FORMAT_PVRTC4_ALPHA: {
+		case Image::FORMAT_PVRTC4A: {
 
 			if (!pvr_supported  || (!pvr_srgb_supported && p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
 
@@ -841,7 +841,7 @@ Image RasterizerGLES2::_get_gl_image_and_format(const Image& p_image, Image::For
 		case Image::FORMAT_YUV_444: {
 
 			if (!image.empty())
-				image.convert(Image::FORMAT_RGB);
+				image.convert(Image::FORMAT_RGB8);
 			r_gl_internal_format=GL_RGB;
 			r_gl_components=3;
 
@@ -1145,7 +1145,7 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 
 	switch(texture->format) {
 
-		case Image::FORMAT_GRAYSCALE: {
+		case Image::FORMAT_L8: {
 
 			format=GL_LUMINANCE;
 			type=GL_UNSIGNED_BYTE;
@@ -1156,19 +1156,19 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 		case Image::FORMAT_INTENSITY: {
 			return Image();
 		} break;
-		case Image::FORMAT_GRAYSCALE_ALPHA: {
+		case Image::FORMAT_LA8: {
 
 			format=GL_LUMINANCE_ALPHA;
 			type=GL_UNSIGNED_BYTE;
 			pixelsize=2;
 
 		} break;
-		case Image::FORMAT_RGB: {
+		case Image::FORMAT_RGB8: {
 			format=GL_RGB;
 			type=GL_UNSIGNED_BYTE;
 			pixelsize=3;
 		} break;
-		case Image::FORMAT_RGBA: {
+		case Image::FORMAT_RGBA8: {
 
 			format=GL_RGBA;
 			type=GL_UNSIGNED_BYTE;
@@ -1178,18 +1178,18 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 
 			format=GL_RGB;
 			type=GL_UNSIGNED_BYTE;
-			fmt=Image::FORMAT_RGB;
+			fmt=Image::FORMAT_RGB8;
 			pixelsize=3;
 		} break;
 		case Image::FORMAT_INDEXED_ALPHA: {
 
 			format=GL_RGBA;
 			type=GL_UNSIGNED_BYTE;
-			fmt=Image::FORMAT_RGBA;
+			fmt=Image::FORMAT_RGBA8;
 			pixelsize=4;
 
 		} break;
-		case Image::FORMAT_BC1: {
+		case Image::FORMAT_DXT1: {
 
 			pixelsize=1; //doesn't matter much
 			format=GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
@@ -1198,14 +1198,14 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 			minw=minh=4;
 
 		} break;
-		case Image::FORMAT_BC2: {
+		case Image::FORMAT_DXT3: {
 			pixelsize=1; //doesn't matter much
 			format=GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
 			compressed=true;
 			minw=minh=4;
 
 		} break;
-		case Image::FORMAT_BC3: {
+		case Image::FORMAT_DXT5: {
 
 			pixelsize=1; //doesn't matter much
 			format=GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
@@ -1213,7 +1213,7 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 			minw=minh=4;
 
 		} break;
-		case Image::FORMAT_BC4: {
+		case Image::FORMAT_ATI1: {
 
 			format=GL_COMPRESSED_RED_RGTC1;
 			pixelsize=1; //doesn't matter much
@@ -1222,7 +1222,7 @@ Image RasterizerGLES2::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_sid
 			minw=minh=4;
 
 		} break;
-		case Image::FORMAT_BC5: {
+		case Image::FORMAT_ATI2: {
 
 			format=GL_COMPRESSED_RG_RGTC2;
 			pixelsize=1; //doesn't matter much
@@ -1359,7 +1359,7 @@ Image::Format RasterizerGLES2::texture_get_format(RID p_texture) const {
 
 	Texture * texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,Image::FORMAT_GRAYSCALE);
+	ERR_FAIL_COND_V(!texture,Image::FORMAT_L8);
 
 	return texture->format;
 }
@@ -4320,7 +4320,7 @@ void RasterizerGLES2::capture_viewport(Image* r_capture) {
 
 	w=DVector<uint8_t>::Write();
 
-	r_capture->create(viewport.width,viewport.height,0,Image::FORMAT_RGB,pixels);
+	r_capture->create(viewport.width,viewport.height,0,Image::FORMAT_RGB8,pixels);
 #else
 
 
@@ -4360,7 +4360,7 @@ void RasterizerGLES2::capture_viewport(Image* r_capture) {
 	}
 
 	w=DVector<uint8_t>::Write();
-	r_capture->create(viewport.width,viewport.height,0,Image::FORMAT_RGBA,pixels);
+	r_capture->create(viewport.width,viewport.height,0,Image::FORMAT_RGBA8,pixels);
 	//r_capture->flip_y();
 
 

drivers/gles2/rasterizer_gles2.h

@@ -154,7 +154,7 @@ class RasterizerGLES2 : public Rasterizer {
 			flags=width=height=0;
 			tex_id=0;
 			data_size=0;
-			format=Image::FORMAT_GRAYSCALE;
+			format=Image::FORMAT_L8;
 			gl_components_cache=0;
 			format_has_alpha=false;
 			has_alpha=false;

drivers/gles2/shaders/canvas.glsl

@@ -105,8 +105,8 @@ precision mediump float;
 precision mediump int;
 #endif
 
- // texunit:0
-uniform sampler2D texture;
+
+uniform sampler2D texture; // texunit:0
 
 varying vec2 uv_interp;
 varying vec4 color_interp;
@@ -319,7 +319,7 @@ LIGHT_SHADER_CODE
 
 #ifdef USE_DEPTH_SHADOWS
 
-#define SHADOW_DEPTH(m_tex,m_uv) (texture2D((m_tex),(m_uv)).z)
+#define SHADOW_DEPTH(m_tex,m_uv) (texture2D((m_tex),(m_uv)).r)
 
 #else
 
@@ -395,5 +395,6 @@ LIGHT_SHADER_CODE
 //	color.rgb*=color.a;
 	gl_FragColor = color;
 
+
 }
 

drivers/gles2/shaders/copy.glsl

@@ -71,6 +71,11 @@ uniform sampler2D source;
 #endif
 varying vec2 uv2_interp;
 
+
+#ifdef USE_DEPTH
+uniform highp sampler2D source_depth; //texunit:1
+#endif
+
 #ifdef USE_GLOW
 
 uniform sampler2D glow_source;
@@ -547,5 +552,10 @@ void main() {
 
 
         gl_FragColor = color;
+
+#ifdef USE_DEPTH
+	gl_FragDepth = texture(source_depth,uv_interp).r;
+#endif
+
 }
 

drivers/gles3/SCsub

@@ -0,0 +1,5 @@
+Import('env')
+
+env.add_source_files(env.drivers_sources,"*.cpp")
+
+SConscript("shaders/SCsub")

drivers/gles3/rasterizer_canvas_gles3.cpp

@@ -0,0 +1,1531 @@
+#include "rasterizer_canvas_gles3.h"
+#include "os/os.h"
+
+static _FORCE_INLINE_ void store_matrix32(const Matrix32& p_mtx, float* p_array) {
+
+	p_array[ 0]=p_mtx.elements[0][0];
+	p_array[ 1]=p_mtx.elements[0][1];
+	p_array[ 2]=0;
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.elements[1][0];
+	p_array[ 5]=p_mtx.elements[1][1];
+	p_array[ 6]=0;
+	p_array[ 7]=0;
+	p_array[ 8]=0;
+	p_array[ 9]=0;
+	p_array[10]=1;
+	p_array[11]=0;
+	p_array[12]=p_mtx.elements[2][0];
+	p_array[13]=p_mtx.elements[2][1];
+	p_array[14]=0;
+	p_array[15]=1;
+}
+
+
+static _FORCE_INLINE_ void store_transform(const Transform& p_mtx, float* p_array) {
+	p_array[ 0]=p_mtx.basis.elements[0][0];
+	p_array[ 1]=p_mtx.basis.elements[1][0];
+	p_array[ 2]=p_mtx.basis.elements[2][0];
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.basis.elements[0][1];
+	p_array[ 5]=p_mtx.basis.elements[1][1];
+	p_array[ 6]=p_mtx.basis.elements[2][1];
+	p_array[ 7]=0;
+	p_array[ 8]=p_mtx.basis.elements[0][2];
+	p_array[ 9]=p_mtx.basis.elements[1][2];
+	p_array[10]=p_mtx.basis.elements[2][2];
+	p_array[11]=0;
+	p_array[12]=p_mtx.origin.x;
+	p_array[13]=p_mtx.origin.y;
+	p_array[14]=p_mtx.origin.z;
+	p_array[15]=1;
+}
+
+static _FORCE_INLINE_ void store_camera(const CameraMatrix& p_mtx, float* p_array) {
+
+	for (int i=0;i<4;i++) {
+		for (int j=0;j<4;j++) {
+
+			p_array[i*4+j]=p_mtx.matrix[i][j];
+		}
+	}
+}
+
+
+RID RasterizerCanvasGLES3::light_internal_create() {
+
+	LightInternal * li = memnew( LightInternal );
+
+	glGenBuffers(1, &li->ubo);
+	glBindBuffer(GL_UNIFORM_BUFFER, li->ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(LightInternal::UBOData), &state.canvas_item_ubo_data, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	return light_internal_owner.make_rid(li);
+}
+
+void RasterizerCanvasGLES3::light_internal_update(RID p_rid, Light* p_light) {
+
+	LightInternal * li = light_internal_owner.getornull(p_rid);
+	ERR_FAIL_COND(!li);
+
+	store_matrix32(p_light->light_shader_xform,li->ubo_data.light_matrix);
+	store_matrix32(p_light->xform_cache.affine_inverse(),li->ubo_data.local_matrix);
+	store_camera(p_light->shadow_matrix_cache,li->ubo_data.shadow_matrix);
+
+	for(int i=0;i<4;i++) {
+
+		li->ubo_data.color[i]=p_light->color[i]*p_light->energy;
+		li->ubo_data.shadow_color[i]=p_light->shadow_color[i];
+	}
+
+	li->ubo_data.light_pos[0]=p_light->light_shader_pos.x;
+	li->ubo_data.light_pos[1]=p_light->light_shader_pos.y;
+	li->ubo_data.shadowpixel_size=1.0/p_light->shadow_buffer_size;
+	li->ubo_data.light_outside_alpha=p_light->mode==VS::CANVAS_LIGHT_MODE_MASK?1.0:0.0;
+	li->ubo_data.light_height=p_light->height;
+	if (p_light->radius_cache==0)
+		li->ubo_data.shadow_gradient=0;
+	else
+		li->ubo_data.shadow_gradient=p_light->shadow_gradient_length/(p_light->radius_cache*1.1);;
+
+	li->ubo_data.shadow_distance_mult=(p_light->radius_cache*1.1);
+
+
+	glBindBuffer(GL_UNIFORM_BUFFER, li->ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(LightInternal::UBOData), &li->ubo_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+}
+
+void RasterizerCanvasGLES3::light_internal_free(RID p_rid) {
+
+	LightInternal * li = light_internal_owner.getornull(p_rid);
+	ERR_FAIL_COND(!li);
+
+	glDeleteBuffers(1,&li->ubo);
+	light_internal_owner.free(p_rid);
+	memdelete(li);
+
+}
+
+void RasterizerCanvasGLES3::canvas_begin(){
+
+	if (storage->frame.current_rt && storage->frame.clear_request) {
+		// a clear request may be pending, so do it
+
+		glClearColor( storage->frame.clear_request_color.r, storage->frame.clear_request_color.g, storage->frame.clear_request_color.b, storage->frame.clear_request_color.a );
+		glClear(GL_COLOR_BUFFER_BIT);
+		storage->frame.clear_request=false;
+
+	}
+
+	/*canvas_shader.unbind();
+	canvas_shader.set_custom_shader(0);
+	canvas_shader.set_conditional(CanvasShaderGLES2::USE_MODULATE,false);
+	canvas_shader.bind();
+	canvas_shader.set_uniform(CanvasShaderGLES2::TEXTURE, 0);
+	canvas_use_modulate=false;*/
+
+	reset_canvas();
+
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT,true);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,false);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,false);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,false);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,false);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,false);
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,false);
+
+
+	state.canvas_shader.set_custom_shader(0);
+	state.canvas_shader.bind();
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,Color(1,1,1,1));
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Matrix32());
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
+
+
+
+
+//	state.canvas_shader.set_uniform(CanvasShaderGLES3::PROJECTION_MATRIX,state.vp);
+	//state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Transform());
+	//state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform());
+
+	glBindBufferBase(GL_UNIFORM_BUFFER,0,state.canvas_item_ubo);
+	glBindVertexArray(data.canvas_quad_array);
+	state.using_texture_rect=true;
+
+
+}
+
+
+void RasterizerCanvasGLES3::canvas_end(){
+
+
+	glBindVertexArray(0);
+	glBindBufferBase(GL_UNIFORM_BUFFER,0,0);
+
+	state.using_texture_rect=false;
+
+}
+
+
+
+RasterizerStorageGLES3::Texture* RasterizerCanvasGLES3::_bind_canvas_texture(const RID& p_texture) {
+
+	if (p_texture==state.current_tex) {
+		return state.current_tex_ptr;
+	}
+
+	if (p_texture.is_valid()) {
+
+
+		RasterizerStorageGLES3::Texture*texture=storage->texture_owner.getornull(p_texture);
+
+		if (!texture) {
+			state.current_tex=RID();
+			state.current_tex_ptr=NULL;
+			glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+			return NULL;
+		}
+
+		if (texture->render_target)
+			texture->render_target->used_in_frame=true;
+
+		glBindTexture(GL_TEXTURE_2D,texture->tex_id);
+		state.current_tex=p_texture;
+		state.current_tex_ptr=texture;
+
+		return texture;
+
+
+	} else {
+
+
+		glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+		state.current_tex=RID();
+		state.current_tex_ptr=NULL;
+	}
+
+
+	return NULL;
+}
+
+void RasterizerCanvasGLES3::_set_texture_rect_mode(bool p_enable) {
+
+	if (state.using_texture_rect==p_enable)
+		return;
+
+	if (p_enable) {
+		glBindVertexArray(data.canvas_quad_array);
+
+
+	} else {
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER,0);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+
+
+	}
+
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT,p_enable);
+	state.canvas_shader.bind();
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
+	state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
+
+
+	state.using_texture_rect=p_enable;
+}
+
+
+void RasterizerCanvasGLES3::_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor) {
+
+	bool do_colors=false;
+	Color m;
+	if (p_singlecolor) {
+		m = *p_colors;
+		glVertexAttrib4f(VS::ARRAY_COLOR,m.r,m.g,m.b,m.a);
+	} else if (!p_colors) {
+
+		glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+	} else
+		do_colors=true;
+
+	RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(p_texture);
+
+#ifndef GLES_NO_CLIENT_ARRAYS
+	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+	glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, sizeof(Vector2), p_vertices );
+	if (do_colors) {
+
+		glEnableVertexAttribArray(VS::ARRAY_COLOR);
+		glVertexAttribPointer( VS::ARRAY_COLOR, 4 ,GL_FLOAT, false, sizeof(Color), p_colors );
+	} else {
+		glDisableVertexAttribArray(VS::ARRAY_COLOR);
+	}
+
+	if (texture && p_uvs) {
+
+		glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
+		glVertexAttribPointer( VS::ARRAY_TEX_UV, 2 ,GL_FLOAT, false, sizeof(Vector2), p_uvs );
+	} else {
+		glDisableVertexAttribArray(VS::ARRAY_TEX_UV);
+	}
+
+	if (p_indices) {
+		glDrawElements(GL_TRIANGLES, p_vertex_count, GL_UNSIGNED_INT, p_indices );
+	} else {
+		glDrawArrays(GL_TRIANGLES,0,p_vertex_count);
+	}
+
+
+#else //WebGL specific impl.
+	glBindBuffer(GL_ARRAY_BUFFER, gui_quad_buffer);
+	float *b = GlobalVertexBuffer;
+	int ofs = 0;
+	if(p_vertex_count > MAX_POLYGON_VERTICES){
+		print_line("Too many vertices to render");
+		return;
+	}
+	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+	glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, sizeof(float)*2, ((float*)0)+ofs );
+	for(int i=0;i<p_vertex_count;i++) {
+		b[ofs++]=p_vertices[i].x;
+		b[ofs++]=p_vertices[i].y;
+	}
+
+	if (p_colors && do_colors) {
+
+		glEnableVertexAttribArray(VS::ARRAY_COLOR);
+		glVertexAttribPointer( VS::ARRAY_COLOR, 4 ,GL_FLOAT, false, sizeof(float)*4, ((float*)0)+ofs );
+		for(int i=0;i<p_vertex_count;i++) {
+			b[ofs++]=p_colors[i].r;
+			b[ofs++]=p_colors[i].g;
+			b[ofs++]=p_colors[i].b;
+			b[ofs++]=p_colors[i].a;
+		}
+
+	} else {
+		glDisableVertexAttribArray(VS::ARRAY_COLOR);
+	}
+
+
+	if (p_uvs) {
+
+		glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
+		glVertexAttribPointer( VS::ARRAY_TEX_UV, 2 ,GL_FLOAT, false, sizeof(float)*2, ((float*)0)+ofs );
+		for(int i=0;i<p_vertex_count;i++) {
+			b[ofs++]=p_uvs[i].x;
+			b[ofs++]=p_uvs[i].y;
+		}
+
+	} else {
+		glDisableVertexAttribArray(VS::ARRAY_TEX_UV);
+	}
+
+	glBufferSubData(GL_ARRAY_BUFFER,0,ofs*4,&b[0]);
+
+	//bind the indices buffer.
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer);
+
+	static const int _max_draw_poly_indices = 16*1024; // change this size if needed!!!
+	ERR_FAIL_COND(p_vertex_count > _max_draw_poly_indices);
+	static uint16_t _draw_poly_indices[_max_draw_poly_indices];
+	for (int i=0; i<p_vertex_count; i++) {
+		_draw_poly_indices[i] = p_indices[i];
+		//OS::get_singleton()->print("ind: %d ", p_indices[i]);
+	};
+
+	//copy the data to GPU.
+	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, p_vertex_count * sizeof(uint16_t), &_draw_poly_indices[0]);
+
+	//draw the triangles.
+	glDrawElements(GL_TRIANGLES, p_vertex_count, GL_UNSIGNED_SHORT, 0);
+
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#endif
+
+	storage->frame.canvas_draw_commands++;
+
+}
+
+void RasterizerCanvasGLES3::_draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color* p_colors, const Vector2 *p_uvs) {
+
+
+
+	static const GLenum prim[5]={GL_POINTS,GL_POINTS,GL_LINES,GL_TRIANGLES,GL_TRIANGLE_FAN};
+
+
+	//#define GLES_USE_PRIMITIVE_BUFFER
+
+	int version=0;
+	int color_ofs=0;
+	int uv_ofs=0;
+	int stride=2;
+
+	if (p_colors) { //color
+		version|=1;
+		color_ofs=stride;
+		stride+=4;
+	}
+
+	if (p_uvs) { //uv
+		version|=2;
+		uv_ofs=stride;
+		stride+=2;
+	}
+
+
+	float b[(2+2+4)];
+
+
+	for(int i=0;i<p_points;i++) {
+		b[stride*i+0]=p_vertices[i].x;
+		b[stride*i+1]=p_vertices[i].y;
+	}
+
+	if (p_colors) {
+
+		for(int i=0;i<p_points;i++) {
+			b[stride*i+color_ofs+0]=p_colors[i].r;
+			b[stride*i+color_ofs+1]=p_colors[i].g;
+			b[stride*i+color_ofs+2]=p_colors[i].b;
+			b[stride*i+color_ofs+3]=p_colors[i].a;
+		}
+
+	}
+
+	if (p_uvs) {
+
+		for(int i=0;i<p_points;i++) {
+			b[stride*i+uv_ofs+0]=p_uvs[i].x;
+			b[stride*i+uv_ofs+1]=p_uvs[i].y;
+		}
+
+	}
+
+	glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
+	glBufferSubData(GL_ARRAY_BUFFER,0,p_points*stride*4,&b[0]);
+	glBindVertexArray(data.primitive_quad_buffer_arrays[version]);
+	glDrawArrays(prim[p_points],0,p_points);
+	glBindVertexArray(0);
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+
+	storage->frame.canvas_draw_commands++;
+}
+
+void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *current_clip,bool &reclip) {
+
+	int cc=p_item->commands.size();
+	Item::Command **commands = p_item->commands.ptr();
+
+
+	for(int i=0;i<cc;i++) {
+
+		Item::Command *c=commands[i];
+
+		switch(c->type) {
+			case Item::Command::TYPE_LINE: {
+
+
+				Item::CommandLine* line = static_cast<Item::CommandLine*>(c);
+				_set_texture_rect_mode(false);
+
+
+				_bind_canvas_texture(RID());
+
+				glVertexAttrib4f(VS::ARRAY_COLOR,line->color.r,line->color.g,line->color.b,line->color.a);
+
+				Vector2 verts[2]={
+					Vector2(line->from.x,line->from.y),
+					Vector2(line->to.x,line->to.y)
+				};
+
+#ifdef GLES_OVER_GL
+				if (line->antialiased)
+					glEnable(GL_LINE_SMOOTH);
+#endif
+				//glLineWidth(line->width);
+				_draw_gui_primitive(2,verts,NULL,NULL);
+
+#ifdef GLES_OVER_GL
+				if (line->antialiased)
+					glDisable(GL_LINE_SMOOTH);
+#endif
+
+
+			} break;
+			case Item::Command::TYPE_RECT: {
+
+				Item::CommandRect* rect = static_cast<Item::CommandRect*>(c);
+
+				_set_texture_rect_mode(true);
+
+				//set color
+				glVertexAttrib4f(VS::ARRAY_COLOR,rect->modulate.r,rect->modulate.g,rect->modulate.b,rect->modulate.a);
+
+				RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(rect->texture);
+
+				if ( texture ) {
+
+					bool untile=false;
+
+					if (rect->flags&CANVAS_RECT_TILE && !(texture->flags&VS::TEXTURE_FLAG_REPEAT)) {
+						glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+						glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+						untile=true;
+					}
+
+					Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
+					Rect2 src_rect = (rect->flags&CANVAS_RECT_REGION) ? Rect2( rect->source.pos * texpixel_size, rect->source.size * texpixel_size ) : Rect2(0,0,1,1);
+
+					if (rect->flags&CANVAS_RECT_FLIP_H) {
+						src_rect.size.x*=-1;
+					}
+
+					if (rect->flags&CANVAS_RECT_FLIP_V) {
+						src_rect.size.y*=-1;
+					}
+
+					if (rect->flags&CANVAS_RECT_TRANSPOSE) {
+						//err..
+					}
+
+					state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+
+
+					glVertexAttrib4f(1,rect->rect.pos.x,rect->rect.pos.y,rect->rect.size.x,rect->rect.size.y);
+					glVertexAttrib4f(2,src_rect.pos.x,src_rect.pos.y,src_rect.size.x,src_rect.size.y);
+					glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+
+					if (untile) {
+						glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+						glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+					}
+
+				} else {
+
+
+					glVertexAttrib4f(1,rect->rect.pos.x,rect->rect.pos.y,rect->rect.size.x,rect->rect.size.y);
+					glVertexAttrib4f(2,0,0,1,1);
+					glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+
+				}
+
+				storage->frame.canvas_draw_commands++;
+
+			} break;
+
+			case Item::Command::TYPE_NINEPATCH: {
+
+				Item::CommandNinePatch* np = static_cast<Item::CommandNinePatch*>(c);
+
+				_set_texture_rect_mode(true);
+
+				glVertexAttrib4f(VS::ARRAY_COLOR,np->color.r,np->color.g,np->color.b,np->color.a);
+
+
+				RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(np->texture);
+
+				if ( !texture ) {
+
+					glVertexAttrib4f(1,np->rect.pos.x,np->rect.pos.y,np->rect.size.x,np->rect.size.y);
+					glVertexAttrib4f(2,0,0,1,1);
+					glDrawArrays(GL_TRIANGLE_FAN,0,4);
+					continue;
+				}
+
+
+				Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
+
+				state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+
+#define DSTRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(1,m_x,m_y,m_w,m_h)
+#define SRCRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(2,(m_x)*texpixel_size.x,(m_y)*texpixel_size.y,(m_w)*texpixel_size.x,(m_h)*texpixel_size.y)
+
+				//top left
+				DSTRECT(np->rect.pos.x,np->rect.pos.y,np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
+				SRCRECT(0,0,np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				//top right
+				DSTRECT(np->rect.pos.x+np->rect.size.x-np->margin[MARGIN_RIGHT],np->rect.pos.y,np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
+				SRCRECT(texture->width-np->margin[MARGIN_RIGHT],0,np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				//bottom right
+				DSTRECT(np->rect.pos.x+np->rect.size.x-np->margin[MARGIN_RIGHT],np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_RIGHT],np->margin[MARGIN_BOTTOM]);
+				SRCRECT(texture->width-np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_RIGHT],np->margin[MARGIN_BOTTOM]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				//bottom left
+				DSTRECT(np->rect.pos.x,np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_LEFT],np->margin[MARGIN_BOTTOM]);
+				SRCRECT(0,texture->height-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_LEFT],np->margin[MARGIN_BOTTOM]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+
+				//top
+				DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y,np->rect.size.width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
+				SRCRECT(np->margin[MARGIN_LEFT],0,texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				//bottom
+				DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->rect.size.width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
+				SRCRECT(np->margin[MARGIN_LEFT],texture->height-np->margin[MARGIN_BOTTOM],texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+
+				//left
+				DSTRECT(np->rect.pos.x,np->rect.pos.y+np->margin[MARGIN_TOP],np->margin[MARGIN_LEFT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+				SRCRECT(0,np->margin[MARGIN_TOP],np->margin[MARGIN_LEFT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				//right
+				DSTRECT(np->rect.pos.x+np->rect.size.width-np->margin[MARGIN_RIGHT],np->rect.pos.y+np->margin[MARGIN_TOP],np->margin[MARGIN_RIGHT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+				SRCRECT(texture->width-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP],np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+				glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				if (np->draw_center) {
+
+					//center
+					DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y+np->margin[MARGIN_TOP],np->rect.size.x-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+					SRCRECT(np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP],texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
+					glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+				}
+
+#undef SRCRECT
+#undef DSTRECT
+
+				storage->frame.canvas_draw_commands++;
+			} break;
+
+			case Item::Command::TYPE_PRIMITIVE: {
+
+				Item::CommandPrimitive* primitive = static_cast<Item::CommandPrimitive*>(c);
+				_set_texture_rect_mode(false);
+
+				ERR_CONTINUE( primitive->points.size()<1);
+
+				RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(primitive->texture);
+
+				if (texture ) {
+					Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
+					state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+
+				}
+				if (primitive->colors.size()==1 && primitive->points.size()>1) {
+
+					Color c = primitive->colors[0];
+					glVertexAttrib4f(VS::ARRAY_COLOR,c.r,c.g,c.b,c.a);
+
+				} else if (primitive->colors.empty()) {
+					glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+				}
+
+				_draw_gui_primitive(primitive->points.size(),primitive->points.ptr(),primitive->colors.ptr(),primitive->uvs.ptr());
+
+			} break;
+			case Item::Command::TYPE_POLYGON: {
+
+				Item::CommandPolygon* polygon = static_cast<Item::CommandPolygon*>(c);
+				_set_texture_rect_mode(false);
+
+				RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(polygon->texture);
+
+				if (texture ) {
+					Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
+					state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+
+				}
+				_draw_polygon(polygon->count,polygon->indices.ptr(),polygon->points.ptr(),polygon->uvs.ptr(),polygon->colors.ptr(),polygon->texture,polygon->colors.size()==1);
+
+			} break;
+			case Item::Command::TYPE_CIRCLE: {
+
+				_set_texture_rect_mode(false);
+
+				Item::CommandCircle* circle = static_cast<Item::CommandCircle*>(c);
+				static const int numpoints=32;
+				Vector2 points[numpoints+1];
+				points[numpoints]=circle->pos;
+				int indices[numpoints*3];
+
+				for(int i=0;i<numpoints;i++) {
+
+					points[i]=circle->pos+Vector2( Math::sin(i*Math_PI*2.0/numpoints),Math::cos(i*Math_PI*2.0/numpoints) )*circle->radius;
+					indices[i*3+0]=i;
+					indices[i*3+1]=(i+1)%numpoints;
+					indices[i*3+2]=numpoints;
+				}
+				_draw_polygon(numpoints*3,indices,points,NULL,&circle->color,RID(),true);
+				//canvas_draw_circle(circle->indices.size(),circle->indices.ptr(),circle->points.ptr(),circle->uvs.ptr(),circle->colors.ptr(),circle->texture,circle->colors.size()==1);
+			} break;
+			case Item::Command::TYPE_TRANSFORM: {
+
+				Item::CommandTransform* transform = static_cast<Item::CommandTransform*>(c);
+				state.extra_matrix=transform->xform;
+				state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
+
+			} break;
+			case Item::Command::TYPE_CLIP_IGNORE: {
+
+				Item::CommandClipIgnore* ci = static_cast<Item::CommandClipIgnore*>(c);
+				if (current_clip) {
+
+					if (ci->ignore!=reclip) {
+						if (ci->ignore) {
+
+							glDisable(GL_SCISSOR_TEST);
+							reclip=true;
+						} else  {
+
+							glEnable(GL_SCISSOR_TEST);
+							//glScissor(viewport.x+current_clip->final_clip_rect.pos.x,viewport.y+ (viewport.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),
+							//current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
+
+							int x = current_clip->final_clip_rect.pos.x;
+							int y = storage->frame.current_rt->height - ( current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.y );
+							int w = current_clip->final_clip_rect.size.x;
+							int h = current_clip->final_clip_rect.size.y;
+
+							glScissor(x,y,w,h);
+
+							reclip=false;
+						}
+					}
+				}
+
+
+
+			} break;
+		}
+	}
+}
+
+#if 0
+void RasterizerGLES2::_canvas_item_setup_shader_params(CanvasItemMaterial *material,Shader* shader) {
+
+	if (canvas_shader.bind())
+		rebind_texpixel_size=true;
+
+	if (material->shader_version!=shader->version) {
+		//todo optimize uniforms
+		material->shader_version=shader->version;
+	}
+
+	if (shader->has_texscreen && framebuffer.active) {
+
+		int x = viewport.x;
+		int y = window_size.height-(viewport.height+viewport.y);
+
+		canvas_shader.set_uniform(CanvasShaderGLES2::TEXSCREEN_SCREEN_MULT,Vector2(float(viewport.width)/framebuffer.width,float(viewport.height)/framebuffer.height));
+		canvas_shader.set_uniform(CanvasShaderGLES2::TEXSCREEN_SCREEN_CLAMP,Color(float(x)/framebuffer.width,float(y)/framebuffer.height,float(x+viewport.width)/framebuffer.width,float(y+viewport.height)/framebuffer.height));
+		canvas_shader.set_uniform(CanvasShaderGLES2::TEXSCREEN_TEX,max_texture_units-1);
+		glActiveTexture(GL_TEXTURE0+max_texture_units-1);
+		glBindTexture(GL_TEXTURE_2D,framebuffer.sample_color);
+		if (framebuffer.scale==1 && !canvas_texscreen_used) {
+#ifdef GLEW_ENABLED
+			if (current_rt) {
+				glReadBuffer(GL_COLOR_ATTACHMENT0);
+			} else {
+				glReadBuffer(GL_BACK);
+			}
+#endif
+			if (current_rt) {
+				glCopyTexSubImage2D(GL_TEXTURE_2D,0,viewport.x,viewport.y,viewport.x,viewport.y,viewport.width,viewport.height);
+				canvas_shader.set_uniform(CanvasShaderGLES2::TEXSCREEN_SCREEN_CLAMP,Color(float(x)/framebuffer.width,float(viewport.y)/framebuffer.height,float(x+viewport.width)/framebuffer.width,float(y+viewport.height)/framebuffer.height));
+				//window_size.height-(viewport.height+viewport.y)
+			} else {
+				glCopyTexSubImage2D(GL_TEXTURE_2D,0,x,y,x,y,viewport.width,viewport.height);
+			}
+//			if (current_clip) {
+//			//	print_line(" a clip ");
+//			}
+
+			canvas_texscreen_used=true;
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+
+	}
+
+	if (shader->has_screen_uv) {
+		canvas_shader.set_uniform(CanvasShaderGLES2::SCREEN_UV_MULT,Vector2(1.0/viewport.width,1.0/viewport.height));
+	}
+
+
+	uses_texpixel_size=shader->uses_texpixel_size;
+
+}
+
+#endif
+
+void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const Color& p_modulate,Light *p_light) {
+
+
+
+
+	Item *current_clip=NULL;
+	RasterizerStorageGLES3::Shader *shader_cache=NULL;
+
+	bool rebind_shader=true;
+
+	Size2 rt_size = Size2(storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,false);
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	state.current_tex=RID();
+	state.current_tex_ptr=NULL;
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+
+
+	int last_blend_mode=-1;
+
+	RID canvas_last_material;
+
+	bool prev_distance_field=false;
+
+	while(p_item_list) {
+
+		Item *ci=p_item_list;
+
+
+		if (prev_distance_field!=ci->distance_field) {
+
+			state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,ci->distance_field);
+			prev_distance_field=ci->distance_field;
+			rebind_shader=true;
+		}
+
+
+		if (current_clip!=ci->final_clip_owner) {
+
+			current_clip=ci->final_clip_owner;
+
+			//setup clip
+			if (current_clip) {
+
+				glEnable(GL_SCISSOR_TEST);
+				glScissor(current_clip->final_clip_rect.pos.x,(rt_size.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
+
+
+			} else {
+
+				glDisable(GL_SCISSOR_TEST);
+			}
+		}
+#if 0
+		if (ci->copy_back_buffer && framebuffer.active && framebuffer.scale==1) {
+
+			Rect2 rect;
+			int x,y;
+
+			if (ci->copy_back_buffer->full) {
+
+				x = viewport.x;
+				y = window_size.height-(viewport.height+viewport.y);
+			} else {
+				x = viewport.x+ci->copy_back_buffer->screen_rect.pos.x;
+				y = window_size.height-(viewport.y+ci->copy_back_buffer->screen_rect.pos.y+ci->copy_back_buffer->screen_rect.size.y);
+			}
+			glActiveTexture(GL_TEXTURE0+max_texture_units-1);
+			glBindTexture(GL_TEXTURE_2D,framebuffer.sample_color);
+
+#ifdef GLEW_ENABLED
+			if (current_rt) {
+				glReadBuffer(GL_COLOR_ATTACHMENT0);
+			} else {
+				glReadBuffer(GL_BACK);
+			}
+#endif
+			if (current_rt) {
+				glCopyTexSubImage2D(GL_TEXTURE_2D,0,viewport.x,viewport.y,viewport.x,viewport.y,viewport.width,viewport.height);
+				//window_size.height-(viewport.height+viewport.y)
+			} else {
+				glCopyTexSubImage2D(GL_TEXTURE_2D,0,x,y,x,y,viewport.width,viewport.height);
+			}
+
+			canvas_texscreen_used=true;
+			glActiveTexture(GL_TEXTURE0);
+
+		}
+
+#endif
+
+
+		//begin rect
+		Item *material_owner = ci->material_owner?ci->material_owner:ci;
+
+		RID material = material_owner->material;
+
+		if (material!=canvas_last_material || rebind_shader) {
+
+			RasterizerStorageGLES3::Material *material_ptr = storage->material_owner.getornull(material);
+			RasterizerStorageGLES3::Shader *shader_ptr = NULL;
+
+			if (material_ptr) {
+
+				shader_ptr = material_ptr->shader;
+
+				if (shader_ptr && shader_ptr->mode!=VS::SHADER_CANVAS_ITEM) {
+					shader_ptr=NULL; //do not use non canvasitem shader
+				}
+			}
+
+
+
+			if (shader_ptr && shader_ptr!=shader_cache) {
+
+				state.canvas_shader.set_custom_shader(shader_ptr->custom_code_id);
+				state.canvas_shader.bind();
+
+				if (material_ptr->ubo_id) {
+					glBindBufferBase(GL_UNIFORM_BUFFER,2,material_ptr->ubo_id);
+				}
+
+				int tc = material_ptr->textures.size();
+				RID* textures = material_ptr->textures.ptr();
+				ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = shader_ptr->texture_hints.ptr();
+
+				for(int i=0;i<tc;i++) {
+
+					glActiveTexture(GL_TEXTURE1+i);
+
+					RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
+					if (!t) {
+
+						switch(texture_hints[i]) {
+							case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
+							case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
+								glBindTexture(GL_TEXTURE_2D,storage->resources.black_tex);
+							} break;
+							case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
+								glBindTexture(GL_TEXTURE_2D,storage->resources.aniso_tex);
+							} break;
+							case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
+								glBindTexture(GL_TEXTURE_2D,storage->resources.normal_tex);
+							} break;
+							default: {
+								glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+							} break;
+						}
+
+						//check hints
+
+						continue;
+					}
+
+					if (storage->config.srgb_decode_supported && t->using_srgb) {
+						//no srgb in 2D
+						glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
+						t->using_srgb=false;
+					}
+
+					glBindTexture(t->target,t->tex_id);
+				}
+
+
+			} else if (!shader_ptr) {
+				state.canvas_shader.set_custom_shader(0);
+				state.canvas_shader.bind();
+
+			}
+
+			shader_cache=shader_ptr;
+
+			canvas_last_material=material;
+			rebind_shader=false;
+
+		}
+
+		int blend_mode = shader_cache ? shader_cache->canvas_item.blend_mode : RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX;
+		bool unshaded = shader_cache && (shader_cache->canvas_item.light_mode==RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_UNSHADED || blend_mode!=RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX);
+		bool reclip=false;
+
+		if (last_blend_mode!=blend_mode) {
+
+			switch(blend_mode) {
+
+				 case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX: {
+					glBlendEquation(GL_FUNC_ADD);
+					if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+						glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+					}
+					else {
+						glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+					}
+
+				 } break;
+				 case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_ADD: {
+
+					glBlendEquation(GL_FUNC_ADD);
+					glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+
+				 } break;
+				 case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_SUB: {
+
+					glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+					glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+				 } break;
+				case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MUL: {
+					glBlendEquation(GL_FUNC_ADD);
+					glBlendFunc(GL_DST_COLOR,GL_ZERO);
+				} break;
+				case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA: {
+					glBlendEquation(GL_FUNC_ADD);
+					glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
+				} break;
+
+			}
+
+			last_blend_mode=blend_mode;
+		}
+
+		state.canvas_item_modulate = unshaded ? ci->final_modulate : Color(
+					ci->final_modulate.r * p_modulate.r,
+					ci->final_modulate.g * p_modulate.g,
+					ci->final_modulate.b * p_modulate.b,
+					ci->final_modulate.a * p_modulate.a );
+
+		state.final_transform = ci->final_transform;
+		state.extra_matrix=Matrix32();
+
+		state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
+		state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
+		state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
+
+
+		if (unshaded || (state.canvas_item_modulate.a>0.001 && (!shader_cache || shader_cache->canvas_item.light_mode!=RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY) && !ci->light_masked ))
+			_canvas_item_render_commands(ci,current_clip,reclip);
+
+		if ((blend_mode==RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX || RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA) && p_light && !unshaded) {
+
+			Light *light = p_light;
+			bool light_used=false;
+			VS::CanvasLightMode mode=VS::CANVAS_LIGHT_MODE_ADD;
+			state.canvas_item_modulate=ci->final_modulate; // remove the canvas modulate
+
+
+			while(light) {
+
+
+				if (ci->light_mask&light->item_mask && p_z>=light->z_min && p_z<=light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache,light->rect_cache)) {
+
+					//intersects this light
+
+					if (!light_used || mode!=light->mode) {
+
+						mode=light->mode;
+
+						switch(mode) {
+
+							case VS::CANVAS_LIGHT_MODE_ADD: {
+								glBlendEquation(GL_FUNC_ADD);
+								glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+
+							} break;
+							case VS::CANVAS_LIGHT_MODE_SUB: {
+								glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+								glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+							} break;
+							case VS::CANVAS_LIGHT_MODE_MIX:
+							case VS::CANVAS_LIGHT_MODE_MASK: {
+								glBlendEquation(GL_FUNC_ADD);
+								glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+							} break;
+						}
+
+					}
+
+					if (!light_used) {
+
+						state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,true);
+						light_used=true;
+
+					}
+
+
+					bool has_shadow = light->shadow_buffer.is_valid() && ci->light_mask&light->item_shadow_mask;
+
+
+					state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,has_shadow);
+					if (has_shadow) {
+						state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_USE_GRADIENT,light->shadow_gradient_length>0);
+						switch(light->shadow_filter) {
+
+							case VS::CANVAS_LIGHT_FILTER_NONE: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,true); break;
+							case VS::CANVAS_LIGHT_FILTER_PCF3: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3,true); break;
+							case VS::CANVAS_LIGHT_FILTER_PCF5: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,true); break;
+							case VS::CANVAS_LIGHT_FILTER_PCF9: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9,true); break;
+							case VS::CANVAS_LIGHT_FILTER_PCF13: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,true); break;
+						}
+
+
+					}
+
+					bool light_rebind = state.canvas_shader.bind();
+
+					if (light_rebind) {
+
+						state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
+						state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
+						state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
+
+					}
+
+					glBindBufferBase(GL_UNIFORM_BUFFER,1,static_cast<LightInternal*>(light->light_internal.get_data())->ubo);
+
+					if (has_shadow) {
+
+						RasterizerStorageGLES3::CanvasLightShadow *cls = storage->canvas_light_shadow_owner.get(light->shadow_buffer);
+						glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-2);
+						glBindTexture(GL_TEXTURE_2D,cls->distance);
+
+						/*canvas_shader.set_uniform(CanvasShaderGLES3::SHADOW_MATRIX,light->shadow_matrix_cache);
+						canvas_shader.set_uniform(CanvasShaderGLES3::SHADOW_ESM_MULTIPLIER,light->shadow_esm_mult);
+						canvas_shader.set_uniform(CanvasShaderGLES3::LIGHT_SHADOW_COLOR,light->shadow_color);*/
+
+					}
+
+					glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-1);
+					RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull(light->texture);
+					if (!t) {
+						glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+					} else {
+
+						glBindTexture(t->target,t->tex_id);
+					}
+
+					glActiveTexture(GL_TEXTURE0);
+					_canvas_item_render_commands(ci,current_clip,reclip); //redraw using light
+
+				}
+
+				light=light->next_ptr;
+			}
+
+			if (light_used) {
+
+
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9,false);
+				state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,false);
+
+				state.canvas_shader.bind();
+
+				last_blend_mode=-1;
+
+				/*
+				//this is set again, so it should not be needed anyway?
+				state.canvas_item_modulate = unshaded ? ci->final_modulate : Color(
+							ci->final_modulate.r * p_modulate.r,
+							ci->final_modulate.g * p_modulate.g,
+							ci->final_modulate.b * p_modulate.b,
+							ci->final_modulate.a * p_modulate.a );
+
+
+				state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
+				state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
+				state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
+
+				glBlendEquation(GL_FUNC_ADD);
+
+				if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+				} else {
+					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				}
+
+				//@TODO RESET canvas_blend_mode
+				*/
+			}
+
+
+		}
+
+		if (reclip) {
+
+			glEnable(GL_SCISSOR_TEST);
+			glScissor(current_clip->final_clip_rect.pos.x,(rt_size.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
+
+
+		}
+
+
+
+		p_item_list=p_item_list->next;
+	}
+
+	if (current_clip) {
+		glDisable(GL_SCISSOR_TEST);
+	}
+
+}
+
+void RasterizerCanvasGLES3::canvas_debug_viewport_shadows(Light* p_lights_with_shadow){
+
+	Light* light=p_lights_with_shadow;
+
+	canvas_begin(); //reset
+	glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+	int h = 10;
+	int w = storage->frame.current_rt->width;
+	int ofs = h;
+	glDisable(GL_BLEND);
+
+	//print_line(" debug lights ");
+	while(light) {
+
+
+	//	print_line("debug light");
+		if (light->shadow_buffer.is_valid()) {
+
+	//		print_line("sb is valid");
+			RasterizerStorageGLES3::CanvasLightShadow * sb = storage->canvas_light_shadow_owner.get(light->shadow_buffer);
+			if (sb) {
+				glBindTexture(GL_TEXTURE_2D,sb->distance);
+				//glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+				draw_generic_textured_rect(Rect2(h,ofs,w-h*2,h),Rect2(0,0,1,1));
+				ofs+=h*2;
+
+			}
+		}
+
+		light=light->shadows_next_ptr;
+	}
+}
+
+
+void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
+
+	RasterizerStorageGLES3::CanvasLightShadow *cls = storage->canvas_light_shadow_owner.get(p_buffer);
+	ERR_FAIL_COND(!cls);
+
+
+	glDisable(GL_BLEND);
+	glDisable(GL_SCISSOR_TEST);
+	glDisable(GL_DITHER);
+	glDisable(GL_CULL_FACE);
+	glDepthFunc(GL_LEQUAL);
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(true);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
+
+	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+	state.canvas_shadow_shader.bind();
+
+	glViewport(0, 0, cls->size,cls->height);
+	glClearDepth(1.0f);
+	glClearColor(1,1,1,1);
+	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+	VS::CanvasOccluderPolygonCullMode cull=VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+
+
+	for(int i=0;i<4;i++) {
+
+		//make sure it remains orthogonal, makes easy to read angle later
+
+		Transform light;
+		light.origin[0]=p_light_xform[2][0];
+		light.origin[1]=p_light_xform[2][1];
+		light.basis[0][0]=p_light_xform[0][0];
+		light.basis[0][1]=p_light_xform[1][0];
+		light.basis[1][0]=p_light_xform[0][1];
+		light.basis[1][1]=p_light_xform[1][1];
+
+		//light.basis.scale(Vector3(to_light.elements[0].length(),to_light.elements[1].length(),1));
+
+	///	p_near=1;
+		CameraMatrix projection;
+		{
+			real_t fov =  90;
+			real_t nearp = p_near;
+			real_t farp = p_far;
+			real_t aspect = 1.0;
+
+			real_t ymax = nearp * Math::tan( Math::deg2rad( fov * 0.5 ) );
+			real_t ymin = - ymax;
+			real_t xmin = ymin * aspect;
+			real_t xmax = ymax * aspect;
+
+			projection.set_frustum( xmin, xmax, ymin, ymax, nearp, farp );
+		}
+
+		Vector3 cam_target=Matrix3(Vector3(0,0,Math_PI*2*(i/4.0))).xform(Vector3(0,1,0));
+		projection = projection * CameraMatrix(Transform().looking_at(cam_target,Vector3(0,0,-1)).affine_inverse());
+
+		state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::PROJECTION_MATRIX,projection);
+		state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::LIGHT_MATRIX,light);
+		state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::DISTANCE_NORM,1.0/p_far);
+
+
+		if (i==0)
+			*p_xform_cache=projection;
+
+		glViewport(0, (cls->height/4)*i, cls->size,cls->height/4);
+
+		LightOccluderInstance *instance=p_occluders;
+
+		while(instance) {
+
+			RasterizerStorageGLES3::CanvasOccluder *cc = storage->canvas_occluder_owner.get(instance->polygon_buffer);
+			if (!cc || cc->len==0 || !(p_light_mask&instance->light_mask)) {
+
+				instance=instance->next;
+				continue;
+			}
+
+			state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::WORLD_MATRIX,instance->xform_cache);
+			if (cull!=instance->cull_cache) {
+
+				cull=instance->cull_cache;
+				switch(cull) {
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED: {
+
+						glDisable(GL_CULL_FACE);
+
+					} break;
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE: {
+
+						glEnable(GL_CULL_FACE);
+						glCullFace(GL_FRONT);
+					} break;
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE: {
+
+						glEnable(GL_CULL_FACE);
+						glCullFace(GL_BACK);
+
+					} break;
+				}
+			}
+/*
+			if (i==0) {
+				for(int i=0;i<cc->lines.size();i++) {
+					Vector2 p = instance->xform_cache.xform(cc->lines.get(i));
+					Plane pp(Vector3(p.x,p.y,0),1);
+					pp.normal = light.xform(pp.normal);
+					pp = projection.xform4(pp);
+					print_line(itos(i)+": "+pp.normal/pp.d);
+					//pp=light_mat.xform4(pp);
+					//print_line(itos(i)+": "+pp.normal/pp.d);
+				}
+			}
+*/
+			glBindBuffer(GL_ARRAY_BUFFER,cc->vertex_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,cc->index_id);
+			glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false, 0, 0);
+			glDrawElements(GL_TRIANGLES,cc->len*3,GL_UNSIGNED_SHORT,0);
+
+
+			instance=instance->next;
+		}
+
+
+	}
+
+	glDisableVertexAttribArray(VS::ARRAY_VERTEX);
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+}
+void RasterizerCanvasGLES3::reset_canvas() {
+
+
+	if (storage->frame.current_rt) {
+		glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
+		glColorMask(1,1,1,1); //don't touch alpha
+	}
+
+
+	glBindVertexArray(0);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+	glEnable(GL_BLEND);
+	glBlendEquation(GL_FUNC_ADD);
+	if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	//glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
+	//glLineWidth(1.0);
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+	for(int i=0;i<VS::ARRAY_MAX;i++) {
+		glDisableVertexAttribArray(i);
+	}
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture( GL_TEXTURE_2D, storage->resources.white_tex );
+
+
+	glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+
+	Transform canvas_transform;
+
+	if (storage->frame.current_rt) {
+
+		float csy = 1.0;
+		if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
+			csy = -1.0;
+		}
+		canvas_transform.translate(-(storage->frame.current_rt->width / 2.0f), -(storage->frame.current_rt->height / 2.0f), 0.0f);
+		canvas_transform.scale( Vector3( 2.0f / storage->frame.current_rt->width, csy * -2.0f / storage->frame.current_rt->height, 1.0f ) );
+	} else {
+		Vector2 ssize = OS::get_singleton()->get_window_size();
+		canvas_transform.translate(-(ssize.width / 2.0f), -(ssize.height / 2.0f), 0.0f);
+		canvas_transform.scale( Vector3( 2.0f / ssize.width, -2.0f / ssize.height, 1.0f ) );
+
+	}
+
+	state.vp=canvas_transform;
+
+	store_transform(canvas_transform,state.canvas_item_ubo_data.projection_matrix);
+	for(int i=0;i<4;i++) {
+		state.canvas_item_ubo_data.time[i]=storage->frame.time[i];
+	}
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+
+	state.canvas_texscreen_used=false;
+
+
+}
+
+
+void RasterizerCanvasGLES3::draw_generic_textured_rect(const Rect2& p_rect, const Rect2& p_src) {
+
+
+	glVertexAttrib4f(1,p_rect.pos.x,p_rect.pos.y,p_rect.size.x,p_rect.size.y);
+	glVertexAttrib4f(2,p_src.pos.x,p_src.pos.y,p_src.size.x,p_src.size.y);
+	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+}
+
+void RasterizerCanvasGLES3::initialize() {
+
+
+	{
+		//quad buffers
+
+		glGenBuffers(1,&data.canvas_quad_vertices);
+		glBindBuffer(GL_ARRAY_BUFFER,data.canvas_quad_vertices);
+		{
+			const float qv[8]={
+				0,0,
+				0,1,
+				1,1,
+				1,0
+			};
+
+			glBufferData(GL_ARRAY_BUFFER,sizeof(float)*8,qv,GL_STATIC_DRAW);
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+
+		glGenVertexArrays(1,&data.canvas_quad_array);
+		glBindVertexArray(data.canvas_quad_array);
+		glBindBuffer(GL_ARRAY_BUFFER,data.canvas_quad_vertices);
+		glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,sizeof(float)*2,0);
+		glEnableVertexAttribArray(0);
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+	}
+
+	{
+
+		glGenBuffers(1,&data.primitive_quad_buffer);
+		glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
+		glBufferData(GL_ARRAY_BUFFER,sizeof(float)*2+sizeof(float)*2+sizeof(float)*4,NULL,GL_DYNAMIC_DRAW); //allocate max size
+		glBindBuffer(GL_ARRAY_BUFFER,0);
+
+
+		for(int i=0;i<4;i++) {
+			glGenVertexArrays(1,&data.primitive_quad_buffer_arrays[i]);
+			glBindVertexArray(data.primitive_quad_buffer_arrays[i]);
+			glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
+
+			int uv_ofs=0;
+			int color_ofs=0;
+			int stride=2*4;
+
+			if (i&1) { //color
+				color_ofs=stride;
+				stride+=4*4;
+			}
+
+			if (i&2) { //uv
+				uv_ofs=stride;
+				stride+=2*4;
+			}
+
+
+			glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+			glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+0);
+
+			if (i&1) {
+				glEnableVertexAttribArray(VS::ARRAY_COLOR);
+				glVertexAttribPointer(VS::ARRAY_COLOR,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+color_ofs);
+			}
+
+			if (i&2) {
+				glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
+				glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+uv_ofs);
+			}
+
+			glBindVertexArray(0);
+		}
+	}
+
+
+	store_transform(Transform(),state.canvas_item_ubo_data.projection_matrix);
+
+
+	glGenBuffers(1, &state.canvas_item_ubo);
+	glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	state.canvas_shader.init();
+	state.canvas_shader.set_base_material_tex_index(1);
+	state.canvas_shadow_shader.init();
+
+	state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_RGBA_SHADOWS,storage->config.use_rgba_2d_shadows);
+	state.canvas_shadow_shader.set_conditional(CanvasShadowShaderGLES3::USE_RGBA_SHADOWS,storage->config.use_rgba_2d_shadows);
+
+
+}
+
+
+void RasterizerCanvasGLES3::finalize() {
+
+	glDeleteBuffers(1,&data.canvas_quad_vertices);
+	glDeleteVertexArrays(1,&data.canvas_quad_array);
+}
+
+RasterizerCanvasGLES3::RasterizerCanvasGLES3()
+{
+
+}

drivers/gles3/rasterizer_canvas_gles3.h

@@ -0,0 +1,107 @@
+#ifndef RASTERIZERCANVASGLES3_H
+#define RASTERIZERCANVASGLES3_H
+
+#include "servers/visual/rasterizer.h"
+#include "rasterizer_storage_gles3.h"
+#include "shaders/canvas_shadow.glsl.h"
+
+
+class RasterizerCanvasGLES3 : public RasterizerCanvas {
+public:
+
+	struct CanvasItemUBO {
+
+		float projection_matrix[16];
+		float time[4];
+
+	};
+
+	struct Data {
+
+		GLuint canvas_quad_vertices;
+		GLuint canvas_quad_array;
+
+		GLuint primitive_quad_buffer;
+		GLuint primitive_quad_buffer_arrays[4];
+
+	} data;
+
+	struct State {
+		CanvasItemUBO canvas_item_ubo_data;
+		GLuint canvas_item_ubo;
+		bool canvas_texscreen_used;
+		CanvasShaderGLES3 canvas_shader;
+		CanvasShadowShaderGLES3 canvas_shadow_shader;
+
+		bool using_texture_rect;
+
+
+		RID current_tex;
+		RasterizerStorageGLES3::Texture *current_tex_ptr;
+
+		Transform vp;
+
+		Color canvas_item_modulate;
+		Matrix32 extra_matrix;
+		Matrix32 final_transform;
+
+	} state;
+
+	RasterizerStorageGLES3 *storage;
+
+	struct LightInternal : public RID_Data {
+
+		struct UBOData {
+
+			float light_matrix[16];
+			float local_matrix[16];
+			float shadow_matrix[16];
+			float color[4];
+			float shadow_color[4];
+			float light_pos[2];
+			float shadowpixel_size;
+			float shadow_gradient;
+			float light_height;
+			float light_outside_alpha;
+			float shadow_distance_mult;
+		} ubo_data;
+
+		GLuint ubo;
+	};
+
+	RID_Owner<LightInternal> light_internal_owner;
+
+	virtual RID light_internal_create();
+	virtual void light_internal_update(RID p_rid, Light* p_light);
+	virtual void light_internal_free(RID p_rid);
+
+
+	virtual void canvas_begin();
+	virtual void canvas_end();
+
+	_FORCE_INLINE_ void _set_texture_rect_mode(bool p_enable);
+	_FORCE_INLINE_ RasterizerStorageGLES3::Texture* _bind_canvas_texture(const RID& p_texture);
+
+	_FORCE_INLINE_ void _draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color* p_colors, const Vector2 *p_uvs);
+	_FORCE_INLINE_ void _draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor);
+	_FORCE_INLINE_ void _canvas_item_render_commands(Item *p_item,Item *current_clip,bool &reclip);
+
+
+	virtual void canvas_render_items(Item *p_item_list,int p_z,const Color& p_modulate,Light *p_light);
+	virtual void canvas_debug_viewport_shadows(Light* p_lights_with_shadow);
+
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
+
+
+	virtual void reset_canvas();
+
+	void draw_generic_textured_rect(const Rect2& p_rect, const Rect2& p_src);
+
+
+	void initialize();
+	void finalize();
+
+	RasterizerCanvasGLES3();
+};
+
+#endif // RASTERIZERCANVASGLES3_H

drivers/gles3/rasterizer_gles3.cpp

@@ -0,0 +1,362 @@
+#include "rasterizer_gles3.h"
+#include "os/os.h"
+#include "globals.h"
+#include "gl_context/context_gl.h"
+#include <string.h>
+RasterizerStorage *RasterizerGLES3::get_storage() {
+
+	return storage;
+}
+
+RasterizerCanvas *RasterizerGLES3::get_canvas() {
+
+	return canvas;
+}
+
+RasterizerScene *RasterizerGLES3::get_scene() {
+
+	return scene;
+}
+
+#define _EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242
+#define _EXT_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243
+#define _EXT_DEBUG_CALLBACK_FUNCTION_ARB 0x8244
+#define _EXT_DEBUG_CALLBACK_USER_PARAM_ARB 0x8245
+#define _EXT_DEBUG_SOURCE_API_ARB 0x8246
+#define _EXT_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247
+#define _EXT_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248
+#define _EXT_DEBUG_SOURCE_THIRD_PARTY_ARB 0x8249
+#define _EXT_DEBUG_SOURCE_APPLICATION_ARB 0x824A
+#define _EXT_DEBUG_SOURCE_OTHER_ARB 0x824B
+#define _EXT_DEBUG_TYPE_ERROR_ARB 0x824C
+#define _EXT_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D
+#define _EXT_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E
+#define _EXT_DEBUG_TYPE_PORTABILITY_ARB 0x824F
+#define _EXT_DEBUG_TYPE_PERFORMANCE_ARB 0x8250
+#define _EXT_DEBUG_TYPE_OTHER_ARB 0x8251
+#define _EXT_MAX_DEBUG_MESSAGE_LENGTH_ARB 0x9143
+#define _EXT_MAX_DEBUG_LOGGED_MESSAGES_ARB 0x9144
+#define _EXT_DEBUG_LOGGED_MESSAGES_ARB 0x9145
+#define _EXT_DEBUG_SEVERITY_HIGH_ARB 0x9146
+#define _EXT_DEBUG_SEVERITY_MEDIUM_ARB 0x9147
+#define _EXT_DEBUG_SEVERITY_LOW_ARB 0x9148
+#define _EXT_DEBUG_OUTPUT 0x92E0
+
+#ifdef WINDOWS_ENABLED
+#define GLAPIENTRY APIENTRY
+#else
+#define GLAPIENTRY
+#endif
+
+static void GLAPIENTRY _gl_debug_print(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam)
+{
+
+	if (type==_EXT_DEBUG_TYPE_OTHER_ARB)
+		return;
+
+	print_line("mesege");
+	char debSource[256], debType[256], debSev[256];
+    if(source == _EXT_DEBUG_SOURCE_API_ARB)
+	strcpy(debSource, "OpenGL");
+    else if(source == _EXT_DEBUG_SOURCE_WINDOW_SYSTEM_ARB)
+	strcpy(debSource, "Windows");
+    else if(source == _EXT_DEBUG_SOURCE_SHADER_COMPILER_ARB)
+	strcpy(debSource, "Shader Compiler");
+    else if(source == _EXT_DEBUG_SOURCE_THIRD_PARTY_ARB)
+	strcpy(debSource, "Third Party");
+    else if(source == _EXT_DEBUG_SOURCE_APPLICATION_ARB)
+	strcpy(debSource, "Application");
+    else if(source == _EXT_DEBUG_SOURCE_OTHER_ARB)
+	strcpy(debSource, "Other");
+
+    if(type == _EXT_DEBUG_TYPE_ERROR_ARB)
+	strcpy(debType, "Error");
+    else if(type == _EXT_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB)
+	strcpy(debType, "Deprecated behavior");
+    else if(type == _EXT_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB)
+	strcpy(debType, "Undefined behavior");
+    else if(type == _EXT_DEBUG_TYPE_PORTABILITY_ARB)
+	strcpy(debType, "Portability");
+    else if(type == _EXT_DEBUG_TYPE_PERFORMANCE_ARB)
+	strcpy(debType, "Performance");
+    else if(type == _EXT_DEBUG_TYPE_OTHER_ARB)
+	strcpy(debType, "Other");
+
+    if(severity == _EXT_DEBUG_SEVERITY_HIGH_ARB)
+	strcpy(debSev, "High");
+    else if(severity == _EXT_DEBUG_SEVERITY_MEDIUM_ARB)
+	strcpy(debSev, "Medium");
+    else if(severity == _EXT_DEBUG_SEVERITY_LOW_ARB)
+	strcpy(debSev, "Low");
+
+	String output = String()+ "GL ERROR: Source: " + debSource + "\tType: " + debType + "\tID: " + itos(id) + "\tSeverity: " + debSev + "\tMessage: " + message;
+
+	ERR_PRINTS(output);
+
+}
+
+
+typedef void (*DEBUGPROCARB)(GLenum source,
+					     GLenum type,
+					     GLuint id,
+					     GLenum severity,
+					     GLsizei length,
+					     const char* message,
+					     const void* userParam);
+
+typedef void (* DebugMessageCallbackARB) (DEBUGPROCARB callback, const void *userParam);
+
+void RasterizerGLES3::initialize() {
+
+	if (OS::get_singleton()->is_stdout_verbose()) {
+		print_line("Using GLES3 video driver");
+	}
+
+#ifdef GLEW_ENABLED
+	GLuint res = glewInit();
+	ERR_FAIL_COND(res!=GLEW_OK);
+	if (OS::get_singleton()->is_stdout_verbose()) {
+		print_line(String("GLES2: Using GLEW ") + (const char*) glewGetString(GLEW_VERSION));
+	}
+
+	// Check for GL 2.1 compatibility, if not bail out
+	if (!glewIsSupported("GL_VERSION_3_0")) {
+		ERR_PRINT("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
+			  "Try a drivers update, buy a new GPU or try software rendering on Linux; Godot will now crash with a segmentation fault.");
+		OS::get_singleton()->alert("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
+					   "Godot Engine will self-destruct as soon as you acknowledge this error message.",
+					   "Fatal error: Insufficient OpenGL / GLES drivers");
+		// TODO: If it's even possible, we should stop the execution without segfault and memory leaks :)
+	}
+#endif
+
+#ifdef GLAD_ENABLED
+
+	if(!gladLoadGL()) {
+		ERR_PRINT("Error initializing GLAD");
+	}
+
+	glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+	glDebugMessageCallbackARB(_gl_debug_print, NULL);
+	glEnable(_EXT_DEBUG_OUTPUT);
+
+#endif
+
+
+/*	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_ERROR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PORTABILITY_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PERFORMANCE_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_OTHER_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+	glDebugMessageInsertARB(
+
+			GL_DEBUG_SOURCE_API_ARB,
+			GL_DEBUG_TYPE_OTHER_ARB, 1,
+			GL_DEBUG_SEVERITY_HIGH_ARB,5, "hello");
+
+*/
+	storage->initialize();
+	canvas->initialize();
+	scene->initialize();
+}
+
+void RasterizerGLES3::begin_frame(){
+
+	uint64_t tick = OS::get_singleton()->get_ticks_usec();
+
+	double time_total = double(tick)/1000000.0;
+
+	storage->frame.time[0]=time_total;
+	storage->frame.time[1]=Math::fmod(time_total,3600);
+	storage->frame.time[2]=Math::fmod(time_total,900);
+	storage->frame.time[3]=Math::fmod(time_total,60);
+	storage->frame.count++;
+	storage->frame.delta = double(tick-storage->frame.prev_tick)/1000000.0;
+	if (storage->frame.prev_tick==0) {
+		//to avoid hiccups
+		storage->frame.delta=0.001;
+	}
+
+	storage->frame.prev_tick=tick;
+
+
+
+	storage->update_dirty_multimeshes();
+	storage->update_dirty_skeletons();
+	storage->update_dirty_shaders();
+	storage->update_dirty_materials();
+	storage->update_particles();
+
+	storage->info.render_object_count=0;
+	storage->info.render_material_switch_count=0;
+	storage->info.render_surface_switch_count=0;
+	storage->info.render_shader_rebind_count=0;
+	storage->info.render_vertices_count=0;
+
+
+	scene->iteration();
+
+
+
+
+}
+
+void RasterizerGLES3::set_current_render_target(RID p_render_target){
+
+	if (!p_render_target.is_valid() && storage->frame.current_rt && storage->frame.clear_request) {
+		//handle pending clear request, if the framebuffer was not cleared
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+		print_line("unbind clear of: "+storage->frame.clear_request_color);
+		glClearColor(
+			storage->frame.clear_request_color.r,
+			storage->frame.clear_request_color.g,
+			storage->frame.clear_request_color.b,
+			storage->frame.clear_request_color.a );
+
+		glClear(GL_COLOR_BUFFER_BIT);
+
+	}
+
+	if (p_render_target.is_valid()) {
+		RasterizerStorageGLES3::RenderTarget * rt = storage->render_target_owner.getornull(p_render_target);
+		if (!rt) {
+			storage->frame.current_rt=NULL;
+		}
+		ERR_FAIL_COND(!rt);
+		storage->frame.current_rt=rt;
+		storage->frame.clear_request=false;
+
+		glViewport(0,0,rt->width,rt->height);				
+
+	} else {
+		storage->frame.current_rt=NULL;
+		storage->frame.clear_request=false;
+		glViewport(0,0,OS::get_singleton()->get_window_size().width,OS::get_singleton()->get_window_size().height);
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->config.system_fbo);
+	}
+}
+
+void RasterizerGLES3::restore_render_target() {
+
+	ERR_FAIL_COND(storage->frame.current_rt==NULL);
+	RasterizerStorageGLES3::RenderTarget * rt = storage->frame.current_rt;
+	glBindFramebuffer(GL_FRAMEBUFFER,rt->fbo);
+	glViewport(0,0,rt->width,rt->height);
+
+}
+
+void RasterizerGLES3::clear_render_target(const Color& p_color) {
+
+	ERR_FAIL_COND(!storage->frame.current_rt);
+
+	storage->frame.clear_request=true;
+	storage->frame.clear_request_color=p_color;
+
+}
+
+void RasterizerGLES3::blit_render_target_to_screen(RID p_render_target,const Rect2& p_screen_rect,int p_screen){
+
+	ERR_FAIL_COND( storage->frame.current_rt );
+
+	RasterizerStorageGLES3::RenderTarget *rt = storage->render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+
+	canvas->canvas_begin();
+	glDisable(GL_BLEND);
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->config.system_fbo);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,rt->color);
+	canvas->draw_generic_textured_rect(p_screen_rect,Rect2(0,0,1,-1));
+	glBindTexture(GL_TEXTURE_2D,0);
+	canvas->canvas_end();
+}
+
+void RasterizerGLES3::end_frame(){
+
+#if 0
+	canvas->canvas_begin();
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+	glDisable(GL_BLEND);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+
+
+	float vtx[8]={0,0,
+	0,1,
+	1,1,
+	1,0
+	};
+
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+
+	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+	glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, 0, vtx );
+
+
+//	glBindBuffer(GL_ARRAY_BUFFER,canvas->data.canvas_quad_vertices);
+//	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+//	glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, 0, 0 );
+
+	glBindVertexArray(canvas->data.canvas_quad_array);
+
+	canvas->draw_generic_textured_rect(Rect2(0,0,15,15),Rect2(0,0,1,1));
+#endif
+	OS::get_singleton()->swap_buffers();
+
+/*	print_line("objects: "+itos(storage->info.render_object_count));
+	print_line("material chages: "+itos(storage->info.render_material_switch_count));
+	print_line("surface changes: "+itos(storage->info.render_surface_switch_count));
+	print_line("shader changes: "+itos(storage->info.render_shader_rebind_count));
+	print_line("vertices: "+itos(storage->info.render_vertices_count));
+*/
+}
+
+void RasterizerGLES3::finalize(){
+
+	storage->finalize();
+	canvas->finalize();
+}
+
+
+Rasterizer *RasterizerGLES3::_create_current() {
+
+	return memnew( RasterizerGLES3 );
+}
+
+void RasterizerGLES3::make_current() {
+	_create_func=_create_current;
+}
+
+
+void RasterizerGLES3::register_config() {
+
+	GLOBAL_DEF("rendering/gles3/render_architecture",0);
+	Globals::get_singleton()->set_custom_property_info("rendering/gles3/render_architecture",PropertyInfo(Variant::INT,"",PROPERTY_HINT_ENUM,"Desktop,Mobile"));
+	GLOBAL_DEF("rendering/gles3/use_nearest_mipmap_filter",false);
+	GLOBAL_DEF("rendering/gles3/anisotropic_filter_level",4.0);
+
+}
+
+RasterizerGLES3::RasterizerGLES3()
+{
+
+	storage = memnew( RasterizerStorageGLES3 );
+	canvas = memnew( RasterizerCanvasGLES3 );
+	scene = memnew( RasterizerSceneGLES3 );
+	canvas->storage=storage;
+	storage->canvas=canvas;
+	scene->storage=storage;
+	storage->scene=scene;
+
+
+
+}
+
+RasterizerGLES3::~RasterizerGLES3() {
+
+	memdelete(storage);
+	memdelete(canvas);
+}

drivers/gles3/rasterizer_gles3.h

@@ -0,0 +1,41 @@
+#ifndef RASTERIZERGLES3_H
+#define RASTERIZERGLES3_H
+
+#include "servers/visual/rasterizer.h"
+#include "rasterizer_storage_gles3.h"
+#include "rasterizer_canvas_gles3.h"
+#include "rasterizer_scene_gles3.h"
+
+
+class RasterizerGLES3 : public Rasterizer {
+
+	static Rasterizer *_create_current();
+
+	RasterizerStorageGLES3 *storage;
+	RasterizerCanvasGLES3 *canvas;
+	RasterizerSceneGLES3 *scene;
+
+public:
+
+	virtual RasterizerStorage *get_storage();
+	virtual RasterizerCanvas *get_canvas();
+	virtual RasterizerScene *get_scene();
+
+	virtual void initialize();
+	virtual void begin_frame();
+	virtual void set_current_render_target(RID p_render_target);
+	virtual void restore_render_target();
+	virtual void clear_render_target(const Color& p_color);
+	virtual void blit_render_target_to_screen(RID p_render_target,const Rect2& p_screen_rect,int p_screen=0);
+	virtual void end_frame();
+	virtual void finalize();
+
+	static void make_current();
+
+
+	static void register_config();
+	RasterizerGLES3();
+	~RasterizerGLES3();
+};
+
+#endif // RASTERIZERGLES3_H

drivers/gles3/rasterizer_scene_gles3.cpp

@@ -0,0 +1,5008 @@
+#include "rasterizer_scene_gles3.h"
+#include "globals.h"
+#include "os/os.h"
+#include "rasterizer_canvas_gles3.h"
+
+static const GLenum _cube_side_enum[6]={
+
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+
+};
+
+
+static _FORCE_INLINE_ void store_matrix32(const Matrix32& p_mtx, float* p_array) {
+
+	p_array[ 0]=p_mtx.elements[0][0];
+	p_array[ 1]=p_mtx.elements[0][1];
+	p_array[ 2]=0;
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.elements[1][0];
+	p_array[ 5]=p_mtx.elements[1][1];
+	p_array[ 6]=0;
+	p_array[ 7]=0;
+	p_array[ 8]=0;
+	p_array[ 9]=0;
+	p_array[10]=1;
+	p_array[11]=0;
+	p_array[12]=p_mtx.elements[2][0];
+	p_array[13]=p_mtx.elements[2][1];
+	p_array[14]=0;
+	p_array[15]=1;
+}
+
+
+static _FORCE_INLINE_ void store_transform(const Transform& p_mtx, float* p_array) {
+	p_array[ 0]=p_mtx.basis.elements[0][0];
+	p_array[ 1]=p_mtx.basis.elements[1][0];
+	p_array[ 2]=p_mtx.basis.elements[2][0];
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.basis.elements[0][1];
+	p_array[ 5]=p_mtx.basis.elements[1][1];
+	p_array[ 6]=p_mtx.basis.elements[2][1];
+	p_array[ 7]=0;
+	p_array[ 8]=p_mtx.basis.elements[0][2];
+	p_array[ 9]=p_mtx.basis.elements[1][2];
+	p_array[10]=p_mtx.basis.elements[2][2];
+	p_array[11]=0;
+	p_array[12]=p_mtx.origin.x;
+	p_array[13]=p_mtx.origin.y;
+	p_array[14]=p_mtx.origin.z;
+	p_array[15]=1;
+}
+
+static _FORCE_INLINE_ void store_camera(const CameraMatrix& p_mtx, float* p_array) {
+
+	for (int i=0;i<4;i++) {
+		for (int j=0;j<4;j++) {
+
+			p_array[i*4+j]=p_mtx.matrix[i][j];
+		}
+	}
+}
+
+/* SHADOW ATLAS API */
+
+RID RasterizerSceneGLES3::shadow_atlas_create() {
+
+	ShadowAtlas *shadow_atlas = memnew( ShadowAtlas );
+	shadow_atlas->fbo=0;
+	shadow_atlas->depth=0;
+	shadow_atlas->size=0;
+	shadow_atlas->smallest_subdiv=0;
+
+	for(int i=0;i<4;i++) {
+		shadow_atlas->size_order[i]=i;
+	}
+
+
+	return shadow_atlas_owner.make_rid(shadow_atlas);
+}
+
+void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
+
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ERR_FAIL_COND(!shadow_atlas);
+	ERR_FAIL_COND(p_size<0);
+
+	p_size = nearest_power_of_2(p_size);
+
+	if (p_size==shadow_atlas->size)
+		return;
+
+	if (shadow_atlas->fbo) {
+		glDeleteTextures(1,&shadow_atlas->depth);
+		glDeleteFramebuffers(1,&shadow_atlas->fbo);
+
+		shadow_atlas->depth=0;
+		shadow_atlas->fbo=0;
+
+		print_line("erasing atlas");
+	}
+	for(int i=0;i<4;i++) {
+		//clear subdivisions
+		shadow_atlas->quadrants[i].shadows.resize(0);
+		shadow_atlas->quadrants[i].shadows.resize( 1<<shadow_atlas->quadrants[i].subdivision );
+	}
+
+	//erase shadow atlas reference from lights
+	for (Map<RID,uint32_t>::Element *E=shadow_atlas->shadow_owners.front();E;E=E->next()) {
+		LightInstance *li = light_instance_owner.getornull(E->key());
+		ERR_CONTINUE(!li);
+		li->shadow_atlases.erase(p_atlas);
+	}
+
+	//clear owners
+	shadow_atlas->shadow_owners.clear();
+
+	shadow_atlas->size=p_size;
+
+	if (shadow_atlas->size)	{
+		glGenFramebuffers(1, &shadow_atlas->fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, shadow_atlas->fbo);
+
+		// Create a texture for storing the depth
+		glActiveTexture(GL_TEXTURE0);
+		glGenTextures(1, &shadow_atlas->depth);
+		glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_atlas->size, shadow_atlas->size, 0,
+			     GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+				       GL_TEXTURE_2D, shadow_atlas->depth, 0);
+
+		glViewport(0,0,shadow_atlas->size,shadow_atlas->size);
+		glClearDepth(0);
+		glClear(GL_DEPTH_BUFFER_BIT);
+
+	}
+}
+
+
+void RasterizerSceneGLES3::shadow_atlas_set_quadrant_subdivision(RID p_atlas,int p_quadrant,int p_subdivision){
+
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ERR_FAIL_COND(!shadow_atlas);
+	ERR_FAIL_INDEX(p_quadrant,4);
+	ERR_FAIL_INDEX(p_subdivision,16384);
+
+
+	uint32_t subdiv = nearest_power_of_2(p_subdivision);
+	if (subdiv&0xaaaaaaaa) { //sqrt(subdiv) must be integer
+		subdiv<<=1;
+	}
+
+	subdiv=int(Math::sqrt(subdiv));
+
+	//obtain the number that will be x*x
+
+	if (shadow_atlas->quadrants[p_quadrant].subdivision==subdiv)
+		return;
+
+	//erase all data from quadrant
+	for(int i=0;i<shadow_atlas->quadrants[p_quadrant].shadows.size();i++) {
+
+		if (shadow_atlas->quadrants[p_quadrant].shadows[i].owner.is_valid()) {
+			shadow_atlas->shadow_owners.erase(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
+			LightInstance *li = light_instance_owner.getornull(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
+			ERR_CONTINUE(!li);
+			li->shadow_atlases.erase(p_atlas);
+		}
+	}
+
+	shadow_atlas->quadrants[p_quadrant].shadows.resize(0);
+	shadow_atlas->quadrants[p_quadrant].shadows.resize(subdiv*subdiv);
+	shadow_atlas->quadrants[p_quadrant].subdivision=subdiv;
+
+	//cache the smallest subdiv (for faster allocation in light update)
+
+	shadow_atlas->smallest_subdiv=1<<30;
+
+	for(int i=0;i<4;i++) {
+		if (shadow_atlas->quadrants[i].subdivision) {
+			shadow_atlas->smallest_subdiv=MIN(shadow_atlas->smallest_subdiv,shadow_atlas->quadrants[i].subdivision);
+		}
+	}
+
+	if (shadow_atlas->smallest_subdiv==1<<30) {
+		shadow_atlas->smallest_subdiv=0;
+	}
+
+	//resort the size orders, simple bublesort for 4 elements..
+
+	int swaps=0;
+	do {
+		swaps=0;
+
+		for(int i=0;i<3;i++) {
+			if (shadow_atlas->quadrants[shadow_atlas->size_order[i]].subdivision < shadow_atlas->quadrants[shadow_atlas->size_order[i+1]].subdivision) {
+				SWAP(shadow_atlas->size_order[i],shadow_atlas->size_order[i+1]);
+				swaps++;
+			}
+		}
+	} while(swaps>0);
+
+
+
+
+
+}
+
+bool RasterizerSceneGLES3::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas,int *p_in_quadrants,int p_quadrant_count,int p_current_subdiv,uint64_t p_tick,int &r_quadrant,int &r_shadow) {
+
+
+	for(int i=p_quadrant_count-1;i>=0;i--) {
+
+		int qidx = p_in_quadrants[i];
+
+		if (shadow_atlas->quadrants[qidx].subdivision==p_current_subdiv) {
+			return false;
+		}
+
+		//look for an empty space
+		int sc = shadow_atlas->quadrants[qidx].shadows.size();
+		ShadowAtlas::Quadrant::Shadow *sarr = shadow_atlas->quadrants[qidx].shadows.ptr();
+
+		int found_free_idx=-1; //found a free one
+		int found_used_idx=-1; //found existing one, must steal it
+		uint64_t min_pass; // pass of the existing one, try to use the least recently used one (LRU fashion)
+
+		for(int j=0;j<sc;j++) {
+			if (!sarr[j].owner.is_valid()) {
+				found_free_idx=j;
+				break;
+			}
+
+			LightInstance *sli = light_instance_owner.getornull(sarr[j].owner);
+			ERR_CONTINUE(!sli);
+
+			if (sli->last_scene_pass!=scene_pass) {
+
+				//was just allocated, don't kill it so soon, wait a bit..
+				if (p_tick-sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec)
+					continue;
+
+				if (found_used_idx==-1 || sli->last_scene_pass<min_pass) {
+					found_used_idx=j;
+					min_pass=sli->last_scene_pass;
+				}
+			}
+		}
+
+		if (found_free_idx==-1 && found_used_idx==-1)
+			continue; //nothing found
+
+		if (found_free_idx==-1 && found_used_idx!=-1) {
+			found_free_idx=found_used_idx;
+		}
+
+		r_quadrant=qidx;
+		r_shadow=found_free_idx;
+
+		return true;
+	}
+
+	return false;
+
+}
+
+
+bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version){
+
+
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ERR_FAIL_COND_V(!shadow_atlas,false);
+
+	LightInstance *li = light_instance_owner.getornull(p_light_intance);
+	ERR_FAIL_COND_V(!li,false);
+
+	if (shadow_atlas->size==0 || shadow_atlas->smallest_subdiv==0) {
+		return false;
+	}
+
+	uint32_t quad_size = shadow_atlas->size>>1;
+	int desired_fit = MIN(quad_size/shadow_atlas->smallest_subdiv,nearest_power_of_2(quad_size*p_coverage));
+
+
+	int valid_quadrants[4];
+	int valid_quadrant_count=0;
+	int best_size=-1; //best size found
+	int best_subdiv=-1; //subdiv for the best size
+
+	//find the quadrants this fits into, and the best possible size it can fit into
+	for(int i=0;i<4;i++) {
+		int q = shadow_atlas->size_order[i];
+		int sd = shadow_atlas->quadrants[q].subdivision;
+		if (sd==0)
+			continue; //unused
+
+		int max_fit = quad_size / sd;
+
+		if (best_size!=-1 && max_fit>best_size)
+			break; //too large
+
+		valid_quadrants[valid_quadrant_count++]=q;
+		best_subdiv=sd;
+
+		if (max_fit>=desired_fit) {
+			best_size=max_fit;
+		}
+	}
+
+	ERR_FAIL_COND_V(valid_quadrant_count==0,false);
+
+	uint64_t tick = OS::get_singleton()->get_ticks_msec();
+
+
+	//see if it already exists
+
+	if (shadow_atlas->shadow_owners.has(p_light_intance)) {
+		//it does!
+		uint32_t key = shadow_atlas->shadow_owners[p_light_intance];
+		uint32_t q = (key>>ShadowAtlas::QUADRANT_SHIFT)&0x3;
+		uint32_t s = key&ShadowAtlas::SHADOW_INDEX_MASK;
+
+		bool should_realloc=shadow_atlas->quadrants[q].subdivision!=best_subdiv && (shadow_atlas->quadrants[q].shadows[s].alloc_tick-tick > shadow_atlas_realloc_tolerance_msec);
+		bool should_redraw=shadow_atlas->quadrants[q].shadows[s].version!=p_light_version;
+
+
+
+		if (!should_realloc) {
+			shadow_atlas->quadrants[q].shadows[s].version=p_light_version;
+			//already existing, see if it should redraw or it's just OK
+			return should_redraw;
+		}
+
+		int new_quadrant,new_shadow;
+
+		//find a better place
+		if (_shadow_atlas_find_shadow(shadow_atlas,valid_quadrants,valid_quadrant_count,shadow_atlas->quadrants[q].subdivision,tick,new_quadrant,new_shadow)) {
+			//found a better place!
+			ShadowAtlas::Quadrant::Shadow *sh = &shadow_atlas->quadrants[new_quadrant].shadows[new_shadow];
+			if (sh->owner.is_valid()) {
+				//is taken, but is invalid, erasing it
+				shadow_atlas->shadow_owners.erase(sh->owner);
+				LightInstance *sli = light_instance_owner.get(sh->owner);
+				sli->shadow_atlases.erase(p_atlas);
+			}
+
+			//erase previous
+			shadow_atlas->quadrants[q].shadows[s].version=0;
+			shadow_atlas->quadrants[q].shadows[s].owner=RID();
+
+			sh->owner=p_light_intance;
+			sh->alloc_tick=tick;
+			sh->version=p_light_version;
+
+			//make new key
+			key=new_quadrant<<ShadowAtlas::QUADRANT_SHIFT;
+			key|=new_shadow;
+			//update it in map
+			shadow_atlas->shadow_owners[p_light_intance]=key;
+			//make it dirty, as it should redraw anyway
+			return true;
+		}
+
+		//no better place for this shadow found, keep current
+
+		//already existing, see if it should redraw or it's just OK
+
+		shadow_atlas->quadrants[q].shadows[s].version=p_light_version;
+
+		return should_redraw;
+	}
+
+	int new_quadrant,new_shadow;
+
+	//find a better place
+	if (_shadow_atlas_find_shadow(shadow_atlas,valid_quadrants,valid_quadrant_count,-1,tick,new_quadrant,new_shadow)) {
+		//found a better place!
+		ShadowAtlas::Quadrant::Shadow *sh = &shadow_atlas->quadrants[new_quadrant].shadows[new_shadow];
+		if (sh->owner.is_valid()) {
+			//is taken, but is invalid, erasing it
+			shadow_atlas->shadow_owners.erase(sh->owner);
+			LightInstance *sli = light_instance_owner.get(sh->owner);
+			sli->shadow_atlases.erase(p_atlas);
+		}
+
+		sh->owner=p_light_intance;
+		sh->alloc_tick=tick;
+		sh->version=p_light_version;
+
+		//make new key
+		uint32_t key=new_quadrant<<ShadowAtlas::QUADRANT_SHIFT;
+		key|=new_shadow;
+		//update it in map
+		shadow_atlas->shadow_owners[p_light_intance]=key;
+		//make it dirty, as it should redraw anyway
+
+		return true;
+	}
+
+	//no place to allocate this light, apologies
+
+	return false;
+
+
+
+
+}
+
+void RasterizerSceneGLES3::set_directional_shadow_count(int p_count) {
+
+	directional_shadow.light_count=p_count;
+	directional_shadow.current_light=0;
+}
+
+int RasterizerSceneGLES3::get_directional_light_shadow_size(RID p_light_intance) {
+
+	ERR_FAIL_COND_V(directional_shadow.light_count==0,0);
+
+	int shadow_size;
+
+	if (directional_shadow.light_count==1) {
+		shadow_size = directional_shadow.size;
+	} else {
+		shadow_size = directional_shadow.size/2; //more than 4 not supported anyway
+	}
+
+	LightInstance *light_instance = light_instance_owner.getornull(p_light_intance);
+	ERR_FAIL_COND_V(!light_instance,0);
+
+	switch(light_instance->light_ptr->directional_shadow_mode) {
+		case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: break; //none
+		case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS:
+		case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: shadow_size/=2; break;
+	}
+
+	return shadow_size;
+
+}
+//////////////////////////////////////////////////////
+
+RID RasterizerSceneGLES3::reflection_atlas_create() {
+
+	ReflectionAtlas *reflection_atlas = memnew( ReflectionAtlas );
+	reflection_atlas->subdiv=0;
+	reflection_atlas->color=0;
+	reflection_atlas->size=0;
+	for(int i=0;i<6;i++) {
+		reflection_atlas->fbo[i]=0;
+	}
+
+	return reflection_atlas_owner.make_rid(reflection_atlas);
+}
+
+void RasterizerSceneGLES3::reflection_atlas_set_size(RID p_ref_atlas,int p_size) {
+
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_ref_atlas);
+	ERR_FAIL_COND(!reflection_atlas);
+
+	int size = nearest_power_of_2(p_size);
+
+	if (size==reflection_atlas->size)
+		return;
+	if (reflection_atlas->size) {
+		for(int i=0;i<6;i++) {
+			glDeleteFramebuffers(1,&reflection_atlas->fbo[i]);
+			reflection_atlas->fbo[i]=0;
+		}
+		glDeleteTextures(1,&reflection_atlas->color);
+		reflection_atlas->color=0;
+	}
+
+	reflection_atlas->size=size;
+
+	for(int i=0;i<reflection_atlas->reflections.size();i++) {
+		//erase probes reference to this
+		if (reflection_atlas->reflections[i].owner.is_valid()) {
+			ReflectionProbeInstance *reflection_probe_instance = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[i].owner);
+			reflection_atlas->reflections[i].owner=RID();
+
+			ERR_CONTINUE(!reflection_probe_instance);
+			reflection_probe_instance->reflection_atlas_index=-1;
+			reflection_probe_instance->atlas=RID();
+			reflection_probe_instance->render_step=-1;
+		}
+	}
+
+
+	if (reflection_atlas->size) {
+
+		bool use_float=true;
+
+
+		GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+		GLenum format = GL_RGBA;
+		GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+
+
+		// Create a texture for storing the color
+		glActiveTexture(GL_TEXTURE0);
+		glGenTextures(1, &reflection_atlas->color);
+		glBindTexture(GL_TEXTURE_2D, reflection_atlas->color);
+
+		int mmsize=reflection_atlas->size;
+
+		for(int i=0;i<6;i++) {
+			glTexImage2D(GL_TEXTURE_2D, i, internal_format, mmsize, mmsize, 0,
+				     format, type, NULL);
+
+			mmsize>>=1;
+		}
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 5);
+
+		mmsize=reflection_atlas->size;
+
+		for(int i=0;i<6;i++) {
+			glGenFramebuffers(1, &reflection_atlas->fbo[i]);
+			glBindFramebuffer(GL_FRAMEBUFFER, reflection_atlas->fbo[i]);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  reflection_atlas->color, i);
+
+			GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+			ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+
+			glDisable(GL_SCISSOR_TEST);
+			glViewport(0,0,mmsize,mmsize);
+			glClearColor(0,0,0,0);
+			glClear(GL_COLOR_BUFFER_BIT); //it needs to be cleared, to avoid generating garbage
+
+			mmsize>>=1;
+
+		}
+
+
+	}
+
+
+
+}
+void RasterizerSceneGLES3::reflection_atlas_set_subdivision(RID p_ref_atlas,int p_subdiv) {
+
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_ref_atlas);
+	ERR_FAIL_COND(!reflection_atlas);
+
+	uint32_t subdiv = nearest_power_of_2(p_subdiv);
+	if (subdiv&0xaaaaaaaa) { //sqrt(subdiv) must be integer
+		subdiv<<=1;
+	}
+
+	subdiv=int(Math::sqrt(subdiv));
+
+	if (reflection_atlas->subdiv==subdiv)
+		return;
+
+
+	if (subdiv) {
+
+		for(int i=0;i<reflection_atlas->reflections.size();i++) {
+			//erase probes reference to this
+			if (reflection_atlas->reflections[i].owner.is_valid()) {
+				ReflectionProbeInstance *reflection_probe_instance = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[i].owner);
+				reflection_atlas->reflections[i].owner=RID();
+
+				ERR_CONTINUE(!reflection_probe_instance);
+				reflection_probe_instance->reflection_atlas_index=-1;
+				reflection_probe_instance->atlas=RID();
+				reflection_probe_instance->render_step=-1;
+			}
+		}
+	}
+
+	reflection_atlas->subdiv=subdiv;
+
+	reflection_atlas->reflections.resize(subdiv*subdiv);
+}
+
+
+////////////////////////////////////////////////////
+
+RID RasterizerSceneGLES3::reflection_probe_instance_create(RID p_probe) {
+
+	RasterizerStorageGLES3::ReflectionProbe *probe = storage->reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!probe,RID());
+
+	ReflectionProbeInstance *rpi = memnew( ReflectionProbeInstance );
+
+	rpi->probe_ptr=probe;
+	rpi->self=reflection_probe_instance_owner.make_rid(rpi);
+	rpi->probe=p_probe;
+	rpi->reflection_atlas_index=-1;
+	rpi->render_step=-1;
+	rpi->last_pass=0;
+
+	return rpi->self;
+}
+
+void RasterizerSceneGLES3::reflection_probe_instance_set_transform(RID p_instance,const Transform& p_transform) {
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND(!rpi);
+	rpi->transform=p_transform;
+
+}
+
+void RasterizerSceneGLES3::reflection_probe_release_atlas_index(RID p_instance) {
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND(!rpi);
+	if (rpi->reflection_atlas_index==-1)
+		return;
+
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ERR_FAIL_COND(!reflection_atlas);
+
+	ERR_FAIL_INDEX(rpi->reflection_atlas_index,reflection_atlas->reflections.size());
+
+	ERR_FAIL_COND(reflection_atlas->reflections[rpi->reflection_atlas_index].owner!=rpi->self);
+
+	reflection_atlas->reflections[rpi->reflection_atlas_index].owner=RID();
+
+	rpi->reflection_atlas_index=-1;
+	rpi->atlas=RID();
+	rpi->render_step=-1;
+
+}
+
+bool RasterizerSceneGLES3::reflection_probe_instance_needs_redraw(RID p_instance) {
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND_V(!rpi,false);
+
+	return rpi->reflection_atlas_index==-1 || rpi->probe_ptr->update_mode==VS::REFLECTION_PROBE_UPDATE_ALWAYS;
+}
+
+bool RasterizerSceneGLES3::reflection_probe_instance_has_reflection(RID p_instance){
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND_V(!rpi,false);
+
+	return rpi->reflection_atlas_index!=-1;
+}
+
+bool RasterizerSceneGLES3::reflection_probe_instance_begin_render(RID p_instance,RID p_reflection_atlas) {
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND_V(!rpi,false);
+
+	rpi->render_step=0;
+
+	if (rpi->reflection_atlas_index!=-1) {
+		return true; //got one already
+	}
+
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
+	ERR_FAIL_COND_V(!reflection_atlas,false);
+
+
+	if (reflection_atlas->size==0 || reflection_atlas->subdiv==0) {
+		return false;
+	}
+
+
+	int best_free=-1;
+	int best_used=-1;
+	uint64_t best_used_frame;
+
+	for(int i=0;i<reflection_atlas->reflections.size();i++) {
+		if (reflection_atlas->reflections[i].owner==RID()) {
+			best_free=i;
+			break;
+		}
+
+		if (rpi->render_step<0 && reflection_atlas->reflections[i].last_frame<storage->frame.count &&
+				(best_used==-1 || reflection_atlas->reflections[i].last_frame<best_used_frame)) {
+				best_used=i;
+			best_used_frame=reflection_atlas->reflections[i].last_frame;
+		}
+	}
+
+	if (best_free==-1 && best_used==-1) {
+		return false ;// sorry, can not do. Try again next frame.
+	}
+
+	if (best_free==-1) {
+		//find best from what is used
+		best_free=best_used;
+
+		ReflectionProbeInstance *victim_rpi = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[best_free].owner);
+		ERR_FAIL_COND_V(!victim_rpi,false);
+		victim_rpi->atlas=RID();
+		victim_rpi->reflection_atlas_index=-1;
+
+	}
+
+	reflection_atlas->reflections[best_free].owner=p_instance;
+	reflection_atlas->reflections[best_free].last_frame=storage->frame.count;
+
+	rpi->reflection_atlas_index=best_free;
+	rpi->atlas=p_reflection_atlas;
+	rpi->render_step=0;
+
+	return true;
+}
+
+bool RasterizerSceneGLES3::reflection_probe_instance_postprocess_step(RID p_instance) {
+
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ERR_FAIL_COND_V(!rpi,true);
+
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ERR_FAIL_COND_V(!reflection_atlas,false);
+
+	ERR_FAIL_COND_V(rpi->render_step>=6,true);
+
+	glBindFramebuffer(GL_FRAMEBUFFER,reflection_atlas->fbo[rpi->render_step]);
+	state.cube_to_dp_shader.bind();
+
+	int target_size=reflection_atlas->size/reflection_atlas->subdiv;
+
+	int cubemap_index=reflection_cubemaps.size()-1;
+
+	for(int i=reflection_cubemaps.size()-1;i>=0;i--) {
+		//find appropriate cubemap to render to
+		if (reflection_cubemaps[i].size>target_size*2)
+			break;
+
+		cubemap_index=i;
+	}
+
+	glDisable(GL_BLEND);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_CUBE_MAP,reflection_cubemaps[cubemap_index].cubemap);
+	glDisable(GL_CULL_FACE);
+
+	storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true);
+	storage->shaders.cubemap_filter.bind();
+
+	int cell_size = reflection_atlas->size / reflection_atlas->subdiv;
+	for(int i=0;i<rpi->render_step;i++) {
+		cell_size>>=1; //mipmaps!
+	}
+	int x = (rpi->reflection_atlas_index % reflection_atlas->subdiv) * cell_size;
+	int y = (rpi->reflection_atlas_index / reflection_atlas->subdiv) * cell_size;
+	int width=cell_size;
+	int height=cell_size;
+
+	storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE,rpi->render_step==0);
+	storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY,rpi->probe_ptr->update_mode==VS::REFLECTION_PROBE_UPDATE_ALWAYS);
+	for(int i=0;i<2;i++) {
+
+		storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP,i>0);
+		storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,rpi->render_step/5.0);
+
+		uint32_t local_width=width,local_height=height;
+		uint32_t local_x=x,local_y=y;
+
+		local_height/=2;
+		local_y+=i*local_height;
+
+		glViewport(local_x,local_y,local_width,local_height);
+
+		_copy_screen();
+	}
+	storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE,false);
+	storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY,false);
+
+
+	rpi->render_step++;
+
+	return rpi->render_step==6;
+}
+
+/* ENVIRONMENT API */
+
+RID RasterizerSceneGLES3::environment_create(){
+
+
+	Environment *env = memnew( Environment );
+
+	return environment_owner.make_rid(env);
+}
+
+void RasterizerSceneGLES3::environment_set_background(RID p_env,VS::EnvironmentBG p_bg){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+	env->bg_mode=p_bg;
+}
+
+void RasterizerSceneGLES3::environment_set_skybox(RID p_env, RID p_skybox){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->skybox=p_skybox;
+
+}
+
+void RasterizerSceneGLES3::environment_set_skybox_scale(RID p_env,float p_scale) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->skybox_scale=p_scale;
+
+}
+
+void RasterizerSceneGLES3::environment_set_bg_color(RID p_env,const Color& p_color){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->bg_color=p_color;
+
+}
+void RasterizerSceneGLES3::environment_set_bg_energy(RID p_env,float p_energy) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->bg_energy=p_energy;
+
+}
+
+void RasterizerSceneGLES3::environment_set_canvas_max_layer(RID p_env,int p_max_layer){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->canvas_max_layer=p_max_layer;
+
+}
+void RasterizerSceneGLES3::environment_set_ambient_light(RID p_env, const Color& p_color, float p_energy, float p_skybox_contribution){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->ambient_color=p_color;
+	env->ambient_energy=p_energy;
+	env->ambient_skybox_contribution=p_skybox_contribution;
+
+}
+
+
+
+void RasterizerSceneGLES3::environment_set_dof_blur_far(RID p_env,bool p_enable,float p_distance,float p_transition,float p_amount,VS::EnvironmentDOFBlurQuality p_quality){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->dof_blur_far_enabled=p_enable;
+	env->dof_blur_far_distance=p_distance;
+	env->dof_blur_far_transition=p_transition;
+	env->dof_blur_far_amount=p_amount;
+	env->dof_blur_far_quality=p_quality;
+
+
+}
+
+void RasterizerSceneGLES3::environment_set_dof_blur_near(RID p_env,bool p_enable,float p_distance,float p_transition,float p_amount,VS::EnvironmentDOFBlurQuality p_quality){
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->dof_blur_near_enabled=p_enable;
+	env->dof_blur_near_distance=p_distance;
+	env->dof_blur_near_transition=p_transition;
+	env->dof_blur_near_amount=p_amount;
+	env->dof_blur_near_quality=p_quality;
+
+
+}
+void RasterizerSceneGLES3::environment_set_glow(RID p_env, bool p_enable, int p_level_flags, float p_intensity, float p_strength, float p_bloom_treshold, VS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_treshold, float p_hdr_bleed_scale, bool p_bicubic_upscale) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->glow_enabled=p_enable;
+	env->glow_levels=p_level_flags;
+	env->glow_intensity=p_intensity;
+	env->glow_strength=p_strength;
+	env->glow_bloom=p_bloom_treshold;
+	env->glow_blend_mode=p_blend_mode;
+	env->glow_hdr_bleed_treshold=p_hdr_bleed_treshold;
+	env->glow_hdr_bleed_scale=p_hdr_bleed_scale;
+	env->glow_bicubic_upscale=p_bicubic_upscale;
+
+}
+void RasterizerSceneGLES3::environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture){
+
+}
+
+void RasterizerSceneGLES3::environment_set_ssr(RID p_env,bool p_enable, int p_max_steps,float p_accel,float p_fade,float p_depth_tolerance,bool p_smooth,bool p_roughness) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->ssr_enabled=p_enable;
+	env->ssr_max_steps=p_max_steps;
+	env->ssr_accel=p_accel;
+	env->ssr_fade=p_fade;
+	env->ssr_depth_tolerance=p_depth_tolerance;
+	env->ssr_smooth=p_smooth;
+	env->ssr_roughness=p_roughness;
+
+}
+
+
+void RasterizerSceneGLES3::environment_set_ssao(RID p_env,bool p_enable, float p_radius, float p_intensity, float p_radius2, float p_intensity2, float p_bias, float p_light_affect,const Color &p_color,bool p_blur) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+	env->ssao_enabled=p_enable;
+	env->ssao_radius=p_radius;
+	env->ssao_intensity=p_intensity;
+	env->ssao_radius2=p_radius2;
+	env->ssao_intensity2=p_intensity2;
+	env->ssao_bias=p_bias;
+	env->ssao_light_affect=p_light_affect;
+	env->ssao_color=p_color;
+	env->ssao_filter=p_blur;
+
+}
+
+void RasterizerSceneGLES3::environment_set_tonemap(RID p_env,VS::EnvironmentToneMapper p_tone_mapper,float p_exposure,float p_white,bool p_auto_exposure,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,float p_auto_exp_scale) {
+
+	Environment *env=environment_owner.getornull(p_env);
+	ERR_FAIL_COND(!env);
+
+
+	env->tone_mapper=p_tone_mapper;
+	env->tone_mapper_exposure=p_exposure;
+	env->tone_mapper_exposure_white=p_white;
+	env->auto_exposure=p_auto_exposure;
+	env->auto_exposure_speed=p_auto_exp_speed;
+	env->auto_exposure_min=p_min_luminance;
+	env->auto_exposure_max=p_max_luminance;
+	env->auto_exposure_grey=p_auto_exp_scale;
+
+}
+
+
+void RasterizerSceneGLES3::environment_set_adjustment(RID p_env,bool p_enable,float p_brightness,float p_contrast,float p_saturation,RID p_ramp) {
+
+
+}
+
+
+RID RasterizerSceneGLES3::light_instance_create(RID p_light) {
+
+
+	LightInstance *light_instance = memnew( LightInstance );
+
+	light_instance->last_pass=0;
+	light_instance->last_scene_pass=0;
+	light_instance->last_scene_shadow_pass=0;
+
+	light_instance->light=p_light;
+	light_instance->light_ptr=storage->light_owner.getornull(p_light);
+
+	ERR_FAIL_COND_V(!light_instance->light_ptr,RID());
+
+	light_instance->self=light_instance_owner.make_rid(light_instance);
+
+	return light_instance->self;
+}
+
+void RasterizerSceneGLES3::light_instance_set_transform(RID p_light_instance,const Transform& p_transform){
+
+	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	ERR_FAIL_COND(!light_instance);
+
+	light_instance->transform=p_transform;
+}
+
+void RasterizerSceneGLES3::light_instance_set_shadow_transform(RID p_light_instance,const CameraMatrix& p_projection,const Transform& p_transform,float p_far,float p_split,int p_pass) {
+
+	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	ERR_FAIL_COND(!light_instance);
+
+	if (light_instance->light_ptr->type!=VS::LIGHT_DIRECTIONAL) {
+		p_pass=0;
+	}
+
+	ERR_FAIL_INDEX(p_pass,4);
+
+	light_instance->shadow_transform[p_pass].camera=p_projection;
+	light_instance->shadow_transform[p_pass].transform=p_transform;
+	light_instance->shadow_transform[p_pass].farplane=p_far;
+	light_instance->shadow_transform[p_pass].split=p_split;
+
+}
+
+
+void RasterizerSceneGLES3::light_instance_mark_visible(RID p_light_instance) {
+
+	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	ERR_FAIL_COND(!light_instance);
+
+	light_instance->last_scene_pass=scene_pass;
+}
+
+
+//////////////////////
+
+RID RasterizerSceneGLES3::gi_probe_instance_create() {
+
+	GIProbeInstance *gipi = memnew(GIProbeInstance);
+
+	return gi_probe_instance_owner.make_rid(gipi);
+}
+
+void RasterizerSceneGLES3::gi_probe_instance_set_light_data(RID p_probe, RID p_base, RID p_data) {
+
+	GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gipi);
+	gipi->data=p_data;
+	gipi->probe=storage->gi_probe_owner.getornull(p_base);
+	if (p_data.is_valid()) {
+		RasterizerStorageGLES3::GIProbeData *gipd = storage->gi_probe_data_owner.getornull(p_data);
+		ERR_FAIL_COND(!gipd);
+		if (gipd) {
+			gipi->tex_cache=gipd->tex_id;
+			gipi->cell_size_cache.x=1.0/gipd->width;
+			gipi->cell_size_cache.y=1.0/gipd->height;
+			gipi->cell_size_cache.z=1.0/gipd->depth;
+		}
+	}
+}
+void RasterizerSceneGLES3::gi_probe_instance_set_transform_to_data(RID p_probe,const Transform& p_xform) {
+
+	GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gipi);
+	gipi->transform_to_data=p_xform;
+
+}
+
+void RasterizerSceneGLES3::gi_probe_instance_set_bounds(RID p_probe,const Vector3& p_bounds) {
+
+	GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gipi);
+	gipi->bounds=p_bounds;
+
+}
+
+////////////////////////////
+////////////////////////////
+////////////////////////////
+
+bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass) {
+
+	if (p_material->shader->spatial.cull_mode==RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_DISABLED) {
+		glDisable(GL_CULL_FACE);
+	} else {
+		glEnable(GL_CULL_FACE);
+	}
+
+	if (state.current_line_width!=p_material->line_width) {
+		//glLineWidth(MAX(p_material->line_width,1.0));
+		state.current_line_width=p_material->line_width;
+	}
+
+	if (state.current_depth_draw!=p_material->shader->spatial.depth_draw_mode) {
+		switch(p_material->shader->spatial.depth_draw_mode) {
+			case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS:
+			case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_OPAQUE: {
+
+				glDepthMask(!p_alpha_pass);
+			} break;
+			case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALWAYS: {
+				glDepthMask(GL_TRUE);
+			} break;
+			case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_NEVER: {
+				glDepthMask(GL_FALSE);
+			} break;
+		}
+
+		state.current_depth_draw=p_material->shader->spatial.depth_draw_mode;
+	}
+
+	//glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
+
+	/*
+	if (p_material->flags[VS::MATERIAL_FLAG_WIREFRAME])
+		glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
+	else
+		glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
+	*/
+
+	//if (p_material->line_width)
+	//	glLineWidth(p_material->line_width);
+
+#if 0
+	//blend mode
+	if (state.current_blend_mode!=p_material->shader->spatial.blend_mode) {
+
+		switch(p_material->shader->spatial.blend_mode) {
+
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX: {
+				glBlendEquation(GL_FUNC_ADD);
+				if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+				} else {
+					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				}
+
+			 } break;
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD: {
+
+				glBlendEquation(GL_FUNC_ADD);
+				glBlendFunc(p_alpha_pass?GL_SRC_ALPHA:GL_ONE,GL_ONE);
+
+			 } break;
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_SUB: {
+
+				glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+				glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+			 } break;
+			case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MUL: {
+				glBlendEquation(GL_FUNC_ADD);
+				if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+				} else {
+					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				}
+
+			} break;
+		}
+
+		state.current_blend_mode=p_material->shader->spatial.blend_mode;
+
+	}
+#endif
+	//material parameters
+
+
+	state.scene_shader.set_custom_shader(p_material->shader->custom_code_id);
+	bool rebind = state.scene_shader.bind();
+
+
+	if (p_material->ubo_id) {
+
+		glBindBufferBase(GL_UNIFORM_BUFFER,1,p_material->ubo_id);
+	}
+
+
+
+	int tc = p_material->textures.size();
+	RID* textures = p_material->textures.ptr();
+	ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = p_material->shader->texture_hints.ptr();
+
+	state.current_main_tex=0;
+
+	for(int i=0;i<tc;i++) {
+
+		glActiveTexture(GL_TEXTURE0+i);
+
+		GLenum target;
+		GLuint tex;
+
+		RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
+
+		if (!t) {
+			//check hints
+			target=GL_TEXTURE_2D;
+
+			switch(texture_hints[i]) {
+				case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
+				case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
+					tex=storage->resources.black_tex;
+				} break;
+				case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
+					tex=storage->resources.aniso_tex;
+				} break;
+				case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
+					tex=storage->resources.normal_tex;
+				} break;
+				default: {
+					tex=storage->resources.white_tex;
+				} break;
+			}
+
+
+		} else {
+
+			if (storage->config.srgb_decode_supported) {
+				//if SRGB decode extension is present, simply switch the texture to whathever is needed
+				bool must_srgb=false;
+
+				if (t->srgb && (texture_hints[i]==ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || texture_hints[i]==ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO)) {
+					must_srgb=true;
+				}
+
+				if (t->using_srgb!=must_srgb) {
+					if (must_srgb) {
+						glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+#ifdef TOOLS_ENABLED
+						if (!(t->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+							t->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+							//notify that texture must be set to linear beforehand, so it works in other platforms when exported
+						}
+#endif
+
+					} else {
+						glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
+					}
+					t->using_srgb=must_srgb;
+				}
+			}
+
+			target=t->target;
+			tex = t->tex_id;
+
+		}
+
+		glBindTexture(target,tex);
+
+		if (i==0) {
+			state.current_main_tex=tex;
+		}
+	}
+
+
+	return rebind;
+
+}
+
+
+void RasterizerSceneGLES3::_setup_geometry(RenderList::Element *e) {
+
+	switch(e->instance->base_type) {
+
+		case VS::INSTANCE_MESH: {
+
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+
+			if (s->morph_targets.size() && e->instance->morph_values.size()) {
+				//blend shapes, use transform feedback
+				storage->mesh_render_blend_shapes(s,e->instance->morph_values.ptr());
+				//rebind shader
+				state.scene_shader.bind();
+			} else {
+
+				glBindVertexArray(s->array_id); // everything is so easy nowadays
+			}
+
+		} break;
+
+		case VS::INSTANCE_MULTIMESH: {
+
+			RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh*>(e->owner);
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+			glBindVertexArray(s->instancing_array_id); // use the instancing array ID
+			glBindBuffer(GL_ARRAY_BUFFER,multi_mesh->buffer); //modify the buffer
+
+			int stride = (multi_mesh->xform_floats+multi_mesh->color_floats)*4;
+			glEnableVertexAttribArray(8);
+			glVertexAttribPointer(8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+0);
+			glVertexAttribDivisor(8,1);
+			glEnableVertexAttribArray(9);
+			glVertexAttribPointer(9,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+4*4);
+			glVertexAttribDivisor(9,1);
+
+			int color_ofs;
+
+			if (multi_mesh->transform_format==VS::MULTIMESH_TRANSFORM_3D) {
+				glEnableVertexAttribArray(10);
+				glVertexAttribPointer(10,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+8*4);
+				glVertexAttribDivisor(10,1);
+				color_ofs=12*4;
+			} else {
+				glDisableVertexAttribArray(10);
+				glVertexAttrib4f(10,0,0,1,0);
+				color_ofs=8*4;
+			}
+
+			switch(multi_mesh->color_format) {
+
+				case VS::MULTIMESH_COLOR_NONE: {
+					glDisableVertexAttribArray(11);
+					glVertexAttrib4f(11,1,1,1,1);
+				} break;
+				case VS::MULTIMESH_COLOR_8BIT: {
+					glEnableVertexAttribArray(11);
+					glVertexAttribPointer(11,4,GL_UNSIGNED_BYTE,GL_TRUE,stride,((uint8_t*)NULL)+color_ofs);
+					glVertexAttribDivisor(11,1);
+
+				} break;
+				case VS::MULTIMESH_COLOR_FLOAT: {
+					glEnableVertexAttribArray(11);
+					glVertexAttribPointer(11,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+color_ofs);
+					glVertexAttribDivisor(11,1);
+				} break;
+			}
+
+		} break;
+	}
+
+}
+
+static const GLenum gl_primitive[]={
+	GL_POINTS,
+	GL_LINES,
+	GL_LINE_STRIP,
+	GL_LINE_LOOP,
+	GL_TRIANGLES,
+	GL_TRIANGLE_STRIP,
+	GL_TRIANGLE_FAN
+};
+
+
+
+void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
+
+	switch(e->instance->base_type) {
+
+		case VS::INSTANCE_MESH: {
+
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+
+			if (s->index_array_len>0) {
+
+
+				glDrawElements(gl_primitive[s->primitive],s->index_array_len, (s->array_len>=(1<<16))?GL_UNSIGNED_INT:GL_UNSIGNED_SHORT,0);
+
+				storage->info.render_vertices_count+=s->index_array_len;
+
+			} else {
+
+				glDrawArrays(gl_primitive[s->primitive],0,s->array_len);
+
+				storage->info.render_vertices_count+=s->array_len;
+
+			}
+
+
+
+
+		} break;
+		case VS::INSTANCE_MULTIMESH: {
+
+			RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh*>(e->owner);
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+
+			int amount = MAX(multi_mesh->size,multi_mesh->visible_instances);
+
+			if (s->index_array_len>0) {
+
+				glDrawElementsInstanced(gl_primitive[s->primitive],s->index_array_len, (s->array_len>=(1<<16))?GL_UNSIGNED_INT:GL_UNSIGNED_SHORT,0,amount);
+
+				storage->info.render_vertices_count+=s->index_array_len * amount;
+
+			} else {
+
+				glDrawArraysInstanced(gl_primitive[s->primitive],0,s->array_len,amount);
+
+				storage->info.render_vertices_count+=s->array_len * amount;
+
+			}
+
+		} break;
+		case VS::INSTANCE_IMMEDIATE: {
+
+			bool restore_tex=false;
+			const RasterizerStorageGLES3::Immediate *im = static_cast<const RasterizerStorageGLES3::Immediate*>( e->geometry );
+
+			if (im->building) {
+				return;
+			}
+
+			glBindBuffer(GL_ARRAY_BUFFER, state.immediate_buffer);
+			glBindVertexArray(state.immediate_array);
+
+
+			for(const List< RasterizerStorageGLES3::Immediate::Chunk>::Element *E=im->chunks.front();E;E=E->next()) {
+
+				const  RasterizerStorageGLES3::Immediate::Chunk &c=E->get();
+				if (c.vertices.empty()) {
+					continue;
+				}
+
+				int vertices = c.vertices.size();
+				uint32_t buf_ofs=0;
+
+				storage->info.render_vertices_count+=vertices;
+
+				if (c.texture.is_valid() && storage->texture_owner.owns(c.texture)) {
+
+					const RasterizerStorageGLES3::Texture *t = storage->texture_owner.get(c.texture);
+					glActiveTexture(GL_TEXTURE0);
+					glBindTexture(t->target,t->tex_id);
+					restore_tex=true;
+
+
+				} else if (restore_tex) {
+
+					glActiveTexture(GL_TEXTURE0);
+					glBindTexture(GL_TEXTURE_2D,state.current_main_tex);
+					restore_tex=false;
+				}
+
+
+
+				if (!c.normals.empty()) {
+
+					glEnableVertexAttribArray(VS::ARRAY_NORMAL);
+					glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*vertices,c.normals.ptr());
+					glVertexAttribPointer(VS::ARRAY_NORMAL, 3, GL_FLOAT, false,sizeof(Vector3)*vertices,((uint8_t*)NULL)+buf_ofs);
+					buf_ofs+=sizeof(Vector3)*vertices;
+
+				} else {
+
+					glDisableVertexAttribArray(VS::ARRAY_NORMAL);
+				}
+
+				if (!c.tangents.empty()) {
+
+					glEnableVertexAttribArray(VS::ARRAY_TANGENT);
+					glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Plane)*vertices,c.tangents.ptr());
+					glVertexAttribPointer(VS::ARRAY_TANGENT, 4, GL_FLOAT, false,sizeof(Plane)*vertices,((uint8_t*)NULL)+buf_ofs);
+					buf_ofs+=sizeof(Plane)*vertices;
+
+				} else {
+
+					glDisableVertexAttribArray(VS::ARRAY_TANGENT);
+				}
+
+				if (!c.colors.empty()) {
+
+					glEnableVertexAttribArray(VS::ARRAY_COLOR);
+					glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Color)*vertices,c.colors.ptr());
+					glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, false,sizeof(Color),((uint8_t*)NULL)+buf_ofs);
+					buf_ofs+=sizeof(Color)*vertices;
+
+				} else {
+
+					glDisableVertexAttribArray(VS::ARRAY_COLOR);
+					glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+				}
+
+
+				if (!c.uvs.empty()) {
+
+					glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
+					glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector2)*vertices,c.uvs.ptr());
+					glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, false,sizeof(Vector2),((uint8_t*)NULL)+buf_ofs);
+					buf_ofs+=sizeof(Vector2)*vertices;
+
+				} else {
+
+					glDisableVertexAttribArray(VS::ARRAY_TEX_UV);
+				}
+
+				if (!c.uvs2.empty()) {
+
+					glEnableVertexAttribArray(VS::ARRAY_TEX_UV2);
+					glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector2)*vertices,c.uvs2.ptr());
+					glVertexAttribPointer(VS::ARRAY_TEX_UV2, 2, GL_FLOAT, false,sizeof(Vector2),((uint8_t*)NULL)+buf_ofs);
+					buf_ofs+=sizeof(Vector2)*vertices;
+
+				} else {
+
+					glDisableVertexAttribArray(VS::ARRAY_TEX_UV2);
+				}
+
+
+				glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+				glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*vertices,c.vertices.ptr());
+				glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false,sizeof(Vector3),((uint8_t*)NULL)+buf_ofs);
+				glDrawArrays(gl_primitive[c.primitive],0,c.vertices.size());
+
+
+			}
+
+
+			if (restore_tex) {
+
+				glActiveTexture(GL_TEXTURE0);
+				glBindTexture(GL_TEXTURE_2D,state.current_main_tex);
+				restore_tex=false;
+			}
+		} break;
+
+	}
+
+}
+
+void RasterizerSceneGLES3::_setup_light(RenderList::Element *e,const Transform& p_view_transform) {
+
+	int omni_indices[16];
+	int omni_count=0;
+	int spot_indices[16];
+	int spot_count=0;
+	int reflection_indices[16];
+	int reflection_count=0;
+
+	int maxobj = MIN(16,state.max_forward_lights_per_object);
+
+	int lc =  e->instance->light_instances.size();
+	if (lc) {
+
+		const RID* lights=e->instance->light_instances.ptr();
+
+		for(int i=0;i<lc;i++) {
+			LightInstance *li=light_instance_owner.getptr(lights[i]);
+			if (li->last_pass!=render_pass) //not visible
+				continue;
+
+			if (li->light_ptr->type==VS::LIGHT_OMNI) {
+				if (omni_count<maxobj && e->instance->layer_mask&li->light_ptr->cull_mask) {
+					omni_indices[omni_count++]=li->light_index;
+				}
+			}
+
+			if (li->light_ptr->type==VS::LIGHT_SPOT) {
+				if (spot_count<maxobj && e->instance->layer_mask&li->light_ptr->cull_mask) {
+					spot_indices[spot_count++]=li->light_index;
+				}
+			}
+		}
+	}
+
+	state.scene_shader.set_uniform(SceneShaderGLES3::OMNI_LIGHT_COUNT,omni_count);
+
+	if (omni_count) {
+		glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::OMNI_LIGHT_INDICES),omni_count,omni_indices);
+	}
+
+	state.scene_shader.set_uniform(SceneShaderGLES3::SPOT_LIGHT_COUNT,spot_count);
+	if (spot_count) {
+		glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::SPOT_LIGHT_INDICES),spot_count,spot_indices);
+	}
+
+
+	int rc = e->instance->reflection_probe_instances.size();
+
+
+	if (rc) {
+
+
+		const RID* reflections=e->instance->reflection_probe_instances.ptr();
+
+		for(int i=0;i<rc;i++) {
+			ReflectionProbeInstance *rpi=reflection_probe_instance_owner.getptr(reflections[i]);
+			if (rpi->last_pass!=render_pass) //not visible
+				continue;
+
+			if (reflection_count<maxobj) {
+				reflection_indices[reflection_count++]=rpi->reflection_index;
+			}
+		}
+	}
+
+	state.scene_shader.set_uniform(SceneShaderGLES3::REFLECTION_COUNT,reflection_count);
+	if (reflection_count) {
+		glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::REFLECTION_INDICES),reflection_count,reflection_indices);
+	}
+
+	int gi_probe_count = e->instance->gi_probe_instances.size();
+	if (gi_probe_count) {
+		const RID * ridp = e->instance->gi_probe_instances.ptr();
+
+		GIProbeInstance *gipi = gi_probe_instance_owner.getptr(ridp[0]);
+
+		glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-6);
+		glBindTexture(GL_TEXTURE_3D,gipi->tex_cache);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_XFORM1, gipi->transform_to_data * p_view_transform);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BOUNDS1, gipi->bounds);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_MULTIPLIER1, gipi->probe?gipi->probe->dynamic_range*gipi->probe->energy:0.0);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BLEND_AMBIENT1, gipi->probe?!gipi->probe->interior:false);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_CELL_SIZE1, gipi->cell_size_cache);
+		if (gi_probe_count>1) {
+
+			GIProbeInstance *gipi2 = gi_probe_instance_owner.getptr(ridp[1]);
+
+			glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-7);
+			glBindTexture(GL_TEXTURE_3D,gipi2->tex_cache);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_XFORM2, gipi2->transform_to_data * p_view_transform);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BOUNDS2, gipi2->bounds);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_CELL_SIZE2, gipi2->cell_size_cache);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_MULTIPLIER2, gipi2->probe?gipi2->probe->dynamic_range*gipi2->probe->energy:0.0);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BLEND_AMBIENT2, gipi2->probe?!gipi2->probe->interior:false);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE2_ENABLED, true );
+		} else {
+
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE2_ENABLED, false );
+		}
+	}
+}
+
+
+void RasterizerSceneGLES3::_setup_transform(InstanceBase *p_instance,const Transform& p_view_transform,const CameraMatrix& p_projection) {
+
+	if (p_instance->billboard || p_instance->billboard_y || p_instance->depth_scale) {
+
+		Transform xf=p_instance->transform;
+		if (p_instance->depth_scale) {
+
+			if (p_projection.matrix[3][3]) {
+				//orthogonal matrix, try to do about the same
+				//with viewport size
+				//real_t w = Math::abs( 1.0/(2.0*(p_projection.matrix[0][0])) );
+				real_t h = Math::abs( 1.0/(2.0*p_projection.matrix[1][1]) );
+				float sc = (h*2.0); //consistent with Y-fov
+				xf.basis.scale( Vector3(sc,sc,sc));
+			} else {
+				//just scale by depth
+				real_t sc = Plane(p_view_transform.origin,-p_view_transform.get_basis().get_axis(2)).distance_to(xf.origin);
+				xf.basis.scale( Vector3(sc,sc,sc));
+			}
+		}
+
+		if (p_instance->billboard && storage->frame.current_rt) {
+
+			Vector3 scale = xf.basis.get_scale();
+
+			if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
+				xf.set_look_at(xf.origin, xf.origin + p_view_transform.get_basis().get_axis(2), -p_view_transform.get_basis().get_axis(1));
+			} else {
+				xf.set_look_at(xf.origin, xf.origin + p_view_transform.get_basis().get_axis(2), p_view_transform.get_basis().get_axis(1));
+			}
+
+			xf.basis.scale(scale);
+		}
+
+		if (p_instance->billboard_y && storage->frame.current_rt) {
+
+			Vector3 scale = xf.basis.get_scale();
+			Vector3 look_at =  p_view_transform.get_origin();
+			look_at.y = 0.0;
+			Vector3 look_at_norm = look_at.normalized();
+
+			if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
+				xf.set_look_at(xf.origin,xf.origin + look_at_norm, Vector3(0.0, -1.0, 0.0));
+			} else {
+				xf.set_look_at(xf.origin,xf.origin + look_at_norm, Vector3(0.0, 1.0, 0.0));
+			}
+			xf.basis.scale(scale);
+		}
+		state.scene_shader.set_uniform(SceneShaderGLES3::WORLD_TRANSFORM, xf);
+
+	} else {
+		state.scene_shader.set_uniform(SceneShaderGLES3::WORLD_TRANSFORM, p_instance->transform);
+	}
+}
+
+void RasterizerSceneGLES3::_set_cull(bool p_front,bool p_reverse_cull) {
+
+	bool front = p_front;
+	if (p_reverse_cull)
+		front=!front;
+
+	if (front!=state.cull_front) {
+
+		glCullFace(front?GL_FRONT:GL_BACK);
+		state.cull_front=front;
+	}
+}
+
+
+
+void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements,int p_element_count,const Transform& p_view_transform,const CameraMatrix& p_projection,GLuint p_base_env,bool p_reverse_cull,bool p_alpha_pass,bool p_shadow,bool p_directional_add,bool p_directional_shadows) {
+
+	if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
+		//p_reverse_cull=!p_reverse_cull;
+		glFrontFace(GL_CCW);
+	} else {
+		glFrontFace(GL_CW);
+	}
+
+	glBindBufferBase(GL_UNIFORM_BUFFER,0,state.scene_ubo); //bind globals ubo
+
+
+	if (!p_shadow && !p_directional_add) {
+		glBindBufferBase(GL_UNIFORM_BUFFER,2,state.env_radiance_ubo); //bind environment radiance info
+		glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-1);
+		glBindTexture(GL_TEXTURE_2D,state.brdf_texture);
+
+		if (p_base_env) {
+			glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-2);
+			glBindTexture(GL_TEXTURE_2D,p_base_env);
+			state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,true);
+		} else {
+			state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
+
+		}
+	} else {
+
+		state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
+	}
+
+
+	state.cull_front=false;
+	glCullFace(GL_BACK);
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,false);
+
+	state.current_blend_mode=-1;
+	state.current_line_width=-1;
+	state.current_depth_draw=-1;
+
+	RasterizerStorageGLES3::Material* prev_material=NULL;
+	RasterizerStorageGLES3::Geometry* prev_geometry=NULL;
+	VS::InstanceType prev_base_type = VS::INSTANCE_MAX;
+
+	int current_blend_mode=-1;
+
+	int prev_shading=-1;
+	RID prev_skeleton;
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true); //by default unshaded (easier to set)
+
+	bool first=true;
+
+	storage->info.render_object_count+=p_element_count;
+
+	for (int i=0;i<p_element_count;i++) {
+
+		RenderList::Element *e = p_elements[i];
+		RasterizerStorageGLES3::Material* material= e->material;
+		RID skeleton = e->instance->skeleton;
+
+		bool rebind=first;
+
+		int shading = (e->sort_key>>RenderList::SORT_KEY_SHADING_SHIFT)&RenderList::SORT_KEY_SHADING_MASK;
+
+		if (!p_shadow) {
+
+
+
+			if (p_directional_add) {
+				if (e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG || !(e->instance->layer_mask&directional_light->light_ptr->cull_mask)) {
+					continue;
+				}
+
+				shading&=~1; //ignore the ignore directional for base pass
+			}
+
+			if (shading!=prev_shading) {
+
+				if (e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG) {
+
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true);
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,false);
+
+
+
+					//state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true);
+				} else {
+
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,e->instance->gi_probe_instances.size()>0);
+
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,!p_directional_add);
+					state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,shadow_filter_mode==SHADOW_FILTER_PCF5);
+					state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,shadow_filter_mode==SHADOW_FILTER_PCF13);
+
+
+					if (p_directional_add || (directional_light && (e->sort_key&RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG)==0)) {
+						state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,true);
+
+						if (p_directional_shadows && directional_light->light_ptr->shadow) {
+							state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,true);
+
+							switch(directional_light->light_ptr->directional_shadow_mode) {
+								case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: break; //none
+								case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS:
+									state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,true);
+									state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,directional_light->light_ptr->directional_blend_splits);
+								break;
+								case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS:
+									state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,true);
+									state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,directional_light->light_ptr->directional_blend_splits);
+								break;
+							}
+						}
+
+					}
+
+				}
+
+
+
+				rebind=true;
+			}
+
+
+			if (p_alpha_pass || p_directional_add) {
+				int desired_blend_mode;
+				if (p_directional_add) {
+					desired_blend_mode=RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD;
+				} else {
+					desired_blend_mode=material->shader->spatial.blend_mode;
+				}
+
+				if (desired_blend_mode!=current_blend_mode) {
+
+
+					switch(desired_blend_mode) {
+
+						 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX: {
+							glBlendEquation(GL_FUNC_ADD);
+							if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+								glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+							}
+							else {
+								glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+							}
+
+						 } break;
+						 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD: {
+
+							glBlendEquation(GL_FUNC_ADD);
+							glBlendFunc(p_alpha_pass?GL_SRC_ALPHA:GL_ONE,GL_ONE);
+
+						 } break;
+						 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_SUB: {
+
+							glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+							glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+						 } break;
+						case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MUL: {
+							glBlendEquation(GL_FUNC_ADD);
+							if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+								glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+							}
+							else {
+								glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+							}
+
+						} break;
+
+					}
+
+					current_blend_mode=desired_blend_mode;
+				}
+
+			}
+
+
+		}
+
+		if (prev_skeleton!=skeleton) {
+			if (prev_skeleton.is_valid() != skeleton.is_valid()) {
+				state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,skeleton.is_valid());
+				rebind=true;
+			}
+			if (skeleton.is_valid()) {
+				RasterizerStorageGLES3::Skeleton *sk = storage->skeleton_owner.getornull(skeleton);
+				if (sk->size) {
+					glBindBufferBase(GL_UNIFORM_BUFFER,7,sk->ubo);
+				}
+			}
+		}
+
+		if ((prev_base_type==VS::INSTANCE_MULTIMESH) != (e->instance->base_type==VS::INSTANCE_MULTIMESH)) {
+			state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING,e->instance->base_type==VS::INSTANCE_MULTIMESH);
+			rebind=true;
+		}
+
+		if (material!=prev_material || rebind) {
+
+			storage->info.render_material_switch_count++;
+
+			rebind = _setup_material(material,p_alpha_pass);
+
+			if (rebind) {
+				storage->info.render_shader_rebind_count++;
+			}
+		}
+
+		if (!(e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG) && !p_directional_add && !p_shadow) {
+			_setup_light(e,p_view_transform);
+
+		}
+
+
+		if (prev_base_type != e->instance->base_type || prev_geometry!=e->geometry) {
+
+			_setup_geometry(e);
+			storage->info.render_surface_switch_count++;
+
+		}
+
+		_set_cull(e->sort_key&RenderList::SORT_KEY_MIRROR_FLAG,p_reverse_cull);
+
+		state.scene_shader.set_uniform(SceneShaderGLES3::NORMAL_MULT, e->instance->mirror?-1.0:1.0);
+
+		_setup_transform(e->instance,p_view_transform,p_projection);
+
+		_render_geometry(e);
+
+		prev_material=material;
+		prev_base_type=e->instance->base_type;
+		prev_geometry=e->geometry;
+		prev_shading=shading;
+		prev_skeleton=skeleton;
+		first=false;
+
+	}
+
+
+
+	glFrontFace(GL_CW);
+	glBindVertexArray(0);
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,false);
+
+}
+
+
+void RasterizerSceneGLES3::_add_geometry(  RasterizerStorageGLES3::Geometry* p_geometry,  InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material,bool p_shadow) {
+
+	RasterizerStorageGLES3::Material *m=NULL;
+	RID m_src=p_instance->material_override.is_valid() ? p_instance->material_override :(p_material>=0?p_instance->materials[p_material]:p_geometry->material);
+
+
+/*
+#ifdef DEBUG_ENABLED
+	if (current_debug==VS::SCENARIO_DEBUG_OVERDRAW) {
+		m_src=overdraw_material;
+	}
+
+#endif
+*/
+
+	if (m_src.is_valid()) {
+		m=storage->material_owner.getornull( m_src );
+
+		if (!m->shader) {
+			m=NULL;
+		}
+	}
+
+	if (!m) {
+		m=storage->material_owner.getptr( default_material );
+	}
+
+	ERR_FAIL_COND(!m);
+
+
+
+	bool has_base_alpha=(m->shader->spatial.uses_alpha);
+	bool has_blend_alpha=m->shader->spatial.blend_mode!=RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX || m->shader->spatial.ontop;
+	bool has_alpha = has_base_alpha || has_blend_alpha;
+	bool shadow = false;
+
+	bool mirror = p_instance->mirror;
+
+	if (m->shader->spatial.cull_mode==RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_FRONT) {
+		mirror=!mirror;
+	}
+
+	if (m->shader->spatial.uses_sss) {
+		state.used_sss=true;
+	}
+
+	if (p_shadow) {
+
+		if (has_blend_alpha || (has_base_alpha && m->shader->spatial.depth_draw_mode!=RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
+			return; //bye
+
+		if (!m->shader->spatial.uses_vertex && !m->shader->spatial.uses_discard && m->shader->spatial.depth_draw_mode!=RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+			//shader does not use discard and does not write a vertex position, use generic material
+			if (p_instance->cast_shadows == VS::SHADOW_CASTING_SETTING_DOUBLE_SIDED)
+				m = storage->material_owner.getptr(default_material_twosided);
+			else
+				m = storage->material_owner.getptr(default_material);
+		}
+
+		has_alpha=false;
+
+	}
+
+
+
+	RenderList::Element *e = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
+
+	if (!e)
+		return;
+
+	e->geometry=p_geometry;
+	e->material=m;
+	e->instance=p_instance;
+	e->owner=p_owner;
+	e->sort_key=0;
+
+	if (e->geometry->last_pass!=render_pass) {
+		e->geometry->last_pass=render_pass;
+		e->geometry->index=current_geometry_index++;
+	}
+
+	if (!p_shadow && directional_light && (directional_light->light_ptr->cull_mask&e->instance->layer_mask)==0) {
+		e->sort_key|=RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG;
+	}
+
+	e->sort_key|=uint64_t(e->geometry->index)<<RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
+	e->sort_key|=uint64_t(e->instance->base_type)<<RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
+
+	if (!p_shadow) {
+
+
+		if (e->material->last_pass!=render_pass) {
+			e->material->last_pass=render_pass;
+			e->material->index=current_material_index++;
+		}
+
+		e->sort_key|=uint64_t(e->material->index)<<RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
+		e->sort_key|=uint64_t(e->instance->depth_layer)<<RenderList::SORT_KEY_DEPTH_LAYER_SHIFT;
+
+		if (!has_blend_alpha && has_alpha && m->shader->spatial.depth_draw_mode==RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+
+			//if nothing exists, add this element as opaque too
+			RenderList::Element *oe = render_list.add_element();
+
+			if (!oe)
+				return;
+
+			copymem(oe,e,sizeof(RenderList::Element));
+		}
+
+		if (e->instance->gi_probe_instances.size()) {
+			e->sort_key|=RenderList::SORT_KEY_GI_PROBES_FLAG;
+		}
+	}
+
+	//if (e->geometry->type==RasterizerStorageGLES3::Geometry::GEOMETRY_MULTISURFACE)
+	//	e->sort_flags|=RenderList::SORT_FLAG_INSTANCING;
+
+
+	if (mirror) {
+		e->sort_key|=RenderList::SORT_KEY_MIRROR_FLAG;
+	}
+
+	//e->light_type=0xFF; // no lights!
+
+	if (shadow || m->shader->spatial.unshaded /*|| current_debug==VS::SCENARIO_DEBUG_SHADELESS*/) {
+
+		e->sort_key|=RenderList::SORT_KEY_UNSHADED_FLAG;
+	}
+}
+
+void RasterizerSceneGLES3::_draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox,const CameraMatrix& p_projection,const Transform& p_transform,bool p_vflip,float p_scale) {
+
+	if (!p_skybox)
+		return;
+
+	RasterizerStorageGLES3::Texture *tex = storage->texture_owner.getornull(p_skybox->cubemap);
+
+	ERR_FAIL_COND(!tex);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(tex->target,tex->tex_id);
+
+
+	if (storage->config.srgb_decode_supported && tex->srgb && !tex->using_srgb) {
+
+		glTexParameteri(tex->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+		tex->using_srgb=true;
+#ifdef TOOLS_ENABLED
+		if (!(tex->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+			tex->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+			//notify that texture must be set to linear beforehand, so it works in other platforms when exported
+		}
+#endif
+	}
+
+	glDepthMask(GL_TRUE);
+	glEnable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+	glDepthFunc(GL_LEQUAL);
+	glColorMask(1,1,1,1);
+
+	float flip_sign = p_vflip?-1:1;
+
+	Vector3 vertices[8]={
+		Vector3(-1,-1*flip_sign,1),
+		Vector3( 0, 1, 0),
+		Vector3( 1,-1*flip_sign,1),
+		Vector3( 1, 1, 0),
+		Vector3( 1, 1*flip_sign,1),
+		Vector3( 1, 0, 0),
+		Vector3(-1, 1*flip_sign,1),
+		Vector3( 0, 0, 0)
+
+	};
+
+
+
+	//skybox uv vectors
+	float vw,vh,zn;
+	p_projection.get_viewport_size(vw,vh);
+	zn=p_projection.get_z_near();
+
+	float scale=p_scale;
+
+	for(int i=0;i<4;i++) {
+
+		Vector3 uv=vertices[i*2+1];
+		uv.x=(uv.x*2.0-1.0)*vw*scale;
+		uv.y=-(uv.y*2.0-1.0)*vh*scale;
+		uv.z=-zn;
+		vertices[i*2+1] = p_transform.basis.xform(uv).normalized();
+		vertices[i*2+1].z = -vertices[i*2+1].z;
+	}
+
+	glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
+	glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*8,vertices);
+	glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+	glBindVertexArray(state.skybox_array);
+
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP,true);
+	storage->shaders.copy.bind();
+
+	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+
+	glBindVertexArray(0);
+	glColorMask(1,1,1,1);
+
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP,false);
+
+}
+
+
+void RasterizerSceneGLES3::_setup_environment(Environment *env,const CameraMatrix& p_cam_projection,const Transform& p_cam_transform) {
+
+
+	//store camera into ubo
+	store_camera(p_cam_projection,state.ubo_data.projection_matrix);
+	store_transform(p_cam_transform,state.ubo_data.camera_matrix);
+	store_transform(p_cam_transform.affine_inverse(),state.ubo_data.camera_inverse_matrix);
+
+	//time global variables
+	for(int i=0;i<4;i++) {
+		state.ubo_data.time[i]=storage->frame.time[i];
+	}
+
+	//bg and ambient
+	if (env) {
+		state.ubo_data.bg_energy=env->bg_energy;
+		state.ubo_data.ambient_energy=env->ambient_energy;
+		Color linear_ambient_color = env->ambient_color.to_linear();
+		state.ubo_data.ambient_light_color[0]=linear_ambient_color.r;
+		state.ubo_data.ambient_light_color[1]=linear_ambient_color.g;
+		state.ubo_data.ambient_light_color[2]=linear_ambient_color.b;
+		state.ubo_data.ambient_light_color[3]=linear_ambient_color.a;
+
+		Color bg_color;
+
+		switch(env->bg_mode) {
+			case VS::ENV_BG_CLEAR_COLOR: {
+				bg_color=storage->frame.clear_request_color.to_linear();
+			} break;
+			case VS::ENV_BG_COLOR: {
+				bg_color=env->bg_color.to_linear();
+			} break;
+			default: {
+				bg_color=Color(0,0,0,1);
+			} break;
+		}
+
+		state.ubo_data.bg_color[0]=bg_color.r;
+		state.ubo_data.bg_color[1]=bg_color.g;
+		state.ubo_data.bg_color[2]=bg_color.b;
+		state.ubo_data.bg_color[3]=bg_color.a;
+
+		state.env_radiance_data.ambient_contribution=env->ambient_skybox_contribution;
+		state.ubo_data.ambient_occlusion_affect_light=env->ssao_light_affect;
+	} else {
+		state.ubo_data.bg_energy=1.0;
+		state.ubo_data.ambient_energy=1.0;
+		//use from clear color instead, since there is no ambient
+		Color linear_ambient_color = storage->frame.clear_request_color.to_linear();
+		state.ubo_data.ambient_light_color[0]=linear_ambient_color.r;
+		state.ubo_data.ambient_light_color[1]=linear_ambient_color.g;
+		state.ubo_data.ambient_light_color[2]=linear_ambient_color.b;
+		state.ubo_data.ambient_light_color[3]=linear_ambient_color.a;
+
+		state.ubo_data.bg_color[0]=linear_ambient_color.r;
+		state.ubo_data.bg_color[1]=linear_ambient_color.g;
+		state.ubo_data.bg_color[2]=linear_ambient_color.b;
+		state.ubo_data.bg_color[3]=linear_ambient_color.a;
+
+		state.env_radiance_data.ambient_contribution=0;
+		state.ubo_data.ambient_occlusion_affect_light=0;
+
+	}
+
+	{
+		//directional shadow
+
+		state.ubo_data.shadow_directional_pixel_size[0]=1.0/directional_shadow.size;
+		state.ubo_data.shadow_directional_pixel_size[1]=1.0/directional_shadow.size;
+
+		glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-4);
+		glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
+	}
+
+
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(State::SceneDataUBO), &state.ubo_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	//fill up environment
+
+	store_transform(p_cam_transform,state.env_radiance_data.transform);
+
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.env_radiance_ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(State::EnvironmentRadianceUBO), &state.env_radiance_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+}
+
+void RasterizerSceneGLES3::_setup_directional_light(int p_index,const Transform& p_camera_inverse_transform,bool p_use_shadows) {
+
+	LightInstance *li = directional_lights[p_index];
+
+	LightDataUBO ubo_data; //used for filling
+
+	float sign = li->light_ptr->negative?-1:1;
+
+	Color linear_col = li->light_ptr->color.to_linear();
+	ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+	ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+	ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+	ubo_data.light_color_energy[3]=0;
+
+	//omni, keep at 0
+	ubo_data.light_pos_inv_radius[0]=0.0;
+	ubo_data.light_pos_inv_radius[1]=0.0;
+	ubo_data.light_pos_inv_radius[2]=0.0;
+	ubo_data.light_pos_inv_radius[3]=0.0;
+
+	Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0,0,-1))).normalized();
+	ubo_data.light_direction_attenuation[0]=direction.x;
+	ubo_data.light_direction_attenuation[1]=direction.y;
+	ubo_data.light_direction_attenuation[2]=direction.z;
+	ubo_data.light_direction_attenuation[3]=1.0;
+
+	ubo_data.light_params[0]=0;
+	ubo_data.light_params[1]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+	ubo_data.light_params[2]=0;
+	ubo_data.light_params[3]=0;
+
+	Color shadow_color = li->light_ptr->shadow_color.to_linear();
+	ubo_data.light_shadow_color[0]=shadow_color.r;
+	ubo_data.light_shadow_color[1]=shadow_color.g;
+	ubo_data.light_shadow_color[2]=shadow_color.b;
+	ubo_data.light_shadow_color[3]=1.0;
+
+
+	if (p_use_shadows && li->light_ptr->shadow) {
+
+		int shadow_count=0;
+
+		switch(li->light_ptr->directional_shadow_mode) {
+			case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
+				shadow_count=1;
+			} break;
+			case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
+				shadow_count=2;
+			} break;
+			case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
+				shadow_count=4;
+			} break;
+
+		}
+
+		for(int j=0;j<shadow_count;j++) {
+
+
+			uint32_t x=li->directional_rect.pos.x;
+			uint32_t y=li->directional_rect.pos.y;
+			uint32_t width=li->directional_rect.size.x;
+			uint32_t height=li->directional_rect.size.y;
+
+
+
+			if (li->light_ptr->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+
+
+				width/=2;
+				height/=2;
+
+				if (j==0) {
+
+				} else if (j==1) {
+					x+=width;
+				} else if (j==2) {
+					y+=height;
+				} else if (j==3) {
+					x+=width;
+					y+=height;
+
+				}
+
+
+
+			} else if (li->light_ptr->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+
+				height/=2;
+
+				if (j==0) {
+
+				} else {
+					y+=height;
+				}
+
+			}
+
+			ubo_data.shadow_split_offsets[j]=1.0/li->shadow_transform[j].split;
+
+			Transform modelview = (p_camera_inverse_transform * li->shadow_transform[j].transform).inverse();
+
+			CameraMatrix bias;
+			bias.set_light_bias();
+			CameraMatrix rectm;
+			Rect2 atlas_rect = Rect2(float(x)/directional_shadow.size,float(y)/directional_shadow.size,float(width)/directional_shadow.size,float(height)/directional_shadow.size);
+			rectm.set_light_atlas_rect(atlas_rect);
+
+
+			CameraMatrix shadow_mtx = rectm * bias * li->shadow_transform[j].camera * modelview;
+
+			store_camera(shadow_mtx,&ubo_data.shadow_matrix1[16*j]);
+
+			ubo_data.light_clamp[0]=atlas_rect.pos.x;
+			ubo_data.light_clamp[1]=atlas_rect.pos.y;
+			ubo_data.light_clamp[2]=atlas_rect.size.x;
+			ubo_data.light_clamp[3]=atlas_rect.size.y;
+
+		}
+
+	}
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.directional_ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(LightDataUBO), &ubo_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	directional_light=li;
+
+	glBindBufferBase(GL_UNIFORM_BUFFER,3,state.directional_ubo);
+
+}
+
+void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result,int p_light_cull_count,const Transform& p_camera_inverse_transform,const CameraMatrix& p_camera_projection,RID p_shadow_atlas) {
+
+
+	state.omni_light_count=0;
+	state.spot_light_count=0;
+	state.directional_light_count=0;
+
+	directional_light=NULL;
+
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+
+
+	for(int i=0;i<p_light_cull_count;i++)	 {
+
+		ERR_BREAK( i>=RenderList::MAX_LIGHTS );
+
+		LightInstance *li = light_instance_owner.getptr(p_light_cull_result[i]);
+
+		LightDataUBO ubo_data; //used for filling
+
+		switch(li->light_ptr->type) {
+
+			case VS::LIGHT_DIRECTIONAL: {
+
+				if (state.directional_light_count<RenderList::MAX_DIRECTIONAL_LIGHTS) {
+					directional_lights[state.directional_light_count++]=li;
+				}
+
+
+			} break;
+			case VS::LIGHT_OMNI: {
+
+				float sign = li->light_ptr->negative?-1:1;
+
+				Color linear_col = li->light_ptr->color.to_linear();
+				ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[3]=0;
+
+
+				Vector3 pos = p_camera_inverse_transform.xform(li->transform.origin);
+
+				//directional, keep at 0
+				ubo_data.light_pos_inv_radius[0]=pos.x;
+				ubo_data.light_pos_inv_radius[1]=pos.y;
+				ubo_data.light_pos_inv_radius[2]=pos.z;
+				ubo_data.light_pos_inv_radius[3]=1.0/MAX(0.001,li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
+
+				ubo_data.light_direction_attenuation[0]=0;
+				ubo_data.light_direction_attenuation[1]=0;
+				ubo_data.light_direction_attenuation[2]=0;
+				ubo_data.light_direction_attenuation[3]=li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+
+				ubo_data.light_params[0]=0;
+				ubo_data.light_params[1]=0;
+				ubo_data.light_params[2]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+				ubo_data.light_params[3]=0;
+
+				Color shadow_color = li->light_ptr->shadow_color.to_linear();
+				ubo_data.light_shadow_color[0]=shadow_color.r;
+				ubo_data.light_shadow_color[1]=shadow_color.g;
+				ubo_data.light_shadow_color[2]=shadow_color.b;
+				ubo_data.light_shadow_color[3]=1.0;
+
+				if (li->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(li->self)) {
+					// fill in the shadow information
+
+					uint32_t key = shadow_atlas->shadow_owners[li->self];
+
+					uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
+					uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
+
+					ERR_CONTINUE(shadow>=shadow_atlas->quadrants[quadrant].shadows.size());
+
+					uint32_t atlas_size = shadow_atlas->size;
+					uint32_t quadrant_size = atlas_size>>1;
+
+					uint32_t x=(quadrant&1)*quadrant_size;
+					uint32_t y=(quadrant>>1)*quadrant_size;
+
+					uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
+					x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+					y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+
+					uint32_t width=shadow_size;
+					uint32_t height=shadow_size;
+
+
+					if (li->light_ptr->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+
+						height/=2;
+					} else {
+						width/=2;
+
+					}
+
+					Transform proj = (p_camera_inverse_transform * li->transform).inverse();
+
+					store_transform(proj,ubo_data.shadow_matrix1);
+
+					ubo_data.light_params[3]=1.0; //means it has shadow
+					ubo_data.light_clamp[0]=float(x)/atlas_size;
+					ubo_data.light_clamp[1]=float(y)/atlas_size;
+					ubo_data.light_clamp[2]=float(width)/atlas_size;
+					ubo_data.light_clamp[3]=float(height)/atlas_size;
+
+				}
+
+
+				li->light_index=state.omni_light_count;
+				copymem(&state.omni_array_tmp[li->light_index*state.ubo_light_size],&ubo_data,state.ubo_light_size);
+				state.omni_light_count++;
+
+
+
+#if 0
+				if (li->light_ptr->shadow_enabled) {
+					li->shadow_projection[0] = Transform(camera_transform_inverse * li->transform).inverse();
+					lights_use_shadow=true;
+				}
+#endif
+			} break;
+			case VS::LIGHT_SPOT: {
+
+				float sign = li->light_ptr->negative?-1:1;
+
+				Color linear_col = li->light_ptr->color.to_linear();
+				ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];;
+				ubo_data.light_color_energy[3]=0;
+
+				Vector3 pos = p_camera_inverse_transform.xform(li->transform.origin);
+
+				//directional, keep at 0
+				ubo_data.light_pos_inv_radius[0]=pos.x;
+				ubo_data.light_pos_inv_radius[1]=pos.y;
+				ubo_data.light_pos_inv_radius[2]=pos.z;
+				ubo_data.light_pos_inv_radius[3]=1.0/MAX(0.001,li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
+
+				Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0,0,-1))).normalized();
+				ubo_data.light_direction_attenuation[0]=direction.x;
+				ubo_data.light_direction_attenuation[1]=direction.y;
+				ubo_data.light_direction_attenuation[2]=direction.z;
+				ubo_data.light_direction_attenuation[3]=li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+
+				ubo_data.light_params[0]=li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ATTENUATION];
+				ubo_data.light_params[1]=Math::cos(Math::deg2rad(li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ANGLE]));
+				ubo_data.light_params[2]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+				ubo_data.light_params[3]=0;
+
+				Color shadow_color = li->light_ptr->shadow_color.to_linear();
+				ubo_data.light_shadow_color[0]=shadow_color.r;
+				ubo_data.light_shadow_color[1]=shadow_color.g;
+				ubo_data.light_shadow_color[2]=shadow_color.b;
+				ubo_data.light_shadow_color[3]=1.0;
+
+				if (li->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(li->self)) {
+					// fill in the shadow information
+
+					uint32_t key = shadow_atlas->shadow_owners[li->self];
+
+					uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
+					uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
+
+					ERR_CONTINUE(shadow>=shadow_atlas->quadrants[quadrant].shadows.size());
+
+					uint32_t atlas_size = shadow_atlas->size;
+					uint32_t quadrant_size = atlas_size>>1;
+
+					uint32_t x=(quadrant&1)*quadrant_size;
+					uint32_t y=(quadrant>>1)*quadrant_size;
+
+					uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
+					x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+					y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+
+					uint32_t width=shadow_size;
+					uint32_t height=shadow_size;
+
+					Rect2 rect(float(x)/atlas_size,float(y)/atlas_size,float(width)/atlas_size,float(height)/atlas_size);
+
+					ubo_data.light_params[3]=1.0; //means it has shadow
+					ubo_data.light_clamp[0]=rect.pos.x;
+					ubo_data.light_clamp[1]=rect.pos.y;
+					ubo_data.light_clamp[2]=rect.size.x;
+					ubo_data.light_clamp[3]=rect.size.y;
+
+					Transform modelview = (p_camera_inverse_transform * li->transform).inverse();
+
+					CameraMatrix bias;
+					bias.set_light_bias();
+					CameraMatrix rectm;
+					rectm.set_light_atlas_rect(rect);
+
+					CameraMatrix shadow_mtx = rectm * bias * li->shadow_transform[0].camera * modelview;
+
+					store_camera(shadow_mtx,ubo_data.shadow_matrix1);
+
+
+				}
+
+				li->light_index=state.spot_light_count;
+				copymem(&state.spot_array_tmp[li->light_index*state.ubo_light_size],&ubo_data,state.ubo_light_size);
+				state.spot_light_count++;
+
+#if 0
+				if (li->light_ptr->shadow_enabled) {
+					CameraMatrix bias;
+					bias.set_light_bias();
+					Transform modelview=Transform(camera_transform_inverse * li->transform).inverse();
+					li->shadow_projection[0] = bias * li->projection * modelview;
+					lights_use_shadow=true;
+				}
+#endif
+			} break;
+
+		}
+
+
+		li->last_pass=render_pass;
+
+		//update UBO for forward rendering, blit to texture for clustered
+
+	}
+
+
+
+	if (state.omni_light_count) {
+
+		glBindBuffer(GL_UNIFORM_BUFFER, state.omni_array_ubo);
+		glBufferSubData(GL_UNIFORM_BUFFER, 0, state.omni_light_count*state.ubo_light_size, state.omni_array_tmp);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		glBindBufferBase(GL_UNIFORM_BUFFER,4,state.omni_array_ubo);
+	}
+
+	if (state.spot_light_count) {
+
+		glBindBuffer(GL_UNIFORM_BUFFER, state.spot_array_ubo);
+		glBufferSubData(GL_UNIFORM_BUFFER, 0, state.spot_light_count*state.ubo_light_size, state.spot_array_tmp);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		glBindBufferBase(GL_UNIFORM_BUFFER,5,state.spot_array_ubo);
+	}
+
+
+
+}
+
+void RasterizerSceneGLES3::_setup_reflections(RID *p_reflection_probe_cull_result,int p_reflection_probe_cull_count,const Transform& p_camera_inverse_transform,const CameraMatrix& p_camera_projection,RID p_reflection_atlas,Environment *p_env) {
+
+	state.reflection_probe_count=0;
+
+	for(int i=0;i<p_reflection_probe_cull_count;i++) {
+
+		ReflectionProbeInstance *rpi=reflection_probe_instance_owner.getornull(p_reflection_probe_cull_result[i]);
+		ERR_CONTINUE(!rpi);
+
+		ReflectionAtlas *reflection_atlas=reflection_atlas_owner.getornull(p_reflection_atlas);
+		ERR_CONTINUE(!reflection_atlas);
+
+		ERR_CONTINUE(rpi->reflection_atlas_index<0);
+
+
+		if (state.reflection_probe_count>=state.max_ubo_reflections)
+			break;
+
+		rpi->last_pass=render_pass;
+
+
+		ReflectionProbeDataUBO reflection_ubo;
+
+		reflection_ubo.box_extents[0]=rpi->probe_ptr->extents.x;
+		reflection_ubo.box_extents[1]=rpi->probe_ptr->extents.y;
+		reflection_ubo.box_extents[2]=rpi->probe_ptr->extents.z;
+		reflection_ubo.box_extents[3]=0;
+
+
+
+		reflection_ubo.box_ofs[0]=rpi->probe_ptr->origin_offset.x;
+		reflection_ubo.box_ofs[1]=rpi->probe_ptr->origin_offset.y;
+		reflection_ubo.box_ofs[2]=rpi->probe_ptr->origin_offset.z;
+		reflection_ubo.box_ofs[3]=0;
+
+		reflection_ubo.params[0]=rpi->probe_ptr->intensity;
+		reflection_ubo.params[1]=0;
+		reflection_ubo.params[2]=rpi->probe_ptr->interior?1.0:0.0;
+		reflection_ubo.params[3]=rpi->probe_ptr->box_projection?1.0:0.0;
+
+		if (rpi->probe_ptr->interior) {
+			Color ambient_linear = rpi->probe_ptr->interior_ambient.to_linear();
+			reflection_ubo.ambient[0]=ambient_linear.r*rpi->probe_ptr->interior_ambient_energy;
+			reflection_ubo.ambient[1]=ambient_linear.g*rpi->probe_ptr->interior_ambient_energy;
+			reflection_ubo.ambient[2]=ambient_linear.b*rpi->probe_ptr->interior_ambient_energy;
+			reflection_ubo.ambient[3]=rpi->probe_ptr->interior_ambient_probe_contrib;
+		} else {
+			Color ambient_linear;
+			float contrib=0;
+			if (p_env) {
+				ambient_linear=p_env->ambient_color.to_linear();
+				ambient_linear.r*=p_env->ambient_energy;
+				ambient_linear.g*=p_env->ambient_energy;
+				ambient_linear.b*=p_env->ambient_energy;
+				contrib=p_env->ambient_skybox_contribution;
+			}
+
+			reflection_ubo.ambient[0]=ambient_linear.r;
+			reflection_ubo.ambient[1]=ambient_linear.g;
+			reflection_ubo.ambient[2]=ambient_linear.b;
+			reflection_ubo.ambient[3]=0;
+		}
+
+		int cell_size = reflection_atlas->size / reflection_atlas->subdiv;
+		int x = (rpi->reflection_atlas_index % reflection_atlas->subdiv) * cell_size;
+		int y = (rpi->reflection_atlas_index / reflection_atlas->subdiv) * cell_size;
+		int width=cell_size;
+		int height=cell_size;
+
+		reflection_ubo.atlas_clamp[0]=float(x)/reflection_atlas->size;
+		reflection_ubo.atlas_clamp[1]=float(y)/reflection_atlas->size;
+		reflection_ubo.atlas_clamp[2]=float(width)/reflection_atlas->size;
+		reflection_ubo.atlas_clamp[3]=float(height/2)/reflection_atlas->size;
+
+		Transform proj = (p_camera_inverse_transform * rpi->transform).inverse();
+		store_transform(proj,reflection_ubo.local_matrix);
+
+		rpi->reflection_index=state.reflection_probe_count;
+		copymem(&state.reflection_array_tmp[rpi->reflection_index*sizeof(ReflectionProbeDataUBO)],&reflection_ubo,sizeof(ReflectionProbeDataUBO));
+		state.reflection_probe_count++;
+
+	}
+
+
+	if (state.reflection_probe_count) {
+
+
+		glBindBuffer(GL_UNIFORM_BUFFER, state.reflection_array_ubo);
+		glBufferSubData(GL_UNIFORM_BUFFER, 0, state.reflection_probe_count*sizeof(ReflectionProbeDataUBO), state.reflection_array_tmp);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		glBindBufferBase(GL_UNIFORM_BUFFER,6,state.reflection_array_ubo);
+	}
+
+}
+
+
+void RasterizerSceneGLES3::_copy_screen() {
+
+	glBindVertexArray( storage->resources.quadie_array);
+	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+	glBindVertexArray(0);
+
+}
+
+void RasterizerSceneGLES3::_copy_to_front_buffer(Environment *env) {
+
+	//copy to front buffer
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+
+	glDepthMask(GL_FALSE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+	glDepthFunc(GL_LEQUAL);
+	glColorMask(1,1,1,1);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
+
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+
+	if (!env) {
+		//no environment, simply convert from linear to srgb
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
+	} else {
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
+
+	}
+
+	storage->shaders.copy.bind();
+
+	_copy_screen();
+
+
+	//turn off everything used
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false);
+
+
+}
+
+void RasterizerSceneGLES3::_copy_texture_to_front_buffer(GLuint p_texture) {
+
+	//copy to front buffer
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+
+	glDepthMask(GL_FALSE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+	glDepthFunc(GL_LEQUAL);
+	glColorMask(1,1,1,1);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,p_texture);
+
+	glViewport(0,0,storage->frame.current_rt->width*0.5,storage->frame.current_rt->height*0.5);
+
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+	storage->shaders.copy.bind();
+
+	_copy_screen();
+
+	//turn off everything used
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
+	storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false);
+
+
+}
+
+void RasterizerSceneGLES3::_fill_render_list(InstanceBase** p_cull_result,int p_cull_count,bool p_shadow){
+
+	current_geometry_index=0;
+	current_material_index=0;
+	state.used_sss=false;
+
+	//fill list
+
+	for(int i=0;i<p_cull_count;i++) {
+
+		InstanceBase *inst = p_cull_result[i];
+		switch(inst->base_type) {
+
+			case VS::INSTANCE_MESH: {
+
+				RasterizerStorageGLES3::Mesh *mesh = storage->mesh_owner.getptr(inst->base);
+				ERR_CONTINUE(!mesh);
+
+				int ssize = mesh->surfaces.size();
+
+				for (int i=0;i<ssize;i++) {
+
+					int mat_idx = inst->materials[i].is_valid() ? i : -1;
+					RasterizerStorageGLES3::Surface *s = mesh->surfaces[i];
+					_add_geometry(s,inst,NULL,mat_idx,p_shadow);
+				}
+
+				//mesh->last_pass=frame;
+
+			} break;
+			case VS::INSTANCE_MULTIMESH: {
+
+				RasterizerStorageGLES3::MultiMesh *multi_mesh = storage->multimesh_owner.getptr(inst->base);
+				ERR_CONTINUE(!multi_mesh);
+
+				if (multi_mesh->size==0 || multi_mesh->visible_instances==0)
+					continue;
+
+				RasterizerStorageGLES3::Mesh *mesh = storage->mesh_owner.getptr(multi_mesh->mesh);
+				if (!mesh)
+					continue; //mesh not assigned
+
+				int ssize = mesh->surfaces.size();
+
+				for (int i=0;i<ssize;i++) {
+
+					RasterizerStorageGLES3::Surface *s = mesh->surfaces[i];
+					_add_geometry(s,inst,multi_mesh,-1,p_shadow);
+				}
+
+			} break;
+			case VS::INSTANCE_IMMEDIATE: {
+
+			} break;
+
+		}
+	}
+}
+
+
+void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_cam_projection) {
+
+
+	glDepthMask(GL_FALSE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+
+
+	if (env->ssao_enabled) {
+		//copy diffuse to front buffer
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+		glReadBuffer(GL_COLOR_ATTACHMENT0);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->fbo);
+		glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+
+
+		//copy from depth, convert to linear
+		GLint ss[2];
+		ss[0]=storage->frame.current_rt->width;
+		ss[1]=storage->frame.current_rt->height;
+
+		for(int i=0;i<storage->frame.current_rt->effects.ssao.depth_mipmap_fbos.size();i++) {
+
+			state.ssao_minify_shader.set_conditional(SsaoMinifyShaderGLES3::MINIFY_START,i==0);
+			state.ssao_minify_shader.bind();
+			state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+			state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+			state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::SOURCE_MIPMAP,MAX(0,i-1));
+			glUniform2iv(state.ssao_minify_shader.get_uniform(SsaoMinifyShaderGLES3::FROM_SIZE),1,ss);
+			ss[0]>>=1;
+			ss[1]>>=1;
+
+			glActiveTexture(GL_TEXTURE0);
+			if (i==0) {
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+			} else {
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.linear_depth);
+			}
+
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.depth_mipmap_fbos[i]); //copy to front first
+			glViewport(0,0,ss[0],ss[1]);
+
+			_copy_screen();
+
+		}
+		ss[0]=storage->frame.current_rt->width;
+		ss[1]=storage->frame.current_rt->height;
+
+		glViewport(0,0,ss[0],ss[1]);
+
+
+		glEnable(GL_DEPTH_TEST);
+		glDepthFunc(GL_GREATER);
+		// do SSAO!
+		state.ssao_shader.set_conditional(SsaoShaderGLES3::ENABLE_RADIUS2,env->ssao_radius2>0.001);
+		state.ssao_shader.bind();
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		glUniform2iv(state.ssao_shader.get_uniform(SsaoShaderGLES3::SCREEN_SIZE),1,ss);
+		float radius = env->ssao_radius;
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS,radius);
+		float intensity = env->ssao_intensity;
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R6,intensity / pow(radius, 6.0f));
+
+		if (env->ssao_radius2>0.001) {
+
+			float radius2 = env->ssao_radius2;
+			state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS2,radius2);
+			float intensity2 = env->ssao_intensity2;
+			state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R62,intensity2 / pow(radius2, 6.0f));
+
+		}
+
+		float proj_info[4]={
+			-2.0f / (ss[0]*p_cam_projection.matrix[0][0]),
+			-2.0f / (ss[1]*p_cam_projection.matrix[1][1]),
+			( 1.0f - p_cam_projection.matrix[0][2]) / p_cam_projection.matrix[0][0],
+			( 1.0f + p_cam_projection.matrix[1][2]) / p_cam_projection.matrix[1][1]
+		};
+
+		glUniform4fv(state.ssao_shader.get_uniform(SsaoShaderGLES3::PROJ_INFO),1,proj_info);
+		float pixels_per_meter = float(p_cam_projection.get_pixels_per_meter(ss[0]));
+
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::PROJ_SCALE,pixels_per_meter);
+		state.ssao_shader.set_uniform(SsaoShaderGLES3::BIAS,env->ssao_bias);
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.linear_depth);
+		glActiveTexture(GL_TEXTURE2);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.blur_fbo[0]); //copy to front first
+		Color white(1,1,1,1);
+		glClearBufferfv(GL_COLOR,0,white.components); // specular
+
+		_copy_screen();
+
+		//do the batm, i mean blur
+
+		state.ssao_blur_shader.bind();
+
+		if (env->ssao_filter) {
+			for(int i=0;i<2;i++) {
+
+				state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+				state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+				GLint axis[2]={i,1-i};
+				glUniform2iv(state.ssao_blur_shader.get_uniform(SsaoBlurShaderGLES3::AXIS),1,axis);
+				glActiveTexture(GL_TEXTURE0);
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.blur_red[i]);
+				glActiveTexture(GL_TEXTURE1);
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+				glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.blur_fbo[1-i]);
+				if (i==0) {
+					glClearBufferfv(GL_COLOR,0,white.components); // specular
+				}
+				_copy_screen();
+
+			}
+		}
+
+		glDisable(GL_DEPTH_TEST);
+		glDepthFunc(GL_LEQUAL);
+
+		// just copy diffuse while applying SSAO
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE,true);
+		state.effect_blur_shader.bind();
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::SSAO_COLOR,env->ssao_color);
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color); //previous level, since mipmaps[0] starts one level bigger
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.blur_red[0]); //previous level, since mipmaps[0] starts one level bigger
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+		_copy_screen();
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE,false);
+
+	} else {
+
+		//copy diffuse to effect buffer
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+		glReadBuffer(GL_COLOR_ATTACHMENT0);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
+		glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+
+	}
+
+
+	if (state.used_sss) {//sss enabled
+		//copy diffuse while performing sss
+
+		//copy normal and roughness to effect buffer
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+		glReadBuffer(GL_COLOR_ATTACHMENT3);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->buffers.effect_fbo);
+		glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT , GL_NEAREST);
+
+		state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_11_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_LOW);
+		state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_17_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_MEDIUM);
+		state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_25_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_HIGH);
+		state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::ENABLE_FOLLOW_SURFACE,subsurface_scatter_follow_surface);
+		state.sss_shader.bind();
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::MAX_RADIUS,subsurface_scatter_size);
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::FOVY,p_cam_projection.get_fov());
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR,Vector2(1,0));
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+		glActiveTexture(GL_TEXTURE2);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+
+		_copy_screen();
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+		state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR,Vector2(0,1));
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+		_copy_screen();
+
+	}
+
+
+
+	if (env->ssr_enabled) {
+
+		//copy normal and roughness to effect buffer
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+		glReadBuffer(GL_COLOR_ATTACHMENT2);
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->buffers.effect_fbo);
+		glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT , GL_NEAREST);
+
+
+		//blur diffuse into effect mipmaps using separatable convolution
+		//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+		for(int i=0;i<storage->frame.current_rt->effects.mip_maps[1].sizes.size();i++) {
+
+
+			int vp_w = storage->frame.current_rt->effects.mip_maps[1].sizes[i].width;
+			int vp_h = storage->frame.current_rt->effects.mip_maps[1].sizes[i].height;
+			glViewport(0,0,vp_w,vp_h);
+			//horizontal pass
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+			state.effect_blur_shader.bind();
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
+			_copy_screen();
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL,false);
+
+			//vertical pass
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL,true);
+			state.effect_blur_shader.bind();
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[i+1].fbo); //next level, since mipmaps[0] starts one level bigger
+			_copy_screen();
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL,false);
+		}
+
+
+		//perform SSR
+
+		state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::SMOOTH_ACCEL,env->ssr_accel>0 && env->ssr_smooth);
+		state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::REFLECT_ROUGHNESS,env->ssr_accel>0 && env->ssr_roughness);
+
+		state.ssr_shader.bind();
+
+		int ssr_w = storage->frame.current_rt->effects.mip_maps[1].sizes[0].width;
+		int ssr_h = storage->frame.current_rt->effects.mip_maps[1].sizes[0].height;
+
+
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PIXEL_SIZE,Vector2(1.0/(ssr_w*0.5),1.0/(ssr_h*0.5)));
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PROJECTION,p_cam_projection);
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::INVERSE_PROJECTION,p_cam_projection.inverse());
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::VIEWPORT_SIZE,Size2(ssr_w,ssr_h));
+		//state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::FRAME_INDEX,int(render_pass));
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::FILTER_MIPMAP_LEVELS,float(storage->frame.current_rt->effects.mip_maps[0].sizes.size()));
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::NUM_STEPS,env->ssr_max_steps);
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::ACCELERATION,env->ssr_accel);
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DEPTH_TOLERANCE,env->ssr_depth_tolerance);
+		state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DISTANCE_FADE,env->ssr_fade);
+
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+		glActiveTexture(GL_TEXTURE2);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[0].fbo);
+		glViewport(0,0,ssr_w,ssr_h);
+
+		_copy_screen();
+		glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+	}
+
+
+
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+	glReadBuffer(GL_COLOR_ATTACHMENT1);
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->fbo);
+	//glDrawBuffer(GL_COLOR_ATTACHMENT0);
+	glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+	glReadBuffer(GL_COLOR_ATTACHMENT0);
+
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+
+	//copy reflection over diffuse, resolving SSR if needed
+	state.resolve_shader.set_conditional(ResolveShaderGLES3::USE_SSR,env->ssr_enabled);
+	state.resolve_shader.bind();
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+	if (env->ssr_enabled) {
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
+	}
+
+
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
+	glEnable(GL_BLEND);
+	glBlendEquation(GL_FUNC_ADD);
+	glBlendFunc(GL_ONE,GL_ONE); //use additive to accumulate one over the other
+
+	_copy_screen();
+
+	glDisable(GL_BLEND); //end additive
+
+	state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY,true);
+	state.effect_blur_shader.bind();
+	state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(0));
+
+	{
+		GLuint db = GL_COLOR_ATTACHMENT0;
+		glDrawBuffers(1,&db);
+	}
+
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+
+	_copy_screen();
+
+	state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY,false);
+
+
+}
+
+void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_cam_projection){
+
+	//copy to front buffer
+
+	glDepthMask(GL_FALSE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+	glDepthFunc(GL_LEQUAL);
+	glColorMask(1,1,1,1);
+
+	//turn off everything used
+
+	//copy specular to front buffer
+	//copy diffuse to effect buffer
+
+
+	glReadBuffer(GL_COLOR_ATTACHMENT0);
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
+	glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+
+	if (!env) {
+		//no environment, simply return and convert to SRGB
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+		storage->shaders.copy.bind();
+
+		_copy_screen();
+
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
+		storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false);	//compute luminance
+
+		return;
+
+	}
+
+
+	//order of operation
+	//1) DOF Blur (first blur, then copy to buffer applying the blur)
+	//2) Motion Blur
+	//3) Bloom
+	//4) Tonemap
+	//5) Adjustments
+
+	GLuint composite_from = storage->frame.current_rt->effects.mip_maps[0].color;
+
+
+	if (env->dof_blur_far_enabled) {
+
+		//blur diffuse into effect mipmaps using separatable convolution
+		//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+
+		int vp_h = storage->frame.current_rt->height;
+		int vp_w = storage->frame.current_rt->width;
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,true);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_LOW);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_HIGH);
+
+		state.effect_blur_shader.bind();
+		int qsteps[3]={4,10,20};
+
+		float radius = (env->dof_blur_far_amount*env->dof_blur_far_amount) / qsteps[env->dof_blur_far_quality];
+
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_far_distance);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_far_distance+env->dof_blur_far_transition);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(1,0));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,composite_from);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+
+		_copy_screen();
+
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(0,1));
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+		_copy_screen();
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,false);
+
+
+		composite_from=storage->frame.current_rt->effects.mip_maps[0].color;
+
+	}
+
+	if (env->dof_blur_near_enabled) {
+
+		//blur diffuse into effect mipmaps using separatable convolution
+		//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+
+		int vp_h = storage->frame.current_rt->height;
+		int vp_w = storage->frame.current_rt->width;
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR,true);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,true);
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_LOW);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_HIGH);
+
+		state.effect_blur_shader.bind();
+		int qsteps[3]={4,10,20};
+
+		float radius = (env->dof_blur_near_amount*env->dof_blur_near_amount) / qsteps[env->dof_blur_near_quality];
+
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_near_distance);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_near_distance-env->dof_blur_near_transition);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(1,0));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,composite_from);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+
+		_copy_screen();
+		//manually do the blend if this is the first operation resolving from the diffuse buffer
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE,composite_from == storage->frame.current_rt->buffers.diffuse);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,false);
+		state.effect_blur_shader.bind();
+
+
+
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_near_distance);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_near_distance-env->dof_blur_near_transition);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(0,1));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
+		state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+
+		if (composite_from != storage->frame.current_rt->buffers.diffuse) {
+
+			glEnable(GL_BLEND);
+			glBlendEquation(GL_FUNC_ADD);
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		} else {
+			glActiveTexture(GL_TEXTURE2);
+			glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
+
+		}
+
+		_copy_screen();
+
+		if (composite_from != storage->frame.current_rt->buffers.diffuse) {
+
+			glDisable(GL_BLEND);
+		}
+
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,false);
+		state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,false);
+
+
+		composite_from=storage->frame.current_rt->effects.mip_maps[0].color;
+
+	}
+
+	if ( env->auto_exposure) {
+
+		//compute auto exposure
+		//first step, copy from image to luminance buffer
+		state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN,true);
+		state.exposure_shader.bind();
+		int ss[2]={
+			storage->frame.current_rt->width,
+			storage->frame.current_rt->height,
+		};
+		int ds[2]={
+			exposure_shrink_size,
+			exposure_shrink_size,
+		};
+
+		glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::SOURCE_RENDER_SIZE),1,ss);
+		glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::TARGET_SIZE),1,ds);
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
+
+
+		glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[0].fbo);
+		glViewport(0,0,exposure_shrink_size,exposure_shrink_size);
+
+		_copy_screen();
+
+
+
+
+
+		//second step, shrink to 2x2 pixels
+		state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN,false);
+		state.exposure_shader.bind();
+		//shrink from second to previous to last level
+
+		int s_size=exposure_shrink_size/3;
+		for(int i=1;i<exposure_shrink.size()-1;i++) {
+
+			glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[i].fbo);
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D,exposure_shrink[i-1].color);
+
+			_copy_screen();
+
+			glViewport(0,0,s_size,s_size);
+
+			s_size/=3;
+
+		}
+		//third step, shrink to 1x1 pixel taking in consideration the previous exposure
+		state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END,true);
+
+		uint64_t tick = OS::get_singleton()->get_ticks_usec();
+		uint64_t tick_diff = storage->frame.current_rt->last_exposure_tick==0?0:tick-storage->frame.current_rt->last_exposure_tick;
+		storage->frame.current_rt->last_exposure_tick=tick;
+
+		if (tick_diff==0 || tick_diff>1000000) {
+			state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET,true);
+
+		}
+
+		state.exposure_shader.bind();
+
+		glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[exposure_shrink.size()-1].fbo);
+		glViewport(0,0,1,1);
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,exposure_shrink[exposure_shrink.size()-2].color);
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color); //read from previous
+
+
+		state.exposure_shader.set_uniform(ExposureShaderGLES3::EXPOSURE_ADJUST,env->auto_exposure_speed*(tick_diff/1000000.0));
+		state.exposure_shader.set_uniform(ExposureShaderGLES3::MAX_LUMINANCE,env->auto_exposure_max);
+		state.exposure_shader.set_uniform(ExposureShaderGLES3::MIN_LUMINANCE,env->auto_exposure_min);
+
+		_copy_screen();
+
+		state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET,false);
+		state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END,false);
+
+		//last step, swap with the framebuffer exposure, so the right exposure is kept int he framebuffer
+		SWAP(exposure_shrink[exposure_shrink.size()-1].fbo,storage->frame.current_rt->exposure.fbo);
+		SWAP(exposure_shrink[exposure_shrink.size()-1].color,storage->frame.current_rt->exposure.color);
+
+
+		glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+	}
+
+
+	int max_glow_level=-1;
+	int glow_mask=0;
+
+
+	if (env->glow_enabled) {
+
+
+		for(int i=0;i<VS::MAX_GLOW_LEVELS;i++) {
+			if (env->glow_levels&(1<<i)) {
+
+				if (i>=storage->frame.current_rt->effects.mip_maps[1].sizes.size()) {
+					max_glow_level=storage->frame.current_rt->effects.mip_maps[1].sizes.size()-1;
+					glow_mask|=1<<max_glow_level;
+
+				} else {
+					max_glow_level=i;
+					glow_mask|=(1<<i);
+				}
+
+			}
+		}
+
+
+		//blur diffuse into effect mipmaps using separatable convolution
+		//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+
+		for(int i=0;i<(max_glow_level+1);i++) {
+
+
+			int vp_w = storage->frame.current_rt->effects.mip_maps[1].sizes[i].width;
+			int vp_h = storage->frame.current_rt->effects.mip_maps[1].sizes[i].height;
+			glViewport(0,0,vp_w,vp_h);
+			//horizontal pass
+			if (i==0) {
+				state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS,true);
+				state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE,env->auto_exposure);
+			}
+
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL,true);
+			state.effect_blur_shader.bind();
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH,env->glow_strength);
+
+			glActiveTexture(GL_TEXTURE0);
+			if (i==0) {
+				glBindTexture(GL_TEXTURE_2D,composite_from);
+
+				state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::EXPOSURE,env->tone_mapper_exposure);
+				if (env->auto_exposure) {
+					state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::AUTO_EXPOSURE_GREY,env->auto_exposure_grey);
+				}
+
+				glActiveTexture(GL_TEXTURE1);
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
+
+				state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_BLOOM,env->glow_bloom);
+				state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_TRESHOLD,env->glow_hdr_bleed_treshold);
+				state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_SCALE,env->glow_hdr_bleed_scale);
+
+			} else {
+				glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
+			}
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
+			_copy_screen();
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL,false);
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS,false);
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE,false);
+
+			//vertical pass
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL,true);
+			state.effect_blur_shader.bind();
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+			state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH,env->glow_strength);
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[i+1].fbo); //next level, since mipmaps[0] starts one level bigger
+			_copy_screen();
+			state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL,false);
+		}
+
+		glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+	}
+
+
+
+
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,composite_from);
+
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_FILMIC);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_ACES);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_REINHARDT);
+
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE,env->auto_exposure);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC,env->glow_bicubic_upscale);
+
+
+
+	if (max_glow_level>=0) {
+
+
+		for(int i=0;i<(max_glow_level+1);i++) {
+
+			if (glow_mask&(1<<i)) {
+				if (i==0) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1,true);
+				}
+				if (i==1) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2,true);
+				}
+				if (i==2) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3,true);
+				}
+				if (i==3) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4,true);
+				}
+				if (i==4) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5,true);
+				}
+				if (i==5) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6,true);
+				}
+				if (i==6) {
+					state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7,true);
+				}
+			}
+		}
+
+		state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN,env->glow_blend_mode==VS::GLOW_BLEND_MODE_SCREEN);
+		state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT,env->glow_blend_mode==VS::GLOW_BLEND_MODE_SOFTLIGHT);
+		state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE,env->glow_blend_mode==VS::GLOW_BLEND_MODE_REPLACE);
+		glActiveTexture(GL_TEXTURE2);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+
+	}
+
+	state.tonemap_shader.bind();
+
+	state.tonemap_shader.set_uniform(TonemapShaderGLES3::EXPOSURE,env->tone_mapper_exposure);
+	state.tonemap_shader.set_uniform(TonemapShaderGLES3::WHITE,env->tone_mapper_exposure_white);
+
+	if (max_glow_level>=0) {
+
+		state.tonemap_shader.set_uniform(TonemapShaderGLES3::GLOW_INTENSITY,env->glow_intensity);
+		int ss[2]={
+			storage->frame.current_rt->width,
+			storage->frame.current_rt->height,
+		};
+		glUniform2iv(state.tonemap_shader.get_uniform(TonemapShaderGLES3::GLOW_TEXTURE_SIZE),1,ss);
+
+	}
+
+	if (env->auto_exposure)	{
+
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
+		state.tonemap_shader.set_uniform(TonemapShaderGLES3::AUTO_EXPOSURE_GREY,env->auto_exposure_grey);
+
+	}
+
+
+
+	_copy_screen();
+
+	//turn off everything used
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT,false);
+	state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC,false);
+
+}
+
+void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const CameraMatrix& p_cam_projection,bool p_cam_ortogonal,InstanceBase** p_cull_result,int p_cull_count,RID* p_light_cull_result,int p_light_cull_count,RID* p_reflection_probe_cull_result,int p_reflection_probe_cull_count,RID p_environment,RID p_shadow_atlas,RID p_reflection_atlas,RID p_reflection_probe,int p_reflection_probe_pass){
+
+	//first of all, make a new render pass
+	render_pass++;
+
+
+	//fill up ubo
+
+	Environment *env = environment_owner.getornull(p_environment);
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+	ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
+
+	if (shadow_atlas && shadow_atlas->size) {
+		glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-3);
+		glBindTexture(GL_TEXTURE_2D,shadow_atlas->depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
+		state.ubo_data.shadow_atlas_pixel_size[0]=1.0/shadow_atlas->size;
+		state.ubo_data.shadow_atlas_pixel_size[1]=1.0/shadow_atlas->size;
+	}
+
+
+	if (reflection_atlas && reflection_atlas->size) {
+		glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-5);
+		glBindTexture(GL_TEXTURE_2D,reflection_atlas->color);
+	}
+
+	if (p_reflection_probe.is_valid()) {
+		state.ubo_data.reflection_multiplier=0.0;
+	} else {
+		state.ubo_data.reflection_multiplier=1.0;
+	}
+
+	state.ubo_data.subsurface_scatter_width=subsurface_scatter_size;
+
+
+	state.ubo_data.shadow_z_offset=0;
+	state.ubo_data.shadow_slope_scale=0;
+	state.ubo_data.shadow_dual_paraboloid_render_side=0;
+	state.ubo_data.shadow_dual_paraboloid_render_zfar=0;
+
+	_setup_environment(env,p_cam_projection,p_cam_transform);
+
+	bool fb_cleared=false;
+
+	glDepthFunc(GL_LEQUAL);
+
+
+	if (storage->frame.current_rt && true) {
+		//pre z pass
+
+
+		glDisable(GL_BLEND);
+		glDepthMask(GL_TRUE);
+		glEnable(GL_DEPTH_TEST);
+		glDisable(GL_SCISSOR_TEST);
+		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
+		glDrawBuffers(0,NULL);
+
+		glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+		glColorMask(0,0,0,0);
+
+		glClearDepth(1.0);
+		glClear(GL_DEPTH_BUFFER_BIT);
+
+
+		render_list.clear();
+		_fill_render_list(p_cull_result,p_cull_count,true);
+		render_list.sort_by_depth(false);
+		state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,true);
+		_render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,0,false,false,true,false,false);
+		state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,false);
+
+		glColorMask(1,1,1,1);
+
+		fb_cleared=true;
+		render_pass++;
+	}
+
+
+	_setup_lights(p_light_cull_result,p_light_cull_count,p_cam_transform.affine_inverse(),p_cam_projection,p_shadow_atlas);
+	_setup_reflections(p_reflection_probe_cull_result,p_reflection_probe_cull_count,p_cam_transform.affine_inverse(),p_cam_projection,p_reflection_atlas,env);
+
+	render_list.clear();
+
+
+	bool use_mrt=false;
+
+
+	_fill_render_list(p_cull_result,p_cull_count,false);
+	//
+
+
+	glEnable(GL_BLEND);
+	glDepthMask(GL_TRUE);
+	glEnable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+
+	//rendering to a probe cubemap side
+	ReflectionProbeInstance *probe = reflection_probe_instance_owner.getornull(p_reflection_probe);
+	GLuint current_fbo;
+
+
+
+	if (probe) {
+
+		ReflectionAtlas *ref_atlas = reflection_atlas_owner.getptr(probe->atlas);
+		ERR_FAIL_COND(!ref_atlas);
+
+		int target_size=ref_atlas->size/ref_atlas->subdiv;
+
+		int cubemap_index=reflection_cubemaps.size()-1;
+
+		for(int i=reflection_cubemaps.size()-1;i>=0;i--) {
+			//find appropriate cubemap to render to
+			if (reflection_cubemaps[i].size>target_size*2)
+				break;
+
+			cubemap_index=i;
+		}
+
+		current_fbo=reflection_cubemaps[cubemap_index].fbo_id[p_reflection_probe_pass];
+		use_mrt=false;
+		state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+
+		glViewport(0,0,reflection_cubemaps[cubemap_index].size,reflection_cubemaps[cubemap_index].size);
+		glBindFramebuffer(GL_FRAMEBUFFER,current_fbo);
+
+	} else {
+
+		use_mrt = state.used_sss || (env && (env->ssao_enabled || env->ssr_enabled)); //only enable MRT rendering if any of these is enabled
+
+		glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+
+		if (use_mrt) {
+
+			current_fbo=storage->frame.current_rt->buffers.fbo;
+
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
+			state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,true);
+
+
+			Vector<GLenum> draw_buffers;
+			draw_buffers.push_back(GL_COLOR_ATTACHMENT0);
+			draw_buffers.push_back(GL_COLOR_ATTACHMENT1);
+			draw_buffers.push_back(GL_COLOR_ATTACHMENT2);
+			if (state.used_sss) {
+				draw_buffers.push_back(GL_COLOR_ATTACHMENT3);
+			}
+			glDrawBuffers(draw_buffers.size(),draw_buffers.ptr());
+
+			Color black(0,0,0,0);
+			glClearBufferfv(GL_COLOR,1,black.components); // specular
+			glClearBufferfv(GL_COLOR,2,black.components); // normal metal rough
+			if (state.used_sss) {
+				glClearBufferfv(GL_COLOR,3,black.components); // normal metal rough
+			}
+
+		} else {
+
+
+
+			current_fbo = storage->frame.current_rt->buffers.fbo;
+			glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
+			state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+
+			Vector<GLenum> draw_buffers;
+			draw_buffers.push_back(GL_COLOR_ATTACHMENT0);
+			glDrawBuffers(draw_buffers.size(),draw_buffers.ptr());
+
+		}
+	}
+
+	if (!fb_cleared) {
+		glClearDepth(1.0);
+		glClear(GL_DEPTH_BUFFER_BIT);
+	}
+
+	Color clear_color(0,0,0,0);
+
+	RasterizerStorageGLES3::SkyBox *skybox=NULL;
+	GLuint env_radiance_tex=0;
+
+	if (!env || env->bg_mode==VS::ENV_BG_CLEAR_COLOR) {
+
+		if (storage->frame.clear_request) {
+
+			clear_color = storage->frame.clear_request_color.to_linear();
+			storage->frame.clear_request=false;
+
+		}
+
+	} else if (env->bg_mode==VS::ENV_BG_COLOR) {
+
+		clear_color = env->bg_color.to_linear();
+		storage->frame.clear_request=false;
+	} else if (env->bg_mode==VS::ENV_BG_SKYBOX) {
+
+		skybox = storage->skybox_owner.getornull(env->skybox);
+
+		if (skybox) {
+			env_radiance_tex=skybox->radiance;
+		}
+		storage->frame.clear_request=false;
+
+	} else {
+		storage->frame.clear_request=false;
+	}
+
+	glClearBufferfv(GL_COLOR,0,clear_color.components); // specular
+
+
+	state.texscreen_copied=false;
+
+	glBlendEquation(GL_FUNC_ADD);
+
+	if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	} else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+
+	glDisable(GL_BLEND);
+
+	render_list.sort_by_key(false);
+
+	if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	} else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+
+
+
+	if (state.directional_light_count==0) {
+		directional_light=NULL;
+		_render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,false,false,false,shadow_atlas!=NULL);
+	} else {
+		for(int i=0;i<state.directional_light_count;i++) {
+			directional_light=directional_lights[i];
+			if (i>0) {
+				glEnable(GL_BLEND);
+			}
+			_setup_directional_light(i,p_cam_transform.affine_inverse(),shadow_atlas!=NULL);
+			_render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,false,false,i>0,shadow_atlas!=NULL);
+
+		}
+	}
+
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+
+	if (use_mrt) {
+		GLenum gldb = GL_COLOR_ATTACHMENT0;
+		glDrawBuffers(1,&gldb);
+	}
+
+	if (env && env->bg_mode==VS::ENV_BG_SKYBOX) {
+
+		//if (use_mrt) {
+		//	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo); //switch to alpha fbo for skybox, only diffuse/ambient matters
+		//
+
+		_draw_skybox(skybox,p_cam_projection,p_cam_transform,storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP],env->skybox_scale);
+	}
+
+
+
+
+
+	//_render_list_forward(&alpha_render_list,camera_transform,camera_transform_inverse,camera_projection,false,fragment_lighting,true);
+	//glColorMask(1,1,1,1);
+
+//	state.scene_shader.set_conditional( SceneShaderGLES3::USE_FOG,false);
+
+
+	if (use_mrt) {
+		_render_mrts(env,p_cam_projection);
+	}
+
+	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
+	glEnable(GL_BLEND);
+	glDepthMask(GL_TRUE);
+	glEnable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+
+	render_list.sort_by_depth(true);
+
+	if (state.directional_light_count==0) {
+		directional_light=NULL;
+		_render_list(&render_list.elements[render_list.max_elements-render_list.alpha_element_count],render_list.alpha_element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,true,false,false,shadow_atlas!=NULL);
+	} else {
+		for(int i=0;i<state.directional_light_count;i++) {
+			directional_light=directional_lights[i];
+			_setup_directional_light(i,p_cam_transform.affine_inverse(),shadow_atlas!=NULL);
+			_render_list(&render_list.elements[render_list.max_elements-render_list.alpha_element_count],render_list.alpha_element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,true,false,i>0,shadow_atlas!=NULL);
+
+		}
+	}
+
+	if (probe) {
+		//rendering a probe, do no more!
+		return;
+	}
+
+
+	_post_process(env,p_cam_projection);
+
+
+	if (false && shadow_atlas) {
+
+		//_copy_texture_to_front_buffer(shadow_atlas->depth);
+		storage->canvas->canvas_begin();
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,shadow_atlas->depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+		storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
+
+	}
+
+	if (false && storage->frame.current_rt) {
+
+		//_copy_texture_to_front_buffer(shadow_atlas->depth);
+		storage->canvas->canvas_begin();
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,exposure_shrink[4].color);
+//		glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
+		storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/16,storage->frame.current_rt->height/16),Rect2(0,0,1,1));
+
+	}
+
+	if (false && reflection_atlas && storage->frame.current_rt) {
+
+		//_copy_texture_to_front_buffer(shadow_atlas->depth);
+		storage->canvas->canvas_begin();
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,reflection_atlas->color);
+		storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
+
+	}
+
+	if (false && directional_shadow.fbo) {
+
+		//_copy_texture_to_front_buffer(shadow_atlas->depth);
+		storage->canvas->canvas_begin();
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+		storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
+
+	}
+
+	if (false && env_radiance_tex) {
+
+			//_copy_texture_to_front_buffer(shadow_atlas->depth);
+			storage->canvas->canvas_begin();
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D,env_radiance_tex);
+			storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
+
+	}
+
+
+#if 0
+	if (use_fb) {
+
+
+
+		for(int i=0;i<VS::ARRAY_MAX;i++) {
+			glDisableVertexAttribArray(i);
+		}
+		glBindBuffer(GL_ARRAY_BUFFER,0);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+		glDisable(GL_BLEND);
+		glDisable(GL_DEPTH_TEST);
+		glDisable(GL_CULL_FACE);
+		glDisable(GL_SCISSOR_TEST);
+		glDepthMask(false);
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR]) {
+
+			int hdr_tm = current_env->fx_param[VS::ENV_FX_PARAM_HDR_TONEMAPPER];
+			switch(hdr_tm) {
+				case VS::ENV_FX_HDR_TONE_MAPPER_LINEAR: {
+
+
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_LOG: {
+					copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,true);
+
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT: {
+					copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT_AUTOWHITE: {
+
+					copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+					copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,true);
+				} break;
+			}
+
+
+			_process_hdr();
+		}
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
+			_process_glow_bloom();
+			int glow_transfer_mode=current_env->fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_BLEND_MODE];
+			if (glow_transfer_mode==1)
+				copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SCREEN,true);
+			if (glow_transfer_mode==2)
+				copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SOFTLIGHT,true);
+		}
+
+		glBindFramebuffer(GL_FRAMEBUFFER, current_rt?current_rt->fbo:base_framebuffer);
+
+		Size2 size;
+		if (current_rt) {
+			glBindFramebuffer(GL_FRAMEBUFFER, current_rt->fbo);
+			glViewport( 0,0,viewport.width,viewport.height);
+			size=Size2(viewport.width,viewport.height);
+		} else {
+			glBindFramebuffer(GL_FRAMEBUFFER, base_framebuffer);
+			glViewport( viewport.x, window_size.height-(viewport.height+viewport.y), viewport.width,viewport.height );
+			size=Size2(viewport.width,viewport.height);
+		}
+
+		//time to copy!!!
+		copy_shader.set_conditional(CopyShaderGLES2::USE_BCS,current_env && current_env->fx_enabled[VS::ENV_FX_BCS]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_SRGB,current_env && current_env->fx_enabled[VS::ENV_FX_SRGB]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW,current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_HDR,current_env && current_env->fx_enabled[VS::ENV_FX_HDR]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_NO_ALPHA,true);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_FXAA,current_env && current_env->fx_enabled[VS::ENV_FX_FXAA]);
+
+		copy_shader.bind();
+		//copy_shader.set_uniform(CopyShaderGLES2::SOURCE,0);
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
+
+			glActiveTexture(GL_TEXTURE1);
+			glBindTexture(GL_TEXTURE_2D, framebuffer.blur[0].color );
+			glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::GLOW_SOURCE),1);
+
+		}
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR]) {
+
+			glActiveTexture(GL_TEXTURE2);
+			glBindTexture(GL_TEXTURE_2D, current_vd->lum_color );
+			glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::HDR_SOURCE),2);
+			copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_EXPOSURE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]));
+			copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_WHITE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_WHITE]));
+
+		}
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_FXAA])
+			copy_shader.set_uniform(CopyShaderGLES2::PIXEL_SIZE,Size2(1.0/size.x,1.0/size.y));
+
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_BCS]) {
+
+			Vector3 bcs;
+			bcs.x=current_env->fx_param[VS::ENV_FX_PARAM_BCS_BRIGHTNESS];
+			bcs.y=current_env->fx_param[VS::ENV_FX_PARAM_BCS_CONTRAST];
+			bcs.z=current_env->fx_param[VS::ENV_FX_PARAM_BCS_SATURATION];
+			copy_shader.set_uniform(CopyShaderGLES2::BCS,bcs);
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, framebuffer.color );
+		glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::SOURCE),0);
+
+		_copy_screen_quad();
+
+		copy_shader.set_conditional(CopyShaderGLES2::USE_BCS,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_SRGB,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_HDR,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_NO_ALPHA,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_FXAA,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SCREEN,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SOFTLIGHT,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,false);
+
+		state.scene_shader.set_conditional(SceneShaderGLES3::USE_8BIT_HDR,false);
+
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR] && GLOBAL_DEF("rasterizer/debug_hdr",false)) {
+			_debug_luminances();
+		}
+	}
+
+	current_env=NULL;
+	current_debug=VS::SCENARIO_DEBUG_DISABLED;
+	if (GLOBAL_DEF("rasterizer/debug_shadow_maps",false)) {
+		_debug_shadows();
+	}
+//	_debug_luminances();
+//	_debug_samplers();
+
+	if (using_canvas_bg) {
+		using_canvas_bg=false;
+		glColorMask(1,1,1,1); //don't touch alpha
+	}
+#endif
+}
+
+void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pass,InstanceBase** p_cull_result,int p_cull_count) {
+
+	render_pass++;
+
+	directional_light=NULL;
+
+	LightInstance *light_instance = light_instance_owner.getornull(p_light);
+	ERR_FAIL_COND(!light_instance);
+	RasterizerStorageGLES3::Light *light = storage->light_owner.getornull(light_instance->light);
+	ERR_FAIL_COND(!light);
+
+	uint32_t x,y,width,height,vp_height;
+
+
+	float dp_direction=0.0;
+	float zfar=0;
+	bool flip_facing=false;
+	int custom_vp_size=0;
+	GLuint fbo;
+	int current_cubemap=-1;
+	float bias=0;
+	float normal_bias=0;
+
+	CameraMatrix light_projection;
+	Transform light_transform;
+
+
+	if (light->type==VS::LIGHT_DIRECTIONAL) {
+		//set pssm stuff
+		if (light_instance->last_scene_shadow_pass!=scene_pass) {
+			//assign rect if unassigned
+			light_instance->light_directional_index = directional_shadow.current_light;
+			light_instance->last_scene_shadow_pass=scene_pass;
+			directional_shadow.current_light++;
+
+			if (directional_shadow.light_count==1) {
+				light_instance->directional_rect=Rect2(0,0,directional_shadow.size,directional_shadow.size);
+			} else if (directional_shadow.light_count==2) {
+				light_instance->directional_rect=Rect2(0,0,directional_shadow.size,directional_shadow.size/2);
+				if (light_instance->light_directional_index==1) {
+					light_instance->directional_rect.pos.x+=light_instance->directional_rect.size.x;
+				}
+			} else  { //3 and 4
+				light_instance->directional_rect=Rect2(0,0,directional_shadow.size/2,directional_shadow.size/2);
+				if (light_instance->light_directional_index&1) {
+					light_instance->directional_rect.pos.x+=light_instance->directional_rect.size.x;
+				}
+				if (light_instance->light_directional_index/2) {
+					light_instance->directional_rect.pos.y+=light_instance->directional_rect.size.y;
+				}
+			}
+		}
+
+		light_projection=light_instance->shadow_transform[p_pass].camera;
+		light_transform=light_instance->shadow_transform[p_pass].transform;
+
+		x=light_instance->directional_rect.pos.x;
+		y=light_instance->directional_rect.pos.y;
+		width=light_instance->directional_rect.size.x;
+		height=light_instance->directional_rect.size.y;
+
+
+
+		if (light->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+
+
+			width/=2;
+			height/=2;
+
+			if (p_pass==0) {
+
+			} else if (p_pass==1) {
+				x+=width;
+			} else if (p_pass==2) {
+				y+=height;
+			} else if (p_pass==3) {
+				x+=width;
+				y+=height;
+
+			}
+
+
+
+		} else if (light->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+
+			height/=2;
+
+			if (p_pass==0) {
+
+			} else {
+				y+=height;
+			}
+
+		}
+
+		zfar=light->param[VS::LIGHT_PARAM_RANGE];
+		bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+		normal_bias=light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
+		fbo=directional_shadow.fbo;
+		vp_height=directional_shadow.size;
+
+	} else {
+		//set from shadow atlas
+
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+		ERR_FAIL_COND(!shadow_atlas);
+		ERR_FAIL_COND(!shadow_atlas->shadow_owners.has(p_light));
+
+		fbo=shadow_atlas->fbo;
+		vp_height=shadow_atlas->size;
+
+		uint32_t key = shadow_atlas->shadow_owners[p_light];
+
+		uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
+		uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
+
+		ERR_FAIL_INDEX(shadow,shadow_atlas->quadrants[quadrant].shadows.size());
+
+		uint32_t quadrant_size = shadow_atlas->size>>1;
+
+		x=(quadrant&1)*quadrant_size;
+		y=(quadrant>>1)*quadrant_size;
+
+		uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
+		x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+		y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+
+		width=shadow_size;
+		height=shadow_size;
+
+		if (light->type==VS::LIGHT_OMNI) {
+
+
+			if (light->omni_shadow_mode==VS::LIGHT_OMNI_SHADOW_CUBE) {
+
+				int cubemap_index=shadow_cubemaps.size()-1;
+
+				for(int i=shadow_cubemaps.size()-1;i>=0;i--) {
+					//find appropriate cubemap to render to
+					if (shadow_cubemaps[i].size>shadow_size*2)
+						break;
+
+					cubemap_index=i;
+				}
+
+				fbo=shadow_cubemaps[cubemap_index].fbo_id[p_pass];
+				light_projection=light_instance->shadow_transform[0].camera;
+				light_transform=light_instance->shadow_transform[0].transform;
+				custom_vp_size=shadow_cubemaps[cubemap_index].size;
+				zfar=light->param[VS::LIGHT_PARAM_RANGE];
+
+				current_cubemap=cubemap_index;
+
+
+			} else {
+
+				light_projection=light_instance->shadow_transform[0].camera;
+				light_transform=light_instance->shadow_transform[0].transform;
+
+				if (light->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+
+					height/=2;
+					y+=p_pass*height;
+				} else {
+					width/=2;
+					x+=p_pass*width;
+
+				}
+
+				dp_direction = p_pass==0?1.0:-1.0;
+				flip_facing = (p_pass == 1);
+				zfar=light->param[VS::LIGHT_PARAM_RANGE];
+				bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+
+				state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID,true);
+			}
+
+		} else if (light->type==VS::LIGHT_SPOT) {
+
+			light_projection=light_instance->shadow_transform[0].camera;
+			light_transform=light_instance->shadow_transform[0].transform;
+
+			dp_direction = 1.0;
+			flip_facing = false;
+			zfar=light->param[VS::LIGHT_PARAM_RANGE];
+			bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+			normal_bias=light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
+		}
+
+	}
+
+	//todo hacer que se redibuje cuando corresponde
+
+
+	render_list.clear();
+	_fill_render_list(p_cull_result,p_cull_count,true);
+
+	render_list.sort_by_depth(false); //shadow is front to back for performance
+
+	glDepthMask(true);
+	glColorMask(1,1,1,1);
+	glDisable(GL_BLEND);
+	glDisable(GL_DITHER);
+	glEnable(GL_DEPTH_TEST);
+	glBindFramebuffer(GL_FRAMEBUFFER,fbo);
+
+	if (custom_vp_size) {
+		glViewport(0,0,custom_vp_size,custom_vp_size);
+		glScissor(0,0,custom_vp_size,custom_vp_size);
+
+
+	} else {
+		glViewport(x,y,width,height);
+		glScissor(x,y,width,height);
+	}
+
+	glEnable(GL_SCISSOR_TEST);
+	glClearDepth(1.0);
+	glClear(GL_DEPTH_BUFFER_BIT);
+	glDisable(GL_SCISSOR_TEST);
+
+	state.ubo_data.shadow_z_offset=bias;
+	state.ubo_data.shadow_slope_scale=normal_bias;
+	state.ubo_data.shadow_dual_paraboloid_render_side=dp_direction;
+	state.ubo_data.shadow_dual_paraboloid_render_zfar=zfar;
+
+	_setup_environment(NULL,light_projection,light_transform);
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,true);
+
+	_render_list(render_list.elements,render_list.element_count,light_transform,light_projection,0,!flip_facing,false,true,false,false);
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,false);
+	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID,false);
+
+
+	if (light->type==VS::LIGHT_OMNI && light->omni_shadow_mode==VS::LIGHT_OMNI_SHADOW_CUBE && p_pass==5) {
+		//convert the chosen cubemap to dual paraboloid!
+
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+
+		glBindFramebuffer(GL_FRAMEBUFFER,shadow_atlas->fbo);
+		state.cube_to_dp_shader.bind();
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_CUBE_MAP,shadow_cubemaps[current_cubemap].cubemap);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+		glDisable(GL_CULL_FACE);
+
+		for(int i=0;i<2;i++) {
+
+			state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FLIP,i==1);
+			state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_NEAR,light_projection.get_z_near());
+			state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FAR,light_projection.get_z_far());
+			state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::BIAS,light->param[VS::LIGHT_PARAM_SHADOW_BIAS]);
+
+			uint32_t local_width=width,local_height=height;
+			uint32_t local_x=x,local_y=y;
+			if (light->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+
+				local_height/=2;
+				local_y+=i*local_height;
+			} else {
+				local_width/=2;
+				local_x+=i*local_width;
+			}
+
+			glViewport(local_x,local_y,local_width,local_height);
+			glScissor(local_x,local_y,local_width,local_height);
+			glEnable(GL_SCISSOR_TEST);
+			glClearDepth(1.0);
+			glClear(GL_DEPTH_BUFFER_BIT);
+			glDisable(GL_SCISSOR_TEST);
+			//glDisable(GL_DEPTH_TEST);
+			glDisable(GL_BLEND);
+
+			_copy_screen();
+
+		}
+
+	}
+
+	glColorMask(1,1,1,1);
+
+
+}
+
+void RasterizerSceneGLES3::set_scene_pass(uint64_t p_pass) {
+	scene_pass=p_pass;
+}
+
+bool RasterizerSceneGLES3::free(RID p_rid) {
+
+	if (light_instance_owner.owns(p_rid)) {
+
+
+		LightInstance *light_instance = light_instance_owner.getptr(p_rid);
+
+		//remove from shadow atlases..
+		for(Set<RID>::Element *E=light_instance->shadow_atlases.front();E;E=E->next()) {
+			ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(E->get());
+			ERR_CONTINUE(!shadow_atlas->shadow_owners.has(p_rid));
+			uint32_t key = shadow_atlas->shadow_owners[p_rid];
+			uint32_t q = (key>>ShadowAtlas::QUADRANT_SHIFT)&0x3;
+			uint32_t s = key&ShadowAtlas::SHADOW_INDEX_MASK;
+
+			shadow_atlas->quadrants[q].shadows[s].owner=RID();
+			shadow_atlas->shadow_owners.erase(p_rid);
+		}
+
+
+		light_instance_owner.free(p_rid);
+		memdelete(light_instance);
+
+	} else if (shadow_atlas_owner.owns(p_rid)) {
+
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(p_rid);
+		shadow_atlas_set_size(p_rid,0);
+		shadow_atlas_owner.free(p_rid);
+		memdelete(shadow_atlas);
+	} else if (reflection_atlas_owner.owns(p_rid)) {
+
+		ReflectionAtlas *reflection_atlas = reflection_atlas_owner.get(p_rid);
+		reflection_atlas_set_size(p_rid,0);
+		reflection_atlas_owner.free(p_rid);
+		memdelete(reflection_atlas);
+	} else if (reflection_probe_instance_owner.owns(p_rid)) {
+
+		ReflectionProbeInstance *reflection_instance = reflection_probe_instance_owner.get(p_rid);
+
+		reflection_probe_release_atlas_index(p_rid);
+		reflection_probe_instance_owner.free(p_rid);
+		memdelete(reflection_instance);
+
+	} else {
+		return false;
+	}
+
+
+	return true;
+
+}
+
+// http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
+static _FORCE_INLINE_ float radicalInverse_VdC(uint32_t bits) {
+      bits = (bits << 16u) | (bits >> 16u);
+      bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+      bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+      bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+      bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+      return float(bits) * 2.3283064365386963e-10f; // / 0x100000000
+}
+
+static _FORCE_INLINE_ Vector2 Hammersley(uint32_t i, uint32_t N) {
+      return Vector2(float(i) / float(N), radicalInverse_VdC(i));
+}
+
+static _FORCE_INLINE_ Vector3 ImportanceSampleGGX(Vector2 Xi, float Roughness, Vector3 N) {
+      float a = Roughness * Roughness; // DISNEY'S ROUGHNESS [see Burley'12 siggraph]
+
+      // Compute distribution direction
+      float Phi = 2.0f * Math_PI * Xi.x;
+      float CosTheta = Math::sqrt((1.0f - Xi.y) / (1.0f + (a*a - 1.0f) * Xi.y));
+      float SinTheta = Math::sqrt((float)Math::abs(1.0f - CosTheta * CosTheta));
+
+      // Convert to spherical direction
+      Vector3 H;
+      H.x = SinTheta * Math::cos(Phi);
+      H.y = SinTheta * Math::sin(Phi);
+      H.z = CosTheta;
+
+      Vector3 UpVector = Math::abs(N.z) < 0.999 ? Vector3(0.0, 0.0, 1.0) : Vector3(1.0, 0.0, 0.0);
+      Vector3 TangentX = UpVector.cross(N);
+      TangentX.normalize();
+      Vector3 TangentY = N.cross(TangentX);
+
+      // Tangent to world space
+      return TangentX * H.x + TangentY * H.y + N * H.z;
+}
+
+static _FORCE_INLINE_ float GGX(float NdotV, float a) {
+	float k = a / 2.0;
+	return NdotV / (NdotV * (1.0 - k) + k);
+}
+
+// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
+float _FORCE_INLINE_ G_Smith(float a, float nDotV, float nDotL)
+{
+	return GGX(nDotL, a * a) * GGX(nDotV, a * a);
+}
+
+void RasterizerSceneGLES3::_generate_brdf() {
+
+	int brdf_size=GLOBAL_DEF("rendering/gles3/brdf_texture_size",64);
+
+
+
+	DVector<uint8_t> brdf;
+	brdf.resize(brdf_size*brdf_size*2);
+
+	DVector<uint8_t>::Write w = brdf.write();
+
+
+	for(int i=0;i<brdf_size;i++) {
+		for(int j=0;j<brdf_size;j++) {
+
+			float Roughness = float(j)/(brdf_size-1);
+			float NoV       = float(i+1)/(brdf_size); //avoid storing nov0
+
+			Vector3 V;
+			V.x = Math::sqrt( 1.0 - NoV * NoV );
+			V.y = 0.0;
+			V.z = NoV;
+
+			Vector3 N = Vector3(0.0, 0.0, 1.0);
+
+			float A = 0;
+			float B = 0;
+
+			for(int s=0;s<512;s++) {
+
+
+				Vector2 xi = Hammersley(s,512);
+				Vector3 H  = ImportanceSampleGGX( xi, Roughness, N );
+				Vector3 L  = 2.0 * V.dot(H) * H - V;
+
+				float NoL = CLAMP( L.z, 0.0, 1.0 );
+				float NoH = CLAMP( H.z, 0.0, 1.0 );
+				float VoH = CLAMP( V.dot(H), 0.0, 1.0 );
+
+				if ( NoL > 0.0 ) {
+					float G     = G_Smith( Roughness, NoV, NoL );
+					float G_Vis = G * VoH / (NoH * NoV);
+					float Fc    = pow(1.0 - VoH, 5.0);
+
+					A += (1.0 - Fc) * G_Vis;
+					B += Fc * G_Vis;
+				}
+			}
+
+			A/=512.0;
+			B/=512.0;
+
+			int tofs = ((brdf_size-j-1)*brdf_size+i)*2;
+			w[tofs+0]=CLAMP(A*255,0,255);
+			w[tofs+1]=CLAMP(B*255,0,255);
+		}
+	}
+
+
+	//set up brdf texture
+
+
+	glGenTextures(1, &state.brdf_texture);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,state.brdf_texture);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, brdf_size, brdf_size, 0, GL_RG, GL_UNSIGNED_BYTE,w.ptr());
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glBindTexture(GL_TEXTURE_2D,0);
+
+}
+
+void RasterizerSceneGLES3::initialize() {
+
+
+	render_pass=0;
+
+	state.scene_shader.init();
+
+	default_shader = storage->shader_create(VS::SHADER_SPATIAL);
+	default_material = storage->material_create();
+	storage->material_set_shader(default_material,default_shader);
+
+	default_shader_twosided = storage->shader_create(VS::SHADER_SPATIAL);
+	default_material_twosided = storage->material_create();
+	storage->shader_set_code(default_shader_twosided,"render_mode cull_disabled;\n");
+	storage->material_set_shader(default_material_twosided,default_shader_twosided);
+
+
+	glGenBuffers(1, &state.scene_ubo);
+	glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(State::SceneDataUBO), &state.scene_ubo, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	glGenBuffers(1, &state.env_radiance_ubo);
+	glBindBuffer(GL_UNIFORM_BUFFER, state.env_radiance_ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(State::EnvironmentRadianceUBO), &state.env_radiance_ubo, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+
+	render_list.max_elements=GLOBAL_DEF("rendering/gles3/max_renderable_elements",(int)RenderList::DEFAULT_MAX_ELEMENTS);
+	if (render_list.max_elements>1000000)
+		render_list.max_elements=1000000;
+	if (render_list.max_elements<1024)
+		render_list.max_elements=1024;
+
+
+
+	{
+		//quad buffers
+
+		glGenBuffers(1,&state.skybox_verts);
+		glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
+		glBufferData(GL_ARRAY_BUFFER,sizeof(Vector3)*8,NULL,GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+
+		glGenVertexArrays(1,&state.skybox_array);
+		glBindVertexArray(state.skybox_array);
+		glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
+		glVertexAttribPointer(VS::ARRAY_VERTEX,3,GL_FLOAT,GL_FALSE,sizeof(Vector3)*2,0);
+		glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+		glVertexAttribPointer(VS::ARRAY_TEX_UV,3,GL_FLOAT,GL_FALSE,sizeof(Vector3)*2,((uint8_t*)NULL)+sizeof(Vector3));
+		glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+	}
+	render_list.init();
+	state.cube_to_dp_shader.init();
+	_generate_brdf();
+
+	shadow_atlas_realloc_tolerance_msec=500;
+
+
+
+
+
+	int max_shadow_cubemap_sampler_size=512;
+
+	int cube_size = max_shadow_cubemap_sampler_size;
+
+	glActiveTexture(GL_TEXTURE0);
+
+	while(cube_size>=32) {
+
+		ShadowCubeMap cube;
+		cube.size=cube_size;
+
+		glGenTextures(1,&cube.cubemap);
+		glBindTexture(GL_TEXTURE_CUBE_MAP,cube.cubemap);
+		//gen cubemap first
+		for(int i=0;i<6;i++) {
+
+			glTexImage2D(_cube_side_enum[i], 0, GL_DEPTH_COMPONENT,  cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		}
+
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		// Remove artifact on the edges of the shadowmap
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+		//gen renderbuffers second, because it needs a complete cubemap
+		for(int i=0;i<6;i++) {
+
+			glGenFramebuffers(1, &cube.fbo_id[i]);
+			glBindFramebuffer(GL_FRAMEBUFFER, cube.fbo_id[i]);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,_cube_side_enum[i], cube.cubemap, 0);
+
+			GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+			ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+		}
+
+		shadow_cubemaps.push_back(cube);
+
+		cube_size>>=1;
+	}
+
+	{
+		//directional light shadow
+		directional_shadow.light_count=0;
+		directional_shadow.size=nearest_power_of_2(GLOBAL_DEF("renderer/directional_shadow_size",2048));
+		glGenFramebuffers(1,&directional_shadow.fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER,directional_shadow.fbo);
+		glGenTextures(1,&directional_shadow.depth);
+		glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,  directional_shadow.size, directional_shadow.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, directional_shadow.depth, 0);
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		if (status!=GL_FRAMEBUFFER_COMPLETE) {
+			ERR_PRINT("Directional shadow framebuffer status invalid");
+		}
+	}
+
+	{
+		//spot and omni ubos
+
+		int max_ubo_size;
+		glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE,&max_ubo_size);
+		const int ubo_light_size=160;
+		state.ubo_light_size=ubo_light_size;
+		state.max_ubo_lights=MIN(RenderList::MAX_LIGHTS,max_ubo_size/ubo_light_size);
+		print_line("max ubo light: "+itos(state.max_ubo_lights));
+
+		state.spot_array_tmp = (uint8_t*)memalloc(ubo_light_size*state.max_ubo_lights);
+		state.omni_array_tmp = (uint8_t*)memalloc(ubo_light_size*state.max_ubo_lights);
+
+
+		glGenBuffers(1, &state.spot_array_ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, state.spot_array_ubo);
+		glBufferData(GL_UNIFORM_BUFFER, ubo_light_size*state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		glGenBuffers(1, &state.omni_array_ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, state.omni_array_ubo);
+		glBufferData(GL_UNIFORM_BUFFER, ubo_light_size*state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		glGenBuffers(1, &state.directional_ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, state.directional_ubo);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(LightDataUBO), NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		state.max_forward_lights_per_object=8;
+
+
+		state.scene_shader.add_custom_define("#define MAX_LIGHT_DATA_STRUCTS "+itos(state.max_ubo_lights)+"\n");
+		state.scene_shader.add_custom_define("#define MAX_FORWARD_LIGHTS "+itos(state.max_forward_lights_per_object)+"\n");
+
+		state.max_ubo_reflections=MIN(RenderList::MAX_REFLECTIONS,max_ubo_size/sizeof(ReflectionProbeDataUBO));
+		print_line("max ubo reflections: "+itos(state.max_ubo_reflections)+"  ubo size: "+itos(sizeof(ReflectionProbeDataUBO)));
+
+		state.reflection_array_tmp = (uint8_t*)memalloc(sizeof(ReflectionProbeDataUBO)*state.max_ubo_reflections);
+
+		glGenBuffers(1, &state.reflection_array_ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, state.reflection_array_ubo);
+		glBufferData(GL_UNIFORM_BUFFER, sizeof(ReflectionProbeDataUBO)*state.max_ubo_reflections, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+		state.scene_shader.add_custom_define("#define MAX_REFLECTION_DATA_STRUCTS "+itos(state.max_ubo_reflections)+"\n");
+
+		state.max_skeleton_bones=MIN(2048,max_ubo_size/(12*sizeof(float)));
+		state.scene_shader.add_custom_define("#define MAX_SKELETON_BONES "+itos(state.max_skeleton_bones)+"\n");
+
+
+	}
+
+	GLOBAL_DEF("rendering/gles3/shadow_filter_mode",1);
+	Globals::get_singleton()->set_custom_property_info("rendering/gles3/shadow_filter_mode",PropertyInfo(Variant::INT,"rendering/gles3/shadow_filter_mode",PROPERTY_HINT_ENUM,"Disabled,PCF5,PCF13"));
+	shadow_filter_mode=SHADOW_FILTER_NEAREST;
+
+	{ //reflection cubemaps
+		int max_reflection_cubemap_sampler_size=512;
+
+		int cube_size = max_reflection_cubemap_sampler_size;
+
+		glActiveTexture(GL_TEXTURE0);
+
+		bool use_float=true;
+
+		GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+		GLenum format = GL_RGBA;
+		GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+
+		while(cube_size>=32) {
+
+			ReflectionCubeMap cube;
+			cube.size=cube_size;
+
+			glGenTextures(1,&cube.depth);
+			glBindTexture(GL_TEXTURE_2D,cube.depth);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,  cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+
+			glGenTextures(1,&cube.cubemap);
+			glBindTexture(GL_TEXTURE_CUBE_MAP,cube.cubemap);
+			//gen cubemap first
+			for(int i=0;i<6;i++) {
+
+				glTexImage2D(_cube_side_enum[i], 0, internal_format,  cube.size, cube.size, 0, format, type, NULL);
+			}
+
+			glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			// Remove artifact on the edges of the reflectionmap
+			glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+			glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+			//gen renderbuffers second, because it needs a complete cubemap
+			for(int i=0;i<6;i++) {
+
+				glGenFramebuffers(1, &cube.fbo_id[i]);
+				glBindFramebuffer(GL_FRAMEBUFFER, cube.fbo_id[i]);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,_cube_side_enum[i], cube.cubemap, 0);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, cube.depth, 0);
+
+				GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+				ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+			}
+
+			reflection_cubemaps.push_back(cube);
+
+			cube_size>>=1;
+		}
+	}
+
+	{
+
+
+		uint32_t immediate_buffer_size=GLOBAL_DEF("rendering/gles3/immediate_buffer_size_kb",2048);
+
+		glGenBuffers(1, &state.immediate_buffer);
+		glBindBuffer(GL_ARRAY_BUFFER, state.immediate_buffer);
+		glBufferData(GL_ARRAY_BUFFER, immediate_buffer_size*1024, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		glGenVertexArrays(1,&state.immediate_array);
+
+
+
+	}
+
+#ifdef GLES_OVER_GL
+//"desktop" opengl needs this.
+	glEnable(GL_PROGRAM_POINT_SIZE);
+
+#endif
+
+	state.resolve_shader.init();
+	state.ssr_shader.init();
+	state.effect_blur_shader.init();
+	state.sss_shader.init();
+	state.ssao_minify_shader.init();
+	state.ssao_shader.init();
+	state.ssao_blur_shader.init();
+	state.exposure_shader.init();
+	state.tonemap_shader.init();
+
+
+	{
+		GLOBAL_DEF("rendering/gles3/subsurface_scattering/quality",1);
+		Globals::get_singleton()->set_custom_property_info("rendering/gles3/subsurface_scattering/quality",PropertyInfo(Variant::INT,"rendering/gles3/subsurface_scattering/quality",PROPERTY_HINT_ENUM,"Low,Medium,High"));
+		GLOBAL_DEF("rendering/gles3/subsurface_scattering/max_size",1.0);
+		Globals::get_singleton()->set_custom_property_info("rendering/gles3/subsurface_scattering/max_size",PropertyInfo(Variant::INT,"rendering/gles3/subsurface_scattering/max_size",PROPERTY_HINT_RANGE,"0.01,8,0.01"));
+		GLOBAL_DEF("rendering/gles3/subsurface_scattering/follow_surface",false);
+
+		GLOBAL_DEF("rendering/gles3/high_quality_vct_gi",true);
+
+
+	}
+
+	exposure_shrink_size=243;
+	int max_exposure_shrink_size=exposure_shrink_size;
+
+	while(max_exposure_shrink_size>0) {
+
+		RasterizerStorageGLES3::RenderTarget::Exposure e;
+
+		glGenFramebuffers(1, &e.fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, e.fbo);
+
+		glGenTextures(1, &e.color);
+		glBindTexture(GL_TEXTURE_2D, e.color);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F,  max_exposure_shrink_size, max_exposure_shrink_size, 0, GL_RED, GL_FLOAT, NULL);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  e.color, 0);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		exposure_shrink.push_back(e);
+		max_exposure_shrink_size/=3;
+
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+
+
+	}
+
+}
+
+void RasterizerSceneGLES3::iteration() {
+
+	shadow_filter_mode=ShadowFilterMode(int(Globals::get_singleton()->get("rendering/gles3/shadow_filter_mode")));
+	subsurface_scatter_follow_surface=Globals::get_singleton()->get("rendering/gles3/subsurface_scattering/follow_surface");
+	subsurface_scatter_quality=SubSurfaceScatterQuality(int(Globals::get_singleton()->get("rendering/gles3/subsurface_scattering/quality")));
+	subsurface_scatter_size=Globals::get_singleton()->get("rendering/gles3/subsurface_scattering/max_size");
+
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::VCT_QUALITY_HIGH,Globals::get_singleton()->get("rendering/gles3/high_quality_vct_gi"));
+}
+
+void RasterizerSceneGLES3::finalize(){
+
+
+}
+
+
+RasterizerSceneGLES3::RasterizerSceneGLES3()
+{
+
+}

drivers/gles3/rasterizer_scene_gles3.h

@@ -0,0 +1,733 @@
+#ifndef RASTERIZERSCENEGLES3_H
+#define RASTERIZERSCENEGLES3_H
+
+#include "rasterizer_storage_gles3.h"
+#include "drivers/gles3/shaders/scene.glsl.h"
+#include "drivers/gles3/shaders/cube_to_dp.glsl.h"
+#include "drivers/gles3/shaders/resolve.glsl.h"
+#include "drivers/gles3/shaders/screen_space_reflection.glsl.h"
+#include "drivers/gles3/shaders/effect_blur.glsl.h"
+#include "drivers/gles3/shaders/subsurf_scattering.glsl.h"
+#include "drivers/gles3/shaders/ssao_minify.glsl.h"
+#include "drivers/gles3/shaders/ssao.glsl.h"
+#include "drivers/gles3/shaders/ssao_blur.glsl.h"
+#include "drivers/gles3/shaders/exposure.glsl.h"
+#include "drivers/gles3/shaders/tonemap.glsl.h"
+
+class RasterizerSceneGLES3 : public RasterizerScene {
+public:
+
+	enum ShadowFilterMode {
+		SHADOW_FILTER_NEAREST,
+		SHADOW_FILTER_PCF5,
+		SHADOW_FILTER_PCF13,
+	};
+
+
+	ShadowFilterMode shadow_filter_mode;
+
+	uint64_t shadow_atlas_realloc_tolerance_msec;
+
+	enum SubSurfaceScatterQuality {
+		SSS_QUALITY_LOW,
+		SSS_QUALITY_MEDIUM,
+		SSS_QUALITY_HIGH,
+	};
+
+	SubSurfaceScatterQuality subsurface_scatter_quality;
+	float subsurface_scatter_size;
+	bool subsurface_scatter_follow_surface;
+
+	uint64_t render_pass;
+	uint64_t scene_pass;
+	uint32_t current_material_index;
+	uint32_t current_geometry_index;
+
+	RID default_material;
+	RID default_material_twosided;
+	RID default_shader;
+	RID default_shader_twosided;
+
+	RasterizerStorageGLES3 *storage;
+
+	Vector<RasterizerStorageGLES3::RenderTarget::Exposure> exposure_shrink;
+	int exposure_shrink_size;
+
+	struct State {
+
+
+
+		bool texscreen_copied;
+		int current_blend_mode;
+		float current_line_width;
+		int current_depth_draw;
+		GLuint current_main_tex;
+
+		SceneShaderGLES3 scene_shader;
+		CubeToDpShaderGLES3 cube_to_dp_shader;
+		ResolveShaderGLES3 resolve_shader;
+		ScreenSpaceReflectionShaderGLES3 ssr_shader;
+		EffectBlurShaderGLES3 effect_blur_shader;
+		SubsurfScatteringShaderGLES3 sss_shader;
+		SsaoMinifyShaderGLES3 ssao_minify_shader;
+		SsaoShaderGLES3 ssao_shader;
+		SsaoBlurShaderGLES3 ssao_blur_shader;
+		ExposureShaderGLES3 exposure_shader;
+		TonemapShaderGLES3 tonemap_shader;
+
+
+		struct SceneDataUBO {
+
+			float projection_matrix[16];
+			float camera_inverse_matrix[16];
+			float camera_matrix[16];
+			float time[4];
+			float ambient_light_color[4];
+			float bg_color[4];
+			float ambient_energy;
+			float bg_energy;
+			float shadow_z_offset;
+			float shadow_slope_scale;
+			float shadow_dual_paraboloid_render_zfar;
+			float shadow_dual_paraboloid_render_side;
+			float shadow_atlas_pixel_size[2];
+			float shadow_directional_pixel_size[2];
+			float reflection_multiplier;
+			float subsurface_scatter_width;
+			float ambient_occlusion_affect_light;
+
+		} ubo_data;
+
+		GLuint scene_ubo;
+
+		struct EnvironmentRadianceUBO {
+
+			float transform[16];
+			float box_min[4]; //unused for now
+			float box_max[4];
+			float ambient_contribution;
+
+		} env_radiance_data;
+
+		GLuint env_radiance_ubo;
+
+		GLuint brdf_texture;
+
+		GLuint skybox_verts;
+		GLuint skybox_array;
+
+		GLuint directional_ubo;
+
+		GLuint spot_array_ubo;
+		GLuint omni_array_ubo;
+		GLuint reflection_array_ubo;
+
+		GLuint immediate_buffer;
+		GLuint immediate_array;
+
+		uint32_t ubo_light_size;
+		uint8_t *spot_array_tmp;
+		uint8_t *omni_array_tmp;
+		uint8_t *reflection_array_tmp;
+
+		int max_ubo_lights;
+		int max_forward_lights_per_object;
+		int max_ubo_reflections;
+		int max_skeleton_bones;
+
+
+
+		int spot_light_count;
+		int omni_light_count;
+		int directional_light_count;
+		int reflection_probe_count;
+
+		bool cull_front;
+		bool used_sss;
+
+	} state;
+
+
+	/* SHADOW ATLAS API */
+
+	struct ShadowAtlas : public RID_Data {
+
+		enum {
+			QUADRANT_SHIFT=27,
+			SHADOW_INDEX_MASK=(1<<QUADRANT_SHIFT)-1,
+			SHADOW_INVALID=0xFFFFFFFF
+		};
+
+		struct Quadrant {
+
+			uint32_t subdivision;
+
+			struct Shadow {
+				RID owner;
+				uint64_t version;
+				uint64_t alloc_tick;
+
+				Shadow() {
+					version=0;
+					alloc_tick=0;
+				}
+			};
+
+			Vector<Shadow> shadows;
+
+			Quadrant() {
+				subdivision=0; //not in use
+			}
+
+		} quadrants[4];
+
+		int size_order[4];
+		uint32_t smallest_subdiv;
+
+		int size;
+
+		GLuint fbo;
+		GLuint depth;
+
+		Map<RID,uint32_t> shadow_owners;
+	};
+
+	struct ShadowCubeMap {
+
+		GLuint fbo_id[6];
+		GLuint cubemap;
+		int size;
+	};
+
+	Vector<ShadowCubeMap> shadow_cubemaps;
+
+	RID_Owner<ShadowAtlas> shadow_atlas_owner;
+
+	RID shadow_atlas_create();
+	void shadow_atlas_set_size(RID p_atlas,int p_size);
+	void shadow_atlas_set_quadrant_subdivision(RID p_atlas,int p_quadrant,int p_subdivision);
+	bool _shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow);
+	bool shadow_atlas_update_light(RID p_atlas,RID p_light_intance,float p_coverage,uint64_t p_light_version);
+
+
+	struct DirectionalShadow {
+		GLuint fbo;
+		GLuint depth;
+		int light_count;
+		int size;
+		int current_light;
+	} directional_shadow;
+
+	virtual int get_directional_light_shadow_size(RID p_light_intance);
+	virtual void set_directional_shadow_count(int p_count);
+
+	/* REFLECTION PROBE ATLAS API */
+
+	struct ReflectionAtlas : public RID_Data {
+
+		int subdiv;
+		int size;
+
+		struct Reflection {
+			RID owner;
+			uint64_t last_frame;
+		};
+
+		GLuint fbo[6];
+		GLuint color;
+
+		Vector<Reflection> reflections;
+	};
+
+	mutable RID_Owner<ReflectionAtlas> reflection_atlas_owner;
+
+	virtual RID reflection_atlas_create();
+	virtual void reflection_atlas_set_size(RID p_ref_atlas,int p_size);
+	virtual void reflection_atlas_set_subdivision(RID p_ref_atlas,int p_subdiv);
+
+	/* REFLECTION CUBEMAPS */
+
+	struct ReflectionCubeMap {
+
+		GLuint fbo_id[6];
+		GLuint cubemap;
+		GLuint depth;
+		int size;
+	};
+
+	Vector<ReflectionCubeMap> reflection_cubemaps;
+
+	/* REFLECTION PROBE INSTANCE */
+
+	struct ReflectionProbeInstance : public RID_Data {
+
+		RasterizerStorageGLES3::ReflectionProbe *probe_ptr;
+		RID probe;
+		RID self;
+		RID atlas;
+
+		int reflection_atlas_index;
+
+		int render_step;
+
+
+
+		uint64_t last_pass;
+		int reflection_index;
+
+		Transform transform;
+	};
+
+	struct ReflectionProbeDataUBO {
+
+		float box_extents[4];
+		float box_ofs[4];
+		float params[4]; // intensity, 0, 0, boxproject
+		float ambient[4]; //color, probe contrib
+		float atlas_clamp[4];
+		float local_matrix[16]; //up to here for spot and omni, rest is for directional
+		//notes: for ambientblend, use distance to edge to blend between already existing global environment
+	};
+
+
+	mutable RID_Owner<ReflectionProbeInstance> reflection_probe_instance_owner;
+
+	virtual RID reflection_probe_instance_create(RID p_probe);
+	virtual void reflection_probe_instance_set_transform(RID p_instance,const Transform& p_transform);
+	virtual void reflection_probe_release_atlas_index(RID p_instance);
+	virtual bool reflection_probe_instance_needs_redraw(RID p_instance);
+	virtual bool reflection_probe_instance_has_reflection(RID p_instance);
+	virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas);
+	virtual bool reflection_probe_instance_postprocess_step(RID p_instance);
+
+
+
+
+	/* ENVIRONMENT API */
+
+	struct Environment : public RID_Data {
+
+		VS::EnvironmentBG bg_mode;
+
+		RID skybox;
+		float skybox_scale;
+
+		Color bg_color;
+		float bg_energy;
+		float skybox_ambient;
+
+		Color ambient_color;
+		float ambient_energy;
+		float ambient_skybox_contribution;
+
+		int canvas_max_layer;
+
+		bool ssr_enabled;
+		int ssr_max_steps;
+		float ssr_accel;
+		float ssr_fade;
+		float ssr_depth_tolerance;
+		bool ssr_smooth;
+		bool ssr_roughness;
+
+
+		bool ssao_enabled;
+		float ssao_intensity;
+		float ssao_radius;
+		float ssao_intensity2;
+		float ssao_radius2;
+		float ssao_bias;
+		float ssao_light_affect;
+		Color ssao_color;
+		bool ssao_filter;
+
+		bool glow_enabled;
+		int glow_levels;
+		float glow_intensity;
+		float glow_strength;
+		float glow_bloom;
+		VS::EnvironmentGlowBlendMode glow_blend_mode;
+		float glow_hdr_bleed_treshold;
+		float glow_hdr_bleed_scale;
+		bool glow_bicubic_upscale;
+
+		VS::EnvironmentToneMapper tone_mapper;
+		float tone_mapper_exposure;
+		float tone_mapper_exposure_white;
+		bool auto_exposure;
+		float auto_exposure_speed;
+		float auto_exposure_min;
+		float auto_exposure_max;
+		float auto_exposure_grey;
+
+		bool dof_blur_far_enabled;
+		float dof_blur_far_distance;
+		float dof_blur_far_transition;
+		float dof_blur_far_amount;
+		VS::EnvironmentDOFBlurQuality dof_blur_far_quality;
+
+		bool dof_blur_near_enabled;
+		float dof_blur_near_distance;
+		float dof_blur_near_transition;
+		float dof_blur_near_amount;
+		VS::EnvironmentDOFBlurQuality dof_blur_near_quality;
+
+		Environment() {
+			bg_mode=VS::ENV_BG_CLEAR_COLOR;
+			skybox_scale=1.0;
+			bg_energy=1.0;
+			skybox_ambient=0;
+			ambient_energy=1.0;
+			ambient_skybox_contribution=0.0;
+			canvas_max_layer=0;
+
+			ssr_enabled=false;
+			ssr_max_steps=64;
+			ssr_accel=0.04;
+			ssr_fade=2.0;
+			ssr_depth_tolerance=0.2;
+			ssr_smooth=true;
+			ssr_roughness=true;
+
+			ssao_enabled=false;
+			ssao_intensity=1.0;
+			ssao_radius=1.0;
+			ssao_intensity2=1.0;
+			ssao_radius2=0.0;
+			ssao_bias=0.01;
+			ssao_light_affect=0;
+			ssao_filter=true;
+
+			tone_mapper=VS::ENV_TONE_MAPPER_LINEAR;
+			tone_mapper_exposure=1.0;
+			tone_mapper_exposure_white=1.0;
+			auto_exposure=false;
+			auto_exposure_speed=0.5;
+			auto_exposure_min=0.05;
+			auto_exposure_max=8;
+			auto_exposure_grey=0.4;
+
+			glow_enabled=false;
+			glow_levels=(1<<2)|(1<<4);
+			glow_intensity=0.8;
+			glow_strength=1.0;
+			glow_bloom=0.0;
+			glow_blend_mode=VS::GLOW_BLEND_MODE_SOFTLIGHT;
+			glow_hdr_bleed_treshold=1.0;
+			glow_hdr_bleed_scale=2.0;
+			glow_bicubic_upscale=false;
+
+			dof_blur_far_enabled=false;
+			dof_blur_far_distance=10;
+			dof_blur_far_transition=5;
+			dof_blur_far_amount=0.1;
+			dof_blur_far_quality=VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
+
+			dof_blur_near_enabled=false;
+			dof_blur_near_distance=2;
+			dof_blur_near_transition=1;
+			dof_blur_near_amount=0.1;
+			dof_blur_near_quality=VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
+
+		}
+	};
+
+	RID_Owner<Environment> environment_owner;
+
+	virtual RID environment_create();
+
+	virtual void environment_set_background(RID p_env,VS::EnvironmentBG p_bg);
+	virtual void environment_set_skybox(RID p_env,RID p_skybox);
+	virtual void environment_set_skybox_scale(RID p_env,float p_scale);
+	virtual void environment_set_bg_color(RID p_env,const Color& p_color);
+	virtual void environment_set_bg_energy(RID p_env,float p_energy);
+	virtual void environment_set_canvas_max_layer(RID p_env,int p_max_layer);
+	virtual void environment_set_ambient_light(RID p_env,const Color& p_color,float p_energy=1.0,float p_skybox_contribution=0.0);
+
+	virtual void environment_set_dof_blur_near(RID p_env,bool p_enable,float p_distance,float p_transition,float p_far_amount,VS::EnvironmentDOFBlurQuality p_quality);
+	virtual void environment_set_dof_blur_far(RID p_env,bool p_enable,float p_distance,float p_transition,float p_far_amount,VS::EnvironmentDOFBlurQuality p_quality);
+	virtual void environment_set_glow(RID p_env,bool p_enable,int p_level_flags,float p_intensity,float p_strength,float p_bloom_treshold,VS::EnvironmentGlowBlendMode p_blend_mode,float p_hdr_bleed_treshold,float p_hdr_bleed_scale,bool p_bicubic_upscale);
+	virtual void environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture);
+
+	virtual void environment_set_ssr(RID p_env,bool p_enable, int p_max_steps,float p_accel,float p_fade,float p_depth_tolerance,bool p_smooth,bool p_roughness);
+	virtual void environment_set_ssao(RID p_env,bool p_enable, float p_radius, float p_radius2, float p_intensity2, float p_intensity, float p_bias, float p_light_affect,const Color &p_color,bool p_blur);
+
+
+	virtual void environment_set_tonemap(RID p_env,VS::EnvironmentToneMapper p_tone_mapper,float p_exposure,float p_white,bool p_auto_exposure,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,float p_auto_exp_scale);
+
+	virtual void environment_set_adjustment(RID p_env,bool p_enable,float p_brightness,float p_contrast,float p_saturation,RID p_ramp);
+
+
+	/* LIGHT INSTANCE */
+
+	struct LightDataUBO {
+
+		float light_pos_inv_radius[4];
+		float light_direction_attenuation[4];
+		float light_color_energy[4];
+		float light_params[4]; //spot attenuation, spot angle, specular, shadow enabled
+		float light_clamp[4];
+		float light_shadow_color[4];
+		float shadow_matrix1[16]; //up to here for spot and omni, rest is for directional
+		float shadow_matrix2[16];
+		float shadow_matrix3[16];
+		float shadow_matrix4[16];
+		float shadow_split_offsets[4];
+
+	};
+
+	struct LightInstance : public RID_Data {
+
+		struct ShadowTransform {
+
+			CameraMatrix camera;
+			Transform transform;
+			float farplane;
+			float split;
+		};
+
+
+
+		ShadowTransform shadow_transform[4];
+
+		RID self;
+		RID light;
+		RasterizerStorageGLES3::Light *light_ptr;
+		Transform transform;
+
+		Vector3 light_vector;
+		Vector3 spot_vector;
+		float linear_att;
+
+		uint64_t shadow_pass;
+		uint64_t last_scene_pass;
+		uint64_t last_scene_shadow_pass;
+		uint64_t last_pass;
+		uint16_t light_index;
+		uint16_t light_directional_index;
+
+		uint32_t current_shadow_atlas_key;
+
+		Vector2 dp;
+
+		Rect2 directional_rect;
+
+
+		Set<RID> shadow_atlases; //shadow atlases where this light is registered
+
+		LightInstance() { }
+
+	};
+
+	mutable RID_Owner<LightInstance> light_instance_owner;
+
+	virtual RID light_instance_create(RID p_light);
+	virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform);
+	virtual void light_instance_set_shadow_transform(RID p_light_instance,const CameraMatrix& p_projection,const Transform& p_transform,float p_far,float p_split,int p_pass);
+	virtual void light_instance_mark_visible(RID p_light_instance);
+
+	/* REFLECTION INSTANCE */
+
+	struct GIProbeInstance : public RID_Data {
+		RID data;
+		RasterizerStorageGLES3::GIProbe *probe;
+		GLuint tex_cache;
+		Vector3 cell_size_cache;
+		Vector3 bounds;
+		Transform transform_to_data;
+
+		GIProbeInstance() { probe=NULL; tex_cache=0; }
+	};
+
+
+
+	mutable RID_Owner<GIProbeInstance> gi_probe_instance_owner;
+
+	virtual RID gi_probe_instance_create();
+	virtual void gi_probe_instance_set_light_data(RID p_probe,RID p_base,RID p_data);
+	virtual void gi_probe_instance_set_transform_to_data(RID p_probe,const Transform& p_xform);
+	virtual void gi_probe_instance_set_bounds(RID p_probe,const Vector3& p_bounds);
+
+	/* RENDER LIST */
+
+	struct RenderList {
+
+		enum {
+			DEFAULT_MAX_ELEMENTS=65536,
+			SORT_FLAG_SKELETON=1,
+			SORT_FLAG_INSTANCING=2,
+			MAX_DIRECTIONAL_LIGHTS=16,
+			MAX_LIGHTS=4096,
+			MAX_REFLECTIONS=1024,
+
+
+			SORT_KEY_DEPTH_LAYER_SHIFT=60,
+			SORT_KEY_UNSHADED_FLAG=uint64_t(1)<<59,
+			SORT_KEY_NO_DIRECTIONAL_FLAG=uint64_t(1)<<58,
+			SORT_KEY_GI_PROBES_FLAG=uint64_t(1)<<57,
+			SORT_KEY_SHADING_SHIFT=57,
+			SORT_KEY_SHADING_MASK=7,
+			SORT_KEY_MATERIAL_INDEX_SHIFT=40,
+			SORT_KEY_GEOMETRY_INDEX_SHIFT=20,
+			SORT_KEY_GEOMETRY_TYPE_SHIFT=15,
+			SORT_KEY_SKELETON_FLAG=2,
+			SORT_KEY_MIRROR_FLAG=1
+
+		};
+
+		int max_elements;
+
+		struct Element {
+
+			RasterizerScene::InstanceBase *instance;
+			RasterizerStorageGLES3::Geometry *geometry;
+			RasterizerStorageGLES3::Material *material;
+			RasterizerStorageGLES3::GeometryOwner *owner;
+			uint64_t sort_key;
+
+		};
+
+
+		Element *_elements;
+		Element **elements;
+
+		int element_count;
+		int alpha_element_count;
+
+
+		void clear() {
+
+			element_count=0;
+			alpha_element_count=0;
+		}
+
+		//should eventually be replaced by radix
+
+		struct SortByKey {
+
+			_FORCE_INLINE_ bool operator()(const Element* A,  const Element* B ) const {
+				return A->sort_key < B->sort_key;
+			}
+		};
+
+		void sort_by_key(bool p_alpha) {
+
+			SortArray<Element*,SortByKey> sorter;
+			if (p_alpha) {
+				sorter.sort(&elements[max_elements-alpha_element_count],alpha_element_count);
+			} else {
+				sorter.sort(elements,element_count);
+			}
+		}
+
+		struct SortByDepth {
+
+			_FORCE_INLINE_ bool operator()(const Element* A,  const Element* B ) const {
+				return A->instance->depth > B->instance->depth;
+			}
+		};
+
+		void sort_by_depth(bool p_alpha) {
+
+			SortArray<Element*,SortByDepth> sorter;
+			if (p_alpha) {
+				sorter.sort(&elements[max_elements-alpha_element_count],alpha_element_count);
+			} else {
+				sorter.sort(elements,element_count);
+			}
+		}
+
+
+		_FORCE_INLINE_ Element* add_element() {
+
+			if (element_count+alpha_element_count>=max_elements)
+				return NULL;
+			elements[element_count]=&_elements[element_count];
+			return elements[element_count++];
+		}
+
+		_FORCE_INLINE_ Element* add_alpha_element() {
+
+			if (element_count+alpha_element_count>=max_elements)
+				return NULL;
+			int idx = max_elements-alpha_element_count-1;
+			elements[idx]=&_elements[idx];
+			alpha_element_count++;
+			return elements[idx];
+		}
+
+		void init() {
+
+			element_count = 0;
+			alpha_element_count =0;
+			elements=memnew_arr(Element*,max_elements);
+			_elements=memnew_arr(Element,max_elements);
+			for (int i=0;i<max_elements;i++)
+				elements[i]=&_elements[i]; // assign elements
+
+		}
+
+
+		RenderList() {
+
+			max_elements=DEFAULT_MAX_ELEMENTS;
+		}
+
+		~RenderList() {
+			memdelete_arr(elements);
+			memdelete_arr(_elements);
+		}
+	};
+
+
+	LightInstance *directional_light;
+	LightInstance *directional_lights[RenderList::MAX_DIRECTIONAL_LIGHTS];
+
+
+
+	RenderList render_list;
+
+	_FORCE_INLINE_ void _set_cull(bool p_front,bool p_reverse_cull);
+
+	_FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass);
+	_FORCE_INLINE_ void _setup_transform(InstanceBase *p_instance,const Transform& p_view_transform,const CameraMatrix& p_projection);
+	_FORCE_INLINE_ void _setup_geometry(RenderList::Element *e);
+	_FORCE_INLINE_ void _render_geometry(RenderList::Element *e);
+	_FORCE_INLINE_ void _setup_light(RenderList::Element *e,const Transform& p_view_transform);
+
+	void _render_list(RenderList::Element **p_elements, int p_element_count, const Transform& p_view_transform, const CameraMatrix& p_projection, GLuint p_base_env, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow, bool p_directional_add, bool p_directional_shadows);
+
+
+	_FORCE_INLINE_ void _add_geometry(  RasterizerStorageGLES3::Geometry* p_geometry,  InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material,bool p_shadow);
+
+	void _draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox, const CameraMatrix& p_projection, const Transform& p_transform, bool p_vflip, float p_scale);
+
+	void _setup_environment(Environment *env, const CameraMatrix &p_cam_projection, const Transform& p_cam_transform);
+	void _setup_directional_light(int p_index, const Transform &p_camera_inverse_transformm, bool p_use_shadows);
+	void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix& p_camera_projection, RID p_shadow_atlas);
+	void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform& p_camera_inverse_transform, const CameraMatrix& p_camera_projection, RID p_reflection_atlas, Environment *p_env);
+
+	void _copy_screen();
+	void _copy_to_front_buffer(Environment *env);
+	void _copy_texture_to_front_buffer(GLuint p_texture); //used for debug
+
+	void _fill_render_list(InstanceBase** p_cull_result,int p_cull_count,bool p_shadow);
+
+	void _render_mrts(Environment *env, const CameraMatrix &p_cam_projection);
+	void _post_process(Environment *env, const CameraMatrix &p_cam_projection);
+
+	virtual void render_scene(const Transform& p_cam_transform,const CameraMatrix& p_cam_projection,bool p_cam_ortogonal,InstanceBase** p_cull_result,int p_cull_count,RID* p_light_cull_result,int p_light_cull_count,RID* p_reflection_probe_cull_result,int p_reflection_probe_cull_count,RID p_environment,RID p_shadow_atlas,RID p_reflection_atlas,RID p_reflection_probe,int p_reflection_probe_pass);
+	virtual void render_shadow(RID p_light,RID p_shadow_atlas,int p_pass,InstanceBase** p_cull_result,int p_cull_count);
+	virtual bool free(RID p_rid);
+
+	void _generate_brdf();
+
+	virtual void set_scene_pass(uint64_t p_pass);
+
+	void iteration();
+	void initialize();
+	void finalize();
+	RasterizerSceneGLES3();
+};
+
+#endif // RASTERIZERSCENEGLES3_H

drivers/gles3/rasterizer_storage_gles3.cpp

@@ -0,0 +1,6495 @@
+#include "rasterizer_storage_gles3.h"
+#include "rasterizer_canvas_gles3.h"
+#include "rasterizer_scene_gles3.h"
+#include "globals.h"
+
+/* TEXTURE API */
+
+#define _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG                   0x8C00
+#define _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG                   0x8C01
+#define _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG                  0x8C02
+#define _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG                  0x8C03
+
+#define _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT               0x8A54
+#define _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT               0x8A55
+#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT         0x8A56
+#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT         0x8A57
+
+
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
+
+#define _EXT_COMPRESSED_LUMINANCE_LATC1_EXT                 0x8C70
+#define _EXT_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT          0x8C71
+#define _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT           0x8C72
+#define _EXT_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT    0x8C73
+
+
+#define _EXT_COMPRESSED_RED_RGTC1_EXT 0x8DBB
+#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
+#define _EXT_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define _EXT_COMPRESSED_RG_RGTC2 0x8DBD
+#define _EXT_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
+#define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
+#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
+#define _EXT_ETC1_RGB8_OES           0x8D64
+
+
+
+#define _EXT_SLUMINANCE_NV                                  0x8C46
+#define _EXT_SLUMINANCE_ALPHA_NV                            0x8C44
+#define _EXT_SRGB8_NV                                       0x8C41
+#define _EXT_SLUMINANCE8_NV                                 0x8C47
+#define _EXT_SLUMINANCE8_ALPHA8_NV                          0x8C45
+
+
+#define _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV                   0x8C4C
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV             0x8C4D
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV             0x8C4E
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV             0x8C4F
+
+
+
+#define _EXT_ATC_RGB_AMD                        0x8C92
+#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD        0x8C93
+#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD    0x87EE
+
+
+#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS                   0x884F
+
+#define _GL_TEXTURE_MAX_ANISOTROPY_EXT          0x84FE
+#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT      0x84FF
+
+#define _EXT_COMPRESSED_R11_EAC 0x9270
+#define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271
+#define _EXT_COMPRESSED_RG11_EAC 0x9272
+#define _EXT_COMPRESSED_SIGNED_RG11_EAC 0x9273
+#define _EXT_COMPRESSED_RGB8_ETC2 0x9274
+#define _EXT_COMPRESSED_SRGB8_ETC2 0x9275
+#define _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
+#define _EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
+#define _EXT_COMPRESSED_RGBA8_ETC2_EAC 0x9278
+#define _EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
+
+#define _EXT_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
+#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
+#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
+#define _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
+
+Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags,GLenum& r_gl_format,GLenum& r_gl_internal_format,GLenum &r_gl_type,bool &r_compressed,bool &srgb) {
+
+
+	r_compressed=false;
+	r_gl_format=0;
+	Image image=p_image;
+	srgb=false;
+
+	bool need_decompress=false;
+
+	switch(p_format) {
+
+		case Image::FORMAT_L8: {
+			r_gl_internal_format=GL_R8;
+			r_gl_format=GL_RED;
+			r_gl_type=GL_UNSIGNED_BYTE;
+
+		} break;
+		case Image::FORMAT_LA8: {
+
+			r_gl_internal_format=GL_RG8;
+			r_gl_format=GL_RG;
+			r_gl_type=GL_UNSIGNED_BYTE;
+		} break;
+		case Image::FORMAT_R8: {
+
+			r_gl_internal_format=GL_R8;
+			r_gl_format=GL_RED;
+			r_gl_type=GL_UNSIGNED_BYTE;
+
+		} break;
+		case Image::FORMAT_RG8: {
+
+			r_gl_internal_format=GL_RG8;
+			r_gl_format=GL_RG;
+			r_gl_type=GL_UNSIGNED_BYTE;
+
+		} break;
+		case Image::FORMAT_RGB8: {
+
+			r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8:GL_RGB8;
+			r_gl_format=GL_RGB;
+			r_gl_type=GL_UNSIGNED_BYTE;
+			srgb=true;
+
+		} break;
+		case Image::FORMAT_RGBA8: {
+
+			r_gl_format=GL_RGBA;
+			r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8;
+			r_gl_type=GL_UNSIGNED_BYTE;
+			srgb=true;
+
+		} break;
+		case Image::FORMAT_RGB565: {
+//#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-)
+			r_gl_internal_format=GL_RGB5;
+			//r_gl_internal_format=GL_RGB565;
+			r_gl_format=GL_RGB;
+			r_gl_type=GL_UNSIGNED_SHORT_5_6_5;
+
+		} break;
+		case Image::FORMAT_RGBA4444: {
+
+			r_gl_internal_format=GL_RGBA4;
+			r_gl_format=GL_RGBA;
+			r_gl_type=GL_UNSIGNED_SHORT_4_4_4_4;
+
+		} break;
+		case Image::FORMAT_RGBA5551: {
+
+			r_gl_internal_format=GL_RGB5_A1;
+			r_gl_format=GL_RGBA;
+			r_gl_type=GL_UNSIGNED_SHORT_5_5_5_1;
+
+
+		} break;
+		case Image::FORMAT_RF: {
+
+
+			r_gl_internal_format=GL_R32F;
+			r_gl_format=GL_RED;
+			r_gl_type=GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGF: {
+
+			r_gl_internal_format=GL_RG32F;
+			r_gl_format=GL_RG;
+			r_gl_type=GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBF: {
+
+			r_gl_internal_format=GL_RGB32F;
+			r_gl_format=GL_RGB;
+			r_gl_type=GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBAF: {
+
+			r_gl_internal_format=GL_RGBA32F;
+			r_gl_format=GL_RGBA;
+			r_gl_type=GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RH: {
+			r_gl_internal_format=GL_R32F;
+			r_gl_format=GL_RED;
+			r_gl_type=GL_HALF_FLOAT;
+		} break;
+		case Image::FORMAT_RGH: {
+			r_gl_internal_format=GL_RG32F;
+			r_gl_format=GL_RG;
+			r_gl_type=GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBH: {
+			r_gl_internal_format=GL_RGB32F;
+			r_gl_format=GL_RGB;
+			r_gl_type=GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBAH: {
+			r_gl_internal_format=GL_RGBA32F;
+			r_gl_format=GL_RGBA;
+			r_gl_type=GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_DXT1: {
+
+			if (config.s3tc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+		} break;
+		case Image::FORMAT_DXT3: {
+
+
+			if (config.s3tc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+		} break;
+		case Image::FORMAT_DXT5: {
+
+			if (config.s3tc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+		} break;
+		case Image::FORMAT_ATI1: {
+
+			if (config.latc_supported) {
+
+
+				r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_LATC1_EXT;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+
+		} break;
+		case Image::FORMAT_ATI2: {
+
+			if (config.latc_supported) {
+
+
+				r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+			} else {
+
+				need_decompress=true;
+			}
+
+		} break;
+		case Image::FORMAT_BPTC_RGBA: {
+
+			if (config.bptc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:_EXT_COMPRESSED_RGBA_BPTC_UNORM;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_BPTC_RGBF: {
+
+			if (config.bptc_supported) {
+
+
+				r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
+				r_gl_format=GL_RGB;
+				r_gl_type=GL_FLOAT;
+				r_compressed=true;
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_BPTC_RGBFU: {
+			if (config.bptc_supported) {
+
+
+				r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
+				r_gl_format=GL_RGB;
+				r_gl_type=GL_FLOAT;
+				r_compressed=true;
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_PVRTC2: {
+
+			if (config.pvrtc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_PVRTC2A: {
+
+			if (config.pvrtc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+		} break;
+		case Image::FORMAT_PVRTC4: {
+
+			if (config.pvrtc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+		} break;
+		case Image::FORMAT_PVRTC4A: {
+
+			if (config.pvrtc_supported) {
+
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+
+		} break;
+		case Image::FORMAT_ETC: {
+
+			if (config.etc_supported) {
+
+				r_gl_internal_format=_EXT_ETC1_RGB8_OES;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+
+		} break;
+		case Image::FORMAT_ETC2_R11: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=_EXT_COMPRESSED_R11_EAC;
+				r_gl_format=GL_RED;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_R11S: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=_EXT_COMPRESSED_SIGNED_R11_EAC;
+				r_gl_format=GL_RED;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RG11: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=_EXT_COMPRESSED_RG11_EAC;
+				r_gl_format=GL_RG;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RG11S: {
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=_EXT_COMPRESSED_SIGNED_RG11_EAC;
+				r_gl_format=GL_RG;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+
+			} else {
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGB8: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ETC2:_EXT_COMPRESSED_RGB8_ETC2;
+				r_gl_format=GL_RGB;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGBA8: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:_EXT_COMPRESSED_RGBA8_ETC2_EAC;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGB8A1: {
+
+			if (config.etc2_supported) {
+
+				r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:_EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+				r_gl_format=GL_RGBA;
+				r_gl_type=GL_UNSIGNED_BYTE;
+				r_compressed=true;
+				srgb=true;
+
+
+			} else {
+
+				need_decompress=true;
+			}
+		} break;
+		default: {
+
+			ERR_FAIL_V(Image());
+		}
+	}
+
+	if (need_decompress) {
+
+		if (!image.empty()) {
+			image.decompress();
+			ERR_FAIL_COND_V(image.is_compressed(),image);
+			image.convert(Image::FORMAT_RGBA8);
+		}
+
+
+		r_gl_format=GL_RGBA;
+		r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8;
+		r_gl_type=GL_UNSIGNED_BYTE;
+		r_compressed=false;
+		srgb=true;
+
+		return image;
+
+	}
+
+
+	return image;
+}
+
+static const GLenum _cube_side_enum[6]={
+
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+
+};
+
+RID RasterizerStorageGLES3::texture_create() {
+
+	Texture *texture = memnew(Texture);
+	ERR_FAIL_COND_V(!texture,RID());
+	glGenTextures(1, &texture->tex_id);
+	texture->active=false;
+	texture->total_data_size=0;
+
+	return texture_owner.make_rid( texture );
+
+}
+
+void RasterizerStorageGLES3::texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
+
+	int components;
+	GLenum format;
+	GLenum internal_format;
+	GLenum type;
+
+	bool compressed;
+	bool srgb;
+
+	if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+		p_flags&=~VS::TEXTURE_FLAG_MIPMAPS; // no mipies for video
+	}
+
+
+	Texture *texture = texture_owner.get( p_texture );
+	ERR_FAIL_COND(!texture);
+	texture->width=p_width;
+	texture->height=p_height;
+	texture->format=p_format;
+	texture->flags=p_flags;
+	texture->stored_cube_sides=0;
+	texture->target = (p_flags & VS::TEXTURE_FLAG_CUBEMAP) ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
+
+	_get_gl_image_and_format(Image(),texture->format,texture->flags,format,internal_format,type,compressed,srgb);
+
+	texture->alloc_width = texture->width;
+	texture->alloc_height = texture->height;
+
+
+	texture->gl_format_cache=format;
+	texture->gl_type_cache=type;
+	texture->gl_internal_format_cache=internal_format;
+	texture->compressed=compressed;
+	texture->srgb=srgb;
+	texture->data_size=0;
+	texture->mipmaps=1;
+
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+
+	if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+		//prealloc if video
+		glTexImage2D(texture->target, 0, internal_format, p_width, p_height, 0, format, type,NULL);
+	}
+
+	texture->active=true;
+}
+
+void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND(!texture);
+	ERR_FAIL_COND(!texture->active);
+	ERR_FAIL_COND(texture->render_target);
+	ERR_FAIL_COND(texture->format != p_image.get_format() );
+	ERR_FAIL_COND( p_image.empty() );
+
+	GLenum type;
+	GLenum format;
+	GLenum internal_format;
+	bool compressed;
+	bool srgb;
+
+
+	if (config.keep_original_textures && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
+		texture->images[p_cube_side]=p_image;
+	}
+
+	Image img = _get_gl_image_and_format(p_image, p_image.get_format(),texture->flags,format,internal_format,type,compressed,srgb);
+
+	if (config.shrink_textures_x2 && (p_image.has_mipmaps() || !p_image.is_compressed()) && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
+
+		texture->alloc_height = MAX(1,texture->alloc_height/2);
+		texture->alloc_width = MAX(1,texture->alloc_width/2);
+
+		if (texture->alloc_width == img.get_width()/2 && texture->alloc_height == img.get_height()/2) {
+
+			img.shrink_x2();
+		} else if (img.get_format() <= Image::FORMAT_RGB565) {
+
+			img.resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
+
+		}
+	};
+
+
+	GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP)?_cube_side_enum[p_cube_side]:GL_TEXTURE_2D;
+
+	texture->data_size=img.get_data().size();
+	DVector<uint8_t>::Read read = img.get_data().read();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	texture->ignore_mipmaps = compressed && !img.has_mipmaps();
+
+	if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps)
+		glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,config.use_fast_texture_filter?GL_LINEAR_MIPMAP_NEAREST:GL_LINEAR_MIPMAP_LINEAR);
+	else {
+		if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+			glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+		} else {
+			glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+
+		}
+	}
+
+
+	if (config.srgb_decode_supported && srgb) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+			glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+			texture->using_srgb=true;
+		} else {
+			glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
+			texture->using_srgb=false;
+		}
+	}
+
+	if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+
+		glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);	// Linear Filtering
+
+	} else {
+
+		glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);	// raw Filtering
+	}
+
+	if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
+		}
+		else{
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+		}
+	} else {
+
+		//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
+		glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+		glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+	}
+
+	//set swizle for older format compatibility
+	switch(texture->format) {
+
+		case Image::FORMAT_L8: {
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ONE);
+
+		} break;
+		case Image::FORMAT_LA8: {
+
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_GREEN);
+		} break;
+		default: {
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_GREEN);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_BLUE);
+			glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ALPHA);
+
+		} break;
+
+	}
+	if (config.use_anisotropic_filter) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
+
+			glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
+		} else {
+			glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
+		}
+	}
+
+	int mipmaps= (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && img.has_mipmaps()) ? img.get_mipmap_count() +1: 1;
+
+
+	int w=img.get_width();
+	int h=img.get_height();
+
+	int tsize=0;
+	for(int i=0;i<mipmaps;i++) {
+
+		int size,ofs;
+		img.get_mipmap_offset_and_size(i,ofs,size);
+
+		//print_line("mipmap: "+itos(i)+" size: "+itos(size)+" w: "+itos(mm_w)+", h: "+itos(mm_h));
+
+		if (texture->compressed) {
+			glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+			glCompressedTexImage2D( blit_target, i, format,w,h,0,size,&read[ofs] );
+
+		} else {
+			glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+			if (texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+				glTexSubImage2D( blit_target, i, 0,0,w, h,format,type,&read[ofs] );
+			} else {
+				glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type,&read[ofs]);
+			}
+
+		}
+		tsize+=size;
+
+		w = MAX(1,w>>1);
+		h = MAX(1,h>>1);
+
+	}
+
+	info.texture_mem-=texture->total_data_size;
+	texture->total_data_size=tsize;
+	info.texture_mem+=texture->total_data_size;
+
+	//printf("texture: %i x %i - size: %i - total: %i\n",texture->width,texture->height,tsize,_rinfo.texture_mem);
+
+	texture->stored_cube_sides|=(1<<p_cube_side);
+
+	if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && mipmaps==1 && !texture->ignore_mipmaps && (!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides==(1<<6)-1)) {
+		//generate mipmaps if they were requested and the image does not contain them
+		glGenerateMipmap(texture->target);
+	}
+
+	texture->mipmaps=mipmaps;
+
+	//texture_set_flags(p_texture,texture->flags);
+
+
+}
+
+Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,Image());
+	ERR_FAIL_COND_V(!texture->active,Image());
+	ERR_FAIL_COND_V(texture->data_size==0,Image());
+	ERR_FAIL_COND_V(texture->render_target,Image());
+
+	if (!texture->images[p_cube_side].empty())
+		return texture->images[p_cube_side];
+
+#ifdef GLES_OVER_GL
+
+	DVector<uint8_t> data;
+
+	int data_size = Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,texture->mipmaps>1?-1:0);
+
+	data.resize(data_size*2); //add some memory at the end, just in case for buggy drivers
+	DVector<uint8_t>::Write wb = data.write();
+
+	glActiveTexture(GL_TEXTURE0);
+
+	glBindTexture(texture->target,texture->tex_id);
+
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+	print_line("GET FORMAT: "+Image::get_format_name(texture->format)+" mipmaps: "+itos(texture->mipmaps));
+
+
+	for(int i=0;i<texture->mipmaps;i++) {
+
+		int ofs=0;
+		if (i>0) {
+			ofs=Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,i-1);
+		}
+
+		if (texture->compressed) {
+
+			glPixelStorei(GL_PACK_ALIGNMENT, 4);
+			glGetCompressedTexImage(texture->target,i,&wb[ofs]);
+
+		} else {
+
+			glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+			glGetTexImage(texture->target,i,texture->gl_format_cache,texture->gl_type_cache,&wb[ofs]);
+		}
+	}
+
+
+	wb=DVector<uint8_t>::Write();
+
+	data.resize(data_size);
+
+	Image img(texture->alloc_width,texture->alloc_height,texture->mipmaps>1?true:false,texture->format,data);
+
+	return img;
+#else
+
+	ERR_EXPLAIN("Sorry, It's not posible to obtain images back in OpenGL ES");
+	return Image();
+#endif
+}
+
+void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) {
+
+	Texture *texture = texture_owner.get( p_texture );
+	ERR_FAIL_COND(!texture);
+	if (texture->render_target) {
+
+		p_flags&=VS::TEXTURE_FLAG_FILTER;//can change only filter
+	}
+
+	bool had_mipmaps = texture->flags&VS::TEXTURE_FLAG_MIPMAPS;
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+	uint32_t cube = texture->flags & VS::TEXTURE_FLAG_CUBEMAP;
+	texture->flags=p_flags|cube; // can't remove a cube from being a cube
+
+
+	if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
+		}
+		else {
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+			glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+		}
+	} else {
+		//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
+		glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+		glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+
+	}
+
+
+	if (config.use_anisotropic_filter) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
+
+			glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
+		} else {
+			glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
+		}
+	}
+
+	if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps) {
+		if (!had_mipmaps && texture->mipmaps==1) {
+			glGenerateMipmap(texture->target);
+		}
+		glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,config.use_fast_texture_filter?GL_LINEAR_MIPMAP_NEAREST:GL_LINEAR_MIPMAP_LINEAR);
+
+	} else{
+		if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+			glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+		} else {
+			glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+
+		}
+	}
+
+
+	if (config.srgb_decode_supported && texture->srgb) {
+
+		if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+
+			glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+			texture->using_srgb=true;
+		} else {
+			glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
+			texture->using_srgb=false;
+		}
+	}
+
+	if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+
+		glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);	// Linear Filtering
+
+	} else {
+
+		glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);	// raw Filtering
+	}
+
+}
+uint32_t RasterizerStorageGLES3::texture_get_flags(RID p_texture) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,0);
+
+	return texture->flags;
+
+}
+Image::Format RasterizerStorageGLES3::texture_get_format(RID p_texture) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,Image::FORMAT_L8);
+
+	return texture->format;
+}
+uint32_t RasterizerStorageGLES3::texture_get_width(RID p_texture) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,0);
+
+	return texture->width;
+}
+uint32_t RasterizerStorageGLES3::texture_get_height(RID p_texture) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,0);
+
+	return texture->height;
+}
+
+
+void RasterizerStorageGLES3::texture_set_size_override(RID p_texture,int p_width, int p_height) {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND(!texture);
+	ERR_FAIL_COND(texture->render_target);
+
+	ERR_FAIL_COND(p_width<=0 || p_width>16384);
+	ERR_FAIL_COND(p_height<=0 || p_height>16384);
+	//real texture size is in alloc width and height
+	texture->width=p_width;
+	texture->height=p_height;
+
+}
+
+void RasterizerStorageGLES3::texture_set_path(RID p_texture,const String& p_path) {
+	Texture * texture = texture_owner.get(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->path=p_path;
+
+}
+
+String RasterizerStorageGLES3::texture_get_path(RID p_texture) const{
+
+	Texture * texture = texture_owner.get(p_texture);
+	ERR_FAIL_COND_V(!texture,String());
+	return texture->path;
+}
+void RasterizerStorageGLES3::texture_debug_usage(List<VS::TextureInfo> *r_info){
+
+	List<RID> textures;
+	texture_owner.get_owned_list(&textures);
+
+	for (List<RID>::Element *E=textures.front();E;E=E->next()) {
+
+		Texture *t = texture_owner.get(E->get());
+		if (!t)
+			continue;
+		VS::TextureInfo tinfo;
+		tinfo.path=t->path;
+		tinfo.format=t->format;
+		tinfo.size.x=t->alloc_width;
+		tinfo.size.y=t->alloc_height;
+		tinfo.bytes=t->total_data_size;
+		r_info->push_back(tinfo);
+	}
+
+}
+
+void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
+
+	config.shrink_textures_x2=p_enable;
+}
+
+void RasterizerStorageGLES3::textures_keep_original(bool p_enable) {
+
+	config.keep_original_textures=p_enable;
+}
+
+RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_resolution) const {
+
+	Texture * texture = texture_owner.get(p_source);
+	ERR_FAIL_COND_V(!texture,RID());
+	ERR_FAIL_COND_V(!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP),RID());
+
+	bool use_float=true;
+
+	if (p_resolution<0) {
+		p_resolution=texture->width;
+	}
+
+
+	glBindVertexArray(0);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+	glDisable(GL_BLEND);
+
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) {
+
+		glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+		texture->using_srgb=true;
+#ifdef TOOLS_ENABLED
+		if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+			texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+			//notify that texture must be set to linear beforehand, so it works in other platforms when exported
+		}
+#endif
+	}
+
+
+	glActiveTexture(GL_TEXTURE1);
+	GLuint new_cubemap;
+	glGenTextures(1, &new_cubemap);
+	glBindTexture(GL_TEXTURE_CUBE_MAP, new_cubemap);
+
+
+	GLuint tmp_fb;
+
+	glGenFramebuffers(1, &tmp_fb);
+	glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
+
+
+	int size = p_resolution;
+
+	int lod=0;
+
+	shaders.cubemap_filter.bind();
+
+	int mipmaps=6;
+
+	int mm_level=mipmaps;
+
+	GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+	GLenum format = GL_RGBA;
+	GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+
+
+	while(mm_level) {
+
+		for(int i=0;i<6;i++) {
+			glTexImage2D(_cube_side_enum[i], lod, internal_format,  size, size, 0, format, type, NULL);
+		}
+
+		lod++;
+		mm_level--;
+
+		if (size>1)
+			size>>=1;
+	}
+
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
+
+	lod=0;
+	mm_level=mipmaps;
+
+	size = p_resolution;
+
+	shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
+
+	while(mm_level) {
+
+		for(int i=0;i<6;i++) {
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], new_cubemap, lod);
+
+			glViewport(0,0,size,size);
+			glBindVertexArray(resources.quadie_array);
+
+			shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID,i);
+			shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
+
+
+			glDrawArrays(GL_TRIANGLE_FAN,0,4);
+			glBindVertexArray(0);
+#ifdef DEBUG_ENABLED
+			GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+			ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+#endif
+		}
+
+
+
+		if (size>1)
+			size>>=1;
+		lod++;
+		mm_level--;
+
+	}
+
+
+	//restore ranges
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
+
+	glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+	glDeleteFramebuffers(1, &tmp_fb);
+
+	Texture * ctex = memnew( Texture );
+
+	ctex->flags=VS::TEXTURE_FLAG_CUBEMAP|VS::TEXTURE_FLAG_MIPMAPS|VS::TEXTURE_FLAG_FILTER;
+	ctex->width=p_resolution;
+	ctex->height=p_resolution;
+	ctex->alloc_width=p_resolution;
+	ctex->alloc_height=p_resolution;
+	ctex->format=use_float?Image::FORMAT_RGBAH:Image::FORMAT_RGBA8;
+	ctex->target=GL_TEXTURE_CUBE_MAP;
+	ctex->gl_format_cache=format;
+	ctex->gl_internal_format_cache=internal_format;
+	ctex->gl_type_cache=type;
+	ctex->data_size=0;
+	ctex->compressed=false;
+	ctex->srgb=false;
+	ctex->total_data_size=0;
+	ctex->ignore_mipmaps=false;
+	ctex->mipmaps=mipmaps;
+	ctex->active=true;
+	ctex->tex_id=new_cubemap;
+	ctex->stored_cube_sides=(1<<6)-1;
+	ctex->render_target=NULL;
+
+	return texture_owner.make_rid(ctex);
+}
+
+
+RID RasterizerStorageGLES3::skybox_create() {
+
+	SkyBox *skybox = memnew( SkyBox );
+	skybox->radiance=0;
+	return skybox_owner.make_rid(skybox);
+}
+
+void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size){
+
+	SkyBox *skybox = skybox_owner.getornull(p_skybox);
+	ERR_FAIL_COND(!skybox);
+
+	if (skybox->cubemap.is_valid()) {
+		skybox->cubemap=RID();
+		glDeleteTextures(1,&skybox->radiance);
+		skybox->radiance=0;
+	}
+
+	skybox->cubemap=p_cube_map;
+	if (!skybox->cubemap.is_valid())
+		return; //cleared
+
+	Texture *texture = texture_owner.getornull(skybox->cubemap);
+	if (!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP)) {
+		skybox->cubemap=RID();
+		ERR_FAIL_COND(!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP));
+	}
+
+	glBindVertexArray(0);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+	glDisable(GL_BLEND);
+
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) {
+
+		glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+		texture->using_srgb=true;
+#ifdef TOOLS_ENABLED
+		if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+			texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+			//notify that texture must be set to linear beforehand, so it works in other platforms when exported
+		}
+#endif
+	}
+
+
+	glActiveTexture(GL_TEXTURE1);
+	glGenTextures(1, &skybox->radiance);
+	glBindTexture(GL_TEXTURE_2D, skybox->radiance);
+
+	GLuint tmp_fb;
+
+	glGenFramebuffers(1, &tmp_fb);
+	glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
+
+
+	int size = p_radiance_size;
+
+	int lod=0;
+
+
+	int mipmaps=6;
+
+	int mm_level=mipmaps;
+
+	bool use_float=true;
+
+	GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+	GLenum format = GL_RGBA;
+	GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+
+	while(mm_level) {
+
+		glTexImage2D(GL_TEXTURE_2D, lod, internal_format,  size, size*2, 0, format, type, NULL);
+		lod++;
+		mm_level--;
+
+		if (size>1)
+			size>>=1;
+	}
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1);
+
+	lod=0;
+	mm_level=mipmaps;
+
+	size = p_radiance_size;
+
+	shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true);
+	shaders.cubemap_filter.bind();
+
+	while(mm_level) {
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  skybox->radiance, lod);
+#ifdef DEBUG_ENABLED
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+#endif
+
+		for(int i=0;i<2;i++) {
+			glViewport(0,i*size,size,size);
+			glBindVertexArray(resources.quadie_array);
+
+			shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP,i>0);
+			shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
+
+
+			glDrawArrays(GL_TRIANGLE_FAN,0,4);
+			glBindVertexArray(0);
+		}
+
+		if (size>1)
+			size>>=1;
+		lod++;
+		mm_level--;
+
+	}
+	shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
+
+
+	//restore ranges
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1);
+
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+	glDeleteFramebuffers(1, &tmp_fb);
+
+}
+
+
+/* SHADER API */
+
+
+RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){
+
+	Shader *shader = memnew( Shader );
+	shader->mode=p_mode;
+	RID rid = shader_owner.make_rid(shader);
+	shader_set_mode(rid,p_mode);
+	_shader_make_dirty(shader);
+	shader->self=rid;
+
+	return rid;
+}
+
+void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) {
+
+	if (p_shader->dirty_list.in_list())
+		return;
+
+	_shader_dirty_list.add(&p_shader->dirty_list);
+}
+
+void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){
+
+	ERR_FAIL_INDEX(p_mode,VS::SHADER_MAX);
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+
+	if (shader->custom_code_id && p_mode==shader->mode)
+		return;
+
+
+	if (shader->custom_code_id) {
+
+		shader->shader->free_custom_shader(shader->custom_code_id);
+		shader->custom_code_id=0;
+	}
+
+	shader->mode=p_mode;
+
+	ShaderGLES3* shaders[VS::SHADER_MAX]={
+		&scene->state.scene_shader,
+		&canvas->state.canvas_shader,
+		&this->shaders.particles,
+
+	};
+
+	shader->shader=shaders[p_mode];
+
+	shader->custom_code_id = shader->shader->create_custom_shader();
+
+	_shader_make_dirty(shader);
+
+}
+VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const {
+
+	const Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader,VS::SHADER_MAX);
+
+	return shader->mode;
+}
+void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){
+
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+
+	shader->code=p_code;
+	_shader_make_dirty(shader);
+}
+String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{
+
+	const Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader,String());
+
+
+	return shader->code;
+}
+
+void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const {
+
+
+	_shader_dirty_list.remove( &p_shader->dirty_list );
+
+	p_shader->valid=false;
+
+	p_shader->uniforms.clear();
+
+	ShaderCompilerGLES3::GeneratedCode gen_code;
+	ShaderCompilerGLES3::IdentifierActions *actions=NULL;
+
+
+
+	switch(p_shader->mode) {
+		case VS::SHADER_CANVAS_ITEM: {
+
+			p_shader->canvas_item.light_mode=Shader::CanvasItem::LIGHT_MODE_NORMAL;
+			p_shader->canvas_item.blend_mode=Shader::CanvasItem::BLEND_MODE_MIX;
+
+			shaders.actions_canvas.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_ADD);
+			shaders.actions_canvas.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MIX);
+			shaders.actions_canvas.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_SUB);
+			shaders.actions_canvas.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MUL);
+			shaders.actions_canvas.render_mode_values["blend_premul_alpha"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_PMALPHA);
+
+			shaders.actions_canvas.render_mode_values["unshaded"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_UNSHADED);
+			shaders.actions_canvas.render_mode_values["light_only"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY);
+
+			actions=&shaders.actions_canvas;
+			actions->uniforms=&p_shader->uniforms;
+
+		} break;
+
+		case VS::SHADER_SPATIAL: {
+
+			p_shader->spatial.blend_mode=Shader::Spatial::BLEND_MODE_MIX;
+			p_shader->spatial.depth_draw_mode=Shader::Spatial::DEPTH_DRAW_OPAQUE;
+			p_shader->spatial.cull_mode=Shader::Spatial::CULL_MODE_BACK;
+			p_shader->spatial.uses_alpha=false;
+			p_shader->spatial.uses_discard=false;
+			p_shader->spatial.unshaded=false;
+			p_shader->spatial.ontop=false;
+			p_shader->spatial.uses_sss=false;
+			p_shader->spatial.uses_vertex=false;
+
+			shaders.actions_scene.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_ADD);
+			shaders.actions_scene.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MIX);
+			shaders.actions_scene.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_SUB);
+			shaders.actions_scene.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MUL);
+
+			shaders.actions_scene.render_mode_values["depth_draw_opaque"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_OPAQUE);
+			shaders.actions_scene.render_mode_values["depth_draw_always"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALWAYS);
+			shaders.actions_scene.render_mode_values["depth_draw_never"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_NEVER);
+			shaders.actions_scene.render_mode_values["depth_draw_alpha_prepass"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS);
+
+			shaders.actions_scene.render_mode_values["cull_front"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_FRONT);
+			shaders.actions_scene.render_mode_values["cull_back"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_BACK);
+			shaders.actions_scene.render_mode_values["cull_disabled"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_DISABLED);
+
+			shaders.actions_scene.render_mode_flags["unshaded"]=&p_shader->spatial.unshaded;
+			shaders.actions_scene.render_mode_flags["ontop"]=&p_shader->spatial.ontop;
+
+			shaders.actions_scene.usage_flag_pointers["ALPHA"]=&p_shader->spatial.uses_alpha;
+			shaders.actions_scene.usage_flag_pointers["VERTEX"]=&p_shader->spatial.uses_vertex;
+
+			shaders.actions_scene.usage_flag_pointers["SSS_STRENGTH"]=&p_shader->spatial.uses_sss;
+			shaders.actions_scene.usage_flag_pointers["DISCARD"]=&p_shader->spatial.uses_discard;
+
+			actions=&shaders.actions_scene;
+			actions->uniforms=&p_shader->uniforms;
+
+
+		}
+		case VS::SHADER_PARTICLES: {
+
+			actions=&shaders.actions_particles;
+			actions->uniforms=&p_shader->uniforms;
+		}
+
+	}
+
+
+	Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code);
+
+
+	ERR_FAIL_COND(err!=OK);
+
+	p_shader->shader->set_custom_shader_code(p_shader->custom_code_id,gen_code.vertex,gen_code.vertex_global,gen_code.fragment,gen_code.light,gen_code.fragment_global,gen_code.uniforms,gen_code.texture_uniforms,gen_code.defines);
+
+	p_shader->ubo_size=gen_code.uniform_total_size;
+	p_shader->ubo_offsets=gen_code.uniform_offsets;
+	p_shader->texture_count=gen_code.texture_uniforms.size();
+	p_shader->texture_hints=gen_code.texture_hints;
+
+	p_shader->uses_vertex_time=gen_code.uses_vertex_time;
+	p_shader->uses_fragment_time=gen_code.uses_fragment_time;
+
+	//all materials using this shader will have to be invalidated, unfortunately
+
+	for (SelfList<Material>* E = p_shader->materials.first();E;E=E->next() ) {
+
+		_material_make_dirty(E->self());
+	}
+
+	p_shader->valid=true;
+	p_shader->version++;
+
+
+}
+
+void RasterizerStorageGLES3::update_dirty_shaders() {
+
+	while( _shader_dirty_list.first() ) {
+		_update_shader(_shader_dirty_list.first()->self() );
+	}
+}
+
+void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{
+
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+
+
+	if (shader->dirty_list.in_list())
+		_update_shader(shader); // ok should be not anymore dirty
+
+
+	Map<int,StringName> order;
+
+
+	for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
+
+
+		order[E->get().order]=E->key();
+	}
+
+
+	for(Map<int,StringName>::Element *E=order.front();E;E=E->next()) {
+
+		PropertyInfo pi;
+		ShaderLanguage::ShaderNode::Uniform &u=shader->uniforms[E->get()];
+		pi.name=E->get();
+		switch(u.type) {
+			case ShaderLanguage::TYPE_VOID: pi.type=Variant::NIL; break;
+			case ShaderLanguage::TYPE_BOOL: pi.type=Variant::BOOL; break;
+			case ShaderLanguage::TYPE_BVEC2: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y"; break;
+			case ShaderLanguage::TYPE_BVEC3: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z"; break;
+			case ShaderLanguage::TYPE_BVEC4: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z,w"; break;
+			case ShaderLanguage::TYPE_UINT:
+			case ShaderLanguage::TYPE_INT: {
+				pi.type=Variant::INT;
+				if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
+					pi.hint=PROPERTY_HINT_RANGE;
+					pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1]);
+				}
+
+			} break;
+			case ShaderLanguage::TYPE_IVEC2:
+			case ShaderLanguage::TYPE_IVEC3:
+			case ShaderLanguage::TYPE_IVEC4:
+			case ShaderLanguage::TYPE_UVEC2:
+			case ShaderLanguage::TYPE_UVEC3:
+			case ShaderLanguage::TYPE_UVEC4: {
+
+				pi.type=Variant::INT_ARRAY;
+			} break;
+			case ShaderLanguage::TYPE_FLOAT: {
+				pi.type=Variant::REAL;
+				if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
+					pi.hint=PROPERTY_HINT_RANGE;
+					pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1])+","+rtos(u.hint_range[2]);
+				}
+
+			} break;
+			case ShaderLanguage::TYPE_VEC2: pi.type=Variant::VECTOR2; break;
+			case ShaderLanguage::TYPE_VEC3: pi.type=Variant::VECTOR3; break;
+			case ShaderLanguage::TYPE_VEC4: {
+				if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
+					pi.type=Variant::COLOR;
+				} else {
+					pi.type=Variant::PLANE;
+				}
+			} break;
+			case ShaderLanguage::TYPE_MAT2: pi.type=Variant::MATRIX32; break;
+			case ShaderLanguage::TYPE_MAT3: pi.type=Variant::MATRIX3; break;
+			case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
+			case ShaderLanguage::TYPE_SAMPLER2D:
+			case ShaderLanguage::TYPE_ISAMPLER2D:
+			case ShaderLanguage::TYPE_USAMPLER2D: {
+
+				 pi.type=Variant::OBJECT;
+				 pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
+				 pi.hint_string="Texture";
+			} break;
+			case ShaderLanguage::TYPE_SAMPLERCUBE: {
+
+				pi.type=Variant::OBJECT;
+				pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
+				pi.hint_string="CubeMap";
+			} break;
+		};
+
+		p_param_list->push_back(pi);
+
+	}
+}
+
+void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){
+
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+	ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
+
+	if (p_texture.is_valid())
+		shader->default_textures[p_name]=p_texture;
+	else
+		shader->default_textures.erase(p_name);
+
+	_shader_make_dirty(shader);
+}
+RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
+
+	const Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND_V(!shader,RID());
+
+	const Map<StringName,RID>::Element *E=shader->default_textures.find(p_name);
+	if (!E)
+		return RID();
+	return E->get();
+}
+
+
+/* COMMON MATERIAL API */
+
+void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
+
+	if (p_material->dirty_list.in_list())
+		return;
+
+	_material_dirty_list.add(&p_material->dirty_list);
+}
+
+RID RasterizerStorageGLES3::material_create(){
+
+	Material *material = memnew( Material );
+
+	return material_owner.make_rid(material);
+}
+
+void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader){
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND(!material);
+
+	Shader *shader=shader_owner.getornull(p_shader);
+
+	if (material->shader) {
+		//if shader, remove from previous shader material list
+		material->shader->materials.remove( &material->list );
+	}
+	material->shader=shader;
+
+	if (shader) {
+		shader->materials.add(&material->list);
+	}
+
+	_material_make_dirty(material);
+
+}
+
+RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{
+
+	const Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND_V(!material,RID());
+
+	if (material->shader)
+		return material->shader->self;
+
+	return RID();
+}
+
+void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND(!material);
+
+	if (p_value.get_type()==Variant::NIL)
+		material->params.erase(p_param);
+	else
+		material->params[p_param]=p_value;
+
+	_material_make_dirty(material);
+
+}
+Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{
+
+	const Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND_V(!material,RID());
+
+	if (material->params.has(p_param))
+		return material->params[p_param];
+
+	return Variant();
+}
+
+void RasterizerStorageGLES3::material_set_line_width(RID p_material, float p_width) {
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND(!material);
+
+	material->line_width=p_width;
+
+
+}
+
+bool RasterizerStorageGLES3::material_is_animated(RID p_material)  {
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND_V(!material,false);
+	if (material->dirty_list.in_list()) {
+		_update_material(material);
+	}
+
+	return material->is_animated_cache;
+
+}
+bool RasterizerStorageGLES3::material_casts_shadows(RID p_material)  {
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND_V(!material,false);
+	if (material->dirty_list.in_list()) {
+		_update_material(material);
+	}
+
+	return material->can_cast_shadow_cache;
+}
+
+void RasterizerStorageGLES3::material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND(!material);
+
+	Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
+	if (E) {
+		E->get()++;
+	} else {
+		material->instance_owners[p_instance]=1;
+	}
+}
+
+void RasterizerStorageGLES3::material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
+
+	Material *material = material_owner.get(  p_material );
+	ERR_FAIL_COND(!material);
+
+	Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
+	ERR_FAIL_COND(!E);
+	E->get()--;
+
+	if (E->get()==0) {
+		material->instance_owners.erase(E);
+	}
+}
+
+
+
+_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data,bool p_linear_color) {
+	switch(type) {
+		case ShaderLanguage::TYPE_BOOL: {
+
+			bool v = value;
+
+			GLuint *gui = (GLuint*)data;
+			*gui = v ? GL_TRUE : GL_FALSE;
+		} break;
+		case ShaderLanguage::TYPE_BVEC2: {
+
+			int v = value;
+			GLuint *gui = (GLuint*)data;
+			gui[0]=v&1 ? GL_TRUE : GL_FALSE;
+			gui[1]=v&2 ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_BVEC3: {
+
+			int v = value;
+			GLuint *gui = (GLuint*)data;
+			gui[0]=v&1 ? GL_TRUE : GL_FALSE;
+			gui[1]=v&2 ? GL_TRUE : GL_FALSE;
+			gui[2]=v&4 ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_BVEC4: {
+
+			int v = value;
+			GLuint *gui = (GLuint*)data;
+			gui[0]=v&1 ? GL_TRUE : GL_FALSE;
+			gui[1]=v&2 ? GL_TRUE : GL_FALSE;
+			gui[2]=v&4 ? GL_TRUE : GL_FALSE;
+			gui[3]=v&8 ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_INT: {
+
+			int v = value;
+			GLint *gui = (GLint*)data;
+			gui[0]=v;
+
+		} break;
+		case ShaderLanguage::TYPE_IVEC2: {
+
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLint *gui = (GLint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<2;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_IVEC3: {
+
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLint *gui = (GLint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<3;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+
+			}
+		} break;
+		case ShaderLanguage::TYPE_IVEC4: {
+
+
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLint *gui = (GLint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<4;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+
+			}
+		} break;
+		case ShaderLanguage::TYPE_UINT: {
+
+			int v = value;
+			GLuint *gui = (GLuint*)data;
+			gui[0]=v;
+
+		} break;
+		case ShaderLanguage::TYPE_UVEC2: {
+
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLuint *gui = (GLuint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<2;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+
+			}
+		} break;
+		case ShaderLanguage::TYPE_UVEC3: {
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLuint *gui = (GLuint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<3;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_UVEC4: {
+			DVector<int> iv = value;
+			int s = iv.size();
+			GLuint *gui = (GLuint*)data;
+
+			DVector<int>::Read r = iv.read();
+
+			for(int i=0;i<4;i++) {
+				if (i<s)
+					gui[i]=r[i];
+				else
+					gui[i]=0;
+			}
+		} break;
+		case ShaderLanguage::TYPE_FLOAT: {
+			float v = value;
+			GLfloat *gui = (GLfloat*)data;
+			gui[0]=v;
+
+		} break;
+		case ShaderLanguage::TYPE_VEC2: {
+			Vector2 v = value;
+			GLfloat *gui = (GLfloat*)data;
+			gui[0]=v.x;
+			gui[1]=v.y;
+
+		} break;
+		case ShaderLanguage::TYPE_VEC3: {
+			Vector3 v = value;
+			GLfloat *gui = (GLfloat*)data;
+			gui[0]=v.x;
+			gui[1]=v.y;
+			gui[2]=v.z;
+
+		} break;
+		case ShaderLanguage::TYPE_VEC4: {
+
+			GLfloat *gui = (GLfloat*)data;
+
+			if (value.get_type()==Variant::COLOR) {
+				Color v=value;
+
+				if (p_linear_color) {
+					v=v.to_linear();
+				}
+
+				gui[0]=v.r;
+				gui[1]=v.g;
+				gui[2]=v.b;
+				gui[3]=v.a;
+			} else if (value.get_type()==Variant::RECT2) {
+				Rect2 v=value;
+
+				gui[0]=v.pos.x;
+				gui[1]=v.pos.y;
+				gui[2]=v.size.x;
+				gui[3]=v.size.y;
+			} else if (value.get_type()==Variant::QUAT) {
+				Quat v=value;
+
+				gui[0]=v.x;
+				gui[1]=v.y;
+				gui[2]=v.z;
+				gui[3]=v.w;
+			} else {
+				Plane v=value;
+
+				gui[0]=v.normal.x;
+				gui[1]=v.normal.y;
+				gui[2]=v.normal.x;
+				gui[3]=v.d;
+
+			}
+		} break;
+		case ShaderLanguage::TYPE_MAT2: {
+			Matrix32 v = value;
+			GLfloat *gui = (GLfloat*)data;
+
+			gui[ 0]=v.elements[0][0];
+			gui[ 1]=v.elements[0][1];
+			gui[ 2]=v.elements[1][0];
+			gui[ 3]=v.elements[1][1];
+		} break;
+		case ShaderLanguage::TYPE_MAT3: {
+
+
+			Matrix3 v = value;
+			GLfloat *gui = (GLfloat*)data;
+
+			gui[ 0]=v.elements[0][0];
+			gui[ 1]=v.elements[1][0];
+			gui[ 2]=v.elements[2][0];
+			gui[ 3]=0;
+			gui[ 4]=v.elements[0][1];
+			gui[ 5]=v.elements[1][1];
+			gui[ 6]=v.elements[2][1];
+			gui[ 7]=0;
+			gui[ 8]=v.elements[0][2];
+			gui[ 9]=v.elements[1][2];
+			gui[10]=v.elements[2][2];
+			gui[11]=0;
+		} break;
+		case ShaderLanguage::TYPE_MAT4: {
+
+			Transform v = value;
+			GLfloat *gui = (GLfloat*)data;
+
+			gui[ 0]=v.basis.elements[0][0];
+			gui[ 1]=v.basis.elements[1][0];
+			gui[ 2]=v.basis.elements[2][0];
+			gui[ 3]=0;
+			gui[ 4]=v.basis.elements[0][1];
+			gui[ 5]=v.basis.elements[1][1];
+			gui[ 6]=v.basis.elements[2][1];
+			gui[ 7]=0;
+			gui[ 8]=v.basis.elements[0][2];
+			gui[ 9]=v.basis.elements[1][2];
+			gui[10]=v.basis.elements[2][2];
+			gui[11]=0;
+			gui[12]=v.origin.x;
+			gui[13]=v.origin.y;
+			gui[14]=v.origin.z;
+			gui[15]=1;
+		} break;
+		default: {}
+	}
+
+}
+
+_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value>& value, uint8_t *data) {
+
+	switch(type) {
+		case ShaderLanguage::TYPE_BOOL: {
+
+			GLuint *gui = (GLuint*)data;
+			*gui = value[0].boolean ? GL_TRUE : GL_FALSE;
+		} break;
+		case ShaderLanguage::TYPE_BVEC2: {
+
+			GLuint *gui = (GLuint*)data;
+			gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
+			gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_BVEC3: {
+
+			GLuint *gui = (GLuint*)data;
+			gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
+			gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
+			gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_BVEC4: {
+
+			GLuint *gui = (GLuint*)data;
+			gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
+			gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
+			gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
+			gui[3]=value[3].boolean ? GL_TRUE : GL_FALSE;
+
+		} break;
+		case ShaderLanguage::TYPE_INT: {
+
+			GLint *gui = (GLint*)data;
+			gui[0]=value[0].sint;
+
+		} break;
+		case ShaderLanguage::TYPE_IVEC2: {
+
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<2;i++) {
+				gui[i]=value[i].sint;
+
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_IVEC3: {
+
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<3;i++) {
+				gui[i]=value[i].sint;
+
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_IVEC4: {
+
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<4;i++) {
+				gui[i]=value[i].sint;
+
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_UINT: {
+
+
+			GLuint *gui = (GLuint*)data;
+			gui[0]=value[0].uint;
+
+		} break;
+		case ShaderLanguage::TYPE_UVEC2: {
+
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<2;i++) {
+				gui[i]=value[i].uint;
+			}
+		} break;
+		case ShaderLanguage::TYPE_UVEC3: {
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<3;i++) {
+				gui[i]=value[i].uint;
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_UVEC4: {
+			GLint *gui = (GLint*)data;
+
+			for(int i=0;i<4;i++) {
+				gui[i]=value[i].uint;
+			}
+		} break;
+		case ShaderLanguage::TYPE_FLOAT: {
+
+			GLfloat *gui = (GLfloat*)data;
+			gui[0]=value[0].real;
+
+		} break;
+		case ShaderLanguage::TYPE_VEC2: {
+
+			GLfloat *gui = (GLfloat*)data;
+
+			for(int i=0;i<2;i++) {
+				gui[i]=value[i].real;
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_VEC3: {
+
+			GLfloat *gui = (GLfloat*)data;
+
+			for(int i=0;i<3;i++) {
+				gui[i]=value[i].real;
+			}
+
+		} break;
+		case ShaderLanguage::TYPE_VEC4: {
+
+			GLfloat *gui = (GLfloat*)data;
+
+			for(int i=0;i<4;i++) {
+				gui[i]=value[i].real;
+			}
+		} break;
+		case ShaderLanguage::TYPE_MAT2: {
+			GLfloat *gui = (GLfloat*)data;
+
+			for(int i=0;i<2;i++) {
+				gui[i]=value[i].real;
+			}
+		} break;
+		case ShaderLanguage::TYPE_MAT3: {
+
+
+
+			GLfloat *gui = (GLfloat*)data;
+
+			gui[ 0]=value[0].real;
+			gui[ 1]=value[1].real;
+			gui[ 2]=value[2].real;
+			gui[ 3]=0;
+			gui[ 4]=value[3].real;
+			gui[ 5]=value[4].real;
+			gui[ 6]=value[5].real;
+			gui[ 7]=0;
+			gui[ 8]=value[6].real;
+			gui[ 9]=value[7].real;
+			gui[10]=value[8].real;
+			gui[11]=0;
+		} break;
+		case ShaderLanguage::TYPE_MAT4: {
+
+			GLfloat *gui = (GLfloat*)data;
+
+			for(int i=0;i<16;i++) {
+				gui[i]=value[i].real;
+			}
+		} break;
+		default: {}
+	}
+
+}
+
+
+_FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, uint8_t *data) {
+
+	switch(type) {
+
+		case ShaderLanguage::TYPE_BOOL:
+		case ShaderLanguage::TYPE_INT:
+		case ShaderLanguage::TYPE_UINT:
+		case ShaderLanguage::TYPE_FLOAT: {
+			zeromem(data,4);
+		} break;
+		case ShaderLanguage::TYPE_BVEC2:
+		case ShaderLanguage::TYPE_IVEC2:
+		case ShaderLanguage::TYPE_UVEC2:
+		case ShaderLanguage::TYPE_VEC2: {
+			zeromem(data,8);
+		} break;
+		case ShaderLanguage::TYPE_BVEC3:
+		case ShaderLanguage::TYPE_IVEC3:
+		case ShaderLanguage::TYPE_UVEC3:
+		case ShaderLanguage::TYPE_VEC3:
+		case ShaderLanguage::TYPE_BVEC4:
+		case ShaderLanguage::TYPE_IVEC4:
+		case ShaderLanguage::TYPE_UVEC4:
+		case ShaderLanguage::TYPE_VEC4:
+		case ShaderLanguage::TYPE_MAT2:{
+
+			zeromem(data,16);
+		} break;
+		case ShaderLanguage::TYPE_MAT3:{
+
+			zeromem(data,48);
+		} break;
+		case ShaderLanguage::TYPE_MAT4:{
+			zeromem(data,64);
+		} break;
+
+		default: {}
+	}
+
+}
+
+void RasterizerStorageGLES3::_update_material(Material* material) {
+
+	if (material->dirty_list.in_list())
+		_material_dirty_list.remove( &material->dirty_list );
+
+
+	if (material->shader && material->shader->dirty_list.in_list()) {
+		_update_shader(material->shader);
+	}
+	//update caches
+
+	{
+		bool can_cast_shadow = false;
+		bool is_animated = false;
+
+		if (material->shader && material->shader->mode==VS::SHADER_SPATIAL) {
+			if (!material->shader->spatial.uses_alpha && material->shader->spatial.blend_mode==Shader::Spatial::BLEND_MODE_MIX) {
+				can_cast_shadow=true;
+			}
+
+			if (material->shader->spatial.uses_discard && material->shader->uses_fragment_time) {
+				is_animated=true;
+			}
+
+			if (material->shader->spatial.uses_vertex && material->shader->uses_vertex_time) {
+				is_animated=true;
+			}
+
+		}
+
+		if (can_cast_shadow!=material->can_cast_shadow_cache || is_animated!=material->is_animated_cache) {
+			material->can_cast_shadow_cache=can_cast_shadow;
+			material->is_animated_cache=is_animated;
+
+			for(Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
+				E->key()->material_changed_notify();
+			}
+
+			for(Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
+				E->key()->base_material_changed();
+			}
+
+		}
+
+	}
+
+
+	//clear ubo if it needs to be cleared
+	if (material->ubo_size) {
+
+		if (!material->shader || material->shader->ubo_size!=material->ubo_size) {
+			//by by ubo
+			glDeleteBuffers(1,&material->ubo_id);
+			material->ubo_id=0;
+			material->ubo_size=0;
+		}
+	}
+
+	//create ubo if it needs to be created
+	if (material->ubo_size==0 && material->shader && material->shader->ubo_size) {
+
+		glGenBuffers(1, &material->ubo_id);
+		glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id);
+		glBufferData(GL_UNIFORM_BUFFER, material->shader->ubo_size, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+		material->ubo_size=material->shader->ubo_size;
+	}
+
+	//fill up the UBO if it needs to be filled
+	if (material->shader && material->ubo_size) {
+		uint8_t* local_ubo = (uint8_t*)alloca(material->ubo_size);
+
+		for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
+
+			if (E->get().order<0)
+				continue; // texture, does not go here
+
+			//regular uniform
+			uint8_t *data = &local_ubo[ material->shader->ubo_offsets[E->get().order] ];
+
+			Map<StringName,Variant>::Element *V = material->params.find(E->key());
+
+			if (V) {
+				//user provided				
+				_fill_std140_variant_ubo_value(E->get().type,V->get(),data,material->shader->mode==VS::SHADER_SPATIAL);
+
+			} else if (E->get().default_value.size()){
+				//default value
+				_fill_std140_ubo_value(E->get().type,E->get().default_value,data);
+				//value=E->get().default_value;
+			} else {
+				//zero because it was not provided
+				_fill_std140_ubo_empty(E->get().type,data);
+			}
+
+
+		}
+
+		glBindBuffer(GL_UNIFORM_BUFFER,material->ubo_id);
+		glBufferSubData(GL_UNIFORM_BUFFER, 0, material->ubo_size, local_ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+	}
+
+	//set up the texture array, for easy access when it needs to be drawn
+	if (material->shader && material->shader->texture_count) {
+
+		material->textures.resize(material->shader->texture_count);
+
+		for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
+
+			if (E->get().texture_order<0)
+				continue; // not a texture, does not go here
+
+			RID texture;
+
+			Map<StringName,Variant>::Element *V = material->params.find(E->key());
+			if (V) {
+				texture=V->get();
+			}
+
+			if (!texture.is_valid()) {
+				Map<StringName,RID>::Element *W = material->shader->default_textures.find(E->key());
+				if (W) {
+					texture=W->get();
+				}
+			}
+
+			material->textures[ E->get().texture_order ]=texture;
+
+
+		}
+
+
+	} else {
+		material->textures.clear();
+	}
+
+}
+
+void RasterizerStorageGLES3::_material_add_geometry(RID p_material,Geometry *p_geometry) {
+
+	Material * material = material_owner.getornull(p_material);
+	ERR_FAIL_COND(!material);
+
+	Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
+
+	if (I) {
+		I->get()++;
+	} else {
+		material->geometry_owners[p_geometry]=1;
+	}
+
+}
+
+void RasterizerStorageGLES3::_material_remove_geometry(RID p_material,Geometry *p_geometry) {
+
+	Material * material = material_owner.getornull(p_material);
+	ERR_FAIL_COND(!material);
+
+	Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
+	ERR_FAIL_COND(!I);
+
+	I->get()--;
+	if (I->get()==0) {
+		material->geometry_owners.erase(I);
+	}
+}
+
+
+void RasterizerStorageGLES3::update_dirty_materials() {
+
+	while( _material_dirty_list.first() ) {
+
+		Material *material = _material_dirty_list.first()->self();
+
+		_update_material(material);
+	}
+}
+
+/* MESH API */
+
+RID RasterizerStorageGLES3::mesh_create(){
+
+	Mesh * mesh = memnew( Mesh );
+
+	return mesh_owner.make_rid(mesh);
+}
+
+
+void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes,const Vector<AABB>& p_bone_aabbs){
+
+	DVector<uint8_t> array = p_array;
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX));
+
+	//must have index and bones, both.
+	{
+		uint32_t bones_weight = VS::ARRAY_FORMAT_BONES|VS::ARRAY_FORMAT_WEIGHTS;
+		ERR_EXPLAIN("Array must have both bones and weights in format or none.");
+		ERR_FAIL_COND( (p_format&bones_weight) && (p_format&bones_weight)!=bones_weight );
+	}
+
+
+	bool has_morph = p_blend_shapes.size();
+
+	Surface::Attrib attribs[VS::ARRAY_MAX];
+
+	int stride=0;
+
+	for(int i=0;i<VS::ARRAY_MAX;i++) {
+
+		attribs[i].index=i;
+
+		if (! (p_format&(1<<i) ) ) {
+			attribs[i].enabled=false;
+			attribs[i].integer=false;
+			continue;
+		}
+
+		attribs[i].enabled=true;
+		attribs[i].offset=stride;
+		attribs[i].integer=false;
+
+		switch(i) {
+
+			case VS::ARRAY_VERTEX: {
+
+				if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
+					attribs[i].size=2;
+				} else {
+					attribs[i].size=(p_format&VS::ARRAY_COMPRESS_VERTEX)?4:3;
+				}
+
+				if (p_format&VS::ARRAY_COMPRESS_VERTEX) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=attribs[i].size*2;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=attribs[i].size*4;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+			} break;
+			case VS::ARRAY_NORMAL: {
+
+				attribs[i].size=3;
+
+				if (p_format&VS::ARRAY_COMPRESS_NORMAL) {
+					attribs[i].type=GL_BYTE;
+					stride+=4; //pad extra byte
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=12;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+
+
+			} break;
+			case VS::ARRAY_TANGENT: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_TANGENT) {
+					attribs[i].type=GL_BYTE;
+					stride+=4;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+
+			} break;
+			case VS::ARRAY_COLOR: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_COLOR) {
+					attribs[i].type=GL_UNSIGNED_BYTE;
+					stride+=4;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+
+			} break;
+			case VS::ARRAY_TEX_UV: {
+
+				attribs[i].size=2;
+
+				if (p_format&VS::ARRAY_COMPRESS_TEX_UV) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=4;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=8;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+
+			} break;
+			case VS::ARRAY_TEX_UV2: {
+
+				attribs[i].size=2;
+
+				if (p_format&VS::ARRAY_COMPRESS_TEX_UV2) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=4;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=8;
+				}
+				attribs[i].normalized=GL_FALSE;
+
+
+
+			} break;
+			case VS::ARRAY_BONES: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) {
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					stride+=8;
+				} else {
+					attribs[i].type=GL_UNSIGNED_BYTE;
+					stride+=4;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+				attribs[i].integer=true;
+
+
+
+			} break;
+			case VS::ARRAY_WEIGHTS: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) {
+
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					stride+=8;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+			} break;
+			case VS::ARRAY_INDEX: {
+
+				attribs[i].size=1;
+
+				if (p_vertex_count>=(1<<16)) {
+					attribs[i].type=GL_UNSIGNED_INT;
+					attribs[i].stride=4;
+				} else {
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					attribs[i].stride=2;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+			} break;
+
+		}
+	}
+
+	for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+		attribs[i].stride=stride;
+	}
+
+	//validate sizes
+
+	int array_size = stride * p_vertex_count;
+	int index_array_size=0;
+
+	print_line("desired size: "+itos(array_size)+" vcount "+itos(p_vertex_count)+" should be: "+itos(array.size()+p_vertex_count*2)+" but is "+itos(array.size()));
+	if (array.size()!=array_size && array.size()+p_vertex_count*2 == array_size) {
+		//old format, convert
+		array = DVector<uint8_t>();
+
+		array.resize( p_array.size()+p_vertex_count*2 );
+
+		DVector<uint8_t>::Write w = array.write();
+		DVector<uint8_t>::Read r = p_array.read();
+
+		uint16_t *w16 = (uint16_t*)w.ptr();
+		const uint16_t *r16 = (uint16_t*)r.ptr();
+
+		uint16_t one = Math::make_half_float(1);
+
+		for(int i=0;i<p_vertex_count;i++) {
+
+			*w16++ = *r16++;
+			*w16++ = *r16++;
+			*w16++ = *r16++;
+			*w16++ = one;
+			for(int j=0;j<(stride/2)-4;j++) {
+				*w16++ = *r16++;
+			}
+		}
+
+	}
+
+	ERR_FAIL_COND(array.size()!=array_size);
+
+	if (p_format&VS::ARRAY_FORMAT_INDEX) {
+
+		index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count;
+	}
+
+
+	ERR_FAIL_COND(p_index_array.size()!=index_array_size);
+
+	ERR_FAIL_COND(p_blend_shapes.size()!=mesh->morph_target_count);
+
+	for(int i=0;i<p_blend_shapes.size();i++) {
+		ERR_FAIL_COND(p_blend_shapes[i].size()!=array_size);
+	}
+
+	//ok all valid, create stuff
+
+	Surface * surface = memnew( Surface );
+
+	surface->active=true;
+	surface->array_len=p_vertex_count;
+	surface->index_array_len=p_index_count;
+	surface->array_byte_size=array.size();
+	surface->index_array_byte_size=p_index_array.size();
+	surface->primitive=p_primitive;
+	surface->mesh=mesh;
+	surface->format=p_format;
+	surface->skeleton_bone_aabb=p_bone_aabbs;
+	surface->skeleton_bone_used.resize(surface->skeleton_bone_aabb.size());
+	surface->aabb=p_aabb;
+	surface->max_bone=p_bone_aabbs.size();
+
+	for(int i=0;i<surface->skeleton_bone_used.size();i++) {
+		if (surface->skeleton_bone_aabb[i].size.x<0 || surface->skeleton_bone_aabb[i].size.y<0 || surface->skeleton_bone_aabb[i].size.z<0) {
+			surface->skeleton_bone_used[i]=false;
+		} else {
+			surface->skeleton_bone_used[i]=true;
+		}
+	}
+
+	for(int i=0;i<VS::ARRAY_MAX;i++) {
+		surface->attribs[i]=attribs[i];
+	}
+
+	{
+
+		DVector<uint8_t>::Read vr = array.read();
+
+		glGenBuffers(1,&surface->vertex_id);
+		glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+		glBufferData(GL_ARRAY_BUFFER,array_size,vr.ptr(),GL_STATIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+
+		if (p_format&VS::ARRAY_FORMAT_INDEX) {
+
+			DVector<uint8_t>::Read ir = p_index_array.read();
+
+			glGenBuffers(1,&surface->index_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
+			glBufferData(GL_ELEMENT_ARRAY_BUFFER,index_array_size,ir.ptr(),GL_STATIC_DRAW);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
+
+
+		}
+
+		//generate arrays for faster state switching
+
+		for(int ai=0;ai<2;ai++) {
+
+			if (ai==0) {
+				//for normal draw
+				glGenVertexArrays(1,&surface->array_id);
+				glBindVertexArray(surface->array_id);
+				glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+			} else if (ai==1) {
+				//for instancing draw (can be changed and no one cares)
+				glGenVertexArrays(1,&surface->instancing_array_id);
+				glBindVertexArray(surface->instancing_array_id);
+				glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+			}
+
+
+			for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+
+				if (!attribs[i].enabled)
+					continue;
+
+				if (attribs[i].integer) {
+					glVertexAttribIPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+				} else {
+					glVertexAttribPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].normalized,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+				}
+				glEnableVertexAttribArray(attribs[i].index);
+
+			}
+
+			if (surface->index_id) {
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
+			}
+
+			glBindVertexArray(0);
+			glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+		}
+
+	}
+
+	{
+
+		//blend shapes
+
+		for(int i=0;i<p_blend_shapes.size();i++) {
+
+			Surface::MorphTarget mt;
+
+			DVector<uint8_t>::Read vr = p_blend_shapes[i].read();
+
+			glGenBuffers(1,&mt.vertex_id);
+			glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
+			glBufferData(GL_ARRAY_BUFFER,array_size,vr.ptr(),GL_STATIC_DRAW);
+			glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+			glGenVertexArrays(1,&mt.array_id);
+			glBindVertexArray(mt.array_id);
+			glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
+
+			for(int j=0;j<VS::ARRAY_MAX-1;j++) {
+
+				if (!attribs[j].enabled)
+					continue;
+
+				if (attribs[j].integer) {
+					glVertexAttribIPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
+				} else {
+					glVertexAttribPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].normalized,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
+				}
+				glEnableVertexAttribArray(attribs[j].index);
+
+			}
+
+			glBindVertexArray(0);
+			glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+			surface->morph_targets.push_back(mt);
+
+		}
+	}
+
+	mesh->surfaces.push_back(surface);
+	mesh->instance_change_notify();
+}
+
+void RasterizerStorageGLES3::mesh_set_morph_target_count(RID p_mesh,int p_amount){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+
+	ERR_FAIL_COND(mesh->surfaces.size()!=0);
+	ERR_FAIL_COND(p_amount<0);
+
+	mesh->morph_target_count=p_amount;
+
+}
+int RasterizerStorageGLES3::mesh_get_morph_target_count(RID p_mesh) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+
+	return mesh->morph_target_count;
+}
+
+
+void RasterizerStorageGLES3::mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	mesh->morph_target_mode=p_mode;
+
+}
+VS::MorphTargetMode RasterizerStorageGLES3::mesh_get_morph_target_mode(RID p_mesh) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,VS::MORPH_MODE_NORMALIZED);
+
+	return mesh->morph_target_mode;
+}
+
+void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
+
+	if (mesh->surfaces[p_surface]->material==p_material)
+		return;
+
+	if (mesh->surfaces[p_surface]->material.is_valid()) {
+		_material_remove_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
+	}
+
+	mesh->surfaces[p_surface]->material=p_material;
+
+	if (mesh->surfaces[p_surface]->material.is_valid()) {
+		_material_add_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
+	}
+
+	mesh->instance_material_change_notify();
+
+
+}
+RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,RID());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),RID());
+
+	return mesh->surfaces[p_surface]->material;
+}
+
+int RasterizerStorageGLES3::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
+
+	return mesh->surfaces[p_surface]->array_len;
+
+}
+int RasterizerStorageGLES3::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
+
+	return mesh->surfaces[p_surface]->index_array_len;
+}
+
+DVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,DVector<uint8_t>());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),DVector<uint8_t>());
+
+	Surface *surface = mesh->surfaces[p_surface];
+
+	glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+	void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_byte_size,GL_MAP_READ_BIT);
+
+	ERR_FAIL_COND_V(!data,DVector<uint8_t>());
+
+	DVector<uint8_t> ret;
+	ret.resize(surface->array_byte_size);
+
+	{
+
+		DVector<uint8_t>::Write w = ret.write();
+		copymem(w.ptr(),data,surface->array_byte_size);
+	}
+	glUnmapBuffer(GL_ARRAY_BUFFER);
+
+
+	return ret;
+}
+
+DVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_mesh, int p_surface) const {
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,DVector<uint8_t>());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),DVector<uint8_t>());
+
+	Surface *surface = mesh->surfaces[p_surface];
+
+	ERR_FAIL_COND_V(surface->index_array_len==0,DVector<uint8_t>());
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
+	void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,surface->index_array_byte_size,GL_MAP_READ_BIT);
+
+	ERR_FAIL_COND_V(!data,DVector<uint8_t>());
+
+	DVector<uint8_t> ret;
+	ret.resize(surface->index_array_byte_size);
+
+	{
+
+		DVector<uint8_t>::Write w = ret.write();
+		copymem(w.ptr(),data,surface->index_array_byte_size);
+	}
+
+	glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+
+	return ret;
+}
+
+
+uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
+
+	return mesh->surfaces[p_surface]->format;
+
+}
+
+VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,VS::PRIMITIVE_MAX);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),VS::PRIMITIVE_MAX);
+
+	return mesh->surfaces[p_surface]->primitive;
+}
+
+AABB RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,AABB());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),AABB());
+
+	return mesh->surfaces[p_surface]->aabb;
+
+
+}
+Vector<DVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,Vector<DVector<uint8_t> >());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<DVector<uint8_t> >());
+
+	Vector<DVector<uint8_t> > bsarr;
+
+	for(int i=0;i<mesh->surfaces[p_surface]->morph_targets.size();i++) {
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh->surfaces[p_surface]->morph_targets[i].vertex_id);
+		void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,mesh->surfaces[p_surface]->array_byte_size,GL_MAP_READ_BIT);
+
+		ERR_FAIL_COND_V(!data,Vector<DVector<uint8_t> >());
+
+		DVector<uint8_t> ret;
+		ret.resize(mesh->surfaces[p_surface]->array_byte_size);
+
+		{
+
+			DVector<uint8_t>::Write w = ret.write();
+			copymem(w.ptr(),data,mesh->surfaces[p_surface]->array_byte_size);
+		}
+
+		bsarr.push_back(ret);
+
+		glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+	}
+
+	return bsarr;
+
+}
+Vector<AABB> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,Vector<AABB >());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<AABB >());
+
+	return mesh->surfaces[p_surface]->skeleton_bone_aabb;
+
+}
+
+
+void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
+
+	Surface *surface = mesh->surfaces[p_surface];
+
+	if (surface->material.is_valid()) {
+		_material_remove_geometry(surface->material,mesh->surfaces[p_surface]);
+	}
+
+	glDeleteBuffers(1,&surface->vertex_id);
+	if (surface->index_id) {
+		glDeleteBuffers(1,&surface->index_id);
+	}
+
+	glDeleteVertexArrays(1,&surface->array_id);
+
+	for(int i=0;i<surface->morph_targets.size();i++) {
+
+		glDeleteBuffers(1,&surface->morph_targets[i].vertex_id);
+		glDeleteVertexArrays(1,&surface->morph_targets[i].array_id);
+	}
+
+	mesh->instance_material_change_notify();
+
+	memdelete(surface);
+
+	mesh->surfaces.remove(p_surface);
+
+	mesh->instance_change_notify();
+}
+int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	return mesh->surfaces.size();
+
+}
+
+void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	mesh->custom_aabb=p_aabb;
+}
+AABB RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
+
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,AABB());
+
+	return mesh->custom_aabb;
+
+}
+
+AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
+
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND_V(!mesh,AABB());
+
+	if (mesh->custom_aabb!=AABB())
+		return mesh->custom_aabb;
+
+	Skeleton *sk=NULL;
+	if (p_skeleton.is_valid())
+		sk=skeleton_owner.get(p_skeleton);
+
+	AABB aabb;
+
+	if (sk && sk->size!=0) {
+
+
+		for (int i=0;i<mesh->surfaces.size();i++) {
+
+			AABB laabb;
+			if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) {
+
+
+				int bs = mesh->surfaces[i]->skeleton_bone_aabb.size();
+				const AABB *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
+				const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
+
+				int sbs = sk->size;
+				ERR_CONTINUE(bs>sbs);
+				float *skb = sk->bones.ptr();
+
+
+
+				bool first=true;
+				if (sk->use_2d) {
+					for(int j=0;j<bs;j++) {
+
+						if (!skused[j])
+							continue;
+
+						float *dataptr = &skb[8*j];
+
+						Transform mtx;
+
+						mtx.basis.elements[0][0]=dataptr[ 0];
+						mtx.basis.elements[0][1]=dataptr[ 1];
+						mtx.origin[0]=dataptr[ 3];
+						mtx.basis.elements[1][0]=dataptr[ 4];
+						mtx.basis.elements[1][1]=dataptr[ 5];
+						mtx.origin[1]=dataptr[ 7];
+
+						AABB baabb = mtx.xform( skbones[j] );
+						if (first) {
+							laabb=baabb;
+							first=false;
+						} else {
+							laabb.merge_with(baabb);
+						}
+					}
+				} else {
+					for(int j=0;j<bs;j++) {
+
+						if (!skused[j])
+							continue;
+
+						float *dataptr = &skb[12*j];
+
+						Transform mtx;
+						mtx.basis.elements[0][0]=dataptr[ 0];
+						mtx.basis.elements[0][1]=dataptr[ 1];
+						mtx.basis.elements[0][2]=dataptr[ 2];
+						mtx.origin.x=dataptr[ 3];
+						mtx.basis.elements[1][0]=dataptr[ 4];
+						mtx.basis.elements[1][1]=dataptr[ 5];
+						mtx.basis.elements[1][2]=dataptr[ 6];
+						mtx.origin.y=dataptr[ 7];
+						mtx.basis.elements[2][0]=dataptr[ 8];
+						mtx.basis.elements[2][1]=dataptr[ 9];
+						mtx.basis.elements[2][2]=dataptr[10];
+						mtx.origin.z=dataptr[11];
+
+						AABB baabb = mtx.xform ( skbones[j] );
+						if (first) {
+							laabb=baabb;
+							first=false;
+						} else {
+							laabb.merge_with(baabb);
+						}
+					}
+				}
+
+			} else {
+
+				laabb=mesh->surfaces[i]->aabb;
+			}
+
+			if (i==0)
+				aabb=laabb;
+			else
+				aabb.merge_with(laabb);
+		}
+	} else {
+
+		for (int i=0;i<mesh->surfaces.size();i++) {
+
+			if (i==0)
+				aabb=mesh->surfaces[i]->aabb;
+			else
+				aabb.merge_with(mesh->surfaces[i]->aabb);
+		}
+
+	}
+
+	return aabb;
+
+}
+void RasterizerStorageGLES3::mesh_clear(RID p_mesh){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	while(mesh->surfaces.size()) {
+		mesh_remove_surface(p_mesh,0);
+	}
+}
+
+void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weights) {
+
+	glBindVertexArray(s->array_id);
+
+	BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX-1]={
+		BlendShapeShaderGLES3::ENABLE_NORMAL, //will be ignored
+		BlendShapeShaderGLES3::ENABLE_NORMAL,
+		BlendShapeShaderGLES3::ENABLE_TANGENT,
+		BlendShapeShaderGLES3::ENABLE_COLOR,
+		BlendShapeShaderGLES3::ENABLE_UV,
+		BlendShapeShaderGLES3::ENABLE_UV2,
+		BlendShapeShaderGLES3::ENABLE_SKELETON,
+		BlendShapeShaderGLES3::ENABLE_SKELETON,
+	};
+
+	int stride=0;
+
+	if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
+		stride=2*4;
+	} else {
+		stride=3*4;
+	}
+
+	static const int sizes[VS::ARRAY_MAX-1]={
+		3*4,
+		3*4,
+		4*4,
+		4*4,
+		2*4,
+		2*4,
+		4*4,
+		4*4
+	};
+
+	for(int i=1;i<VS::ARRAY_MAX-1;i++) {
+		shaders.blend_shapes.set_conditional(cond[i],s->format&(1<<i)); //enable conditional for format
+		if (s->format&(1<<i)) {
+			stride+=sizes[i];
+		}
+	}
+
+
+	//copy all first
+	float base_weight=1.0;
+
+	int mtc = s->morph_targets.size();
+
+	if (s->mesh->morph_target_mode==VS::MORPH_MODE_NORMALIZED) {
+
+		for(int i=0;i<mtc;i++) {
+			base_weight-=p_weights[i];
+		}
+	}
+
+
+
+	shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,false); //first pass does not blend
+	shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::USE_2D_VERTEX,s->format&VS::ARRAY_FLAG_USE_2D_VERTICES); //use 2D vertices if needed
+
+	shaders.blend_shapes.bind();
+
+	shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,base_weight);
+	glEnable(GL_RASTERIZER_DISCARD);
+
+	glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[0]);
+	glBeginTransformFeedback(GL_POINTS);
+	glDrawArrays(GL_POINTS,0,s->array_len);
+	glEndTransformFeedback();
+
+
+	shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,true); //first pass does not blend
+	shaders.blend_shapes.bind();
+
+	for(int ti=0;ti<mtc;ti++) {
+		float weight = p_weights[ti];
+
+		if (weight<0.001) //not bother with this one
+			continue;
+
+		glBindVertexArray(s->morph_targets[ti].array_id);
+		glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]);
+		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[1]);
+
+		shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,weight);
+
+		int ofs=0;
+		for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+
+			if (s->format&(1<<i)) {
+				glEnableVertexAttribArray(i+8);
+				switch(i) {
+
+					case VS::ARRAY_VERTEX: {
+						if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
+							glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+							ofs+=2*4;
+						} else {
+							glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+							ofs+=3*4;
+						}
+					} break;
+					case VS::ARRAY_NORMAL: {
+						glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=3*4;
+					} break;
+					case VS::ARRAY_TANGENT: {
+						glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=4*4;
+
+					} break;
+					case VS::ARRAY_COLOR: {
+						glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=4*4;
+
+					} break;
+					case VS::ARRAY_TEX_UV: {
+						glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=2*4;
+
+					} break;
+					case VS::ARRAY_TEX_UV2: {
+						glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=2*4;
+
+					} break;
+					case VS::ARRAY_BONES: {
+						glVertexAttribIPointer(i+8,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs);
+						ofs+=4*4;
+
+					} break;
+					case VS::ARRAY_WEIGHTS: {
+						glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=4*4;
+
+					} break;
+				}
+
+			} else {
+				glDisableVertexAttribArray(i+8);
+			}
+		}
+
+		glBeginTransformFeedback(GL_POINTS);
+		glDrawArrays(GL_POINTS,0,s->array_len);
+		glEndTransformFeedback();
+
+
+		SWAP(resources.transform_feedback_buffers[0],resources.transform_feedback_buffers[1]);
+
+	}
+
+	glDisable(GL_RASTERIZER_DISCARD);
+	glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
+
+
+	glBindVertexArray(resources.transform_feedback_array);
+	glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]);
+
+	int ofs=0;
+	for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+
+		if (s->format&(1<<i)) {
+			glEnableVertexAttribArray(i);
+			switch(i) {
+
+				case VS::ARRAY_VERTEX: {
+					if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
+						glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=2*4;
+					} else {
+						glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+						ofs+=3*4;
+					}
+				} break;
+				case VS::ARRAY_NORMAL: {
+					glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=3*4;
+				} break;
+				case VS::ARRAY_TANGENT: {
+					glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=4*4;
+
+				} break;
+				case VS::ARRAY_COLOR: {
+					glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=4*4;
+
+				} break;
+				case VS::ARRAY_TEX_UV: {
+					glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=2*4;
+
+				} break;
+				case VS::ARRAY_TEX_UV2: {
+					glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=2*4;
+
+				} break;
+				case VS::ARRAY_BONES: {
+					glVertexAttribIPointer(i,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs);
+					ofs+=4*4;
+
+				} break;
+				case VS::ARRAY_WEIGHTS: {
+					glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
+					ofs+=4*4;
+
+				} break;
+			}
+
+		} else {
+			glDisableVertexAttribArray(i);
+		}
+	}
+
+	if (s->index_array_len) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,s->index_id);
+	}
+
+}
+
+/* MULTIMESH API */
+
+
+RID RasterizerStorageGLES3::multimesh_create(){
+
+	MultiMesh *multimesh = memnew( MultiMesh );
+	return multimesh_owner.make_rid(multimesh);
+}
+
+void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+
+	if (multimesh->size==p_instances && multimesh->transform_format==p_transform_format && multimesh->color_format==p_color_format)
+		return;
+
+	if (multimesh->buffer) {
+		glDeleteBuffers(1,&multimesh->buffer);
+		multimesh->data.resize(0);
+	}
+
+	multimesh->size=p_instances;
+	multimesh->transform_format=p_transform_format;
+	multimesh->color_format=p_color_format;
+
+	if (multimesh->size) {
+
+		if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
+			multimesh->xform_floats=8;
+		} else {
+			multimesh->xform_floats=12;
+
+		}
+
+		if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) {
+			multimesh->color_floats=0;
+		} else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+			multimesh->color_floats=1;
+		} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
+			multimesh->color_floats=4;
+		}
+
+		int format_floats = multimesh->color_floats+multimesh->xform_floats;
+		multimesh->data.resize(format_floats*p_instances);
+		for(int i=0;i<p_instances;i+=format_floats) {
+
+			int color_from=0;
+
+			if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
+				multimesh->data[i+0]=1.0;
+				multimesh->data[i+1]=0.0;
+				multimesh->data[i+2]=0.0;
+				multimesh->data[i+3]=0.0;
+				multimesh->data[i+4]=0.0;
+				multimesh->data[i+5]=1.0;
+				multimesh->data[i+6]=0.0;
+				multimesh->data[i+7]=0.0;
+				color_from=8;
+			} else {
+				multimesh->data[i+0]=1.0;
+				multimesh->data[i+1]=0.0;
+				multimesh->data[i+2]=0.0;
+				multimesh->data[i+3]=0.0;
+				multimesh->data[i+4]=0.0;
+				multimesh->data[i+5]=1.0;
+				multimesh->data[i+6]=0.0;
+				multimesh->data[i+7]=0.0;
+				multimesh->data[i+8]=0.0;
+				multimesh->data[i+9]=0.0;
+				multimesh->data[i+10]=1.0;
+				multimesh->data[i+11]=0.0;
+				color_from=12;
+			}
+
+			if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) {
+				//none
+			} else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+
+				union {
+					uint32_t colu;
+					float colf;
+				} cu;
+
+				cu.colu=0xFFFFFFFF;
+				multimesh->data[i+color_from+0]=cu.colf;
+
+			} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
+				multimesh->data[i+color_from+0]=1.0;
+				multimesh->data[i+color_from+1]=1.0;
+				multimesh->data[i+color_from+2]=1.0;
+				multimesh->data[i+color_from+3]=1.0;
+			}
+		}
+
+		glGenBuffers(1,&multimesh->buffer);
+		glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer);
+		glBufferData(GL_ARRAY_BUFFER,multimesh->data.size()*sizeof(float),NULL,GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER,0);
+
+	}
+
+	multimesh->dirty_data=true;
+	multimesh->dirty_aabb=true;
+
+	if (!multimesh->update_list.in_list()) {
+		multimesh_update_list.add(&multimesh->update_list);
+	}
+
+}
+
+int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,0);
+
+	return multimesh->size;
+}
+
+void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+
+	multimesh->mesh=p_mesh;
+
+	multimesh->dirty_aabb=true;
+
+	if (!multimesh->update_list.in_list()) {
+		multimesh_update_list.add(&multimesh->update_list);
+	}
+}
+
+void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+	ERR_FAIL_INDEX(p_index,multimesh->size);
+	ERR_FAIL_COND(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D);
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index];
+
+	dataptr[ 0]=p_transform.basis.elements[0][0];
+	dataptr[ 1]=p_transform.basis.elements[0][1];
+	dataptr[ 2]=p_transform.basis.elements[0][2];
+	dataptr[ 3]=p_transform.origin.x;
+	dataptr[ 4]=p_transform.basis.elements[1][0];
+	dataptr[ 5]=p_transform.basis.elements[1][1];
+	dataptr[ 6]=p_transform.basis.elements[1][2];
+	dataptr[ 7]=p_transform.origin.y;
+	dataptr[ 8]=p_transform.basis.elements[2][0];
+	dataptr[ 9]=p_transform.basis.elements[2][1];
+	dataptr[10]=p_transform.basis.elements[2][2];
+	dataptr[11]=p_transform.origin.z;
+
+	multimesh->dirty_data=true;
+	multimesh->dirty_aabb=true;
+
+	if (!multimesh->update_list.in_list()) {
+		multimesh_update_list.add(&multimesh->update_list);
+	}
+}
+
+void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Matrix32& p_transform){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+	ERR_FAIL_INDEX(p_index,multimesh->size);
+	ERR_FAIL_COND(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D);
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index];
+
+	dataptr[ 0]=p_transform.elements[0][0];
+	dataptr[ 1]=p_transform.elements[1][0];
+	dataptr[ 2]=0;
+	dataptr[ 3]=p_transform.elements[2][0];
+	dataptr[ 4]=p_transform.elements[0][1];
+	dataptr[ 5]=p_transform.elements[1][1];
+	dataptr[ 6]=0;
+	dataptr[ 7]=p_transform.elements[2][1];
+
+	multimesh->dirty_data=true;
+	multimesh->dirty_aabb=true;
+
+	if (!multimesh->update_list.in_list()) {
+		multimesh_update_list.add(&multimesh->update_list);
+	}
+}
+void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+	ERR_FAIL_INDEX(p_index,multimesh->size);
+	ERR_FAIL_COND(multimesh->color_format==VS::MULTIMESH_COLOR_NONE);
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index+multimesh->xform_floats];
+
+	if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+
+		uint8_t *data8=(uint8_t*)dataptr;
+		data8[0]=CLAMP(p_color.r*255.0,0,255);
+		data8[1]=CLAMP(p_color.g*255.0,0,255);
+		data8[2]=CLAMP(p_color.b*255.0,0,255);
+		data8[3]=CLAMP(p_color.a*255.0,0,255);
+
+	} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
+		dataptr[ 0]=p_color.r;
+		dataptr[ 1]=p_color.g;
+		dataptr[ 2]=p_color.b;
+		dataptr[ 3]=p_color.a;
+	}
+
+
+	multimesh->dirty_data=true;
+	multimesh->dirty_aabb=true;
+
+	if (!multimesh->update_list.in_list()) {
+		multimesh_update_list.add(&multimesh->update_list);
+	}
+}
+
+RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,RID());
+
+	return multimesh->mesh;
+}
+
+
+Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh,int p_index) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,Transform());
+	ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform());
+	ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D,Transform());
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index];
+
+	Transform xform;
+
+	xform.basis.elements[0][0]=dataptr[ 0];
+	xform.basis.elements[0][1]=dataptr[ 1];
+	xform.basis.elements[0][2]=dataptr[ 2];
+	xform.origin.x=dataptr[ 3];
+	xform.basis.elements[1][0]=dataptr[ 4];
+	xform.basis.elements[1][1]=dataptr[ 5];
+	xform.basis.elements[1][2]=dataptr[ 6];
+	xform.origin.y=dataptr[ 7];
+	xform.basis.elements[2][0]=dataptr[ 8];
+	xform.basis.elements[2][1]=dataptr[ 9];
+	xform.basis.elements[2][2]=dataptr[10];
+	xform.origin.z=dataptr[11];
+
+	return xform;
+}
+Matrix32 RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,Matrix32());
+	ERR_FAIL_INDEX_V(p_index,multimesh->size,Matrix32());
+	ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D,Matrix32());
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index];
+
+	Matrix32 xform;
+
+	xform.elements[0][0]=dataptr[ 0];
+	xform.elements[1][0]=dataptr[ 1];
+	xform.elements[2][0]=dataptr[ 3];
+	xform.elements[0][1]=dataptr[ 4];
+	xform.elements[1][1]=dataptr[ 5];
+	xform.elements[2][1]=dataptr[ 7];
+
+	return xform;
+}
+
+Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p_index) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,Color());
+	ERR_FAIL_INDEX_V(p_index,multimesh->size,Color());
+	ERR_FAIL_COND_V(multimesh->color_format==VS::MULTIMESH_COLOR_NONE,Color());
+
+	int stride = multimesh->color_floats+multimesh->xform_floats;
+	float *dataptr=&multimesh->data[stride*p_index+multimesh->color_floats];
+
+	if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+		union {
+			uint32_t colu;
+			float colf;
+		} cu;
+
+		return Color::hex(BSWAP32(cu.colu));
+
+	} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
+		Color c;
+		c.r=dataptr[ 0];
+		c.g=dataptr[ 1];
+		c.b=dataptr[ 2];
+		c.a=dataptr[ 3];
+
+		return c;
+	}
+
+	return Color();
+
+}
+
+void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh,int p_visible){
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+
+	multimesh->visible_instances=p_visible;
+}
+int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,-1);
+
+	return multimesh->visible_instances;
+}
+
+AABB RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
+
+	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	ERR_FAIL_COND_V(!multimesh,AABB());
+
+	const_cast<RasterizerStorageGLES3*>(this)->update_dirty_multimeshes(); //update pending AABBs
+
+	return multimesh->aabb;
+}
+
+void RasterizerStorageGLES3::update_dirty_multimeshes() {
+
+	while(multimesh_update_list.first()) {
+
+		MultiMesh *multimesh = multimesh_update_list.first()->self();
+
+		if (multimesh->size && multimesh->dirty_data) {
+
+
+			glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer);
+			glBufferSubData(GL_ARRAY_BUFFER,0,multimesh->data.size()*sizeof(float),multimesh->data.ptr());
+			glBindBuffer(GL_ARRAY_BUFFER,0);
+
+
+		}
+
+
+
+		if (multimesh->size && multimesh->dirty_aabb) {
+
+			AABB mesh_aabb;
+
+			if (multimesh->mesh.is_valid()) {
+				mesh_aabb=mesh_get_aabb(multimesh->mesh,RID());
+			} else {
+				mesh_aabb.size+=Vector3(0.001,0.001,0.001);
+			}
+
+			int stride=multimesh->color_floats+multimesh->xform_floats;
+			int count = multimesh->data.size();
+			float *data=multimesh->data.ptr();
+
+			AABB aabb;
+
+			if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
+
+				for(int i=0;i<count;i+=stride) {
+
+					float *dataptr=&data[i];
+					Transform xform;
+					xform.basis[0][0]=dataptr[ 0];
+					xform.basis[0][1]=dataptr[ 1];
+					xform.origin[0]=dataptr[ 3];
+					xform.basis[1][0]=dataptr[ 4];
+					xform.basis[1][1]=dataptr[ 5];
+					xform.origin[1]=dataptr[ 7];
+
+					AABB laabb = xform.xform(mesh_aabb);
+					if (i==0)
+						aabb=laabb;
+					else
+						aabb.merge_with(laabb);
+				}
+			} else {
+
+				for(int i=0;i<count;i+=stride) {
+
+					float *dataptr=&data[i];
+					Transform xform;
+
+					xform.basis.elements[0][0]=dataptr[ 0];
+					xform.basis.elements[0][1]=dataptr[ 1];
+					xform.basis.elements[0][2]=dataptr[ 2];
+					xform.origin.x=dataptr[ 3];
+					xform.basis.elements[1][0]=dataptr[ 4];
+					xform.basis.elements[1][1]=dataptr[ 5];
+					xform.basis.elements[1][2]=dataptr[ 6];
+					xform.origin.y=dataptr[ 7];
+					xform.basis.elements[2][0]=dataptr[ 8];
+					xform.basis.elements[2][1]=dataptr[ 9];
+					xform.basis.elements[2][2]=dataptr[10];
+					xform.origin.z=dataptr[11];
+
+					AABB laabb = xform.xform(mesh_aabb);
+					if (i==0)
+						aabb=laabb;
+					else
+						aabb.merge_with(laabb);
+				}
+			}
+
+			multimesh->aabb=aabb;
+		}
+		multimesh->dirty_aabb=false;
+		multimesh->dirty_data=false;
+
+		multimesh->instance_change_notify();
+
+		multimesh_update_list.remove(multimesh_update_list.first());
+	}
+}
+
+/* IMMEDIATE API */
+
+
+RID RasterizerStorageGLES3::immediate_create() {
+
+	Immediate *im = memnew( Immediate );
+	return immediate_owner.make_rid(im);
+
+}
+
+void RasterizerStorageGLES3::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(im->building);
+
+	Immediate::Chunk ic;
+	ic.texture=p_texture;
+	ic.primitive=p_rimitive;
+	im->chunks.push_back(ic);
+	im->mask=0;
+	im->building=true;
+
+
+}
+void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	Immediate::Chunk *c = &im->chunks.back()->get();
+
+
+	if (c->vertices.empty() && im->chunks.size()==1) {
+
+		im->aabb.pos=p_vertex;
+		im->aabb.size=Vector3();
+	} else {
+		im->aabb.expand_to(p_vertex);
+	}
+
+	if (im->mask&VS::ARRAY_FORMAT_NORMAL)
+		c->normals.push_back(chunk_normal);
+	if (im->mask&VS::ARRAY_FORMAT_TANGENT)
+		c->tangents.push_back(chunk_tangent);
+	if (im->mask&VS::ARRAY_FORMAT_COLOR)
+		c->colors.push_back(chunk_color);
+	if (im->mask&VS::ARRAY_FORMAT_TEX_UV)
+		c->uvs.push_back(chunk_uv);
+	if (im->mask&VS::ARRAY_FORMAT_TEX_UV2)
+		c->uvs2.push_back(chunk_uv2);
+	im->mask|=VS::ARRAY_FORMAT_VERTEX;
+	c->vertices.push_back(p_vertex);
+
+}
+
+
+void RasterizerStorageGLES3::immediate_normal(RID p_immediate,const Vector3& p_normal){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->mask|=VS::ARRAY_FORMAT_NORMAL;
+	chunk_normal=p_normal;
+
+}
+void RasterizerStorageGLES3::immediate_tangent(RID p_immediate,const Plane& p_tangent){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->mask|=VS::ARRAY_FORMAT_TANGENT;
+	chunk_tangent=p_tangent;
+
+}
+void RasterizerStorageGLES3::immediate_color(RID p_immediate,const Color& p_color){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->mask|=VS::ARRAY_FORMAT_COLOR;
+	chunk_color=p_color;
+
+}
+void RasterizerStorageGLES3::immediate_uv(RID p_immediate,const Vector2& tex_uv){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->mask|=VS::ARRAY_FORMAT_TEX_UV;
+	chunk_uv=tex_uv;
+
+}
+void RasterizerStorageGLES3::immediate_uv2(RID p_immediate,const Vector2& tex_uv){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->mask|=VS::ARRAY_FORMAT_TEX_UV2;
+	chunk_uv2=tex_uv;
+
+}
+
+void RasterizerStorageGLES3::immediate_end(RID p_immediate){
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(!im->building);
+
+	im->building=false;
+
+	im->instance_change_notify();
+
+}
+void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	ERR_FAIL_COND(im->building);
+
+	im->chunks.clear();
+	im->instance_change_notify();
+
+}
+
+AABB RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND_V(!im,AABB());
+	return im->aabb;
+}
+
+void RasterizerStorageGLES3::immediate_set_material(RID p_immediate,RID p_material) {
+
+	Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND(!im);
+	im->material=p_material;
+	im->instance_material_change_notify();
+
+}
+
+RID RasterizerStorageGLES3::immediate_get_material(RID p_immediate) const {
+
+	const Immediate *im = immediate_owner.get(p_immediate);
+	ERR_FAIL_COND_V(!im,RID());
+	return im->material;
+
+}
+
+/* SKELETON API */
+
+RID RasterizerStorageGLES3::skeleton_create(){
+
+	Skeleton *skeleton = memnew( Skeleton );
+	return skeleton_owner.make_rid(skeleton);
+}
+
+void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton){
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	ERR_FAIL_COND(!skeleton);
+	ERR_FAIL_COND(p_bones<0);
+
+	if (skeleton->size==p_bones && skeleton->use_2d==p_2d_skeleton)
+		return;
+
+	if (skeleton->ubo) {
+		glDeleteBuffers(1,&skeleton->ubo);
+		skeleton->ubo=0;
+	}
+
+	skeleton->size=p_bones;
+	if (p_2d_skeleton) {
+		skeleton->bones.resize(p_bones*8);
+		for(int i=0;i<skeleton->bones.size();i+=8) {
+			skeleton->bones[i+0]=1;
+			skeleton->bones[i+1]=0;
+			skeleton->bones[i+2]=0;
+			skeleton->bones[i+3]=0;
+			skeleton->bones[i+4]=0;
+			skeleton->bones[i+5]=1;
+			skeleton->bones[i+6]=0;
+			skeleton->bones[i+7]=0;
+		}
+
+	} else {
+		skeleton->bones.resize(p_bones*12);
+		for(int i=0;i<skeleton->bones.size();i+=12) {
+			skeleton->bones[i+0]=1;
+			skeleton->bones[i+1]=0;
+			skeleton->bones[i+2]=0;
+			skeleton->bones[i+3]=0;
+			skeleton->bones[i+4]=0;
+			skeleton->bones[i+5]=1;
+			skeleton->bones[i+6]=0;
+			skeleton->bones[i+7]=0;
+			skeleton->bones[i+8]=0;
+			skeleton->bones[i+9]=0;
+			skeleton->bones[i+10]=1;
+			skeleton->bones[i+11]=0;
+		}
+
+	}
+
+
+
+	if (p_bones) {
+		glGenBuffers(1, &skeleton->ubo);
+		glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo);
+		glBufferData(GL_UNIFORM_BUFFER, skeleton->bones.size()*sizeof(float), NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_UNIFORM_BUFFER, 0);
+	}
+
+	if (!skeleton->update_list.in_list()) {
+		skeleton_update_list.add(&skeleton->update_list);
+	}
+
+
+
+}
+int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const{
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	ERR_FAIL_COND_V(!skeleton,0);
+
+	return skeleton->size;
+}
+
+void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform){
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+
+	ERR_FAIL_COND(!skeleton);
+	ERR_FAIL_INDEX(p_bone,skeleton->size);
+	ERR_FAIL_COND(skeleton->use_2d);
+
+	float * bones = skeleton->bones.ptr();
+	bones[p_bone*12+ 0]=p_transform.basis.elements[0][0];
+	bones[p_bone*12+ 1]=p_transform.basis.elements[0][1];
+	bones[p_bone*12+ 2]=p_transform.basis.elements[0][2];
+	bones[p_bone*12+ 3]=p_transform.origin.x;
+	bones[p_bone*12+ 4]=p_transform.basis.elements[1][0];
+	bones[p_bone*12+ 5]=p_transform.basis.elements[1][1];
+	bones[p_bone*12+ 6]=p_transform.basis.elements[1][2];
+	bones[p_bone*12+ 7]=p_transform.origin.y;
+	bones[p_bone*12+ 8]=p_transform.basis.elements[2][0];
+	bones[p_bone*12+ 9]=p_transform.basis.elements[2][1];
+	bones[p_bone*12+10]=p_transform.basis.elements[2][2];
+	bones[p_bone*12+11]=p_transform.origin.z;
+
+	if (!skeleton->update_list.in_list()) {
+		skeleton_update_list.add(&skeleton->update_list);
+	}
+
+}
+
+
+Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int p_bone) const{
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+
+	ERR_FAIL_COND_V(!skeleton,Transform());
+	ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform());
+	ERR_FAIL_COND_V(skeleton->use_2d,Transform());
+
+	float * bones = skeleton->bones.ptr();
+	Transform mtx;
+	mtx.basis.elements[0][0]=bones[p_bone*12+ 0];
+	mtx.basis.elements[0][1]=bones[p_bone*12+ 1];
+	mtx.basis.elements[0][2]=bones[p_bone*12+ 2];
+	mtx.origin.x=bones[p_bone*12+ 3];
+	mtx.basis.elements[1][0]=bones[p_bone*12+ 4];
+	mtx.basis.elements[1][1]=bones[p_bone*12+ 5];
+	mtx.basis.elements[1][2]=bones[p_bone*12+ 6];
+	mtx.origin.y=bones[p_bone*12+ 7];
+	mtx.basis.elements[2][0]=bones[p_bone*12+ 8];
+	mtx.basis.elements[2][1]=bones[p_bone*12+ 9];
+	mtx.basis.elements[2][2]=bones[p_bone*12+10];
+	mtx.origin.z=bones[p_bone*12+11];
+
+	return mtx;
+}
+void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Matrix32& p_transform){
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+
+	ERR_FAIL_COND(!skeleton);
+	ERR_FAIL_INDEX(p_bone,skeleton->size);
+	ERR_FAIL_COND(!skeleton->use_2d);
+
+	float * bones = skeleton->bones.ptr();
+	bones[p_bone*12+ 0]=p_transform.elements[0][0];
+	bones[p_bone*12+ 1]=p_transform.elements[1][0];
+	bones[p_bone*12+ 2]=0;
+	bones[p_bone*12+ 3]=p_transform.elements[2][0];
+	bones[p_bone*12+ 4]=p_transform.elements[0][1];
+	bones[p_bone*12+ 5]=p_transform.elements[1][1];
+	bones[p_bone*12+ 6]=0;
+	bones[p_bone*12+ 7]=p_transform.elements[2][1];
+
+	if (!skeleton->update_list.in_list()) {
+		skeleton_update_list.add(&skeleton->update_list);
+	}
+
+}
+Matrix32 RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+
+
+	ERR_FAIL_COND_V(!skeleton,Matrix32());
+	ERR_FAIL_INDEX_V(p_bone,skeleton->size,Matrix32());
+	ERR_FAIL_COND_V(!skeleton->use_2d,Matrix32());
+
+	Matrix32 mtx;
+
+	float * bones = skeleton->bones.ptr();
+	mtx.elements[0][0]=bones[p_bone*12+ 0];
+	mtx.elements[1][0]=bones[p_bone*12+ 1];
+	mtx.elements[2][0]=bones[p_bone*12+ 3];
+	mtx.elements[0][1]=bones[p_bone*12+ 4];
+	mtx.elements[1][1]=bones[p_bone*12+ 5];
+	mtx.elements[2][1]=bones[p_bone*12+ 7];
+
+	return mtx;
+}
+
+void RasterizerStorageGLES3::update_dirty_skeletons() {
+
+	while(skeleton_update_list.first()) {
+
+		Skeleton *skeleton = skeleton_update_list.first()->self();
+		if (skeleton->size) {
+			glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo);
+			glBufferSubData(GL_UNIFORM_BUFFER,0,skeleton->bones.size()*sizeof(float),skeleton->bones.ptr());
+			glBindBuffer(GL_UNIFORM_BUFFER, 0);
+		}
+
+		for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
+			E->get()->base_changed();
+		}
+
+		skeleton_update_list.remove(skeleton_update_list.first());
+	}
+
+}
+
+/* Light API */
+
+RID RasterizerStorageGLES3::light_create(VS::LightType p_type){
+
+	Light *light = memnew( Light );
+	light->type=p_type;
+
+	light->param[VS::LIGHT_PARAM_ENERGY]=1.0;
+	light->param[VS::LIGHT_PARAM_SPECULAR]=0.5;
+	light->param[VS::LIGHT_PARAM_RANGE]=1.0;
+	light->param[VS::LIGHT_PARAM_SPOT_ANGLE]=45;
+	light->param[VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE]=0;
+	light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET]=0.1;
+	light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET]=0.3;
+	light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET]=0.6;
+	light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS]=0.1;
+	light->param[VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE]=0.1;
+
+
+	light->color=Color(1,1,1,1);
+	light->shadow=false;
+	light->negative=false;
+	light->cull_mask=0xFFFFFFFF;
+	light->directional_shadow_mode=VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
+	light->omni_shadow_mode=VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID;
+	light->omni_shadow_detail=VS::LIGHT_OMNI_SHADOW_DETAIL_VERTICAL;
+	light->directional_blend_splits=false;
+
+	light->version=0;
+
+	return light_owner.make_rid(light);
+}
+
+void RasterizerStorageGLES3::light_set_color(RID p_light,const Color& p_color){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->color=p_color;
+}
+void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,float p_value){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+	ERR_FAIL_INDEX(p_param,VS::LIGHT_PARAM_MAX);
+
+	switch(p_param) {
+		case VS::LIGHT_PARAM_RANGE:
+		case VS::LIGHT_PARAM_SPOT_ANGLE:
+		case VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE:
+		case VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET:
+		case VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET:
+		case VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET:
+		case VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS:
+		case VS::LIGHT_PARAM_SHADOW_BIAS:
+		case VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE: {
+
+			light->version++;
+			light->instance_change_notify();
+		} break;
+	}
+
+	light->param[p_param]=p_value;
+}
+void RasterizerStorageGLES3::light_set_shadow(RID p_light,bool p_enabled){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+	light->shadow=p_enabled;
+
+	light->version++;
+	light->instance_change_notify();
+}
+
+void RasterizerStorageGLES3::light_set_shadow_color(RID p_light,const Color& p_color) {
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+	light->shadow_color=p_color;
+
+}
+
+void RasterizerStorageGLES3::light_set_projector(RID p_light,RID p_texture){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->projector=p_texture;
+}
+
+void RasterizerStorageGLES3::light_set_negative(RID p_light,bool p_enable){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->negative=p_enable;
+}
+void RasterizerStorageGLES3::light_set_cull_mask(RID p_light,uint32_t p_mask){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->cull_mask=p_mask;
+
+	light->version++;
+	light->instance_change_notify();
+
+}
+
+void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) {
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->omni_shadow_mode=p_mode;
+
+	light->version++;
+	light->instance_change_notify();
+
+
+}
+
+VS::LightOmniShadowMode RasterizerStorageGLES3::light_omni_get_shadow_mode(RID p_light) {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,VS::LIGHT_OMNI_SHADOW_CUBE);
+
+	return light->omni_shadow_mode;
+}
+
+
+void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail) {
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->omni_shadow_detail=p_detail;
+	light->version++;
+	light->instance_change_notify();
+}
+
+
+void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode){
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->directional_shadow_mode=p_mode;
+	light->version++;
+	light->instance_change_notify();
+
+}
+
+void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light,bool p_enable) {
+
+	Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->directional_blend_splits=p_enable;
+	light->version++;
+	light->instance_change_notify();
+
+}
+
+
+bool RasterizerStorageGLES3::light_directional_get_blend_splits(RID p_light) const {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,false);
+
+	return light->directional_blend_splits;
+}
+
+VS::LightDirectionalShadowMode RasterizerStorageGLES3::light_directional_get_shadow_mode(RID p_light) {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
+
+	return light->directional_shadow_mode;
+}
+
+
+VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+
+	return light->type;
+}
+
+float RasterizerStorageGLES3::light_get_param(RID p_light,VS::LightParam p_param) {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+
+	return light->param[p_param];
+}
+
+Color RasterizerStorageGLES3::light_get_color(RID p_light) {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,Color());
+
+	return light->color;
+
+}
+
+bool RasterizerStorageGLES3::light_has_shadow(RID p_light) const {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+
+	return light->shadow;
+}
+
+uint64_t RasterizerStorageGLES3::light_get_version(RID p_light) const {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,0);
+
+	return light->version;
+}
+
+
+AABB RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
+
+	const Light * light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light,AABB());
+
+	switch( light->type ) {
+
+		case VS::LIGHT_SPOT: {
+
+			float len=light->param[VS::LIGHT_PARAM_RANGE];
+			float size=Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE]))*len;
+			return AABB( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
+		} break;
+		case VS::LIGHT_OMNI: {
+
+			float r = light->param[VS::LIGHT_PARAM_RANGE];
+			return AABB( -Vector3(r,r,r), Vector3(r,r,r)*2 );
+		} break;
+		case VS::LIGHT_DIRECTIONAL: {
+
+			return AABB();
+		} break;
+		default: {}
+	}
+
+	ERR_FAIL_V( AABB() );
+	return AABB();
+}
+
+/* PROBE API */
+
+RID RasterizerStorageGLES3::reflection_probe_create(){
+
+	ReflectionProbe *reflection_probe = memnew( ReflectionProbe );
+
+	reflection_probe->intensity=1.0;
+	reflection_probe->interior_ambient=Color();
+	reflection_probe->interior_ambient_energy=1.0;
+	reflection_probe->max_distance=0;
+	reflection_probe->extents=Vector3(1,1,1);
+	reflection_probe->origin_offset=Vector3(0,0,0);
+	reflection_probe->interior=false;
+	reflection_probe->box_projection=false;
+	reflection_probe->enable_shadows=false;
+	reflection_probe->cull_mask=(1<<20)-1;
+	reflection_probe->update_mode=VS::REFLECTION_PROBE_UPDATE_ONCE;
+
+	return reflection_probe_owner.make_rid(reflection_probe);
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_update_mode(RID p_probe, VS::ReflectionProbeUpdateMode p_mode) {
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->update_mode=p_mode;
+	reflection_probe->instance_change_notify();
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->intensity=p_intensity;
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_interior_ambient(RID p_probe, const Color& p_ambient) {
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->interior_ambient=p_ambient;
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy) {
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->interior_ambient_energy=p_energy;
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib) {
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->interior_ambient_probe_contrib=p_contrib;
+
+}
+
+
+void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->max_distance=p_distance;
+	reflection_probe->instance_change_notify();
+
+}
+void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3& p_extents){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->extents=p_extents;
+	reflection_probe->instance_change_notify();
+
+}
+void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->origin_offset=p_offset;
+	reflection_probe->instance_change_notify();
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_as_interior(RID p_probe, bool p_enable){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->interior=p_enable;
+
+}
+void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->box_projection=p_enable;
+
+}
+
+void RasterizerStorageGLES3::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->enable_shadows=p_enable;
+	reflection_probe->instance_change_notify();
+
+}
+void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers){
+
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->cull_mask=p_layers;
+	reflection_probe->instance_change_notify();
+
+}
+
+AABB RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,AABB());
+
+	AABB aabb;
+	aabb.pos=-reflection_probe->extents;
+	aabb.size=reflection_probe->extents*2.0;
+
+	return aabb;
+
+
+}
+VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_update_mode(RID p_probe) const{
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,VS::REFLECTION_PROBE_UPDATE_ALWAYS);
+
+	return reflection_probe->update_mode;
+}
+
+uint32_t RasterizerStorageGLES3::reflection_probe_get_cull_mask(RID p_probe) const {
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,0);
+
+	return reflection_probe->cull_mask;
+
+}
+
+Vector3 RasterizerStorageGLES3::reflection_probe_get_extents(RID p_probe) const {
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,Vector3());
+
+	return reflection_probe->extents;
+
+}
+Vector3 RasterizerStorageGLES3::reflection_probe_get_origin_offset(RID p_probe) const{
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,Vector3());
+
+	return reflection_probe->origin_offset;
+
+}
+
+bool RasterizerStorageGLES3::reflection_probe_renders_shadows(RID p_probe) const {
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,false);
+
+	return reflection_probe->enable_shadows;
+
+}
+
+float RasterizerStorageGLES3::reflection_probe_get_origin_max_distance(RID p_probe) const{
+
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe,0);
+
+	return reflection_probe->max_distance;
+
+}
+
+/* ROOM API */
+
+RID RasterizerStorageGLES3::room_create(){
+
+	return RID();
+}
+void RasterizerStorageGLES3::room_add_bounds(RID p_room, const DVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform){
+
+
+}
+void RasterizerStorageGLES3::room_clear_bounds(RID p_room){
+
+
+}
+
+/* PORTAL API */
+
+// portals are only (x/y) points, forming a convex shape, which its clockwise
+// order points outside. (z is 0);
+
+RID RasterizerStorageGLES3::portal_create(){
+
+	return RID();
+}
+void RasterizerStorageGLES3::portal_set_shape(RID p_portal, const Vector<Point2>& p_shape){
+
+
+}
+void RasterizerStorageGLES3::portal_set_enabled(RID p_portal, bool p_enabled){
+
+
+}
+void RasterizerStorageGLES3::portal_set_disable_distance(RID p_portal, float p_distance){
+
+
+}
+void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color& p_color){
+
+
+}
+
+RID RasterizerStorageGLES3::gi_probe_create() {
+
+	GIProbe *gip = memnew( GIProbe );
+
+	gip->bounds=AABB(Vector3(),Vector3(1,1,1));
+	gip->dynamic_range=1.0;
+	gip->energy=1.0;
+	gip->interior=false;
+	gip->compress=false;
+	gip->version=1;
+	gip->cell_size=1.0;
+
+	return gi_probe_owner.make_rid(gip);
+}
+
+void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const AABB& p_bounds){
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->bounds=p_bounds;
+	gip->version++;
+	gip->instance_change_notify();
+}
+AABB RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,AABB());
+
+	return gip->bounds;
+}
+
+void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe,float p_size) {
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->cell_size=p_size;
+	gip->version++;
+	gip->instance_change_notify();
+}
+
+float RasterizerStorageGLES3::gi_probe_get_cell_size(RID p_probe) const {
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,0);
+
+	return gip->cell_size;
+
+}
+
+void RasterizerStorageGLES3::gi_probe_set_to_cell_xform(RID p_probe,const Transform& p_xform) {
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->to_cell=p_xform;
+}
+
+Transform RasterizerStorageGLES3::gi_probe_get_to_cell_xform(RID p_probe) const {
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,Transform());
+
+	return gip->to_cell;
+
+}
+
+
+
+void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe,const DVector<int>& p_data){
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->dynamic_data=p_data;
+	gip->version++;
+	gip->instance_change_notify();
+
+}
+DVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,DVector<int>());
+
+	return gip->dynamic_data;
+}
+
+void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int p_range){
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->dynamic_range=p_range;
+
+}
+int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,0);
+
+	return gip->dynamic_range;
+}
+
+void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe,float p_range){
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->energy=p_range;
+
+}
+
+void RasterizerStorageGLES3::gi_probe_set_interior(RID p_probe,bool p_enable) {
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->interior=p_enable;
+
+}
+
+bool RasterizerStorageGLES3::gi_probe_is_interior(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,false);
+
+	return gip->interior;
+
+}
+
+
+void RasterizerStorageGLES3::gi_probe_set_compress(RID p_probe,bool p_enable) {
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->compress=p_enable;
+
+}
+
+bool RasterizerStorageGLES3::gi_probe_is_compressed(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,false);
+
+	return gip->compress;
+
+}
+float RasterizerStorageGLES3::gi_probe_get_energy(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,0);
+
+	return gip->energy;
+}
+
+
+
+uint32_t RasterizerStorageGLES3::gi_probe_get_version(RID p_probe) {
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,0);
+
+	return gip->version;
+}
+
+RasterizerStorage::GIProbeCompression RasterizerStorageGLES3::gi_probe_get_dynamic_data_get_preferred_compression() const {
+	if (config.s3tc_supported) {
+		return GI_PROBE_S3TC;
+	} else {
+		return GI_PROBE_UNCOMPRESSED;
+	}
+}
+
+RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_height, int p_depth, GIProbeCompression p_compression) {
+
+	GIProbeData *gipd = memnew( GIProbeData );
+
+	gipd->width=p_width;
+	gipd->height=p_height;
+	gipd->depth=p_depth;
+	gipd->compression=p_compression;
+
+	glActiveTexture(GL_TEXTURE0);
+	glGenTextures(1,&gipd->tex_id);
+	glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
+
+	int level=0;
+	int min_size=1;
+
+	if (gipd->compression==GI_PROBE_S3TC) {
+		min_size=4;
+	}
+
+	print_line("dyndata create");
+	while(true) {
+
+		if (gipd->compression==GI_PROBE_S3TC) {
+			int size = p_width * p_height * p_depth;
+			glCompressedTexImage3D(GL_TEXTURE_3D,level,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,p_width,p_height,p_depth,0, size,NULL);
+		} else {
+			glTexImage3D(GL_TEXTURE_3D,level,GL_RGBA8,p_width,p_height,p_depth,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
+		}
+
+		if (p_width<=min_size || p_height<=min_size || p_depth<=min_size)
+			break;
+		p_width>>=1;
+		p_height>>=1;
+		p_depth>>=1;
+		level++;
+	}
+
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
+	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, level);
+
+	gipd->levels=level+1;
+
+	return gi_probe_data_owner.make_rid(gipd);
+}
+
+void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, int p_depth_slice, int p_slice_count, int p_mipmap, const void *p_data) {
+
+	GIProbeData *gipd = gi_probe_data_owner.getornull(p_gi_probe_data);
+	ERR_FAIL_COND(!gipd);
+/*
+	Vector<uint8_t> data;
+	data.resize((gipd->width>>p_mipmap)*(gipd->height>>p_mipmap)*(gipd->depth>>p_mipmap)*4);
+
+	for(int i=0;i<(gipd->width>>p_mipmap);i++) {
+		for(int j=0;j<(gipd->height>>p_mipmap);j++) {
+			for(int k=0;k<(gipd->depth>>p_mipmap);k++) {
+
+				int ofs = (k*(gipd->height>>p_mipmap)*(gipd->width>>p_mipmap)) + j *(gipd->width>>p_mipmap) + i;
+				ofs*=4;
+				data[ofs+0]=i*0xFF/(gipd->width>>p_mipmap);
+				data[ofs+1]=j*0xFF/(gipd->height>>p_mipmap);
+				data[ofs+2]=k*0xFF/(gipd->depth>>p_mipmap);
+				data[ofs+3]=0xFF;
+			}
+		}
+	}
+*/
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
+	if (gipd->compression==GI_PROBE_S3TC) {
+		int size = (gipd->width>>p_mipmap) * (gipd->height>>p_mipmap) * p_slice_count;
+		glCompressedTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,size, p_data);
+	} else {
+		glTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,GL_RGBA,GL_UNSIGNED_BYTE,p_data);
+	}
+	//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,p_data);
+	//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,data.ptr());
+
+}
+
+///////
+
+
+
+RID RasterizerStorageGLES3::particles_create() {
+
+	Particles *particles = memnew( Particles );
+
+
+	return particles_owner.make_rid(particles);
+}
+
+void RasterizerStorageGLES3::particles_set_emitting(RID p_particles,bool p_emitting) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->emitting=p_emitting;
+
+}
+void RasterizerStorageGLES3::particles_set_amount(RID p_particles,int p_amount) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	int floats = p_amount*24;
+	float * data = memnew_arr(float,floats);
+
+	for(int i=0;i<floats;i++) {
+		data[i]=0;
+	}
+
+
+	glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]);
+	glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW);
+
+	glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[1]);
+	glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW);
+
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+
+	particles->prev_ticks=0;
+	particles->phase=0;
+	particles->prev_phase=0;
+
+	memdelete_arr(data);
+
+}
+
+void RasterizerStorageGLES3::particles_set_lifetime(RID p_particles,float p_lifetime){
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->lifetime=p_lifetime;
+}
+void RasterizerStorageGLES3::particles_set_pre_process_time(RID p_particles,float p_time) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->pre_process_time=p_time;
+
+}
+void RasterizerStorageGLES3::particles_set_explosiveness_ratio(RID p_particles,float p_ratio) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->explosiveness=p_ratio;
+}
+void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles,float p_ratio) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->randomness=p_ratio;
+
+}
+void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const AABB& p_aabb) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	particles->custom_aabb=p_aabb;
+
+}
+void RasterizerStorageGLES3::particles_set_gravity(RID p_particles,const Vector3& p_gravity) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->gravity=p_gravity;
+
+}
+void RasterizerStorageGLES3::particles_set_use_local_coordinates(RID p_particles,bool p_enable) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->use_local_coords=p_enable;
+}
+void RasterizerStorageGLES3::particles_set_process_material(RID p_particles,RID p_material) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->process_material=p_material;
+}
+
+void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->emission_shape=p_shape;
+}
+void RasterizerStorageGLES3::particles_set_emission_sphere_radius(RID p_particles,float p_radius) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->emission_sphere_radius=p_radius;
+}
+void RasterizerStorageGLES3::particles_set_emission_box_extents(RID p_particles,const Vector3& p_extents) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->emission_box_extents=p_extents;
+}
+void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles,const DVector<Vector3>& p_points) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->emission_points=p_points;
+}
+
+
+void RasterizerStorageGLES3::particles_set_draw_order(RID p_particles,VS::ParticlesDrawOrder p_order) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->draw_order=p_order;
+}
+
+void RasterizerStorageGLES3::particles_set_draw_passes(RID p_particles,int p_count) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+
+	particles->draw_passes.resize(p_count);
+}
+void RasterizerStorageGLES3::particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
+	particles->draw_passes[p_pass].material=p_material;
+
+}
+void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh) {
+
+	Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND(!particles);
+	ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
+	particles->draw_passes[p_pass].mesh=p_mesh;
+
+}
+
+AABB RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
+
+	const Particles *particles = particles_owner.getornull(p_particles);
+	ERR_FAIL_COND_V(!particles,AABB());
+
+	return particles->computed_aabb;
+}
+
+void RasterizerStorageGLES3::update_particles() {
+
+	glEnable(GL_RASTERIZER_DISCARD);
+	glBindVertexArray(0);
+
+
+	while (particle_update_list.first()) {
+
+		//use transform feedback to process particles
+
+		Particles *particles = particle_update_list.first()->self();
+
+
+		Material *material = material_owner.getornull(particles->process_material);
+		if (!material || !material->shader || material->shader->mode!=VS::SHADER_PARTICLES) {
+
+			shaders.particles.set_custom_shader(0);
+		} else {
+			shaders.particles.set_custom_shader( material->shader->custom_code_id );
+
+			if (material->ubo_id) {
+
+				glBindBufferBase(GL_UNIFORM_BUFFER,0,material->ubo_id);
+			}
+
+			int tc = material->textures.size();
+			RID* textures = material->textures.ptr();
+			ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = material->shader->texture_hints.ptr();
+
+
+			for(int i=0;i<tc;i++) {
+
+				glActiveTexture(GL_TEXTURE0+i);
+
+				GLenum target;
+				GLuint tex;
+
+				RasterizerStorageGLES3::Texture *t = texture_owner.getornull( textures[i] );
+
+				if (!t) {
+					//check hints
+					target=GL_TEXTURE_2D;
+
+					switch(texture_hints[i]) {
+						case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
+						case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
+							tex=resources.black_tex;
+						} break;
+						case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
+							tex=resources.aniso_tex;
+						} break;
+						case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
+							tex=resources.normal_tex;
+						} break;
+						default: {
+							tex=resources.white_tex;
+						} break;
+					}
+
+
+				} else {
+
+					target=t->target;
+					tex = t->tex_id;
+
+				}
+
+				glBindTexture(target,tex);
+			}
+
+		}
+
+		shaders.particles.bind();
+
+		shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN,particles->origin);
+
+		float new_phase = Math::fmod(particles->phase+(frame.delta/particles->lifetime),1.0);
+
+		shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE,new_phase);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE,particles->phase);
+		particles->phase = new_phase;
+
+		shaders.particles.set_uniform(ParticlesShaderGLES3::TOTAL_PARTICLES,particles->amount);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::TIME,0.0);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::EXPLOSIVENESS,particles->explosiveness);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA,frame.delta);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::GRAVITY,particles->gravity);
+		shaders.particles.set_uniform(ParticlesShaderGLES3::ATTRACTOR_COUNT,0);
+
+
+
+
+		glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]);
+		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particles->particle_buffers[1]);
+
+		for(int i=0;i<6;i++) {
+			glEnableVertexAttribArray(i);
+			glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,sizeof(float)*4*6,((uint8_t*)0)+(i*16));
+		}
+
+
+		glBeginTransformFeedback(GL_POINTS);
+		glDrawArrays(GL_POINTS,0,particles->amount);
+		glEndTransformFeedback();
+
+		particle_update_list.remove(particle_update_list.first());
+
+		SWAP(particles->particle_buffers[0],particles->particle_buffers[1]);
+	}
+
+	glDisable(GL_RASTERIZER_DISCARD);
+
+	for(int i=0;i<6;i++) {
+		glDisableVertexAttribArray(i);
+	}
+
+}
+
+////////
+
+void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) {
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	ERR_FAIL_COND(!skeleton);
+
+	skeleton->instances.insert(p_instance);
+}
+
+void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) {
+
+	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	ERR_FAIL_COND(!skeleton);
+
+	skeleton->instances.erase(p_instance);
+}
+
+
+void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance) {
+
+	Instantiable *inst=NULL;
+	switch(p_instance->base_type) {
+		case VS::INSTANCE_MESH: {
+			inst = mesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_MULTIMESH: {
+			inst = multimesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_IMMEDIATE: {
+			inst = immediate_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_REFLECTION_PROBE: {
+			inst = reflection_probe_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_LIGHT: {
+			inst = light_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_GI_PROBE: {
+			inst = gi_probe_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		default: {
+			if (!inst) {
+				ERR_FAIL();
+			}
+		}
+	}
+
+	inst->instance_list.add( &p_instance->dependency_item );
+}
+
+void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance){
+
+	Instantiable *inst=NULL;
+
+	switch(p_instance->base_type) {
+		case VS::INSTANCE_MESH: {
+			inst = mesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_MULTIMESH: {
+			inst = multimesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_IMMEDIATE: {
+			inst = immediate_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_REFLECTION_PROBE: {
+			inst = reflection_probe_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_LIGHT: {
+			inst = light_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		case VS::INSTANCE_GI_PROBE: {
+			inst = gi_probe_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		default: {
+
+			if (!inst) {
+				ERR_FAIL();
+			}
+		}
+	}
+
+	ERR_FAIL_COND(!inst);
+
+	inst->instance_list.remove( &p_instance->dependency_item );
+}
+
+
+/* RENDER TARGET */
+
+
+void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
+
+	if (rt->fbo) {
+		glDeleteFramebuffers(1,&rt->fbo);
+		glDeleteTextures(1,&rt->color);
+		rt->fbo=0;
+	}
+
+	if (rt->buffers.fbo) {
+		glDeleteFramebuffers(1,&rt->buffers.fbo);
+		glDeleteRenderbuffers(1,&rt->buffers.depth);
+		glDeleteRenderbuffers(1,&rt->buffers.diffuse);
+		glDeleteRenderbuffers(1,&rt->buffers.specular);
+		glDeleteRenderbuffers(1,&rt->buffers.normal_rough);
+		glDeleteRenderbuffers(1,&rt->buffers.motion_sss);
+		glDeleteFramebuffers(1,&rt->buffers.effect_fbo);
+		glDeleteTextures(1,&rt->buffers.effect);
+
+		rt->buffers.fbo=0;
+	}
+
+	if (rt->depth) {
+		glDeleteTextures(1,&rt->depth);
+		rt->depth=0;
+	}
+
+	if (rt->effects.ssao.blur_fbo[0]) {
+		glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[0]);
+		glDeleteTextures(1,&rt->effects.ssao.blur_red[0]);
+		glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[1]);
+		glDeleteTextures(1,&rt->effects.ssao.blur_red[1]);
+		for(int i=0;i<rt->effects.ssao.depth_mipmap_fbos.size();i++) {
+			glDeleteFramebuffers(1,&rt->effects.ssao.depth_mipmap_fbos[i]);
+		}
+
+		rt->effects.ssao.depth_mipmap_fbos.clear();
+
+		glDeleteTextures(1,&rt->effects.ssao.linear_depth);
+	}
+
+	if (rt->exposure.fbo) {
+		glDeleteFramebuffers(1,&rt->exposure.fbo);
+		glDeleteTextures(1,&rt->exposure.color);
+	}
+	Texture *tex = texture_owner.get(rt->texture);
+	tex->alloc_height=0;
+	tex->alloc_width=0;
+	tex->width=0;
+	tex->height=0;
+
+	for(int i=0;i<2;i++) {
+		for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
+			glDeleteFramebuffers(1,&rt->effects.mip_maps[i].sizes[j].fbo);
+		}
+
+		glDeleteTextures(1,&rt->effects.mip_maps[i].color);
+		rt->effects.mip_maps[i].sizes.clear();
+		rt->effects.mip_maps[i].levels=0;
+	}
+/*
+	if (rt->effects.screen_space_depth) {
+		glDeleteTextures(1,&rt->effects.screen_space_depth);
+		rt->effects.screen_space_depth=0;
+
+	}
+*/
+}
+
+void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
+
+	if (rt->width<=0 || rt->height<=0)
+		return;
+
+
+	GLuint color_internal_format;
+	GLuint color_format;
+	GLuint color_type;
+	Image::Format image_format;
+
+
+
+	if (!rt->flags[RENDER_TARGET_HDR] || rt->flags[RENDER_TARGET_NO_3D]) {
+
+		color_internal_format=GL_RGBA8;
+		color_format=GL_RGBA;
+		color_type=GL_UNSIGNED_BYTE;
+		image_format=Image::FORMAT_RGBA8;
+	} else {
+		color_internal_format=GL_RGBA16F;
+		color_format=GL_RGBA;
+		color_type=GL_HALF_FLOAT;
+		image_format=Image::FORMAT_RGBAH;
+	}
+
+
+	{
+		/* FRONT FBO */
+
+		glActiveTexture(GL_TEXTURE0);
+
+		glGenFramebuffers(1, &rt->fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
+
+
+		glGenTextures(1, &rt->depth);
+		glBindTexture(GL_TEXTURE_2D, rt->depth);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, rt->width, rt->height, 0,
+			     GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+				       GL_TEXTURE_2D, rt->depth, 0);
+
+		glGenTextures(1, &rt->color);
+		glBindTexture(GL_TEXTURE_2D, rt->color);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format,  rt->width, rt->height, 0, color_format, color_type, NULL);
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->color, 0);
+
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+
+		ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+
+		Texture *tex = texture_owner.get(rt->texture);
+		tex->format=image_format;
+		tex->gl_format_cache=color_format;
+		tex->gl_type_cache=color_type;
+		tex->gl_internal_format_cache=color_internal_format;
+		tex->tex_id=rt->color;
+		tex->width=rt->width;
+		tex->alloc_width=rt->width;
+		tex->height=rt->height;
+		tex->alloc_height=rt->height;
+
+
+		texture_set_flags(rt->texture,tex->flags);
+
+	}
+
+
+	/* BACK FBO */
+
+	if (config.render_arch==RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) {
+
+
+
+		static const int msaa_value[]={0,2,4,8,16};
+		int msaa=msaa_value[rt->msaa];
+
+		//regular fbo
+		glGenFramebuffers(1, &rt->buffers.fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, rt->buffers.fbo);
+
+		glGenRenderbuffers(1, &rt->buffers.depth);
+		glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.depth);
+		if (msaa==0)
+			glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH24_STENCIL8,rt->width,rt->height);
+		else
+			glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_DEPTH24_STENCIL8,rt->width,rt->height);
+
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,rt->buffers.depth);
+	
+		glGenRenderbuffers(1, &rt->buffers.diffuse);
+		glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.diffuse);
+
+		if (msaa==0)
+			glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height);
+		else
+			glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA16F,rt->width,rt->height);
+
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,rt->buffers.diffuse);
+
+		glGenRenderbuffers(1, &rt->buffers.specular);
+		glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.specular);
+
+		if (msaa==0)
+			glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA16F,rt->width,rt->height);
+		else
+			glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height);
+
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT1,GL_RENDERBUFFER,rt->buffers.specular);
+
+		glGenRenderbuffers(1, &rt->buffers.normal_rough);
+		glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.normal_rough);
+
+		if (msaa==0)
+			glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height);
+		else
+			glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height);
+
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT2,GL_RENDERBUFFER,rt->buffers.normal_rough);
+
+
+		glGenRenderbuffers(1, &rt->buffers.motion_sss);
+		glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.motion_sss);
+
+		if (msaa==0)
+			glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height);
+		else
+			glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height);
+
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT3,GL_RENDERBUFFER,rt->buffers.motion_sss);
+
+
+
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+
+		if (status != GL_FRAMEBUFFER_COMPLETE) {
+			printf("err status: %x\n",status);
+			_render_target_clear(rt);
+			ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+		}		
+
+		glBindRenderbuffer(GL_RENDERBUFFER,0);
+
+		// effect resolver
+
+		glGenFramebuffers(1, &rt->buffers.effect_fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, rt->buffers.effect_fbo);
+
+		glGenTextures(1, &rt->buffers.effect);
+		glBindTexture(GL_TEXTURE_2D, rt->buffers.effect);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, rt->width, rt->height, 0,
+			     GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+				       GL_TEXTURE_2D, rt->buffers.effect, 0);
+
+
+		if (status != GL_FRAMEBUFFER_COMPLETE) {
+			printf("err status: %x\n",status);
+			_render_target_clear(rt);
+			ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+		}
+
+		glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+
+		if (status != GL_FRAMEBUFFER_COMPLETE) {
+			_render_target_clear(rt);
+			ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+		}
+
+		for(int i=0;i<2;i++) {
+
+			ERR_FAIL_COND( rt->effects.mip_maps[i].sizes.size() );
+			int w=rt->width;
+			int h=rt->height;
+
+
+			if (i>0) {
+				w>>=1;
+				h>>=1;
+			}
+
+
+			glGenTextures(1, &rt->effects.mip_maps[i].color);
+			glBindTexture(GL_TEXTURE_2D, rt->effects.mip_maps[i].color);
+
+			int level=0;
+
+			while(true) {
+
+				RenderTarget::Effects::MipMaps::Size mm;
+
+				glTexImage2D(GL_TEXTURE_2D, level, color_internal_format,  w, h, 0, color_format, color_type, NULL);
+				mm.width=w;
+				mm.height=h;
+				rt->effects.mip_maps[i].sizes.push_back(mm);
+
+				w>>=1;
+				h>>=1;
+
+				if (w<2 || h<2)
+					break;
+
+				level++;
+
+			}
+
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level);
+
+
+			for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
+
+				RenderTarget::Effects::MipMaps::Size &mm=rt->effects.mip_maps[i].sizes[j];
+
+				glGenFramebuffers(1, &mm.fbo);
+				glBindFramebuffer(GL_FRAMEBUFFER, mm.fbo);
+				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,rt->effects.mip_maps[i].color ,j);
+
+				status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+				if (status != GL_FRAMEBUFFER_COMPLETE) {
+					_render_target_clear(rt);
+					ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+				}
+
+
+				float zero[4]={1,0,1,0};
+				glClearBufferfv(GL_COLOR,0,zero);
+
+
+			}
+
+			glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+			rt->effects.mip_maps[i].levels=level;
+
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+			//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+
+		}
+		///////////////// ssao
+
+		//AO strength textures
+		for(int i=0;i<2;i++) {
+
+			glGenFramebuffers(1, &rt->effects.ssao.blur_fbo[i]);
+			glBindFramebuffer(GL_FRAMEBUFFER, rt->effects.ssao.blur_fbo[i]);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+					       GL_TEXTURE_2D, rt->depth, 0);
+
+			glGenTextures(1, &rt->effects.ssao.blur_red[i]);
+			glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.blur_red[i]);
+
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_R8,  rt->width, rt->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->effects.ssao.blur_red[i], 0);
+
+			status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+			if (status != GL_FRAMEBUFFER_COMPLETE) {
+				_render_target_clear(rt);
+				ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+			}
+
+		}
+		//5 mip levels for depth texture, but base is read separately
+
+		glGenTextures(1, &rt->effects.ssao.linear_depth);
+		glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.linear_depth);
+
+		int ssao_w=rt->width/2;
+		int ssao_h=rt->height/2;
+
+
+		for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw
+
+			glTexImage2D(GL_TEXTURE_2D, i, GL_R16UI,  ssao_w, ssao_h, 0, GL_RED_INTEGER, GL_UNSIGNED_SHORT, NULL);
+			ssao_w>>=1;
+			ssao_h>>=1;
+		}
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3);
+
+		for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw
+
+			GLuint fbo;
+			glGenFramebuffers(1, &fbo);
+			glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->effects.ssao.linear_depth, i);
+			rt->effects.ssao.depth_mipmap_fbos.push_back(fbo);
+		}
+
+
+		//////Exposure
+
+		glGenFramebuffers(1, &rt->exposure.fbo);
+		glBindFramebuffer(GL_FRAMEBUFFER, rt->exposure.fbo);
+
+		glGenTextures(1, &rt->exposure.color);
+		glBindTexture(GL_TEXTURE_2D, rt->exposure.color);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F,  1, 1, 0, GL_RED, GL_FLOAT, NULL);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  rt->exposure.color, 0);
+
+		status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		if (status != GL_FRAMEBUFFER_COMPLETE) {
+			_render_target_clear(rt);
+			ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+		}
+
+	}
+}
+
+
+RID RasterizerStorageGLES3::render_target_create(){
+
+	RenderTarget *rt = memnew( RenderTarget );
+
+	Texture * t = memnew( Texture );
+
+	t->flags=0;
+	t->width=0;
+	t->height=0;
+	t->alloc_height=0;
+	t->alloc_width=0;
+	t->format=Image::FORMAT_R8;
+	t->target=GL_TEXTURE_2D;
+	t->gl_format_cache=0;
+	t->gl_internal_format_cache=0;
+	t->gl_type_cache=0;
+	t->data_size=0;
+	t->compressed=false;
+	t->srgb=false;
+	t->total_data_size=0;
+	t->ignore_mipmaps=false;
+	t->mipmaps=0;
+	t->active=true;
+	t->tex_id=0;
+
+
+	rt->texture=texture_owner.make_rid(t);
+
+	return render_target_owner.make_rid(rt);
+}
+
+void RasterizerStorageGLES3::render_target_set_size(RID p_render_target,int p_width, int p_height){
+
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+
+	if (rt->width==p_width && rt->height==p_height)
+		return;
+
+	_render_target_clear(rt);
+	rt->width=p_width;
+	rt->height=p_height;
+	_render_target_allocate(rt);
+
+}
+
+
+RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) const{
+
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND_V(!rt,RID());
+
+	return rt->texture;
+}
+
+void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target,RenderTargetFlags p_flag,bool p_value) {
+
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+
+	rt->flags[p_flag]=p_value;
+
+	switch(p_flag) {
+		case RENDER_TARGET_NO_3D:
+		case RENDER_TARGET_TRANSPARENT: {
+			//must reset for these formats
+			_render_target_clear(rt);
+			_render_target_allocate(rt);
+
+		} break;
+		default: {}
+	}
+}
+
+bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target){
+
+	return false;
+}
+
+void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target,VS::ViewportMSAA p_msaa) {
+
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+
+	if (rt->msaa==p_msaa)
+		return;
+
+	_render_target_clear(rt);
+	rt->msaa=p_msaa;
+	_render_target_allocate(rt);
+
+}
+
+/* CANVAS SHADOW */
+
+
+RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
+
+	CanvasLightShadow *cls = memnew( CanvasLightShadow );
+	if (p_width>config.max_texture_size)
+		p_width=config.max_texture_size;
+
+	cls->size=p_width;
+	cls->height=16;
+
+	glActiveTexture(GL_TEXTURE0);
+
+	glGenFramebuffers(1, &cls->fbo);
+	glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
+
+	glGenRenderbuffers(1, &cls->depth);
+	glBindRenderbuffer(GL_RENDERBUFFER, cls->depth );
+	glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24, cls->size, cls->height);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, cls->depth);
+	glBindRenderbuffer(GL_RENDERBUFFER, 0 );
+
+	glGenTextures(1,&cls->distance);
+	glBindTexture(GL_TEXTURE_2D, cls->distance);
+	if (config.use_rgba_2d_shadows) {
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, cls->size, cls->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	} else {
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, cls->size, cls->height, 0, GL_RED, GL_FLOAT, NULL);
+	}
+
+
+
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, cls->distance, 0);
+
+
+	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+	//printf("errnum: %x\n",status);
+	glBindFramebuffer(GL_FRAMEBUFFER, config.system_fbo);
+
+	ERR_FAIL_COND_V( status != GL_FRAMEBUFFER_COMPLETE, RID() );
+
+	return canvas_light_shadow_owner.make_rid(cls);
+}
+
+/* LIGHT SHADOW MAPPING */
+
+
+RID RasterizerStorageGLES3::canvas_light_occluder_create() {
+
+	CanvasOccluder *co = memnew( CanvasOccluder );
+	co->index_id=0;
+	co->vertex_id=0;
+	co->len=0;
+
+	return canvas_occluder_owner.make_rid(co);
+}
+
+void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines) {
+
+	CanvasOccluder *co = canvas_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!co);
+
+	co->lines=p_lines;
+
+	if (p_lines.size()!=co->len) {
+
+		if (co->index_id)
+			glDeleteBuffers(1,&co->index_id);
+		if (co->vertex_id)
+			glDeleteBuffers(1,&co->vertex_id);
+
+		co->index_id=0;
+		co->vertex_id=0;
+		co->len=0;
+
+	}
+
+	if (p_lines.size()) {
+
+
+
+		DVector<float> geometry;
+		DVector<uint16_t> indices;
+		int lc = p_lines.size();
+
+		geometry.resize(lc*6);
+		indices.resize(lc*3);
+
+		DVector<float>::Write vw=geometry.write();
+		DVector<uint16_t>::Write iw=indices.write();
+
+
+		DVector<Vector2>::Read lr=p_lines.read();
+
+		const int POLY_HEIGHT = 16384;
+
+		for(int i=0;i<lc/2;i++) {
+
+			vw[i*12+0]=lr[i*2+0].x;
+			vw[i*12+1]=lr[i*2+0].y;
+			vw[i*12+2]=POLY_HEIGHT;
+
+			vw[i*12+3]=lr[i*2+1].x;
+			vw[i*12+4]=lr[i*2+1].y;
+			vw[i*12+5]=POLY_HEIGHT;
+
+			vw[i*12+6]=lr[i*2+1].x;
+			vw[i*12+7]=lr[i*2+1].y;
+			vw[i*12+8]=-POLY_HEIGHT;
+
+			vw[i*12+9]=lr[i*2+0].x;
+			vw[i*12+10]=lr[i*2+0].y;
+			vw[i*12+11]=-POLY_HEIGHT;
+
+			iw[i*6+0]=i*4+0;
+			iw[i*6+1]=i*4+1;
+			iw[i*6+2]=i*4+2;
+
+			iw[i*6+3]=i*4+2;
+			iw[i*6+4]=i*4+3;
+			iw[i*6+5]=i*4+0;
+
+		}
+
+		//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
+
+
+		if (!co->vertex_id) {
+			glGenBuffers(1,&co->vertex_id);
+			glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
+			glBufferData(GL_ARRAY_BUFFER,lc*6*sizeof(real_t),vw.ptr(),GL_STATIC_DRAW);
+		} else {
+
+			glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
+			glBufferSubData(GL_ARRAY_BUFFER,0,lc*6*sizeof(real_t),vw.ptr());
+
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+		if (!co->index_id) {
+
+			glGenBuffers(1,&co->index_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
+			glBufferData(GL_ELEMENT_ARRAY_BUFFER,lc*3*sizeof(uint16_t),iw.ptr(),GL_STATIC_DRAW);
+		} else {
+
+
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
+			glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,lc*3*sizeof(uint16_t),iw.ptr());
+		}
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
+
+		co->len=lc;
+
+	}
+
+}
+
+VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
+
+	if (mesh_owner.owns(p_rid)) {
+		return VS::INSTANCE_MESH;
+	}
+
+	if (multimesh_owner.owns(p_rid)) {
+		return VS::INSTANCE_MULTIMESH;
+	}
+
+	if (immediate_owner.owns(p_rid)) {
+		return VS::INSTANCE_IMMEDIATE;
+	}
+
+	if (light_owner.owns(p_rid)) {
+		return VS::INSTANCE_LIGHT;
+	}
+
+	if (reflection_probe_owner.owns(p_rid)) {
+		return VS::INSTANCE_REFLECTION_PROBE;
+	}
+
+	if (gi_probe_owner.owns(p_rid)) {
+		return VS::INSTANCE_GI_PROBE;
+	}
+
+	return VS::INSTANCE_NONE;
+}
+
+bool RasterizerStorageGLES3::free(RID p_rid){
+
+	if (render_target_owner.owns(p_rid)) {
+
+		RenderTarget *rt = render_target_owner.getornull(p_rid);
+		_render_target_clear(rt);
+		Texture *t=texture_owner.get(rt->texture);
+		texture_owner.free(rt->texture);
+		memdelete(t);
+		render_target_owner.free(p_rid);
+		memdelete(rt);
+
+	} else if (texture_owner.owns(p_rid)) {
+		// delete the texture
+		Texture *texture = texture_owner.get(p_rid);
+		ERR_FAIL_COND_V(texture->render_target,true); //cant free the render target texture, dude
+		info.texture_mem-=texture->total_data_size;
+		texture_owner.free(p_rid);
+		memdelete(texture);
+	} else if (skybox_owner.owns(p_rid)) {
+		// delete the skybox
+		SkyBox *skybox = skybox_owner.get(p_rid);
+		skybox_set_texture(p_rid,RID(),256);
+		skybox_owner.free(p_rid);
+		memdelete(skybox);
+
+	} else if (shader_owner.owns(p_rid)) {
+
+		// delete the texture
+		Shader *shader = shader_owner.get(p_rid);
+
+
+		if (shader->shader)
+			shader->shader->free_custom_shader(shader->custom_code_id);
+
+		if (shader->dirty_list.in_list())
+			_shader_dirty_list.remove(&shader->dirty_list);
+
+		while (shader->materials.first()) {
+
+			Material *mat = shader->materials.first()->self();
+
+			mat->shader=NULL;
+			_material_make_dirty(mat);
+
+			shader->materials.remove( shader->materials.first() );
+		}
+
+		//material_shader.free_custom_shader(shader->custom_code_id);
+		shader_owner.free(p_rid);
+		memdelete(shader);
+
+	} else if (material_owner.owns(p_rid)) {
+
+		// delete the texture
+		Material *material = material_owner.get(p_rid);
+
+		if (material->shader) {
+			material->shader->materials.remove( & material->list );
+		}
+
+		if (material->ubo_id) {
+			glDeleteBuffers(1,&material->ubo_id);
+		}
+
+		//remove from owners
+		for (Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
+
+			Geometry *g = E->key();
+			g->material=RID();
+		}
+		for (Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
+			RasterizerScene::InstanceBase*ins=E->key();
+			if (ins->material_override==p_rid) {
+				ins->material_override=RID();
+			}
+
+			for(int i=0;i<ins->materials.size();i++) {
+				if (ins->materials[i]==p_rid) {
+					ins->materials[i]=RID();
+				}
+			}
+
+		}
+
+		material_owner.free(p_rid);
+		memdelete(material);
+
+	} else if (skeleton_owner.owns(p_rid)) {
+
+		// delete the texture
+		Skeleton *skeleton = skeleton_owner.get(p_rid);
+		if (skeleton->update_list.in_list()) {
+			skeleton_update_list.remove(&skeleton->update_list);
+		}
+
+		for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
+			E->get()->skeleton=RID();
+		}
+
+		skeleton_allocate(p_rid,0,false);
+		skeleton_owner.free(p_rid);
+		memdelete(skeleton);
+
+	} else if (mesh_owner.owns(p_rid)) {
+
+		// delete the texture
+		Mesh *mesh = mesh_owner.get(p_rid);
+		mesh->instance_remove_deps();
+		mesh_clear(p_rid);
+
+		mesh_owner.free(p_rid);
+		memdelete(mesh);
+
+	} else if (multimesh_owner.owns(p_rid)) {
+
+		// delete the texture
+		MultiMesh *multimesh = multimesh_owner.get(p_rid);
+		multimesh->instance_remove_deps();
+
+		multimesh_allocate(p_rid,0,VS::MULTIMESH_TRANSFORM_2D,VS::MULTIMESH_COLOR_NONE); //frees multimesh
+		update_dirty_multimeshes();
+
+		multimesh_owner.free(p_rid);
+		memdelete(multimesh);
+	} else if (immediate_owner.owns(p_rid)) {
+
+		Immediate *immediate = immediate_owner.get(p_rid);
+		immediate->instance_remove_deps();
+
+		immediate_owner.free(p_rid);
+		memdelete(immediate);
+	} else if (light_owner.owns(p_rid)) {
+
+		// delete the texture
+		Light *light = light_owner.get(p_rid);
+		light->instance_remove_deps();
+
+		light_owner.free(p_rid);
+		memdelete(light);
+
+	} else if (reflection_probe_owner.owns(p_rid)) {
+
+		// delete the texture
+		ReflectionProbe *reflection_probe = reflection_probe_owner.get(p_rid);
+		reflection_probe->instance_remove_deps();
+
+		reflection_probe_owner.free(p_rid);
+		memdelete(reflection_probe);
+
+	} else if (gi_probe_owner.owns(p_rid)) {
+
+		// delete the texture
+		GIProbe *gi_probe = gi_probe_owner.get(p_rid);
+
+
+		gi_probe_owner.free(p_rid);
+		memdelete(gi_probe);
+	} else if (gi_probe_data_owner.owns(p_rid)) {
+
+		// delete the texture
+		GIProbeData *gi_probe_data = gi_probe_data_owner.get(p_rid);
+
+		print_line("dyndata delete");
+		glDeleteTextures(1,&gi_probe_data->tex_id);
+		gi_probe_owner.free(p_rid);
+		memdelete(gi_probe_data);
+
+	} else if (canvas_occluder_owner.owns(p_rid)) {
+
+
+		CanvasOccluder *co = canvas_occluder_owner.get(p_rid);
+		if (co->index_id)
+			glDeleteBuffers(1,&co->index_id);
+		if (co->vertex_id)
+			glDeleteBuffers(1,&co->vertex_id);
+
+		canvas_occluder_owner.free(p_rid);
+		memdelete(co);
+
+	} else if (canvas_light_shadow_owner.owns(p_rid)) {
+
+		CanvasLightShadow *cls = canvas_light_shadow_owner.get(p_rid);
+		glDeleteFramebuffers(1,&cls->fbo);
+		glDeleteRenderbuffers(1,&cls->depth);
+		glDeleteTextures(1,&cls->distance);
+		canvas_light_shadow_owner.free(p_rid);
+		memdelete(cls);
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+////////////////////////////////////////////
+
+
+void RasterizerStorageGLES3::initialize() {
+
+	config.render_arch=RENDER_ARCH_DESKTOP;
+	//config.fbo_deferred=int(Globals::get_singleton()->get("rendering/gles3/lighting_technique"));
+
+	config.system_fbo=0;
+
+
+	//// extensions config
+	///
+
+	{
+
+		int max_extensions=0;
+		print_line("getting extensions");
+		glGetIntegerv(GL_NUM_EXTENSIONS,&max_extensions);
+		print_line("total "+itos(max_extensions));
+		for(int i=0;i<max_extensions;i++) {
+			const GLubyte *s = glGetStringi( GL_EXTENSIONS,i );
+			if (!s)
+				break;
+			config.extensions.insert((const char*)s);
+		}
+	}
+
+	config.shrink_textures_x2=false;
+	config.use_fast_texture_filter=int(Globals::get_singleton()->get("rendering/gles3/use_nearest_mipmap_filter"));
+	config.use_anisotropic_filter = config.extensions.has("GL_EXT_texture_filter_anisotropic");
+
+	config.s3tc_supported=config.extensions.has("GL_EXT_texture_compression_dxt1") || config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc");
+	config.etc_supported=config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");
+	config.latc_supported=config.extensions.has("GL_EXT_texture_compression_latc");
+	config.bptc_supported=config.extensions.has("GL_ARB_texture_compression_bptc");
+#ifdef GLES_OVER_GL
+	config.etc2_supported=false;
+#else
+	config.etc2_supported=true;
+#endif
+	config.pvrtc_supported=config.extensions.has("GL_IMG_texture_compression_pvrtc");
+	config.srgb_decode_supported=config.extensions.has("GL_EXT_texture_sRGB_decode");
+
+
+
+	config.anisotropic_level=1.0;
+	config.use_anisotropic_filter=config.extensions.has("GL_EXT_texture_filter_anisotropic");
+	if (config.use_anisotropic_filter) {
+		glGetFloatv(_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&config.anisotropic_level);
+		config.anisotropic_level=MIN(int(Globals::get_singleton()->get("rendering/gles3/anisotropic_filter_level")),config.anisotropic_level);
+	}
+
+
+	frame.clear_request=false;
+
+	shaders.copy.init();
+
+	{
+		//default textures
+
+
+		glGenTextures(1, &resources.white_tex);
+		unsigned char whitetexdata[8*8*3];
+		for(int i=0;i<8*8*3;i++) {
+			whitetexdata[i]=255;
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,resources.white_tex);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,whitetexdata);
+		glGenerateMipmap(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D,0);
+
+		glGenTextures(1, &resources.black_tex);
+		unsigned char blacktexdata[8*8*3];
+		for(int i=0;i<8*8*3;i++) {
+			blacktexdata[i]=0;
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,resources.black_tex);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,blacktexdata);
+		glGenerateMipmap(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D,0);
+
+		glGenTextures(1, &resources.normal_tex);
+		unsigned char normaltexdata[8*8*3];
+		for(int i=0;i<8*8*3;i+=3) {
+			normaltexdata[i+0]=128;
+			normaltexdata[i+1]=128;
+			normaltexdata[i+2]=255;
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,resources.normal_tex);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,normaltexdata);
+		glGenerateMipmap(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D,0);
+
+
+		glGenTextures(1, &resources.aniso_tex);
+		unsigned char anisotexdata[8*8*3];
+		for(int i=0;i<8*8*3;i+=3) {
+			anisotexdata[i+0]=255;
+			anisotexdata[i+1]=128;
+			anisotexdata[i+2]=0;
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,resources.aniso_tex);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,anisotexdata);
+		glGenerateMipmap(GL_TEXTURE_2D);
+		glBindTexture(GL_TEXTURE_2D,0);
+
+	}
+
+	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&config.max_texture_image_units);
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE,&config.max_texture_size);
+
+#ifdef GLES_OVER_GL
+	config.use_rgba_2d_shadows=false;
+#else
+	config.use_rgba_2d_shadows=true;
+#endif
+
+
+	//generic quadie for copying
+
+	{
+		//quad buffers
+
+		glGenBuffers(1,&resources.quadie);
+		glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
+		{
+			const float qv[16]={
+				-1,-1,
+				 0, 0,
+				-1, 1,
+				 0, 1,
+				 1, 1,
+				 1, 1,
+				 1,-1,
+				 1, 0,
+			};
+
+			glBufferData(GL_ARRAY_BUFFER,sizeof(float)*16,qv,GL_STATIC_DRAW);
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+
+		glGenVertexArrays(1,&resources.quadie_array);
+		glBindVertexArray(resources.quadie_array);
+		glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
+		glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,0);
+		glEnableVertexAttribArray(0);
+		glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,((uint8_t*)NULL)+8);
+		glEnableVertexAttribArray(4);
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+	}
+
+	//generic quadie for copying without touching skybox
+
+	{
+		//transform feedback buffers
+		uint32_t xf_feedback_size = GLOBAL_DEF("rendering/gles3/blend_shape_max_buffer_size_kb",4096);
+		for(int i=0;i<2;i++) {
+
+			glGenBuffers(1,&resources.transform_feedback_buffers[i]);
+			glBindBuffer(GL_ARRAY_BUFFER,resources.transform_feedback_buffers[i]);
+			glBufferData(GL_ARRAY_BUFFER,xf_feedback_size*1024,NULL,GL_STREAM_DRAW);
+		}
+
+		shaders.blend_shapes.init();;
+
+		glGenVertexArrays(1,&resources.transform_feedback_array);
+
+	}
+
+	shaders.cubemap_filter.init();
+	shaders.particles.init();
+
+	glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
+
+	frame.count=0;
+	frame.prev_tick=0;
+	frame.delta=0;
+	config.keep_original_textures=false;
+}
+
+void RasterizerStorageGLES3::finalize() {
+
+	glDeleteTextures(1, &resources.white_tex);
+	glDeleteTextures(1, &resources.black_tex);
+	glDeleteTextures(1, &resources.normal_tex);
+
+}
+
+
+RasterizerStorageGLES3::RasterizerStorageGLES3()
+{
+
+}

drivers/gles3/rasterizer_storage_gles3.h

@@ -0,0 +1,1247 @@
+#ifndef RASTERIZERSTORAGEGLES3_H
+#define RASTERIZERSTORAGEGLES3_H
+
+#include "servers/visual/rasterizer.h"
+#include "servers/visual/shader_language.h"
+#include "shader_gles3.h"
+#include "shaders/copy.glsl.h"
+#include "shaders/canvas.glsl.h"
+#include "shaders/blend_shape.glsl.h"
+#include "shaders/cubemap_filter.glsl.h"
+#include "shaders/particles.glsl.h"
+#include "self_list.h"
+#include "shader_compiler_gles3.h"
+
+class RasterizerCanvasGLES3;
+class RasterizerSceneGLES3;
+
+#define _TEXTURE_SRGB_DECODE_EXT        0x8A48
+#define _DECODE_EXT             0x8A49
+#define _SKIP_DECODE_EXT        0x8A4A
+
+class RasterizerStorageGLES3 : public RasterizerStorage {
+public:
+
+	RasterizerCanvasGLES3 *canvas;
+	RasterizerSceneGLES3 *scene;
+
+	enum RenderArchitecture {
+		RENDER_ARCH_MOBILE,
+		RENDER_ARCH_DESKTOP,
+	};
+
+	struct Config {
+
+		RenderArchitecture render_arch;
+
+		GLuint system_fbo; //on some devices, such as apple, screen is rendered to yet another fbo.
+
+		bool shrink_textures_x2;
+		bool use_fast_texture_filter;
+		bool use_anisotropic_filter;
+
+		bool s3tc_supported;
+		bool latc_supported;
+		bool bptc_supported;
+		bool etc_supported;
+		bool etc2_supported;
+		bool pvrtc_supported;
+
+		bool srgb_decode_supported;
+
+		bool use_rgba_2d_shadows;
+
+		float anisotropic_level;
+
+		int max_texture_image_units;
+		int max_texture_size;
+
+		Set<String> extensions;
+
+		bool keep_original_textures;
+	} config;
+
+	mutable struct Shaders {
+
+		CopyShaderGLES3 copy;
+
+		ShaderCompilerGLES3 compiler;
+
+		CubemapFilterShaderGLES3 cubemap_filter;
+
+		BlendShapeShaderGLES3 blend_shapes;
+
+		ParticlesShaderGLES3 particles;
+
+		ShaderCompilerGLES3::IdentifierActions actions_canvas;
+		ShaderCompilerGLES3::IdentifierActions actions_scene;
+		ShaderCompilerGLES3::IdentifierActions actions_particles;
+	} shaders;
+
+	struct Resources {
+
+		GLuint white_tex;
+		GLuint black_tex;
+		GLuint normal_tex;
+		GLuint aniso_tex;
+
+		GLuint quadie;
+		GLuint quadie_array;
+
+		GLuint transform_feedback_buffers[2];
+		GLuint transform_feedback_array;
+
+	} resources;
+
+	struct Info {
+
+		uint64_t texture_mem;
+
+		uint32_t render_object_count;
+		uint32_t render_material_switch_count;
+		uint32_t render_surface_switch_count;
+		uint32_t render_shader_rebind_count;
+		uint32_t render_vertices_count;
+
+	} info;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////DATA///////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+
+
+
+	struct Instantiable : public RID_Data {
+
+		SelfList<RasterizerScene::InstanceBase>::List instance_list;
+
+		_FORCE_INLINE_ void instance_change_notify() {
+
+			SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
+			while(instances) {
+
+				instances->self()->base_changed();
+				instances=instances->next();
+			}
+		}
+
+		_FORCE_INLINE_ void instance_material_change_notify() {
+
+			SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
+			while(instances) {
+
+				instances->self()->base_material_changed();
+				instances=instances->next();
+			}
+		}
+
+		_FORCE_INLINE_ void instance_remove_deps() {
+			SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
+			while(instances) {
+
+				SelfList<RasterizerScene::InstanceBase> *next = instances->next();
+				instances->self()->base_removed();
+				instances=next;
+			}
+		}
+
+
+		Instantiable() {  }
+		virtual ~Instantiable() {
+
+		}
+	};
+
+	struct GeometryOwner : public Instantiable {
+
+		virtual ~GeometryOwner() {}
+	};
+	struct Geometry : Instantiable {
+
+		enum Type {
+			GEOMETRY_INVALID,
+			GEOMETRY_SURFACE,
+			GEOMETRY_IMMEDIATE,
+			GEOMETRY_MULTISURFACE,
+		};
+
+
+		Type type;
+		RID material;
+		uint64_t last_pass;
+		uint32_t index;
+
+		virtual void material_changed_notify() {}
+
+		Geometry() {
+			last_pass=0;
+			index=0;
+		}
+
+	};
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////API////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////
+
+
+	/* TEXTURE API */
+
+	struct RenderTarget;
+
+	struct Texture : public RID_Data {
+
+		String path;
+		uint32_t flags;
+		int width,height;
+		int alloc_width, alloc_height;
+		Image::Format format;
+
+		GLenum target;
+		GLenum gl_format_cache;
+		GLenum gl_internal_format_cache;
+		GLenum gl_type_cache;
+		int data_size; //original data size, useful for retrieving back
+		bool compressed;
+		bool srgb;
+		int total_data_size;
+		bool ignore_mipmaps;
+
+		int mipmaps;
+
+		bool active;
+		GLuint tex_id;
+
+		bool using_srgb;
+
+		uint16_t stored_cube_sides;
+
+		RenderTarget *render_target;
+
+		Image images[6];
+
+		Texture() {
+
+			using_srgb=false;
+			stored_cube_sides=0;
+			ignore_mipmaps=false;
+			render_target=NULL;
+			flags=width=height=0;
+			tex_id=0;
+			data_size=0;
+			format=Image::FORMAT_L8;
+			active=false;
+			compressed=false;
+			total_data_size=0;
+			target=GL_TEXTURE_2D;
+			mipmaps=0;
+
+		}
+
+		~Texture() {
+
+			if (tex_id!=0) {
+
+				glDeleteTextures(1,&tex_id);
+			}
+		}
+	};
+
+	mutable RID_Owner<Texture> texture_owner;
+
+	Image _get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags, GLenum& r_gl_format, GLenum& r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
+
+	virtual RID texture_create();
+	virtual void texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags=VS::TEXTURE_FLAGS_DEFAULT);
+	virtual void texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT);
+	virtual Image texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT) const;
+	virtual void texture_set_flags(RID p_texture,uint32_t p_flags);
+	virtual uint32_t texture_get_flags(RID p_texture) const;
+	virtual Image::Format texture_get_format(RID p_texture) const;
+	virtual uint32_t texture_get_width(RID p_texture) const;
+	virtual uint32_t texture_get_height(RID p_texture) const;
+	virtual void texture_set_size_override(RID p_texture,int p_width, int p_height);
+
+	virtual void texture_set_path(RID p_texture,const String& p_path);
+	virtual String texture_get_path(RID p_texture) const;
+
+	virtual void texture_set_shrink_all_x2_on_set_data(bool p_enable);
+
+	virtual void texture_debug_usage(List<VS::TextureInfo> *r_info);
+
+	virtual RID texture_create_radiance_cubemap(RID p_source,int p_resolution=-1) const;
+
+	virtual void textures_keep_original(bool p_enable);
+
+	/* SKYBOX API */
+
+	struct SkyBox : public RID_Data {
+
+		RID cubemap;
+		GLuint radiance;
+		int radiance_size;
+	};
+
+	mutable RID_Owner<SkyBox> skybox_owner;
+
+	virtual RID skybox_create();
+	virtual void skybox_set_texture(RID p_skybox,RID p_cube_map,int p_radiance_size);
+
+	/* SHADER API */
+
+	struct Material;
+
+	struct Shader : public RID_Data {
+
+		RID self;
+
+		VS::ShaderMode mode;
+		ShaderGLES3 *shader;
+		String code;
+		SelfList<Material>::List materials;
+
+
+
+		Map<StringName,ShaderLanguage::ShaderNode::Uniform> uniforms;
+		Vector<uint32_t> ubo_offsets;
+		uint32_t ubo_size;
+
+		uint32_t texture_count;
+
+		uint32_t custom_code_id;
+		uint32_t version;
+
+		SelfList<Shader> dirty_list;
+
+		Map<StringName,RID> default_textures;
+
+		Vector<ShaderLanguage::ShaderNode::Uniform::Hint> texture_hints;
+
+		bool valid;
+
+		String path;
+
+		struct CanvasItem {
+
+			enum BlendMode {
+				BLEND_MODE_MIX,
+				BLEND_MODE_ADD,
+				BLEND_MODE_SUB,
+				BLEND_MODE_MUL,
+				BLEND_MODE_PMALPHA,
+			};
+
+			int blend_mode;
+
+			enum LightMode {
+				LIGHT_MODE_NORMAL,
+				LIGHT_MODE_UNSHADED,
+				LIGHT_MODE_LIGHT_ONLY
+			};
+
+			int light_mode;
+
+		} canvas_item;
+
+		struct Spatial {
+
+			enum BlendMode {
+				BLEND_MODE_MIX,
+				BLEND_MODE_ADD,
+				BLEND_MODE_SUB,
+				BLEND_MODE_MUL,
+			};
+
+			int blend_mode;
+
+			enum DepthDrawMode {
+				DEPTH_DRAW_OPAQUE,
+				DEPTH_DRAW_ALWAYS,
+				DEPTH_DRAW_NEVER,
+				DEPTH_DRAW_ALPHA_PREPASS,
+			};
+
+			int depth_draw_mode;
+
+			enum CullMode {
+				CULL_MODE_FRONT,
+				CULL_MODE_BACK,
+				CULL_MODE_DISABLED,
+			};
+
+			int cull_mode;
+
+			bool uses_alpha;
+			bool unshaded;
+			bool ontop;
+			bool uses_vertex;
+			bool uses_discard;
+			bool uses_sss;
+
+		} spatial;
+
+		struct Particles {
+
+
+		} particles;
+
+
+		bool uses_vertex_time;
+		bool uses_fragment_time;
+
+		Shader() : dirty_list(this) {
+
+			shader=NULL;
+			valid=false;
+			custom_code_id=0;
+			version=1;
+		}
+	};
+
+	mutable SelfList<Shader>::List _shader_dirty_list;
+	void _shader_make_dirty(Shader* p_shader);
+
+	mutable RID_Owner<Shader> shader_owner;
+
+	virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_SPATIAL);
+
+	virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode);
+	virtual VS::ShaderMode shader_get_mode(RID p_shader) const;
+
+	virtual void shader_set_code(RID p_shader, const String& p_code);
+	virtual String shader_get_code(RID p_shader) const;
+	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
+
+	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
+	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
+
+	void _update_shader(Shader* p_shader) const;
+
+	void update_dirty_shaders();
+
+
+
+	/* COMMON MATERIAL API */
+
+	struct Material : public RID_Data {
+
+		Shader *shader;
+		GLuint ubo_id;
+		uint32_t ubo_size;
+		Map<StringName,Variant> params;
+		SelfList<Material> list;
+		SelfList<Material> dirty_list;
+		Vector<RID> textures;
+		float line_width;
+
+		uint32_t index;
+		uint64_t last_pass;
+
+		Map<Geometry*,int> geometry_owners;
+		Map<RasterizerScene::InstanceBase*,int> instance_owners;
+
+		bool can_cast_shadow_cache;
+		bool is_animated_cache;
+
+		Material() : list(this), dirty_list(this) {
+			can_cast_shadow_cache=false;
+			is_animated_cache=false;
+			shader=NULL;
+			line_width=1.0;
+			ubo_id=0;
+			ubo_size=0;
+			last_pass=0;
+		}
+
+	};
+
+	mutable SelfList<Material>::List _material_dirty_list;
+	void _material_make_dirty(Material *p_material) const;
+	void _material_add_geometry(RID p_material,Geometry *p_instantiable);
+	void _material_remove_geometry(RID p_material, Geometry *p_instantiable);
+
+
+	mutable RID_Owner<Material> material_owner;
+
+	virtual RID material_create();
+
+	virtual void material_set_shader(RID p_material, RID p_shader);
+	virtual RID material_get_shader(RID p_material) const;
+
+	virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value);
+	virtual Variant material_get_param(RID p_material, const StringName& p_param) const;
+
+	virtual void material_set_line_width(RID p_material, float p_width);
+
+	virtual bool material_is_animated(RID p_material);
+	virtual bool material_casts_shadows(RID p_material);
+
+	virtual void material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance);
+	virtual void material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance);
+
+	void _update_material(Material* material);
+
+	void update_dirty_materials();
+
+	/* MESH API */
+
+
+
+
+
+
+	struct Mesh;
+	struct Surface : public Geometry {
+
+		struct Attrib {
+
+			bool enabled;
+			bool integer;
+			GLuint index;
+			GLint size;
+			GLenum type;
+			GLboolean normalized;
+			GLsizei stride;
+			uint32_t offset;
+		};
+
+		Attrib attribs[VS::ARRAY_MAX];
+
+
+
+		Mesh *mesh;
+		uint32_t format;
+
+		GLuint array_id;
+		GLuint instancing_array_id;
+		GLuint vertex_id;
+		GLuint index_id;
+
+		Vector<AABB> skeleton_bone_aabb;
+		Vector<bool> skeleton_bone_used;
+
+		//bool packed;
+
+		struct MorphTarget {
+			GLuint vertex_id;
+			GLuint array_id;
+		};
+
+		Vector<MorphTarget> morph_targets;
+
+		AABB aabb;
+
+		int array_len;
+		int index_array_len;
+		int max_bone;
+
+		int array_byte_size;
+		int index_array_byte_size;
+
+
+		VS::PrimitiveType primitive;
+
+		bool active;
+
+		virtual void material_changed_notify() {
+			mesh->instance_material_change_notify();
+		}
+
+		Surface() {
+
+			array_byte_size=0;
+			index_array_byte_size=0;
+			mesh=NULL;
+			format=0;
+			array_id=0;
+			vertex_id=0;
+			index_id=0;
+			array_len=0;
+			type=GEOMETRY_SURFACE;
+			primitive=VS::PRIMITIVE_POINTS;
+			index_array_len=0;
+			active=false;
+
+		}
+
+		~Surface() {
+
+		}
+	};
+
+
+	struct Mesh : public GeometryOwner {
+
+		bool active;
+		Vector<Surface*> surfaces;
+		int morph_target_count;
+		VS::MorphTargetMode morph_target_mode;
+		AABB custom_aabb;
+		mutable uint64_t last_pass;
+		Mesh() {
+			morph_target_mode=VS::MORPH_MODE_NORMALIZED;
+			morph_target_count=0;
+			last_pass=0;
+			active=false;
+		}
+	};
+
+	mutable RID_Owner<Mesh> mesh_owner;
+
+	virtual RID mesh_create();
+
+	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >(),const Vector<AABB>& p_bone_aabbs=Vector<AABB>());
+
+	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount);
+	virtual int mesh_get_morph_target_count(RID p_mesh) const;
+
+
+	virtual void mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode);
+	virtual VS::MorphTargetMode mesh_get_morph_target_mode(RID p_mesh) const;
+
+	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material);
+	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const;
+
+	virtual int mesh_surface_get_array_len(RID p_mesh, int p_surface) const;
+	virtual int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const;
+
+	virtual DVector<uint8_t> mesh_surface_get_array(RID p_mesh, int p_surface) const;
+	virtual DVector<uint8_t> mesh_surface_get_index_array(RID p_mesh, int p_surface) const;
+
+
+	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const;
+	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const;
+
+	virtual AABB mesh_surface_get_aabb(RID p_mesh, int p_surface) const;
+	virtual Vector<DVector<uint8_t> > mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const;
+	virtual Vector<AABB> mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const;
+
+	virtual void mesh_remove_surface(RID p_mesh, int p_surface);
+	virtual int mesh_get_surface_count(RID p_mesh) const;
+
+	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb);
+	virtual AABB mesh_get_custom_aabb(RID p_mesh) const;
+
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton) const;
+	virtual void mesh_clear(RID p_mesh);
+
+	void mesh_render_blend_shapes(Surface *s, float *p_weights);
+
+	/* MULTIMESH API */
+
+	struct MultiMesh : public GeometryOwner {
+		RID mesh;
+		int size;
+		VS::MultimeshTransformFormat transform_format;
+		VS::MultimeshColorFormat color_format;
+		Vector<float> data;
+		AABB aabb;
+		SelfList<MultiMesh> update_list;
+		GLuint buffer;
+		int visible_instances;
+
+		int xform_floats;
+		int color_floats;
+
+		bool dirty_aabb;
+		bool dirty_data;
+
+		MultiMesh() : update_list(this) {
+			dirty_aabb=true;
+			dirty_data=true;
+			xform_floats=0;
+			color_floats=0;
+			visible_instances=-1;
+			size=0;
+			buffer=0;
+			transform_format=VS::MULTIMESH_TRANSFORM_2D;
+			color_format=VS::MULTIMESH_COLOR_NONE;
+		}
+	};
+
+	mutable RID_Owner<MultiMesh> multimesh_owner;
+
+	SelfList<MultiMesh>::List multimesh_update_list;
+
+	void update_dirty_multimeshes();
+
+	virtual RID multimesh_create();
+
+	virtual void multimesh_allocate(RID p_multimesh,int p_instances,VS::MultimeshTransformFormat p_transform_format,VS::MultimeshColorFormat p_color_format);
+	virtual int multimesh_get_instance_count(RID p_multimesh) const;
+
+	virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh);
+	virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform);
+	virtual void multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Matrix32& p_transform);
+	virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color);
+
+	virtual RID multimesh_get_mesh(RID p_multimesh) const;
+
+	virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const;
+	virtual Matrix32 multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const;
+	virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const;
+
+	virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
+
+	virtual AABB multimesh_get_aabb(RID p_multimesh) const;
+
+	/* IMMEDIATE API */
+
+	struct Immediate : public Geometry {
+
+		struct Chunk {
+
+			RID texture;
+			VS::PrimitiveType primitive;
+			Vector<Vector3> vertices;
+			Vector<Vector3> normals;
+			Vector<Plane> tangents;
+			Vector<Color> colors;
+			Vector<Vector2> uvs;
+			Vector<Vector2> uvs2;
+		};
+
+		List<Chunk> chunks;
+		bool building;
+		int mask;
+		AABB aabb;
+
+		Immediate() { type=GEOMETRY_IMMEDIATE; building=false;}
+
+	};
+
+	Vector3 chunk_vertex;
+	Vector3 chunk_normal;
+	Plane chunk_tangent;
+	Color chunk_color;
+	Vector2 chunk_uv;
+	Vector2 chunk_uv2;
+
+	mutable RID_Owner<Immediate> immediate_owner;
+
+	virtual RID immediate_create();
+	virtual void immediate_begin(RID p_immediate,VS::PrimitiveType p_rimitive,RID p_texture=RID());
+	virtual void immediate_vertex(RID p_immediate,const Vector3& p_vertex);	
+	virtual void immediate_normal(RID p_immediate,const Vector3& p_normal);
+	virtual void immediate_tangent(RID p_immediate,const Plane& p_tangent);
+	virtual void immediate_color(RID p_immediate,const Color& p_color);
+	virtual void immediate_uv(RID p_immediate,const Vector2& tex_uv);
+	virtual void immediate_uv2(RID p_immediate,const Vector2& tex_uv);
+	virtual void immediate_end(RID p_immediate);
+	virtual void immediate_clear(RID p_immediate);
+	virtual void immediate_set_material(RID p_immediate,RID p_material);
+	virtual RID immediate_get_material(RID p_immediate) const;
+	virtual AABB immediate_get_aabb(RID p_immediate) const;
+
+	/* SKELETON API */
+
+	struct Skeleton : RID_Data {
+		int size;
+		bool use_2d;
+		Vector<float> bones; //4x3 or 4x2 depending on what is needed
+		GLuint ubo;
+		SelfList<Skeleton> update_list;
+		Set<RasterizerScene::InstanceBase*> instances; //instances using skeleton
+
+		Skeleton() : update_list(this) {
+			size=0;
+			use_2d=false;
+			ubo=0;
+		}
+	};
+
+	mutable RID_Owner<Skeleton> skeleton_owner;
+
+	SelfList<Skeleton>::List skeleton_update_list;
+
+	void update_dirty_skeletons();
+
+	virtual RID skeleton_create();
+	virtual void skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton=false);
+	virtual int skeleton_get_bone_count(RID p_skeleton) const;
+	virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform);
+	virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone) const;
+	virtual void skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Matrix32& p_transform);
+	virtual Matrix32 skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const;
+
+	/* Light API */
+
+
+	struct Light : Instantiable {
+
+		VS::LightType type;
+		float param[VS::LIGHT_PARAM_MAX];
+		Color color;
+		Color shadow_color;
+		RID projector;
+		bool shadow;
+		bool negative;
+		uint32_t cull_mask;
+		VS::LightOmniShadowMode omni_shadow_mode;
+		VS::LightOmniShadowDetail omni_shadow_detail;
+		VS::LightDirectionalShadowMode directional_shadow_mode;
+		bool directional_blend_splits;
+		uint64_t version;
+	};
+
+	mutable RID_Owner<Light> light_owner;
+
+	virtual RID light_create(VS::LightType p_type);
+
+	virtual void light_set_color(RID p_light,const Color& p_color);
+	virtual void light_set_param(RID p_light,VS::LightParam p_param,float p_value);
+	virtual void light_set_shadow(RID p_light,bool p_enabled);
+	virtual void light_set_shadow_color(RID p_light,const Color& p_color);
+	virtual void light_set_projector(RID p_light,RID p_texture);
+	virtual void light_set_negative(RID p_light,bool p_enable);
+	virtual void light_set_cull_mask(RID p_light,uint32_t p_mask);
+
+
+	virtual void light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode);
+	virtual void light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail);
+
+	virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode);
+	virtual void light_directional_set_blend_splits(RID p_light,bool p_enable);
+	virtual bool light_directional_get_blend_splits(RID p_light) const;
+
+	virtual VS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light);
+	virtual VS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light);
+
+	virtual bool light_has_shadow(RID p_light) const;
+
+	virtual VS::LightType light_get_type(RID p_light) const;
+	virtual float light_get_param(RID p_light,VS::LightParam p_param);
+	virtual Color light_get_color(RID p_light);
+
+	virtual AABB light_get_aabb(RID p_light) const;
+	virtual uint64_t light_get_version(RID p_light) const;
+
+	/* PROBE API */
+
+	struct ReflectionProbe : Instantiable {
+
+		VS::ReflectionProbeUpdateMode update_mode;
+		float intensity;
+		Color interior_ambient;
+		float interior_ambient_energy;
+		float interior_ambient_probe_contrib;
+		float max_distance;
+		Vector3 extents;
+		Vector3 origin_offset;
+		bool interior;
+		bool box_projection;
+		bool enable_shadows;
+		uint32_t cull_mask;
+
+	};
+
+	mutable RID_Owner<ReflectionProbe> reflection_probe_owner;
+
+	virtual RID reflection_probe_create();
+
+	virtual void reflection_probe_set_update_mode(RID p_probe, VS::ReflectionProbeUpdateMode p_mode);
+	virtual void reflection_probe_set_intensity(RID p_probe, float p_intensity);
+	virtual void reflection_probe_set_interior_ambient(RID p_probe, const Color& p_ambient);
+	virtual void reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy);
+	virtual void reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib);
+	virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance);
+	virtual void reflection_probe_set_extents(RID p_probe, const Vector3& p_extents);
+	virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset);
+	virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable);
+	virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable);
+	virtual void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable);
+	virtual void reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers);
+
+	virtual AABB reflection_probe_get_aabb(RID p_probe) const;
+	virtual VS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const;
+	virtual uint32_t reflection_probe_get_cull_mask(RID p_probe) const;
+
+	virtual Vector3 reflection_probe_get_extents(RID p_probe) const;
+	virtual Vector3 reflection_probe_get_origin_offset(RID p_probe) const;
+	virtual float reflection_probe_get_origin_max_distance(RID p_probe) const;
+	virtual bool reflection_probe_renders_shadows(RID p_probe) const;
+
+
+
+
+	/* ROOM API */
+
+	virtual RID room_create();
+	virtual void room_add_bounds(RID p_room, const DVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform);
+	virtual void room_clear_bounds(RID p_room);
+
+	/* PORTAL API */
+
+	// portals are only (x/y) points, forming a convex shape, which its clockwise
+	// order points outside. (z is 0);
+
+	virtual RID portal_create();
+	virtual void portal_set_shape(RID p_portal, const Vector<Point2>& p_shape);
+	virtual void portal_set_enabled(RID p_portal, bool p_enabled);
+	virtual void portal_set_disable_distance(RID p_portal, float p_distance);
+	virtual void portal_set_disabled_color(RID p_portal, const Color& p_color);
+
+
+
+
+
+
+
+	/* GI PROBE API */
+
+	struct GIProbe : public Instantiable {
+
+
+		AABB bounds;
+		Transform to_cell;
+		float cell_size;
+
+		int dynamic_range;
+		float energy;
+		bool interior;
+		bool compress;
+
+		uint32_t version;
+
+		DVector<int> dynamic_data;
+
+
+	};
+
+	mutable RID_Owner<GIProbe> gi_probe_owner;
+
+	virtual RID gi_probe_create();
+
+	virtual void gi_probe_set_bounds(RID p_probe,const AABB& p_bounds);
+	virtual AABB gi_probe_get_bounds(RID p_probe) const;
+
+	virtual void gi_probe_set_cell_size(RID p_probe, float p_size);
+	virtual float gi_probe_get_cell_size(RID p_probe) const;
+
+	virtual void gi_probe_set_to_cell_xform(RID p_probe,const Transform& p_xform);
+	virtual Transform gi_probe_get_to_cell_xform(RID p_probe) const;
+
+	virtual void gi_probe_set_dynamic_data(RID p_probe,const DVector<int>& p_data);
+	virtual DVector<int> gi_probe_get_dynamic_data(RID p_probe) const;
+
+	virtual void gi_probe_set_dynamic_range(RID p_probe,int p_range);
+	virtual int gi_probe_get_dynamic_range(RID p_probe) const;
+
+	virtual void gi_probe_set_energy(RID p_probe,float p_range);
+	virtual float gi_probe_get_energy(RID p_probe) const;
+
+	virtual void gi_probe_set_interior(RID p_probe,bool p_enable);
+	virtual bool gi_probe_is_interior(RID p_probe) const;
+
+	virtual void gi_probe_set_compress(RID p_probe,bool p_enable);
+	virtual bool gi_probe_is_compressed(RID p_probe) const;
+
+	virtual uint32_t gi_probe_get_version(RID p_probe);
+
+	struct GIProbeData : public RID_Data {
+
+		int width;
+		int height;
+		int depth;
+		int levels;
+		GLuint tex_id;
+		GIProbeCompression compression;
+
+		GIProbeData() {
+		}
+	};
+
+	mutable RID_Owner<GIProbeData> gi_probe_data_owner;
+
+	virtual GIProbeCompression gi_probe_get_dynamic_data_get_preferred_compression() const;
+	virtual RID gi_probe_dynamic_data_create(int p_width,int p_height,int p_depth,GIProbeCompression p_compression);
+	virtual void gi_probe_dynamic_data_update(RID p_gi_probe_data,int p_depth_slice,int p_slice_count,int p_mipmap,const void* p_data);
+
+	/* PARTICLES */
+
+	struct Particles : public Instantiable {
+
+		bool emitting;
+		int amount;
+		float lifetime;
+		float pre_process_time;
+		float explosiveness;
+		float randomness;
+		AABB custom_aabb;
+		Vector3 gravity;
+		bool use_local_coords;
+		RID process_material;
+
+		VS::ParticlesEmissionShape emission_shape;
+		float emission_sphere_radius;
+		Vector3 emission_box_extents;
+		DVector<Vector3> emission_points;
+		GLuint emission_point_texture;
+
+		VS::ParticlesDrawOrder draw_order;
+		struct DrawPass {
+			RID mesh;
+			RID material;
+		};
+
+		Vector<DrawPass> draw_passes;
+
+		AABB computed_aabb;
+
+		GLuint particle_buffers[2];
+
+		SelfList<Particles> particle_element;
+
+		float phase;
+		float prev_phase;
+		uint64_t prev_ticks;
+
+		Transform origin;
+
+		Particles() : particle_element(this) {
+			emitting=false;
+			amount=0;
+			lifetime=1.0;;
+			pre_process_time=0.0;
+			explosiveness=0.0;
+			randomness=0.0;
+			use_local_coords=true;
+
+			draw_order=VS::PARTICLES_DRAW_ORDER_INDEX;
+			emission_shape=VS::PARTICLES_EMSSION_POINT;
+			emission_sphere_radius=1.0;
+			emission_box_extents=Vector3(1,1,1);
+			emission_point_texture=0;
+			particle_buffers[0]=0;
+			particle_buffers[1]=0;
+
+			prev_ticks=0;
+
+			glGenBuffers(2,particle_buffers);
+		}
+
+		~Particles() {
+
+			glDeleteBuffers(2,particle_buffers);
+		}
+
+
+	};
+
+	SelfList<Particles>::List particle_update_list;
+
+	void update_particles();
+
+
+	mutable RID_Owner<Particles> particles_owner;
+
+	virtual RID particles_create();
+
+	virtual void particles_set_emitting(RID p_particles,bool p_emitting);
+	virtual void particles_set_amount(RID p_particles,int p_amount);
+	virtual void particles_set_lifetime(RID p_particles,float p_lifetime);
+	virtual void particles_set_pre_process_time(RID p_particles,float p_time);
+	virtual void particles_set_explosiveness_ratio(RID p_particles,float p_ratio);
+	virtual void particles_set_randomness_ratio(RID p_particles,float p_ratio);
+	virtual void particles_set_custom_aabb(RID p_particles,const AABB& p_aabb);
+	virtual void particles_set_gravity(RID p_particles,const Vector3& p_gravity);
+	virtual void particles_set_use_local_coordinates(RID p_particles,bool p_enable);
+	virtual void particles_set_process_material(RID p_particles,RID p_material);
+
+	virtual void particles_set_emission_shape(RID p_particles,VS::ParticlesEmissionShape p_shape);
+	virtual void particles_set_emission_sphere_radius(RID p_particles,float p_radius);
+	virtual void particles_set_emission_box_extents(RID p_particles,const Vector3& p_extents);
+	virtual void particles_set_emission_points(RID p_particles,const DVector<Vector3>& p_points);
+
+
+	virtual void particles_set_draw_order(RID p_particles,VS::ParticlesDrawOrder p_order);
+
+	virtual void particles_set_draw_passes(RID p_particles,int p_count);
+	virtual void particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material);
+	virtual void particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh);
+
+	virtual AABB particles_get_current_aabb(RID p_particles);
+
+	/* INSTANCE */
+
+	virtual void instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance);
+	virtual void instance_remove_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance);
+
+	virtual void instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
+	virtual void instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
+
+	/* RENDER TARGET */
+
+	struct RenderTarget : public RID_Data {
+
+		GLuint fbo;
+		GLuint color;
+		GLuint depth;
+
+		struct Buffers {
+			GLuint fbo;
+			GLuint depth;
+			GLuint specular;
+			GLuint diffuse;
+			GLuint normal_rough;
+			GLuint motion_sss;
+
+			GLuint effect_fbo;
+			GLuint effect;
+
+		} buffers;
+
+		struct Effects {
+
+			struct MipMaps {
+
+				struct Size {
+					GLuint fbo;
+					int width;
+					int height;
+				};
+
+				Vector<Size> sizes;
+				GLuint color;
+				int levels;
+
+				MipMaps() { color=0; levels=0;}
+			};
+
+			MipMaps mip_maps[2]; //first mipmap chain starts from full-screen
+			//GLuint depth2; //depth for the second mipmap chain, in case of desiring upsampling
+
+			struct SSAO {
+				GLuint blur_fbo[2]; // blur fbo
+				GLuint blur_red[2]; // 8 bits red buffer
+
+				GLuint linear_depth;
+
+				Vector<GLuint> depth_mipmap_fbos; //fbos for depth mipmapsla ver
+
+				SSAO() { blur_fbo[0]=0; blur_fbo[1]=0; linear_depth=0; }
+			} ssao;
+
+			Effects() {}
+
+		} effects;
+
+		struct Exposure {
+			GLuint fbo;
+			GLuint color;
+
+			Exposure() { fbo=0; }
+		} exposure;
+
+		uint64_t last_exposure_tick;
+
+		int width,height;
+
+		bool flags[RENDER_TARGET_FLAG_MAX];
+
+		bool used_in_frame;
+		VS::ViewportMSAA msaa;
+
+		RID texture;
+
+		RenderTarget() {
+
+			msaa=VS::VIEWPORT_MSAA_DISABLED;
+			width=0;
+			height=0;
+			depth=0;
+			fbo=0;
+			buffers.fbo=0;
+			used_in_frame=false;
+
+			flags[RENDER_TARGET_VFLIP]=false;
+			flags[RENDER_TARGET_TRANSPARENT]=false;
+			flags[RENDER_TARGET_NO_3D]=false;
+			flags[RENDER_TARGET_HDR]=true;
+			flags[RENDER_TARGET_NO_SAMPLING]=false;
+
+			last_exposure_tick=0;
+		}
+	};
+
+	mutable RID_Owner<RenderTarget> render_target_owner;
+
+	void _render_target_clear(RenderTarget *rt);
+	void _render_target_allocate(RenderTarget *rt);
+
+	virtual RID render_target_create();
+	virtual void render_target_set_size(RID p_render_target,int p_width, int p_height);
+	virtual RID render_target_get_texture(RID p_render_target) const;
+
+	virtual void render_target_set_flag(RID p_render_target,RenderTargetFlags p_flag,bool p_value);
+	virtual bool render_target_renedered_in_frame(RID p_render_target);
+	virtual void render_target_set_msaa(RID p_render_target,VS::ViewportMSAA p_msaa);
+
+	/* CANVAS SHADOW */
+
+	struct CanvasLightShadow : public RID_Data {
+
+		int size;
+		int height;
+		GLuint fbo;
+		GLuint depth;
+		GLuint distance; //for older devices
+	};
+
+	RID_Owner<CanvasLightShadow> canvas_light_shadow_owner;
+
+	virtual RID canvas_light_shadow_buffer_create(int p_width);
+
+	/* LIGHT SHADOW MAPPING */
+
+	struct CanvasOccluder : public RID_Data {
+
+		GLuint vertex_id; // 0 means, unconfigured
+		GLuint index_id; // 0 means, unconfigured
+		DVector<Vector2> lines;
+		int len;
+	};
+
+	RID_Owner<CanvasOccluder> canvas_occluder_owner;
+
+	virtual RID canvas_light_occluder_create();
+	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines);
+
+	virtual VS::InstanceType get_base_type(RID p_rid) const;
+
+	virtual bool free(RID p_rid);
+
+
+	struct Frame {
+
+		RenderTarget *current_rt;
+
+		bool clear_request;
+		Color clear_request_color;
+		int canvas_draw_commands;
+		float time[4];
+		float delta;
+		uint64_t prev_tick;
+		uint64_t count;
+	} frame;
+
+	void initialize();
+	void finalize();
+
+
+
+	RasterizerStorageGLES3();
+};
+
+
+#endif // RASTERIZERSTORAGEGLES3_H

drivers/gles3/shader_compiler_gles3.cpp

@@ -0,0 +1,738 @@
+#include "shader_compiler_gles3.h"
+#include "os/os.h"
+
+#define SL ShaderLanguage
+
+static String _mktab(int p_level) {
+
+	String tb;
+	for(int i=0;i<p_level;i++) {
+		tb+="\t";
+	}
+
+	return tb;
+}
+
+static String _typestr(SL::DataType p_type) {
+
+	return ShaderLanguage::get_datatype_name(p_type);
+}
+
+static int _get_datatype_size(SL::DataType p_type) {
+
+	switch(p_type) {
+
+		case SL::TYPE_VOID: return 0;
+		case SL::TYPE_BOOL: return 4;
+		case SL::TYPE_BVEC2: return 8;
+		case SL::TYPE_BVEC3: return 16;
+		case SL::TYPE_BVEC4: return 16;
+		case SL::TYPE_INT: return 4;
+		case SL::TYPE_IVEC2: return 8;
+		case SL::TYPE_IVEC3: return 16;
+		case SL::TYPE_IVEC4: return 16;
+		case SL::TYPE_UINT: return 4;
+		case SL::TYPE_UVEC2: return 8;
+		case SL::TYPE_UVEC3: return 16;
+		case SL::TYPE_UVEC4: return 16;
+		case SL::TYPE_FLOAT: return 4;
+		case SL::TYPE_VEC2: return 8;
+		case SL::TYPE_VEC3: return 16;
+		case SL::TYPE_VEC4: return 16;
+		case SL::TYPE_MAT2: return 16;
+		case SL::TYPE_MAT3: return 48;
+		case SL::TYPE_MAT4: return 64;
+		case SL::TYPE_SAMPLER2D: return 16;
+		case SL::TYPE_ISAMPLER2D: return 16;
+		case SL::TYPE_USAMPLER2D: return 16;
+		case SL::TYPE_SAMPLERCUBE: return 16;
+	}
+
+	ERR_FAIL_V(0);
+}
+
+
+
+static String _prestr(SL::DataPrecision p_pres) {
+
+
+	switch(p_pres) {
+		case SL::PRECISION_LOWP: return "lowp ";
+		case SL::PRECISION_MEDIUMP: return "mediump ";
+		case SL::PRECISION_HIGHP: return "highp ";
+		case SL::PRECISION_DEFAULT: return "";
+	}
+	return "";
+}
+
+
+static String _opstr(SL::Operator p_op) {
+
+	return SL::get_operator_text(p_op);
+}
+
+static String _mkid(const String& p_id) {
+
+	return "m_"+p_id;
+}
+
+static String f2sp0(float p_float) {
+
+	if (int(p_float)==p_float)
+		return itos(p_float)+".0";
+	else
+		return rtoss(p_float);
+}
+
+static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value>& p_values) {
+
+	switch(p_type) {
+		case SL::TYPE_BOOL:  return p_values[0].boolean?"true":"false";
+		case SL::TYPE_BVEC2:
+		case SL::TYPE_BVEC3:
+		case SL::TYPE_BVEC4: {
+
+
+			String text="bvec"+itos(p_type-SL::TYPE_BOOL+1)+"(";
+			for(int i=0;i<p_values.size();i++) {
+				if (i>0)
+					text+=",";
+
+				text+=p_values[i].boolean?"true":"false";
+			}
+			text+=")";
+			return text;
+		}
+
+		case SL::TYPE_INT:  return itos(p_values[0].sint);
+		case SL::TYPE_IVEC2:
+		case SL::TYPE_IVEC3:
+		case SL::TYPE_IVEC4: {
+
+			String text="ivec"+itos(p_type-SL::TYPE_INT+1)+"(";
+			for(int i=0;i<p_values.size();i++) {
+				if (i>0)
+					text+=",";
+
+				text+=itos(p_values[i].sint);
+			}
+			text+=")";
+			return text;
+
+		} break;
+		case SL::TYPE_UINT:  return itos(p_values[0].uint)+"u";
+		case SL::TYPE_UVEC2:
+		case SL::TYPE_UVEC3:
+		case SL::TYPE_UVEC4:   {
+
+			String text="uvec"+itos(p_type-SL::TYPE_UINT+1)+"(";
+			for(int i=0;i<p_values.size();i++) {
+				if (i>0)
+					text+=",";
+
+				text+=itos(p_values[i].uint)+"u";
+			}
+			text+=")";
+			return text;
+		} break;
+		case SL::TYPE_FLOAT:  return f2sp0(p_values[0].real)+"f";
+		case SL::TYPE_VEC2:
+		case SL::TYPE_VEC3:
+		case SL::TYPE_VEC4:  {
+
+			String text="vec"+itos(p_type-SL::TYPE_FLOAT+1)+"(";
+			for(int i=0;i<p_values.size();i++) {
+				if (i>0)
+					text+=",";
+
+				text+=f2sp0(p_values[i].real);
+			}
+			text+=")";
+			return text;
+
+		} break;
+		default: ERR_FAIL_V(String());
+	}
+}
+
+void ShaderCompilerGLES3::_dump_function_deps(SL::ShaderNode* p_node, const StringName& p_for_func, const Map<StringName,String>& p_func_code, String& r_to_add, Set<StringName> &added) {
+
+	int fidx=-1;
+
+	for(int i=0;i<p_node->functions.size();i++) {
+		if (p_node->functions[i].name==p_for_func) {
+			fidx=i;
+			break;
+		}
+	}
+
+	ERR_FAIL_COND(fidx==-1);
+
+	for (Set<StringName>::Element *E=p_node->functions[fidx].uses_function.front();E;E=E->next()) {
+
+		if (added.has(E->get())) {
+			continue; //was added already
+		}
+
+		_dump_function_deps(p_node,E->get(),p_func_code,r_to_add,added);
+
+		SL::FunctionNode *fnode=NULL;
+
+		for(int i=0;i<p_node->functions.size();i++) {
+			if (p_node->functions[i].name==E->get()) {
+				fnode=p_node->functions[i].function;
+				break;
+			}
+		}
+
+		ERR_FAIL_COND(!fnode);
+
+		r_to_add+="\n";
+
+		String header;
+		header=_typestr(fnode->return_type)+" "+_mkid(fnode->name)+"(";
+		for(int i=0;i<fnode->arguments.size();i++) {
+
+			if (i>0)
+				header+=", ";
+			header+=_prestr(fnode->arguments[i].precision)+_typestr(fnode->arguments[i].type)+" "+_mkid(fnode->arguments[i].name);
+		}
+
+		header+=")\n";
+		r_to_add+=header;
+		r_to_add+=p_func_code[E->get()];
+
+		added.insert(E->get());
+	}
+}
+
+String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, GeneratedCode& r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions) {
+
+	String code;
+
+	switch(p_node->type) {
+
+		case SL::Node::TYPE_SHADER: {
+
+			SL::ShaderNode *pnode=(SL::ShaderNode*)p_node;
+
+			for(int i=0;i<pnode->render_modes.size();i++) {
+
+				if (p_default_actions.render_mode_defines.has(pnode->render_modes[i]) && !used_rmode_defines.has(pnode->render_modes[i])) {
+
+					r_gen_code.defines.push_back(p_default_actions.render_mode_defines[pnode->render_modes[i]].utf8());
+					used_rmode_defines.insert(pnode->render_modes[i]);
+				}
+
+				if (p_actions.render_mode_flags.has(pnode->render_modes[i])) {
+					*p_actions.render_mode_flags[pnode->render_modes[i]]=true;
+				}
+
+				if (p_actions.render_mode_values.has(pnode->render_modes[i])) {
+					Pair<int*,int> &p = p_actions.render_mode_values[pnode->render_modes[i]];
+					*p.first=p.second;
+				}
+			}
+
+
+			int max_texture_uniforms=0;
+			int max_uniforms=0;
+
+			for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+				if (SL::is_sampler_type(E->get().type))
+					max_texture_uniforms++;
+				else
+					max_uniforms++;
+			}
+
+			r_gen_code.texture_uniforms.resize(max_texture_uniforms);
+			r_gen_code.texture_hints.resize(max_texture_uniforms);
+
+			Vector<int> uniform_sizes;
+			Vector<int> uniform_alignments;
+			Vector<StringName> uniform_defines;
+			uniform_sizes.resize(max_uniforms);
+			uniform_alignments.resize(max_uniforms);
+			uniform_defines.resize(max_uniforms);
+
+			for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+
+				String ucode;
+
+				if (SL::is_sampler_type(E->get().type)) {
+					ucode="uniform ";
+				}
+
+				ucode+=_prestr(E->get().precission);
+				ucode+=_typestr(E->get().type);
+				ucode+=" "+_mkid(E->key());
+				ucode+=";\n";
+				if (SL::is_sampler_type(E->get().type)) {
+					r_gen_code.vertex_global+=ucode;
+					r_gen_code.fragment_global+=ucode;
+					r_gen_code.texture_uniforms[E->get().texture_order]=_mkid(E->key());
+					r_gen_code.texture_hints[E->get().texture_order]=E->get().hint;
+				} else {
+					if (r_gen_code.uniforms.empty()) {
+
+						r_gen_code.defines.push_back(String("#define USE_MATERIAL\n").ascii());
+					}
+					uniform_defines[E->get().order]=ucode;
+					uniform_sizes[E->get().order]=_get_datatype_size(E->get().type);
+					uniform_alignments[E->get().order]=MIN(16,_get_datatype_size(E->get().type));
+				}
+
+				p_actions.uniforms->insert(E->key(),E->get());
+
+			}
+
+			for(int i=0;i<max_uniforms;i++) {
+				r_gen_code.uniforms+=uniform_defines[i];
+			}
+			// add up
+			for(int i=0;i<uniform_sizes.size();i++) {
+
+				if (i>0) {
+
+					int align = uniform_sizes[i-1] % uniform_alignments[i];
+					if (align!=0) {
+						uniform_sizes[i-1]+=uniform_alignments[i]-align;
+					}
+
+					uniform_sizes[i]=uniform_sizes[i]+uniform_sizes[i-1];
+
+				}
+			}
+			//offset
+			r_gen_code.uniform_offsets.resize(uniform_sizes.size());
+			for(int i=0;i<uniform_sizes.size();i++) {
+
+				if (i>0)
+					r_gen_code.uniform_offsets[i]=uniform_sizes[i-1];
+				else
+					r_gen_code.uniform_offsets[i]=0;
+
+
+			}
+/*
+			for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+
+				if (SL::is_sampler_type(E->get().type)) {
+					continue;
+				}
+
+				print_line("u - "+String(E->key())+" offset: "+itos(r_gen_code.uniform_offsets[E->get().order]));
+
+			}
+
+*/
+			if (uniform_sizes.size()) {
+				r_gen_code.uniform_total_size=uniform_sizes[ uniform_sizes.size() -1 ];
+			} else {
+				r_gen_code.uniform_total_size=0;
+			}
+
+			for(Map<StringName,SL::ShaderNode::Varying>::Element *E=pnode->varyings.front();E;E=E->next()) {
+
+				String vcode;
+				vcode+=_prestr(E->get().precission);
+				vcode+=_typestr(E->get().type);
+				vcode+=" "+String(E->key());
+				vcode+=";\n";
+				r_gen_code.vertex_global+="out "+vcode;
+				r_gen_code.fragment_global+="in "+vcode;
+			}
+
+			Map<StringName,String> function_code;
+
+			//code for functions
+			for(int i=0;i<pnode->functions.size();i++) {
+				SL::FunctionNode *fnode=pnode->functions[i].function;
+				function_code[fnode->name]=_dump_node_code(fnode->body,p_level+1,r_gen_code,p_actions,p_default_actions);
+			}
+
+			//place functions in actual code
+
+			Set<StringName> added_vtx;
+			Set<StringName> added_fragment; //share for light
+
+			for(int i=0;i<pnode->functions.size();i++) {
+
+				SL::FunctionNode *fnode=pnode->functions[i].function;
+
+				current_func_name=fnode->name;
+
+				if (fnode->name=="vertex") {
+
+					_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.vertex_global,added_vtx);
+					r_gen_code.vertex=function_code["vertex"];
+				}
+
+				if (fnode->name=="fragment") {
+
+					_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
+					r_gen_code.fragment=function_code["fragment"];
+				}
+
+				if (fnode->name=="light") {
+
+					_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
+					r_gen_code.light=function_code["light"];
+				}
+			}
+
+			//code+=dump_node_code(pnode->body,p_level);
+		} break;
+		case SL::Node::TYPE_FUNCTION: {
+
+		} break;
+		case SL::Node::TYPE_BLOCK: {
+			SL::BlockNode *bnode=(SL::BlockNode*)p_node;
+
+			//variables
+			code+=_mktab(p_level-1)+"{\n";
+			for(Map<StringName,SL::BlockNode::Variable>::Element *E=bnode->variables.front();E;E=E->next()) {
+
+				code+=_mktab(p_level)+_prestr(E->get().precision)+_typestr(E->get().type)+" "+_mkid(E->key())+";\n";
+			}
+
+			for(int i=0;i<bnode->statements.size();i++) {
+
+				String scode = _dump_node_code(bnode->statements[i],p_level,r_gen_code,p_actions,p_default_actions);
+
+				if (bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW || bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW) {
+					code+=scode; //use directly
+				} else {
+					code+=_mktab(p_level)+scode+";\n";
+				}
+			}
+			code+=_mktab(p_level-1)+"}\n";
+
+
+		} break;
+		case SL::Node::TYPE_VARIABLE: {
+			SL::VariableNode *vnode=(SL::VariableNode*)p_node;
+
+			if (p_default_actions.usage_defines.has(vnode->name) && !used_name_defines.has(vnode->name)) {
+				String define = p_default_actions.usage_defines[vnode->name];
+				if (define.begins_with("@")) {
+					define = p_default_actions.usage_defines[define.substr(1,define.length())];
+				}
+				r_gen_code.defines.push_back(define.utf8());
+				used_name_defines.insert(vnode->name);
+			}
+
+			if (p_actions.usage_flag_pointers.has(vnode->name) && !used_flag_pointers.has(vnode->name)) {
+				*p_actions.usage_flag_pointers[vnode->name]=true;
+				used_flag_pointers.insert(vnode->name);
+			}
+
+			if (p_default_actions.renames.has(vnode->name))
+				code=p_default_actions.renames[vnode->name];
+			else
+				code=_mkid(vnode->name);
+
+			if (vnode->name==time_name) {
+				if (current_func_name==vertex_name) {
+					r_gen_code.uses_vertex_time=true;
+				}
+				if (current_func_name==fragment_name) {
+					r_gen_code.uses_fragment_time=true;
+				}
+			}
+
+		} break;
+		case SL::Node::TYPE_CONSTANT: {
+			SL::ConstantNode *cnode=(SL::ConstantNode*)p_node;
+			return get_constant_text(cnode->datatype,cnode->values);
+
+		} break;
+		case SL::Node::TYPE_OPERATOR: {
+			SL::OperatorNode *onode=(SL::OperatorNode*)p_node;
+
+
+			switch(onode->op) {
+
+				case SL::OP_ASSIGN:
+				case SL::OP_ASSIGN_ADD:
+				case SL::OP_ASSIGN_SUB:
+				case SL::OP_ASSIGN_MUL:
+				case SL::OP_ASSIGN_DIV:
+				case SL::OP_ASSIGN_SHIFT_LEFT:
+				case SL::OP_ASSIGN_SHIFT_RIGHT:
+				case SL::OP_ASSIGN_MOD:
+				case SL::OP_ASSIGN_BIT_AND:
+				case SL::OP_ASSIGN_BIT_OR:
+				case SL::OP_ASSIGN_BIT_XOR:
+					code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions);
+					break;
+				case SL::OP_BIT_INVERT:
+				case SL::OP_NEGATE:
+				case SL::OP_NOT:
+				case SL::OP_DECREMENT:
+				case SL::OP_INCREMENT:
+					code=_opstr(onode->op)+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions);
+					break;
+				case SL::OP_POST_DECREMENT:
+				case SL::OP_POST_INCREMENT:
+					code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op);
+					break;
+				case SL::OP_CALL:
+				case SL::OP_CONSTRUCT: {
+
+					ERR_FAIL_COND_V(onode->arguments[0]->type!=SL::Node::TYPE_VARIABLE,String());
+
+					SL::VariableNode *vnode=(SL::VariableNode*)onode->arguments[0];
+
+					if (onode->op==SL::OP_CONSTRUCT) {
+						code+=String(vnode->name);
+					} else {
+
+						if (internal_functions.has(vnode->name)) {
+							code+=vnode->name;
+						} else if (p_default_actions.renames.has(vnode->name)) {
+							code+=p_default_actions.renames[vnode->name];
+						} else {
+							code+=_mkid(vnode->name);
+						}
+					}
+
+					code+="(";
+
+					for(int i=1;i<onode->arguments.size();i++) {
+						if (i>1)
+							code+=", ";
+						code+=_dump_node_code(onode->arguments[i],p_level,r_gen_code,p_actions,p_default_actions);
+					}
+					code+=")";
+				} break;
+				default: {
+
+					code="("+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions)+")";
+					break;
+
+				}
+			}
+
+		} break;
+		case SL::Node::TYPE_CONTROL_FLOW: {
+			SL::ControlFlowNode *cfnode=(SL::ControlFlowNode*)p_node;
+			if (cfnode->flow_op==SL::FLOW_OP_IF) {
+
+				code+=_mktab(p_level)+"if ("+_dump_node_code(cfnode->expressions[0],p_level,r_gen_code,p_actions,p_default_actions)+")\n";
+				code+=_dump_node_code(cfnode->blocks[0],p_level+1,r_gen_code,p_actions,p_default_actions);
+				if (cfnode->blocks.size()==2) {
+
+					code+=_mktab(p_level)+"else\n";
+					code+=_dump_node_code(cfnode->blocks[1],p_level+1,r_gen_code,p_actions,p_default_actions);
+				}
+
+
+			} else if (cfnode->flow_op==SL::FLOW_OP_RETURN) {
+
+				if (cfnode->blocks.size()) {
+					code="return "+_dump_node_code(cfnode->blocks[0],p_level,r_gen_code,p_actions,p_default_actions);
+				} else {
+					code="return";
+				}
+			}
+
+		} break;
+		case SL::Node::TYPE_MEMBER: {
+			SL::MemberNode *mnode=(SL::MemberNode*)p_node;
+			code=_dump_node_code(mnode->owner,p_level,r_gen_code,p_actions,p_default_actions)+"."+mnode->name;
+
+		} break;
+	}
+
+	return code;
+
+}
+
+
+Error ShaderCompilerGLES3::compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String &p_path,GeneratedCode& r_gen_code) {
+
+
+
+	Error err = parser.compile(p_code,ShaderTypes::get_singleton()->get_functions(p_mode),ShaderTypes::get_singleton()->get_modes(p_mode));
+
+	if (err!=OK) {
+#if 1
+
+		Vector<String> shader = p_code.split("\n");
+		for(int i=0;i<shader.size();i++) {
+			print_line(itos(i)+" "+shader[i]);
+		}
+#endif
+
+		_err_print_error(NULL,p_path.utf8().get_data(),parser.get_error_line(),parser.get_error_text().utf8().get_data(),ERR_HANDLER_SHADER);
+		return err;
+	}
+
+	r_gen_code.defines.clear();
+	r_gen_code.vertex=String();
+	r_gen_code.vertex_global=String();
+	r_gen_code.fragment=String();
+	r_gen_code.fragment_global=String();
+	r_gen_code.light=String();
+	r_gen_code.uses_fragment_time=false;
+	r_gen_code.uses_vertex_time=false;
+
+
+
+	used_name_defines.clear();
+	used_rmode_defines.clear();
+
+	_dump_node_code(parser.get_shader(),1,r_gen_code,*p_actions,actions[p_mode]);
+
+	return OK;
+
+}
+
+
+ShaderCompilerGLES3::ShaderCompilerGLES3() {
+
+	/** CANVAS ITEM SHADER **/
+
+	actions[VS::SHADER_CANVAS_ITEM].renames["SRC_VERTEX"]="vertex";
+	actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX"]="outvec.xy";
+	actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX_COLOR"]="vertex_color";
+	actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
+	actions[VS::SHADER_CANVAS_ITEM].renames["POINT_SIZE"]="gl_PointSize";
+
+	actions[VS::SHADER_CANVAS_ITEM].renames["WORLD_MATRIX"]="modelview_matrix";
+	actions[VS::SHADER_CANVAS_ITEM].renames["PROJECTION_MATRIX"]="projection_matrix";
+	actions[VS::SHADER_CANVAS_ITEM].renames["EXTRA_MATRIX"]=="extra_matrix";
+	actions[VS::SHADER_CANVAS_ITEM].renames["TIME"]="time";
+
+	actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
+	actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL"]="normal";
+	actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP"]="normal_map";
+	actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP_DEPTH"]="normal_depth";
+	actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
+	actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
+	actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE"]="color_texture";
+	actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE_PIXEL_SIZE"]="color_texpixel_size";
+	actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_UV"]="screen_uv";
+	actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_TEXTURE"]="screen_texture";
+	actions[VS::SHADER_CANVAS_ITEM].renames["POINT_COORD"]="gl_PointCoord";
+
+	actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_VEC"]="light_vec";
+	actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_HEIGHT"]="light_height";
+	actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_COLOR"]="light_color";
+	actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_UV"]="light_uv";
+	//actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_SHADOW_COLOR"]="light_shadow_color";
+	actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT"]="light";
+	actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_COLOR"]="shadow_color";
+
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["COLOR"]="#define COLOR_USED\n";
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_TEXTURE"]="#define SCREEN_TEXTURE_USED\n";
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_UV"]="#define SCREEN_UV_USED\n";
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMAL"]="#define NORMAL_USED\n";
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMALMAP"]="#define NORMALMAP_USED\n";
+	actions[VS::SHADER_CANVAS_ITEM].usage_defines["SHADOW_COLOR"]="#define SHADOW_COLOR_USED\n";
+
+	actions[VS::SHADER_CANVAS_ITEM].render_mode_defines["skip_transform"]="#define SKIP_TRANSFORM_USED\n";
+
+	/** SPATIAL SHADER **/
+
+
+	actions[VS::SHADER_SPATIAL].renames["WORLD_MATRIX"]="world_transform";
+	actions[VS::SHADER_SPATIAL].renames["INV_CAMERA_MATRIX"]="camera_inverse_matrix";
+	actions[VS::SHADER_SPATIAL].renames["PROJECTION_MATRIX"]="projection_matrix";
+
+
+	actions[VS::SHADER_SPATIAL].renames["VERTEX"]="vertex.xyz";
+	actions[VS::SHADER_SPATIAL].renames["NORMAL"]="normal";
+	actions[VS::SHADER_SPATIAL].renames["TANGENT"]="tangent";
+	actions[VS::SHADER_SPATIAL].renames["BINORMAL"]="binormal";
+	actions[VS::SHADER_SPATIAL].renames["UV"]="uv_interp";
+	actions[VS::SHADER_SPATIAL].renames["UV2"]="uv2_interp";
+	actions[VS::SHADER_SPATIAL].renames["COLOR"]="color_interp";
+	actions[VS::SHADER_SPATIAL].renames["POINT_SIZE"]="gl_PointSize";
+	//actions[VS::SHADER_SPATIAL].renames["INSTANCE_ID"]=ShaderLanguage::TYPE_INT;
+
+	//builtins
+
+	actions[VS::SHADER_SPATIAL].renames["TIME"]="time";
+	//actions[VS::SHADER_SPATIAL].renames["VIEWPORT_SIZE"]=ShaderLanguage::TYPE_VEC2;
+
+	actions[VS::SHADER_SPATIAL].renames["FRAGCOORD"]="gl_FragCoord";
+	actions[VS::SHADER_SPATIAL].renames["FRONT_FACING"]="gl_FrotFacing";
+	actions[VS::SHADER_SPATIAL].renames["NORMALMAP"]="normalmap";
+	actions[VS::SHADER_SPATIAL].renames["NORMALMAP_DEPTH"]="normaldepth";
+	actions[VS::SHADER_SPATIAL].renames["ALBEDO"]="albedo";
+	actions[VS::SHADER_SPATIAL].renames["ALPHA"]="alpha";
+	actions[VS::SHADER_SPATIAL].renames["SPECULAR"]="specular";
+	actions[VS::SHADER_SPATIAL].renames["ROUGHNESS"]="roughness";
+	actions[VS::SHADER_SPATIAL].renames["RIM"]="rim";
+	actions[VS::SHADER_SPATIAL].renames["RIM_TINT"]="rim_tint";
+	actions[VS::SHADER_SPATIAL].renames["CLEARCOAT"]="clearcoat";
+	actions[VS::SHADER_SPATIAL].renames["CLEARCOAT_GLOSS"]="clearcoat_gloss";
+	actions[VS::SHADER_SPATIAL].renames["ANISOTROPY"]="anisotropy";
+	actions[VS::SHADER_SPATIAL].renames["ANISOTROPY_FLOW"]="anisotropy_flow";
+	actions[VS::SHADER_SPATIAL].renames["SSS_SPREAD"]="sss_spread";
+	actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"]="sss_strength";
+	actions[VS::SHADER_SPATIAL].renames["AO"]="ao";
+	actions[VS::SHADER_SPATIAL].renames["EMISSION"]="emission";
+	actions[VS::SHADER_SPATIAL].renames["DISCARD"]="_discard";
+//	actions[VS::SHADER_SPATIAL].renames["SCREEN_UV"]=ShaderLanguage::TYPE_VEC2;
+	actions[VS::SHADER_SPATIAL].renames["POINT_COORD"]="gl_PointCoord";
+
+
+	actions[VS::SHADER_SPATIAL].usage_defines["TANGENT"]="#define ENABLE_TANGENT_INTERP\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["BINORMAL"]="@TANGENT";
+	actions[VS::SHADER_SPATIAL].usage_defines["RIM"]="#define LIGHT_USE_RIM\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["RIM_TINT"]="@RIM";
+	actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT"]="#define LIGHT_USE_CLEARCOAT\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT_GLOSS"]="@CLEARCOAT";
+	actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY"]="#define LIGHT_USE_ANISOTROPY\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY_FLOW"]="@ANISOTROPY";
+	actions[VS::SHADER_SPATIAL].usage_defines["AO"]="#define ENABLE_AO\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["UV"]="#define ENABLE_UV_INTERP\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["UV2"]="#define ENABLE_UV2_INTERP\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP"]="#define ENABLE_NORMALMAP\n";
+	actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP_DEPTH"]="@NORMALMAP";
+	actions[VS::SHADER_SPATIAL].usage_defines["COLOR"]="#define ENABLE_COLOR_INTERP\n";
+
+	actions[VS::SHADER_SPATIAL].usage_defines["SSS_STRENGTH"]="#define ENABLE_SSS_MOTION\n";
+
+	actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"]="sss_strength";
+
+
+	actions[VS::SHADER_SPATIAL].render_mode_defines["skip_transform"]="#define SKIP_TRANSFORM_USED\n";
+
+
+	/* PARTICLES SHADER */
+
+	actions[VS::SHADER_PARTICLES].renames["COLOR"]="color";
+	actions[VS::SHADER_PARTICLES].renames["VELOCITY"]="out_velocity_active.xyz";
+	actions[VS::SHADER_PARTICLES].renames["MASS"]="mass";
+	actions[VS::SHADER_PARTICLES].renames["ACTIVE"]="active";
+	actions[VS::SHADER_PARTICLES].renames["RESTART"]="restart";
+	actions[VS::SHADER_PARTICLES].renames["CUSTOM"]="out_custom";
+	actions[VS::SHADER_PARTICLES].renames["TRANSFORM"]="xform";
+	actions[VS::SHADER_PARTICLES].renames["TIME"]="time";
+	actions[VS::SHADER_PARTICLES].renames["LIFETIME"]="lifetime";
+	actions[VS::SHADER_PARTICLES].renames["DELTA"]="delta";
+	actions[VS::SHADER_PARTICLES].renames["SEED"]="seed";
+	actions[VS::SHADER_PARTICLES].renames["ORIGIN"]="origin";
+	actions[VS::SHADER_PARTICLES].renames["INDEX"]="index";
+
+	actions[VS::SHADER_SPATIAL].render_mode_defines["disable_force"]="#define DISABLE_FORCE\n";
+	actions[VS::SHADER_SPATIAL].render_mode_defines["disable_velocity"]="#define DISABLE_VELOCITY\n";
+
+
+	vertex_name="vertex";
+	fragment_name="fragment";
+	time_name="TIME";
+
+
+	List<String> func_list;
+
+	ShaderLanguage::get_builtin_funcs(&func_list);
+
+	for (List<String>::Element *E=func_list.front();E;E=E->next()) {
+		internal_functions.insert(E->get());
+	}
+}

drivers/gles3/shader_compiler_gles3.h

@@ -0,0 +1,77 @@
+#ifndef SHADERCOMPILERGLES3_H
+#define SHADERCOMPILERGLES3_H
+
+#include "servers/visual/shader_language.h"
+#include "servers/visual/shader_types.h"
+#include "servers/visual_server.h"
+#include "pair.h"
+
+class ShaderCompilerGLES3 {
+public:
+	struct IdentifierActions {
+
+		Map<StringName,Pair<int*,int> > render_mode_values;
+		Map<StringName,bool*> render_mode_flags;
+		Map<StringName,bool*> usage_flag_pointers;
+
+		Map<StringName,ShaderLanguage::ShaderNode::Uniform> *uniforms;
+	};
+
+	struct GeneratedCode {
+
+		Vector<CharString> defines;
+		Vector<StringName> texture_uniforms;
+		Vector<ShaderLanguage::ShaderNode::Uniform::Hint> texture_hints;
+
+		Vector<uint32_t> uniform_offsets;
+		uint32_t uniform_total_size;
+		String uniforms;
+		String vertex_global;
+		String vertex;
+		String fragment_global;
+		String fragment;
+		String light;
+
+		bool uses_fragment_time;
+		bool uses_vertex_time;
+
+	};
+
+private:
+
+	ShaderLanguage parser;
+
+	struct DefaultIdentifierActions {
+
+		Map<StringName,String> renames;
+		Map<StringName,String> render_mode_defines;
+		Map<StringName,String> usage_defines;
+	};
+
+	void _dump_function_deps(ShaderLanguage::ShaderNode *p_node, const StringName& p_for_func, const Map<StringName, String> &p_func_code, String& r_to_add,Set<StringName> &added);
+	String _dump_node_code(ShaderLanguage::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions& p_actions, const DefaultIdentifierActions& p_default_actions);
+
+
+	StringName current_func_name;
+	StringName vertex_name;
+	StringName fragment_name;
+	StringName time_name;
+
+	Set<StringName> used_name_defines;
+	Set<StringName> used_flag_pointers;
+	Set<StringName> used_rmode_defines;
+	Set<StringName> internal_functions;
+
+
+	DefaultIdentifierActions actions[VS::SHADER_MAX];
+
+public:
+
+
+	Error compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String& p_path, GeneratedCode& r_gen_code);
+
+
+	ShaderCompilerGLES3();
+};
+
+#endif // SHADERCOMPILERGLES3_H

drivers/gles3/shader_gles3.cpp

@@ -0,0 +1,839 @@
+/*************************************************************************/
+/*  shader_gles2.cpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is 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 Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS 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     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "shader_gles3.h"
+
+
+#include "print_string.h"
+
+//#define DEBUG_OPENGL
+
+#ifdef DEBUG_OPENGL
+
+#define DEBUG_TEST_ERROR(m_section)\
+{\
+	uint32_t err = glGetError();\
+	if (err) {\
+		print_line("OpenGL Error #"+itos(err)+" at: "+m_section);\
+	}\
+}
+#else
+
+#define DEBUG_TEST_ERROR(m_section)
+
+#endif
+
+ShaderGLES3 *ShaderGLES3::active=NULL;
+
+
+
+//#define DEBUG_SHADER
+
+#ifdef DEBUG_SHADER
+
+#define DEBUG_PRINT(m_text) print_line(m_text);
+
+#else
+
+#define DEBUG_PRINT(m_text)
+
+#endif
+
+
+void ShaderGLES3::bind_uniforms() {
+
+	if (!uniforms_dirty) {
+		return;
+	};
+
+	// upload default uniforms
+	const Map<uint32_t,Variant>::Element *E =uniform_defaults.front();
+
+	while(E) {
+		int idx=E->key();
+		int location=version->uniform_location[idx];
+
+		if (location<0) {
+			E=E->next();
+			continue;
+
+		}
+
+		const Variant &v=E->value();
+		_set_uniform_variant(location, v);
+		//print_line("uniform "+itos(location)+" value "+v+ " type "+Variant::get_type_name(v.get_type()));
+		E=E->next();
+	};
+
+	const Map<uint32_t,CameraMatrix>::Element* C = uniform_cameras.front();
+	while (C) {
+
+		int location = version->uniform_location[C->key()];
+		if (location<0) {
+			C=C->next();
+			continue;
+		}
+
+		glUniformMatrix4fv(location,1,false,&(C->get().matrix[0][0]));
+		C = C->next();
+	};
+
+	uniforms_dirty = false;
+};
+
+GLint ShaderGLES3::get_uniform_location(int p_idx) const {
+
+	ERR_FAIL_COND_V(!version, -1);
+
+	return version->uniform_location[p_idx];
+};
+
+bool ShaderGLES3::bind() {
+		
+	if (active!=this || !version || new_conditional_version.key!=conditional_version.key) {
+		conditional_version=new_conditional_version;
+		version = get_current_version();
+	} else {
+
+		return false;
+	}
+	
+	ERR_FAIL_COND_V(!version,false);
+
+	glUseProgram( version->id );
+
+	DEBUG_TEST_ERROR("Use Program");
+
+	active=this;
+	uniforms_dirty = true;
+/*
+ *	why on earth is this code here?
+	for (int i=0;i<texunit_pair_count;i++) {
+
+		glUniform1i(texunit_pairs[i].location, texunit_pairs[i].index);
+		DEBUG_TEST_ERROR("Uniform 1 i");
+	}
+
+*/
+	return true;
+}
+
+void ShaderGLES3::unbind() {
+
+	version=NULL;
+	glUseProgram(0);
+	uniforms_dirty = true;
+	active=NULL;
+}
+
+
+static void _display_error_with_code(const String& p_error,const Vector<const char*>& p_code) {
+
+
+	int line=1;
+	String total_code;
+
+	for(int i=0;i<p_code.size();i++) {
+		total_code+=String(p_code[i]);
+	}
+
+	Vector<String> lines = String(total_code).split("\n");
+
+	for(int j=0;j<lines.size();j++) {
+
+		print_line(itos(line)+": "+lines[j]);
+		line++;
+	}
+
+	ERR_PRINTS(p_error);
+
+}
+
+ShaderGLES3::Version* ShaderGLES3::get_current_version() {
+
+	Version *_v=version_map.getptr(conditional_version);
+
+	if (_v) {
+
+		if (conditional_version.code_version!=0) {
+			CustomCode *cc=custom_code_map.getptr(conditional_version.code_version);
+			ERR_FAIL_COND_V(!cc,_v);
+			if (cc->version==_v->code_version)
+				return _v;
+		} else {
+			return _v;
+		}
+
+	}
+
+
+
+	if (!_v)
+		version_map[conditional_version]=Version();
+
+
+	Version &v = version_map[conditional_version];
+
+	if (!_v) {
+
+		v.uniform_location = memnew_arr( GLint, uniform_count );
+
+	} else {
+		if (v.ok) {
+			//bye bye shaders
+			glDeleteShader( v.vert_id );
+			glDeleteShader( v.frag_id );
+			glDeleteProgram( v.id );
+			v.id=0;
+		}
+
+	}
+
+
+
+	v.ok=false;
+	/* SETUP CONDITIONALS */
+	
+	Vector<const char*> strings;
+#ifdef GLES_OVER_GL
+	strings.push_back("#version 330\n");
+#else
+	strings.push_back("#version 300 es\n");
+#endif
+
+
+
+	int define_line_ofs=1;
+
+	for(int i=0;i<custom_defines.size();i++) {
+
+		strings.push_back(custom_defines[i].get_data());
+		define_line_ofs++;
+	}
+
+	for(int j=0;j<conditional_count;j++) {
+		
+		bool enable=((1<<j)&conditional_version.version);
+		strings.push_back(enable?conditional_defines[j]:"");
+		if (enable)
+			define_line_ofs++;
+
+		if (enable) {
+			DEBUG_PRINT(conditional_defines[j]);
+		}
+
+	}
+
+
+	
+	//keep them around during the function
+	CharString code_string;
+	CharString code_string2;
+	CharString code_globals;
+	CharString material_string;
+
+
+	//print_line("code version? "+itos(conditional_version.code_version));
+
+	CustomCode *cc=NULL;
+
+	if ( conditional_version.code_version>0 ) {
+		//do custom code related stuff
+
+		ERR_FAIL_COND_V( !custom_code_map.has( conditional_version.code_version ), NULL );
+		cc=&custom_code_map[conditional_version.code_version];
+		v.code_version=cc->version;
+		define_line_ofs+=2;
+
+	}
+
+
+	/* CREATE PROGRAM */
+	
+	v.id = glCreateProgram();
+	
+	ERR_FAIL_COND_V(v.id==0, NULL);
+	
+	/* VERTEX SHADER */
+
+
+	if (cc) {
+		for(int i=0;i<cc->custom_defines.size();i++) {
+
+			strings.push_back(cc->custom_defines[i].get_data());
+			DEBUG_PRINT("CD #"+itos(i)+": "+String(cc->custom_defines[i]));
+		}
+	}
+
+	int strings_base_size=strings.size();
+
+	//vertex precision is high
+	strings.push_back("precision highp float;\n");
+	strings.push_back("precision highp int;\n");
+
+#if 0
+	if (cc) {
+
+		String _code_string = "#define VERTEX_SHADER_CODE "+cc->vertex+"\n";
+		String _code_globals = "#define VERTEX_SHADER_GLOBALS "+cc->vertex_globals+"\n";
+
+		code_string=_code_string.ascii();
+		code_globals=_code_globals.ascii();
+		DEBUG_PRINT( code_globals.get_data() );
+		DEBUG_PRINT( code_string.get_data() );
+		strings.push_back(code_globals);
+		strings.push_back(code_string);
+	}
+#endif
+
+
+	strings.push_back(vertex_code0.get_data());
+	if (cc) {
+		code_globals=cc->vertex_globals.ascii();
+		strings.push_back(code_globals.get_data());
+	}
+
+	strings.push_back(vertex_code1.get_data());
+
+	if (cc) {
+		material_string=cc->uniforms.ascii();
+		strings.push_back(material_string.get_data());
+	}
+
+	strings.push_back(vertex_code2.get_data());
+
+	if (cc) {
+		code_string=cc->vertex.ascii();
+		strings.push_back(code_string.get_data());
+	}
+
+	strings.push_back(vertex_code3.get_data());
+#ifdef DEBUG_SHADER
+
+	DEBUG_PRINT("\nVertex Code:\n\n"+String(code_string.get_data()));
+	for(int i=0;i<strings.size();i++) {
+
+		//print_line("vert strings "+itos(i)+":"+String(strings[i]));
+	}
+#endif
+
+
+	v.vert_id = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(v.vert_id,strings.size(),&strings[0],NULL);
+	glCompileShader(v.vert_id);
+	
+	GLint status;
+	
+	glGetShaderiv(v.vert_id,GL_COMPILE_STATUS,&status);			
+	if (status==GL_FALSE) {
+	// error compiling
+		GLsizei iloglen;
+		glGetShaderiv(v.vert_id,GL_INFO_LOG_LENGTH,&iloglen);
+		
+		if (iloglen<0) {
+			
+			glDeleteShader(v.vert_id);
+			glDeleteProgram( v.id );
+			v.id=0;
+			
+			ERR_PRINT("NO LOG, WTF");
+		} else {
+
+			if (iloglen==0) {
+
+				iloglen = 4096; //buggy driver (Adreno 220+....)
+			}
+
+			
+			char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
+			ilogmem[iloglen]=0;
+			glGetShaderInfoLog(v.vert_id, iloglen, &iloglen, ilogmem); 	
+			
+			String err_string=get_shader_name()+": Vertex Program Compilation Failed:\n";
+			
+			err_string+=ilogmem;
+			_display_error_with_code(err_string,strings);
+			Memory::free_static(ilogmem);
+			glDeleteShader(v.vert_id);
+			glDeleteProgram( v.id );
+			v.id=0;
+			
+		}
+		
+		ERR_FAIL_V(NULL);
+	}	
+
+
+	/* FRAGMENT SHADER */
+
+	strings.resize(strings_base_size);
+	//fragment precision is medium
+	strings.push_back("precision highp float;\n");
+	strings.push_back("precision highp int;\n");
+
+#if 0
+	if (cc) {
+
+		String _code_string = "#define FRAGMENT_SHADER_CODE "+cc->fragment+"\n";
+		String _code_globals = "#define FRAGMENT_SHADER_GLOBALS "+cc->fragment_globals+"\n";
+
+		code_string=_code_string.ascii();
+		code_globals=_code_globals.ascii();
+		DEBUG_PRINT( code_globals.get_data() );
+		DEBUG_PRINT( code_string.get_data() );
+		strings.push_back(code_globals);
+		strings.push_back(code_string);
+	}
+#endif
+
+
+	strings.push_back(fragment_code0.get_data());
+	if (cc) {
+		code_globals=cc->fragment_globals.ascii();
+		strings.push_back(code_globals.get_data());
+	}
+
+	strings.push_back(fragment_code1.get_data());
+
+	if (cc) {
+		material_string=cc->uniforms.ascii();
+		strings.push_back(material_string.get_data());
+	}
+
+	strings.push_back(fragment_code2.get_data());
+
+	if (cc) {
+		code_string=cc->fragment.ascii();
+		strings.push_back(code_string.get_data());
+	}
+
+	strings.push_back(fragment_code3.get_data());
+
+	if (cc) {
+		code_string2=cc->light.ascii();
+		strings.push_back(code_string2.get_data());
+	}
+
+	strings.push_back(fragment_code4.get_data());
+
+#ifdef DEBUG_SHADER
+	DEBUG_PRINT("\nFragment Code:\n\n"+String(code_string.get_data()));
+	for(int i=0;i<strings.size();i++) {
+
+		//print_line("frag strings "+itos(i)+":"+String(strings[i]));
+	}
+#endif
+
+	v.frag_id = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(v.frag_id,strings.size(),&strings[0],NULL);
+	glCompileShader(v.frag_id);
+	
+	glGetShaderiv(v.frag_id,GL_COMPILE_STATUS,&status);			
+	if (status==GL_FALSE) {
+	// error compiling
+		GLsizei iloglen;
+		glGetShaderiv(v.frag_id,GL_INFO_LOG_LENGTH,&iloglen);
+		
+		if (iloglen<0) {
+
+			glDeleteShader(v.frag_id);
+			glDeleteShader(v.vert_id);
+			glDeleteProgram( v.id );
+			v.id=0;
+			ERR_PRINT("NO LOG, WTF");
+		} else {
+			
+			if (iloglen==0) {
+
+				iloglen = 4096; //buggy driver (Adreno 220+....)
+			}
+
+			char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
+			ilogmem[iloglen]=0;
+			glGetShaderInfoLog(v.frag_id, iloglen, &iloglen, ilogmem); 	
+			
+			String err_string=get_shader_name()+": Fragment Program Compilation Failed:\n";
+			
+			err_string+=ilogmem;
+			_display_error_with_code(err_string,strings);
+			ERR_PRINT(err_string.ascii().get_data());
+			Memory::free_static(ilogmem);
+			glDeleteShader(v.frag_id);
+			glDeleteShader(v.vert_id);
+			glDeleteProgram( v.id );
+			v.id=0;
+			
+		}
+		
+		ERR_FAIL_V( NULL );
+	}		
+
+	glAttachShader(v.id,v.frag_id);
+	glAttachShader(v.id,v.vert_id);
+
+	// bind attributes before linking
+	for (int i=0;i<attribute_pair_count;i++) {
+
+		glBindAttribLocation(v.id, attribute_pairs[i].index, attribute_pairs[i].name );
+	}
+
+	//if feedback exists, set it up
+
+	if (feedback_count) {
+		Vector<const char*> feedback;
+		for(int i=0;i<feedback_count;i++) {
+
+			if (feedbacks[i].conditional==-1 || (1<<feedbacks[i].conditional)&conditional_version.version) {
+				//conditional for this feedback is enabled
+				print_line("tf varying: "+itos(feedback.size())+" "+String(feedbacks[i].name));
+				feedback.push_back(feedbacks[i].name);
+			}
+		}
+
+		if (feedback.size()) {
+			glTransformFeedbackVaryings(v.id,feedback.size(),feedback.ptr(),GL_INTERLEAVED_ATTRIBS );
+		}
+
+	}
+
+	glLinkProgram(v.id);
+	
+	glGetProgramiv(v.id, GL_LINK_STATUS, &status);
+	
+	if (status==GL_FALSE) {
+	// error linking
+		GLsizei iloglen;
+		glGetProgramiv(v.id,GL_INFO_LOG_LENGTH,&iloglen);
+		
+		if (iloglen<0) {
+			
+			glDeleteShader(v.frag_id);
+			glDeleteShader(v.vert_id);
+			glDeleteProgram( v.id );
+			v.id=0;
+			ERR_FAIL_COND_V(iloglen<=0, NULL);		
+		}
+
+		if (iloglen==0) {
+
+			iloglen = 4096; //buggy driver (Adreno 220+....)
+		}
+
+		
+		char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
+		ilogmem[iloglen]=0;
+		glGetProgramInfoLog(v.id, iloglen, &iloglen, ilogmem); 	
+		
+		String err_string=get_shader_name()+": Program LINK FAILED:\n";
+		
+		err_string+=ilogmem;
+		_display_error_with_code(err_string,strings);
+		ERR_PRINT(err_string.ascii().get_data());
+		Memory::free_static(ilogmem);
+		glDeleteShader(v.frag_id);
+		glDeleteShader(v.vert_id);
+		glDeleteProgram( v.id );
+		v.id=0;
+		
+		ERR_FAIL_V(NULL);
+	}
+	
+	/* UNIFORMS */		
+	
+	glUseProgram(v.id);
+
+
+	//print_line("uniforms:  ");
+	for(int j=0;j<uniform_count;j++) {
+		
+		
+		v.uniform_location[j]=glGetUniformLocation(v.id,uniform_names[j]);
+	//	print_line("uniform "+String(uniform_names[j])+" location "+itos(v.uniform_location[j]));
+	}
+	
+	// set texture uniforms
+	for (int i=0;i<texunit_pair_count;i++) {
+
+		GLint loc = glGetUniformLocation(v.id,texunit_pairs[i].name);
+		if (loc>=0) {
+			if (texunit_pairs[i].index<0) {
+				glUniform1i(loc,max_image_units+texunit_pairs[i].index); //negative, goes down
+			} else {
+
+				glUniform1i(loc,texunit_pairs[i].index);
+			}
+		}
+	}
+
+	// assign uniform block bind points
+	for (int i=0;i<ubo_count;i++) {
+
+		GLint loc =  glGetUniformBlockIndex(v.id,ubo_pairs[i].name);
+		if (loc>=0)
+			 glUniformBlockBinding(v.id,loc,ubo_pairs[i].index);
+	}
+
+	if ( cc ) {
+
+		v.texture_uniform_locations.resize(cc->texture_uniforms.size());
+		for(int i=0;i<cc->texture_uniforms.size();i++) {
+
+			v.texture_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->texture_uniforms[i]).ascii().get_data());
+			glUniform1i(v.texture_uniform_locations[i],i+base_material_tex_index);
+		}
+	}
+
+	glUseProgram(0);
+	
+
+	v.ok=true;
+
+	return &v;
+}
+
+GLint ShaderGLES3::get_uniform_location(const String& p_name) const {
+
+	ERR_FAIL_COND_V(!version,-1);
+	return glGetUniformLocation(version->id,p_name.ascii().get_data());
+}
+
+
+void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_count,const char** p_uniform_names,int p_uniform_count, const AttributePair* p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs, int p_ubo_pair_count, const Feedback* p_feedback, int p_feedback_count,const char*p_vertex_code, const char *p_fragment_code,int p_vertex_code_start,int p_fragment_code_start) {
+
+	ERR_FAIL_COND(version);
+	conditional_version.key=0;
+	new_conditional_version.key=0;
+	uniform_count=p_uniform_count;
+	conditional_count=p_conditional_count;
+	conditional_defines=p_conditional_defines;
+	uniform_names=p_uniform_names;
+	vertex_code=p_vertex_code;
+	fragment_code=p_fragment_code;
+	texunit_pairs=p_texunit_pairs;
+	texunit_pair_count=p_texunit_pair_count;
+	vertex_code_start=p_vertex_code_start;
+	fragment_code_start=p_fragment_code_start;
+	attribute_pairs=p_attribute_pairs;
+	attribute_pair_count=p_attribute_count;
+	ubo_pairs=p_ubo_pairs;
+	ubo_count=p_ubo_pair_count;
+	feedbacks=p_feedback;
+	feedback_count=p_feedback_count;
+
+	//split vertex and shader code (thank you, retarded shader compiler programmers from you know what company).
+	{
+		String globals_tag="\nVERTEX_SHADER_GLOBALS";
+		String material_tag="\nMATERIAL_UNIFORMS";
+		String code_tag="\nVERTEX_SHADER_CODE";
+		String code =  vertex_code;
+		int cpos = code.find(globals_tag);
+		if (cpos==-1) {
+			vertex_code0=code.ascii();
+		} else {
+			vertex_code0=code.substr(0,cpos).ascii();
+			code = code.substr(cpos+globals_tag.length(),code.length());
+
+			cpos = code.find(material_tag);
+
+			if (cpos==-1) {
+				vertex_code1=code.ascii();
+			} else {
+
+				vertex_code1=code.substr(0,cpos).ascii();
+				String code2 = code.substr(cpos+material_tag.length(),code.length());
+
+				cpos = code2.find(code_tag);
+				if (cpos==-1) {
+					vertex_code2=code2.ascii();
+				} else {
+
+					vertex_code2=code2.substr(0,cpos).ascii();
+					vertex_code3 = code2.substr(cpos+code_tag.length(),code2.length()).ascii();
+				}
+
+			}
+		}
+	}
+
+	{
+		String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
+		String material_tag="\nMATERIAL_UNIFORMS";
+		String code_tag="\nFRAGMENT_SHADER_CODE";
+		String light_code_tag="\nLIGHT_SHADER_CODE";
+		String code =  fragment_code;
+		int cpos = code.find(globals_tag);
+		if (cpos==-1) {
+			fragment_code0=code.ascii();
+		} else {
+			fragment_code0=code.substr(0,cpos).ascii();
+			//print_line("CODE0:\n"+String(fragment_code0.get_data()));
+			code = code.substr(cpos+globals_tag.length(),code.length());			
+			cpos = code.find(material_tag);
+
+			if (cpos==-1) {
+				fragment_code1=code.ascii();
+			} else {
+
+				fragment_code1=code.substr(0,cpos).ascii();
+				//print_line("CODE1:\n"+String(fragment_code1.get_data()));
+
+				String code2 = code.substr(cpos+material_tag.length(),code.length());
+				cpos = code2.find(code_tag);
+
+				if (cpos==-1) {
+					fragment_code2=code2.ascii();
+				} else {
+
+					fragment_code2=code2.substr(0,cpos).ascii();
+					//print_line("CODE2:\n"+String(fragment_code2.get_data()));
+
+					String code3 = code2.substr(cpos+code_tag.length(),code2.length());
+
+					cpos = code3.find(light_code_tag);
+					if (cpos==-1) {
+						fragment_code3=code3.ascii();
+					} else {
+
+						fragment_code3=code3.substr(0,cpos).ascii();
+					//	print_line("CODE3:\n"+String(fragment_code3.get_data()));
+						fragment_code4 = code3.substr(cpos+light_code_tag.length(),code3.length()).ascii();
+						//print_line("CODE4:\n"+String(fragment_code4.get_data()));
+					}
+				}
+			}
+		}
+	}
+
+	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&max_image_units);
+
+}
+
+void ShaderGLES3::finish() {
+	
+	const VersionKey *V=NULL;
+	while((V=version_map.next(V))) {
+	
+		Version &v=version_map[*V];
+		glDeleteShader( v.vert_id );
+		glDeleteShader( v.frag_id );
+		glDeleteProgram( v.id );
+		memdelete_arr( v.uniform_location );			
+
+	}
+	
+}
+
+
+void ShaderGLES3::clear_caches() {
+
+	const VersionKey *V=NULL;
+	while((V=version_map.next(V))) {
+	
+		Version &v=version_map[*V];
+		glDeleteShader( v.vert_id );
+		glDeleteShader( v.frag_id );
+		glDeleteProgram( v.id );
+		memdelete_arr( v.uniform_location );
+	}
+
+	version_map.clear();
+
+	custom_code_map.clear();
+	version=NULL;	
+	last_custom_code=1;
+	uniforms_dirty = true;
+
+}
+
+uint32_t ShaderGLES3::create_custom_shader() {
+
+	custom_code_map[last_custom_code]=CustomCode();
+	custom_code_map[last_custom_code].version=1;
+	return last_custom_code++;
+}
+
+void ShaderGLES3::set_custom_shader_code(uint32_t p_code_id, const String& p_vertex, const String& p_vertex_globals, const String& p_fragment, const String& p_light, const String& p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines) {
+
+	ERR_FAIL_COND(!custom_code_map.has(p_code_id));
+	CustomCode *cc=&custom_code_map[p_code_id];
+
+
+	cc->vertex=p_vertex;
+	cc->vertex_globals=p_vertex_globals;
+	cc->fragment=p_fragment;
+	cc->fragment_globals=p_fragment_globals;
+	cc->light=p_light;
+	cc->texture_uniforms=p_texture_uniforms;
+	cc->uniforms=p_uniforms;
+	cc->custom_defines=p_custom_defines;
+	cc->version++;
+}
+
+void ShaderGLES3::set_custom_shader(uint32_t p_code_id) {
+
+	new_conditional_version.code_version=p_code_id;
+}
+
+void ShaderGLES3::free_custom_shader(uint32_t p_code_id) {
+
+  /*  if (! custom_code_map.has( p_code_id )) {
+        print_line("no code id "+itos(p_code_id));
+    } else {
+        print_line("freed code id "+itos(p_code_id));
+
+    }*/
+
+	ERR_FAIL_COND(! custom_code_map.has( p_code_id ));
+	if (conditional_version.code_version==p_code_id)
+		conditional_version.code_version=0; //bye
+
+	custom_code_map.erase(p_code_id);
+
+}
+
+void ShaderGLES3::set_base_material_tex_index(int p_idx) {
+
+	base_material_tex_index=p_idx;
+}
+
+ShaderGLES3::ShaderGLES3() {
+	version=NULL;
+	last_custom_code=1;
+	uniforms_dirty = true;
+	base_material_tex_index=0;
+
+}
+
+
+ShaderGLES3::~ShaderGLES3() {
+	
+	finish();
+}
+
+
+

drivers/gles3/shader_gles3.h

@@ -0,0 +1,399 @@
+/*************************************************************************/
+/*  shader_gles2.h                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is 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 Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS 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     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef SHADER_GLES3_H
+#define SHADER_GLES3_H
+
+#include <stdio.h>
+
+#include "platform_config.h"
+#ifndef GLES3_INCLUDE_H
+#include <GLES3/gl3.h>
+#else
+#include GLES3_INCLUDE_H
+#endif
+
+#include "hash_map.h"
+#include "map.h"
+#include "variant.h"
+#include "camera_matrix.h"
+
+/**
+	@author Juan Linietsky <[email protected]>
+*/
+
+
+class ShaderGLES3 {
+protected:	
+
+	struct Enum {
+
+		uint64_t mask;
+		uint64_t shift;
+		const char *defines[16];
+	};
+
+	struct EnumValue {
+
+		uint64_t set_mask;
+		uint64_t clear_mask;
+	};
+
+	struct AttributePair {
+
+		const char *name;
+		int index;
+	};
+
+	struct UniformPair {
+		const char* name;
+		Variant::Type type_hint;
+	};
+
+	struct TexUnitPair {
+
+		const char *name;
+		int index;
+	};
+
+	struct UBOPair {
+
+		const char *name;
+		int index;
+	};
+
+	struct Feedback {
+
+		const char *name;
+		int conditional;
+	};
+
+	bool uniforms_dirty;
+private:	
+
+	//@TODO Optimize to a fixed set of shader pools and use a LRU
+	int uniform_count;
+	int texunit_pair_count;
+	int conditional_count;
+	int ubo_count;
+	int feedback_count;
+	int vertex_code_start;
+	int fragment_code_start;
+	int attribute_pair_count;
+
+	struct CustomCode {
+
+		String vertex;
+		String vertex_globals;
+		String fragment;
+		String fragment_globals;
+		String light;
+		String uniforms;
+		uint32_t version;
+		Vector<StringName> texture_uniforms;
+		Vector<CharString> custom_defines;
+
+	};
+
+
+	struct Version {
+		
+		GLuint id;
+		GLuint vert_id;
+		GLuint frag_id;					
+		GLint *uniform_location;
+		Vector<GLint> texture_uniform_locations;
+		uint32_t code_version;
+		bool ok;
+		Version() { code_version=0; ok=false; uniform_location=NULL; }
+	};
+	
+	Version *version;
+
+	union VersionKey {
+
+		struct {
+			uint32_t version;
+			uint32_t code_version;
+		};
+		uint64_t key;
+		bool operator==(const VersionKey& p_key) const { return key==p_key.key; }
+		bool operator<(const VersionKey& p_key) const { return key<p_key.key; }
+
+	};
+
+	struct VersionKeyHash {
+
+		static _FORCE_INLINE_ uint32_t hash( const VersionKey& p_key) { return HashMapHahserDefault::hash(p_key.key); };
+	};
+
+	//this should use a way more cachefriendly version..
+	HashMap<VersionKey,Version,VersionKeyHash> version_map;
+
+	HashMap<uint32_t,CustomCode> custom_code_map;
+	uint32_t last_custom_code;
+	
+	
+	VersionKey conditional_version;
+	VersionKey new_conditional_version;
+	
+	virtual String get_shader_name() const=0;
+	
+	const char** conditional_defines;
+	const char** uniform_names;
+	const AttributePair *attribute_pairs;
+	const TexUnitPair *texunit_pairs;
+	const UBOPair *ubo_pairs;
+	const Feedback *feedbacks;
+	const char* vertex_code;
+	const char* fragment_code;
+	CharString fragment_code0;
+	CharString fragment_code1;
+	CharString fragment_code2;
+	CharString fragment_code3;
+	CharString fragment_code4;
+
+	CharString vertex_code0;
+	CharString vertex_code1;
+	CharString vertex_code2;
+	CharString vertex_code3;
+
+	Vector<CharString> custom_defines;
+
+	int base_material_tex_index;
+
+	Version * get_current_version();
+	
+	static ShaderGLES3 *active;
+
+	int max_image_units;
+
+	_FORCE_INLINE_ void _set_uniform_variant(GLint p_uniform,const Variant& p_value) {
+
+		if (p_uniform<0)
+			return; // do none
+		switch(p_value.get_type()) {
+
+		case Variant::BOOL:
+		case Variant::INT: {
+
+			int val=p_value;
+			glUniform1i( p_uniform, val );
+		} break;
+		case Variant::REAL: {
+
+			real_t val=p_value;
+			glUniform1f( p_uniform, val );
+		} break;
+		case Variant::COLOR: {
+
+			Color val=p_value;
+			glUniform4f( p_uniform, val.r, val.g,val.b,val.a );
+		} break;
+		case Variant::VECTOR2: {
+
+			Vector2 val=p_value;
+			glUniform2f( p_uniform, val.x,val.y );
+		} break;
+		case Variant::VECTOR3: {
+
+			Vector3 val=p_value;
+			glUniform3f( p_uniform, val.x,val.y,val.z );
+		} break;
+		case Variant::PLANE: {
+
+			Plane val=p_value;
+			glUniform4f( p_uniform, val.normal.x,val.normal.y,val.normal.z,val.d );
+		} break;
+		case Variant::QUAT: {
+
+			Quat val=p_value;
+			glUniform4f( p_uniform, val.x,val.y,val.z,val.w );
+		} break;
+
+		case Variant::MATRIX32: {
+
+			Matrix32 tr=p_value;
+			GLfloat matrix[16]={ /* build a 16x16 matrix */
+				tr.elements[0][0],
+				tr.elements[0][1],
+				0,
+				0,
+				tr.elements[1][0],
+				tr.elements[1][1],
+				0,
+				0,
+				0,
+				0,
+				1,
+				0,
+				tr.elements[2][0],
+				tr.elements[2][1],
+				0,
+				1
+			};
+
+			glUniformMatrix4fv(p_uniform,1,false,matrix);
+
+		} break;
+		case Variant::MATRIX3:
+		case Variant::TRANSFORM: {
+
+			Transform tr=p_value;
+			GLfloat matrix[16]={ /* build a 16x16 matrix */
+				tr.basis.elements[0][0],
+				tr.basis.elements[1][0],
+				tr.basis.elements[2][0],
+				0,
+				tr.basis.elements[0][1],
+				tr.basis.elements[1][1],
+				tr.basis.elements[2][1],
+				0,
+				tr.basis.elements[0][2],
+				tr.basis.elements[1][2],
+				tr.basis.elements[2][2],
+				0,
+				tr.origin.x,
+				tr.origin.y,
+				tr.origin.z,
+				1
+			};
+
+
+			glUniformMatrix4fv(p_uniform,1,false,matrix);
+		} break;
+		default: { ERR_FAIL(); } // do nothing
+
+		}	
+	}
+
+	Map<uint32_t,Variant> uniform_defaults;
+	Map<uint32_t,CameraMatrix> uniform_cameras;
+
+
+protected:	
+
+	_FORCE_INLINE_ int _get_uniform(int p_which) const;
+	_FORCE_INLINE_ void _set_conditional(int p_which, bool p_value);
+	
+	void setup(const char** p_conditional_defines, int p_conditional_count,const char** p_uniform_names,int p_uniform_count, const AttributePair* p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs,int p_ubo_pair_count, const Feedback* p_feedback, int p_feedback_count,const char*p_vertex_code, const char *p_fragment_code,int p_vertex_code_start,int p_fragment_code_start);
+	
+	ShaderGLES3();
+public:
+	
+	enum {
+		CUSTOM_SHADER_DISABLED=0
+	};
+
+	GLint get_uniform_location(const String& p_name) const;
+	GLint get_uniform_location(int p_uniform) const;
+	
+	static _FORCE_INLINE_ ShaderGLES3 *get_active() { return active; };
+	bool bind();
+	void unbind();
+	void bind_uniforms();
+
+	
+	inline GLuint get_program() const { return version?version->id:0; }
+	
+	void clear_caches();
+
+	uint32_t create_custom_shader();
+	void set_custom_shader_code(uint32_t p_id,const String& p_vertex, const String& p_vertex_globals,const String& p_fragment,const String& p_p_light,const String& p_fragment_globals,const String& p_uniforms,const Vector<StringName>& p_texture_uniforms,const Vector<CharString> &p_custom_defines);
+	void set_custom_shader(uint32_t p_id);
+	void free_custom_shader(uint32_t p_id);
+
+	void set_uniform_default(int p_idx, const Variant& p_value) {
+
+		if (p_value.get_type()==Variant::NIL) {
+
+			uniform_defaults.erase(p_idx);
+		} else {
+
+			uniform_defaults[p_idx]=p_value;
+		}
+		uniforms_dirty = true;
+	}
+
+	uint32_t get_version() const { return new_conditional_version.version; }
+
+	void set_uniform_camera(int p_idx, const CameraMatrix& p_mat) {
+
+		uniform_cameras[p_idx] = p_mat;
+		uniforms_dirty = true;
+	};
+
+	_FORCE_INLINE_ void set_texture_uniform(int p_idx, const Variant& p_value) {
+
+		ERR_FAIL_COND(!version);
+		ERR_FAIL_INDEX(p_idx,version->texture_uniform_locations.size());
+		_set_uniform_variant( version->texture_uniform_locations[p_idx], p_value );
+	}
+	
+	_FORCE_INLINE_ GLint get_texture_uniform_location(int p_idx) {
+
+		ERR_FAIL_COND_V(!version,-1);
+		ERR_FAIL_INDEX_V(p_idx,version->texture_uniform_locations.size(),-1);
+		return version->texture_uniform_locations[p_idx];
+	}
+
+	virtual void init()=0;
+	void finish();
+
+	void set_base_material_tex_index(int p_idx);
+
+	void add_custom_define(const String& p_define) {
+		custom_defines.push_back(p_define.utf8());
+	}
+
+	virtual ~ShaderGLES3();
+
+};
+
+
+// called a lot, made inline 
+
+
+int ShaderGLES3::_get_uniform(int p_which) const {
+	
+	ERR_FAIL_INDEX_V( p_which, uniform_count,-1 );
+	ERR_FAIL_COND_V( !version, -1 );
+	return version->uniform_location[p_which];
+}
+
+void ShaderGLES3::_set_conditional(int p_which, bool p_value) {
+	
+	ERR_FAIL_INDEX(p_which,conditional_count);
+	if (p_value)
+		new_conditional_version.version|=(1<<p_which);
+	else
+		new_conditional_version.version&=~(1<<p_which);
+}
+
+#endif
+

drivers/gles3/shaders/SCsub

@@ -0,0 +1,22 @@
+Import('env')
+
+if env['BUILDERS'].has_key('GLES3_GLSL'):
+	env.GLES3_GLSL('copy.glsl');
+	env.GLES3_GLSL('resolve.glsl');
+	env.GLES3_GLSL('canvas.glsl');
+	env.GLES3_GLSL('canvas_shadow.glsl');
+	env.GLES3_GLSL('scene.glsl');
+	env.GLES3_GLSL('cubemap_filter.glsl');
+	env.GLES3_GLSL('cube_to_dp.glsl');
+	env.GLES3_GLSL('blend_shape.glsl');
+	env.GLES3_GLSL('screen_space_reflection.glsl');
+	env.GLES3_GLSL('effect_blur.glsl');
+	env.GLES3_GLSL('subsurf_scattering.glsl');
+	env.GLES3_GLSL('ssao.glsl');
+	env.GLES3_GLSL('ssao_minify.glsl');
+	env.GLES3_GLSL('ssao_blur.glsl');
+	env.GLES3_GLSL('exposure.glsl');
+	env.GLES3_GLSL('tonemap.glsl');
+	env.GLES3_GLSL('particles.glsl');
+
+

drivers/gles3/shaders/blend_shape.glsl

@@ -0,0 +1,197 @@
+[vertex]
+
+
+/*
+from VisualServer:
+
+ARRAY_VERTEX=0,
+ARRAY_NORMAL=1,
+ARRAY_TANGENT=2,
+ARRAY_COLOR=3,
+ARRAY_TEX_UV=4,
+ARRAY_TEX_UV2=5,
+ARRAY_BONES=6,
+ARRAY_WEIGHTS=7,
+ARRAY_INDEX=8,
+*/
+
+#ifdef USE_2D_VERTEX
+#define VFORMAT vec2
+#else
+#define VFORMAT vec3
+#endif
+
+/* INPUT ATTRIBS */
+
+layout(location=0) in highp VFORMAT vertex_attrib;
+layout(location=1) in vec3 normal_attrib;
+
+#ifdef ENABLE_TANGENT
+layout(location=2) in vec4 tangent_attrib;
+#endif
+
+#ifdef ENABLE_COLOR
+layout(location=3) in vec4 color_attrib;
+#endif
+
+#ifdef ENABLE_UV
+layout(location=4) in vec2 uv_attrib;
+#endif
+
+#ifdef ENABLE_UV2
+layout(location=5) in vec2 uv2_attrib;
+#endif
+
+#ifdef ENABLE_SKELETON
+layout(location=6) in ivec4 bone_attrib;
+layout(location=7) in vec4 weight_attrib;
+#endif
+
+/* BLEND ATTRIBS */
+
+#ifdef ENABLE_BLEND
+
+layout(location=8) in highp VFORMAT vertex_attrib_blend;
+layout(location=9) in vec3 normal_attrib_blend;
+
+#ifdef ENABLE_TANGENT
+layout(location=10) in vec4 tangent_attrib_blend;
+#endif
+
+#ifdef ENABLE_COLOR
+layout(location=11) in vec4 color_attrib_blend;
+#endif
+
+#ifdef ENABLE_UV
+layout(location=12) in vec2 uv_attrib_blend;
+#endif
+
+#ifdef ENABLE_UV2
+layout(location=13) in vec2 uv2_attrib_blend;
+#endif
+
+#ifdef ENABLE_SKELETON
+layout(location=14) in ivec4 bone_attrib_blend;
+layout(location=15) in vec4 weight_attrib_blend;
+#endif
+
+#endif
+
+/* OUTPUTS */
+
+out VFORMAT vertex_out; //tfb:
+
+#ifdef ENABLE_NORMAL
+out vec3 normal_out; //tfb:ENABLE_NORMAL
+#endif
+
+#ifdef ENABLE_TANGENT
+out vec4 tangent_out; //tfb:ENABLE_TANGENT
+#endif
+
+#ifdef ENABLE_COLOR
+out vec4 color_out; //tfb:ENABLE_COLOR
+#endif
+
+#ifdef ENABLE_UV
+out vec2 uv_out; //tfb:ENABLE_UV
+#endif
+
+#ifdef ENABLE_UV2
+out vec2 uv2_out; //tfb:ENABLE_UV2
+#endif
+
+#ifdef ENABLE_SKELETON
+out ivec4 bone_out; //tfb:ENABLE_SKELETON
+out vec4 weight_out; //tfb:ENABLE_SKELETON
+#endif
+
+uniform float blend_amount;
+
+void main() {
+
+
+#ifdef ENABLE_BLEND
+
+	vertex_out = vertex_attrib_blend + vertex_attrib * blend_amount;
+
+#ifdef ENABLE_NORMAL
+	normal_out = normal_attrib_blend + normal_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_TANGENT
+
+	tangent_out.xyz = tangent_attrib_blend.xyz + tangent_attrib.xyz * blend_amount;
+	tangent_out.w = tangent_attrib_blend.w; //just copy, no point in blending his
+#endif
+
+#ifdef ENABLE_COLOR
+
+	color_out = color_attrib_blend + color_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_UV
+
+	uv_out = uv_attrib_blend + uv_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_UV2
+
+	uv2_out = uv2_attrib_blend + uv2_attrib * blend_amount;
+#endif
+
+
+#ifdef ENABLE_SKELETON
+
+	bone_out = bone_attrib_blend;
+	weight_out = weight_attrib_blend + weight_attrib * blend_amount;
+#endif
+
+#else //ENABLE_BLEND
+
+
+	vertex_out = vertex_attrib * blend_amount;
+
+#ifdef ENABLE_NORMAL
+	normal_out = normal_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_TANGENT
+
+	tangent_out.xyz = tangent_attrib.xyz * blend_amount;
+	tangent_out.w = tangent_attrib.w; //just copy, no point in blending his
+#endif
+
+#ifdef ENABLE_COLOR
+
+	color_out = color_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_UV
+
+	uv_out = uv_attrib * blend_amount;
+#endif
+
+#ifdef ENABLE_UV2
+
+	uv2_out = uv2_attrib * blend_amount;
+#endif
+
+
+#ifdef ENABLE_SKELETON
+
+	bone_out = bone_attrib;
+	weight_out = weight_attrib * blend_amount;
+#endif
+
+#endif
+	gl_Position = vec4(0.0);
+}
+
+[fragment]
+
+
+void main() {
+
+}
+

drivers/gles3/shaders/canvas.glsl

@@ -0,0 +1,456 @@
+[vertex]
+
+
+layout(location=0) in highp vec2 vertex;
+layout(location=3) in vec4 color_attrib;
+
+#ifdef USE_TEXTURE_RECT
+
+layout(location=1) in highp vec4 dst_rect;
+layout(location=2) in highp vec4 src_rect;
+
+#else
+
+layout(location=4) in highp vec2 uv_attrib;
+
+//skeletn
+#endif
+
+
+layout(std140) uniform CanvasItemData { //ubo:0
+
+	highp mat4 projection_matrix;
+	highp vec4 time;
+};
+
+uniform highp mat4 modelview_matrix;
+uniform highp mat4 extra_matrix;
+
+
+out mediump vec2 uv_interp;
+out mediump vec4 color_interp;
+
+#ifdef USE_LIGHTING
+
+layout(std140) uniform LightData { //ubo:1
+
+	//light matrices
+	highp mat4 light_matrix;
+	highp mat4 light_local_matrix;
+	highp mat4 shadow_matrix;
+	highp vec4 light_color;
+	highp vec4 light_shadow_color;
+	highp vec2 light_pos;
+	highp float shadowpixel_size;
+	highp float shadow_gradient;
+	highp float light_height;
+	highp float light_outside_alpha;
+	highp float shadow_distance_mult;
+};
+
+
+out vec4 light_uv_interp;
+
+#if defined(NORMAL_USED)
+out vec4 local_rot;
+#endif
+
+#ifdef USE_SHADOWS
+out highp vec2 pos;
+#endif
+
+#endif
+
+
+VERTEX_SHADER_GLOBALS
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData { //ubo:2
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+void main() {
+
+	vec4 vertex_color = color_attrib;
+
+
+#ifdef USE_TEXTURE_RECT
+
+
+	uv_interp = src_rect.xy + abs(src_rect.zw) * vertex;
+	highp vec4 outvec = vec4(dst_rect.xy + dst_rect.zw * mix(vertex,vec2(1.0,1.0)-vertex,lessThan(src_rect.zw,vec2(0.0,0.0))),0.0,1.0);
+
+#else
+	uv_interp = uv_attrib;
+	highp vec4 outvec = vec4(vertex,0.0,1.0);
+#endif
+
+
+{
+	vec2 src_vtx=outvec.xy;
+
+VERTEX_SHADER_CODE
+
+}
+
+#if !defined(SKIP_TRANSFORM_USED)
+	outvec = extra_matrix * outvec;
+	outvec = modelview_matrix * outvec;
+#endif
+
+	color_interp = vertex_color;
+
+#ifdef USE_PIXEL_SNAP
+
+	outvec.xy=floor(outvec+0.5);
+#endif
+
+
+	gl_Position = projection_matrix * outvec;
+
+#ifdef USE_LIGHTING
+
+	light_uv_interp.xy = (light_matrix * outvec).xy;
+	light_uv_interp.zw =(light_local_matrix * outvec).xy;
+#ifdef USE_SHADOWS
+	pos=outvec.xy;
+#endif
+
+#if defined(NORMAL_USED)
+	local_rot.xy=normalize( (modelview_matrix * ( extra_matrix * vec4(1.0,0.0,0.0,0.0) )).xy  );
+	local_rot.zw=normalize( (modelview_matrix * ( extra_matrix * vec4(0.0,1.0,0.0,0.0) )).xy  );
+#ifdef USE_TEXTURE_RECT
+	local_rot.xy*=sign(src_rect.z);
+	local_rot.zw*=sign(src_rect.w);
+#endif
+
+#endif
+
+#endif
+
+}
+
+[fragment]
+
+
+
+uniform mediump sampler2D color_texture; // texunit:0
+uniform highp vec2 color_texpixel_size;
+
+in mediump vec2 uv_interp;
+in mediump vec4 color_interp;
+
+
+#if defined(SCREEN_TEXTURE_USED)
+
+uniform sampler2D screen_texture; // texunit:-3
+
+#endif
+
+layout(std140) uniform CanvasItemData {
+
+	highp mat4 projection_matrix;
+	highp vec4 time;
+};
+
+
+#ifdef USE_LIGHTING
+
+layout(std140) uniform LightData {
+
+	highp mat4 light_matrix;
+	highp mat4 light_local_matrix;
+	highp mat4 shadow_matrix;
+	highp vec4 light_color;
+	highp vec4 light_shadow_color;
+	highp vec2 light_pos;
+	highp float shadowpixel_size;
+	highp float shadow_gradient;
+	highp float light_height;
+	highp float light_outside_alpha;
+	highp float shadow_distance_mult;
+};
+
+uniform lowp sampler2D light_texture; // texunit:-1
+in vec4 light_uv_interp;
+
+
+#if defined(NORMAL_USED)
+in vec4 local_rot;
+#endif
+
+#ifdef USE_SHADOWS
+
+uniform highp sampler2D shadow_texture; // texunit:-2
+in highp vec2 pos;
+
+#endif
+
+#endif
+
+uniform mediump vec4 final_modulate;
+
+FRAGMENT_SHADER_GLOBALS
+
+
+layout(location=0) out mediump vec4 frag_color;
+
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData {
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+void main() {
+
+	vec4 color = color_interp;
+#if defined(NORMAL_USED)
+	vec3 normal = vec3(0.0,0.0,1.0);
+#endif
+
+#if !defined(COLOR_USED)
+//default behavior, texture by color
+
+#ifdef USE_DISTANCE_FIELD
+	const float smoothing = 1.0/32.0;
+	float distance = texture(color_texture, uv_interp).a;
+	color.a = smoothstep(0.5 - smoothing, 0.5 + smoothing, distance) * color.a;
+#else
+	color *= texture( color_texture,  uv_interp );
+
+#endif
+
+#endif
+
+#if defined(ENABLE_SCREEN_UV)
+	vec2 screen_uv = gl_FragCoord.xy*screen_uv_mult;
+#endif
+
+
+{
+	float normal_depth=1.0;
+
+#if defined(NORMALMAP_USED)
+	vec3 normal_map=vec3(0.0,0.0,1.0);
+#endif
+
+FRAGMENT_SHADER_CODE
+
+#if defined(NORMALMAP_USED)
+	normal = mix(vec3(0.0,0.0,1.0), normal_map * vec3(2.0,-2.0,1.0) - vec3( 1.0, -1.0, 0.0 ), normal_depth );
+#endif
+
+}
+#ifdef DEBUG_ENCODED_32
+	highp float enc32 = dot( color,highp vec4(1.0 / (256.0 * 256.0 * 256.0),1.0 / (256.0 * 256.0),1.0 / 256.0,1)  );
+	color = vec4(vec3(enc32),1.0);
+#endif
+
+
+	color*=final_modulate;
+
+
+
+
+#ifdef USE_LIGHTING
+
+	vec2 light_vec = light_uv_interp.zw;; //for shadow and normal mapping
+
+#if defined(NORMAL_USED)
+	normal.xy =  mat2(local_rot.xy,local_rot.zw) * normal.xy;
+#endif
+
+	float att=1.0;
+
+	vec2 light_uv = light_uv_interp.xy;
+	vec4 light = texture(light_texture,light_uv) * light_color;
+#if defined(SHADOW_COLOR_USED)
+	vec4 shadow_color=vec4(0.0,0.0,0.0,0.0);
+#endif
+
+	if (any(lessThan(light_uv_interp.xy,vec2(0.0,0.0))) || any(greaterThanEqual(light_uv_interp.xy,vec2(1.0,1.0)))) {
+		color.a*=light_outside_alpha; //invisible
+
+	} else {
+
+#if defined(USE_LIGHT_SHADER_CODE)
+//light is written by the light shader
+		{
+			vec4 light_out=light*color;
+LIGHT_SHADER_CODE
+			color=light_out;
+		}
+
+#else
+
+#if defined(NORMAL_USED)
+		vec3 light_normal = normalize(vec3(light_vec,-light_height));
+		light*=max(dot(-light_normal,normal),0.0);
+#endif
+
+		color*=light;
+/*
+#ifdef USE_NORMAL
+	color.xy=local_rot.xy;//normal.xy;
+	color.zw=vec2(0.0,1.0);
+#endif
+*/
+
+//light shader code
+#endif
+
+
+#ifdef USE_SHADOWS
+
+		float angle_to_light = -atan(light_vec.x,light_vec.y);
+		float PI = 3.14159265358979323846264;
+		/*int i = int(mod(floor((angle_to_light+7.0*PI/6.0)/(4.0*PI/6.0))+1.0, 3.0)); // +1 pq os indices estao em ordem 2,0,1 nos arrays
+		float ang*/
+
+		float su,sz;
+
+		float abs_angle = abs(angle_to_light);
+		vec2 point;
+		float sh;
+		if (abs_angle<45.0*PI/180.0) {
+			point = light_vec;
+			sh=0.0+(1.0/8.0);
+		} else if (abs_angle>135.0*PI/180.0) {
+			point = -light_vec;
+			sh = 0.5+(1.0/8.0);
+		} else if (angle_to_light>0.0) {
+
+			point = vec2(light_vec.y,-light_vec.x);
+			sh = 0.25+(1.0/8.0);
+		} else {
+
+			point = vec2(-light_vec.y,light_vec.x);
+			sh = 0.75+(1.0/8.0);
+
+		}
+
+
+		highp vec4 s = shadow_matrix * vec4(point,0.0,1.0);
+		s.xyz/=s.w;
+		su=s.x*0.5+0.5;
+		sz=s.z*0.5+0.5;
+		//sz=lightlength(light_vec);
+
+		highp float shadow_attenuation=0.0;
+
+#ifdef USE_RGBA_SHADOWS
+
+#define SHADOW_DEPTH(m_tex,m_uv) dot(texture2D((m_tex),(m_uv)),vec4(1.0 / (256.0 * 256.0 * 256.0),1.0 / (256.0 * 256.0),1.0 / 256.0,1)  )
+
+#else
+
+#define SHADOW_DEPTH(m_tex,m_uv) (texture2D((m_tex),(m_uv)).r)
+
+#endif
+
+
+
+#ifdef SHADOW_USE_GRADIENT
+
+#define SHADOW_TEST(m_ofs) { highp float sd = SHADOW_DEPTH(shadow_texture,vec2(m_ofs,sh)); shadow_attenuation+=1.0-smoothstep(sd,sd+shadow_gradient,sz); }
+
+#else
+
+#define SHADOW_TEST(m_ofs) { highp float sd = SHADOW_DEPTH(shadow_texture,vec2(m_ofs,sh)); shadow_attenuation+=step(sz,sd); }
+
+#endif
+
+
+#ifdef SHADOW_FILTER_NEAREST
+
+		SHADOW_TEST(su+shadowpixel_size);
+
+#endif
+
+
+#ifdef SHADOW_FILTER_PCF3
+
+		SHADOW_TEST(su+shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su-shadowpixel_size);
+		shadow_attenuation/=3.0;
+
+#endif
+
+
+#ifdef SHADOW_FILTER_PCF5
+
+		SHADOW_TEST(su+shadowpixel_size*3.0);
+		SHADOW_TEST(su+shadowpixel_size*2.0);
+		SHADOW_TEST(su+shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su-shadowpixel_size);
+		SHADOW_TEST(su-shadowpixel_size*2.0);
+		SHADOW_TEST(su-shadowpixel_size*3.0);
+		shadow_attenuation/=5.0;
+
+#endif
+
+
+#ifdef SHADOW_FILTER_PCF9
+
+		SHADOW_TEST(su+shadowpixel_size*4.0);
+		SHADOW_TEST(su+shadowpixel_size*3.0);
+		SHADOW_TEST(su+shadowpixel_size*2.0);
+		SHADOW_TEST(su+shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su-shadowpixel_size);
+		SHADOW_TEST(su-shadowpixel_size*2.0);
+		SHADOW_TEST(su-shadowpixel_size*3.0);
+		SHADOW_TEST(su-shadowpixel_size*4.0);
+		shadow_attenuation/=9.0;
+
+#endif
+
+#ifdef SHADOW_FILTER_PCF13
+
+		SHADOW_TEST(su+shadowpixel_size*6.0);
+		SHADOW_TEST(su+shadowpixel_size*5.0);
+		SHADOW_TEST(su+shadowpixel_size*4.0);
+		SHADOW_TEST(su+shadowpixel_size*3.0);
+		SHADOW_TEST(su+shadowpixel_size*2.0);
+		SHADOW_TEST(su+shadowpixel_size);
+		SHADOW_TEST(su);
+		SHADOW_TEST(su-shadowpixel_size);
+		SHADOW_TEST(su-shadowpixel_size*2.0);
+		SHADOW_TEST(su-shadowpixel_size*3.0);
+		SHADOW_TEST(su-shadowpixel_size*4.0);
+		SHADOW_TEST(su-shadowpixel_size*5.0);
+		SHADOW_TEST(su-shadowpixel_size*6.0);
+		shadow_attenuation/=13.0;
+
+#endif
+
+
+#if defined(SHADOW_COLOR_USED)
+	color=mix(shadow_color,color,shadow_attenuation);
+#else
+	//color*=shadow_attenuation;
+	color=mix(light_shadow_color,color,shadow_attenuation);
+#endif
+//use shadows
+#endif
+	}
+
+//use lighting
+#endif
+//	color.rgb*=color.a;
+	frag_color = color;
+
+}
+

drivers/gles3/shaders/canvas_shadow.glsl

@@ -0,0 +1,49 @@
+[vertex]
+
+
+
+uniform highp mat4 projection_matrix;
+uniform highp mat4 light_matrix;
+uniform highp mat4 world_matrix;
+uniform highp float distance_norm;
+
+layout(location=0) in highp vec3 vertex;
+
+out highp vec4 position_interp;
+
+void main() {
+
+	gl_Position = projection_matrix * (light_matrix * (world_matrix *  vec4(vertex,1.0)));
+	position_interp=gl_Position;
+}
+
+[fragment]
+
+in highp vec4 position_interp;
+
+#ifdef USE_RGBA_SHADOWS
+
+layout(location=0) out lowp vec4 distance_buf;
+
+#else
+
+layout(location=0) out highp float distance_buf;
+
+#endif
+
+void main() {
+
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0;//bias;
+
+#ifdef USE_RGBA_SHADOWS
+
+	highp vec4 comp = fract(depth * vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0));
+	comp -= comp.xxyz * vec4(0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
+	distance_buf=comp;
+#else
+
+	distance_buf=depth;
+
+#endif
+}
+

drivers/gles3/shaders/copy.glsl

@@ -0,0 +1,105 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+#ifdef USE_CUBEMAP
+layout(location=4) in vec3 cube_in;
+#else
+layout(location=4) in vec2 uv_in;
+#endif
+layout(location=5) in vec2 uv2_in;
+
+#ifdef USE_CUBEMAP
+out vec3 cube_interp;
+#else
+out vec2 uv_interp;
+#endif
+
+out vec2 uv2_interp;
+
+void main() {
+
+#ifdef USE_CUBEMAP
+	cube_interp = cube_in;
+#else
+	uv_interp = uv_in;
+#endif
+	uv2_interp = uv2_in;
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+
+#ifdef USE_CUBEMAP
+in vec3 cube_interp;
+uniform samplerCube source_cube; //texunit:0
+#else
+in vec2 uv_interp;
+uniform sampler2D source; //texunit:0
+#endif
+
+
+float sRGB_gamma_correct(float c){
+    float a = 0.055;
+    if(c < 0.0031308)
+	return 12.92*c;
+    else
+	return (1.0+a)*pow(c, 1.0/2.4) - a;
+}
+
+
+uniform float stuff;
+uniform vec2 pixel_size;
+
+in vec2 uv2_interp;
+
+layout(location = 0) out vec4 frag_color;
+
+void main() {
+
+	//vec4 color = color_interp;
+
+#ifdef USE_CUBEMAP
+	vec4 color = texture( source_cube,  normalize(cube_interp) );
+
+#else
+	vec4 color = texture( source,  uv_interp );
+#endif
+
+#ifdef LINEAR_TO_SRGB
+	//regular Linear -> SRGB conversion
+	vec3 a = vec3(0.055);
+	color.rgb = mix( (vec3(1.0)+a)*pow(color.rgb,vec3(1.0/2.4))-a , 12.92*color.rgb , lessThan(color.rgb,vec3(0.0031308)));
+#endif
+
+#ifdef DEBUG_GRADIENT
+	color.rg=uv_interp;
+	color.b=0.0;
+#endif
+
+#ifdef DISABLE_ALPHA
+	color.a=1.0;
+#endif
+
+
+#ifdef GAUSSIAN_HORIZONTAL
+	color*=0.38774;
+	color+=texture( source,  uv_interp+vec2( 1.0, 0.0)*pixel_size )*0.24477;
+	color+=texture( source,  uv_interp+vec2( 2.0, 0.0)*pixel_size )*0.06136;
+	color+=texture( source,  uv_interp+vec2(-1.0, 0.0)*pixel_size )*0.24477;
+	color+=texture( source,  uv_interp+vec2(-2.0, 0.0)*pixel_size )*0.06136;
+#endif
+
+#ifdef GAUSSIAN_VERTICAL
+	color*=0.38774;
+	color+=texture( source,  uv_interp+vec2( 0.0, 1.0)*pixel_size )*0.24477;
+	color+=texture( source,  uv_interp+vec2( 0.0, 2.0)*pixel_size )*0.06136;
+	color+=texture( source,  uv_interp+vec2( 0.0,-1.0)*pixel_size )*0.24477;
+	color+=texture( source,  uv_interp+vec2( 0.0,-2.0)*pixel_size )*0.06136;
+#endif
+
+
+	frag_color = color;
+}
+

drivers/gles3/shaders/cube_to_dp.glsl

@@ -0,0 +1,79 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+
+void main() {
+
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+
+uniform highp samplerCube source_cube; //texunit:0
+in vec2 uv_interp;
+
+uniform bool z_flip;
+uniform highp float z_far;
+uniform highp float z_near;
+uniform highp float bias;
+
+void main() {
+
+	highp vec3 normal = vec3( uv_interp * 2.0 - 1.0, 0.0 );
+/*
+	if(z_flip) {
+		normal.z = 0.5 - 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+	} else {
+		normal.z = -0.5 + 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+	}
+*/
+
+	//normal.z = sqrt(1.0-dot(normal.xy,normal.xy));
+	//normal.xy*=1.0+normal.z;
+
+	normal.z = 0.5 - 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+	normal = normalize(normal);
+
+/*
+	normal.z=0.5;
+	normal=normalize(normal);
+*/
+	if (!z_flip) {
+		normal.z=-normal.z;
+	}
+
+	//normal = normalize(vec3( uv_interp * 2.0 - 1.0, 1.0 ));
+	float depth = texture(source_cube,normal).r;
+
+	// absolute values for direction cosines, bigger value equals closer to basis axis
+	vec3 unorm = abs(normal);
+
+	if ( (unorm.x >= unorm.y) && (unorm.x >= unorm.z) ) {
+	    // x code
+	    unorm = normal.x > 0.0 ?  vec3( 1.0, 0.0, 0.0 ) : vec3( -1.0, 0.0, 0.0 ) ;
+	} else if ( (unorm.y > unorm.x) && (unorm.y >= unorm.z) ) {
+	    // y code
+	    unorm = normal.y > 0.0 ?  vec3( 0.0, 1.0, 0.0 ) :  vec3( 0.0, -1.0, 0.0 ) ;
+	} else if ( (unorm.z > unorm.x) && (unorm.z > unorm.y) ) {
+	    // z code
+	    unorm = normal.z > 0.0 ?  vec3( 0.0, 0.0, 1.0 ) :  vec3( 0.0, 0.0, -1.0 ) ;
+	} else {
+	    // oh-no we messed up code
+	    // has to be
+	    unorm = vec3( 1.0, 0.0, 0.0 );
+	}
+
+	float depth_fix = 1.0 / dot(normal,unorm);
+
+
+	depth = 2.0 * depth - 1.0;
+	float linear_depth = 2.0 * z_near * z_far / (z_far + z_near - depth * (z_far - z_near));
+	gl_FragDepth = (linear_depth*depth_fix+bias) / z_far;
+}
+

drivers/gles3/shaders/cubemap_filter.glsl

@@ -0,0 +1,218 @@
+[vertex]
+
+
+layout(location=0) in highp vec2 vertex;
+
+layout(location=4) in highp vec2 uv;
+
+out highp vec2 uv_interp;
+
+void main() {
+
+	uv_interp=uv;
+	gl_Position=vec4(vertex,0,1);
+}
+
+[fragment]
+
+
+precision highp float;
+precision highp int;
+
+
+uniform samplerCube source_cube; //texunit:0
+uniform int face_id;
+uniform float roughness;
+in highp vec2 uv_interp;
+
+
+layout(location = 0) out vec4 frag_color;
+
+
+#define M_PI 3.14159265359
+
+
+vec3 texelCoordToVec(vec2 uv, int faceID)
+{
+    mat3 faceUvVectors[6];
+/*
+    // -x
+    faceUvVectors[1][0] = vec3(0.0, 0.0, 1.0);  // u -> +z
+    faceUvVectors[1][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[1][2] = vec3(-1.0, 0.0, 0.0); // -x face
+
+    // +x
+    faceUvVectors[0][0] = vec3(0.0, 0.0, -1.0); // u -> -z
+    faceUvVectors[0][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[0][2] = vec3(1.0, 0.0, 0.0);  // +x face
+
+    // -y
+    faceUvVectors[3][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[3][1] = vec3(0.0, 0.0, -1.0); // v -> -z
+    faceUvVectors[3][2] = vec3(0.0, -1.0, 0.0); // -y face
+
+    // +y
+    faceUvVectors[2][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[2][1] = vec3(0.0, 0.0, 1.0);  // v -> +z
+    faceUvVectors[2][2] = vec3(0.0, 1.0, 0.0);  // +y face
+
+    // -z
+    faceUvVectors[5][0] = vec3(-1.0, 0.0, 0.0); // u -> -x
+    faceUvVectors[5][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[5][2] = vec3(0.0, 0.0, -1.0); // -z face
+
+    // +z
+    faceUvVectors[4][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[4][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[4][2] = vec3(0.0, 0.0, 1.0);  // +z face
+*/
+
+    // -x
+    faceUvVectors[0][0] = vec3(0.0, 0.0, 1.0);  // u -> +z
+    faceUvVectors[0][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[0][2] = vec3(-1.0, 0.0, 0.0); // -x face
+
+    // +x
+    faceUvVectors[1][0] = vec3(0.0, 0.0, -1.0); // u -> -z
+    faceUvVectors[1][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[1][2] = vec3(1.0, 0.0, 0.0);  // +x face
+
+    // -y
+    faceUvVectors[2][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[2][1] = vec3(0.0, 0.0, -1.0); // v -> -z
+    faceUvVectors[2][2] = vec3(0.0, -1.0, 0.0); // -y face
+
+    // +y
+    faceUvVectors[3][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[3][1] = vec3(0.0, 0.0, 1.0);  // v -> +z
+    faceUvVectors[3][2] = vec3(0.0, 1.0, 0.0);  // +y face
+
+    // -z
+    faceUvVectors[4][0] = vec3(-1.0, 0.0, 0.0); // u -> -x
+    faceUvVectors[4][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[4][2] = vec3(0.0, 0.0, -1.0); // -z face
+
+    // +z
+    faceUvVectors[5][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+    faceUvVectors[5][1] = vec3(0.0, -1.0, 0.0); // v -> -y
+    faceUvVectors[5][2] = vec3(0.0, 0.0, 1.0);  // +z face
+
+    // out = u * s_faceUv[0] + v * s_faceUv[1] + s_faceUv[2].
+    vec3 result = (faceUvVectors[faceID][0] * uv.x) + (faceUvVectors[faceID][1] * uv.y) + faceUvVectors[faceID][2];
+    return normalize(result);
+}
+
+vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N)
+{
+	float a = Roughness * Roughness; // DISNEY'S ROUGHNESS [see Burley'12 siggraph]
+
+	// Compute distribution direction
+	float Phi = 2.0 * M_PI * Xi.x;
+	float CosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y));
+	float SinTheta = sqrt(1.0 - CosTheta * CosTheta);
+
+	// Convert to spherical direction
+	vec3 H;
+	H.x = SinTheta * cos(Phi);
+	H.y = SinTheta * sin(Phi);
+	H.z = CosTheta;
+
+	vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+	vec3 TangentX = normalize(cross(UpVector, N));
+	vec3 TangentY = cross(N, TangentX);
+
+	// Tangent to world space
+	return TangentX * H.x + TangentY * H.y + N * H.z;
+}
+
+// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
+float GGX(float NdotV, float a)
+{
+	float k = a / 2.0;
+	return NdotV / (NdotV * (1.0 - k) + k);
+}
+
+// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
+float G_Smith(float a, float nDotV, float nDotL)
+{
+	return GGX(nDotL, a * a) * GGX(nDotV, a * a);
+}
+
+float radicalInverse_VdC(uint bits) {
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
+}
+
+vec2 Hammersley(uint i, uint N) {
+     return vec2(float(i)/float(N), radicalInverse_VdC(i));
+}
+
+
+
+#ifdef LOW_QUALITY
+
+#define SAMPLE_COUNT 64u
+
+#else
+
+#define SAMPLE_COUNT 512u
+
+#endif
+
+uniform bool z_flip;
+
+void main() {
+
+#ifdef USE_DUAL_PARABOLOID
+
+	vec3 N = vec3( uv_interp * 2.0 - 1.0, 0.0 );
+	N.z = 0.5 - 0.5*((N.x * N.x) + (N.y * N.y));
+	N = normalize(N);
+
+	if (!z_flip) {
+		N.y=-N.y; //y is flipped to improve blending between both sides
+	} else {
+		N.z=-N.z;
+	}
+
+
+#else
+	vec2 uv         = (uv_interp * 2.0) - 1.0;
+	vec3 N          = texelCoordToVec(uv, face_id);
+#endif
+	//vec4 color = color_interp;
+
+#ifdef USE_DIRECT_WRITE
+
+	frag_color=vec4(texture(N,source_cube).rgb,1.0);
+
+#else
+
+	vec4 sum = vec4(0.0, 0.0, 0.0, 0.0);
+
+	for(uint sampleNum = 0u; sampleNum < SAMPLE_COUNT; sampleNum++) {
+		vec2 xi = Hammersley(sampleNum, SAMPLE_COUNT);
+
+		vec3 H  = ImportanceSampleGGX( xi, roughness, N );
+		vec3 V  = N;
+		vec3 L  = normalize(2.0 * dot( V, H ) * H - V);
+
+		float ndotl = clamp(dot(N, L),0.0,1.0);
+
+		if (ndotl>0.0) {
+			sum.rgb += textureLod(source_cube, H, 0.0).rgb *ndotl;
+			sum.a += ndotl;
+		}
+	}
+	sum /= sum.a;
+
+	frag_color = vec4(sum.rgb, 1.0);
+
+#endif
+
+}
+

drivers/gles3/shaders/effect_blur.glsl

@@ -0,0 +1,278 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+
+
+void main() {
+
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+
+in vec2 uv_interp;
+uniform sampler2D source_color; //texunit:0
+
+#ifdef SSAO_MERGE
+uniform sampler2D source_ssao; //texunit:1
+#endif
+
+uniform float lod;
+uniform vec2 pixel_size;
+
+
+layout(location = 0) out vec4 frag_color;
+
+#ifdef SSAO_MERGE
+
+uniform vec4 ssao_color;
+
+#endif
+
+#if defined (GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
+
+uniform float glow_strength;
+
+#endif
+
+#if defined(DOF_FAR_BLUR) || defined (DOF_NEAR_BLUR)
+
+#ifdef DOF_QUALITY_LOW
+const int dof_kernel_size=5;
+const int dof_kernel_from=2;
+const float dof_kernel[5] = float[] (0.153388,0.221461,0.250301,0.221461,0.153388);
+#endif
+
+#ifdef DOF_QUALITY_MEDIUM
+const int dof_kernel_size=11;
+const int dof_kernel_from=5;
+const float dof_kernel[11] = float[] (0.055037,0.072806,0.090506,0.105726,0.116061,0.119726,0.116061,0.105726,0.090506,0.072806,0.055037);
+
+#endif
+
+#ifdef DOF_QUALITY_HIGH
+const int dof_kernel_size=21;
+const int dof_kernel_from=10;
+const float dof_kernel[21] = float[] (0.028174,0.032676,0.037311,0.041944,0.046421,0.050582,0.054261,0.057307,0.059587,0.060998,0.061476,0.060998,0.059587,0.057307,0.054261,0.050582,0.046421,0.041944,0.037311,0.032676,0.028174);
+#endif
+
+uniform sampler2D dof_source_depth; //texunit:1
+uniform float dof_begin;
+uniform float dof_end;
+uniform vec2 dof_dir;
+uniform float dof_radius;
+
+#ifdef DOF_NEAR_BLUR_MERGE
+
+uniform sampler2D source_dof_original; //texunit:2
+#endif
+
+#endif
+
+
+#ifdef GLOW_FIRST_PASS
+
+uniform float exposure;
+uniform float white;
+
+#ifdef GLOW_USE_AUTO_EXPOSURE
+
+uniform highp sampler2D source_auto_exposure; //texunit:1
+uniform highp float auto_exposure_grey;
+
+#endif
+
+uniform float glow_bloom;
+uniform float glow_hdr_treshold;
+uniform float glow_hdr_scale;
+
+#endif
+
+uniform float camera_z_far;
+uniform float camera_z_near;
+
+void main() {
+
+
+
+#ifdef GAUSSIAN_HORIZONTAL
+	vec2 pix_size = pixel_size;
+	pix_size*=0.5; //reading from larger buffer, so use more samples
+	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.214607;
+	color+=textureLod( source_color,  uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.189879;
+	color+=textureLod( source_color,  uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.157305;
+	color+=textureLod( source_color,  uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.071303;
+	color+=textureLod( source_color,  uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.189879;
+	color+=textureLod( source_color,  uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.157305;
+	color+=textureLod( source_color,  uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.071303;
+	frag_color = color;
+#endif
+
+#ifdef GAUSSIAN_VERTICAL
+	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pixel_size,lod )*0.38774;
+	color+=textureLod( source_color,  uv_interp+vec2( 0.0, 1.0)*pixel_size,lod )*0.24477;
+	color+=textureLod( source_color,  uv_interp+vec2( 0.0, 2.0)*pixel_size,lod )*0.06136;
+	color+=textureLod( source_color,  uv_interp+vec2( 0.0,-1.0)*pixel_size,lod )*0.24477;
+	color+=textureLod( source_color,  uv_interp+vec2( 0.0,-2.0)*pixel_size,lod )*0.06136;
+	frag_color = color;
+#endif
+
+//glow uses larger sigma for a more rounded blur effect
+
+#ifdef GLOW_GAUSSIAN_HORIZONTAL
+	vec2 pix_size = pixel_size;
+	pix_size*=0.5; //reading from larger buffer, so use more samples
+	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.174938;
+	color+=textureLod( source_color,  uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.165569;
+	color+=textureLod( source_color,  uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.140367;
+	color+=textureLod( source_color,  uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.106595;
+	color+=textureLod( source_color,  uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.165569;
+	color+=textureLod( source_color,  uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.140367;
+	color+=textureLod( source_color,  uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.106595;
+	color*=glow_strength;
+	frag_color = color;
+#endif
+
+#ifdef GLOW_GAUSSIAN_VERTICAL
+	vec4 color =textureLod( source_color,  uv_interp+vec2(0.0, 0.0)*pixel_size,lod )*0.288713;
+	color+=textureLod( source_color,  uv_interp+vec2(0.0, 1.0)*pixel_size,lod )*0.233062;
+	color+=textureLod( source_color,  uv_interp+vec2(0.0, 2.0)*pixel_size,lod )*0.122581;
+	color+=textureLod( source_color,  uv_interp+vec2(0.0,-1.0)*pixel_size,lod )*0.233062;
+	color+=textureLod( source_color,  uv_interp+vec2(0.0,-2.0)*pixel_size,lod )*0.122581;
+	color*=glow_strength;
+	frag_color = color;
+#endif
+
+#ifdef DOF_FAR_BLUR
+
+	vec4 color_accum = vec4(0.0);
+
+	float depth = textureLod( dof_source_depth, uv_interp, 0.0).r;
+	depth = depth * 2.0 - 1.0;
+	depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+
+	float amount = smoothstep(dof_begin,dof_end,depth);
+	float k_accum=0.0;
+
+	for(int i=0;i<dof_kernel_size;i++) {
+
+		int int_ofs = i-dof_kernel_from;
+		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * amount * dof_radius;
+
+		float tap_k = dof_kernel[i];
+
+		float tap_depth = texture( dof_source_depth, tap_uv, 0.0).r;
+		tap_depth = tap_depth * 2.0 - 1.0;
+		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
+
+		float tap_amount = mix(smoothstep(dof_begin,dof_end,tap_depth),1.0,int_ofs==0);
+		tap_amount*=tap_amount*tap_amount; //prevent undesired glow effect
+
+		vec4 tap_color = textureLod( source_color, tap_uv, 0.0) * tap_k;
+
+		k_accum+=tap_k*tap_amount;
+		color_accum+=tap_color*tap_amount;
+
+
+	}
+
+	if (k_accum>0.0) {
+		color_accum/=k_accum;
+	}
+
+	frag_color = color_accum;///k_accum;
+
+#endif
+
+#ifdef DOF_NEAR_BLUR
+
+	vec4 color_accum = vec4(0.0);
+
+	float max_accum=0;
+
+	for(int i=0;i<dof_kernel_size;i++) {
+
+		int int_ofs = i-dof_kernel_from;
+		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * dof_radius;
+		float ofs_influence = max(0.0,1.0-float(abs(int_ofs))/float(dof_kernel_from));
+
+		float tap_k = dof_kernel[i];
+
+		vec4 tap_color = textureLod( source_color, tap_uv, 0.0);
+
+		float tap_depth = texture( dof_source_depth, tap_uv, 0.0).r;
+		tap_depth = tap_depth * 2.0 - 1.0;
+		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
+		float tap_amount = 1.0-smoothstep(dof_end,dof_begin,tap_depth);
+		tap_amount*=tap_amount*tap_amount; //prevent undesired glow effect
+
+#ifdef DOF_NEAR_FIRST_TAP
+
+		tap_color.a= 1.0-smoothstep(dof_end,dof_begin,tap_depth);
+
+#endif
+
+		max_accum=max(max_accum,tap_amount*ofs_influence);
+
+		color_accum+=tap_color*tap_k;
+
+	}
+
+	color_accum.a=max(color_accum.a,sqrt(max_accum));
+
+
+#ifdef DOF_NEAR_BLUR_MERGE
+
+	vec4 original = textureLod( source_dof_original, uv_interp, 0.0);
+	color_accum = mix(original,color_accum,color_accum.a);
+
+#endif
+
+#ifndef DOF_NEAR_FIRST_TAP
+	//color_accum=vec4(vec3(color_accum.a),1.0);
+#endif
+	frag_color = color_accum;
+
+#endif
+
+
+
+#ifdef GLOW_FIRST_PASS
+
+#ifdef GLOW_USE_AUTO_EXPOSURE
+
+	frag_color/=texelFetch(source_auto_exposure,ivec2(0,0),0).r/auto_exposure_grey;
+#endif
+	frag_color*=exposure;
+
+	float luminance = max(frag_color.r,max(frag_color.g,frag_color.b));
+	float feedback = max( smoothstep(glow_hdr_treshold,glow_hdr_treshold+glow_hdr_scale,luminance), glow_bloom );
+
+	frag_color *= feedback;
+
+#endif
+
+
+#ifdef SIMPLE_COPY
+	vec4 color =textureLod( source_color,  uv_interp,0.0);
+	frag_color = color;
+#endif
+
+#ifdef SSAO_MERGE
+
+	vec4 color =textureLod( source_color,  uv_interp,0.0);
+	float ssao =textureLod( source_ssao,  uv_interp,0.0).r;
+
+	frag_color = vec4( mix(color.rgb,color.rgb*mix(ssao_color.rgb,vec3(1.0),ssao),color.a), 1.0 );
+
+#endif
+
+
+}
+

drivers/gles3/shaders/exposure.glsl

@@ -0,0 +1,98 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+
+
+void main() {
+
+	gl_Position = vertex_attrib;
+
+}
+
+[fragment]
+
+
+uniform highp sampler2D source_exposure; //texunit:0
+
+#ifdef EXPOSURE_BEGIN
+
+uniform highp ivec2 source_render_size;
+uniform highp ivec2 target_size;
+
+#endif
+
+#ifdef EXPOSURE_END
+
+uniform highp sampler2D prev_exposure; //texunit:1
+uniform highp float exposure_adjust;
+uniform highp float min_luminance;
+uniform highp float max_luminance;
+
+#endif
+
+layout(location = 0) out highp float exposure;
+
+
+
+void main() {
+
+
+
+#ifdef EXPOSURE_BEGIN
+
+
+	ivec2 src_pos = ivec2(gl_FragCoord.xy)*source_render_size/target_size;
+
+#if 1
+	//more precise and expensive, but less jittery
+	ivec2 next_pos = ivec2(gl_FragCoord.xy+ivec2(1))*source_render_size/target_size;
+	next_pos = max(next_pos,src_pos+ivec2(1)); //so it at least reads one pixel
+	highp vec3 source_color=vec3(0.0);
+	for(int i=src_pos.x;i<next_pos.x;i++) {
+		for(int j=src_pos.y;j<next_pos.y;j++) {
+			source_color += texelFetch(source_exposure,ivec2(i,j),0).rgb;
+		}
+	}
+
+	source_color/=float( (next_pos.x-src_pos.x)*(next_pos.y-src_pos.y) );
+#else
+	highp vec3 source_color = texelFetch(source_exposure,src_pos,0).rgb;
+
+#endif
+
+	exposure = max(source_color.r,max(source_color.g,source_color.b));
+
+#else
+
+	ivec2 coord = ivec2(gl_FragCoord.xy);
+	exposure  = texelFetch(source_exposure,coord*3+ivec2(0,0),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(1,0),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(2,0),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(0,1),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(1,1),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(2,1),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(0,2),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(1,2),0).r;
+	exposure += texelFetch(source_exposure,coord*3+ivec2(2,2),0).r;
+	exposure *= (1.0/9.0);
+
+#ifdef EXPOSURE_END
+
+#ifdef EXPOSURE_FORCE_SET
+	//will stay as is
+#else
+	highp float prev_lum = texelFetch(prev_exposure,ivec2(0,0),0).r; //1 pixel previous exposure
+	exposure = clamp( prev_lum + (exposure-prev_lum)*exposure_adjust,min_luminance,max_luminance);
+
+#endif //EXPOSURE_FORCE_SET
+
+
+#endif //EXPOSURE_END
+
+#endif //EXPOSURE_BEGIN
+
+
+}
+
+

drivers/gles3/shaders/particles.glsl

@@ -0,0 +1,167 @@
+[vertex]
+
+
+
+layout(location=0) in highp vec4 color;
+layout(location=1) in highp vec4 velocity_active;
+layout(location=2) in highp vec4 custom;
+layout(location=3) in highp vec4 xform_1;
+layout(location=4) in highp vec4 xform_2;
+layout(location=5) in highp vec4 xform_3;
+
+
+struct Attractor {
+
+	vec3 pos;
+	vec3 dir;
+	float radius;
+	float eat_radius;
+	float strength;
+	float attenuation;
+};
+
+#define MAX_ATTRACTORS 64
+
+uniform mat4 origin;
+uniform float system_phase;
+uniform float prev_system_phase;
+uniform float total_particles;
+uniform float explosiveness;
+uniform vec4 time;
+uniform float delta;
+uniform vec3 gravity;
+uniform int attractor_count;
+uniform Attractor attractors[MAX_ATTRACTORS];
+
+
+out highp vec4 out_color; //tfb:
+out highp vec4 out_velocity_active; //tfb:
+out highp vec4 out_custom; //tfb:
+out highp vec4 out_xform_1; //tfb:
+out highp vec4 out_xform_2; //tfb:
+out highp vec4 out_xform_3; //tfb:
+
+VERTEX_SHADER_GLOBALS
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData { //ubo:0
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+void main() {
+
+	bool apply_forces=true;
+	bool apply_velocity=true;
+
+	float mass = 1.0;
+
+	float restart_phase = float(gl_InstanceID)/total_particles;
+	restart_phase*= explosiveness;
+	bool restart=false;
+	bool active = out_velocity_active.a > 0.5;
+
+	if (system_phase > prev_system_phase) {
+		restart = prev_system_phase < restart_phase && system_phase >= restart_phase;
+	} else {
+		restart = prev_system_phase < restart_phase || system_phase >= restart_phase;
+	}
+
+	if (restart) {
+		active=true;
+	}
+
+	out_color=color;
+	out_velocity_active=velocity_active;
+	out_custom=custom;
+
+	mat4 xform = transpose(mat4(xform_1,xform_2,xform_3,vec4(vec3(0.0),1.0)));
+
+
+	out_rot_active=rot_active;
+
+	if (active) {
+		//execute shader
+
+		{
+			VERTEX_SHADER_CODE
+		}
+
+#if !defined(DISABLE_FORCE)
+
+		{
+
+			vec3 force = gravity;
+			for(int i=0;i<attractor_count;i++) {
+
+				vec3 rel_vec = out_pos_lifetime.xyz - attractors[i].pos;
+				float dist = rel_vec.length();
+				if (attractors[i].radius < dist)
+					continue;
+				if (attractors[i].eat_radius>0 &&  attractors[i].eat_radius > dist) {
+					out_velocity_active.a=0.0;
+				}
+
+				rel_vec = normalize(rel_vec);
+
+				float attenuation = pow(dist / attractors[i].radius,attractors[i].attenuation);
+
+				if (attractors[i].dir==vec3(0.0)) {
+					//towards center
+					force+=attractors[i].strength * rel_vec * attenuation * mass;
+				} else {
+					force+=attractors[i].strength * attractors[i].dir * attenuation *mass;
+
+				}
+			}
+
+			out_velocity_seed.xyz += force * delta;
+		}
+#endif
+
+#if !defined(DISABLE_VELOCITY)
+
+		{
+
+			out_pos_lifetime.xyz += out_velocity_seed.xyz * delta;
+		}
+#endif
+	}
+
+	xform = transpose(xform);
+
+	out_velocity_active.a = mix(0.0,1.0,active);
+
+	out_xform_1 = xform[0];
+	out_xform_2 = xform[1];
+	out_xform_3 = xform[2];
+
+
+}
+
+[fragment]
+
+//any code here is never executed, stuff is filled just so it works
+
+FRAGMENT_SHADER_GLOBALS
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData {
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+void main() {
+
+	{
+		FRAGMENT_SHADER_CODE
+	}
+}

drivers/gles3/shaders/resolve.glsl

@@ -0,0 +1,41 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+
+
+void main() {
+
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+
+in vec2 uv_interp;
+uniform sampler2D source_specular; //texunit:0
+uniform sampler2D source_ssr; //texunit:1
+
+uniform float stuff;
+
+in vec2 uv2_interp;
+
+layout(location = 0) out vec4 frag_color;
+
+void main() {
+
+	vec4 specular = texture( source_specular,  uv_interp );
+
+#ifdef USE_SSR
+
+	vec4 ssr = textureLod(source_ssr,uv_interp,0.0);
+	specular.rgb = mix(specular.rgb,ssr.rgb*specular.a,ssr.a);
+#endif
+
+	frag_color = vec4(specular.rgb,1.0);
+}
+

drivers/gles3/shaders/scene.glsl

@@ -0,0 +1,1432 @@
+[vertex]
+
+
+/*
+from VisualServer:
+
+ARRAY_VERTEX=0,
+ARRAY_NORMAL=1,
+ARRAY_TANGENT=2,
+ARRAY_COLOR=3,
+ARRAY_TEX_UV=4,
+ARRAY_TEX_UV2=5,
+ARRAY_BONES=6,
+ARRAY_WEIGHTS=7,
+ARRAY_INDEX=8,
+*/
+
+//hack to use uv if no uv present so it works with lightmap
+
+
+/* INPUT ATTRIBS */
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=1) in vec3 normal_attrib;
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+layout(location=2) in vec4 tangent_attrib;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+layout(location=3) in vec4 color_attrib;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+layout(location=4) in vec2 uv_attrib;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+layout(location=5) in vec2 uv2_attrib;
+#endif
+
+uniform float normal_mult;
+
+#ifdef USE_SKELETON
+layout(location=6) in ivec4 bone_indices; // attrib:6
+layout(location=7) in vec4 bone_weights; // attrib:7
+#endif
+
+#ifdef USE_INSTANCING
+
+layout(location=8) in highp vec4 instance_xform0;
+layout(location=9) in highp vec4 instance_xform1;
+layout(location=10) in highp vec4 instance_xform2;
+layout(location=11) in lowp vec4 instance_color;
+
+#endif
+
+layout(std140) uniform SceneData { //ubo:0
+
+	highp mat4 projection_matrix;
+	highp mat4 camera_inverse_matrix;
+	highp mat4 camera_matrix;
+	highp vec4 time;
+
+	highp vec4 ambient_light_color;
+	highp vec4 bg_color;
+	float ambient_energy;
+	float bg_energy;
+
+	float shadow_z_offset;
+	float shadow_z_slope_scale;
+	float shadow_dual_paraboloid_render_zfar;
+	float shadow_dual_paraboloid_render_side;
+
+	vec2 shadow_atlas_pixel_size;
+	vec2 directional_shadow_pixel_size;
+
+	float reflection_multiplier;
+	float subsurface_scatter_width;
+	float ambient_occlusion_affect_light;
+
+};
+
+uniform highp mat4 world_transform;
+
+#ifdef USE_LIGHT_DIRECTIONAL
+
+layout(std140) uniform DirectionalLightData { //ubo:3
+
+	highp vec4 light_pos_inv_radius;
+	mediump vec4 light_direction_attenuation;
+	mediump vec4 light_color_energy;
+	mediump vec4 light_params; //cone attenuation, angle, specular, shadow enabled,
+	mediump vec4 light_clamp;
+	mediump vec4 shadow_color;
+	highp mat4 shadow_matrix1;
+	highp mat4 shadow_matrix2;
+	highp mat4 shadow_matrix3;
+	highp mat4 shadow_matrix4;
+	mediump vec4 shadow_split_offsets;
+};
+
+#endif
+
+
+/* Varyings */
+
+out highp vec3 vertex_interp;
+out vec3 normal_interp;
+
+#if defined(ENABLE_COLOR_INTERP)
+out vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+out vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+out vec2 uv2_interp;
+#endif
+
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+out vec3 tangent_interp;
+out vec3 binormal_interp;
+#endif
+
+
+#if !defined(USE_DEPTH_SHADOWS) && defined(USE_SHADOW_PASS)
+
+varying vec4 position_interp;
+
+#endif
+
+
+VERTEX_SHADER_GLOBALS
+
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData { //ubo:1
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+out highp float dp_clip;
+
+#endif
+
+#ifdef USE_SKELETON
+
+layout(std140) uniform SkeletonData { //ubo:7
+
+	mat3x4 skeleton[MAX_SKELETON_BONES];
+};
+
+#endif
+
+void main() {
+
+	highp vec4 vertex = vertex_attrib; // vec4(vertex_attrib.xyz * data_attrib.x,1.0);
+	highp mat4 modelview = camera_inverse_matrix * world_transform;
+	vec3 normal = normal_attrib * normal_mult;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+	vec3 tangent = tangent_attrib.xyz;
+	tangent*=normal_mult;
+	float binormalf = tangent_attrib.a;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+	color_interp = color_attrib;
+#endif
+
+
+#ifdef USE_SKELETON
+
+	{
+		//skeleton transform
+		highp mat3x4 m=skeleton[bone_indices.x]*bone_weights.x;
+		m+=skeleton[bone_indices.y]*bone_weights.y;
+		m+=skeleton[bone_indices.z]*bone_weights.z;
+		m+=skeleton[bone_indices.w]*bone_weights.w;
+
+		vertex.xyz = vertex * m;
+
+		normal = vec4(normal,0.0) * m;
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+		tangent.xyz = vec4(tangent.xyz,0.0) * mn;
+#endif
+	}
+#endif // USE_SKELETON1
+
+
+#ifdef USE_INSTANCING
+
+	{
+		highp mat3x4 m=mat3x4(instance_xform0,instance_xform1,instance_xform2);
+
+		vertex.xyz = vertex * m;
+		normal = vec4(normal,0.0) * m;
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+		tangent.xyz = vec4(tangent.xyz,0.0) * mn;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+		color_interp*=instance_color;
+#endif
+	}
+#endif //USE_INSTANCING
+
+#if !defined(SKIP_TRANSFORM_USED)
+
+	vertex = modelview * vertex;
+	normal = normalize((modelview * vec4(normal,0.0)).xyz);
+#endif
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+# if !defined(SKIP_TRANSFORM_USED)
+
+	tangent=normalize((modelview * vec4(tangent,0.0)).xyz);
+# endif
+	vec3 binormal = normalize( cross(normal,tangent) * binormalf );
+#endif
+
+
+
+
+#if defined(ENABLE_UV_INTERP)
+	uv_interp = uv_attrib;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+	uv2_interp = uv2_attrib;
+#endif
+
+{
+
+VERTEX_SHADER_CODE
+
+}
+
+	vertex_interp = vertex.xyz;
+	normal_interp = normal;
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+	tangent_interp = tangent;
+	binormal_interp = binormal;
+#endif
+
+#ifdef RENDER_DEPTH
+
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	vertex_interp.z*= shadow_dual_paraboloid_render_side;
+	normal_interp.z*= shadow_dual_paraboloid_render_side;
+
+	dp_clip=vertex_interp.z; //this attempts to avoid noise caused by objects sent to the other parabolloid side due to bias
+
+	//for dual paraboloid shadow mapping, this is the fastest but least correct way, as it curves straight edges
+
+	highp vec3 vtx = vertex_interp+normalize(vertex_interp)*shadow_z_offset;
+	highp float distance = length(vtx);
+	vtx = normalize(vtx);
+	vtx.xy/=1.0-vtx.z;
+	vtx.z=(distance/shadow_dual_paraboloid_render_zfar);
+	vtx.z=vtx.z * 2.0 - 1.0;
+
+	vertex.xyz=vtx;
+	vertex.w=1.0;
+
+
+#else
+
+	float z_ofs = shadow_z_offset;
+	z_ofs += (1.0-abs(normal_interp.z))*shadow_z_slope_scale;
+	vertex_interp.z-=z_ofs;
+
+#endif //RENDER_DEPTH_DUAL_PARABOLOID
+
+#endif //RENDER_DEPTH
+
+
+#if !defined(SKIP_TRANSFORM_USED) && !defined(RENDER_DEPTH_DUAL_PARABOLOID)
+	gl_Position = projection_matrix * vec4(vertex_interp,1.0);
+#else
+	gl_Position = vertex;
+#endif
+
+
+}
+
+
+[fragment]
+
+
+
+#define M_PI 3.14159265359
+
+/* Varyings */
+
+#if defined(ENABLE_COLOR_INTERP)
+in vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+in vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+in vec2 uv2_interp;
+#endif
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+in vec3 tangent_interp;
+in vec3 binormal_interp;
+#endif
+
+in highp vec3 vertex_interp;
+in vec3 normal_interp;
+
+
+/* PBR CHANNELS */
+
+//used on forward mainly
+uniform bool no_ambient_light;
+
+uniform sampler2D brdf_texture; //texunit:-1
+
+#ifdef USE_RADIANCE_MAP
+
+uniform sampler2D radiance_map; //texunit:-2
+
+
+layout(std140) uniform Radiance { //ubo:2
+
+	mat4 radiance_inverse_xform;
+	vec3 radiance_box_min;
+	vec3 radiance_box_max;
+	float radiance_ambient_contribution;
+
+};
+
+#endif
+
+/* Material Uniforms */
+
+
+FRAGMENT_SHADER_GLOBALS
+
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData {
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+
+layout(std140) uniform SceneData {
+
+	highp mat4 projection_matrix;
+	highp mat4 camera_inverse_matrix;
+	highp mat4 camera_matrix;
+	highp vec4 time;
+
+	highp vec4 ambient_light_color;
+	highp vec4 bg_color;
+	float ambient_energy;
+	float bg_energy;
+
+	float shadow_z_offset;
+	float shadow_z_slope_scale;
+	float shadow_dual_paraboloid_render_zfar;
+	float shadow_dual_paraboloid_render_side;
+
+	vec2 shadow_atlas_pixel_size;
+	vec2 directional_shadow_pixel_size;
+
+	float reflection_multiplier;
+	float subsurface_scatter_width;
+	float ambient_occlusion_affect_light;
+
+};
+
+//directional light data
+
+#ifdef USE_LIGHT_DIRECTIONAL
+
+layout(std140) uniform DirectionalLightData {
+
+	highp vec4 light_pos_inv_radius;
+	mediump vec4 light_direction_attenuation;
+	mediump vec4 light_color_energy;
+	mediump vec4 light_params; //cone attenuation, angle, specular, shadow enabled,
+	mediump vec4 light_clamp;
+	mediump vec4 shadow_color;
+	highp mat4 shadow_matrix1;
+	highp mat4 shadow_matrix2;
+	highp mat4 shadow_matrix3;
+	highp mat4 shadow_matrix4;
+	mediump vec4 shadow_split_offsets;
+};
+
+
+uniform highp sampler2DShadow directional_shadow; //texunit:-4
+
+#endif
+
+//omni and spot
+
+struct LightData {
+
+	highp vec4 light_pos_inv_radius;
+	mediump vec4 light_direction_attenuation;
+	mediump vec4 light_color_energy;
+	mediump vec4 light_params; //cone attenuation, angle, specular, shadow enabled,
+	mediump vec4 light_clamp;
+	mediump vec4 shadow_color;
+	highp mat4 shadow_matrix;
+
+};
+
+
+layout(std140) uniform OmniLightData { //ubo:4
+
+	LightData omni_lights[MAX_LIGHT_DATA_STRUCTS];
+};
+
+layout(std140) uniform SpotLightData { //ubo:5
+
+	LightData spot_lights[MAX_LIGHT_DATA_STRUCTS];
+};
+
+
+uniform highp sampler2DShadow shadow_atlas; //texunit:-3
+
+
+struct ReflectionData {
+
+	mediump vec4 box_extents;
+	mediump vec4 box_offset;
+	mediump vec4 params; // intensity, 0, interior , boxproject
+	mediump vec4 ambient; //ambient color, energy
+	mediump vec4 atlas_clamp;
+	highp mat4 local_matrix; //up to here for spot and omni, rest is for directional
+	//notes: for ambientblend, use distance to edge to blend between already existing global environment
+};
+
+layout(std140) uniform ReflectionProbeData { //ubo:6
+
+	ReflectionData reflections[MAX_REFLECTION_DATA_STRUCTS];
+};
+uniform mediump sampler2D reflection_atlas; //texunit:-5
+
+
+#ifdef USE_FORWARD_LIGHTING
+
+uniform int omni_light_indices[MAX_FORWARD_LIGHTS];
+uniform int omni_light_count;
+
+uniform int spot_light_indices[MAX_FORWARD_LIGHTS];
+uniform int spot_light_count;
+
+uniform int reflection_indices[MAX_FORWARD_LIGHTS];
+uniform int reflection_count;
+
+#endif
+
+
+
+#ifdef USE_MULTIPLE_RENDER_TARGETS
+
+layout(location=0) out vec4 diffuse_buffer;
+layout(location=1) out vec4 specular_buffer;
+layout(location=2) out vec4 normal_mr_buffer;
+#if defined (ENABLE_SSS_MOTION)
+layout(location=3) out vec4 motion_ssr_buffer;
+#endif
+
+#else
+
+layout(location=0) out vec4 frag_color;
+
+#endif
+
+
+// GGX Specular
+// Source: http://www.filmicworlds.com/images/ggx-opt/optimized-ggx.hlsl
+float G1V(float dotNV, float k)
+{
+    return 1.0 / (dotNV * (1.0 - k) + k);
+}
+
+
+float SchlickFresnel(float u)
+{
+    float m = 1.0-u;
+    float m2 = m*m;
+    return m2*m2*m; // pow(m,5)
+}
+
+float GTR1(float NdotH, float a)
+{
+    if (a >= 1.0) return 1.0/M_PI;
+    float a2 = a*a;
+    float t = 1.0 + (a2-1.0)*NdotH*NdotH;
+    return (a2-1.0) / (M_PI*log(a2)*t);
+}
+
+void light_compute(vec3 N, vec3 L,vec3 V,vec3 B, vec3 T,vec3 light_color,vec3 diffuse_color, vec3 specular_color, float specular_blob_intensity, float roughness, float rim,float rim_tint, float clearcoat, float clearcoat_gloss,float anisotropy,inout vec3 diffuse, inout vec3 specular) {
+
+	float dotNL = max(dot(N,L), 0.0 );
+	float dotNV = max(dot(N,V), 0.0 );
+
+#if defined(LIGHT_USE_RIM)
+	float rim_light = pow(1.0-dotNV,(1.0-roughness)*16.0);
+	diffuse += rim_light * rim * mix(vec3(1.0),diffuse_color,rim_tint) * light_color;
+#endif
+
+	diffuse += dotNL * light_color * diffuse_color;
+
+	if (roughness > 0.0) {
+
+		float alpha = roughness * roughness;
+
+		vec3 H = normalize(V + L);
+
+		float dotNH = max(dot(N,H), 0.0 );
+		float dotLH = max(dot(L,H), 0.0 );
+
+		// D
+#if defined(LIGHT_USE_ANISOTROPY)
+
+		float aspect = sqrt(1.0-anisotropy*0.9);
+		float rx = roughness/aspect;
+		float ry = roughness*aspect;
+		float ax = rx*rx;
+		float ay = ry*ry;
+		float dotXH = dot( T, H );
+		float dotYH = dot( B, H );
+		float pi = M_PI;
+		float denom = dotXH*dotXH / (ax*ax) + dotYH*dotYH / (ay*ay) + dotNH*dotNH;
+		float D = 1.0 / ( pi * ax*ay * denom*denom );
+
+#else
+		float alphaSqr = alpha * alpha;
+		float pi = M_PI;
+		float denom = dotNH * dotNH * (alphaSqr - 1.0) + 1.0;
+		float D = alphaSqr / (pi * denom * denom);
+#endif
+		// F
+		float F0 = 1.0;
+		float dotLH5 = SchlickFresnel( dotLH );
+		float F = F0 + (1.0 - F0) * (dotLH5);
+
+		// V
+		float k = alpha / 2.0f;
+		float vis = G1V(dotNL, k) * G1V(dotNV, k);
+
+		float speci = dotNL * D * F * vis;
+
+		specular += speci * light_color /* specular_color*/ * specular_blob_intensity;
+
+#if defined(LIGHT_USE_CLEARCOAT)
+		float Dr = GTR1(dotNH, mix(.1,.001,clearcoat_gloss));
+		float Fr = mix(.04, 1.0, dotLH5);
+		float Gr = G1V(dotNL, .25) * G1V(dotNV, .25);
+
+		specular += .25*clearcoat*Gr*Fr*Dr;
+#endif
+	}
+
+
+}
+
+
+float sample_shadow(highp sampler2DShadow shadow, vec2 shadow_pixel_size, vec2 pos, float depth, vec4 clamp_rect) {
+
+#ifdef SHADOW_MODE_PCF_13
+
+	float avg=textureProj(shadow,vec4(pos,depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(shadow_pixel_size.x,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(-shadow_pixel_size.x,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,-shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(shadow_pixel_size.x,shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(-shadow_pixel_size.x,shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(shadow_pixel_size.x,-shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(-shadow_pixel_size.x,-shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(shadow_pixel_size.x*2.0,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(-shadow_pixel_size.x*2.0,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,shadow_pixel_size.y*2.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,-shadow_pixel_size.y*2.0),depth,1.0));
+	return avg*(1.0/13.0);
+
+#endif
+
+#ifdef SHADOW_MODE_PCF_5
+
+	float avg=textureProj(shadow,vec4(pos,depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(shadow_pixel_size.x,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(-shadow_pixel_size.x,0.0),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,shadow_pixel_size.y),depth,1.0));
+	avg+=textureProj(shadow,vec4(pos+vec2(0.0,-shadow_pixel_size.y),depth,1.0));
+	return avg*(1.0/5.0);
+#endif
+
+#if !defined(SHADOW_MODE_PCF_5) && !defined(SHADOW_MODE_PCF_13)
+
+	return textureProj(shadow,vec4(pos,depth,1.0));
+#endif
+
+}
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+in highp float dp_clip;
+
+#endif
+
+#if 0
+//need to save texture depth for this
+
+vec3 light_transmittance(float translucency,vec3 light_vec, vec3 normal, vec3 pos, float distance) {
+
+	float scale = 8.25 * (1.0 - translucency) / subsurface_scatter_width;
+	float d = scale * distance;
+
+    /**
+     * Armed with the thickness, we can now calculate the color by means of the
+     * precalculated transmittance profile.
+     * (It can be precomputed into a texture, for maximum performance):
+     */
+	float dd = -d * d;
+	vec3 profile = vec3(0.233, 0.455, 0.649) * exp(dd / 0.0064) +
+		     vec3(0.1,   0.336, 0.344) * exp(dd / 0.0484) +
+		     vec3(0.118, 0.198, 0.0)   * exp(dd / 0.187)  +
+		     vec3(0.113, 0.007, 0.007) * exp(dd / 0.567)  +
+		     vec3(0.358, 0.004, 0.0)   * exp(dd / 1.99)   +
+		     vec3(0.078, 0.0,   0.0)   * exp(dd / 7.41);
+
+    /**
+     * Using the profile, we finally approximate the transmitted lighting from
+     * the back of the object:
+     */
+    return profile * clamp(0.3 + dot(light_vec, normal),0.0,1.0);
+}
+#endif
+
+void light_process_omni(int idx, vec3 vertex, vec3 eye_vec,vec3 normal,vec3 binormal, vec3 tangent, vec3 albedo, vec3 specular, float roughness, float rim, float rim_tint, float clearcoat, float clearcoat_gloss,float anisotropy,inout vec3 diffuse_light, inout vec3 specular_light) {
+
+	vec3 light_rel_vec = omni_lights[idx].light_pos_inv_radius.xyz-vertex;
+	float normalized_distance = length( light_rel_vec )*omni_lights[idx].light_pos_inv_radius.w;
+	vec3 light_attenuation = vec3(pow( max(1.0 - normalized_distance, 0.0), omni_lights[idx].light_direction_attenuation.w ));
+
+	if (omni_lights[idx].light_params.w>0.5) {
+		//there is a shadowmap
+
+		highp vec3 splane=(omni_lights[idx].shadow_matrix * vec4(vertex,1.0)).xyz;
+		float shadow_len=length(splane);
+		splane=normalize(splane);
+		vec4 clamp_rect=omni_lights[idx].light_clamp;
+
+		if (splane.z>=0.0) {
+
+			splane.z+=1.0;
+
+			clamp_rect.y+=clamp_rect.w;
+
+		} else {
+
+			splane.z=1.0 - splane.z;
+
+			//if (clamp_rect.z<clamp_rect.w) {
+			//	clamp_rect.x+=clamp_rect.z;
+			//} else {
+			//	clamp_rect.y+=clamp_rect.w;
+			//}
+
+		}
+
+		splane.xy/=splane.z;
+		splane.xy=splane.xy * 0.5 + 0.5;
+		splane.z = shadow_len * omni_lights[idx].light_pos_inv_radius.w;
+
+		splane.xy = clamp_rect.xy+splane.xy*clamp_rect.zw;
+
+		light_attenuation*=mix(omni_lights[idx].shadow_color.rgb,vec3(1.0),sample_shadow(shadow_atlas,shadow_atlas_pixel_size,splane.xy,splane.z,clamp_rect));
+	}
+
+	light_compute(normal,normalize(light_rel_vec),eye_vec,binormal,tangent,omni_lights[idx].light_color_energy.rgb*light_attenuation,albedo,specular,omni_lights[idx].light_params.z,roughness,rim,rim_tint,clearcoat,clearcoat_gloss,anisotropy,diffuse_light,specular_light);
+
+}
+
+void light_process_spot(int idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 binormal, vec3 tangent,vec3 albedo, vec3 specular, float roughness, float rim,float rim_tint, float clearcoat, float clearcoat_gloss,float anisotropy, inout vec3 diffuse_light, inout vec3 specular_light) {
+
+	vec3 light_rel_vec = spot_lights[idx].light_pos_inv_radius.xyz-vertex;
+	float normalized_distance = length( light_rel_vec )*spot_lights[idx].light_pos_inv_radius.w;
+	vec3 light_attenuation = vec3(pow( max(1.0 - normalized_distance, 0.0), spot_lights[idx].light_direction_attenuation.w ));
+	vec3 spot_dir = spot_lights[idx].light_direction_attenuation.xyz;
+	float spot_cutoff=spot_lights[idx].light_params.y;
+	float scos = max(dot(-normalize(light_rel_vec), spot_dir),spot_cutoff);
+	float spot_rim = (1.0 - scos) / (1.0 - spot_cutoff);
+	light_attenuation *= 1.0 - pow( spot_rim, spot_lights[idx].light_params.x);
+
+	if (spot_lights[idx].light_params.w>0.5) {
+		//there is a shadowmap
+		highp vec4 splane=(spot_lights[idx].shadow_matrix * vec4(vertex,1.0));
+		splane.xyz/=splane.w;
+		light_attenuation*=mix(spot_lights[idx].shadow_color.rgb,vec3(1.0),sample_shadow(shadow_atlas,shadow_atlas_pixel_size,splane.xy,splane.z,spot_lights[idx].light_clamp));
+	}
+
+	light_compute(normal,normalize(light_rel_vec),eye_vec,binormal,tangent,spot_lights[idx].light_color_energy.rgb*light_attenuation,albedo,specular,spot_lights[idx].light_params.z,roughness,rim,rim_tint,clearcoat,clearcoat_gloss,anisotropy,diffuse_light,specular_light);
+
+}
+
+void reflection_process(int idx, vec3 vertex, vec3 normal,vec3 binormal, vec3 tangent,float roughness,float anisotropy,vec3 ambient,vec3 skybox,vec2 brdf, inout highp vec4 reflection_accum,inout highp vec4 ambient_accum) {
+
+	vec3 ref_vec = normalize(reflect(vertex,normal));
+	vec3 local_pos = (reflections[idx].local_matrix * vec4(vertex,1.0)).xyz;
+	vec3 box_extents = reflections[idx].box_extents.xyz;
+
+	if (any(greaterThan(abs(local_pos),box_extents))) { //out of the reflection box
+		return;
+	}
+
+	vec3 inner_pos = abs(local_pos / box_extents);
+	float blend = max(inner_pos.x,max(inner_pos.y,inner_pos.z));
+	//make blend more rounded
+	blend=mix(length(inner_pos),blend,blend);
+	blend*=blend;
+	blend=1.001-blend;
+
+	if (reflections[idx].params.x>0.0){// compute reflection
+
+		vec3 local_ref_vec = (reflections[idx].local_matrix * vec4(ref_vec,0.0)).xyz;
+
+		if (reflections[idx].params.w > 0.5) { //box project
+
+			vec3 nrdir = normalize(local_ref_vec);
+			vec3 rbmax = (box_extents - local_pos)/nrdir;
+			vec3 rbmin = (-box_extents - local_pos)/nrdir;
+
+
+			vec3 rbminmax = mix(rbmin,rbmax,greaterThan(nrdir,vec3(0.0,0.0,0.0)));
+
+			float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);
+			vec3 posonbox = local_pos + nrdir * fa;
+			local_ref_vec = posonbox - reflections[idx].box_offset.xyz;
+		}
+
+
+
+		vec3 splane=normalize(local_ref_vec);
+		vec4 clamp_rect=reflections[idx].atlas_clamp;
+
+		splane.z*=-1.0;
+		if (splane.z>=0.0) {
+			splane.z+=1.0;
+			clamp_rect.y+=clamp_rect.w;
+		} else {
+			splane.z=1.0 - splane.z;
+			splane.y=-splane.y;
+		}
+
+		splane.xy/=splane.z;
+		splane.xy=splane.xy * 0.5 + 0.5;
+
+		splane.xy = splane.xy * clamp_rect.zw + clamp_rect.xy;
+		splane.xy = clamp(splane.xy,clamp_rect.xy,clamp_rect.xy+clamp_rect.zw);
+
+		highp vec4 reflection;
+		reflection.rgb = textureLod(reflection_atlas,splane.xy,roughness*5.0).rgb *  brdf.x + brdf.y;
+
+		if (reflections[idx].params.z < 0.5) {
+			reflection.rgb = mix(skybox,reflection.rgb,blend);
+		}
+		reflection.rgb*=reflections[idx].params.x;
+		reflection.a = blend;
+		reflection.rgb*=reflection.a;
+
+		reflection_accum+=reflection;
+	}
+
+	if (reflections[idx].ambient.a>0.0) { //compute ambient using skybox
+
+
+		vec3 local_amb_vec = (reflections[idx].local_matrix * vec4(normal,0.0)).xyz;
+
+		vec3 splane=normalize(local_amb_vec);
+		vec4 clamp_rect=reflections[idx].atlas_clamp;
+
+		splane.z*=-1.0;
+		if (splane.z>=0.0) {
+			splane.z+=1.0;
+			clamp_rect.y+=clamp_rect.w;
+		} else {
+			splane.z=1.0 - splane.z;
+			splane.y=-splane.y;
+		}
+
+		splane.xy/=splane.z;
+		splane.xy=splane.xy * 0.5 + 0.5;
+
+		splane.xy = splane.xy * clamp_rect.zw + clamp_rect.xy;
+		splane.xy = clamp(splane.xy,clamp_rect.xy,clamp_rect.xy+clamp_rect.zw);
+
+		highp vec4 ambient_out;
+		ambient_out.a=blend;
+		ambient_out.rgb = textureLod(reflection_atlas,splane.xy,5.0).rgb;
+		ambient_out.rgb=mix(reflections[idx].ambient.rgb,ambient_out.rgb,reflections[idx].ambient.a);
+		if (reflections[idx].params.z < 0.5) {
+			ambient_out.rgb = mix(ambient,ambient_out.rgb,blend);
+		}
+
+		ambient_out.rgb *= ambient_out.a;
+		ambient_accum+=ambient_out;
+	} else {
+
+		highp vec4 ambient_out;
+		ambient_out.a=blend;
+		ambient_out.rgb=reflections[idx].ambient.rgb;
+		if (reflections[idx].params.z < 0.5) {
+			ambient_out.rgb = mix(ambient,ambient_out.rgb,blend);
+		}
+		ambient_out.rgb *= ambient_out.a;
+		ambient_accum+=ambient_out;
+
+	}
+}
+
+#ifdef USE_GI_PROBES
+
+uniform mediump sampler3D gi_probe1; //texunit:-6
+uniform highp mat4 gi_probe_xform1;
+uniform highp vec3 gi_probe_bounds1;
+uniform highp vec3 gi_probe_cell_size1;
+uniform highp float gi_probe_multiplier1;
+uniform bool gi_probe_blend_ambient1;
+
+uniform mediump sampler3D gi_probe2; //texunit:-7
+uniform highp mat4 gi_probe_xform2;
+uniform highp vec3 gi_probe_bounds2;
+uniform highp vec3 gi_probe_cell_size2;
+uniform highp float gi_probe_multiplier2;
+uniform bool gi_probe2_enabled;
+uniform bool gi_probe_blend_ambient2;
+
+vec3 voxel_cone_trace(sampler3D probe, vec3 cell_size, vec3 pos, vec3 ambient, bool blend_ambient, vec3 direction, float tan_half_angle, float max_distance) {
+
+
+	float dist = dot(direction,mix(vec3(-1.0),vec3(1.0),greaterThan(direction,vec3(0.0))))*2.0;
+	float alpha=0.0;
+	vec3 color = vec3(0.0);
+
+	while(dist < max_distance && alpha < 0.95) {
+		float diameter = max(1.0, 2.0 * tan_half_angle * dist);
+		vec4 scolor = textureLod(probe, (pos + dist * direction) * cell_size, log2(diameter) );
+		float a = (1.0 - alpha);
+		color += scolor.rgb * a;
+		alpha += a * scolor.a;
+		dist += diameter * 0.5;
+	}
+
+	//color.rgb = mix(color.rgb,mix(ambient,color.rgb,alpha),blend_ambient);
+
+	return color;
+}
+
+void gi_probe_compute(sampler3D probe, mat4 probe_xform, vec3 bounds,vec3 cell_size,vec3 pos, vec3 ambient, vec3 environment, bool blend_ambient,float multiplier, mat3 normal_mtx,vec3 ref_vec, float roughness, out vec4 out_spec, out vec4 out_diff) {
+
+
+
+	vec3 probe_pos = (probe_xform * vec4(pos,1.0)).xyz;
+	vec3 ref_pos = (probe_xform * vec4(pos+ref_vec,1.0)).xyz;
+
+	ref_vec = normalize(ref_pos - probe_pos);
+
+/*	out_diff.rgb = voxel_cone_trace(probe,cell_size,probe_pos,normalize((probe_xform * vec4(ref_vec,0.0)).xyz),0.0 ,100.0);
+	out_diff.a = 1.0;
+	return;*/
+	//out_diff = vec4(textureLod(probe,probe_pos*cell_size,3.0).rgb,1.0);
+	//return;
+
+	if (any(bvec2(any(lessThan(probe_pos,vec3(0.0))),any(greaterThan(probe_pos,bounds)))))
+		return;
+
+	vec3 blendv = probe_pos/bounds * 2.0 - 1.0;
+	float blend = 1.001-max(blendv.x,max(blendv.y,blendv.z));
+	blend=1.0;
+
+	float max_distance = length(bounds);
+
+	//radiance
+#ifdef VCT_QUALITY_HIGH
+
+#define MAX_CONE_DIRS 6
+	vec3 cone_dirs[MAX_CONE_DIRS] = vec3[] (
+		vec3(0, 0, 1),
+		vec3(0.866025, 0, 0.5),
+		vec3(0.267617, 0.823639, 0.5),
+		vec3(-0.700629, 0.509037, 0.5),
+		vec3(-0.700629, -0.509037, 0.5),
+		vec3(0.267617, -0.823639, 0.5)
+	);
+
+	float cone_weights[MAX_CONE_DIRS] = float[](0.25, 0.15, 0.15, 0.15, 0.15, 0.15);
+	float cone_angle_tan = 0.577;
+	float min_ref_tan = 0.0;
+#else
+
+#define MAX_CONE_DIRS 4
+
+	vec3 cone_dirs[MAX_CONE_DIRS] = vec3[] (
+			vec3(0.707107, 0, 0.707107),
+			vec3(0, 0.707107, 0.707107),
+			vec3(-0.707107, 0, 0.707107),
+			vec3(0, -0.707107, 0.707107)
+	);
+
+	float cone_weights[MAX_CONE_DIRS] = float[](0.25, 0.25, 0.25, 0.25);
+	float cone_angle_tan = 0.98269;
+	max_distance*=0.5;
+	float min_ref_tan = 0.2;
+
+#endif
+	vec3 light=vec3(0.0);
+	for(int i=0;i<MAX_CONE_DIRS;i++) {
+
+		vec3 dir = normalize( (probe_xform * vec4(pos + normal_mtx * cone_dirs[i],1.0)).xyz - probe_pos);
+		light+=cone_weights[i] * voxel_cone_trace(probe,cell_size,probe_pos,ambient,blend_ambient,dir,cone_angle_tan,max_distance);
+
+	}
+
+	light*=multiplier;
+
+	out_diff = vec4(light*blend,blend);
+
+	//irradiance
+
+	vec3 irr_light =  voxel_cone_trace(probe,cell_size,probe_pos,environment,blend_ambient,ref_vec,max(min_ref_tan,tan(roughness * 0.5 * M_PI)) ,max_distance);
+
+	irr_light *= multiplier;
+	//irr_light=vec3(0.0);
+
+	out_spec = vec4(irr_light*blend,blend);
+}
+
+
+void gi_probes_compute(vec3 pos, vec3 normal, float roughness, vec3 specular, inout vec3 out_specular, inout vec3 out_ambient) {
+
+	roughness = roughness * roughness;
+
+	vec3 ref_vec = normalize(reflect(normalize(pos),normal));
+
+	//find arbitrary tangent and bitangent, then build a matrix
+	vec3 v0 = abs(normal.z) < 0.999 ? vec3(0, 0, 1) : vec3(0, 1, 0);
+	vec3 tangent = normalize(cross(v0, normal));
+	vec3 bitangent = normalize(cross(tangent, normal));
+	mat3 normal_mat = mat3(tangent,bitangent,normal);
+
+	vec4 diff_accum = vec4(0.0);
+	vec4 spec_accum = vec4(0.0);
+
+	vec3 ambient = out_ambient;
+	out_ambient = vec3(0.0);
+
+	vec3 environment = out_specular;
+
+	out_specular = vec3(0.0);
+
+	gi_probe_compute(gi_probe1,gi_probe_xform1,gi_probe_bounds1,gi_probe_cell_size1,pos,ambient,environment,gi_probe_blend_ambient1,gi_probe_multiplier1,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
+
+	if (gi_probe2_enabled) {
+
+		gi_probe_compute(gi_probe2,gi_probe_xform2,gi_probe_bounds2,gi_probe_cell_size2,pos,ambient,environment,gi_probe_blend_ambient2,gi_probe_multiplier2,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
+	}
+
+	if (diff_accum.a>0.0) {
+		diff_accum.rgb/=diff_accum.a;
+	}
+
+	if (spec_accum.a>0.0) {
+		spec_accum.rgb/=spec_accum.a;
+	}
+
+	out_specular+=spec_accum.rgb;
+	out_ambient+=diff_accum.rgb;
+
+}
+
+#endif
+
+
+void main() {
+
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	if (dp_clip>0.0)
+		discard;
+#endif
+
+	//lay out everything, whathever is unused is optimized away anyway
+	highp vec3 vertex = vertex_interp;
+	vec3 albedo = vec3(0.8,0.8,0.8);
+	vec3 specular = vec3(0.2,0.2,0.2);
+	vec3 emission = vec3(0.0,0.0,0.0);
+	float roughness = 1.0;
+	float rim = 0.0;
+	float rim_tint = 0.0;
+	float clearcoat=0.0;
+	float clearcoat_gloss=0.0;
+	float anisotropy = 1.0;
+	vec2 anisotropy_flow = vec2(1.0,0.0);
+
+#if defined(ENABLE_AO)
+	float ao=1.0;
+#endif
+
+	float alpha = 1.0;
+
+#ifdef METERIAL_DOUBLESIDED
+	float side=float(gl_FrontFacing)*2.0-1.0;
+#else
+	float side=1.0;
+#endif
+
+
+#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+	vec3 binormal = normalize(binormal_interp)*side;
+	vec3 tangent = normalize(tangent_interp)*side;
+#else
+	vec3 binormal = vec3(0.0);
+	vec3 tangent = vec3(0.0);
+#endif
+	vec3 normal = normalize(normal_interp)*side;
+
+#if defined(ENABLE_UV_INTERP)
+	vec2 uv = uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+	vec2 uv2 = uv2_interp;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+	vec4 color = color_interp;
+#endif
+
+#if defined(ENABLE_NORMALMAP)
+
+	vec3 normalmap = vec3(0.0);
+#endif
+
+	float normaldepth=1.0;
+
+
+
+#if defined(ENABLE_DISCARD)
+	bool discard_=false;
+#endif
+
+#if defined (ENABLE_SSS_MOTION)
+	float sss_strength=0.0;
+#endif
+
+{
+
+
+FRAGMENT_SHADER_CODE
+
+}
+
+
+
+#if defined(ENABLE_NORMALMAP)
+
+	normalmap.xy=normalmap.xy*2.0-1.0;
+	normalmap.z=sqrt(1.0-dot(normalmap.xy,normalmap.xy)); //always ignore Z, as it can be RG packed, Z may be pos/neg, etc.
+
+	normal = normalize( mix(normal_interp,tangent * normalmap.x + binormal * normalmap.y + normal * normalmap.z,normaldepth) ) * side;
+
+#endif
+
+#if defined(LIGHT_USE_ANISOTROPY)
+
+	if (anisotropy>0.01) {
+		//rotation matrix
+		mat3 rot = mat3( tangent, binormal, normal );
+		//make local to space
+		tangent = normalize(rot * vec3(anisotropy_flow.x,anisotropy_flow.y,0.0));
+		binormal = normalize(rot * vec3(-anisotropy_flow.y,anisotropy_flow.x,0.0));
+	}
+
+#endif
+
+#if defined(ENABLE_DISCARD)
+	if (discard_) {
+	//easy to eliminate dead code
+		discard;
+	}
+#endif
+
+#ifdef ENABLE_CLIP_ALPHA
+	if (albedo.a<0.99) {
+		//used for doublepass and shadowmapping
+		discard;
+	}
+#endif
+
+/////////////////////// LIGHTING //////////////////////////////
+
+	//apply energy conservation
+
+	vec3 specular_light = vec3(0.0,0.0,0.0);
+	vec3 ambient_light;
+	vec3 diffuse_light = vec3(0.0,0.0,0.0);
+
+	vec3 eye_vec = -normalize( vertex_interp );
+
+#ifndef RENDER_DEPTH
+	float ndotv = clamp(dot(normal,eye_vec),0.0,1.0);
+
+	vec2 brdf = texture(brdf_texture, vec2(roughness, ndotv)).xy;
+#endif
+
+#ifdef USE_RADIANCE_MAP
+
+	if (no_ambient_light) {
+		ambient_light=vec3(0.0,0.0,0.0);
+	} else {
+		{
+
+
+
+			float lod = roughness * 5.0;
+
+			{ //read radiance from dual paraboloid
+
+				vec3 ref_vec = reflect(-eye_vec,normal); //2.0 * ndotv * normal - view; // reflect(v, n);
+				ref_vec=normalize((radiance_inverse_xform * vec4(ref_vec,0.0)).xyz);
+
+				vec3 norm = normalize(ref_vec);
+				float y_ofs=0.0;
+				if (norm.z>=0.0) {
+
+					norm.z+=1.0;
+					y_ofs+=0.5;
+				} else {
+					norm.z=1.0 - norm.z;
+					norm.y=-norm.y;
+				}
+
+				norm.xy/=norm.z;
+				norm.xy=norm.xy * vec2(0.5,0.25) + vec2(0.5,0.25+y_ofs);
+				specular_light = textureLod(radiance_map, norm.xy, lod).xyz * brdf.x + brdf.y;
+
+			}
+			//no longer a cubemap
+			//vec3 radiance = textureLod(radiance_cube, r, lod).xyz * ( brdf.x + brdf.y);
+
+		}
+
+		{
+
+			/*vec3 ambient_dir=normalize((radiance_inverse_xform * vec4(normal,0.0)).xyz);
+			vec3 env_ambient=textureLod(radiance_cube, ambient_dir, 5.0).xyz;
+
+			ambient_light=mix(ambient_light_color.rgb,env_ambient,radiance_ambient_contribution);*/
+			ambient_light=vec3(0.0,0.0,0.0);
+		}
+	}
+
+#else
+
+	if (no_ambient_light){
+		ambient_light=vec3(0.0,0.0,0.0);
+	} else {
+		ambient_light=ambient_light_color.rgb;
+	}
+#endif
+
+
+#ifdef USE_LIGHT_DIRECTIONAL
+
+	vec3 light_attenuation=vec3(1.0);
+
+#ifdef LIGHT_DIRECTIONAL_SHADOW
+
+	if (gl_FragCoord.w > shadow_split_offsets.w) {
+
+	vec3 pssm_coord;
+
+#ifdef LIGHT_USE_PSSM_BLEND
+	float pssm_blend;
+	vec3 pssm_coord2;
+	bool use_blend=true;
+	vec3 light_pssm_split_inv = 1.0/shadow_split_offsets.xyz;
+	float w_inv = 1.0/gl_FragCoord.w;
+#endif
+
+
+#ifdef LIGHT_USE_PSSM4
+
+
+	if (gl_FragCoord.w > shadow_split_offsets.y) {
+
+		if (gl_FragCoord.w > shadow_split_offsets.x) {
+
+			highp vec4 splane=(shadow_matrix1 * vec4(vertex,1.0));
+			pssm_coord=splane.xyz/splane.w;
+
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+
+			splane=(shadow_matrix2 * vec4(vertex,1.0));
+			pssm_coord2=splane.xyz/splane.w;
+			pssm_blend=smoothstep(0.0,light_pssm_split_inv.x,w_inv);
+#endif
+
+		} else {
+
+			highp vec4 splane=(shadow_matrix2 * vec4(vertex,1.0));
+			pssm_coord=splane.xyz/splane.w;
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+			splane=(shadow_matrix3 * vec4(vertex,1.0));
+			pssm_coord2=splane.xyz/splane.w;
+			pssm_blend=smoothstep(light_pssm_split_inv.x,light_pssm_split_inv.y,w_inv);
+#endif
+
+		}
+	} else {
+
+
+		if (gl_FragCoord.w > shadow_split_offsets.z) {
+
+			highp vec4 splane=(shadow_matrix3 * vec4(vertex,1.0));
+			pssm_coord=splane.xyz/splane.w;
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+			splane=(shadow_matrix4 * vec4(vertex,1.0));
+			pssm_coord2=splane.xyz/splane.w;
+			pssm_blend=smoothstep(light_pssm_split_inv.y,light_pssm_split_inv.z,w_inv);
+#endif
+
+		} else {
+			highp vec4 splane=(shadow_matrix4 * vec4(vertex,1.0));
+			pssm_coord=splane.xyz/splane.w;
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+			use_blend=false;
+
+#endif
+
+		}
+	}
+
+#endif //LIGHT_USE_PSSM4
+
+#ifdef LIGHT_USE_PSSM2
+
+	if (gl_FragCoord.w > shadow_split_offsets.x) {
+
+		highp vec4 splane=(shadow_matrix1 * vec4(vertex,1.0));
+		pssm_coord=splane.xyz/splane.w;
+
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+
+		splane=(shadow_matrix2 * vec4(vertex,1.0));
+		pssm_coord2=splane.xyz/splane.w;
+		pssm_blend=smoothstep(0.0,light_pssm_split_inv.x,w_inv);
+#endif
+
+	} else {
+		highp vec4 splane=(shadow_matrix2 * vec4(vertex,1.0));
+		pssm_coord=splane.xyz/splane.w;
+#if defined(LIGHT_USE_PSSM_BLEND)
+		use_blend=false;
+
+#endif
+
+	}
+
+#endif //LIGHT_USE_PSSM2
+
+#if !defined(LIGHT_USE_PSSM4) && !defined(LIGHT_USE_PSSM2)
+	{ //regular orthogonal
+		highp vec4 splane=(shadow_matrix1 * vec4(vertex,1.0));
+		pssm_coord=splane.xyz/splane.w;
+	}
+#endif
+
+
+	//one one sample
+	light_attenuation=mix(shadow_color.rgb,vec3(1.0),sample_shadow(directional_shadow,directional_shadow_pixel_size,pssm_coord.xy,pssm_coord.z,light_clamp));
+
+
+#if defined(LIGHT_USE_PSSM_BLEND)
+	if (use_blend) {
+		vec3 light_attenuation2=mix(shadow_color.rgb,vec3(1.0),sample_shadow(directional_shadow,directional_shadow_pixel_size,pssm_coord2.xy,pssm_coord2.z,light_clamp));
+		light_attenuation=mix(light_attenuation,light_attenuation2,pssm_blend);
+	}
+#endif
+
+	}
+
+#endif //LIGHT_DIRECTIONAL_SHADOW
+
+	light_compute(normal,-light_direction_attenuation.xyz,eye_vec,binormal,tangent,light_color_energy.rgb*light_attenuation,albedo,specular,light_params.z,roughness,rim,rim_tint,clearcoat,clearcoat_gloss,anisotropy,diffuse_light,specular_light);
+
+
+#endif //#USE_LIGHT_DIRECTIONAL
+
+#ifdef USE_GI_PROBES
+	gi_probes_compute(vertex,normal,roughness,specular,specular_light,ambient_light);
+#endif
+
+
+#ifdef USE_FORWARD_LIGHTING
+
+	highp vec4 reflection_accum = vec4(0.0,0.0,0.0,0.0);
+	highp vec4 ambient_accum = vec4(0.0,0.0,0.0,0.0);
+
+
+
+	for(int i=0;i<reflection_count;i++) {
+		reflection_process(reflection_indices[i],vertex,normal,binormal,tangent,roughness,anisotropy,ambient_light,specular_light,brdf,reflection_accum,ambient_accum);
+	}
+
+	if (reflection_accum.a>0.0) {
+		specular_light+=reflection_accum.rgb/reflection_accum.a;
+	}
+	if (ambient_accum.a>0.0) {
+		ambient_light+=ambient_accum.rgb/ambient_accum.a;
+	}
+
+	for(int i=0;i<omni_light_count;i++) {
+		light_process_omni(omni_light_indices[i],vertex,eye_vec,normal,binormal,tangent,albedo,specular,roughness,rim,rim_tint,clearcoat,clearcoat_gloss,anisotropy,diffuse_light,specular_light);
+	}
+
+	for(int i=0;i<spot_light_count;i++) {
+		light_process_spot(spot_light_indices[i],vertex,eye_vec,normal,binormal,tangent,albedo,specular,roughness,rim,rim_tint,clearcoat,clearcoat_gloss,anisotropy,diffuse_light,specular_light);
+	}
+
+
+
+#endif
+
+
+
+
+#if defined(USE_LIGHT_SHADER_CODE)
+//light is written by the light shader
+{
+
+LIGHT_SHADER_CODE
+
+}
+#endif
+
+#ifdef RENDER_DEPTH
+//nothing happens, so a tree-ssa optimizer will result in no fragment shader :)
+#else
+
+	specular_light*=reflection_multiplier;
+	ambient_light*=albedo; //ambient must be multiplied by albedo at the end
+
+#if defined(ENABLE_AO)
+	ambient_light*=ao;
+#endif
+
+	//energy conservation
+	diffuse_light=mix(diffuse_light,vec3(0.0),specular);
+	ambient_light=mix(ambient_light,vec3(0.0),specular);
+	specular_light *= max(vec3(0.04),specular);
+
+#ifdef USE_MULTIPLE_RENDER_TARGETS
+
+#if defined(ENABLE_AO)
+
+	float ambient_scale=0.0; // AO is supplied by material
+#else
+	//approximate ambient scale for SSAO, since we will lack full ambient
+	float max_emission=max(emission.r,max(emission.g,emission.b));
+	float max_ambient=max(ambient_light.r,max(ambient_light.g,ambient_light.b));
+	float max_diffuse=max(diffuse_light.r,max(diffuse_light.g,diffuse_light.b));
+	float total_ambient = max_ambient+max_diffuse+max_emission;
+	float ambient_scale = (total_ambient>0.0) ? (max_ambient+ambient_occlusion_affect_light*max_diffuse)/total_ambient : 0.0;
+#endif //ENABLE_AO
+
+	diffuse_buffer=vec4(emission+diffuse_light+ambient_light,ambient_scale);
+	specular_buffer=vec4(specular_light,max(specular.r,max(specular.g,specular.b)));
+
+
+	normal_mr_buffer=vec4(normalize(normal)*0.5+0.5,roughness);
+
+#if defined (ENABLE_SSS_MOTION)
+	motion_ssr_buffer = vec4(vec3(0.0),sss_strength);
+#endif
+
+#else
+
+
+#ifdef SHADELESS
+	frag_color=vec4(albedo,alpha);
+#else
+	frag_color=vec4(emission+ambient_light+diffuse_light+specular_light,alpha);
+#endif //SHADELESS
+
+
+#endif //USE_MULTIPLE_RENDER_TARGETS
+
+
+
+#endif //RENDER_DEPTH
+
+
+}
+
+

drivers/gles3/shaders/screen_space_reflection.glsl

@@ -0,0 +1,345 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+out vec2 pos_interp;
+
+void main() {
+
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+	pos_interp.xy=gl_Position.xy;
+}
+
+[fragment]
+
+
+in vec2 uv_interp;
+in vec2 pos_interp;
+
+uniform sampler2D source_diffuse; //texunit:0
+uniform sampler2D source_normal_roughness; //texunit:1
+uniform sampler2D source_depth; //texunit:2
+
+uniform float camera_z_near;
+uniform float camera_z_far;
+
+uniform vec2 viewport_size;
+uniform vec2 pixel_size;
+
+uniform float filter_mipmap_levels;
+
+uniform mat4 inverse_projection;
+uniform mat4 projection;
+
+uniform int num_steps;
+uniform float depth_tolerance;
+uniform float distance_fade;
+uniform float acceleration;
+
+layout(location = 0) out vec4 frag_color;
+
+
+vec2 view_to_screen(vec3 view_pos,out float w) {
+    vec4 projected = projection * vec4(view_pos, 1.0);
+    projected.xyz /= projected.w;
+    projected.xy = projected.xy * 0.5 + 0.5;
+    w=projected.w;
+    return projected.xy;
+}
+
+
+
+#define M_PI 3.14159265359
+
+
+void main() {
+
+
+	////
+
+	vec4 diffuse = texture( source_diffuse,  uv_interp );
+	vec4 normal_roughness = texture( source_normal_roughness, uv_interp);
+
+	vec3 normal;
+
+	normal = normal_roughness.xyz*2.0-1.0;
+
+	float roughness = normal_roughness.w;
+
+	float depth_tex = texture(source_depth,uv_interp).r;
+
+	vec4 world_pos = inverse_projection * vec4( uv_interp*2.0-1.0, depth_tex*2.0-1.0, 1.0 );
+	vec3 vertex = world_pos.xyz/world_pos.w;
+
+	vec3 view_dir = normalize(vertex);
+	vec3 ray_dir = normalize(reflect(view_dir, normal));
+
+	if (dot(ray_dir,normal)<0.001) {
+		frag_color=vec4(0.0);
+		return;
+	}
+	//ray_dir = normalize(view_dir - normal * dot(normal,view_dir) * 2.0);
+
+	//ray_dir = normalize(vec3(1,1,-1));
+
+
+	////////////////
+
+
+	//make ray length and clip it against the near plane (don't want to trace beyond visible)
+	float ray_len = (vertex.z + ray_dir.z * camera_z_far) > -camera_z_near ? (-camera_z_near - vertex.z) / ray_dir.z : camera_z_far;
+	vec3 ray_end = vertex + ray_dir*ray_len;
+
+	float w_begin;
+	vec2 vp_line_begin = view_to_screen(vertex,w_begin);
+	float w_end;
+	vec2 vp_line_end = view_to_screen( ray_end, w_end);
+	vec2 vp_line_dir = vp_line_end-vp_line_begin;
+
+	//we need to interpolate w along the ray, to generate perspective correct reflections
+
+	w_begin = 1.0/w_begin;
+	w_end = 1.0/w_end;
+
+
+	float z_begin = vertex.z*w_begin;
+	float z_end = ray_end.z*w_end;
+
+	vec2 line_begin = vp_line_begin/pixel_size;
+	vec2 line_dir = vp_line_dir/pixel_size;
+	float z_dir = z_end - z_begin;
+	float w_dir = w_end - w_begin;
+
+
+	// clip the line to the viewport edges
+
+	float scale_max_x = min(1, 0.99 * (1.0 - vp_line_begin.x) / max(1e-5, vp_line_dir.x));
+	float scale_max_y = min(1, 0.99 * (1.0 - vp_line_begin.y) / max(1e-5, vp_line_dir.y));
+	float scale_min_x = min(1, 0.99 * vp_line_begin.x / max(1e-5, -vp_line_dir.x));
+	float scale_min_y = min(1, 0.99 * vp_line_begin.y / max(1e-5, -vp_line_dir.y));
+	float line_clip = min(scale_max_x, scale_max_y) * min(scale_min_x, scale_min_y);
+	line_dir *= line_clip;
+	z_dir *= line_clip;
+	w_dir *=line_clip;
+
+	//clip z and w advance to line advance
+	vec2 line_advance = normalize(line_dir); //down to pixel
+	float step_size = length(line_advance)/length(line_dir);
+	float z_advance = z_dir*step_size; // adapt z advance to line advance
+	float w_advance = w_dir*step_size; // adapt w advance to line advance
+
+	//make line advance faster if direction is closer to pixel edges (this avoids sampling the same pixel twice)
+	float advance_angle_adj = 1.0/max(abs(line_advance.x),abs(line_advance.y));
+	line_advance*=advance_angle_adj; // adapt z advance to line advance
+	z_advance*=advance_angle_adj;
+	w_advance*=advance_angle_adj;
+
+	vec2 pos = line_begin;
+	float z = z_begin;
+	float w = w_begin;
+	float z_from=z/w;
+	float z_to=z_from;
+	float depth;
+	vec2 prev_pos=pos;
+
+	bool found=false;
+
+	//if acceleration > 0, distance between pixels gets larger each step. This allows covering a larger area
+	float accel=1.0+acceleration;
+	float steps_taken=0;
+
+	for(float i=0;i<num_steps;i++) {
+
+		pos+=line_advance;
+		z+=z_advance;
+		w+=w_advance;
+
+		//convert to linear depth
+		depth = texture(source_depth, pos*pixel_size).r * 2.0 - 1.0;
+		depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+		depth=-depth;
+
+		z_from = z_to;
+		z_to = z/w;
+
+		if (depth>z_to) {
+			//if depth was surpassed
+			if (depth<=max(z_to,z_from)+depth_tolerance) {
+				//check the depth tolerance
+				found=true;
+			}
+			break;
+		}
+
+		steps_taken+=1.0;
+		prev_pos=pos;
+		z_advance*=accel;
+		w_advance*=accel;
+		line_advance*=accel;
+	}
+
+
+
+
+	if (found) {
+
+		float margin_blend=1.0;
+
+
+		vec2 margin = vec2((viewport_size.x+viewport_size.y)*0.5*0.05); //make a uniform margin
+		if (any(bvec4(lessThan(pos,-margin),greaterThan(pos,viewport_size+margin)))) {
+			//clip outside screen + margin
+			frag_color=vec4(0.0);
+			return;
+		}
+
+		{
+			//blend fading out towards external margin
+			vec2 margin_grad = mix(pos-viewport_size,-pos,lessThan(pos,vec2(0.0)));
+			margin_blend = 1.0-smoothstep(0.0,margin.x,max(margin_grad.x,margin_grad.y));
+			//margin_blend=1.0;
+
+		}
+
+		vec2 final_pos;
+		float grad;
+
+#ifdef SMOOTH_ACCEL
+		//if the distance between point and prev point is >1, then take some samples in the middle for smoothing out the image
+		vec2 blend_dir = pos - prev_pos;
+		float steps = min(8.0,length(blend_dir));
+		if (steps>2.0) {
+			vec2 blend_step = blend_dir/steps;
+			float blend_z = (z_to-z_from)/steps;
+			vec2 new_pos;
+			float subgrad=0.0;
+			for(float i=0.0;i<steps;i++) {
+
+				new_pos = (prev_pos+blend_step*i);
+				float z = z_from+blend_z*i;
+
+				depth = texture(source_depth, new_pos*pixel_size).r * 2.0 - 1.0;
+				depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+				depth=-depth;
+
+				subgrad=i/steps;
+				if (depth>z)
+					break;
+			}
+
+			final_pos = new_pos;
+			grad=(steps_taken+subgrad)/num_steps;
+
+		} else {
+#endif
+			grad=steps_taken/num_steps;
+			final_pos=pos;
+#ifdef SMOOTH_ACCEL
+		}
+
+#endif
+
+
+
+#ifdef REFLECT_ROUGHNESS
+
+
+		vec4 final_color;
+		//if roughness is enabled, do screen space cone tracing
+		if (roughness > 0.001) {
+			///////////////////////////////////////////////////////////////////////////////////////
+			//use a blurred version (in consecutive mipmaps) of the screen to simulate roughness
+
+			float gloss = 1.0-roughness;
+			float cone_angle = roughness * M_PI * 0.5;
+			vec2 cone_dir = final_pos - line_begin;
+			float cone_len = length(cone_dir);
+			cone_dir = normalize(cone_dir); //will be used normalized from now on
+			float max_mipmap = filter_mipmap_levels -1;
+			float gloss_mult=gloss;
+
+			float rem_alpha=1.0;
+			final_color = vec4(0.0);
+
+			for(int i=0;i<7;i++) {
+
+				float op_len = 2.0 * tan(cone_angle) * cone_len; //oposite side of iso triangle
+				float radius;
+				{
+					//fit to sphere inside cone (sphere ends at end of cone), something like this:
+					// ___
+					// \O/
+					//  V
+					//
+					// as it avoids bleeding from beyond the reflection as much as possible. As a plus
+					// it also makes the rough reflection more elongated.
+					float a = op_len;
+					float h = cone_len;
+					float a2 = a * a;
+					float fh2 = 4.0f * h * h;
+					radius = (a * (sqrt(a2 + fh2) - a)) / (4.0f * h);
+				}
+
+				//find the place where screen must be sampled
+				vec2 sample_pos = ( line_begin + cone_dir * (cone_len - radius) ) * pixel_size;
+				//radius is in pixels, so it's natural that log2(radius) maps to the right mipmap for the amount of pixels
+				float mipmap = clamp( log2( radius ), 0.0, max_mipmap );
+
+				//mipmap = max(mipmap-1.0,0.0);
+				//do sampling
+
+				vec4 sample_color;
+				{
+					sample_color = textureLod(source_diffuse,sample_pos,mipmap);
+				}
+
+				//multiply by gloss
+				sample_color.rgb*=gloss_mult;
+				sample_color.a=gloss_mult;
+
+				rem_alpha -= sample_color.a;
+				if(rem_alpha < 0.0) {
+					sample_color.rgb *= (1.0 - abs(rem_alpha));
+				}
+
+				final_color+=sample_color;
+
+				if (final_color.a>=0.95) {
+					// This code of accumulating gloss and aborting on near one
+					// makes sense when you think of cone tracing.
+					// Think of it as if roughness was 0, then we could abort on the first
+					// iteration. For lesser roughness values, we need more iterations, but
+					// each needs to have less influence given the sphere is smaller
+					break;
+				}
+
+				cone_len-=radius*2.0; //go to next (smaller) circle.
+
+				gloss_mult*=gloss;
+
+
+			}
+		} else {
+			final_color = textureLod(source_diffuse,final_pos*pixel_size,0.0);
+		}
+
+		frag_color = vec4(final_color.rgb,pow(clamp(1.0-grad,0.0,1.0),distance_fade)*margin_blend);
+
+#else
+		frag_color = vec4(textureLod(source_diffuse,final_pos*pixel_size,0.0).rgb,pow(clamp(1.0-grad,0.0,1.0),distance_fade)*margin_blend);
+#endif
+
+
+
+	} else {
+		frag_color = vec4(0.0,0.0,0.0,0.0);
+	}
+
+
+
+}
+

drivers/gles3/shaders/ssao.glsl

@@ -0,0 +1,247 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+
+void main() {
+
+	gl_Position = vertex_attrib;
+	gl_Position.z=1.0;
+}
+
+[fragment]
+
+
+#define NUM_SAMPLES (11)
+
+// If using depth mip levels, the log of the maximum pixel offset before we need to switch to a lower
+// miplevel to maintain reasonable spatial locality in the cache
+// If this number is too small (< 3), too many taps will land in the same pixel, and we'll get bad variance that manifests as flashing.
+// If it is too high (> 5), we'll get bad performance because we're not using the MIP levels effectively
+#define LOG_MAX_OFFSET (3)
+
+// This must be less than or equal to the MAX_MIP_LEVEL defined in SSAO.cpp
+#define MAX_MIP_LEVEL (4)
+
+// This is the number of turns around the circle that the spiral pattern makes.  This should be prime to prevent
+// taps from lining up.  This particular choice was tuned for NUM_SAMPLES == 9
+#define NUM_SPIRAL_TURNS (7)
+
+
+uniform sampler2D source_depth; //texunit:0
+uniform usampler2D source_depth_mipmaps; //texunit:1
+uniform sampler2D source_normal; //texunit:2
+
+uniform ivec2 screen_size;
+uniform float camera_z_far;
+uniform float camera_z_near;
+
+uniform float intensity_div_r6;
+uniform float radius;
+
+#ifdef ENABLE_RADIUS2
+uniform float intensity_div_r62;
+uniform float radius2;
+#endif
+
+uniform float bias;
+uniform float proj_scale;
+
+layout(location = 0) out float visibility;
+
+uniform vec4 proj_info;
+
+vec3 reconstructCSPosition(vec2 S, float z) {
+    return vec3((S.xy * proj_info.xy + proj_info.zw) * z, z);
+}
+
+vec3 getPosition(ivec2 ssP) {
+    vec3 P;
+    P.z = texelFetch(source_depth, ssP, 0).r;
+
+    P.z = P.z * 2.0 - 1.0;
+    P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
+    P.z = -P.z;
+
+    // Offset to pixel center
+    P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
+    return P;
+}
+
+/** Reconstructs screen-space unit normal from screen-space position */
+vec3 reconstructCSFaceNormal(vec3 C) {
+    return normalize(cross(dFdy(C), dFdx(C)));
+}
+
+
+
+/** Returns a unit vector and a screen-space radius for the tap on a unit disk (the caller should scale by the actual disk radius) */
+vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR){
+    // Radius relative to ssR
+    float alpha = float(sampleNumber + 0.5) * (1.0 / NUM_SAMPLES);
+    float angle = alpha * (NUM_SPIRAL_TURNS * 6.28) + spinAngle;
+
+    ssR = alpha;
+    return vec2(cos(angle), sin(angle));
+}
+
+
+/** Read the camera-space position of the point at screen-space pixel ssP + unitOffset * ssR.  Assumes length(unitOffset) == 1 */
+vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
+    // Derivation:
+    //  mipLevel = floor(log(ssR / MAX_OFFSET));
+	int mipLevel = clamp(int(floor(log2(ssR))) - LOG_MAX_OFFSET, 0, MAX_MIP_LEVEL);
+
+	ivec2 ssP = ivec2(ssR * unitOffset) + ssC;
+
+	vec3 P;
+
+	// We need to divide by 2^mipLevel to read the appropriately scaled coordinate from a MIP-map.
+	// Manually clamp to the texture size because texelFetch bypasses the texture unit
+	ivec2 mipP = clamp(ssP >> mipLevel, ivec2(0), (screen_size >> mipLevel) - ivec2(1));
+
+
+	if (mipLevel < 1) {
+		//read from depth buffer
+		P.z = texelFetch(source_depth, mipP, 0).r;
+		P.z = P.z * 2.0 - 1.0;
+		P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
+		P.z = -P.z;
+
+	} else {
+		//read from mipmaps
+		uint d = texelFetch(source_depth_mipmaps, mipP, mipLevel-1).r;
+		P.z = -(float(d)/65535.0)*camera_z_far;
+	}
+
+
+	// Offset to pixel center
+	P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
+
+	return P;
+}
+
+
+
+/** Compute the occlusion due to sample with index \a i about the pixel at \a ssC that corresponds
+    to camera-space point \a C with unit normal \a n_C, using maximum screen-space sampling radius \a ssDiskRadius
+
+    Note that units of H() in the HPG12 paper are meters, not
+    unitless.  The whole falloff/sampling function is therefore
+    unitless.  In this implementation, we factor out (9 / radius).
+
+    Four versions of the falloff function are implemented below
+*/
+float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius,in float p_radius, in int tapIndex, in float randomPatternRotationAngle) {
+    // Offset on the unit disk, spun for this pixel
+    float ssR;
+    vec2 unitOffset = tapLocation(tapIndex, randomPatternRotationAngle, ssR);
+    ssR *= ssDiskRadius;
+
+    // The occluding point in camera space
+    vec3 Q = getOffsetPosition(ssC, unitOffset, ssR);
+
+    vec3 v = Q - C;
+
+    float vv = dot(v, v);
+    float vn = dot(v, n_C);
+
+    const float epsilon = 0.01;
+    float radius2 = p_radius*p_radius;
+
+    // A: From the HPG12 paper
+    // Note large epsilon to avoid overdarkening within cracks
+    //return float(vv < radius2) * max((vn - bias) / (epsilon + vv), 0.0) * radius2 * 0.6;
+
+    // B: Smoother transition to zero (lowers contrast, smoothing out corners). [Recommended]
+    float f=max(radius2 - vv, 0.0);
+    return f * f * f * max((vn - bias) / (epsilon + vv), 0.0);
+
+    // C: Medium contrast (which looks better at high radii), no division.  Note that the
+    // contribution still falls off with radius^2, but we've adjusted the rate in a way that is
+    // more computationally efficient and happens to be aesthetically pleasing.
+    // return 4.0 * max(1.0 - vv * invRadius2, 0.0) * max(vn - bias, 0.0);
+
+    // D: Low contrast, no division operation
+    // return 2.0 * float(vv < radius * radius) * max(vn - bias, 0.0);
+}
+
+
+
+void main() {
+
+
+	// Pixel being shaded
+	ivec2 ssC = ivec2(gl_FragCoord.xy);
+
+	// World space point being shaded
+	vec3 C = getPosition(ssC);
+
+/*	if (C.z <= -camera_z_far*0.999) {
+	       // We're on the skybox
+	       visibility=1.0;
+	       return;
+	}*/
+
+	//visibility=-C.z/camera_z_far;
+	//return;
+
+	//vec3 n_C = texelFetch(source_normal,ssC,0).rgb * 2.0 - 1.0;
+
+	vec3 n_C = reconstructCSFaceNormal(C);
+	n_C = -n_C;
+
+
+	// Hash function used in the HPG12 AlchemyAO paper
+	float randomPatternRotationAngle = (3 * ssC.x ^ ssC.y + ssC.x * ssC.y) * 10;
+
+	// Reconstruct normals from positions. These will lead to 1-pixel black lines
+	// at depth discontinuities, however the blur will wipe those out so they are not visible
+	// in the final image.
+
+	// Choose the screen-space sample radius
+	// proportional to the projected area of the sphere
+	float ssDiskRadius = -proj_scale * radius / C.z;
+
+	float sum = 0.0;
+	for (int i = 0; i < NUM_SAMPLES; ++i) {
+		sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius,i, randomPatternRotationAngle);
+	}
+
+	float A = max(0.0, 1.0 - sum * intensity_div_r6 * (5.0 / NUM_SAMPLES));
+
+#ifdef ENABLE_RADIUS2
+
+	//go again for radius2
+	randomPatternRotationAngle = (5 * ssC.x ^ ssC.y + ssC.x * ssC.y) * 11;
+
+	// Reconstruct normals from positions. These will lead to 1-pixel black lines
+	// at depth discontinuities, however the blur will wipe those out so they are not visible
+	// in the final image.
+
+	// Choose the screen-space sample radius
+	// proportional to the projected area of the sphere
+	ssDiskRadius = -proj_scale * radius2 / C.z;
+
+	sum = 0.0;
+	for (int i = 0; i < NUM_SAMPLES; ++i) {
+		sum += sampleAO(ssC, C, n_C, ssDiskRadius,radius2, i, randomPatternRotationAngle);
+	}
+
+	A= min(A,max(0.0, 1.0 - sum * intensity_div_r62 * (5.0 / NUM_SAMPLES)));
+#endif
+	// Bilateral box-filter over a quad for free, respecting depth edges
+	// (the difference that this makes is subtle)
+	if (abs(dFdx(C.z)) < 0.02) {
+		A -= dFdx(A) * ((ssC.x & 1) - 0.5);
+	}
+	if (abs(dFdy(C.z)) < 0.02) {
+		A -= dFdy(A) * ((ssC.y & 1) - 0.5);
+	}
+
+	visibility = A;
+
+}
+
+
+

drivers/gles3/shaders/ssao_blur.glsl

@@ -0,0 +1,113 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+
+
+void main() {
+
+	gl_Position = vertex_attrib;
+	gl_Position.z=1.0;
+}
+
+[fragment]
+
+
+uniform sampler2D source_ssao; //texunit:0
+uniform sampler2D source_depth; //texunit:1
+
+
+layout(location = 0) out float visibility;
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Tunable Parameters:
+
+/** Increase to make depth edges crisper. Decrease to reduce flicker. */
+#define EDGE_SHARPNESS     (1.0)
+
+/** Step in 2-pixel intervals since we already blurred against neighbors in the
+    first AO pass.  This constant can be increased while R decreases to improve
+    performance at the expense of some dithering artifacts.
+
+    Morgan found that a scale of 3 left a 1-pixel checkerboard grid that was
+    unobjectionable after shading was applied but eliminated most temporal incoherence
+    from using small numbers of sample taps.
+    */
+#define SCALE               (3)
+
+/** Filter radius in pixels. This will be multiplied by SCALE. */
+#define R                   (4)
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+
+// Gaussian coefficients
+const float gaussian[R + 1] =
+//    float[](0.356642, 0.239400, 0.072410, 0.009869);
+//    float[](0.398943, 0.241971, 0.053991, 0.004432, 0.000134);  // stddev = 1.0
+    float[](0.153170, 0.144893, 0.122649, 0.092902, 0.062970);  // stddev = 2.0
+//      float[](0.111220, 0.107798, 0.098151, 0.083953, 0.067458, 0.050920, 0.036108); // stddev = 3.0
+
+/** (1, 0) or (0, 1)*/
+uniform ivec2       axis;
+
+uniform float camera_z_far;
+uniform float camera_z_near;
+
+void main() {
+
+	ivec2 ssC = ivec2(gl_FragCoord.xy);
+
+	float depth = texelFetch(source_depth, ssC, 0).r;
+
+	depth = depth * 2.0 - 1.0;
+	depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+
+	float depth_divide = 1.0 / camera_z_far;
+
+	depth*=depth_divide;
+
+	//if (depth > camera_z_far*0.999) {
+	//	discard;//skybox
+	//}
+
+	float sum = texelFetch(source_ssao, ssC, 0).r;
+
+	// Base weight for depth falloff.  Increase this for more blurriness,
+	// decrease it for better edge discrimination
+	float BASE = gaussian[0];
+	float totalWeight = BASE;
+	sum *= totalWeight;
+
+
+	for (int r = -R; r <= R; ++r) {
+		// We already handled the zero case above.  This loop should be unrolled and the static branch optimized out,
+		// so the IF statement has no runtime cost
+		if (r != 0) {
+
+			ivec2 ppos = ssC + axis * (r * SCALE);
+			float value = texelFetch(source_ssao, ppos, 0).r;
+			float temp_depth = texelFetch(source_depth, ssC, 0).r;
+
+			temp_depth = temp_depth * 2.0 - 1.0;
+			temp_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - temp_depth * (camera_z_far - camera_z_near));
+			temp_depth *= depth_divide;
+
+			// spatial domain: offset gaussian tap
+			float weight = 0.3 + gaussian[abs(r)];
+
+			// range domain (the "bilateral" weight). As depth difference increases, decrease weight.
+			weight *= max(0.0, 1.0
+				      - (EDGE_SHARPNESS * 2000.0) * abs(temp_depth - depth)
+				      );
+
+			sum += value * weight;
+			totalWeight += weight;
+		}
+	}
+
+	const float epsilon = 0.0001;
+	visibility = sum / (totalWeight + epsilon);
+}

drivers/gles3/shaders/ssao_minify.glsl

@@ -0,0 +1,55 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+
+void main() {
+
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+
+#ifdef MINIFY_START
+
+#define SDEPTH_TYPE highp sampler2D
+uniform float camera_z_far;
+uniform float camera_z_near;
+
+#else
+
+#define SDEPTH_TYPE mediump usampler2D
+
+#endif
+
+uniform SDEPTH_TYPE source_depth; //texunit:0
+
+uniform ivec2 from_size;
+uniform int source_mipmap;
+
+layout(location = 0) out mediump uint depth;
+
+void main() {
+
+
+	ivec2 ssP = ivec2(gl_FragCoord.xy);
+
+	  // Rotated grid subsampling to avoid XY directional bias or Z precision bias while downsampling.
+	  // On DX9, the bit-and can be implemented with floating-point modulo
+
+#ifdef MINIFY_START
+	float fdepth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
+	fdepth = fdepth * 2.0 - 1.0;
+	fdepth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - fdepth * (camera_z_far - camera_z_near));
+	fdepth /= camera_z_far;
+	depth = uint(clamp(fdepth*65535,0.0,65535.0));
+
+#else
+	depth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
+#endif
+
+
+}
+
+

drivers/gles3/shaders/subsurf_scattering.glsl

@@ -0,0 +1,172 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+
+
+void main() {
+
+	uv_interp = uv_in;
+	gl_Position = vertex_attrib;
+}
+
+[fragment]
+
+//#define QUALIFIER uniform // some guy on the interweb says it may be faster with this
+#define QUALIFIER const
+
+#ifdef USE_25_SAMPLES
+
+const int kernel_size=25;
+QUALIFIER vec4 kernel[25] = vec4[] (
+    vec4(0.530605, 0.613514, 0.739601, 0.0),
+    vec4(0.000973794, 1.11862e-005, 9.43437e-007, -3.0),
+    vec4(0.00333804, 7.85443e-005, 1.2945e-005, -2.52083),
+    vec4(0.00500364, 0.00020094, 5.28848e-005, -2.08333),
+    vec4(0.00700976, 0.00049366, 0.000151938, -1.6875),
+    vec4(0.0094389, 0.00139119, 0.000416598, -1.33333),
+    vec4(0.0128496, 0.00356329, 0.00132016, -1.02083),
+    vec4(0.017924, 0.00711691, 0.00347194, -0.75),
+    vec4(0.0263642, 0.0119715, 0.00684598, -0.520833),
+    vec4(0.0410172, 0.0199899, 0.0118481, -0.333333),
+    vec4(0.0493588, 0.0367726, 0.0219485, -0.1875),
+    vec4(0.0402784, 0.0657244, 0.04631, -0.0833333),
+    vec4(0.0211412, 0.0459286, 0.0378196, -0.0208333),
+    vec4(0.0211412, 0.0459286, 0.0378196, 0.0208333),
+    vec4(0.0402784, 0.0657244, 0.04631, 0.0833333),
+    vec4(0.0493588, 0.0367726, 0.0219485, 0.1875),
+    vec4(0.0410172, 0.0199899, 0.0118481, 0.333333),
+    vec4(0.0263642, 0.0119715, 0.00684598, 0.520833),
+    vec4(0.017924, 0.00711691, 0.00347194, 0.75),
+    vec4(0.0128496, 0.00356329, 0.00132016, 1.02083),
+    vec4(0.0094389, 0.00139119, 0.000416598, 1.33333),
+    vec4(0.00700976, 0.00049366, 0.000151938, 1.6875),
+    vec4(0.00500364, 0.00020094, 5.28848e-005, 2.08333),
+    vec4(0.00333804, 7.85443e-005, 1.2945e-005, 2.52083),
+    vec4(0.000973794, 1.11862e-005, 9.43437e-007, 3.0)
+);
+
+#endif //USE_25_SAMPLES
+
+#ifdef USE_17_SAMPLES
+
+const int kernel_size=17;
+
+QUALIFIER vec4 kernel[17] = vec4[](
+    vec4(0.536343, 0.624624, 0.748867, 0.0),
+    vec4(0.00317394, 0.000134823, 3.77269e-005, -2.0),
+    vec4(0.0100386, 0.000914679, 0.000275702, -1.53125),
+    vec4(0.0144609, 0.00317269, 0.00106399, -1.125),
+    vec4(0.0216301, 0.00794618, 0.00376991, -0.78125),
+    vec4(0.0347317, 0.0151085, 0.00871983, -0.5),
+    vec4(0.0571056, 0.0287432, 0.0172844, -0.28125),
+    vec4(0.0582416, 0.0659959, 0.0411329, -0.125),
+    vec4(0.0324462, 0.0656718, 0.0532821, -0.03125),
+    vec4(0.0324462, 0.0656718, 0.0532821, 0.03125),
+    vec4(0.0582416, 0.0659959, 0.0411329, 0.125),
+    vec4(0.0571056, 0.0287432, 0.0172844, 0.28125),
+    vec4(0.0347317, 0.0151085, 0.00871983, 0.5),
+    vec4(0.0216301, 0.00794618, 0.00376991, 0.78125),
+    vec4(0.0144609, 0.00317269, 0.00106399, 1.125),
+    vec4(0.0100386, 0.000914679, 0.000275702, 1.53125),
+    vec4(0.00317394, 0.000134823, 3.77269e-005, 2.0)
+);
+
+#endif //USE_17_SAMPLES
+
+
+#ifdef USE_11_SAMPLES
+
+const int kernel_size=11;
+
+QUALIFIER vec4 kernel[11] = vec4[](
+    vec4(0.560479, 0.669086, 0.784728, 0.0),
+    vec4(0.00471691, 0.000184771, 5.07566e-005, -2.0),
+    vec4(0.0192831, 0.00282018, 0.00084214, -1.28),
+    vec4(0.03639, 0.0130999, 0.00643685, -0.72),
+    vec4(0.0821904, 0.0358608, 0.0209261, -0.32),
+    vec4(0.0771802, 0.113491, 0.0793803, -0.08),
+    vec4(0.0771802, 0.113491, 0.0793803, 0.08),
+    vec4(0.0821904, 0.0358608, 0.0209261, 0.32),
+    vec4(0.03639, 0.0130999, 0.00643685, 0.72),
+    vec4(0.0192831, 0.00282018, 0.00084214, 1.28),
+    vec4(0.00471691, 0.000184771, 5.07565e-005, 2.0)
+);
+
+#endif //USE_11_SAMPLES
+
+
+uniform float max_radius;
+uniform float fovy;
+uniform float camera_z_far;
+uniform float camera_z_near;
+uniform vec2 dir;
+in vec2 uv_interp;
+
+uniform sampler2D source_diffuse; //texunit:0
+uniform sampler2D source_motion_ss; //texunit:1
+uniform sampler2D source_depth; //texunit:2
+
+layout(location = 0) out vec4 frag_color;
+
+void main() {
+
+	float strength = texture(source_motion_ss,uv_interp).a;
+	strength*=strength; //stored as sqrt
+
+	// Fetch color of current pixel:
+	vec4 base_color = texture(source_diffuse, uv_interp);
+
+	if (strength>0.0) {
+
+
+		// Fetch linear depth of current pixel:
+		float depth = texture(source_depth, uv_interp).r * 2.0 - 1.0;
+		depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
+		depth=-depth;
+
+
+		// Calculate the radius scale (1.0 for a unit plane sitting on the
+		// projection window):
+		float distance = 1.0 / tan(0.5 * fovy);
+		float scale = distance / -depth; //remember depth is negative by default in OpenGL
+
+		// Calculate the final step to fetch the surrounding pixels:
+		vec2 step = max_radius * scale * dir;
+		step *= strength; // Modulate it using the alpha channel.
+		step *= 1.0 / 3.0; // Divide by 3 as the kernels range from -3 to 3.
+
+		// Accumulate the center sample:
+		vec3 color_accum = base_color.rgb;
+		color_accum *= kernel[0].rgb;
+
+		// Accumulate the other samples:
+		for (int i = 1; i < kernel_size; i++) {
+			// Fetch color and depth for current sample:
+			vec2 offset = uv_interp + kernel[i].a * step;
+			vec3 color = texture(source_diffuse, offset).rgb;
+
+#ifdef ENABLE_FOLLOW_SURFACE
+			// If the difference in depth is huge, we lerp color back to "colorM":
+			float depth_cmp = texture(source_depth, offset).r *2.0 - 1.0;
+			depth_cmp = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth_cmp * (camera_z_far - camera_z_near));
+			depth_cmp=-depth_cmp;
+
+			float s = clamp(300.0f * distance *
+					       max_radius * abs(depth - depth_cmp),0.0,1.0);
+			color = mix(color, base_color.rgb, s);
+#endif
+
+			// Accumulate:
+			color_accum += kernel[i].rgb * color;
+		}
+
+		frag_color = vec4(color_accum,base_color.a); //keep alpha (used for SSAO)
+	} else {
+		frag_color = base_color;
+	}
+}
+

drivers/gles3/shaders/tonemap.glsl

@@ -0,0 +1,263 @@
+[vertex]
+
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=4) in vec2 uv_in;
+
+out vec2 uv_interp;
+
+
+
+void main() {
+
+	gl_Position = vertex_attrib;
+	uv_interp = uv_in;
+
+}
+
+[fragment]
+
+
+in vec2 uv_interp;
+
+uniform highp sampler2D source; //texunit:0
+
+uniform float exposure;
+uniform float white;
+
+#ifdef USE_AUTO_EXPOSURE
+
+uniform highp sampler2D source_auto_exposure; //texunit:1
+uniform highp float auto_exposure_grey;
+
+#endif
+
+#if defined(USE_GLOW_LEVEL1) || defined(USE_GLOW_LEVEL2) || defined(USE_GLOW_LEVEL3) || defined(USE_GLOW_LEVEL4) || defined(USE_GLOW_LEVEL5) || defined(USE_GLOW_LEVEL6) || defined(USE_GLOW_LEVEL7)
+
+uniform highp sampler2D source_glow; //texunit:2
+uniform highp float glow_intensity;
+
+#endif
+
+layout(location = 0) out vec4 frag_color;
+
+#ifdef USE_GLOW_FILTER_BICUBIC
+
+// w0, w1, w2, and w3 are the four cubic B-spline basis functions
+float w0(float a)
+{
+    return (1.0/6.0)*(a*(a*(-a + 3.0) - 3.0) + 1.0);
+}
+
+float w1(float a)
+{
+    return (1.0/6.0)*(a*a*(3.0*a - 6.0) + 4.0);
+}
+
+float w2(float a)
+{
+    return (1.0/6.0)*(a*(a*(-3.0*a + 3.0) + 3.0) + 1.0);
+}
+
+float w3(float a)
+{
+    return (1.0/6.0)*(a*a*a);
+}
+
+// g0 and g1 are the two amplitude functions
+float g0(float a)
+{
+    return w0(a) + w1(a);
+}
+
+float g1(float a)
+{
+    return w2(a) + w3(a);
+}
+
+// h0 and h1 are the two offset functions
+float h0(float a)
+{
+    return -1.0 + w1(a) / (w0(a) + w1(a));
+}
+
+float h1(float a)
+{
+    return 1.0 + w3(a) / (w2(a) + w3(a));
+}
+
+uniform ivec2 glow_texture_size;
+
+vec4 texture2D_bicubic(sampler2D tex, vec2 uv,int p_lod)
+{
+	float lod=float(p_lod);
+	vec2 tex_size = vec2(glow_texture_size >> p_lod);
+	vec2 pixel_size =1.0/tex_size;
+	uv = uv*tex_size + 0.5;
+	vec2 iuv = floor( uv );
+	vec2 fuv = fract( uv );
+
+	float g0x = g0(fuv.x);
+	float g1x = g1(fuv.x);
+	float h0x = h0(fuv.x);
+	float h1x = h1(fuv.x);
+	float h0y = h0(fuv.y);
+	float h1y = h1(fuv.y);
+
+	vec2 p0 = (vec2(iuv.x + h0x, iuv.y + h0y) - 0.5) * pixel_size;
+	vec2 p1 = (vec2(iuv.x + h1x, iuv.y + h0y) - 0.5) * pixel_size;
+	vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - 0.5) * pixel_size;
+	vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - 0.5) * pixel_size;
+
+	return g0(fuv.y) * (g0x * textureLod(tex, p0,lod)  +
+			    g1x * textureLod(tex, p1,lod)) +
+			g1(fuv.y) * (g0x * textureLod(tex, p2,lod)  +
+				     g1x * textureLod(tex, p3,lod));
+}
+
+
+
+#define GLOW_TEXTURE_SAMPLE(m_tex,m_uv,m_lod) texture2D_bicubic(m_tex,m_uv,m_lod)
+
+#else
+
+#define GLOW_TEXTURE_SAMPLE(m_tex,m_uv,m_lod) textureLod(m_tex,m_uv,float(m_lod))
+
+#endif
+
+
+void main() {
+
+	ivec2 coord = ivec2(gl_FragCoord.xy);
+	vec3 color = texelFetch(source,coord,0).rgb;
+
+
+#ifdef USE_AUTO_EXPOSURE
+
+	color/=texelFetch(source_auto_exposure,ivec2(0,0),0).r/auto_exposure_grey;
+#endif
+
+	color*=exposure;
+
+
+#if defined(USE_GLOW_LEVEL1) || defined(USE_GLOW_LEVEL2) || defined(USE_GLOW_LEVEL3) || defined(USE_GLOW_LEVEL4) || defined(USE_GLOW_LEVEL5) || defined(USE_GLOW_LEVEL6) || defined(USE_GLOW_LEVEL7)
+	vec3 glow = vec3(0.0);
+
+#ifdef USE_GLOW_LEVEL1
+
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,1).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL2
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,2).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL3
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,3).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL4
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,4).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL5
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,5).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL6
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,6).rgb;
+#endif
+
+#ifdef USE_GLOW_LEVEL7
+	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,7).rgb;
+#endif
+
+
+	glow *= glow_intensity;
+
+
+
+#ifdef USE_GLOW_REPLACE
+
+	color.rgb = glow;
+
+#endif
+
+#ifdef USE_GLOW_SCREEN
+
+	color.rgb = clamp((color.rgb + glow) - (color.rgb * glow), 0.0, 1.0);
+
+#endif
+
+#ifdef USE_GLOW_SOFTLIGHT
+
+	{
+
+		glow = (glow * 0.5) + 0.5;
+		color.r =  (glow.r <= 0.5) ? (color.r - (1.0 - 2.0 * glow.r) * color.r * (1.0 - color.r)) : (((glow.r > 0.5) && (color.r <= 0.25)) ? (color.r + (2.0 * glow.r - 1.0) * (4.0 * color.r * (4.0 * color.r + 1.0) * (color.r - 1.0) + 7.0 * color.r)) : (color.r + (2.0 * glow.r - 1.0) * (sqrt(color.r) - color.r)));
+		color.g =  (glow.g <= 0.5) ? (color.g - (1.0 - 2.0 * glow.g) * color.g * (1.0 - color.g)) : (((glow.g > 0.5) && (color.g <= 0.25)) ? (color.g + (2.0 * glow.g - 1.0) * (4.0 * color.g * (4.0 * color.g + 1.0) * (color.g - 1.0) + 7.0 * color.g)) : (color.g + (2.0 * glow.g - 1.0) * (sqrt(color.g) - color.g)));
+		color.b =  (glow.b <= 0.5) ? (color.b - (1.0 - 2.0 * glow.b) * color.b * (1.0 - color.b)) : (((glow.b > 0.5) && (color.b <= 0.25)) ? (color.b + (2.0 * glow.b - 1.0) * (4.0 * color.b * (4.0 * color.b + 1.0) * (color.b - 1.0) + 7.0 * color.b)) : (color.b + (2.0 * glow.b - 1.0) * (sqrt(color.b) - color.b)));
+	}
+
+#endif
+
+#if !defined(USE_GLOW_SCREEN) && !defined(USE_GLOW_SOFTLIGHT) && !defined(USE_GLOW_REPLACE)
+	color.rgb+=glow;
+#endif
+
+
+#endif
+
+
+#ifdef USE_REINDHART_TONEMAPPER
+
+	{
+		color.rgb = ( color.rgb * ( 1.0 + ( color.rgb / ( white) ) ) ) / ( 1.0 + color.rgb );
+
+	}
+#endif
+
+#ifdef USE_FILMIC_TONEMAPPER
+
+	{
+
+		float A = 0.15;
+		float B = 0.50;
+		float C = 0.10;
+		float D = 0.20;
+		float E = 0.02;
+		float F = 0.30;
+		float W = 11.2;
+
+		vec3 coltn = ((color.rgb*(A*color.rgb+C*B)+D*E)/(color.rgb*(A*color.rgb+B)+D*F))-E/F;
+		float whitetn = ((white*(A*white+C*B)+D*E)/(white*(A*white+B)+D*F))-E/F;
+
+		color.rgb=coltn/whitetn;
+
+	}
+#endif
+
+#ifdef USE_ACES_TONEMAPPER
+
+	{
+		float a = 2.51f;
+		float b = 0.03f;
+		float c = 2.43f;
+		float d = 0.59f;
+		float e = 0.14f;
+		color.rgb = clamp((color.rgb*(a*color.rgb+b))/(color.rgb*(c*color.rgb+d)+e),vec3(0.0),vec3(1.0));
+	}
+
+#endif
+
+	//regular Linear -> SRGB conversion
+	vec3 a = vec3(0.055);
+	color.rgb = mix( (vec3(1.0)+a)*pow(color.rgb,vec3(1.0/2.4))-a , 12.92*color.rgb , lessThan(color.rgb,vec3(0.0031308)));
+
+
+
+
+	frag_color=vec4(color.rgb,1.0);
+}
+
+

drivers/png/image_loader_png.cpp

@@ -114,25 +114,36 @@ Error ImageLoaderPNG::_load_image(void *rf_up,png_rw_ptr p_func,Image *p_image)
 	printf("Color type:%i\n", color);
 	*/
 
+	bool update_info=false;
+
 	if (depth<8) { //only bit dept 8 per channel is handled
 
 		png_set_packing(png);
+		update_info=true;
+
 	};
 
+	if (png_get_color_type(png,info)==PNG_COLOR_TYPE_PALETTE) {
+		png_set_palette_to_rgb(png);
+		update_info=true;
+	}
+
 	if (depth > 8) {
 		png_set_strip_16(png);
-		png_read_update_info(png, info);
+		update_info=true;
 	}
 
 	if (png_get_valid(png,info,PNG_INFO_tRNS)) {
 //		png_set_expand_gray_1_2_4_to_8(png);
 		png_set_tRNS_to_alpha(png);
+		update_info=true;
+	}
+
+	if (update_info) {
 		png_read_update_info(png, info);
 		png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL);
 	}
 
-	int palette_colors = 0;
-	int palette_components = 0;
 	int components = 0;
 
 	Image::Format fmt;
@@ -141,38 +152,24 @@ Error ImageLoaderPNG::_load_image(void *rf_up,png_rw_ptr p_func,Image *p_image)
 
 		case PNG_COLOR_TYPE_GRAY: {
 
-			fmt=Image::FORMAT_GRAYSCALE;
+			fmt=Image::FORMAT_L8;
 			components=1;
 		} break;
 		case PNG_COLOR_TYPE_GRAY_ALPHA: {
 
-			fmt=Image::FORMAT_GRAYSCALE_ALPHA;
+			fmt=Image::FORMAT_LA8;
 			components=2;
 		} break;
 		case PNG_COLOR_TYPE_RGB: {
 
-			fmt=Image::FORMAT_RGB;
+			fmt=Image::FORMAT_RGB8;
 			components=3;
 		} break;
 		case PNG_COLOR_TYPE_RGB_ALPHA: {
 
-			fmt=Image::FORMAT_RGBA;
+			fmt=Image::FORMAT_RGBA8;
 			components=4;
-		} break;
-		case PNG_COLOR_TYPE_PALETTE: {
-
-			int ntrans = 0;
-			png_get_tRNS(png, info, NULL, &ntrans, NULL);
-			//printf("transparent colors %i\n", ntrans);
-
-			fmt = ntrans > 0 ? Image::FORMAT_INDEXED_ALPHA : Image::FORMAT_INDEXED;
-			palette_components = ntrans > 0 ? 4 : 3;
-			components = 1;
-
-			png_colorp colors;
-			png_get_PLTE(png, info, &colors, &palette_colors);
-
-		} break;
+		} break;		
 		default: {
 
 			ERR_PRINT("INVALID PNG TYPE");
@@ -186,7 +183,7 @@ Error ImageLoaderPNG::_load_image(void *rf_up,png_rw_ptr p_func,Image *p_image)
 
 	DVector<uint8_t> dstbuff;
 
-	dstbuff.resize( rowsize * height + palette_components * 256 ); // alloc the entire palette? - yes always
+	dstbuff.resize( rowsize * height  );
 
 	DVector<uint8_t>::Write dstbuff_write = dstbuff.write();
 
@@ -200,38 +197,6 @@ Error ImageLoaderPNG::_load_image(void *rf_up,png_rw_ptr p_func,Image *p_image)
 
 	png_read_image(png, (png_bytep*)row_p);
 
-	if (palette_colors) {
-
-		uint8_t *r_pal = &data[components*width*height]; // end of the array
-		png_colorp colors;
-		int num;
-		png_get_PLTE(png, info, &colors, &num);
-
-		int ofs = 0;
-		for (int i=0; i < palette_colors; i++) {
-
-			r_pal[ofs + 0] = colors[i].red;
-			r_pal[ofs + 1] = colors[i].green;
-			r_pal[ofs + 2] = colors[i].blue;
-			if (palette_components == 4) {
-				r_pal[ofs + 3] = 255;
-			};
-			ofs += palette_components;
-		};
-
-		if (fmt == Image::FORMAT_INDEXED_ALPHA) {
-			png_color_16p alphas;
-			png_bytep alpha_idx;
-			int count;
-			png_get_tRNS(png, info, &alpha_idx, &count, &alphas);
-			for (int i=0; i<count; i++) {
-
-				//printf("%i: loading alpha fron transparent color %i, values %i, %i, %i, %i, %i\n", i, (int)alpha_idx[i], (int)alphas[i].index, (int)alphas[i].red, (int)alphas[i].green, (int)alphas[i].blue, (int)alphas[i].gray);
-				//r_pal[alpha_idx[i]] = alphas[i].gray >> 8;
-				r_pal[i*4+3] = alpha_idx[i];
-			};
-		};
-	};
 
 	memdelete_arr( row_p );
 
@@ -325,11 +290,11 @@ static DVector<uint8_t> _lossless_pack_png(const Image& p_image) {
 
 
 	Image img = p_image;
-	if (img.get_format() > Image::FORMAT_INDEXED_ALPHA)
+	if (img.is_compressed())
 		img.decompress();
 
 
-	ERR_FAIL_COND_V(img.get_format() > Image::FORMAT_INDEXED_ALPHA, DVector<uint8_t>());
+	ERR_FAIL_COND_V(img.is_compressed(), DVector<uint8_t>());
 
 	png_structp png_ptr;
 	png_infop info_ptr;
@@ -366,22 +331,22 @@ static DVector<uint8_t> _lossless_pack_png(const Image& p_image) {
 
 	switch(img.get_format()) {
 
-		case Image::FORMAT_GRAYSCALE: {
+		case Image::FORMAT_L8: {
 
 			pngf=PNG_COLOR_TYPE_GRAY;
 			cs=1;
 		} break;
-		case Image::FORMAT_GRAYSCALE_ALPHA: {
+		case Image::FORMAT_LA8: {
 
 			pngf=PNG_COLOR_TYPE_GRAY_ALPHA;
 			cs=2;
 		} break;
-		case Image::FORMAT_RGB: {
+		case Image::FORMAT_RGB8: {
 
 			pngf=PNG_COLOR_TYPE_RGB;
 			cs=3;
 		} break;
-		case Image::FORMAT_RGBA: {
+		case Image::FORMAT_RGBA8: {
 
 			pngf=PNG_COLOR_TYPE_RGB_ALPHA;
 			cs=4;
@@ -390,12 +355,12 @@ static DVector<uint8_t> _lossless_pack_png(const Image& p_image) {
 
 			if (img.detect_alpha()) {
 
-				img.convert(Image::FORMAT_RGBA);
+				img.convert(Image::FORMAT_RGBA8);
 				pngf=PNG_COLOR_TYPE_RGB_ALPHA;
 				cs=4;
 			} else {
 
-				img.convert(Image::FORMAT_RGB);
+				img.convert(Image::FORMAT_RGB8);
 				pngf=PNG_COLOR_TYPE_RGB;
 				cs=3;
 			}

drivers/png/resource_saver_png.cpp

@@ -98,10 +98,10 @@ Error ResourceSaverPNG::save(const String &p_path,const RES& p_resource,uint32_t
 
 Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
 
-	if (p_img.get_format() > Image::FORMAT_INDEXED_ALPHA)
+	if (p_img.is_compressed())
 		p_img.decompress();
 
-	ERR_FAIL_COND_V(p_img.get_format() > Image::FORMAT_INDEXED_ALPHA, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_img.is_compressed(), ERR_INVALID_PARAMETER);
 
 	png_structp png_ptr;
 	png_infop info_ptr;
@@ -140,22 +140,22 @@ Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
 
 	switch(p_img.get_format()) {
 
-		case Image::FORMAT_GRAYSCALE: {
+		case Image::FORMAT_L8: {
 
 			pngf=PNG_COLOR_TYPE_GRAY;
 			cs=1;
 		} break;
-		case Image::FORMAT_GRAYSCALE_ALPHA: {
+		case Image::FORMAT_LA8: {
 
 			pngf=PNG_COLOR_TYPE_GRAY_ALPHA;
 			cs=2;
 		} break;
-		case Image::FORMAT_RGB: {
+		case Image::FORMAT_RGB8: {
 
 			pngf=PNG_COLOR_TYPE_RGB;
 			cs=3;
 		} break;
-		case Image::FORMAT_RGBA: {
+		case Image::FORMAT_RGBA8: {
 
 			pngf=PNG_COLOR_TYPE_RGB_ALPHA;
 			cs=4;
@@ -164,12 +164,12 @@ Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
 
 			if (p_img.detect_alpha()) {
 
-				p_img.convert(Image::FORMAT_RGBA);
+				p_img.convert(Image::FORMAT_RGBA8);
 				pngf=PNG_COLOR_TYPE_RGB_ALPHA;
 				cs=4;
 			} else {
 
-				p_img.convert(Image::FORMAT_RGB);
+				p_img.convert(Image::FORMAT_RGB8);
 				pngf=PNG_COLOR_TYPE_RGB;
 				cs=3;
 			}

drivers/unix/os_unix.cpp

@@ -88,6 +88,10 @@ void OS_Unix::print_error(const char* p_function,const char* p_file,int p_line,c
 			print("\E[1;35mSCRIPT ERROR: %s: \E[0m\E[1m%s\n",p_function,err_details);
 			print("\E[0;35m   At: %s:%i.\E[0m\n",p_file,p_line);
 			break;
+		case ERR_SHADER:
+			print("\E[1;36mSHADER ERROR: %s: \E[0m\E[1m%s\n",p_function,err_details);
+			print("\E[0;36m   At: %s:%i.\E[0m\n",p_file,p_line);
+			break;
 	}
 }
 

main/main.cpp

@@ -1295,6 +1295,17 @@ bool Main::start() {
 			appname = TranslationServer::get_singleton()->translate(appname);
 			OS::get_singleton()->set_window_title(appname);
 
+			int shadow_atlas_size = GLOBAL_DEF("rendering/shadow_atlas/size",2048);
+			int shadow_atlas_q0_subdiv = GLOBAL_DEF("rendering/shadow_atlas/quadrant_0_subdiv",2);
+			int shadow_atlas_q1_subdiv = GLOBAL_DEF("rendering/shadow_atlas/quadrant_1_subdiv",2);
+			int shadow_atlas_q2_subdiv = GLOBAL_DEF("rendering/shadow_atlas/quadrant_2_subdiv",3);
+			int shadow_atlas_q3_subdiv = GLOBAL_DEF("rendering/shadow_atlas/quadrant_3_subdiv",4);
+
+			sml->get_root()->set_shadow_atlas_size(shadow_atlas_size);
+			sml->get_root()->set_shadow_atlas_quadrant_subdiv(0,Viewport::ShadowAtlasQuadrantSubdiv(shadow_atlas_q0_subdiv));
+			sml->get_root()->set_shadow_atlas_quadrant_subdiv(1,Viewport::ShadowAtlasQuadrantSubdiv(shadow_atlas_q1_subdiv));
+			sml->get_root()->set_shadow_atlas_quadrant_subdiv(2,Viewport::ShadowAtlasQuadrantSubdiv(shadow_atlas_q2_subdiv));
+			sml->get_root()->set_shadow_atlas_quadrant_subdiv(3,Viewport::ShadowAtlasQuadrantSubdiv(shadow_atlas_q3_subdiv));
 
 		} else {
 			GLOBAL_DEF("display/stretch_mode","disabled");
@@ -1303,7 +1314,17 @@ bool Main::start() {
 			Globals::get_singleton()->set_custom_property_info("display/stretch_aspect",PropertyInfo(Variant::STRING,"display/stretch_aspect",PROPERTY_HINT_ENUM,"ignore,keep,keep_width,keep_height"));
 			sml->set_auto_accept_quit(GLOBAL_DEF("application/auto_accept_quit",true));
 
-
+			GLOBAL_DEF("rendering/shadow_atlas/size",2048);
+			Globals::get_singleton()->set_custom_property_info("rendering/shadow_atlas/size",PropertyInfo(Variant::INT,"rendering/shadow_atlas/size",PROPERTY_HINT_RANGE,"256,16384"));
+
+			GLOBAL_DEF("rendering/shadow_atlas/quadrant_0_subdiv",2);
+			GLOBAL_DEF("rendering/shadow_atlas/quadrant_1_subdiv",2);
+			GLOBAL_DEF("rendering/shadow_atlas/quadrant_2_subdiv",3);
+			GLOBAL_DEF("rendering/shadow_atlas/quadrant_3_subdiv",4);
+			Globals::get_singleton()->set_custom_property_info("rendering/shadow_atlas/quadrant_0_subdiv",PropertyInfo(Variant::INT,"rendering/shadow_atlas/quadrant_0_subdiv",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"));
+			Globals::get_singleton()->set_custom_property_info("rendering/shadow_atlas/quadrant_1_subdiv",PropertyInfo(Variant::INT,"rendering/shadow_atlas/quadrant_1_subdiv",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"));
+			Globals::get_singleton()->set_custom_property_info("rendering/shadow_atlas/quadrant_2_subdiv",PropertyInfo(Variant::INT,"rendering/shadow_atlas/quadrant_2_subdiv",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"));
+			Globals::get_singleton()->set_custom_property_info("rendering/shadow_atlas/quadrant_3_subdiv",PropertyInfo(Variant::INT,"rendering/shadow_atlas/quadrant_3_subdiv",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"));
 		}
 
 

methods.py

@@ -122,7 +122,7 @@ def build_glsl_header(filename):
                 uline = line[:line.lower().find("//")]
                 uline = uline[uline.find("uniform") + len("uniform"):]
                 uline = uline.replace(";", "")
-                uline = uline.replace("{", "")
+                uline = uline.replace("{", "").strip()
                 lines = uline.split(",")
                 for x in lines:
 
@@ -228,6 +228,7 @@ def build_glsl_header(filename):
 
         fd.write("\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable)  {  _set_conditional(p_conditional,p_enable); }\n\n")
     fd.write("\t#define _FU if (get_uniform(p_uniform)<0) return; ERR_FAIL_COND( get_active()!=this );\n\n ")
+    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, bool p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value?1:0); }\n\n")
     fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
     fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
     fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
@@ -655,6 +656,7 @@ class LegacyGLHeaderStruct:
         self.fragment_lines = []
         self.uniforms = []
         self.attributes = []
+        self.feedbacks = []
         self.fbos = []
         self.conditionals = []
         self.enums = {}
@@ -753,7 +755,29 @@ def include_file_in_legacygl_header(filename, header_data, depth):
                     header_data.texunits += [(x, texunit)]
                     header_data.texunit_names += [x]
 
-        elif (line.find("uniform") != -1):
+        elif (line.find("uniform") != -1 and line.lower().find("ubo:") != -1):
+            # uniform buffer object
+            ubostr = line[line.find(":") + 1:].strip()
+            ubo = str(int(ubostr))
+            uline = line[:line.lower().find("//")]
+            uline = uline[uline.find("uniform") + len("uniform"):]
+            uline = uline.replace("highp", "")
+            uline = uline.replace(";", "")
+            uline = uline.replace("{", "").strip()
+            lines = uline.split(",")
+            for x in lines:
+
+                x = x.strip()
+                x = x[x.rfind(" ") + 1:]
+                if (x.find("[") != -1):
+                    # unfiorm array
+                    x = x[:x.find("[")]
+
+                if (not x in header_data.ubo_names):
+                    header_data.ubos += [(x, ubo)]
+                    header_data.ubo_names += [x]
+
+        elif (line.find("uniform") != -1 and line.find("{") == -1 and line.find(";") != -1):
             uline = line.replace("uniform", "")
             uline = uline.replace(";", "")
             lines = uline.split(",")
@@ -768,7 +792,7 @@ def include_file_in_legacygl_header(filename, header_data, depth):
                 if (not x in header_data.uniforms):
                     header_data.uniforms += [x]
 
-        if ((line.strip().find("in ") == 0 or line.strip().find("attribute ") == 0) and line.find("attrib:") != -1):
+        if (line.strip().find("attribute ") == 0 and line.find("attrib:") != -1):
             uline = line.replace("in ", "")
             uline = uline.replace("attribute ", "")
             uline = uline.replace("highp ", "")
@@ -782,6 +806,19 @@ def include_file_in_legacygl_header(filename, header_data, depth):
                     bind = bind.replace("attrib:", "").strip()
                     header_data.attributes += [(name, bind)]
 
+        if (line.strip().find("out ") == 0 and line.find("tfb:") != -1):
+            uline = line.replace("out ", "")
+            uline = uline.replace("highp ", "")
+            uline = uline.replace(";", "")
+            uline = uline[uline.find(" "):].strip()
+
+            if (uline.find("//") != -1):
+                name, bind = uline.split("//")
+                if (bind.find("tfb:") != -1):
+                    name = name.strip()
+                    bind = bind.replace("tfb:", "").strip()
+                    header_data.feedbacks += [(name, bind)]
+
         line = line.replace("\r", "")
         line = line.replace("\n", "")
         # line=line.replace("\\","\\\\")
@@ -991,12 +1028,14 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs):
         fd.write("\t\tstatic const Enum *_enums=NULL;\n")
         fd.write("\t\tstatic const EnumValue *_enum_values=NULL;\n")
 
+    conditionals_found = []
     if (len(header_data.conditionals)):
 
         fd.write("\t\tstatic const char* _conditional_strings[]={\n")
         if (len(header_data.conditionals)):
             for x in header_data.conditionals:
                 fd.write("\t\t\t\"#define " + x + "\\n\",\n")
+                conditionals_found.append(x)
         fd.write("\t\t};\n\n")
     else:
         fd.write("\t\tstatic const char **_conditional_strings=NULL;\n")
@@ -1021,6 +1060,25 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs):
         else:
             fd.write("\t\tstatic AttributePair *_attribute_pairs=NULL;\n")
 
+    feedback_count = 0
+
+    if (len(header_data.feedbacks)):
+
+        fd.write("\t\tstatic const Feedback _feedbacks[]={\n")
+        for x in header_data.feedbacks:
+            name = x[0]
+            cond = x[1]
+            if (cond in conditionals_found):
+                fd.write("\t\t\t{\"" + name + "\"," + str(conditionals_found.index(cond)) + "},\n")
+            else:
+                fd.write("\t\t\t{\"" + name + "\",-1},\n")
+
+            feedback_count += 1
+
+        fd.write("\t\t};\n\n")
+    else:
+        fd.write("\t\tstatic const Feedback* _feedbacks=NULL;\n")
+
     if (len(header_data.texunits)):
         fd.write("\t\tstatic TexUnitPair _texunit_pairs[]={\n")
         for x in header_data.texunits:
@@ -1029,6 +1087,14 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs):
     else:
         fd.write("\t\tstatic TexUnitPair *_texunit_pairs=NULL;\n")
 
+    if (len(header_data.ubos)):
+        fd.write("\t\tstatic UBOPair _ubo_pairs[]={\n")
+        for x in header_data.ubos:
+            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
+        fd.write("\t\t};\n\n")
+    else:
+        fd.write("\t\tstatic UBOPair *_ubo_pairs=NULL;\n")
+
     fd.write("\t\tstatic const char _vertex_code[]={\n")
     for x in header_data.vertex_lines:
         for i in range(len(x)):
@@ -1050,9 +1116,9 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs):
     fd.write("\t\tstatic const int _fragment_code_start=" + str(header_data.fragment_offset) + ";\n")
 
     if output_attribs:
-        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_attribute_pairs," + str(len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
+        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_attribute_pairs," + str(len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(feedback_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
     else:
-        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_texunit_pairs," + str(len(header_data.texunits)) + ",_enums," + str(len(header_data.enums)) + ",_enum_values," + str(enum_value_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
+        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_texunit_pairs," + str(len(header_data.texunits)) + ",_enums," + str(len(header_data.enums)) + ",_enum_values," + str(enum_value_count) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(feedback_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
 
     fd.write("\t};\n\n")
 
@@ -1084,6 +1150,12 @@ def build_gles2_headers(target, source, env):
         build_legacygl_header(str(x), include="drivers/gles2/shader_gles2.h", class_suffix="GLES2", output_attribs=True)
 
 
+def build_gles3_headers(target, source, env):
+
+    for x in source:
+        build_legacygl_header(str(x), include="drivers/gles3/shader_gles3.h", class_suffix="GLES3", output_attribs=True)
+
+
 def update_version():
 
     rev = "custom_build"

modules/dds/texture_loader_dds.cpp

@@ -74,21 +74,20 @@ struct DDSFormatInfo {
 
 
 static const DDSFormatInfo dds_format_info[DDS_MAX]={
-	{"DXT1",true,false,4,8,Image::FORMAT_BC1},
-	{"DXT3",true,false,4,16,Image::FORMAT_BC2},
-	{"DXT5",true,false,4,16,Image::FORMAT_BC3},
-	{"ATI1",true,false,4,8,Image::FORMAT_BC4},
-	{"ATI2",true,false,4,16,Image::FORMAT_BC5},
-	{"BGRA8",false,false,1,4,Image::FORMAT_RGBA},
-	{"BGR8",false,false,1,3,Image::FORMAT_RGB},
-	{"RGBA8",false,false,1,4,Image::FORMAT_RGBA},
-	{"RGB8",false,false,1,3,Image::FORMAT_RGB},
-	{"BGR5A1",false,false,1,2,Image::FORMAT_RGBA},
-	{"BGR565",false,false,1,2,Image::FORMAT_RGB},
-	{"BGR10A2",false,false,1,4,Image::FORMAT_RGBA},
-	{"INDEXED",false,true,1,1,Image::FORMAT_INDEXED},
-	{"GRAYSCALE",false,false,1,1,Image::FORMAT_GRAYSCALE},
-	{"GRAYSCALE_ALPHA",false,false,1,2,Image::FORMAT_GRAYSCALE_ALPHA}
+	{"DXT1",true,false,4,8,Image::FORMAT_DXT1},
+	{"DXT3",true,false,4,16,Image::FORMAT_DXT3},
+	{"DXT5",true,false,4,16,Image::FORMAT_DXT5},
+	{"ATI1",true,false,4,8,Image::FORMAT_ATI1},
+	{"ATI2",true,false,4,16,Image::FORMAT_ATI2},
+	{"BGRA8",false,false,1,4,Image::FORMAT_RGBA8},
+	{"BGR8",false,false,1,3,Image::FORMAT_RGB8},
+	{"RGBA8",false,false,1,4,Image::FORMAT_RGBA8},
+	{"RGB8",false,false,1,3,Image::FORMAT_RGB8},
+	{"BGR5A1",false,false,1,2,Image::FORMAT_RGBA8},
+	{"BGR565",false,false,1,2,Image::FORMAT_RGB8},
+	{"BGR10A2",false,false,1,4,Image::FORMAT_RGBA8},
+	{"GRAYSCALE",false,false,1,1,Image::FORMAT_L8},
+	{"GRAYSCALE_ALPHA",false,false,1,2,Image::FORMAT_LA8}
 };
 
 

modules/etc1/image_etc.cpp

@@ -42,7 +42,7 @@ static void _decompress_etc(Image *p_img) {
 
 	DVector<uint8_t>::Read r = src.read();
 
-	int mmc=p_img->get_mipmaps();
+	int mmc=p_img->get_mipmap_count();
 
 
 	for(int i=0;i<=mmc;i++) {
@@ -93,9 +93,9 @@ static void _decompress_etc(Image *p_img) {
 
 	r=DVector<uint8_t>::Read();
 	//print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps()));
-	*p_img=Image(p_img->get_width(),p_img->get_height(),p_img->get_mipmaps(),Image::FORMAT_RGB,dst);
-	if (p_img->get_mipmaps())
-		p_img->generate_mipmaps(-1,true);
+	*p_img=Image(p_img->get_width(),p_img->get_height(),p_img->has_mipmaps(),Image::FORMAT_RGB8,dst);
+	if (p_img->has_mipmaps())
+		p_img->generate_mipmaps(true);
 
 
 }
@@ -108,11 +108,11 @@ static void _compress_etc(Image *p_img) {
 
 	ERR_FAIL_COND( nearest_power_of_2(imgw)!=imgw || nearest_power_of_2(imgh)!=imgh );
 
-	if (img.get_format()!=Image::FORMAT_RGB)
-		img.convert(Image::FORMAT_RGB);
+	if (img.get_format()!=Image::FORMAT_RGB8)
+		img.convert(Image::FORMAT_RGB8);
 
 
-	int mmc=img.get_mipmaps();
+	int mmc=img.get_mipmap_count();
 	if (mmc==0)
 		img.generate_mipmaps(); // force mipmaps, so it works on most hardware
 
@@ -186,7 +186,7 @@ static void _compress_etc(Image *p_img) {
 
 	}
 
-	*p_img=Image(p_img->get_width(),p_img->get_height(),mc-1,Image::FORMAT_ETC,dst_data);
+	*p_img=Image(p_img->get_width(),p_img->get_height(),(mc-1)?true:false,Image::FORMAT_ETC,dst_data);
 
 
 }

modules/gridmap/config.py

@@ -1,7 +1,8 @@
 
 
 def can_build(platform):
-    return True
+    # FIXME: Disabled temporary for gles3 implementation
+    return False
 
 
 def configure(env):

modules/gridmap/grid_map.cpp

@@ -960,9 +960,9 @@ void GridMap::_octant_bake(const OctantKey &p_key, const Ref<TriangleMesh>& p_tm
 
 						st->add_to_format(VS::ARRAY_FORMAT_COLOR);
 						if (m.is_valid()) {
-							Ref<FixedMaterial> fm = m;
+							Ref<FixedSpatialMaterial> fm = m;
 							if (fm.is_valid())
-								fm->set_fixed_flag(FixedMaterial::FLAG_USE_COLOR_ARRAY,true);
+								fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY,true);
 						}
 					}
 				}

modules/jpg/image_loader_jpegd.cpp

@@ -84,9 +84,9 @@ Error jpeg_load_image_from_buffer(Image *p_image,const uint8_t* p_buffer, int p_
 
 	Image::Format fmt;
 	if (comps==1)
-		fmt=Image::FORMAT_GRAYSCALE;
+		fmt=Image::FORMAT_L8;
 	else
-		fmt=Image::FORMAT_RGBA;
+		fmt=Image::FORMAT_RGBA8;
 
 	dw = DVector<uint8_t>::Write();
 	p_image->create(image_width,image_height,0,fmt,data);

modules/pvr/texture_loader_pvr.cpp

@@ -116,33 +116,33 @@ RES ResourceFormatPVR::load(const String &p_path,const String& p_original_path,E
 	switch(flags&0xFF) {
 
 		case 0x18:
-		case 0xC: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC2_ALPHA:Image::FORMAT_PVRTC2;  break;
+		case 0xC: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC2A:Image::FORMAT_PVRTC2;  break;
 		case 0x19:
-		case 0xD: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC4_ALPHA:Image::FORMAT_PVRTC4;  break;
+		case 0xD: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC4A:Image::FORMAT_PVRTC4;  break;
 		case 0x16:
-			format=Image::FORMAT_GRAYSCALE; break;
+			format=Image::FORMAT_L8; break;
 		case 0x17:
-			format=Image::FORMAT_GRAYSCALE_ALPHA; break;
+			format=Image::FORMAT_LA8; break;
 		case 0x20:
 		case 0x80:
 		case 0x81:
-			format=Image::FORMAT_BC1; break;
+			format=Image::FORMAT_DXT1; break;
 		case 0x21:
 		case 0x22:
 		case 0x82:
 		case 0x83:
-			format=Image::FORMAT_BC2; break;
+			format=Image::FORMAT_DXT3; break;
 		case 0x23:
 		case 0x24:
 		case 0x84:
 		case 0x85:
-			format=Image::FORMAT_BC3; break;
+			format=Image::FORMAT_DXT5; break;
 		case 0x4:
 		case 0x15:
-			format=Image::FORMAT_RGB; break;
+			format=Image::FORMAT_RGB8; break;
 		case 0x5:
 		case 0x12:
-			format=Image::FORMAT_RGBA; break;
+			format=Image::FORMAT_RGBA8; break;
 		case 0x36:
 			format=Image::FORMAT_ETC; break;
 		default:
@@ -198,24 +198,24 @@ static void _compress_pvrtc4(Image * p_img) {
 
 	bool make_mipmaps=false;
 	if (img.get_width()%8 || img.get_height()%8) {
-		make_mipmaps=img.get_mipmaps()>0;
+		make_mipmaps=img.has_mipmaps();
 		img.resize(img.get_width()+(8-(img.get_width()%8)),img.get_height()+(8-(img.get_height()%8)));
 	}
-	img.convert(Image::FORMAT_RGBA);
-	if (img.get_mipmaps()==0 && make_mipmaps)
+	img.convert(Image::FORMAT_RGBA8);
+	if (!img.has_mipmaps() && make_mipmaps)
 		img.generate_mipmaps();
 
 	bool use_alpha=img.detect_alpha();
 
 	Image new_img;
-	new_img.create(img.get_width(),img.get_height(),true,use_alpha?Image::FORMAT_PVRTC4_ALPHA:Image::FORMAT_PVRTC4);
+	new_img.create(img.get_width(),img.get_height(),true,use_alpha?Image::FORMAT_PVRTC4A:Image::FORMAT_PVRTC4);
 	DVector<uint8_t> data=new_img.get_data();
 	{
 		DVector<uint8_t>::Write wr=data.write();
 		DVector<uint8_t>::Read r=img.get_data().read();
 
 
-		for(int i=0;i<=new_img.get_mipmaps();i++) {
+		for(int i=0;i<=new_img.get_mipmap_count();i++) {
 
 			int ofs,size,w,h;
 			img.get_mipmap_offset_size_and_dimensions(i,ofs,size,w,h);
@@ -234,7 +234,7 @@ static void _compress_pvrtc4(Image * p_img) {
 
 	}
 
-	*p_img = Image(new_img.get_width(),new_img.get_height(),new_img.get_mipmaps(),new_img.get_format(),data);
+	*p_img = Image(new_img.get_width(),new_img.get_height(),new_img.has_mipmaps(),new_img.get_format(),data);
 
 }
 
@@ -673,9 +673,9 @@ static void _pvrtc_decompress(Image* p_img) {
 //		decompress_pvrtc((PVRTCBlock*)p_comp_img,p_2bit,p_width,p_height,1,p_dst);
 //	}
 
-	ERR_FAIL_COND( p_img->get_format()!=Image::FORMAT_PVRTC2 && p_img->get_format()!=Image::FORMAT_PVRTC2_ALPHA && p_img->get_format()!=Image::FORMAT_PVRTC4 && p_img->get_format()!=Image::FORMAT_PVRTC4_ALPHA);
+	ERR_FAIL_COND( p_img->get_format()!=Image::FORMAT_PVRTC2 && p_img->get_format()!=Image::FORMAT_PVRTC2A && p_img->get_format()!=Image::FORMAT_PVRTC4 && p_img->get_format()!=Image::FORMAT_PVRTC4A);
 
-	bool _2bit = (p_img->get_format()==Image::FORMAT_PVRTC2 || p_img->get_format()==Image::FORMAT_PVRTC2_ALPHA );
+	bool _2bit = (p_img->get_format()==Image::FORMAT_PVRTC2 || p_img->get_format()==Image::FORMAT_PVRTC2A );
 
 	DVector<uint8_t> data = p_img->get_data();
 	DVector<uint8_t>::Read r = data.read();
@@ -694,8 +694,8 @@ static void _pvrtc_decompress(Image* p_img) {
 	w=DVector<uint8_t>::Write();
 	r=DVector<uint8_t>::Read();
 
-	bool make_mipmaps=p_img->get_mipmaps()>0;
-	Image newimg(p_img->get_width(),p_img->get_height(),0,Image::FORMAT_RGBA,newdata);
+	bool make_mipmaps=p_img->has_mipmaps();
+	Image newimg(p_img->get_width(),p_img->get_height(),false,Image::FORMAT_RGBA8,newdata);
 	if (make_mipmaps)
 		newimg.generate_mipmaps();
 	*p_img=newimg;

modules/squish/image_compress_squish.cpp

@@ -37,7 +37,7 @@ void image_compress_squish(Image *p_image) {
 	int w=p_image->get_width();
 	int h=p_image->get_height();
 
-	if (p_image->get_mipmaps() == 0) {
+	if (!p_image->has_mipmaps() ) {
 		ERR_FAIL_COND( !w || w % 4 != 0);
 		ERR_FAIL_COND( !h || h % 4 != 0);
 	} else {
@@ -45,26 +45,26 @@ void image_compress_squish(Image *p_image) {
 		ERR_FAIL_COND( !h || h !=nearest_power_of_2(h) );
 	};
 
-	if (p_image->get_format()>=Image::FORMAT_BC1)
+	if (p_image->get_format()>=Image::FORMAT_DXT1)
 		return; //do not compress, already compressed
 
 	int shift=0;
 	int squish_comp=squish::kColourRangeFit;
 	Image::Format target_format;
 
-	if (p_image->get_format()==Image::FORMAT_GRAYSCALE_ALPHA) {
+	if (p_image->get_format()==Image::FORMAT_LA8) {
 		//compressed normalmap
-		target_format = Image::FORMAT_BC3; squish_comp|=squish::kDxt5;;
+		target_format = Image::FORMAT_DXT5; squish_comp|=squish::kDxt5;;
 	} else if (p_image->detect_alpha()!=Image::ALPHA_NONE) {
 
-		target_format = Image::FORMAT_BC2; squish_comp|=squish::kDxt3;;
+		target_format = Image::FORMAT_DXT3; squish_comp|=squish::kDxt3;;
 	} else {
-		target_format = Image::FORMAT_BC1; shift=1; squish_comp|=squish::kDxt1;;
+		target_format = Image::FORMAT_DXT1; shift=1; squish_comp|=squish::kDxt1;;
 	}
 
-	p_image->convert(Image::FORMAT_RGBA); //always expects rgba
+	p_image->convert(Image::FORMAT_RGBA8); //always expects rgba
 
-	int mm_count = p_image->get_mipmaps();
+	int mm_count = p_image->get_mipmap_count();
 
 	DVector<uint8_t> data;
 	int target_size = Image::get_image_data_size(w,h,target_format,mm_count);
@@ -87,6 +87,6 @@ void image_compress_squish(Image *p_image) {
 	rb = DVector<uint8_t>::Read();
 	wb = DVector<uint8_t>::Write();
 
-	p_image->create(p_image->get_width(),p_image->get_height(),p_image->get_mipmaps(),target_format,data);
+	p_image->create(p_image->get_width(),p_image->get_height(),p_image->has_mipmaps(),target_format,data);
 
 }

modules/theora/video_stream_theora.cpp

@@ -103,7 +103,7 @@ void VideoStreamPlaybackTheora::video_write(void){
 				dst[p++] = 255;
 			};
 		}
-		format = Image::FORMAT_RGBA;
+		format = Image::FORMAT_RGBA8;
 	}
 	//	*/
 
@@ -130,10 +130,10 @@ void VideoStreamPlaybackTheora::video_write(void){
 			yuv420_2_rgb8888((uint8_t*)dst, (uint8_t*)yuv[0].data, (uint8_t*)yuv[2].data, (uint8_t*)yuv[1].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x<<2, 0);
 		};
 
-		format = Image::FORMAT_RGBA;
+		format = Image::FORMAT_RGBA8;
 	}
 
-	Image img(size.x,size.y,0,Image::FORMAT_RGBA,frame_data); //zero copy image creation
+	Image img(size.x,size.y,0,Image::FORMAT_RGBA8,frame_data); //zero copy image creation
 
 	texture->set_data(img); //zero copy send to visual server
 
@@ -202,7 +202,7 @@ void VideoStreamPlaybackTheora::video_write(void){
 				}
 			}
 
-			format = Image::FORMAT_RGBA;
+			format = Image::FORMAT_RGBA8;
 
 		} else {
 
@@ -470,7 +470,7 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 		size.x = w;
 		size.y = h;
 
-		texture->create(w,h,Image::FORMAT_RGBA,Texture::FLAG_FILTER|Texture::FLAG_VIDEO_SURFACE);
+		texture->create(w,h,Image::FORMAT_RGBA8,Texture::FLAG_FILTER|Texture::FLAG_VIDEO_SURFACE);
 
 	}else{
 		/* tear down the partial theora setup */

modules/webm/video_stream_webm.cpp

@@ -127,7 +127,7 @@ bool VideoStreamPlaybackWebm::open_file(const String &p_file) {
 			}
 
 			frame_data.resize((webm->getWidth() * webm->getHeight()) << 2);
-			texture->create(webm->getWidth(), webm->getHeight(), Image::FORMAT_RGBA, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
+			texture->create(webm->getWidth(), webm->getHeight(), Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
 
 			return true;
 		}
@@ -318,7 +318,7 @@ void VideoStreamPlaybackWebm::update(float p_delta) {
 							}
 
 							if (converted)
-								texture->set_data(Image(image.w, image.h, 0, Image::FORMAT_RGBA, frame_data)); //Zero copy send to visual server
+								texture->set_data(Image(image.w, image.h, 0, Image::FORMAT_RGBA8, frame_data)); //Zero copy send to visual server
 						}
 
 						break;

modules/webp/image_loader_webp.cpp

@@ -42,9 +42,9 @@ static DVector<uint8_t> _webp_lossy_pack(const Image& p_image,float p_quality) {
 
 	Image img=p_image;
 	if (img.detect_alpha())
-		img.convert(Image::FORMAT_RGBA);
+		img.convert(Image::FORMAT_RGBA8);
 	else
-		img.convert(Image::FORMAT_RGB);
+		img.convert(Image::FORMAT_RGB8);
 
 	Size2 s(img.get_width(),img.get_height());
 	DVector<uint8_t> data = img.get_data();
@@ -52,7 +52,7 @@ static DVector<uint8_t> _webp_lossy_pack(const Image& p_image,float p_quality) {
 
 	uint8_t *dst_buff=NULL;
 	size_t dst_size=0;
-	if (img.get_format()==Image::FORMAT_RGB) {
+	if (img.get_format()==Image::FORMAT_RGB8) {
 
 		dst_size = WebPEncodeRGB(r.ptr(),s.width,s.height,3*s.width,CLAMP(p_quality*100.0,0,100.0),&dst_buff);
 	} else {
@@ -109,7 +109,7 @@ static Image _webp_lossy_unpack(const DVector<uint8_t>& p_buffer) {
 
 	dst_w = DVector<uint8_t>::Write();
 
-	return Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA:Image::FORMAT_RGB,dst_image);
+	return Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA8:Image::FORMAT_RGB8,dst_image);
 
 }
 
@@ -161,7 +161,7 @@ Error ImageLoaderWEBP::load_image(Image *p_image,FileAccess *f) {
 	src_r = DVector<uint8_t>::Read();
 	dst_w = DVector<uint8_t>::Write();
 
-	*p_image = Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA:Image::FORMAT_RGB,dst_image);
+	*p_image = Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA8:Image::FORMAT_RGB8,dst_image);
 
 
 	return OK;

platform/iphone/rasterizer_iphone.cpp

@@ -134,21 +134,21 @@ static Image _get_gl_image_and_format(const Image& p_image, Image::Format p_form
 
 	switch(p_format) {
 
-		case Image::FORMAT_GRAYSCALE: {
+		case Image::FORMAT_L8: {
 			r_gl_components=1;
 			r_gl_format=GL_LUMINANCE;
 
 		} break;
 		case Image::FORMAT_INTENSITY: {
 
-			image.convert(Image::FORMAT_RGBA);
+			image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=4;
 			r_gl_format=GL_RGBA;
 			r_has_alpha_cache=true;
 		} break;
-		case Image::FORMAT_GRAYSCALE_ALPHA: {
+		case Image::FORMAT_LA8: {
 
-			image.convert(Image::FORMAT_RGBA);
+			image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=4;
 			r_gl_format=GL_RGBA;
 			r_has_alpha_cache=true;
@@ -156,7 +156,7 @@ static Image _get_gl_image_and_format(const Image& p_image, Image::Format p_form
 
 		case Image::FORMAT_INDEXED: {
 
-			image.convert(Image::FORMAT_RGB);
+			image.convert(Image::FORMAT_RGB8);
 			r_gl_components=3;
 			r_gl_format=GL_RGB;
 
@@ -164,17 +164,17 @@ static Image _get_gl_image_and_format(const Image& p_image, Image::Format p_form
 
 		case Image::FORMAT_INDEXED_ALPHA: {
 
-			image.convert(Image::FORMAT_RGBA);
+			image.convert(Image::FORMAT_RGBA8);
 			r_gl_components=4;
 			r_gl_format=GL_RGB;
 			r_has_alpha_cache=true;
 
 		} break;
-		case Image::FORMAT_RGB: {
+		case Image::FORMAT_RGB8: {
 
 			r_gl_components=3; r_gl_format=GL_RGB;
 		} break;
-		case Image::FORMAT_RGBA: {
+		case Image::FORMAT_RGBA8: {
 
 			r_gl_components=4;
 			r_gl_format=GL_RGBA;
@@ -344,7 +344,7 @@ Image::Format RasterizerIPhone::texture_get_format(RID p_texture) const {
 
 	Texture * texture = texture_owner.get(p_texture);
 
-	ERR_FAIL_COND_V(!texture,Image::FORMAT_GRAYSCALE);
+	ERR_FAIL_COND_V(!texture,Image::FORMAT_L8);
 
 	return texture->format;
 }
@@ -486,7 +486,7 @@ RID RasterizerIPhone::material_create() {
 	return material_owner.make_rid( memnew( Material ) );
 }
 
-void RasterizerIPhone::fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant& p_value) {
+void RasterizerIPhone::fixed_material_set_parameter(RID p_material, VS::FixedSpatialMaterialParam p_parameter, const Variant& p_value) {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND(!m);
@@ -494,7 +494,7 @@ void RasterizerIPhone::fixed_material_set_parameter(RID p_material, VS::FixedMat
 
 	m->parameters[p_parameter] = p_value;
 }
-Variant RasterizerIPhone::fixed_material_get_parameter(RID p_material,VS::FixedMaterialParam p_parameter) const {
+Variant RasterizerIPhone::fixed_material_get_parameter(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND_V(!m, Variant());
@@ -503,7 +503,7 @@ Variant RasterizerIPhone::fixed_material_get_parameter(RID p_material,VS::FixedM
 	return m->parameters[p_parameter];
 }
 
-void RasterizerIPhone::fixed_material_set_texture(RID p_material,VS::FixedMaterialParam p_parameter, RID p_texture) {
+void RasterizerIPhone::fixed_material_set_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter, RID p_texture) {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND(!m);
@@ -511,7 +511,7 @@ void RasterizerIPhone::fixed_material_set_texture(RID p_material,VS::FixedMateri
 
 	m->textures[p_parameter] = p_texture;
 }
-RID RasterizerIPhone::fixed_material_get_texture(RID p_material,VS::FixedMaterialParam p_parameter) const {
+RID RasterizerIPhone::fixed_material_get_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND_V(!m, RID());
@@ -535,7 +535,7 @@ VS::MaterialBlendMode RasterizerIPhone::fixed_material_get_detail_blend_mode(RID
 	return m->detail_blend_mode;
 }
 
-void RasterizerIPhone::fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode) {
+void RasterizerIPhone::fixed_material_set_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter, VS::FixedSpatialMaterialTexCoordMode p_mode) {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND(!m);
@@ -543,7 +543,7 @@ void RasterizerIPhone::fixed_material_set_texcoord_mode(RID p_material,VS::Fixed
 
 	m->texcoord_mode[p_parameter] = p_mode;
 }
-VS::FixedMaterialTexCoordMode RasterizerIPhone::fixed_material_get_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter) const {
+VS::FixedSpatialMaterialTexCoordMode RasterizerIPhone::fixed_material_get_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND_V(!m, VS::FIXED_MATERIAL_TEXCOORD_TEXGEN);
@@ -552,7 +552,7 @@ VS::FixedMaterialTexCoordMode RasterizerIPhone::fixed_material_get_texcoord_mode
 	return m->texcoord_mode[p_parameter]; // for now
 }
 
-void RasterizerIPhone::fixed_material_set_texgen_mode(RID p_material,VS::FixedMaterialTexGenMode p_mode) {
+void RasterizerIPhone::fixed_material_set_texgen_mode(RID p_material,VS::FixedSpatialMaterialTexGenMode p_mode) {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND(!m);
@@ -560,7 +560,7 @@ void RasterizerIPhone::fixed_material_set_texgen_mode(RID p_material,VS::FixedMa
 	m->texgen_mode = p_mode;
 };
 
-VS::FixedMaterialTexGenMode RasterizerIPhone::fixed_material_get_texgen_mode(RID p_material) const {
+VS::FixedSpatialMaterialTexGenMode RasterizerIPhone::fixed_material_get_texgen_mode(RID p_material) const {
 
 	Material *m=material_owner.get( p_material );
 	ERR_FAIL_COND_V(!m, VS::FIXED_MATERIAL_TEXGEN_SPHERE);

platform/iphone/rasterizer_iphone.h

@@ -74,7 +74,7 @@ class RasterizerIPhone : public Rasterizer {
 
 			flags=width=height=0;
 			tex_id=0;
-			format=Image::FORMAT_GRAYSCALE;
+			format=Image::FORMAT_L8;
 			gl_components_cache=0;
 			format_has_alpha=false;
 			has_alpha=false;
@@ -100,11 +100,11 @@ class RasterizerIPhone : public Rasterizer {
 		RID textures[VisualServer::FIXED_MATERIAL_PARAM_MAX];
 
 		Transform uv_transform;
-		VS::FixedMaterialTexCoordMode texcoord_mode[VisualServer::FIXED_MATERIAL_PARAM_MAX];
+		VS::FixedSpatialMaterialTexCoordMode texcoord_mode[VisualServer::FIXED_MATERIAL_PARAM_MAX];
 
 		VS::MaterialBlendMode detail_blend_mode;
 
-		VS::FixedMaterialTexGenMode texgen_mode;
+		VS::FixedSpatialMaterialTexGenMode texgen_mode;
 
 		Material() {
 
@@ -624,20 +624,20 @@ public:
 
 	virtual RID material_create();
 
-	virtual void fixed_material_set_parameter(RID p_material, VS::FixedMaterialParam p_parameter, const Variant& p_value);
-	virtual Variant fixed_material_get_parameter(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_parameter(RID p_material, VS::FixedSpatialMaterialParam p_parameter, const Variant& p_value);
+	virtual Variant fixed_material_get_parameter(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
 
-	virtual void fixed_material_set_texture(RID p_material,VS::FixedMaterialParam p_parameter, RID p_texture);
-	virtual RID fixed_material_get_texture(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter, RID p_texture);
+	virtual RID fixed_material_get_texture(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
 
 	virtual void fixed_material_set_detail_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
 	virtual VS::MaterialBlendMode fixed_material_get_detail_blend_mode(RID p_material) const;
 
-	virtual void fixed_material_set_texgen_mode(RID p_material,VS::FixedMaterialTexGenMode p_mode);
-	virtual VS::FixedMaterialTexGenMode fixed_material_get_texgen_mode(RID p_material) const;
+	virtual void fixed_material_set_texgen_mode(RID p_material,VS::FixedSpatialMaterialTexGenMode p_mode);
+	virtual VS::FixedSpatialMaterialTexGenMode fixed_material_get_texgen_mode(RID p_material) const;
 
-	virtual void fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode);
-	virtual VS::FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter) const;
+	virtual void fixed_material_set_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter, VS::FixedSpatialMaterialTexCoordMode p_mode);
+	virtual VS::FixedSpatialMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::FixedSpatialMaterialParam p_parameter) const;
 
 	virtual void fixed_material_set_uv_transform(RID p_material,const Transform& p_transform);
 	virtual Transform fixed_material_get_uv_transform(RID p_material) const;

platform/osx/export/export.cpp

@@ -207,7 +207,7 @@ void EditorExportPlatformOSX::_make_icon(const Image& p_icon,Vector<uint8_t>& ic
 	while(size>=16) {
 
 		Image copy = p_icon;
-		copy.convert(Image::FORMAT_RGBA);
+		copy.convert(Image::FORMAT_RGBA8);
 		copy.resize(size,size);
 		it->create_from_image(copy);
 		String path = EditorSettings::get_singleton()->get_settings_path()+"/tmp/icon.png";

platform/osx/os_osx.mm

@@ -1313,7 +1313,7 @@ void OS_OSX::set_window_title(const String& p_title) {
 void OS_OSX::set_icon(const Image& p_icon) {
 
 	Image img=p_icon;
-	img.convert(Image::FORMAT_RGBA);
+	img.convert(Image::FORMAT_RGBA8);
 	NSBitmapImageRep *imgrep= [[[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
 			  pixelsWide: p_icon.get_width()
 			  pixelsHigh: p_icon.get_height()

platform/osx/platform_config.h

@@ -27,5 +27,7 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include <alloca.h>
+
 #define GLES2_INCLUDE_H "GL/glew.h"
+#define GLES3_INCLUDE_H "GL/glew.h"
 #define PTHREAD_RENAME_SELF

platform/server/os_server.cpp

@@ -26,8 +26,8 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#include "servers/visual/visual_server_raster.h"
-#include "servers/visual/rasterizer_dummy.h"
+//#include "servers/visual/visual_server_raster.h"
+//#include "servers/visual/rasterizer_dummy.h"
 #include "os_server.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -57,9 +57,9 @@ void OS_Server::initialize(const VideoMode& p_desired,int p_video_driver,int p_a
 	current_videomode=p_desired;
 	main_loop=NULL;
 
-	rasterizer = memnew( RasterizerDummy );
+	//rasterizer = memnew( RasterizerDummy );
 
-	visual_server = memnew( VisualServerRaster(rasterizer) );
+	//visual_server = memnew( VisualServerRaster(rasterizer) );
 
 	AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
 
@@ -114,7 +114,7 @@ void OS_Server::finalize() {
 
 	visual_server->finish();
 	memdelete(visual_server);
-	memdelete(rasterizer);
+	//memdelete(rasterizer);
 
 	physics_server->finish();
 	memdelete(physics_server);

platform/server/os_server.h

@@ -51,7 +51,7 @@
 
 class OS_Server : public OS_Unix {
 
-	Rasterizer *rasterizer;
+//	Rasterizer *rasterizer;
 	VisualServer *visual_server;
 	VideoMode current_videomode;
 	List<String> args;

platform/windows/context_gl_win.cpp

@@ -110,6 +110,7 @@ bool ContextGL_Win::is_using_vsync() const {
 	return use_vsync;
 }
 
+#define _WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
 
 Error ContextGL_Win::initialize() {
 
@@ -162,10 +163,10 @@ Error ContextGL_Win::initialize() {
 	if (opengl_3_context) {
 
 		int attribs[] = {
-			 WGL_CONTEXT_MAJOR_VERSION_ARB, 3,//we want a 3.1 context
-			 WGL_CONTEXT_MINOR_VERSION_ARB, 2,
+			 WGL_CONTEXT_MAJOR_VERSION_ARB, 3,//we want a 3.3 context
+			 WGL_CONTEXT_MINOR_VERSION_ARB, 3,
 			 //and it shall be forward compatible so that we can only use up to date functionality
-			 WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+			 WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB|_WGL_CONTEXT_DEBUG_BIT_ARB,
 		0}; //zero indicates the end of the array
 
 		PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL; //pointer to the method
@@ -182,7 +183,7 @@ Error ContextGL_Win::initialize() {
 		if (!(new_hRC=wglCreateContextAttribsARB(hDC,0, attribs)))
 		{
 			wglDeleteContext(hRC);
-			MessageBox(NULL,"Can't Create An OpenGL 3.1 Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+			MessageBox(NULL,"Can't Create An OpenGL 3.3 Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
 			return ERR_CANT_CREATE;								// Return false
 		}
 		wglMakeCurrent(hDC,NULL);
@@ -191,11 +192,11 @@ Error ContextGL_Win::initialize() {
 
 		if (!wglMakeCurrent(hDC,hRC)) 				// Try To Activate The Rendering Context
 		{
-			MessageBox(NULL,"Can't Activate The GL 3.1 Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
+			MessageBox(NULL,"Can't Activate The GL 3.3 Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
 			return ERR_CANT_CREATE;							// Return FALSE
 		}
 
-		printf("Activated GL 3.1 context");
+		printf("Activated GL 3.3 context");
 	}
 
 	wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)  wglGetProcAddress ("wglSwapIntervalEXT");

platform/windows/detect.py

@@ -246,7 +246,7 @@ def configure(env):
         env.Append(CCFLAGS=['/DWIN32'])
         env.Append(CCFLAGS=['/DTYPED_METHOD_BIND'])
 
-        env.Append(CCFLAGS=['/DGLES2_ENABLED'])
+        env.Append(CCFLAGS=['/DOPENGL_ENABLED'])
         LIBS = ['winmm', 'opengl32', 'dsound', 'kernel32', 'ole32', 'oleaut32', 'user32', 'gdi32', 'IPHLPAPI', 'Shlwapi', 'wsock32', 'Ws2_32', 'shell32', 'advapi32', 'dinput8', 'dxguid']
         env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS])
 
@@ -370,7 +370,7 @@ def configure(env):
 
         env.Append(CCFLAGS=['-DWINDOWS_ENABLED', '-mwindows'])
         env.Append(CPPFLAGS=['-DRTAUDIO_ENABLED'])
-        env.Append(CCFLAGS=['-DGLES2_ENABLED'])
+        env.Append(CCFLAGS=['-DOPENGL_ENABLED'])
         env.Append(LIBS=['mingw32', 'opengl32', 'dsound', 'ole32', 'd3d9', 'winmm', 'gdi32', 'iphlpapi', 'shlwapi', 'wsock32', 'ws2_32', 'kernel32', 'oleaut32', 'dinput8', 'dxguid'])
 
         # if (env["bits"]=="32"):