ref_gl: fix codestyle

engine/client/cl_main.c

@@ -2341,7 +2341,7 @@ void CL_ReadPackets( void )
 	// decide the simulation time
 	cl.oldtime = cl.time;
 
-	if( cls.demoplayback != DEMO_XASH3D && !cl.paused )
+	if( !cl.paused )
 		cl.time += host.frametime;
 
 	// demo time

engine/client/cl_parse_48.c

@@ -265,8 +265,18 @@ void CL_LegacyParseResourceList( sizebuf_t *msg )
 	}
 
 	if( CL_IsPlaybackDemo() )
-	{
 		return;
+
+	if( !cl_allow_download.value )
+	{
+		Con_DPrintf( "Refusing new resource, cl_allow_download set to 0\n" );
+		reslist.rescount = 0;
+	}
+
+	if( cls.state == ca_active && !cl_download_ingame.value )
+	{
+		Con_DPrintf( "Refusing new resource, cl_download_ingame set to 0\n" );
+		reslist.rescount = 0;
 	}
 
 	HTTP_ResetProcessState();

engine/platform/sdl/vid_sdl.c

@@ -812,8 +812,13 @@ qboolean VID_CreateWindow( int width, int height, window_mode_t window_mode )
 	{
 		if( !glw_state.initialized )
 		{
-			if( !GL_CreateContext( ))
-				return false;
+			while( !GL_CreateContext( ))
+			{
+				glw_state.safe++;
+				if(glw_state.safe > SAFE_DONTCARE)
+					return false;
+				GL_SetupAttributes(); // re-choose attributes
+			}
 
 			VID_StartupGamma();
 		}

ref/gl/gl2_shim/fragment.glsl.inc

@@ -0,0 +1,70 @@
+"#if VER <= 300\n"
+"#define layout(x)\n"
+"#endif\n"
+"#if VER < 300\n"
+"#define out attribute\n"
+"#define in varying\n"
+"#define texture texture2D\n"
+"#endif\n"
+"#if VER >= 130 || VER == 100\n"
+"precision mediump float;\n"
+"#endif\n"
+"#if VER == 100\n"
+"#define PREC mediump\n"
+"#else\n"
+"#define PREC\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"uniform sampler2D uTex0;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"uniform sampler2D uTex1;\n"
+"#endif\n"
+"#if FEAT_ALPHA_TEST\n"
+"uniform float uAlphaTest;\n"
+"#endif\n"
+"#if FEAT_FOG\n"
+"uniform PREC vec4 uFog;\n"
+"#endif\n"
+"uniform PREC vec4 uColor;\n"
+"#if ATTR_COLOR\n"
+"in PREC vec4 vColor;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"in PREC vec2 vTexCoord0;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"in PREC vec2 vTexCoord1;\n"
+"#endif\n"
+"#if ATTR_NORMAL\n"
+"in PREC vec2 vNormal;\n"
+"#endif\n"
+"#if VER >= 300\n"
+"out vec4 oFragColor;\n"
+"#else\n"
+"#define oFragColor gl_FragColor\n"
+"#endif\n"
+"void main()\n"
+"{\n"
+"#if ATTR_COLOR\n"
+"PREC vec4 c = vColor;\n"
+"#else\n"
+"PREC vec4 c = uColor;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"c = c * texture(uTex0, vTexCoord0);\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"c = c * texture(uTex1, vTexCoord1);\n"
+"#endif\n"
+"#if FEAT_ALPHA_TEST\n"
+"if(c.a <= uAlphaTest)\n"
+"discard;\n"
+"#endif\n"
+"#if FEAT_FOG\n"
+"float fogDist = gl_FragCoord.z / gl_FragCoord.w;\n"
+"float fogRate = clamp(exp(-uFog.w * fogDist), 0.0, 1.0);\n"
+"c.rgb = mix(uFog.rgb, c.rgb, fogRate);\n"
+"#endif\n"
+"oFragColor = c;\n"
+"}\n"

ref/gl/gl2_shim/gl2_shim.h

@@ -0,0 +1,24 @@
+/*
+vgl_shim.h - vitaGL custom immediate mode shim
+Copyright (C) 2023 fgsfds
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#pragma once
+
+// max verts in a single frame
+#define GL2_MAX_VERTS 32768
+
+int GL2_ShimInit( void );
+void GL2_ShimInstall( void );
+void GL2_ShimShutdown( void );
+void GL2_ShimEndFrame( void );

ref/gl/gl2_shim/vertex.glsl.inc

@@ -0,0 +1,53 @@
+"#if VER <= 300\n"
+"#define layout(x)\n"
+"#endif\n"
+"#if VER < 300\n"
+"#define in attribute\n"
+"#define out varying\n"
+"#endif\n"
+"\n"
+"layout(location = LOC_ATTR_POSITION) in vec3 inPosition;\n"
+"#if ATTR_COLOR\n"
+"layout(location = LOC_ATTR_COLOR) in vec4 inColor;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"layout(location = LOC_ATTR_TEXCOORD0) in vec2 inTexCoord0;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"layout(location = LOC_ATTR_TEXCOORD1) in vec2 inTexCoord1;\n"
+"#endif\n"
+"\n"
+"#if ATTR_NORMAL\n"
+"in vec3 inNormal;\n"
+"#endif\n"
+"#if ATTR_COLOR\n"
+"out vec4 vColor;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"out vec2 vTexCoord0;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"out vec2 vTexCoord1;\n"
+"#endif\n"
+"#if ATTR_NORMAL\n"
+"out vec3 vNormal;\n"
+"#endif\n"
+"\n"
+"uniform mat4 uMVP;\n"
+"\n"
+"void main()\n"
+"{\n"
+"gl_Position = uMVP * vec4(inPosition,1.0);\n"
+"#if ATTR_COLOR\n"
+"vColor = inColor;\n"
+"#endif\n"
+"#if ATTR_NORMAL\n"
+"vNormal = inNormal;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD0\n"
+"vTexCoord0 = inTexCoord0;\n"
+"#endif\n"
+"#if ATTR_TEXCOORD1\n"
+"vTexCoord1 = inTexCoord1;\n"
+"#endif\n"
+"}\n"

ref/gl/gl2_shim/wscript

@@ -0,0 +1,25 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+import os
+
+def options(opt):
+	pass
+
+def configure(conf):
+	conf.define('REF_DLL', 1)
+
+def build(bld):
+	source = bld.path.ant_glob( [ '*.c' ] )
+	includes = [ '.' ]
+	libs = [ 'engine_includes', 'sdk_includes' ]
+	bld.env.LDFLAGS += ['-fPIC']
+	bld.env.CFLAGS += ['-fPIC']
+	bld.stlib(
+		source    = source,
+		target    = 'gl2_shim',
+		features  = 'c',
+		includes  = includes,
+		use       = libs,
+		subsystem = bld.env.MSVC_SUBSYSTEM
+	)

ref/gl/gl_export.h

@@ -27,6 +27,8 @@ GNU General Public License for more details.
 #define XASH_GLES
 #define XASH_GL_STATIC
 #define REF_GL_KEEP_MANGLED_FUNCTIONS
+#elif defined XASH_GLES3COMPAT
+#define XASH_GLES
 #endif
 
 typedef uint GLenum;
@@ -811,6 +813,19 @@ typedef float GLmatrix[16];
 #define GL_DEBUG_SEVERITY_MEDIUM_ARB		0x9147
 #define GL_DEBUG_SEVERITY_LOW_ARB		0x9148
 
+// GL Core additions
+#define GL_NUM_EXTENSIONS                 0x821D
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_COHERENT_BIT 0x0080
+#define GL_MAP_PERSISTENT_BIT 0x0040
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+
 #define WGL_CONTEXT_MAJOR_VERSION_ARB		0x2091
 #define WGL_CONTEXT_MINOR_VERSION_ARB		0x2092
 #define WGL_CONTEXT_LAYER_PLANE_ARB		0x2093
@@ -888,6 +903,7 @@ typedef float GLmatrix[16];
 // helper opengl functions
 APIENTRY_LINKAGE GLenum GL_FUNCTION( glGetError )(void);
 APIENTRY_LINKAGE const GLubyte * GL_FUNCTION( glGetString )(GLenum name);
+APIENTRY_LINKAGE const GLubyte * GL_FUNCTION( glGetStringi )(GLenum name, GLint i);
 
 // base gl functions
 APIENTRY_LINKAGE void GL_FUNCTION( glAccum )(GLenum op, GLfloat value);
@@ -1358,7 +1374,18 @@ APIENTRY_LINKAGE void GL_FUNCTION( glGenVertexArrays )( GLsizei n, const GLuint
 APIENTRY_LINKAGE GLboolean GL_FUNCTION( glIsVertexArray )( GLuint array );
 APIENTRY_LINKAGE void GL_FUNCTION( glSwapInterval ) ( int interval );
 
-#if !defined( XASH_GLES ) && !defined( XASH_GL4ES )
+// arb shaders change in core
+APIENTRY_LINKAGE void GL_FUNCTION( glDeleteProgram )(GLuint program);
+APIENTRY_LINKAGE void GL_FUNCTION( glGetProgramiv )(GLuint program, GLenum e, GLuint *v);
+APIENTRY_LINKAGE void GL_FUNCTION( glGetProgramInfoLog )(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
+
+// gl2shim deps
+APIENTRY_LINKAGE void GL_FUNCTION( glBufferStorage )( GLenum target,  GLsizei size, const GLvoid * data, GLbitfield flags);
+APIENTRY_LINKAGE void GL_FUNCTION( glFlushMappedBufferRange )(GLenum target, GLsizei offset, GLsizei length);
+APIENTRY_LINKAGE void *GL_FUNCTION( glMapBufferRange )(GLenum target, GLsizei offset, GLsizei length, GLbitfield access);
+APIENTRY_LINKAGE void GL_FUNCTION( glDrawRangeElementsBaseVertex )( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLuint vertex );
+
+#if !defined( XASH_GL_STATIC ) || (!defined( XASH_GLES ) && !defined( XASH_GL4ES ))
 APIENTRY_LINKAGE void GL_FUNCTION( glTexImage2DMultisample )(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
 #endif /* !XASH_GLES && !XASH_GL4ES */
 

ref/gl/gl_image.c

@@ -1070,7 +1070,7 @@ static void GL_TextureImageRAW( gl_texture_t *tex, GLint side, GLint level, GLin
 	}
 	else if( tex->target == GL_TEXTURE_2D_MULTISAMPLE )
 	{
-#if !defined( XASH_GLES ) && !defined( XASH_GL4ES )
+#if !defined( XASH_GL_STATIC ) || (!defined( XASH_GLES ) && !defined( XASH_GL4ES ))
 		samplesCount = (GLsizei)gEngfuncs.pfnGetCvarFloat("gl_msaa_samples");
 		switch (samplesCount)
 		{
@@ -1083,9 +1083,9 @@ static void GL_TextureImageRAW( gl_texture_t *tex, GLint side, GLint level, GLin
 				samplesCount = 1;
 		}
 		pglTexImage2DMultisample( tex->target, samplesCount, tex->format, width, height, GL_TRUE );
-#else /* !XASH_GLES && !XASH_GL4ES */
+#else /* !XASH_GL_STATIC !XASH_GLES && !XASH_GL4ES */
 		gEngfuncs.Con_Printf( S_ERROR "GLES renderer don't support GL_TEXTURE_2D_MULTISAMPLE!\n" );
-#endif /* !XASH_GLES && !XASH_GL4ES */
+#endif /* !XASH_GL_STATIC !XASH_GLES && !XASH_GL4ES */
 	}
 	else // 2D or RECT
 	{
@@ -1418,7 +1418,7 @@ static gl_texture_t *GL_AllocTexture( const char *name, texFlags_t flags )
 	// copy initial params
 	Q_strncpy( tex->name, name, sizeof( tex->name ));
 
-	if( FBitSet( flags, TF_SKYSIDE ))
+	if( FBitSet( flags, TF_SKYSIDE ) && glConfig.context != CONTEXT_TYPE_GL_CORE )
 		tex->texnum = tr.skyboxbasenum++;
 	else
 	{

ref/gl/gl_local.h

@@ -40,6 +40,9 @@ int VGL_ShimInit( void );
 void VGL_ShimShutdown( void );
 void VGL_ShimEndFrame( void );
 #endif
+#if !defined(XASH_GL_STATIC)
+#include "gl2_shim/gl2_shim.h"
+#endif
 
 #ifndef offsetof
 #ifdef __GNUC__
@@ -561,7 +564,7 @@ void GL_CheckForErrors_( const char *filename, const int fileline );
 const char *GL_ErrorString( int err );
 qboolean GL_Support( int r_ext );
 int GL_MaxTextureUnits( void );
-qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext );
+qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext, float minver );
 void GL_SetExtension( int r_ext, int enable );
 
 //
@@ -617,6 +620,11 @@ enum
 	GL_DRAW_RANGEELEMENTS_EXT,
 	GL_TEXTURE_MULTISAMPLE,
 	GL_ARB_TEXTURE_COMPRESSION_BPTC,
+	GL_SHADER_OBJECTS_EXT,
+	GL_ARB_VERTEX_ARRAY_OBJECT_EXT,
+	GL_BUFFER_STORAGE_EXT,
+	GL_MAP_BUFFER_RANGE_EXT,
+	GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT,
 	GL_EXTCOUNT,		// must be last
 };
 
@@ -662,6 +670,8 @@ typedef struct
 	int		depth_bits;
 	int		stencil_bits;
 	int		msaasamples;
+	int		version_major;
+	int		version_minor;
 
 	gl_context_type_t	context;
 	gles_wrapper_t	wrapper;
@@ -738,7 +748,8 @@ extern convar_t	r_lockfrustum;
 extern convar_t	r_traceglow;
 extern convar_t	r_vbo;
 extern convar_t	r_vbo_dlightmode;
-
+extern convar_t r_studio_sort_textures;
+extern convar_t r_studio_drawelements;
 
 //
 // engine shared convars

ref/gl/gl_opengl.c

@@ -222,8 +222,10 @@ static dllfunc_t vbofuncs[] =
 	{ GL_CALL( glDeleteBuffersARB ) },
 	{ GL_CALL( glGenBuffersARB ) },
 	{ GL_CALL( glIsBufferARB ) },
+#ifndef XASH_GLES
 	{ GL_CALL( glMapBufferARB ) },
-	{ GL_CALL( glUnmapBufferARB ) }, // ,
+	{ GL_CALL( glUnmapBufferARB ) },
+#endif
 	{ GL_CALL( glBufferDataARB ) },
 	{ GL_CALL( glBufferSubDataARB ) },
 	{ NULL, NULL }
@@ -247,6 +249,192 @@ static dllfunc_t drawrangeelementsextfuncs[] =
 { NULL, NULL }
 };
 
+
+// mangling in gl2shim???
+// still need resolve some ext dynamicly, and mangling beginend wrappers will help only with LTO
+// anyway this will not work with gl-wes/nanogl, we do not link to libGLESv2, so skip this now
+#ifndef XASH_GL_STATIC
+
+static dllfunc_t mapbufferrangefuncs[] =
+{
+{ GL_CALL( glMapBufferRange ) },
+{ GL_CALL( glFlushMappedBufferRange ) },
+#ifdef XASH_GLES
+{ GL_CALL( glUnmapBufferARB ) },
+#endif
+{ NULL, NULL }
+};
+
+static dllfunc_t drawrangeelementsbasevertexfuncs[] =
+{
+{ GL_CALL( glDrawRangeElementsBaseVertex ) },
+{ NULL, NULL }
+};
+
+static dllfunc_t bufferstoragefuncs[] =
+{
+{ GL_CALL( glBufferStorage ) },
+{ NULL, NULL }
+};
+
+
+static dllfunc_t shaderobjectsfuncs[] =
+{
+	{ GL_CALL( glDeleteObjectARB ) },
+	{ GL_CALL( glGetHandleARB ) },
+	{ GL_CALL( glDetachObjectARB ) },
+	{ GL_CALL( glCreateShaderObjectARB ) },
+	{ GL_CALL( glShaderSourceARB ) },
+	{ GL_CALL( glCompileShaderARB ) },
+	{ GL_CALL( glCreateProgramObjectARB ) },
+	{ GL_CALL( glAttachObjectARB ) },
+	{ GL_CALL( glLinkProgramARB ) },
+	{ GL_CALL( glUseProgramObjectARB ) },
+	{ GL_CALL( glValidateProgramARB ) },
+	{ GL_CALL( glUniform1fARB ) },
+	{ GL_CALL( glUniform2fARB ) },
+	{ GL_CALL( glUniform3fARB ) },
+	{ GL_CALL( glUniform4fARB ) },
+	{ GL_CALL( glUniform1iARB ) },
+	{ GL_CALL( glUniform2iARB ) },
+	{ GL_CALL( glUniform3iARB ) },
+	{ GL_CALL( glUniform4iARB ) },
+	{ GL_CALL( glUniform1fvARB ) },
+	{ GL_CALL( glUniform2fvARB ) },
+	{ GL_CALL( glUniform3fvARB ) },
+	{ GL_CALL( glUniform4fvARB ) },
+	{ GL_CALL( glUniform1ivARB ) },
+	{ GL_CALL( glUniform2ivARB ) },
+	{ GL_CALL( glUniform3ivARB ) },
+	{ GL_CALL( glUniform4ivARB ) },
+	{ GL_CALL( glUniformMatrix2fvARB ) },
+	{ GL_CALL( glUniformMatrix3fvARB ) },
+	{ GL_CALL( glUniformMatrix4fvARB ) },
+	{ GL_CALL( glGetObjectParameterfvARB ) },
+	{ GL_CALL( glGetObjectParameterivARB ) },
+	{ GL_CALL( glGetInfoLogARB ) },
+	{ GL_CALL( glGetAttachedObjectsARB ) },
+	{ GL_CALL( glGetUniformLocationARB ) },
+	{ GL_CALL( glGetActiveUniformARB ) },
+	{ GL_CALL( glGetUniformfvARB ) },
+	{ GL_CALL( glGetUniformivARB ) },
+	{ GL_CALL( glGetShaderSourceARB ) },
+	{ GL_CALL( glVertexAttribPointerARB ) },
+	{ GL_CALL( glEnableVertexAttribArrayARB ) },
+	{ GL_CALL( glDisableVertexAttribArrayARB ) },
+	{ GL_CALL( glBindAttribLocationARB ) },
+	{ GL_CALL( glGetActiveAttribARB ) },
+	{ GL_CALL( glGetAttribLocationARB ) },
+	{ GL_CALL( glVertexAttrib2fARB ) },
+	{ GL_CALL( glVertexAttrib2fvARB ) },
+//	{ GL_CALL( glVertexAttrib3fv ) },
+//	{ GL_CALL( glVertexAttrib4f ) },
+//	{ GL_CALL( glVertexAttrib4fv ) },
+//	{ GL_CALL( glVertexAttrib4ubv ) },
+{ NULL, NULL }
+};
+
+
+/*
+==================
+Even if *ARB functions may work in GL driver in Core context,
+renderdoc completely ignores this calls, so we cannot workaround this
+by removing ARB suffix after failed function resolve
+I desided not to remove ARB suffix from function declarations because
+it historicaly related to ARB_shader_object extension, not GL2+ functions
+and all shader code from XashXT/ancient xash3d uses it too
+Commented out lines left there intentionally to prevent usage on core/gles
+==================
+*/
+
+static dllfunc_t shaderobjectsfuncs_gles[] =
+{
+	{ "glDeleteShader"             , (void **)&pglDeleteObjectARB },
+	//{ "glGetHandleARB"                , (void **)&pglGetHandleARB },
+	{ "glDetachShader"             , (void **)&pglDetachObjectARB },
+	{ "glCreateShader"       , (void **)&pglCreateShaderObjectARB },
+	{ "glShaderSource"             , (void **)&pglShaderSourceARB },
+	{ "glCompileShader"            , (void **)&pglCompileShaderARB },
+	{ "glCreateProgram"      , (void **)&pglCreateProgramObjectARB },
+	{ "glAttachShader"             , (void **)&pglAttachObjectARB },
+	{ "glLinkProgram"              , (void **)&pglLinkProgramARB },
+	{ "glUseProgram"         , (void **)&pglUseProgramObjectARB },
+	{ "glValidateProgram"          , (void **)&pglValidateProgramARB },
+	{ "glUniform1f"                , (void **)&pglUniform1fARB },
+	{ "glUniform2f"                , (void **)&pglUniform2fARB },
+	{ "glUniform3f"                , (void **)&pglUniform3fARB },
+	{ "glUniform4f"                , (void **)&pglUniform4fARB },
+	{ "glUniform1i"                , (void **)&pglUniform1iARB },
+	{ "glUniform2i"                , (void **)&pglUniform2iARB },
+	{ "glUniform3i"                , (void **)&pglUniform3iARB },
+	{ "glUniform4i"                , (void **)&pglUniform4iARB },
+	{ "glUniform1f"               , (void **)&pglUniform1fvARB },
+	{ "glUniform2fv"               , (void **)&pglUniform2fvARB },
+	{ "glUniform3fv"               , (void **)&pglUniform3fvARB },
+	{ "glUniform4fv"               , (void **)&pglUniform4fvARB },
+	{ "glUniform1iv"               , (void **)&pglUniform1ivARB },
+	{ "glUniform2iv"               , (void **)&pglUniform2ivARB },
+	{ "glUniform3iv"               , (void **)&pglUniform3ivARB },
+	{ "glUniform4iv"               , (void **)&pglUniform4ivARB },
+	{ "glUniformMatrix2fv"         , (void **)&pglUniformMatrix2fvARB },
+	{ "glUniformMatrix3fv"         , (void **)&pglUniformMatrix3fvARB },
+	{ "glUniformMatrix4fv"         , (void **)&pglUniformMatrix4fvARB },
+//	{ "glGetShaderfv"     , (void **)&pglGetObjectParameterfvARB }, // missing in ES2?
+	{ "glGetShaderiv"     , (void **)&pglGetObjectParameterivARB },
+	{ "glGetShaderInfoLog"               , (void **)&pglGetInfoLogARB },
+//	{ "glGetAttachedObjects"       , (void **)&pglGetAttachedObjectsARB }, // missing in ES2?
+	{ "glGetUniformLocation"       , (void **)&pglGetUniformLocationARB },
+	{ "glGetActiveUniform"         , (void **)&pglGetActiveUniformARB },
+	{ "glGetUniformfv"             , (void **)&pglGetUniformfvARB },
+	{ "glGetUniformiv"             , (void **)&pglGetUniformivARB },
+	{ "glGetShaderSource"          , (void **)&pglGetShaderSourceARB },
+	{ "glVertexAttribPointer"      , (void **)&pglVertexAttribPointerARB },
+	{ "glEnableVertexAttribArray"  , (void **)&pglEnableVertexAttribArrayARB },
+	{ "glDisableVertexAttribArray" , (void **)&pglDisableVertexAttribArrayARB },
+	{ "glBindAttribLocation"       , (void **)&pglBindAttribLocationARB },
+	{ "glGetActiveAttrib"          , (void **)&pglGetActiveAttribARB },
+	{ "glGetAttribLocation"        , (void **)&pglGetAttribLocationARB },
+	{ "glVertexAttrib2f"              , (void **)&pglVertexAttrib2fARB },
+	{ "glVertexAttrib2fv"             , (void **)&pglVertexAttrib2fvARB },
+	{ "glVertexAttrib3fv"             , (void **)&pglVertexAttrib3fvARB },
+
+	// Core/GLES only
+	{ GL_CALL( glGetProgramiv ) },
+	{ GL_CALL( glDeleteProgram ) },
+	{ GL_CALL( glGetProgramInfoLog ) },
+	//{ "glVertexAttrib4f"              , (void **)&pglVertexAttrib4fARB },
+	//{ "glVertexAttrib4fv"             , (void **)&pglVertexAttrib4fvARB },
+	//{ "glVertexAttrib4ubv"            , (void **)&pglVertexAttrib4ubvARB },
+	{ NULL, NULL }
+};
+
+static dllfunc_t vaofuncs[] =
+{
+	{ GL_CALL( glBindVertexArray ) },
+	{ GL_CALL( glDeleteVertexArrays ) },
+	{ GL_CALL( glGenVertexArrays ) },
+	{ GL_CALL( glIsVertexArray ) },
+	{ NULL, NULL }
+};
+
+static dllfunc_t multitexturefuncs_es[] =
+{
+	{ GL_CALL( glActiveTexture ) },
+	{ GL_CALL( glActiveTextureARB ) },
+	{ GL_CALL( glClientActiveTexture ) },
+	{ GL_CALL( glClientActiveTextureARB ) },
+	{ NULL					, NULL }
+};
+
+static dllfunc_t multitexturefuncs_es2[] =
+{
+	{ GL_CALL( glActiveTexture ) },
+	{ GL_CALL( glActiveTextureARB ) },
+	{ NULL					, NULL }
+};
+
+#endif
+
 /*
 ========================
 DebugCallback
@@ -319,12 +507,13 @@ int GL_MaxTextureUnits( void )
 GL_CheckExtension
 =================
 */
-qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext )
+qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext, float minver )
 {
 	const dllfunc_t	*func;
 	cvar_t		*parm = NULL;
 	const char	*extensions_string;
 	char		desc[MAX_VA_STRING];
+	float glver = (float)glConfig.version_major + glConfig.version_minor / 10.0f;
 
 	gEngfuncs.Con_Reportf( "GL_CheckExtension: %s ", name );
 	GL_SetExtension( r_ext, true );
@@ -345,7 +534,7 @@ qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char
 
 	extensions_string = glConfig.extensions_string;
 
-	if(( name[2] == '_' || name[3] == '_' ) && !Q_strstr( extensions_string, name ))
+	if(( name[2] == '_' || name[3] == '_' ) && !Q_strstr( extensions_string, name ) && ( glver < minver  || !minver || !glver ) )
 	{
 		GL_SetExtension( r_ext, false );	// update render info
 		gEngfuncs.Con_Reportf( "- ^1failed\n" );
@@ -362,8 +551,22 @@ qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char
 		// functions are cleared before all the extensions are evaluated
 		if((*func->func = (void *)gEngfuncs.GL_GetProcAddress( func->name )) == NULL )
 		{
-			// one or more functions are invalid, extension will be disabled
-			GL_SetExtension( r_ext, false );
+			// HACK: fix ARB names
+			char *str = Q_strstr( func->name, "ARB" );
+			if(str)
+			{
+				string name;
+
+				Q_strncpy( name, func->name, MAX_STRING );
+				name[str - func->name] = '\0';
+				*func->func = gEngfuncs.GL_GetProcAddress( name );
+
+				if( !*func->func )
+					GL_SetExtension( r_ext, false );
+			}
+			else
+				// one or more functions are invalid, extension will be disabled
+				GL_SetExtension( r_ext, false );
 		}
 	}
 #endif
@@ -545,7 +748,11 @@ void GL_InitExtensionsGLES( void )
 #elif defined( XASH_WES )
 	glConfig.context = CONTEXT_TYPE_GLES_2_X;
 	glConfig.wrapper = GLES_WRAPPER_WES;
+#elif defined( XASH_GLES3COMPAT )
+	glConfig.context = CONTEXT_TYPE_GLES_2_X;
+	glConfig.wrapper = GLES_WRAPPER_NONE;
 #else
+
 #error "unknown gles wrapper"
 #endif
 
@@ -556,12 +763,22 @@ void GL_InitExtensionsGLES( void )
 		switch( extid )
 		{
 		case GL_ARB_VERTEX_BUFFER_OBJECT_EXT:
-			GL_SetExtension( extid, true );
+			GL_CheckExtension( "vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", extid, 1.0 );
 			break;
 		case GL_ARB_MULTITEXTURE:
+			if( !GL_CheckExtension( "multitexture", multitexturefuncs, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.0 ) && glConfig.wrapper == GLES_WRAPPER_NONE )
+			{
+#ifndef XASH_GL_STATIC
+				if( !GL_CheckExtension( "multitexture_es1", multitexturefuncs_es, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.0 )
+						&& !GL_CheckExtension( "multitexture_es2", multitexturefuncs_es2, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 2.0 ))
+					break;
+#endif
+			}
 			GL_SetExtension( extid, true ); // required to be supported by wrapper
 
 			pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units );
+			if( glConfig.max_texture_units <= 1 )
+				pglGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &glConfig.max_texture_units );
 			if( glConfig.max_texture_units <= 1 )
 			{
 				GL_SetExtension( extid, false );
@@ -571,24 +788,48 @@ void GL_InitExtensionsGLES( void )
 			glConfig.max_texture_coords = glConfig.max_teximage_units = glConfig.max_texture_units;
 			break;
 		case GL_TEXTURE_CUBEMAP_EXT:
-			if( GL_CheckExtension( "GL_OES_texture_cube_map", NULL, "gl_texture_cubemap", extid ))
+			if( GL_CheckExtension( "GL_OES_texture_cube_map", NULL, "gl_texture_cubemap", extid, 0 ))
 				pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size );
 			break;
 		case GL_ANISOTROPY_EXT:
 			glConfig.max_texture_anisotropy = 0.0f;
-			if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_ext_anisotropic_filter", extid ))
+			if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_ext_anisotropic_filter", extid, 0 ))
 				pglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.max_texture_anisotropy );
 			break;
 		case GL_TEXTURE_LOD_BIAS:
-			if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", extid ))
+			if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", extid, 0 ))
 				pglGetFloatv( GL_MAX_TEXTURE_LOD_BIAS_EXT, &glConfig.max_texture_lod_bias );
 			break;
 		case GL_ARB_TEXTURE_NPOT_EXT:
-			GL_CheckExtension( "GL_OES_texture_npot", NULL, "gl_texture_npot", extid );
+			GL_CheckExtension( "GL_OES_texture_npot", NULL, "gl_texture_npot", extid, 0 );
 			break;
+#ifndef XASH_GL_STATIC
+		case GL_SHADER_OBJECTS_EXT:
+			GL_CheckExtension( "ES2 Shaders", shaderobjectsfuncs_gles, "gl_shaderobjects", extid, 2.0 );
+			break;
+		case GL_ARB_VERTEX_ARRAY_OBJECT_EXT:
+			if( !GL_CheckExtension( "GL_OES_vertex_array_object", vaofuncs, "gl_vertex_array_object", extid, 3.0 ))
+				GL_CheckExtension( "GL_EXT_vertex_array_object", vaofuncs, "gl_vertex_array_object", extid, 3.0 );
+			break;
+		case GL_DRAW_RANGEELEMENTS_EXT:
+			if( !GL_CheckExtension( "GL_EXT_draw_range_elements", drawrangeelementsfuncs, "gl_drawrangeelements", extid, 3.0 ))
+				GL_CheckExtension( "GL_OES_draw_range_elements", drawrangeelementsfuncs, "gl_drawrangeelements", extid, 3.0 );
+			break;
+		case GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT:
+			if( !GL_CheckExtension( "GL_OES_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 0 ))
+				GL_CheckExtension( "GL_EXT_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 3.2 );
+			break;
+		case GL_MAP_BUFFER_RANGE_EXT:
+			GL_CheckExtension( "GL_EXT_map_buffer_range", mapbufferrangefuncs, "gl_map_buffer_range", GL_MAP_BUFFER_RANGE_EXT , 3.0);
+			break;
+		case GL_BUFFER_STORAGE_EXT:
+			GL_CheckExtension( "GL_EXT_buffer_storage", bufferstoragefuncs, "gl_buffer_storage", GL_BUFFER_STORAGE_EXT, 0);
+			break;
+
+#endif
 		case GL_DEBUG_OUTPUT:
 			if( glw_state.extended )
-				GL_CheckExtension( "GL_KHR_debug", NULL, NULL, extid );
+				GL_CheckExtension( "GL_KHR_debug", NULL, NULL, extid, 0 );
 			break;
 		// case GL_TEXTURE_COMPRESSION_EXT: NOPE
 		// case GL_SHADER_GLSL100_EXT: NOPE
@@ -607,12 +848,15 @@ void GL_InitExtensionsGLES( void )
 			GL_SetExtension( extid, false );
 		}
 	}
+#ifndef XASH_GL_STATIC
+	GL2_ShimInit();
+#endif
 }
 #else
 void GL_InitExtensionsBigGL( void )
 {
 	// intialize wrapper type
-	glConfig.context = CONTEXT_TYPE_GL;
+	glConfig.context = gEngfuncs.Sys_CheckParm( "-glcore" )? CONTEXT_TYPE_GL_CORE : CONTEXT_TYPE_GL;
 	glConfig.wrapper = GLES_WRAPPER_NONE;
 
 	if( Q_stristr( glConfig.renderer_string, "geforce" ))
@@ -643,7 +887,7 @@ void GL_InitExtensionsBigGL( void )
 
 	// multitexture
 	glConfig.max_texture_units = glConfig.max_texture_coords = glConfig.max_teximage_units = 1;
-	if( GL_CheckExtension( "GL_ARB_multitexture", multitexturefuncs, "gl_arb_multitexture", GL_ARB_MULTITEXTURE ))
+	if( GL_CheckExtension( "GL_ARB_multitexture", multitexturefuncs, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.3f ))
 	{
 		pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units );
 	}
@@ -652,7 +896,7 @@ void GL_InitExtensionsBigGL( void )
 		GL_SetExtension( GL_ARB_MULTITEXTURE, false );
 
 	// 3d texture support
-	if( GL_CheckExtension( "GL_EXT_texture3D", texture3dextfuncs, "gl_texture_3d", GL_TEXTURE_3D_EXT ))
+	if( GL_CheckExtension( "GL_EXT_texture3D", texture3dextfuncs, "gl_texture_3d", GL_TEXTURE_3D_EXT, 2.0f ))
 	{
 		pglGetIntegerv( GL_MAX_3D_TEXTURE_SIZE, &glConfig.max_3d_texture_size );
 
@@ -664,25 +908,25 @@ void GL_InitExtensionsBigGL( void )
 	}
 
 	// 2d texture array support
-	if( GL_CheckExtension( "GL_EXT_texture_array", texture3dextfuncs, "gl_texture_2d_array", GL_TEXTURE_ARRAY_EXT ))
+	if( GL_CheckExtension( "GL_EXT_texture_array", texture3dextfuncs, "gl_texture_2d_array", GL_TEXTURE_ARRAY_EXT, 0 ))
 		pglGetIntegerv( GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, &glConfig.max_2d_texture_layers );
 
 	// cubemaps support
-	if( GL_CheckExtension( "GL_ARB_texture_cube_map", NULL, "gl_texture_cubemap", GL_TEXTURE_CUBEMAP_EXT ))
+	if( GL_CheckExtension( "GL_ARB_texture_cube_map", NULL, "gl_texture_cubemap", GL_TEXTURE_CUBEMAP_EXT, 0 ))
 	{
 		pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size );
 
 		// check for seamless cubemaps too
-		GL_CheckExtension( "GL_ARB_seamless_cube_map", NULL, "gl_texture_cubemap_seamless", GL_ARB_SEAMLESS_CUBEMAP );
+		GL_CheckExtension( "GL_ARB_seamless_cube_map", NULL, "gl_texture_cubemap_seamless", GL_ARB_SEAMLESS_CUBEMAP, 0 );
 	}
 
-	GL_CheckExtension( "GL_ARB_texture_non_power_of_two", NULL, "gl_texture_npot", GL_ARB_TEXTURE_NPOT_EXT );
-	GL_CheckExtension( "GL_ARB_texture_compression", texturecompressionfuncs, "gl_texture_dxt_compression", GL_TEXTURE_COMPRESSION_EXT );
-	if( !GL_CheckExtension( "GL_EXT_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT ))
-		GL_CheckExtension( "GL_SGIS_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT );
+	GL_CheckExtension( "GL_ARB_texture_non_power_of_two", NULL, "gl_texture_npot", GL_ARB_TEXTURE_NPOT_EXT, 0 );
+	GL_CheckExtension( "GL_ARB_texture_compression", texturecompressionfuncs, "gl_texture_dxt_compression", GL_TEXTURE_COMPRESSION_EXT, 0 );
+	if( !GL_CheckExtension( "GL_EXT_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT, 2.0 )) // present in ES2
+		GL_CheckExtension( "GL_SGIS_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT, 0 );
 
 	glConfig.max_texture_anisotropy = 0.0f;
-	if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_texture_anisotropic_filter", GL_ANISOTROPY_EXT ))
+	if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_texture_anisotropic_filter", GL_ANISOTROPY_EXT, 0 ))
 		pglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.max_texture_anisotropy );
 
 #if XASH_WIN32 // Win32 only drivers?
@@ -690,20 +934,30 @@ void GL_InitExtensionsBigGL( void )
 	if( glConfig.hardware_type != GLHW_INTEL )
 #endif
 	{
-		if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", GL_TEXTURE_LOD_BIAS ))
+		if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", GL_TEXTURE_LOD_BIAS, 1.4 ))
 			pglGetFloatv( GL_MAX_TEXTURE_LOD_BIAS_EXT, &glConfig.max_texture_lod_bias );
 	}
 
-	GL_CheckExtension( "GL_ARB_texture_border_clamp", NULL, NULL, GL_CLAMP_TEXBORDER_EXT );
+	GL_CheckExtension( "GL_ARB_texture_border_clamp", NULL, NULL, GL_CLAMP_TEXBORDER_EXT, 2.0 ); // present in ES2
 
-	GL_CheckExtension( "GL_ARB_depth_texture", NULL, NULL, GL_DEPTH_TEXTURE );
-	GL_CheckExtension( "GL_ARB_texture_float", NULL, "gl_texture_float", GL_ARB_TEXTURE_FLOAT_EXT );
-	GL_CheckExtension( "GL_ARB_depth_buffer_float", NULL, "gl_texture_depth_float", GL_ARB_DEPTH_FLOAT_EXT );
-	GL_CheckExtension( "GL_EXT_gpu_shader4", NULL, NULL, GL_EXT_GPU_SHADER4 ); // don't confuse users
-	GL_CheckExtension( "GL_ARB_vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", GL_ARB_VERTEX_BUFFER_OBJECT_EXT );
-	GL_CheckExtension( "GL_ARB_texture_multisample", multisampletexfuncs, "gl_texture_multisample", GL_TEXTURE_MULTISAMPLE );
-	GL_CheckExtension( "GL_ARB_texture_compression_bptc", NULL, "gl_texture_bptc_compression", GL_ARB_TEXTURE_COMPRESSION_BPTC );
-	if( GL_CheckExtension( "GL_ARB_shading_language_100", NULL, NULL, GL_SHADER_GLSL100_EXT ))
+	GL_CheckExtension( "GL_ARB_depth_texture", NULL, NULL, GL_DEPTH_TEXTURE, 1.4 ); // missing in gles, check GL_OES_depth_texture
+	GL_CheckExtension( "GL_ARB_texture_float", NULL, "gl_texture_float", GL_ARB_TEXTURE_FLOAT_EXT, 0 );
+	GL_CheckExtension( "GL_ARB_depth_buffer_float", NULL, "gl_texture_depth_float", GL_ARB_DEPTH_FLOAT_EXT, 0 );
+	GL_CheckExtension( "GL_EXT_gpu_shader4", NULL, NULL, GL_EXT_GPU_SHADER4, 0 ); // don't confuse users
+	GL_CheckExtension( "GL_ARB_vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", GL_ARB_VERTEX_BUFFER_OBJECT_EXT, 2.0 );
+	GL_CheckExtension( "GL_ARB_texture_multisample", multisampletexfuncs, "gl_texture_multisample", GL_TEXTURE_MULTISAMPLE, 0 );
+	GL_CheckExtension( "GL_ARB_texture_compression_bptc", NULL, "gl_texture_bptc_compression", GL_ARB_TEXTURE_COMPRESSION_BPTC, 0 );
+#ifndef XASH_GL_STATIC
+	if( glConfig.context == CONTEXT_TYPE_GL_CORE )
+		GL_CheckExtension( "shader_objects", shaderobjectsfuncs_gles, "gl_shaderobjects", GL_SHADER_OBJECTS_EXT, 2.0 );
+	else
+		GL_CheckExtension( "GL_ARB_shader_objects", shaderobjectsfuncs, "gl_shaderobjects", GL_SHADER_OBJECTS_EXT, 2.0 );
+	GL_CheckExtension( "GL_ARB_vertex_array_object", vaofuncs, "gl_vertex_array_object", GL_ARB_VERTEX_ARRAY_OBJECT_EXT, 3.0 );
+	GL_CheckExtension( "GL_ARB_buffer_storage", bufferstoragefuncs, "gl_buffer_storage", GL_BUFFER_STORAGE_EXT, 4.4);
+	GL_CheckExtension( "GL_ARB_map_buffer_range", mapbufferrangefuncs, "gl_map_buffer_range", GL_MAP_BUFFER_RANGE_EXT , 3.0);
+	GL_CheckExtension( "GL_ARB_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 3.2 );
+#endif
+	if( GL_CheckExtension( "GL_ARB_shading_language_100", NULL, NULL, GL_SHADER_GLSL100_EXT, 2.0 ))
 	{
 		pglGetIntegerv( GL_MAX_TEXTURE_COORDS_ARB, &glConfig.max_texture_coords );
 		pglGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &glConfig.max_teximage_units );
@@ -724,12 +978,12 @@ void GL_InitExtensionsBigGL( void )
 	}
 
 	// rectangle textures support
-	GL_CheckExtension( "GL_ARB_texture_rectangle", NULL, "gl_texture_rectangle", GL_TEXTURE_2D_RECT_EXT );
+	GL_CheckExtension( "GL_ARB_texture_rectangle", NULL, "gl_texture_rectangle", GL_TEXTURE_2D_RECT_EXT, 0 );
 
-	if( !GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, "gl_drawrangeelements", GL_DRAW_RANGEELEMENTS_EXT ) )
+	if( !GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, "gl_drawrangeelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ) )
 	{
 		if( GL_CheckExtension( "glDrawRangeElementsEXT", drawrangeelementsextfuncs,
-			"gl_drawrangelements", GL_DRAW_RANGEELEMENTS_EXT ) )
+			"gl_drawrangelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ))
 		{
 #ifndef XASH_GL_STATIC
 			pglDrawRangeElements = pglDrawRangeElementsEXT;
@@ -739,7 +993,7 @@ void GL_InitExtensionsBigGL( void )
 
 	// this won't work without extended context
 	if( glw_state.extended )
-		GL_CheckExtension( "GL_ARB_debug_output", debugoutputfuncs, "gl_debug_output", GL_DEBUG_OUTPUT );
+		GL_CheckExtension( "GL_ARB_debug_output", debugoutputfuncs, "gl_debug_output", GL_DEBUG_OUTPUT, 0 );
 
 #if XASH_PSVITA
 	// not all GL1.1 functions are implemented in vitaGL, but there's enough
@@ -747,23 +1001,77 @@ void GL_InitExtensionsBigGL( void )
 	// init our immediate mode override
 	VGL_ShimInit();
 #endif
+#if !defined(XASH_GLES) && !defined(XASH_GL_STATIC)
+	if( gEngfuncs.Sys_CheckParm( "-gl2shim" ))
+		GL2_ShimInit();
+#endif
 }
 #endif
 
 void GL_InitExtensions( void )
 {
 	char value[MAX_VA_STRING];
+	GLint major = 0, minor = 0;
 
 	GL_OnContextCreated();
 
 	// initialize gl extensions
-	GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, GL_OPENGL_110 );
+	GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, GL_OPENGL_110, 1.0 );
 
 	// get our various GL strings
 	glConfig.vendor_string = (const char *)pglGetString( GL_VENDOR );
 	glConfig.renderer_string = (const char *)pglGetString( GL_RENDERER );
 	glConfig.version_string = (const char *)pglGetString( GL_VERSION );
 	glConfig.extensions_string = (const char *)pglGetString( GL_EXTENSIONS );
+
+	pglGetIntegerv( GL_MAJOR_VERSION, &major );
+	pglGetIntegerv( GL_MINOR_VERSION, &minor );
+	if( !major && glConfig.version_string )
+	{
+		const char *str = glConfig.version_string;
+		float ver;
+
+		while( *str && ( *str < '0' || *str > '9' )) str++;
+		ver = Q_atof(str);
+		if( ver )
+		{
+			glConfig.version_major = ver;
+			glConfig.version_minor = (int)(ver * 10) % 10;
+		}
+	}
+	else
+	{
+		glConfig.version_major = major;
+		glConfig.version_minor = minor;
+	}
+#ifndef XASH_GL_STATIC
+	if( !glConfig.extensions_string )
+	{
+		int n = 0;
+		pglGetStringi = gEngfuncs.GL_GetProcAddress( "glGetStringi" );
+
+		pglGetIntegerv( GL_NUM_EXTENSIONS, &n );
+		if( n && pglGetStringi )
+		{
+			int i, len = 1;
+			char *str;
+
+			for( i = 0; i < n; i++ )
+				len += Q_strlen((const char *)pglGetStringi( GL_EXTENSIONS, i )) + 1;
+
+			str = (char*)Mem_Calloc( r_temppool, len );
+			glConfig.extensions_string = str;
+
+			for( i = 0; i < n; i++ )
+			{
+				int l = Q_strncpy( str, pglGetStringi( GL_EXTENSIONS, i ), len );
+				str += l;
+				*str++ = ' ';
+				len -= l + 1;
+			}
+		}
+	}
+#endif
 	gEngfuncs.Con_Reportf( "^3Video^7: %s\n", glConfig.renderer_string );
 
 #ifdef XASH_GLES
@@ -843,6 +1151,8 @@ void GL_InitCommands( void )
 	gEngfuncs.Cvar_RegisterVariable( &r_lockpvs );
 	gEngfuncs.Cvar_RegisterVariable( &r_lockfrustum );
 	gEngfuncs.Cvar_RegisterVariable( &r_traceglow );
+	gEngfuncs.Cvar_RegisterVariable( &r_studio_sort_textures );
+	gEngfuncs.Cvar_RegisterVariable( &r_studio_drawelements );
 
 	gEngfuncs.Cvar_RegisterVariable( &gl_extensions );
 	gEngfuncs.Cvar_RegisterVariable( &gl_texture_nearest );
@@ -927,6 +1237,8 @@ qboolean R_Init( void )
 
 	GL_SetDefaultState();
 
+	r_temppool = Mem_AllocPool( "Render Zone" );
+
 	// create the window and set up the context
 	if( !gEngfuncs.R_Init_Video( REF_GL )) // request GL context
 	{
@@ -934,11 +1246,10 @@ qboolean R_Init( void )
 		gEngfuncs.R_Free_Video();
 // Why? Host_Error again???
 //		gEngfuncs.Host_Error( "Can't initialize video subsystem\nProbably driver was not installed" );
+		Mem_FreePool( &r_temppool );
 		return false;
 	}
 
-	r_temppool = Mem_AllocPool( "Render Zone" );
-
 	GL_SetDefaults();
 	R_CheckVBO();
 	R_InitImages();
@@ -963,6 +1274,9 @@ void R_Shutdown( void )
 
 	GL_RemoveCommands();
 	R_ShutdownImages();
+#if !defined(XASH_GLES) && !defined(XASH_GL_STATIC)
+	GL2_ShimShutdown();
+#endif
 
 	Mem_FreePool( &r_temppool );
 
@@ -1046,14 +1360,22 @@ void GL_SetupAttributes( int safegl )
 		SetBits( context_flags, FCONTEXT_CORE_PROFILE );
 
 		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_CORE );
+		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 3 );
+		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 3 );
 	}
 	else
 	{
-		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_COMPATIBILITY );
+		if( !safegl )
+			gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_COMPATIBILITY );
+		else
+		{
+			gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 1 );
+			gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 1 );
+		}
 	}
 #endif // XASH_GLES
 
-	if( gEngfuncs.Sys_CheckParm( "-gldebug" ) )
+	if( gEngfuncs.Sys_CheckParm( "-gldebug" ))
 	{
 		gEngfuncs.Con_Reportf( "Creating an extended GL context for debug...\n" );
 		SetBits( context_flags, FCONTEXT_DEBUG_ARB );
@@ -1182,6 +1504,8 @@ void GL_OnContextCreated( void )
 	glState.stencilEnabled = glConfig.stencil_bits ? true : false;
 
 	gEngfuncs.GL_GetAttribute( REF_GL_MULTISAMPLESAMPLES, &glConfig.msaasamples );
+	gEngfuncs.GL_GetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, &glConfig.version_major );
+	gEngfuncs.GL_GetAttribute( REF_GL_CONTEXT_MINOR_VERSION, &glConfig.version_minor );
 
 #ifdef XASH_WES
 	wes_init( "" );

ref/gl/gl_rmain.c

@@ -20,6 +20,7 @@ GNU General Public License for more details.
 #include "particledef.h"
 #include "entity_types.h"
 
+
 #define IsLiquidContents( cnt )	( cnt == CONTENTS_WATER || cnt == CONTENTS_SLIME || cnt == CONTENTS_LAVA )
 
 float		gldepthmin, gldepthmax;
@@ -1126,6 +1127,9 @@ void R_EndFrame( void )
 {
 #if XASH_PSVITA
 	VGL_ShimEndFrame();
+#endif
+#if !defined( XASH_GL_STATIC )
+	GL2_ShimEndFrame();
 #endif
 	// flush any remaining 2D bits
 	R_Set2DMode( false );

ref/gl/gl_rsurf.c

@@ -1792,11 +1792,7 @@ void R_GenerateVBO( void )
 	R_ClearVBO();
 
 	// we do not want to write vbo code that does not use multitexture
-#if ALLOW_VBO
-	if( !GL_Support( GL_ARB_VERTEX_BUFFER_OBJECT_EXT ) || !GL_Support( GL_ARB_MULTITEXTURE ) || glConfig.max_texture_units < 2 )
-#else
-	if( 1 )
-#endif
+	if( !GL_Support( GL_ARB_VERTEX_BUFFER_OBJECT_EXT ) || !GL_Support( GL_ARB_MULTITEXTURE ) || glConfig.max_texture_units < 2 || !gEngfuncs.Sys_CheckParm("-gl-allow-vbo-dontuse") )
 	{
 		gEngfuncs.Cvar_FullSet( "gl_vbo", "0", FCVAR_READ_ONLY );
 		return;

ref/gl/gl_studio.c

@@ -121,9 +121,9 @@ typedef struct
 } studio_draw_state_t;
 
 // studio-related cvars
-static CVAR_DEFINE_AUTO( r_studio_sort_textures, "0", FCVAR_GLCONFIG, "change draw order for additive meshes" );
+CVAR_DEFINE_AUTO( r_studio_sort_textures, "0", FCVAR_GLCONFIG, "change draw order for additive meshes" );
+CVAR_DEFINE_AUTO( r_studio_drawelements, "1", FCVAR_GLCONFIG, "use glDrawElements for studiomodels" );
 static cvar_t			*cl_righthand = NULL;
-static CVAR_DEFINE_AUTO( r_studio_drawelements, "1", FCVAR_GLCONFIG, "use glDrawElements for studiomodels" );
 
 static r_studio_interface_t	*pStudioDraw;
 static studio_draw_state_t	g_studio;		// global studio state
@@ -146,8 +146,6 @@ R_StudioInit
 */
 void R_StudioInit( void )
 {
-	gEngfuncs.Cvar_RegisterVariable( &r_studio_sort_textures );
-	gEngfuncs.Cvar_RegisterVariable( &r_studio_drawelements );
 
 #if XASH_PSVITA
 	// don't do the same array-building work twice since that's what our FFP shim does anyway

ref/gl/gl_warp.c

@@ -761,11 +761,8 @@ void EmitWaterPolys( msurface_t *warp, qboolean reverse )
 	float	s, t, os, ot;
 	glpoly_t	*p;
 	int	i;
-#ifndef XASH_GLES
-	const qboolean useQuads = FBitSet( warp->flags, SURF_DRAWTURB_QUADS );
-#else
-	const qboolean useQuads = false; // TODO: figure out why
-#endif
+
+	const qboolean useQuads = FBitSet( warp->flags, SURF_DRAWTURB_QUADS ) && glConfig.context == CONTEXT_TYPE_GL;
 
 	if( !warp->polys ) return;
 

ref/gl/wscript

@@ -39,7 +39,7 @@ def build(bld):
 	else:
 		libs += [ 'public', 'M' ]
 
-	source = bld.path.ant_glob(['*.c'])
+	source = bld.path.ant_glob(['*.c', 'gl2_shim/*.c'])
 	includes = '.'
 
 	targets = {
@@ -63,6 +63,11 @@ def build(bld):
 			'libs':    ['DL', 'gl4es', 'LOG'],
 			'defines': ['XASH_GL_STATIC', 'XASH_GL4ES'],
 		},
+		'ref_gles3compat': {
+			'enable':  bld.env.GLES3COMPAT,
+			'libs':    ['DL', 'gl4es', 'LOG'],
+			'defines': ['XASH_GLES3COMPAT'],
+		},
 	}
 
 	for k,v in targets.items():

ref/soft/r_local.h

@@ -1096,6 +1096,7 @@ extern convar_t   sw_surfcacheoverride;
 extern convar_t   sw_texfilt;
 extern convar_t   r_traceglow;
 extern convar_t   sw_noalphabrushes;
+extern convar_t   r_studio_sort_textures;
 
 extern struct qfrustum_s {
 	mplane_t screenedge[4];

ref/soft/r_main.c

@@ -1918,6 +1918,7 @@ qboolean GAME_EXPORT R_Init( void )
 	gEngfuncs.Cvar_RegisterVariable( &sw_texfilt );
 #endif
 	gEngfuncs.Cvar_RegisterVariable( &r_novis );
+	gEngfuncs.Cvar_RegisterVariable( &r_studio_sort_textures );
 
 	r_temppool = Mem_AllocPool( "ref_soft zone" );
 

ref/soft/r_studio.c

@@ -117,7 +117,7 @@ typedef struct
 } studio_draw_state_t;
 
 // studio-related cvars
-static CVAR_DEFINE_AUTO( r_studio_sort_textures, "0", FCVAR_GLCONFIG, "change draw order for additive meshes" );
+CVAR_DEFINE_AUTO( r_studio_sort_textures, "0", FCVAR_GLCONFIG, "change draw order for additive meshes" );
 static cvar_t			*cl_righthand = NULL;
 
 static r_studio_interface_t	*pStudioDraw;
@@ -141,8 +141,6 @@ R_StudioInit
 */
 void R_StudioInit( void )
 {
-	gEngfuncs.Cvar_RegisterVariable( &r_studio_sort_textures );
-
 	Matrix3x4_LoadIdentity( g_studio.rotationmatrix );
 
 	// g-cont. cvar disabled by Valve

utils/mdldec/qc.c

@@ -15,6 +15,7 @@ GNU General Public License for more details.
 
 #include <stdlib.h>
 #include <string.h>
+#include "xash3d_mathlib.h"
 #include "eiface.h"
 #include "studio.h"
 #include "crtlib.h"
@@ -197,6 +198,7 @@ static void WriteTextureRenderMode( FILE *fp )
 {
 	int		  i;
 	mstudiotexture_t *texture;
+	long		  pos = ftell( fp );
 
 	for( i = 0; i < texture_hdr->numtextures; i++ )
 	{
@@ -234,6 +236,9 @@ static void WriteTextureRenderMode( FILE *fp )
 		if( texture->flags & STUDIO_NF_TWOSIDE )
 			fprintf( fp, "$texrendermode \"%s\" \"twoside\" \n", texture->name );
 	}
+
+	if( ftell( fp ) != pos )
+		fputs( "\n", fp );
 }
 
 /*
@@ -250,15 +255,15 @@ static void WriteSkinFamilyInfo( FILE *fp )
 	if( texture_hdr->numskinfamilies < 2 )
 		return;
 
-	fprintf( fp, "\n// %i skin families\n", texture_hdr->numskinfamilies );
+	fprintf( fp, "// %i skin families\n", texture_hdr->numskinfamilies );
 
-	fputs( "$texturegroup skinfamilies \n{\n", fp );
+	fputs( "$texturegroup \"skinfamilies\"\n{\n", fp );
 
 	skinref = (short *)( (byte *)texture_hdr + texture_hdr->skinindex );
 
 	for( i = 0; i < texture_hdr->numskinfamilies; ++i )
 	{
-		fputs( "{", fp );
+		fputs( "\t{\n", fp );
 
 		for( j = 0; j < texture_hdr->numskinref; ++j )
 		{
@@ -271,15 +276,15 @@ static void WriteSkinFamilyInfo( FILE *fp )
 
 				texture = (mstudiotexture_t *)( (byte *)texture_hdr + texture_hdr->textureindex ) + index;
 
-				fprintf( fp, " \"%s\" ", texture->name );
+				fprintf( fp, "\t\t\"%s\"\n", texture->name );
 				break;
 			}
 		}
 
-		fputs( "}\n", fp );
+		fputs( "\t}\n", fp );
 	}
 
-	fputs( "}\n", fp );
+	fputs( "}\n\n", fp );
 }
 
 /*
@@ -296,7 +301,7 @@ static void WriteAttachmentInfo( FILE *fp )
 	if( !model_hdr->numattachments )
 		return;
 
-	fprintf( fp, "\n// %i attachment(s)\n", model_hdr->numattachments );
+	fprintf( fp, "// %i attachment%s\n", model_hdr->numattachments, model_hdr->numattachments > 1 ? "s" : "" );
 
 	for( i = 0; i < model_hdr->numattachments; ++i )
 	{
@@ -305,6 +310,8 @@ static void WriteAttachmentInfo( FILE *fp )
 
 		fprintf( fp, "$attachment %i \"%s\" %f %f %f\n", i, bone->name, attachment->org[0], attachment->org[1], attachment->org[2] );
 	}
+
+	fputs( "\n", fp );
 }
 
 /*
@@ -319,7 +326,7 @@ static void WriteBodyGroupInfo( FILE *fp )
 	mstudiomodel_t		*model;
 	char			 modelname[64];
 
-	fputs( "\n// reference mesh(es)\n", fp );
+	fprintf( fp, "// %i reference mesh%s\n", model_hdr->numbodyparts, model_hdr->numbodyparts > 1 ? "es" : "" );
 
 	for( i = 0; i < model_hdr->numbodyparts; ++i )
 	{
@@ -331,7 +338,7 @@ static void WriteBodyGroupInfo( FILE *fp )
 
 			COM_FileBase( model->name, modelname, sizeof( modelname ));
 
-			fprintf( fp, "$body \"%s\" \"%s\"\n\n", bodypart->name, modelname );
+			fprintf( fp, "$body \"%s\" \"%s\"\n", bodypart->name, modelname );
 			continue;
 		}
 
@@ -345,17 +352,19 @@ static void WriteBodyGroupInfo( FILE *fp )
 
 			if( !Q_strncmp( model->name, "blank", 5 ) )
 			{
-				fputs( "blank\n", fp );
+				fputs( "\tblank\n", fp );
 				continue;
 			}
 
 			COM_FileBase( model->name, modelname, sizeof( modelname ));
 
-			fprintf( fp, "studio \"%s\"\n", modelname );
+			fprintf( fp, "\tstudio \"%s\"\n", modelname );
 		}
 
-		fputs( "}\n\n" , fp );
+		fputs( "}\n", fp );
 	}
+
+	fputs( "\n", fp );
 }
 
 /*
@@ -373,7 +382,7 @@ static void WriteControllerInfo( FILE *fp )
 	if( !model_hdr->numbonecontrollers )
 		return;
 
-	fprintf( fp, "\n// %i bone controller(s)\n", model_hdr->numbonecontrollers );
+	fprintf( fp, "// %i bone controller%s\n", model_hdr->numbonecontrollers, model_hdr->numbonecontrollers > 1 ? "s" : "" );
 
 	for( i = 0; i < model_hdr->numbonecontrollers; ++i )
 	{
@@ -382,10 +391,19 @@ static void WriteControllerInfo( FILE *fp )
 
 		GetMotionTypeString( bonecontroller->type & ~STUDIO_RLOOP, motion_types, sizeof( motion_types ), false );
 
-		fprintf( fp, "$controller %i \"%s\" %s %f %f\n",
-		    bonecontroller->index, bone->name, motion_types,
+		fputs( "$controller ", fp );
+
+		if( bonecontroller->index == 4 )
+			fputs( "Mouth", fp );
+		else
+			fprintf( fp, "%i", bonecontroller->index );
+
+		fprintf( fp, " \"%s\" %s %f %f\n",
+		    bone->name, motion_types,
 		    bonecontroller->start, bonecontroller->end );
 	}
+
+	fputs( "\n", fp );
 }
 
 /*
@@ -402,7 +420,7 @@ static void WriteHitBoxInfo( FILE *fp )
 	if( !model_hdr->numhitboxes )
 		return;
 
-	fprintf( fp, "\n// %i hit box(es)\n", model_hdr->numhitboxes );
+	fprintf( fp, "// %i hit box%s\n", model_hdr->numhitboxes, model_hdr->numhitboxes > 1 ? "es" : "" );
 
 	for( i = 0; i < model_hdr->numhitboxes; i++ )
 	{
@@ -414,6 +432,31 @@ static void WriteHitBoxInfo( FILE *fp )
 		    hitbox->bbmin[0], hitbox->bbmin[1], hitbox->bbmin[2],
 		    hitbox->bbmax[0], hitbox->bbmax[1], hitbox->bbmax[2] );
 	}
+
+	fputs( "\n", fp );
+}
+
+/*
+============
+CalcSequenceGroupSize
+============
+*/
+static int CalcSequenceGroupSize( void )
+{
+	int			i, maxsize = 0, groupsize = DEFAULT_SEQGROUPSIZE;
+
+	for( i = 1; i < model_hdr->numseqgroups; i++ )
+		maxsize = Q_max( anim_hdr[i]->length, maxsize );
+
+	if( maxsize > 0 )
+	{
+		groupsize = maxsize / 1024;
+
+		if( maxsize % 1024 )
+			groupsize++;
+	}
+
+	return groupsize;
 }
 
 /*
@@ -430,132 +473,93 @@ static void WriteSequenceInfo( FILE *fp )
 	mstudioseqdesc_t	*seqdesc;
 
 	if( model_hdr->numseqgroups > 1 )
-		fputs( "\n$sequencegroupsize 64\n", fp );
+		fprintf( fp, "$sequencegroupsize %d\n\n", CalcSequenceGroupSize( ) );
 
 	if( model_hdr->numseq > 0 )
-		fprintf( fp, "\n// %i animation sequence(s)\n", model_hdr->numseq );
+		fprintf( fp, "// %i animation sequence%s\n", model_hdr->numseq, model_hdr->numseq > 1 ? "s" : "" );
 
 	for( i = 0; i < model_hdr->numseq; ++i )
 	{
 		seqdesc = (mstudioseqdesc_t *)( (byte *)model_hdr + model_hdr->seqindex ) + i;
 
-		fprintf( fp, "$sequence \"%s\" ", seqdesc->label );
+		fprintf( fp, "$sequence \"%s\" {\n", seqdesc->label );
 
 		if( seqdesc->numblends > 1 )
 		{
-			if( seqdesc->numblends > 2 )
+			for( j = 0; j < seqdesc->numblends; j++ )
 			{
-				fputs( "{\n", fp );
-
-				for( j = 0; j < seqdesc->numblends; j++ )
-				{
-					fputs( "          ", fp );
-
-					fprintf( fp, "\"%s_blend%i\" ", seqdesc->label, j + 1 );
-
-					fputs( "\n", fp );
-				}
-
-				fputs( "          ", fp );
+				fprintf( fp, "\t\"%s_blend%02i\"\n", seqdesc->label, j + 1 );
 			}
-			else
-			{
-				fprintf( fp, "\"%s_blend1\" ", seqdesc->label );
-				fprintf( fp, "\"%s_blend2\" ", seqdesc->label );
-			}
-
-			GetMotionTypeString( seqdesc->blendtype[0], motion_types, sizeof( motion_types ), false );
-
-			fprintf( fp, "blend %s %.0f %.0f",
-			    motion_types, seqdesc->blendstart[0], seqdesc->blendend[0] );
 		}
 		else
 		{
-			fprintf( fp, "\"%s\"", seqdesc->label );
+			fprintf( fp, "\t\"%s\"\n", seqdesc->label );
 		}
 
-		if( seqdesc->motiontype )
-		{
-			GetMotionTypeString( seqdesc->motiontype, motion_types, sizeof( motion_types ), true );
-
-			fprintf( fp, "%s", motion_types );
-		}
-
-		fprintf( fp, " fps %.0f ", seqdesc->fps );
-
-		if( seqdesc->flags == 1 )
-			fputs( "loop ", fp );
-
 		if( seqdesc->activity )
 		{
 			activity = FindActivityName( seqdesc->activity );
 
 			if( activity )
 			{
-				fprintf( fp, "%s %i ", activity, seqdesc->actweight );
+				fprintf( fp, "\t%s %i\n", activity, seqdesc->actweight );
 			}
 			else
 			{
 				printf( "WARNING: Sequence %s has a custom activity flag (ACT_%i %i).\n",
 				    seqdesc->label, seqdesc->activity, seqdesc->actweight );
 
-				fprintf( fp, "ACT_%i %i ", seqdesc->activity, seqdesc->actweight );
+				fprintf( fp, "\tACT_%i %i\n", seqdesc->activity, seqdesc->actweight );
 			}
 		}
 
+		if( seqdesc->blendtype[0] )
+		{
+			GetMotionTypeString( seqdesc->blendtype[0], motion_types, sizeof( motion_types ), false );
+
+			fprintf( fp, "\tblend %s %.0f %.0f\n",
+			    motion_types, seqdesc->blendstart[0], seqdesc->blendend[0] );
+		}
+
+		for( j = 0; j < seqdesc->numevents; j++ )
+		{
+			event = (mstudioevent_t *)( (byte *)model_hdr + seqdesc->eventindex ) + j;
+
+			fprintf( fp, "\t{ event %i %i", event->event, event->frame );
+
+			if( event->options[0] != '\0' )
+				fprintf( fp, " \"%s\"", event->options );
+
+			fputs( " }\n", fp );
+		}
+
+
+		fprintf( fp, "\tfps %.0f\n", seqdesc->fps );
+
+		if( seqdesc->flags == 1 )
+			fputs( "\tloop\n", fp );
+
+		if( seqdesc->motiontype )
+		{
+			GetMotionTypeString( seqdesc->motiontype, motion_types, sizeof( motion_types ), true );
+
+			fprintf( fp, "\t%s\n", motion_types );
+		}
+
 		if( seqdesc->entrynode && seqdesc->exitnode )
 		{
 			if( seqdesc->entrynode == seqdesc->exitnode )
-				fprintf( fp, "node %i ", seqdesc->entrynode );
+				fprintf( fp, "\tnode %i\n", seqdesc->entrynode );
 			else if( seqdesc->nodeflags )
-				fprintf( fp, "rtransition %i %i ", seqdesc->entrynode, seqdesc->exitnode );
+				fprintf( fp, "\trtransition %i %i\n", seqdesc->entrynode, seqdesc->exitnode );
 			else
-				fprintf( fp, "transition %i %i ", seqdesc->entrynode, seqdesc->exitnode );
+				fprintf( fp, "\ttransition %i %i\n", seqdesc->entrynode, seqdesc->exitnode );
 		}
 
-		if( seqdesc->numevents > 2 )
-		{
-			fputs( "{\n ", fp );
-
-			for( j = 0; j < seqdesc->numevents; j++ )
-			{
-				if( seqdesc->numblends <= 2 )
-					fputs( " ", fp );
-				else
-					fputs( "          ", fp );
-
-				event = (mstudioevent_t *)( (byte *)model_hdr + seqdesc->eventindex ) + j;
-
-				fprintf( fp, "{ event %i %i", event->event, event->frame );
-
-				if( event->options[0] != '\0' )
-					fprintf( fp, " \"%s\"", event->options );
-
-				fputs( " }\n ", fp );
-			}
-
-			fputs( "}", fp );
-		}
-		else
-		{
-			for( j = 0; j < seqdesc->numevents; j++ )
-			{
-				event = (mstudioevent_t *)( (byte *)model_hdr + seqdesc->eventindex ) + j;
-
-				fprintf( fp, "{ event %i %i", event->event, event->frame );
-
-				if( event->options[0] != '\0')
-					fprintf( fp, " \"%s\"", event->options );
-
-				fputs( " } ", fp );
-			}
-		}
-
-		fputs( "\n", fp );
-
-		if( seqdesc->numblends > 2 )
-			fputs( "}\n", fp );
+		fputs( "}\n", fp );
 	}
+
+	fputs( "\n", fp );
 }
 
 /*
@@ -601,41 +605,34 @@ void WriteQCScript( void )
 
 	fprintf( fp, "$modelname \"%s.mdl\"\n", modelfile );
 
-	fputs( "$cd \".\\\"\n", fp );
-	fputs( "$cdtexture \".\\\"\n", fp );
-	fputs( "$scale 1.0\n", fp );
+	fputs( "$cd \".\"\n", fp );
+	fputs( "$cdtexture \".\"\n", fp );
 	fputs( "$cliptotextures\n", fp );
-	fputs( "\n", fp );
-
-	if( !model_hdr->numtextures )
-		fputs( "$externaltextures\n", fp );
-
-	if( model_hdr->flags != 0 )
-	{
-		fprintf( fp, "$flags %i\n", model_hdr->flags );
-
-		printf( "WARNING: This model uses the $flags keyword set to %i\n", model_hdr->flags );
-	}
-
-	fputs( "\n", fp );
-
-	fprintf( fp, "$bbox %f %f %f", model_hdr->min[0], model_hdr->min[1], model_hdr->min[2] );
-	fprintf( fp, " %f %f %f\n", model_hdr->max[0], model_hdr->max[1], model_hdr->max[2] );
-	fprintf( fp, "$cbox %f %f %f", model_hdr->bbmin[0], model_hdr->bbmin[1], model_hdr->bbmin[2] );
-	fprintf( fp, " %f %f %f\n", model_hdr->bbmax[0], model_hdr->bbmax[1], model_hdr->bbmax[2] );
-	fprintf( fp, "$eyeposition %f %f %f\n", model_hdr->eyeposition[0], model_hdr->eyeposition[1], model_hdr->eyeposition[2] );
-
+	fputs( "$scale 1.0\n", fp );
 	fputs( "\n", fp );
 
 	WriteBodyGroupInfo( fp );
-	WriteTextureRenderMode( fp );
+
+	fprintf( fp, "$flags %i\n\n", model_hdr->flags );
+	fprintf( fp, "$eyeposition %f %f %f\n\n", model_hdr->eyeposition[0], model_hdr->eyeposition[1], model_hdr->eyeposition[2] );
+
+	if( !model_hdr->numtextures )
+		fputs( "$externaltextures\n\n", fp );
+
 	WriteSkinFamilyInfo( fp );
+	WriteTextureRenderMode( fp );
 	WriteAttachmentInfo( fp );
-	WriteControllerInfo( fp );
+
+	fprintf( fp, "$bbox %f %f %f", model_hdr->min[0], model_hdr->min[1], model_hdr->min[2] );
+	fprintf( fp, " %f %f %f\n\n", model_hdr->max[0], model_hdr->max[1], model_hdr->max[2] );
+	fprintf( fp, "$cbox %f %f %f", model_hdr->bbmin[0], model_hdr->bbmin[1], model_hdr->bbmin[2] );
+	fprintf( fp, " %f %f %f\n\n", model_hdr->bbmax[0], model_hdr->bbmax[1], model_hdr->bbmax[2] );
+
 	WriteHitBoxInfo( fp );
+	WriteControllerInfo( fp );
 	WriteSequenceInfo( fp );
 
-	fputs( "\n// End of QC script.\n", fp );
+	fputs( "// End of QC script.\n", fp );
 	fclose( fp );
 
 	printf( "QC Script: %s\n", filename );

utils/mdldec/qc.h

@@ -16,6 +16,7 @@ GNU General Public License for more details.
 #ifndef QC_H
 #define QC_H
 
+#define DEFAULT_SEQGROUPSIZE	64
 #define ACTIVITIES_FILE	"activities.txt"
 
 qboolean	LoadActivityList( const char *appname );

utils/mdldec/smd.c

@@ -383,6 +383,7 @@ WriteFrameInfo
 static void WriteFrameInfo( FILE *fp, mstudioanim_t *anim, mstudioseqdesc_t *seqdesc, int frame )
 {
 	int			 i, j;
+	float			 scale;
 	vec_t			 motion[6]; // x, y, z, xr, yr, zr
 	mstudiobone_t		*bone;
 
@@ -396,8 +397,10 @@ static void WriteFrameInfo( FILE *fp, mstudioanim_t *anim, mstudioseqdesc_t *seq
 
 		if( bone->parent == -1 )
 		{
+			scale = frame / (float)( seqdesc->numframes - 1 );
+
 			for( j = 0; j < 3; j++ )
-				motion[j] += frame * 1.0f / seqdesc->numframes * seqdesc->linearmovement[j];
+				motion[j] += scale * seqdesc->linearmovement[j];
 
 			ProperBoneRotationZ( motion, 270.0f );
 		}
@@ -522,7 +525,7 @@ static void WriteSequences( void )
 			if( seqdesc->numblends == 1 )
 				len = Q_snprintf( filename, MAX_SYSPATH, "%s%s.smd", destdir, seqdesc->label );
 			else
-				len = Q_snprintf( filename, MAX_SYSPATH, "%s%s_blend%i.smd", destdir, seqdesc->label, j + 1 );
+				len = Q_snprintf( filename, MAX_SYSPATH, "%s%s_blend%02i.smd", destdir, seqdesc->label, j + 1 );
 
 			if( len == -1 )
 			{

wscript

@@ -90,6 +90,7 @@ SUBDIRS = [
 
 	# enabled on PSVita only
 	Subproject('ref/gl/vgl_shim',   lambda x: x.env.DEST_OS == 'psvita'),
+
 ]
 
 REFDLLS = [
@@ -98,6 +99,7 @@ REFDLLS = [
 	RefDll('gles1', False, 'NANOGL'),
 	RefDll('gles2', False, 'GLWES'),
 	RefDll('gl4es', False),
+	RefDll('gles3compat', False),
 ]
 
 def options(opt):