glOrtho ( 0.0f, 1.0, 0.0 /*screen_height*/, 1.0 /*0.0f*/, 0.0f, 1.0f );

#include "Sprite.hpp"

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

Sprite::Sprite ( )
{
}

void Sprite::free_data ( )
{
//    if ( texture ) free ( texture );
    if ( vertices ) free ( vertices );
    if ( pixels ) free ( pixels );
}
void Sprite::load ( long pos )
{
    offset = 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" );
    }
    std::fclose ( fd );

    glGenTextures ( 1, &tex );
    glBindTexture ( GL_TEXTURE_2D, tex );
#if 1
    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 );
#endif
//     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels );

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

    max_draw = height * width;
    vertices = new float [ 3 * 2 ];
    vertices[0] = 0.0f;
    vertices[1] = 0.3f;
    vertices[2] = 0.3f;
    vertices[3] = 0.0f;
    vertices[4] = 0.3f;
    vertices[5] = 0.3f;
}
void Sprite::render ( )
{
#if 1
    if ( y > 1.0 ) return;
    if ( y < -0.3 ) return;
#endif

    glBindTexture ( GL_TEXTURE_2D, tex );
    glPushMatrix ( );

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

    glTranslatef ( this->x, this->y, 0 );

    glEnableClientState ( GL_VERTEX_ARRAY );
    glEnableClientState ( GL_TEXTURE_COORD_ARRAY );

    glVertexPointer ( 2, GL_FLOAT, 0, vertices );
    glTexCoordPointer ( 2, GL_FLOAT, 0, vertices );
    glDrawArrays ( GL_TRIANGLES, 0, 6 );

    glDisableClientState ( GL_VERTEX_ARRAY );
    glDisableClientState ( GL_TEXTURE_COORD_ARRAY );

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

    glPopMatrix ( );

    glFlush ( );
}

int Sprite::get_width ( )
{
    return width;
}

int Sprite::get_height ( )
{
    return height;
}

int Sprite::get_x ( )
{
    return x;
}

int Sprite::get_y ( )
{
    return y;
}

void Sprite::set_pos ( int x, int y )
{
    this->x = x;
    this->y = y;
}

void Sprite::slice ( int width, int height )
{
}

int Sprite::get_max_frames ( )
{
    return max_frames;
}

                for ( int i = 0; i < MAX_SPRITES; i++ ) {
                        s1[i].render ( );
                        s2[i].render ( );
                        s3[i].render ( );
                        s4[i].render ( );
                        s5[i].render ( );
                        s6[i].render ( );
                }

                      if ( s1[i].get_y() <= screen_height && s1[i].get_y() > -256 ) s1[i].render ( );

convert *.png avatar.gif