void startup(int argc, char* argv[]) {
	GLenum glew_init_result;
	create_window(argc, argv);
	glewExperimental = GL_TRUE;
	glew_init_result = glewInit();

	check_gl_error(glew_init_result, "");

	fprintf(stdout, "INFO: OpenGL Version: %s\n", glGetString(GL_VERSION));

    rendering_program = create_shaders();
    create_vao();

    // glEnable(GL_CULL_FACE);
    // glCullFace(GL_BACK);
}

void Mesh::Clear() {
	finalized = false;
	this->vertices.clear();
	this->indices.clear();
	if (this->VAO)
		glDeleteVertexArrays(1, &this->VAO);
	if (this->VBO)
		glDeleteBuffers(1, &this->VBO);
	if (this->EBO)
		glDeleteBuffers(1, &this->EBO);
	check_gl_error();

	this->VAO = 0;
	this->VBO = 0;
	this->EBO = 0;
}

void
cylinder::init_model(view& scene)
{
	if (!scene.cylinder_model[0].compiled()) {
		clear_gl_error();
		// The number of faces corrisponding to each level of detail.
		size_t n_faces[] = { 8, 16, 32, 64, 96, 188 };
		size_t n_stacks[] = {1, 1, 3, 6, 10, 20 };
		for (size_t i = 0; i < 6; ++i) {
			scene.cylinder_model[i].gl_compile_begin();
			render_cylinder_model( n_faces[i], n_stacks[i]);
			scene.cylinder_model[i].gl_compile_end();
		}
		check_gl_error();
	}
}

void			Framebuffer::setDepthTextureOnly()
{
	glGenTextures(1, &m_depthTextureOnlyHandle);
	glBindTexture(GL_TEXTURE_2D, m_depthTextureOnlyHandle);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, m_width, m_height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);

	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthTextureOnlyHandle, 0);

	check_gl_error();
}

static void
setup_texture(ModeInfo * mi)
{
  planetstruct *gp = &planets[MI_SCREEN(mi)];

  glGenTextures (1, &gp->tex1);
  glBindTexture (GL_TEXTURE_2D, gp->tex1);

  /* Must be after glBindTexture */
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  if (!which_image ||
      !*which_image ||
      !strcmp(which_image, "BUILTIN"))
    {
    BUILTIN:
      setup_xpm_texture (mi, dymaxionmap_xpm);
    }
  else
    {
      if (! setup_file_texture (mi, which_image))
        goto BUILTIN;
    }

  glGenTextures (1, &gp->tex2);
  glBindTexture (GL_TEXTURE_2D, gp->tex2);

  /* Must be after glBindTexture */
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  setup_xpm_texture (mi, ground);

  check_gl_error("texture initialization");

  /* Need to flip the texture top for bottom for some reason. */
  glMatrixMode (GL_TEXTURE);
  glScalef (1, -1, 1);
  glMatrixMode (GL_MODELVIEW);
}

int main(int argc, char **argv) {

  try {

    graphicObjects = GraphicObject::loadObjects("resources/mobile.obj", "resources/");

    // initialize GLUT; set double buffered window and RGBA color model
    glutInit(&argc, argv);

    //Intel HD Fix
    glutInitContextVersion(3, 3);
    glutInitContextProfile(GLUT_CORE_PROFILE);
    glewExperimental = GL_TRUE;

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(900, 900);
    glutInitWindowPosition(10, 10);
    glutCreateWindow("CG Proseminar - Mobile");

    // initialize GL extension wrangler
    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      return 1;
    }

    check_gl_error();

    // Setup scene and rendering parameters
    initialize();

    // Specify callback functions;enter GLUT event processing loo
    // handing control over to GLUT
    glutIdleFunc(onIdle);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutPassiveMotionFunc(mouse);

    glutMainLoop();
  }
  catch (const std::exception &e) {
    return EXIT_SUCCESS;
  }


  return 0;
}

void Framebuffer::clean()
{
	bind();
	if(m_colorTextureHandles.size() != 0)
	{
		glClear(GL_COLOR_BUFFER_BIT);
	}
	if (m_depthRBOHandle != GL_INVALID_VALUE || m_depthTextureOnlyHandle != GL_INVALID_VALUE)
	{
		glClear(GL_DEPTH_BUFFER_BIT);
	} else if (m_depthStencilRBOHandle != GL_INVALID_VALUE || m_depthStencilTextureHandle != GL_INVALID_VALUE)
	{
		glClear(GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
	}
	unbind();
	check_gl_error();
}

void
cone::gl_pick_render(view& scene)
{
	if (degenerate())
		return;
	init_model(scene);

	size_t lod = 2;
	clear_gl_error();

	gl_matrix_stackguard guard;
	const double length = axis.mag();
	model_world_transform( scene.gcf, vector( length, radius, radius ) ).gl_mult();

	scene.cone_model[lod].gl_render();
	check_gl_error();
}

static void
render_scene_to_texture (ModeInfo *mi)
{
  glblur_configuration *bp = &bps[MI_SCREEN(mi)];

  glViewport (0, 0, bp->tex_w, bp->tex_h);

  glCallList (bp->scene_dlist1);
  glCallList (bp->scene_dlist2);

  glBindTexture (GL_TEXTURE_2D, bp->texture);
  glCopyTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE, 0, 0,
                    bp->tex_w, bp->tex_h, 0);
  check_gl_error ("texture2D");

  glViewport (0, 0, MI_WIDTH(mi), MI_HEIGHT(mi));
}

static bool glsl_set_shader_matrix(ALLEGRO_SHADER *shader,
   const char *name, ALLEGRO_TRANSFORM *matrix)
{
   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
   GLint handle;

   handle = glGetUniformLocation(gl_shader->program_object, name);

   if (handle < 0) {
      ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
      return false;
   }

   glUniformMatrix4fv(handle, 1, false, (float *)matrix->m);

   return check_gl_error(name);
}

static bool glsl_set_shader_float(ALLEGRO_SHADER *shader,
   const char *name, float f)
{
   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
   GLint handle;

   handle = glGetUniformLocation(gl_shader->program_object, name);

   if (handle < 0) {
      ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
      return false;
   }

   glUniform1f(handle, f);

   return check_gl_error(name);
}

void racing_loop (double time_step){
    CControl *ctrl = Players.GetCtrl (g_game.player_id);
	double ycoord = Course.FindYCoord (ctrl->cpos.x, ctrl->cpos.z);
	bool airborne = (bool) (ctrl->cpos.y > (ycoord + JUMP_MAX_START_HEIGHT));

    check_gl_error();
    ClearRenderContext ();
	Env.SetupFog ();
	Music.Update ();    

	CalcTrickControls (ctrl, time_step, airborne);

	if (!g_game.finish) CalcSteeringControls (ctrl, time_step);
		else CalcFinishControls (ctrl, time_step, airborne);
	PlayTerrainSound (ctrl, airborne);

//  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	ctrl->UpdatePlayerPos (time_step); 
//  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

	if (g_game.finish) IncCameraDistance (time_step);
	update_view (ctrl, time_step);
	UpdateTrackmarks (ctrl);

    SetupViewFrustum (ctrl);
	if (sky) Env.DrawSkybox (ctrl->viewpos);
	if (fog) Env.DrawFog ();
	void SetupLight ();
	if (terr) RenderCourse ();
	DrawTrackmarks ();
	if (trees) DrawTrees ();
	if (param.perf_level > 2) {
		update_particles (time_step);
		draw_particles (ctrl);
    }
	Char.Draw (g_game.char_id);
	UpdateWind (time_step, ctrl);
	UpdateSnow (time_step, ctrl);
	DrawSnow (ctrl);
	DrawHud (ctrl);
	
	Reshape (param.x_resolution, param.y_resolution);
    Winsys.SwapBuffers ();
	if (g_game.finish == false) g_game.time += time_step;
} 

static void
init_stars (ModeInfo *mi)
{
  planetstruct *gp = &planets[MI_SCREEN(mi)];
  int i, j;
  int width  = MI_WIDTH(mi);
  int height = MI_HEIGHT(mi);
  int size = (width > height ? width : height);
  int nstars = size * size / 80;
  int max_size = 3;
  GLfloat inc = 0.5;
  int steps = max_size / inc;

  gp->starlist = glGenLists(1);
  glNewList(gp->starlist, GL_COMPILE);
  for (j = 1; j <= steps; j++)
    {
      glPointSize(inc * j);
      glBegin (GL_POINTS);
      for (i = 0; i < nstars / steps; i++)
	{
	  GLfloat d = 0.1;
	  GLfloat r = 0.15 + frand(0.3);
	  GLfloat g = r + frand(d) - d;
	  GLfloat b = r + frand(d) - d;

	  GLfloat x = frand(1)-0.5;
	  GLfloat y = frand(1)-0.5;
	  GLfloat z = ((random() & 1)
		       ? frand(1)-0.5
		       : (BELLRAND(1)-0.5)/12);	  /* milky way */
	  d = sqrt (x*x + y*y + z*z);
	  x /= d;
	  y /= d;
	  z /= d;
	  glColor3f (r, g, b);
	  glVertex3f (x, y, z);
	  gp->starcount++;
	}
      glEnd ();
    }
  glEndList ();

  check_gl_error("stars initialization");
}

/* Set up and enable texturing on our object */
static void
setup_xpm_texture (ModeInfo *mi, const unsigned char *data, unsigned long size)
{
  XImage *image = image_data_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi),
                                        data, size);
  char buf[1024];
  clear_gl_error();
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  /* iOS invalid enum:
  glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width);
  */
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
               image->width, image->height, 0,
               GL_RGBA, GL_UNSIGNED_BYTE, image->data);
  sprintf (buf, "builtin texture (%dx%d)", image->width, image->height);
  check_gl_error(buf);
  XDestroyImage (image);
}

void Painter::draw()
{
    glClearColor(1., 1., 1., 0.);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    interface->draw();
    wire_frame->draw();
    
    domain->draw();
    
    glDisable(GL_CULL_FACE);
    edges->draw(GL_POINTS);
    unmoved->draw(GL_POINTS);
    low_quality->draw();
    glEnable(GL_CULL_FACE);
    
    check_gl_error();
}

int main() {
	sf::Window window( { 200, 200 }, "Buffer Example", sf::Style::Default, sf::ContextSettings( 0, 0, 0, 3, 2, sf::ContextSettings::Core ) );
	ogl_LoadFunctions();

	// Create the buffer object
	auto buffer1 = gls::buffer<GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW>();

	// Write some initial data into the buffer object
	auto write_data = std::vector<float>();
	write_data = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f };
	buffer1.data( write_data.size() * sizeof( float ), write_data.data() );

	// Copy the data into another buffer object
	auto buffer2 = gls::buffer<GL_ELEMENT_ARRAY_BUFFER, GL_STREAM_READ>();
	buffer2.copy_sub_data( buffer1, 0, 0, buffer1.size() );

	// Modify the data in the second buffer object
	write_data = { 0.f, 0.f, 0.f };
	buffer2.sub_data( 3 * sizeof( float ), write_data.size() * sizeof( float ), write_data.data() );

	// Read the data back from the buffer object
	auto read_data = std::vector<float>();
	read_data.resize( static_cast<std::size_t>( buffer2.size() ) / sizeof( float ) );
	buffer2.get_sub_data( 0, read_data.size() * sizeof( float ), read_data.data() );

	// Print out the data
	for( auto value : read_data ) {
		std::cout << value << " ";
	}
	std::cout << std::endl;

	while( window.isOpen() ) {
		auto event = sf::Event();

		while( window.pollEvent( event ) ) {
			if( event.type == sf::Event::Closed ) {
				window.close();
			}
		}

		check_gl_error( glClear( GL_COLOR_BUFFER_BIT ) );
		window.display();
	}
}

void RenderSequence (double timestep) {
	check_gl_error();
	set_gl_options (TUX);
    ClearRenderContext (colDDBackgr);

	GluCamera.Update (timestep);
	if (TestFrame.active) TestFrame.UpdateTest (timestep, &TestChar);
	else if (keyrun) {
		TestFrame.InitTest (NullVec, &TestChar);
		keyrun = false;
	}

	glPushMatrix ();
	TestChar.Draw ();
	glPopMatrix ();

	Reshape (param.x_resolution, param.y_resolution);
    Winsys.SwapBuffers();
}

void draw(int x, int y, int width, int height)
{
	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
	glPixelTransferf(GL_GREEN_SCALE, 255.0f);
	glDrawPixels(width, height, GL_GREEN, GL_UNSIGNED_BYTE, (GLvoid*)bufs[grid.which_buf]);

	/*float red[2]   = {0.0f, 1.0f};*/
	/*float green[2] = {0.0f, 1.0f};*/
	/*float blue[2]  = {0.0f, 0.0f};*/
	/*float alpha[2] = {0.0f, 0.0f};*/
	/*glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 2, red);*/
	/*glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 2, green);*/
	/*glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 2, blue);*/
	/*glPixelMapfv(GL_PIXEL_MAP_I_TO_A, 2, alpha);*/
	/*glDrawPixels(width, height, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, (GLvoid*)bufs[grid.which_buf]);*/


	check_gl_error();
}

static int
draw_cubes (ModeInfo *mi, cube *c)
{
  int polys = 0;
  int i, j;

  glColor4fv (c->color);
  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, c->color);

  glPushMatrix();
  for (j = 0; j < 6; j++)
    {
      for (i = 0; i < 4; i++)
        {
          polys += draw_strut (mi, c);
          glRotatef (90, 0, 0, 1);
        }
      if (j == 3)
        glRotatef (90, 0, 0, 1);
      if (j < 4)
        glRotatef (90, 0, 1, 0);
      else
        glRotatef (180, 1, 0, 0);
    }
  glPopMatrix();

  if (c->next)
    {
      /* This leaves rotations on the prevailing matrix stack, but since
         this is a tail-call, that's fine.  Don't blow the matrix stack. */
      glRotatef (c->rot.x, 1, 0, 0);
      glRotatef (c->rot.y, 0, 1, 0);
      glRotatef (c->rot.z, 0, 0, 1);
      glTranslatef (c->pos.x, c->pos.y, c->pos.z);
      c->next->pos = c->pos;
      c->next->rot = c->rot;
      polys += draw_cubes (mi, c->next);
    }

  check_gl_error("cubetwist");
  return polys;
}

void		create_buffers(t_core *c)
{
	glGenVertexArrays(1, &c->otest.vao_id);
	glBindVertexArray(c->otest.vao_id);
	glGenBuffers(2, &c->otest.vbo_ids[0]);
	glBindBuffer(GL_ARRAY_BUFFER, c->otest.vbo_ids[0]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * c->otest.vertices_size * 6,
				c->otest.vertices, GL_STATIC_DRAW);
	glEnableVertexAttribArray(c->position_loc);
	glVertexAttribPointer(c->position_loc, 3, GL_FLOAT, GL_FALSE,
							6 * sizeof(GLfloat), (void *)0);
	glEnableVertexAttribArray(c->color_loc);
	glVertexAttribPointer(c->color_loc, 3, GL_FLOAT, GL_FALSE,
						6 * sizeof(GLfloat), (void *)(3 * sizeof(GLfloat)));
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, c->otest.vbo_ids[1]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
				sizeof(GLushort) * c->otest.indices_size * 3,
				c->otest.indices, GL_STATIC_DRAW);
	check_gl_error(__LINE__);
}