vlib.h

/*

  Velocity  v1.5
  Copyright 2006, 2007 Gabriel Anderson

  This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

//---------------------------------------------------------------------------------//
// Includes                                                                        //
//---------------------------------------------------------------------------------//

#include <pspkernel.h>
#include <pspdisplay.h>
#include <pspdebug.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
#include <pspctrl.h>
#include <pspgu.h>
#include <psprtc.h>
#include <psppower.h>
#include <malloc.h>
#include <png.h>
#include <pspaudio.h>
#include <pspatrac3.h>
#include <pspvfpu.h>
#include <jpeglib.h>

#if defined(__cplusplus)
extern "C" {
#endif

//---------------------------------------------------------------------------------//
// Data                                                                            //
//---------------------------------------------------------------------------------//

extern SceCtrlData ctrl;

// Structs for Verts!

typedef struct {
  u32 color;
  short x, y, z;
}
CP_Vertex_2D; // Color, Position, 2D

typedef struct {
  short u, v;
  short x, y, z;
}
TP_Vertex_2D; // Texture, Position, 2D

typedef struct {
  u32 color;
  float x, y, z;
}
CP_Vertex_3D; // Color, Position, 3D

typedef struct {
  float nx, ny, nz;
  u32 color;
  float x, y, z;
}
NCP_Vertex_3D; // Normals, Color, Position, 3D

typedef struct {
  float u, v;
  float x, y, z;
}
TP_Vertex_3D; // Texture, Position, 3D

typedef struct {
  float nx, ny, nz;
  float u, v;
  float x, y, z;
}
NTP_Vertex_3D; // Normals, Texture, Position, 3D

// Holds an image
typedef struct {
  // Public
  float x, y, width, height;
  float startX, startY, endX, endY;
  float angle, centerX, centerY;

  // Private
  // DO NOT CHANGE EVER
  int initWidth, initHeight;
  int realWidth, realHeight; // Width and height of the texture (both pow2)
  int totalSize; // The total size of the image (bytes)
  short location;
  u32* data; // image data
}
Image;

// Holds a model
typedef struct {
  float posX, posY, posZ;
  float sizeX, sizeY, sizeZ;
  float rotX, rotY, rotZ;
  int vertTotal;
  u32 __attribute__ ( ( aligned ( 16 ) ) ) *displayList;
  TP_Vertex_3D *verts;
  Image *img;
}
Model;

// Holds audio
typedef struct {}
Audio;

// Holds font
typedef struct {}
Font;

typedef struct {
  union {
    struct {
int select:
1, start:
      3;
int up:
1, right:
1, down:
1, left:
      1;
int L:
1, R:
      1;
int triangle:
3, circle:
1, cross:
1, square:
      1;
int home:
1, hold:
1, wlanOn:
1, remote:
1, volUp:
      1;
int volDown:
1, screen:
1, note:
1, disc:
1, ms:
      1;
    };
    int value; // what buttons are on
  } pressed; // For checking if a button is pressed

  union {
    struct {
int select:
1, start:
      3;
int up:
1, right:
1, down:
1, left:
      1;
int L:
1, R:
      1;
int triangle:
3, circle:
1, cross:
1, square:
      1;
int home:
1, hold:
1, wlanOn:
1, remote:
1, volUp:
      1;
int volDown:
1, screen:
1, note:
1, disc:
1, ms:
      1;
    };
    int value; // what buttons are on
  } held; // For checking if a button is held

  union {
    struct {
int select:
1, start:
      3;
int up:
1, right:
1, down:
1, left:
      1;
int L:
1, R:
      1;
int triangle:
3, circle:
1, cross:
1, square:
      1;
int home:
1, hold:
1, wlanOn:
1, remote:
1, volUp:
      1;
int volDown:
1, screen:
1, note:
1, disc:
1, ms:
      1;
    };
    int value; // what buttons are on
  } released; // For checking if a button is released

  int repeatMask; // what buttons are going to be repeated
  int repeatCounter; // A counter for the button repeats when held
  int repeatInit; // The amount of time between the first repeat when held (this only happens once, unless the button is released and held again(physically))
  int repeatInterval; // The amount of time between repeats after the first repeat (this is continous, and is used until the button is released(physically))

  short analogX; // The current of the analog nub horizontally. Can be anywhere from 128 to -128.
  short analogY; // The current of the analog nub horizontally. Can be anywhere from 128 to -128.
}
CONTROLLER;

extern CONTROLLER *button;

extern u32* fbp0;
extern u32* fbp1;
extern u16* zbp;
extern unsigned int __attribute__ ( ( aligned ( 16 ) ) ) DList[262144];

extern int curFps, lastFps;  // for calculating the frames per second

extern u32 tickResolution;
extern u64 fpsTickNow;
extern u64 fpsTickLast;

extern CONTROLLER buttonInit;
extern SceCtrlData ctrl;

extern float deltaTime; // The current delta time, used for time based movement

extern const int PRINT_BUFF;

extern const int IN_RAM;
extern const int IN_VRAM;

extern const int OFF;
extern const int ON;

extern const int POINTS;
extern const int LINES;
extern const int LINE_STRIP;
extern const int TRIANGLES;
extern const int TRIANGLE_STRIP;
extern const int TRIANGLE_FAN;
extern const int SPRITES;

extern const float PI;
extern const float PI_180;
extern short drawingStarted;

extern ScePspFMatrix4 m_ortho, m_projection, m_projection_view, m_projection_model, m_ortho_view, m_ortho_model;

#define RGB(r,g,b)  ((r) | ((g)<<8) | ((b)<<16) | (0xff<<24))
#define RGBA(r,g,b,a) ((r) | ((g)<<8) | ((b)<<16) | ((a)<<24))

#define IsSet(val,flag) (val&flag)==flag

#define MASK_NONE 0x0
#define MASK_SELECT 0x000001
#define MASK_START 0x000008
#define MASK_UP 0x000010
#define MASK_RIGHT 0x000020
#define MASK_DOWN 0x000040
#define MASK_LEFT 0x000080
#define MASK_LTRIG 0x000100
#define MASK_RTRIG 0x000200
#define MASK_TRIANGLE 0x001000
#define MASK_CIRCLE 0x002000
#define MASK_CROSS 0x004000
#define MASK_SQUARE 0x008000
#define MASK_HOME 0x010000
#define MASK_HOLD 0x020000
#define MASK_NOTE 0x800000
#define MASK_SCREEN 0x400000
#define MASK_VOLUP 0x100000
#define MASK_VOLDOWN 0x200000
#define MASK_WLANON 0x040000
#define MASK_REMOTE 0x080000
#define MASK_DISC 0x1000000
#define MASK_MS 0x2000000
#define MASK_ALL MASK_SELECT|MASK_START|MASK_UP|MASK_RIGHT|MASK_DOWN|MASK_LEFT|MASK_LTRIG|MASK_RTRIG|MASK_TRIANGLE|MASK_CIRCLE|MASK_CROSS|MASK_SQUARE

//---------------------------------------------------------------------------------//
// Vram                                                                            //
//---------------------------------------------------------------------------------//

void* vrelptr ( void *ptr );  // make a pointer relative to memory base address (ATTENTION: A NULL rel ptr is not illegal/invalid!)
void* vabsptr ( void *ptr );  // make a pointer absolute (default return type of valloc)

void* valloc ( size_t size );
void vfree ( void* ptr );
size_t vmemavail();
size_t vlargestblock();

#ifdef _DEBUG
// Debug printf (to stdout) a trace of the current Memblocks
void __memwalk();
#endif


//---------------------------------------------------------------------------------//
// General                                                                         //
//---------------------------------------------------------------------------------//


void start_vLib ( void );

void stop_vLib ( void );

void start_drawing ( void );

void end_drawing ( void );

void sync_frame ( void );

void flip_screen ( void );

void wait_to_vsync ( void );

void clear_screen ( void );

void set_clear_color ( u32 color );

void update_delta_time ( void );

//---------------------------------------------------------------------------------//
// Shape                                                                           //
//---------------------------------------------------------------------------------//


void draw_pixel ( float x, float y, u32 color );

void draw_line ( float startX, float startY, float endX, float endY, u32 color );

void draw_grad_line ( float startX, float startY, float endX, float endY, u32 color1, u32 color2 );

void draw_rect ( float x, float y, float width, float height, u32 color );

void draw_grad_rect ( float x, float y, float width, float height, u32 color1, u32 color2, u32 color3, u32 color4 );

void draw_fill_rect ( float x, float y, float width, float height, u32 color );

void draw_fill_grad_rect ( float x, float y, float width, float height, u32 color1, u32 color2, u32 color3, u32 color4 );

//---------------------------------------------------------------------------------//
// Image                                                                           //
//---------------------------------------------------------------------------------//


Image *load_image ( const char *filename, int location ); // Determines the type of image and loads it

void unload_image ( Image *img );

void draw_image ( Image *img );

void set_linear_filter ( short state );

//void flip ( Image *img );
//void setImageAlpha ( Image *img, u8 alpha );

//---------------------------------------------------------------------------------//
// Model                                                                           //
//---------------------------------------------------------------------------------//


Model *load_model ( const char *filename );
void unload_model ( Model *mdl );

void draw_model ( Model *mdl, Image *img );

void set_fog ( float near, float far, unsigned int color ); // Need to add in a toggle to turn this on/off
void disable_fog ( void );

//---------------------------------------------------------------------------------//
// Camera                                                                          //
//---------------------------------------------------------------------------------//


void set_camera_3rd_person ( float posX, float posY, float posZ, float rotX, float rotY, float zoom );

//---------------------------------------------------------------------------------//
// Audio                                                                           //
//---------------------------------------------------------------------------------//


Audio *load_audio ( const char *filename );
void play_audio ( Audio *aud, int stream );

//---------------------------------------------------------------------------------//
// Font                                                                            //
//---------------------------------------------------------------------------------//


Font *load_font ( const char *filename );
void print ( Font *fnt, char *format );

//---------------------------------------------------------------------------------//
// Controller                                                                      //
//---------------------------------------------------------------------------------//


CONTROLLER *read_input ( int masked, int init, int interval );

//---------------------------------------------------------------------------------//
// VFPU                                                                         //
//---------------------------------------------------------------------------------//


// Some simple math operations
float vfpu_sinf ( float rad );
float vfpu_cosf ( float rad );
float vfpu_sqrtf ( float x );

// Matrix operations
void vfpu_identity_m ( ScePspFMatrix4 *m );
void vfpu_translate_m ( ScePspFMatrix4 *m, float x, float y, float z );
void vfpu_rotateX_m ( ScePspFMatrix4 *m, float x );
void vfpu_rotateY_m ( ScePspFMatrix4 *m, float y );
void vfpu_rotateZ_m ( ScePspFMatrix4 *m, float z );
void vfpu_rotateXYZ_m ( ScePspFMatrix4 *m, float x, float y, float z );
void vfpu_rotateZYX_m ( ScePspFMatrix4 *m, float z, float y, float x );
void vfpu_scale_m ( ScePspFMatrix4 *m, float x, float y, float z );
void vfpu_lookAt_m ( ScePspFMatrix4 *m, ScePspFVector3* eye, ScePspFVector3* center, ScePspFVector3* up );
void vfpu_perspective_m ( ScePspFMatrix4 *m, float fovy, float aspect, float near, float far );
void vfpu_ortho_m ( ScePspFMatrix4 *m, float left, float right, float bottom, float top, float near, float far );

//---------------------------------------------------------------------------------//
// Debugging                                                                       //
//---------------------------------------------------------------------------------//


// The functions are all going to be combined with some of the other functions to make an all powerful super function!
void fps ( void );
void fpsX ( const char *format, ... );
void sysmon ( void );
void sysmonX ( const char *format, ... );

// Some functions I use to benchmark functions. DO NOT USE!
void start_ticker ( void );
int end_ticker ( void );

#if defined(__cplusplus)
}
#endif

---