// Main loop
glfwSwapInterval(1); // Turn VSync on if supported
while( isRunning )
{
    // UPDATE

    float amount = 1.0f / 200.0f;    
    static float accumulator = 0.0f;
    accumulator += timer.GetTime();
    timer.Reset();    
                
    while (accumulator >= amount)
    {    
        glfwPollEvents();

        int x,y;
        glfwGetMousePos( &x, &y );

        MouseMoveWrapper(x, y);
        
        CheckAndCallMousePressWrapper();

        states.back()->Update(amount);        
    
        accumulator -= amount;
    }
        
    // RENDER

    Render();            
}

 

#include 'stdlib.h'    // For malloc() etc.
#include 'stdio.h'     // For printf(), fopen() etc.
#include 'math.h'      // For sin(), cos() etc.
#include 'GL/glfw.h'   // For GLFW, OpenGL and GLU

#pragma comment (lib, "glfw.lib")
#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glu32.lib")

float theFov = 45.0f;
#define RADIANS 0.017453292519943295769236907684886
bool VSync = true;

int theFPS = 0;
int currentFPS = 0;

void SetVSync()
{
    VSync = !VSync;

    glfwSwapInterval(VSync);
}

float UnProjectX(int xValue, float zNear)
{        
    float h = 2.0f*zNear*tan(theFov / 2 * RADIANS);
    float w = 1.33333333f*h;
    return float(xValue)/ 800.0f*  w - w / 2;
}

void clamp(float & value, float min, float max)
{
    if (value  max)
        value = max;
}

void DrawQuad(float x, float y, float w, float h)
{
    glBegin(GL_QUADS);
        glVertex2f(x - w/2, y - h/2);
        glVertex2f(x + w/2, y - h/2);
        glVertex2f(x + w/2, y + h/2);
        glVertex2f(x - w/2, y + h/2);
    glEnd();
}

float padPos[2] = {0.0f, -2.0f};
void UpdatePad(float amount)
{
    int x,y;
    int middleX = 400;
    glfwGetMousePos(&x, &y);

    int pixelsMoved = x - middleX;
    float oglUnitsMoved = UnProjectX(pixelsMoved, 6.0f) -
                          UnProjectX(0.0f, 6.0f);
    
    padPos[0] += oglUnitsMoved;
            
    clamp(padPos[0], -2.7f, 2.7f);

    glfwSetMousePos(middleX, y);
}

void Update()
{
    float amount = 1.0f / 500.0f;    
    static float accumulator = 0.0f;
    float currentTime = glfwGetTime();
    static float lastTime = currentTime;
    accumulator += currentTime - lastTime;
    lastTime = currentTime;
        
    glfwPollEvents();        

    while (accumulator >= amount)
    {
        UpdatePad(amount);    
    
        accumulator -= amount;
    }
}

void Draw( void )
{
    glClear( GL_COLOR_BUFFER_BIT );
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -6.0f);

    DrawQuad(padPos[0], padPos[1], 1.0f, 0.2f);
    
    glfwSwapBuffers();
}


//----------------------------------------------------------------------
// main() - Program entry point
//----------------------------------------------------------------------

void GLFWCALL My_Key_Callback(int key, int action)
{
  if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
    SetVSync();
}
 
int main( int argc, char **argv )
{
    int    ok;             // Flag telling if the window was opened
    int    running;        // Flag telling if the program is running

    // Initialize GLFW
    glfwInit();

    // Open window
    ok = glfwOpenWindow(
        800, 600,          // Width and height of window
        8, 8, 8,           // Number of red, green, and blue bits for color buffer
        8,                 // Number of bits for alpha buffer
        24,                // Number of bits for depth buffer (Z-buffer)
        0,                 // Number of bits for stencil buffer
        GLFW_WINDOW        // We want a desktop window (could be GLFW_FULLSCREEN)
    );

    // If we could not open a window, exit now
    if( !ok )
    {
        glfwTerminate();
        return 0;
    }

    // Set window title
    glfwSetWindowTitle( "My OpenGL program" );

    // Enable sticky keys
    glfwEnable( GLFW_STICKY_KEYS );

    // Main rendering loop

    // Set up projection matrix
    glMatrixMode( GL_PROJECTION );    // Select projection matrix
    glLoadIdentity();                 // Start with an identity matrix
    gluPerspective(                   // Set perspective view
        theFov,                         // Field of view = 65 degrees
        (double)800/(double)600, // Window aspect (assumes square pixels)
        1.0,                          // Near Z clipping plane
        100.0                         // Far Z clippling plane
    );
    
    glMatrixMode(GL_MODELVIEW);

    // Set viewport
    glViewport( 0, 0, 800, 600 );
    
    glfwDisable ( GLFW_MOUSE_CURSOR );    

    glfwSetKeyCallback(My_Key_Callback);

    SetVSync();

    do
    {    
        Update();
        
        Draw();                
        
        currentFPS++;
        
        float currentTime = glfwGetTime();
        static float lastTime = 0; // update din prima
        
        if (currentTime - lastTime >= 1.0f)
        {
            lastTime = currentTime;
            theFPS = currentFPS;
            currentFPS = 0;
            
            char mess[256];
            sprintf(mess,"%s FPS: %d", VSync ? "VSync enabled" : "VSync disabled",
                        theFPS);
            glfwSetWindowTitle(mess);
        }

        // Check if the escape key was pressed, or if the window was closed
        running = !glfwGetKey( GLFW_KEY_ESC ) &&
                  glfwGetWindowParam( GLFW_OPENED );
    }
    while( running );

    // Terminate GLFW
    glfwTerminate();

    // Exit program
    return 0;
}

 

    // Check for new window messages
    while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
    {
        switch( msg.message )
        {
            // QUIT-message (from close window)?
            case WM_QUIT:
                winclosed = GL_TRUE;
                break;

            // Ok, send it to the window message handler
            default:
                DispatchMessage( &msg );
                break;
        }
    }