void Sprite::load ( long pos )
{
    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 int [ max_pixels ];

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

    indices.length = max_pixels;
    indices.v = new unsigned char [ indices.length ];
    for ( int i = 0; i < indices.length; i++ ) {
  indices.v[i] = i;
    }
    v = new float [ 3 * 2 ];
    v[0] = 0.0f;
    v[1] = 1.0f;

    v[2] = 1.0f;
    v[3] = 0.0f;

    v[4] = 1.0f;
    v[5] = 1.0f;

    std::fclose ( fd );
}

void Sprite::render ( )
{
    glBindTexture ( GL_TEXTURE_2D, tex );
    glEnableClientState ( GL_VERTEX_ARRAY );
    glEnableClientState ( GL_TEXTURE_COORD_ARRAY );

    glVertexPointer ( 2, GL_FLOAT, 0, v );
    glTexCoordPointer ( 2, GL_FLOAT, 0, pixels );

    glPushMatrix ( );
    glTranslatef ( 0, 0, -10 );

    glDrawElements ( GL_TRIANGLES, indices.length, GL_UNSIGNED_BYTE, indices.v );
    glPopMatrix ( );

    glDisableClientState ( GL_VERTEX_ARRAY );
    glDisableClientState ( GL_TEXTURE_COORD_ARRAY );
    glFlush ( );
}

C2DBackgroung::C2DBackgroung()
{
    m_nTexture = 0;

// Faces...
    m_arrFaces.Set(2);
    face_t f1 = {0, 1, 2};
    face_t f2 = {0, 2, 3};

    m_arrFaces[0] = f1;
    m_arrFaces[1] = f2;

// Verts...
    m_arrVerts.Set(4);
    vert_t v1 = { 0.f, 0.f, 0.f, 0.f, 1.f, 0.f };
    vert_t v2 = { 0.f, 0.f, 0.f, 1.f, 1.f, 0.f };
    vert_t v3 = { 0.f, 0.f, 0.f, 1.f, 0.f, 0.f };
    vert_t v4 = { 0.f, 0.f, 0.f, 0.f, 0.f, 0.f };

    m_arrVerts[0] = v1;
    m_arrVerts[1] = v2;
    m_arrVerts[2] = v3;
    m_arrVerts[3] = v4;
}

C2DBackgroung::~C2DBackgroung()
{

}

#include "bmp_file.h"

BOOL C2DBackgroung::LoadTexture(char *pName)
{
    AUX_RGBImageRec *pTexImage = NULL;

    glPixelStorei(GL_PACK_ALIGNMENT, 1);

    BMP_File bmp;
    if(!bmp.Load(pName)){
//  AfxMessageBox("Can't load 2D Background Image file!");
  return FALSE;
    }

    bmp.FlipY();

    if(m_nTexture){
  glBindTexture(GL_TEXTURE_2D, m_nTexture);
  glDeleteTextures(1, &m_nTexture);
  m_nTexture = 0;
    }

    glGenTextures(1, &m_nTexture);
    glBindTexture(GL_TEXTURE_2D, m_nTexture);
    glEnable(GL_TEXTURE_2D);

//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, bmp.SizeX(), bmp.SizeY(), GL_RGB, GL_UNSIGNED_BYTE, bmp.Memory());

//    if(pTexImage->data){ free(pTexImage->data); }
//    free(pTexImage);

    return TRUE;
    
}

void C2DBackgroung::Draw()
{
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    glBindTexture(GL_TEXTURE_2D, m_nTexture);

    glDisable(GL_COLOR_MATERIAL);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
    
    glVertexPointer(3, GL_FLOAT, sizeof(vert_t), &m_arrVerts[0].x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(vert_t), &m_arrVerts[0].tx);
    glDrawElements(GL_TRIANGLES, m_arrFaces.Size() * 3, GL_UNSIGNED_INT, m_arrFaces.Memory());

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);
    
    glDisable(GL_TEXTURE_2D);
}