path: root/libpsx/include/psxgpu.h

#ifndef _PSXGPU_H
#define _PSXGPU_H

#ifdef __cplusplus
extern "C"
{
#endif

#include <stdarg.h>

#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