#include "Sprite.hpp"

Sprite::Sprite ( long pos )
{
    //init_texture ( );
}

Sprite::Sprite ( )
{
}

void Sprite::load ( long pos )
{
    std::FILE *fd = std::fopen ( "data", "r" );
    if ( !fd ) {
  std::perror ( "sprite load" );
  exit ( EXIT_FAILURE );
    }

    int ret;
    ret = std::fseek ( fd, pos, SEEK_SET );
    if ( ret == -1 ) {
  perror ( "fseek\n" );
    }

    ret = std::fread ( &width, sizeof ( unsigned int ), 1, fd );
    if ( ret == -1 ) {
  perror ( "width\n" );
    }
    ret = std::fread ( &height, sizeof ( unsigned int ), 1, fd );
    if ( ret == -1 ) {
  perror ( "heigth\n" );
    }
    ret = std::fread ( &max_pixels, sizeof ( unsigned int ), 1, fd );
    if ( ret == -1 ) {
  perror ( "max_pixels\n" );
    }

    pixels = new unsigned char [ max_pixels ];
    if ( !pixels ) {
  printf (" !@!\n" );
    }

    ret = std::fread ( &pixels[0] , sizeof ( unsigned char ), max_pixels, fd );
    if ( ret == -1 ) {
  perror ( "pixels\n" );
    }

    vertices = new int [ max_pixels ];
    if ( !vertices ) {
  printf ( "@!@\n" );
    }
    for ( int y = 0; y < 64; y++ ) {
  for ( int x = 0, i = 0; x < 64; i += 2, x++ ) {
   vertices[ 0 + ( y * ( 64 - 1 ) + i ) ] = x;
   vertices[ 1 + ( y * ( 64 - 1 ) + i ) ] = y;
  }
    }

    std::fclose ( fd );
}
void Sprite::render ( )
{

    glPushMatrix ( );

#if 0
    glFrontFace ( GL_CCW );
    glEnable ( GL_CULL_FACE );
    glCullFace ( GL_BACK );
#endif

    glEnableClientState ( GL_VERTEX_ARRAY );
    glEnableClientState ( GL_COLOR_ARRAY );

    glVertexPointer ( 2, GL_INT, 0, vertices );
    glColorPointer ( 4, GL_UNSIGNED_BYTE, 0, pixels );
//    glDrawElements ( GL_POINTS, indices.length, GL_UNSIGNED_BYTE, indices.v );
    glDrawArrays ( GL_POINTS, 0, 4096 );

    glDisableClientState ( GL_VERTEX_ARRAY );
    glDisableClientState ( GL_COLOR_ARRAY );

    glDisable ( GL_CULL_FACE );
//    glTranslatef ( 0, 0, -10 );

    glPopMatrix ( );

    glFlush ( );
}
void Sprite::init_texture ( )
{
}

for ( int y = 0; y < 64; y++ ) {
  for ( int x = 0, i = 0; x < 64; i += 2, x++ ) {
   vertices[ 0 + ( y * ( 64 - 1 )  + i ) ] = x;
   vertices[ 1 + ( y * ( 64 - 1 ) + i ) ] = y;
  }
    }

#include "Sprite.hpp"

Sprite::Sprite ( )
{
}

void Sprite::load ( long pos )
{
    init_texture ( );
    std::FILE *fd = std::fopen ( "data", "r" );
    if ( !fd ) {
  std::perror ( "sprite load" );
  exit ( EXIT_FAILURE );
    }

    std::fseek ( fd, pos, SEEK_SET );

    std::fread ( &width, sizeof ( unsigned int ), 1, fd );
    std::fread ( &height, sizeof ( unsigned int ), 1, fd );
    std::fread ( &max_pixels, sizeof ( unsigned int ), 1, fd );

    pixels = new unsigned char [ max_pixels ];

//    for ( int i = 0; i < max_pixels; i++ ) {
  std::fread ( &pixels[0] , sizeof ( unsigned char ), max_pixels, fd );
//    }

#if 0
    vertices = new float [ 8 ] {
  0, 64,
  0, 0,
  64, 0,
  64, 64
    };
    texture = new float [ 8 ] {
  64, 0,
  0, 0,
  0, 64,
  64, 64
    };
#endif
#if 1
    vertices = new float [ 8 ] {
  0, 1,
  0, 0,
  1, 0,
  1, 1
    };
    texture = new float [ 8 ] {
  1, 0,
  0, 0,
  0, 1,
  1, 1
    };
#endif

    indices.length = 6;
    indices.v = new unsigned char [ indices.length ] {
  0, 1, 2,
  0, 2, 3
    };

    std::fclose ( fd );
}
void Sprite::render ( )
{
#if 1
    glEnable ( GL_TEXTURE_2D );
    glBindTexture ( GL_TEXTURE_2D, tex );

    glPushMatrix ( );

#if 0
    glFrontFace ( GL_CCW );
    glEnable ( GL_CULL_FACE );
    glCullFace ( GL_BACK );
#endif

    glEnableClientState ( GL_VERTEX_ARRAY );
    glEnableClientState ( GL_TEXTURE_COORD_ARRAY );

    glVertexPointer ( 2, GL_FLOAT, 0, vertices );
    glTexCoordPointer ( 2, GL_FLOAT, 0, texture );
    glDrawElements ( GL_TRIANGLES, indices.length, GL_UNSIGNED_BYTE, indices.v );

    glDisableClientState ( GL_VERTEX_ARRAY );
    glDisableClientState ( GL_TEXTURE_COORD_ARRAY );

    glDisable ( GL_CULL_FACE );
    glTranslatef ( 0, 0, 2 );

    glPopMatrix ( );

    glFlush ( );
    glDisable ( GL_TEXTURE_2D );
#endif
}
void Sprite::init_texture ( )
{
    glGenTextures ( 1, &tex );
    glBindTexture ( GL_TEXTURE_2D, tex );

    glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER );
    glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
    glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER );

    glTexImage2D ( GL_TEXTURE_2D,
   0,
   GL_RGBA,
   width,
   height,
   0,
   GL_RGBA,
   GL_UNSIGNED_BYTE,
   pixels );

    glEnable ( GL_TEXTURE_2D );

}