wchar_t * text = L"привет gcup, я пишу в линуксе с sdl2 и opengl.\n"
                "Мне нравиться когда у меня начинает что-то получаться.\n"
                "А также я считаю что эта тема может пригодиться многим, кто хочет работать с freetype2.\n"
                "И так, код будет снизу!";
        font->init ( text, 21, 1, 4, 4, 0, 0, 0 );

#ifndef H_FONT_H
#define H_FONT_H
#include <stdint.h>
#include <ft2build.h>
#include <string>
#include <vector>
#include <SDL2/SDL_opengl.h>
#include <SDL2/SDL_opengles2.h>
#include "gl_mat.hpp"
#include "global.hpp"
#include <wchar.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H

class Font {
    public:
  Font ( ) { }
  Font ( const char *ttf_file );
  void setPos ( int x, int y );
  void init ( wchar_t *text, int fontSize, int align, int valign, int space, uint8_t r, uint8_t g, uint8_t b );
  void setSize ( int w, int h );
  void draw ( );
    private:
  FT_Face face = 0;
  float *texture;
  float *vertices;
  int width;
  int height;
  int sampler;
  GLuint textureid;
  int x;
  int y;
  int max_draw;
  float ortho[4][4];
  float translate[4][4];
  float result[4][4];
  unsigned int program;
  FT_Library ft_library;
  FT_Face ttf;

};
#endif

#include "font.hpp"

Font::Font ( const char *ttf_file )
{
    glm::clearMatrix4x4 ( &ortho[0] );
    glm::clearMatrix4x4 ( &translate[0] );
    glm::clearMatrix4x4 ( &result[0] );

    program = global.programs["sprite"];
    int width = global.width;
    int height = global.height;
    glm::ortho ( &ortho[0], 0.0f, width, 0.0f, height, 0.0f, 1.0f );
    setPos ( 0, 0 );

    FT_Init_FreeType( &ft_library );

#ifdef __ANDROID__
    FT_NewFace ( ft_library, ttf_file, 0, &face );
#else
    char *path = (char *) new char[255];
    sprintf ( path, "assets/%s", ttf_file );
    FT_New_Face ( ft_library, path, 0, &face );
    free ( path );
#endif
}

void Font::init ( wchar_t *es, int fontSize, int align, int vert, int space, uint8_t r, uint8_t g, uint8_t b )
{
    FT_Set_Pixel_Sizes ( face, 0, fontSize );

    FT_Glyph glyph;

    int w = 0;
    unsigned int h = 0;
    unsigned int maxh = 0;
    unsigned int toprow = 0;
    int len = wcslen ( es );
    for ( int i = 0; i < len; i++ ) {
  wchar_t charcode = es[i];
  FT_Load_Char ( face, charcode, FT_LOAD_RENDER );
  FT_UInt glyph_index = FT_Get_Char_Index ( face, charcode );

  FT_Load_Glyph ( face, glyph_index, FT_LOAD_DEFAULT );
  FT_Render_Glyph ( face->glyph, FT_RENDER_MODE_NORMAL );
  FT_Get_Glyph ( face->glyph, &glyph );

  FT_Glyph_To_Bitmap ( &glyph, FT_RENDER_MODE_NORMAL, 0, 1 );
  FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph) glyph;
  FT_Bitmap bitmap = bitmap_glyph->bitmap;
  w += bitmap.width;

   int resize = bitmap.rows - bitmap_glyph->top;
   h = bitmap.rows + resize;
   if ( toprow < bitmap.rows ) toprow = bitmap.rows;
  
  if ( maxh < bitmap.rows + bitmap_glyph->top ) maxh = bitmap.rows + bitmap_glyph->top;

  if ( charcode == ' ' ) w += space;
  if ( charcode == '\n' ) {
   h += vert + maxh;
   FT_Done_Glyph ( glyph );
   continue;
  }
  w += align;

  FT_Done_Glyph ( glyph );
    }

    uint8_t im[h][w];
    memset ( &im[0][0], 0, w * h * sizeof ( uint8_t ) );

    int ih = 0;
    int iw = 0;
    int posy = 0;
    int topy = 0;
    int maxwidth = 0;
    for ( int i = 0; i < len; i++ ) {
  wchar_t charcode = es[i];
  FT_Load_Char ( face, charcode, FT_LOAD_RENDER );
  FT_UInt glyph_index = FT_Get_Char_Index ( face, charcode );

  FT_Load_Glyph ( face, glyph_index, FT_LOAD_DEFAULT );
  FT_Render_Glyph ( face->glyph, FT_RENDER_MODE_NORMAL );
  FT_Get_Glyph ( face->glyph, &glyph );

  FT_Glyph_To_Bitmap ( &glyph, FT_RENDER_MODE_NORMAL, 0, 1 );
  FT_BitmapGlyph bitmap_glyph = (FT_BitmapGlyph) glyph;
  FT_Bitmap bitmap = bitmap_glyph->bitmap;

  posy = bitmap_glyph->top;
  posy = bitmap.rows - posy;
  topy = toprow - bitmap.rows;

  if ( charcode == '\n' ) {
   ih += maxh;
   iw = 0;
   FT_Done_Glyph ( glyph );
   continue;
  }
  for ( unsigned int y = 0, i = 0; y < bitmap.rows; y++ ) {
   for ( unsigned int x = 0; x < bitmap.width; x++, i++ ) {
    im [ ih + posy + y + topy ] [ iw + x ] = bitmap.buffer[i];
   }
  }
  iw += bitmap.width;
  iw += align;
  if ( maxwidth < iw ) maxwidth = iw;

  if ( charcode == ' ' ) {
   iw += space;
  }

  FT_Done_Glyph ( glyph );

    }

    iw = maxwidth;
    width = iw;
    height = h;

    unsigned int size = width * height;
    uint8_t *image_data = new uint8_t [ size * 4 ];
    memset ( image_data, 255, size * 4 * sizeof ( uint8_t ) );

    for ( unsigned int i = 0, y = 0; i < size; y++ ) {
  for ( int x = 0; x < width; x++, i++ ) {
   image_data[ 4 * i + 3] = im [ y ][ x ];
   image_data[ 4 * i + 0] = r;
   image_data[ 4 * i + 1] = g;
   image_data[ 4 * i + 2] = b;
  }
    }

    glGenTextures ( 1, &textureid );
    glBindTexture ( GL_TEXTURE_2D, textureid );
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data );

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
    setSize ( width, height );
    delete[] image_data;

}
void Font::setSize ( int w, int h )
{
    vertices = new float [ 12 ];
    vertices[0] = 0;
    vertices[1] = 0;
    vertices[2] = 0;
    vertices[3] = h;
    vertices[4] = w;
    vertices[5] = 0;

    vertices[6] = w;
    vertices[7] = 0;
    vertices[8] = w;
    vertices[9] = h;
    vertices[10] = 0;
    vertices[11] = h;

    texture = new float [ 12 ];
    texture[0] = 0;
    texture[1] = 1;
    texture[2] = 0;
    texture[3] = 0;
    texture[4] = 1;
    texture[5] = 1;

    texture[6] = 1;
    texture[7] = 1;
    texture[8] = 1;
    texture[9] = 0;
    texture[10] = 0;
    texture[11] = 0;
}

void Font::setPos ( int x, int y )
{
    this->x = x;
    this->y = y;
    glm::translate ( &translate[0], x, y, 0 );
    glm::sumMatrix ( &result[0], &translate[0], &ortho[0] );
}

void Font::draw ( )
{
    glUseProgram ( program );

    sampler = glGetUniformLocation ( program, "s_texture" );

    glActiveTexture ( GL_TEXTURE0 );
    glBindTexture ( GL_TEXTURE_2D, textureid );
    glUniform1i ( sampler, 0 );

    GLint projection_location = glGetUniformLocation ( program, "transform" );
    glUniformMatrix4fv ( projection_location, 1, GL_FALSE, &result[0][0] );

    glEnableVertexAttribArray ( 0 );
    glEnableVertexAttribArray ( 1 );

    glVertexAttribPointer ( 0, 2, GL_FLOAT, GL_FALSE, 0, vertices );
    glVertexAttribPointer ( 1, 2, GL_FLOAT, GL_FALSE, 0, texture );

    glDrawArrays ( GL_TRIANGLES, 0, 12 );

    glDisableVertexAttribArray ( 0 );
    glDisableVertexAttribArray ( 1 );
}

  const char *vshader =
          "#version 300 es\n"
   "layout(location = 0) in vec2 position;\n"
   "layout(location = 1) in vec2 texCoord;\n"
   "uniform mat4 transform;\n"
    "out vec2 v_texCoord;\n"
   "void main ( )\n"
   "{\n"
   " gl_Position = transform * vec4 ( position, 0.0, 1.0 );\n"
   " v_texCoord = texCoord;\n"
   "}";

  const char *fshader =
   "#version 300 es\n"
   "precision mediump float;\n"
   "in vec2 v_texCoord;\n"
   "layout(location = 0) out vec4 outColor;\n"
   "uniform sampler2D s_texture;\n"
   "void main ( )\n"
   "{\n"
   " outColor = texture ( s_texture, v_texCoord );\n"
   "}";

#include "Game.hpp"
#include "Sprite.hpp"

Game::Game ( )
{
    SDL_Init ( SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS );
    SDL_DisplayMode mode;
    SDL_GetCurrentDisplayMode ( 0, &mode );
    screen_width = mode.w;
    screen_height = mode.h;

    window = SDL_CreateWindow ( "slots",
   0, 0,
   screen_width,
   screen_height,
   SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN
   );

    SDL_GLContext glc;

    SDL_GL_SetAttribute ( SDL_GL_CONTEXT_MAJOR_VERSION, 4 );
    SDL_GL_SetAttribute ( SDL_GL_CONTEXT_MAJOR_VERSION, 0 );
    glc = SDL_GL_CreateContext ( window );
    SDL_GL_MakeCurrent ( window, glc );

    glViewport ( 0, 0, screen_width, screen_height );
    glMatrixMode ( GL_PROJECTION );
    glLoadIdentity ( );

    GLfloat aspect;
    aspect = (GLfloat) screen_width / (GLfloat) screen_height;
    glOrtho ( 0.0f, 1.0, 0.0 /*screen_height*/, 1.0 /*0.0f*/, 0.0f, 1.0f );
//    glMatrixMode ( GL_TEXTURE );
    glMatrixMode ( GL_MODELVIEW );
    glLoadIdentity ( );
    glEnable ( GL_BLEND );
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
int thread ( void *data )
{
    SDL_Event event;
    while ( SDL_WaitEvent ( &event ) ) {
    }
}
#define MAX_SPRITES 24
#define BOTTOM 21
#define SPEED 0.09

char lines[3][5];
int offsets[] = { 0, 262156, 8818724, 9080880 };
void place ( Sprite *s, int end, float y, float x )
{
    for ( int i = 0; i < ( MAX_SPRITES - end ); i++, y += 0.2 ) {
  int ii = random () % 4;
  s[i].load ( offsets [ ii ] );
  s[i].set_pos ( x, y );
  s[i].number = ii;
    }
}
int st = 0;
int new_game = 0;

void run ( Sprite *s )
{
    for ( int i = 0; i < MAX_SPRITES; i++ ) {
  s[i].set_pos ( s[i].get_x(), s[i].get_y() - SPEED );
  if ( s[BOTTOM].get_y () <= 0.15 ) {
   s[i + 0].set_pos ( s[i + 0].get_x(), 0.15 );
   s[i + 1].set_pos ( s[i + 1].get_x(), 0.15 + 0.2 );
   s[i + 2].set_pos ( s[i + 2].get_x(), 0.15 + 0.2 + 0.2 );
   st = 0;
   new_game = 1;
   break;
  }
    }
}
void copy ( Sprite *s )
{
    for ( int i = 0; i < 3; i++ ) {
  s[i].free_data ( );
    }
    s[0].load ( s[MAX_SPRITES - 3].offset );
    s[0].set_pos ( s[MAX_SPRITES - 3].get_x(), s[MAX_SPRITES - 3].get_y() );
    s[1].load ( s[MAX_SPRITES - 2].offset );
    s[1].set_pos ( s[MAX_SPRITES -2].get_x(), s[MAX_SPRITES - 2].get_y() );
    s[2].load ( s[MAX_SPRITES - 1].offset );
    s[2].set_pos ( s[MAX_SPRITES - 1].get_x(), s[MAX_SPRITES - 1].get_y() );

    for ( int i = 3; i < MAX_SPRITES; i++ ) {
  s[i].free_data ();
    }
}

void check_win ( Sprite *s1, Sprite *s2, Sprite *s3, Sprite *s4, Sprite *s5 )
{
    lines[0][0] = s1[0].number;
    lines[1][0] = s1[1].number;
    lines[2][0] = s1[2].number;
    lines[0][1] = s2[0].number;
    lines[1][1] = s2[1].number;
    lines[2][1] = s2[2].number;
    lines[0][2] = s3[0].number;
    lines[1][2] = s3[1].number;
    lines[2][2] = s3[2].number;
    lines[0][3] = s4[0].number;
    lines[1][3] = s4[1].number;
    lines[2][3] = s4[2].number;
    lines[0][4] = s5[0].number;
    lines[1][4] = s5[1].number;
    lines[2][4] = s5[2].number;

    int ns1 = 0;
    int win = 0;
    for ( int i = 0; i < 5; i++ ) {
  ns1 = lines[0][i];
  
    }
}

void Game::loop ( )
{
    SDL_CreateThread ( thread, "thread", NULL );

    Sprite *s1 = new Sprite [MAX_SPRITES];
#if 1
    Sprite *s2 = new Sprite [MAX_SPRITES];
    Sprite *s3 = new Sprite [MAX_SPRITES];
    Sprite *s4 = new Sprite [MAX_SPRITES];
    Sprite *s5 = new Sprite [MAX_SPRITES];
#endif
#if 1
    Sprite *background = new Sprite ( );
    background->load ( 524312 );
    background->set_pos ( 0.0, 0.0 );
    background->set_size ( 1.0, 1.0 );
#endif

    for ( int i = 0; i < MAX_SPRITES; i++ ) {
  s1[i].set_size ( 0.15, 0.2 );
  s2[i].set_size ( 0.15, 0.2 );
  s3[i].set_size ( 0.15, 0.2 );
  s4[i].set_size ( 0.15, 0.2 );
  s5[i].set_size ( 0.15, 0.2 );
    }
    srandom ( time ( 0 ) );

    place ( &s1[0], 0, 0.15, 0.15 );
    place ( &s2[0], 0, 0.15, 0.15 + 0.15 );
    place ( &s3[0], 0, 0.15, 0.15 + 0.15 + 0.15 );
    place ( &s4[0], 0, 0.15, 0.15 + 0.15 + 0.15 + 0.15 );
    place ( &s5[0], 0, 0.15, 0.15 + 0.15 + 0.15 + 0.15 + 0.15 );

    while ( 1 ) {
  const Uint8 *state = SDL_GetKeyboardState ( NULL );
  if ( state [ SDL_SCANCODE_Q ] ) {
   SDL_Quit ( );
   exit ( EXIT_SUCCESS );
  }
  if ( state [ SDL_SCANCODE_SPACE ] ) {
   if ( st == 1 ) {
   } else {
    st = 1;
    new_game = 0;
   }
  }
  if ( st >= 1 ) {
   run ( s1 );
#if 1
   run ( s2 );
   run ( s3 );
   run ( s4 );
   run ( s5 );
#endif
  }
  if ( new_game ) {
   copy ( s1 );
#if 1
   copy ( s2 );
   copy ( s3 );
   copy ( s4 );
   copy ( s5 );
#endif
   place ( &s1[3], 3, 0.15 + 0.2 + 0.2 + 0.2, 0.15 );
   place ( &s2[3], 3, 0.15 + 0.2 + 0.2 + 0.2, 0.15 + 0.15 );
   place ( &s3[3], 3, 0.15 + 0.2 + 0.2 + 0.2, 0.15 + 0.15 + 0.15 );
   place ( &s4[3], 3, 0.15 + 0.2 + 0.2 + 0.2, 0.15 + 0.15 + 0.15 + 0.15 );
   place ( &s5[3], 3, 0.15 + 0.2 + 0.2 + 0.2, 0.15 + 0.15 + 0.15 + 0.15 + 0.15 );
//   check_win ( s1, s2, s3, s4, s5 );
   new_game = 0;
   continue;
  }
  glClearColor ( 1, 1, 1, 1 );
  glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  for ( int i = 0; i < MAX_SPRITES; i++ ) {
   s1[i].render ( );
   s2[i].render ( );
   s3[i].render ( );
   s4[i].render ( );
   s5[i].render ( );
  }
  background->render();
  SDL_GL_SwapWindow ( window );
  SDL_Delay ( 0.01 );
    }
}

#include "Sprite.hpp"

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

Sprite::Sprite ( )
{
}

void Sprite::free_data ( )
{
    if ( texture ) delete ( texture );
    if ( vertices ) delete ( vertices );
    if ( pixels ) delete ( 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 [ 12 ];
    vertices[0] = 0.0f;
    vertices[1] = 0.0f;
    vertices[2] = 0.0f;
    vertices[3] = fheight;
    vertices[4] = fwidth;
    vertices[5] = 0.0f;

    vertices[6] = fwidth;
    vertices[7] = 0.0f;
    vertices[8] = fwidth;
    vertices[9] = fheight;
    vertices[10] = 0.0f;
    vertices[11] = fheight;

    texture = new float [ 12 ];
    texture[0] = 0.0f;
    texture[1] = 1.0f;
    texture[2] = 0.0f;
    texture[3] = 0.0f;
    texture[4] = 1.0f;
    texture[5] = 1.0f;

    texture[6] = 1.0f;
    texture[7] = 1.0f;
    texture[8] = 1.0f;
    texture[9] = 0.0f;
    texture[10] = 0.0f;
    texture[11] = 0.0f;
}
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, texture );
    glDrawArrays ( GL_TRIANGLES, 0, 12 );

    glDisableClientState ( GL_VERTEX_ARRAY );
    glDisableClientState ( GL_TEXTURE_COORD_ARRAY );

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

    glPopMatrix ( );

    glFlush ( );
}

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

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

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

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

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

void Sprite::slice ( int width, int height )
{
}
void Sprite::set_size ( float width, float height )
{
    this->fwidth = width;
    this->fheight = height;
}

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