main

float redValue   = 0f;
        float greenValue = 0f;
        float blueValue  = 0f;

        float redValueTemp   = 0f;
        float greenValueTemp = 0f;
        float blueValueTemp  = 0f;

        float[] color_1 = {1.0f, 0.0f, 0.0f};
        float[] color_2 = {0.0f, 1.0f, 0.0f};
        float[] color_3 = {0.0f, 0.0f, 1.0f};
        float[] color_4 = {1.0f, 1.0f, 1.0f};

        float y = 0;
        float x = 0;

        float x_spacing = 0;
        float y_spacing = 0;

        float spacing_speed = 0.01f;
        float spacing_speed_speed = 0.001f;

        boolean q_down = false;
        boolean a_down = false;
        boolean w_down = false;
        boolean s_down = false;
        boolean e_down = false;
        boolean d_down = false;

        boolean showQuad = false;

        float[] stillImage = {};

        glClear(GL_COLOR_BUFFER_BIT);
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();

        while(!glfwWindowShouldClose(window)) {
            /* Keyboard keys */

            //Key Q
            if(glfwGetKey(window, GLFW_KEY_Q) == GL_TRUE) {
                x_spacing += spacing_speed;
                q_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_Q) == GL_FALSE && q_down) {
                q_down = false;
            }

            //Key A
            if(glfwGetKey(window, GLFW_KEY_A) == GL_TRUE && x_spacing - spacing_speed > 0) {
                x_spacing-= spacing_speed;
                a_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_A) == GL_FALSE && a_down) {
                a_down = false;
            }

            //Key W
            if(glfwGetKey(window, GLFW_KEY_W) == GL_TRUE) {
                y_spacing+= spacing_speed;
                w_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_W) == GL_FALSE && w_down) {
                w_down = false;
            }

            //Key S
            if(glfwGetKey(window, GLFW_KEY_S) == GL_TRUE && y_spacing - spacing_speed > 0) {
                y_spacing-= spacing_speed;
                s_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_S) == GL_FALSE && s_down) {
                s_down = false;
            }

            //Key E
            if(glfwGetKey(window, GLFW_KEY_E) == GL_TRUE && !e_down) {
                spacing_speed += spacing_speed_speed;
                e_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_E) == GL_FALSE && e_down) {
                e_down = false;
            }

            //Key D
            if(glfwGetKey(window, GLFW_KEY_D) == GL_TRUE && spacing_speed - spacing_speed_speed > 0 && !d_down) {
                spacing_speed -= spacing_speed_speed;
                d_down = true;
            } else if(glfwGetKey(window, GLFW_KEY_D) == GL_FALSE && d_down) {
                d_down = false;
            }

            //Key Enter
            if(glfwGetKey(window, GLFW_KEY_ENTER) == GL_TRUE && !showQuad) {
                showQuad = true;
            } else if(glfwGetKey(window, GLFW_KEY_ENTER) == GL_FALSE && showQuad) {
                showQuad = false;
            }


            glfwPollEvents();
            glClear(GL_COLOR_BUFFER_BIT);

            if(true) {
                for (int i = 0; i < (windowWidth / (x_spacing + 1)) * (windowHeight / (y_spacing + 1)); i++) {

                    /* First to second color */

                    //Red
                    if (x > 0) {
                        redValue = (color_1[0]) - ((1.0f - color_2[0]) / (windowWidth / x));
                    } else {
                        redValue = color_1[0];
                    }

                    //Green
                    if (x > 0) {
                        greenValue = (color_1[1]) - ((1.0f - color_2[1]) / (windowWidth / x));
                    } else {
                        greenValue = color_1[1];
                    }

                    //Blue
                    if (x > 0) {
                        blueValue = (color_1[2]) - ((1.0f - color_2[2]) / (windowWidth / x));
                    } else {
                        blueValue = color_1[2];
                    }


                    /* Third to forth color */

                    //Red
                    if (x > 0) {
                        redValueTemp = (color_3[0]) - ((1.0f - color_4[0]) / (windowWidth / x));
                    } else {
                        redValueTemp = color_3[0];
                    }

                    //Green
                    if (x > 0) {
                        greenValueTemp = (color_3[1]) - ((1.0f - color_4[1]) / (windowWidth / x));
                    } else {
                        greenValueTemp = color_3[1];
                    }

                    //Blue
                    if (x > 0) {
                        blueValueTemp = (color_3[2]) - ((1.0f - color_4[2]) / (windowWidth / x));
                    } else {
                        blueValueTemp = color_3[2];
                    }


                    /* Combining first and second with third and forth */

                    //Red
                    if (y > 0) {
                        redValue = (redValue) - ((1.0f - redValueTemp) / (windowHeight / y));
                    }

                    //Green
                    if (y > 0) {
                        greenValue = (greenValue) - ((1.0f - greenValueTemp) / (windowHeight / y));
                    }

                    //Blue
                    if (y > 0) {
                        blueValue = (blueValue) - ((1.0f - blueValueTemp) / (windowHeight / y));
                    }


                    /* Correction when starting value is less than finishing */

                    if (redValue < 0) {
                        redValue *= -1.0f;
                    }

                    if (greenValue < 0) {
                        greenValue *= -1.0f;
                    }

                    if (blueValue < 0) {
                        blueValue *= -1.0f;
                    }

                    //Apply color to pixel
                    glColor3f(redValue, greenValue, blueValue);

                    //Draw point
                    drawPoint(x, y);

                    //next x-pixel
                    x += (x_spacing + 1);

                    //When to reset x-pixel to 0 and next y-pixel
                    if (i % (int) ((windowWidth) / (x_spacing + 1)) == 0) {
                        y += (y_spacing + 1);
                        x = 0;
                    }
                }
            }

            //Reset x and y after entire array is done
            y = 0;
            x = 0;

            //Draw a Quad with colors when Enter is pressed
            if(showQuad) {
                drawQuad(color_1, color_3, color_4, color_2);
                System.out.println("Quad showing");
            }

            glFlush();
            glfwSwapBuffers(window);
        }