outdated: 40.Introduction to Physical Simulations

#ifndef GL_FRAMEWORK_INCLUDED
#define GL_FRAMEWORK_INCLUDED

#include <windows.h>

typedef struct {                                   // Structure for keyboard stuff
    BOOL keyDown[256];
} Keys;

typedef struct {                                   // Contains information vital to applications 
    HMODULE hInstance;                             // Application Instance
    const char* className;
} Application;

typedef struct {                                   // Window creation info
    Application* application;
    char* title;
    int width;
    int height;
    int bitsPerPixel;
    BOOL isFullScreen;
} GL_WindowInit;

typedef struct {                                   // Contains information vital to a window
    Keys* keys;
    HWND hWnd;                                     // Windows handle
    HDC hDC;                                       // Device context
    HGLRC hRC;                                     // Rendering context
    GL_WindowInit init;
    BOOL isVisible;                                // Window visiable?
    DWORD lastTickCount;                           // Tick counter
} GL_Window;

void TerminateApplication(GL_Window* window);      // Terminate the application

void ToggleFullscreen(GL_Window* window);          // Toggle fullscreen / Windowed mode

BOOL Initialize(GL_Window* window, Keys* keys);

void Deinitialize(void);

void Update(DWORD milliseconds);

void Draw(void);

#endif

#include <Windows.h>
#include <GL\glew.h>
#include <GL\glut.h>
#include "Previous.h"

#define WM_TOGGLEFULLSCREEN (WM_USER+1)                   // Application define message for toggling 
// between fulscreen / windowed mode
static BOOL g_isProgramLooping;                           // Window creation loop, for fullscreen / windowed mode
static BOOL g_createFullScreen;                           // If true, then create window

void TerminateApplication(GL_Window* window)              // Terminate the application
{
    PostMessage(window->hWnd, WM_QUIT, 0, 0);             // Send a WM_QUIT message
    g_isProgramLooping = FALSE;                           // Stop looping of the program
}

void ToggleFullscreen(GL_Window* window)                  // Toggle fullscreen /windowed mode
{
    PostMessage(window->hWnd, WM_TOGGLEFULLSCREEN, 0, 0); // Send a WM_TOGGLEFULLSCREEN message
}

void ReshapeGL(int width, int height)                     // Reshape the window  when it‘s moved or resized
{
    glViewport(0, 0, (GLsizei)(width), (GLsizei)(height)); // Reset the current viewport
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    // Calcutate the aspect ratio of the window
    gluPerspective(45.0f, (GLfloat)(width) / (GLfloat)(height), 1.0, 100.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

BOOL ChangeScreenResolution(int width, int height, int bitsPerPixel)     // Change the screen resolution
{
    DEVMODE dmScreenSettings;                              // Device mode
    ZeroMemory(&dmScreenSettings, sizeof(DEVMODE));        // Make sure memory is cleared
    dmScreenSettings.dmSize = sizeof(DEVMODE);             // Size of the devmode structure
    dmScreenSettings.dmPelsWidth = width;
    dmScreenSettings.dmPelsHeight = height;
    dmScreenSettings.dmBitsPerPel = bitsPerPixel;
    dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
    if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
        return FALSE;                                      // Display change failed
    }
    return TRUE;
}

BOOL CreateWindowGL(GL_Window* window)
{
    DWORD windowStyle = WS_OVERLAPPEDWINDOW;                // Define window style
    DWORD windowExtendedStyle = WS_EX_APPWINDOW;            // Define the window‘s extended style

    PIXELFORMATDESCRIPTOR pdf = {
        sizeof(PIXELFORMATDESCRIPTOR),                      // Size of this pixel format descriptor
        1,                                                  // Version Number
        PFD_DRAW_TO_WINDOW |                                // Format must support window
        PFD_SUPPORT_OPENGL |                                // Format must support openGL
        PFD_DOUBLEBUFFER,                                   // Must support double buffering
        PFD_TYPE_RGBA,                                      // Request an RGBA format
        window->init.bitsPerPixel,                          // Select color depth
        0, 0, 0, 0, 0, 0,                                   // Color bits ignored
        0,                                                  // No alpha buffer
        0,                                                  // Shift bit ignored
        0,                                                  // No accumulation buffer
        0, 0, 0, 0,                                         // Accumulation bits ignored
        16,                                                 // 16bits Z-buffer (depth buffer)
        0,                                                  // No stencil buffer
        0,                                                  // No auxiliary buffer
        PFD_MAIN_PLANE,                                     // Main drawing layer
        0,                                                  // Reserved
        0, 0, 0                                             // Layer masks ignored
    };
    RECT windowRect = { 0, 0, window->init.width, window->init.height };   // Window coordiantes

    GLuint PixelFormat;

    if (window->init.isFullScreen == TRUE) {
        if (ChangeScreenResolution(window->init.width, window->init.height, window->init.bitsPerPixel) == FALSE)
        {
            // Fullscreen mode failed, run in windowed mode instead
            MessageBox(HWND_DESKTOP, "Mode Switch Failed.\nRuning In Windowed Mode.",
                "Error", MB_OK | MB_ICONEXCLAMATION);
            window->init.isFullScreen = FALSE;
        }
        else {
            ShowCursor(FALSE);
            windowStyle = WS_POPUP;                         // Popup window
            windowExtendedStyle |= WS_EX_TOPMOST;
        }
    }
    else {
        // Adjust window, account for window borders
        AdjustWindowRectEx(&windowRect, windowStyle, 0, windowExtendedStyle);
    }
    // Create Opengl window
    window->hWnd = CreateWindowEx(windowExtendedStyle,      // Extended style
        window->init.application->className,                // Class name
        window->init.title,                                 // Window title
        windowStyle,                                        // Window style
        0, 0,                                               // Window X,Y position
        windowRect.right - windowRect.left,                 // Window width
        windowRect.bottom - windowRect.top,                 // Window height
        HWND_DESKTOP,                                       // Desktop is window‘s parent
        0,                                                  // No menu
        window->init.application->hInstance,                // Pass the window instance
        window);

    if (window->hWnd == 0) {                                // Was window creation a success?
        return FALSE;
    }
    window->hDC = GetDC(window->hWnd);
    if (window->hDC == 0) {
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    PixelFormat = ChoosePixelFormat(window->hDC, &pdf);     // Find a compatible pixel format
    if (PixelFormat == 0) {
        ReleaseDC(window->hWnd, window->hDC);               // Release device context
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    if (SetPixelFormat(window->hDC, PixelFormat, &pdf) == FALSE) {   // Try to set the pixel format
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    window->hRC = wglCreateContext(window->hDC);            // Try to get a rendering context
    if (window->hRC == 0) {
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    // Make the rendering context our current rendering context
    if (wglMakeCurrent(window->hDC, window->hRC) == FALSE) {
        wglDeleteContext(window->hRC);                      //  Delete the rendering context
        window->hRC = 0;
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    ShowWindow(window->hWnd, SW_NORMAL);                    // Make the window visiable
    window->isVisible = TRUE;
    ReshapeGL(window->init.width, window->init.height);     // Reshape our GL window
    ZeroMemory(window->keys, sizeof(Keys));                 // Clear all keys
    window->lastTickCount = GetTickCount();
    return TRUE;
}

BOOL DestoryWindowGL(GL_Window* window)
{
    if (window->hWnd != 0) {
        if (window->hDC != 0) {
            wglMakeCurrent(window->hDC, 0);                 // Setting current active rendering context to zero
            if (window->hRC != 0) {
                wglDeleteContext(window->hRC);
                window->hRC = 0;
            }
            ReleaseDC(window->hWnd, window->hDC);
            window->hDC = 0;
        }
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
    }
    if (window->init.isFullScreen) {
        ChangeDisplaySettings(NULL, 0);                     // Switch back to desktop resolution
        ShowCursor(TRUE);
    }
    return TRUE;
}

// Process window message callback
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Get the window context
    GL_Window* window = (GL_Window*)(GetWindowLong(hWnd, GWL_USERDATA));
    switch (uMsg) {                                         // Evaluate window message
    case WM_SYSCOMMAND:                                     // Intercept system commands
    {
        switch (wParam) {                                   // Check system calls
        case SC_SCREENSAVE:                                 // Screensaver trying to start?
        case SC_MONITORPOWER:                               // Mointer trying to enter powersave?
            return 0;                                           // Prevent form happening
        }
        break;
    }
    return 0;
    case WM_CREATE:
    {
        CREATESTRUCT* creation = (CREATESTRUCT*)(lParam);   // Store window structure pointer
        window = (GL_Window*)(creation->lpCreateParams);
        SetWindowLong(hWnd, GWL_USERDATA, (LONG)(window));
    }
    return 0;

    case WM_CLOSE:
        TerminateApplication(window);
        return 0;

    case WM_SIZE:
        switch (wParam) {
        case SIZE_MINIMIZED:                                 // Was window minimized?
            window->isVisible = FALSE;
            return 0;
        case SIZE_MAXIMIZED:
            window->isVisible = TRUE;
            ReshapeGL(LOWORD(lParam), HIWORD(lParam));
            return 0;
        case SIZE_RESTORED:
            window->isVisible = TRUE;
            ReshapeGL(LOWORD(lParam), HIWORD(lParam));
            return 0;
        }
        break;

    case WM_KEYDOWN:
        if ((wParam >= 0) && (wParam <= 255)) {
            window->keys->keyDown[wParam] = TRUE;            // Set the selected key(wParam) to true
            return 0;
        }
        break;

    case WM_KEYUP:
        if ((wParam >= 0) && (wParam <= 255)) {
            window->keys->keyDown[wParam] = FALSE;
            return 0;
        }
        break;

    case WM_TOGGLEFULLSCREEN:
        g_createFullScreen = (g_createFullScreen == TRUE) ? FALSE : TRUE;
        PostMessage(hWnd, WM_QUIT, 0, 0);
        break;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);        // Pass unhandle message to DefWindowProc
}

BOOL RegisterWindowClass(Application* application)
{
    WNDCLASSEX windowClass;
    ZeroMemory(&windowClass, sizeof(WNDCLASSEX));            // Make sure memory is cleared
    windowClass.cbSize = sizeof(WNDCLASSEX);                 // Size of the windowClass structure
    windowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;  // Redraws the window for any movement / resizing
    windowClass.lpfnWndProc = (WNDPROC)(WindowProc);         // WindowProc handles message
    windowClass.hInstance = application->hInstance;          // Set the instance
    windowClass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE);// Class background brush color
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);       // Load the arrow pointer
    windowClass.lpszClassName = application->className;      // Sets the application className
    if (RegisterClassEx(&windowClass) == 0) {
        MessageBox(HWND_DESKTOP, "RegisterClassEx Failed!", "Error", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;
    }
    return TRUE;
}

int WINAPI WinMain(HINSTANCE hIstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    Application application;
    GL_Window window;
    Keys keys;
    BOOL isMessagePumpActive;
    MSG msg;
    DWORD tickCount;

    application.className = "OpenGL";
    application.hInstance = hIstance;

    ZeroMemory(&window, sizeof(GL_Window));
    window.keys = &keys;                                     // Window key structure
    window.init.application = &application;                  // Window application
    window.init.title = "Resource File";                       // Window title
    window.init.width = 640;                                 // Window width
    window.init.height = 480;                                // Window height
    window.init.bitsPerPixel = 16;                           // Bits per pixel
    window.init.isFullScreen = TRUE;                         // Fullscreen? (set to TRUE)

    ZeroMemory(&keys, sizeof(Keys));
    if (MessageBox(HWND_DESKTOP, "Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",
        MB_YESNO | MB_ICONQUESTION) == IDNO)
    {
        window.init.isFullScreen = FALSE;
    }
    if (RegisterWindowClass(&application) == FALSE)
    {
        MessageBox(HWND_DESKTOP, "Error Registering Window Class!", "Error", MB_OK | MB_ICONEXCLAMATION);
        return -1;
    }
    g_isProgramLooping = TRUE;
    g_createFullScreen = window.init.isFullScreen;
    while (g_isProgramLooping) {                             // Loop until WM_QUIT is received
        window.init.isFullScreen = g_createFullScreen;       // Set init param of window creation to fullscreen?
        if (CreateWindowGL(&window) == TRUE) {               // Was window creation successful?
                                                             // At this point we should have a window that is setup to render OpenGL
            if (Initialize(&window, &keys) == FALSE) {
                TerminateApplication(&window);               // Close window, this will handle the shutdown
            }
            else {
                isMessagePumpActive = TRUE;
                while (isMessagePumpActive == TRUE) {
                    // Success creating window. Check for window messages
                    if (PeekMessage(&msg, window.hWnd, 0, 0, PM_REMOVE) != 0) {
                        if (msg.message != WM_QUIT) {
                            DispatchMessage(&msg);
                        }
                        else {
                            isMessagePumpActive = FALSE;     // Terminate the message pump
                        }
                    }
                    else {
                        if (window.isVisible == FALSE) {
                            WaitMessage();                   // Application is minimized wait for a message
                        }
                        else {
                            // Process application loop
                            tickCount = GetTickCount();      // Get the tick count
                            Update(tickCount - window.lastTickCount); // Update the counter
                            window.lastTickCount = tickCount;// Set last count to current count
                            Draw();                          // Draw screen
                            SwapBuffers(window.hDC);
                        }
                    }
                }
            }
            // Application is finished
            Deinitialize();
            DestoryWindowGL(&window);
        }
        else {
            MessageBox(HWND_DESKTOP, "Error Creating OpenGL Window", "Error", MB_OK | MB_ICONEXCLAMATION);
            g_isProgramLooping = FALSE;
        }
    }
    UnregisterClass(application.className, application.hInstance);    // UnRegister window class
    return 0;
}

#include <math.h>

class Vector3D {
public:
    float x, y, z;

    Vector3D(): x(0), y(0), z(0) {}
    Vector3D(float x, float y, float z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }

    Vector3D& operator= (Vector3D v)
    {
        x = v.x;
        y = v.y;
        z = v.z;
        return *this;
    }

    Vector3D operator+ (Vector3D v)
    {
        return Vector3D(x + v.x, y + v.y, z + v.z);
    }

    Vector3D operator- (Vector3D v)
    {
        return Vector3D(x - v.x, y - v.y, z - v.z);
    }

    Vector3D operator* (float value)
    {
        return Vector3D(x * value, y * value, z * value);
    }

    Vector3D operator/ (float value)
    {
        return Vector3D(x / value, y / value, z / value);
    }

    Vector3D& operator+= (Vector3D v)
    {
        x += v.x;
        y += v.y;
        z += v.z;
        return *this;
    }

    Vector3D& operator-= (Vector3D v)
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        return *this;
    }

    Vector3D& operator*= (Vector3D v)
    {
        x *= v.x;
        y *= v.y;
        z *= v.z;
        return *this;
    }

    Vector3D& operator/= (Vector3D v)
    {
        x /= v.x;
        y /= v.y;
        z /= v.z;
        return *this;
    }

    Vector3D operator- ()
    {
        return Vector3D(-x, -y, -z);
    }

    float length()
    {
        return sqrtf(x*x + y*y + z*z);
    }

    void unitize()                            // Normalizes
    {
        float length = this->length();
        if (length == 0) return;

        x /= length;
        y /= length;
        z /= length;
    }

    Vector3D unit()                        // Normalizes return a new Vector3D
    {
        float length = this->length();
        if (length == 0)
            return *this;
        return Vector3D(x / length, y / length, z / length);
    }
};

class Mass {
public:
    float m;                 // The mass value
    Vector3D pos;            // Position
    Vector3D vel;            // Velocity
    Vector3D force;          // Force

    Mass(float m): m(m) {}

    void applyForce(Vector3D force)
    {
        this->force += force;
    }

    void init()
    {
        force.x = 0;
        force.y = 0;
        force.z = 0;
    }

    void simulate(float dt)                 // New velocity and position
    {
        vel += (force / m) * dt;
        pos += vel * dt;
    }
};

class Simulation {
public:
    int    numOfMasses;
    Mass** masses;

    Simulation(int numOfMasses, float m)                 // Constructor
    {
        this->numOfMasses = numOfMasses;
        masses = new Mass*[numOfMasses];
        for (int i = 0; i < numOfMasses; ++i) {
            masses[i] = new Mass(m);
        }
    }

    virtual void release()                      // Delete
    {
        for (int i = 0; i < numOfMasses; ++i) {
            delete(masses[i]);
            masses[i] = NULL;
        }
        delete(masses);
        masses = NULL;
    }

    Mass* getMass(int index)
    {
        if (index < 0 || index >= numOfMasses) {
            return NULL;
        }
        return masses[index];
    }

    virtual void init()
    {
        for (int i = 0; i < numOfMasses; ++i) {
            masses[i]->init();
        }
    }
    // No implementation because no forces are wanted in this basic container
    // in advanced containers, this method will be overrided and some forces will act on masses
    virtual void solve() {}

    virtual void simulate(float dt)
    {
        for (int i = 0; i < numOfMasses; ++i) {
            masses[i]->simulate(dt);
        }
    }

    virtual void operate(float dt)                     // The complete produce of simulation
    {
        init();
        solve();
        simulate(dt);
    }
};

class ConstantVelocity : public Simulation {
public:
    ConstantVelocity() : Simulation(1, 1.0f)
    {
        masses[0]->pos = Vector3D(0.0f, 0.0f, 0.0f);
        masses[0]->vel = Vector3D(1.0f, 0.0f, 0.0f);
    }
};

class MotionUnderGravitation : public Simulation {
public:
    Vector3D gravitation;
    MotionUnderGravitation(Vector3D gravitation) : Simulation(1, 1.0f)
    {
        this->gravitation = gravitation;
        masses[0]->pos = Vector3D(-10.0f, 0.0f, 0.0f);
        masses[0]->vel = Vector3D(10.0f, 15.0f, 0.0f);
    }

    virtual void solve()
    {
        for (int i = 0; i < numOfMasses; ++i) {
            masses[i]->applyForce(gravitation * masses[i]->m);
        }
    }
};

class MassConnectedWithSpring : public Simulation {
public:
    float springConstant;                      // More the springConstant, stiffer the spring force
    Vector3D connectionPos;                    // The arbitrary constant point that the mass is connected

    MassConnectedWithSpring(float springConstant) :Simulation(1, 1.0f)
    {
        this->springConstant = springConstant;
        connectionPos = Vector3D(0.0f, -5.0f, 0.0f);
        masses[0]->pos = connectionPos + Vector3D(10.0f, 0.0f, 0.0f);
        masses[0]->vel = Vector3D(0.0f, 0.0f, 0.0f);
    }

    virtual void solve()
    {
        for (int i = 0; i < numOfMasses; ++i) {
            Vector3D springVector = masses[i]->pos - connectionPos;
            masses[i]->applyForce(-springVector * springConstant);
        }
    }
};

#include "Physics1.h"

// An object to represent a spring with inner friction binding two masses.
// The spring has a normal length (The length that the spring does not exert any force)
class Spring {
public:
    Mass* mass1;
    Mass* mass2;

    float springConstant;             // A constant to represent the stiffness of the spring
    float springLength;
    float frictionConstant;

    // Constructor
    Spring(Mass* mass1, Mass* mass2, float springConstant, float springLength, float frictionConstant) :
        mass1(mass1), mass2(mass2), springConstant(springConstant), springLength(springLength), 
        frictionConstant(frictionConstant) {}

    void solve()
    {
        Vector3D springVector = mass1->pos - mass2->pos;
        float r = springVector.length();
        Vector3D force;

        if (r != 0) {
            force += (springVector / r) * (r - springLength) * (-springConstant);
        }
        force += -(mass1->vel - mass2->vel) * frictionConstant;

        mass1->applyForce(force);
        mass2->applyForce(-force);
    }
};

class RopeSimulation : public Simulation {
public:
    Spring** springs;

    Vector3D gravitation;
    Vector3D ropeConnectionPos;
    Vector3D ropeConnectionVel;
    
    // A constant to represent how much the ground shall repel the masses
    float groundRepulsionConstant;
    // A constant of friction applied to masses by the ground (sliding of rope)
    float groundFrictionConstant;
    // A constant of absorption friction alppiled to masses by the ground (vertical collisions of rope)
    float groundAbsorptionConstant;

    float groundHeight;
    float airFrictionConstant;              // A constant of air friction-applied to masses

    RopeSimulation(
        int numOfMasses,
        float m,
        float springConstant,
        float springLength,
        float springFrictionConstant,
        Vector3D gravitation,
        float airFrictionConstant,
        float groundRepulsionConstant,
        float groundFrictionConstant,
        float groundAbsorptionConstant,
        float groundHeight
        ) : Simulation(numOfMasses, m) {
        this->gravitation = gravitation;
        this->airFrictionConstant = airFrictionConstant;
        this->groundFrictionConstant = groundFrictionConstant;
        this->groundRepulsionConstant = groundRepulsionConstant;
        this->groundAbsorptionConstant = groundAbsorptionConstant;
        this->groundHeight = groundHeight;

        for (int i = 0; i < numOfMasses; ++i) {
            masses[i]->pos.x = i * springLength;
            masses[i]->pos.y = 0;
            masses[i]->pos.z = 0;
        }
        springs = new Spring*[numOfMasses - 1];

        for (int i = 0; i < numOfMasses - 1; ++i) {
            springs[i] = new Spring(masses[i], masses[i + 1], springConstant, springLength, 
                springFrictionConstant);
        }
    }

    void release()
    {
        Simulation::release();
        for (int i = 0; i < numOfMasses - 1; ++i) {
            delete(springs[i]);
            springs[i] = NULL;
        }
        delete(springs);
        springs = NULL;
    }

    void solve()
    {
        for (int i = 0; i < numOfMasses - 1; ++i) {
            springs[i]->solve();
        }
        for (int i = 0; i < numOfMasses; ++i) {
            masses[i]->applyForce(gravitation * masses[i]->m);          // Gravitation
            masses[i]->applyForce(-masses[i]->vel * airFrictionConstant);    // Air Friction

            if (masses[i]->pos.y < groundHeight) {
                Vector3D v = masses[i]->vel;             // Velocity
                v.y = 0;                                 // Omit the velocity component in y direction

                // The velocity in y direction is omited because we will apply a friction force to create
                // a sliding effect. Sliding is parallel to the ground. Velocity in y direction will be used
                // in the absorption effect.
                masses[i]->applyForce(-v * groundFrictionConstant);
                v = masses[i]->vel;
                v.x = 0;               // Omit
                v.z = 0;

                if (v.y < 0) {      // Absorb energy only when a mass collides towards the ground
                    masses[i]->applyForce(-v * groundAbsorptionConstant);
                }

                // The ground shall repel a mass like a spring.
                Vector3D force = Vector3D(0, groundRepulsionConstant, 0) * (groundHeight - masses[i]->pos.y);
                masses[i]->applyForce(force);
            }
        }
    }

    void simulate(float dt)              // Overriden
    {
        Simulation::simulate(dt);
        ropeConnectionPos += ropeConnectionVel * dt;   // Iterate the positon of ropeConnectionPos

        if (ropeConnectionPos.y < groundHeight) {
            ropeConnectionPos.y = groundHeight;
            ropeConnectionVel.y = 0;
        }

        masses[0]->pos = ropeConnectionPos;
        masses[0]->vel = ropeConnectionVel;
    }

    void setRopeConnectionVel(Vector3D ropeConnectionVel)
    {
        this->ropeConnectionVel = ropeConnectionVel;
    }
};

#include <Windows.h>
#include <GL/glew.h>
#include <GL/glut.h>
#include <GL/GLUAX.H>
#include <math.h>
#include <stdio.h>
#include "Previous.h"
#include "Physics2.h"

#pragma comment(lib, "legacy_stdio_definitions.lib")

#ifndef CDS_FULLSCREEN
#define CDS_FULLSCREEN 4
#endif

GL_Window* g_window;
Keys* g_keys;

RopeSimulation* ropeSimulation = new RopeSimulation(
    80,                 // Particles
    0.05f,              // Each particle has a weight of 50 grams
    1000.0f,            // SpringConstant
    0.05f,              // Normal length of string in the rope
    0.2f,               // Spring inner friction constant
    Vector3D(0, -9.81f, 0),  // Gravitational acceleration
    0.02f,              // Air friction constant
    100.0f,             // Ground repel constant
    0.2f,               // Ground slide friction
    2.0f,               // Ground absoption constant
    -1.5f);             // Height of ground

BOOL Initialize(GL_Window* window, Keys* keys)
{
    g_window = window;
    g_keys = keys;

    ropeSimulation->getMass(ropeSimulation->numOfMasses - 1)->vel.z = 10.0f;

    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
    glClearDepth(1.0f);
    glShadeModel(GL_SMOOTH);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    return TRUE;
}

void Deinitialize(void)
{
    ropeSimulation->release();
    delete(ropeSimulation);
    ropeSimulation = NULL;
}

void Update(DWORD milliseconds)
{
    if (g_keys->keyDown[VK_ESCAPE] == TRUE)
        TerminateApplication(g_window);
    if (g_keys->keyDown[VK_F1] == TRUE)
        ToggleFullscreen(g_window);

    Vector3D ropeConnectionVel;
    if (g_keys->keyDown[VK_RIGHT] == TRUE)
        ropeConnectionVel.x += 3.0f;
    if (g_keys->keyDown[VK_LEFT] == TRUE)
        ropeConnectionVel.x -= 3.0f;
    if (g_keys->keyDown[VK_UP] == TRUE)
        ropeConnectionVel.z -= 3.0f;
    if (g_keys->keyDown[VK_DOWN] == TRUE)
        ropeConnectionVel.z += 3.0f;
    if (g_keys->keyDown[VK_HOME] == TRUE)
        ropeConnectionVel.y += 3.0f;
    if (g_keys->keyDown[VK_END] == TRUE)
        ropeConnectionVel.y -= 3.0f;

    ropeSimulation->setRopeConnectionVel(ropeConnectionVel);

    float dt = milliseconds / 1000.0f;
    float maxPossible_dt = 0.002f;                     // Maximum possible dt is 0.002 seconds
    
    int numOfIteration = (int)(dt / maxPossible_dt) + 1;
    if (numOfIteration != 0) {
        dt /= numOfIteration;
    }

    for (int i = 0; i < numOfIteration; ++i) {
        ropeSimulation->operate(dt);
    }
}

void Draw(void)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0, 0, 4, 0, 0, 0, 0, 1, 0);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glBegin(GL_QUADS);
        glColor3ub(0, 0, 255);
        glVertex3f(20, ropeSimulation->groundHeight, 20);
        glVertex3f(-20, ropeSimulation->groundHeight, 20);
        glColor3ub(0, 0, 0);
        glVertex3f(-20, ropeSimulation->groundHeight, -20);
        glVertex3f(20, ropeSimulation->groundHeight, -20);
    glEnd();
    // Shadow of rope
    glColor3ub(0, 0, 0);
    for (int i = 0; i < ropeSimulation->numOfMasses - 1; ++i) {
        Mass* mass1 = ropeSimulation->getMass(i);
        Vector3D* pos1 = &mass1->pos;

        Mass* mass2 = ropeSimulation->getMass(i + 1);
        Vector3D* pos2 = &mass2->pos;

        glLineWidth(2);
        glBegin(GL_LINES);
            glVertex3f(pos1->x, ropeSimulation->groundHeight, pos1->z);
            glVertex3f(pos2->x, ropeSimulation->groundHeight, pos2->z);
        glEnd();
    }

    glColor3ub(255, 255, 0);
    for (int i = 0; i < ropeSimulation->numOfMasses - 1; ++i) {
        Mass* mass1 = ropeSimulation->getMass(i);
        Vector3D* pos1 = &mass1->pos;

        Mass* mass2 = ropeSimulation->getMass(i + 1);
        Vector3D* pos2 = &mass2->pos;

        glLineWidth(4);
        glBegin(GL_LINES);
            glVertex3f(pos1->x, pos1->y, pos1->z);
            glVertex3f(pos2->x, pos2->y, pos2->z);
        glEnd();
    }
    glFlush();
}