OpenGL: glViewport() testing

//=============================================================================================
// Szamitogepes grafika hazi feladat keret. Ervenyes 2013-tol.
// A //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// sorokon beluli reszben celszeru garazdalkodni, mert a tobbit ugyis toroljuk.
// A beadott program csak ebben a fajlban lehet, a fajl 1 byte-os ASCII karaktereket tartalmazhat.
// Tilos:
// - mast "beincludolni", illetve mas konyvtarat hasznalni
// - faljmuveleteket vegezni (printf is fajlmuvelet!)
// - new operatort hivni az onInitialization függvényt kivéve, a lefoglalt adat korrekt felszabadítása nélkül
// - felesleges programsorokat a beadott programban hagyni
// - tovabbi kommenteket a beadott programba irni a forrasmegjelolest kommentjeit kiveve
// ---------------------------------------------------------------------------------------------
// A feladatot ANSI C++ nyelvu forditoprogrammal ellenorizzuk, a Visual Studio-hoz képesti elteresekrol
// es a leggyakoribb hibakrol (pl. ideiglenes objektumot nem lehet referencia tipusnak ertekul adni)
// a hazibeado portal ad egy osszefoglalot.
// ---------------------------------------------------------------------------------------------
// A feladatmegoldasokban csak olyan gl/glu/glut fuggvenyek hasznalhatok, amelyek
// 1. Az oran a feladatkiadasig elhangzottak ES (logikai AND muvelet)
// 2. Az alabbi listaban szerepelnek:
// Rendering pass: glBegin, glVertex[2|3]f, glColor3f, glNormal3f, glTexCoord2f, glEnd, glDrawPixels
// Transzformaciok: glViewport, glMatrixMode, glLoadIdentity, glMultMatrixf, gluOrtho2D,
// glTranslatef, glRotatef, glScalef, gluLookAt, gluPerspective, glPushMatrix, glPopMatrix,
// Illuminacio: glMaterialfv, glMaterialfv, glMaterialf, glLightfv
// Texturazas: glGenTextures, glBindTexture, glTexParameteri, glTexImage2D, glTexEnvi,
// Pipeline vezerles: glShadeModel, glEnable/Disable a kovetkezokre:
// GL_LIGHTING, GL_NORMALIZE, GL_DEPTH_TEST, GL_CULL_FACE, GL_TEXTURE_2D, GL_BLEND, GL_LIGHT[0..7]
//
// NYILATKOZAT
// ---------------------------------------------------------------------------------------------
// Nev    : Haraszin Peter
// Neptun : O70NT3
// ---------------------------------------------------------------------------------------------
// ezennel kijelentem, hogy a feladatot magam keszitettem, es ha barmilyen segitseget igenybe vettem vagy
// mas szellemi termeket felhasznaltam, akkor a forrast es az atvett reszt kommentekben egyertelmuen jeloltem.
// A forrasmegjeloles kotelme vonatkozik az eloadas foliakat es a targy oktatoi, illetve a
// grafhazi doktor tanacsait kiveve barmilyen csatornan (szoban, irasban, Interneten, stb.) erkezo minden egyeb
// informaciora (keplet, program, algoritmus, stb.). Kijelentem, hogy a forrasmegjelolessel atvett reszeket is ertem,
// azok helyessegere matematikai bizonyitast tudok adni. Tisztaban vagyok azzal, hogy az atvett reszek nem szamitanak
// a sajat kontribucioba, igy a feladat elfogadasarol a tobbi resz mennyisege es minosege alapjan szuletik dontes.
// Tudomasul veszem, hogy a forrasmegjeloles kotelmenek megsertese eseten a hazifeladatra adhato pontokat
// negativ elojellel szamoljak el es ezzel parhuzamosan eljaras is indul velem szemben.
//=============================================================================================

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

#if defined(__APPLE__)
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <GLUT/glut.h>
#else
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#include <windows.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdio.h>
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Innentol modosithatod...

/**
 * 3D Vektor
 */
struct Vector {
  float x, y, z;

  Vector() {
    x = y = z = 0;
  }

  Vector(float x0, float y0, float z0 = 0) {
    x = x0;
    y = y0;
    z = z0;
  }

  Vector operator*(float a) {
    return Vector(x * a, y * a, z * a);
  }

  Vector operator+(const Vector& v) {
    return Vector(x + v.x, y + v.y, z + v.z);
  }

  Vector operator-(const Vector& v) {
    return Vector(x - v.x, y - v.y, z - v.z);
  }

  float operator*(const Vector& v) { // dot product
    return (x * v.x + y * v.y + z * v.z);
  }

  Vector operator%(const Vector& v) { // cross product
    return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
  }

  float Length() {
    return sqrt(x * x + y * y + z * z);
  }
};

/**
 * Spektrum illetve szin
 */
struct Color {
  float r, g, b;

  Color() {
    r = g = b = 0;
  }

  Color(float r0, float g0, float b0) {
    r = r0;
    g = g0;
    b = b0;
  }

  Color operator*(float a) {
    return Color(r * a, g * a, b * a);
  }

  Color operator*(const Color& c) {
    return Color(r * c.r, g * c.g, b * c.b);
  }

  Color operator+(const Color& c) {
    return Color(r + c.r, g + c.g, b + c.b);
  }
};

long time = 0;
long old_time = 0;

const int screenWidth = 600; // alkalmazas ablak felbontasa
const int screenHeight = 600;

Color image[screenWidth*screenHeight]; // egy alkalmazas ablaknyi kep

const float camera_size = 50.0f;

/**
 * Inicializacio, a program futasanak kezdeten, az OpenGL-kontextus letrehozasa utan hivodik meg (ld. main() fv.)
 */
void onInitialization() {
  //  glViewport(0, 0, screenWidth, screenHeight);
  // !!! AZ ALÁBBI HATÁSTALAN!!! EGYSZER legalább szükséges meghívni az onDisplay-ben is
  glViewport(0, 0, screenWidth, screenHeight / 2.0);

  // Peldakent keszitunk egy kepet az operativ memoriaba
  for (int Y = 0; Y < screenHeight; Y++)
    for (int X = 0; X < screenWidth; X++)
      image[Y * screenWidth + X] = Color((float) X / screenWidth, (float) Y / screenHeight, 0);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, camera_size, 0.0, camera_size);

}

bool glViewportAlreadyCalledInOnDisplay = false;

/**
 * Rajzolas, ha az alkalmazas ablak ervenytelenne valik, akkor ez a fuggveny hivodik meg
 */
void onDisplay() {
  glClearColor(0.1f, 0.2f, 0.3f, 1.0f); // torlesi szin beallitasa
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // kepernyo torles

  //  // HA ITT MÁR EGYETLEN EGYSZER MEGHÍVTAM, AKKOR ÉRVÉNYESÜL, nem módosul ez a beállítás
  //  if(!glViewportAlreadyCalledInOnDisplay){
  //    glViewport(0, 0, screenWidth, screenHeight/2.0);
  //    glViewportAlreadyCalledInOnDisplay = true;
  //  }

  // Peldakent atmasoljuk a kepet a rasztertarba
  glDrawPixels(screenWidth, screenHeight, GL_RGB, GL_FLOAT, image);

  // bal also
  glBegin(GL_TRIANGLES);
  glColor3f(0.0f, 0.0f, 1.0f);
  glVertex2f(0.0f, 0.0f);
  glVertex2f(10.0f, 0.0f);
  glVertex2f(10.0f, 10.0f);
  glEnd();


  // kozep
  glBegin(GL_TRIANGLES);
  glColor3f(0.34, 1, 0);
  glVertex2f(10.0f, 20.0f);
  glVertex2f(60.0f, 20.0f);
  glVertex2f(60.0f, 70.0f);
  glEnd();


  // max koordinátában
  glBegin(GL_TRIANGLES);
  glColor3f(1, 0, 1);
  glVertex2f(60.0f, 80.0f);
  glVertex2f(70.0f, 80.0f);
  glVertex2f(70.0f, 90.0f);
  glEnd();

  // jobb fölső sarokban
  glBegin(GL_TRIANGLES);
  glColor3f(1, 0, 0);
  glVertex2f(90.0f, 90.0f);
  glVertex2f(100.0f, 90.0f);
  glVertex2f(100.0f, 100.0f);
  glEnd();


  // jobb alsó sarokban
  glBegin(GL_TRIANGLES);
  glColor3f(0, 0.5, 0);
  glVertex2f(90.0f, 0.0f);
  glVertex2f(100.0f, 0.0f);
  glVertex2f(100.0f, 10.0f);
  glEnd();

  glutSwapBuffers(); // Buffercsere: rajzolas vege

}

/**
 * Billentyuzetesemenyeket lekezelo fuggveny (lenyomas)
 * @param key
 * @param x
 * @param y
 */
void onKeyboard(unsigned char key, int x, int y) {
  switch (key) {
      // d beture rajzold ujra a kepet
    case 'd':
      glutPostRedisplay();
      break;
      // s pressed
    case 's':
    {
      // most ezt az igen egyszerű tilitolit kiszedtem, nehogy plágiumgyanú érjen bárkit :D
    }
      break;
      // space pressed
    case ' ':
    {

    }
      break;
      // Esc pressed
    case 27:
      exit(0);
      break;
    case 'y':
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluOrtho2D(0.0, 100.0, 0.0, 100.0);
      glutPostRedisplay();
      break;
    case 'x':
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluOrtho2D(0.0, 50.0, 0.0, 50.0);
      glutPostRedisplay();
      break;
    case 'c':
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluOrtho2D(25.0, 75.0, 25.0, 75.0);
      glutPostRedisplay();
      break;
    case 'v':
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluOrtho2D(50.0, 100.0, 50.0, 100.0);
      glutPostRedisplay();
      break;
    default:
      break;
  }
}

/**
 * Billentyuzetesemenyeket lekezelo fuggveny (felengedes)
 * @param key
 * @param x
 * @param y
 */
void onKeyboardUp(unsigned char key, int x, int y) {

}

/**
 * Egeresemenyeket lekezelo fuggveny
 * @param button
 * @param state
 * @param x
 * @param y
 */
void onMouse(int button, int state, int x, int y) {
  if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) // A GLUT_LEFT_BUTTON / GLUT_RIGHT_BUTTON illetve GLUT_DOWN / GLUT_UP
    glutPostRedisplay(); // Ilyenkor rajzold ujra a kepet
}

/**
 * Egermozgast lekezelo fuggveny
 * @param x
 * @param y
 */
void onMouseMotion(int x, int y) {

}

/**
 * `Idle' esemenykezelo, jelzi, hogy az ido telik, az Idle esemenyek frekvenciajara csak a 0 a garantalt minimalis ertek
 */
void onIdle() {
  old_time = time;
  time = glutGet(GLUT_ELAPSED_TIME); // program inditasa ota eltelt ido

  glutPostRedisplay(); // felrajzolás
}

// ...Idaig modosithatod
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// A C++ program belepesi pontja, a main fuggvenyt mar nem szabad bantani

int main(int argc, char **argv) {
  glutInit(&argc, argv); // GLUT inicializalasa
  glutInitWindowSize(600, 600); // Alkalmazas ablak kezdeti merete 600x600 pixel
  glutInitWindowPosition(100, 100); // Az elozo alkalmazas ablakhoz képest hol tunik fel
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); // 8 bites R,G,B,A + dupla buffer + melyseg buffer

  glutCreateWindow("Grafika hazi feladat"); // Alkalmazas ablak megszuletik es megjelenik a kepernyon

  glMatrixMode(GL_MODELVIEW); // A MODELVIEW transzformaciot egysegmatrixra inicializaljuk
  glLoadIdentity();
  glMatrixMode(GL_PROJECTION); // A PROJECTION transzformaciot egysegmatrixra inicializaljuk
  glLoadIdentity();

  onInitialization(); // Az altalad irt inicializalast lefuttatjuk

  glutDisplayFunc(onDisplay); // Esemenykezelok regisztralasa
  glutMouseFunc(onMouse);
  glutIdleFunc(onIdle);
  glutKeyboardFunc(onKeyboard);
  glutKeyboardUpFunc(onKeyboardUp);
  glutMotionFunc(onMouseMotion);

  glutMainLoop(); // Esemenykezelo hurok

  return 0;
}