/*
 OpenGL visualization skeleton for displaying bitmap images. Just provide a GenerateImage function.
 Good starting point for all image processing exercises for parallel programming.

 Example of generating bitmaps using GenerateImage and the prepared GLUT OpenGL visualization.
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#ifdef __APPLE__
  #include <GLUT/glut.h>
#else
  #include <GL/freeglut.h>
  #include <GL/freeglut_ext.h>
#endif

typedef struct {
    GLbyte r;
    GLbyte g;
    GLbyte b;
} pixel;

typedef struct{
    int x;
    int y;
} vertex;

   pixel black;

// postupnost bodov, najprv 3 potom 2
//treba vedet zobrazit pole (postupnost)
//vertex[] pole = { {1,2,3}, {4,5}, {6,7}};

#define TEX_SIZE 512
pixel image[TEX_SIZE][TEX_SIZE];

GLuint texture;

int mocnina(int a, int b)
{
    return (int) pow(a,b);
}

void line(vertex a, vertex b)
{
    int i,j;

    for (i=a.x; i<=b.x; i++)
        for (j=a.y; j<=b.y; j++)
            image[i][j] = black;
}


float *multiply (float ucka[4], int matrix[4][4])
{
    float *m = malloc(4 * sizeof(float));
    int i,j;

    m[0] = ucka[0] * matrix[0][0] + ucka[1] * matrix[1][0] + ucka[2] * matrix[2][0] + ucka[3] * matrix[3][0];
    m[1] = ucka[0] * matrix[0][1] + ucka[1] * matrix[1][1] + ucka[2] * matrix[2][1] + ucka[3] * matrix[3][1];
    m[2] = ucka[0] * matrix[0][2] + ucka[1] * matrix[1][2] + ucka[2] * matrix[2][2] + ucka[3] * matrix[3][2];
    m[3] = ucka[0] * matrix[0][3] + ucka[1] * matrix[1][3] + ucka[2] * matrix[2][3] + ucka[3] * matrix[3][3];

    return m;
}

int mul(float m[4], int v[4])
{
    float f = 0;
    int i;

    for (i=0; i<4; i++)
        f += m[i] * v[i];

    return (int)f;
}

void GenerateImage() {

    int x,y;
    float u;

   black.r = 0;
   black.g = 0;
   black.b = 0;

    for (x = 0; x < TEX_SIZE; x++)
        for (y = 0; y < TEX_SIZE; y++)
            image[x][y].r = image[x][y].b = image[x][y].g = 255;

 /*   int Vy1 = 130;
    int Vx1 = 130;
    int Vx2 = 50;
    int Vy2 = 50;


        for (u = 0; u < 1; u += 0.01) {
        Qy = (1 - u) * Vy1 + Vy2;
        Qx = (1 - u) * Vx1 + Vx2;
        image[Qx][Qy] = black;
    }*/

    vertex v0;
    vertex v1;
    vertex v2;
    vertex Q, Q2;

    v0.x = 10;
    v0.y = 500;
    v1.x = 100;
    v1.y = 20;
    v2.x = 500;
    v2.y = 500;

    for (u = 0; u < 1; u += 0.00001) {
        Q.y = (1 - u) * ( (1-u) * v0.y + u * v1.y) + u * ( (1-u) * v1.y + u * v2.y) ;
        Q.x = (1 - u) * ( (1-u) * v0.x + u * v1.x) + u * ( (1-u) * v1.x + u * v2.x) ;
        image[Q.y][Q.x] = black;
    }

    v0.x = 10;
    v0.y = 200;
    v1.x = 250;
    v1.y = 20;
    v2.x = 500;
    v2.y = 200;

    for (u = 0; u < 1; u += 0.00001) {
        Q.y = (1 - u) * ( (1-u) * v0.y + u * v1.y) + u * ( (1-u) * v1.y + u * v2.y) ;
        Q.x = (1 - u) * ( (1-u) * v0.x + u * v1.x) + u * ( (1-u) * v1.x + u * v2.x) ;
        image[Q.y][Q.x] = black;
    }

    v0.x = 200;
    v0.y = 90;
    v1.x = 160;
    v1.y = 60;
    v2.x = 200;
    v2.y = 40;

    for (u = 0; u < 1; u += 0.0001) {
        Q.y = (1 - u) * ( (1-u) * v0.y + u * v1.y) + u * ( (1-u) * v1.y + u * v2.y) ;
        Q.x = (1 - u) * ( (1-u) * v0.x + u * v1.x) + u * ( (1-u) * v1.x + u * v2.x) ;
        image[Q.y][Q.x] = black;
    }

    float ucka[4] = {1,1,1,1};

    float *temp;

    int matrix[4][4] = {-1,3,-1,1,3,-6,3,0,-3,3,0,0,1,0,0,0};

    int verticesX[4] = {100,160,140,100};
    int verticesY[4] = {50,30,20,0};


    for (u = 0; u < 1; u += 0.00001) {

        ucka[0] = u*u*u;
        ucka[1] = u*u;
        ucka[2] = u;
        ucka[3] = 1;

        temp = multiply(ucka, matrix);

        Q.y = mul(temp, verticesY);
        Q.x = mul(temp, verticesX);

       // printf("%.2f %.2f %.2f %.2f\n",temp[0],temp[1],temp[2],temp[3]);

        image[Q.y][Q.x] = black;
    }

}

// Initialize OpenGL state
void init() {
	// Texture setup
    glEnable(GL_TEXTURE_2D);
    glGenTextures( 1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    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_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    // Other
    glClearColor(0,0,0,0);
    gluOrtho2D(-1,1,-1,1);
    glLoadIdentity();
    glColor3f(1,1,1);
}

// Generate and display the image.
void display() {
    // Call user image generation
    GenerateImage();
    // Copy image to texture memory
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEX_SIZE, TEX_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    // Clear screen buffer
    glClear(GL_COLOR_BUFFER_BIT);
    // Render a quad
    glBegin(GL_QUADS);
        glTexCoord2f(1,0); glVertex2f(1,-1);
        glTexCoord2f(1,1); glVertex2f(1,1);
        glTexCoord2f(0,1); glVertex2f(-1,1);
        glTexCoord2f(0,0); glVertex2f(-1,-1);
    glEnd();
    // Display result
    glFlush();
    glutPostRedisplay();
    glutSwapBuffers();
}

// Main entry function
int main(int argc, char ** argv) {
    // Init GLUT
    glutInit(&argc, argv);
    glutInitWindowSize(TEX_SIZE, TEX_SIZE);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutCreateWindow("OpenGL Window");
    // Set up OpenGL state
    init();
    // Run the control loop
    glutDisplayFunc(display);
    glutMainLoop();
    return EXIT_SUCCESS;
}