pspgu.h

Go to the documentation of this file.

/*
 * PSP Software Development Kit - https://github.com/pspdev
 * -----------------------------------------------------------------------
 * Licensed under the BSD license, see LICENSE in PSPSDK root for details.
 *
 * Copyright (c) 2005 Jesper Svennevid
 */
 
#ifndef __pspgu_h__
#define __pspgu_h__
 
#include <psptypes.h>
#include <pspge.h>
 
#if defined(__cplusplus)
extern "C" {
#endif
 
/* PI, float-sized */
#define GU_PI                   (3.141593f)
 
/* Boolean values for convenience */
#define GU_FALSE                (0)
#define GU_TRUE                 (1)
 
/* Primitive types */
#define GU_POINTS               (0)
#define GU_LINES                (1)
#define GU_LINE_STRIP           (2)
#define GU_TRIANGLES            (3)
#define GU_TRIANGLE_STRIP       (4)
#define GU_TRIANGLE_FAN         (5)
#define GU_SPRITES              (6)
 
/* States */
#define GU_ALPHA_TEST           (0)
#define GU_DEPTH_TEST           (1)
#define GU_SCISSOR_TEST         (2)
#define GU_STENCIL_TEST         (3)
#define GU_BLEND                (4)
#define GU_CULL_FACE            (5)
#define GU_DITHER               (6)
#define GU_FOG                  (7)
#define GU_CLIP_PLANES          (8)
#define GU_TEXTURE_2D           (9)
#define GU_LIGHTING             (10)
#define GU_LIGHT0               (11)
#define GU_LIGHT1               (12)
#define GU_LIGHT2               (13)
#define GU_LIGHT3               (14)
#define GU_LINE_SMOOTH          (15)
#define GU_PATCH_CULL_FACE      (16)
#define GU_COLOR_TEST           (17)
#define GU_COLOR_LOGIC_OP       (18)
#define GU_FACE_NORMAL_REVERSE  (19)
#define GU_PATCH_FACE           (20)
#define GU_FRAGMENT_2X          (21)
 
/* Matrix modes */
#define GU_PROJECTION           (0)
#define GU_VIEW                 (1)
#define GU_MODEL                (2)
#define GU_TEXTURE              (3)
 
/* Vertex Declarations Begin */
#define GU_TEXTURE_SHIFT(n)     ((n)<<0)
#define GU_TEXTURE_8BIT         GU_TEXTURE_SHIFT(1)
#define GU_TEXTURE_16BIT        GU_TEXTURE_SHIFT(2)
#define GU_TEXTURE_32BITF       GU_TEXTURE_SHIFT(3)
#define GU_TEXTURE_BITS         GU_TEXTURE_SHIFT(3)
 
#define GU_COLOR_SHIFT(n)       ((n)<<2)
#define GU_COLOR_5650           GU_COLOR_SHIFT(4)
#define GU_COLOR_5551           GU_COLOR_SHIFT(5)
#define GU_COLOR_4444           GU_COLOR_SHIFT(6)
#define GU_COLOR_8888           GU_COLOR_SHIFT(7)
#define GU_COLOR_BITS           GU_COLOR_SHIFT(7)
 
#define GU_NORMAL_SHIFT(n)      ((n)<<5)
#define GU_NORMAL_8BIT          GU_NORMAL_SHIFT(1)
#define GU_NORMAL_16BIT         GU_NORMAL_SHIFT(2)
#define GU_NORMAL_32BITF        GU_NORMAL_SHIFT(3)
#define GU_NORMAL_BITS          GU_NORMAL_SHIFT(3)
 
#define GU_VERTEX_SHIFT(n)      ((n)<<7)
#define GU_VERTEX_8BIT          GU_VERTEX_SHIFT(1)
#define GU_VERTEX_16BIT         GU_VERTEX_SHIFT(2)
#define GU_VERTEX_32BITF        GU_VERTEX_SHIFT(3)
#define GU_VERTEX_BITS          GU_VERTEX_SHIFT(3)
 
#define GU_WEIGHT_SHIFT(n)      ((n)<<9)
#define GU_WEIGHT_8BIT          GU_WEIGHT_SHIFT(1)
#define GU_WEIGHT_16BIT         GU_WEIGHT_SHIFT(2)
#define GU_WEIGHT_32BITF        GU_WEIGHT_SHIFT(3)
#define GU_WEIGHT_BITS          GU_WEIGHT_SHIFT(3)
 
#define GU_INDEX_SHIFT(n)       ((n)<<11)
#define GU_INDEX_8BIT           GU_INDEX_SHIFT(1)
#define GU_INDEX_16BIT          GU_INDEX_SHIFT(2)
#define GU_INDEX_BITS           GU_INDEX_SHIFT(3)
 
#define GU_WEIGHTS(n)           ((((n)-1)&7)<<14)
#define GU_WEIGHTS_BITS         GU_WEIGHTS(8)
#define GU_VERTICES(n)          ((((n)-1)&7)<<18)
#define GU_VERTICES_BITS        GU_VERTICES(8)
 
#define GU_TRANSFORM_SHIFT(n)   ((n)<<23)
#define GU_TRANSFORM_3D         GU_TRANSFORM_SHIFT(0)
#define GU_TRANSFORM_2D         GU_TRANSFORM_SHIFT(1)
#define GU_TRANSFORM_BITS       GU_TRANSFORM_SHIFT(1)
/* Vertex Declarations End */
 
/* Pixel Formats */
#define GU_PSM_5650             (0) /* Display, Texture, Palette */
#define GU_PSM_5551             (1) /* Display, Texture, Palette */
#define GU_PSM_4444             (2) /* Display, Texture, Palette */
#define GU_PSM_8888             (3) /* Display, Texture, Palette */
#define GU_PSM_T4               (4) /* Texture */
#define GU_PSM_T8               (5) /* Texture */
#define GU_PSM_T16              (6) /* Texture */
#define GU_PSM_T32              (7) /* Texture */
#define GU_PSM_DXT1             (8) /* Texture */
#define GU_PSM_DXT3             (9) /* Texture */
#define GU_PSM_DXT5             (10) /* Texture */
 
/* Spline Mode */
#define GU_FILL_FILL    (0)
#define GU_OPEN_FILL    (1)
#define GU_FILL_OPEN    (2)
#define GU_OPEN_OPEN    (3)
 
/* Shading Model */
#define GU_FLAT                 (0)
#define GU_SMOOTH               (1)
 
/* Logical operation */
#define GU_CLEAR                (0)
#define GU_AND                  (1)
#define GU_AND_REVERSE          (2)
#define GU_COPY                 (3)
#define GU_AND_INVERTED         (4)
#define GU_NOOP                 (5)
#define GU_XOR                  (6)
#define GU_OR                   (7)
#define GU_NOR                  (8)
#define GU_EQUIV                (9)
#define GU_INVERTED             (10)
#define GU_OR_REVERSE           (11)
#define GU_COPY_INVERTED        (12)
#define GU_OR_INVERTED          (13)
#define GU_NAND                 (14)
#define GU_SET                  (15)
 
/* Texture Filter */
#define GU_NEAREST              (0)
#define GU_LINEAR               (1)
#define GU_NEAREST_MIPMAP_NEAREST (4)
#define GU_LINEAR_MIPMAP_NEAREST (5)
#define GU_NEAREST_MIPMAP_LINEAR (6)
#define GU_LINEAR_MIPMAP_LINEAR (7)
 
/* Texture Map Mode */
#define GU_TEXTURE_COORDS       (0)
#define GU_TEXTURE_MATRIX       (1)
#define GU_ENVIRONMENT_MAP      (2)
 
/* Texture Level Mode */
#define GU_TEXTURE_AUTO         (0)
#define GU_TEXTURE_CONST        (1)
#define GU_TEXTURE_SLOPE        (2)
 
/* Texture Projection Map Mode */
#define GU_POSITION             (0)
#define GU_UV                   (1)
#define GU_NORMALIZED_NORMAL    (2)
#define GU_NORMAL               (3)
 
/* Wrap Mode */
#define GU_REPEAT               (0)
#define GU_CLAMP                (1)
 
/* Front Face Direction */
#define GU_CW                   (0)
#define GU_CCW                  (1)
 
/* Test Function */
#define GU_NEVER                (0)
#define GU_ALWAYS               (1)
#define GU_EQUAL                (2)
#define GU_NOTEQUAL             (3)
#define GU_LESS                 (4)
#define GU_LEQUAL               (5)
#define GU_GREATER              (6)
#define GU_GEQUAL               (7)
 
/* Clear Buffer Mask */
#define GU_COLOR_BUFFER_BIT     (1)
#define GU_STENCIL_BUFFER_BIT   (2)
#define GU_DEPTH_BUFFER_BIT     (4)
#define GU_FAST_CLEAR_BIT       (16)
 
/* Texture Effect */
#define GU_TFX_MODULATE         (0)
#define GU_TFX_DECAL            (1)
#define GU_TFX_BLEND            (2)
#define GU_TFX_REPLACE          (3)
#define GU_TFX_ADD              (4)
 
/* Texture Color Component */
#define GU_TCC_RGB              (0)
#define GU_TCC_RGBA             (1)
 
/* Blending Op */
#define GU_ADD                  (0)
#define GU_SUBTRACT             (1)
#define GU_REVERSE_SUBTRACT     (2)
#define GU_MIN                  (3)
#define GU_MAX                  (4)
#define GU_ABS                  (5)
 
/* Blending Factor */
#define GU_SRC_COLOR            (0)
#define GU_ONE_MINUS_SRC_COLOR  (1)
#define GU_SRC_ALPHA            (2)
#define GU_ONE_MINUS_SRC_ALPHA  (3)
#define GU_DST_COLOR            (0)
#define GU_ONE_MINUS_DST_COLOR  (1)
#define GU_DST_ALPHA            (4)
#define GU_ONE_MINUS_DST_ALPHA  (5)
#define GU_FIX                  (10)
 
/* Stencil Operations */
#define GU_KEEP                 (0)
#define GU_ZERO                 (1)
#define GU_REPLACE              (2)
#define GU_INVERT               (3)
#define GU_INCR                 (4)
#define GU_DECR                 (5)
 
/* Light Components */
#define GU_AMBIENT              (1)
#define GU_DIFFUSE              (2)
#define GU_SPECULAR             (4)
#define GU_AMBIENT_AND_DIFFUSE  (GU_AMBIENT|GU_DIFFUSE)
#define GU_DIFFUSE_AND_SPECULAR (GU_DIFFUSE|GU_SPECULAR)
#define GU_UNKNOWN_LIGHT_COMPONENT (8)
 
/* Light modes */
#define GU_SINGLE_COLOR         (0)
#define GU_SEPARATE_SPECULAR_COLOR (1)
 
/* Light Type */
#define GU_DIRECTIONAL          (0)
#define GU_POINTLIGHT           (1)
#define GU_SPOTLIGHT            (2)
 
/* Contexts */
#define GU_DIRECT               (0)
#define GU_CALL                 (1)
#define GU_SEND                 (2)
 
/* List Queue */
#define GU_TAIL                 (0)
#define GU_HEAD                 (1)
 
/* Sync behavior (mode) */
#define GU_SYNC_FINISH  (0)
#define GU_SYNC_SIGNAL  (1)
#define GU_SYNC_DONE    (2)
#define GU_SYNC_LIST    (3)
#define GU_SYNC_SEND    (4)
 
/* behavior (what) */
#define GU_SYNC_WAIT    (0)
#define GU_SYNC_NOWAIT  (1)
 
/* Sync behavior (what) [see pspge.h] */
#define GU_SYNC_WHAT_DONE (0)
#define GU_SYNC_WHAT_QUEUED (1)
#define GU_SYNC_WHAT_DRAW (2)
#define GU_SYNC_WHAT_STALL (3)
#define GU_SYNC_WHAT_CANCEL (4)
 
/* Signals */
#define GU_CALLBACK_SIGNAL      (1)
#define GU_CALLBACK_FINISH      (4)
 
/* Signal behavior */
#define GU_BEHAVIOR_SUSPEND (1)
#define GU_BEHAVIOR_CONTINUE (2)
 
/* Color Macros, maps 8 bit unsigned channels into one 32-bit value */
#define GU_ABGR(a,b,g,r)        (((a) << 24)|((b) << 16)|((g) << 8)|(r))
#define GU_ARGB(a,r,g,b)        GU_ABGR((a),(b),(g),(r))
#define GU_RGBA(r,g,b,a)        GU_ARGB((a),(r),(g),(b))
 
/* Color Macro, maps floating point channels (0..1) into one 32-bit value */
#define GU_COLOR(r,g,b,a)       GU_RGBA((u32)((r) * 255.0f),(u32)((g) * 255.0f),(u32)((b) * 255.0f),(u32)((a) * 255.0f))
 
typedef void (*GuSwapBuffersCallback)(void** display,void** render);
 
void sceGuDepthBuffer(void* zbp, int zbw);
 
void sceGuDispBuffer(int width, int height, void* dispbp, int dispbw);
 
void sceGuDrawBuffer(int psm, void* fbp, int fbw);
 
void sceGuDrawBufferList(int psm, void* fbp, int fbw);
 
int sceGuDisplay(int state);
 
void sceGuDepthFunc(int function);
 
void sceGuDepthMask(int mask);
 
void sceGuDepthOffset(unsigned int offset);
 
void sceGuDepthRange(int near, int far);
 
void sceGuFog(float near, float far, unsigned int color);
 
void sceGuInit(void);
 
void sceGuTerm(void);
 
void sceGuBreak(int a0);
void sceGuContinue(void);
 
void* sceGuSetCallback(int signal, void (*callback)(int));
 
void sceGuSignal(int signal, int behavior);
 
void sceGuSendCommandf(int cmd, float argument);
 
void sceGuSendCommandi(int cmd, int argument);
 
void* sceGuGetMemory(int size);
 
void sceGuStart(int cid, void* list);
 
int sceGuFinish(void);
 
int sceGuFinishId(unsigned int id);
 
void sceGuCallList(const void* list);
 
void sceGuCallMode(int mode);
 
int sceGuCheckList(void);
 
int sceGuSendList(int mode, const void* list, PspGeContext* context);
 
void* sceGuSwapBuffers(void);
 
int sceGuSync(int mode, int what);
 
void sceGuDrawArray(int prim, int vtype, int count, const void* indices, const void* vertices);
 
void sceGuBeginObject(int vtype, int count, const void* indices, const void* vertices);
 
void sceGuEndObject(void);
 
void sceGuSetStatus(int state, int status);
 
int sceGuGetStatus(int state);
 
void sceGuSetAllStatus(int status);
 
int sceGuGetAllStatus(void);
 
void sceGuEnable(int state);
 
void sceGuDisable(int state);
 
void sceGuLight(int light, int type, int components, const ScePspFVector3* position);
 
void sceGuLightAtt(int light, float atten0, float atten1, float atten2);
 
void sceGuLightColor(int light, int component, unsigned int color);
 
void sceGuLightMode(int mode);
 
void sceGuLightSpot(int light, const ScePspFVector3* direction, float exponent, float cutoff);
 
void sceGuClear(int flags);
 
void sceGuClearColor(unsigned int color);
 
void sceGuClearDepth(unsigned int depth);
 
void sceGuClearStencil(unsigned int stencil);
 
void sceGuPixelMask(unsigned int mask);
 
void sceGuColor(unsigned int color);
 
void sceGuColorFunc(int func, unsigned int color, unsigned int mask);
 
void sceGuColorMaterial(int components);
 
void sceGuAlphaFunc(int func, int value, int mask);
 
void sceGuAmbient(unsigned int color);
void sceGuAmbientColor(unsigned int color);
 
void sceGuBlendFunc(int op, int src, int dest, unsigned int srcfix, unsigned int destfix);
 
void sceGuMaterial(int mode, int color);
 
void sceGuModelColor(unsigned int emissive, unsigned int ambient, unsigned int diffuse, unsigned int specular);
 
void sceGuStencilFunc(int func, int ref, int mask);
 
void sceGuStencilOp(int fail, int zfail, int zpass);
 
void sceGuSpecular(float power);
 
void sceGuFrontFace(int order);
 
void sceGuLogicalOp(int op);
 
void sceGuSetDither(const ScePspIMatrix4* matrix);
 
void sceGuShadeModel(int mode);
 
void sceGuCopyImage(int psm, int sx, int sy, int width, int height, int srcw, void* src, int dx, int dy, int destw, void* dest);
 
void sceGuTexEnvColor(unsigned int color);
 
void sceGuTexFilter(int min, int mag);
 
void sceGuTexFlush(void);
 
void sceGuTexFunc(int tfx, int tcc);
 
void sceGuTexImage(int mipmap, int width, int height, int tbw, const void* tbp);
 
void sceGuTexLevelMode(unsigned int mode, float bias);
 
void sceGuTexMapMode(int mode, unsigned int a1, unsigned int a2);
 
void sceGuTexMode(int tpsm, int maxmips, int a2, int swizzle);
 
void sceGuTexOffset(float u, float v);
 
void sceGuTexProjMapMode(int mode);
 
void sceGuTexScale(float u, float v);
void sceGuTexSlope(float slope);
 
void sceGuTexSync();
 
void sceGuTexWrap(int u, int v);
 
void sceGuClutLoad(int num_blocks, const void* cbp);
 
void sceGuClutMode(unsigned int cpsm, unsigned int shift, unsigned int mask, unsigned int a3);
 
void sceGuOffset(unsigned int x, unsigned int y);
 
void sceGuScissor(int x, int y, int w, int h);
 
void sceGuViewport(int cx, int cy, int width, int height);
 
void sceGuDrawBezier(int vtype, int ucount, int vcount, const void* indices, const void* vertices);
 
void sceGuPatchDivide(unsigned int ulevel, unsigned int vlevel);
 
void sceGuPatchFrontFace(unsigned int a0);
 
void sceGuPatchPrim(int prim);
 
void sceGuDrawSpline(int vtype, int ucount, int vcount, int uedge, int vedge, const void* indices, const void* vertices);
 
void sceGuSetMatrix(int type, const ScePspFMatrix4* matrix);
 
void sceGuBoneMatrix(unsigned int index, const ScePspFMatrix4* matrix);
 
void sceGuMorphWeight(int index, float weight);
 
void sceGuDrawArrayN(int primitive_type, int vertex_type, int count, int a3, const void* indices, const void* vertices);
 
void guSwapBuffersBehaviour(int behaviour);
 
void guSwapBuffersCallback(GuSwapBuffersCallback callback);
 
void* guGetStaticVramBuffer(unsigned int width, unsigned int height, unsigned int psm);
 
void* guGetStaticVramTexture(unsigned int width, unsigned int height, unsigned int psm);
 
int guGetDisplayState();
 
#if defined(__cplusplus)
};
#endif
 
#endif