#ifndef _PSXGPU_H #define _PSXGPU_H #ifdef __cplusplus extern "C" { #endif #include #define GPU_DATA_PORT_ADDR 0x1f801810 #define GPU_CONTROL_PORT_ADDR 0x1f801814 #define GPU_DATA_PORT *((volatile unsigned int*)GPU_DATA_PORT_ADDR) #define GPU_CONTROL_PORT *((volatile unsigned int*)GPU_CONTROL_PORT_ADDR) #define DPCR *((volatile unsigned int*)0x1f8010f0) #define D2_MADR *((volatile unsigned int*)0x1f8010a0) #define D2_BCR *((volatile unsigned int*)0x1f8010a4) #define D2_CHCR *((volatile unsigned int*)0x1f8010a8) #define get_clutid(cx, cy) (((cx&0x3ff)>>4)|((cy&0x1ff)<<6)) /** * Initializes the GPU. Same as GsInitEx(0) * * The display is left disabled. * You can enable it with GsEnableDisplay() or more preferably with GsSetVideoMode() */ void GsInit(void); /** * Initializes the GPU. * * The display is left disabled. * You can enable it with GsEnableDisplay() or more preferably with GsSetVideoMode() * @param flags Flag bitmask */ void GsInitEx(unsigned int flags); /** * Resets the GPU */ void GsReset(void); /** * Enables the display (i.e. generation of video output). * * Unless you are doing low-level GPU programming, you don't need to call this function; * the display is enabled automatically by GsSetVideoMode(). * @param enable If TRUE (>=1) the display will be enabled, if FALSE (== 0) it will be disabled */ void GsEnableDisplay(int enable); /** * Sets a video mode and enables the display. It does so in a quicker way * than GsSetVideoModeEx(), which wants more arguments but offers greater control * @param width Width + 640, 384, 320 and 256 are supported by the PlayStation hardware. * @param height Height + 480 and 240 are supported by the PlayStation hardware. * You probably want to use GsSetVideoModeEx() if you set * 480 here, because this function doesn't enable interlacing. * @param video_mode Video mode + VMODE_NTSC for NTSC, VMODE_PAL for PAL * @return 1 on success, 0 on failure (such as unavailable video mode) */ int GsSetVideoMode(int width, int height, int video_mode); /** * Works like GsSetVideoMode() but offers more control. * Interlaced, 24-bit RGB, and "reverse" flags can be specified. * @param width Width + 640, 384, 320 and 256 are supported by the PlayStation hardware. * @param height Height + 480 and 240 are supported by the PlayStation hardware. * @param video_mode Video mode + VMODE_NTSC for NTSC, VMODE_PAL for PAL * @param rgb24 24-bit RGB mode + If TRUE (!=0) enables the very rarely used 24-bit color mode. Unless you're very creative, don't enable this. * @param inter Interlacing + If TRUE (!=0) enables interlacing. If you set the height paramater to 480, and you want to display your program on a real television screen, you must enable this. * @param reverse Reverse?? + The function of this is not really known. Stay safe and set this to FALSE (0). * @return 1 on success, 0 on failure (such as unavailable video mode) */ int GsSetVideoModeEx(int width, int height, int video_mode, int rgb24, int inter, int reverse); /** * Assigns the internal pointer to the primitive list to the desired one, * and resets the linked list position counter. * The memory address specified by your pointer has to have enough space free to contain all * the packets which you want to send. * @param listptr Pointer to primitive list */ void GsSetList(unsigned int *listptr); /** * Assigns the internal pointer to the primitive list to the desired one, * an sets the linked list position counter to the specified value. * The memory address specified by your pointer has to have enough space free to contain all * the packets which you want to send, and you must ensure that the specified position * is not out of bounds. * @param listptr Pointer to primitive list * @param listpos List position */ void GsSetListEx(unsigned int *listptr, unsigned int listpos); /** * Draws the primitive list. * * This also has the effect of resetting the current drawing list position. */ void GsDrawList(void); /** * Draws the primitive list using port I/O access. * * GsDrawList() uses DMA to transfer the primitive data in the linked list to the GPU. * * This function which is of main interest to low-level programmers, uses GPU port I/O access instead, * and it is slower (as reads and writes must be done by the main CPU), but works in all situations, * even when you can't get DMA working. * * This function due to its nature is blocking, and always waits for completion. */ void GsDrawListPIO(void); /** * Makes non-blocking gpu functions like GsDrawList() * wait for completion. Removes the need to use GsIsDrawing()/GsIsWorking() */ void GsSetAutoWait(void); /** Monochrome 3 point polygon */ typedef struct { /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X Coordinates for vertexes */ short x[3]; /** Y Coordinates for vertexes */ short y[3]; /** Attribute bitmask */ unsigned int attribute; }GsPoly3; /** Monochrome 4 point polygon */ typedef struct { /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X Coordinates for vertexes */ short x[4]; /** Y Coordinates for vertexes */ short y[4]; /** Attribute */ unsigned int attribute; }GsPoly4; /** Textured 3 point polygon */ typedef struct { /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X Coordinates for vertexes */ short x[3]; /** Y Coordinates for vertexes */ short y[3]; /** X Texture offsets for vertexes */ unsigned char u[3]; /** Y Texture offset for vertexes */ unsigned char v[3]; /** CLUT X coordinate */ short cx; /** CLUT Y coordinate */ short cy; /** Attribute */ unsigned int attribute; /** Texture page */ unsigned char tpage; }GsTPoly3; /** Textured 4 point polygon */ typedef struct { /** X Coordinates for vertexes */ short x[4]; /** Y Coordinates for vertexes */ short y[4]; /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** CLUT X coordinate */ short cx; /** CLUT Y coordinate */ short cy; /** Texture page */ unsigned char tpage; /** Horizontal texture offset */ unsigned char u[4]; /** Vertical texture offset */ unsigned char v[4]; /** Attribute */ unsigned int attribute; }GsTPoly4; /** Graduated 3 point polygon */ typedef struct { /** Red color components (0-255) */ unsigned char r[3]; /** Green color components (0-255) */ unsigned char g[3]; /** Blue color components (0-255) */ unsigned char b[3]; /** X Coordinates for vertexes */ short x[3]; /** Y Coordinates for vertexes */ short y[3]; /** Attribute */ unsigned int attribute; }GsGPoly3; /** Graduated 4 point polygon */ typedef struct { /** Red color components (0-255) */ unsigned char r[4]; /** Green color components (0-255) */ unsigned char g[4]; /** Blue color components (0-255) */ unsigned char b[4]; /** X Coordinates for vertexes */ short x[4]; /** Y Coordinates for vertexes */ short y[4]; /** Attribute */ unsigned int attribute; }GsGPoly4; /** Graduated textured 3 point polygon */ typedef struct { /** Red color components (0-255) */ unsigned char r[3]; /** Green color components (0-255) */ unsigned char g[3]; /** Blue color components (0-255) */ unsigned char b[3]; /** X Coordinates for vertexes */ short x[3]; /** Y Coordinates for vertexes */ short y[3]; /** CLUT X coordinate */ short cx; /** CLUT Y coordinate */ short cy; /** Texture page */ unsigned char tpage; /** Horizontal texture offset */ unsigned char u[3]; /** Vertical texture offset */ unsigned char v[3]; /** Attribute */ unsigned int attribute; }GsGTPoly3; /** Graduated textured 4 point polygon */ typedef struct { /** Red color components (0-255) */ unsigned char r[4]; /** Green color components (0-255) */ unsigned char g[4]; /** Blue color components (0-255) */ unsigned char b[4]; /** X Coordinates for vertexes */ short x[4]; /** Y Coordinates for vertexes */ short y[4]; /** CLUT X coordinate */ short cx; /** CLUT Y coordinate */ short cy; /** Texture page */ unsigned char tpage; /** Horizontal texture offset */ unsigned char u[4]; /** Vertical texture offset */ unsigned char v[4]; /** Attribute */ unsigned int attribute; }GsGTPoly4; /** Monochrome line */ typedef struct { /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X Coordinates for points */ short x[2]; /** Y Coordinates for points */ short y[2]; /** Attribute */ unsigned int attribute; }GsLine; /** Dot (pixel) */ typedef struct { /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X coordinate */ short x; /** Y coordinate */ short y; /** Attribute */ unsigned int attribute; }GsDot; /** Graduated line */ typedef struct { /** Red color components (0-255) */ unsigned char r[2]; /** Green color components (0-255) */ unsigned char g[2]; /** Blue color components (0-255) */ unsigned char b[2]; /** X coordinates for points */ short x[2]; /** Y coordinates for points */ short y[2]; /** Attribute */ unsigned int attribute; }GsGLine; /** Sprite */ typedef struct { short x, y; /* X, Y positions */ unsigned char u, v; /* Offset into texture page of sprite image data */ short w, h; /* Width and height of sprite */ short cx, cy; /* Color look up table (palette) X, Y positions */ unsigned char r, g, b; /* Luminosity of color components - 128 is normal luminosity */ unsigned char tpage; /* Texture page */ unsigned int attribute; /* Attribute */ /* Scaling? These are only candidates... scalex: Denotes horizontal scaling 0 = true size (unmodified) 1 = true size (*1) 2 = double size (*2) 3 = triple size (*3) ... -1 = true size (/1) -2 = half size (/2) -3 = one-third size (/3) ... scaley: Denotes vertical scaling *** The behaviour below was introduced in PSXSDK 0.5 If scalex > 8, resulting width will be (original_width * scalex) / 4096 scalex = 4096 (SCALE_ONE) (original width), scalex = 2048 (half width), etc. If scaley > 8, resulting height will be (original_height * scaley) / 4096 works like scalex but affects height */ int scalex, scaley; int rotate; // Rotation angle - Fixed point notation, 4096 = 1 degree int mx, my; // Coordinates of rotation center - relative to coordinates of sprite }GsSprite; /** Rectangle */ typedef struct { short x, y; short w, h; unsigned char r, g, b; unsigned int attribute; /* Attribute */ }GsRectangle; typedef struct { /** Number of points */ unsigned int npoints; /** Red color component (0-255) */ unsigned char r; /** Green color component (0-255) */ unsigned char g; /** Blue color component (0-255) */ unsigned char b; /** X Coordinates for points */ short *x; /** Y Coordinates for points */ short *y; /** Attribute */ unsigned int attribute; }GsPolyLine; typedef struct { /** Number of points */ unsigned int npoints; /** Red color components (0-255) */ unsigned char *r; /** Green color components (0-255) */ unsigned char *g; /** Blue color components (0-255) */ unsigned char *b; /** X Coordinates for points */ short *x; /** Y Coordinates for points */ short *y; /** Attribute */ unsigned int attribute; }GsGPolyLine; /** Map */ //typedef struct //{ // short x, y; /* X, Y positions */ // unsigned char u, v; /* Offset into texture page of sprite image data */ // short w, h; /* Width and height of tilemap */ // short l; /* Length of tilemap line */ // short cx, cy; /* Color look up table (palette) X, Y positions */ // unsigned char r, g, b; /* Luminosity of color components - 128 is normal luminosity */ // unsigned char tpage; /* Texture page */ // unsigned int attribute; /* Attribute */ // // unsigned short tmw, tmh; /* Map texture width and height */ // unsigned char tw, th; /* Map tile width and height */ // // unsigned char tsize; /* Size of tile in map (1 = 8-bit, 2 = 16-bit, 4 = 32-bit) */ // // unsigned int tmask; /* Inverted mask for tile number */ // // void *data; /* Pointer to beginning of map data */ //}GsMap; /** Texture color modes. */ enum psx_gpu_texmodes { /** 4-bit color mode */ COLORMODE_4BPP, /** 8-bit color mode */ COLORMODE_8BPP, /** 16-bit color mode */ COLORMODE_16BPP, /** 24-bit color mode */ COLORMODE_24BPP }; /** * This is the luminance factor with which images * are drawn as they are stored. (i.e. without applying lighting) * * NORMAL_LUMINOSITY (sic) is kept for backward compatibility, * but "luminosity" is an incorrect term here. */ #define NORMAL_LUMINANCE 128 #define NORMAL_LUMINOSITY NORMAL_LUMINANCE /** * Macro to specify texture color mode, takes a value from psx_gpu_texmodes */ #define COLORMODE(x) ((x) & 3) /** * Macro to specify translucency/semitransparency mode, where x can be a value from 0 to 3. * * If a pixel in image data to be drawn has the STP bit set, semitransparency * processing is enabled for that pixel. * * When the color is black (RGB=0,0,0) STP is processed differently from when it is not * black. * * The table below shows the differences: * * Color | STP bit | Processing off | Processing on * ----- | ---- | ----- | ---- * Black | 0 | Transparent | Transparent * Black | 1 | Non-transparent |Non-Transparent * Not black | 0 | Non-Transparent |Non-Transparent * Not black | 1 | Non-Transparent |Transparent * * If the image pixel is semi-transparent (STP bit set) and not black, the formulas for the * final pixel color are the following: * * Mode | From framebuffer pixel| From image pixel * ---- | --- | ----- * 0 | +50% | +50% * 1 | +100% | +100% * 2 | +100% | -100% * 3 | +100% | +25% * * The final color component values do not underflow or overflow, they simply saturate at 0 or 255. */ #define TRANS_MODE(x) ((x&3)<<2) /** * Enable semi-transparency processing for the primitive. */ #define ENABLE_TRANS (1<<4) /** * Enable horizontal flipping for the primitive. */ #define H_FLIP (1<<5) /** * Enable vertical flipping for the primitive. */ #define V_FLIP (1<<6) /** * Drawing environment. */ typedef struct { /** * Dithering enabled flag. */ unsigned char dither; /** * Enable drawing on display area flag. * * If this flag is enabled, drawing on display area is allowed. * * Usually you enable this flag when you do not want to use double buffering. */ unsigned char draw_on_display; /** * Drawing area X start coordinate in framebuffer */ short x; /** * Drawing area Y start coordinate in framebuffer */ short y; /** * Drawing area width. */ short w; /** * Drawing area height. */ short h; /* * Drawing offset */ //short off_x, off_y; /** * Masking settings (can also be set with GsSetMasking()) */ /** * Do not draw over pixels which have their mask bit set */ unsigned char ignore_mask; /** * If this is set, every pixel drawn will have the mask bit set */ unsigned char set_mask; }GsDrawEnv; /** * Display environment. * * The width and height of the display area are those of the currently set video mode. */ typedef struct { /** Display area X start coordinate in framebuffer. */ short x; /** Display area Y start coordinate in framebuffer. */ short y; }GsDispEnv; /** * Image * @brief This structure describes a TIM image */ typedef struct { /** Pixel (color) mode. 0 = 4bpp, 1 = 8bpp, 2 = 16bpp, 3 = 24bpp */ int pmode; /** Reports whether this image has a Color Look Up Table. 1 if there's a CLUT, 0 otherwise. */ int has_clut; /** X coordinate of CLUT in framebuffer */ int clut_x; /** Y coordinate of CLUT in framebuffer */ int clut_y; /** Width of CLUT in framebuffer */ int clut_w; /** Height of CLUT in framebuffer */ int clut_h; /** X coordinate of image in framebuffer */ int x; /** Y coordinate of image in framebuffer */ int y; /** Width of image in framebuffer */ int w; /** Height of image in framebuffer */ int h; /** Pointer to CLUT data */ const void *clut_data; /** Pointer to image data */ const void *data; }GsImage; /** * Adds a monochrome 3 point polygon to the packet list * @param poly3 Pointer to structure for monochrome 3 point polygon */ void GsSortPoly3(const GsPoly3 *poly3); /** * Adds a monochrome 4 point polygon to the packet list * @param poly4 Pointer to structure for monochrome 4 point polygon */ void GsSortPoly4(const GsPoly4 *poly4); /** * Adds a textured 3 point polygon to the packet list * @param tpoly3 Pointer to structure for textured 3 point polygon */ void GsSortTPoly3(const GsTPoly3 *tpoly3); /** * Adds a textured 4 point polygon to the packet list * @param tpoly4 Pointer to structure for textured 4 point polygon */ void GsSortTPoly4(const GsTPoly4 *tpoly4); /** * Adds a gradated 3 point polygon to the packet list * @param poly3 Pointer to structure for gradated 3 point polygon */ void GsSortGPoly3(const GsGPoly3 *poly3); /** * Adds a gradated 4 point polygon to the packet list * @param poly4 Pointer to structure for gradated 4 point polygon */ void GsSortGPoly4(const GsGPoly4 *poly4); /** * Adds a gradated textured 3 point polygon to the packet list * @param tpoly3 Pointer to structure for textured 3 point polygon */ void GsSortGTPoly3(const GsGTPoly3 *tpoly3); /** * Adds a gradated 4 point polygon to the packet list * @param tpoly4 Pointer to structure for textured 4 point polygon */ void GsSortGTPoly4(const GsGTPoly4 *tpoly4); /** * Adds a monochrome line to the packet list * @param line Pointer to structure for monochrome line */ void GsSortLine(const GsLine *line); /** * Adds a gradated line to the packet list * @param line Pointer to structure for gradated line */ void GsSortGLine(const GsGLine *line); /** * Adds a dot (pixel) to the packet list * @param dot Pointer to structure for dot */ void GsSortDot(const GsDot *dot); /** * Adds a sprite to the packet list * @param sprite Pointer to structure for sprite */ void GsSortSprite(const GsSprite *sprite); /** * Always adds a REAL sprite to the packet list * * + GsSortSprite() on the other hand checks for scaling and flipping, which * are not supported by the "sprite" primitive on the PlayStation, but instead * are done by using a textured 4-point polygon accordingly. * GsSortSprite() only uses the sprite primitive when all the attributes * can be done with a "sprite" primitive as well. * * @param sprite Pointer to structure for sprite */ void GsSortSimpleSprite(const GsSprite *sprite); /** * Adds a rectangle to the packet list * @param rectangle Pointer to structure for rectangle */ void GsSortRectangle(const GsRectangle *rectangle); /** * Moves image data from a part of the framebuffer to another. * Actually it does a copy. * @param src_x Top-left X coordinate of source area * @param src_y Top-left Y coordinate of source area * @param dst_x Top-left X coordinate of destination area * @param dst_y Top-left Y coordinate of destination area * @param w Width of area * @param h Height of area */ void MoveImage(int src_x, int src_y, int dst_x, int dst_y, int w, int h); /** * Loads image data into framebuffer memory. * @param img Pointer to raw image data * @param x Top-left X coordinate of destination area * @param y Top-left Y coordinate of destination area * @param w Width of image data * @param h Height of image data */ void LoadImage(const void *img, int x, int y, int w, int h); /** * Draws a rectangle in the framebuffer, without considering drawing * and display environments (i.e. it does so in an absolute way) * @param x Top-left X coordinate of area * @param y Top-left Y coordinate of area * @param w Area width * @param h Area height * @param r Red (0 - 255) * @param g Green (0 - 255) * @param b Blue (0 - 255) */ void DrawFBRect(int x, int y, int w, int h, int r, int g, int b); /** * Set drawing environment * @param drawenv Pointer to drawing environment structure */ void GsSetDrawEnv(const GsDrawEnv *drawenv); /** * Set drawing environment via DMA commands. * @param drawenv Pointer to drawing environment structure */ void GsSetDrawEnv_DMA(const GsDrawEnv* drawenv); /** * Set display environment * @param dispenv Pointer to display environment structure */ void GsSetDispEnv(const GsDispEnv *dispenv); /* If this flag is set, pixels drawn have MSB set */ #define MASK_SET 1 /* If this flag is set, pixels aren't drawn over pixels with MSB set */ #define MASK_IGNORE 2 /** * Sets masking settings * @param flag Bitwise flags */ void GsSetMasking(unsigned char flag); /** * Return pointer position in linked list * @return Pointer position in linked list */ unsigned int GsListPos(void); /** * Three functions which send data to the control port and to the data port */ void gpu_ctrl(unsigned int command, unsigned int param); void gpu_data(unsigned int data); void gpu_data_ctrl(unsigned int command, unsigned int param); /** * Puts information about a TIM image passed in a buffer in a GsImage structure. */ int GsImageFromTim(GsImage *image, const void *timdata); /** * Uploads an image described by a GsImage structure to video memory. */ void GsUploadImage(const GsImage *image); /** * Upload a CLUT described by a GsImage structure to video memory. */ void GsUploadCLUT(const GsImage *image); /** * Fills a GsSprite structure with information from an image described * by a GsImage structure, then optionally uploads data to video memory. * Sprite coordinates are set to 0. */ int GsSpriteFromImage(GsSprite *sprite, const GsImage *image, int do_upload); /** * Checks if the GPU is drawing * @return 1 if GPU is drawing, 0 otherwise */ int GsIsDrawing(void); /** * Checks if the GPU is working. Alias of GsIsDrawing() * @return 1 if GPU is working, 0 otherwise. */ int GsIsWorking(void); // Alias of GsIsDrawing() /** * Clear Video RAM */ void GsClearMem(void); /** * Loads the built-in 8x8 font in Video RAM at the specified coordinates * * * Specifying cx and cy as -1 will not load the black&white CLUT to * video memory. Use GsSetFont() to specify clut x and clut y in that case. * * The font occupies a space of 16x128 pixels in 16-bit mode, * and 64x128 in 4-bit mode. * @param fb_x X coordinate in framebuffer * @param fb_y Y coordinate in framebuffer * @param cx X coordinate of black/white CLUT in framebuffer * @param cy Y coordinate of black/white CLUT in framebuffer */ void GsLoadFont(int fb_x, int fb_y, int cx, int cy); /** * Prints string using 8x8 font at screen coordinates x, y * @param x X coordinate * @param y Y coordinate * @param fmt format (like *printf()) * @return Position identifier. */ unsigned int GsPrintFont(int x, int y, const char *fmt, ...); /** * Prints string using 8x8 font at screen coordinates x, y * Apart from using a variable argument list, this function * is identical to GsPrintFont() * @param x X coordinate * @param y Y coordinate * @param fmt format (like *printf()) * @param ap Variable argument list * @return Position identifier. */ unsigned int GsVPrintFont(int x, int y, const char *fmt, va_list ap); /** * Change font coordinates without reloading it */ void GsSetFont(int fb_x, int fb_y, int cx, int cy); /** * This is a function that sets an internal variable * flags should be specified as an OR mask * * to set the wrap and scale attributes, with X scaling factor 2 and Y scaling * factor 3, for example: * GsSetFontAttrib(PRFONT_WRAP | PRFONT_SCALE * | PRFONT_SCALEX(2) | PRFONT_SCALEY(3)); * * to remove all attributes (normal printing): * * GsSetFontAttrib(0); * * PRFONT_WRAP can't coexist with PRFONT_CENTER or PRFONT_RIGHT * PRFONT_CENTER and PRFONT_RIGHT are justifying attributes and as such * they are mutually exclusive - they cannot coexist with each other. * Specifying both will give priority to PRFONT_CENTER. * * Attribute list: * * PRFONT_WRAP - Wrap to next row when the text would fall off the screen * Ideal for debug * PRFONT_SCALE - Enable font scaling * PRFONT_SCALEX(i) - Specifies the factor "i" as the X scaling factor * This has the same meaning as a sprite's scaling factor * PRFONT_SCALEY(i) - Specify the factor "i" as the Y scaling factor * This has the same meaning as a sprite's scaling factor * PRFONT_RIGHT - Justifies text to the right * PRFONT_CENTER - Justifies text at the center * PRFONT_RL(f) - Luminance factor for the red component * PRFONT_GL(f) - Luminance factor for the green component * PRFONT_BL(f) - Luminance factor for the blue component */ void GsSetFontAttrib(unsigned int flags); /** * Sets drawing environment * Enables drawing on the display area, disables dithering and disables all masking flags by default * @param x Top-left X coordinate of framebuffer area to use for drawing * @param y Top-left Y coordinate of framebuffer area to use for drawing * @param w Width of area * @param h Height of area */ void GsSetDrawEnvSimple(int x, int y, int w, int h); /** * Sets display environment * @param x Top-left X coordinate of framebuffer area to display * @param y Top-left Y coordinate of framebuffer area to display */ void GsSetDispEnvSimple(int x, int y); /** Television video modes. */ enum psx_gpu_vmodes { /** NTSC video mode, 60Hz */ VMODE_NTSC, /** PAL video mode, 50Hz */ VMODE_PAL }; /** One scaling unit. */ #define SCALE_ONE 4096 /** One rotation unit. */ #define ROTATE_ONE 4096 // GsSetFontAttrib() Attribute Flags #define PRFONT_WRAP 1 #define PRFONT_CENTER 2 #define PRFONT_RIGHT 4 #define PRFONT_SCALE 8 #define PRFONT_UNIXLF 16 #define PRFONT_COLOR 32 // These below are not really attributes... but use them as if they were. unsigned int PRFONT_SCALEX(int i); unsigned int PRFONT_SCALEY(int i); unsigned int PRFONT_RL(unsigned char f); unsigned int PRFONT_GL(unsigned char f); unsigned int PRFONT_BL(unsigned char f); // Use this to get the final X and Y positions from the return value // of GsPrintFont(). Especially useful after wrapping. #define prfont_get_fx(i) ((short)(i & 0xffff)) #define prfont_get_fy(i) ((short)((i >> 16) & 0xffff)) // Width and height of the screen in the current video mode /** This global variable reports the current screen width, as set by GsSetVideoMode(). Do not modify. */ extern unsigned short GsScreenW; /** This global variable reports the current screen height, as set by GsSetVideoMode(). Do not modify. */ extern unsigned short GsScreenH; /** This global variable reports the current screen color mode (PAL or NTSC), as set by GsSetVideoMode(). You can use the values in the psx_gpu_vmodes enum to evaluate this. Do not modify. */ extern unsigned char GsScreenM; // Current video mode /** This global variable reports the width of the current drawing environment. */ extern unsigned short GsCurDrawEnvW; /** This global variable reports the height of the current drawing environment. */ extern unsigned short GsCurDrawEnvH; /** * Clear the entire drawing area with specified color * @param r Red (0 - 255) * @param g Green (0 - 255) * @param b Blue (0 - 255) */ void GsSortCls(int r, int g, int b); /** @attention Macros by their definition do not like being passed invalid values. */ /** * Macro to get a texture page number from a coordinate in VRAM * @param x X coordinate (0-1023) * @param y Y coordinate (0-511) */ #define gs_get_tpage_num(x,y) ((x/64)+((y/256)*16)) /** * Macro to get an horizontal texture offset from a X coordinate in VRAM * @param x X coordinate (0-1023) */ #define gs_get_tpage_u(x) (x&0x3f) /** * Macro to get a vertical texture offset from a Y coordinate in VRAM * @param y Y coordinate (0-511) */ #define gs_get_tpage_v(y) (y&0xff) /** * This macro converts a RGB 888 color to PlayStation color format. * @param r Red component (0-255) * @param g Green component (0-255) * @param b Blue component (0-255) */ #define gs_rgb_to_psx(r, g, b) ((r>>3)|((g>>3)<<5)|((b>>3)<<10)) /** * This macro converts a RGB 888 color (a color whose color components have an intensity between 0 and 255) * to PlayStation color format, considering an alpha bit. If the alpha bit is non-zero, the STP bit in the color * is set and will be considered for PlayStation translucency effects. * @param r Red component (0-255) * @param g Green component (0-255) * @param b Blue component (0-255) * @param a Alpha bit (STP/semitransparency bit) */ #define gs_rgba_to_psx(r, g, b, a) ((r>>3)|((g>>3)<<5)|((b>>3)<<10)|(a==0?0:1)) /** * This function can rotate a vector about the X, Y and Z axes * If you don't want to rotate a vector about an axis, pass 0 as angle to that axis * * It is correct to pass the same argument to v and n, as calculations are first done in an internal buffer * and then stored in the output array * * @param x_a Number of degrees (0-359) to which the vector should be rotated about the X axis * @param y_a Number of degrees (0-359) to which the vector should be rotated about the Y axis * @param z_a Number of degrees (0-359) to which the vector should be rotated about the Z axis * @param v Pointer to an array of coordinates for the source vector * @param n Pointer to destination array for the coordinates of the rotated vector */ void GsRotateVector(int x_a, int y_a, int z_a, double *v, double *n); /** * Adds a monochrome polyline to the packet list * @param line Pointer to structure for monochrome polyline */ void GsSortPolyLine(const GsPolyLine *line); /** * Adds a gradated polyline to the packet list * @param line Pointer to structure for monochrome line */ void GsSortGPolyLine(const GsGPolyLine *line); #ifdef __cplusplus } #endif //void GsSortSimpleMap(GsMap *map); #endif