xash3d-fwgs/ref/soft/r_glblit.c

#include "r_local.h"
#define APIENTRY_LINKAGE static
#include "../gl/gl_export.h"

struct swblit_s
{
	uint stride;
	uint bpp;
	uint rmask, gmask, bmask;
	void *(*pLockBuffer)( void );
	void (*pUnlockBuffer)( void );
	qboolean(*pCreateBuffer)( int width, int height, uint *stride, uint *bpp, uint *r, uint *g, uint *b );
	uint rotate;
	qboolean gl1;
} swblit;


qboolean R_SetDisplayTransform( ref_screen_rotation_t rotate, int offset_x, int offset_y, float scale_x, float scale_y )
{
	qboolean ret = true;
	if( rotate > 1 )
	{
		gEngfuncs.Con_Printf("only 0-1 rotation supported\n");
		ret = false;
	}
	else
		swblit.rotate = rotate;

	if( offset_x || offset_y )
	{
		// it is possible implement for offset > 0
		gEngfuncs.Con_Printf("offset transform not supported\n");
		ret = false;
	}

	if( scale_x != 1.0f || scale_y != 1.0f )
	{
		// maybe implement 2x2?
		gEngfuncs.Con_Printf("scale transform not supported\n");
		ret = false;
	}

	return ret;
}

/*
========================
DebugCallback

For ARB_debug_output
========================
*/
static void APIENTRY GL_DebugOutput( GLuint source, GLuint type, GLuint id, GLuint severity, GLint length, const GLcharARB *message, GLvoid *userParam )
{
	switch( type )
	{
	case GL_DEBUG_TYPE_ERROR_ARB:
		gEngfuncs.Con_Printf( S_OPENGL_ERROR "%s\n", message );
		break;
	case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
	case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
		gEngfuncs.Con_Printf( S_OPENGL_WARN "%s\n", message );
		break;
	case GL_DEBUG_TYPE_PORTABILITY_ARB:
		gEngfuncs.Con_Reportf( S_OPENGL_WARN "%s\n", message );
		break;
	case GL_DEBUG_TYPE_PERFORMANCE_ARB:
	case GL_DEBUG_TYPE_OTHER_ARB:
	default:
		gEngfuncs.Con_Printf( S_OPENGL_NOTE "%s\n", message );
		break;
	}
}


static unsigned short *glbuf;
static int tex;

#define LOAD(x) p##x = gEngfuncs.GL_GetProcAddress(#x); \
	gEngfuncs.Con_Printf(#x " : %p\n",p##x)


void GAME_EXPORT GL_SetupAttributes( int safegl )
{
#if GLDEBUG
	gEngfuncs.Con_Reportf( "Creating an extended GL context for debug...\n" );
	gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_FLAGS, REF_GL_CONTEXT_DEBUG_FLAG );
#endif
	// untill we have any blitter in ref api, setup GL
	gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_ES );
	gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_EGL, 1 );
//	safegl=1;
	if( safegl )
	{
		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 1 );
		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 1 );
		swblit.gl1 = true;
	}
	else
	{
		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 3 );
		gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 0 );
	}
	gEngfuncs.GL_SetAttribute( REF_GL_DOUBLEBUFFER, 1 );

	gEngfuncs.GL_SetAttribute( REF_GL_RED_SIZE, 5 );
	gEngfuncs.GL_SetAttribute( REF_GL_GREEN_SIZE, 6 );
	gEngfuncs.GL_SetAttribute( REF_GL_BLUE_SIZE, 5 );
}

void (*pglOrthof)(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
void GL_FUNCTION( glBindBuffer)(GLenum target, GLuint buffer);

void GL_FUNCTION( glBufferData )(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
void GL_FUNCTION( glGenBuffers )(GLsizei n, GLuint *buffers);
void GL_FUNCTION( glDeleteBuffers )(GLsizei n, const GLuint *buffers);
GLvoid* GL_FUNCTION( glMapBufferOES )(GLenum target, GLenum access);
GLboolean GL_FUNCTION( glUnmapBufferOES )(GLenum target);
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
#define GL_FRAMEBUFFER 0x8D40
#define GL_COLOR_ATTACHMENT0 0x8CE0
#define GL_READ_FRAMEBUFFER 0x8CA8
#define GL_DRAW_FRAMEBUFFER 0x8CA9
void GAME_EXPORT GL_InitExtensions( void )
{
	LOAD(glBegin);
	LOAD(glEnd);
	LOAD(glTexCoord2f);
	LOAD(glVertex2f);
	LOAD(glEnable);
	LOAD(glDisable);
	LOAD(glTexImage2D);
	LOAD(glOrtho);
	LOAD(glOrthof);
	LOAD(glMatrixMode);
	LOAD(glLoadIdentity);
	LOAD(glViewport);
	LOAD(glBindTexture);
	LOAD(glDebugMessageCallbackARB);
	LOAD(glDebugMessageControlARB);
	LOAD(glGetError);
	LOAD(glGenTextures);
	LOAD(glTexParameteri);
	LOAD(glEnableClientState);
	LOAD(glDisableClientState);
	LOAD(glVertexPointer);
	LOAD(glTexCoordPointer);
	LOAD(glDrawElements);
	LOAD(glClear);
	LOAD(glClearColor);
	LOAD(glGetString);
	LOAD(glColor4f);
	LOAD(glDrawArrays);
	LOAD(glBindBuffer);
	LOAD(glBufferData);
	LOAD(glGenBuffers);
	LOAD(glDeleteBuffers);
	LOAD(glMapBufferOES);
	if( !pglMapBufferOES )
		pglMapBufferOES = gEngfuncs.GL_GetProcAddress("glMapBuffer");
	LOAD(glUnmapBufferOES);
	if( !pglUnmapBufferOES )
		pglUnmapBufferOES = gEngfuncs.GL_GetProcAddress("glUnmapBuffer");
	LOAD(glGenFramebuffers);
	LOAD(glBindFramebuffer);
	LOAD(glFramebufferTexture2D);
	LOAD(glBlitFramebuffer);
	LOAD(glGenTextures);
	gEngfuncs.Con_Printf("version:%s\n",pglGetString(GL_VERSION));
#if GLDEBUG
	if( gpGlobals->developer )
	{
		gEngfuncs.Con_Reportf( "Installing GL_DebugOutput...\n");
		pglDebugMessageCallbackARB( GL_DebugOutput, NULL );

		// force everything to happen in the main thread instead of in a separate driver thread
		pglEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB );
	}

	// enable all the low priority messages
	pglDebugMessageControlARB( GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, true );
#endif

}
void GAME_EXPORT GL_ClearExtensions( void )
{

}

static void *R_Lock_GL1( void )
{
	return glbuf;
}

static void R_Unlock_GL1( void )
{

	pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vid.width, vid.height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glbuf );
	//gEngfuncs.Con_Printf("%d\n",pglGetError());
	pglBegin( GL_QUADS );
		pglTexCoord2f( 0, 0 );
		pglVertex2f( 0, 0 );

		pglTexCoord2f( 1, 0 );
		pglVertex2f( 1, 0 );

		pglTexCoord2f( 1, 1 );
		pglVertex2f( 1, 1 );

		pglTexCoord2f( 0, 1 );
		pglVertex2f( 0, 1 );
	pglEnd();
	gEngfuncs.GL_SwapBuffers();
}


static void R_Unlock_GLES1( void )
{
	pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vid.width, vid.height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glbuf );
	pglDrawArrays( GL_TRIANGLE_FAN, 0,4 );

	gEngfuncs.GL_SwapBuffers();
}

static qboolean R_CreateBuffer_GL1( int width, int height, uint *stride, uint *bpp, uint *r, uint *g, uint *b )
{
	pglViewport( 0, 0, width, height );
	pglMatrixMode( GL_PROJECTION );
	pglLoadIdentity();
	pglOrtho( 0, 1, 1, 0, -99999, 99999 );
	pglMatrixMode( GL_MODELVIEW );
	pglLoadIdentity();

	pglEnable( GL_TEXTURE_2D );
	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	if( glbuf )
		Mem_Free(glbuf);

	glbuf = Mem_Malloc( r_temppool, width*height*2 );

	*stride = width;
	*bpp = 2;
	*r = MASK(5) << (6 + 5);
	*g = MASK(6) << 5;
	*b = MASK(5);

	return true;
}

static qboolean R_CreateBuffer_GLES1( int width, int height, uint *stride, uint *bpp, uint *r, uint *g, uint *b )
{
	float data[] = {
		// quad verts match texcoords
		0, 0,
		1, 0,
		1, 1,
		0, 1,
	};
	int vbo;

	pglViewport( 0, 0, width, height );
	pglMatrixMode( GL_PROJECTION );
	pglLoadIdentity();
	// project 0..1 to screen size
	pglOrthof( 0, 1, 1, 0, -99999, 99999 );
	pglMatrixMode( GL_MODELVIEW );
	pglLoadIdentity();

	pglEnable( GL_TEXTURE_2D );
	pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
	pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

	//if( vbo )
	//	pglDeleteBuffers( 1,&vbo );

	pglGenBuffers( 1,&vbo );
	pglBindBuffer( GL_ARRAY_BUFFER_ARB, vbo );
	pglBufferData( GL_ARRAY_BUFFER_ARB, sizeof(data), data, GL_STATIC_DRAW_ARB );

	pglEnableClientState( GL_VERTEX_ARRAY );
	pglEnableClientState( GL_TEXTURE_COORD_ARRAY );

	pglVertexPointer( 2, GL_FLOAT, 8, 0 );
	pglTexCoordPointer( 2, GL_FLOAT, 8, 0 );
	pglBindBuffer( GL_ARRAY_BUFFER_ARB, 0 ) ;
	pglColor4f( 1, 1, 1, 1 );


	if( glbuf )
		Mem_Free( glbuf );

	glbuf = Mem_Malloc( r_temppool, width*height*2 );

	*stride = width;
	*bpp = 2;
	*r = MASK(5) << (6 + 5);
	*g = MASK(6) << 5;
	*b = MASK(5);

	return true;
}

static void *R_Lock_GLES3( void )
{
	void *buf = NULL;

	if( !vid.width || !vid.height )
		return NULL;

	if( glbuf )
		return glbuf;

	pglBufferData( GL_PIXEL_UNPACK_BUFFER, vid.width * vid.height * 2, 0, GL_STREAM_DRAW_ARB );
	if( pglMapBufferOES )
		buf = pglMapBufferOES( GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY_ARB );
	if( !buf )
	{
		if( pglUnmapBufferOES )
			pglUnmapBufferOES( GL_PIXEL_UNPACK_BUFFER );
		pglBindBuffer( GL_PIXEL_UNPACK_BUFFER, 0 );
		glbuf = Mem_Malloc( r_temppool, vid.width*vid.height*2 );
		pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vid.width, vid.height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glbuf );
		return glbuf;
	}
	else
		return buf;
}


static void R_Unlock_GLES3( void )
{
	gEngfuncs.GL_SwapBuffers();
	if( glbuf )
		pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vid.width, vid.height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glbuf );
	else
	{
		if( pglUnmapBufferOES )
			pglUnmapBufferOES( GL_PIXEL_UNPACK_BUFFER );
		pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vid.width, vid.height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0 );
	}
	//pglDrawArrays( GL_TRIANGLE_FAN, 0,4 );
	pglBlitFramebuffer( 0, vid.height, vid.width, 0, 0, 0, vid.width, vid.height, GL_COLOR_BUFFER_BIT, GL_NEAREST );
}

static qboolean R_CreateBuffer_GLES3( int width, int height, uint *stride, uint *bpp, uint *r, uint *g, uint *b )
{
	float data[] = {
		// quad verts match texcoords
		0, 0,
		1, 0,
		1, 1,
		0, 1,
	};
	GLuint vbo, pbo, fbo, to;

	// shitty fbo does not work without texture objects :(
	pglGenTextures( 1, &to );
	pglBindTexture( GL_TEXTURE_2D, to );
	pglViewport( 0, 0, width, height );
	/*
	pglMatrixMode( GL_PROJECTION );
	pglLoadIdentity();
	// project 0..1 to screen size
	pglOrtho( 0, 1, 1, 0, -99999, 99999 );
	pglMatrixMode( GL_MODELVIEW );
	pglLoadIdentity();

	pglEnable( GL_TEXTURE_2D );
	pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
	pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

	if( vbo )
		pglDeleteBuffers( 1,&vbo );

	if( pbo )
		pglDeleteBuffers( 1,&pbo );
	*/

	//pglGenBuffers( 1,&vbo );
	pglGenBuffers( 1, &pbo );
	//pglBindBuffer( GL_ARRAY_BUFFER_ARB, vbo );
	//pglBufferData( GL_ARRAY_BUFFER_ARB, sizeof(data), data, GL_STATIC_DRAW_ARB );

	//pglEnableClientState( GL_VERTEX_ARRAY );
	//pglEnableClientState( GL_TEXTURE_COORD_ARRAY );

	//pglVertexPointer( 2, GL_FLOAT, 8, 0 );
	//pglTexCoordPointer( 2, GL_FLOAT, 8, 0 );
	//pglBindBuffer( GL_ARRAY_BUFFER_ARB, 0 );

	pglBindBuffer( GL_PIXEL_UNPACK_BUFFER, pbo );
	pglBufferData( GL_PIXEL_UNPACK_BUFFER, width * height * 2, 0, GL_STREAM_DRAW_ARB );
	pglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0 );

	pglGenFramebuffers(1, &fbo);
	pglBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
	pglFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, to, 0);
	pglBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

	//pglColor4f( 1, 1, 1, 1 );


	*stride = width;
	*bpp = 2;
	*r = MASK(5) << (6 + 5);
	*g = MASK(6) << 5;
	*b = MASK(5);

	return true;
}



static int FIRST_BIT( uint mask )
{
	uint i;

	for( i = 0; !(BIT(i) & mask); i++ );

	return i;
}

static int COUNT_BITS( uint mask )
{
	uint i;

	for( i = 0; mask; mask = mask >> 1 )
		i += mask & 1;

	return i;
}

static void R_BuildScreenMap( void )
{
	int i;
	uint rshift = FIRST_BIT(swblit.rmask), gshift = FIRST_BIT(swblit.gmask), bshift = FIRST_BIT(swblit.bmask);
	uint rbits = COUNT_BITS(swblit.rmask), gbits = COUNT_BITS(swblit.gmask), bbits = COUNT_BITS(swblit.bmask);
	uint rmult = BIT(rbits), gmult = BIT(gbits), bmult = BIT(bbits);
	uint rdiv = MASK(5), gdiv = MASK(6), bdiv = MASK(5);

	gEngfuncs.Con_Printf("Blit table: %d %d %d %d %d %d\n", rmult, gmult, bmult, rdiv, gdiv, bdiv );

#ifdef SEPARATE_BLIT
	for( i = 0; i < 256; i++ )
	{
		unsigned int r,g,b;

		// 332 to 565
		r = ((i >> (8 - 3) )<< 2 ) & MASK(5);
		g = ((i >> (8 - 3 - 3)) << 3) & MASK(6);
		b = ((i >> (8 - 3 - 3 - 2)) << 3) & MASK(5);
		vid.screen_major[i] = r << (6 + 5) | (g << 5) | b;


		// restore minor GBRGBRGB
		r = MOVE_BIT(i, 5, 1) | MOVE_BIT(i, 2, 0);
		g = MOVE_BIT(i, 7, 2) | MOVE_BIT(i, 4, 1) | MOVE_BIT(i, 1, 0);
		b = MOVE_BIT(i, 6, 2) | MOVE_BIT(i, 3, 1) | MOVE_BIT(i, 0, 0);
		vid.screen_minor[i] = r << (6 + 5) | (g << 5) | b;

	}
#else
	for( i = 0; i < 256; i++ )
	{
		unsigned int r,g,b , major, j;

		// 332 to 565
		r = ((i >> (8 - 3) )<< 2 ) & MASK(5);
		g = ((i >> (8 - 3 - 3)) << 3) & MASK(6);
		b = ((i >> (8 - 3 - 3 - 2)) << 3) & MASK(5);
		//major = r << (6 + 5) | (g << 5) | b;
		major = (r * rmult / rdiv) << rshift | (g * gmult / gdiv) << gshift | (b * bmult / bdiv) << bshift;


		for( j = 0; j < 256; j++ )
		{
			uint minor;
			// restore minor GBRGBRGB
			r = MOVE_BIT(j, 5, 1) | MOVE_BIT(j, 2, 0);
			g = MOVE_BIT(j, 7, 2) | MOVE_BIT(j, 4, 1) | MOVE_BIT(j, 1, 0);
			b = MOVE_BIT(j, 6, 2) | MOVE_BIT(j, 3, 1) | MOVE_BIT(j, 0, 0);
			//vid.screen[(i<<8)|j] = r << (6 + 5) | (g << 5) | b | major;
			minor = (r * rmult / rdiv) << rshift | (g * gmult / gdiv) << gshift | (b * bmult / bdiv) << bshift;

			if( swblit.bpp == 2 )
				vid.screen[(i<<8)|j] = major | minor;
			else
				vid.screen32[(i<<8)|j] = major | minor;

		}

	}
#endif
}

#define FOR_EACH_COLOR(x) 	for( r##x = 0; r##x < BIT(3); r##x++ ) for( g##x = 0; g##x < BIT(3); g##x++ ) for( b##x = 0; b##x < BIT(2); b##x++ )

static void R_BuildBlendMaps( void )
{
	unsigned int r1, g1, b1;
	unsigned int r2, g2, b2;
	unsigned int i, j;

	FOR_EACH_COLOR(1)FOR_EACH_COLOR(2)
	{
		unsigned int r, g, b;
		unsigned short index1 = r1 << (2 + 3) | g1 << 2 | b1;
		unsigned short index2 = (r2 << (2 + 3) | g2 << 2 | b2) << 8;
		unsigned int a;

		r = r1 + r2;
		g = g1 + g2;
		b = b1 + b2;
		if( r > MASK(3) )
			r = MASK(3);
		if( g > MASK(3) )
			g = MASK(3);
		if( b > MASK(2) )
			b = MASK(2);
		ASSERT(!vid.addmap[index2|index1]);

		vid.addmap[index2|index1] =  r << (2 + 3) | g << 2 | b;
		r = r1 * r2 / MASK(3);
		g = g1 * g2 / MASK(3);
		b = b1 * b2 / MASK(2);

		vid.modmap[index2|index1] =  r << (2 + 3) | g << 2 | b;
#if 0
		for( a = 0; a < 8; a++ )
		{
			r = r1 * (7 - a) / 7 + r2 * a / 7;
			g = g1 * (7 - a) / 7 + g2 * a / 7;
			b = b1 * (7 - a) / 7 + b2 * a / 7;
			//if( b == 1 ) b = 0;
			vid.alphamap[a << 16|index2|index1] =  r << (2 + 3) | g << 2 | b;
		}
#endif
	}
	for( i = 0; i < 8192; i++ )
	{
		unsigned int r, g, b;
		uint color = i << 3;
		uint m = color >> 8;
		uint j = color & 0xff;
		unsigned short index1 = i;

		r1 = ((m >> (8 - 3) )<< 2 ) & MASK(5);
		g1 = ((m >> (8 - 3 - 3)) << 3) & MASK(6);
		b1 = ((m >> (8 - 3 - 3 - 2)) << 3) & MASK(5);
		r1 |= MOVE_BIT(j, 5, 1) | MOVE_BIT(j, 2, 0);
		g1 |= MOVE_BIT(j, 7, 2) | MOVE_BIT(j, 4, 1) | MOVE_BIT(j, 1, 0);
		b1 |= MOVE_BIT(j, 6, 2) | MOVE_BIT(j, 3, 1) | MOVE_BIT(j, 0, 0);


		for( j = 0; j < 32; j++)
		{
			unsigned int index2 = j << 13;
			unsigned int major, minor;
			r = r1 * j / 32;
			g = g1 * j / 32;
			b = b1 * j / 32;
			major = (((r >> 2) & MASK(3)) << 5) |( (( (g >> 3) & MASK(3)) << 2 )  )| (((b >> 3) & MASK(2)));

			// save minor GBRGBRGB
			minor = MOVE_BIT(r,1,5) | MOVE_BIT(r,0,2) | MOVE_BIT(g,2,7) | MOVE_BIT(g,1,4) | MOVE_BIT(g,0,1) | MOVE_BIT(b,2,6)| MOVE_BIT(b,1,3)|MOVE_BIT(b,0,0);

			vid.colormap[index2|index1] =  major << 8 | (minor & 0xFF);
		}
	}
#if 1
	for( i = 0; i < 1024; i++ )
	{
		unsigned int r, g, b;
		uint color = i << 6 | BIT(5) | BIT(4) | BIT(3);
		uint m = color >> 8;
		uint j = color & 0xff;
		unsigned short index1 = i;

		r1 = ((m >> (8 - 3) )<< 2 ) & MASK(5);
		g1 = ((m >> (8 - 3 - 3)) << 3) & MASK(6);
		b1 = ((m >> (8 - 3 - 3 - 2)) << 3) & MASK(5);
		r1 |= MOVE_BIT(j, 5, 1) | MOVE_BIT(j, 2, 0);
		g1 |= MOVE_BIT(j, 7, 2) | MOVE_BIT(j, 4, 1) | MOVE_BIT(j, 1, 0);
		b1 |= MOVE_BIT(j, 6, 2) | MOVE_BIT(j, 3, 1) | MOVE_BIT(j, 0, 0);


		FOR_EACH_COLOR(2)
		{
			unsigned int index2 = (r2 << (2 + 3) | g2 << 2 | b2) << 10;
			unsigned int k;
			for( k = 0; k < 3; k++ )
			{
				unsigned int major, minor;
				unsigned int a = k + 2;


				r = r1 * (7 - a) / 7 + (r2 << 2 | BIT(2)) * a / 7;
				g = g1 * (7 - a) / 7 + (g2 << 3 | MASK(2)) * a / 7;
				b = b1 * (7 - a) / 7 + (b2 << 3 | MASK(2)) * a / 7;
				if( r > MASK(5) )
					r = MASK(5);
				if( g > MASK(6) )
					g = MASK(6);
				if( b > MASK(5) )
					b = MASK(5);


				ASSERT( b < 32 );
				major = (((r >> 2) & MASK(3)) << 5) |( (( (g >> 3) & MASK(3)) << 2 )  )| (((b >> 3) & MASK(2)));

				// save minor GBRGBRGB
				minor = MOVE_BIT(r,1,5) | MOVE_BIT(r,0,2) | MOVE_BIT(g,2,7) | MOVE_BIT(g,1,4) | MOVE_BIT(g,0,1) | MOVE_BIT(b,2,6)| MOVE_BIT(b,1,3)|MOVE_BIT(b,0,0);
				minor = minor & ~0x3f;


				vid.alphamap[k << 18|index2|index1] =  major << 8 | (minor & 0xFF);
			}
		}
	}
#endif
}

void R_AllocScreen( void );

void R_InitBlit( qboolean glblit )
{
	R_BuildBlendMaps();

	if( glblit && swblit.gl1 )
	{
		swblit.pLockBuffer = R_Lock_GL1;
		swblit.pUnlockBuffer = R_Unlock_GLES1;
		swblit.pCreateBuffer = R_CreateBuffer_GLES1;
	}
	else if( glblit )
	{
		swblit.pLockBuffer = R_Lock_GLES3;
		swblit.pUnlockBuffer = R_Unlock_GLES3;
		swblit.pCreateBuffer = R_CreateBuffer_GLES3;
	}
	else
	{
		swblit.pLockBuffer = gEngfuncs.SW_LockBuffer;
		swblit.pUnlockBuffer = gEngfuncs.SW_UnlockBuffer;
		swblit.pCreateBuffer = gEngfuncs.SW_CreateBuffer;
	}
	R_AllocScreen();
}

void R_AllocScreen( void )
{
	int w, h;

	if( gpGlobals->width < 128 )
		gpGlobals->width = 128;
	if( gpGlobals->height < 128 )
		gpGlobals->height = 128;

	R_InitCaches();

	if( swblit.rotate )
		w = gpGlobals->height, h = gpGlobals->width;
	else
		h = gpGlobals->height, w = gpGlobals->width;

	swblit.pCreateBuffer( w, h, &swblit.stride, &swblit.bpp,
							   &swblit.rmask, &swblit.gmask, &swblit.bmask);
	R_BuildScreenMap();
	vid.width = gpGlobals->width;
	vid.height = gpGlobals->height;
	vid.rowbytes = gpGlobals->width; // rowpixels
	if( d_pzbuffer )
		free( d_pzbuffer );
	d_pzbuffer = malloc( vid.width*vid.height*2 + 64 );
	if( vid.buffer )
		free( vid.buffer );

	vid.buffer = malloc( vid.width * vid.height*sizeof( pixel_t ) );
}

void R_BlitScreen( void )
{
	int u, v;
	void *buffer = swblit.pLockBuffer();
//	gEngfuncs.Con_Printf("blit begin\n");
	//memset( vid.buffer, 10, vid.width * vid.height );

	if( !buffer || gpGlobals->width != vid.width || gpGlobals->height != vid.height )
	{
		gEngfuncs.Con_Printf("pre allocscrn\n");
		R_AllocScreen();
		gEngfuncs.Con_Printf("post allocscrn\n");
		return;
	}
	//return;
	//byte *buf = vid.buffer;

	//#pragma omp parallel for schedule(static)
	//gEngfuncs.Con_Printf("swblit %d %d", swblit.bpp, vid.height );
	if( swblit.rotate )
	{
		if( swblit.bpp == 2 )
		{
			unsigned short *pbuf = buffer;
			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint d = swblit.stride - v - 1;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen[vid.buffer[start + u]];
					pbuf[d] = s;
					d += swblit.stride;
				}
			}
		}
		else if( swblit.bpp == 4 )
		{
			unsigned int *pbuf = buffer;

			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint d = swblit.stride - v - 1;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen32[vid.buffer[start + u]];
					pbuf[d] = s;
					d += swblit.stride;
				}
			}
		}
		else if( swblit.bpp == 3 )
		{
			byte *pbuf = buffer;
			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint d = swblit.stride - v - 1;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen32[vid.buffer[start + u]];
					pbuf[(d)*3] = s;
					s = s >> 8;
					pbuf[(d)*3+1] = s;
					s = s >> 8;
					pbuf[(d)*3+2] = s;
					d += swblit.stride;
				}
			}
		}
	}
	else
	{
		if( swblit.bpp == 2 )
		{
			unsigned short *pbuf = buffer;
			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint dstart = swblit.stride * v;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen[vid.buffer[start + u]];
					pbuf[dstart + u] = s;
				}
			}
		}
		else if( swblit.bpp == 4 )
		{
			unsigned int *pbuf = buffer;

			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint dstart = swblit.stride * v;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen32[vid.buffer[start + u]];
					pbuf[dstart + u] = s;
				}
			}
		}
		else if( swblit.bpp == 3 )
		{
			byte *pbuf = buffer;
			for( v = 0; v < vid.height;v++)
			{
				uint start = vid.rowbytes * v;
				uint dstart = swblit.stride * v;

				for( u = 0; u < vid.width; u++ )
				{
					unsigned int s = vid.screen32[vid.buffer[start + u]];
					pbuf[(dstart+u)*3] = s;
					s = s >> 8;
					pbuf[(dstart+u)*3+1] = s;
					s = s >> 8;
					pbuf[(dstart+u)*3+2] = s;
				}
			}
		}
	}

	swblit.pUnlockBuffer();
//	gEngfuncs.Con_Printf("blit end\n");
}

static uint32_t Get8888PixelAt( int u, int start )
{
	uint32_t s;
	switch( swblit.bpp )
	{
	case 2:
	{
		pixel_t color = vid.screen[vid.buffer[start + u]];
		uint8_t c[3];
		c[0] = (((( color >> 11 ) & 0x1F ) * 527 ) + 23 ) >> 6;
		c[1] = (((( color >> 5 )  & 0x3F ) * 259 ) + 33 ) >> 6;
		c[2] = (((( color )       & 0x1F ) * 527 ) + 23 ) >> 6;

		s = c[0] << 16 | c[1] << 8 | c[2];
		break;
	}
	case 3:
	case 4:
	default:
		s = vid.screen32[vid.buffer[start + u]];
		break;
	}
	return s | 0xFF000000;
}

qboolean GAME_EXPORT VID_ScreenShot( const char *filename, int shot_type )
{
	rgbdata_t *r_shot;
	uint	flags = IMAGE_FLIP_Y;
	int	width = 0, height = 0, u, v;
	qboolean	result;

	r_shot = Mem_Calloc( r_temppool, sizeof( rgbdata_t ));
	r_shot->width = (vid.width + 3) & ~3;
	r_shot->height = (vid.height + 3) & ~3;
	r_shot->flags = IMAGE_HAS_COLOR;
	r_shot->type = PF_BGRA_32; // was RGBA
	r_shot->size = r_shot->width * r_shot->height * gEngfuncs.Image_GetPFDesc( r_shot->type )->bpp;
	r_shot->palette = NULL;
	r_shot->buffer = Mem_Malloc( r_temppool, r_shot->size );

	// get screen frame
	if( swblit.rotate )
	{
		uint32_t *pbuf = (uint32_t *)r_shot->buffer;

		for( v = 0; v < vid.height; v++ )
		{
			uint start = vid.rowbytes * ( vid.height - v );
			uint d = swblit.stride - v - 1;

			for( u = 0; u < vid.width; u++ )
			{
				pbuf[d] = Get8888PixelAt( u, start );
				d += swblit.stride;
			}
		}
	}
	else
	{
		uint32_t *pbuf = (uint32_t *)r_shot->buffer;

		for( v = 0; v < vid.height;v++)
		{
			uint start = vid.rowbytes * ( vid.height - v );
			uint dstart = swblit.stride * v;

			for( u = 0; u < vid.width; u++ )
			{
				pbuf[dstart + u] = Get8888PixelAt( u, start );
			}
		}
	}

	switch( shot_type )
	{
	case VID_SCREENSHOT:
		break;
	case VID_SNAPSHOT:
		gEngfuncs.fsapi->AllowDirectPaths( true );
		break;
	case VID_LEVELSHOT:
		flags |= IMAGE_RESAMPLE;
		if( gpGlobals->wideScreen )
		{
			height = 480;
			width = 800;
		}
		else
		{
			height = 480;
			width = 640;
		}
		break;
	case VID_MINISHOT:
		flags |= IMAGE_RESAMPLE;
		height = 200;
		width = 320;
		break;
	case VID_MAPSHOT:
		flags |= IMAGE_RESAMPLE|IMAGE_QUANTIZE;	// GoldSrc request overviews in 8-bit format
		height = 768;
		width = 1024;
		break;
	}

	gEngfuncs.Image_Process( &r_shot, width, height, flags, 0.0f );

	// write image
	result = gEngfuncs.FS_SaveImage( filename, r_shot );
	gEngfuncs.fsapi->AllowDirectPaths( false );			// always reset after store screenshot
	gEngfuncs.FS_FreeImage( r_shot );

	return result;
}