void GLView::handleIdle()
{
    modcounter++;
    if (!paused) world->update();

    //show FPS
    int currentTime = glutGet( GLUT_ELAPSED_TIME );
    frames++;
    if ((currentTime - lastUpdate) >= 1000) {
        std::pair<int,int> num_herbs_carns = world->numHerbCarnivores();
        sprintf( buf, "FPS: %d NumAgents: %d Carnivors: %d Herbivors: %d Epoch: %d", frames, world->numAgents(), num_herbs_carns.second, num_herbs_carns.first, world->epoch() );
        glutSetWindowTitle( buf );
        frames = 0;
        lastUpdate = currentTime;
    }
    if (skipdraw<=0 && draw) {
        clock_t endwait;
        float mult=-0.005*(skipdraw-1); //ugly, ah well
        endwait = clock () + mult * CLOCKS_PER_SEC ;
        while (clock() < endwait) {}
    }

    if (draw) {
        if (skipdraw>0) {
            if (modcounter%skipdraw==0) renderScene();    //increase fps by skipping drawing
        }
        else renderScene(); //we will decrease fps by waiting using clocks
    }

}

void display()
{
	// Compute the MVP (Model View Projection matrix)
	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
	glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
	glm::mat4 Model = glm::mat4(1.0f);

	{
		glm::mat4 Projection = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / float(FRAMEBUFFER_SIZE.y), 0.1f, 100.0f);
		glm::mat4 MVP = Projection * View * Model;

		glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
		glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);
		renderScene(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), MVP, Texture2DName);
	}

	{
		glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x) / float(Window.Size.y), 0.1f, 100.0f);
		glm::mat4 MVP = Projection * View * Model;

		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		glViewport(0, 0, Window.Size.x, Window.Size.y);
		renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, ColorbufferName);
		glBindSampler(0, SamplerName);
		glGenerateMipmap(GL_TEXTURE_2D);
	}

	glf::checkError("display");
	glf::swapBuffers();
}

void display()
{
	// Compute the MVP (Model View Projection matrix)
	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
	glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
	glm::mat4 Model = glm::mat4(1.0f);
	glm::mat4 MVP = Projection * View * Model;

	glEnable(GL_SCISSOR_TEST);

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glScissor(0, 0, Window.Size.x, Window.Size.y);
	glClear(GL_COLOR_BUFFER_BIT);

	glViewport(0, 0, Window.Size.x, Window.Size.y);
	renderScene(MVP);

	glClearColor(0.0f, 0.5f, 1.0f, 1.0f);
	glScissor(64, 48, 160, 120);
	glClear(GL_COLOR_BUFFER_BIT);

	glViewport(64, 48, 160, 120);
	renderScene(MVP);

	glDisable(GL_SCISSOR_TEST);

	glf::checkError("display");
	glf::swapBuffers();
}

void GM_Debug::updateScene()
{
	renderScene();
	g_engine->resetClipping();
	desktop.DelayedRemove();
	if (killpopup) {
        delete popup;
        popup = NULL;
        killpopup = false;
        renderScene();
	}
}

void display()
{
	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
	glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
	glm::mat4 Model = glm::mat4(1.0f);

	glEnable(GL_SCISSOR_TEST);
	glDisable(GL_FRAMEBUFFER_SRGB);
	glScissorIndexed(0, 0, 0, Window.Size.x, Window.Size.y);
	glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);

	{
		glm::mat4 Projection = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / float(FRAMEBUFFER_SIZE.y), 0.1f, 100.0f);
		glm::mat4 MVP = Projection * View * Model;

		glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y));
		glDisable(GL_FRAMEBUFFER_SRGB);

		glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
		glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
		renderScene(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), MVP, Texture2DName);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}

	{
		glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x) / float(Window.Size.y), 0.1f, 100.0f);
		glm::mat4 MVP = Projection * View * Model;

		glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size.x, Window.Size.y)[0]);

		// Correct display
		glScissorIndexed(0, 0, Window.Size.y / 2 - 1, Window.Size.x, Window.Size.y / 2);
		glEnable(GL_FRAMEBUFFER_SRGB);
		glSamplerParameteri(SamplerName, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT); // GL_DECODE_EXT 
		renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName);
		glDisable(GL_FRAMEBUFFER_SRGB);

		// Incorrected display
		glScissorIndexed(0, 0, 0, Window.Size.x, Window.Size.y / 2);
		glEnable(GL_FRAMEBUFFER_SRGB);
		glSamplerParameteri(SamplerName, GL_TEXTURE_SRGB_DECODE_EXT, GL_DECODE_EXT); // GL_DECODE_EXT 
		renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName);
		glDisable(GL_FRAMEBUFFER_SRGB);
	}

	glf::swapBuffers();
	glf::checkError("display");
}

void display (void)
{
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glDisable(GL_LIGHTING);
	drawAxis();
	glEnable(GL_LIGHTING);
	glColor3f (1., 0, 0.);
	renderScene();
	float ground[4] = {1,0,0,4};
	myShadowMatrix(ground, position);
	glColor3f (0.5, 0.5, 0.5);
	renderScene();
	glFlush ();
}

/*Main Loop*/
void mainLoop() {
  double oldTime = glfwGetTime(), oldFrameTime = glfwGetTime();
  double currentTime, deltaFrame;

  while (!glfwWindowShouldClose(window)) {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /*Delta*/
    currentTime = glfwGetTime();
    delta = (currentTime-oldTime);
    deltaFrame = (currentTime-oldFrameTime);
    nFrames++;

    /* Update scene elements */
    world.update();

    /*Draw*/
    renderReflection();
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    renderScene(true);

    world.camera.calcMovement(keyState);
    world.camera.move(delta, world.sea.seaLevel + 1.0f);

    glfwSwapBuffers(window);
    glfwPollEvents();

    oldTime = currentTime;
  }
}

void DS_Basic_MRT::buildGBuffers()
{
	HRESULT hr;
	//-- G-Buffsers
	SetRenderTarget SRT(m_pD3DDevice, m_posRT);

	IDirect3DSurface9 *pSurfaceZ = NULL;
	hr = m_posRT_Z->GetSurfaceLevel(0, &pSurfaceZ );

	IDirect3DSurface9 *pSurfaceNormal = NULL;
	hr = m_normalRT->GetSurfaceLevel(0, &pSurfaceNormal );
	
	IDirect3DSurface9 *pSurfaceDiffuse= NULL;
	hr = m_diffuseRT->GetSurfaceLevel(0, &pSurfaceDiffuse );
	
	hr = m_pD3DDevice->SetRenderTarget(1, pSurfaceZ);
	hr = m_pD3DDevice->SetRenderTarget(2, pSurfaceNormal);
	hr = m_pD3DDevice->SetRenderTarget(3, pSurfaceDiffuse);

	pSurfaceZ->Release();
	pSurfaceDiffuse->Release();
	pSurfaceNormal->Release();

	hr = m_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0);

	hr = m_pEffect->SetTechnique("init_mrt");
	renderScene();

	hr = m_pD3DDevice->SetRenderTarget(1, NULL);
	hr = m_pD3DDevice->SetRenderTarget(2, NULL);
	hr = m_pD3DDevice->SetRenderTarget(3, NULL);

	//hr = D3DXSaveTextureToFile("D:\\test.dds", D3DXIFF_DDS, m_posRT, NULL);
}

  void draw() {
    glClear(GL_COLOR_BUFFER_BIT);
    gl::MatrixStack & mv = gl::Stacks::modelview();
    gl::MatrixStack & pr = gl::Stacks::projection();

    FOR_EACH_EYE(eye) {
      const PerEyeArg & eyeArgs = eyes[eye];
      frameBuffer.activate();
      glEnable(GL_DEPTH_TEST);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

      gl::Stacks::with_push(pr, mv, [&]{
        mv.preMultiply(eyeArgs.modelviewOffset);
        pr.preMultiply(eyeArgs.projectionOffset);
        renderScene();
      });

      frameBuffer.deactivate();
      glDisable(GL_DEPTH_TEST);

      viewport(eye);
      distortProgram->use();
      glActiveTexture(GL_TEXTURE1);
      eyeArgs.distortionTexture->bind();
      glActiveTexture(GL_TEXTURE0);
      frameBuffer.color->bind();
      quadGeometry->bindVertexArray();
      quadGeometry->draw();
      gl::VertexArray::unbind();
      gl::Program::clear();
    }
  }

  void draw() {
    static int frameIndex = 0;
    static ovrPosef eyePoses[2];
    ++frameIndex;
    ovrHmd_GetEyePoses(hmd, frameIndex, eyeOffsets, eyePoses, nullptr);

    ovrHmd_BeginFrame(hmd, frameIndex);
    glEnable(GL_DEPTH_TEST);

    for (int i = 0; i < 2; ++i) {
      ovrEyeType eye = hmd->EyeRenderOrder[i];

      const ovrRecti & vp = textures[eye].Header.RenderViewport;
      eyeFramebuffers[eye]->Bind();
      oglplus::Context::Viewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h);
      Stacks::projection().top() = eyeProjections[eye];

      MatrixStack & mv = Stacks::modelview();
      mv.withPush([&]{
        // Apply the per-eye offset & the head pose
        mv.top() = glm::inverse(ovr::toGlm(eyePoses[eye])) * mv.top();
        renderScene();
      });
    };
    oglplus::DefaultFramebuffer().Bind(oglplus::Framebuffer::Target::Draw);

    ovrHmd_EndFrame(hmd, eyePoses, textures);
  }

/*Setup a viewport of a first person view from a base.*/
void firstPersonView(float baseRotation, float starRotation, int leftY)
{
    glPushMatrix();
    
    glTranslatef(0.0, 0.0, -2.3);
    /*Rotate on x axis to get the flat ringworld.*/
    glRotatef(-90.0, 1.0, 0.0, 0.0);
    /*Rotate on z to get to a base.*/
    glRotatef(baseRotation, 0.0, 0.0, 1.0);
    
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, 700.0f/350.0f, 0.1f, 100.0f);
    glMatrixMode(GL_MODELVIEW);
    glViewport(0, leftY, 700, 350);

    /*Draw the star background perspective.*/
    glPushMatrix();
    glRotatef(starRotation, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, -2.2);
    drawStarBackground();
    glPopMatrix();

    renderScene();
    glPopMatrix();
}

MainWindow::MainWindow(QWidget *parent)
    : QWidget(parent)
    , m_rendererPanel(new RendererPanel(this))
{

    setlocale(LC_ALL,"C");
    //omp_set_dynamic(1);
    display.resize(512,512);
    layout = new QHBoxLayout();
    layout->addWidget(&display);

    layout->addWidget(m_rendererPanel);

    mainLayout = new QVBoxLayout();
    renderButton = new QPushButton("Render");
    mainLayout->addLayout(layout);
    mainLayout->addWidget(renderButton);

    setLayout(mainLayout);

    m_image = new Image(512, 512);
    display.setImage(m_image);

    connect(renderButton, SIGNAL(clicked()), this, SLOT(renderScene()));
}

void Game::renderScreen()
{
  m_currentCam->setAsCamera();

  renderScene(false);

  PlaneObject *plane = objects->getPlaneObject();
  if(plane != NULL)
  {
    //render plane reticles    
    plane->renderReticle(15.0f, 1.3f);
    plane->renderReticle(8.0f, 1.0f);
    
    if (plane->isPlaneAlive() == false)
    {
      int textY = gRenderer.getScreenY()/2;
      IRectangle rect = IRectangle(0,textY,gRenderer.getScreenX()-1, textY + 30);
      gRenderer.drawText("Press \"Space Bar\" to Respawn",&rect, eTextAlignModeCenter, false);
    }
  }

  gConsole.render();
  if (GameBase::m_renderInfo)
    GameBase::renderInfo();  
}

//extern void update();
void update()
{
	// add any update code here...

	// always re-render the scene..
	renderScene();
}

void onDraw()
{
  /*setViewer O(1)*/
  setMatrixMode(PROJECTION);
  initMatrix();
  setViewer(vertex(eyex, eyey, eyez), vertex(lookx, looky, lookz), vertex(upx, upy, upz));
  setFrustum(10, 10*MAX_H/MAX_W, 4, 25);

  /*createPolygons O(1)*/
  initScene();
  setMatrixMode(MODELVIEW); 
  initMatrix();
  blockWithHole(-5.0,0.0,0.0);
  blockColoured(barx, bary, 0.0);

 
  /*calcData*/
  /*
    For each polygon,
      Go to next triangle if current polygon doesn't face viewer O(1)
      Calculate pixel values of vertices of the triangle O(1)
      clip triangle  //unless you model your scene such that no part ever goes outside the viewport (commentception) O(1)
      For each triangle, O(m*n)
        Add x,y,z position of scan conversion pixels to temp per-polygon table (indexed on y position with min and max x values)
        Also store a min and max x for y=0, y=MAX_Y-1. Add the x,y values for the points in between to the temp table
        Copy temp table to data table with the points between min and max x values filled (in case of conlict, min z value only) O(m*n)
  */

  /*drawPixels*/
  if(q4) innerclipTriangles();
  renderScene();
  glDrawPixels(MAX_W, MAX_H, GL_RGBA, GL_BYTE, data);
  glFlush();
}

void main()
{
	glfwInit();

	// Create a window
	window = glfwCreateWindow(800, 800, "Jarvis March", nullptr, nullptr);
	glfwMakeContextCurrent(window);
	glfwSwapInterval(0);

	// Initializes most things needed before the main loop
	init();

	//Generate the point mesh
	Vertex pointVertex;
	pointVertex.x = pointVertex.y = pointVertex.z = pointVertex.r = 0.0f;
	pointVertex.g = pointVertex.b = pointVertex.a = 1.0f;

	//rope creation
	point = new struct Mesh(1, &pointVertex, GL_POINTS);

	//Scale the rope
	point->scale = glm::scale(point->scale, glm::vec3(1.0f));

	//Generate 25 rigidbodies
	for(int i = 0; i < 25; i++)
	{
		float x = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX)) - 0.5f;
		float y = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX)) - 0.5f;

		bodies.push_back(RigidBody(glm::vec3(0.0f), glm::vec3(x, y, 0.0f)));
	}

	// Enter the main loop.
	while (!glfwWindowShouldClose(window))
	{
		//Check time will update the programs clock and determine if & how many times the physics must be updated
		checkTime();

		// Call the render function.
		renderScene();

		// Swaps the back buffer to the front buffer
		// Remember, you're rendering to the back buffer, then once rendering is complete, you're moving the back buffer to the front so it can be displayed.
		glfwSwapBuffers(window);

		// Checks to see if any events are pending and then processes them.
		glfwPollEvents();
	}

	// After the program is over, cleanup your data!
	glDeleteShader(vertex_shader);
	glDeleteShader(fragment_shader);
	glDeleteProgram(program);
	// Note: If at any point you stop using a "program" or shaders, you should free the data up then and there.

	delete point;

	// Frees up GLFW memory
	glfwTerminate();
}

// The main method.
int main(int argc, char** argv) {
  const char* fileName = "Img";
  // Print usage info.
  if (argc > 4) {
    printf("Usage: %s <optional: output> <optional: chunks chunknr> "
           "<optional: random seed>\n", argv[0]);
    exit(EXIT_FAILURE);
  }
  // Initialize the rand function.
  unsigned int seed = static_cast<unsigned int>(time(NULL));
  if (argc > 1) {
    fileName = argv[1];
  }
  size_t chunks = 1;
  size_t chunkNr = 0;
  if (argc > 3) {
    chunks = atol(argv[2]);
    chunkNr = atol(argv[3]);
  }
  if (argc == 5) {
    seed = static_cast<unsigned int>(atoi(argv[4]));
  }
  printf("Random seed used: %u\n\n", seed);
  srand(seed);

  // Render our test scene.
  renderScene(fileName, chunks, chunkNr);
}

void View::mainLoop() {
	short continuer = 1;
	SDL_Event event;
	SDL_EnableKeyRepeat(40,40);
	SDL_WM_GrabInput(SDL_GRAB_ON);
	SDL_ShowCursor(SDL_DISABLE);
	while ( SDL_PollEvent(&event) ); // empty queue.

	int lastTime = SDL_GetTicks() - 30;
	int currentTime = 0;

	while (continuer) {
		lastTime = currentTime;
		currentTime = SDL_GetTicks();
		while ( SDL_PollEvent(&event) ) {
			switch(event.type) {
			case SDL_QUIT:
				continuer = 0;
				break;
			case SDL_KEYDOWN:
			case SDL_KEYUP:
				camera.keyboard(event.key);
				break;
			case SDL_MOUSEMOTION:
				camera.mouseMotion(event.motion);
				break;
			default:
				break;
			}
		}
		renderScene(lastTime,currentTime);
	}

	SDL_Quit();
}

void updateGL() {
    //Done TODO: also clear the stencil buffer before rendering again //
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    // set viewport dimensions //
    glViewport(0, 0, windowWidth, windowHeight);

    // get projection mat from camera controller //
    glm_ProjectionMatrix.top() = camera.getProjectionMat();
    // upload projection matrix //
    glUniformMatrix4fv(uniformLocations["projection"], 1, false, glm::value_ptr(glm_ProjectionMatrix.top()));

    // init scene graph by cloning the top entry, which can now be manipulated //
    // get modelview mat from camera controller //
    glm_ModelViewMatrix.top() = camera.getModelViewMat();

    // #INFO# render scene //
    renderScene();

    // #INFO# render shadow volume //
    renderShadow();

    // swap renderbuffers for smooth rendering //
    glutSwapBuffers();
}

void render(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

	renderScene();

	glutSwapBuffers();
}