mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-16 08:43:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

(RGL) Cleanups

Browse Source
This commit is contained in:
twinaphex 2013-01-03 14:31:25 +01:00
parent d6dca4c3d0
commit 471acec6c9
9 changed files with 272 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
console/rgl/include/RGL/Utils.h
View File

@ -6,8 +6,7 @@
#include "platform.h" #include "platform.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C" {
{
#endif #endif
#ifndef MSVC #ifndef MSVC
@ -87,11 +86,11 @@ extern "C"
// names API // names API
RGL_EXPORT void rglInitNameSpace( struct rglNameSpace * name ); RGL_EXPORT void rglInitNameSpace (void *data);
RGL_EXPORT void rglFreeNameSpace( struct rglNameSpace * name ); RGL_EXPORT void rglFreeNameSpace (void *data);
RGL_EXPORT unsigned int rglCreateName( struct rglNameSpace * ns, void* object ); RGL_EXPORT unsigned int rglCreateName (void *data, void* object);
RGL_EXPORT unsigned int rglIsName( struct rglNameSpace* ns, unsigned int name ); RGL_EXPORT unsigned int rglIsName( void *data, unsigned int name);
RGL_EXPORT void rglEraseName( struct rglNameSpace* ns, unsigned int name ); RGL_EXPORT void rglEraseName (void *data, unsigned int name);
static inline void * rglGetNamedValue( struct rglNameSpace* ns, unsigned int name ) static inline void * rglGetNamedValue( struct rglNameSpace* ns, unsigned int name )
{ {
return ns->data[name - 1]; return ns->data[name - 1];
@ -109,7 +108,7 @@ extern "C"
#ifdef __cplusplus #ifdef __cplusplus
} // Close scope of 'extern "C"' declaration that encloses file. }
#endif #endif
#ifndef RGLT_UNUSED #ifndef RGLT_UNUSED

66
console/rgl/include/RGL/private.h
View File

@ -56,7 +56,7 @@ extern "C"
extern GLuint rglValidateStates( GLuint mask ); extern GLuint rglValidateStates( GLuint mask );
void rglAttachContext( RGLdevice *device, RGLcontext* context ); void rglAttachContext( RGLdevice *device, RGLcontext* context );
void rglDetachContext( RGLdevice *device, RGLcontext* context ); void rglDetachContext( RGLdevice *device, RGLcontext* context );
void rglInvalidateAllStates( RGLcontext* context ); void rglInvalidateAllStates (void *data);
void rglResetAttributeState( rglAttributeState* as ); void rglResetAttributeState( rglAttributeState* as );
void rglSetFlipHandler(void (*handler)(const GLuint head), RGLdevice *device); void rglSetFlipHandler(void (*handler)(const GLuint head), RGLdevice *device);
void rglSetVBlankHandler(void (*handler)(const GLuint head), RGLdevice *device); void rglSetVBlankHandler(void (*handler)(const GLuint head), RGLdevice *device);
@ -64,8 +64,8 @@ extern "C"
//---------------------------------------- //----------------------------------------
// Texture.c // Texture.c
//---------------------------------------- //----------------------------------------
rglTexture *rglAllocateTexture(); rglTexture *rglAllocateTexture (void);
void rglFreeTexture( rglTexture *texture ); void rglFreeTexture (void *data);
void rglTextureUnbind( RGLcontext* context, GLuint name ); void rglTextureUnbind( RGLcontext* context, GLuint name );
extern int rglTextureInit( RGLcontext* context, GLuint name ); extern int rglTextureInit( RGLcontext* context, GLuint name );
extern void rglTextureDelete( RGLcontext* context, GLuint name ); extern void rglTextureDelete( RGLcontext* context, GLuint name );
@ -111,8 +111,8 @@ extern "C"
GLboolean rglIsType( GLenum type ); GLboolean rglIsType( GLenum type );
GLboolean rglIsFormat( GLenum format ); GLboolean rglIsFormat( GLenum format );
GLboolean rglIsValidPair( GLenum format, GLenum type ); GLboolean rglIsValidPair( GLenum format, GLenum type );
void rglImageAllocCPUStorage( rglImage *image ); void rglImageAllocCPUStorage (void *data);
void rglImageFreeCPUStorage( rglImage *image ); void rglImageFreeCPUStorage (void *data);
extern void rglSetImage( rglImage* image, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei alignment, GLenum format, GLenum type, const GLvoid* pixels ); extern void rglSetImage( rglImage* image, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei alignment, GLenum format, GLenum type, const GLvoid* pixels );
extern void rglSetSubImage( GLenum target, GLint level, rglTexture *texture, rglImage* image, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, GLsizei alignment, GLenum format, GLenum type, const GLvoid* pixels ); extern void rglSetSubImage( GLenum target, GLint level, rglTexture *texture, rglImage* image, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, GLsizei alignment, GLenum format, GLenum type, const GLvoid* pixels );
extern int rglGetPixelSize( GLenum format, GLenum type ); extern int rglGetPixelSize( GLenum format, GLenum type );
@ -126,7 +126,7 @@ extern "C"
extern int rglGetStorageSize( GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth ); extern int rglGetStorageSize( GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth );
extern void rglImageToRaster( const rglImage* image, rglRaster* raster, GLuint x, GLuint y, GLuint z ); extern void rglImageToRaster( const rglImage* image, rglRaster* raster, GLuint x, GLuint y, GLuint z );
extern void rglRasterToImage( const rglRaster* raster, rglImage* image, GLuint x, GLuint y, GLuint z ); extern void rglRasterToImage( const rglRaster* raster, rglImage* image, GLuint x, GLuint y, GLuint z );
extern void rglRawRasterToImage( const rglRaster* raster, rglImage* image, GLuint x, GLuint y, GLuint z ); extern void rglRawRasterToImage (const void *in_data, void *out_data, GLuint x, GLuint y, GLuint z);
void rglResampleImage3D( rglImage* src, rglImage* dst ); void rglResampleImage3D( rglImage* src, rglImage* dst );
//---------------------------------------- //----------------------------------------
@ -210,9 +210,9 @@ extern "C"
//---------------------------------------- //----------------------------------------
// Raster/.../PlatformRaster.c // Raster/.../PlatformRaster.c
//---------------------------------------- //----------------------------------------
void* rglPlatformRasterInit(); void* rglPlatformRasterInit (void);
void rglPlatformRasterExit( void* driver ); void rglPlatformRasterExit (void* driver);
void rglPlatformRasterDestroyResources(); void rglPlatformRasterDestroyResources (void);
void rglPlatformDraw( rglDrawParams* dparams ); void rglPlatformDraw( rglDrawParams* dparams );
GLboolean rglPlatformNeedsConversion( const rglAttributeState* as, GLuint index ); GLboolean rglPlatformNeedsConversion( const rglAttributeState* as, GLuint index );
// [YLIN] Try to avoid LHS inside this function. // [YLIN] Try to avoid LHS inside this function.
@ -232,51 +232,19 @@ extern "C"
//---------------------------------------- //----------------------------------------
// Raster/.../PlatformTexture.c // Raster/.../PlatformTexture.c
//---------------------------------------- //----------------------------------------
extern int rglPlatformTextureSize(); extern int rglPlatformTextureSize (void);
extern int rglPlatformTextureMaxUnits(); extern int rglPlatformTextureMaxUnits (void);
extern void rglPlatformCreateTexture( rglTexture* texture ); extern void rglPlatformCreateTexture( rglTexture* texture );
extern void rglPlatformDestroyTexture( rglTexture* texture ); extern void rglPlatformDestroyTexture( rglTexture* texture );
extern void rglPlatformValidateTextureStage( int unit, rglTexture*texture ); extern void rglPlatformValidateTextureStage (int unit, void *data);
void rglPlatformValidateVertexTextures(); void rglPlatformValidateVertexTextures (void);
extern GLenum rglPlatformChooseInternalStorage( rglImage* image, GLenum internalformat ); extern GLenum rglPlatformChooseInternalStorage (void *data, GLenum internalformat);
extern GLenum rglPlatformTranslateTextureFormat( GLenum internalFormat ); extern GLenum rglPlatformTranslateTextureFormat( GLenum internalFormat );
extern void rglPlatformCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ); extern void rglPlatformCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
GLenum rglPlatformChooseInternalFormat( GLenum internalformat ); GLenum rglPlatformChooseInternalFormat( GLenum internalformat );
void rglPlatformExpandInternalFormat( GLenum internalformat, GLenum *format, GLenum *type ); void rglPlatformExpandInternalFormat( GLenum internalformat, GLenum *format, GLenum *type );
void rglPlatformGetImageData( GLenum target, GLint level, rglTexture *texture, rglImage *image ); void rglPlatformGetImageData( GLenum target, GLint level, rglTexture *texture, rglImage *image );
extern void rglPlatformSetCompressedTexture( GLboolean rglPlatformTextureReference (void *data, GLuint pitch, rglBufferObject *bufferObject, GLintptr offset);
GLenum target,
GLint level,
GLenum internalformat,
GLsizei width, GLsizei height, GLsizei depth,
GLint border,
GLsizei imageSize,
const GLvoid* data );
extern void rglPlatformSetCompressedTextureSub(
GLenum target,
GLint level,
GLint xoffset, GLint yoffset, GLint zoffset,
GLsizei width, GLsizei height, GLsizei depth,
GLenum format,
GLsizei imageSize,
const GLvoid* data );
extern GLboolean rglPlatformTexturePBOImage(
rglTexture* texture,
rglImage* image,
GLint level,
GLint internalformat,
GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type,
const GLvoid *offset );
extern GLboolean rglPlatformTexturePBOSubImage(
rglTexture* texture,
rglImage* image,
GLint level,
GLint xoffset, GLint yoffset, GLint zoffset,
GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type,
const GLvoid *pixels );
GLboolean rglPlatformTextureReference( rglTexture *texture, GLuint pitch, rglBufferObject *bufferObject, GLintptr offset );
//---------------------------------------- //----------------------------------------
// Raster/.../PlatformFBops.c // Raster/.../PlatformFBops.c
@ -302,14 +270,14 @@ extern "C"
GLboolean rglPlatformCreateBufferObject( rglBufferObject* bufferObject ); GLboolean rglPlatformCreateBufferObject( rglBufferObject* bufferObject );
void rglPlatformDestroyBufferObject( rglBufferObject* bufferObject ); void rglPlatformDestroyBufferObject( rglBufferObject* bufferObject );
void rglPlatformBufferObjectSetData( rglBufferObject* bufferObject, GLintptr offset, GLsizeiptr size, const GLvoid *data, GLboolean tryImmediateCopy ); void rglPlatformBufferObjectSetData( rglBufferObject* bufferObject, GLintptr offset, GLsizeiptr size, const GLvoid *data, GLboolean tryImmediateCopy );
GLvoid rglPlatformBufferObjectCopyData( rglBufferObject* bufferObjectDst, rglBufferObject* bufferObjectSrc ); GLvoid rglPlatformBufferObjectCopyData (void *dst, void *src);
// map / unmap buffers. Internally refcounted // map / unmap buffers. Internally refcounted
char *rglPlatformBufferObjectMap( rglBufferObject* bufferObject, GLenum access ); char *rglPlatformBufferObjectMap( rglBufferObject* bufferObject, GLenum access );
GLboolean rglPlatformBufferObjectUnmap( rglBufferObject* bufferObject ); GLboolean rglPlatformBufferObjectUnmap( rglBufferObject* bufferObject );
void rglPlatformGetBufferParameteriv( rglBufferObject *bufferObject, GLenum pname, int *params ); void rglPlatformGetBufferParameteriv( rglBufferObject *bufferObject, GLenum pname, int *params );
// this is shared in glBindTexture and cgGL code // this is shared in glBindTexture and cgGL code
RGL_EXPORT void rglBindTextureInternal( rglTextureImageUnit *unit, GLuint name, GLenum target ); RGL_EXPORT void rglBindTextureInternal (void *data, GLuint name, GLenum target);
void rglBindVertexTextureInternal( GLuint unit, GLuint name ); void rglBindVertexTextureInternal( GLuint unit, GLuint name );
//---------------------------------------- //----------------------------------------

56
console/rgl/src/Utils/NameSpace.cpp
View File

@ -5,31 +5,36 @@
#include <string.h> #include <string.h>
void rglInitNameSpace( rglNameSpace * name ) void rglInitNameSpace(void *data)
{ {
rglNameSpace *name = (rglNameSpace*)data;
name->data = NULL; name->data = NULL;
name->firstFree = NULL; name->firstFree = NULL;
name->capacity = 0; name->capacity = 0;
} }
void rglFreeNameSpace( rglNameSpace * ns ) void rglFreeNameSpace(void *data)
{ {
// XXX should we verify all names were freed ? rglNameSpace *name = (rglNameSpace*)data;
if ( ns->data ) { free( ns->data ); }; if (name->data)
ns->data = NULL; free(name->data);
ns->capacity = 0;
ns->firstFree = NULL; name->data = NULL;
name->capacity = 0;
name->firstFree = NULL;
} }
static const int NAME_INCREMENT = 4; static const int NAME_INCREMENT = 4;
unsigned int rglCreateName( rglNameSpace * ns, void* object )
unsigned int rglCreateName(void *data, void* object)
{ {
rglNameSpace *name = (rglNameSpace*)data;
// NULL is reserved for the guard of the linked list. // NULL is reserved for the guard of the linked list.
if (ns->firstFree == NULL) if (name->firstFree == NULL)
{ {
// need to allocate more pointer space // need to allocate more pointer space
int newCapacity = ns->capacity + NAME_INCREMENT; int newCapacity = name->capacity + NAME_INCREMENT;
// realloc the block of pointers // realloc the block of pointers
void** newData = ( void** )malloc( newCapacity * sizeof( void* ) ); void** newData = ( void** )malloc( newCapacity * sizeof( void* ) );
@ -39,37 +44,41 @@ unsigned int rglCreateName( rglNameSpace * ns, void* object )
rglCgRaiseError( CG_MEMORY_ALLOC_ERROR ); rglCgRaiseError( CG_MEMORY_ALLOC_ERROR );
return 0; return 0;
} }
memcpy( newData, ns->data, ns->capacity * sizeof( void* ) ); memcpy( newData, name->data, name->capacity * sizeof( void* ) );
if ( ns->data != NULL ) free( ns->data );
ns->data = newData; if (name->data != NULL)
free (name->data);
name->data = newData;
// initialize the pointers to the next free elements. // initialize the pointers to the next free elements.
// (effectively build a linked list of free elements in place) // (effectively build a linked list of free elements in place)
// treat the last item differently, by linking it to NULL // treat the last item differently, by linking it to NULL
for ( int index = ns->capacity; index < newCapacity - 1; ++index ) for ( int index = name->capacity; index < newCapacity - 1; ++index )
ns->data[index] = ns->data + index + 1; name->data[index] = name->data + index + 1;
ns->data[newCapacity - 1] = NULL; name->data[newCapacity - 1] = NULL;
// update the first free element to the new data pointer. // update the first free element to the new data pointer.
ns->firstFree = ns->data + ns->capacity; name->firstFree = name->data + name->capacity;
// update the new capacity. // update the new capacity.
ns->capacity = newCapacity; name->capacity = newCapacity;
} }
// firstFree is a pointer, compute the index of it // firstFree is a pointer, compute the index of it
unsigned int result = ns->firstFree - ns->data; unsigned int result = name->firstFree - name->data;
// update the first free to the next free element. // update the first free to the next free element.
ns->firstFree = ( void** ) * ns->firstFree; name->firstFree = (void**)*name->firstFree;
// store the object in data. // store the object in data.
ns->data[result] = object; name->data[result] = object;
// offset the index by 1 to avoid the name 0 // offset the index by 1 to avoid the name 0
return result + 1; return result + 1;
} }
unsigned int rglIsName( rglNameSpace* ns, unsigned int name ) unsigned int rglIsName (void *data, unsigned int name )
{ {
rglNameSpace *ns = (rglNameSpace*)data;
// there should always be a namesepace // there should always be a namesepace
// 0 is never valid. // 0 is never valid.
if (RGL_UNLIKELY(name == 0)) if (RGL_UNLIKELY(name == 0))
@ -95,8 +104,9 @@ unsigned int rglIsName( rglNameSpace* ns, unsigned int name )
return 1; return 1;
} }
void rglEraseName( rglNameSpace* ns, unsigned int name ) void rglEraseName(void *data, unsigned int name )
{ {
rglNameSpace *ns = (rglNameSpace*)data;
if (rglIsName(ns, name)) if (rglIsName(ns, name))
{ {
--name; --name;

43
console/rgl/src/ps3/include/GmmAlloc.h
View File

@ -116,15 +116,9 @@ uint32_t gmmInit(
const uint32_t mainSize const uint32_t mainSize
); );
uint32_t gmmDestroy(); uint32_t gmmDestroy(void);
uint32_t gmmIdToOffset(const uint32_t id);
uint32_t gmmIdToOffset( char *gmmIdToAddress(const uint32_t id);
const uint32_t id
);
char *gmmIdToAddress(
const uint32_t id
);
uint32_t gmmFPOffsetToId( uint32_t gmmFPOffsetToId(
const uint32_t offset, const uint32_t offset,
@ -132,21 +126,10 @@ uint32_t gmmFPOffsetToId(
bool bLocalMemory bool bLocalMemory
); );
void gmmPinId( void gmmPinId (const uint32_t id);
const uint32_t id void gmmUnpinId (const uint32_t id);
); uint32_t gmmFree (const uint32_t freeId);
void gmmUpdateFreeList (const uint8_t location);
void gmmUnpinId(
const uint32_t id
);
uint32_t gmmFree(
const uint32_t freeId
);
void gmmUpdateFreeList(
const uint8_t location
);
uint32_t gmmAlloc( uint32_t gmmAlloc(
void *data, void *data,
@ -161,9 +144,7 @@ uint32_t gmmAllocExtendedTileBlock(
const uint32_t tag const uint32_t tag
); );
uint32_t gmmGetBlockSize( uint32_t gmmGetBlockSize (const uint32_t id);
const uint32_t id
);
void gmmSetTileAttrib( void gmmSetTileAttrib(
const uint32_t id, const uint32_t id,
@ -171,13 +152,13 @@ void gmmSetTileAttrib(
void *pData void *pData
); );
void *gmmGetTileData(const uint32_t id); void *gmmGetTileData (const uint32_t id);
void gmmPinAllocations(void); void gmmPinAllocations (void);
void gmmUnpinAllocations(void); void gmmUnpinAllocations (void);
static inline uint8_t gmmIdIsMain(const uint32_t id) static inline uint8_t gmmIdIsMain (const uint32_t id)
{ {
return false; return false;
} }

54
console/rgl/src/ps3/include/rgl-externs.h
View File

@ -1,41 +1,29 @@
void rglGcmFifoFinish(rglGcmFifo *fifo); void rglGcmFifoFinish (rglGcmFifo *fifo);
GLboolean rglGcmFifoReferenceInUse( rglGcmFifo *fifo, GLuint reference ); GLboolean rglGcmFifoReferenceInUse (rglGcmFifo *fifo, GLuint reference);
GLuint rglGcmFifoPutReference( rglGcmFifo *fifo ); GLuint rglGcmFifoPutReference (rglGcmFifo *fifo);
void rglGcmFifoFlush( rglGcmFifo *fifo ); void rglGcmFifoFlush (rglGcmFifo *fifo);
uint32_t * rglGcmFifoWaitForFreeSpace( rglGcmFifo *fifo, GLuint spaceInWords ); uint32_t * rglGcmFifoWaitForFreeSpace (rglGcmFifo *fifo, GLuint spaceInWords);
void rglGcmGetTileRegionInfo( void* data, GLuint *address, GLuint *size ); void rglGcmGetTileRegionInfo (void* data, GLuint *address, GLuint *size);
GLboolean rglGcmTryResizeTileRegion( GLuint address, GLuint size, void* data ); GLboolean rglGcmTryResizeTileRegion( GLuint address, GLuint size, void* data );
void rglGcmTransferData void rglGcmTransferData (GLuint dstId, GLuint dstIdOffset,
( GLint dstPitch, GLuint srcId, GLuint srcIdOffset,
GLuint dstId, GLint srcPitch, GLint bytesPerRow, GLint rowCount);
GLuint dstIdOffset,
GLint dstPitch,
GLuint srcId,
GLuint srcIdOffset,
GLint srcPitch,
GLint bytesPerRow,
GLint rowCount
);
int32_t rglOutOfSpaceCallback( struct CellGcmContextData* fifoContext, uint32_t spaceInWords ); int32_t rglOutOfSpaceCallback (struct CellGcmContextData* fifoContext, uint32_t spaceInWords);
void rglGcmFifoGlSetRenderTarget( rglGcmRenderTargetEx const * const args ); void rglGcmFifoGlSetRenderTarget (rglGcmRenderTargetEx const * const args);
void rglpFifoGlFinish( void ); void rglpFifoGlFinish (void);
void rglCreatePushBuffer( _CGprogram *program ); void rglCreatePushBuffer (void *data);
void rglSetDefaultValuesFP( _CGprogram *program ); void rglSetDefaultValuesFP( _CGprogram *program );
void rglSetDefaultValuesVP( _CGprogram *program ); void rglSetDefaultValuesVP( _CGprogram *program );
void rglGcmSend( unsigned int dstId, unsigned dstOffset, unsigned int pitch, const char *src, unsigned int size ); void rglGcmSend( unsigned int dstId, unsigned dstOffset, unsigned int pitch, const char *src, unsigned int size );
void rglGcmMemcpy( const GLuint dstId, unsigned dstOffset, unsigned int pitch, const GLuint srcId, GLuint srcOffset, unsigned int size ); void rglGcmMemcpy( const GLuint dstId, unsigned dstOffset, unsigned int pitch, const GLuint srcId, GLuint srcOffset, unsigned int size );
void rglPlatformValidateTextureResources( rglTexture *texture ); void rglPlatformValidateTextureResources (void *data);
GLuint rglGetGcmImageOffset( rglGcmTextureLayout *layout, GLuint face, GLuint level ); GLuint rglGetGcmImageOffset (rglGcmTextureLayout *layout, GLuint face, GLuint level );
void rglSetNativeCgFragmentProgram( const GLvoid *header ); void rglSetNativeCgFragmentProgram(const void *data);
void rglGcmFreeTiledSurface( GLuint bufferId ); void rglGcmFreeTiledSurface (GLuint bufferId);
void rglGcmCopySurface( void rglGcmCopySurface(const void *data, GLuint srcX, GLuint srcY,
const rglGcmSurface* src, const void *data_dst, GLuint dstX, GLuint dstY,
GLuint srcX, GLuint srcY, GLuint width, GLuint height, GLboolean writeSync);
const rglGcmSurface* dst, void rglSetNativeCgVertexProgram (const void *data);
GLuint dstX, GLuint dstY,
GLuint width, GLuint height,
GLboolean writeSync);
void rglSetNativeCgVertexProgram( const void *header );

19
console/rgl/src/ps3/include/rgl-inline.h
View File

@ -553,21 +553,14 @@ static inline void rglGcmFifoGlFinishFenceRef( const GLuint ref )
rglGcmFifo *fifo = &rglGcmState_i.fifo; rglGcmFifo *fifo = &rglGcmState_i.fifo;
// wait for completion // wait for completion
for ( ;; ) while (rglGcmFifoReferenceInUse(fifo, ref))
{
// gpu passed reference ?
if ( !rglGcmFifoReferenceInUse( fifo, ref ) )
break;
// avoid polling on bus (interrupts memory traffic)
sys_timer_usleep(10); sys_timer_usleep(10);
}
} }
#define RGLGCM_UTIL_LABEL_INDEX 253 #define RGLGCM_UTIL_LABEL_INDEX 253
// Utility to let RSX wait for complete RSX pipeline idle // Utility to let RSX wait for complete RSX pipeline idle
static inline void rglGcmUtilWaitForIdle() static inline void rglGcmUtilWaitForIdle (void)
{ {
// set write label command in push buffer, and wait // set write label command in push buffer, and wait
// NOTE: this is for RSX to wailt // NOTE: this is for RSX to wailt
@ -686,7 +679,7 @@ static inline void rglGcmFifoGlBlendFunc( rglGcmEnum sf, rglGcmEnum df, rglGcmEn
// Can be used for printing out macro and constant values. // Can be used for printing out macro and constant values.
// example: rglPrintIt( RGLGCM_3DCONST(SET_SURFACE_FORMAT, COLOR, LE_A8R8G8B8) ); // example: rglPrintIt( RGLGCM_3DCONST(SET_SURFACE_FORMAT, COLOR, LE_A8R8G8B8) );
// 00 00 00 08 : 00000000 00000000 00000000 00001000 */ // 00 00 00 08 : 00000000 00000000 00000000 00001000 */
void static inline rglPrintIt( unsigned int v ) void static inline rglPrintIt (unsigned int v )
{ {
// HEX (space between bytes) // HEX (space between bytes)
printf( "%02x %02x %02x %02x : ", ( v >> 24 )&0xff, ( v >> 16 )&0xff, ( v >> 8 )&0xff, v&0xff ); printf( "%02x %02x %02x %02x : ", ( v >> 24 )&0xff, ( v >> 16 )&0xff, ( v >> 8 )&0xff, v&0xff );
@ -925,9 +918,11 @@ static inline void rglGcmFifoGlDisable( rglGcmEnum cap )
} }
} }
static inline void rglFifoGlProgramParameterfvVP( const _CGprogram *program, const CgParameterEntry *parameterEntry, const GLfloat *value ) static inline void rglFifoGlProgramParameterfvVP (const void *data, const CgParameterEntry *parameterEntry, const GLfloat *value)
{ {
const _CGprogram *program = (const _CGprogram*)data;
const CgParameterResource *parameterResource = rglGetParameterResource( program, parameterEntry ); const CgParameterResource *parameterResource = rglGetParameterResource( program, parameterEntry );
if ( parameterResource->resource != ( unsigned short ) - 1 ) if ( parameterResource->resource != ( unsigned short ) - 1 )
{ {
switch ( parameterResource->type ) switch ( parameterResource->type )
@ -1028,7 +1023,7 @@ static inline void rglFifoGlProgramParameterfvVP( const _CGprogram *program, con
} }
// Look up the memory location of a buffer object (VBO, PBO) // Look up the memory location of a buffer object (VBO, PBO)
static inline GLuint rglGcmGetBufferObjectOrigin( GLuint buffer ) static inline GLuint rglGcmGetBufferObjectOrigin (GLuint buffer)
{ {
rglBufferObject *bufferObject = (rglBufferObject*)_CurrentContext->bufferObjectNameSpace.data[buffer]; rglBufferObject *bufferObject = (rglBufferObject*)_CurrentContext->bufferObjectNameSpace.data[buffer];
rglGcmBufferObject *gcmBuffer = ( rglGcmBufferObject * ) & bufferObject->platformBufferObject; rglGcmBufferObject *gcmBuffer = ( rglGcmBufferObject * ) & bufferObject->platformBufferObject;

76
console/rgl/src/ps3/rgl_ps3.cpp
View File

@ -384,9 +384,7 @@ uint32_t gmmIdToOffset(const uint32_t id)
return offset; return offset;
} }
char *gmmIdToAddress( char *gmmIdToAddress (const uint32_t id)
const uint32_t id
)
{ {
GmmBaseBlock *pBaseBlock = (GmmBaseBlock *)id; GmmBaseBlock *pBaseBlock = (GmmBaseBlock *)id;
@ -704,8 +702,9 @@ static GmmTileBlock *gmmAllocTileBlock(GmmAllocator *pAllocator,
return pBlock; return pBlock;
} }
static void gmmFreeBlock(GmmBlock *pBlock) static void gmmFreeBlock (void *data)
{ {
GmmBlock *pBlock = (GmmBlock*)data;
GmmAllocator *pAllocator; GmmAllocator *pAllocator;
if (pBlock->pPrev) if (pBlock->pPrev)
@ -745,7 +744,7 @@ static void gmmFreeBlock(GmmBlock *pBlock)
gmmFreeFixedBlock(pBlock); gmmFreeFixedBlock(pBlock);
} }
static void gmmAddPendingFree(void *data) static void gmmAddPendingFree (void *data)
{ {
GmmBlock *pBlock = (GmmBlock*)data; GmmBlock *pBlock = (GmmBlock*)data;
GmmAllocator *pAllocator; GmmAllocator *pAllocator;
@ -1224,14 +1223,10 @@ static void gmmRemovePendingFree(
void gmmUpdateFreeList(const uint8_t location) void gmmUpdateFreeList(const uint8_t location)
{ {
GmmAllocator *pAllocator;
const uint32_t fence = rglGcmState_i.semaphores->userSemaphores[RGLGCM_SEMA_FENCE].val; const uint32_t fence = rglGcmState_i.semaphores->userSemaphores[RGLGCM_SEMA_FENCE].val;
GmmBlock *pBlock = NULL; GmmBlock *pBlock = NULL;
GmmBlock *pTemp = NULL; GmmBlock *pTemp = NULL;
GmmAllocator *pAllocator = pGmmLocalAllocator;
pAllocator = pGmmLocalAllocator;
pBlock = pAllocator->pPendingFreeHead; pBlock = pAllocator->pPendingFreeHead;
@ -1251,12 +1246,9 @@ void gmmUpdateFreeList(const uint8_t location)
static void gmmFreeAll(const uint8_t location) static void gmmFreeAll(const uint8_t location)
{ {
GmmAllocator *pAllocator;
GmmBlock *pBlock; GmmBlock *pBlock;
GmmBlock *pTemp; GmmBlock *pTemp;
GmmAllocator *pAllocator = pGmmLocalAllocator;
pAllocator = pGmmLocalAllocator;
pBlock = pAllocator->pPendingFreeHead; pBlock = pAllocator->pPendingFreeHead;
while (pBlock) while (pBlock)
@ -1444,31 +1436,31 @@ uint32_t gmmAlloc(void *data, const uint8_t location,
FRAGMENT SHADER FRAGMENT SHADER
============================================================ */ ============================================================ */
void rglSetNativeCgFragmentProgram(const void *header) void rglSetNativeCgFragmentProgram(const void *data)
{ {
const _CGprogram *ps = (const _CGprogram *)header; const _CGprogram *program = (const _CGprogram *)data;
CellCgbFragmentProgramConfiguration conf; CellCgbFragmentProgramConfiguration conf;
conf.offset = gmmIdToOffset(ps->loadProgramId) + ps->loadProgramOffset; conf.offset = gmmIdToOffset(program->loadProgramId) + program->loadProgramOffset;
rglGcmInterpolantState *s = &rglGcmState_i.state.interpolant; rglGcmInterpolantState *s = &rglGcmState_i.state.interpolant;
s->fragmentProgramAttribMask |= ps->header.attributeInputMask | CELL_GCM_ATTRIB_OUTPUT_MASK_POINTSIZE; s->fragmentProgramAttribMask |= program->header.attributeInputMask | CELL_GCM_ATTRIB_OUTPUT_MASK_POINTSIZE;
conf.attributeInputMask = ( s->vertexProgramAttribMask) & conf.attributeInputMask = ( s->vertexProgramAttribMask) &
s->fragmentProgramAttribMask; s->fragmentProgramAttribMask;
conf.texCoordsInputMask = ps->header.fragmentProgram.texcoordInputMask; conf.texCoordsInputMask = program->header.fragmentProgram.texcoordInputMask;
conf.texCoords2D = ps->header.fragmentProgram.texcoord2d; conf.texCoords2D = program->header.fragmentProgram.texcoord2d;
conf.texCoordsCentroid = ps->header.fragmentProgram.texcoordCentroid; conf.texCoordsCentroid = program->header.fragmentProgram.texcoordCentroid;
int fragmentControl = ( 1 << 15 ) | ( 1 << 10 ); int fragmentControl = ( 1 << 15 ) | ( 1 << 10 );
fragmentControl |= ps->header.fragmentProgram.flags & CGF_DEPTHREPLACE ? 0xE : 0x0; fragmentControl |= program->header.fragmentProgram.flags & CGF_DEPTHREPLACE ? 0xE : 0x0;
fragmentControl |= ps->header.fragmentProgram.flags & CGF_OUTPUTFROMH0 ? 0x00 : 0x40; fragmentControl |= program->header.fragmentProgram.flags & CGF_OUTPUTFROMH0 ? 0x00 : 0x40;
fragmentControl |= ps->header.fragmentProgram.flags & CGF_PIXELKILL ? 0x80 : 0x00; fragmentControl |= program->header.fragmentProgram.flags & CGF_PIXELKILL ? 0x80 : 0x00;
conf.fragmentControl = fragmentControl; conf.fragmentControl = fragmentControl;
conf.registerCount = ps->header.fragmentProgram.registerCount < 2 ? 2 : ps->header.fragmentProgram.registerCount; conf.registerCount = program->header.fragmentProgram.registerCount < 2 ? 2 : program->header.fragmentProgram.registerCount;
uint32_t controlTxp = _CurrentContext->AllowTXPDemotion; uint32_t controlTxp = _CurrentContext->AllowTXPDemotion;
conf.fragmentControl &= ~CELL_GCM_MASK_SET_SHADER_CONTROL_CONTROL_TXP; conf.fragmentControl &= ~CELL_GCM_MASK_SET_SHADER_CONTROL_CONTROL_TXP;
@ -1476,41 +1468,41 @@ void rglSetNativeCgFragmentProgram(const void *header)
GCM_FUNC( cellGcmSetFragmentProgramLoad, &conf ); GCM_FUNC( cellGcmSetFragmentProgramLoad, &conf );
GCM_FUNC( cellGcmSetZMinMaxControl, ( ps->header.fragmentProgram.flags & CGF_DEPTHREPLACE ) ? RGLGCM_FALSE : RGLGCM_TRUE, RGLGCM_FALSE, RGLGCM_FALSE ); GCM_FUNC( cellGcmSetZMinMaxControl, ( program->header.fragmentProgram.flags & CGF_DEPTHREPLACE ) ? RGLGCM_FALSE : RGLGCM_TRUE, RGLGCM_FALSE, RGLGCM_FALSE );
} }
/*============================================================ /*============================================================
VERTEX SHADER VERTEX SHADER
============================================================ */ ============================================================ */
void rglSetNativeCgVertexProgram(const void *header) void rglSetNativeCgVertexProgram(const void *data)
{ {
const _CGprogram *vs = (const _CGprogram*) header; const _CGprogram *program = (const _CGprogram*)data;
__dcbt(vs->ucode); __dcbt(program->ucode);
__dcbt(((uint8_t*)vs->ucode)+128); __dcbt(((uint8_t*)program->ucode)+128);
__dcbt(((uint8_t*)vs->ucode)+256); __dcbt(((uint8_t*)program->ucode)+256);
__dcbt(((uint8_t*)vs->ucode)+384); __dcbt(((uint8_t*)program->ucode)+384);
CellCgbVertexProgramConfiguration conf; CellCgbVertexProgramConfiguration conf;
conf.instructionSlot = vs->header.vertexProgram.instructionSlot; conf.instructionSlot = program->header.vertexProgram.instructionSlot;
conf.instructionCount = vs->header.instructionCount; conf.instructionCount = program->header.instructionCount;
conf.registerCount = vs->header.vertexProgram.registerCount; conf.registerCount = program->header.vertexProgram.registerCount;
conf.attributeInputMask = vs->header.attributeInputMask; conf.attributeInputMask = program->header.attributeInputMask;
rglGcmFifoWaitForFreeSpace( &rglGcmState_i.fifo, 7 + 5 * conf.instructionCount ); rglGcmFifoWaitForFreeSpace( &rglGcmState_i.fifo, 7 + 5 * conf.instructionCount );
GCM_FUNC( cellGcmSetVertexProgramLoad, &conf, vs->ucode ); GCM_FUNC( cellGcmSetVertexProgramLoad, &conf, program->ucode );
GCM_FUNC( cellGcmSetUserClipPlaneControl, 0, 0, 0, 0, 0, 0 ); GCM_FUNC( cellGcmSetUserClipPlaneControl, 0, 0, 0, 0, 0, 0 );
rglGcmInterpolantState *s = &rglGcmState_i.state.interpolant; rglGcmInterpolantState *s = &rglGcmState_i.state.interpolant;
s->vertexProgramAttribMask = vs->header.vertexProgram.attributeOutputMask; s->vertexProgramAttribMask = program->header.vertexProgram.attributeOutputMask;
GCM_FUNC( cellGcmSetVertexAttribOutputMask, (( s->vertexProgramAttribMask) & GCM_FUNC( cellGcmSetVertexAttribOutputMask, (( s->vertexProgramAttribMask) &
s->fragmentProgramAttribMask) ); s->fragmentProgramAttribMask) );
_CGprogram *program = ( _CGprogram* )vs; program = (_CGprogram*)data;
int count = program->defaultValuesIndexCount; int count = program->defaultValuesIndexCount;
for ( int i = 0;i < count;i++ ) for ( int i = 0;i < count;i++ )
{ {
@ -1529,13 +1521,15 @@ void rglSetNativeCgVertexProgram(const void *header)
============================================================ */ ============================================================ */
void rglGcmCopySurface( void rglGcmCopySurface(
const rglGcmSurface* src, const void *data,
GLuint srcX, GLuint srcY, GLuint srcX, GLuint srcY,
const rglGcmSurface* dst, const void *data_dst,
GLuint dstX, GLuint dstY, GLuint dstX, GLuint dstY,
GLuint width, GLuint height, GLuint width, GLuint height,
GLboolean writeSync ) // don't overwrite dst directly (not used yet) GLboolean writeSync ) // don't overwrite dst directly (not used yet)
{ {
const rglGcmSurface *src = (const rglGcmSurface*)data;
const rglGcmSurface *dst = (const rglGcmSurface*)data_dst;
const GLuint srcPitch = src->pitch ? src->pitch : src->bpp * src->width; const GLuint srcPitch = src->pitch ? src->pitch : src->bpp * src->width;
const GLuint dstPitch = dst->pitch ? dst->pitch : dst->bpp * dst->width; const GLuint dstPitch = dst->pitch ? dst->pitch : dst->bpp * dst->width;

187
console/rgl/src/ps3/rgl_ps3_raster.cpp
View File

@ -61,10 +61,11 @@ static void setAttribConstantIndex( CgRuntimeParameter* __restrict ptr, const vo
rglVertexAttrib4fNV( index, f[0], f[1], f[2], f[3] ); rglVertexAttrib4fNV( index, f[0], f[1], f[2], f[3] );
} }
void rglPlatformSetVertexRegister4fv( unsigned int reg, const float * __restrict v ) void rglPlatformSetVertexRegister4fv (unsigned int reg, const float * __restrict v)
{ {
// save to shared memory for context restore after flip // save to shared memory for context restore after flip
__builtin_memcpy( rglGetGcmDriver()->sharedVPConstants + reg*4*sizeof( float ), v, 4*sizeof( float ) ); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
__builtin_memcpy(driver->sharedVPConstants + reg*4*sizeof( float ), v, 4*sizeof( float ) );
GCM_FUNC( cellGcmSetVertexProgramParameterBlock, reg, 1, v ); GCM_FUNC( cellGcmSetVertexProgramParameterBlock, reg, 1, v );
} }
@ -81,11 +82,6 @@ void rglPlatformSetVertexRegister4fv( unsigned int reg, const float * __restrict
//here ec has been advanced and is already on top of the embedded constant count //here ec has been advanced and is already on top of the embedded constant count
template<int SIZE> inline static void swapandsetfp( int ucodeSize, unsigned int loadProgramId, unsigned int loadProgramOffset, unsigned short *ec, const unsigned int * __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 )
{ {
//unsigned int v2[4];
//for (long i=0; i < SIZE; ++i)
//{
// v2[i] = SWAP_IF_BIG_ENDIAN(v[i]);
//}
GCM_FUNC( cellGcmSetTransferLocation, CELL_GCM_LOCATION_LOCAL ); GCM_FUNC( cellGcmSetTransferLocation, CELL_GCM_LOCATION_LOCAL );
unsigned short count = *( ec++ ); unsigned short count = *( ec++ );
for ( unsigned long offsetIndex = 0; offsetIndex < count; ++offsetIndex ) for ( unsigned long offsetIndex = 0; offsetIndex < count; ++offsetIndex )
@ -124,7 +120,7 @@ template<int SIZE> static void setVectorTypefp( CgRuntimeParameter* __restrict p
template<int SIZE> static void setVectorTypeSharedfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int /*index*/ ) template<int SIZE> static void setVectorTypeSharedfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int /*index*/ )
{ {
RGLcontext * LContext = _CurrentContext; RGLcontext * LContext = _CurrentContext;
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry ); const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry );
unsigned short resource = parameterResource->resource; unsigned short resource = parameterResource->resource;
unsigned short sharedResource = *(( unsigned short * )( ptr->program->resources ) + resource ); unsigned short sharedResource = *(( unsigned short * )( ptr->program->resources ) + resource );
@ -146,7 +142,7 @@ template<int SIZE> static void setVectorTypeSharedfpIndex( CgRuntimeParameter* _
template<int SIZE> static void setVectorTypeSharedfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index ) template<int SIZE> static void setVectorTypeSharedfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{ {
RGLcontext * LContext = _CurrentContext; RGLcontext * LContext = _CurrentContext;
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry ); const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry );
unsigned short resource = parameterResource->resource; unsigned short resource = parameterResource->resource;
@ -320,7 +316,7 @@ template <int ROWS, int COLS, int ORDER> static void setMatrixSharedvpIndexArray
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 setMatrixSharedfpIndex( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int /*index*/ )
{ {
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry ); const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry );
unsigned short resource = parameterResource->resource; unsigned short resource = parameterResource->resource;
@ -360,7 +356,7 @@ template <int ROWS, int COLS, int ORDER> static void setMatrixSharedfpIndex( CgR
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 setMatrixSharedfpIndexArray( CgRuntimeParameter* __restrict ptr, const void* __restrict v, const int index )
{ {
//TODO: double check for the semi endian swap... not done here, is it done by the RSX ? //TODO: double check for the semi endian swap... not done here, is it done by the RSX ?
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry ); const CgParameterResource *parameterResource = rglGetParameterResource( ptr->program, ptr->parameterEntry );
unsigned short resource = parameterResource->resource; unsigned short resource = parameterResource->resource;
@ -575,9 +571,7 @@ static void setSamplerfp( CgRuntimeParameter*ptr, const void*v, int ) //index
// the spec says that the set should not cause the bind // the spec says that the set should not cause the bind
// so only do the bind when the call comes from cgGLEnableTextureParameter // so only do the bind when the call comes from cgGLEnableTextureParameter
if ( v ) if ( v )
{
*( GLuint* )ptr->pushBufferPointer = *( GLuint* )v; *( GLuint* )ptr->pushBufferPointer = *( GLuint* )v;
}
else else
{ {
rglTextureImageUnit *unit = _CurrentContext->TextureImageUnits + ( parameterResource->resource - CG_TEXUNIT0 ); rglTextureImageUnit *unit = _CurrentContext->TextureImageUnits + ( parameterResource->resource - CG_TEXUNIT0 );
@ -608,8 +602,10 @@ static void setSamplervp( CgRuntimeParameter*ptr, const void*v, int ) //index
#define COL_MAJOR 1 #define COL_MAJOR 1
//This function creates the push buffer and the related structures //This function creates the push buffer and the related structures
void rglCreatePushBuffer( _CGprogram *program ) void rglCreatePushBuffer(void *data)
{ {
_CGprogram *program = (_CGprogram*)data;
//first pass to compute the space needed //first pass to compute the space needed
int bufferSize = 0; int bufferSize = 0;
int programPushBufferPointersSize = 0; int programPushBufferPointersSize = 0;
@ -882,11 +878,10 @@ void rglCreatePushBuffer( _CGprogram *program )
} }
else else
{ {
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
if ( parameterEntry->flags & CGP_CONTIGUOUS ) if ( parameterEntry->flags & CGP_CONTIGUOUS )
{
rtParameter->pushBufferPointer = driver->sharedVPConstants + parameterResource->resource * 4 * sizeof( float ); rtParameter->pushBufferPointer = driver->sharedVPConstants + parameterResource->resource * 4 * sizeof( float );
}
else else
{ {
int registerStride = isMatrix(( CGtype )parameterResource->type ) ? rglGetTypeRowCount(( CGtype )parameterResource->type ) : 1; int registerStride = isMatrix(( CGtype )parameterResource->type ) ? rglGetTypeRowCount(( CGtype )parameterResource->type ) : 1;
@ -1252,6 +1247,7 @@ void rglPlatformDestroyBufferObject( rglBufferObject* bufferObject )
void rglPlatformBufferObjectSetData( rglBufferObject* bufferObject, GLintptr offset, GLsizeiptr size, const GLvoid *data, GLboolean tryImmediateCopy ) void rglPlatformBufferObjectSetData( rglBufferObject* bufferObject, GLintptr offset, GLsizeiptr size, const GLvoid *data, GLboolean tryImmediateCopy )
{ {
rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
rglGcmBufferObject *rglBuffer = ( rglGcmBufferObject * )bufferObject->platformBufferObject; rglGcmBufferObject *rglBuffer = ( rglGcmBufferObject * )bufferObject->platformBufferObject;
if ( size == bufferObject->size && tryImmediateCopy ) if ( size == bufferObject->size && tryImmediateCopy )
@ -1292,15 +1288,17 @@ void rglPlatformBufferObjectSetData( rglBufferObject* bufferObject, GLintptr off
} }
// be conservative here. Whenever we write to any Buffer Object, invalidate the vertex cache // be conservative here. Whenever we write to any Buffer Object, invalidate the vertex cache
rglGetGcmDriver()->invalidateVertexCache = GL_TRUE; driver->invalidateVertexCache = GL_TRUE;
} }
GLvoid rglPlatformBufferObjectCopyData( GLvoid rglPlatformBufferObjectCopyData(void *bufferObjectDst, void *bufferObjectSrc)
rglBufferObject* bufferObjectDst,
rglBufferObject* bufferObjectSrc )
{ {
rglGcmBufferObject* dst = ( rglGcmBufferObject* )bufferObjectDst->platformBufferObject; rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
rglGcmBufferObject* src = ( rglGcmBufferObject* )bufferObjectSrc->platformBufferObject;
rglBufferObject *in_dst = (rglBufferObject*)bufferObjectDst;
rglBufferObject *in_src = (rglBufferObject*)bufferObjectSrc;
rglGcmBufferObject* dst = (rglGcmBufferObject*)in_dst->platformBufferObject;
rglGcmBufferObject* src = (rglGcmBufferObject*)in_src->platformBufferObject;
// copy data // copy data
// There is currently no requirement to copy from one pool to another. // There is currently no requirement to copy from one pool to another.
@ -1308,7 +1306,7 @@ GLvoid rglPlatformBufferObjectCopyData(
rglGcmMemcpy( dst->bufferId, 0, dst->pitch, src->bufferId, 0, src->bufferSize ); rglGcmMemcpy( dst->bufferId, 0, dst->pitch, src->bufferId, 0, src->bufferSize );
// be conservative here. Whenever we write to any Buffer Object, invalidate the vertex cache // be conservative here. Whenever we write to any Buffer Object, invalidate the vertex cache
rglGetGcmDriver()->invalidateVertexCache = GL_TRUE; driver->invalidateVertexCache = GL_TRUE;
} }
char *rglPlatformBufferObjectMap( rglBufferObject* bufferObject, GLenum access ) char *rglPlatformBufferObjectMap( rglBufferObject* bufferObject, GLenum access )
@ -1339,7 +1337,7 @@ char *rglPlatformBufferObjectMap( rglBufferObject* bufferObject, GLenum access )
// flush the vertex cache in case VBO data has been modified. // flush the vertex cache in case VBO data has been modified.
if ( rglBuffer->mapAccess != GL_READ_ONLY ) if ( rglBuffer->mapAccess != GL_READ_ONLY )
{ {
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
++driver->flushBufferCount; ++driver->flushBufferCount;
} }
@ -1362,7 +1360,7 @@ GLboolean rglPlatformBufferObjectUnmap( rglBufferObject* bufferObject )
// flush the vertex cache in case VBO data has been modified. // flush the vertex cache in case VBO data has been modified.
if ( rglBuffer->mapAccess != GL_READ_ONLY ) if ( rglBuffer->mapAccess != GL_READ_ONLY )
{ {
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
--driver->flushBufferCount; --driver->flushBufferCount;
// make sure we flush for the next draw // make sure we flush for the next draw
@ -1384,17 +1382,22 @@ GLboolean rglPlatformBufferObjectUnmap( rglBufferObject* bufferObject )
void rglFBClear( GLbitfield mask ) void rglFBClear( GLbitfield mask )
{ {
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
rglGcmDriver *driver = rglGetGcmDriver(); if (!driver->rtValid)
if ( !driver->rtValid ) return; return;
GLbitfield newmask = 0; GLbitfield newmask = 0;
if (( mask & GL_COLOR_BUFFER_BIT ) && driver->rt.colorBufferCount ) newmask |= RGLGCM_COLOR_BUFFER_BIT;
if ((mask & GL_COLOR_BUFFER_BIT) && driver->rt.colorBufferCount)
newmask |= RGLGCM_COLOR_BUFFER_BIT;
if ( !newmask ) return; if (!newmask)
return;
GLbitfield clearMask = newmask; GLbitfield clearMask = newmask;
if ( driver->rt.colorFormat != RGLGCM_ARGB8 ) clearMask &= ~RGLGCM_COLOR_BUFFER_BIT; if (driver->rt.colorFormat != RGLGCM_ARGB8)
clearMask &= ~RGLGCM_COLOR_BUFFER_BIT;
// always use quad clear for colors with MRT // always use quad clear for colors with MRT
// There is one global clear mask for all render targets. This doesn't // There is one global clear mask for all render targets. This doesn't
@ -1497,13 +1500,10 @@ GLenum rglPlatformFramebufferCheckStatus( rglFramebuffer* framebuffer )
&colorTexture, &colorTexture,
&colorFace ); &colorFace );
// TODO: Complete texture may not be required. // TODO: Complete texture may not be required.
if ( colorTexture != NULL ) if (colorTexture != NULL)
{ {
if ( colorTexture->referenceBuffer && !colorTexture->isRenderTarget ) if (colorTexture->referenceBuffer && !colorTexture->isRenderTarget)
{
//RGL_REPORT_EXTRA( RGL_REPORT_FRAMEBUFFER_UNSUPPORTED, "Framebuffer color attachment texture is a reference in a format that cannot be rendered to (swizzled texture, smaller than 16x16 or with more than 32 bits per pixel)" );
return GL_FRAMEBUFFER_UNSUPPORTED_OES; return GL_FRAMEBUFFER_UNSUPPORTED_OES;
}
// all attachments must have the same dimensions // all attachments must have the same dimensions
image[nBuffers] = colorTexture->image; image[nBuffers] = colorTexture->image;
@ -1516,10 +1516,8 @@ GLenum rglPlatformFramebufferCheckStatus( rglFramebuffer* framebuffer )
// all color attachments need the same format // all color attachments need the same format
if ( colorFormat && colorFormat != image[nBuffers]->internalFormat ) if ( colorFormat && colorFormat != image[nBuffers]->internalFormat )
{
//RGL_REPORT_EXTRA( RGL_REPORT_FRAMEBUFFER_INCOMPLETE, "Framebuffer attachments have inconsistent color formats" );
return GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES; return GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES;
}
colorFormat = image[nBuffers]->internalFormat; colorFormat = image[nBuffers]->internalFormat;
++nBuffers; ++nBuffers;
@ -1530,10 +1528,8 @@ GLenum rglPlatformFramebufferCheckStatus( rglFramebuffer* framebuffer )
if ( nBuffers ) if ( nBuffers )
{ {
if ( !rglIsDrawableColorFormat( colorFormat ) ) if ( !rglIsDrawableColorFormat( colorFormat ) )
{
//RGL_REPORT_EXTRA( RGL_REPORT_FRAMEBUFFER_UNSUPPORTED, "Color attachment to framebuffer must be a supported drawable format (GL_ARGB_SCE, GL_RGB16F_ARB, GL_RGBA16F_ARB, GL_RGB32F_ARB, GL_RGBA32F_ARB, GL_LUMINANCE32F_ARB)" );
return GL_FRAMEBUFFER_UNSUPPORTED_OES; return GL_FRAMEBUFFER_UNSUPPORTED_OES;
}
switch ( colorFormat ) switch ( colorFormat )
{ {
case RGLGCM_ARGB8: case RGLGCM_ARGB8:
@ -1563,8 +1559,10 @@ GLenum rglPlatformFramebufferCheckStatus( rglFramebuffer* framebuffer )
void rglPlatformFramebuffer::validate( RGLcontext *LContext ) void rglPlatformFramebuffer::validate( RGLcontext *LContext )
{ {
complete = ( rglPlatformFramebufferCheckStatus( this ) == GL_FRAMEBUFFER_COMPLETE_OES ); complete = (rglPlatformFramebufferCheckStatus(this) == GL_FRAMEBUFFER_COMPLETE_OES);
if ( !complete ) return;
if (!complete)
return;
GLuint width = RGLGCM_MAX_RT_DIMENSION; GLuint width = RGLGCM_MAX_RT_DIMENSION;
GLuint height = RGLGCM_MAX_RT_DIMENSION; GLuint height = RGLGCM_MAX_RT_DIMENSION;
@ -1578,6 +1576,7 @@ void rglPlatformFramebuffer::validate( RGLcontext *LContext )
GLuint defaultPitch = 0; GLuint defaultPitch = 0;
GLuint defaultId = GMM_ERROR; GLuint defaultId = GMM_ERROR;
GLuint defaultIdOffset = 0; GLuint defaultIdOffset = 0;
for ( int i = 0; i < RGLGCM_SETRENDERTARGET_MAXCOUNT; ++i ) for ( int i = 0; i < RGLGCM_SETRENDERTARGET_MAXCOUNT; ++i )
{ {
// get the texture and face // get the texture and face
@ -1641,17 +1640,19 @@ void rglValidateFramebuffer( void )
rglGcmDevice *gcmDevice = ( rglGcmDevice * )LDevice->platformDevice; rglGcmDevice *gcmDevice = ( rglGcmDevice * )LDevice->platformDevice;
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglGcmDriver * gcmDriver = rglGetGcmDriver(); rglGcmDriver *gcmDriver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
// reset buffer data // reset buffer data
gcmDriver->rtValid = GL_FALSE; gcmDriver->rtValid = GL_FALSE;
// get buffer parameters // get buffer parameters
// This may come from a framebuffer_object or the default framebuffer. // This may come from a framebuffer_object or the default framebuffer.
if ( LContext->framebuffer )
if (LContext->framebuffer)
{ {
rglPlatformFramebuffer* framebuffer = static_cast<rglPlatformFramebuffer *>( rglGetFramebuffer( LContext, LContext->framebuffer ) ); rglPlatformFramebuffer* framebuffer = static_cast<rglPlatformFramebuffer *>( rglGetFramebuffer( LContext, LContext->framebuffer ) );
if ( framebuffer->needValidate ) framebuffer->validate( LContext ); if (framebuffer->needValidate)
framebuffer->validate( LContext );
gcmDriver->rt = framebuffer->rt; gcmDriver->rt = framebuffer->rt;
} }
@ -1680,7 +1681,7 @@ void rglValidateFramebuffer( void )
// Initialize the driver and setup the fixed function pipeline // Initialize the driver and setup the fixed function pipeline
// shader and needed connections between GL state and the shader // shader and needed connections between GL state and the shader
void *rglPlatformRasterInit() void *rglPlatformRasterInit (void)
{ {
rglpFifoGlFinish(); rglpFifoGlFinish();
rglGcmDriver *driver = ( rglGcmDriver * )malloc( sizeof( rglGcmDriver ) ); rglGcmDriver *driver = ( rglGcmDriver * )malloc( sizeof( rglGcmDriver ) );
@ -1700,9 +1701,9 @@ void *rglPlatformRasterInit()
} }
// Destroy the driver, and free all its used memory // Destroy the driver, and free all its used memory
void rglPlatformRasterExit( void *drv ) void rglPlatformRasterExit (void *data)
{ {
rglGcmDriver *driver = ( rglGcmDriver * )drv; rglGcmDriver *driver = (rglGcmDriver*)data;
gmmFree( driver->sharedFPConstantsId ); gmmFree( driver->sharedFPConstantsId );
free( driver->sharedVPConstants ); free( driver->sharedVPConstants );
@ -1725,7 +1726,8 @@ extern bool _cellRSXFifoDisassembleToFileMask;
// memory setup operations first // memory setup operations first
void rglPlatformDraw( rglDrawParams* dparams ) void rglPlatformDraw( rglDrawParams* dparams )
{ {
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
if (RGL_UNLIKELY(!driver->rtValid)) if (RGL_UNLIKELY(!driver->rtValid))
return; return;
@ -1760,17 +1762,15 @@ void rglPlatformDraw( rglDrawParams* dparams )
gmmIdToOffset( driver->fpLoadProgramId ) + driver->fpLoadProgramOffset ); gmmIdToOffset( driver->fpLoadProgramId ) + driver->fpLoadProgramOffset );
} }
// glDrawArrays()
rglGcmFifoGlDrawArrays(( rglGcmEnum )dparams->mode, dparams->firstVertex, dparams->vertexCount ); rglGcmFifoGlDrawArrays(( rglGcmEnum )dparams->mode, dparams->firstVertex, dparams->vertexCount );
} }
// Set up the current fragment program on hardware // Set up the current fragment program on hardware
void rglValidateFragmentProgram() void rglValidateFragmentProgram (void)
{ {
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
_CGprogram *program = LContext->BoundFragmentProgram; _CGprogram *program = LContext->BoundFragmentProgram;
// params are set directly in the GPU memory, so there is nothing to be done here. // params are set directly in the GPU memory, so there is nothing to be done here.
@ -1818,12 +1818,12 @@ GLboolean rglPlatformRequiresSlowPath( rglDrawParams* dparams, const GLenum inde
} }
// Return the current RGLGcmDriver // Return the current RGLGcmDriver
rglGcmDriver* rglGetRGLGcmDriver() rglGcmDriver* rglGetRGLGcmDriver (void)
{ {
return ( rglGcmDriver * )( _CurrentDevice->rasterDriver ); return ( rglGcmDriver * )( _CurrentDevice->rasterDriver );
} }
void rglPlatformRasterFlush() void rglPlatformRasterFlush (void)
{ {
rglGcmFifoGlFlush(); rglGcmFifoGlFlush();
} }
@ -1839,7 +1839,7 @@ void rglpFifoGlFinish( void )
GLuint rglValidateAttributesSlow( rglDrawParams *dparams, GLboolean *isMain ) GLuint rglValidateAttributesSlow( rglDrawParams *dparams, GLboolean *isMain )
{ {
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglGcmDriver *driver = rglGetGcmDriver(); rglGcmDriver *driver = (rglGcmDriver*)_CurrentDevice->rasterDriver;
rglAttributeState* as = LContext->attribs; rglAttributeState* as = LContext->attribs;
// allocate upload transfer buffer if necessary // allocate upload transfer buffer if necessary
@ -1868,7 +1868,8 @@ GLuint rglValidateAttributesSlow( rglDrawParams *dparams, GLboolean *isMain )
for(GLuint i = 0; i < RGL_MAX_VERTEX_ATTRIBS; ++i) for(GLuint i = 0; i < RGL_MAX_VERTEX_ATTRIBS; ++i)
{ {
// skip this attribute if not needing update // skip this attribute if not needing update
if ( ! RGLBIT_GET( needsUpdateMask, i ) ) continue; if (!RGLBIT_GET( needsUpdateMask, i))
continue;
rglAttribute* attrib = as->attrib + i; rglAttribute* attrib = as->attrib + i;
if ( RGLBIT_GET( as->EnabledMask, i ) ) if ( RGLBIT_GET( as->EnabledMask, i ) )
@ -1974,14 +1975,15 @@ GLuint rglGetGcmImageOffset( rglGcmTextureLayout *layout, GLuint face, GLuint le
GLuint minWidth = 1; GLuint minWidth = 1;
GLuint minHeight = 1; GLuint minHeight = 1;
for ( GLuint f = 0;f < layout->faces;++f ) for (GLuint f = 0; f < layout->faces; ++f)
{ {
GLuint width = layout->baseWidth; GLuint width = layout->baseWidth;
GLuint height = layout->baseHeight; GLuint height = layout->baseHeight;
GLuint depth = layout->baseDepth; GLuint depth = layout->baseDepth;
for ( GLuint i = 0;i < layout->levels; ++i ) for ( GLuint i = 0;i < layout->levels; ++i )
{ {
if (( level == i ) && ( face == f ) ) return bytes; if ((level == i) && (face == f))
return bytes;
width = MAX( minWidth, width ); width = MAX( minWidth, width );
height = MAX( minHeight, height ); height = MAX( minHeight, height );
@ -2008,19 +2010,19 @@ int rglPlatformTextureSize()
} }
// Calculate pitch for a texture // Calculate pitch for a texture
static GLuint _getTexturePitch( const rglTexture * texture ) static GLuint _getTexturePitch(const rglTexture * texture)
{ {
return rglPad( rglGetStorageSize( texture->image->format, texture->image->type, texture->image->width, 1, 1 ), 64 ); // TransferVid2Vid needs 64byte pitch alignment return rglPad( rglGetStorageSize( texture->image->format, texture->image->type, texture->image->width, 1, 1 ), 64 ); // TransferVid2Vid needs 64byte pitch alignment
} }
// Return maximum number of texture image units // Return maximum number of texture image units
int rglPlatformTextureMaxUnits() int rglPlatformTextureMaxUnits (void)
{ {
return RGLGCM_MAX_TEXIMAGE_COUNT; return RGLGCM_MAX_TEXIMAGE_COUNT;
} }
// Create a gcm texture by initializing memory to 0 // Create a gcm texture by initializing memory to 0
void rglPlatformCreateTexture( rglTexture* texture ) void rglPlatformCreateTexture (rglTexture* texture)
{ {
rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture; rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture;
memset( gcmTexture, 0, sizeof( rglGcmTexture ) ); memset( gcmTexture, 0, sizeof( rglGcmTexture ) );
@ -2052,9 +2054,7 @@ void rglPlatformDropTexture( rglTexture *texture )
rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture; rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture;
if (gcmTexture->pool != RGLGCM_SURFACE_POOL_NONE) if (gcmTexture->pool != RGLGCM_SURFACE_POOL_NONE)
{
rglPlatformFreeGcmTexture( texture ); rglPlatformFreeGcmTexture( texture );
}
gcmTexture->pool = RGLGCM_SURFACE_POOL_NONE; gcmTexture->pool = RGLGCM_SURFACE_POOL_NONE;
gcmTexture->gpuAddressId = GMM_ERROR; gcmTexture->gpuAddressId = GMM_ERROR;
@ -2139,9 +2139,7 @@ void rglPlatformChooseGPUFormatAndLayout(
// if we don't want mipmapping, but still have valid mipmaps, load all the mipmaps. // if we don't want mipmapping, but still have valid mipmaps, load all the mipmaps.
// This is to avoid a big cost when switching from mipmaps to non-mipmaps. // This is to avoid a big cost when switching from mipmaps to non-mipmaps.
if (( texture->minFilter == GL_LINEAR ) || ( texture->minFilter == GL_NEAREST ) ) if (( texture->minFilter == GL_LINEAR ) || ( texture->minFilter == GL_NEAREST ) )
{
levels = 1; levels = 1;
}
newLayout->levels = levels; newLayout->levels = levels;
newLayout->faces = texture->faceCount; newLayout->faces = texture->faceCount;
@ -2448,8 +2446,11 @@ void rglPlatformUploadTexture( rglTexture* texture )
} }
// map RGL internal types to GCM // map RGL internal types to GCM
static inline void rglGcmUpdateGcmTexture( rglTexture * texture, rglGcmTextureLayout * layout, rglGcmTexture * platformTexture ) static inline void rglGcmUpdateGcmTexture (void *data_tex, rglGcmTextureLayout * layout, void *data_plattex)
{ {
rglTexture *texture = (rglTexture*)data_tex;
rglGcmTexture *platformTexture = (rglGcmTexture*)data_plattex;
// use color format for depth with no compare mode // use color format for depth with no compare mode
// This hack is needed because the hardware will not read depth // This hack is needed because the hardware will not read depth
// textures without performing a compare. The depth value will need to // textures without performing a compare. The depth value will need to
@ -2476,6 +2477,8 @@ static inline void rglGcmUpdateGcmTexture( rglTexture * texture, rglGcmTextureLa
platformTexture->gcmTexture.cubemap = CELL_GCM_FALSE; platformTexture->gcmTexture.cubemap = CELL_GCM_FALSE;
// set dimension, swizzled implies P2 width/height/depth // set dimension, swizzled implies P2 width/height/depth
#if 0
switch ( texture->target ) switch ( texture->target )
{ {
case 0: case 0:
@ -2483,6 +2486,9 @@ static inline void rglGcmUpdateGcmTexture( rglTexture * texture, rglGcmTextureLa
platformTexture->gcmTexture.dimension = CELL_GCM_TEXTURE_DIMENSION_2; platformTexture->gcmTexture.dimension = CELL_GCM_TEXTURE_DIMENSION_2;
break; break;
} }
#else
platformTexture->gcmTexture.dimension = CELL_GCM_TEXTURE_DIMENSION_2;
#endif
// system or local texture // system or local texture
platformTexture->gcmTexture.location = CELL_GCM_LOCATION_LOCAL; platformTexture->gcmTexture.location = CELL_GCM_LOCATION_LOCAL;
@ -2490,9 +2496,9 @@ static inline void rglGcmUpdateGcmTexture( rglTexture * texture, rglGcmTextureLa
} }
// map RGL internal types to GCM // map RGL internal types to GCM
void rglGcmUpdateMethods( rglTexture * texture ) void rglGcmUpdateMethods(void *data)
{ {
rglTexture *texture = (rglTexture*)data;
rglGcmTexture *platformTexture = ( rglGcmTexture * )texture->platformTexture; rglGcmTexture *platformTexture = ( rglGcmTexture * )texture->platformTexture;
rglGcmTextureLayout *layout = &platformTexture->gpuLayout; rglGcmTextureLayout *layout = &platformTexture->gpuLayout;
@ -2566,8 +2572,9 @@ void rglGcmUpdateMethods( rglTexture * texture )
} }
// Validate texture resources // Validate texture resources
void rglPlatformValidateTextureResources( rglTexture *texture ) void rglPlatformValidateTextureResources (void *data)
{ {
rglTexture *texture = (rglTexture*)data;
texture->isComplete = GL_TRUE; texture->isComplete = GL_TRUE;
// We may need to reallocate the texture when the parameters are changed // We may need to reallocate the texture when the parameters are changed
@ -2594,8 +2601,9 @@ void rglPlatformValidateTextureResources( rglTexture *texture )
#include <cell/gcm/gcm_method_data.h> #include <cell/gcm/gcm_method_data.h>
// Set a texture to a gcm texture unit // Set a texture to a gcm texture unit
static inline void rglGcmSetTextureUnit( GLuint unit, rglGcmTexture *platformTexture ) static inline void rglGcmSetTextureUnit (GLuint unit, void *data)
{ {
rglGcmTexture *platformTexture = (rglGcmTexture*)data;
const GLuint imageOffset = gmmIdToOffset(platformTexture->gpuAddressId) + platformTexture->gpuAddressIdOffset; const GLuint imageOffset = gmmIdToOffset(platformTexture->gpuAddressId) + platformTexture->gpuAddressIdOffset;
platformTexture->gcmTexture.offset = imageOffset; platformTexture->gcmTexture.offset = imageOffset;
@ -2642,8 +2650,6 @@ static inline void rglGcmSetTextureUnit( GLuint unit, rglGcmTexture *platformTex
platformTexture->gcmTexture.pitch, platformTexture->gcmTexture.pitch,
platformTexture->gcmTexture.depth); platformTexture->gcmTexture.depth);
gcm_context->current = &current[11]; gcm_context->current = &current[11];
} }
// Validate incomplete texture by remapping // Validate incomplete texture by remapping
@ -2671,8 +2677,10 @@ inline static void rglPlatformValidateIncompleteTexture( GLuint unit )
#undef RGLGCM_REMAP_MODES #undef RGLGCM_REMAP_MODES
// Valiate resources of a texture and set it to a unit // Valiate resources of a texture and set it to a unit
void rglPlatformValidateTextureStage( int unit, rglTexture* texture ) void rglPlatformValidateTextureStage( int unit, void *data)
{ {
rglTexture *texture = (rglTexture*)data;
if ( RGL_UNLIKELY( texture->revalidate ) ) if ( RGL_UNLIKELY( texture->revalidate ) )
{ {
// this updates the isComplete bit. // this updates the isComplete bit.
@ -2691,8 +2699,6 @@ void rglPlatformValidateTextureStage( int unit, rglTexture* texture )
//RGL_REPORT_EXTRA( RGL_REPORT_TEXTURE_INCOMPLETE, "Texture %d bound to unit %d(%s) is incomplete.", texture->name, unit, rglGetGLEnumName( texture->target ) ); //RGL_REPORT_EXTRA( RGL_REPORT_TEXTURE_INCOMPLETE, "Texture %d bound to unit %d(%s) is incomplete.", texture->name, unit, rglGetGLEnumName( texture->target ) );
rglPlatformValidateIncompleteTexture( unit ); rglPlatformValidateIncompleteTexture( unit );
} }
} }
// Choose internal format closest to given format // Choose internal format closest to given format
@ -2776,8 +2782,9 @@ void rglPlatformExpandInternalFormat( GLenum internalFormat, GLenum *format, GLe
} }
// Choose internal storage type and size, and set it to image, based on given format // Choose internal storage type and size, and set it to image, based on given format
GLenum rglPlatformChooseInternalStorage( rglImage* image, GLenum internalFormat ) GLenum rglPlatformChooseInternalStorage (void *data, GLenum internalFormat )
{ {
rglImage *image = (rglImage*)data;
// see note at bottom concerning storageSize // see note at bottom concerning storageSize
image->storageSize = 0; image->storageSize = 0;
@ -2812,8 +2819,9 @@ GLenum rglPlatformTranslateTextureFormat( GLenum internalFormat )
// Implementation of texture reference // Implementation of texture reference
// Associate bufferObject to texture by assigning buffer's gpu address to the gcm texture // Associate bufferObject to texture by assigning buffer's gpu address to the gcm texture
GLboolean rglPlatformTextureReference( rglTexture *texture, GLuint pitch, rglBufferObject *bufferObject, GLintptr offset ) GLboolean rglPlatformTextureReference (void *data, GLuint pitch, rglBufferObject *bufferObject, GLintptr offset )
{ {
rglTexture *texture = (rglTexture*)data;
rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture; rglGcmTexture *gcmTexture = ( rglGcmTexture * )texture->platformTexture;
// XXX check pitch restrictions ? // XXX check pitch restrictions ?
@ -2866,9 +2874,10 @@ GLboolean rglPlatformTextureReference( rglTexture *texture, GLuint pitch, rglBuf
// Render target rt's color and depth buffer parameters are updated with args // Render target rt's color and depth buffer parameters are updated with args
// Fifo functions are called as required // Fifo functions are called as required
void static inline rglGcmSetColorDepthBuffers( rglGcmRenderTarget *rt, rglGcmRenderTargetEx const * const args ) void static inline rglGcmSetColorDepthBuffers(void *data, rglGcmRenderTargetEx const * const args )
{ {
CellGcmSurface * grt = &rt->gcmRenderTarget; rglGcmRenderTarget *rt = (rglGcmRenderTarget*)data;
CellGcmSurface *grt = &rt->gcmRenderTarget;
rt->colorBufferCount = args->colorBufferCount; rt->colorBufferCount = args->colorBufferCount;
@ -2931,10 +2940,10 @@ void static inline rglGcmSetColorDepthBuffers( rglGcmRenderTarget *rt, rglGcmRen
} }
} }
// Update rt's color and depth format with args // Update rt's color and depth format with args
void static inline rglGcmSetColorDepthFormats( rglGcmRenderTarget *rt, rglGcmRenderTargetEx const * const args ) void static inline rglGcmSetColorDepthFormats (void *data, rglGcmRenderTargetEx const * const args)
{ {
rglGcmRenderTarget *rt = (rglGcmRenderTarget*)data;
CellGcmSurface * grt = &rt->gcmRenderTarget; CellGcmSurface * grt = &rt->gcmRenderTarget;
// set the color format // set the color format
@ -2962,8 +2971,9 @@ void static inline rglGcmSetColorDepthFormats( rglGcmRenderTarget *rt, rglGcmRen
} }
// Update rt's color targets // Update rt's color targets
static void inline rglGcmSetTarget( rglGcmRenderTarget *rt, rglGcmRenderTargetEx const * const args ) static void inline rglGcmSetTarget (void *data, rglGcmRenderTargetEx const * const args )
{ {
rglGcmRenderTarget *rt = (rglGcmRenderTarget*)data;
CellGcmSurface * grt = &rt->gcmRenderTarget; CellGcmSurface * grt = &rt->gcmRenderTarget;
// set target combo // set target combo
@ -3021,7 +3031,7 @@ void rglGcmFifoGlSetRenderTarget( rglGcmRenderTargetEx const * const args )
PLATFORM TNL PLATFORM TNL
============================================================ */ ============================================================ */
void rglValidateVertexProgram() void rglValidateVertexProgram (void)
{ {
// if validation is required, it means the program has to be downloaded. // if validation is required, it means the program has to be downloaded.
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
@ -3033,7 +3043,7 @@ void rglValidateVertexProgram()
rglValidateVertexConstants(); rglValidateVertexConstants();
} }
void rglValidateVertexConstants() void rglValidateVertexConstants (void)
{ {
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
_CGprogram *cgprog = LContext->BoundVertexProgram; _CGprogram *cgprog = LContext->BoundVertexProgram;
@ -3059,6 +3069,9 @@ void rglValidateVertexConstants()
void rglDrawUtilQuad( GLboolean useFixedVP, GLboolean useFixedFP, GLuint x, GLuint y, GLuint width, GLuint height ) void rglDrawUtilQuad( GLboolean useFixedVP, GLboolean useFixedFP, GLuint x, GLuint y, GLuint width, GLuint height )
{ {
(void)useFixedVP;
(void)useFixedFP;
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglGcmFifoGlDisable( RGLGCM_BLEND ); rglGcmFifoGlDisable( RGLGCM_BLEND );

66
console/rgl/src/rgl.cpp
View File

@ -37,8 +37,10 @@ static rglBufferObject *rglCreateBufferObject(void)
return buffer; return buffer;
} }
static void rglFreeBufferObject( rglBufferObject *buffer ) static void rglFreeBufferObject (void *data)
{ {
rglBufferObject *buffer = (rglBufferObject*)data;
if ( --buffer->refCount == 0 ) if ( --buffer->refCount == 0 )
{ {
rglPlatformDestroyBufferObject( buffer ); rglPlatformDestroyBufferObject( buffer );
@ -47,8 +49,9 @@ static void rglFreeBufferObject( rglBufferObject *buffer )
} }
} }
static void rglUnbindBufferObject( RGLcontext *LContext, GLuint name ) static void rglUnbindBufferObject (void *data, GLuint name)
{ {
RGLcontext *LContext = (RGLcontext*)data;
if ( LContext->ArrayBuffer == name ) LContext->ArrayBuffer = 0; if ( LContext->ArrayBuffer == name ) LContext->ArrayBuffer = 0;
if ( LContext->PixelUnpackBuffer == name ) LContext->PixelUnpackBuffer = 0; if ( LContext->PixelUnpackBuffer == name ) LContext->PixelUnpackBuffer = 0;
for ( int i = 0;i < RGL_MAX_VERTEX_ATTRIBS;++i ) for ( int i = 0;i < RGL_MAX_VERTEX_ATTRIBS;++i )
@ -631,11 +634,11 @@ int rglGetPixelSize( GLenum format, GLenum type )
return rglGetComponentCount( format )*componentSize; return rglGetComponentCount( format )*componentSize;
} }
void rglRawRasterToImage( void rglRawRasterToImage(const void *in_data,
const rglRaster* raster, void *out_data, GLuint x, GLuint y, GLuint z )
rglImage* image,
GLuint x, GLuint y, GLuint z )
{ {
const rglRaster* raster = (const rglRaster*)in_data;
rglImage *image = (rglImage*)out_data;
const int pixelBits = rglGetPixelSize( image->format, image->type ) * 8; const int pixelBits = rglGetPixelSize( image->format, image->type ) * 8;
const GLuint size = pixelBits / 8; const GLuint size = pixelBits / 8;
@ -696,8 +699,10 @@ void rglRawRasterToImage(
} }
} }
void rglImageAllocCPUStorage( rglImage *image ) void rglImageAllocCPUStorage (void *data)
{ {
rglImage *image = (rglImage*)data;
if (( image->storageSize > image->mallocStorageSize ) || ( !image->mallocData ) ) if (( image->storageSize > image->mallocStorageSize ) || ( !image->mallocData ) )
{ {
if (image->mallocData) if (image->mallocData)
@ -709,8 +714,9 @@ void rglImageAllocCPUStorage( rglImage *image )
image->data = rglPadPtr( image->mallocData, 128 ); image->data = rglPadPtr( image->mallocData, 128 );
} }
void rglImageFreeCPUStorage( rglImage *image ) void rglImageFreeCPUStorage(void *data)
{ {
rglImage *image = (rglImage*)data;
if (!image->mallocData) if (!image->mallocData)
return; return;
@ -985,8 +991,10 @@ void rglResetAttributeState( rglAttributeState* as )
as->HasVBOMask = 0; as->HasVBOMask = 0;
} }
static void rglResetContext( RGLcontext *LContext ) static void rglResetContext (void *data)
{ {
RGLcontext *LContext = (RGLcontext*)data;
rglTexNameSpaceResetNames( &LContext->textureNameSpace ); rglTexNameSpaceResetNames( &LContext->textureNameSpace );
rglTexNameSpaceResetNames( &LContext->bufferObjectNameSpace ); rglTexNameSpaceResetNames( &LContext->bufferObjectNameSpace );
rglTexNameSpaceResetNames( &LContext->framebufferNameSpace ); rglTexNameSpaceResetNames( &LContext->framebufferNameSpace );
@ -1067,7 +1075,9 @@ static void rglResetContext( RGLcontext *LContext )
RGLcontext* psglCreateContext(void) RGLcontext* psglCreateContext(void)
{ {
RGLcontext* LContext = ( RGLcontext* )malloc( sizeof( RGLcontext ) ); RGLcontext* LContext = ( RGLcontext* )malloc( sizeof( RGLcontext ) );
if ( !LContext ) return NULL;
if (!LContext)
return NULL;
memset( LContext, 0, sizeof( RGLcontext ) ); memset( LContext, 0, sizeof( RGLcontext ) );
@ -1158,8 +1168,9 @@ void RGL_EXPORT psglDestroyContext( RGLcontext* LContext )
free( LContext ); free( LContext );
} }
void rglInvalidateAllStates( RGLcontext* context ) void rglInvalidateAllStates (void *data)
{ {
RGLcontext *context = (RGLcontext*)data;
context->needValidate = RGL_VALIDATE_ALL; context->needValidate = RGL_VALIDATE_ALL;
context->attribs->DirtyMask = ( 1 << RGL_MAX_VERTEX_ATTRIBS ) - 1; context->attribs->DirtyMask = ( 1 << RGL_MAX_VERTEX_ATTRIBS ) - 1;
} }
@ -1367,9 +1378,10 @@ rglTexture *rglAllocateTexture(void)
return texture; return texture;
} }
void rglFreeTexture( rglTexture *texture ) void rglFreeTexture (void *data)
{ {
rglTextureTouchFBOs( texture ); rglTexture *texture = (rglTexture*)data;
rglTextureTouchFBOs(texture);
texture->framebuffers.~Vector<rglFramebuffer *>(); texture->framebuffers.~Vector<rglFramebuffer *>();
if ( texture->image ) if ( texture->image )
@ -1404,8 +1416,9 @@ void rglTextureUnbind( RGLcontext* context, GLuint name )
} }
} }
GLboolean rglTextureIsValid( const rglTexture* texture ) GLboolean rglTextureIsValid (const void *data)
{ {
const rglTexture *texture = (const rglTexture*)data;
if ( texture->imageCount < 1 + texture->baseLevel ) if ( texture->imageCount < 1 + texture->baseLevel )
return GL_FALSE; return GL_FALSE;
if ( !texture->image ) if ( !texture->image )
@ -1449,11 +1462,11 @@ GLenum rglGetEnabledTextureMode( const rglTextureImageUnit *unit )
// here, if fragment program is enabled and a valid program is set, get the enabled // here, if fragment program is enabled and a valid program is set, get the enabled
// units from the program instead of the texture units. // units from the program instead of the texture units.
if ( _CurrentContext->BoundFragmentProgram != NULL && _CurrentContext->FragmentProgram != GL_FALSE) if ( _CurrentContext->BoundFragmentProgram != NULL && _CurrentContext->FragmentProgram != GL_FALSE)
{
return unit->fragmentTarget; return unit->fragmentTarget;
} else if ( unit->enable2D )
else if ( unit->enable2D ) return GL_TEXTURE_2D; return GL_TEXTURE_2D;
else return 0;
return 0;
} }
rglTexture *rglGetCurrentTexture( const rglTextureImageUnit *unit, GLenum target ) rglTexture *rglGetCurrentTexture( const rglTextureImageUnit *unit, GLenum target )
@ -1508,8 +1521,9 @@ int rglGetImage( GLenum target, GLint level, rglTexture **texture, rglImage **im
return 0; return 0;
} }
void rglBindTextureInternal( rglTextureImageUnit *unit, GLuint name, GLenum target ) void rglBindTextureInternal (void *data, GLuint name, GLenum target )
{ {
rglTextureImageUnit *unit = (rglTextureImageUnit*)data;
RGLcontext* LContext = _CurrentContext; RGLcontext* LContext = _CurrentContext;
rglTexture *texture = NULL; rglTexture *texture = NULL;
if ( name ) if ( name )
@ -1524,6 +1538,7 @@ void rglBindTextureInternal( rglTextureImageUnit *unit, GLuint name, GLenum targ
} }
} }
#if 0
switch ( target ) switch ( target )
{ {
case GL_TEXTURE_2D: case GL_TEXTURE_2D:
@ -1532,6 +1547,10 @@ void rglBindTextureInternal( rglTextureImageUnit *unit, GLuint name, GLenum targ
default: default:
break; break;
} }
#else
unit->bound2D = name;
#endif
rglUpdateCurrentTextureCache( unit ); rglUpdateCurrentTextureCache( unit );
LContext->needValidate |= RGL_VALIDATE_TEXTURES_USED; LContext->needValidate |= RGL_VALIDATE_TEXTURES_USED;
} }
@ -1565,9 +1584,7 @@ GLAPI void APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param )
case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MIN_FILTER:
texture->minFilter = param; texture->minFilter = param;
if ( texture->referenceBuffer == 0 ) if ( texture->referenceBuffer == 0 )
{
texture->revalidate |= RGL_TEXTURE_REVALIDATE_LAYOUT; texture->revalidate |= RGL_TEXTURE_REVALIDATE_LAYOUT;
}
break; break;
case GL_TEXTURE_MAG_FILTER: case GL_TEXTURE_MAG_FILTER:
texture->magFilter = param; texture->magFilter = param;
@ -1586,10 +1603,9 @@ GLAPI void APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param )
break; break;
case GL_TEXTURE_FROM_VERTEX_PROGRAM_SCE: case GL_TEXTURE_FROM_VERTEX_PROGRAM_SCE:
if ( param != 0 ) if ( param != 0 )
{
texture->vertexEnable = GL_TRUE; texture->vertexEnable = GL_TRUE;
} else
else texture->vertexEnable = GL_FALSE; texture->vertexEnable = GL_FALSE;
texture->revalidate |= RGL_TEXTURE_REVALIDATE_LAYOUT; texture->revalidate |= RGL_TEXTURE_REVALIDATE_LAYOUT;
break; break;
case GL_TEXTURE_ALLOCATION_HINT_SCE: case GL_TEXTURE_ALLOCATION_HINT_SCE:
@ -1660,9 +1676,7 @@ GLAPI void APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalForm
if ( LContext->PixelUnpackBuffer != 0 ) if ( LContext->PixelUnpackBuffer != 0 )
{
rglPlatformBufferObjectUnmap( bufferObject ); rglPlatformBufferObjectUnmap( bufferObject );
}
texture->revalidate |= RGL_TEXTURE_REVALIDATE_IMAGES; texture->revalidate |= RGL_TEXTURE_REVALIDATE_IMAGES;