RetroArch/console/rgl/ps3/rgl.cpp

#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <float.h>

#include <cell/gcm.h>

#include <sys/sys_time.h>

#include "rgl.h"
#include "private.h"
#include <ppu_intrinsics.h>

#include "cg.h"
#include <Cg/cgc.h>
#include <Cg/cgGL.h>
#include "readelf.h"
#include "cgnv2rt.h"

#include <cell/sysmodule.h>

#include "../../../compat/strl.h"

#define RGL_ALIGN_FAST_TRANSFER 128

#define ENDIAN_32(X, F) ((F) ? endianSwapWord(X) : (X))
#define SWAP_IF_BIG_ENDIAN(arg) endianSwapWordByHalf(arg)
#define ROW_MAJOR 0
#define COL_MAJOR 1

#define pad(x, pad) (((x) + (pad) - 1 ) / (pad) * (pad))

#define gmmAddressToOffset(address, isMain) ((isMain) ? (address)-pGmmMainAllocator->memoryBase : (address)-pGmmLocalAllocator->memoryBase)

#define GL_UNSIGNED_SHORT_8_8		GL_UNSIGNED_SHORT_8_8_SCE
#define GL_UNSIGNED_SHORT_8_8_REV	GL_UNSIGNED_SHORT_8_8_REV_SCE
#define GL_UNSIGNED_INT_16_16		GL_UNSIGNED_INT_16_16_SCE
#define GL_UNSIGNED_INT_16_16_REV	GL_UNSIGNED_INT_16_16_REV_SCE

#define DECLARE_C_TYPES \
DECLARE_TYPE(GL_BYTE,GLbyte,127.f) \
DECLARE_TYPE(GL_UNSIGNED_BYTE,GLubyte,255.f) \
DECLARE_TYPE(GL_SHORT,GLshort,32767.f) \
DECLARE_TYPE(GL_UNSIGNED_SHORT,GLushort,65535.f) \
DECLARE_TYPE(GL_INT,GLint,2147483647.f) \
DECLARE_TYPE(GL_UNSIGNED_INT,GLuint,4294967295.0) \
DECLARE_TYPE(GL_FIXED,GLfixed,65535.f)

#define DECLARE_UNPACKED_TYPES \
DECLARE_UNPACKED_TYPE(GL_BYTE) \
DECLARE_UNPACKED_TYPE(GL_UNSIGNED_BYTE) \
DECLARE_UNPACKED_TYPE(GL_SHORT) \
DECLARE_UNPACKED_TYPE(GL_UNSIGNED_SHORT) \
DECLARE_UNPACKED_TYPE(GL_INT) \
DECLARE_UNPACKED_TYPE(GL_UNSIGNED_INT) \
DECLARE_UNPACKED_TYPE(GL_HALF_FLOAT_ARB) \
DECLARE_UNPACKED_TYPE(GL_FLOAT) \
DECLARE_UNPACKED_TYPE(GL_FIXED)


#define DECLARE_PACKED_TYPES \
DECLARE_PACKED_TYPE_AND_REV_2(UNSIGNED_BYTE,4,4) \
DECLARE_PACKED_TYPE_AND_REV_2(UNSIGNED_BYTE,6,2) \
DECLARE_PACKED_TYPE_AND_REV_3(UNSIGNED_BYTE,3,3,2) \
DECLARE_PACKED_TYPE_AND_REV_4(UNSIGNED_BYTE,2,2,2,2) \
DECLARE_PACKED_TYPE_AND_REV_2(UNSIGNED_SHORT,12,4) \
DECLARE_PACKED_TYPE_AND_REV_2(UNSIGNED_SHORT,8,8) \
DECLARE_PACKED_TYPE_AND_REV_3(UNSIGNED_SHORT,5,6,5) \
DECLARE_PACKED_TYPE_AND_REV_4(UNSIGNED_SHORT,4,4,4,4) \
DECLARE_PACKED_TYPE_AND_REV_4(UNSIGNED_SHORT,5,5,5,1) \
DECLARE_PACKED_TYPE_AND_REV_2(UNSIGNED_INT,16,16) \
DECLARE_PACKED_TYPE_AND_REV_4(UNSIGNED_INT,8,8,8,8) \
DECLARE_PACKED_TYPE_AND_REV_4(UNSIGNED_INT,10,10,10,2)

#define DECLARE_FORMATS \
DECLARE_FORMAT(GL_RGB,3) \
DECLARE_FORMAT(GL_BGR,3) \
DECLARE_FORMAT(GL_RGBA,4) \
DECLARE_FORMAT(GL_BGRA,4) \
DECLARE_FORMAT(GL_ABGR,4) \
DECLARE_FORMAT(GL_ARGB_SCE,4) \
DECLARE_FORMAT(GL_RED,1) \
DECLARE_FORMAT(GL_GREEN,1) \
DECLARE_FORMAT(GL_BLUE,1) \
DECLARE_FORMAT(GL_ALPHA,1)

#define jsMATRIX_SIZEf  (sizeof(GLfloat)*ELEMENTS_IN_MATRIX)

enum
{
   M10 = 1, M20, M30,
   M01, M11, M21, M31,
   M02, M12, M22, M32,
   M03, M13, M23, M33
};

static int _RGLInitCompleted = 0;
static char* _RGLVendorString = "Retro Arch";

static char* _RGLRendererString = "RGL";
static char* _RGLExtensionsString = "";

static char* _RGLVersionNumber = "1.0";

PSGLcontext* _CurrentContext = NULL;

 RGLcontextHookFunction _RGLContextCreateHook = NULL;
 RGLcontextHookFunction _RGLContextDestroyHook = NULL;

GmmAllocator         *pGmmLocalAllocator = NULL;
GmmAllocator         *pGmmMainAllocator = NULL;
static volatile uint32_t    *pLock = NULL;
static uint32_t             cachedLockValue = 0;
static GmmFixedAllocData    *pGmmFixedAllocData = NULL;
GLuint nvFenceCounter = 0;
static const unsigned int capacityIncr = 16;
static const int NAME_INCREMENT = 4;

#define DECLARE_TYPE(TYPE,CTYPE,MAXVAL) \
typedef CTYPE type_##TYPE; \
static inline type_##TYPE _RGLFloatTo_##TYPE(float v) { return (type_##TYPE)(_RGLClampf(v)*MAXVAL); } \
static inline float _RGLFloatFrom_##TYPE(type_##TYPE v) { return ((float)v)/MAXVAL; }
DECLARE_C_TYPES
#undef DECLARE_TYPE

typedef GLfloat type_GL_FLOAT;
static inline type_GL_FLOAT _RGLFloatTo_GL_FLOAT( float v ) {return v;}
static inline float _RGLFloatFrom_GL_FLOAT( type_GL_FLOAT v ) {return v;}

typedef GLhalfARB type_GL_HALF_FLOAT_ARB;

static const char *_getStringTable(const Elf32_Ehdr *ehdr)
{
	const char *sectionHeaderStart = (const char*)ehdr + ehdr->e_shoff;
	const Elf32_Shdr *shstrtabHeader = (const Elf32_Shdr*)sectionHeaderStart + ehdr->e_shstrndx;
	return (const char*)ehdr + shstrtabHeader->sh_offset;
}

const char *findSectionInPlace(const char* memory,unsigned int /*size*/,const char *name, size_t *sectionSize)
{
	const Elf32_Ehdr *ehdr = (const Elf32_Ehdr*)memory;
	
	const char *shstrtab = _getStringTable(ehdr);
	
	size_t sectionCount = ehdr->e_shnum;
	const char *sectionHeaderStart = (const char*)ehdr + ehdr->e_shoff;
	for (size_t i=0;i<sectionCount;i++)
	{
		const Elf32_Shdr *sectionHeader = (const Elf32_Shdr *)sectionHeaderStart + i;
		const char *sectionName = shstrtab + sectionHeader->sh_name;
		if (!strcmp(name,sectionName))
		{
			*sectionSize = sectionHeader->sh_size;
			return (const char*)ehdr + sectionHeader->sh_offset;
		}
	}
	return NULL;
}

const char *findSymbolSectionInPlace(const char *memory, unsigned int /*size*/, size_t *symbolSize, size_t *symbolCount, const char **symbolstrtab)
{
	const Elf32_Ehdr *ehdr = (const Elf32_Ehdr*)memory;
	
	size_t sectionCount = ehdr->e_shnum;
	const char *sectionHeaderStart = (const char*)ehdr + ehdr->e_shoff;
	for (size_t i=0;i<sectionCount;i++)
	{
		const Elf32_Shdr *sectionHeader = (const Elf32_Shdr *)sectionHeaderStart + i;
		if (sectionHeader->sh_type == SHT_SYMTAB)
		{
			*symbolSize = sectionHeader->sh_entsize;
			*symbolCount = sectionHeader->sh_size / sectionHeader->sh_entsize;

			const Elf32_Shdr *symbolStrHeader = (const Elf32_Shdr *)sectionHeaderStart + sectionHeader->sh_link;
			*symbolstrtab = (const char*)ehdr + symbolStrHeader->sh_offset;
			return (const char*)ehdr + sectionHeader->sh_offset;
		}
	}
	return NULL;
}


int lookupSymbolValueInPlace(const char* symbolSection, size_t symbolSize, size_t symbolCount, const char *symbolstrtab, const char *name)
{
	for (size_t i=0;i<symbolCount;i++)
	{
		Elf32_Sym* elf_sym = (Elf32_Sym*)symbolSection;

		if (!strcmp(symbolstrtab + elf_sym->st_name, name))
		{
			return elf_sym->st_value;
		}
		symbolSection+= symbolSize;
	}
	return -1;
}

const char *getSymbolByIndexInPlace(const char* symbolSection, size_t symbolSize, size_t symbolCount,  const char *symbolstrtab, int index)
{
	Elf32_Sym* elf_sym = (Elf32_Sym*)symbolSection + index;
	return symbolstrtab + elf_sym->st_name;
}

static inline type_GL_HALF_FLOAT_ARB _RGLFloatTo_GL_HALF_FLOAT_ARB( float x )
{
	jsIntAndFloat V = {f: x};
	unsigned int S = ( V.i >> 31 ) & 1;
	int E = (( V.i >> 23 ) & 0xff ) - 0x7f;
	unsigned int M = V.i & 0x007fffff;
	if (( E == 0x80 ) && ( M ) ) return 0x7fff;
	else if ( E >= 15 ) return( S << 15 ) | 0x7c00;
	else if ( E <= -14 ) return( S << 15 ) | (( 0x800000 + M ) >> ( -14 - E ) );
	else return( S << 15 ) | ((( E + 15 )&0x1f ) << 10 ) | ( M >> 13 );
}

static inline float _RGLFloatFrom_GL_HALF_FLOAT_ARB( type_GL_HALF_FLOAT_ARB x )
{
    unsigned int S = x >> 15;
    unsigned int E = ( x & 0x7C00 ) >> 10;
    unsigned int M = x & 0x03ff;
    float f;
    if ( E == 31 )
    {
        if ( M == 0 ) f = _RGLInfinity.f;
        else f = _RGLNan.f;
    }
    else if ( E == 0 )
    {
        if ( M == 0 ) f = 0.f;
        else f = M * 1.f / ( 1 << 24 );
    }
    else f = ( 0x400 + M ) * 1.f / ( 1 << 25 ) * ( 1 << E );
    return S ? -f : f;
}

#define DECLARE_PACKED_TYPE_AND_REV_2(REALTYPE,S1,S2) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S1##_##S2,2,S1,S2,0,0,) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S2##_##S1##_REV,2,S2,S1,0,0,_REV)

#define DECLARE_PACKED_TYPE_AND_REV_3(REALTYPE,S1,S2,S3) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S1##_##S2##_##S3,3,S1,S2,S3,0,) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S3##_##S2##_##S1##_REV,3,S3,S2,S1,0,_REV)

#define DECLARE_PACKED_TYPE_AND_REV_4(REALTYPE,S1,S2,S3,S4) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S1##_##S2##_##S3##_##S4,4,S1,S2,S3,S4,) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,GL_##REALTYPE##_##S4##_##S3##_##S2##_##S1##_REV,4,S4,S3,S2,S1,_REV)

#define DECLARE_PACKED_TYPE_AND_REALTYPE(REALTYPE,N,S1,S2,S3,S4,REV) \
DECLARE_PACKED_TYPE(GL_##REALTYPE,PACKED_TYPE(REALTYPE,N,S1,S2,S3,S4,REV),N,S1,S2,S3,S4,REV)

#define INDEX(N,X) (X)
#define INDEX_REV(N,X) (N-1-X)

#define GET_BITS(to,from,first,count) if ((count)>0) to=((GLfloat)(((from)>>(first))&((1<<(count))-1)))/(GLfloat)((1<<((count==0)?1:count))-1)
#define PUT_BITS(from,to,first,count) if ((count)>0) to|=((unsigned int)((from)*((GLfloat)((1<<((count==0)?1:count))-1))))<<(first);

static inline void _RGLFifoGlVertexAttribPointer
(
    GLuint          index,
    GLint           size,
    RGLEnum       type,
    GLboolean       normalized,
    GLsizei         stride,
    GLushort        frequency,
    GLboolean       isMain,
    GLuint          offset
)
{
    switch ( size )
    {
        case 0:
            stride = 0;
            normalized = 0;
            type = RGL_FLOAT;
            offset = 0;
            break;
        case 1:
        case 2:
        case 3:
        case 4:
            break;
        default:
            break;
    }

    uint8_t gcmType = 0;
    switch ( type )
    {
        case RGL_UNSIGNED_BYTE:
            if (normalized)
                gcmType = CELL_GCM_VERTEX_UB;
            else
                gcmType = CELL_GCM_VERTEX_UB256;
            break;

        case RGL_SHORT:
            gcmType = normalized ? CELL_GCM_VERTEX_S1 : CELL_GCM_VERTEX_S32K;
            break;

        case RGL_FLOAT:
            gcmType = CELL_GCM_VERTEX_F;
            break;

        case RGL_HALF_FLOAT:
            gcmType = CELL_GCM_VERTEX_SF;
            break;

        case RGL_CMP:
            size = 1;
            gcmType = CELL_GCM_VERTEX_CMP;
            break;

        default:
            break;
    }

    uint8_t location = CELL_GCM_LOCATION_LOCAL;

    if ( isMain )
        location = CELL_GCM_LOCATION_MAIN;

    cellGcmSetVertexDataArrayInline( &_RGLState.fifo, index, frequency, stride, size, gcmType, location, offset );
}

static void _RGLResetAttributeState( jsAttributeState* as )
{
    for ( int i = 0; i < _RGL_MAX_VERTEX_ATTRIBS; ++i )
    {
        as->attrib[i].clientSize = 4;
        as->attrib[i].clientType = GL_FLOAT;
        as->attrib[i].clientStride = 16;
        as->attrib[i].clientData = NULL;

        as->attrib[i].value[0] = 0.0f;
        as->attrib[i].value[1] = 0.0f;
        as->attrib[i].value[2] = 0.0f;
        as->attrib[i].value[3] = 1.0f;

        as->attrib[i].normalized = GL_FALSE;
        as->attrib[i].frequency = 1;

        as->attrib[i].arrayBuffer = 0;
    }

    as->attrib[_RGL_ATTRIB_PRIMARY_COLOR_INDEX].value[0] = 1.0f;
    as->attrib[_RGL_ATTRIB_PRIMARY_COLOR_INDEX].value[1] = 1.0f;
    as->attrib[_RGL_ATTRIB_PRIMARY_COLOR_INDEX].value[2] = 1.0f;
    as->attrib[_RGL_ATTRIB_PRIMARY_COLOR_INDEX].value[3] = 1.0f;

    as->attrib[_RGL_ATTRIB_SECONDARY_COLOR_INDEX].value[0] = 1.0f;
    as->attrib[_RGL_ATTRIB_SECONDARY_COLOR_INDEX].value[1] = 1.0f;
    as->attrib[_RGL_ATTRIB_SECONDARY_COLOR_INDEX].value[2] = 1.0f;
    as->attrib[_RGL_ATTRIB_SECONDARY_COLOR_INDEX].value[3] = 1.0f;

    as->attrib[_RGL_ATTRIB_NORMAL_INDEX].value[0] = 0.f;
    as->attrib[_RGL_ATTRIB_NORMAL_INDEX].value[1] = 0.f;
    as->attrib[_RGL_ATTRIB_NORMAL_INDEX].value[2] = 1.f;

    as->DirtyMask = ( 1 << _RGL_MAX_VERTEX_ATTRIBS ) - 1;
    as->EnabledMask = 0;
    as->NeedsConversionMask = 0;
    as->HasVBOMask = 0;
    as->ModuloMask = 0;
}

static jsAttribSet* _RGLCreateAttribSet( void )
{
   jsAttribSet* attribSet = ( jsAttribSet * )memalign( 16, sizeof( jsAttribSet ) );

   _RGLResetAttributeState( &attribSet->attribs );

   attribSet->dirty = GL_TRUE;
   attribSet->beenUpdatedMask = 0;
   attribSet->cmdBuffer = NULL;
   attribSet->cmdNumWords = 0;

   return attribSet;
}

static void _RGLDestroyAttribSet( jsAttribSet* attribSet )
{
   if ( attribSet->cmdBuffer )
      free( attribSet->cmdBuffer );
   free( attribSet );
}

static inline jsBufferObject *_RGLGetBufferObject( PSGLcontext *LContext, GLuint name )
{
	return ( jsBufferObject * )LContext->bufferObjectNameSpace.data[name];
}

static void _RGLAttribSetDeleteBuffer( PSGLcontext *LContext, GLuint buffName )
{
    jsBufferObject *bufferObject = _RGLGetBufferObject( LContext, buffName );
    GLuint attrSetCount = bufferObject->attribSets.getCount();
    if ( attrSetCount == 0 ) return;
    for ( unsigned int i = 0;i < attrSetCount;++i )
    {
        jsAttribSet *attribSet = bufferObject->attribSets[i];

        for ( GLuint j = 0; j < _RGL_MAX_VERTEX_ATTRIBS; ++j )
            if ( attribSet->attribs.attrib[j].arrayBuffer == buffName )
               attribSet->attribs.attrib[j].arrayBuffer = 0;

        attribSet->dirty = GL_TRUE;
    }
    LContext->attribSetDirty = GL_TRUE;
    bufferObject->attribSets.clear();
}

static inline jsAttribSet* _RGLGetAttribSet( GLuint name )
{
	PSGLcontext* LContext = _CurrentContext;
	return ( jsAttribSet* ) LContext->attribSetNameSpace.data[name];
}

static void _RGLAttribSetMarkDirty (void)
{
    PSGLcontext* LContext = _CurrentContext;
    jsAttribSet* attribSet = _RGLGetAttribSet( LContext->attribSetName );
    attribSet->dirty = GL_TRUE;
    LContext->attribSetDirty = GL_TRUE;
}

static jsBufferObject *_RGLCreateBufferObject (void)
{
   GLuint size = sizeof( jsBufferObject ) + sizeof( RGLBufferObject);
   jsBufferObject *buffer = ( jsBufferObject * )malloc( size );

   if( !buffer )
      return NULL;

   memset( buffer, 0, size );

   buffer->refCount = 1;
   new( &buffer->textureReferences ) RGL::Vector<jsTexture *>();
   new( &buffer->attribSets ) RGL::Vector<jsAttribSet *>();

   return buffer;
}

static void _RGLPlatformDestroyBufferObject( jsBufferObject* bufferObject )
{
   RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

   switch ( jsBuffer->pool )
   {
      case _RGL_SURFACE_POOL_SYSTEM:
      case _RGL_SURFACE_POOL_LINEAR:
         gmmFree( jsBuffer->bufferId );
	 break;
      case _RGL_SURFACE_POOL_NONE:
         break;
      default:
	 break;
   }

   jsBuffer->pool = _RGL_SURFACE_POOL_NONE;
   jsBuffer->bufferId = GMM_ERROR;
}

static void _RGLFreeBufferObject( jsBufferObject *buffer )
{
    if ( --buffer->refCount == 0 )
    {
        _RGLPlatformDestroyBufferObject( buffer );
        buffer->textureReferences.~Vector<jsTexture *>();
        buffer->attribSets.~Vector<jsAttribSet *>();
	if(buffer != NULL)
		free( buffer );
    }
}

static void _RGLUnbindBufferObject( PSGLcontext *LContext, GLuint name )
{
    if ( LContext->ArrayBuffer == name ) LContext->ArrayBuffer = 0;
    if ( LContext->PixelUnpackBuffer == name ) LContext->PixelUnpackBuffer = 0;
    for ( int i = 0;i < _RGL_MAX_VERTEX_ATTRIBS;++i )
    {
        if ( LContext->attribs->attrib[i].arrayBuffer == name )
        {
            LContext->attribs->attrib[i].arrayBuffer = 0;
            LContext->attribs->HasVBOMask &= ~( 1 << i );
        }
    }
    _RGLAttribSetDeleteBuffer( LContext, name );
}

GLAPI void APIENTRY glBindBuffer( GLenum target, GLuint name )
{
    PSGLcontext *LContext = _CurrentContext;
    if ( name ) _RGLTexNameSpaceCreateNameLazy( &LContext->bufferObjectNameSpace, name );

    switch ( target )
    {
        case GL_ARRAY_BUFFER: LContext->ArrayBuffer = name;
            break;
        case GL_ELEMENT_ARRAY_BUFFER:
            break;
        case GL_PIXEL_PACK_BUFFER_ARB:
            break;
        case GL_PIXEL_UNPACK_BUFFER_ARB:
            LContext->PixelUnpackBuffer = name;
            break;
        case GL_TEXTURE_REFERENCE_BUFFER_SCE:
            LContext->TextureBuffer = name;
            break;
        default:
            break;
    }
}

GLAPI void APIENTRY glDeleteBuffers( GLsizei n, const GLuint *buffers )
{
    PSGLcontext *LContext = _CurrentContext;
    for ( int i = 0;i < n;++i )
    {
        if ( !_RGLTexNameSpaceIsName( &LContext->bufferObjectNameSpace, buffers[i] ) )
           continue;
        if ( buffers[i] )
           _RGLUnbindBufferObject( LContext, buffers[i] );
    }
    _RGLTexNameSpaceDeleteNames( &LContext->bufferObjectNameSpace, n, buffers );
}

GLAPI void APIENTRY glGenBuffers( GLsizei n, GLuint *buffers )
{
    PSGLcontext *LContext = _CurrentContext;
    _RGLTexNameSpaceGenNames( &LContext->bufferObjectNameSpace, n, buffers );
}

static inline jsFramebuffer *_RGLGetFramebuffer( PSGLcontext *LContext, GLuint name )
{
	return ( jsFramebuffer * )LContext->framebufferNameSpace.data[name];
}

static inline void _RGLTextureTouchFBOs( jsTexture *texture )
{
	PSGLcontext *LContext = _CurrentContext;
	if ( !LContext ) return;
	GLuint fbCount = texture->framebuffers.getCount();
	if ( fbCount > 0 )
	{
		jsFramebuffer *contextFramebuffer = LContext->framebuffer ? _RGLGetFramebuffer( LContext, LContext->framebuffer ) : NULL;
		for ( GLuint i = 0;i < fbCount;++i )
		{
			jsFramebuffer* framebuffer = texture->framebuffers[i];
			framebuffer->needValidate = GL_TRUE;
			if ( RGL_UNLIKELY( framebuffer == contextFramebuffer ) ) LContext->needValidate |= PSGL_VALIDATE_FRAMEBUFFER;
		}
	}
}

static void _RGLAllocateBuffer( jsBufferObject* bufferObject )
{
   RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

   _RGLPlatformDestroyBufferObject( bufferObject );

   jsBuffer->pool = _RGL_SURFACE_POOL_LINEAR;
   jsBuffer->bufferId = gmmAlloc(0, jsBuffer->bufferSize);
   jsBuffer->pitch = 0;

   if ( jsBuffer->bufferId == GMM_ERROR )
      jsBuffer->pool = _RGL_SURFACE_POOL_NONE;

   GLuint referenceCount = bufferObject->textureReferences.getCount();
   if ( referenceCount > 0 )
   {
      for ( GLuint i = 0;i < referenceCount;++i )
      {
         jsTexture *texture = bufferObject->textureReferences[i];
	 RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
	 gcmTexture->gpuAddressId = jsBuffer->bufferId;
	 gcmTexture->gpuAddressIdOffset = texture->offset;
	 texture->revalidate |= _RGL_TEXTURE_REVALIDATE_PARAMETERS;
	 _RGLTextureTouchFBOs( texture );
      }
      _CurrentContext->needValidate |= PSGL_VALIDATE_TEXTURES_USED | PSGL_VALIDATE_VERTEX_TEXTURES_USED ;
   }
}

static void _RGLMemcpy( const GLuint dstId, unsigned dstOffset, unsigned int pitch, const GLuint srcId, unsigned int size )
{
   pitch = pitch ? : 64;
   const GLuint dstOffsetAlign = dstOffset % pitch;
   GLuint srcOffset = 0;

   if ( dstOffsetAlign )
   {
      const GLuint firstBytes = MIN( pitch - dstOffsetAlign, size );

      _RGLTransferDataVidToVid(
		      dstId,
		      0,
		      pitch,
		      dstOffsetAlign / 2, dstOffset / pitch,
		      srcId,
		      srcOffset,
		      pitch,
		      0, 0,
		      firstBytes / 2, 1,
		      2 );
      dstOffset += firstBytes;
      srcOffset += firstBytes;
      size -= firstBytes;
   }

   const GLuint fullLines = size / pitch;
   const GLuint extraBytes = size % pitch;
   if ( fullLines )
      _RGLTransferDataVidToVid(
		      dstId,
		      0,
		      pitch,
		      0, dstOffset / pitch,
		      srcId,
		      srcOffset,
		      pitch,
		      0, 0,
		      pitch / 2, fullLines,
		      2 );
   if ( extraBytes )
      _RGLTransferDataVidToVid(
		      dstId,
		      0,
		      pitch,
		      0, fullLines + dstOffset / pitch,
		      srcId,
		      srcOffset,
		      pitch,
		      0, fullLines,
		      extraBytes / 2, 1,
		      2 );
}

static void _RGLPlatformBufferObjectSetData( jsBufferObject* bufferObject, GLintptr offset, GLsizeiptr size, const GLvoid *data, GLboolean tryImmediateCopy )
{
    RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

    if ( size == bufferObject->size && tryImmediateCopy )
        memcpy( gmmIdToAddress( jsBuffer->bufferId ) + offset, data, size );
    else
        if ( size >= bufferObject->size )
        {
            jsBuffer->bufferSize = _RGLPad( size, _RGL_BUFFER_OBJECT_BLOCK_SIZE );
            _RGLAllocateBuffer( bufferObject );

            switch ( jsBuffer->pool )
            {
                case _RGL_SURFACE_POOL_NONE:
                    _RGLSetError( GL_OUT_OF_MEMORY );
                    return;
                default:
                    memcpy( gmmIdToAddress( jsBuffer->bufferId ), data, size );
                    break;
            }
        }
        else
        {
            if ( tryImmediateCopy )
                memcpy( gmmIdToAddress( jsBuffer->bufferId ) + offset, data, size );
            else
	    {
		    unsigned int dstId = jsBuffer->bufferId;
		    unsigned int pitch = jsBuffer->pitch;
		    const char *src = (const char *)data;
		    switch ( bufferObject->usage )
		    {
			    case GL_STREAM_DRAW:
			    case GL_STREAM_READ:
			    case GL_STREAM_COPY:
			    case GL_DYNAMIC_DRAW:
			    case GL_DYNAMIC_READ:
			    case GL_DYNAMIC_COPY:
				    {
					    GLuint id = gmmAlloc(0, size);

					    memcpy( gmmIdToAddress(id), src, size );
					    _RGLMemcpy( dstId, offset, pitch, id, size );

					    gmmFree( id );
				    }
				    break;
			    default:
				    cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
				    _RGLFifoFinish( &_RGLState.fifo );
				    memcpy( gmmIdToAddress( dstId ) + offset, src, size );
				    break;
		    };
	    }
        }

    ((RGLDriver *)_CurrentDevice->rasterDriver)->invalidateVertexCache = GL_TRUE;
}

static GLboolean _RGLPlatformCreateBufferObject( jsBufferObject* bufferObject )
{
   RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

   jsBuffer->pool = _RGL_SURFACE_POOL_NONE;
   jsBuffer->bufferId = GMM_ERROR;
   jsBuffer->mapCount = 0;
   jsBuffer->mapAccess = GL_NONE;
   jsBuffer->bufferSize = _RGLPad( bufferObject->size, _RGL_BUFFER_OBJECT_BLOCK_SIZE );

   _RGLAllocateBuffer( bufferObject );

   return jsBuffer->bufferId != GMM_ERROR;
}

GLAPI void APIENTRY glBufferData( GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage )
{
   PSGLcontext *LContext = _CurrentContext;

   GLuint name = 0;
   switch ( target )
   {
      case GL_ARRAY_BUFFER:
         name = LContext->ArrayBuffer;
	 break;
      case GL_ELEMENT_ARRAY_BUFFER:
	 break;
      case GL_PIXEL_PACK_BUFFER_ARB:
	 break;
      case GL_PIXEL_UNPACK_BUFFER_ARB:
	 name = LContext->PixelUnpackBuffer;
	 break;
      case GL_TEXTURE_REFERENCE_BUFFER_SCE:
	 name = LContext->TextureBuffer;
	 break;
      default:
	 _RGLSetError( GL_INVALID_ENUM );
	 return;
   }

   jsBufferObject* bufferObject = _RGLGetBufferObject( LContext, name );

   if ( bufferObject->refCount > 1 )
   {
      _RGLTexNameSpaceDeleteNames( &LContext->bufferObjectNameSpace, 1, &name );
      _RGLTexNameSpaceCreateNameLazy( &LContext->bufferObjectNameSpace, name );
      bufferObject = _RGLGetBufferObject( LContext, name );
   }

   if ( bufferObject->size > 0 ) _RGLPlatformDestroyBufferObject( bufferObject );
   bufferObject->usage = usage;
   bufferObject->size = size;
   bufferObject->width = 0;
   bufferObject->height = 0;
   bufferObject->internalFormat = GL_NONE;

   if ( size > 0 )
   {
      GLboolean created = _RGLPlatformCreateBufferObject( bufferObject );
      if ( !created )
      {
         _RGLSetError( GL_OUT_OF_MEMORY );
	 return;
      }
      if ( data )
         _RGLPlatformBufferObjectSetData( bufferObject, 0, size, data, GL_TRUE );
   }

   GLuint attrSetCount = bufferObject->attribSets.getCount();
   if ( attrSetCount == 0 )
      return;

   for ( unsigned int i = 0;i < attrSetCount;++i )
   {
	   jsAttribSet *attribSet = bufferObject->attribSets[i];
	   attribSet->dirty = GL_TRUE;
   }

   LContext->attribSetDirty = GL_TRUE;
}

static GLvoid _RGLPlatformBufferObjectCopyData( jsBufferObject* bufferObjectDst,
    jsBufferObject* bufferObjectSrc )
{

    RGLBufferObject* dst = ( RGLBufferObject* )bufferObjectDst->platformBufferObject;
    RGLBufferObject* src = ( RGLBufferObject* )bufferObjectSrc->platformBufferObject;

    switch ( dst->pool )
    {
        case _RGL_SURFACE_POOL_LINEAR:
            _RGLMemcpy( dst->bufferId, 0, dst->pitch, src->bufferId, src->bufferSize );
            break;
        case _RGL_SURFACE_POOL_SYSTEM:
	    cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
	    _RGLFifoFinish( &_RGLState.fifo );
            memcpy( gmmIdToAddress( dst->bufferId ), gmmIdToAddress( src->bufferId ),
			    src->bufferSize );
            break;
    }

    ((RGLDriver *)_CurrentDevice->rasterDriver)->invalidateVertexCache = GL_TRUE;
}

GLAPI void APIENTRY glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data )
{
    PSGLcontext *LContext = _CurrentContext;
    GLuint name = 0;
    switch ( target )
    {
        case GL_ARRAY_BUFFER:
            name = LContext->ArrayBuffer;
            break;
        case GL_ELEMENT_ARRAY_BUFFER:
            break;
        case GL_PIXEL_PACK_BUFFER_ARB:
            break;
        case GL_PIXEL_UNPACK_BUFFER_ARB:
            name = LContext->PixelUnpackBuffer;
            break;
        case GL_TEXTURE_REFERENCE_BUFFER_SCE:
            name = LContext->TextureBuffer;
            break;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }

    jsBufferObject* bufferObject = _RGLGetBufferObject( LContext, name );


    if ( bufferObject->refCount > 1 )
    {
        jsBufferObject* oldBufferObject = bufferObject;

        _RGLTexNameSpaceDeleteNames( &LContext->bufferObjectNameSpace, 1, &name );
        _RGLTexNameSpaceCreateNameLazy( &LContext->bufferObjectNameSpace, name );

        bufferObject = _RGLGetBufferObject( LContext, name );
        bufferObject->size = oldBufferObject->size;
        bufferObject->usage = oldBufferObject->usage;

        GLboolean created = _RGLPlatformCreateBufferObject( bufferObject );
        if ( !created )
        {
            _RGLSetError( GL_OUT_OF_MEMORY );
            return;
        }
        _RGLPlatformBufferObjectCopyData( bufferObject, oldBufferObject );
    }
    _RGLPlatformBufferObjectSetData( bufferObject, offset, size, data, GL_FALSE );
}


static inline jsTexture* _RGLGetTexture( PSGLcontext *LContext, GLuint name )
{
	return ( jsTexture* )LContext->textureNameSpace.data[name];
}

static inline jsTexture* _RGLGetTextureSafe( PSGLcontext *LContext, GLuint name )
{
	return _RGLTexNameSpaceIsName( &LContext->textureNameSpace, name ) ? ( jsTexture* )LContext->textureNameSpace.data[name] : NULL;
}

static void _RGLFramebufferGetAttachmentTexture(
    const jsFramebufferAttachment* attachment,
    jsTexture** texture,
    GLuint* face )
{
   PSGLcontext* LContext = _CurrentContext;
    switch ( attachment->type )
    {
        case _RGL_FRAMEBUFFER_ATTACHMENT_NONE:
            *texture = NULL;
            *face = 0;
            break;
        case _RGL_FRAMEBUFFER_ATTACHMENT_RENDERBUFFER:
            break;
        case _RGL_FRAMEBUFFER_ATTACHMENT_TEXTURE:
            *texture = _RGLGetTextureSafe( LContext, attachment->name );
            *face = 0;
            break;
        default:
            *face = 0;
            *texture = NULL;
	    break;
    }
}

static GLboolean _RGLTextureIsValid( const jsTexture* texture )
{
    if ( texture->imageCount < 1 )
        return GL_FALSE;
    if ( !texture->image )
        return GL_FALSE;
    const jsImage* image = texture->image;

    int width = image->width;
    int height = image->height;
    GLenum format = image->format;
    GLenum type = image->type;
    GLenum internalFormat = image->internalFormat;
    if (( internalFormat == 0 ) || ( format == 0 ) || ( type == 0 ) )
        return GL_FALSE;

    if ( !image->isSet )
	    return GL_FALSE;
    if ( width != image->width )
	    return GL_FALSE;
    if ( height != image->height )
	    return GL_FALSE;
    if ( format != image->format )
	    return GL_FALSE;
    if ( type != image->type )
	    return GL_FALSE;
    if ( internalFormat != image->internalFormat )
	    return GL_FALSE;

    return GL_TRUE;
}

static GLenum _RGLPlatformFramebufferCheckStatus( jsFramebuffer* framebuffer )
{
   GLuint nBuffers = 0;

   jsImage* image[_RGL_MAX_COLOR_ATTACHMENTS + 2] = {0};

   GLuint colorFormat = 0;
   for ( int i = 0; i < _RGL_MAX_COLOR_ATTACHMENTS; ++i )
   {
      jsTexture* colorTexture = NULL;
      GLuint colorFace = 0;
      _RGLFramebufferGetAttachmentTexture(&framebuffer->color[i], &colorTexture, &colorFace );

      if ( colorTexture != NULL )
      {
         if ( !_RGLTextureIsValid( colorTexture ) )
	 {
            printf("RGL ERR: Framebuffer color attachment texture is not complete.\n");
	    return GL_FRAMEBUFFER_UNSUPPORTED_OES;
	 }

         image[nBuffers] = colorTexture->image;

	 if ( colorFormat && colorFormat != image[nBuffers]->internalFormat )
	 {
            printf("RGL ERR: Framebuffer attachments have inconsistent color formats.\n" );
	    return GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES;
	 }
	 colorFormat = image[nBuffers]->internalFormat;

	 ++nBuffers;
      }
   }

   if ( nBuffers && colorFormat != RGL_ARGB8)
   {
      printf("RGL: Color attachment to framebuffer must be a supported drawable format (GL_ARGB_SCE)\n");
      return GL_FRAMEBUFFER_UNSUPPORTED_OES;
   }

   if ( nBuffers == 0 )
      return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES;

   for ( GLuint i = 0; i < nBuffers; ++i )
      for ( GLuint j = i + 1; j < nBuffers; ++j )
         if ( image[i] == image[j] )
            return GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_OES;

   return GL_FRAMEBUFFER_COMPLETE_OES;
}

enum _RGLTextureStrategy {
    _RGL_TEXTURE_STRATEGY_END,
    _RGL_TEXTURE_STRATEGY_UNTILED_ALLOC,
    _RGL_TEXTURE_STRATEGY_UNTILED_CLEAR,
};

static enum _RGLTextureStrategy linearGPUStrategy[] =
    {
        _RGL_TEXTURE_STRATEGY_UNTILED_ALLOC,
        _RGL_TEXTURE_STRATEGY_UNTILED_CLEAR,
        _RGL_TEXTURE_STRATEGY_UNTILED_ALLOC,
        _RGL_TEXTURE_STRATEGY_END,
    };

static void _RGLImageAllocCPUStorage( jsImage *image )
{
    if (( image->storageSize > image->mallocStorageSize ) || ( !image->mallocData ) )
    {
        if ( image->mallocData ) free( image->mallocData );
        image->mallocData = ( char * )malloc( image->storageSize + 128 );
        image->mallocStorageSize = image->storageSize;
    }
    image->data = _RGLPadPtr( image->mallocData, 128 );
}

static inline int _RGLGetComponentCount( GLenum format )
{
    switch ( format )
    {
#define DECLARE_FORMAT(FORMAT,COUNT) \
		case FORMAT: \
			return COUNT;
            DECLARE_FORMATS
#undef DECLARE_FORMAT
        default:
            return 0;
    }
}

typedef void( GetComponentsFunction_t )( const unsigned char *bytes, GLfloat *values, int count );
typedef void( PutComponentsFunction_t )( unsigned char *bytes, GLfloat *values, int count );
typedef void( ColorConvertFunction_t )( jsColorRGBAf *color, GLfloat *values );


#define DECLARE_UNPACKED_TYPE(TYPE) \
static void _RGLGetComponents_##TYPE(const unsigned char *bytes, GLfloat *values, int count) \
{ \
	int i; \
	for (i=0;i<count;++i) \
	{ \
		const type_##TYPE data=*(const type_##TYPE *)bytes; \
		values[i]=_RGLFloatFrom_##TYPE(data); \
		bytes+=sizeof(type_##TYPE); \
	} \
}
DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
static void _RGLGetComponents_##TYPE(const unsigned char *bytes, GLfloat *values, int count) \
{ \
	const type_##REALTYPE data=*(const type_##REALTYPE *)bytes; \
	GET_BITS(values[INDEX##REV(N,0)],data,S2+S3+S4,S1); \
	GET_BITS(values[INDEX##REV(N,1)],data,S3+S4,S2); \
	GET_BITS(values[INDEX##REV(N,2)],data,S4,S3); \
	GET_BITS(values[INDEX##REV(N,3)],data,0,S4); \
}
DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

#define DECLARE_UNPACKED_TYPE(TYPE) \
static void _RGLPutComponents_##TYPE(unsigned char *bytes, GLfloat *values, int count) \
{ \
	int i; \
	for (i=0;i<count;++i) \
	{ \
		type_##TYPE *data=(type_##TYPE *)bytes; \
		*data=_RGLFloatTo_##TYPE(values[i]); \
		bytes+=sizeof(type_##TYPE); \
	} \
}
DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
static void _RGLPutComponents_##TYPE(unsigned char *bytes, GLfloat *values, int count) \
{ \
	type_##REALTYPE *data=(type_##REALTYPE *)bytes; \
	*data=0; \
	PUT_BITS(values[INDEX##REV(N,0)],*data,S2+S3+S4,S1); \
	PUT_BITS(values[INDEX##REV(N,1)],*data,S3+S4,S2); \
	PUT_BITS(values[INDEX##REV(N,2)],*data,S4,S3); \
	PUT_BITS(values[INDEX##REV(N,3)],*data,0,S4); \
}
DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

static inline GetComponentsFunction_t *_RGLFindGetComponentsFunction( GLenum type )
{
    switch ( type )
    {

#define DECLARE_UNPACKED_TYPE(TYPE) \
		case TYPE: \
			return &_RGLGetComponents_##TYPE;
            DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
		case TYPE: \
			return &_RGLGetComponents_##TYPE;
            DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

        default:
            return NULL;
    }
}

static inline PutComponentsFunction_t *_RGLFindPutComponentsFunction( GLenum type )
{
    switch ( type )
    {
#define DECLARE_UNPACKED_TYPE(TYPE) \
		case TYPE: \
			return &_RGLPutComponents_##TYPE;
            DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
		case TYPE: \
			return &_RGLPutComponents_##TYPE;
            DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

        default:
            return NULL;
    }
}

static void _RGLValuesToColor_GL_RGB( jsColorRGBAf *c, GLfloat *v ) { c->R = v[0]; c->G = v[1]; c->B = v[2]; c->A = 1.f; }
static void _RGLValuesToColor_GL_BGR( jsColorRGBAf *c, GLfloat *v ) { c->B = v[0]; c->G = v[1]; c->R = v[2]; c->A = 1.f; }
static void _RGLValuesToColor_GL_RGBA( jsColorRGBAf *c, GLfloat *v ) { c->R = v[0]; c->G = v[1]; c->B = v[2]; c->A = v[3]; }
static void _RGLValuesToColor_GL_BGRA( jsColorRGBAf *c, GLfloat *v ) { c->B = v[0]; c->G = v[1]; c->R = v[2]; c->A = v[3]; }
static void _RGLValuesToColor_GL_ABGR( jsColorRGBAf *c, GLfloat *v ) { c->A = v[0]; c->B = v[1]; c->G = v[2]; c->R = v[3]; }
static void _RGLValuesToColor_GL_ARGB_SCE( jsColorRGBAf *c, GLfloat *v ) { c->A = v[0]; c->R = v[1]; c->G = v[2]; c->B = v[3]; }
static void _RGLValuesToColor_GL_RED( jsColorRGBAf *c, GLfloat *v ) { c->R = v[0]; c->G = 0.f; c->B = 0.f; c->A = 1.f; }
static void _RGLValuesToColor_GL_GREEN( jsColorRGBAf *c, GLfloat *v ) { c->R = 0.f; c->G = v[0]; c->B = 0.f; c->A = 1.f; }
static void _RGLValuesToColor_GL_BLUE( jsColorRGBAf *c, GLfloat *v ) { c->R = 0.f; c->G = 0.f; c->B = v[0]; c->A = 1.f; }
static void _RGLValuesToColor_GL_ALPHA( jsColorRGBAf *c, GLfloat *v ) { c->R = 0.f; c->G = 0.f; c->B = 0.f; c->A = v[0]; }

static void _RGLColorToValues_GL_RGB( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->R; v[1] = c->G; v[2] = c->B; }
static void _RGLColorToValues_GL_BGR( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->B; v[1] = c->G; v[2] = c->R; }
static void _RGLColorToValues_GL_RGBA( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->R; v[1] = c->G; v[2] = c->B; v[3] = c->A; }
static void _RGLColorToValues_GL_BGRA( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->B; v[1] = c->G; v[2] = c->R; v[3] = c->A; }
static void _RGLColorToValues_GL_ABGR( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->A; v[1] = c->B; v[2] = c->G; v[3] = c->R; }
static void _RGLColorToValues_GL_ARGB_SCE( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->A; v[1] = c->R; v[2] = c->G; v[3] = c->B; }
static void _RGLColorToValues_GL_RED( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->R; }
static void _RGLColorToValues_GL_GREEN( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->G; }
static void _RGLColorToValues_GL_BLUE( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->B; }
static void _RGLColorToValues_GL_ALPHA( jsColorRGBAf *c, GLfloat *v ) { v[0] = c->A; }

static inline ColorConvertFunction_t *_RGLFindValuesToColorFunction( GLenum format )
{
    switch ( format )
    {
#define DECLARE_FORMAT(FORMAT,COUNT) \
		case FORMAT: \
			return &_RGLValuesToColor_##FORMAT;
            DECLARE_FORMATS
#undef DECLARE_FORMAT
        default:
            return NULL;
    }
}

static inline ColorConvertFunction_t *_RGLFindColorToValuesFunction( GLenum format )
{
    switch ( format )
    {
#define DECLARE_FORMAT(FORMAT,COUNT) \
		case FORMAT: \
			return &_RGLColorToValues_##FORMAT;
            DECLARE_FORMATS
#undef DECLARE_FORMAT
        default:
            return NULL;
    }
}

static void _RGLRasterToImage(const jsRaster* raster, jsImage* image)
{
	const int srcComponents = _RGLGetComponentCount( raster->format );
	const int dstComponents = _RGLGetComponentCount( image->format );
	GetComponentsFunction_t* getComponents = _RGLFindGetComponentsFunction( raster->type );
	PutComponentsFunction_t* putComponents = _RGLFindPutComponentsFunction( image->type );
	ColorConvertFunction_t* valuesToColor = _RGLFindValuesToColorFunction( raster->format );
	ColorConvertFunction_t* colorToValues = _RGLFindColorToValuesFunction( image->format );

	for ( int j = 0; j < raster->height; ++j )
	{
		const unsigned char *src = ( const unsigned char * )raster->data +
			j * raster->ystride;
		unsigned char *dst = ( unsigned char * )image->data +
			( j ) * image->ystride +
			0 * image->xstride;

		for ( int k = 0; k < raster->width; ++k )
		{
			GLfloat values[4];
			jsColorRGBAf color;
			getComponents( src, values, srcComponents );
			valuesToColor( &color, values );
			colorToValues( &color, values );

			if (image->type!=GL_FLOAT && image->type!=GL_HALF_FLOAT_ARB)
			{
				values[0]= MAX( MIN( values[0], 1.f ), 0.f );
				values[1]= MAX( MIN( values[1], 1.f ), 0.f );
				values[2]= MAX( MIN( values[2], 1.f ), 0.f );
				values[3]= MAX( MIN( values[3], 1.f ), 0.f );
			}

			putComponents( dst, values, dstComponents );

			src += raster->xstride;
			dst += image->xstride;
		}
	}
}

static void _RGLPlatformCopyGPUTexture( jsTexture* texture )
{
	RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;

	if ( gcmTexture->gpuAddressId == GMM_ERROR )
		return;

	RGLTextureLayout *layout = &gcmTexture->gpuLayout;

	jsImage* image = texture->image;

	if ( image->dataState == _RGL_IMAGE_DATASTATE_GPU )
	{
		_RGLImageAllocCPUStorage( image );

		cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
		_RGLFifoFinish( &_RGLState.fifo );

		char* gpuData = gmmIdToAddress(gcmTexture->gpuAddressId) + gcmTexture->gpuAddressIdOffset;

		jsRaster raster = 
		{
			format : image->format,
			type   : image->type,
			width  : image->width,
			height : image->height,
			xstride : image->xstride,
			ystride : layout->pitch,
			data    : gpuData
		};

		_RGLRasterToImage( &raster, image);

		image->dataState = _RGL_IMAGE_DATASTATE_HOST;
	}
}

static void _RGLPlatformFreeGcmTexture( jsTexture* texture )
{
    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
    switch ( gcmTexture->pool )
    {
        case _RGL_SURFACE_POOL_LINEAR:
        case _RGL_SURFACE_POOL_SYSTEM:
            gmmFree( gcmTexture->gpuAddressId );
        case _RGL_SURFACE_POOL_NONE:
            break;
        default:
		break;
    }

    gcmTexture->gpuAddressId = GMM_ERROR;
    gcmTexture->gpuAddressIdOffset = 0;
    gcmTexture->gpuSize = 0;
}

void _RGLPlatformDropTexture( jsTexture *texture )
{
    RGLTexture * gcmTexture = ( RGLTexture * )texture->platformTexture;
    if ( gcmTexture->pbo != NULL )
    {
	    _RGLPlatformCopyGPUTexture( texture );
	    _RGLFreeBufferObject( gcmTexture->pbo );
	    gcmTexture->pbo = NULL;
	    gcmTexture->gpuAddressId = GMM_ERROR;
	    gcmTexture->gpuAddressIdOffset = 0;
	    gcmTexture->pool = _RGL_SURFACE_POOL_NONE;
	    gcmTexture->gpuSize = 0;
    }

    if ( gcmTexture->pool != _RGL_SURFACE_POOL_NONE )
    {
        _RGLPlatformCopyGPUTexture( texture );
        _RGLPlatformFreeGcmTexture( texture );
    }

    gcmTexture->pool = _RGL_SURFACE_POOL_NONE;
    gcmTexture->gpuAddressId = GMM_ERROR;
    gcmTexture->gpuAddressIdOffset = 0;
    gcmTexture->gpuSize = 0;
    texture->revalidate |= _RGL_TEXTURE_REVALIDATE_IMAGES;
    _RGLTextureTouchFBOs( texture );
}

int _RGLGetPixelSize( GLenum format, GLenum type )
{
    int componentSize;
    switch ( type )
    {

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
		case TYPE: \
			return sizeof(type_##REALTYPE);
            DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

#define DECLARE_UNPACKED_TYPE(TYPE) \
		case TYPE: \
			componentSize=sizeof(type_##TYPE); \
			break;
            DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

        default:
            return 0;
    }
    return _RGLGetComponentCount( format )*componentSize;
}

static inline int _RGLGetStorageSize( GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth )
{
	return _RGLGetPixelSize( format, type )*width*height*depth;
}

static void _RGLPlatformChooseGPUFormatAndLayout(
    const jsTexture* texture,
    GLboolean forceLinear,
    GLuint pitch,
    RGLTextureLayout* newLayout )
{
	jsImage *image = texture->image;

	newLayout->baseWidth = image->width;
	newLayout->baseHeight = image->height;
	newLayout->internalFormat = ( RGLEnum )image->internalFormat;
	newLayout->pixelBits = _RGLPlatformGetBitsPerPixel( newLayout->internalFormat );
	newLayout->pitch = pitch ? pitch : _RGLPad( _RGLGetStorageSize( texture->image->format, texture->image->type, texture->image->width, 1, 1 ), 64 );
}

void _RGLPlatformDropUnboundTextures( GLenum pool )
{
    PSGLcontext*	LContext = _CurrentContext;
    GLuint i, j;
    for ( i = 0;i < LContext->textureNameSpace.capacity;++i )
    {
        GLboolean bound = GL_FALSE;
        jsTexture *texture = ( jsTexture * )LContext->textureNameSpace.data[i];
        if ( !texture || ( texture->referenceBuffer != 0 ) ) continue;

        for ( j = 0; j < _RGL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; ++j )
        {
            if ( LContext->VertexTextureImages[j] == texture )
            {
                bound = GL_TRUE;
                break;
            }
        }
        for ( j = 0;j < _RGL_MAX_TEXTURE_IMAGE_UNITS;++j )
        {
            jsTextureImageUnit *tu = LContext->TextureImageUnits + j;
            if ( tu->bound2D == i )
            {
                bound = GL_TRUE;
                break;
            }
        }
        if ( bound )
            continue;

        RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
        if ( gcmTexture->pbo != NULL && gcmTexture->pbo->refCount > 1 )
            continue;

        if ( pool != _RGL_SURFACE_POOL_NONE &&
                pool != gcmTexture->pool )
            continue;

        _RGLPlatformDropTexture( texture );
    }
}

static void _RGLPlatformReallocateGcmTexture( jsTexture* texture )
{
    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;

    enum _RGLTextureStrategy *step = linearGPUStrategy;

    GLuint size = 0;
    GLuint id = GMM_ERROR;

    const RGLTextureLayout currentLayout = gcmTexture->gpuLayout;
    const GLuint currentSize = gcmTexture->gpuSize;

    // process strategy
    GLboolean done = GL_FALSE;
    while ( !done )
    {
        RGLTextureLayout newLayout;

        switch ( *step++ )
        {
            case _RGL_TEXTURE_STRATEGY_UNTILED_ALLOC:
                _RGLPlatformChooseGPUFormatAndLayout( texture, GL_TRUE, 0, &newLayout );
		size = _RGLPad( newLayout.baseHeight * newLayout.pitch, 1);

                if ( gcmTexture->pool == _RGL_SURFACE_POOL_LINEAR )
                {
                    if ( currentSize >= size && newLayout.pitch == currentLayout.pitch )
                    {
                        gcmTexture->gpuLayout = newLayout;
                        done = GL_TRUE;
                    }
                    else
                        _RGLPlatformDropTexture( texture );
                }

                if ( !done )
                {
		    id = gmmAlloc(0, size);
                    if ( id != GMM_ERROR )
                    {
                        if ( gcmTexture->pool != _RGL_SURFACE_POOL_NONE )
                            _RGLPlatformDropTexture( texture );

                        gcmTexture->pool = _RGL_SURFACE_POOL_LINEAR;
                        gcmTexture->gpuAddressId = id;
                        gcmTexture->gpuAddressIdOffset = 0;
                        gcmTexture->gpuSize = size;
                        gcmTexture->gpuLayout = newLayout;

                        done = GL_TRUE;
                    }
                }
                break;
            case _RGL_TEXTURE_STRATEGY_UNTILED_CLEAR:
                _RGLPlatformDropUnboundTextures( _RGL_SURFACE_POOL_LINEAR );
                break;
            case _RGL_TEXTURE_STRATEGY_END:
                _RGLSetError( GL_OUT_OF_MEMORY );
                done = GL_TRUE;
                break;
            default:
	    	break;
        }
    }
    _RGLTextureTouchFBOs( texture );
}

static void _RGLImageFreeCPUStorage( jsImage *image )
{
    if ( !image->mallocData ) return;
    if (image->mallocData != NULL)
	    free( image->mallocData );
    image->mallocStorageSize = 0;
    image->data = NULL;
    image->mallocData = NULL;
    image->dataState &= ~_RGL_IMAGE_DATASTATE_HOST;
}

static void _RGLPlatformValidateTextureResources( jsTexture *texture )
{
    if ( RGL_UNLIKELY( !_RGLTextureIsValid( texture ) ) )
    {
        texture->isComplete = GL_FALSE;
        return;
    }
    texture->isComplete = GL_TRUE;

    if ( texture->revalidate & _RGL_TEXTURE_REVALIDATE_IMAGES || texture->revalidate & _RGL_TEXTURE_REVALIDATE_LAYOUT )
    {
	    _RGLPlatformReallocateGcmTexture( texture );
	    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
	    RGLTextureLayout *layout = &gcmTexture->gpuLayout;

	    const GLuint pixelBytes = layout->pixelBits / 8;

	    RGLSurface src = {
source:		_RGL_SURFACE_SOURCE_TEMPORARY,
		width:		0,
		height:		0,
		bpp:		pixelBytes,
		pitch:		0,
		format:		layout->internalFormat,
		pool:		_RGL_SURFACE_POOL_LINEAR,
		ppuData:     NULL,
		dataId:      GMM_ERROR,
		dataIdOffset:0,
	    };

	    RGLSurface dst = {
source:		_RGL_SURFACE_SOURCE_TEXTURE,
		width:		0,
		height:		0,
		bpp:		pixelBytes,
		pitch:		layout->pitch,
		format:		layout->internalFormat,
		pool:		_RGL_SURFACE_POOL_SYSTEM,
		ppuData:     NULL,
		dataId:      GMM_ERROR,
		dataIdOffset:0,
	    };

	    GLuint bounceBufferId = GMM_ERROR;
	    jsImage *image = texture->image;
	    if ( image->dataState == _RGL_IMAGE_DATASTATE_HOST )
	    {
		    src.ppuData = image->data;

		    if ( bounceBufferId == GMM_ERROR)
			    bounceBufferId = gmmAlloc(0, gcmTexture->gpuSize);

		    if ( bounceBufferId != GMM_ERROR )
		    {
			    src.dataId = bounceBufferId;
			    src.dataIdOffset = 0;

			    memcpy( gmmIdToAddress( src.dataId ), image->data, 
					    image->storageSize );
		    }

		    src.width = image->width;
		    src.height = image->height;
		    src.pitch = pixelBytes * src.width;

		    dst.width = src.width;
		    dst.height = image->height;
		    dst.dataId = gcmTexture->gpuAddressId;
		    dst.dataIdOffset = gcmTexture->gpuAddressIdOffset;

		    _RGLTransferDataVidToVid( dst.dataId, dst.dataIdOffset, dst.pitch ? dst.pitch : (dst.bpp * dst.width), 0, 0, src.dataId, src.dataIdOffset, src.pitch ? src.pitch : (src.bpp * src.width), 0, 0, src.width, src.height, src.bpp );

		    _RGLImageFreeCPUStorage( image );
		    image->dataState |= _RGL_IMAGE_DATASTATE_GPU;
	    }

	    if ( bounceBufferId != GMM_ERROR )
		    gmmFree( bounceBufferId );

	    cellGcmSetInvalidateTextureCacheInline( &_RGLState.fifo, CELL_GCM_INVALIDATE_TEXTURE);
    }

    RGLTexture *platformTexture = ( RGLTexture * )texture->platformTexture;
    RGLTextureLayout *layout = &platformTexture->gpuLayout;

    GLuint minFilter = texture->minFilter;
    GLuint magFilter = texture->magFilter;

    platformTexture->gcmMethods.filter.min = _RGLMapMinTextureFilter( minFilter );
    platformTexture->gcmMethods.filter.mag = _RGLMapMagTextureFilter( magFilter );
    platformTexture->gcmMethods.filter.bias = ( GLint )(( -.26f ) * 256.0f );

    GLuint gamma = 0;
    GLuint remap = texture->gammaRemap;
    gamma |= ( remap & RGL_GAMMA_REMAP_RED_BIT ) 	? CELL_GCM_TEXTURE_GAMMA_R : 0;
    gamma |= ( remap & RGL_GAMMA_REMAP_GREEN_BIT )	? CELL_GCM_TEXTURE_GAMMA_G : 0;
    gamma |= ( remap & RGL_GAMMA_REMAP_BLUE_BIT ) 	? CELL_GCM_TEXTURE_GAMMA_B : 0;
    gamma |= ( remap & RGL_GAMMA_REMAP_ALPHA_BIT ) 	? CELL_GCM_TEXTURE_GAMMA_A : 0;

    platformTexture->gcmMethods.address.gamma = gamma;

    GLuint internalFormat = layout->internalFormat;

    _RGLMapTextureFormat( internalFormat,
                            platformTexture->gcmTexture.format, platformTexture->gcmTexture.remap );

    if ( layout->pitch )
        platformTexture->gcmTexture.format += 0x20;

    platformTexture->gcmTexture.width = layout->baseWidth;
    platformTexture->gcmTexture.height = layout->baseHeight;
    platformTexture->gcmTexture.depth = 1;
    platformTexture->gcmTexture.pitch = layout->pitch;
    platformTexture->gcmTexture.mipmap = 1;
    platformTexture->gcmTexture.cubemap = CELL_GCM_FALSE;
    platformTexture->gcmTexture.dimension = CELL_GCM_TEXTURE_DIMENSION_2;

    if ( gmmIdIsMain(platformTexture->gpuAddressId) )
        platformTexture->gcmTexture.location = CELL_GCM_LOCATION_MAIN;
    else
        platformTexture->gcmTexture.location = CELL_GCM_LOCATION_LOCAL;

    texture->revalidate = 0;
}

static void jsPlatformFramebuffer_validate( jsPlatformFramebuffer * fb, PSGLcontext *LContext )
{
    fb->complete = ( _RGLPlatformFramebufferCheckStatus(fb) == GL_FRAMEBUFFER_COMPLETE_OES );
    if ( !fb->complete ) return;

    GLuint width = CELL_GCM_MAX_RT_DIMENSION;
    GLuint height = CELL_GCM_MAX_RT_DIMENSION;

    fb->rt.colorBufferCount = 0;
    fb->rt.colorFormat = RGL_NONE;
    fb->colorBufferMask = 0x0;
    GLuint defaultPitch = 0;
    GLuint defaultId = GMM_ERROR;
    GLuint defaultIdOffset = 0;
    for ( int i = 0; i < RGL_SETRENDERTARGET_MAXCOUNT; ++i )
    {
        jsTexture* colorTexture = NULL;
        GLuint face = 0;
        _RGLFramebufferGetAttachmentTexture(&fb->color[i], &colorTexture, &face );
        if ( colorTexture == NULL ) continue;

        RGLTexture* nvTexture = ( RGLTexture * )colorTexture->platformTexture;

        if ( !colorTexture->isRenderTarget )
        {
            colorTexture->isRenderTarget = GL_TRUE;
            colorTexture->revalidate |= _RGL_TEXTURE_REVALIDATE_LAYOUT;
        }
        _RGLPlatformValidateTextureResources( colorTexture );
        colorTexture->image->dataState = _RGL_IMAGE_DATASTATE_GPU;

        fb->rt.colorId[i] = nvTexture->gpuAddressId;
        fb->rt.colorIdOffset[i] = nvTexture->gpuAddressIdOffset;
        fb->rt.colorPitch[i] = nvTexture->gpuLayout.pitch ? nvTexture->gpuLayout.pitch : nvTexture->gpuLayout.pixelBits * nvTexture->gpuLayout.baseWidth / 8;
        fb->colorBufferMask |= 1 << i;

        width = MIN( width, nvTexture->gpuLayout.baseWidth );
        height = MIN( height, nvTexture->gpuLayout.baseHeight );
        fb->rt.colorFormat = nvTexture->gpuLayout.internalFormat;
        fb->rt.colorBufferCount = i + 1;
        defaultId = fb->rt.colorId[i];
        defaultIdOffset = fb->rt.colorIdOffset[i];
        defaultPitch = fb->rt.colorPitch[i];

        if ( !( fb->colorBufferMask & ( 1 << i ) ) )
        {
            fb->rt.colorId[i] = defaultId;
            fb->rt.colorIdOffset[i] = defaultIdOffset;
            fb->rt.colorPitch[i] = defaultPitch;
        }
    }

    fb->rt.width = width;
    fb->rt.height = height;

    fb->rt.yInverted = CELL_GCM_FALSE;
    fb->rt.xOffset = 0;
    fb->rt.yOffset = 0;
    fb->needValidate = GL_FALSE;
}

static void _RGLValidateFramebuffer( void )
{
    PSGLdevice *LDevice = _CurrentDevice;
    RGLDevice *gcmDevice = ( RGLDevice * )LDevice->platformDevice;

    PSGLcontext* LContext = _CurrentContext;
    RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;

    driver->rtValid = GL_FALSE;

    if ( LContext->framebuffer )
    {
        jsPlatformFramebuffer* framebuffer = static_cast<jsPlatformFramebuffer *>( _RGLGetFramebuffer( LContext, LContext->framebuffer ) );

        if ( framebuffer->needValidate )
           jsPlatformFramebuffer_validate( framebuffer, LContext );

	driver->rt = framebuffer->rt;
        driver->colorBufferMask = framebuffer->colorBufferMask;
    }
    else
    {
	driver->rt = gcmDevice->rt;
        driver->colorBufferMask = 0x1;
    }

    driver->rtValid = GL_TRUE;

    _RGLFifoGlSetRenderTarget( &driver->rt );

    LContext->needValidate &= ~PSGL_VALIDATE_FRAMEBUFFER;
    _RGLFifoGlViewport(LContext->ViewPort.X, LContext->ViewPort.Y, 
    LContext->ViewPort.XSize, LContext->ViewPort.YSize, 0.0f, 1.0f);
}

GLAPI void APIENTRY glClear( GLbitfield mask )
{
   PSGLcontext *LContext = _CurrentContext;
   RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;
   RGLFifo * fifo = &_RGLState.fifo;

   if ( LContext->needValidate & PSGL_VALIDATE_FRAMEBUFFER )
      _RGLValidateFramebuffer();

   if ( !driver->rtValid )
      return;

   GLbitfield newmask = 0;
   if (driver->rt.colorBufferCount ) newmask |= RGL_COLOR_BUFFER_BIT;

   if ( !newmask )
      return;

   GLbitfield clearMask = newmask;

   if ( driver->rt.colorBufferCount > 1 )
	   clearMask &= ~RGL_COLOR_BUFFER_BIT;

   if ( clearMask )
   {
      GLuint hwColor;
      RGL_CALC_COLOR_LE_ARGB8( &hwColor, RGL_CLAMPF_01(LContext->ClearColor.R), RGL_CLAMPF_01(LContext->ClearColor.G), RGL_CLAMPF_01(LContext->ClearColor.B), RGL_CLAMPF_01(LContext->ClearColor.A) );

      cellGcmSetClearColorInline( &_RGLState.fifo, hwColor);
      cellGcmSetClearSurfaceInline ( &_RGLState.fifo, CELL_GCM_CLEAR_R | CELL_GCM_CLEAR_G | CELL_GCM_CLEAR_B | CELL_GCM_CLEAR_A);
      newmask &= ~clearMask;
   }

   if ( newmask )
   {
      cellGcmSetScissorInline( &_RGLState.fifo, 0, 0, 4095, 4095);
      cellGcmSetDepthTestEnableInline( &_RGLState.fifo, CELL_GCM_FALSE);
      cellGcmSetStencilTestEnableInline( &_RGLState.fifo, CELL_GCM_FALSE);

      static float _RGLClearVertexBuffer[12] __attribute__(( aligned( RGL_ALIGN_FAST_TRANSFER ) ) ) =
      {
	      -1.f, -1.f, 0.f,
	      -1.f, 1.f, 0.f,
	      1.f, -1.f, 0.f,
	      1.f, 1.f, 0.f,
      };

      _RGLClearVertexBuffer[2] = 2.f - 1.f;
      _RGLClearVertexBuffer[5] = 2.f - 1.f;
      _RGLClearVertexBuffer[8] = 2.f - 1.f;
      _RGLClearVertexBuffer[11] = 2.f - 1.f;

      GLuint bufferId = gmmAlloc(0, sizeof(_RGLClearVertexBuffer));
      memcpy( gmmIdToAddress(bufferId), _RGLClearVertexBuffer, sizeof( _RGLClearVertexBuffer ) );
      _RGLFifoGlVertexAttribPointer( 0, 3, RGL_FLOAT, CELL_GCM_FALSE, 3*sizeof( GLfloat ), 1, 0, gmmIdToOffset(bufferId) );
      RGLBIT_TRUE( LContext->attribs->DirtyMask, 0 );

      for ( int i = 1; i < _RGL_MAX_VERTEX_ATTRIBS;++i )
      {
         _RGLFifoGlVertexAttribPointer( i, 0, RGL_FLOAT, 0, 0, 0, 0, 0 );
	 RGLBIT_TRUE( LContext->attribs->DirtyMask, i );
      }
      cellGcmSetVertexData4fInline( &_RGLState.fifo, _RGL_ATTRIB_PRIMARY_COLOR_INDEX, (GLfloat*)&LContext->ClearColor);

      LContext->needValidate |= PSGL_VALIDATE_FRAGMENT_PROGRAM;

      gmmFree( bufferId );
   }

   cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
   _RGLFifoFlush( fifo );
}

GLAPI void APIENTRY glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
    PSGLcontext *LContext = _CurrentContext;

    LContext->ClearColor.R = _RGLClampf( red );
    LContext->ClearColor.G = _RGLClampf( green );
    LContext->ClearColor.B = _RGLClampf( blue );
    LContext->ClearColor.A = _RGLClampf( alpha );
}

GLAPI void APIENTRY glBlendEquation( GLenum mode )
{
    PSGLcontext *LContext = _CurrentContext;

    LContext->BlendEquationRGB = LContext->BlendEquationAlpha = mode;
    LContext->needValidate |= PSGL_VALIDATE_BLENDING;
}

GLAPI void APIENTRY glBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
    PSGLcontext*	LContext = _CurrentContext;
    LContext->BlendColor.R = _RGLClampf( red );
    LContext->BlendColor.G = _RGLClampf( green );
    LContext->BlendColor.B = _RGLClampf( blue );
    LContext->BlendColor.A = _RGLClampf( alpha );

    LContext->needValidate |= PSGL_VALIDATE_BLENDING;
}


GLAPI void APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor )
{
    PSGLcontext *LContext = _CurrentContext;

    LContext->BlendFactorSrcRGB = sfactor;
    LContext->BlendFactorSrcAlpha = sfactor;
    LContext->BlendFactorDestRGB = dfactor;
    LContext->BlendFactorDestAlpha = dfactor;
    LContext->needValidate |= PSGL_VALIDATE_BLENDING;
}


jsFramebufferAttachment* _RGLFramebufferGetAttachment( jsFramebuffer *framebuffer, GLenum attachment )
{
    switch ( attachment )
    {
        case GL_COLOR_ATTACHMENT0_EXT:
        case GL_COLOR_ATTACHMENT1_EXT:
        case GL_COLOR_ATTACHMENT2_EXT:
        case GL_COLOR_ATTACHMENT3_EXT:
            return &framebuffer->color[attachment - GL_COLOR_ATTACHMENT0_EXT];
        case GL_DEPTH_ATTACHMENT_OES:
        case GL_STENCIL_ATTACHMENT_OES:
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return NULL;
    }
}

GLAPI void APIENTRY glBindFramebufferOES( GLenum target, GLuint framebuffer )
{
    PSGLcontext* LContext = _CurrentContext;

    if ( framebuffer )
        _RGLTexNameSpaceCreateNameLazy( &LContext->framebufferNameSpace, framebuffer );

    LContext->framebuffer = framebuffer;
    LContext->needValidate |= PSGL_VALIDATE_FRAMEBUFFER;
}

GLAPI void APIENTRY glDeleteFramebuffersOES( GLsizei n, const GLuint *framebuffers )
{

    PSGLcontext *LContext = _CurrentContext;

    for ( int i = 0; i < n; ++i )
    {
        if ( framebuffers[i] && framebuffers[i] == LContext->framebuffer )
           glBindFramebufferOES( GL_FRAMEBUFFER_OES, 0 );
    }

    _RGLTexNameSpaceDeleteNames( &LContext->framebufferNameSpace, n, framebuffers );
}

GLAPI void APIENTRY glGenFramebuffersOES( GLsizei n, GLuint *framebuffers )
{
    PSGLcontext *LContext = _CurrentContext;
    _RGLTexNameSpaceGenNames( &LContext->framebufferNameSpace, n, framebuffers );
}


GLAPI GLenum APIENTRY glCheckFramebufferStatusOES( GLenum target )
{
    PSGLcontext *LContext = _CurrentContext;


    if ( LContext->framebuffer )
    {
        jsFramebuffer* framebuffer = _RGLGetFramebuffer( LContext, LContext->framebuffer );
        return _RGLPlatformFramebufferCheckStatus( framebuffer );
    }

    return GL_FRAMEBUFFER_COMPLETE_OES;
}

GLAPI void APIENTRY glFramebufferTexture2DOES( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
   PSGLcontext* LContext = _CurrentContext;

   jsFramebuffer* framebuffer = _RGLGetFramebuffer( LContext, LContext->framebuffer );

   jsFramebufferAttachment* attach = _RGLFramebufferGetAttachment( framebuffer, GL_COLOR_ATTACHMENT0_EXT );

   if ( !attach )
      return;

   jsTexture *textureObject = NULL;
   GLuint face;
   _RGLFramebufferGetAttachmentTexture(attach, &textureObject, &face );

   if ( textureObject )
      textureObject->framebuffers.removeElement( framebuffer );

   if ( texture )
   {
      attach->type = _RGL_FRAMEBUFFER_ATTACHMENT_TEXTURE;
      textureObject = _RGLGetTexture( LContext, texture );
      textureObject->framebuffers.pushBack( framebuffer );
   }
   else
      attach->type = _RGL_FRAMEBUFFER_ATTACHMENT_NONE;

   attach->name = texture;
   attach->textureTarget = GL_TEXTURE_2D;

   framebuffer->needValidate = GL_TRUE;
   LContext->needValidate |= PSGL_VALIDATE_FRAMEBUFFER;
}

void cgRTCgcInit( void )
{
    _cgRTCgcCompileProgramHook = &compile_program_from_string;
    _cgRTCgcFreeCompiledProgramHook = &free_compiled_program;
}

void cgRTCgcFree( void )
{
    _cgRTCgcCompileProgramHook = 0;
    _cgRTCgcFreeCompiledProgramHook = 0;
}

void _RGLInitNameSpace( jsNameSpace * name )
{
   name->data = NULL;
   name->firstFree = NULL;
   name->capacity = 0;
}

void _RGLFreeNameSpace( jsNameSpace * ns )
{
   if ( ns->data )
      free( ns->data );

   ns->data = NULL;
   ns->capacity = 0;
   ns->firstFree = NULL;
}

jsName _RGLCreateName( jsNameSpace * ns, void* object )
{
   if ( NULL == ns->firstFree )
   {
      int newCapacity = ns->capacity + NAME_INCREMENT;

      void** newData = ( void** )malloc( newCapacity * sizeof( void* ) );
      if ( newData == NULL )
      {
         _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
	 return 0;
      }
      memcpy( newData, ns->data, ns->capacity * sizeof( void* ) );

      if ( ns->data != NULL )
         free( ns->data );

      ns->data = newData;

      for ( int index = ns->capacity; index < newCapacity - 1; ++index )
         ns->data[index] = ns->data + index + 1;

      ns->data[newCapacity - 1] = NULL;
      ns->firstFree = ns->data + ns->capacity;
      ns->capacity = newCapacity;
   }
   jsName result = ns->firstFree - ns->data;

   ns->firstFree = ( void** ) * ns->firstFree;
   ns->data[result] = object;

   return result + 1;
}

unsigned int _RGLIsName( jsNameSpace* ns, jsName name )
{
   if ( RGL_UNLIKELY( 0 == name ) )
      return 0;

   --name;

   if ( RGL_UNLIKELY( name >= ns->capacity ) )
      return 0;

   void** value = ( void** )ns->data[name];

   if ( RGL_UNLIKELY( NULL == value ||
   ( value >= ns->data && value < ns->data + ns->capacity ) ) )
      return 0;

   return 1;
}

void _RGLEraseName( jsNameSpace* ns, jsName name )
{
   if ( _RGLIsName( ns, name ) )
   {
      --name;
      ns->data[name] = ns->firstFree;
      ns->firstFree = ns->data + name;
   }
}

void _RGLTexNameSpaceInit( jsTexNameSpace *ns, jsTexNameSpaceCreateFunction create, jsTexNameSpaceDestroyFunction destroy )
{
    ns->capacity = capacityIncr;
    ns->data = ( void ** )malloc( ns->capacity * sizeof( void* ) );
    memset( ns->data, 0, ns->capacity*sizeof( void* ) );
    ns->create = create;
    ns->destroy = destroy;
}

void _RGLTexNameSpaceFree( jsTexNameSpace *ns )
{
   for ( GLuint i = 1;i < ns->capacity;++i )
      if ( ns->data[i] ) ns->destroy( ns->data[i] );

   if(ns->data != NULL)
      free( ns->data );

   ns->data = NULL;
}

void _RGLTexNameSpaceResetNames( jsTexNameSpace *ns )
{
   for ( GLuint i = 1;i < ns->capacity;++i )
   {
      if ( ns->data[i] )
      {
         ns->destroy( ns->data[i] );
	 ns->data[i] = NULL;
      }
   }
}

GLuint _RGLTexNameSpaceGetFree( jsTexNameSpace *ns )
{
    GLuint i;
    for ( i = 1;i < ns->capacity;++i )
        if ( !ns->data[i] ) break;
    return i;
}

GLboolean _RGLTexNameSpaceCreateNameLazy( jsTexNameSpace *ns, GLuint name )
{
    if ( name >= ns->capacity )
    {
        int newCapacity = name >= ns->capacity + capacityIncr ? name + 1 : ns->capacity + capacityIncr;
        void **newData = ( void ** )realloc( ns->data, newCapacity * sizeof( void * ) );
        memset( newData + ns->capacity, 0, ( newCapacity - ns->capacity )*sizeof( void * ) );
        ns->data = newData;
        ns->capacity = newCapacity;
    }
    if ( !ns->data[name] )
    {
        ns->data[name] = ns->create();
        if ( ns->data[name] ) return GL_TRUE;
    }
    return GL_FALSE;
}

GLboolean _RGLTexNameSpaceIsName( jsTexNameSpace *ns, GLuint name )
{
    if (( name > 0 ) && ( name < ns->capacity ) ) return( ns->data[name] != 0 );
    else return GL_FALSE;
}

void _RGLTexNameSpaceGenNames( jsTexNameSpace *ns, GLsizei n, GLuint *names )
{
    for ( int i = 0;i < n;++i )
    {
        GLuint name = _RGLTexNameSpaceGetFree( ns );
        names[i] = name;
        if ( name ) _RGLTexNameSpaceCreateNameLazy( ns, name );
    }
}

void _RGLTexNameSpaceDeleteNames( jsTexNameSpace *ns, GLsizei n, const GLuint *names )
{
    for ( int i = 0;i < n;++i )
    {
        GLuint name = names[i];
        if ( !_RGLTexNameSpaceIsName( ns, name ) ) continue;
        ns->destroy( ns->data[name] );
        ns->data[name] = NULL;
    }
}

static inline unsigned int endianSwapWordByHalf( unsigned int v )
{
	return ( v&0xffff ) << 16 | v >> 16;
}

static uint32_t gmmInitFixedAllocator (void)
{
	pGmmFixedAllocData = (GmmFixedAllocData *)malloc(sizeof(GmmFixedAllocData));

	if (pGmmFixedAllocData == NULL)
		return GMM_ERROR;

	memset(pGmmFixedAllocData, 0, sizeof(GmmFixedAllocData));

	for (int i=0; i<2; i++)
	{
		int blockCount = (i==0) ? GMM_BLOCK_COUNT : GMM_TILE_BLOCK_COUNT;
		int blockSize  = (i==0) ? sizeof(GmmBlock): sizeof(GmmTileBlock);

		pGmmFixedAllocData->ppBlockList[i] = (char **)malloc(sizeof(char *));
		if (pGmmFixedAllocData->ppBlockList[i] == NULL)
			return GMM_ERROR;

		pGmmFixedAllocData->ppBlockList[i][0] = (char *)malloc(blockSize * blockCount);
		if (pGmmFixedAllocData->ppBlockList[i][0] == NULL)
			return GMM_ERROR;

		pGmmFixedAllocData->ppFreeBlockList[i] = (uint16_t **)malloc(sizeof(uint16_t *));
		if (pGmmFixedAllocData->ppFreeBlockList[i] == NULL)
			return GMM_ERROR;

		pGmmFixedAllocData->ppFreeBlockList[i][0] = (uint16_t *)malloc(sizeof(uint16_t) * blockCount);
		if (pGmmFixedAllocData->ppFreeBlockList[i][0] == NULL)
			return GMM_ERROR;

		pGmmFixedAllocData->pBlocksUsed[i] = (uint16_t *)malloc(sizeof(uint16_t));
		if (pGmmFixedAllocData->pBlocksUsed[i] == NULL)
			return GMM_ERROR;

		for (int j=0; j<blockCount; j++)
		{
			pGmmFixedAllocData->ppFreeBlockList[i][0][j] = j; 
		}

		pGmmFixedAllocData->pBlocksUsed[i][0] = 0;
		pGmmFixedAllocData->BlockListCount[i] = 1;
	}

	return CELL_OK;
}

static void gmmRemovePendingFree(
    GmmAllocator *pAllocator,
    GmmBlock *pBlock
)
{
    if (pBlock == pAllocator->pPendingFreeHead)
        pAllocator->pPendingFreeHead = pBlock->pNextFree;

    if (pBlock == pAllocator->pPendingFreeTail)
        pAllocator->pPendingFreeTail = pBlock->pPrevFree;

    if (pBlock->pNextFree)
        pBlock->pNextFree->pPrevFree = pBlock->pPrevFree;

    if (pBlock->pPrevFree)
        pBlock->pPrevFree->pNextFree = pBlock->pNextFree;
}

static uint8_t gmmSizeToFreeIndex(
    uint32_t size
)
{
    if (size >= GMM_FREE_BIN_0 && size < GMM_FREE_BIN_1)
    {
        return 0;
    }
    else if (size >= GMM_FREE_BIN_1 && size < GMM_FREE_BIN_2)
    {
        return 1;
    }
    else if (size >= GMM_FREE_BIN_2 && size < GMM_FREE_BIN_3)
    {
        return 2;
    }
    else if (size >= GMM_FREE_BIN_3 && size < GMM_FREE_BIN_4)
    {
        return 3;
    }
    else if (size >= GMM_FREE_BIN_4 && size < GMM_FREE_BIN_5)
    {
        return 4;
    }
    else if (size >= GMM_FREE_BIN_5 && size < GMM_FREE_BIN_6)
    {
        return 5;
    }
    else if (size >= GMM_FREE_BIN_6 && size < GMM_FREE_BIN_7)
    {
        return 6;
    }
    else if (size >= GMM_FREE_BIN_7 && size < GMM_FREE_BIN_8)
    {
        return 7;
    }
    else if (size >= GMM_FREE_BIN_8 && size < GMM_FREE_BIN_9)
    {
        return 8;
    }
    else if (size >= GMM_FREE_BIN_9 && size < GMM_FREE_BIN_10)
    {
        return 9;
    }
    else if (size >= GMM_FREE_BIN_10 && size < GMM_FREE_BIN_11)
    {
        return 10;
    }
    else if (size >= GMM_FREE_BIN_11 && size < GMM_FREE_BIN_12)
    {
        return 11;
    }
    else if (size >= GMM_FREE_BIN_12 && size < GMM_FREE_BIN_13)
    {
        return 12;
    }
    else if (size >= GMM_FREE_BIN_13 && size < GMM_FREE_BIN_14)
    {
        return 13;
    }
    else if (size >= GMM_FREE_BIN_14 && size < GMM_FREE_BIN_15)
    {
        return 14;
    }
    else if (size >= GMM_FREE_BIN_15 && size < GMM_FREE_BIN_16)
    {
        return 15;
    }
    else if (size >= GMM_FREE_BIN_16 && size < GMM_FREE_BIN_17)
    {
        return 16;
    }
    else if (size >= GMM_FREE_BIN_17 && size < GMM_FREE_BIN_18)
    {
        return 17;
    }
    else if (size >= GMM_FREE_BIN_18 && size < GMM_FREE_BIN_19)
    {
        return 18;
    }
    else if (size >= GMM_FREE_BIN_19 && size < GMM_FREE_BIN_20)
    {
        return 19;
    }
    else if (size >= GMM_FREE_BIN_20 && size < GMM_FREE_BIN_21)
    {
        return 20;
    }
    else
        return 21;
}

static void gmmAddFree(
    GmmAllocator *pAllocator,
    GmmBlock *pBlock
)
{
    uint8_t freeIndex = gmmSizeToFreeIndex(pBlock->base.size);


    if (pAllocator->pFreeHead[freeIndex])
    {
        GmmBlock *pInsertBefore = pAllocator->pFreeHead[freeIndex];

        while (pInsertBefore && pInsertBefore->base.size < pBlock->base.size)
        {
            pInsertBefore = pInsertBefore->pNextFree;
        }

        if (pInsertBefore == NULL)
        {
            pBlock->pNextFree = NULL;
            pBlock->pPrevFree = pAllocator->pFreeTail[freeIndex];
            pAllocator->pFreeTail[freeIndex]->pNextFree = pBlock;
            pAllocator->pFreeTail[freeIndex] = pBlock;
        }
        else if (pInsertBefore == pAllocator->pFreeHead[freeIndex])
        {
            pBlock->pNextFree = pInsertBefore;
            pBlock->pPrevFree = pInsertBefore->pPrevFree;
            pInsertBefore->pPrevFree = pBlock;
            pAllocator->pFreeHead[freeIndex] = pBlock;
        }
        else
        {
            pBlock->pNextFree = pInsertBefore;
            pBlock->pPrevFree = pInsertBefore->pPrevFree;
            pInsertBefore->pPrevFree->pNextFree = pBlock;
            pInsertBefore->pPrevFree = pBlock;
        }
    }
    else
    {
        pBlock->pNextFree = NULL;
        pBlock->pPrevFree = NULL;
        pAllocator->pFreeHead[freeIndex] = pBlock;
        pAllocator->pFreeTail[freeIndex] = pBlock;
    }
}

void gmmUpdateFreeList (const uint8_t location)
{
    GmmAllocator    *pAllocator;
    const uint32_t  fence = _RGLState.semaphores->userSemaphores[_RGL_SEMA_FENCE].val;
    GmmBlock        *pBlock = NULL;
    GmmBlock        *pTemp = NULL;

    pAllocator = (location == CELL_GCM_LOCATION_LOCAL) ? 
                 pGmmLocalAllocator : 
                 pGmmMainAllocator;
    

    pBlock = pAllocator->pPendingFreeHead;

    while (pBlock)
    {
        pTemp = pBlock->pNextFree;

        if ( !(( fence - pBlock->fence ) & 0x80000000 ) )
        {
            gmmRemovePendingFree(pAllocator, pBlock);
            gmmAddFree(pAllocator, pBlock);
        }

        pBlock = pTemp;
    }

}

static void *gmmAllocFixed(uint8_t isTile)
{
    int blockCount = isTile ? GMM_TILE_BLOCK_COUNT : GMM_BLOCK_COUNT;
    int blockSize  = isTile ? sizeof(GmmTileBlock) : sizeof(GmmBlock);
    int listCount  = pGmmFixedAllocData->BlockListCount[isTile];

    for (int i=0; i<listCount; i++)
    {
        if (pGmmFixedAllocData->pBlocksUsed[isTile][i] < blockCount)
        {
            return pGmmFixedAllocData->ppBlockList[isTile][i] + 
                   (pGmmFixedAllocData->ppFreeBlockList[isTile][i][pGmmFixedAllocData->pBlocksUsed[isTile][i]++] * 
                    blockSize);
        }
    }

    char **ppBlockList = 
        (char **)realloc(pGmmFixedAllocData->ppBlockList[isTile],
                         (listCount + 1) * sizeof(char *));
    if (ppBlockList == NULL)
        return NULL;

    pGmmFixedAllocData->ppBlockList[isTile] = ppBlockList;

    pGmmFixedAllocData->ppBlockList[isTile][listCount] = 
        (char *)malloc(blockSize * blockCount);
    if (pGmmFixedAllocData->ppBlockList[isTile][listCount] == NULL)
        return NULL;

    uint16_t **ppFreeBlockList = 
        (uint16_t **)realloc(pGmmFixedAllocData->ppFreeBlockList[isTile],
                            (listCount + 1) * sizeof(uint16_t *));
    if (ppFreeBlockList == NULL)
        return NULL;

    pGmmFixedAllocData->ppFreeBlockList[isTile] = ppFreeBlockList;

    pGmmFixedAllocData->ppFreeBlockList[isTile][listCount] = 
        (uint16_t *)malloc(sizeof(uint16_t) * blockCount);
    if (pGmmFixedAllocData->ppFreeBlockList[isTile][listCount] == NULL)
        return NULL;

    uint16_t *pBlocksUsed = 
        (uint16_t *)realloc(pGmmFixedAllocData->pBlocksUsed[isTile],
                            (listCount + 1) * sizeof(uint16_t));
    if (pBlocksUsed == NULL)
        return NULL;

    pGmmFixedAllocData->pBlocksUsed[isTile] = pBlocksUsed;
                                
    for (int i=0; i<blockCount; i++)
    {
        pGmmFixedAllocData->ppFreeBlockList[isTile][listCount][i] = i; 
    }

    pGmmFixedAllocData->pBlocksUsed[isTile][listCount] = 0;
    pGmmFixedAllocData->BlockListCount[isTile]++;

    return pGmmFixedAllocData->ppBlockList[isTile][listCount] + 
           (pGmmFixedAllocData->ppFreeBlockList[isTile][listCount][pGmmFixedAllocData->pBlocksUsed[isTile][listCount]++] * 
            blockSize);
}

static void gmmFreeFixed(uint8_t isTile, void *pBlock)
{
    int blockCount = isTile ? GMM_TILE_BLOCK_COUNT : GMM_BLOCK_COUNT;
    int blockSize  = isTile ? sizeof(GmmTileBlock) : sizeof(GmmBlock);

    for (int i=0; i<pGmmFixedAllocData->BlockListCount[isTile]; i++)
    {
        if (pBlock >= pGmmFixedAllocData->ppBlockList[isTile][i] &&
            pBlock < (pGmmFixedAllocData->ppBlockList[isTile][i] + blockSize * blockCount))
        {
            int index = ((char *)pBlock - pGmmFixedAllocData->ppBlockList[isTile][i]) / blockSize;
            pGmmFixedAllocData->ppFreeBlockList[isTile][i][--pGmmFixedAllocData->pBlocksUsed[isTile][i]] = index;
        }
    }
}

uint32_t gmmInit(
    const void *localMemoryBase,
    const void *localStartAddress,
    const uint32_t localSize,
    const void *mainMemoryBase,
    const void *mainStartAddress,
    const uint32_t mainSize
)
{
    GmmAllocator *pAllocator[2];
    uint32_t alignedLocalSize, alignedMainSize;
    uint32_t localEndAddress = (uint32_t)localStartAddress + localSize;
    uint32_t mainEndAddress = (uint32_t)mainStartAddress + mainSize;

    localEndAddress = (localEndAddress / GMM_TILE_ALIGNMENT) * GMM_TILE_ALIGNMENT;
    mainEndAddress = (mainEndAddress / GMM_TILE_ALIGNMENT) * GMM_TILE_ALIGNMENT;

    alignedLocalSize = localEndAddress - (uint32_t)localStartAddress;
    alignedMainSize = mainEndAddress - (uint32_t)mainStartAddress;


    pAllocator[0] = (GmmAllocator *)malloc(2*sizeof(GmmAllocator));
    pAllocator[1] = pAllocator[0] + 1;

    if (pAllocator[0] == NULL)
        return GMM_ERROR;

    memset(pAllocator[0], 0, 2*sizeof(GmmAllocator));

    if (pAllocator[0])
    {
        pAllocator[0]->memoryBase = (uint32_t)localMemoryBase;
        pAllocator[1]->memoryBase = (uint32_t)mainMemoryBase;
        pAllocator[0]->startAddress = (uint32_t)localStartAddress;
        pAllocator[1]->startAddress = (uint32_t)mainStartAddress;
        pAllocator[0]->size = alignedLocalSize;
        pAllocator[1]->size = alignedMainSize;
        pAllocator[0]->freeAddress = pAllocator[0]->startAddress;
        pAllocator[1]->freeAddress = pAllocator[1]->startAddress;
        pAllocator[0]->tileStartAddress = ((uint32_t)localStartAddress) + alignedLocalSize;
        pAllocator[1]->tileStartAddress = ((uint32_t)mainStartAddress) + alignedMainSize;
        pAllocator[0]->totalSize = alignedLocalSize;
        pAllocator[1]->totalSize = alignedMainSize;

        pGmmLocalAllocator = pAllocator[0];
        pGmmMainAllocator = pAllocator[1];
    }
    else
        return GMM_ERROR;

    pLock = cellGcmGetLabelAddress(GMM_PPU_WAIT_INDEX);
    *pLock = 0;
    cachedLockValue = 0;

    return gmmInitFixedAllocator();
}

void gmmSetTileAttrib(
    const uint32_t id,
    const uint32_t tag,
    void *pData
)
{
    GmmTileBlock    *pTileBlock = (GmmTileBlock *)id;

    pTileBlock->tileTag = tag;
    pTileBlock->pData = pData;
}

uint32_t gmmIdToOffset(const uint32_t id)
{
    GmmBaseBlock    *pBaseBlock = (GmmBaseBlock *)id;
    return gmmAddressToOffset(pBaseBlock->address, pBaseBlock->isMain);
}

char *gmmIdToAddress(const uint32_t id)
{
    GmmBaseBlock    *pBaseBlock = (GmmBaseBlock *)id;

    do
    {
	    if (cachedLockValue == 0)
		    break;

	    cachedLockValue = *pLock;

	    if (cachedLockValue == 0)
		    break;

	    sys_timer_usleep(30);
    }while(1);

    return (char *)pBaseBlock->address;
}

static GmmBlock *gmmAllocBlock(GmmAllocator *pAllocator, uint32_t size)
{
    uint32_t    address;
    GmmBlock    *pNewBlock = NULL;
    GmmBlock    *pBlock = pAllocator->pTail;

    address = pAllocator->freeAddress;

    if (UINT_MAX - address >= size && 
        address + size <= pAllocator->startAddress + pAllocator->size)
    {
        pNewBlock = (GmmBlock *)gmmAllocFixed(0);
        if (pNewBlock == NULL)
            return NULL;

        memset(pNewBlock, 0, sizeof(GmmBlock));

        pNewBlock->base.address = address;
        pNewBlock->base.isMain = (pAllocator == pGmmMainAllocator);
        pNewBlock->base.size = size;
        pAllocator->freeAddress = address + size;

        if (pBlock)
        {
            pNewBlock->pPrev = pBlock;
            pBlock->pNext = pNewBlock;
            pAllocator->pTail = pNewBlock;
        }
        else
        {
            pAllocator->pHead = pNewBlock;
            pAllocator->pTail = pNewBlock;
        }
    }

    return pNewBlock;
}

static GmmTileBlock *gmmFindFreeTileBlock(
    GmmAllocator *pAllocator,
    const uint32_t size
)
{
    GmmTileBlock    *pBlock = pAllocator->pTileHead;
    GmmTileBlock    *pBestAfterBlock = NULL;
    GmmTileBlock    *pNewBlock = NULL;
    uint32_t        bestSize = 0;
    uint32_t        freeSize = 0;

    while (pBlock && pBlock->pNext)
    {
        freeSize = pBlock->pNext->base.address - pBlock->base.address - pBlock->base.size;

        if (freeSize >= size &&
            (pBestAfterBlock == NULL || freeSize < bestSize) &&
            (pBlock->pNext == NULL ||
             pBlock->pData != pBlock->pNext->pData))
        {
            pBestAfterBlock = pBlock;
            bestSize = freeSize;
        }

        pBlock = pBlock->pNext;
    }

    if (pBestAfterBlock)
    {
        pNewBlock = (GmmTileBlock *)gmmAllocFixed(1);

        if (pNewBlock == NULL)
            return NULL;

        memset(pNewBlock, 0, sizeof(GmmTileBlock));

        pNewBlock->base.address = pBestAfterBlock->base.address + pBestAfterBlock->base.size;
        pNewBlock->base.isMain = (pAllocator == pGmmMainAllocator);
        pNewBlock->base.isTile = 1;
        pNewBlock->base.size = size;

        pNewBlock->pNext = pBestAfterBlock->pNext;
        pNewBlock->pPrev = pBestAfterBlock;
        pNewBlock->pPrev->pNext = pNewBlock;
        pNewBlock->pNext->pPrev = pNewBlock;

        return pNewBlock;
    }
    else
    {
        return NULL;
    }
}

static GmmTileBlock *gmmCreateTileBlock(
    GmmAllocator *pAllocator,
    const uint32_t size
)
{
    GmmTileBlock    *pNewBlock;
    uint32_t        address;

    address = pAllocator->tileStartAddress - size;

    if (address > pAllocator->startAddress + pAllocator->size)
        return NULL;

    if (pAllocator->pTail &&
        pAllocator->pTail->base.address + pAllocator->pTail->base.size > address)
    {
        return NULL;
    }

    pAllocator->size = address - pAllocator->startAddress;
    pAllocator->tileSize = pAllocator->tileStartAddress + pAllocator->tileSize - address;
    pAllocator->tileStartAddress = address;

    pNewBlock = (GmmTileBlock *)gmmAllocFixed(1);
    if (pNewBlock == NULL)
    {
        return NULL;
    }

    memset(pNewBlock, 0, sizeof(GmmTileBlock));

    pNewBlock->base.address = address;
    pNewBlock->base.isMain = (pAllocator == pGmmMainAllocator);
    pNewBlock->base.isTile = 1;
    pNewBlock->base.size = size;
    pNewBlock->pNext = pAllocator->pTileHead;

    if (pAllocator->pTileHead)
    {
        pAllocator->pTileHead->pPrev = pNewBlock;
        pAllocator->pTileHead = pNewBlock;
    }
    else
    {
        pAllocator->pTileHead = pNewBlock;
        pAllocator->pTileTail = pNewBlock;
    }

    return pNewBlock;
}

static void gmmFreeTileBlock(
    GmmTileBlock    *pTileBlock
)
{
    GmmAllocator    *pAllocator;

    if (pTileBlock->pPrev)
        pTileBlock->pPrev->pNext = pTileBlock->pNext;

    if (pTileBlock->pNext)
        pTileBlock->pNext->pPrev = pTileBlock->pPrev;

    if (pTileBlock->base.isMain)
        pAllocator = pGmmMainAllocator;
    else
        pAllocator = pGmmLocalAllocator;

    if (pAllocator->pTileHead == pTileBlock)
    {
        pAllocator->pTileHead = pTileBlock->pNext;

        if (pAllocator->pTileHead)
        {
            pAllocator->pTileHead->pPrev = NULL;
        }

        pAllocator->size = pAllocator->pTileHead ? 
                           pAllocator->pTileHead->base.address - pAllocator->startAddress :
                           pAllocator->totalSize;
        pAllocator->tileSize = pAllocator->totalSize - pAllocator->size;
        pAllocator->tileStartAddress = pAllocator->pTileHead ?
                                       pAllocator->pTileHead->base.address :
                                       pAllocator->startAddress + pAllocator->size;
    }

    if (pAllocator->pTileTail == pTileBlock)
    {
        pAllocator->pTileTail = pTileBlock->pPrev;
        
        if (pAllocator->pTileTail)
        {
            pAllocator->pTileTail->pNext = NULL;
        }
    }

    gmmFreeFixed(1, pTileBlock);
}

uint32_t gmmAllocExtendedTileBlock(const uint32_t size, const uint32_t tag)
{
    GmmAllocator    *pAllocator =  pGmmLocalAllocator;
    uint32_t        retId = 0;
    uint32_t        newSize;
    uint8_t         resizeSucceed = 1;

    newSize = pad(size, GMM_TILE_ALIGNMENT);

    GmmTileBlock    *pBlock = pAllocator->pTileTail;

    while (pBlock)
    {
        if (pBlock->tileTag == tag)
        {
            GLuint address, tileSize;
            _RGLGetTileRegionInfo(pBlock->pData, &address, &tileSize);

            if ((pBlock->pNext && pBlock->pNext->base.address-pBlock->base.address-pBlock->base.size >= newSize) ||
                (pBlock->pPrev && pBlock->base.address-pBlock->pPrev->base.address-pBlock->pPrev->base.size >= newSize))
            {
                GmmTileBlock *pNewBlock = (GmmTileBlock *)gmmAllocFixed(1);
                if (pNewBlock == NULL)
                    break;

                retId = (uint32_t)pNewBlock;

                memset(pNewBlock, 0, sizeof(GmmTileBlock));

                pNewBlock->base.isMain = (pAllocator == pGmmMainAllocator);
                pNewBlock->base.isTile = 1;
                pNewBlock->base.size = newSize;

                if (pBlock->pNext && pBlock->pNext->base.address-pBlock->base.address-pBlock->base.size >= newSize)
                {
                    pNewBlock->base.address = pBlock->base.address+pBlock->base.size;
                    pNewBlock->pNext = pBlock->pNext;
                    pNewBlock->pPrev = pBlock;
                    pBlock->pNext->pPrev = pNewBlock;
                    pBlock->pNext = pNewBlock;

                    if (pNewBlock->pPrev->pData != pNewBlock->pNext->pData)
                    {
                        resizeSucceed = _RGLTryResizeTileRegion( address, tileSize+newSize, pBlock->pData );
                    }
                }
                else
                {
                    pNewBlock->base.address = pBlock->base.address-newSize;
                    pNewBlock->pNext = pBlock;
                    pNewBlock->pPrev = pBlock->pPrev;
                    pBlock->pPrev->pNext = pNewBlock;
                    pBlock->pPrev = pNewBlock;

                    if (pNewBlock->pPrev->pData != pNewBlock->pNext->pData)
                    {
                        resizeSucceed = _RGLTryResizeTileRegion( (GLuint)gmmIdToOffset((uint32_t)pNewBlock), tileSize+newSize, pBlock->pData );
                    }
                }
                gmmSetTileAttrib( retId, tag, pBlock->pData );
                break;
            }

            if (pBlock == pAllocator->pTileHead)
            {
                retId = (uint32_t)gmmCreateTileBlock(pAllocator, newSize); 
                if (retId == 0)
                    break;

                resizeSucceed = _RGLTryResizeTileRegion( (GLuint)gmmIdToOffset(retId), tileSize+newSize, pBlock->pData );
                gmmSetTileAttrib( retId, tag, pBlock->pData );
                break;
            }
        }

        pBlock = pBlock->pPrev;
    }

    if (retId == 0)
        return GMM_ERROR;

    if (!resizeSucceed)
    {
        gmmFreeTileBlock((GmmTileBlock *)retId);
        return GMM_ERROR;
    }

    return retId;
}

static GmmTileBlock *gmmAllocTileBlock(
    GmmAllocator *pAllocator,
    const uint32_t size
)
{
    GmmTileBlock    *pBlock = gmmFindFreeTileBlock(pAllocator, size); 

    if (pBlock == NULL)
        pBlock = gmmCreateTileBlock(pAllocator, size);

    return pBlock;
}

static void gmmFreeBlock(
    GmmBlock *pBlock
)
{
    GmmAllocator    *pAllocator;

    if (pBlock->pPrev)
        pBlock->pPrev->pNext = pBlock->pNext;

    if (pBlock->pNext)
        pBlock->pNext->pPrev = pBlock->pPrev;
   
    if (pBlock->base.isMain)
        pAllocator = pGmmMainAllocator;
    else
        pAllocator = pGmmLocalAllocator;

    if (pAllocator->pHead == pBlock)
    {
        pAllocator->pHead = pBlock->pNext;

        if (pAllocator->pHead)
            pAllocator->pHead->pPrev = NULL;
    }

    if (pAllocator->pTail == pBlock)
    {
        pAllocator->pTail = pBlock->pPrev;
        
        if (pAllocator->pTail)
            pAllocator->pTail->pNext = NULL;
    }

    if (pBlock->pPrev == NULL)
        pAllocator->pSweepHead = pAllocator->pHead;
    else if (pBlock->pPrev &&
             (pAllocator->pSweepHead == NULL || 
              (pAllocator->pSweepHead &&
               pAllocator->pSweepHead->base.address > pBlock->pPrev->base.address)))
    {
        pAllocator->pSweepHead = pBlock->pPrev;
    }

    pAllocator->freedSinceSweep += pBlock->base.size;
    
    gmmFreeFixed(0, pBlock);
}

static void gmmAddPendingFree(
    GmmBlock *pBlock
)
{
    GmmAllocator    *pAllocator;

    if (pBlock->base.isMain)
        pAllocator = pGmmMainAllocator;
    else
        pAllocator = pGmmLocalAllocator;

    if (pAllocator->pPendingFreeTail)
    {
        pBlock->pNextFree = NULL;
        pBlock->pPrevFree = pAllocator->pPendingFreeTail;
        pAllocator->pPendingFreeTail->pNextFree = pBlock;
        pAllocator->pPendingFreeTail = pBlock;
    }
    else
    {
        pBlock->pNextFree = NULL;
        pBlock->pPrevFree = NULL;
        pAllocator->pPendingFreeHead = pBlock;
        pAllocator->pPendingFreeTail = pBlock;
    }

    pBlock->isPinned = 0;

    GLuint* ref = &pBlock->fence;
    ++nvFenceCounter;
    cellGcmSetWriteBackEndLabelInline( &_RGLState.fifo, _RGL_SEMA_FENCE, nvFenceCounter);
    *ref = nvFenceCounter;
}



uint32_t gmmFree(const uint32_t freeId)
{
    GmmBaseBlock    *pBaseBlock = (GmmBaseBlock *)freeId;
    

    if (pBaseBlock->isTile)
    {
        GmmTileBlock *pTileBlock = (GmmTileBlock *)pBaseBlock;

        if (pTileBlock->pPrev &&
            pTileBlock->pNext &&
            pTileBlock->pPrev->pData == pTileBlock->pNext->pData)
        {
        }
        else if (pTileBlock->pPrev && pTileBlock->pPrev->pData == pTileBlock->pData)
        {
            GLuint address, size;

            _RGLGetTileRegionInfo(pTileBlock->pData, &address, &size);
            if ( !_RGLTryResizeTileRegion(address, (size-pTileBlock->base.size), pTileBlock->pData) )
            {
                _RGLTryResizeTileRegion(address, 0, pTileBlock->pData);
                if ( !_RGLTryResizeTileRegion(address, (size-pTileBlock->base.size), pTileBlock->pData) )
                {
                }
            }
        }
        else if (pTileBlock->pNext && pTileBlock->pNext->pData == pTileBlock->pData)
        {
            GLuint address, size;

            _RGLGetTileRegionInfo(pTileBlock->pData, &address, &size);
            if ( !_RGLTryResizeTileRegion((address+pTileBlock->base.size), (size-pTileBlock->base.size), pTileBlock->pData) )
            {
                _RGLTryResizeTileRegion(address, 0, pTileBlock->pData);
                if ( !_RGLTryResizeTileRegion((address+pTileBlock->base.size), (size-pTileBlock->base.size), pTileBlock->pData) )
                {
                }
            }
        }
        else
        {
            if ( !_RGLTryResizeTileRegion( (GLuint)gmmIdToOffset(freeId), 0, ((GmmTileBlock *)freeId)->pData ) )
            {
            }
        }

        gmmFreeTileBlock(pTileBlock);
    }
    else
    {
        GmmBlock *pBlock = (GmmBlock *)pBaseBlock;

        gmmAddPendingFree(pBlock);
    }

    return CELL_OK;
}

static inline void gmmLocalMemcpy(
    const uint32_t dstOffset,
    const uint32_t srcOffset,
    const uint32_t moveSize
)
{
	CellGcmContextData *thisContext = &_RGLState.fifo;
    int32_t offset = 0;
    int32_t sizeLeft = moveSize;
    int32_t dimension = 4096;

    while (sizeLeft)
    {
        while(sizeLeft >= dimension*dimension*4)
        {
            cellGcmSetTransferImage(thisContext,
                                    CELL_GCM_TRANSFER_LOCAL_TO_LOCAL,
                                    dstOffset+offset,
                                    dimension*4,
                                    0,
                                    0,
                                    srcOffset+offset,
                                    dimension*4,
                                    0,
                                    0,
                                    dimension,
                                    dimension,
                                    4);

            offset = offset + dimension*dimension*4;
            sizeLeft = sizeLeft - (dimension*dimension*4);
        }

        dimension = dimension >> 1;

        if (dimension == 32)
            break;
    }

    if (sizeLeft)
    {
        cellGcmSetTransferImage(thisContext, 
                                CELL_GCM_TRANSFER_LOCAL_TO_LOCAL,
                                dstOffset+offset,
                                sizeLeft,
                                0,
                                0,
                                srcOffset+offset,
                                sizeLeft,
                                0,
                                0,
                                sizeLeft/4,
                                1,
                                4);
    }
}

static inline void gmmMemcpy(const uint32_t dstOffset, const uint32_t srcOffset, const uint32_t moveSize)
{
	if (dstOffset + moveSize <= srcOffset)
	{
		gmmLocalMemcpy(dstOffset, srcOffset, moveSize);
	}
	else
	{
		uint32_t moveBlockSize = srcOffset-dstOffset;
		uint32_t iterations = (moveSize+moveBlockSize-1)/moveBlockSize;

		for (uint32_t i=0; i<iterations; i++)
                   gmmLocalMemcpy(dstOffset+(i*moveBlockSize), srcOffset+(i*moveBlockSize), moveBlockSize);
	}
}

static uint8_t gmmInternalSweep (void)
{
    GmmAllocator    *pAllocator  = pGmmLocalAllocator;
    GmmBlock        *pBlock;       
    GmmBlock        *pSrcBlock;
    GmmBlock        *pTempBlock;
    GmmBlock        *pTempBlockNext;
    uint32_t        dstAddress, srcAddress;
    uint32_t        srcOffset, dstOffset;
    uint32_t        prevEndAddress;
    uint32_t        moveSize, moveDistance;
    uint8_t         ret = 0;
    uint32_t        totalMoveSize = 0;

    pBlock = pAllocator->pSweepHead;
    srcAddress = 0;
    dstAddress = 0;
    prevEndAddress = 0;
    pSrcBlock = pBlock;

    while (pBlock != NULL)
    {
        if (pBlock->isPinned == 0)
        {
            if (pBlock->pPrev)
                prevEndAddress = pBlock->pPrev->base.address + pBlock->pPrev->base.size;
            else
                prevEndAddress = pAllocator->startAddress;

            if (pBlock->base.address > prevEndAddress)
            {
                dstAddress = prevEndAddress;
                srcAddress = pBlock->base.address;
                pSrcBlock = pBlock;
            }

            moveSize = pBlock->base.address + pBlock->base.size - srcAddress;

            if (srcAddress > dstAddress &&
                (pBlock->pNext == NULL ||
                 pBlock->pNext->base.address > pBlock->base.address + pBlock->base.size ||
                 pBlock->pNext->isPinned))
            {
                dstOffset = gmmAddressToOffset(dstAddress, 0);
                srcOffset = gmmAddressToOffset(srcAddress, 0);

                totalMoveSize += moveSize;

                gmmMemcpy(dstOffset, srcOffset, moveSize);

                pTempBlock = pSrcBlock;

                moveDistance = srcOffset - dstOffset;

                while (pTempBlock != pBlock->pNext)
                {
                    pTempBlock->base.address -= moveDistance;
                    pTempBlock = pTempBlock->pNext;
                }
            }
        }
        else
        {
            uint32_t availableSize;

            srcAddress = 0;
            dstAddress = 0;

            if (pBlock->pPrev == NULL)
                availableSize = pBlock->base.address - pAllocator->startAddress;
            else
                availableSize = pBlock->base.address - (pBlock->pPrev->base.address + pBlock->pPrev->base.size);

            pTempBlock = pBlock->pNext;

            while (availableSize >= GMM_ALIGNMENT && pTempBlock)
            {
                pTempBlockNext = pTempBlock->pNext;

                if (pTempBlock->isPinned == 0 && pTempBlock->base.size <= availableSize)
                {
                    uint32_t pinDstAddress = (pBlock->pPrev == NULL) ?
                                             pAllocator->startAddress :
                                             pBlock->pPrev->base.address + pBlock->pPrev->base.size;
                    uint32_t pinSrcAddress = pTempBlock->base.address;

                    dstOffset = gmmAddressToOffset(pinDstAddress, 0);
                    srcOffset = gmmAddressToOffset(pinSrcAddress, 0);

                    totalMoveSize += pTempBlock->base.size;

                    gmmMemcpy(dstOffset, srcOffset, pTempBlock->base.size);

                    pTempBlock->base.address = pinDstAddress;

                    if (pTempBlock == pAllocator->pTail)
                    {
                        if (pTempBlock->pNext)
                            pAllocator->pTail = pTempBlock->pNext;
                        else
                            pAllocator->pTail = pTempBlock->pPrev;
                    }

                    if (pTempBlock->pNext)
                        pTempBlock->pNext->pPrev = pTempBlock->pPrev;

                    if (pTempBlock->pPrev)
                        pTempBlock->pPrev->pNext = pTempBlock->pNext;

                    if (pBlock->pPrev)
                        pBlock->pPrev->pNext = pTempBlock;
                    else
                        pAllocator->pHead = pTempBlock;

                    pTempBlock->pPrev = pBlock->pPrev;
                    pTempBlock->pNext = pBlock;
                    pBlock->pPrev = pTempBlock;
                }

                if (pBlock->pPrev)
                    availableSize = pBlock->base.address - (pBlock->pPrev->base.address + pBlock->pPrev->base.size);

                pTempBlock = pTempBlockNext;
            }

            if (availableSize)
            {
                GmmBlock *pNewBlock = (GmmBlock *)gmmAllocFixed(0);

                if (pNewBlock)
                {
                    memset(pNewBlock, 0, sizeof(GmmBlock));
                    pNewBlock->base.address = pBlock->base.address - availableSize;
                    pNewBlock->base.isMain = pBlock->base.isMain;
                    pNewBlock->base.size = availableSize;
                    pNewBlock->pNext = pBlock;
                    pNewBlock->pPrev = pBlock->pPrev;

                    if (pBlock->pPrev)
                        pBlock->pPrev->pNext = pNewBlock;

                    pBlock->pPrev = pNewBlock;

                    if (pBlock == pAllocator->pHead)
                        pAllocator->pHead = pNewBlock;

                    gmmAddFree(pAllocator, pNewBlock);

                    ret = 1;
                }
            }
        }

        pBlock = pBlock->pNext;
    }

    uint32_t newFreeAddress = pAllocator->pTail ? 
                              pAllocator->pTail->base.address + pAllocator->pTail->base.size :
                              pAllocator->startAddress;

    if (pAllocator->freeAddress != newFreeAddress)
    {
        pAllocator->freeAddress = newFreeAddress;
        ret = 1;
    }

    pAllocator->freedSinceSweep = 0;
    pAllocator->pSweepHead = NULL;


    return ret;
}


static void gmmFreeAll (void)
{
    GmmAllocator    *pAllocator = pGmmLocalAllocator;
    GmmBlock        *pBlock;
    GmmBlock        *pTemp;

    pBlock = pAllocator->pPendingFreeHead;
    while (pBlock)
    {
        pTemp = pBlock->pNextFree;
        gmmFreeBlock(pBlock);
        pBlock = pTemp;
    }
    pAllocator->pPendingFreeHead = NULL;
    pAllocator->pPendingFreeTail = NULL;

    for (int i=0; i<GMM_NUM_FREE_BINS; i++)
    {
        pBlock = pAllocator->pFreeHead[i];
        while (pBlock)
        {
            pTemp = pBlock->pNextFree;
            gmmFreeBlock(pBlock);
            pBlock = pTemp;
        }
        pAllocator->pFreeHead[i] = NULL;
        pAllocator->pFreeTail[i] = NULL;
    }
}

static void gmmRemoveFree(
    GmmAllocator *pAllocator,
    GmmBlock *pBlock,
    uint8_t freeIndex
)
{

    if (pBlock == pAllocator->pFreeHead[freeIndex])
        pAllocator->pFreeHead[freeIndex] = pBlock->pNextFree;

    if (pBlock == pAllocator->pFreeTail[freeIndex])
        pAllocator->pFreeTail[freeIndex] = pBlock->pPrevFree;

    if (pBlock->pNextFree)
        pBlock->pNextFree->pPrevFree = pBlock->pPrevFree;

    if (pBlock->pPrevFree)
        pBlock->pPrevFree->pNextFree = pBlock->pNextFree;
}

static uint32_t gmmFindFreeBlock(
    GmmAllocator    *pAllocator,
    uint32_t        size
)
{
    uint32_t        retId = GMM_ERROR;
    GmmBlock        *pBlock;
    uint8_t         found = 0;
    uint8_t         freeIndex = gmmSizeToFreeIndex(size);

    pBlock = pAllocator->pFreeHead[freeIndex];

    while (freeIndex < GMM_NUM_FREE_BINS)
    {
        if (pBlock)
        {
            if (pBlock->base.size >= size)
            {
                found = 1;
                break;
            }
            pBlock = pBlock->pNextFree;
        }
        else if (++freeIndex < GMM_NUM_FREE_BINS)
        {
            pBlock = pAllocator->pFreeHead[freeIndex];
        }
    }

    if (found)
    {
        if (pBlock->base.size != size)
        {
            // create a new block here
            GmmBlock *pNewBlock = (GmmBlock *)gmmAllocFixed(0);
            if (pNewBlock == NULL)
                return GMM_ERROR;

            memset(pNewBlock, 0, sizeof(GmmBlock));
            pNewBlock->base.address = pBlock->base.address + size;
            pNewBlock->base.isMain = pBlock->base.isMain;
            pNewBlock->base.size = pBlock->base.size - size;
            pNewBlock->pNext = pBlock->pNext;
            pNewBlock->pPrev = pBlock;
            if (pBlock->pNext)
            {
                pBlock->pNext->pPrev = pNewBlock;
            }
            pBlock->pNext = pNewBlock;

            if (pBlock == pAllocator->pTail)
                pAllocator->pTail = pNewBlock;

            gmmAddFree(pAllocator, pNewBlock);
        }
        pBlock->base.size = size;
        gmmRemoveFree(pAllocator, pBlock, freeIndex);
        retId = (uint32_t)pBlock;
    }

    return retId;
}

uint32_t gmmAlloc(const uint8_t isTile, const uint32_t size)
{
	CellGcmContextData *thisContext = (CellGcmContextData*)&_RGLState.fifo;
	GmmAllocator    *pAllocator;
	uint32_t        retId;
	uint32_t        newSize;

	if (__builtin_expect((size == 0),0))
		return GMM_ERROR;

	pAllocator = pGmmLocalAllocator;

	if (!isTile)
	{
		newSize = pad(size, GMM_ALIGNMENT);

		retId = gmmFindFreeBlock(pAllocator, newSize);
	}
	else
	{
		newSize = pad(size, GMM_TILE_ALIGNMENT);
		retId = GMM_ERROR;
	}

	if (retId == GMM_ERROR)
	{
		if (isTile)
			retId = (uint32_t)gmmAllocTileBlock(pAllocator, newSize);
		else
			retId = (uint32_t)gmmAllocBlock(pAllocator, newSize);

		if (retId == RGL_MEMORY_ALLOC_ERROR)
		{
			gmmFreeAll();

			if (gmmInternalSweep())
			{
				*pLock = 1;
				cachedLockValue = 1;
				cellGcmSetWriteBackEndLabel(thisContext, GMM_PPU_WAIT_INDEX, 0);

				cellGcmFlush(thisContext);
			}

			if (isTile)
				retId = (uint32_t)gmmAllocTileBlock(pAllocator, newSize);
			else
				retId = (uint32_t)gmmAllocBlock(pAllocator, newSize);

			if (!isTile && retId == RGL_MEMORY_ALLOC_ERROR)
				retId = gmmFindFreeBlock(pAllocator, newSize);
		}
	}

	return retId;
}


static int _RGLLoadFPShader( _CGprogram *program )
{
   unsigned int ucodeSize = program->header.instructionCount * 16;

   if ( program->loadProgramId == GMM_ERROR )
   {
      program->loadProgramId = gmmAlloc(0, ucodeSize);
      program->loadProgramOffset = 0;
   }

   unsigned int dstId = program->loadProgramId;
   unsigned dstOffset = program->loadProgramOffset;
   const char *src = (char*)program->ucode;

   GLuint id = gmmAlloc(0, ucodeSize);

   memcpy( gmmIdToAddress(id), src, ucodeSize );
   _RGLMemcpy( dstId, dstOffset, 0, id, ucodeSize );

   gmmFree( id );
   return GL_TRUE;
}

static void _RGLUnloadFPShader( _CGprogram *program )
{
   if ( program->loadProgramId != GMM_ERROR )
   {
      gmmFree( program->loadProgramId );
      program->loadProgramId = GMM_ERROR;
      program->loadProgramOffset = 0;
   }
}

typedef struct RGLparamUIDRec
{
   char * string;
   GLboolean global;
} RGLparamUID;

typedef struct RGLparamUIDTableRec
{
   int count;
   RGLparamUID* uids;
} RGLparamUIDTable;


RGLparamUID getParamUIDByIndex( const RGLparamUIDTable* st, int index )
{
   return st->uids[index];
}

void _RGLPlatformSetVertexRegister4fv( unsigned int reg, const float * __restrict v )
{
}

void _RGLPlatformSetVertexRegisterBlock( unsigned int reg, unsigned int count, const float * __restrict v )
{
}


void _RGLPlatformSetFragmentRegister4fv( unsigned int reg, const float * __restrict v )
{
}

void _RGLPlatformSetFragmentRegisterBlock( unsigned int reg, unsigned int count, const float * __restrict v )
{
}

template<int SIZE> inline static void swapandsetfp( int ucodeSize, unsigned int loadProgramId, unsigned int loadProgramOffset, unsigned short *ec, const unsigned int   * __restrict v )
{
   cellGcmSetTransferLocationInline ( &_RGLState.fifo, CELL_GCM_LOCATION_LOCAL);
   unsigned short count = *( ec++ );
   for ( unsigned long offsetIndex = 0; offsetIndex < count; ++offsetIndex )
   {
      void *pointer=NULL;
      const int paddedSIZE = (SIZE + 1) & ~1;
      cellGcmSetInlineTransferPointerInline( &_RGLState.fifo, gmmIdToOffset( loadProgramId ) + loadProgramOffset + *(ec++), paddedSIZE, &pointer);
      float *fp = (float*)pointer;
      float *src = (float*)v;
      for (uint32_t j=0; j<SIZE;j++)
      {
         *fp = cellGcmSwap16Float32(*src);
	 fp++;src++;
      }
   }
}

template<int SIZE> static void setVectorTypefp( CgRuntimeParameter* __restrict ptr, const void* __restrict v )
{
   float * __restrict  f = ( float* )v;
   float * __restrict  data = ( float* )ptr->pushBufferPointer;

   for ( long i = 0; i < SIZE; ++i )
      data[i] = f[i];

   _CGprogram *program = ptr->program;

   CgParameterResource *parameterResource = _RGLGetParameterResource( ptr->program, ptr->parameterEntry );
   unsigned short resource = parameterResource->resource;
   unsigned short *ec = ( unsigned short * )( ptr->program->resources ) + resource + 1;
   if ( RGL_LIKELY( *ec ) )
   {
      swapandsetfp<SIZE>( program->header.instructionCount*16, program->loadProgramId, program->loadProgramOffset, ec, ( unsigned int * )data );
   }
}

template<int SIZE> static void setVectorTypeSharedfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int )
{
}

template<int SIZE> static void setVectorTypeSharedfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
}
template<int SIZE> static void setVectorTypeSharedvpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int )
{
    const float * __restrict f = ( const float * __restrict )v;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( ptr->program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;
    float * __restrict dst = ( float * __restrict )ptr->pushBufferPointer;
    for ( long i = 0; i < SIZE; ++ i )
        dst[i] = f[i];
    _RGLPlatformSetVertexRegister4fv( resource, dst );
}

template<int SIZE> static void setVectorTypeSharedvpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    const float * __restrict f = ( const float * __restrict )v;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( ptr->program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource + index;
    float * __restrict dst = ( float * __restrict )ptr->pushBufferPointer;
    for ( long i = 0; i < SIZE; ++ i )
        dst[i] = f[i];
    _RGLPlatformSetVertexRegister4fv( resource, dst );
}

template <int SIZE> static void setVectorTypevpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int )
{
    PSGLcontext * LContext = _CurrentContext;
    const float * __restrict f = ( const float* )v;
    float * __restrict dst = ( float* )ptr->pushBufferPointer;
    for ( long i = 0; i < SIZE; ++ i )
        dst[i] = f[i];
    LContext->needValidate |= PSGL_VALIDATE_VERTEX_CONSTANTS;
}
template <int SIZE> static void setVectorTypevpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    PSGLcontext * LContext = _CurrentContext;
    const float * __restrict f = ( const float* )v;
    float *  __restrict dst = ( float* )( *(( unsigned int ** )ptr->pushBufferPointer + index ) );
    for ( long i = 0; i < SIZE; ++ i )
        dst[i] = f[i];
    LContext->needValidate |= PSGL_VALIDATE_VERTEX_CONSTANTS;
}
template<int SIZE> static void setVectorTypefpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int )
{
    float * __restrict  f = ( float* )v;
    float * __restrict  data = ( float* )ptr->pushBufferPointer;
    for ( long i = 0; i < SIZE; ++i )
        data[i] = f[i];
    _CGprogram *program = ptr->program;

    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;
    unsigned short *ec = ( unsigned short * )( ptr->program->resources ) + resource + 1;
    if ( RGL_LIKELY( *ec ) )
    {
        swapandsetfp<SIZE>( program->header.instructionCount*16, program->loadProgramId, program->loadProgramOffset, ec, ( unsigned int * )data );
    }
}
template<int SIZE> static void setVectorTypefpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    float * __restrict  f = ( float* )v;
    float * __restrict  data = ( float* )ptr->pushBufferPointer;
    for ( long i = 0; i < SIZE; ++i )
        data[i] = f[i];
    _CGprogram *program = ptr->program;

    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;
    unsigned short *ec = ( unsigned short * )( program->resources ) + resource + 1;
    int arrayIndex = index;
    while ( arrayIndex )
    {
        ec += (( *ec ) + 2 );
        arrayIndex--;
    }
    if ( RGL_LIKELY( *ec ) )
    {
        swapandsetfp<SIZE>( program->header.instructionCount*16, program->loadProgramId, program->loadProgramOffset, ec, ( unsigned int * )data );
    }
}

template <int ROWS, int COLS, int ORDER> static void setMatrixvpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    PSGLcontext * LContext = _CurrentContext;
    float *  __restrict f = ( float* )v;
    float *  __restrict dst = ( float* )ptr->pushBufferPointer;
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
            dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
    }
    LContext->needValidate |= PSGL_VALIDATE_VERTEX_CONSTANTS;
}

template <int ROWS, int COLS, int ORDER> static void setMatrixSharedvpIndex( CgRuntimeParameter*  __restrict ptr, const void*  __restrict v, const int /*index*/ )
{
    float * __restrict f = ( float* )v;
    float * __restrict dst = ( float* )ptr->pushBufferPointer;

    const CgParameterResource *parameterResource = _RGLGetParameterResource( ptr->program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;

    float tmp[ROWS*4];
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
        {
            tmp[row*4 + col] = dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
        }
        for ( long col = COLS; col < 4; ++col ) tmp[row*4 + col] = dst[row*4+col];
    }

    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, resource, ROWS, (const float*)tmp);
}

template <int ROWS, int COLS, int ORDER> static void setMatrixSharedvpIndexArray( CgRuntimeParameter*  __restrict ptr, const void*  __restrict v, const int index )
{
    float * __restrict f = ( float* )v;
    float * __restrict dst = ( float* )ptr->pushBufferPointer;

    const CgParameterResource *parameterResource = _RGLGetParameterResource( ptr->program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource + index * ROWS;

    float tmp[ROWS*4];
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
        {
            tmp[row*4 + col] = dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
        }
        for ( long col = COLS; col < 4; ++col ) tmp[row*4 + col] = dst[row*4+col];
    }
    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, resource, ROWS, (const float*)tmp);
}

template <int ROWS, int COLS, int ORDER> static void setMatrixSharedfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int /*index*/ )
{
}

template <int ROWS, int COLS, int ORDER> static void setMatrixSharedfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
}

template <int ROWS, int COLS, int ORDER> static void setMatrixvpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    PSGLcontext * LContext = _CurrentContext;
    float *  __restrict f = ( float* )v;
    float *  __restrict dst = ( float* )( *(( unsigned int ** )ptr->pushBufferPointer + index ) );
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
            dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
    }
    LContext->needValidate |= PSGL_VALIDATE_VERTEX_CONSTANTS;
}
template <int ROWS, int COLS, int ORDER> static void setMatrixfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int /*index*/ )
{
    float *  __restrict f = ( float* )v;
    float *  __restrict dst = ( float* )ptr->pushBufferPointer;
    _CGprogram *program = (( CgRuntimeParameter* )ptr )->program;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;
    unsigned short *ec = ( unsigned short * )program->resources + resource + 1;
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
            dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
        int count = *ec;
        if ( RGL_LIKELY( count ) )
        {
            swapandsetfp<COLS>( program->header.instructionCount*16, program->loadProgramId, program->loadProgramOffset, ec, ( unsigned int * )dst + row * 4 );
        }
        ec += count + 2;
    }
}
template <int ROWS, int COLS, int ORDER> static void setMatrixfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{
    float *  __restrict f = ( float* )v;
    float *  __restrict dst = ( float* )ptr->pushBufferPointer;
    _CGprogram *program = ptr->program;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, ptr->parameterEntry );
    unsigned short resource = parameterResource->resource;
    unsigned short *ec = ( unsigned short * )program->resources + resource + 1;
    int arrayIndex = index * ROWS;
    while ( arrayIndex ) 
    {
        unsigned short count = ( *ec );
        ec += ( count + 2 ); 
        arrayIndex--;
    }
    for ( long row = 0; row < ROWS; ++row )
    {
        for ( long col = 0; col < COLS; ++col )
            dst[row * 4 + col] = ( ORDER == ROW_MAJOR ) ? f[row * COLS + col] : f[col * ROWS + row];
        int count = *ec;
        if ( RGL_LIKELY( count ) )
        {
            swapandsetfp<COLS>( program->header.instructionCount*16, program->loadProgramId, program->loadProgramOffset, ec, ( unsigned int * )dst + row * 4 );
        }
        ec += count + 2;
    }
}

static _cgSetArrayIndexFunction setVectorTypeIndex[2][2][2][4] =
    {
        {
            {
                {&setVectorTypevpIndex<1>, &setVectorTypevpIndex<2>, &setVectorTypevpIndex<3>, &setVectorTypevpIndex<4>, },
                {&setVectorTypefpIndex<1>, &setVectorTypefpIndex<2>, &setVectorTypefpIndex<3>, &setVectorTypefpIndex<4>, }
            },
            {
                {&setVectorTypeSharedvpIndex<1>, &setVectorTypeSharedvpIndex<2>, &setVectorTypeSharedvpIndex<3>, &setVectorTypeSharedvpIndex<4>, }, 
                {&setVectorTypeSharedfpIndex<1>, &setVectorTypeSharedfpIndex<2>, &setVectorTypeSharedfpIndex<3>, &setVectorTypeSharedfpIndex<4>, } 
            },
        },
        {
            {
                {&setVectorTypevpIndexArray<1>, &setVectorTypevpIndexArray<2>, &setVectorTypevpIndexArray<3>, &setVectorTypevpIndexArray<4>, },
                {&setVectorTypefpIndexArray<1>, &setVectorTypefpIndexArray<2>, &setVectorTypefpIndexArray<3>, &setVectorTypefpIndexArray<4>, }
            },
            {
                {&setVectorTypeSharedvpIndexArray<1>, &setVectorTypeSharedvpIndexArray<2>, &setVectorTypeSharedvpIndexArray<3>, &setVectorTypeSharedvpIndexArray<4>, }, //should be the shared
                {&setVectorTypeSharedfpIndexArray<1>, &setVectorTypeSharedfpIndexArray<2>, &setVectorTypeSharedfpIndexArray<3>, &setVectorTypeSharedfpIndexArray<4>, } //should be the shared
            },
        },
    };

static _cgSetArrayIndexFunction setMatrixTypeIndex[2][2][2][4][4][2] =
    {
        {
            {
                {
                    {{ &setMatrixvpIndex<1, 1, 0>, &setMatrixvpIndex<1, 1, 1>}, { &setMatrixvpIndex<1, 2, 0>, &setMatrixvpIndex<1, 2, 1>}, { &setMatrixvpIndex<1, 3, 0>, &setMatrixvpIndex<1, 3, 1>}, { &setMatrixvpIndex<1, 4, 0>, &setMatrixvpIndex<1, 4, 1>}},
                    {{ &setMatrixvpIndex<2, 1, 0>, &setMatrixvpIndex<2, 1, 1>}, { &setMatrixvpIndex<2, 2, 0>, &setMatrixvpIndex<2, 2, 1>}, { &setMatrixvpIndex<2, 3, 0>, &setMatrixvpIndex<2, 3, 1>}, { &setMatrixvpIndex<2, 4, 0>, &setMatrixvpIndex<2, 4, 1>}},
                    {{ &setMatrixvpIndex<3, 1, 0>, &setMatrixvpIndex<3, 1, 1>}, { &setMatrixvpIndex<3, 2, 0>, &setMatrixvpIndex<3, 2, 1>}, { &setMatrixvpIndex<3, 3, 0>, &setMatrixvpIndex<3, 3, 1>}, { &setMatrixvpIndex<3, 4, 0>, &setMatrixvpIndex<3, 4, 1>}},
                    {{ &setMatrixvpIndex<4, 1, 0>, &setMatrixvpIndex<4, 1, 1>}, { &setMatrixvpIndex<4, 2, 0>, &setMatrixvpIndex<4, 2, 1>}, { &setMatrixvpIndex<4, 3, 0>, &setMatrixvpIndex<4, 3, 1>}, { &setMatrixvpIndex<4, 4, 0>, &setMatrixvpIndex<4, 4, 1>}},
                },
                {
                    {{ &setMatrixfpIndex<1, 1, 0>, &setMatrixfpIndex<1, 1, 1>}, { &setMatrixfpIndex<1, 2, 0>, &setMatrixfpIndex<1, 2, 1>}, { &setMatrixfpIndex<1, 3, 0>, &setMatrixfpIndex<1, 3, 1>}, { &setMatrixfpIndex<1, 4, 0>, &setMatrixfpIndex<1, 4, 1>}},
                    {{ &setMatrixfpIndex<2, 1, 0>, &setMatrixfpIndex<2, 1, 1>}, { &setMatrixfpIndex<2, 2, 0>, &setMatrixfpIndex<2, 2, 1>}, { &setMatrixfpIndex<2, 3, 0>, &setMatrixfpIndex<2, 3, 1>}, { &setMatrixfpIndex<2, 4, 0>, &setMatrixfpIndex<2, 4, 1>}},
                    {{ &setMatrixfpIndex<3, 1, 0>, &setMatrixfpIndex<3, 1, 1>}, { &setMatrixfpIndex<3, 2, 0>, &setMatrixfpIndex<3, 2, 1>}, { &setMatrixfpIndex<3, 3, 0>, &setMatrixfpIndex<3, 3, 1>}, { &setMatrixfpIndex<3, 4, 0>, &setMatrixfpIndex<3, 4, 1>}},
                    {{ &setMatrixfpIndex<4, 1, 0>, &setMatrixfpIndex<4, 1, 1>}, { &setMatrixfpIndex<4, 2, 0>, &setMatrixfpIndex<4, 2, 1>}, { &setMatrixfpIndex<4, 3, 0>, &setMatrixfpIndex<4, 3, 1>}, { &setMatrixfpIndex<4, 4, 0>, &setMatrixfpIndex<4, 4, 1>}},
                },
            },
            { //should be shared
                {
                    {{ &setMatrixSharedvpIndex<1, 1, 0>, &setMatrixSharedvpIndex<1, 1, 1>}, { &setMatrixSharedvpIndex<1, 2, 0>, &setMatrixSharedvpIndex<1, 2, 1>}, { &setMatrixSharedvpIndex<1, 3, 0>, &setMatrixSharedvpIndex<1, 3, 1>}, { &setMatrixSharedvpIndex<1, 4, 0>, &setMatrixSharedvpIndex<1, 4, 1>}},
                    {{ &setMatrixSharedvpIndex<2, 1, 0>, &setMatrixSharedvpIndex<2, 1, 1>}, { &setMatrixSharedvpIndex<2, 2, 0>, &setMatrixSharedvpIndex<2, 2, 1>}, { &setMatrixSharedvpIndex<2, 3, 0>, &setMatrixSharedvpIndex<2, 3, 1>}, { &setMatrixSharedvpIndex<2, 4, 0>, &setMatrixSharedvpIndex<2, 4, 1>}},
                    {{ &setMatrixSharedvpIndex<3, 1, 0>, &setMatrixSharedvpIndex<3, 1, 1>}, { &setMatrixSharedvpIndex<3, 2, 0>, &setMatrixSharedvpIndex<3, 2, 1>}, { &setMatrixSharedvpIndex<3, 3, 0>, &setMatrixSharedvpIndex<3, 3, 1>}, { &setMatrixSharedvpIndex<3, 4, 0>, &setMatrixSharedvpIndex<3, 4, 1>}},
                    {{ &setMatrixSharedvpIndex<4, 1, 0>, &setMatrixSharedvpIndex<4, 1, 1>}, { &setMatrixSharedvpIndex<4, 2, 0>, &setMatrixSharedvpIndex<4, 2, 1>}, { &setMatrixSharedvpIndex<4, 3, 0>, &setMatrixSharedvpIndex<4, 3, 1>}, { &setMatrixSharedvpIndex<4, 4, 0>, &setMatrixSharedvpIndex<4, 4, 1>}},
                },
                {
                    {{ &setMatrixSharedfpIndex<1, 1, 0>, &setMatrixSharedfpIndex<1, 1, 1>}, { &setMatrixSharedfpIndex<1, 2, 0>, &setMatrixSharedfpIndex<1, 2, 1>}, { &setMatrixSharedfpIndex<1, 3, 0>, &setMatrixSharedfpIndex<1, 3, 1>}, { &setMatrixSharedfpIndex<1, 4, 0>, &setMatrixSharedfpIndex<1, 4, 1>}},
                    {{ &setMatrixSharedfpIndex<2, 1, 0>, &setMatrixSharedfpIndex<2, 1, 1>}, { &setMatrixSharedfpIndex<2, 2, 0>, &setMatrixSharedfpIndex<2, 2, 1>}, { &setMatrixSharedfpIndex<2, 3, 0>, &setMatrixSharedfpIndex<2, 3, 1>}, { &setMatrixSharedfpIndex<2, 4, 0>, &setMatrixSharedfpIndex<2, 4, 1>}},
                    {{ &setMatrixSharedfpIndex<3, 1, 0>, &setMatrixSharedfpIndex<3, 1, 1>}, { &setMatrixSharedfpIndex<3, 2, 0>, &setMatrixSharedfpIndex<3, 2, 1>}, { &setMatrixSharedfpIndex<3, 3, 0>, &setMatrixSharedfpIndex<3, 3, 1>}, { &setMatrixSharedfpIndex<3, 4, 0>, &setMatrixSharedfpIndex<3, 4, 1>}},
                    {{ &setMatrixSharedfpIndex<4, 1, 0>, &setMatrixSharedfpIndex<4, 1, 1>}, { &setMatrixSharedfpIndex<4, 2, 0>, &setMatrixSharedfpIndex<4, 2, 1>}, { &setMatrixSharedfpIndex<4, 3, 0>, &setMatrixSharedfpIndex<4, 3, 1>}, { &setMatrixSharedfpIndex<4, 4, 0>, &setMatrixSharedfpIndex<4, 4, 1>}},
                },
            },
        },
        {
            {
                {
                    {{ &setMatrixvpIndexArray<1, 1, 0>, &setMatrixvpIndexArray<1, 1, 1>}, { &setMatrixvpIndexArray<1, 2, 0>, &setMatrixvpIndexArray<1, 2, 1>}, { &setMatrixvpIndexArray<1, 3, 0>, &setMatrixvpIndexArray<1, 3, 1>}, { &setMatrixvpIndexArray<1, 4, 0>, &setMatrixvpIndexArray<1, 4, 1>}},
                    {{ &setMatrixvpIndexArray<2, 1, 0>, &setMatrixvpIndexArray<2, 1, 1>}, { &setMatrixvpIndexArray<2, 2, 0>, &setMatrixvpIndexArray<2, 2, 1>}, { &setMatrixvpIndexArray<2, 3, 0>, &setMatrixvpIndexArray<2, 3, 1>}, { &setMatrixvpIndexArray<2, 4, 0>, &setMatrixvpIndexArray<2, 4, 1>}},
                    {{ &setMatrixvpIndexArray<3, 1, 0>, &setMatrixvpIndexArray<3, 1, 1>}, { &setMatrixvpIndexArray<3, 2, 0>, &setMatrixvpIndexArray<3, 2, 1>}, { &setMatrixvpIndexArray<3, 3, 0>, &setMatrixvpIndexArray<3, 3, 1>}, { &setMatrixvpIndexArray<3, 4, 0>, &setMatrixvpIndexArray<3, 4, 1>}},
                    {{ &setMatrixvpIndexArray<4, 1, 0>, &setMatrixvpIndexArray<4, 1, 1>}, { &setMatrixvpIndexArray<4, 2, 0>, &setMatrixvpIndexArray<4, 2, 1>}, { &setMatrixvpIndexArray<4, 3, 0>, &setMatrixvpIndexArray<4, 3, 1>}, { &setMatrixvpIndexArray<4, 4, 0>, &setMatrixvpIndexArray<4, 4, 1>}},
                },
                {
                    {{ &setMatrixfpIndexArray<1, 1, 0>, &setMatrixfpIndexArray<1, 1, 1>}, { &setMatrixfpIndexArray<1, 2, 0>, &setMatrixfpIndexArray<1, 2, 1>}, { &setMatrixfpIndexArray<1, 3, 0>, &setMatrixfpIndexArray<1, 3, 1>}, { &setMatrixfpIndexArray<1, 4, 0>, &setMatrixfpIndexArray<1, 4, 1>}},
                    {{ &setMatrixfpIndexArray<2, 1, 0>, &setMatrixfpIndexArray<2, 1, 1>}, { &setMatrixfpIndexArray<2, 2, 0>, &setMatrixfpIndexArray<2, 2, 1>}, { &setMatrixfpIndexArray<2, 3, 0>, &setMatrixfpIndexArray<2, 3, 1>}, { &setMatrixfpIndexArray<2, 4, 0>, &setMatrixfpIndexArray<2, 4, 1>}},
                    {{ &setMatrixfpIndexArray<3, 1, 0>, &setMatrixfpIndexArray<3, 1, 1>}, { &setMatrixfpIndexArray<3, 2, 0>, &setMatrixfpIndexArray<3, 2, 1>}, { &setMatrixfpIndexArray<3, 3, 0>, &setMatrixfpIndexArray<3, 3, 1>}, { &setMatrixfpIndexArray<3, 4, 0>, &setMatrixfpIndexArray<3, 4, 1>}},
                    {{ &setMatrixfpIndexArray<4, 1, 0>, &setMatrixfpIndexArray<4, 1, 1>}, { &setMatrixfpIndexArray<4, 2, 0>, &setMatrixfpIndexArray<4, 2, 1>}, { &setMatrixfpIndexArray<4, 3, 0>, &setMatrixfpIndexArray<4, 3, 1>}, { &setMatrixfpIndexArray<4, 4, 0>, &setMatrixfpIndexArray<4, 4, 1>}},
                },
            },
            { //should be shared
                {
                    {{ &setMatrixSharedvpIndexArray<1, 1, 0>, &setMatrixSharedvpIndexArray<1, 1, 1>}, { &setMatrixSharedvpIndexArray<1, 2, 0>, &setMatrixSharedvpIndexArray<1, 2, 1>}, { &setMatrixSharedvpIndexArray<1, 3, 0>, &setMatrixSharedvpIndexArray<1, 3, 1>}, { &setMatrixSharedvpIndexArray<1, 4, 0>, &setMatrixSharedvpIndexArray<1, 4, 1>}},
                    {{ &setMatrixSharedvpIndexArray<2, 1, 0>, &setMatrixSharedvpIndexArray<2, 1, 1>}, { &setMatrixSharedvpIndexArray<2, 2, 0>, &setMatrixSharedvpIndexArray<2, 2, 1>}, { &setMatrixSharedvpIndexArray<2, 3, 0>, &setMatrixSharedvpIndexArray<2, 3, 1>}, { &setMatrixSharedvpIndexArray<2, 4, 0>, &setMatrixSharedvpIndexArray<2, 4, 1>}},
                    {{ &setMatrixSharedvpIndexArray<3, 1, 0>, &setMatrixSharedvpIndexArray<3, 1, 1>}, { &setMatrixSharedvpIndexArray<3, 2, 0>, &setMatrixSharedvpIndexArray<3, 2, 1>}, { &setMatrixSharedvpIndexArray<3, 3, 0>, &setMatrixSharedvpIndexArray<3, 3, 1>}, { &setMatrixSharedvpIndexArray<3, 4, 0>, &setMatrixSharedvpIndexArray<3, 4, 1>}},
                    {{ &setMatrixSharedvpIndexArray<4, 1, 0>, &setMatrixSharedvpIndexArray<4, 1, 1>}, { &setMatrixSharedvpIndexArray<4, 2, 0>, &setMatrixSharedvpIndexArray<4, 2, 1>}, { &setMatrixSharedvpIndexArray<4, 3, 0>, &setMatrixSharedvpIndexArray<4, 3, 1>}, { &setMatrixSharedvpIndexArray<4, 4, 0>, &setMatrixSharedvpIndexArray<4, 4, 1>}},
                },
                {
                    {{ &setMatrixSharedfpIndexArray<1, 1, 0>, &setMatrixSharedfpIndexArray<1, 1, 1>}, { &setMatrixSharedfpIndexArray<1, 2, 0>, &setMatrixSharedfpIndexArray<1, 2, 1>}, { &setMatrixSharedfpIndexArray<1, 3, 0>, &setMatrixSharedfpIndexArray<1, 3, 1>}, { &setMatrixSharedfpIndexArray<1, 4, 0>, &setMatrixSharedfpIndexArray<1, 4, 1>}},
                    {{ &setMatrixSharedfpIndexArray<2, 1, 0>, &setMatrixSharedfpIndexArray<2, 1, 1>}, { &setMatrixSharedfpIndexArray<2, 2, 0>, &setMatrixSharedfpIndexArray<2, 2, 1>}, { &setMatrixSharedfpIndexArray<2, 3, 0>, &setMatrixSharedfpIndexArray<2, 3, 1>}, { &setMatrixSharedfpIndexArray<2, 4, 0>, &setMatrixSharedfpIndexArray<2, 4, 1>}},
                    {{ &setMatrixSharedfpIndexArray<3, 1, 0>, &setMatrixSharedfpIndexArray<3, 1, 1>}, { &setMatrixSharedfpIndexArray<3, 2, 0>, &setMatrixSharedfpIndexArray<3, 2, 1>}, { &setMatrixSharedfpIndexArray<3, 3, 0>, &setMatrixSharedfpIndexArray<3, 3, 1>}, { &setMatrixSharedfpIndexArray<3, 4, 0>, &setMatrixSharedfpIndexArray<3, 4, 1>}},
                    {{ &setMatrixSharedfpIndexArray<4, 1, 0>, &setMatrixSharedfpIndexArray<4, 1, 1>}, { &setMatrixSharedfpIndexArray<4, 2, 0>, &setMatrixSharedfpIndexArray<4, 2, 1>}, { &setMatrixSharedfpIndexArray<4, 3, 0>, &setMatrixSharedfpIndexArray<4, 3, 1>}, { &setMatrixSharedfpIndexArray<4, 4, 0>, &setMatrixSharedfpIndexArray<4, 4, 1>}},
                },
            },
        }
    };

_cgSetArrayIndexFunction getVectorTypeIndexSetterFunction( unsigned short a, unsigned short b, unsigned short c, unsigned short d )
{
    return setVectorTypeIndex[a][b][c][d];
}

_cgSetArrayIndexFunction getMatrixTypeIndexSetterFunction( unsigned short a, unsigned short b, unsigned short c, unsigned short d, unsigned short e, unsigned short f )
{
    return setMatrixTypeIndex[a][b][c][d][e][f];
}

static void _RGLBindTextureInternal( jsTextureImageUnit *unit, GLuint name)
{
    PSGLcontext*	LContext = _CurrentContext;
    jsTexture *texture = NULL;
    if ( name )
    {
	    _RGLTexNameSpaceCreateNameLazy( &LContext->textureNameSpace, name );
	    texture = ( jsTexture * )LContext->textureNameSpace.data[name];
	    texture->target = GL_TEXTURE_2D;
    }

    unit->bound2D = name;

    unit->currentTexture = _RGLGetCurrentTexture( unit, GL_TEXTURE_2D );
    LContext->needValidate |= PSGL_VALIDATE_TEXTURES_USED;
}

static void setSamplerfp( CgRuntimeParameter*ptr, const void*v, int )
{
    _CGprogram *program = (( CgRuntimeParameter* )ptr )->program;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, (( CgRuntimeParameter* )ptr )->parameterEntry );

    if ( v )
    {
        *( GLuint* )ptr->pushBufferPointer = *( GLuint* )v;
    }
    else
    {
        jsTextureImageUnit *unit = _CurrentContext->TextureImageUnits + ( parameterResource->resource - CG_TEXUNIT0 );
        _RGLBindTextureInternal( unit, *( GLuint* )ptr->pushBufferPointer);
    }
}

static void setSamplervp( CgRuntimeParameter*ptr, const void*v, int )
{
    _CGprogram *program = (( CgRuntimeParameter* )ptr )->program;
    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, (( CgRuntimeParameter* )ptr )->parameterEntry );

    if ( v )
    {
        *( GLuint* )ptr->pushBufferPointer = *( GLuint* )v;
    }
    else
    {
	    GLuint unit = parameterResource->resource - CG_TEXUNIT0;
	    GLuint name = *( GLuint* )ptr->pushBufferPointer;
	    PSGLcontext *LContext = _CurrentContext;
	    jsTexture *texture = NULL;

	    if ( name && (name < LContext->textureNameSpace.capacity) )
		    texture = ( jsTexture * )LContext->textureNameSpace.data[name];

	    LContext->VertexTextureImages[unit] = texture;
	    LContext->needValidate |= PSGL_VALIDATE_VERTEX_TEXTURES_USED;
    }
}

static void _RGLCreatePushBuffer( _CGprogram *program )
{
    int bufferSize = 0;
    int programPushBufferPointersSize = 0;
    int extraStorageInWords = 0;
    int offsetCount = 0;
    int samplerCount = 0;
    int profileIndex = ( program->header.profile == CG_PROFILE_SCE_FP_TYPEB ||
                         program->header.profile == CG_PROFILE_SCE_FP_RSX ) ? FRAGMENT_PROFILE_INDEX : VERTEX_PROFILE_INDEX;

    bool hasSharedParams = false;
    int arrayCount = 1;
    for ( int i = 0;i < program->rtParametersCount;i++ )
    {
        const CgParameterEntry *parameterEntry = program->parametersEntries + i;

        if (( parameterEntry->flags & CGP_STRUCTURE ) || ( parameterEntry->flags & CGP_UNROLLED ) )
        {
            arrayCount = 1;
            continue;
        }

        if (( parameterEntry->flags & CGPF_REFERENCED ) )
        {
            if ( parameterEntry->flags & CGP_ARRAY )
            {
                const CgParameterArray *parameterArray = _RGLGetParameterArray( program, parameterEntry );
                arrayCount = _RGLGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount );
                continue;
            }
            if (( parameterEntry->flags & CGPV_MASK ) == CGPV_UNIFORM )
            {
                const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
                if ( parameterResource->type >= CG_SAMPLER1D &&  parameterResource->type <= CG_SAMPLERCUBE )
                {
                    offsetCount += arrayCount;
                    samplerCount += arrayCount;
                }
                else if ( profileIndex == VERTEX_PROFILE_INDEX )
                {
                    if ( parameterResource->type == CGP_SCF_BOOL )
                    {
                    }
                    else if ( !( parameterEntry->flags & CGPF_SHARED ) )
                    {
                        int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
                        if ( parameterEntry->flags & CGP_CONTIGUOUS )
                            bufferSize += 3 + 4 * arrayCount * registerStride;
                        else
                        {
                            programPushBufferPointersSize += arrayCount;
                            int resourceIndex = parameterResource->resource;
                            int referencedSize = 3 + 4 * registerStride;
                            int notReferencedSize = 4 * registerStride;
                            for ( int j = 0;j < arrayCount;j++, resourceIndex += registerStride )
                            {
                                if ( program->resources[resourceIndex] != 0xffff )
                                    bufferSize += referencedSize;
                                else
                                    extraStorageInWords += notReferencedSize;
                            }
                        }
                    }
                    else
                    {
                        hasSharedParams = true;
                        if ( !( parameterEntry->flags & CGP_CONTIGUOUS ) )
                        {
                            programPushBufferPointersSize += arrayCount;
                        }
                    }
                }
                else
                {
                    int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
                    if ( !( parameterEntry->flags & CGPF_SHARED ) )
                    {
                        extraStorageInWords += 4 * arrayCount * registerStride;
                    }
                    else
                    {
                        hasSharedParams = true;
                        unsigned short *resource = program->resources + parameterResource->resource;
                        for ( int j = 0;j < arrayCount*registerStride;j++ )
                        {
                            resource++;
                            unsigned short count = *resource++;
                            bufferSize += 24 * count;
                            resource += count;
                        }
                    }
                }
            }
        }
        arrayCount = 1;
    }

    if (( profileIndex == FRAGMENT_PROFILE_INDEX ) && ( hasSharedParams ) )
    {
        bufferSize += 8 + 3 + 2;
    }

    bufferSize = _RGLPad( bufferSize, 4 );

    unsigned int storageSizeInWords = bufferSize + extraStorageInWords;
    if ( storageSizeInWords )
        program->memoryBlock = ( unsigned int* )memalign( 16, storageSizeInWords * 4 );
    else
        program->memoryBlock = NULL;

    program->samplerCount = samplerCount;
    if ( samplerCount )
    {
        program->samplerValuesLocation = ( GLuint* )malloc( samplerCount * sizeof( GLuint ) );
        program->samplerIndices = ( GLuint* )malloc( samplerCount * sizeof( GLuint ) );
        program->samplerUnits = ( GLuint* )malloc( samplerCount * sizeof( GLuint ) );
    }
    else
    {
        program->samplerValuesLocation = NULL;
        program->samplerIndices = NULL;
        program->samplerUnits = NULL;
    }

    GLuint *samplerValuesLocation = program->samplerValuesLocation;
    GLuint *samplerIndices = program->samplerIndices;
    GLuint *samplerUnits = program->samplerUnits;

    if ( programPushBufferPointersSize )
        program->constantPushBufferPointers = ( unsigned int** )malloc( programPushBufferPointersSize * 4 );
    else
        program->constantPushBufferPointers = NULL;

    uint32_t *RGLCurrent = ( uint32_t * )program->memoryBlock;
    program->constantPushBuffer = ( bufferSize > 0 ) ? ( unsigned int * )RGLCurrent : NULL;
    unsigned int **programPushBuffer = program->constantPushBufferPointers;
    program->constantPushBufferWordSize = bufferSize;
    GLuint *currentStorage = ( GLuint * )( RGLCurrent + bufferSize );

    arrayCount = 1;
    const CgParameterEntry *containerEntry = NULL;
    for ( int i = 0;i < program->rtParametersCount;i++ )
    {
        CgRuntimeParameter *rtParameter = program->runtimeParameters + i;
        const CgParameterEntry *parameterEntry = program->parametersEntries + i;
        if ( containerEntry == NULL )
            containerEntry = parameterEntry;

        rtParameter->samplerSetter = _cgRaiseInvalidParamIndex;
        rtParameter->setterIndex = _cgRaiseInvalidParamIndex;
        rtParameter->setterrIndex = _cgRaiseNotMatrixParamIndex;
        rtParameter->settercIndex = _cgRaiseNotMatrixParamIndex;

        CGparameter id = ( CGparameter )_RGLCreateName( &_CurrentContext->cgParameterNameSpace, ( void* )rtParameter );
        if ( !id )
            break;

        rtParameter->id = id;
        rtParameter->parameterEntry = parameterEntry;
        rtParameter->program = program;

        if (( parameterEntry->flags & CGP_STRUCTURE ) || ( parameterEntry->flags & CGP_UNROLLED ) )
        {
            arrayCount = 1;
            containerEntry = NULL;
            continue;
        }

        if ( parameterEntry->flags & CGPF_REFERENCED )
        {
            if ( parameterEntry->flags & CGP_ARRAY )
            {
                const CgParameterArray *parameterArray = _RGLGetParameterArray( program, parameterEntry );
                arrayCount = _RGLGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount );
                continue;
            }
            if (( parameterEntry->flags & CGPV_MASK ) == CGPV_UNIFORM )
            {
                rtParameter->glType = GL_NONE;
                const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
                if ( parameterResource->type >= CG_SAMPLER1D && parameterResource->type <= CG_SAMPLERCUBE )
                {
                    rtParameter->pushBufferPointer = samplerValuesLocation;

                    *samplerValuesLocation = 0;
                    samplerValuesLocation++;

                    *samplerIndices = i;
                    samplerIndices++;
                    *samplerUnits = parameterResource->resource - CG_TEXUNIT0;
                    samplerUnits++;

                    if ( profileIndex == VERTEX_PROFILE_INDEX )
                    {
                        rtParameter->setterIndex = _cgIgnoreSetParamIndex;
                        rtParameter->samplerSetter = setSamplervp;
                    }
                    else
                    {
                        rtParameter->samplerSetter = setSamplerfp;
                    }
                    rtParameter->glType = _RGLCgGetSamplerGLTypeFromCgType(( CGtype )( parameterResource->type ) );
                }
                else
                {
                    if ( profileIndex == VERTEX_PROFILE_INDEX )
                    {
                        if ( parameterResource->type == CGP_SCF_BOOL )
                        {
                        }
                        else if ( !( parameterEntry->flags & CGPF_SHARED ) )
                        {
                            int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
                            int registerCount = arrayCount * registerStride;
                            if ( parameterEntry->flags & CGP_CONTIGUOUS )
                            {
                                memset( RGLCurrent, 0, 4*( 4*registerCount + 3 ) );
                                GCM_FUNC_BUFFERED( cellGcmSetVertexProgramParameterBlock, RGLCurrent, parameterResource->resource, registerCount, ( float* )RGLCurrent );
                                rtParameter->pushBufferPointer = RGLCurrent - 4 * registerCount;
                            }
                            else
                            {
                                rtParameter->pushBufferPointer = programPushBuffer;
                                int resourceIndex = parameterResource->resource;
                                for ( int j = 0;j < arrayCount;j++, resourceIndex += registerStride )
                                {
                                    if ( program->resources[resourceIndex] != 0xffff )
                                    {
                                        memset( RGLCurrent, 0, 4*( 4*registerStride + 3 ) );
                                        GCM_FUNC_BUFFERED( cellGcmSetVertexProgramParameterBlock, RGLCurrent, program->resources[resourceIndex], registerStride, ( float* )RGLCurrent );
                                        *( programPushBuffer++ ) = ( unsigned int* )( RGLCurrent - 4 * registerStride );
                                    }
                                    else
                                    {
                                        *( programPushBuffer++ ) = ( unsigned int* )currentStorage;
                                        currentStorage += 4 * registerStride;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if ( parameterEntry->flags & CGPF_SHARED )
                        {
                            rtParameter->pushBufferPointer = NULL;
                        }
                        else
                        {
                            int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
                            int registerCount = arrayCount * registerStride;
                            rtParameter->pushBufferPointer = currentStorage;
                            currentStorage += 4 * registerCount;
                        }
                    }

                    switch ( parameterResource->type )
                    {
                        case CG_FLOAT:
                        case CG_FLOAT1: case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4:
                        {
                            unsigned int floatCount = _RGLCountFloatsInCgType(( CGtype )parameterResource->type );
                            rtParameter->setterIndex = setVectorTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][floatCount - 1];
                        }
                        break;
                        case CG_FLOAT1x1: case CG_FLOAT1x2: case CG_FLOAT1x3: case CG_FLOAT1x4:
                        case CG_FLOAT2x1: case CG_FLOAT2x2: case CG_FLOAT2x3: case CG_FLOAT2x4:
                        case CG_FLOAT3x1: case CG_FLOAT3x2: case CG_FLOAT3x3: case CG_FLOAT3x4:
                        case CG_FLOAT4x1: case CG_FLOAT4x2: case CG_FLOAT4x3: case CG_FLOAT4x4:
                            rtParameter->setterrIndex = setMatrixTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][_RGLGetTypeRowCount(( CGtype )parameterResource->type ) - 1][_RGLGetTypeColCount(( CGtype )parameterResource->type ) - 1][ROW_MAJOR];
                            rtParameter->settercIndex = setMatrixTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][_RGLGetTypeRowCount(( CGtype )parameterResource->type ) - 1][_RGLGetTypeColCount(( CGtype )parameterResource->type ) - 1][COL_MAJOR];
                            break;
                        case CG_SAMPLER1D: case CG_SAMPLER2D: case CG_SAMPLER3D: case CG_SAMPLERRECT: case CG_SAMPLERCUBE:
                            break;
                        case CGP_SCF_BOOL:
                            break;
                        case CG_HALF:
                        case CG_HALF1: case CG_HALF2: case CG_HALF3: case CG_HALF4:
                        case CG_INT:
                        case CG_INT1: case CG_INT2: case CG_INT3: case CG_INT4:
                        case CG_BOOL:
                        case CG_BOOL1: case CG_BOOL2: case CG_BOOL3: case CG_BOOL4:
                        case CG_FIXED:
                        case CG_FIXED1: case CG_FIXED2: case CG_FIXED3: case CG_FIXED4:
                        {
                            unsigned int floatCount = _RGLCountFloatsInCgType(( CGtype )parameterResource->type );
                            rtParameter->setterIndex = setVectorTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][floatCount - 1];
                        }
                        break;
                        case CG_HALF1x1: case CG_HALF1x2: case CG_HALF1x3: case CG_HALF1x4:
                        case CG_HALF2x1: case CG_HALF2x2: case CG_HALF2x3: case CG_HALF2x4:
                        case CG_HALF3x1: case CG_HALF3x2: case CG_HALF3x3: case CG_HALF3x4:
                        case CG_HALF4x1: case CG_HALF4x2: case CG_HALF4x3: case CG_HALF4x4:
                        case CG_INT1x1: case CG_INT1x2: case CG_INT1x3: case CG_INT1x4:
                        case CG_INT2x1: case CG_INT2x2: case CG_INT2x3: case CG_INT2x4:
                        case CG_INT3x1: case CG_INT3x2: case CG_INT3x3: case CG_INT3x4:
                        case CG_INT4x1: case CG_INT4x2: case CG_INT4x3: case CG_INT4x4:
                        case CG_BOOL1x1: case CG_BOOL1x2: case CG_BOOL1x3: case CG_BOOL1x4:
                        case CG_BOOL2x1: case CG_BOOL2x2: case CG_BOOL2x3: case CG_BOOL2x4:
                        case CG_BOOL3x1: case CG_BOOL3x2: case CG_BOOL3x3: case CG_BOOL3x4:
                        case CG_BOOL4x1: case CG_BOOL4x2: case CG_BOOL4x3: case CG_BOOL4x4:
                        case CG_FIXED1x1: case CG_FIXED1x2: case CG_FIXED1x3: case CG_FIXED1x4:
                        case CG_FIXED2x1: case CG_FIXED2x2: case CG_FIXED2x3: case CG_FIXED2x4:
                        case CG_FIXED3x1: case CG_FIXED3x2: case CG_FIXED3x3: case CG_FIXED3x4:
                        case CG_FIXED4x1: case CG_FIXED4x2: case CG_FIXED4x3: case CG_FIXED4x4:
                            rtParameter->setterrIndex = setMatrixTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][_RGLGetTypeRowCount(( CGtype )parameterResource->type ) - 1][_RGLGetTypeColCount(( CGtype )parameterResource->type ) - 1][ROW_MAJOR];
                            rtParameter->settercIndex = setMatrixTypeIndex[( containerEntry->flags&CGP_ARRAY ) ? 1 : 0][( containerEntry->flags&CGPF_SHARED ) ? 1 : 0][profileIndex][_RGLGetTypeRowCount(( CGtype )parameterResource->type ) - 1][_RGLGetTypeColCount(( CGtype )parameterResource->type ) - 1][COL_MAJOR];
                            break;
			case CG_STRING:
			    break;
                        default:
                            break;
                    }
                }
            }
        }
        else
        {
            if (( parameterEntry->flags & CGPV_MASK ) == CGPV_UNIFORM )
            {
                if ( parameterEntry->flags & CGP_ARRAY )
                    continue;

                const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
                switch ( parameterResource->type )
                {
                    case CG_FLOAT:
                    case CG_FLOAT1: case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4:
                        rtParameter->setterIndex = _cgIgnoreSetParamIndex;
                        break;
                    case CG_FLOAT1x1: case CG_FLOAT1x2: case CG_FLOAT1x3: case CG_FLOAT1x4:
                    case CG_FLOAT2x1: case CG_FLOAT2x2: case CG_FLOAT2x3: case CG_FLOAT2x4:
                    case CG_FLOAT3x1: case CG_FLOAT3x2: case CG_FLOAT3x3: case CG_FLOAT3x4:
                    case CG_FLOAT4x1: case CG_FLOAT4x2: case CG_FLOAT4x3: case CG_FLOAT4x4:
                        rtParameter->setterrIndex = _cgIgnoreSetParamIndex;
                        rtParameter->settercIndex = _cgIgnoreSetParamIndex;
                        break;
                    case CG_SAMPLER1D: case CG_SAMPLER2D: case CG_SAMPLER3D: case CG_SAMPLERRECT: case CG_SAMPLERCUBE:
                        rtParameter->samplerSetter = _cgIgnoreSetParamIndex;
                        break;
                    case CGP_SCF_BOOL:
                        break;
		    case CG_HALF:
                    case CG_HALF1: case CG_HALF2: case CG_HALF3: case CG_HALF4:
		    case CG_INT:
                    case CG_INT1: case CG_INT2: case CG_INT3: case CG_INT4:
		    case CG_BOOL:
                    case CG_BOOL1: case CG_BOOL2: case CG_BOOL3: case CG_BOOL4:
		    case CG_FIXED:
                    case CG_FIXED1: case CG_FIXED2: case CG_FIXED3: case CG_FIXED4:
                        rtParameter->setterIndex = _cgIgnoreSetParamIndex;
                        break;
                    case CG_HALF1x1: case CG_HALF1x2: case CG_HALF1x3: case CG_HALF1x4:
                    case CG_HALF2x1: case CG_HALF2x2: case CG_HALF2x3: case CG_HALF2x4:
                    case CG_HALF3x1: case CG_HALF3x2: case CG_HALF3x3: case CG_HALF3x4:
                    case CG_HALF4x1: case CG_HALF4x2: case CG_HALF4x3: case CG_HALF4x4:
                    case CG_INT1x1: case CG_INT1x2: case CG_INT1x3: case CG_INT1x4:
                    case CG_INT2x1: case CG_INT2x2: case CG_INT2x3: case CG_INT2x4:
                    case CG_INT3x1: case CG_INT3x2: case CG_INT3x3: case CG_INT3x4:
                    case CG_INT4x1: case CG_INT4x2: case CG_INT4x3: case CG_INT4x4:
                    case CG_BOOL1x1: case CG_BOOL1x2: case CG_BOOL1x3: case CG_BOOL1x4:
                    case CG_BOOL2x1: case CG_BOOL2x2: case CG_BOOL2x3: case CG_BOOL2x4:
                    case CG_BOOL3x1: case CG_BOOL3x2: case CG_BOOL3x3: case CG_BOOL3x4:
                    case CG_BOOL4x1: case CG_BOOL4x2: case CG_BOOL4x3: case CG_BOOL4x4:
                    case CG_FIXED1x1: case CG_FIXED1x2: case CG_FIXED1x3: case CG_FIXED1x4:
                    case CG_FIXED2x1: case CG_FIXED2x2: case CG_FIXED2x3: case CG_FIXED2x4:
                    case CG_FIXED3x1: case CG_FIXED3x2: case CG_FIXED3x3: case CG_FIXED3x4:
                    case CG_FIXED4x1: case CG_FIXED4x2: case CG_FIXED4x3: case CG_FIXED4x4:
                        rtParameter->setterrIndex = _cgIgnoreSetParamIndex;
                        rtParameter->settercIndex = _cgIgnoreSetParamIndex;
                        break;
		    case CG_STRING:
			break;
                    default:
                        break;
                }
            }
        }
        arrayCount = 1;
        containerEntry = NULL;
    }

    if ( bufferSize > 0 )
    {
      int nopCount = ( program->constantPushBuffer + bufferSize ) - ( unsigned int * )RGLCurrent;
      GCM_FUNC_BUFFERED( cellGcmSetNopCommand, RGLCurrent, nopCount );
    }
}

static int _RGLGenerateProgram( _CGprogram *program, int profileIndex, const CgProgramHeader *programHeader, const void *ucode, const CgParameterTableHeader *parameterHeader,
                           const CgParameterEntry *parameterEntries, const char *stringTable, const float *defaultValues )
{
    CGprofile profile = ( CGprofile )programHeader->profile;

    int need_swapping = 0;

    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    if (( profile != CG_PROFILE_SCE_FP_TYPEB ) && ( profile != CG_PROFILE_SCE_VP_TYPEB ) &&
            ( profile != CG_PROFILE_SCE_FP_RSX ) && ( profile != CG_PROFILE_SCE_VP_RSX ) )
    {
        need_swapping = 1;
    }

    int invalidProfile = 0;
    switch ( ENDIAN_32( profile, need_swapping ) )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
            if ( profileIndex != VERTEX_PROFILE_INDEX ) invalidProfile = 1;
            break;
        case CG_PROFILE_SCE_FP_TYPEB:
            if ( profileIndex != FRAGMENT_PROFILE_INDEX ) invalidProfile = 1;
            break;
        case CG_PROFILE_SCE_VP_RSX:
            if ( profileIndex != VERTEX_PROFILE_INDEX ) invalidProfile = 1;
            break;
        case CG_PROFILE_SCE_FP_RSX:
            if ( profileIndex != FRAGMENT_PROFILE_INDEX ) invalidProfile = 1;
            break;
        default:
            invalidProfile = 1;
            break;
    }
    if ( invalidProfile )
    {
        _RGLCgRaiseError( CG_UNKNOWN_PROFILE_ERROR );
        return 0;
    }

    memcpy( &program->header, programHeader, sizeof( program->header ) );

    program->ucode = ucode;
    program->loadProgramId = GMM_ERROR;
    program->loadProgramOffset = 0;

    size_t parameterSize = parameterHeader->entryCount * sizeof( CgRuntimeParameter );
    void *memoryBlock;
    if ( parameterSize )
        memoryBlock = memalign( 16, parameterSize );
    else
        memoryBlock = NULL;

    program->rtParametersCount = parameterHeader->entryCount;
    program->runtimeParameters = ( CgRuntimeParameter* )memoryBlock;

    if ( parameterEntries == NULL )
        parameterEntries = ( CgParameterEntry* )( parameterHeader + 1 );

    program->parametersEntries = parameterEntries;
    program->parameterResources = ( char* )( program->parametersEntries + program->rtParametersCount );
    program->resources = ( unsigned short* )(( char* )program->parametersEntries + ( parameterHeader->resourceTableOffset - sizeof( CgParameterTableHeader ) ) );
    program->defaultValuesIndexCount = parameterHeader->defaultValueIndexCount;
    program->defaultValuesIndices = ( CgParameterDefaultValue* )(( char* )program->parametersEntries + ( parameterHeader->defaultValueIndexTableOffset - sizeof( CgParameterTableHeader ) ) );

    program->defaultValues = NULL;

    memset( program->runtimeParameters, 0, parameterHeader->entryCount*sizeof( CgRuntimeParameter ) );

    program->stringTable = stringTable;
    program->defaultValues = defaultValues;

    _RGLCreatePushBuffer( program );

    int count = program->defaultValuesIndexCount;
    if ( profileIndex == FRAGMENT_PROFILE_INDEX)
    {
	    for ( int i = 0; i < count;i++ )
	    {
		    const void * __restrict pItemDefaultValues = program->defaultValues + program->defaultValuesIndices[i].defaultValueIndex;
		    const unsigned int * itemDefaultValues = ( const unsigned int * )pItemDefaultValues;
		    int index = ( int )program->defaultValuesIndices[i].entryIndex;

		    CgRuntimeParameter *rtParameter = program->runtimeParameters + index;
		    float *hostMemoryCopy = ( float * )rtParameter->pushBufferPointer;

		    if ( hostMemoryCopy )
		    {
			    const CgParameterEntry *parameterEntry = rtParameter->parameterEntry;
			    int arrayCount = 1;
			    if ( parameterEntry->flags & CGP_ARRAY )
			    {
				    const CgParameterArray *parameterArray = _RGLGetParameterArray( program, parameterEntry );
				    arrayCount = _RGLGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount );
				    i++;
				    parameterEntry++;
			    }
			    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
			    unsigned short *resource = program->resources + parameterResource->resource + 1;
			    int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
			    int registerCount = arrayCount * registerStride;
			    int j;
			    for ( j = 0;j < registerCount;j++ )
			    {
				    unsigned short embeddedConstCount = *( resource++ );
				    int k;
				    for ( k = 0;k < embeddedConstCount;k++ )
				    {
					    unsigned short ucodePatchOffset = *( resource )++;
					    unsigned int *dst = ( unsigned int* )(( char* )program->ucode + ucodePatchOffset );
					    dst[0] = SWAP_IF_BIG_ENDIAN( itemDefaultValues[0] );
					    dst[1] = SWAP_IF_BIG_ENDIAN( itemDefaultValues[1] );
					    dst[2] = SWAP_IF_BIG_ENDIAN( itemDefaultValues[2] );
					    dst[3] = SWAP_IF_BIG_ENDIAN( itemDefaultValues[3] );
				    }
				    memcpy(( void* )hostMemoryCopy, ( void* )itemDefaultValues, sizeof( float )*4 );
				    hostMemoryCopy += 4;
				    itemDefaultValues += 4;
				    resource++;
			    }
		    }
	    }
    }
    else
    {
	    for ( int i = 0; i < count;i++ )
	    {
		    int index = ( int )program->defaultValuesIndices[i].entryIndex;
		    CgRuntimeParameter *rtParameter = program->runtimeParameters + index;

		    int arrayCount = 1;
		    const CgParameterEntry *parameterEntry = rtParameter->parameterEntry;
		    bool isArray = false;
		    if ( parameterEntry->flags & CGP_ARRAY )
		    {
			    isArray = true;
			    const CgParameterArray *parameterArray = _RGLGetParameterArray( program, parameterEntry );
			    arrayCount = _RGLGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount );
			    parameterEntry++;
			    rtParameter++;
		    }

		    if ( rtParameter->pushBufferPointer )
		    {
			    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
			    const float *itemDefaultValues = program->defaultValues + program->defaultValuesIndices[i].defaultValueIndex;
			    int registerStride = isMatrix(( CGtype )parameterResource->type ) ? _RGLGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
			    if ( parameterEntry->flags & CGP_CONTIGUOUS )
				    memcpy( rtParameter->pushBufferPointer, itemDefaultValues, arrayCount * registerStride *4*sizeof( float ) );
			    else
			    {
				    unsigned int *pushBufferPointer = (( unsigned int * )rtParameter->pushBufferPointer );
				    for ( int j = 0;j < arrayCount;j++ )
				    {
					    unsigned int *pushBufferAddress = isArray ? ( *( unsigned int** )pushBufferPointer ) : pushBufferPointer;
					    memcpy( pushBufferAddress, itemDefaultValues, registerStride*4*sizeof( float ) );
					    pushBufferPointer += isArray ? 1 : 3 + registerStride * 4;
					    itemDefaultValues += 4 * registerStride;
				    }
			    }
		    }
	    }
    }

    program->loadProgramId = GMM_ERROR;
    program->loadProgramOffset = 0;
    if ( profileIndex == FRAGMENT_PROFILE_INDEX )
    {
        int loaded = _RGLLoadFPShader( program );
        if ( ! loaded )
        {
            _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
            return 0;
        }
    }

    program->programGroup = NULL;
    program->programIndexInGroup = -1;

    return 1;
}


int _RGLPlatformGenerateFragmentProgram( _CGprogram *program, const CgProgramHeader *programHeader, const void *ucode,
                                        const CgParameterTableHeader *parameterHeader, const char *stringTable, const float *defaultValues )
{
    return _RGLGenerateProgram( program, FRAGMENT_PROFILE_INDEX, programHeader, ucode, parameterHeader, NULL, stringTable, defaultValues );

}

void _RGLPlatformVertexProgramErase( void* platformProgram )
{
    _CGprogram* program = ( _CGprogram* )platformProgram;
    if ( program->runtimeParameters )
        free( program->runtimeParameters );

    if ( program->memoryBlock )
        free( program->memoryBlock );

    if ( program->samplerIndices )
    {
        free( program->samplerValuesLocation );
        free( program->samplerIndices );
        free( program->samplerUnits );
    }

    if ( program->constantPushBufferPointers )
        free( program->constantPushBufferPointers );
}

void _RGLPlatformProgramErase( void* platformProgram )
{
    _CGprogram* program = ( _CGprogram* )platformProgram;

    if ( program->loadProgramId != GMM_ERROR )
        _RGLUnloadFPShader( program );

    if ( program->runtimeParameters )
    {
        int i;
        int count = ( int )program->rtParametersCount;
        for ( i = 0;i < count;i++ )
        {
            _RGLEraseName( &_CurrentContext->cgParameterNameSpace, ( jsName )program->runtimeParameters[i].id );
        }
        free( program->runtimeParameters );
    }

    if ( program->memoryBlock )
        free( program->memoryBlock );

    if ( program->samplerIndices )
    {
        free( program->samplerValuesLocation );
        free( program->samplerIndices );
        free( program->samplerUnits );
    }

    if ( program->constantPushBufferPointers )
        free( program->constantPushBufferPointers );
}


CGbool _RGLPlatformSupportsFragmentProgram( CGprofile p )
{
    if ( p == CG_PROFILE_SCE_FP_TYPEB )
        return CG_TRUE;
    if ( CG_PROFILE_SCE_FP_RSX == p )
        return CG_TRUE;
    return CG_FALSE;
}

CGprofile _RGLPlatformGetLatestProfile( CGGLenum profile_type )
{
    switch ( profile_type )
    {
        case CG_GL_VERTEX:
            return CG_PROFILE_SCE_VP_RSX;
        case CG_GL_FRAGMENT:
            return CG_PROFILE_SCE_FP_RSX;
        default:
            break;
    }
    return CG_PROFILE_UNKNOWN;
}

int _RGLPlatformCopyProgram( _CGprogram* source, _CGprogram* destination )
{
    CgParameterTableHeader parameterHeader;
    parameterHeader.entryCount = source->rtParametersCount;
    parameterHeader.resourceTableOffset = ( uintptr_t )(( char* )source->resources - ( char* )source->parametersEntries + sizeof( CgParameterTableHeader ) );
    parameterHeader.defaultValueIndexCount = source->defaultValuesIndexCount;
    parameterHeader.defaultValueIndexTableOffset = ( uintptr_t )(( char* )source->defaultValuesIndices - ( char* )source->parametersEntries + sizeof( CgParameterTableHeader ) );

    int profileIndex;

    switch ( source->header.profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
            profileIndex = VERTEX_PROFILE_INDEX;
            break;

        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
            profileIndex = FRAGMENT_PROFILE_INDEX;
            break;
        default:
            return 0;
    }
    return _RGLGenerateProgram( destination, profileIndex, &source->header, source->ucode, &parameterHeader, source->parametersEntries, source->stringTable, source->defaultValues );
}






static char *_RGLPlatformBufferObjectMap( jsBufferObject* bufferObject, GLenum access )
{
    RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

    if ( jsBuffer->mapCount++ == 0 )
    {
        if ( access == GL_WRITE_ONLY )
        {
            _RGLAllocateBuffer( bufferObject );
            if ( jsBuffer->pool == _RGL_SURFACE_POOL_NONE )
            {
                _RGLSetError( GL_OUT_OF_MEMORY );
                return NULL;
            }
	}
	else
	{
		cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
		_RGLFifoFinish( &_RGLState.fifo );
	}

        jsBuffer->mapAccess = access;

        if ( jsBuffer->mapAccess != GL_READ_ONLY )
	{
		RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;
		++driver->flushBufferCount;
	}

	GmmBaseBlock    *pBaseBlock = (GmmBaseBlock *)jsBuffer->bufferId;

	if (!pBaseBlock->isTile)
	{
		GmmBlock *pBlock = (GmmBlock *)jsBuffer->bufferId;

		pBlock->isPinned = 1;
	}
    }

    return gmmIdToAddress( jsBuffer->bufferId );
}

static jsFramebuffer* _RGLCreateFramebuffer( void )
{
   jsFramebuffer* framebuffer = new jsPlatformFramebuffer();
   return framebuffer;
}

static void _RGLDestroyFramebuffer( jsFramebuffer* framebuffer )
{
   delete framebuffer;
}

static void _RGLPlatformDestroyTexture( jsTexture* texture )
{
    if ( !texture->referenceBuffer )
    {
        RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
        if ( gcmTexture->pbo != NULL )
        {
            _RGLFreeBufferObject( gcmTexture->pbo );
            gcmTexture->pbo = NULL;
            gcmTexture->pool = _RGL_SURFACE_POOL_NONE;
            gcmTexture->gpuAddressId = GMM_ERROR;
            gcmTexture->gpuAddressIdOffset = 0;
            gcmTexture->gpuSize = 0;
        }

        _RGLPlatformFreeGcmTexture( texture );
    }
    _RGLTextureTouchFBOs( texture );
}

// Get size of texture in GPU layout
static inline GLuint _RGLPlatformTextureGetGPUSize( const jsTexture* texture )
{
    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
    return _RGLPad( gcmTexture->gpuLayout.baseHeight * gcmTexture->gpuLayout.pitch, 1);
}

#include <cell/gcm/gcm_method_data.h>

static void _RGLPlatformValidateTextureStage( int unit, jsTexture* texture )
{
    if ( RGL_UNLIKELY( texture->revalidate ) )
    {
        _RGLPlatformValidateTextureResources( texture );
    }

    GLboolean isCompleteCache = texture->isComplete;

    if ( RGL_LIKELY( isCompleteCache ) )
    {
        RGLTexture *platformTexture = ( RGLTexture * )texture->platformTexture;
	const GLuint imageOffset = gmmIdToOffset(platformTexture->gpuAddressId) + platformTexture->gpuAddressIdOffset;
	platformTexture->gcmTexture.offset = imageOffset; 

	cellGcmSetTexture( &_RGLState.fifo, unit, &platformTexture->gcmTexture);
	CellGcmContextData *gcm_context = (CellGcmContextData*)&_RGLState.fifo;
	cellGcmReserveMethodSizeInline(gcm_context, 11);
	uint32_t *current = gcm_context->current;
	current[0] = CELL_GCM_METHOD_HEADER_TEXTURE_OFFSET(unit, 8);
	current[1] = CELL_GCM_METHOD_DATA_TEXTURE_OFFSET(platformTexture->gcmTexture.offset);
	current[2] = CELL_GCM_METHOD_DATA_TEXTURE_FORMAT(platformTexture->gcmTexture.location,
			CELL_GCM_FALSE, 
			CELL_GCM_TEXTURE_DIMENSION_2,
			platformTexture->gcmTexture.format,
			1);
	current[3] = CELL_GCM_METHOD_DATA_TEXTURE_ADDRESS(
			CELL_GCM_TEXTURE_BORDER, /* wrapS */
			CELL_GCM_TEXTURE_BORDER, /* wrapT */
			CELL_GCM_TEXTURE_BORDER, /* wrapR */
			CELL_GCM_TEXTURE_UNSIGNED_REMAP_NORMAL, /* unsignedRemap */
			CELL_GCM_TEXTURE_ZFUNC_NEVER,
			platformTexture->gcmMethods.address.gamma,
			0);
	current[4] = CELL_GCM_METHOD_DATA_TEXTURE_CONTROL0(CELL_GCM_TRUE,
			0, /* minLOD */
			256000, /* maxLOD */
			CELL_GCM_TEXTURE_MAX_ANISO_1);
	current[5] = platformTexture->gcmTexture.remap;
	current[6] = CELL_GCM_METHOD_DATA_TEXTURE_FILTER(
			(platformTexture->gcmMethods.filter.bias & 0x1fff),
			platformTexture->gcmMethods.filter.min,
			platformTexture->gcmMethods.filter.mag,
			CELL_GCM_TEXTURE_CONVOLUTION_QUINCUNX); /* filter */
	current[7] = CELL_GCM_METHOD_DATA_TEXTURE_IMAGE_RECT(
			platformTexture->gcmTexture.height,
			platformTexture->gcmTexture.width);
	current[8] = CELL_GCM_METHOD_DATA_TEXTURE_BORDER_COLOR(0);
	current[9] = CELL_GCM_METHOD_HEADER_TEXTURE_CONTROL3(unit,1);
	current[10] = CELL_GCM_METHOD_DATA_TEXTURE_CONTROL3(
			platformTexture->gcmTexture.pitch,
			1); /* depth */
	gcm_context->current = &current[11];
    }
    else
    {
        //printf("RGL WARN: Texture bound to unit %d is incomplete.\n", unit);
	GLuint remap = CELL_GCM_REMAP_MODE(
			CELL_GCM_TEXTURE_REMAP_ORDER_XYXY,
			CELL_GCM_TEXTURE_REMAP_FROM_A,
			CELL_GCM_TEXTURE_REMAP_FROM_R,
			CELL_GCM_TEXTURE_REMAP_FROM_G,
			CELL_GCM_TEXTURE_REMAP_FROM_B,
			CELL_GCM_TEXTURE_REMAP_ONE,
			CELL_GCM_TEXTURE_REMAP_ZERO,
			CELL_GCM_TEXTURE_REMAP_ZERO,
			CELL_GCM_TEXTURE_REMAP_ZERO );

	cellGcmSetTextureControlInline( &_RGLState.fifo, unit, CELL_GCM_FALSE, 0, 0, 0);
	cellGcmSetTextureRemapInline( &_RGLState.fifo, unit, remap);
    }


}

static GLenum _RGLPlatformChooseInternalFormat( GLenum internalFormat )
{
    switch ( internalFormat )
    {
        case GL_ALPHA:
        case GL_ALPHA4:
        case GL_ALPHA8:
            return RGL_ALPHA8;
        case GL_RGB10:
        case GL_RGB10_A2:
        case GL_RGB12:
        case GL_RGB16:
            return RGL_FLOAT_RGBX32;
        case GL_RGBA12:
        case GL_RGBA16:
            return RGL_FLOAT_RGBA32;
        case 3:
        case GL_R3_G3_B2:
        case GL_RGB4:
        case GL_RGB:
        case GL_RGB8:
        case RGL_RGBX8:
            return RGL_RGBX8;
        case 4:
        case GL_RGBA2:
        case GL_RGBA4:
        case GL_RGBA8:
        case GL_RGBA:
            return RGL_RGBA8;
        case GL_RGB5_A1:
            return RGL_RGB5_A1_SCE;
        case GL_RGB5:
            return RGL_RGB565_SCE;
        case GL_BGRA:
        case RGL_BGRA8:
            return RGL_BGRA8;
        case GL_ARGB_SCE:
            return RGL_ARGB8;
        default:
            return GL_INVALID_ENUM;
    }
    return GL_INVALID_ENUM;
}

static void _RGLPlatformExpandInternalFormat( GLenum internalFormat, GLenum *format, GLenum *type )
{
    switch ( internalFormat )
    {
        case RGL_ALPHA8:
            *format = GL_ALPHA;
            *type = GL_UNSIGNED_BYTE;
            break;
        case RGL_ARGB8:
            *format = GL_BGRA;
            *type = GL_UNSIGNED_INT_8_8_8_8_REV;
            break;
        case RGL_RGB5_A1_SCE:
            *format = GL_RGBA;
            *type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
            break;
        case RGL_RGB565_SCE:
            *format = GL_RGB;
            *type = GL_UNSIGNED_SHORT_5_6_5_REV;
            break;
        default:
            return;
    }
}

static GLenum _RGLPlatformChooseInternalStorage( jsImage* image, GLenum internalFormat )
{
	image->storageSize = 0;

	GLenum platformInternalFormat = _RGLPlatformChooseInternalFormat( internalFormat );

	if ( platformInternalFormat == GL_INVALID_ENUM )
		return GL_INVALID_ENUM;

	image->internalFormat = platformInternalFormat;
	_RGLPlatformExpandInternalFormat( platformInternalFormat, &image->format, &image->type );

	image->storageSize = _RGLGetStorageSize(
			image->format, image->type,
			image->width, image->height, 1 );

	return GL_NO_ERROR;
}

static inline GLuint _RGLGetBufferObjectOrigin( GLuint buffer )
{
    jsBufferObject *bufferObject = _RGLGetBufferObject( _CurrentContext, buffer );
    RGLBufferObject *gcmBuffer = ( RGLBufferObject * ) & bufferObject->platformBufferObject;
    return gcmBuffer->bufferId;
}

static void _RGLSetImage( jsImage *image, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei alignment, GLenum format, GLenum type, const GLvoid *pixels )
{
    image->width = width;
    image->height = height;
    image->alignment = alignment;

    image->xblk = 0;
    image->yblk = 0;

    image->xstride = 0;
    image->ystride = 0;

    image->format = 0;
    image->type = 0;
    image->internalFormat = 0;
    const GLenum status = _RGLPlatformChooseInternalStorage( image, internalFormat );
    (( void )status );

    image->data = NULL;
    image->mallocData = NULL;
    image->mallocStorageSize = 0;

    image->isSet = GL_TRUE;

    if ( image->xstride == 0 )
	    image->xstride = _RGLGetPixelSize( image->format, image->type );
    if ( image->ystride == 0 )
	    image->ystride = image->width * image->xstride;

    if ( pixels )
    {
        _RGLImageAllocCPUStorage( image );
        if ( !image->data )
            return;

        jsRaster raster;
        raster.format = format;
        raster.type = type;
        raster.width = width;
        raster.height = height;
        raster.data = ( void * )pixels;

        raster.xstride = _RGLGetPixelSize( raster.format, raster.type );
        raster.ystride = ( raster.width * raster.xstride + alignment - 1 ) / alignment * alignment;

        _RGLRasterToImage( &raster, image);
        image->dataState = _RGL_IMAGE_DATASTATE_HOST;
    }
    else
        image->dataState = _RGL_IMAGE_DATASTATE_UNSET;
}

static GLboolean _RGLPlatformTexturePBOImage(
    jsTexture* texture,
    jsImage* image,
    GLint internalFormat,
    GLsizei width, GLsizei height,
    GLenum format, GLenum type,
    const GLvoid *offset )
{
    PSGLcontext*	LContext = _CurrentContext;

    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;

    image->dataState = _RGL_IMAGE_DATASTATE_UNSET;
    if ( gcmTexture->pbo != NULL )
        _RGLPlatformDropTexture( texture );

    _RGLSetImage( image, internalFormat, width, height, 1 /* depth */, LContext->unpackAlignment, format, type, NULL );

    if ( LContext->PixelUnpackBuffer == 0 )
        return GL_FALSE;

    const GLuint pboPitch = _RGLPad(
                                _RGLGetStorageSize( format, type, width, 1, 1 ),
                                LContext->unpackAlignment );
    if (( pboPitch&3 ) != 0 )
    {
        printf("RGL WARN: PBO image pitch not a multiple of 4, using slow path.\n" );
        return GL_FALSE;
    }

    GLuint gpuId = _RGLGetBufferObjectOrigin( LContext->PixelUnpackBuffer );
    GLuint gpuIdOffset = (( GLubyte* )offset - ( GLubyte* )NULL );

    if ( gmmIdToOffset(gpuId)+gpuIdOffset & 63 )
    {
        printf("RGL: PBO offset not 64-byte aligned, using slow path.\n");
        return GL_FALSE;
    }

    GLboolean formatOK = GL_FALSE;
    switch ( internalFormat )
    {
        case 4:
        case GL_RGBA:
        case GL_RGBA8:
            if ( format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 )
                formatOK = GL_TRUE;
            break;
        case GL_ALPHA:
        case GL_ALPHA8:
            if ( format == GL_ALPHA && type == GL_UNSIGNED_BYTE )
                formatOK = GL_TRUE;
            break;
        case GL_ARGB_SCE:
            if ( format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV )
                formatOK = GL_TRUE;
            break;
        default:
            formatOK = GL_FALSE;
    }

    if ( !formatOK )
    {
        printf("RGL: PBO format/type requires conversion to texture internal format, using slow path.\n");
        return GL_FALSE;
    }

    if ( !_RGLTextureIsValid( texture ) )
    {
        printf("RGL: PBO transfering to incomplete texture, using slow path.\n");
        return GL_FALSE;
    }

    RGLTextureLayout newLayout;
    _RGLPlatformChooseGPUFormatAndLayout( texture, GL_TRUE, pboPitch, &newLayout );

    jsBufferObject* bufferObject = _RGLGetBufferObject( LContext, LContext->PixelUnpackBuffer );
    if ( newLayout.pitch != 0 && !bufferObject->mapped )
    {
        gcmTexture->gpuLayout = newLayout;
        if ( gcmTexture->gpuAddressId != GMM_ERROR && gcmTexture->pbo == NULL )
        {
            _RGLPlatformFreeGcmTexture( texture );
        }
        gcmTexture->pbo = bufferObject;
        gcmTexture->gpuAddressId = gpuId; 
        gcmTexture->gpuAddressIdOffset = gpuIdOffset;
        gcmTexture->pool = _RGL_SURFACE_POOL_LINEAR;
        gcmTexture->gpuSize = _RGLPlatformTextureGetGPUSize( texture );
        ++bufferObject->refCount;
    }
    else
    {
        const GLuint bytesPerPixel = newLayout.pixelBits / 8;
        RGLSurface src =
	{
source:		_RGL_SURFACE_SOURCE_PBO,
		width:		image->width,
		height:		image->height,
		bpp:		bytesPerPixel,
		pitch:		pboPitch,
		format:		newLayout.internalFormat,
		pool:		_RGL_SURFACE_POOL_LINEAR,
		ppuData:    NULL,
		dataId:     gpuId,
		dataIdOffset: gpuIdOffset, 
	};

        texture->revalidate |= _RGL_TEXTURE_REVALIDATE_LAYOUT;
        _RGLPlatformValidateTextureResources( texture );

        RGLSurface dst =
	{
source:		_RGL_SURFACE_SOURCE_TEXTURE,
		width:		image->width,
		height:		image->height,
		bpp:		bytesPerPixel,
		pitch:		gcmTexture->gpuLayout.pitch,
		format:		gcmTexture->gpuLayout.internalFormat,
		pool:		gcmTexture->pool,
		ppuData:    NULL,
		dataId:     gcmTexture->gpuAddressId,
		dataIdOffset: gcmTexture->gpuAddressIdOffset,
	};

	_RGLTransferDataVidToVid( dst.dataId, dst.dataIdOffset, dst.pitch ? dst.pitch : (dst.bpp * dst.width), 0, 0, src.dataId, src.dataIdOffset, src.pitch ? src.pitch : (src.bpp * src.width), 0, 0, width, height, src.bpp );
    }

    _RGLImageFreeCPUStorage( image );
    image->dataState = _RGL_IMAGE_DATASTATE_GPU;

    texture->revalidate &= ~( _RGL_TEXTURE_REVALIDATE_LAYOUT | _RGL_TEXTURE_REVALIDATE_IMAGES );
    texture->revalidate |= _RGL_TEXTURE_REVALIDATE_PARAMETERS;
    _RGLTextureTouchFBOs( texture );

    return GL_TRUE;
}

static GLboolean _RGLPlatformTextureReference( jsTexture *texture, GLuint pitch, jsBufferObject *bufferObject, GLintptr offset )
{
    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;

    RGLTextureLayout newLayout;
    _RGLPlatformChooseGPUFormatAndLayout( texture, GL_TRUE, pitch, &newLayout );

    texture->isRenderTarget = GL_TRUE;

    if ( gcmTexture->gpuAddressId != GMM_ERROR )
        _RGLPlatformDestroyTexture( texture );

    RGLBufferObject *gcmBuffer = ( RGLBufferObject * ) & bufferObject->platformBufferObject;

    gcmTexture->gpuLayout = newLayout;
    gcmTexture->pool = gcmBuffer->pool;
    gcmTexture->gpuAddressId = gcmBuffer->bufferId;
    gcmTexture->gpuAddressIdOffset = offset;
    gcmTexture->gpuSize = _RGLPad( newLayout.baseHeight * newLayout.pitch, 1);

    texture->revalidate &= ~( _RGL_TEXTURE_REVALIDATE_LAYOUT | _RGL_TEXTURE_REVALIDATE_IMAGES );
    texture->revalidate |= _RGL_TEXTURE_REVALIDATE_PARAMETERS;
    _RGLTextureTouchFBOs( texture );
    return GL_TRUE;
}

static inline void _RGLSetColorDepthBuffers( RGLRenderTarget *rt, RGLRenderTargetEx const * const args )
{
    CellGcmSurface *   grt = &rt->gcmRenderTarget;

    rt->colorBufferCount = args->colorBufferCount;

    GLuint oldHeight;
    GLuint oldyInverted;

    oldyInverted = rt->yInverted;
    oldHeight = rt->gcmRenderTarget.height;

    GLuint i;

    for ( i = 0; i < args->colorBufferCount; i++ )
    {
        if ( args->colorPitch[i] == 0 )
        {
            grt->colorOffset[i] = 0;
            grt->colorPitch[i] = 0x200;
            grt->colorLocation[i] = CELL_GCM_LOCATION_LOCAL;
        }
        else
        {
            if ( args->colorId[i] != GMM_ERROR )
            {
                if ( gmmIdIsMain(args->colorId[i]) )
                    grt->colorLocation[i] = CELL_GCM_LOCATION_MAIN;
                else
                    grt->colorLocation[i] = CELL_GCM_LOCATION_LOCAL;
                grt->colorOffset[i] = gmmIdToOffset(args->colorId[i]) + args->colorIdOffset[i];
                grt->colorPitch[i] = args->colorPitch[i];
            }
        }
    }

    for ( ; i < RGL_SETRENDERTARGET_MAXCOUNT; i++ )
    {
        grt->colorOffset[i] = grt->colorOffset[0];
        grt->colorPitch[i]   = grt->colorPitch[0];
        grt->colorLocation[i] = grt->colorLocation[0];
    }

    rt->yInverted = args->yInverted;
    grt->x        = args->xOffset; 
    grt->y        = args->yOffset; 
    grt->width    = args->width;
    grt->height   = args->height;

    if (( grt->height != oldHeight ) | ( rt->yInverted != oldyInverted ) )
    {
	    RGLViewportState *v = &_RGLState.state.viewport;
	    _RGLFifoGlViewport( v->x, v->y, v->w, v->h );
    }
}

static inline void _RGLSetColorDepthFormats( RGLRenderTarget *rt, RGLRenderTargetEx const * const args )
{
	CellGcmSurface *   grt = &rt->gcmRenderTarget;

	grt->colorFormat = CELL_GCM_SURFACE_A8R8G8B8;
	grt->depthFormat = CELL_GCM_SURFACE_Z24S8;
	grt->depthLocation = CELL_GCM_LOCATION_LOCAL;
	grt->depthOffset = 0;
	grt->depthPitch = 64;
}

static inline void _RGLSetTarget( RGLRenderTarget *rt, RGLRenderTargetEx const * const args )
{
    CellGcmSurface *   grt = &rt->gcmRenderTarget;

    switch ( rt->colorBufferCount )
    {
        case 0:
            grt->colorTarget = CELL_GCM_SURFACE_TARGET_NONE;
            break;
        case 1:
            grt->colorTarget = CELL_GCM_SURFACE_TARGET_1;
            break;
        case 2:
            grt->colorTarget = CELL_GCM_SURFACE_TARGET_MRT1;
            break;
        case 3:
            grt->colorTarget = CELL_GCM_SURFACE_TARGET_MRT2;
            break;
        case 4:
            grt->colorTarget = CELL_GCM_SURFACE_TARGET_MRT3;
            break;
        default:
            break;
    }
}

void _RGLFifoGlSetRenderTarget( RGLRenderTargetEx const * const args )
{
    RGLRenderTarget *rt = &_RGLState.renderTarget;
    CellGcmSurface *   grt = &_RGLState.renderTarget.gcmRenderTarget;

    _RGLSetColorDepthBuffers( rt, args );
    _RGLSetColorDepthFormats( rt, args );

    grt->antialias = CELL_GCM_SURFACE_CENTER_1;

    cellGcmSetAntiAliasingControlInline( &_RGLState.fifo, CELL_GCM_FALSE, CELL_GCM_FALSE, CELL_GCM_FALSE, 0xFFFF);

    grt->type = CELL_GCM_SURFACE_PITCH;
    _RGLSetTarget( rt, args );

    cellGcmSetSurfaceInline( &_RGLState.fifo, grt);
    cellGcmSetDepthTestEnableInline( &_RGLState.fifo, CELL_GCM_FALSE);
}

void _RGLSetError( GLenum error )
{
}

GLAPI GLenum APIENTRY glGetError()
{
    if ( !_CurrentContext )
	return GL_INVALID_OPERATION;
    else
    {
        GLenum error = _CurrentContext->error;

        _CurrentContext->error = GL_NO_ERROR;
        return error;
    }
}

static uint32_t * _RGLFifoWaitForFreeSpace( RGLFifo *fifo, GLuint spaceInWords )
{
   if ( fifo->current + spaceInWords + 1024 > fifo->end )
      _RGLOutOfSpaceCallback( fifo, spaceInWords );

   return _RGLState.fifo.current;
}

static inline void _RGLPushProgramPushBuffer( _CGprogram * cgprog )
{
	_RGLFifoWaitForFreeSpace( &_RGLState.fifo,  cgprog->constantPushBufferWordSize + 4 + 32); 
	uint32_t padding_in_word = ( ( 0x10-(((uint32_t)_RGLState.fifo.current)&0xf))&0xf )>>2;
	uint32_t padded_size = ( ((cgprog->constantPushBufferWordSize)<<2) + 0xf )&~0xf;
	cellGcmSetNopCommandUnsafeInline( &_RGLState.fifo, padding_in_word);
	memcpy16(_RGLState.fifo.current, cgprog->constantPushBuffer, padded_size);
	_RGLState.fifo.current+=cgprog->constantPushBufferWordSize;
}

static GLuint _RGLValidateStates( void )
{
    PSGLcontext* LContext = _CurrentContext;
    RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;

    LContext->needValidate &= PSGL_VALIDATE_ALL;
    GLuint  dirty = LContext->needValidate;
    GLuint  needValidate = LContext->needValidate;

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_FRAMEBUFFER ) )
    {
        _RGLValidateFramebuffer();

        needValidate = LContext->needValidate;
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_TEXTURES_USED ) )
    {
        long unitInUseCount = LContext->BoundFragmentProgram->samplerCount;
        const GLuint* unitsInUse = LContext->BoundFragmentProgram->samplerUnits;

	for ( long i = 0; i < unitInUseCount; ++i )
	{
		long unit = unitsInUse[i];
		jsTexture* texture = LContext->TextureImageUnits[unit].currentTexture;

		_RGLPlatformValidateTextureStage( unit, texture );
	}
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_VERTEX_PROGRAM ) )
    {
	    const void *header = LContext->BoundVertexProgram;
	    const _CGprogram *vs = ( const _CGprogram* ) header;

	    __dcbt(vs->ucode);
	    __dcbt(((uint8_t*)vs->ucode)+128);
	    __dcbt(((uint8_t*)vs->ucode)+256);
	    __dcbt(((uint8_t*)vs->ucode)+384);

	    CellCgbVertexProgramConfiguration conf;
	    conf.instructionSlot = vs->header.vertexProgram.instructionSlot;
	    conf.instructionCount = vs->header.instructionCount;
	    conf.registerCount = vs->header.vertexProgram.registerCount;
	    conf.attributeInputMask = vs->header.attributeInputMask;

	    _RGLFifoWaitForFreeSpace( &_RGLState.fifo, 7 + 5 * conf.instructionCount );

	    cellGcmSetVertexProgramLoadInline( &_RGLState.fifo, &conf, vs->ucode);
	    cellGcmSetUserClipPlaneControlInline( &_RGLState.fifo, 0, 0, 0, 0, 0, 0 );

	    RGLInterpolantState *s = &_RGLState.state.interpolant;
	    s->vertexProgramAttribMask = vs->header.vertexProgram.attributeOutputMask;

	    cellGcmSetVertexAttribOutputMaskInline( &_RGLState.fifo,  s->vertexProgramAttribMask & s->fragmentProgramAttribMask);

	    _CGprogram *program = ( _CGprogram* )vs;
	    int count = program->defaultValuesIndexCount;
	    for ( int i = 0; i < count; i++ )
	    {
		    const CgParameterEntry *parameterEntry = program->parametersEntries + program->defaultValuesIndices[i].entryIndex;
		    if (( parameterEntry->flags & CGPF_REFERENCED ) && ( parameterEntry->flags & CGPV_MASK ) == CGPV_CONSTANT )
		    {
			    const float *itemDefaultValues = program->defaultValues + program->defaultValuesIndices[i].defaultValueIndex;
			    const GLfloat *value = itemDefaultValues;
			    const CgParameterResource *parameterResource = _RGLGetParameterResource( program, parameterEntry );
			    if ( parameterResource->resource != ( unsigned short ) - 1 )
			    {
				    switch ( parameterResource->type )
				    {
					    case CG_FLOAT:
					    case CG_FLOAT1:
					    case CG_FLOAT2:
					    case CG_FLOAT3:
					    case CG_FLOAT4:
						    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 1, value );
						    break;
					    case CG_FLOAT4x4:
						    {
							    GLfloat v2[16];
							    v2[0] = value[0];v2[1] = value[4];v2[2] = value[8];v2[3] = value[12];
							    v2[4] = value[1];v2[5] = value[5];v2[6] = value[9];v2[7] = value[13];
							    v2[8] = value[2];v2[9] = value[6];v2[10] = value[10];v2[11] = value[14];
							    v2[12] = value[3];v2[13] = value[7];v2[14] = value[11];v2[15] = value[15];
							    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 4, v2 );
						    }
						    break;
					    case CG_FLOAT3x3:
						    {
							    GLfloat v2[12];
							    v2[0] = value[0];v2[1] = value[3];v2[2] = value[6];v2[3] = 0;
							    v2[4] = value[1];v2[5] = value[4];v2[6] = value[7];v2[7] = 0;
							    v2[8] = value[2];v2[9] = value[5];v2[10] = value[8];v2[11] = 0;
							    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 3, v2 );
						    }
						    break;
					    case CG_HALF:
					    case CG_HALF1:
					    case CG_HALF2:
					    case CG_HALF3:
					    case CG_HALF4:
					    case CG_INT:
					    case CG_INT1:
					    case CG_INT2:
					    case CG_INT3:
					    case CG_INT4:
					    case CG_BOOL:
					    case CG_BOOL1:
					    case CG_BOOL2:
					    case CG_BOOL3:
					    case CG_BOOL4:
					    case CG_FIXED:
					    case CG_FIXED1:
					    case CG_FIXED2:
					    case CG_FIXED3:
					    case CG_FIXED4:
						    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 1, value );
						    break;
					    case CG_HALF4x4:
					    case CG_INT4x4:
					    case CG_BOOL4x4:
					    case CG_FIXED4x4:
						    {
							    GLfloat v2[16];
							    v2[0] = value[0];v2[1] = value[4];v2[2] = value[8];v2[3] = value[12];
							    v2[4] = value[1];v2[5] = value[5];v2[6] = value[9];v2[7] = value[13];
							    v2[8] = value[2];v2[9] = value[6];v2[10] = value[10];v2[11] = value[14];
							    v2[12] = value[3];v2[13] = value[7];v2[14] = value[11];v2[15] = value[15];
							    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 4, v2 );
						    }
						    break;
					    case CG_HALF3x3:
					    case CG_INT3x3:
					    case CG_BOOL3x3:
					    case CG_FIXED3x3:
						    {
							    GLfloat v2[12];
							    v2[0] = value[0];v2[1] = value[3];v2[2] = value[6];v2[3] = 0;
							    v2[4] = value[1];v2[5] = value[4];v2[6] = value[7];v2[7] = 0;
							    v2[8] = value[2];v2[9] = value[5];v2[10] = value[8];v2[11] = 0;
							    cellGcmSetVertexProgramParameterBlockInline( &_RGLState.fifo, parameterResource->resource, 3, v2 );
						    }
						    break;
					    default:
						    break;
				    }
			    }
		    }
	    }

	    if(!(LContext->needValidate & PSGL_VALIDATE_VERTEX_CONSTANTS) && LContext->BoundVertexProgram->parentContext)
	    {
		    cellGcmSetTransformBranchBitsInline( &_RGLState.fifo, LContext->BoundVertexProgram->controlFlowBools | LContext->BoundVertexProgram->parentContext->controlFlowBoolsShared );

		    _RGLPushProgramPushBuffer( LContext->BoundVertexProgram );
	    }
    }

    if ( RGL_LIKELY( needValidate & PSGL_VALIDATE_VERTEX_CONSTANTS ) && LContext->BoundVertexProgram->parentContext)
    {
	    cellGcmSetTransformBranchBitsInline( &_RGLState.fifo, LContext->BoundVertexProgram->controlFlowBools | LContext->BoundVertexProgram->parentContext->controlFlowBoolsShared );

	    _RGLPushProgramPushBuffer( LContext->BoundVertexProgram );
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_VERTEX_TEXTURES_USED ) )
    {
	    for ( int unit = 0; unit < _RGL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; ++unit )
	    {
		    jsTexture *texture = LContext->VertexTextureImages[unit];
		    if ( texture )
			    if ( RGL_UNLIKELY( texture->revalidate ) )
				    _RGLPlatformValidateTextureResources( texture );

		    cellGcmSetVertexTextureAddressInline( &_RGLState.fifo, unit, CELL_GCM_TEXTURE_WRAP, CELL_GCM_TEXTURE_WRAP);
		    cellGcmSetVertexTextureControlInline( &_RGLState.fifo, unit, GL_FALSE, 0, 256);
		    cellGcmSetVertexTextureFilterInline( &_RGLState.fifo, unit, 0);
	    }
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_FRAGMENT_PROGRAM ) )
    {
	    _CGprogram *program = LContext->BoundFragmentProgram;

	    const GLvoid *header = program;
	    const _CGprogram *ps = ( const _CGprogram * )header;

	    CellCgbFragmentProgramConfiguration conf;

	    conf.offset = gmmIdToOffset(ps->loadProgramId) + ps->loadProgramOffset;

	    RGLInterpolantState *s = &_RGLState.state.interpolant;
	    s->fragmentProgramAttribMask |= ps->header.attributeInputMask | CELL_GCM_ATTRIB_OUTPUT_MASK_POINTSIZE;

	    conf.attributeInputMask = s->vertexProgramAttribMask & s->fragmentProgramAttribMask;
	    conf.texCoordsInputMask = ps->header.fragmentProgram.texcoordInputMask;
	    conf.texCoords2D = ps->header.fragmentProgram.texcoord2d;
	    conf.texCoordsCentroid = ps->header.fragmentProgram.texcoordCentroid;

	    int fragmentControl = ( 1 << 15 ) | ( 1 << 10 );
	    fragmentControl |= ps->header.fragmentProgram.flags & CGF_DEPTHREPLACE ? 0xE : 0x0;
	    fragmentControl |= ps->header.fragmentProgram.flags & CGF_OUTPUTFROMH0 ? 0x00 : 0x40;
	    fragmentControl |= ps->header.fragmentProgram.flags & CGF_PIXELKILL ? 0x80 : 0x00;

	    conf.fragmentControl  = fragmentControl;
	    conf.registerCount = ps->header.fragmentProgram.registerCount < 2 ? 2 : ps->header.fragmentProgram.registerCount;

	    uint32_t controlTxp = _CurrentContext->AllowTXPDemotion; 
	    conf.fragmentControl &= ~CELL_GCM_MASK_SET_SHADER_CONTROL_CONTROL_TXP; 
	    conf.fragmentControl |= controlTxp << CELL_GCM_SHIFT_SET_SHADER_CONTROL_CONTROL_TXP; 

	    cellGcmSetFragmentProgramLoadInline( &_RGLState.fifo, &conf);
	    cellGcmSetZMinMaxControlInline( &_RGLState.fifo, ( ps->header.fragmentProgram.flags & CGF_DEPTHREPLACE ) ? CELL_GCM_FALSE : CELL_GCM_TRUE, CELL_GCM_FALSE, CELL_GCM_FALSE );


	    driver->fpLoadProgramId = program->loadProgramId;
	    driver->fpLoadProgramOffset = program->loadProgramOffset;
    }
	
    if ( RGL_LIKELY(( needValidate & ~( PSGL_VALIDATE_TEXTURES_USED |
                                       PSGL_VALIDATE_VERTEX_PROGRAM |
                                       PSGL_VALIDATE_VERTEX_CONSTANTS |
                                       PSGL_VALIDATE_VERTEX_TEXTURES_USED |
                                       PSGL_VALIDATE_FRAGMENT_PROGRAM ) ) == 0 ) )
    {
        LContext->needValidate = 0;
        return dirty;
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_BLENDING ) )
    {
	if ((LContext->Blending || LContext->BlendingMrt[0] || LContext->BlendingMrt[1] || LContext->BlendingMrt[2]))
	{
		GLuint hwColor;
		cellGcmSetBlendEnableInline( &_RGLState.fifo, LContext->Blending);
		cellGcmSetBlendEnableMrtInline( &_RGLState.fifo, LContext->BlendingMrt[0], LContext->BlendingMrt[1], LContext->BlendingMrt[2] );

		RGL_CALC_COLOR_LE_ARGB8( &hwColor, RGL_CLAMPF_01(LContext->BlendColor.R), RGL_CLAMPF_01(LContext->BlendColor.G), RGL_CLAMPF_01(LContext->BlendColor.B), RGL_CLAMPF_01(LContext->BlendColor.A) );
		cellGcmSetBlendColorInline( &_RGLState.fifo, hwColor, hwColor);
		cellGcmSetBlendEquationInline( &_RGLState.fifo, (RGLEnum)LContext->BlendEquationRGB, (RGLEnum)LContext->BlendEquationAlpha );
		cellGcmSetBlendFuncInline( &_RGLState.fifo, (RGLEnum)LContext->BlendFactorSrcRGB, (RGLEnum)LContext->BlendFactorDestRGB, (RGLEnum)LContext->BlendFactorSrcAlpha, (RGLEnum)LContext->BlendFactorDestAlpha);
	}
	else 
	{
		cellGcmSetBlendEnableInline( &_RGLState.fifo, CELL_GCM_FALSE);
		cellGcmSetBlendEnableMrtInline( &_RGLState.fifo, CELL_GCM_FALSE, CELL_GCM_FALSE, CELL_GCM_FALSE );
	}
    }

    if ( RGL_UNLIKELY( needValidate & PSGL_VALIDATE_SHADER_SRGB_REMAP ) )
    {
	cellGcmSetFragmentProgramGammaEnableInline( &_RGLState.fifo, LContext->ShaderSRGBRemap ? CELL_GCM_TRUE : CELL_GCM_FALSE);

	LContext->needValidate &= ~PSGL_VALIDATE_SHADER_SRGB_REMAP;
    }

    LContext->needValidate = 0;
    return dirty;
}

PSGLcontext *psglGetCurrentContext()
{
    return _CurrentContext;
}


const GLfloat _RGLIdentityMatrixf[ELEMENTS_IN_MATRIX] =
{
	1.f, 0.f, 0.f, 0.f,
	0.f, 1.f, 0.f, 0.f,
	0.f, 0.f, 1.f, 0.f,
	0.f, 0.f, 0.f, 1.f
};

static void _RGLMatrixStackReset( jsMatrixStack* LMatrixStack )
{
    LMatrixStack->MatrixStackPtr = 0;
    memcpy( LMatrixStack->MatrixStackf, _RGLIdentityMatrixf, jsMATRIX_SIZEf );
    LMatrixStack->dirty = GL_TRUE;
}

static void _RGLResetContext( PSGLcontext *LContext )
{
    _RGLMatrixStackReset( &( LContext->ModelViewMatrixStack ) );
    _RGLMatrixStackReset( &( LContext->ProjectionMatrixStack ) );
    _RGLTexNameSpaceResetNames( &LContext->textureNameSpace );
    _RGLTexNameSpaceResetNames( &LContext->bufferObjectNameSpace );
    _RGLTexNameSpaceResetNames( &LContext->framebufferNameSpace );
    _RGLTexNameSpaceResetNames( &LContext->attribSetNameSpace );

    LContext->InverseModelViewValid = GL_FALSE;
    LContext->ScalingFactor = 1.f;

    LContext->ViewPort.X = 0;
    LContext->ViewPort.Y = 0;
    LContext->ViewPort.XSize = 0;
    LContext->ViewPort.YSize = 0;

    LContext->ClearColor.R = 0.f;
    LContext->ClearColor.G = 0.f;
    LContext->ClearColor.B = 0.f;
    LContext->ClearColor.A = 0.f;
    LContext->AccumClearColor.R = 0.f;
    LContext->AccumClearColor.G = 0.f;
    LContext->AccumClearColor.B = 0.f;
    LContext->AccumClearColor.A = 0.f;

    LContext->ShaderSRGBRemap = GL_FALSE;

    LContext->Blending = GL_FALSE;
    LContext->BlendingMrt[0] = GL_FALSE;
    LContext->BlendingMrt[1] = GL_FALSE;
    LContext->BlendingMrt[2] = GL_FALSE;
    LContext->BlendColor.R = 0.0f;
    LContext->BlendColor.G = 0.0f;
    LContext->BlendColor.B = 0.0f;
    LContext->BlendColor.A = 0.0f;
    LContext->BlendEquationRGB = GL_FUNC_ADD;
    LContext->BlendEquationAlpha = GL_FUNC_ADD;
    LContext->BlendFactorSrcRGB = GL_ONE;
    LContext->BlendFactorDestRGB = GL_ZERO;
    LContext->BlendFactorSrcAlpha = GL_ONE;
    LContext->BlendFactorDestAlpha = GL_ZERO;

    LContext->Dithering = GL_TRUE;

    for ( int i = 0;i < _RGL_MAX_TEXTURE_COORDS;++i )
    {
        jsTextureCoordsUnit *tu = LContext->TextureCoordsUnits + i;
        tu->revalidate = 0;
        _RGLMatrixStackReset( &( tu->TextureMatrixStack ) );
    }
    for ( int i = 0;i < _RGL_MAX_TEXTURE_IMAGE_UNITS;++i )
    {
        jsTextureImageUnit *tu = LContext->TextureImageUnits + i;
        tu->bound2D = 0;

        tu->fragmentTarget = 0;

        tu->envMode = GL_MODULATE;
        tu->envColor.R = 0.f;
        tu->envColor.G = 0.f;
        tu->envColor.B = 0.f;
        tu->envColor.A = 0.f;

        tu->currentTexture = NULL;
    }
    for ( int i = 0;i < _RGL_MAX_VERTEX_TEXTURE_IMAGE_UNITS;++i )
    {
        LContext->VertexTextureImages[i] = NULL;
    }

    LContext->ActiveTexture = 0;
    LContext->CurrentImageUnit = LContext->TextureImageUnits;
    LContext->CurrentCoordsUnit = LContext->TextureCoordsUnits;

    LContext->packAlignment = 4;
    LContext->unpackAlignment = 4;

    LContext->CS_ActiveTexture = 0;

    _RGLResetAttributeState( &LContext->defaultAttribs0 );
    LContext->attribs = &LContext->defaultAttribs0;
    LContext->attribSetName = 0;
    LContext->attribSetDirty = GL_FALSE;

    LContext->framebuffer = 0;

    LContext->VertexProgram = GL_FALSE;
    LContext->BoundVertexProgram = 0;

    LContext->FragmentProgram = GL_FALSE;
    LContext->BoundFragmentProgram = 0;

    LContext->ArrayBuffer = 0;
    LContext->PixelUnpackBuffer = 0;
    LContext->TextureBuffer = 0;

    LContext->VSync = GL_FALSE;

    LContext->AllowTXPDemotion = GL_FALSE; 
}

static void _RGLMatrixStackInit( jsMatrixStack* LMatrixStack, GLuint depth )
{
    LMatrixStack->MatrixStackf = ( GLfloat * )malloc( jsMATRIX_SIZEf * depth );
    if ( !LMatrixStack->MatrixStackf ) return;

    _RGLMatrixStackReset( LMatrixStack );
}

static jsTexture *_RGLAllocateTexture (void)
{
    GLuint size = sizeof( jsTexture ) + sizeof( RGLTexture);
    jsTexture *texture = ( jsTexture * )malloc( size );
    memset( texture, 0, size );
    texture->target = 0;
    texture->minFilter = GL_NEAREST_MIPMAP_LINEAR;
    texture->magFilter = GL_LINEAR;
    texture->gammaRemap = 0;
    texture->usage = 0;
    texture->isRenderTarget = GL_FALSE;
    texture->image = NULL;
    texture->isComplete = GL_FALSE;
    texture->imageCount = 0;
    texture->revalidate = 0;
    texture->referenceBuffer = NULL;
    new( &texture->framebuffers ) RGL::Vector<jsFramebuffer *>();
    RGLTexture *gcmTexture = ( RGLTexture * )texture->platformTexture;
    memset( gcmTexture, 0, sizeof( RGLTexture ) );
    gcmTexture->gpuAddressId = GMM_ERROR;
    return texture;
}

static void _RGLFreeTexture( jsTexture *texture )
{
    _RGLTextureTouchFBOs( texture );
    texture->framebuffers.~Vector<jsFramebuffer *>();
    if ( texture->image )
    {
	    for ( GLuint i = 0;i < texture->imageCount;++i )
	    {
		    jsImage *image = texture->image + i;
		    _RGLImageFreeCPUStorage( image );
	    }
	    if(texture->image != NULL)
		    free( texture->image );
    }
    if ( texture->referenceBuffer )
    {
        texture->referenceBuffer->textureReferences.removeElement( texture );
    }
    _RGLPlatformDestroyTexture( texture );
    if(texture != NULL)
	    free( texture );
}

PSGLcontext* psglCreateContext (void)
{
    PSGLcontext* LContext = ( PSGLcontext* )malloc( sizeof( PSGLcontext ) );
    if ( !LContext ) return NULL;

    memset( LContext, 0, sizeof( PSGLcontext ) );

    LContext->error = GL_NO_ERROR;
    LContext->MatrixMode = GL_MODELVIEW;

    _RGLMatrixStackInit( &( LContext->ModelViewMatrixStack ), _RGL_MAX_MODELVIEW_STACK_DEPTH );
    if ( !LContext->ModelViewMatrixStack.MatrixStackf )
    {
        psglDestroyContext( LContext );
        return NULL;
    }
    _RGLMatrixStackInit( &( LContext->ProjectionMatrixStack ), _RGL_MAX_PROJECTION_STACK_DEPTH );
    if ( !LContext->ProjectionMatrixStack.MatrixStackf )
    {
        psglDestroyContext( LContext );
        return NULL;
    }

    for ( int i = 0; i < _RGL_MAX_TEXTURE_COORDS; i++ )
    {
        _RGLMatrixStackInit( &( LContext->TextureCoordsUnits[i].TextureMatrixStack ), _RGL_MAX_TEXTURE_STACK_DEPTH );
        if ( !LContext->TextureCoordsUnits[i].TextureMatrixStack.MatrixStackf )
        {
            psglDestroyContext( LContext );
            return NULL;
        }
    }

    _RGLTexNameSpaceInit( &LContext->textureNameSpace, ( jsTexNameSpaceCreateFunction )_RGLAllocateTexture, ( jsTexNameSpaceDestroyFunction )_RGLFreeTexture );

    for ( int i = 0;i < _RGL_MAX_TEXTURE_IMAGE_UNITS;++i )
    {
        jsTextureImageUnit *tu = LContext->TextureImageUnits + i;

        tu->default2D = _RGLAllocateTexture();
        if ( !tu->default2D )
        {
            psglDestroyContext( LContext );
            return NULL;
        }
        tu->default2D->target = GL_TEXTURE_2D;
    }

    _RGLTexNameSpaceInit( &LContext->bufferObjectNameSpace, ( jsTexNameSpaceCreateFunction )_RGLCreateBufferObject, ( jsTexNameSpaceDestroyFunction )_RGLFreeBufferObject );
    _RGLTexNameSpaceInit( &LContext->framebufferNameSpace, ( jsTexNameSpaceCreateFunction )_RGLCreateFramebuffer, ( jsTexNameSpaceDestroyFunction )_RGLDestroyFramebuffer );
    _RGLTexNameSpaceInit( &LContext->attribSetNameSpace, ( jsTexNameSpaceCreateFunction )_RGLCreateAttribSet, ( jsTexNameSpaceDestroyFunction )_RGLDestroyAttribSet );

    LContext->needValidate = 0;
    LContext->everAttached = 0;

    LContext->RGLcgLastError = CG_NO_ERROR;
    LContext->RGLcgErrorCallbackFunction = NULL;
    LContext->RGLcgContextHead = ( CGcontext )NULL;
	
    _RGLInitNameSpace( &LContext->cgProgramNameSpace );
    _RGLInitNameSpace( &LContext->cgParameterNameSpace );
    _RGLInitNameSpace( &LContext->cgContextNameSpace );

    _RGLResetContext( LContext );

    if ( _RGLContextCreateHook ) _RGLContextCreateHook( LContext );

    return( LContext );
}

void  psglResetCurrentContext (void)
{
    PSGLcontext *context = _CurrentContext;
    _RGLResetContext( context );
    context->needValidate |= PSGL_VALIDATE_ALL;
}

static void _RGLMatrixStackClear( jsMatrixStack* LMatrixStack )
{
    if ( LMatrixStack->MatrixStackf ) free( LMatrixStack->MatrixStackf );
    LMatrixStack->MatrixStackf = NULL;
    LMatrixStack->MatrixStackPtr = 0;
    LMatrixStack->dirty = GL_FALSE;
}

void  psglDestroyContext( PSGLcontext* LContext )
{
    if ( _CurrentContext == LContext )
    {
	cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
        _RGLFifoFinish( &_RGLState.fifo );
    }

    while ( LContext->RGLcgContextHead != ( CGcontext )NULL )
    {
        PSGLcontext* current = _CurrentContext;
        _CurrentContext = LContext;
        cgDestroyContext( LContext->RGLcgContextHead );
        _CurrentContext = current;
    }
    _RGLFreeNameSpace( &LContext->cgProgramNameSpace );
    _RGLFreeNameSpace( &LContext->cgParameterNameSpace );
    _RGLFreeNameSpace( &LContext->cgContextNameSpace );

    if ( _RGLContextDestroyHook ) _RGLContextDestroyHook( LContext );

    _RGLMatrixStackClear( &( LContext->ModelViewMatrixStack ) );
    _RGLMatrixStackClear( &( LContext->ProjectionMatrixStack ) );

    for ( int i = 0; i < _RGL_MAX_TEXTURE_COORDS; i++ )
        _RGLMatrixStackClear( &( LContext->TextureCoordsUnits[i].TextureMatrixStack ) );

    for ( int i = 0; i < _RGL_MAX_TEXTURE_IMAGE_UNITS; ++i )
    {
        jsTextureImageUnit* tu = LContext->TextureImageUnits + i;
        if ( tu->default2D ) _RGLFreeTexture( tu->default2D );
    }

    _RGLTexNameSpaceFree( &LContext->textureNameSpace );
    _RGLTexNameSpaceFree( &LContext->bufferObjectNameSpace );
    _RGLTexNameSpaceFree( &LContext->framebufferNameSpace );
    _RGLTexNameSpaceFree( &LContext->attribSetNameSpace );

    if ( _CurrentContext == LContext )
    {
        psglMakeCurrent( NULL, NULL );
    }

    if(LContext != NULL)
	    free( LContext );
}

void _RGLAttachContext( PSGLdevice *device, PSGLcontext* context )
{
	if ( !context->everAttached )
	{
		context->ViewPort.XSize = device->deviceParameters.width;
		context->ViewPort.YSize = device->deviceParameters.height;
		context->everAttached = GL_TRUE;
		_RGLFifoGlViewport(context->ViewPort.X, context->ViewPort.Y, 
				context->ViewPort.XSize, context->ViewPort.YSize, 0.0f, 1.0f);
	}
	context->needValidate = PSGL_VALIDATE_ALL;

	for ( int unit = 0;unit < _RGL_MAX_TEXTURE_UNITS;unit++ )
		context->TextureCoordsUnits[unit].TextureMatrixStack.dirty = GL_TRUE;

	context->ModelViewMatrixStack.dirty = GL_TRUE;
	context->ProjectionMatrixStack.dirty = GL_TRUE;
	context->attribs->DirtyMask = ( 1 << _RGL_MAX_VERTEX_ATTRIBS ) - 1;
}

GLAPI void APIENTRY glGetFloatv( GLenum pname, GLfloat* params )
{
    PSGLcontext* LContext = _CurrentContext;
    jsMatrixStack* LMatrixStack = NULL;
    GLfloat *LMatrix = NULL;

    switch ( pname )
    {
        case GL_MODELVIEW_MATRIX:
            jsContextGetMatrixf( LContext, GL_MODELVIEW, LMatrixStack, LMatrix );
            break;

        case GL_PROJECTION_MATRIX:
            jsContextGetMatrixf( LContext, GL_PROJECTION, LMatrixStack, LMatrix );
            break;

        case GL_TEXTURE_MATRIX:
            jsContextGetMatrixf( LContext, GL_TEXTURE, LMatrixStack, LMatrix );
            break;
        case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
	    return;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
    memcpy( params, LMatrixStack->MatrixStackf + LMatrixStack->MatrixStackPtr * ELEMENTS_IN_MATRIX, jsMATRIX_SIZEf );
}

GLAPI void APIENTRY glEnable( GLenum cap )
{
    PSGLcontext* LContext = _CurrentContext;

    switch ( cap )
    {
        case GL_SHADER_SRGB_REMAP_SCE:
            LContext->ShaderSRGBRemap = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_SHADER_SRGB_REMAP;
            break;
        case GL_BLEND:
            LContext->Blending = GL_TRUE;
            LContext->BlendingMrt[0] = GL_TRUE;
            LContext->BlendingMrt[1] = GL_TRUE;
            LContext->BlendingMrt[2] = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT0_SCE:
            LContext->Blending = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT1_SCE:
            LContext->BlendingMrt[0] = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT2_SCE:
            LContext->BlendingMrt[1] = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT3_SCE:
            LContext->BlendingMrt[2] = GL_TRUE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;
        case GL_POINT_SMOOTH:
            break;
        case GL_DITHER:
            LContext->Dithering = GL_TRUE;
            break;
        case GL_POINT_SPRITE_OES:
        case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
            break;
        case GL_VSYNC_SCE:
            LContext->VSync = GL_TRUE;
            break;
	case GL_FRAGMENT_PROGRAM_CONTROL_CONTROLTXP_SCE:
	    LContext->AllowTXPDemotion = GL_TRUE;
	    LContext->needValidate |= PSGL_VALIDATE_FRAGMENT_PROGRAM;
	    break; 
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
}

GLAPI void APIENTRY glDisable( GLenum cap )
{
    PSGLcontext* LContext = _CurrentContext;

    switch ( cap )
    {
        case GL_SHADER_SRGB_REMAP_SCE:
            LContext->ShaderSRGBRemap = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_SHADER_SRGB_REMAP;
            break;
        case GL_BLEND:
            LContext->Blending = GL_FALSE;
            LContext->BlendingMrt[0] = GL_FALSE;
            LContext->BlendingMrt[1] = GL_FALSE;
            LContext->BlendingMrt[2] = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT0_SCE:
            LContext->Blending = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT1_SCE:
            LContext->BlendingMrt[0] = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT2_SCE:
            LContext->BlendingMrt[1] = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;

        case GL_BLEND_MRT3_SCE:
            LContext->BlendingMrt[2] = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_BLENDING;
            break;
        case GL_POINT_SMOOTH:
        case GL_LINE_SMOOTH:
            break;
        case GL_DITHER:
            LContext->Dithering = GL_FALSE;
            break;
        case GL_POINT_SPRITE_OES:
        case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
            break;
        case GL_VSYNC_SCE:
            LContext->VSync = GL_FALSE;
            break;
	case GL_FRAGMENT_PROGRAM_CONTROL_CONTROLTXP_SCE:
	    LContext->AllowTXPDemotion = GL_FALSE;
	    LContext->needValidate |= PSGL_VALIDATE_FRAGMENT_PROGRAM;
	    break; 

        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
}

GLAPI void APIENTRY glEnableClientState( GLenum array )
{
    PSGLcontext* LContext = _CurrentContext;

    switch ( array )
    {
        case GL_VERTEX_ARRAY:
            _RGLEnableVertexAttribArrayNV( _RGL_ATTRIB_POSITION_INDEX );
            break;
        case GL_COLOR_ARRAY:
            _RGLEnableVertexAttribArrayNV( _RGL_ATTRIB_PRIMARY_COLOR_INDEX );
            break;
        case GL_NORMAL_ARRAY:
            _RGLEnableVertexAttribArrayNV( _RGL_ATTRIB_NORMAL_INDEX );
            break;
        case GL_TEXTURE_COORD_ARRAY:
            _RGLEnableVertexAttribArrayNV( _RGL_ATTRIB_TEX_COORD0_INDEX + LContext->CS_ActiveTexture );
            break;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
}

GLAPI void APIENTRY glDisableClientState( GLenum array )
{
    PSGLcontext* LContext = _CurrentContext;

    switch ( array )
    {
        case GL_VERTEX_ARRAY:
            _RGLDisableVertexAttribArrayNV( _RGL_ATTRIB_POSITION_INDEX );
            break;
        case GL_COLOR_ARRAY:
            _RGLDisableVertexAttribArrayNV( _RGL_ATTRIB_PRIMARY_COLOR_INDEX );
            break;
        case GL_NORMAL_ARRAY:
            _RGLDisableVertexAttribArrayNV( _RGL_ATTRIB_NORMAL_INDEX );
            break;
        case GL_TEXTURE_COORD_ARRAY:
            _RGLDisableVertexAttribArrayNV( _RGL_ATTRIB_TEX_COORD0_INDEX + LContext->CS_ActiveTexture );
            break;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
}

GLAPI void APIENTRY glFlush()
{
    PSGLcontext *LContext = _CurrentContext;
    RGLFifo *fifo = &_RGLState.fifo;

    if ( RGL_UNLIKELY( LContext->needValidate ) )
	_RGLValidateStates();

    cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);

    _RGLFifoFlush( fifo );
}

GLAPI void APIENTRY glFinish (void)
{
    glFlush();
    cellGcmSetInvalidateVertexCacheInline( &_RGLState.fifo);
    _RGLFifoFinish( &_RGLState.fifo );
}

GLAPI const GLubyte* APIENTRY glGetString( GLenum name )
{
    switch ( name )
    {
        case GL_VENDOR:
            return(( GLubyte* )_RGLVendorString );
        case GL_RENDERER:
            return(( GLubyte* )_RGLRendererString );
        case GL_VERSION:
            return(( GLubyte* )_RGLVersionNumber );
        case GL_EXTENSIONS:
            return(( GLubyte* )_RGLExtensionsString );
        default:
        {
            _RGLSetError( GL_INVALID_ENUM );
            return(( GLubyte* )NULL );
        }
    }
}


void psglInit( PSGLinitOptions* options )
{
	if ( !_RGLInitCompleted )
	{
		int ret = cellSysmoduleLoadModule( CELL_SYSMODULE_GCM_SYS );
		ret = cellSysmoduleLoadModule( CELL_SYSMODULE_RESC );

		_RGLDeviceInit( options );
		_CurrentContext = NULL;
		_CurrentDevice = NULL;
	}

	_RGLInitCompleted = 1;
}

void psglExit (void)
{
    PSGLcontext* LContext = _CurrentContext;
    if ( LContext )
    {
	    glFlush();
	    cellGcmSetInvalidateVertexCacheInline ( &_RGLState.fifo);
	    _RGLFifoFinish( &_RGLState.fifo );

	    psglMakeCurrent( NULL, NULL );
	    _RGLDeviceExit();

	    _CurrentContext = NULL; 

	    _RGLInitCompleted = 0;
    }
}

#undef __STRICT_ANSI__

GLAPI void APIENTRY glLoadIdentity()
{
    PSGLcontext* LContext = _CurrentContext;
    jsMatrixStack* LMatrixStack = NULL;

    jsContextGetMatrixStack(LContext, LContext->MatrixMode, LMatrixStack);
    memcpy( LMatrixStack->MatrixStackf + LMatrixStack->MatrixStackPtr*ELEMENTS_IN_MATRIX, _RGLIdentityMatrixf, jsMATRIX_SIZEf );

    LMatrixStack->dirty = GL_TRUE;
}

GLAPI void APIENTRY glMatrixMode( GLenum mode )
{
    PSGLcontext* LContext = _CurrentContext;
    LContext->MatrixMode = mode;
}

GLAPI void APIENTRY glOrthof( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar )
{
    PSGLcontext* LContext = _CurrentContext;
    jsMatrixStack* LMatrixStack = NULL;
    GLfloat *LMatrix = NULL;

    jsContextGetMatrixStack(LContext, LContext->MatrixMode, LMatrixStack);
    if (LMatrixStack)
	    LMatrix = LMatrixStack->MatrixStackf + LMatrixStack->MatrixStackPtr * ELEMENTS_IN_MATRIX;

    GLfloat L00, L01, L02, L03, L10, L11, L12, L13, L20, L21, L22, L23, L30, L31, L32, L33;


    GLfloat m00 = 2.f / ( right - left );
    GLfloat m03 = -( right + left ) / ( right - left );
    GLfloat m11 = 2.f / ( top - bottom );
    GLfloat m13 = -( top + bottom ) / ( top - bottom );
    GLfloat m22 = -2.f / ( zFar - zNear );
    GLfloat m23 = -( zFar + zNear ) / ( zFar - zNear );

    L00 = LMatrix[0];
    L01 = LMatrix[M01];
    L02 = LMatrix[M02];
    L03 = LMatrix[M03];
    L10 = LMatrix[M10];
    L11 = LMatrix[M11];
    L12 = LMatrix[M12];
    L13 = LMatrix[M13];
    L20 = LMatrix[M20];
    L21 = LMatrix[M21];
    L22 = LMatrix[M22];
    L23 = LMatrix[M23];
    L30 = LMatrix[M30];
    L31 = LMatrix[M31];
    L32 = LMatrix[M32];
    L33 = LMatrix[M33];

    LMatrix[0] = L00 * m00;
    LMatrix[M01] = L01 * m11;
    LMatrix[M02] = L02 * m22;
    LMatrix[M03] = L00 * m03 + L01 * m13 + L02 * m23 + L03;

    LMatrix[M10] = L10 * m00;
    LMatrix[M11] = L11 * m11;
    LMatrix[M12] = L12 * m22;
    LMatrix[M13] = L10 * m03 + L11 * m13 + L12 * m23 + L13;

    LMatrix[M20] = L20 * m00;
    LMatrix[M21] = L21 * m11;
    LMatrix[M22] = L22 * m22;
    LMatrix[M23] = L20 * m03 + L21 * m13 + L22 * m23 + L23;

    LMatrix[M30] = L30 * m00;
    LMatrix[M31] = L31 * m11;
    LMatrix[M32] = L32 * m22;
    LMatrix[M33] = L30 * m03 + L31 * m13 + L32 * m23 + L33;

    LMatrixStack->dirty = GL_TRUE;
    if ( LContext->MatrixMode == GL_MODELVIEW )
        LContext->InverseModelViewValid = GL_FALSE;
}

const uint32_t c_rounded_size_of_RGLDrawParams = (sizeof(jsDrawParams)+0x7f)&~0x7f;
static uint8_t s_dparams_buff[ c_rounded_size_of_RGLDrawParams ] __attribute__((aligned(128)));

int _psglCheckDrawElementsVBOBounds = 0;

GLAPI void APIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )
{
    _RGLVertexAttribPointerNV( _RGL_ATTRIB_POSITION_INDEX, size, type, GL_FALSE, stride, pointer );
}

GLAPI void APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )
{
    PSGLcontext*	LContext = _CurrentContext;

    _RGLVertexAttribPointerNV(
        _RGL_ATTRIB_TEX_COORD0_INDEX + LContext->CS_ActiveTexture,
        size,
        type,
        GL_FALSE,
        stride,
        pointer );
}

GLAPI void APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )
{
    _RGLVertexAttribPointerNV( _RGL_ATTRIB_PRIMARY_COLOR_INDEX, size, type, GL_TRUE, stride, pointer );
}

static GLboolean _RGLPlatformNeedsConversion( const jsAttributeState* as, GLuint index )
{
    const jsAttribute* attrib = as->attrib + index;

    switch ( attrib->clientType )
    {
        case GL_SHORT:
        case GL_HALF_FLOAT_ARB:
        case GL_FLOAT:
        case GL_FIXED_11_11_10_SCE:
            return GL_FALSE;
        case GL_UNSIGNED_BYTE:
            if ( attrib->normalized ||
                 attrib->clientSize == 4 ) 
                 return GL_FALSE; 
            break;
        default:
            break;
    }
    printf("RGL WARN: Attribute %d needs conversion. Slow path ahead.\n", index);
    return GL_TRUE;
}

static int _RGLGetTypeSize( GLenum type )
{
    switch ( type )
    {

#define DECLARE_PACKED_TYPE(REALTYPE,TYPE,N,S1,S2,S3,S4,REV) \
		case TYPE: \
			return sizeof(type_##REALTYPE);
            DECLARE_PACKED_TYPES
#undef DECLARE_PACKED_TYPE

#define DECLARE_UNPACKED_TYPE(TYPE) \
		case TYPE: \
			return sizeof(type_##TYPE);
            DECLARE_UNPACKED_TYPES
#undef DECLARE_UNPACKED_TYPE

        default:
            return 0;
    }
}

void _RGLVertexAttribPointerNV(
    GLuint index,
    GLint fsize,
    GLenum type,
    GLboolean normalized,
    GLsizei stride,
    const GLvoid* pointer )
{
    PSGLcontext*	LContext = _CurrentContext;

    GLsizei defaultStride = 0;
    switch ( type )
    {
        case GL_FLOAT:
        case GL_HALF_FLOAT_ARB:
        case GL_BYTE:
        case GL_UNSIGNED_BYTE:
        case GL_SHORT:
        case GL_FIXED:
            defaultStride = fsize * _RGLGetTypeSize( type );
            break;
        case GL_FIXED_11_11_10_SCE:
            defaultStride = 4;
            break;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }

    jsAttributeState* as = LContext->attribs;
    jsAttribute* attrib = as->attrib + index;
    attrib->clientSize = fsize;
    attrib->clientType = type;
    attrib->clientStride = stride ? stride : defaultStride;
    attrib->clientData = ( void* )pointer;
    GLuint oldArrayBuffer = attrib->arrayBuffer;
    attrib->arrayBuffer = LContext->ArrayBuffer;
    attrib->normalized = normalized;
    RGLBIT_ASSIGN( as->HasVBOMask, index, attrib->arrayBuffer != 0 );
    GLboolean needConvert = _RGLPlatformNeedsConversion( as, index );
    RGLBIT_ASSIGN( as->NeedsConversionMask, index, needConvert );

    RGLBIT_TRUE( as->DirtyMask, index );

    if ( LContext->attribSetName )
    {
        jsAttribSet* attribSet = _RGLGetAttribSet( LContext->attribSetName );

        if ( oldArrayBuffer )
        {
            int refcount = 0;
            for ( unsigned int i = 0; i < _RGL_MAX_VERTEX_ATTRIBS; ++i )
            {
                if ( attribSet->attribs.attrib[i].arrayBuffer == oldArrayBuffer ) ++refcount;
            }
            if ( refcount == 1 ) _RGLGetBufferObject( LContext, oldArrayBuffer )->attribSets.removeElement( attribSet );
        }

        if ( attrib->arrayBuffer )
        {
            _RGLGetBufferObject( LContext, attrib->arrayBuffer )->attribSets.appendUnique( attribSet );
        }

        _RGLAttribSetMarkDirty();
    }
}

void _RGLEnableVertexAttribArrayNV( GLuint index )
{
    PSGLcontext *LContext = _CurrentContext;

    RGLBIT_TRUE( LContext->attribs->EnabledMask, index );
    RGLBIT_TRUE( LContext->attribs->DirtyMask, index );

    if ( LContext->attribSetName )
	    _RGLAttribSetMarkDirty();
}

void _RGLDisableVertexAttribArrayNV( GLuint index )
{
    PSGLcontext *LContext = _CurrentContext;

    RGLBIT_FALSE( LContext->attribs->EnabledMask, index );
    RGLBIT_TRUE( LContext->attribs->DirtyMask, index );

    if ( LContext->attribSetName )
	    _RGLAttribSetMarkDirty();
}

static GLuint _RGLValidateAttributesSlow( jsDrawParams *dparams, GLboolean *isMain )
{
	PSGLcontext*	LContext = _CurrentContext;
	RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;
	jsAttributeState* as = LContext->attribs;

	void* xferBuffer = NULL;
	GLuint xferId = GMM_ERROR;
	GLuint VBOId = GMM_ERROR;
	GLuint gpuOffset;
	if ( RGL_UNLIKELY( dparams->xferTotalSize ) )
	{
		xferId = gmmAlloc(0, dparams->xferTotalSize);
		xferBuffer = gmmIdToAddress(xferId);
	}

	unsigned int needsUpdateMask = ( as->DirtyMask | ( as->EnabledMask & ~as->HasVBOMask ) );

	LContext->attribSetDirty = GL_FALSE;

	if ( needsUpdateMask )
	{
		for ( GLuint i = 0; i < _RGL_MAX_VERTEX_ATTRIBS; ++i )
		{
			if ( ! RGLBIT_GET( needsUpdateMask, i ) )
				continue;

			jsAttribute* attrib = as->attrib + i;
			if ( RGLBIT_GET( as->EnabledMask, i ) )
			{
				const GLsizei stride = attrib->clientStride;
				const GLuint freq = attrib->frequency;

				if ( RGL_UNLIKELY( dparams->attribXferSize[i] ) )
				{
					GLuint maxElements = dparams->firstVertex + dparams->vertexCount;

					GLuint offset;
					if ( RGLBIT_GET( as->ModuloMask, i ) )
						offset = ( maxElements > freq ) ? 0 : dparams->firstVertex * stride;
					else
						offset = ( dparams->firstVertex / freq ) * stride;

					char * b = ( char * )xferBuffer + dparams->attribXferOffset[i];
					memcpy( b + offset,
							( char * )attrib->clientData + offset,
							dparams->attribXferSize[i] - offset );

					*isMain = gmmIdIsMain(xferId);
					gpuOffset = gmmIdToOffset(xferId) + (b - ( char * )xferBuffer);

				}
				else
				{
					VBOId = _RGLGetBufferObjectOrigin( attrib->arrayBuffer );
					*isMain = gmmIdIsMain(VBOId);
					gpuOffset = gmmIdToOffset(VBOId)
						+ (( const GLubyte* )attrib->clientData - ( const GLubyte* )NULL );
				}

				_RGLFifoGlVertexAttribPointer( i, attrib->clientSize,
						( RGLEnum )attrib->clientType, attrib->normalized,
						stride, freq, *isMain, gpuOffset );
			}
			else
			{
				_RGLFifoGlVertexAttribPointer( i, 0, RGL_FLOAT, 0, 0, 0, 0, 0 );
				cellGcmSetVertexData4fInline( &_RGLState.fifo, i,attrib->value);
			}
		}
		cellGcmSetFrequencyDividerOperationInline( &_RGLState.fifo, as->ModuloMask);
		driver->invalidateVertexCache = GL_TRUE;
	}
	as->DirtyMask = 0;

	if ( xferId != GMM_ERROR )
		gmmFree( xferId );

	return 0;
}

GLAPI void APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count )
{
	PSGLcontext*	LContext = _CurrentContext;
	jsAttributeState* as = LContext->attribs;
	RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;
	const GLuint clientSideMask = as->EnabledMask & ~as->HasVBOMask;

	if ( RGL_UNLIKELY( ! RGLBIT_GET( LContext->attribs->EnabledMask, _RGL_ATTRIB_POSITION_INDEX ) ) ) return;

	uint32_t _tmp_clear_loop = c_rounded_size_of_RGLDrawParams>>7;
	do{
		--_tmp_clear_loop;
		__dcbz(s_dparams_buff+(_tmp_clear_loop<<7));
	}while(_tmp_clear_loop);
	jsDrawParams *dparams = (jsDrawParams *)s_dparams_buff;
	dparams->mode = mode;
	dparams->firstVertex = first;
	dparams->vertexCount = count;
	GLuint maxElements = dparams->firstVertex + dparams->vertexCount;

	if ( LContext->needValidate )
		_RGLValidateStates();

	if ( RGL_UNLIKELY( clientSideMask ) )
	{
		for ( int i = 0; i < _RGL_MAX_VERTEX_ATTRIBS; ++i )
		{
			if ( clientSideMask & ( 1 << i ) )
			{
				jsAttribute* attrib = as->attrib + i;
				const GLuint freq = attrib->frequency;
				GLuint count;
				if ( RGLBIT_GET( as->ModuloMask, i ) )
					count = maxElements > freq ? freq : maxElements; else
					count = ( maxElements + freq - 1 ) / freq;

				const GLuint numBytes = attrib->clientStride * count;
				dparams->attribXferOffset[i] = dparams->xferTotalSize;
				dparams->attribXferSize[i] = numBytes;

				const GLuint numBytesPadded = _RGLPad( numBytes, 128 );
				dparams->xferTotalSize += numBytesPadded;
				dparams->attribXferTotalSize += numBytesPadded;
			}
			else
			{
				dparams->attribXferOffset[i] = 0;
				dparams->attribXferSize[i] = 0;
			}
		}
	}

	if ( driver->flushBufferCount != 0 )
		driver->invalidateVertexCache = GL_TRUE;

	GLboolean isMain = 0;

	if ( LContext->attribSetDirty && LContext->attribSetName )
	{
		jsAttribSet* attribSet = _RGLGetAttribSet( LContext->attribSetName );
	}
	uint32_t totalXfer = 0;
	for ( GLuint i = 0; i < _RGL_MAX_VERTEX_ATTRIBS; ++i )
		totalXfer += dparams->attribXferSize[i];

	GLuint gpuOffset = _RGLValidateAttributesSlow( dparams, &isMain );
	(void)gpuOffset;

	if ( driver->invalidateVertexCache )
	{
		driver->invalidateVertexCache = GL_FALSE;
		cellGcmSetInvalidateVertexCacheInline ( &_RGLState.fifo);
	}

	cellGcmSetUpdateFragmentProgramParameterInline( &_RGLState.fifo, gmmIdToOffset( driver->fpLoadProgramId) +driver->fpLoadProgramOffset );

	cellGcmSetDrawArraysInline( &_RGLState.fifo, CELL_GCM_PRIMITIVE_QUADS, dparams->firstVertex, dparams->vertexCount);
}

GLAPI void APIENTRY glGenTextures( GLsizei n, GLuint *textures )
{
   PSGLcontext*	LContext = _CurrentContext;
   _RGLTexNameSpaceGenNames( &LContext->textureNameSpace, n, textures );
}

static void _RGLTextureUnbind( PSGLcontext* context, GLuint name )
{
    int unit;
    for ( unit = 0;unit < _RGL_MAX_TEXTURE_IMAGE_UNITS;++unit )
    {
        jsTextureImageUnit *tu = context->TextureImageUnits + unit;
        GLboolean dirty = GL_FALSE;
        if ( tu->bound2D == name )
        {
            tu->bound2D = 0;
            dirty = GL_TRUE;
        }
        if ( dirty )
        {
	    tu->currentTexture = _RGLGetCurrentTexture( tu, GL_TEXTURE_2D );
            context->needValidate |= PSGL_VALIDATE_TEXTURES_USED;
        }
    }
    if ( _RGLTexNameSpaceIsName( &context->textureNameSpace, name ) )
    {
        jsTexture*texture = ( jsTexture * )context->textureNameSpace.data[name];
        for ( unit = 0;unit < _RGL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; ++unit )
        {
            if ( context->VertexTextureImages[unit] == texture )
            {
                context->VertexTextureImages[unit] = NULL;
                context->needValidate |= PSGL_VALIDATE_VERTEX_TEXTURES_USED;
            }
        }
    }
}

GLAPI void APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures )
{
   PSGLcontext*	LContext = _CurrentContext;
   for ( int i = 0;i < n;++i )
      if ( textures[i] )
         _RGLTextureUnbind( LContext, textures[i] );

   _RGLTexNameSpaceDeleteNames( &LContext->textureNameSpace, n, textures );
} 
GLAPI void APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param )
{
   PSGLcontext*	LContext = _CurrentContext;
   jsTexture *texture = _RGLGetCurrentTexture( LContext->CurrentImageUnit, target );

   switch ( pname )
   {
	   case GL_TEXTURE_MIN_FILTER:
		   texture->minFilter = param;
		   if ( texture->referenceBuffer == 0 )
		   {
			   texture->revalidate |= _RGL_TEXTURE_REVALIDATE_LAYOUT; }
		   break;
	   case GL_TEXTURE_MAG_FILTER:
		   texture->magFilter = param;
		   break;
	   case GL_TEXTURE_MAX_LEVEL:
	   case GL_TEXTURE_WRAP_S:
	   case GL_TEXTURE_WRAP_T:
	   case GL_TEXTURE_WRAP_R:
	   case GL_TEXTURE_FROM_VERTEX_PROGRAM_SCE:
		   break;
	   case GL_TEXTURE_ALLOCATION_HINT_SCE:
		   texture->usage = param;
		   texture->revalidate |= _RGL_TEXTURE_REVALIDATE_LAYOUT;
		   break;
	   case GL_TEXTURE_MIN_LOD:
	   case GL_TEXTURE_MAX_LOD:
	   case GL_TEXTURE_LOD_BIAS:
	   case GL_TEXTURE_MAX_ANISOTROPY_EXT:
	   case GL_DEPTH_TEXTURE_MODE_ARB:
	   case GL_TEXTURE_COMPARE_MODE_ARB:
	   case GL_TEXTURE_COMPARE_FUNC_ARB:
		   break;
	   case GL_TEXTURE_GAMMA_REMAP_R_SCE:
	   case GL_TEXTURE_GAMMA_REMAP_G_SCE:
	   case GL_TEXTURE_GAMMA_REMAP_B_SCE:
	   case GL_TEXTURE_GAMMA_REMAP_A_SCE:
		   {
			   GLuint bit = 1 << ( pname - GL_TEXTURE_GAMMA_REMAP_R_SCE );
			   if ( param ) texture->gammaRemap |= bit;
			   else texture->gammaRemap &= ~bit;
		   }
		   break;
	   default:
		   _RGLSetError( GL_INVALID_ENUM );
		   return;
   }

   texture->revalidate |= _RGL_TEXTURE_REVALIDATE_PARAMETERS;
   LContext->needValidate |= PSGL_VALIDATE_TEXTURES_USED | PSGL_VALIDATE_VERTEX_TEXTURES_USED;
}

GLAPI void APIENTRY glBindTexture( GLenum target, GLuint name )
{
   PSGLcontext*	LContext = _CurrentContext;
   jsTextureImageUnit *unit = LContext->CurrentImageUnit;

   _RGLBindTextureInternal( unit, name);
}

static void _RGLReallocateImages( jsTexture *texture, GLsizei dimension )
{
	GLuint oldCount = texture->imageCount;
	if ( dimension <= 0 ) dimension = 1;
	GLuint n = 1 + _RGLLog2( dimension );
	n = MAX( n, oldCount );
	jsImage *images = ( jsImage * )realloc( texture->image, n * sizeof( jsImage ) );
	memset( images + oldCount, 0, ( n - oldCount )*sizeof( jsImage ) );
	texture->image = images;
	texture->imageCount = n;
}

static int _RGLGetImage( GLenum target, GLint level, jsTexture **texture, jsImage **image, GLsizei reallocateSize )
{
   PSGLcontext*	LContext = _CurrentContext;
   jsTextureImageUnit *unit = LContext->CurrentImageUnit;

   jsTexture *tex = _RGLGetCurrentTexture( unit, GL_TEXTURE_2D );

   if ( level >= ( int )tex->imageCount )
      _RGLReallocateImages( tex, reallocateSize );

   *image = tex->image;
   *texture = tex;
   return 0;
}


GLAPI void APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalFormat,
                                  GLsizei width, GLsizei height, GLint border, GLenum format,
                                  GLenum type, const GLvoid *pixels )
{
    PSGLcontext*	LContext = _CurrentContext;
    jsTexture *texture;
    jsImage *image;

     _RGLGetImage( GL_TEXTURE_2D, 0, &texture, &image, MAX( width, height ) );

    image->dataState = _RGL_IMAGE_DATASTATE_UNSET;

    GLboolean directPBO = GL_FALSE;
    if ( LContext->PixelUnpackBuffer != 0 )
    {
        directPBO = _RGLPlatformTexturePBOImage(
                        texture,
                        image,
                        internalFormat,
                        width, height,
                        format, type,
                        pixels );
    }

    if ( !directPBO )
    {
        jsBufferObject* bufferObject = NULL;
        if ( LContext->PixelUnpackBuffer != 0 )
        {
            bufferObject = _RGLGetBufferObject( LContext, LContext->PixelUnpackBuffer );
            pixels = _RGLPlatformBufferObjectMap( bufferObject, GL_READ_ONLY ) +
                     (( const GLubyte* )pixels - ( const GLubyte* )NULL );
        }

        _RGLSetImage(
            image,
            internalFormat,
            width, height, 1,
            LContext->unpackAlignment,
            format, type,
            pixels );


        if ( LContext->PixelUnpackBuffer != 0 )
	{
		RGLBufferObject *jsBuffer = ( RGLBufferObject * )bufferObject->platformBufferObject;

		if ( --jsBuffer->mapCount == 0 )
		{
			if ( jsBuffer->mapAccess != GL_READ_ONLY )
			{
				RGLDriver *driver= (RGLDriver *)_CurrentDevice->rasterDriver;
				--driver->flushBufferCount;

				driver->invalidateVertexCache = GL_TRUE;
			}

			jsBuffer->mapAccess = GL_NONE;

			GmmBaseBlock    *pBaseBlock = (GmmBaseBlock *)jsBuffer->bufferId;

			if (!pBaseBlock->isTile)
			{
				GmmBlock *pBlock = (GmmBlock *)jsBuffer->bufferId;

				pBlock->isPinned = 0;
			}
		}
	}

        texture->revalidate |= _RGL_TEXTURE_REVALIDATE_IMAGES;
    }

    _RGLTextureTouchFBOs( texture );
    LContext->needValidate |= PSGL_VALIDATE_TEXTURES_USED | PSGL_VALIDATE_VERTEX_TEXTURES_USED;
}

GLAPI void APIENTRY glActiveTexture( GLenum texture )
{
    PSGLcontext*	LContext = _CurrentContext;

    int unit = texture - GL_TEXTURE0;
    LContext->ActiveTexture = unit;
    LContext->CurrentImageUnit = unit < _RGL_MAX_TEXTURE_IMAGE_UNITS ? LContext->TextureImageUnits + unit : NULL;
    LContext->CurrentCoordsUnit = unit < _RGL_MAX_TEXTURE_COORDS ? LContext->TextureCoordsUnits + unit : NULL;
}


GLAPI void APIENTRY glClientActiveTexture( GLenum texture )
{
   PSGLcontext*	LContext = _CurrentContext;
   LContext->CS_ActiveTexture = texture - GL_TEXTURE0;
}


GLAPI void APIENTRY glPixelStorei( GLenum pname, GLint param )
{
    PSGLcontext*	LContext = _CurrentContext;

    switch ( pname )
    {
        case GL_PACK_ALIGNMENT:
            LContext->packAlignment = param;
            break;
        case GL_UNPACK_ALIGNMENT:
            LContext->unpackAlignment = param;
            break;
        default:
            _RGLSetError( GL_INVALID_ENUM );
            return;
    }
}


GLAPI void APIENTRY glTextureReferenceSCE( GLenum target, GLuint levels, GLuint baseWidth, GLuint baseHeight, GLuint baseDepth, GLenum internalFormat, GLuint pitch, GLintptr offset )
{
    PSGLcontext*	LContext = _CurrentContext;

    jsTexture *texture = _RGLGetCurrentTexture( LContext->CurrentImageUnit, GL_TEXTURE_2D);
    jsBufferObject *bufferObject = _RGLGetBufferObject( LContext, LContext->TextureBuffer );
    _RGLReallocateImages( texture, MAX( baseWidth, MAX( baseHeight, baseDepth ) ) );

    GLuint width = baseWidth;
    GLuint height = baseHeight;
    _RGLSetImage(texture->image, GL_RGB5_A1, width, height, 0, LContext->unpackAlignment,
		    0, 0, NULL );
    width = MAX( 1U, width / 2 );
    height = MAX( 1U, height / 2 );
    texture->usage = GL_TEXTURE_LINEAR_GPU_SCE;

    GLboolean r = _RGLPlatformTextureReference( texture, pitch, bufferObject, offset );

    if(!r)
	    return;

    bufferObject->textureReferences.pushBack( texture );
    texture->referenceBuffer = bufferObject;
    texture->offset = offset;
    _RGLTextureTouchFBOs( texture );
    LContext->needValidate |= PSGL_VALIDATE_TEXTURES_USED | PSGL_VALIDATE_VERTEX_TEXTURES_USED ;
}

GLAPI void APIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
{

    PSGLcontext*	LContext = _CurrentContext;

    LContext->ViewPort.X = x;
    LContext->ViewPort.Y = y;
    LContext->ViewPort.XSize = width;
    LContext->ViewPort.YSize = height;
    _RGLFifoGlViewport(LContext->ViewPort.X, LContext->ViewPort.Y, 
		    LContext->ViewPort.XSize, LContext->ViewPort.YSize, 0.0f, 1.0f);
}

jsTexture *_RGLGetCurrentTexture( const jsTextureImageUnit *unit, GLenum target )
{
    PSGLcontext*	LContext = _CurrentContext;
    GLuint name = unit->bound2D;
    jsTexture *defaultTexture = unit->default2D;

    if ( name )
        return ( jsTexture * )LContext->textureNameSpace.data[name];
    else
    	return defaultTexture;
}

CgprogramHookFunction _cgProgramCreateHook = NULL;
CgprogramHookFunction _cgProgramDestroyHook = NULL;
CgprogramCopyHookFunction _cgProgramCopyHook = NULL;

cgRTCgcCompileHookFunction _cgRTCgcCompileProgramHook = NULL;
cgRTCgcFreeHookFunction _cgRTCgcFreeCompiledProgramHook;

CgcontextHookFunction _cgContextCreateHook = NULL;
CgcontextHookFunction _cgContextDestroyHook = NULL;

CgparameterHookFunction _cgParameterCreateHook = NULL;
CgparameterHookFunction _cgParameterDestroyHook = NULL;

typedef struct RGLcgProfileMapType
{
    CGprofile id;
    char* string;
    int is_vertex_program;
}
RGLcgProfileMapType;

static void _RGLCgProgramPushFront( _CGcontext* ctx, _CGprogram* prog )
{
    prog->next = ctx->programList;
    ctx->programList = prog;
    prog->parentContext = ctx;
    ctx->programCount++;
}

static _CGprogram* _RGLCgProgramFindPrev( _CGcontext* ctx, _CGprogram* prog )
{
    _CGprogram* ptr = ctx->programList;

    while ( NULL != ptr && prog != ptr->next )
    {
        ptr = ptr->next;
    }

    return ptr;
}

void _RGLCgProgramErase( _CGprogram* prog )
{
    if ( _cgProgramDestroyHook ) _cgProgramDestroyHook( prog );

    switch ( prog->header.profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
            _RGLPlatformProgramErase( prog );
            break;
        default:
            break;
    }

    if ( prog->id ) _RGLEraseName( &_CurrentContext->cgProgramNameSpace, ( jsName )prog->id );
    if ( prog->runtimeElf )
        free( prog->runtimeElf );

    memset( prog, 0, sizeof( _CGprogram ) );
}

bool _RGLCgCreateProgramChecks( CGcontext ctx, CGprofile profile, CGenum program_type )
{
    if ( !CG_IS_CONTEXT( ctx ) )
    {
        _RGLCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR );
        return false;
    }

    switch ( profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
        case CG_PROFILE_SCE_FP_RSX:
            break;
        default:
            _RGLCgRaiseError( CG_UNKNOWN_PROFILE_ERROR );
            return false;
    }

    switch ( program_type )
    {
        case CG_BINARY:
        case CG_SOURCE:
            break;
        default:
            _RGLCgRaiseError( CG_INVALID_ENUMERANT_ERROR );
            return false;
    }

    return true;
}

typedef struct
{
    const char* elfFile;
    size_t elfFileSize;

    const char *symtab;
    size_t symbolSize;
    size_t symbolCount;
    const char *symbolstrtab;

    const char* shadertab;
    size_t shadertabSize;
    const char* strtab;
    size_t strtabSize;
    const char* consttab;
    size_t consttabSize;
}
CGELFBinary;

typedef struct
{
    const char *texttab;
    size_t texttabSize;
    const char *paramtab;
    size_t paramtabSize;
    int index;
}
CGELFProgram;

static bool cgOpenElf( const void *ptr, size_t size, CGELFBinary *elfBinary )
{
    while ( 1 )
    {
        size_t symbolSize;
        size_t symbolCount;
        const char *symbolstrtab;
        const char *symtab = findSymbolSectionInPlace(( const char * )ptr, size, &symbolSize, &symbolCount, &symbolstrtab );
        if ( !symtab )
            break;

        size_t shadertabSize;
        const char *shadertab = findSectionInPlace(( const char* )ptr, size, ".shadertab", &shadertabSize );
        if ( !shadertab )
            break;
        size_t strtabSize;
        const char *strtab = findSectionInPlace(( const char* )ptr, size, ".strtab", &strtabSize );
        if ( !strtab )
            break;
        size_t consttabSize;
        const char *consttab = findSectionInPlace(( const char* )ptr, size, ".const", &consttabSize );
        if ( !consttab )
            break;

        elfBinary->elfFile = ( const char* )ptr;
        elfBinary->elfFileSize = size;
        elfBinary->symtab = symtab;
        elfBinary->symbolSize = symbolSize;
        elfBinary->symbolCount = symbolCount;
        elfBinary->symbolstrtab = symbolstrtab;

        elfBinary->shadertab = shadertab;
        elfBinary->shadertabSize = shadertabSize;
        elfBinary->strtab = strtab;
        elfBinary->strtabSize = strtabSize;

        elfBinary->consttab = consttab;
        elfBinary->consttabSize = consttabSize;

        return true;
    }

    return false;
}

static bool cgGetElfProgramByIndex( CGELFBinary *elfBinary, int index, CGELFProgram *elfProgram )
{
    while ( true )
    {
        char sectionName[64];
        snprintf( sectionName, sizeof(sectionName), ".text%04i", index );
        size_t texttabSize;
        const char *texttab = findSectionInPlace( elfBinary->elfFile, elfBinary->elfFileSize, sectionName, &texttabSize );
        if ( !texttab )
            break;
        snprintf( sectionName, sizeof(sectionName), ".paramtab%04i", index );
        size_t paramtabSize;
        const char *paramtab = findSectionInPlace( elfBinary->elfFile, elfBinary->elfFileSize, sectionName, &paramtabSize );
        if ( !paramtab )
            break;

        elfProgram->texttab = texttab;
        elfProgram->texttabSize = texttabSize;
        elfProgram->paramtab = paramtab;
        elfProgram->paramtabSize = paramtabSize;
        elfProgram->index = index;
        return true;
    }
    return false;
}

static bool cgGetElfProgramByName( CGELFBinary *elfBinary, const char *name, CGELFProgram *elfProgram )
{
    //if no name try to return the first program
    int res;
    if ( name == NULL || name[0] == '\0' )
        res = 0;
    else
        res = lookupSymbolValueInPlace( elfBinary->symtab, elfBinary->symbolSize, elfBinary->symbolCount, elfBinary->symbolstrtab, name );

    if ( res != -1 )
        return cgGetElfProgramByIndex( elfBinary, res, elfProgram );
    else
        return false;
}

static CGprogram _RGLCgCreateProgram( CGcontext ctx, CGprofile profile, const CgProgramHeader *programHeader, const void *ucode, const CgParameterTableHeader *parameterHeader, const char *stringTable, const float *defaultValues )
{
    // Create the program structure.
    // all the structural data is filled in here,
    // as well as the profile.
    // The parameters and the actual program are generated from the ABI specific calls.

    _CGprogram* prog = ( _CGprogram* )malloc( sizeof( _CGprogram ) );
    if ( NULL == prog )
    {
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        return NULL;
    }

    // zero out the fields
    memset( prog, 0, sizeof( _CGprogram ) );

    // fill in the fields we know
    prog->parentContext = _cgGetContextPtr( ctx );
    prog->header.profile = profile;

    int success = 0;

    // create a name for the program and record it in the object
    CGprogram id = ( CGprogram )_RGLCreateName( &_CurrentContext->cgProgramNameSpace, prog );
    if ( !id )
    {
        free( prog );
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        return NULL;
    }
    prog->id = id;

    //hack to counter removal of TypeC during beta
    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    // load the binary into the program object
    switch ( profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
            //case CG_PROFILE_SCE_VP_TYPEC:
        case CG_PROFILE_SCE_VP_RSX:
            // TODO ************** need to include the entry symbol too
	    success =  _RGLGenerateProgram( prog, VERTEX_PROFILE_INDEX, programHeader,
			    ucode, parameterHeader, NULL, stringTable, defaultValues );
            break;
        case CG_PROFILE_SCE_FP_TYPEB:
            //case CG_PROFILE_SCE_FP_TYPEC:
        case CG_PROFILE_SCE_FP_RSX:
            success = _RGLPlatformGenerateFragmentProgram( prog, programHeader, ucode, parameterHeader, stringTable, defaultValues );
            break;
        default:
            // should never reach here
	    break;
    }

    // if the creation failed, free all resources.
    // the error was raised when the error was encoutered.
    if ( 0 == success )
    {
        // free the program object
        free( prog );
        // release the id too
        _RGLEraseName( &_CurrentContext->cgProgramNameSpace, ( jsName )id );
        return NULL;
    }

    // success! add the program to the program list in the context.
    _RGLCgProgramPushFront( prog->parentContext, prog );
    if ( _cgProgramCreateHook ) _cgProgramCreateHook( prog );

    // everything worked.
    return id;
}

static CGprogram _RGLCgUpdateProgramAtIndex( CGprogramGroup group, int index, int refcount );

CG_API CGprogram cgCreateProgram( CGcontext ctx,
                                  CGenum program_type,
                                  const char* program,
                                  CGprofile profile,
                                  const char* entry,
                                  const char** args )
{
    // Load a program from a memory pointer.
    // NOTE: in our API all programs are pre-compiled binaries
    // so entry point and compiler arguments are ignored.

    //hack to counter removal of TypeC during beta
    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    //hack to counter change of defines for program_type at r5294
    // previously CG_BINARY was defined the same as CG_ROW_MAJOR
    // if those values are passed in here, move them to the new values and remove this hack after we have
    // an sdk that incorporates these changes so that prebuild libs (aka debugfont) can be used meanwhile
    if ( program_type == CG_ROW_MAJOR )
        program_type = CG_BINARY;

    if ( !_RGLCgCreateProgramChecks( ctx, profile, program_type ) )
        return NULL;

    //data to extract from the buffer passed:
    CgProgramHeader *programHeader = NULL;
    const void *ucode = NULL;
    CgParameterTableHeader *parameterHeader = NULL;
    const char *stringTable = NULL;
    const float *defaultValues = NULL;

    //first step, compile any source file
    const char *binaryBuffer = NULL;
    char* compiled_program = NULL;
    if ( program_type == CG_SOURCE )
    {
        if ( _cgRTCgcCompileProgramHook )
        {
            _cgRTCgcCompileProgramHook( program, cgGetProfileString( profile ), entry, args, &compiled_program );
            if ( !compiled_program )
            {
                _RGLCgRaiseError( CG_COMPILER_ERROR );
                return NULL;
            }
            binaryBuffer = compiled_program;
        }
        else
        {
            printf("RGL ERR: The CG runtime compiler hasn't been setup. cgRTCgcInit() should be called prior to this function.\n" );
            _RGLCgRaiseError( CG_INVALID_ENUMERANT_ERROR );
            return NULL;
        }
    }
    else
    {
        binaryBuffer = program;
    }

    bool bConvertedToElf = false;

    //At that point we have a binary file which is either any ELF or an NV format file
    const unsigned int ElfTag = 0x7F454C46; // == MAKEFOURCC(0x7F,'E','L','F');
    if ( !( *( unsigned int* )binaryBuffer == ElfTag ) )
    {
        //we have an NV file, convert it to the runtime format

        // if it was initially binary, throw warning about old format and recommend conversion to new with cgnv2elf
        // don't throw the warning if it was source, cause clearly that would have been on purpose.
        if ( program_type == CG_BINARY )
        {
            printf("RGL WARN: A binary shader is being loaded using a deprecated binary format.  Please use the cgnv2elf tool to convert to the new, memory-saving, faster-loading format.\n");
        }

        //convert from NV format to the runtime format
        int compiled_program_size = 0;
        STL_NAMESPACE vector<char> stringTableArray;
        STL_NAMESPACE vector<float> defaultValuesArray;
        CgBinaryProgram* nvProgram = ( CgBinaryProgram* )binaryBuffer;
        char *runtimeElfShader = NULL;
        //check the endianness
        int totalSize;
        if (( nvProgram->profile != CG_PROFILE_SCE_FP_TYPEB ) && ( nvProgram->profile != CG_PROFILE_SCE_VP_TYPEB ) &&
                ( nvProgram->profile != ( CGprofile )7006 ) && ( nvProgram->profile != ( CGprofile )7005 ) &&
                ( nvProgram->profile != CG_PROFILE_SCE_FP_RSX ) && ( nvProgram->profile != CG_PROFILE_SCE_VP_RSX ) )
        {
            totalSize = endianSwapWord( nvProgram->totalSize );
        }
        else
            totalSize = nvProgram->totalSize;
        int res = convertNvToElfFromMemory( binaryBuffer, totalSize, 2, 0, ( void** ) & runtimeElfShader, &compiled_program_size, stringTableArray, defaultValuesArray );
        if ( res != 0 )
        {
            printf("RGL ERR: invalid CG binary program.\n");
            _RGLCgRaiseError( CG_COMPILER_ERROR );
            if ( compiled_program )
                _cgRTCgcFreeCompiledProgramHook( compiled_program );
            return NULL;
        }

        if ( compiled_program )
            _cgRTCgcFreeCompiledProgramHook( compiled_program );

        size_t stringTableSize = stringTableArray.size() * sizeof( stringTable[0] );
        size_t defaultTableSize = defaultValuesArray.size() * sizeof( defaultValues[0] );
        int paddedSize = _RGLPad( compiled_program_size, 4 );

        char *runtimeElf = ( char* )memalign( 16, paddedSize + stringTableSize + defaultTableSize );
        if ( !runtimeElf )
        {
            _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
            return NULL;
        }
        bConvertedToElf = true;
        memcpy( runtimeElf, runtimeElfShader, compiled_program_size );

        convertNvToElfFreeBinaryShader( runtimeElfShader );

        float* pDefaultValues = ( float* )(( char* )runtimeElf + paddedSize );
        defaultValues = pDefaultValues;

        if ( defaultTableSize )
            memcpy( pDefaultValues, &defaultValuesArray[0], defaultTableSize );

        char *pStringTable = ( char* )runtimeElf + paddedSize + defaultTableSize;
        stringTable = pStringTable;

        if ( stringTableSize )
            memcpy( pStringTable, &stringTableArray[0], stringTableSize );

        programHeader = ( CgProgramHeader* )runtimeElf;
        size_t elfUcodeSize = programHeader->instructionCount * 16;
        size_t ucodeOffset = _RGLPad( sizeof( CgProgramHeader ), 16 );
        size_t parameterOffset = _RGLPad( ucodeOffset + elfUcodeSize, 16 );
        ucode = ( char* )runtimeElf + ucodeOffset;
        parameterHeader = ( CgParameterTableHeader* )(( char* )runtimeElf + parameterOffset );
    }
    else
    {
        CGELFBinary elfBinary;
        CGELFProgram elfProgram;
        if ((( intptr_t )binaryBuffer ) & 15 )
        {
            printf("RGL ERR: CG Binary not aligned on 16 bytes, needed for ucode section.\n");
            _RGLCgRaiseError( CG_PROGRAM_LOAD_ERROR );
            return NULL;
        }
        bool res = cgOpenElf( binaryBuffer, 0, &elfBinary );
        if ( !res )
        {
            printf("RGL ERR: not a valid ELF.\n");
            _RGLCgRaiseError( CG_PROGRAM_LOAD_ERROR );
            return NULL;
        }
        if ( !cgGetElfProgramByName( &elfBinary, entry, &elfProgram ) )
        {
            printf("RGL ERR: couldn't find the shader entry in the CG binary.\n");
            return NULL;
        }

        programHeader = ( CgProgramHeader* )elfBinary.shadertab + elfProgram.index;
        ucode = ( char* )elfProgram.texttab;
        parameterHeader = ( CgParameterTableHeader* )elfProgram.paramtab;
        stringTable = elfBinary.strtab;
        defaultValues = ( float* )elfBinary.consttab;
    }

    CGprogram prog = _RGLCgCreateProgram( ctx, profile, programHeader, ucode, parameterHeader, stringTable, defaultValues );

    if ( bConvertedToElf )
    {
        _CGprogram* ptr = _cgGetProgPtr( prog );
        ptr->runtimeElf = programHeader;
    }

    return prog;
}



CG_API CGprogram cgCreateProgramFromFile( CGcontext ctx,
        CGenum program_type,
        const char* program_file,
        CGprofile profile,
        const char* entry,
        const char** args )
{
    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    if ( program_type == CG_ROW_MAJOR )
        program_type = CG_BINARY;

    if ( !_RGLCgCreateProgramChecks( ctx, profile, program_type ) )
        return NULL;

    FILE* fp = NULL;
    if ( RGL_LIKELY( program_type == CG_BINARY ) )
    {
        CGprogram ret = NULL;

        _CGcontext *context = _cgGetContextPtr( ctx );
        CGprogramGroup group = NULL;

        group = context->groupList;
        while ( group )
        {
            const char *groupName = _RGLCgGetProgramGroupName( group );
            if ( groupName && !strcmp( groupName, program_file ) )
            {
                int index;
                if ( entry == NULL )
                    index = 0;
                else
                    index = _RGLCgGetProgramIndex( group, entry );
                if ( index >= 0 )
                {
                    ret = _RGLCgUpdateProgramAtIndex( group, index, 1 );
                    break;
                }
                else
                {
                    return ( CGprogram )NULL;
                }
            }
            group = group->next;
        }

        if ( ret )
            return ret;
        else
        {
            fp = fopen( program_file, "rb" );

            if ( NULL == fp )
            {
                _RGLCgRaiseError( CG_FILE_READ_ERROR );
                return ( CGprogram )NULL;
            }

            unsigned int filetag = 0;
            int res = fread( &filetag, sizeof( filetag ), 1, fp );
            if ( !res )
            {
                fclose( fp );
                _RGLCgRaiseError( CG_FILE_READ_ERROR );
                return ( CGprogram )NULL;
            }
            const unsigned int ElfTag = 0x7F454C46;
            if ( filetag == ElfTag )
            {
                fclose( fp );

                group = _RGLCgCreateProgramGroupFromFile( ctx, program_file );
                if ( group )
                {
                    _CGprogramGroup *_group = ( _CGprogramGroup * )group;
                    _group->userCreated = false;
                    if ( entry == NULL )
                    {
                        if ( group->programCount == 1 )
                        {
                            ret = _RGLCgUpdateProgramAtIndex( group, 0, 1 );
                        }
                    }
                    else
                    {
                        int index = _RGLCgGetProgramIndex( group, entry );
                        if ( index == -1 )
                        {
                            printf("RGL ERR: couldn't find the shader entry in the CG binary.\n");
                        }
                        else
                        {
                            ret = _RGLCgUpdateProgramAtIndex( group, index, 1 );
                        }
                    }
                }
                return ret;
            }
        }
    }

    if ( !fp )
    {
        fp = fopen( program_file, "rb" );
        if ( NULL == fp )
        {
            _RGLCgRaiseError( CG_FILE_READ_ERROR );
            return ( CGprogram )NULL;
        }
    }

    size_t file_size = 0;
    fseek( fp, 0, SEEK_END );
    file_size = ftell( fp );
    rewind( fp );

    char* ptr = ( char* )malloc( file_size + 1 );
    if ( NULL == ptr )
    {
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        fclose( fp );
        return ( CGprogram )NULL;
    }

    fread( ptr, file_size, 1, fp );
    fclose( fp );

    if ( program_type == CG_SOURCE )
    {
        ptr[file_size] = '\0';
    }

    CGprogram ret = cgCreateProgram( ctx, program_type, ptr, profile, entry, args );

    free( ptr );

    return ret;
}

CG_API CGprogram cgCopyProgram( CGprogram program )
{
    if ( !CG_IS_PROGRAM( program ) )
    {
        _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
        return NULL;
    }
    _CGprogram* prog = _cgGetProgPtr( program );
    if ( NULL == prog )
    {
        _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
        return ( CGprogram )NULL;
    }
    
    _CGprogram* newprog;
    size_t paddedProgramSize = 0;
    size_t ucodeSize = 0;

    if (prog->header.profile == CG_PROFILE_SCE_FP_TYPEB || prog->header.profile == CG_PROFILE_SCE_FP_RSX)
	{
	    paddedProgramSize = _RGLPad( sizeof( _CGprogram ), 16);
	    ucodeSize = prog->header.instructionCount * 16;
	    newprog = ( _CGprogram* )malloc( paddedProgramSize + ucodeSize );
	}
    else
	{
	    newprog = ( _CGprogram* )malloc( sizeof( _CGprogram ) );
	}

    if ( NULL == newprog )
    {
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        return ( CGprogram )NULL;
    }
    memset( newprog, 0, sizeof( _CGprogram ) );

    newprog->header.profile = prog->header.profile;
    newprog->parentContext = prog->parentContext;

    newprog->id = ( CGprogram )_RGLCreateName( &_CurrentContext->cgProgramNameSpace, newprog );

    int success = 0;
    switch ( prog->header.profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
            success = _RGLPlatformCopyProgram( prog, newprog );
            break;
        default:
            _RGLCgRaiseError( CG_UNKNOWN_PROFILE_ERROR );
            success = 0;
            break;
    }

    if ( success == 0 )
    {
        free( newprog );
        _RGLEraseName( &_CurrentContext->cgProgramNameSpace, ( jsName )newprog->id );
        return ( CGprogram )NULL;
    }

    if (prog->header.profile == CG_PROFILE_SCE_FP_TYPEB || prog->header.profile == CG_PROFILE_SCE_FP_RSX)
	{
	    newprog->ucode = (char*)newprog + paddedProgramSize;
	    memcpy((char*)newprog->ucode, (char*)prog->ucode, ucodeSize);
	}

    if ( prog->programGroup )
    {
        newprog->programGroup = prog->programGroup;
        newprog->programIndexInGroup = -1;
        _RGLCgUpdateProgramAtIndex( newprog->programGroup, -1, 1 );
    }

    _RGLCgProgramPushFront( newprog->parentContext, newprog );

    if ( _cgProgramCopyHook ) _cgProgramCopyHook( newprog, prog );

    return newprog->id;
}


CG_API void cgDestroyProgram( CGprogram program )
{
    if ( !CG_IS_PROGRAM( program ) )
    {
        _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
        return;
    }
    _CGprogram* ptr = _cgGetProgPtr( program );
    if ( NULL == ptr )
    {
        _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
        return;
    }

    if ( ptr->programGroup )
    {
        if ( !ptr->programGroup->userCreated )
        {
            if ( ptr->programIndexInGroup != -1 && ptr->programGroup->programs[ptr->programIndexInGroup].refCount == 0 )
            {
                _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
                return;
            }
            else
            {
                bool isGroupMember = ( ptr->programIndexInGroup != -1 );
                _RGLCgUpdateProgramAtIndex( ptr->programGroup, ptr->programIndexInGroup, -1 );
                if ( isGroupMember )
                    return;
            }
        }
    }

    _CGcontext* ctx = ptr->parentContext;

    if ( ptr == ctx->programList )
    {
        _CGprogram* p = ctx->programList;
        ctx->programList = p->next;
	_RGLCgProgramErase( p );
	if(p != NULL)
		free( p );
    }
    else
    {
        _CGprogram* p = _RGLCgProgramFindPrev( ctx, ptr );

	_CGprogram* next = p->next;
	if ( next )
	{
		p->next = next->next;
		_RGLCgProgramErase( next );
		if(next != NULL)
			free( next );
	}
    }
    return;
}

static CGprogram _RGLCgUpdateProgramAtIndex( CGprogramGroup group, int index, int refcount )
{
    if ( index < ( int )group->programCount )
    {
        if ( index >= 0 )
        {
            if ( refcount == 1 && group->programs[index].refCount == 1 )
            {
                CGprogram res = cgCopyProgram( group->programs[index].program );
                return res;
            }
            group->programs[index].refCount += refcount;
        }

        group->refCount += refcount;
        if ( refcount < 0 )
        {
            if ( group->refCount == 0 && !group->userCreated )
            {
                _RGLCgDestroyProgramGroup( group );
            }
            return NULL;
        }
        else
            return group->programs[index].program;
    }
    else
        return NULL;
}

static void _RGLCgAddGroup( CGcontext ctx, CGprogramGroup group )
{
    _CGcontext *context = _cgGetContextPtr( ctx );
    if ( !context->groupList )
        context->groupList = group;
    else
    {
        _CGprogramGroup *current = context->groupList;
        while ( current->next )
            current = current->next;
        current->next = group;
    }
}

static void _RGLCgRemoveGroup( CGcontext ctx, CGprogramGroup group )
{
    _CGcontext *context = _cgGetContextPtr( ctx );
    _CGprogramGroup *current = context->groupList;
    _CGprogramGroup *previous = NULL;
    while ( current && current != group )
    {
        previous = current;
        current = current->next;
    }
    if ( current )
    {
        if ( !previous )
            context->groupList = current->next;
        else
            previous->next = current->next;
    }
}

CGprogramGroup _RGLCgCreateProgramGroupFromFile( CGcontext ctx, const char *group_file )
{
    FILE* fp = fopen( group_file, "rb" );

    if ( NULL == fp )
    {
        _RGLCgRaiseError( CG_FILE_READ_ERROR );
        return ( CGprogramGroup )NULL;
    }

    size_t file_size = 0;
    fseek( fp, 0, SEEK_END );
    file_size = ftell( fp );
    rewind( fp );

    char* ptr = ( char* )malloc( file_size + 1 );
    if ( NULL == ptr )
    {
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        return ( CGprogramGroup )NULL;
    }

    fread( ptr, file_size, 1, fp );
    fclose( fp );

    CGprogramGroup group = _RGLCgCreateProgramGroup( ctx, group_file, ptr, file_size );
    if ( !group )
        free( ptr );

    return group;
}

CGprogramGroup _RGLCgCreateProgramGroup( CGcontext ctx,  const char *name, void *ptr, int size )
{
    _CGprogramGroup *group = NULL;
    CGELFBinary elfBinary;
    elfBinary.elfFile = NULL;

    while ( 1 )
    {
        bool res = cgOpenElf( ptr, size, &elfBinary );
        if ( !res )
            break;

        size_t elfConstTableSize = ( size_t )elfBinary.consttabSize;
        size_t elfStringTableSize = ( size_t )elfBinary.strtabSize;

        int programCount = elfBinary.shadertabSize / sizeof( CgProgramHeader );
        int i;

        size_t nvProgramNamesOffset = _RGLPad( sizeof( _CGprogramGroup ), sizeof( _CGnamedProgram ) );
        size_t nvDefaultValuesTableOffset = _RGLPad( nvProgramNamesOffset + programCount * sizeof( _CGnamedProgram ), 16 );

        size_t nvStringTableOffset = nvDefaultValuesTableOffset + elfConstTableSize;
        size_t structureSize = nvStringTableOffset + elfStringTableSize;

        group = ( CGprogramGroup )malloc( structureSize );
        if ( !group )
            break;

        group->ctx = ctx;
        group->next = NULL;
        group->programCount = ( unsigned int )programCount;
        group->constantTable = ( unsigned int * )(( char* )group + nvDefaultValuesTableOffset );
        group->stringTable = ( unsigned int * )(( char* )group + nvStringTableOffset );
        group->programs = ( _CGnamedProgram * )(( char* )group + nvProgramNamesOffset );
        group->userCreated = true;
        group->refCount = 0;
        group->filedata = ( char* )ptr;
        if ( name )
        {
            int len = strlen( name );
            group->name = ( char* )malloc( len + 1 );
            if ( !group->name )
                break;
            strlcpy( group->name, name, sizeof(group->name));
        }
        else
            group->name = NULL;

        if ( elfConstTableSize )
            memcpy(( char* )group + nvDefaultValuesTableOffset, elfBinary.consttab, elfConstTableSize );
        if ( elfStringTableSize )
            memcpy(( char* )group + nvStringTableOffset, elfBinary.strtab, elfStringTableSize );

        _RGLCgAddGroup( ctx, group );

        for ( i = 0;i < ( int )group->programCount;i++ )
        {
            CgProgramHeader *cgShader = ( CgProgramHeader* )elfBinary.shadertab + i;

            if ( cgShader->profile == ( CGprofile )7005 )
                cgShader->profile = CG_PROFILE_SCE_VP_RSX;
            if ( cgShader->profile == ( CGprofile )7006 )
                cgShader->profile = CG_PROFILE_SCE_FP_RSX;

            CGELFProgram elfProgram;
            bool res = cgGetElfProgramByIndex( &elfBinary, i, &elfProgram );
            if ( !res )
                return false;

            CgProgramHeader *programHeader = cgShader;
            char *ucode = ( char * )elfProgram.texttab;
            CgParameterTableHeader *parameterHeader  = ( CgParameterTableHeader * )elfProgram.paramtab;

            const char *programName = getSymbolByIndexInPlace( elfBinary.symtab, elfBinary.symbolSize, elfBinary.symbolCount, elfBinary.symbolstrtab, i + 1 );
            group->programs[i].name = programName;
            group->programs[i].program = _RGLCgCreateProgram( ctx, ( CGprofile )cgShader->profile, programHeader, ucode, parameterHeader, ( const char* )group->stringTable, ( const float* )group->constantTable );
            _CGprogram *cgProgram = _cgGetProgPtr( group->programs[i].program );
            cgProgram->programGroup = group;
            cgProgram->programIndexInGroup = i;
            group->programs[i].refCount = 0;
        }
        break;
    }

    return group;
}

void _RGLCgDestroyProgramGroup( CGprogramGroup group )
{
    _CGprogramGroup *_group = ( _CGprogramGroup * )group;
    for ( int i = 0;i < ( int )_group->programCount;i++ )
    {
        _CGprogram *cgProgram = _cgGetProgPtr( group->programs[i].program );
        cgProgram->programGroup = NULL;
        cgDestroyProgram( _group->programs[i].program );
    }
    if(_group->filedata != NULL)
	    free( _group->filedata );
    if ( _group->name )
        free( _group->name );

    _RGLCgRemoveGroup( group->ctx, group );
    if(_group != NULL)
	    free( _group );
}

const char *_RGLCgGetProgramGroupName( CGprogramGroup group )
{
    _CGprogramGroup *_group = ( _CGprogramGroup * )group;
    return _group->name;
}

int _RGLCgGetProgramIndex( CGprogramGroup group, const char *name )
{
    int i;
    for ( i = 0;i < ( int )group->programCount;i++ )
    {
        if ( !strcmp( name, group->programs[i].name ) )
            return i;
    }
    return -1;
}

CGprogram _RGLCgGetProgramAtIndex( CGprogramGroup group, unsigned int index )
{
    return _RGLCgUpdateProgramAtIndex( group, index, 0 );
}

int _RGLCgGetProgramCount( CGprogramGroup group )
{
    return group->programCount;
}

static const RGLcgProfileMapType RGLcgProfileMap[] =
    {
        {( CGprofile )6144, "CG_PROFILE_START", 1 },
        {( CGprofile )6145, "unknown", 1 },

#define CG_PROFILE_MACRO(name, compiler_id, compiler_id_caps, compiler_opt,int_id,vertex_profile) \
    {CG_PROFILE_ ## compiler_id_caps, compiler_opt, vertex_profile},
#include <Cg/cg_profiles.h>

        {( CGprofile )0, "", 0 }
    };

CG_API const char* cgGetProfileString( CGprofile profile )
{
    const size_t arraysize = sizeof( RGLcgProfileMap ) / sizeof( RGLcgProfileMapType );
    unsigned int i = 0;
    while ( i < arraysize )
    {
        if ( profile == RGLcgProfileMap[i].id )
        {
            return RGLcgProfileMap[i].string;
        }
        ++i;
    }
    return "";
}

CG_API CGprofile cgGetProfile( const char* profile_string )
{
    size_t arraysize = sizeof( RGLcgProfileMap ) / sizeof( RGLcgProfileMapType );
    unsigned int i = 0;
    while ( i < arraysize )
    {
        if ( 0 == strcmp( RGLcgProfileMap[i].string, profile_string ) )
        {
            return RGLcgProfileMap[i].id;
        }
        ++i;
    }
    return CG_PROFILE_UNKNOWN;
}

CG_API CGerror cgGetError( void )
{
    CGerror err = _CurrentContext->RGLcgLastError;
    _CurrentContext->RGLcgLastError = CG_NO_ERROR;
    return err;
}

CG_API const char* cgGetErrorString( CGerror error )
{
	return "cgGetErrorString: N/A\n";
}

CG_API const char* cgGetLastErrorString( CGerror* error )
{
	return "cgGetErrorString: N/A\n";
}

CG_API void cgSetErrorCallback( CGerrorCallbackFunc func )
{
    _CurrentContext->RGLcgErrorCallbackFunction = func;
}


CG_API CGerrorCallbackFunc cgGetErrorCallback( void )
{
    return _CurrentContext->RGLcgErrorCallbackFunction;
}

void _RGLCgDestroyContextParam( CgRuntimeParameter* ptr )
{
    if ( _cgParameterDestroyHook ) _cgParameterDestroyHook( ptr );
    _RGLEraseName( &_CurrentContext->cgParameterNameSpace, ( jsName )( ptr->id ) );
    free( ptr );
}

static int _RGLGetSizeofSubArray( const short *dimensions, int count )
{
    int res = 1;
    for ( int i = 0;i < count;i++ )
        res *= ( int )( *( dimensions++ ) );
    return res;
}


static _CGparameter *_cgGetNamedParameter( _CGprogram* progPtr, const char* name, CGenum name_space, int *arrayIndex, const CgParameterEntry *_startEntry = NULL, int _entryCount = -1 )
{
    if ( name == NULL )
        return NULL;

    *arrayIndex = -1;
    int done = 0;
    const char *structureEnd;
    const char *structureStart = name;
    int itemIndex = -1;
    _CGprogram *program = progPtr;

    const CgParameterEntry *currentEntry;
    const CgParameterEntry *lastEntry;

    int containerCount = -2;
    if ( _startEntry && _entryCount != -1 )
    {
        currentEntry = _startEntry;
        containerCount = _entryCount;
    }
    else
    {
        currentEntry = program->parametersEntries;
    }
    lastEntry = program->parametersEntries + program->rtParametersCount;

    bool bWasUnrolled = false;
    const char *prevStructureStart = structureStart;

    while (( !done ) && ( *structureStart ) && ( containerCount != -1 ) )
    {
        structureEnd = strpbrk( structureStart, ".[" );
        if ( structureEnd == NULL )
        {
            structureEnd = structureStart + strlen( structureStart );
            done = 1;
        }

        if ( bWasUnrolled )
        {
            bWasUnrolled = false;
            structureStart = prevStructureStart;
        }
        char structName[256];
        int length = ( int )( structureEnd - structureStart );
        strncpy( structName, structureStart, length );
        structName[length] = '\0';
        prevStructureStart = structureStart;
        structureStart = structureEnd + 1;

        bool found = false;
        while ( !found && currentEntry < lastEntry && ( containerCount == -2 || containerCount > 0 ) )
        {
            if ( !strncmp( structName, program->stringTable + currentEntry->nameOffset, length )
                    && ( name_space == 0 || ( name_space == CG_GLOBAL && ( currentEntry->flags & CGPF_GLOBAL ) )
                         || ( name_space == CG_PROGRAM && !( currentEntry->flags & CGPF_GLOBAL ) ) ) )
            {
                if (( int )strlen( program->stringTable + currentEntry->nameOffset ) != length )
                {
                    if ( !strcmp( name, program->stringTable + currentEntry->nameOffset ) )
                    {
                        found = true;
                        done = 1;
                    }

                    if ( !strncmp( name, program->stringTable + currentEntry->nameOffset, length ) &&
                            !strcmp( "[0]", program->stringTable + currentEntry->nameOffset + length ) )
                    {
                        found = true;
                        done = 1;
                    }
                }
                else
                    found = true;
            }

            if ( !found )
            {
                int skipCount = 1;
                while ( skipCount && currentEntry < lastEntry )
                {
                    if ( currentEntry->flags & CGP_STRUCTURE )
                    {
                        const CgParameterStructure *parameterStructure = _RGLGetParameterStructure( program, currentEntry );
                        skipCount += parameterStructure->memberCount;
                    }
                    else if ( currentEntry->flags & CGP_ARRAY )
                    {
                        if ( currentEntry->flags & CGP_UNROLLED )
                        {
                            const CgParameterArray *parameterArray =  _RGLGetParameterArray( program, currentEntry );
                            skipCount += _RGLGetSizeofSubArray(( short* )parameterArray->dimensions, parameterArray->dimensionCount );
                        }
                        else
                            skipCount++;
                    }
                    currentEntry++;
                    skipCount--;
                }
            }
            if ( containerCount != -2 )
                containerCount--;
        }

        if ( found )
        {
            switch ( currentEntry->flags & CGP_TYPE_MASK )
            {
                case 0:
                    itemIndex = ( int )( currentEntry - program->parametersEntries );
                    break;
                case CGP_ARRAY:
                {

                    const CgParameterEntry *arrayEntry = currentEntry;
                    const CgParameterArray *parameterArray =  _RGLGetParameterArray( program, arrayEntry );

                    if ( *structureEnd == '\0' )
                    {
                        itemIndex = ( int )( currentEntry - program->parametersEntries );
                        break;
                    }

                    currentEntry++;
                    if ( currentEntry->flags &CGP_STRUCTURE )
                    {
                        bWasUnrolled = true;
                        containerCount = _RGLGetSizeofSubArray(( short* )parameterArray->dimensions, parameterArray->dimensionCount );
                        break;
                    }
                    else
                    {
                        const char *arrayStart = structureEnd;
                        const char *arrayEnd = structureEnd;

                        int dimensionCount = 0;
                        int arrayCellIndex = 0;
                        while ( *arrayStart == '[' && dimensionCount < parameterArray->dimensionCount )
                        {
                            arrayEnd = strchr( arrayStart + 1, ']' );
                            int length = ( int )( arrayEnd - arrayStart - 1 );
                            char indexString[16];
                            strncpy( indexString, arrayStart + 1, length );
                            indexString[length] = '\0';
                            int index = atoi( indexString );
                            int rowSize = parameterArray->dimensions[dimensionCount];
                            if ( index >= rowSize )
                            {
				return NULL;
                            }
                            arrayCellIndex += index * _RGLGetSizeofSubArray(( short* )parameterArray->dimensions + dimensionCount, parameterArray->dimensionCount - dimensionCount - 1 );

                            arrayStart = arrayEnd + 1;
                            dimensionCount++;
                        }
                        structureEnd = arrayStart;
                        if ( *structureEnd == '\0' )
                            done = 1;

                        if ( done )
                        {
                            ( *arrayIndex ) = arrayCellIndex;
                            itemIndex = ( int )( currentEntry - program->parametersEntries );
                        }
                    }
                }
                break;
                case CGP_STRUCTURE:
                    if ( done )
                    {
                        itemIndex = ( int )( currentEntry - program->parametersEntries );
                    }
                    else
                    {
                        const CgParameterStructure *parameterStructure = _RGLGetParameterStructure( program, currentEntry );
                        containerCount = parameterStructure->memberCount;
                    }
                    break;
                default:
                    break;
            }
        }
        if ( found )
        {
            if ( !bWasUnrolled )
                currentEntry++;
        }
        else
            break;
    }

    if ( itemIndex != -1 )
        return ( _CGparameter* )( program->runtimeParameters + itemIndex );
    else
        return NULL;
}

CG_API CGparameter cgGetNamedParameter( CGprogram prog, const char* name )
{
    if ( !CG_IS_PROGRAM( prog ) )
    {
        _RGLCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR );
        return ( CGparameter )NULL;
    }

    _CGprogram* progPtr = _cgGetProgPtr( prog );
    int arrayIndex = -1;
    CgRuntimeParameter *param = ( CgRuntimeParameter * )_cgGetNamedParameter( progPtr, name, ( CGenum )0, &arrayIndex );
    if ( param )
    {
        int ret = ( int )param->id;
        if ( arrayIndex != -1 )
            ret |= ( arrayIndex << CG_PARAMETERSIZE );
        return ( CGparameter )ret;
    }
    else
        return ( CGparameter )NULL;
}

static CGbool _RGLPlatformSupportsVertexProgram( CGprofile p )
{
    if ( p == CG_PROFILE_SCE_VP_TYPEB )
        return CG_TRUE;
    if ( p == CG_PROFILE_SCE_VP_TYPEC )
        return CG_TRUE;
    if ( p == CG_PROFILE_SCE_VP_RSX )
        return CG_TRUE;
    return CG_FALSE;
}

CGGL_API CGbool cgGLIsProfileSupported( CGprofile profile )
{
    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    switch ( profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
            return ( CGbool ) _RGLPlatformSupportsVertexProgram( profile );
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
            return ( CGbool ) _RGLPlatformSupportsFragmentProgram( profile );
        default:
            return CG_FALSE;
    }
}

CGGL_API void cgGLEnableProfile( CGprofile profile )
{
	if ( profile == ( CGprofile )7005 )
		profile = CG_PROFILE_SCE_VP_RSX;
	if ( profile == ( CGprofile )7006 )
		profile = CG_PROFILE_SCE_FP_RSX;

	PSGLcontext* LContext = _CurrentContext;
	struct _CGprogram* current = LContext->BoundFragmentProgram;
	switch ( profile )
	{
		case CG_PROFILE_SCE_VP_TYPEB:
		case CG_PROFILE_SCE_VP_RSX:
			LContext->VertexProgram = GL_TRUE;
			LContext->needValidate |= PSGL_VALIDATE_VERTEX_PROGRAM | PSGL_VALIDATE_VERTEX_TEXTURES_USED;
			break;

		case CG_PROFILE_SCE_FP_TYPEB:
		case CG_PROFILE_SCE_FP_RSX:
			LContext->FragmentProgram = GL_TRUE;
			if ( current )
			{
				for ( GLuint i = 0; i < current->samplerCount; ++i )
				{
					int unit = current->samplerUnits[i];
					_CurrentContext->TextureImageUnits[unit].currentTexture = _RGLGetCurrentTexture( &_CurrentContext->TextureImageUnits[unit], GL_TEXTURE_2D );
				}
			}
			LContext->needValidate |= PSGL_VALIDATE_FRAGMENT_PROGRAM | PSGL_VALIDATE_TEXTURES_USED;
			break;
		default:
			_RGLCgRaiseError( CG_INVALID_PROFILE_ERROR );
			break;
	}
}

CGGL_API void cgGLDisableProfile( CGprofile profile )
{
    if ( profile == ( CGprofile )7005 )
        profile = CG_PROFILE_SCE_VP_RSX;
    if ( profile == ( CGprofile )7006 )
        profile = CG_PROFILE_SCE_FP_RSX;

    PSGLcontext* LContext = _CurrentContext;
    switch ( profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
            LContext->VertexProgram = GL_FALSE;
            LContext->needValidate |= PSGL_VALIDATE_VERTEX_PROGRAM ;
            break;
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
            LContext->FragmentProgram = GL_FALSE;
	    for ( GLuint unit = 0; unit < _RGL_MAX_TEXTURE_UNITS; ++unit )
		    LContext->TextureImageUnits[unit].currentTexture = _RGLGetCurrentTexture( &LContext->TextureImageUnits[unit], GL_TEXTURE_2D );

	    LContext->needValidate |= PSGL_VALIDATE_FFX_FRAGMENT_PROGRAM | PSGL_VALIDATE_TEXTURES_USED;
            break;
        default:
            _RGLCgRaiseError( CG_INVALID_PROFILE_ERROR );
            break;
    }
}


CGGL_API CGprofile cgGLGetLatestProfile( CGGLenum profile_type )
{
    switch ( profile_type )
    {
        case CG_GL_VERTEX:
        case CG_GL_FRAGMENT:
            return _RGLPlatformGetLatestProfile( profile_type );
        default:
            _RGLCgRaiseError( CG_INVALID_ENUMERANT_ERROR );
            return CG_PROFILE_UNKNOWN;
    }
}

CGGL_API void cgGLSetOptimalOptions( CGprofile profile )
{
}

CGGL_API void cgGLLoadProgram( CGprogram program )
{
}

CGGL_API CGbool cgGLIsProgramLoaded( CGprogram program )
{
    return CG_TRUE;
}


CGGL_API void cgGLBindProgram( CGprogram program )
{
    _CGprogram* ptr = _cgGetProgPtr( program );

    switch ( ptr->header.profile )
    {
	    case CG_PROFILE_SCE_VP_TYPEB:
	    case 7005:
	    case CG_PROFILE_SCE_VP_RSX:
		    _CurrentContext->BoundVertexProgram = ptr;
		    _CurrentContext->needValidate |= PSGL_VALIDATE_VERTEX_PROGRAM | PSGL_VALIDATE_VERTEX_TEXTURES_USED;
		    break;

	    case CG_PROFILE_SCE_FP_TYPEB:
	    case 7006:
	    case CG_PROFILE_SCE_FP_RSX:
		    _CurrentContext->BoundFragmentProgram = ptr;
		    _CurrentContext->needValidate |= PSGL_VALIDATE_FRAGMENT_PROGRAM | PSGL_VALIDATE_TEXTURES_USED;

		    for ( GLuint index = 0; index < ptr->samplerCount; ++index )
		    {
			    CgRuntimeParameter *rtParameter = ptr->runtimeParameters + ptr->samplerIndices[index];
			    CgParameterResource *parameter = ( CgParameterResource * )( ptr->parameterResources + rtParameter->parameterEntry->typeIndex );
			    unsigned int unit = parameter->resource - CG_TEXUNIT0;

			    _CurrentContext->TextureImageUnits[unit].fragmentTarget = rtParameter->glType;
			    _CurrentContext->TextureImageUnits[unit].currentTexture = _RGLGetCurrentTexture( &_CurrentContext->TextureImageUnits[unit], GL_TEXTURE_2D );
		    }
		    break;

	    default:
		    _RGLCgRaiseError( CG_INVALID_PROFILE_ERROR );
		    return;
    }

}

CGGL_API void cgGLUnbindProgram( CGprofile profile )
{
    switch ( profile )
    {
        case CG_PROFILE_SCE_VP_TYPEB:
        case CG_PROFILE_SCE_VP_RSX:
        case 7005:
		_CurrentContext->BoundVertexProgram = NULL;
		_CurrentContext->needValidate |= PSGL_VALIDATE_VERTEX_PROGRAM;
            break;
        case CG_PROFILE_SCE_FP_TYPEB:
        case CG_PROFILE_SCE_FP_RSX:
        case 7006:
	    _CurrentContext->BoundFragmentProgram = NULL;
	    for ( GLuint unit = 0; unit < _RGL_MAX_TEXTURE_UNITS; ++unit )
		    _CurrentContext->TextureImageUnits[unit].currentTexture = _RGLGetCurrentTexture( &_CurrentContext->TextureImageUnits[unit], GL_TEXTURE_2D );

	    _CurrentContext->needValidate |= PSGL_VALIDATE_FFX_FRAGMENT_PROGRAM | PSGL_VALIDATE_TEXTURES_USED;
            break;
        default:
            _RGLCgRaiseError( CG_INVALID_PROFILE_ERROR );
            return;
    }

}

CGGL_API GLuint cgGLGetProgramID( CGprogram program )
{

    return 0;
}

CGGL_API void cgGLEnableProgramProfiles( CGprogram program )
{
    return;
}

CGGL_API void cgGLDisableProgramProfiles( CGprogram program )
{
    return;
}


CGGL_API void cgGLSetParameter1f( CGparameter param, float x )
{

    CgRuntimeParameter *ptr = _RGLCgGLTestParameter( param );

    float v[4] = {x, x, x, x};
    ptr->setterIndex( ptr, v, CG_GETINDEX( param ) );
}

CGGL_API void cgGLSetParameter2f( CGparameter param, float x, float y )
{
    CgRuntimeParameter *ptr = _RGLCgGLTestParameter( param );

    float v[4] = {x, y, y, y};
    ptr->setterIndex( ptr, v, CG_GETINDEX( param ) );
}

CGGL_API void cgGLSetParameterPointer( CGparameter param,
                                       GLint fsize,
                                       GLenum type,
                                       GLsizei stride,
                                       const GLvoid *pointer )
{

    CgRuntimeParameter *_ptr = _RGLCgGLTestParameter( param );

    const CgParameterResource *parameterResource = _RGLGetParameterResource( _ptr->program, _ptr->parameterEntry );
    GLuint index = ( GLuint )( parameterResource->resource - CG_ATTR0 );

    _RGLVertexAttribPointerNV(
        index,
        fsize,
        type,
        ( _ptr->parameterEntry->flags & CGP_NORMALIZE ) ? 1 : 0,
        stride,
        pointer );
}

CGGL_API void cgGLEnableClientState( CGparameter param )
{

    CgRuntimeParameter *_ptr = _RGLCgGLTestParameter( param );

    const CgParameterResource *parameterResource = _RGLGetParameterResource( _ptr->program, _ptr->parameterEntry );

    GLuint index = ( GLuint )( parameterResource->resource - CG_ATTR0 );
    _RGLEnableVertexAttribArrayNV( index );
}

CGGL_API void cgGLDisableClientState( CGparameter param )
{
    CgRuntimeParameter *_ptr = _RGLCgGLTestParameter( param );


    const CgParameterResource *parameterResource = _RGLGetParameterResource( _ptr->program, _ptr->parameterEntry );


    GLuint index = ( GLuint )( parameterResource->resource - CG_ATTR0 );
    _RGLDisableVertexAttribArrayNV( index );
}

CGGL_API void cgGLSetStateMatrixParameter( CGparameter param,
        CGGLenum matrix,
        CGGLenum transform )
{
    float m[4][4];
    switch ( matrix )
    {
        case CG_GL_MODELVIEW_MATRIX:
            glGetFloatv( GL_MODELVIEW_MATRIX, ( float* )m );
            break;
        case CG_GL_PROJECTION_MATRIX:
            glGetFloatv( GL_PROJECTION_MATRIX, ( float* )m );
            break;
        case CG_GL_TEXTURE_MATRIX:
            glGetFloatv( GL_TEXTURE_MATRIX, ( float* )m );
            break;
        case CG_GL_MODELVIEW_PROJECTION_MATRIX:
        {
            float mv[4][4], p[4][4];
            glGetFloatv( GL_MODELVIEW_MATRIX, ( float* )mv );
            glGetFloatv( GL_PROJECTION_MATRIX, ( float* )p );

#define M(I,J) \
			m[I][J] = mv[I][0]*p[0][J] + mv[I][1]*p[1][J] + mv[I][2]*p[2][J] + mv[I][3]*p[3][J]
            M( 0, 0 ); M( 0, 1 ); M( 0, 2 ); M( 0, 3 );
            M( 1, 0 ); M( 1, 1 ); M( 1, 2 ); M( 1, 3 );
            M( 2, 0 ); M( 2, 1 ); M( 2, 2 ); M( 2, 3 );
            M( 3, 0 ); M( 3, 1 ); M( 3, 2 ); M( 3, 3 );
#undef M
        }
        break;
        default:
            _RGLCgRaiseError( CG_INVALID_ENUMERANT_ERROR );
            return;
    }

    CgRuntimeParameter* ptr = _RGLCgGLTestParameter( param );

    CGtype parameterType = _RGLGetParameterCGtype( ptr->program, ptr->parameterEntry );
    if ( RGL_LIKELY( parameterType == CG_FLOAT4x4 ) )
    {
        ptr->settercIndex( ptr, m, CG_GETINDEX( param ) );
    }
    else
    {
        float packedmatrix[16];
        unsigned int rows = _RGLGetTypeRowCount( parameterType );
        unsigned int cols = _RGLGetTypeColCount( parameterType );
        for ( GLuint row = 0; row < rows; ++row )
            for ( GLuint j = 0; j < cols; ++j )
                packedmatrix[row*cols + j] = m[j][row];
        ptr->setterrIndex( ptr, packedmatrix, CG_GETINDEX( param ) );
    }
}

CGGL_API void cgGLSetTextureParameter( CGparameter param, GLuint texobj )
{
    CgRuntimeParameter* ptr = _cgGLTestTextureParameter( param );

    ptr->samplerSetter( ptr, &texobj, 0 );
}

CGGL_API void cgGLEnableTextureParameter( CGparameter param )
{
    CgRuntimeParameter* ptr = _cgGLTestTextureParameter( param );
    ptr->samplerSetter( ptr, NULL, 0 );
}

static void _RGLCgContextZero( _CGcontext* p )
{
    memset( p, 0, sizeof( *p ) );
    p->compileType = CG_UNKNOWN;

}

static void _RGLCgContextPushFront( _CGcontext* ctx )
{
    if ( _CurrentContext->RGLcgContextHead )
    {
        _CGcontext* head = _cgGetContextPtr( _CurrentContext->RGLcgContextHead );
        ctx->next = head;
    }
    _CurrentContext->RGLcgContextHead = ctx->id;
}

static void destroy_context( _CGcontext*ctx )
{
    if ( _cgContextDestroyHook ) _cgContextDestroyHook( ctx );
    _RGLEraseName( &_CurrentContext->cgContextNameSpace, ( jsName )ctx->id );
    _RGLCgContextZero( ctx );
    free( ctx );
}

CG_API CGcontext cgCreateContext( void )
{
    _CGcontext* ptr = NULL;

    ptr = ( _CGcontext* )malloc( sizeof( _CGcontext ) );
    if ( NULL == ptr )
    {
        _RGLCgRaiseError( CG_MEMORY_ALLOC_ERROR );
        return ( CGcontext )NULL;
    }

    _RGLCgContextZero( ptr );

    CGcontext result = ( CGcontext )_RGLCreateName( &_CurrentContext->cgContextNameSpace, ptr );
    if ( !result ) { free( ptr ); return NULL; }

    ptr->id = result;
    ptr->defaultProgram.parentContext = ptr;

    _RGLCgContextPushFront( ptr );

    if ( _cgContextCreateHook ) _cgContextCreateHook( ptr );

    return result;
}

CG_API void cgDestroyContext( CGcontext c )
{
    if ( !CG_IS_CONTEXT( c ) )
    {
        _RGLCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR );
        return;
    }

    _CGcontext* ctx = _cgGetContextPtr( c );

    _RGLCgProgramErase( &ctx->defaultProgram );

    while ( ctx->programList )
    {
        _CGprogram * p = ctx->programList;
        ctx->programList = p->next;
	_RGLCgProgramErase( p );
	if(p != NULL)
		free( p );
    }

    _CGcontext * const head = _cgGetContextPtr( _CurrentContext->RGLcgContextHead );
    if ( head != ctx )
    {
        _CGcontext* ptr = head;
        while ( ptr->next != ctx ) ptr = ptr->next;
        ptr->next = ctx->next;
        destroy_context( ctx );
    }
    else
    {

        _CGcontext* second = head->next;
        destroy_context( head );

        if ( second )
        {
            _CurrentContext->RGLcgContextHead = second->id;
        }
        else
        {
            _CurrentContext->RGLcgContextHead = 0;
        }
    }
}

CG_API const char* cgGetLastListing( CGcontext c )
{
    if ( !CG_IS_CONTEXT( c ) )
    {
        _RGLCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR );
        return NULL;
    }

    return NULL;
}

void _RGLCgRaiseError( CGerror error )
{
    _CurrentContext->RGLcgLastError = error;


    printf("RGL: Cg error:%s.\n", cgGetErrorString( error ) );

    if ( _CurrentContext->RGLcgErrorCallbackFunction )
        _CurrentContext->RGLcgErrorCallbackFunction();
}

unsigned int _RGLCountFloatsInCgType( CGtype type )
{
    int size = 0;
    switch ( type )
    {
        case CG_FLOAT:
        case CG_FLOAT1:
        case CG_FLOAT1x1:
            size = 1;
            break;
        case CG_FLOAT2:
        case CG_FLOAT2x1:
        case CG_FLOAT1x2:
            size = 2;
            break;
        case CG_FLOAT3:
        case CG_FLOAT3x1:
        case CG_FLOAT1x3:
            size = 3;
            break;
        case CG_FLOAT4:
        case CG_FLOAT4x1:
        case CG_FLOAT1x4:
        case CG_FLOAT2x2:
            size = 4;
            break;
        case CG_FLOAT2x3:
        case CG_FLOAT3x2:
            size = 6;
            break;
        case CG_FLOAT2x4:
        case CG_FLOAT4x2:
            size = 8;
            break;
        case CG_FLOAT3x3:
            size = 9;
            break;
        case CG_FLOAT3x4:
        case CG_FLOAT4x3:
            size = 12;
            break;
        case CG_FLOAT4x4:
            size = 16;
            break;
        case CG_SAMPLER1D:
        case CG_SAMPLER2D:
        case CG_SAMPLER3D:
        case CG_SAMPLERRECT:
        case CG_SAMPLERCUBE:
        case CG_BOOL:
        case CG_HALF:
        case CG_HALF1:
        case CG_HALF1x1:
            size = 1;
            break;
        case CG_HALF2:
        case CG_HALF2x1:
        case CG_HALF1x2:
            size = 2;
            break;
        case CG_HALF3:
        case CG_HALF3x1:
        case CG_HALF1x3:
            size = 3;
            break;
        case CG_HALF4:
        case CG_HALF4x1:
        case CG_HALF1x4:
        case CG_HALF2x2:
            size = 4;
            break;
        case CG_HALF2x3:
        case CG_HALF3x2:
            size = 6;
            break;
        case CG_HALF2x4:
        case CG_HALF4x2:
            size = 8;
            break;
        case CG_HALF3x3:
            size = 9;
            break;
        case CG_HALF3x4:
        case CG_HALF4x3:
            size = 12;
            break;
        case CG_HALF4x4:
            size = 16;
            break;
        case CG_INT:
        case CG_INT1:
        case CG_INT1x1:
            size = 1;
            break;
        case CG_INT2:
        case CG_INT2x1:
        case CG_INT1x2:
            size = 2;
            break;
        case CG_INT3:
        case CG_INT3x1:
        case CG_INT1x3:
            size = 3;
            break;
        case CG_INT4:
        case CG_INT4x1:
        case CG_INT1x4:
        case CG_INT2x2:
            size = 4;
            break;
        case CG_INT2x3:
        case CG_INT3x2:
            size = 6;
            break;
        case CG_INT2x4:
        case CG_INT4x2:
            size = 8;
            break;
        case CG_INT3x3:
            size = 9;
            break;
        case CG_INT3x4:
        case CG_INT4x3:
            size = 12;
            break;
        case CG_INT4x4:
            size = 16;
            break;
        case CG_BOOL1:
        case CG_BOOL1x1:
            size = 1;
            break;
        case CG_BOOL2:
        case CG_BOOL2x1:
        case CG_BOOL1x2:
            size = 2;
            break;
        case CG_BOOL3:
        case CG_BOOL3x1:
        case CG_BOOL1x3:
            size = 3;
            break;
        case CG_BOOL4:
        case CG_BOOL4x1:
        case CG_BOOL1x4:
        case CG_BOOL2x2:
            size = 4;
            break;
        case CG_BOOL2x3:
        case CG_BOOL3x2:
            size = 6;
            break;
        case CG_BOOL2x4:
        case CG_BOOL4x2:
            size = 8;
            break;
        case CG_BOOL3x3:
            size = 9;
            break;
        case CG_BOOL3x4:
        case CG_BOOL4x3:
            size = 12;
            break;
        case CG_BOOL4x4:
            size = 16;
            break;
        case CG_FIXED:
        case CG_FIXED1:
        case CG_FIXED1x1:
            size = 1;
            break;
        case CG_FIXED2:
        case CG_FIXED2x1:
        case CG_FIXED1x2:
            size = 2;
            break;
        case CG_FIXED3:
        case CG_FIXED3x1:
        case CG_FIXED1x3:
            size = 3;
            break;
        case CG_FIXED4:
        case CG_FIXED4x1:
        case CG_FIXED1x4:
        case CG_FIXED2x2:
            size = 4;
            break;
        case CG_FIXED2x3:
        case CG_FIXED3x2:
            size = 6;
            break;
        case CG_FIXED2x4:
        case CG_FIXED4x2:
            size = 8;
            break;
        case CG_FIXED3x3:
            size = 9;
            break;
        case CG_FIXED3x4:
        case CG_FIXED4x3:
            size = 12;
            break;
        case CG_FIXED4x4:
            size = 16;
            break;
        default:
            size = 0;
            break;
    }
    return size;
}

void _cgRaiseInvalidParam( CgRuntimeParameter*p, const void*v )
{
    _RGLCgRaiseError( CG_INVALID_PARAMETER_ERROR );
}
void _cgRaiseInvalidParamIndex( CgRuntimeParameter*p, const void*v, const int index )
{
    _RGLCgRaiseError( CG_INVALID_PARAMETER_ERROR );
}

void _cgRaiseNotMatrixParam( CgRuntimeParameter*p, const void*v )
{
    _RGLCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR );
}
void _cgRaiseNotMatrixParamIndex( CgRuntimeParameter*p, const void*v, const int index )
{
    _RGLCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR );
}

void _cgIgnoreSetParam( CgRuntimeParameter*p, const void*v )
{
}
void _cgIgnoreSetParamIndex( CgRuntimeParameter*p, const void*v, const int index )
{
}

CgRuntimeParameter* _cgGLTestTextureParameter( CGparameter param )
{
    CgRuntimeParameter* ptr = _RGLCgGLTestParameter( param );
    return ptr;
}


#define CG_DATATYPE_MACRO(name, compiler_name, enum_name, base_enum, nrows, ncols,classname) \
	nrows ,
static int _typesRowCount[] =
    {
#include "Cg/cg_datatypes.h"
    };

#define CG_DATATYPE_MACRO(name, compiler_name, enum_name, base_enum, nrows, ncols,classname) \
	ncols ,
static int _typesColCount[] =
    {
#include "Cg/cg_datatypes.h"
    };

unsigned int _RGLGetTypeRowCount( CGtype parameterType )
{
    int typeIndex = parameterType - 1 - CG_TYPE_START_ENUM;
    return _typesRowCount[typeIndex];
}

unsigned int _RGLGetTypeColCount( CGtype parameterType )
{
    int typeIndex = parameterType - 1 - CG_TYPE_START_ENUM;
    return _typesColCount[typeIndex];
}