View difference between Paste ID: a3XtuCVh and GFh3iyLA

 #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>
 #endif
 
 struct Vector {
   float x, y, z;
 
   Vector(float v = 0) : x(v), y(v), z(v) { }
   Vector(float x, float y, float z) : x(x), y(y), z(z) { }
-  Vector operator+(const Vector& v) const {
+  Vector operator+(const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }
-    return Vector(x + v.x, y + v.y, z + v.z);
+  Vector operator-(const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
   Vector operator*(const Vector& v) const { return Vector(x * v.x, y * v.y, z * v.z); }
-  Vector operator-(const Vector& v) const {
+  Vector operator/(const Vector& v) const { return Vector(x / v.x, y / v.y, z / v.z); }
-    return Vector(x - v.x, y - v.y, z - v.z);
+  float length() const { return sqrt(x*x + y*y + z*z); }
   void glTranslatef() { ::glTranslatef(x, y, z); }
-  Vector operator*(const Vector& v) const {
+  void glRotatef(float angle) { ::glRotatef(angle, x, y, z); }
-    return Vector(x * v.x, y * v.y, z * v.z);
+  void glScalef() { ::glScalef(x, y, z); }
 };
-  Vector operator/(const Vector& v) const {
+
-    return Vector(x / v.x, y / v.y, z / v.z);
+
 Vector pos_crate(0, 0, -5), pos_left_base(1, 0, 0), pos_right_base(-1, 0, 0), scale_base(1, 1, 3), pos_main_arm(0, 0, -2),
-  float length() const {
+
-    return sqrt(x*x + y*y + z*z);
+
 
 float rot_base = 0, rot_main_arm = 70, rot_lower_arm = -60, rot_finger = 20, rot_finger_relative = 20;
-  void glTranslatef() {
+
-    ::glTranslatef(x, y, z);
+
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  void glRotatef(float angle) {
+
-    ::glRotatef(angle, x, y, z);
+
 
     // Jobb oldali alap
-  void glScalef() {
+
-    ::glScalef(x, y, z);
+
       scale_base.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     // Bal oldali alap
     glPushMatrix(); {
       pos_left_base.glTranslatef();
       scale_base.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     x_axis.glRotatef(rot_main_arm);
     pos_main_arm.glTranslatef();
 
     // Felkar
     glPushMatrix(); {
       scale_main_arm.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     pos_main_arm.glTranslatef();
 
     x_axis.glRotatef(rot_lower_arm);
     pos_lower_arm.glTranslatef();
 
     // Alkar
     glPushMatrix(); {
       scale_lower_arm.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     pos_lower_arm.glTranslatef();
 
     // Csukló
     glPushMatrix(); {
       scale_wrist.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     // Jobb 'ujj'
     glPushMatrix(); {
       z_axis.glRotatef(-rot_finger);
 
       glTranslatef(0, pos_right_finger.y, 0);
 
       glPushMatrix(); {
         glTranslatef(pos_right_finger.x, 0, 0);
         z_axis.glRotatef(-rot_finger_relative);
         scale_finger.glScalef();
         glutSolidCube(1.0f);
       } glPopMatrix();
 
       pos_right_finger.glTranslatef();
       z_axis.glRotatef(rot_finger_relative);
       scale_finger.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
     // Bal 'ujj'
     glPushMatrix(); {
       z_axis.glRotatef(rot_finger);
 
       glTranslatef(0, pos_left_finger.y, 0);
 
       glPushMatrix(); {
         glTranslatef(pos_left_finger.x, 0, 0);
         z_axis.glRotatef(rot_finger_relative);
         scale_finger.glScalef();
         glutSolidCube(1.0f);
       } glPopMatrix();
 
       pos_left_finger.glTranslatef();
       z_axis.glRotatef(-rot_finger_relative);
       scale_finger.glScalef();
       glutSolidCube(1.0f);
     } glPopMatrix();
 
   } glPopMatrix();
 
   // Láda
   glPushMatrix(); {
     pos_crate.glTranslatef();
     glutSolidCube(1.0f);
   } glPopMatrix();
 
   glutSwapBuffers();
 }
 
 enum keys_enum {q, a, w, s, e, d, r, f, num_keys};
 bool is_pressed[num_keys];
 void updateCratePos(float dt);
 
 void onIdle() {
   // Itt nem szükséges a pontos diszkrét idő szimuláció
   static int last_time = glutGet(GLUT_ELAPSED_TIME);
   int curr_time = glutGet(GLUT_ELAPSED_TIME);
   float dt = (curr_time - last_time) / 1000.0f;
   last_time = curr_time;
 
   if(is_pressed[q] && !is_pressed[a])
     rot_finger += 32 * dt;
   else if(!is_pressed[q] && is_pressed[a])
     rot_finger -= 32 * dt;
 
   if(is_pressed[w] && !is_pressed[s])
     rot_lower_arm += 32 * dt;
   else if(!is_pressed[w] && is_pressed[s])
     rot_lower_arm -= 32 * dt;
 
-int sgn(float f) {
+
-  if(fabs(f) > 0.5f) {
+
-    return f / fabs(f);
+
     rot_main_arm -= 32 * dt;
-    return 0;
+
   if(is_pressed[f] && !is_pressed[r])
     rot_base += 32 * dt;
   else if(!is_pressed[f] && is_pressed[r])
     rot_base -= 32 * dt;
 
   updateCratePos(dt);
   glutPostRedisplay();
 }
 
 void onKeyboard(unsigned char key, int, int) {
   switch (key) {
     case 'q': case 'Q':
       is_pressed[q] = true;
       break;
     case 'a': case 'A':
       is_pressed[a] = true;
       break;
     case 'w': case 'W':
       is_pressed[w] = true;
       break;
     case 's': case 'S':
       is_pressed[s] = true;
       break;
     case 'e': case 'E':
       is_pressed[e] = true;
       break;
     case 'd': case 'D':
       is_pressed[d] = true;
       break;
     case 'r': case 'R':
       is_pressed[r] = true;
       break;
     case 'f': case 'F':
       is_pressed[f] = true;
       break;
   }
 }
 
 void onKeyboardUp(unsigned char key, int, int) {
   switch (key) {
     case 'q': case 'Q':
       is_pressed[q] = false;
       break;
     case 'a': case 'A':
       is_pressed[a] = false;
       break;
     case 'w': case 'W':
       is_pressed[w] = false;
       break;
     case 's': case 'S':
       is_pressed[s] = false;
       break;
     case 'e': case 'E':
       is_pressed[e] = false;
       break;
     case 'd': case 'D':
       is_pressed[d] = false;
       break;
     case 'r': case 'R':
       is_pressed[r] = false;
       break;
     case 'f': case 'F':
       is_pressed[f] = false;
       break;
   }
 }
 
 void onInitialization();
 
 void onMouse(int, int, int, int) {}
 
 void onMouseMotion(int, int) {}
 
 int main(int argc, char **argv) {
   glutInit(&argc, argv);
   glutInitWindowSize(600, 600);
   glutInitWindowPosition(100, 100);
   glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
 
   glutCreateWindow("Grafika pelda program");
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
 
   onInitialization();
 
   glutDisplayFunc(onDisplay);
   glutMouseFunc(onMouse);
   glutIdleFunc(onIdle);
   glutKeyboardFunc(onKeyboard);
   glutKeyboardUpFunc(onKeyboardUp);
   glutMotionFunc(onMouseMotion);
 
   glutMainLoop();
 
   return 0;
 }
 
 // Ez a rész szükséges ahhoz, hogy a kockát 3d-ben lásd,
 // de a példa szempontjából most lényegtelen, hogy
 // ténylegesen mit csinál.
 void onInitialization() {
   glEnable(GL_DEPTH_TEST);
   glMatrixMode(GL_PROJECTION);
   gluPerspective(60, 1, 0.1, 20);
   glMatrixMode(GL_MODELVIEW);
   gluLookAt(-9, 6, -6, 9, 0, 0, 0, 1, 0);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   float p[4] = {-2, 4, -1, 0};
   glLightfv(GL_LIGHT0, GL_POSITION, p);
   // float c[4] = {0.0f, 0.4f, 1.0f, 1.0f};
   // glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, c);
 }
 
 Vector pos_left_finger_tip, pos_right_finger_tip, pos_grab;
 
 float crate_speed = 0.0f;
 
 // A példa program egy másik szépséghibája,
 // hogy a láda mefogásához hackelni kell egy kicsit.
 void updateCratePos(float dt) {
   glPushMatrix(); {
     glLoadIdentity();
     y_axis.glRotatef(rot_base);
     x_axis.glRotatef(rot_main_arm);
     pos_main_arm.glTranslatef();
     pos_main_arm.glTranslatef();
     x_axis.glRotatef(rot_lower_arm);
     pos_lower_arm.glTranslatef();
     pos_lower_arm.glTranslatef();
 
     glPushMatrix(); {
       z_axis.glRotatef(-rot_finger);
       glTranslatef(0, pos_right_finger.y, 0);
       pos_right_finger.glTranslatef();
       z_axis.glRotatef(rot_finger_relative);
       scale_finger.glScalef();
       glTranslatef(0, -0.5f, 0);
 
       float mx[16];
       glGetFloatv(GL_MODELVIEW_MATRIX, mx);
       pos_right_finger_tip.x = mx[12];
       pos_right_finger_tip.y = mx[13];
       pos_right_finger_tip.z = mx[14];
 
     } glPopMatrix();
 
     glPushMatrix(); {
       z_axis.glRotatef(rot_finger);
       glTranslatef(0, pos_left_finger.y, 0);
       pos_left_finger.glTranslatef();
       z_axis.glRotatef(-rot_finger_relative);
       scale_finger.glScalef();
       glTranslatef(0, -0.5f, 0);
 
       float mx[16];
       glGetFloatv(GL_MODELVIEW_MATRIX, mx);
       pos_left_finger_tip.x = mx[12];
       pos_left_finger_tip.y = mx[13];
       pos_left_finger_tip.z = mx[14];
     } glPopMatrix();
 
   } glPopMatrix();
 
   pos_grab = (pos_right_finger_tip + pos_left_finger_tip) / 2;
 
   if((pos_right_finger_tip - pos_left_finger_tip).length() < 1.2f
       && (pos_grab - pos_crate).length() < 0.6f) {
     pos_crate = pos_grab;
   } else {
     if(pos_crate.y > 0) {
       crate_speed -= 0.1 * dt;
       pos_crate.y += crate_speed;
     } else {
       crate_speed = 0;
     }
   }
 }