// gLib2D by Geecko - A simple, fast, light-weight 2D graphics library.
//
// This work is licensed under the Creative Commons BY-SA 3.0 Unported License.
// See LICENSE for more details.

#include <pspkernel.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <pspgu.h>
#include <malloc.h>
#include <string.h>

#include "glib2d.h"

#define PSP_LINE_SIZE (512)
#define PIXEL_SIZE (4)
#define FRAMEBUFFER_SIZE (PSP_LINE_SIZE*G_SCR_H*PIXEL_SIZE)
#define MALLOC_STEP 10

#define DEFAULT_SIDE       (10)
#define DEFAULT_COORD_MODE (G_UP_LEFT)
#define DEFAULT_X          (0.f)
#define DEFAULT_Y          (0.f)
#define DEFAULT_Z          (0.f)
#define DEFAULT_COLOR      (WHITE)
#define DEFAULT_ALPHA      (0xFF)

#define CURRENT_OBJ obj_list[obj_list_size]

typedef struct
{
  float x, y, z;
  int crop_x, crop_y;
  int crop_w, crop_h;
  int scale_w, scale_h;
  gColor color;
} Obj_Properties;

// * Main vars *
static unsigned int __attribute__((aligned(16))) gu_list[262144];
bool init = G_FALSE, start = G_FALSE;
// * Object vars *
Obj_Properties* obj_list = NULL;
int obj_list_size, obj_list_size_malloc; // Real & malloc'ed size
bool obj_begin = G_FALSE;
bool obj_use_z, obj_use_vert_color, obj_use_blend;
// * Coord vars *
gEnum obj_coord_mode;
float obj_x, obj_y, obj_z;
// * Crop vars *
int obj_crop_x, obj_crop_y;
int obj_crop_w, obj_crop_h;
// * Scale vars *
float obj_scale_w, obj_scale_h;
// * Color & alpha vars *
gColor obj_color;
gAlpha obj_alpha;
bool obj_colors_count, obj_alpha_count;

// * Internal functions *

void _gInit()
{
  // Init & setup GU
  sceGuInit();
  sceGuStart(GU_DIRECT, gu_list);

  sceGuDrawBuffer(GU_PSM_8888,(void*)FRAMEBUFFER_SIZE,PSP_LINE_SIZE);
  sceGuDispBuffer(G_SCR_W,G_SCR_H,(void*)0,PSP_LINE_SIZE);
  sceGuDepthBuffer((void*)(FRAMEBUFFER_SIZE*2),PSP_LINE_SIZE);
  sceGuOffset(2048-(G_SCR_W/2),2048-(G_SCR_H/2));
  sceGuViewport(2048,2048,G_SCR_W,G_SCR_H);
  sceGuDepthRange(65535,0);
  sceGuClearDepth(65535);

  sceGuScissor(0,0,G_SCR_W,G_SCR_H);
  sceGuAlphaFunc(GU_GREATER,0,0xff);
  sceGuDepthFunc(GU_LEQUAL);
  sceGuBlendFunc(GU_ADD,GU_SRC_ALPHA,GU_ONE_MINUS_SRC_ALPHA,0,0);
  sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA);
  sceGuTexFilter(GU_LINEAR,GU_LINEAR);
  sceGuFrontFace(GU_CW);
  sceGuShadeModel(GU_SMOOTH);

  sceGuEnable(GU_CULL_FACE);
  sceGuEnable(GU_CLIP_PLANES);
  sceGuEnable(GU_ALPHA_TEST);
  sceGuEnable(GU_CLIP_PLANES);
  sceGuEnable(GU_SCISSOR_TEST);

  sceGuFinish();
  sceGuSync(0,0);
  sceDisplayWaitVblankStart();
  sceGuDisplay(GU_TRUE);

  init = G_TRUE;
}


void _gStart()
{
  if (!init) _gInit();

  sceKernelDcacheWritebackAll();
  sceGuStart(GU_DIRECT,gu_list);
  start = G_TRUE;
}


void _gCoordInit()
{
  gResetCoord();
  obj_use_z = G_FALSE;
}


void _gScaleInit()
{
  gResetScale();
}


void _gColorInit()
{
  gResetColor();
  obj_colors_count = 0;
  obj_use_vert_color = G_FALSE;
}


void _gAlphaInit()
{
  gResetAlpha();
  obj_use_blend = G_FALSE;
}


void _gAdd()
{
  if (!obj_begin) return;

  if (obj_list_size >= obj_list_size_malloc)
  {
    obj_list_size_malloc += MALLOC_STEP;
    obj_list = realloc(obj_list,obj_list_size_malloc * sizeof(Obj_Properties));
  }

  CURRENT_OBJ.x = obj_x;
  CURRENT_OBJ.y = obj_y;
  CURRENT_OBJ.z = obj_z;
  CURRENT_OBJ.scale_w = obj_scale_w;
  CURRENT_OBJ.scale_h = obj_scale_h;
  CURRENT_OBJ.color = G_MODULATE(obj_color,255,obj_alpha); // Apply alpha modulation

  obj_list_size++;
}


// Vertex order: [texture uv] [color] [vertex]
void* _gSetVertex(void* v, int i, bool x, bool y)
{
  int* v_p_int = v;
  gColor* v_p_color;
  float* v_p_float = v;

  // Texture

  // Color
  v_p_color = (gColor*)v_p_int;
  if (obj_use_vert_color) *(v_p_color++) = obj_list[i].color;
  // Coord
  v_p_float = (float*)v_p_color;
  *(v_p_float++) = obj_list[i].x + (x ? obj_list[i].scale_w : 0);
  *(v_p_float++) = obj_list[i].y + (y ? obj_list[i].scale_h : 0);
  *(v_p_float++) = obj_list[i].z;

  return (void*)v_p_float;
}


// Insertion sort, because it is a fast and _stable_ sort.
void _gVertexSort()
{
  int i, j;
  Obj_Properties obj_tmp;
  for (i=1; i<obj_list_size; i++)
  {
    j = i;
    memcpy(&obj_tmp,obj_list+j,sizeof(Obj_Properties));
    while (j>0 && obj_list[j-1].z < obj_tmp.z)
    {
      memcpy(obj_list+j,obj_list+j-1,sizeof(Obj_Properties));
      j--;
    }
    memcpy(obj_list+j,&obj_tmp,sizeof(Obj_Properties));
  }
}

// * Main functions *

void gClear(gColor color, bool zclear)
{
  if (!start) _gStart();

  sceGuClearColor(color);
  sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT
             | (zclear ? GU_DEPTH_BUFFER_BIT : 0));
}


void gBegin()
{
  if (obj_begin) return;
  if (!start) _gStart();

  _gCoordInit();
  _gScaleInit();
  _gColorInit();
  _gAlphaInit();

  obj_list_size = 0;
  obj_list_size_malloc = MALLOC_STEP;
  obj_list = realloc(obj_list,obj_list_size_malloc * sizeof(Obj_Properties));

  obj_begin = G_TRUE;
}


void gEnd()
{
  if (!obj_begin || obj_list_size <= 0) return;

  // Horror : we need to sort the vertices.
  if (obj_use_z && obj_use_blend) _gVertexSort();

  int prim = GU_SPRITES,
      v_obj_nbr = 2,
      v_nbr = v_obj_nbr * obj_list_size,
      v_coord_size = 3,
      v_tex_size = 0,
      v_color_size = (obj_use_vert_color) ? 1 : 0,
      v_size = v_tex_size * sizeof(int) +
               v_color_size * sizeof(gColor) +
               v_coord_size * sizeof(float),
      v_type = GU_VERTEX_32BITF | GU_TRANSFORM_2D,
      i;

  if (obj_use_vert_color) v_type |= GU_COLOR_8888;

  void *v = sceGuGetMemory(v_nbr * v_size), *vi = v;

  for (i=0; i!=obj_list_size; i++)
  {
    vi = _gSetVertex(vi,i,0,0);
    vi = _gSetVertex(vi,i,1,1);
  }

  if (obj_use_z)          sceGuEnable(GU_DEPTH_TEST);
  else                    sceGuDisable(GU_DEPTH_TEST);
  if (obj_use_blend)      sceGuEnable(GU_BLEND);
  else                    sceGuDisable(GU_BLEND);
  if (obj_use_vert_color) sceGuColor(WHITE);
  else                    sceGuColor(obj_color);
  sceGuDisable(GU_TEXTURE_2D);

  sceGuDrawArray(prim,v_type,v_nbr,NULL,v);

  obj_begin = G_FALSE;
}


void gReset()
{
  gResetCoord();
  gResetScale();
  gResetColor();
  gResetAlpha();
}


void gFlip(bool vsync)
{
  sceGuFinish();
  sceGuSync(0,0);
  if (vsync) sceDisplayWaitVblankStart();
  sceGuSwapBuffers();
  start = G_FALSE;
}

// * Coord functions *

void gResetCoord()
{
  obj_coord_mode = DEFAULT_COORD_MODE;
  obj_x = DEFAULT_X;
  obj_y = DEFAULT_Y;
  obj_z = DEFAULT_Z;
}


void gSetCoordMode(gEnum mode)
{
  obj_coord_mode = mode;
  if (obj_coord_mode < G_UP_LEFT || obj_coord_mode > G_CENTER)
    obj_coord_mode = G_UP_LEFT;
}


void gSetCoordXY(float x, float y)
{
  obj_x = x;
  obj_y = y;
  obj_z = 0;
  _gAdd();
}


void gSetCoordXYZ(float x, float y, float z)
{
  obj_x = x;
  obj_y = y;
  obj_z = z;
  obj_use_z = G_TRUE;
  _gAdd();
}


void gSetCoordXYRelative(float x, float y)
{
  gSetCoordXY(obj_x + x,obj_y + y);
}


void gSetCoordXYZRelative(float x, float y, float z)
{
  gSetCoordXYZ(obj_x + x,obj_y + y,obj_z + z);
}

// * Scale functions *

void gResetScale()
{
  obj_scale_w = DEFAULT_SIDE;
  obj_scale_h = DEFAULT_SIDE;
}


void gSetScale(float w, float h)
{
  gSetScaleRelative(w,h);
}


void gSetScaleWH(int w, int h)
{
  obj_scale_w = w;
  obj_scale_h = h;
}


void gSetScaleRelative(float w, float h)
{
  obj_scale_w *= w;
  obj_scale_h *= h;
}


void gSetScaleWHRelative(int w, int h)
{
  obj_scale_w += w;
  obj_scale_h += h;
}

// * Color functions *

void gResetColor()
{
  obj_color = DEFAULT_COLOR;
}


void gResetAlpha()
{
  obj_alpha = DEFAULT_ALPHA;
}


void gSetColor(gColor color)
{
  obj_color = color;
  if (++obj_colors_count > 1) obj_use_vert_color = G_TRUE;
  if (G_GET_A(obj_color) < 255) obj_use_blend = G_TRUE;
}


void gSetAlpha(gAlpha alpha)
{
  obj_alpha = alpha;
  if (obj_alpha > 255) obj_alpha = 255;
  else if (obj_alpha < 0) obj_alpha = 0;
  if (++obj_alpha_count > 1) obj_use_vert_color = G_TRUE;
  if (obj_alpha < 255) obj_use_blend = G_TRUE;
}


void gSetAlphaRelative(gAlpha alpha)
{
  gSetAlpha(obj_alpha + alpha);
}

// EOF