RetroArch/console/rgl/ps3/rgl.h
2012-08-15 13:15:12 +02:00

1049 lines
30 KiB
C

#ifndef _RGL_H
#define _RGL_H
#include "gl.h"
#include "glext.h"
#include "base.hpp"
#ifdef __PSL1GHT__
#include <rsx/rsx.h>
#include <rsx/resc.h>
#include <sysutil/video.h>
#include <unistd.h>
#include "../../../ps3/sdk_defines.h"
#define CGerror int
typedef void (* CGerrorCallbackFunc)(void);
typedef struct _CGcontext *CGcontext;
#else
#include <cell/resc.h>
#endif
#define MAX_COLOR_ATTACHMENTS 4
#define SUBPIXEL_ADJUST (0.5/(1<<12))
#define gmmIdIsMain(id) (((GmmBaseBlock *)id)->isMain)
#define gmmAddressToOffset(address, isMain) ((isMain) ? (address)-pGmmMainAllocator->memoryBase : (address)-pGmmLocalAllocator->memoryBase)
#ifdef __cplusplus
extern "C"
{
#endif
typedef enum RGLEnum
{
RGL_NONE = 0x0000,
RGL_COLOR_BUFFER_BIT = 0x4000,
RGL_ZERO = 0,
RGL_ONE = 1,
RGL_SRC_COLOR = 0x0300,
RGL_ONE_MINUS_SRC_COLOR = 0x0301,
RGL_SRC_ALPHA = 0x0302,
RGL_ONE_MINUS_SRC_ALPHA = 0x0303,
RGL_DST_ALPHA = 0x0304,
RGL_ONE_MINUS_DST_ALPHA = 0x0305,
RGL_DST_COLOR = 0x0306,
RGL_ONE_MINUS_DST_COLOR = 0x0307,
RGL_SRC_ALPHA_SATURATE = 0x0308,
RGL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
RGL_CONSTANT_ALPHA = 0x8003,
RGL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
RGL_MIN = 0x8007,
RGL_MAX = 0x8008,
RGL_FUNC_SUBTRACT = 0x800A,
RGL_FUNC_REVERSE_SUBTRACT = 0x800B,
RGL_LUMINANCE8 = 0x8040,
RGL_LUMINANCE16 = 0x8042,
RGL_ALPHA8 = 0x803C,
RGL_ALPHA16 = 0x803E,
RGL_INTENSITY8 = 0x804B,
RGL_INTENSITY16 = 0x804D,
RGL_LUMINANCE8_ALPHA8 = 0x8045,
RGL_LUMINANCE16_ALPHA16 = 0x8048,
RGL_HILO8 = 0x885E,
RGL_HILO16 = 0x86F8,
RGL_ARGB8 = 0x6007,
RGL_BGRA8 = 0xff01,
RGL_RGBA8 = 0x8058,
RGL_ABGR8 = 0xff02,
RGL_XBGR8 = 0xff03,
RGL_RGBX8 = 0xff07,
RGL_FLOAT_R32 = 0x8885,
RGL_FLOAT_RGBA16 = 0x888A,
RGL_FLOAT_RGBA32 = 0x888B,
RGL_FLOAT_RGBX16 = 0xff04,
RGL_FLOAT_RGBX32 = 0xff05,
RGL_LUMINANCE32F_ARB = 0x8818,
RGL_ALPHA_LUMINANCE16F_SCE = 0x600B,
RGL_RGB5_A1_SCE = 0x600C,
RGL_RGB565_SCE = 0x600D,
RGL_DITHER = 0x0bd0,
RGL_PSHADER_SRGB_REMAPPING = 0xff06,
RGL_VERTEX_ATTRIB_ARRAY0 = 0x8650,
RGL_VERTEX_ATTRIB_ARRAY1 = 0x8651,
RGL_VERTEX_ATTRIB_ARRAY2 = 0x8652,
RGL_VERTEX_ATTRIB_ARRAY3 = 0x8653,
RGL_VERTEX_ATTRIB_ARRAY4 = 0x8654,
RGL_VERTEX_ATTRIB_ARRAY5 = 0x8655,
RGL_VERTEX_ATTRIB_ARRAY6 = 0x8656,
RGL_VERTEX_ATTRIB_ARRAY7 = 0x8657,
RGL_VERTEX_ATTRIB_ARRAY8 = 0x8658,
RGL_VERTEX_ATTRIB_ARRAY9 = 0x8659,
RGL_VERTEX_ATTRIB_ARRAY10 = 0x865a,
RGL_VERTEX_ATTRIB_ARRAY11 = 0x865b,
RGL_VERTEX_ATTRIB_ARRAY12 = 0x865c,
RGL_VERTEX_ATTRIB_ARRAY13 = 0x865d,
RGL_VERTEX_ATTRIB_ARRAY14 = 0x865e,
RGL_VERTEX_ATTRIB_ARRAY15 = 0x865f,
RGL_CLAMP = 0x2900,
RGL_REPEAT = 0x2901,
RGL_CLAMP_TO_EDGE = 0x812F,
RGL_CLAMP_TO_BORDER = 0x812D,
RGL_MIRRORED_REPEAT = 0x8370,
RGL_MIRROR_CLAMP = 0x8742,
RGL_MIRROR_CLAMP_TO_EDGE = 0x8743,
RGL_MIRROR_CLAMP_TO_BORDER = 0x8912,
RGL_GAMMA_REMAP_RED_BIT = 0x0001,
RGL_GAMMA_REMAP_GREEN_BIT = 0x0002,
RGL_GAMMA_REMAP_BLUE_BIT = 0x0004,
RGL_GAMMA_REMAP_ALPHA_BIT = 0x0008,
RGL_TEXTURE_WRAP_S = 0x2802,
RGL_TEXTURE_WRAP_T = 0x2803,
RGL_TEXTURE_WRAP_R = 0x8072,
RGL_TEXTURE_MIN_FILTER = 0x2801,
RGL_TEXTURE_MAG_FILTER = 0x2800,
RGL_TEXTURE_MAX_ANISOTROPY = 0x84FE,
RGL_TEXTURE_COMPARE_FUNC = 0x884D,
RGL_TEXTURE_MIN_LOD = 0x813A,
RGL_TEXTURE_MAX_LOD = 0x813B,
RGL_TEXTURE_LOD_BIAS = 0x8501,
RGL_TEXTURE_BORDER_COLOR = 0x1004,
RGL_TEXTURE_GAMMA_REMAP = 0xff30,
RGL_VERTEX_PROGRAM = 0x8620,
RGL_FRAGMENT_PROGRAM = 0x8804,
RGL_FLOAT = 0x1406,
RGL_HALF_FLOAT = 0x140B,
RGL_SHORT = 0x1402,
RGL_UNSIGNED_BYTE = 0x1401,
RGL_UNSIGNED_SHORT = 0x1403,
RGL_UNSIGNED_INT = 0x1405,
RGL_BYTE = 0x1400,
RGL_INT = 0x1404,
RGL_CMP = 0x6020,
} RGLEnum;
typedef struct PSGLdevice PSGLdevice;
typedef struct PSGLcontext PSGLcontext;
typedef struct RGLViewportState RGLViewportState;
struct RGLState;
extern RGLState _RGLState;
struct RGLViewportState
{
GLint x, y, w, h;
GLfloat xScale, xCenter;
GLfloat yScale, yCenter;
};
struct jsFramebufferAttachment
{
GLenum type;
GLuint name;
GLenum textureTarget;
jsFramebufferAttachment(): type( GL_NONE ), name( 0 ), textureTarget( GL_NONE ) {};
};
struct jsFramebuffer
{
jsFramebufferAttachment color[MAX_COLOR_ATTACHMENTS];
GLboolean needValidate;
jsFramebuffer(): needValidate( GL_TRUE ) {};
virtual ~jsFramebuffer() {};
};
#define RGLBIT_GET(f,n) ((f) & (1<<(n)))
#define RGLBIT_TRUE(f,n) ((f) |= (1<<(n)))
#define RGLBIT_FALSE(f,n) ((f) &= ~(1<<(n)))
#define RGLBIT_ASSIGN(f,n,val) do { if(val) RGLBIT_TRUE(f,n); else RGLBIT_FALSE(f,n); } while(0)
typedef struct
{
GLfloat X, Y , Z, W;
} jsPositionXYZW;
typedef struct
{
GLfloat X, Y , Z;
} jsPositionXYZ;
typedef struct
{
GLfloat R, G, B, A;
} jsColorRGBAf;
typedef struct
{
int X, Y, XSize, YSize;
} jsViewPort;
typedef struct
{
int id;
GLuint offset;
GLuint size;
GLuint pitch;
GLuint bank;
} jsTiledRegion;
enum
{
IMAGE_DATASTATE_UNSET = 0x0,
IMAGE_DATASTATE_HOST = 0x1,
IMAGE_DATASTATE_GPU = 0x2
};
typedef struct jsImage_
{
GLboolean isSet;
GLenum internalFormat;
GLenum format;
GLenum type;
GLsizei width;
GLsizei height;
GLsizei alignment;
GLsizei storageSize;
GLsizei xstride, ystride;
GLuint xblk, yblk;
char *data;
char *mallocData;
GLsizei mallocStorageSize;
GLenum dataState;
} jsImage;
typedef struct
{
GLenum format;
GLenum type;
GLsizei width;
GLsizei height;
GLsizei xstride;
GLsizei ystride;
void* data;
} jsRaster;
#define TEXTURE_REVALIDATE_LAYOUT 0x01
#define TEXTURE_REVALIDATE_IMAGES 0x02
#define TEXTURE_REVALIDATE_PARAMETERS 0x04
typedef struct jsBufferObject jsBufferObject;
typedef struct
{
GLuint revalidate;
GLuint target;
GLuint minFilter;
GLuint magFilter;
GLuint gammaRemap;
GLenum usage;
GLboolean isRenderTarget;
GLboolean isComplete;
jsBufferObject *referenceBuffer;
GLintptr offset;
RGL::Vector<jsFramebuffer *> framebuffers;
GLuint imageCount;
jsImage* image;
void * platformTexture[];
}
jsTexture;
#define MAX_TEXTURE_COORDS 8
#define MAX_TEXTURE_IMAGE_UNITS 16
#define MAX_VERTEX_TEXTURE_IMAGE_UNITS 4
#define MAX_TEXTURE_UNITS 4
#define MAX_VERTEX_ATTRIBS 16
typedef struct
{
GLuint bound2D;
jsTexture* default2D;
GLenum fragmentTarget;
GLenum envMode;
jsColorRGBAf envColor;
jsTexture* currentTexture;
} jsTextureImageUnit;
enum
{
FRAMEBUFFER_ATTACHMENT_NONE,
FRAMEBUFFER_ATTACHMENT_RENDERBUFFER,
FRAMEBUFFER_ATTACHMENT_TEXTURE,
};
typedef enum PSGLtvStandard
{
PSGL_TV_STANDARD_NONE,
PSGL_TV_STANDARD_NTSC_M,
PSGL_TV_STANDARD_NTSC_J,
PSGL_TV_STANDARD_PAL_M,
PSGL_TV_STANDARD_PAL_B,
PSGL_TV_STANDARD_PAL_D,
PSGL_TV_STANDARD_PAL_G,
PSGL_TV_STANDARD_PAL_H,
PSGL_TV_STANDARD_PAL_I,
PSGL_TV_STANDARD_PAL_N,
PSGL_TV_STANDARD_PAL_NC,
PSGL_TV_STANDARD_HD480I,
PSGL_TV_STANDARD_HD480P,
PSGL_TV_STANDARD_HD576I,
PSGL_TV_STANDARD_HD576P,
PSGL_TV_STANDARD_HD720P,
PSGL_TV_STANDARD_HD1080I,
PSGL_TV_STANDARD_HD1080P,
PSGL_TV_STANDARD_1280x720_ON_VESA_1280x768 = 128,
PSGL_TV_STANDARD_1280x720_ON_VESA_1280x1024,
PSGL_TV_STANDARD_1920x1080_ON_VESA_1920x1200,
} PSGLtvStandard;
typedef enum PSGLdeviceConnector
{
PSGL_DEVICE_CONNECTOR_NONE,
PSGL_DEVICE_CONNECTOR_VGA,
PSGL_DEVICE_CONNECTOR_DVI,
PSGL_DEVICE_CONNECTOR_HDMI,
PSGL_DEVICE_CONNECTOR_COMPOSITE,
PSGL_DEVICE_CONNECTOR_SVIDEO,
PSGL_DEVICE_CONNECTOR_COMPONENT,
} PSGLdeviceConnector;
typedef enum PSGLbufferingMode
{
PSGL_BUFFERING_MODE_SINGLE = 1,
PSGL_BUFFERING_MODE_DOUBLE = 2,
PSGL_BUFFERING_MODE_TRIPLE = 3,
} PSGLbufferingMode;
typedef enum RescRatioMode
{
RESC_RATIO_MODE_FULLSCREEN,
RESC_RATIO_MODE_LETTERBOX,
RESC_RATIO_MODE_PANSCAN,
} RescRatioMode;
typedef enum RescPalTemporalMode
{
RESC_PAL_TEMPORAL_MODE_50_NONE,
RESC_PAL_TEMPORAL_MODE_60_DROP,
RESC_PAL_TEMPORAL_MODE_60_INTERPOLATE,
RESC_PAL_TEMPORAL_MODE_60_INTERPOLATE_30_DROP,
RESC_PAL_TEMPORAL_MODE_60_INTERPOLATE_DROP_FLEXIBLE,
} RescPalTemporalMode;
typedef enum RescInterlaceMode
{
RESC_INTERLACE_MODE_NORMAL_BILINEAR,
RESC_INTERLACE_MODE_INTERLACE_FILTER,
} RescInterlaceMode;
typedef struct
{
GLuint enable;
GLenum colorFormat;
GLenum depthFormat;
GLenum multisamplingMode;
PSGLtvStandard TVStandard;
PSGLdeviceConnector connector;
PSGLbufferingMode bufferingMode;
GLuint width;
GLuint height;
GLuint renderWidth;
GLuint renderHeight;
RescRatioMode rescRatioMode;
RescPalTemporalMode rescPalTemporalMode;
RescInterlaceMode rescInterlaceMode;
GLfloat horizontalScale;
GLfloat verticalScale;
} PSGLdeviceParameters;
struct PSGLdevice
{
PSGLdeviceParameters deviceParameters;
GLvoid* rasterDriver;
char platformDevice[];
};
typedef struct
{
GLenum mode;
GLint firstVertex;
GLsizei vertexCount;
GLuint xferTotalSize;
GLuint indexXferOffset;
GLuint indexXferSize;
GLuint attribXferTotalSize;
GLuint attribXferOffset[MAX_VERTEX_ATTRIBS];
GLuint attribXferSize[MAX_VERTEX_ATTRIBS];
} jsDrawParams;
#define _RGL_ATTRIB_POSITION_INDEX 0
#define _RGL_ATTRIB_WEIGHT_INDEX 1
#define _RGL_ATTRIB_NORMAL_INDEX 2
#define _RGL_ATTRIB_PRIMARY_COLOR_INDEX 3
#define _RGL_ATTRIB_SECONDARY_COLOR_INDEX 4
#define _RGL_ATTRIB_FOG_COORD_INDEX 5
#define _RGL_ATTRIB_POINT_SIZE_INDEX 6
#define _RGL_ATTRIB_BLEND_INDICES_INDEX 7
#define _RGL_ATTRIB_TEX_COORD0_INDEX 8
#define _RGL_ATTRIB_TEX_COORD1_INDEX 9
#define _RGL_ATTRIB_TEX_COORD2_INDEX 10
#define _RGL_ATTRIB_TEX_COORD3_INDEX 11
#define _RGL_ATTRIB_TEX_COORD4_INDEX 12
#define _RGL_ATTRIB_TEX_COORD5_INDEX 13
#define _RGL_ATTRIB_TEX_COORD6_INDEX 14
#define _RGL_ATTRIB_TEX_COORD7_INDEX 15
typedef struct
{
GLvoid *clientData;
GLuint clientSize;
GLenum clientType;
GLsizei clientStride;
GLuint arrayBuffer;
GLfloat value[4];
GLuint frequency;
GLboolean normalized;
} __attribute__((aligned (16))) jsAttribute;
typedef struct
{
jsAttribute attrib[MAX_VERTEX_ATTRIBS];
unsigned int DirtyMask;
unsigned int EnabledMask;
unsigned int NeedsConversionMask;
unsigned int HasVBOMask;
unsigned int ModuloMask;
} __attribute__((aligned (16))) jsAttributeState;
typedef struct
{
jsAttributeState attribs;
GLboolean dirty;
unsigned int beenUpdatedMask;
GLvoid *cmdBuffer;
GLuint cmdNumWords;
} __attribute__((aligned (16))) jsAttribSet;
struct jsBufferObject
{
GLuint refCount;
GLsizeiptr size;
GLenum usage;
GLboolean mapped;
GLenum internalFormat;
GLuint width;
GLuint height;
RGL::Vector<jsTexture *> textureReferences;
RGL::Vector<jsAttribSet *> attribSets;
void *platformBufferObject[];
};
typedef struct jsNameSpace
{
void** data;
void** firstFree;
unsigned long capacity;
} jsNameSpace;
typedef void *(*jsTexNameSpaceCreateFunction)(void);
typedef void(*jsTexNameSpaceDestroyFunction)(void *);
typedef struct jsTexNameSpace
{
void** data;
GLuint capacity;
jsTexNameSpaceCreateFunction create;
jsTexNameSpaceDestroyFunction destroy;
}
jsTexNameSpace;
struct PSGLcontext
{
GLenum error;
jsViewPort ViewPort;
jsAttributeState defaultAttribs0;
jsAttributeState *attribs;
jsTexNameSpace attribSetNameSpace;
GLuint attribSetName;
GLboolean attribSetDirty;
jsColorRGBAf ClearColor;
GLboolean ShaderSRGBRemap;
GLboolean Blending;
GLboolean BlendingMrt[3];
GLenum BlendEquationRGB;
GLenum BlendEquationAlpha;
GLenum BlendFactorSrcRGB;
GLenum BlendFactorDestRGB;
GLenum BlendFactorSrcAlpha;
GLenum BlendFactorDestAlpha;
jsColorRGBAf BlendColor;
jsTexNameSpace textureNameSpace;
GLuint ActiveTexture;
GLuint CS_ActiveTexture;
jsTextureImageUnit TextureImageUnits[MAX_TEXTURE_IMAGE_UNITS];
jsTextureImageUnit* CurrentImageUnit;
jsTexture *VertexTextureImages[MAX_VERTEX_TEXTURE_IMAGE_UNITS];
GLsizei packAlignment;
GLsizei unpackAlignment;
jsTexNameSpace bufferObjectNameSpace;
GLuint ArrayBuffer;
GLuint PixelUnpackBuffer;
GLuint TextureBuffer;
GLuint framebuffer;
jsTexNameSpace framebufferNameSpace;
GLboolean VertexProgram;
struct _CGprogram* BoundVertexProgram;
GLboolean FragmentProgram;
struct _CGprogram* BoundFragmentProgram;
GLboolean AllowTXPDemotion;
GLboolean VSync;
GLuint needValidate;
GLboolean everAttached;
CGerror RGLcgLastError;
CGerrorCallbackFunc RGLcgErrorCallbackFunction;
CGcontext RGLcgContextHead;
jsNameSpace cgContextNameSpace;
jsNameSpace cgProgramNameSpace;
jsNameSpace cgParameterNameSpace;
};
#define MAX(A,B) ((A)>(B)?(A):(B))
#define MIN(A,B) ((A)<(B)?(A):(B))
#define RGL_LIKELY(COND) (COND)
#define RGL_UNLIKELY(COND) (COND)
static inline unsigned int endianSwapWord( unsigned int v )
{
return ( v&0xff ) << 24 | ( v&0xff00 ) << 8 |
( v&0xff0000 ) >> 8 | ( v&0xff000000 ) >> 24;
}
static inline int _RGLLog2( unsigned int i )
{
int l = 0;
while ( i )
{
++l;
i >>= 1;
}
return l -1;
}
static inline unsigned long _RGLPad(unsigned long x, unsigned long pad)
{
return ( x + pad - 1 ) / pad*pad;
}
typedef struct MemoryBlockManager_t_
{
char *memory;
GLuint size;
GLuint minAlignment;
GLenum method;
GLuint *book;
GLint bookSize;
GLint bookAlloc;
} MemoryBlockManager_t;
typedef unsigned long jsName;
jsName _RGLCreateName( struct jsNameSpace * ns, void* object );
unsigned int _RGLIsName( struct jsNameSpace* ns, jsName name );
void _RGLEraseName( struct jsNameSpace* ns, jsName name );
static inline void * _RGLGetNamedValue( struct jsNameSpace* ns, jsName name )
{
return ns->data[name - 1];
}
void _RGLTexNameSpaceInit( jsTexNameSpace *ns, jsTexNameSpaceCreateFunction create, jsTexNameSpaceDestroyFunction destroy );
void _RGLTexNameSpaceFree( jsTexNameSpace *ns );
void _RGLTexNameSpaceResetNames( jsTexNameSpace *ns );
GLuint _RGLTexNameSpaceGetFree( jsTexNameSpace *ns );
GLboolean _RGLTexNameSpaceCreateNameLazy( jsTexNameSpace *ns, GLuint name );
GLboolean _RGLTexNameSpaceIsName( jsTexNameSpace *ns, GLuint name );
void _RGLTexNameSpaceGenNames( jsTexNameSpace *ns, GLsizei n, GLuint *names );
void _RGLTexNameSpaceDeleteNames( jsTexNameSpace *ns, GLsizei n, const GLuint *names );
void _RGLTexNameSpaceReinit( jsTexNameSpace * saved, jsTexNameSpace * active );
#define MEMORY_ALLOC_ERROR 0
#define GMM_ERROR 0xFFFFFFFF
#define GMM_TILE_ALIGNMENT 0x10000
#define GMM_ALIGNMENT 128
#define GMM_RSX_WAIT_INDEX 254
#define GMM_PPU_WAIT_INDEX 255
#define GMM_BLOCK_COUNT 512
#define GMM_TILE_BLOCK_COUNT 16
#define GMM_NUM_FREE_BINS 22
#define GMM_FREE_BIN_0 0x80 // 0x00 - 0x80
#define GMM_FREE_BIN_1 0x100 // 0x80 - 0x100
#define GMM_FREE_BIN_2 0x180 // ...
#define GMM_FREE_BIN_3 0x200
#define GMM_FREE_BIN_4 0x280
#define GMM_FREE_BIN_5 0x300
#define GMM_FREE_BIN_6 0x380
#define GMM_FREE_BIN_7 0x400
#define GMM_FREE_BIN_8 0x800
#define GMM_FREE_BIN_9 0x1000
#define GMM_FREE_BIN_10 0x2000
#define GMM_FREE_BIN_11 0x4000
#define GMM_FREE_BIN_12 0x8000
#define GMM_FREE_BIN_13 0x10000
#define GMM_FREE_BIN_14 0x20000
#define GMM_FREE_BIN_15 0x40000
#define GMM_FREE_BIN_16 0x80000
#define GMM_FREE_BIN_17 0x100000
#define GMM_FREE_BIN_18 0x200000
#define GMM_FREE_BIN_19 0x400000
#define GMM_FREE_BIN_20 0x800000
#define GMM_FREE_BIN_21 0x1000000
typedef struct GmmFixedAllocData
{
char **ppBlockList[2];
uint16_t **ppFreeBlockList[2];
uint16_t *pBlocksUsed[2];
uint16_t BlockListCount[2];
} GmmFixedAllocData;
typedef struct GmmBaseBlock
{
uint8_t isTile;
uint8_t isMain;
uint32_t address;
uint32_t size;
} GmmBaseBlock;
typedef struct GmmBlock
{
GmmBaseBlock base;
struct GmmBlock *pPrev;
struct GmmBlock *pNext;
uint8_t isPinned;
struct GmmBlock *pPrevFree;
struct GmmBlock *pNextFree;
uint32_t fence;
} GmmBlock;
typedef struct GmmTileBlock
{
GmmBaseBlock base;
struct GmmTileBlock *pPrev;
struct GmmTileBlock *pNext;
uint32_t tileTag;
void *pData;
} GmmTileBlock;
typedef struct GmmAllocator
{
uint32_t memoryBase;
uint32_t startAddress;
uint32_t size;
uint32_t freeAddress;
GmmBlock *pHead;
GmmBlock *pTail;
GmmBlock *pSweepHead;
uint32_t freedSinceSweep;
uint32_t tileStartAddress;
uint32_t tileSize;
GmmTileBlock *pTileHead;
GmmTileBlock *pTileTail;
GmmBlock *pPendingFreeHead;
GmmBlock *pPendingFreeTail;
GmmBlock *pFreeHead[GMM_NUM_FREE_BINS];
GmmBlock *pFreeTail[GMM_NUM_FREE_BINS];
uint32_t totalSize;
} GmmAllocator;
extern GmmAllocator *pGmmLocalAllocator;
extern GmmAllocator *pGmmMainAllocator;
uint32_t gmmInit(
const void *localMemoryBase,
const void *localStartAddress,
const uint32_t localSize,
const void *mainMemoryBase,
const void *mainStartAddress,
const uint32_t mainSize
);
uint32_t gmmIdToOffset(const uint32_t id);
char *gmmIdToAddress(const uint32_t id);
uint32_t gmmFree(const uint32_t freeId);
uint32_t gmmAlloc(const uint8_t isTile, const uint32_t size);
uint32_t gmmAllocExtendedTileBlock(const uint32_t size, const uint32_t tag);
void gmmSetTileAttrib(const uint32_t id, const uint32_t tag, void *pData);
#define GCM_FUNC_BUFFERED( GCM_FUNCTION, COMMAND_BUFFER, ...) \
{ \
CellGcmContextData gcmContext; \
gcmContext.current = (uint32_t *)COMMAND_BUFFER; \
GCM_FUNCTION ## UnsafeInline( &gcmContext, __VA_ARGS__ ); \
COMMAND_BUFFER = (typeof(COMMAND_BUFFER))gcmContext.current; \
}
#define GCM_FUNC_BUFFERED_NO_ARGS( GCM_FUNCTION, COMMAND_BUFFER ) \
{ \
CellGcmContextData gcmContext; \
gcmContext.current = (uint32_t *)COMMAND_BUFFER; \
GCM_FUNCTION ## UnsafeInline( &gcmContext ); \
COMMAND_BUFFER = (typeof(COMMAND_BUFFER))gcmContext.current; \
}
typedef struct
{
unsigned dst_id;
unsigned dst_id_offset;
unsigned dst_pitch;
unsigned dst_x;
unsigned dst_y;
unsigned src_id;
unsigned src_id_offset;
unsigned src_pitch;
unsigned src_x;
unsigned src_y;
unsigned width;
unsigned height;
unsigned bpp;
void *fifo_ptr;
} transfer_params_t;
#define HOST_BUFFER_ALIGNMENT 128
#define _RGL_TRANSIENT_MEMORY_DEFAULT (32 << 20)
#define _RGL_PERSISTENT_MEMORY_DEFAULT (160 << 20)
#define _RGL_FIFO_SIZE_DEFAULT (256 * 1024)
#define _RGL_HOST_SIZE_DEFAULT (0)
#define _RGL_TRANSIENT_ENTRIES_DEFAULT 64
#define _RGL_BUFFER_OBJECT_BLOCK_SIZE 128
typedef struct PSGLinitOptions
{
GLuint enable;
int errorConsole;
GLuint fifoSize;
GLuint hostMemorySize;
} PSGLinitOptions;
struct RGLSemaphore
{
GLuint val;
GLuint pad0;
GLuint pad1;
GLuint pad2;
};
struct RGLSemaphoreMemory
{
RGLSemaphore userSemaphores[256];
};
struct RGLResource
{
char *localAddress;
GLuint localSize;
GLuint MemoryClock;
GLuint GraphicsClock;
char * hostMemoryBase;
GLuint hostMemorySize;
GLuint hostMemoryReserved;
unsigned long dmaPushBufferOffset;
char * dmaPushBuffer;
GLuint dmaPushBufferSize;
void* dmaControl;
RGLSemaphoreMemory *semaphores;
};
typedef volatile struct
{
GLuint Ignored00[0x010];
GLuint Put;
GLuint Get;
GLuint Reference;
GLuint Ignored01[0x1];
GLuint SetReference;
GLuint TopLevelGet;
GLuint Ignored02[0x2];
GLuint SetContextDmaSemaphore;
GLuint SetSemaphoreOffset;
GLuint SetSemaphoreAcquire;
GLuint SetSemaphoreRelease;
GLuint Ignored03[0x7e4];
} RGLControlDma;
struct RGLFifo: public CellGcmContextData
{
RGLControlDma *dmaControl;
uint32_t *dmaPushBufferBegin;
uint32_t *dmaPushBufferEnd;
GLuint fifoBlockSize;
unsigned long dmaPushBufferOffset;
GLuint dmaPushBufferSizeInWords;
uint32_t *lastPutWritten;
uint32_t *lastGetRead;
GLuint lastSWReferenceWritten;
GLuint lastSWReferenceFlushed;
GLuint lastHWReferenceRead;
uint32_t *dmaPushBufferGPU;
int spuid;
};
static inline void TransferDataVidToVid(transfer_params_t *params)
{
GmmBaseBlock *pBaseBlock_dst = (GmmBaseBlock *)params->dst_id;
GmmBaseBlock *pBaseBlock_src = (GmmBaseBlock *)params->src_id;
GLuint dstOffset_tmp = gmmAddressToOffset(pBaseBlock_dst->address, pBaseBlock_dst->isMain) + params->dst_id_offset;
GLuint srcOffset_tmp = gmmAddressToOffset(pBaseBlock_src->address, pBaseBlock_src->isMain) + params->src_id_offset;
cellGcmSetTransferImage( (RGLFifo*)params->fifo_ptr, CELL_GCM_TRANSFER_LOCAL_TO_LOCAL, dstOffset_tmp, params->dst_pitch, params->dst_x, params->dst_y, srcOffset_tmp, params->src_pitch, params->src_x, params->src_y, params->width, params->height, params->bpp);
}
typedef struct RGLRenderTarget RGLRenderTarget;
typedef struct RGLCachedState RGLCachedState;
typedef struct RGLBlendState RGLBlendState;
typedef struct RGLInterpolantState RGLInterpolantState;
struct RGLInterpolantState
{
GLuint vertexProgramAttribMask;
GLuint fragmentProgramAttribMask;
};
struct RGLBlendState
{
GLuint alphaFunc;
GLfloat alphaRef;
};
struct RGLRenderTarget
{
GLuint colorFormat;
GLuint colorBufferCount;
GLuint yInverted;
CellGcmSurface gcmRenderTarget;
};
struct RGLCachedState
{
RGLBlendState blend;
RGLViewportState viewport;
RGLInterpolantState interpolant;
};
struct RGLState
{
char *localAddress;
void *hostMemoryBase;
GLuint hostMemorySize;
RGLSemaphoreMemory *semaphores;
RGLFifo fifo;
RGLRenderTarget renderTarget;
RGLCachedState state;
CellGcmConfig config;
GLuint labelValue;
};
GLboolean _RGLInit( PSGLinitOptions* options, RGLResource *resource );
#define SEMA_NEVENTS 128
#define SEMA_BASE 64
#define SEMA_FENCE (SEMA_BASE + SEMA_NEVENTS)
void _RGLIncFenceRef( GLuint* ref );
typedef struct
{
GLenum pool;
unsigned int bufferId;
unsigned int bufferSize;
unsigned int pitch;
GLuint mapCount;
GLenum mapAccess;
} RGLBufferObject;
void _RGLSetNativeCgVertexProgram( const void *header );
void _RGLSetNativeCgFragmentProgram( const void *header );
GLboolean _RGLTryResizeTileRegion( GLuint address, GLuint size, void* data );
static inline GLuint _RGLPlatformGetBitsPerPixel( GLenum internalFormat )
{
switch ( internalFormat )
{
case RGL_HILO8:
case RGL_RGB5_A1_SCE:
case RGL_RGB565_SCE:
return 16;
case RGL_ALPHA8:
return 8;
case RGL_RGBX8:
case RGL_RGBA8:
case RGL_ABGR8:
case RGL_ARGB8:
case RGL_BGRA8:
return 32;
default:
return 0;
}
}
static inline void _RGLFifoGlViewport( GLint x, GLint y, GLsizei width, GLsizei height, GLclampf zNear = 0.0f, GLclampf zFar = 1.0f )
{
RGLViewportState *vp = &_RGLState.state.viewport;
RGLRenderTarget *rt = &_RGLState.renderTarget;
GLint clipX0, clipX1, clipY0, clipY1;
vp->x = x;
vp->y = y;
vp->w = width;
vp->h = height;
clipX0 = x;
clipX1 = x + width;
clipY0 = y;
clipY1 = y + height;
if ( rt->yInverted )
{
clipY0 = rt->gcmRenderTarget.height - ( y + height );
clipY1 = rt->gcmRenderTarget.height - y;
}
if ( clipX0 < 0 )
clipX0 = 0;
if ( clipY0 < 0 )
clipY0 = 0;
if ( clipX1 >= CELL_GCM_MAX_RT_DIMENSION )
clipX1 = CELL_GCM_MAX_RT_DIMENSION;
if ( clipY1 >= CELL_GCM_MAX_RT_DIMENSION )
clipY1 = CELL_GCM_MAX_RT_DIMENSION;
if (( clipX1 <= clipX0 ) || ( clipY1 <= clipY0 ) )
clipX0 = clipY0 = clipX1 = clipY1 = 0;
vp->xScale = width * 0.5f;
vp->xCenter = (GLfloat)(x + vp->xScale + SUBPIXEL_ADJUST);
vp->yScale = height;
if ( rt->yInverted )
{
vp->yScale *= -0.5f;
vp->yCenter = (GLfloat)(rt->gcmRenderTarget.height - y + vp->yScale + SUBPIXEL_ADJUST);
}
else
{
vp->yScale *= 0.5f;
vp->yCenter = (GLfloat)(y + vp->yScale + SUBPIXEL_ADJUST);
}
float scale[4] = { vp->xScale, vp->yScale, 0.5f, 0.0f };
float offset[4] = { vp->xCenter, vp->yCenter, 0.5f, 0.0f };
cellGcmSetViewportInline( &_RGLState.fifo, clipX0, clipY0, clipX1 - clipX0,
clipY1 - clipY0, zNear, zFar, scale, offset );
}
#define PSGL_DEVICE_PARAMETERS_COLOR_FORMAT 0x0001
#define PSGL_DEVICE_PARAMETERS_DEPTH_FORMAT 0x0002
#define PSGL_DEVICE_PARAMETERS_MULTISAMPLING_MODE 0x0004
#define PSGL_DEVICE_PARAMETERS_TV_STANDARD 0x0008
#define PSGL_DEVICE_PARAMETERS_CONNECTOR 0x0010
#define PSGL_DEVICE_PARAMETERS_BUFFERING_MODE 0x0020
#define PSGL_DEVICE_PARAMETERS_WIDTH_HEIGHT 0x0040
#define PSGL_DEVICE_PARAMETERS_RESC_RENDER_WIDTH_HEIGHT 0x0080
#define PSGL_DEVICE_PARAMETERS_RESC_RATIO_MODE 0x0100
#define PSGL_DEVICE_PARAMETERS_RESC_PAL_TEMPORAL_MODE 0x0200
#define PSGL_DEVICE_PARAMETERS_RESC_INTERLACE_MODE 0x0400
#define PSGL_DEVICE_PARAMETERS_RESC_ADJUST_ASPECT_RATIO 0x0800
// mask for validation
#define PSGL_VALIDATE_NONE 0x00000000
#define PSGL_VALIDATE_FRAMEBUFFER 0x00000001
#define PSGL_VALIDATE_TEXTURES_USED 0x00000002
#define PSGL_VALIDATE_VERTEX_PROGRAM 0x00000004
#define PSGL_VALIDATE_VERTEX_CONSTANTS 0x00000008
#define PSGL_VALIDATE_VERTEX_TEXTURES_USED 0x00000010
#define PSGL_VALIDATE_FFX_VERTEX_PROGRAM 0x00000020
#define PSGL_VALIDATE_FRAGMENT_PROGRAM 0x00000040
#define PSGL_VALIDATE_FFX_FRAGMENT_PROGRAM 0x00000080
#define PSGL_VALIDATE_VIEWPORT 0x00000200
#define PSGL_VALIDATE_FACE_CULL 0x00010000
#define PSGL_VALIDATE_BLENDING 0x00020000
#define PSGL_VALIDATE_POINT_RASTER 0x00040000
#define PSGL_VALIDATE_LINE_RASTER 0x00080000
#define PSGL_VALIDATE_POLYGON_OFFSET 0x00100000
#define PSGL_VALIDATE_SHADE_MODEL 0x00200000
#define PSGL_VALIDATE_LOGIC_OP 0x00400000
#define PSGL_VALIDATE_MULTISAMPLING 0x00800000
#define PSGL_VALIDATE_POLYGON_MODE 0x01000000
#define PSGL_VALIDATE_PRIMITIVE_RESTART 0x02000000
#define PSGL_VALIDATE_CLIP_PLANES 0x04000000
#define PSGL_VALIDATE_SHADER_SRGB_REMAP 0x08000000
#define PSGL_VALIDATE_POINT_SPRITE 0x10000000
#define PSGL_VALIDATE_TWO_SIDE_COLOR 0x20000000
#define PSGL_VALIDATE_ALL 0x3FFFFFFF
#define PSGL_INIT_PERSISTENT_MEMORY_SIZE 0x0004
#define PSGL_INIT_TRANSIENT_MEMORY_SIZE 0x0008
#define PSGL_INIT_ERROR_CONSOLE 0x0010
#define PSGL_INIT_FIFO_SIZE 0x0020
#define PSGL_INIT_HOST_MEMORY_SIZE 0x0040
#define PSGL_INIT_USE_PMQUERIES 0x0080
extern void psglInit( PSGLinitOptions* options );
extern void psglExit();
PSGLdevice *psglCreateDeviceAuto( GLenum colorFormat, GLenum depthFormat, GLenum multisamplingMode );
PSGLdevice *psglCreateDeviceExtended( const PSGLdeviceParameters *parameters );
void psglGetDeviceDimensions(const PSGLdevice *device, GLuint *width, GLuint *height );
void psglDestroyDevice( PSGLdevice* device );
void psglMakeCurrent( PSGLcontext* context, PSGLdevice* device );
PSGLcontext *psglCreateContext(void);
void psglDestroyContext( PSGLcontext* LContext );
void psglResetCurrentContext(void);
PSGLcontext *psglGetCurrentContext(void);
PSGLdevice *psglGetCurrentDevice(void);
void psglSwap(void);
#ifdef __cplusplus
}
#endif
#endif