mirror of
https://github.com/pspdev/pspsdk.git
synced 2025-10-03 08:41:34 +00:00
252 lines
6.7 KiB
C
252 lines
6.7 KiB
C
/*
|
|
* 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 __pspgum_h__
|
|
#define __pspgum_h__
|
|
|
|
#include <psptypes.h>
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
// stack functions
|
|
|
|
void sceGumDrawArray(int prim, int vtype, int count, const void* indices, const void* vertices);
|
|
void sceGumDrawArrayN(int prim, int vtype, int count, int a3, const void* indices, const void* vertices);
|
|
void sceGumDrawBezier(int vtype, int ucount, int vcount, const void* indices, const void* vertices);
|
|
void sceGumDrawSpline(int vtype, int ucount, int vcount, int uedge, int vedge, const void* indices, const void* vertices);
|
|
|
|
/**
|
|
* Load identity matrix
|
|
*
|
|
* [1 0 0 0]
|
|
* [0 1 0 0]
|
|
* [0 0 1 0]
|
|
* [0 0 0 1]
|
|
**/
|
|
void sceGumLoadIdentity(void);
|
|
|
|
/**
|
|
* Load matrix
|
|
*
|
|
* @param m - Matrix to load into stack
|
|
**/
|
|
void sceGumLoadMatrix(const ScePspFMatrix4* m);
|
|
|
|
void sceGumLookAt(ScePspFVector3* eye, ScePspFVector3* center, ScePspFVector3* up);
|
|
|
|
/**
|
|
* Select which matrix stack to operate on
|
|
*
|
|
* Available matrix modes are:
|
|
* - GU_PROJECTION
|
|
* - GU_VIEW
|
|
* - GU_MODEL
|
|
* - GU_TEXTURE
|
|
*
|
|
* @param mode - Matrix mode to use
|
|
**/
|
|
void sceGumMatrixMode(int mode);
|
|
|
|
/**
|
|
* Multiply current matrix with input
|
|
*
|
|
* @param m - Matrix to multiply stack with
|
|
**/
|
|
void sceGumMultMatrix(const ScePspFMatrix4* m);
|
|
|
|
/**
|
|
* Apply ortho projection matrix
|
|
*
|
|
* @note The matrix loses its orthonogal status after executing this function.
|
|
**/
|
|
void sceGumOrtho(float left, float right, float bottom, float top, float near, float far);
|
|
|
|
/**
|
|
* Apply perspective projection matrix
|
|
*
|
|
* @note The matrix loses its orthonogal status after executing this function.
|
|
**/
|
|
void sceGumPerspective(float fovy, float aspect, float near, float far);
|
|
|
|
/**
|
|
* Pop matrix from stack
|
|
**/
|
|
void sceGumPopMatrix(void);
|
|
|
|
/**
|
|
* Push current matrix onto stack
|
|
**/
|
|
void sceGumPushMatrix(void);
|
|
|
|
/**
|
|
* Rotate around the X axis
|
|
*
|
|
* @param angle - Angle in radians
|
|
**/
|
|
void sceGumRotateX(float angle);
|
|
|
|
/**
|
|
* Rotate around the Y axis
|
|
*
|
|
* @param angle - Angle in radians
|
|
**/
|
|
void sceGumRotateY(float angle);
|
|
|
|
/**
|
|
* Rotate around the Z axis
|
|
*
|
|
* @param angle - Angle in radians
|
|
**/
|
|
void sceGumRotateZ(float angle);
|
|
|
|
/**
|
|
* Rotate around all 3 axis in order X, Y, Z
|
|
*
|
|
* @param v - Pointer to vector containing angles
|
|
**/
|
|
void sceGumRotateXYZ(const ScePspFVector3* v);
|
|
|
|
/**
|
|
* Rotate around all 3 axis in order Z, Y, X
|
|
*
|
|
* @param v - Pointer to vector containing angles
|
|
**/
|
|
void sceGumRotateZYX(const ScePspFVector3* v);
|
|
|
|
/**
|
|
* Apply rotation represented by quaternion q
|
|
*
|
|
* @param q - Pointer to quaternion
|
|
**/
|
|
void sceGumRotate(const ScePspFQuaternion* q);
|
|
|
|
/**
|
|
* Scale matrix
|
|
*
|
|
* @note The matrix loses its orthonogal status after executing this function.
|
|
**/
|
|
void sceGumScale(const ScePspFVector3* v);
|
|
|
|
/**
|
|
* Store current matrix in the stack
|
|
*
|
|
* @param m - Matrix to write result to
|
|
**/
|
|
void sceGumStoreMatrix(ScePspFMatrix4* m);
|
|
|
|
/**
|
|
* Translate coordinate system
|
|
*
|
|
* @param v - Translation coordinates
|
|
**/
|
|
void sceGumTranslate(const ScePspFVector3* v);
|
|
|
|
/**
|
|
* Explicitly flush dirty matrices to the hardware
|
|
**/
|
|
void sceGumUpdateMatrix(void);
|
|
|
|
/**
|
|
* Invert 4x4 matrix
|
|
*
|
|
* This invert algorithm can operate on matrices that are not orthongal (See sceGumFastInverse())
|
|
**/
|
|
void sceGumFullInverse();
|
|
|
|
/**
|
|
* Invert orthonogal 4x4 matrix
|
|
*
|
|
* Note that the matrix in the stack has to be orthonogal (that is, all rotational axises must be unit length & orthonogal against the others),
|
|
* otherwise the result of the function cannot be depended on. If you need to invert a matrix that is not orthonogal, use sceGumFullInverse().
|
|
**/
|
|
void sceGumFastInverse();
|
|
|
|
/**
|
|
* Stack-aware version of sceGuBeginObject() (look in pspgu.h for description)
|
|
*
|
|
* @note NOT YET IMPLEMENTED
|
|
*
|
|
* @param vtype - Vertex type to process
|
|
* @param count - Number of vertices to test
|
|
* @param indices - Optional index-list
|
|
* @param vertices - Vertex-list
|
|
**/
|
|
void sceGumBeginObject(int vtype, int count, const void* indices, const void* vertices);
|
|
|
|
/**
|
|
* Stack-aware version of sceGuEndObject()
|
|
*
|
|
* @note NOT YET IMPLEMENTED
|
|
**/
|
|
void sceGumEndObject();
|
|
|
|
// unimplemented functions
|
|
|
|
//sceGumLoadContext
|
|
//sceGumSetCurMatrix
|
|
//sceGumSetMatrixStack
|
|
//sceGumStoreContext
|
|
|
|
// standalone functions
|
|
|
|
void gumInit(void);
|
|
|
|
/**
|
|
* Load matrix with identity
|
|
*
|
|
* @param m - Matrix to load with identity
|
|
**/
|
|
void gumLoadIdentity(ScePspFMatrix4* m);
|
|
|
|
void gumLoadQuaternion(ScePspFMatrix4* r, const ScePspFQuaternion* q);
|
|
void gumLoadMatrix(ScePspFMatrix4* r, const ScePspFMatrix4* a);
|
|
void gumLookAt(ScePspFMatrix4* m, ScePspFVector3* eye, ScePspFVector3* center, ScePspFVector3* up);
|
|
void gumMultMatrix(ScePspFMatrix4* result, const ScePspFMatrix4* a, const ScePspFMatrix4* b);
|
|
void gumOrtho(ScePspFMatrix4* m, float left, float right, float bottom, float top, float near, float far);
|
|
void gumPerspective(ScePspFMatrix4* m, float fovy, float aspect, float near, float far);
|
|
void gumRotateX(ScePspFMatrix4* m, float angle);
|
|
void gumRotateXYZ(ScePspFMatrix4* m, const ScePspFVector3* v);
|
|
void gumRotateY(ScePspFMatrix4* m, float angle);
|
|
void gumRotateZ(ScePspFMatrix4* m, float angle);
|
|
void gumRotateZYX(ScePspFMatrix4* m, const ScePspFVector3* v);
|
|
void gumRotateMatrix(ScePspFMatrix4* m, const ScePspFQuaternion* q);
|
|
void gumScale(ScePspFMatrix4* m, const ScePspFVector3* v);
|
|
void gumTranslate(ScePspFMatrix4* m, const ScePspFVector3* v);
|
|
void gumFullInverse(ScePspFMatrix4* r, const ScePspFMatrix4* a);
|
|
|
|
/**
|
|
* Invert orthonogal 4x4 matrix
|
|
*
|
|
* Note that the matrix in the stack has to be orthonogal (that is, all rotational axises must be unit length & orthonogal against the others),
|
|
* otherwise the result of the function cannot be depended on. If you need to invert a matrix that is not orthonogal, use gumFullInverse().
|
|
*
|
|
* @param r - Matrix receiving result
|
|
* @param a - Orthonogal matrix that is to be inverted
|
|
**/
|
|
void gumFastInverse(ScePspFMatrix4* r, const ScePspFMatrix4* a);
|
|
|
|
// vector functions
|
|
|
|
void gumCrossProduct(ScePspFVector3* r, const ScePspFVector3* a, const ScePspFVector3* b);
|
|
float gumDotProduct(const ScePspFVector3* a, const ScePspFVector3* b);
|
|
void gumNormalize(ScePspFVector3* v);
|
|
void gumRotateVector(ScePspFVector3* r, const ScePspFQuaternion* q, const ScePspFVector3* v);
|
|
|
|
// quaternion functions
|
|
void gumNormalizeQuaternion(ScePspFQuaternion* q);
|
|
void gumLoadAxisAngle(ScePspFQuaternion* r, ScePspFVector3* axis, float t);
|
|
void gumMultQuaternion(ScePspFQuaternion* result, const ScePspFQuaternion* a, const ScePspFQuaternion* b);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|