#if !defined( Ps2BaseH )
#    define   Ps2BaseH

#include "math.h"
#include <libvu0.h>
#include "ps2gs.h"
#include "ps2vpufile.h"
#include "ps2dma.h"
#include "ps2vpu.h"


class Ps2Base {
 protected:
  char *g_program_name;

  int g_inter;
  int g_out_mode;
  int g_ff_mode;
  int g_resolution;
  int g_refresh_rate;
  int g_psm;
  int g_zpsm;
  int g_zbits;

  int g_fd_gs;
  ps2_vpu *g_vpu0, *g_vpu1;

  void usage(const char *msg1, const char *msg2, const char *MoreUsage );

  ps2_gs_gparam *gp;
 public:
  Ps2Base();
  void parseCommandLine(int argc, char *argv[], bool (*ParseExtraOption)( const char *option )=NULL, const char *Usage="" );
  void gsEnableVcSwitch();
  int release();
  int acquire();
  void gsStartDisplay();

  virtual void doExtraAcquire();
  virtual void doExtraRelease();

  bool hasZBuffer() { return g_zbits != 0; }
  int  zBufferEnd() { return (1<<g_zbits)-1; }

  void gsReset() {
    ps2_gs_reset(0, g_inter, g_out_mode, g_ff_mode, g_resolution, g_refresh_rate);
  }

  void dmaSendToVpu1( VPUFILE *vfd, ps2_dmatag *dma_start) {
    ps2_dma_send( ps2_vpu_fd(g_vpu1), vfd, dma_start);
  }

  void dmaStartForVpu1( VPUFILE *vfd, ps2_dmatag *dma_start) {
    ps2_dma_start(ps2_vpu_fd(g_vpu1), vfd, dma_start);
  }

};

class Ps2Simple : public Ps2Base {
 protected:
  ps2_gs_dbuff g_db;
  int next2k;
  int odev;
  u_int frame;
	
  int getNext2k() { 
    return next2k; 
  }

  void clearBackBuffer( int frame ) {
    ps2_gs_put_drawenv( frame ? &g_db.giftag0 : &g_db.giftag1 );
    ps2_gs_finish g_finish;
    ps2_gs_set_finish(&g_finish);
    ps2_gs_wait_finish(&g_finish);
  }

  void swapBuffers( int frame, int odev ) {
    ps2_gs_set_half_offset((frame & 1) ? &g_db.draw1 : &g_db.draw0, odev);
    ps2_gs_swap_dbuff(&g_db, frame);
  }

  void gsSetDoubleBuffer() {
    ps2_gs_gparam *gp = ps2_gs_get_gparam();
    next2k = ps2_gs_set_dbuff(&g_db, g_psm, gp->width, gp->height,
			      (g_zbits == 0) ? 0 : PS2_GS_ZGREATER,
			      g_zpsm, 1);
  }

 public:
  Ps2Simple() {
    frame = 1;
  }

  void init(int argc, char *argv[], bool (*ParseExtraOption)( const char *option )=NULL, const char *Usage="" ) {
    parseCommandLine( argc, argv, ParseExtraOption, Usage );
    ps2_gs_vc_graphicsmode();
    gsReset();
    gsSetDoubleBuffer();
    setRgbAq();
  }

  void start() {
    doExtraAcquire();
    clearBackBuffer( frame & 1 );
    odev = !ps2_gs_sync_v(0);
    gsStartDisplay();
    gsEnableVcSwitch();

    ps2_gs_vc_lock();
    swapBuffers( frame, odev );
  }

  void flip() {
    frame++;
    odev = !ps2_gs_sync_v(0);
    ps2_gs_vc_unlock();

    ps2_gs_vc_lock();
    swapBuffers( frame, odev );
  }
  u_int getFrame() { return frame; }

  void setRgbAq( int r=0x10, int g=0x10, int b=0x10 ) {
    *(__u64 *)&g_db.clear0.rgbaq = PS2_GS_SETREG_RGBAQ( r, g, b, 0x80, 0x3f800000);
    *(__u64 *)&g_db.clear1.rgbaq = PS2_GS_SETREG_RGBAQ( r, g, b, 0x80, 0x3f800000);
  }

};

class TexEnv {
public:
  ps2_giftag giftag;

  ps2_gsreg_test gs_test;
  ps2_gsreg_addr gs_test1addr;

  ps2_gs_alphaenv gs_alpha;
  ps2_gs_texenv gs_tex;

  void draw( ps2_image *image, int width, int height, __u64 alpha );
  void draw2( ps2_image *image, int width, int height, __u64 alpha, __u64 test );
};

inline void vset( ps2_vu0_fvector vec, float x, float y, float z, float w ) {
  vec[0] = x;
  vec[1] = y;
  vec[2] = z;
  vec[3] = z;
}

inline float length( ps2_vu0_fvector vec ) {
  return sqrtf(vec[0] * vec[0] + 
	       vec[1] * vec[1] +
	       vec[2] * vec[2]);	
}


#endif