API tools faq
paste
dorbird

OpenGl

dorbird
Apr 21st, 2015
368
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 32.34 KB | None | 0 0
raw download clone embed print report
  1. #define GLFW_DLL
  2. #include <GLFW/glfw3.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <math.h>
  6. #include <iostream>
  7.  
  8. //#include <glm\glm.hpp>
  9.  
  10. using namespace std;
  11.  
  12. #include "vec3.hpp"
  13. static double alpha_ = 0;
  14. static double beta_ = 0;
  15. static double gamma_= 0;
  16. static double delta_ = 0;
  17. static double epsilon_ = 0;
  18. static double zetta_ = 0;
  19. static double bla_ = 0;
  20. static double dt_ = 1;
  21. static double angleXAxis_=20;
  22. static double angleYAxis_=45;
  23. static double angleZAxis_=0;
  24. static double posX_=0;
  25. static double posY_=0;
  26. static double posZ_=0;
  27. static double posX2_=0;
  28. static double posY2_=0;
  29. static double posZ2_=0;
  30.  
  31. static double a[2] = {80,90};
  32. //static double q[3] = {0, 0, 0};
  33. Vec3 q(0,0,0);
  34. Vec3 theta(M_PI/2, M_PI/2, M_PI/2);
  35.  
  36. static double J[3][3];
  37. static double JTrans[3][3];
  38. static double JTemp[3][3];
  39. static double JTemp2[3][3];
  40. static double result[3][3];
  41.  
  42.  
  43. static Vec3 e1(1,0,0);
  44. static Vec3 e2(0,1,0);
  45. static Vec3 e3(0,0,1);
  46. static Vec3 KAX_(1,0,0);
  47. static Vec3 KAY_(0,1,0);
  48. static Vec3 KAZ_(0,0,1);
  49.  
  50.  
  51. static Vec3 mouseSpeed(0,0,0);
  52.  
  53. static double window_width_ = 1000;
  54. static double window_height_ =1000;
  55. double speed=1;
  56.  
  57. double getDistanceToLine(Vec3 normale, Vec3 punkt, double verschiebung){
  58.         return abs((normale/normale.Length())*punkt-verschiebung);
  59. }
  60.  
  61. double getAngle2D(double Ax, double  Ay, double Bx, double By){
  62.         return atan2(Ay,Ax)-atan2(By,Bx)/M_PI*180;
  63. }
  64. Vec3 rotationUmVector(Vec3 N,double alpha){
  65.         Vec3 result(0,0,0);
  66.  
  67.  
  68.  
  69.         return result;
  70.  
  71. }
  72. Vec3 spiegelungUrsprungsgerade(double alpha, Vec3 V){
  73.         Vec3 result(0,0,0);
  74.         result.p[0]=V.p[0]*cos(2*alpha)+V.p[2]*sin(2*alpha);
  75.         result.p[2]=V.p[0]*sin(2*alpha)+V.p[2]*(-cos(2*alpha));
  76.         return result;
  77. }
  78. Vec3 spiegelungUmNomrale(Vec3 V,Vec3 A){
  79.         Vec3 result = V-2*((A*V)/(A*A))*A;
  80.         return result;
  81. }
  82. void SetMaterialColor(int side, double r, double g, double b) {
  83.   float amb[4], dif[4], spe[4];
  84.   int mat;
  85.  
  86.   dif[0] = r;
  87.   dif[1] = g;
  88.   dif[2] = b;
  89.  
  90.   for(int i = 0; i < 3; i++) {
  91.     amb[i] = .1 * dif[i];
  92.     spe[i] = .5;
  93.   }
  94.   amb[3] = dif[3] = spe[3] = 1.0;
  95.  
  96.   switch(side){
  97.     case 1:     mat = GL_FRONT;
  98.       break;
  99.     case 2:     mat = GL_BACK;
  100.       break;
  101.     default: mat = GL_FRONT_AND_BACK;
  102.   }
  103.  
  104.   glMaterialfv(mat, GL_AMBIENT, amb);
  105.   glMaterialfv(mat, GL_DIFFUSE, dif);
  106.   glMaterialfv(mat, GL_SPECULAR, spe);
  107.   glMaterialf( mat, GL_SHININESS, 20);
  108. }
  109. // draw a sphere composed of triangles
  110. void DrawSphere(const Vec3& ctr, double r){
  111.   int     i, j,
  112.           n1 = 20, n2 = 60;
  113.   Vec3    normal, v1;
  114.   double  a1, a1d = M_PI / n1,
  115.           a2, a2d = M_PI / n2,
  116.           s1, s2,
  117.           c1, c2;
  118.  
  119.   glShadeModel(GL_SMOOTH);
  120.   for(i = 0; i < n1; i++){
  121.     a1 = i * a1d;
  122. //    if(i<=n1*0.5)SetMaterialColor(3,0,0,0);
  123. //    if(i>n1*0.5)SetMaterialColor(3,1,1,1);
  124.  
  125.     glBegin(GL_TRIANGLE_STRIP);
  126.     for(j = 0; j <= n2; j++){
  127.       a2 = (j + .5 * (i % 2)) * 2 * a2d;
  128.  
  129.       s1 = sin(a1);
  130.       c1 = cos(a1);
  131.       s2 = sin(a2);
  132.       c2 = cos(a2);
  133.       normal = c1 * XVec3 + s1 * (c2 * YVec3 + s2 * ZVec3);
  134.       v1 = ctr + r * normal;
  135.       glNormal3dv(normal.p);
  136.       glVertex3dv(v1.p);
  137.  
  138.       s1 = sin(a1 + a1d);
  139.       c1 = cos(a1 + a1d);
  140.       s2 = sin(a2 + a2d);
  141.       c2 = cos(a2 + a2d);
  142.       normal = c1 * XVec3 + s1 * (c2 * YVec3 + s2 * ZVec3);
  143.       v1 = ctr + r * normal;
  144.       glNormal3dv(normal.p);
  145.       glVertex3dv(v1.p);
  146.     }
  147.     glEnd();
  148.   }
  149. }
  150.  
  151. // set viewport transformations and draw objects
  152. void InitLighting() {
  153.   GLfloat lp1[4]  = { 10,  20,  10,  0};
  154.   GLfloat lp2[4]  = { -50,  50, -10,  0};
  155.   GLfloat lp3[4]  = { -5,  -50, -10,  0};
  156.   GLfloat red[49]  = {1.0, .8,  .8,  1};
  157.   GLfloat blue[4] = { .8, .8, 1.0,  1};
  158.  
  159.   glEnable(GL_DEPTH_TEST);
  160.   glDepthFunc(GL_LESS);
  161.   glClearColor(1, 1, 1, 1);
  162.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  163.  
  164.   glShadeModel(GL_SMOOTH);
  165.   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
  166.   glEnable(GL_LIGHTING);
  167.  
  168.   glLightfv(GL_LIGHT1, GL_POSITION, lp1);
  169.   glLightfv(GL_LIGHT1, GL_DIFFUSE,  red);
  170.   glLightfv(GL_LIGHT1, GL_SPECULAR, red);
  171.   glEnable(GL_LIGHT1);
  172.  
  173.   glLightfv(GL_LIGHT2, GL_POSITION, lp2);
  174.   glLightfv(GL_LIGHT2, GL_DIFFUSE,  blue);
  175.   glLightfv(GL_LIGHT2, GL_SPECULAR, blue);
  176.   glEnable(GL_LIGHT2);
  177.  
  178.   glLightfv(GL_LIGHT2, GL_POSITION, lp3);
  179.   glLightfv(GL_LIGHT2, GL_DIFFUSE,  blue);
  180.   glLightfv(GL_LIGHT2, GL_SPECULAR, blue);
  181.   glEnable(GL_LIGHT3);
  182.  
  183.   glClearColor(1, 0, 0, 1);
  184.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  185.  
  186.   // init viewport to canvassize
  187.   glViewport(0, 0, window_width_, window_height_);
  188.  
  189.   // init coordinate system
  190.   glMatrixMode(GL_PROJECTION);
  191.   glLoadIdentity();
  192.   glOrtho(-30, 30, -30, 30, -50, 50);
  193.  
  194. //  double n=10;
  195. //  double f=40;
  196. //  double a=0.5;
  197. //  double fov=90;
  198. //  double l=-1*n*tan((a*fov)/2);
  199. //  double r=f*tan((a*fov)/2);
  200. //  double b=-1*n*tan(fov/2);
  201. //  double t=f*tan(fov/2);
  202. //
  203. //  glFrustum(l, r, b, t, n, f);
  204.  
  205.   glMatrixMode(GL_MODELVIEW);
  206.   glLoadIdentity();
  207. }
  208.  
  209. void DrawQuad(Vec3 a,Vec3 b,Vec3 c,Vec3 d){
  210.         Vec3 norm((a-b)%(a-c));
  211.         norm=norm/norm.Length();
  212.         glBegin(GL_QUADS);
  213.         glNormal3dv(norm.p);
  214.         glVertex3dv(a.p);
  215.         glVertex3dv(b.p);
  216.         glVertex3dv(c.p);
  217.         glVertex3dv(d.p);
  218.         glEnd();
  219. }
  220. void DrawTriangle(Vec3 a,Vec3 b,Vec3 c){
  221.         Vec3 norm((a-b)%(a-c));
  222.         norm=norm/norm.Length();
  223.         glBegin(GL_TRIANGLES);
  224.         glNormal3dv(norm.p);
  225.         glVertex3dv(a.p);
  226.         glVertex3dv(b.p);
  227.         glVertex3dv(c.p);
  228.         glEnd();
  229. }
  230. void DrawFancyQuad(Vec3 a,Vec3 b,Vec3 c,Vec3 d,double pro,double hoehe){
  231.         Vec3 h(0,0,hoehe);
  232.         Vec3 a2=((a-b)*0.1-(a-d)*0.1)+h;
  233.         Vec3 b2=((b-c)*0.1-(b-a)*0.1)+h;
  234.         Vec3 c2=((c-d)*0.1-(c-b)*0.1)+h;
  235.         Vec3 d2=((d-a)*0.1-(d-c)*0.1)+h;
  236.  
  237.         DrawQuad(a,d,c,b);
  238.         DrawQuad(a2,b2,c2,d2);
  239.         DrawQuad(c2,b2,b,c);
  240.         DrawQuad(d2,c2,c,d);
  241.         DrawQuad(a2,d2,d,a);
  242.         DrawQuad(b2,a2,a,b);
  243.  
  244. }
  245. void DrawPyramidOrigami(float seitenlaenge, float angle){
  246.         float hoehe=sqrt(seitenlaenge*seitenlaenge-(seitenlaenge/2)*(seitenlaenge/2));
  247.         Vec3 P1(0,0,0);
  248.         Vec3 P2(seitenlaenge,0,0);
  249.         Vec3 P3(seitenlaenge/2,hoehe,0);
  250.  
  251.         DrawTriangle(P1,P2,P3);
  252.  
  253.         glPushMatrix();
  254.         glTranslatef(0,0,0);
  255.         glRotatef(60,0,0,1);
  256.         glRotated(angle,1,0,0);
  257.         DrawTriangle(P1,P2,P3);
  258.         glPopMatrix();
  259.  
  260.         glPushMatrix();
  261.         glTranslatef(seitenlaenge/2,hoehe,0);
  262.         glRotated(-60,0,0,1);
  263.         glRotated(angle,1,0,0);
  264.         DrawTriangle(P1,P2,P3);
  265.         glPopMatrix();
  266.  
  267.         glPushMatrix();
  268.         glTranslatef(seitenlaenge,0,0);
  269.         glRotated(180,0,0,1);
  270.         glRotated(angle,1,0,0);
  271.         DrawTriangle(P1,P2,P3);
  272.         glPopMatrix();
  273.  
  274. }
  275. void DrawIkosaederOrigami(float seitenlaenge, float angle){
  276.         float hoehe=sqrt(seitenlaenge*seitenlaenge-(seitenlaenge/2)*(seitenlaenge/2));
  277.         Vec3 P1(0,0,0);
  278.         Vec3 P2(seitenlaenge,0,0);
  279.         Vec3 P3(seitenlaenge/2,hoehe,0);
  280.         glTranslatef(0,-3*seitenlaenge,0);
  281.         //glPushMatrix();
  282.         glTranslatef(0,0,0);
  283.         glRotated(0,0,0,1);
  284.         glRotated(angle,1,0,0);
  285.         DrawTriangle(P1,P2,P3);
  286.         //glPopMatrix();
  287.         glPushMatrix();
  288.         glTranslatef(seitenlaenge/2,hoehe,0);
  289.         glRotated(-60,0,0,1);
  290.         glRotated(angle,1,0,0);
  291.         DrawTriangle(P1,P2,P3);
  292.         glPopMatrix();
  293.         //glPushMatrix();
  294.         glTranslatef(0,0,0);
  295.         glRotated(60,0,0,1);
  296.         glRotated(angle,1,0,0);
  297.         DrawTriangle(P1,P2,P3);
  298.         //glPopMatrix();
  299.         glPushMatrix();
  300.         glTranslatef(0,0,0);
  301.         glRotated(60,0,0,1);
  302.         glRotated(angle,1,0,0);
  303.         DrawTriangle(P1,P2,P3);
  304.         glPopMatrix();
  305.  
  306.         //glPushMatrix();
  307.         glTranslatef(seitenlaenge/2,hoehe,0);
  308.         glRotated(-60,0,0,1);
  309.         glRotated(angle,1,0,0);
  310.         DrawTriangle(P1,P2,P3);
  311.         //glPopMatrix();
  312.         glPushMatrix();
  313.         glTranslatef(seitenlaenge/2,hoehe,0);
  314.         glRotated(-60,0,0,1);
  315.         glRotated(angle,1,0,0);
  316.         DrawTriangle(P1,P2,P3);
  317.         glPopMatrix();
  318.         //glPushMatrix();
  319.         glTranslatef(0,0,0);
  320.         glRotated(60,0,0,1);
  321.         glRotated(angle,1,0,0);
  322.         DrawTriangle(P1,P2,P3);
  323.         //glPopMatrix();
  324.         glPushMatrix();
  325.         glTranslatef(0,0,0);
  326.         glRotated(60,0,0,1);
  327.         glRotated(angle,1,0,0);
  328.         DrawTriangle(P1,P2,P3);
  329.         glPopMatrix();
  330.  
  331.         //glPushMatrix();
  332.         glTranslatef(seitenlaenge/2,hoehe,0);
  333.         glRotated(-60,0,0,1);
  334.         glRotated(angle,1,0,0);
  335.         DrawTriangle(P1,P2,P3);
  336.         //glPopMatrix();
  337.         glPushMatrix();
  338.         glTranslatef(seitenlaenge/2,hoehe,0);
  339.         glRotated(-60,0,0,1);
  340.         glRotated(angle,1,0,0);
  341.         DrawTriangle(P1,P2,P3);
  342.         glPopMatrix();
  343.         //glPushMatrix();
  344.         glTranslatef(0,0,0);
  345.         glRotated(60,0,0,1);
  346.         glRotated(angle,1,0,0);
  347.         DrawTriangle(P1,P2,P3);
  348.         //glPopMatrix();
  349.         glPushMatrix();
  350.         glTranslatef(0,0,0);
  351.         glRotated(60,0,0,1);
  352.         glRotated(angle,1,0,0);
  353.         DrawTriangle(P1,P2,P3);
  354.         glPopMatrix();
  355.  
  356.         //glPushMatrix();
  357.         glTranslatef(seitenlaenge/2,hoehe,0);
  358.         glRotated(-60,0,0,1);
  359.         glRotated(angle,1,0,0);
  360.         DrawTriangle(P1,P2,P3);
  361.         //glPopMatrix();
  362.         glPushMatrix();
  363.         glTranslatef(seitenlaenge/2,hoehe,0);
  364.         glRotated(-60,0,0,1);
  365.         glRotated(angle,1,0,0);
  366.         DrawTriangle(P1,P2,P3);
  367.         glPopMatrix();
  368.         //glPushMatrix();
  369.         glTranslatef(0,0,0);
  370.         glRotated(60,0,0,1);
  371.         glRotated(angle,1,0,0);
  372.         DrawTriangle(P1,P2,P3);
  373.         //glPopMatrix();
  374.         glPushMatrix();
  375.         glTranslatef(0,0,0);
  376.         glRotated(60,0,0,1);
  377.         glRotated(angle,1,0,0);
  378.         DrawTriangle(P1,P2,P3);
  379.         glPopMatrix();
  380.  
  381.         //glPushMatrix();
  382.         glTranslatef(seitenlaenge/2,hoehe,0);
  383.         glRotated(-60,0,0,1);
  384.         glRotated(angle,1,0,0);
  385.         DrawTriangle(P1,P2,P3);
  386.         //glPopMatrix();
  387.         glPushMatrix();
  388.         glTranslatef(seitenlaenge/2,hoehe,0);
  389.         glRotated(-60,0,0,1);
  390.         glRotated(angle,1,0,0);
  391.         DrawTriangle(P1,P2,P3);
  392.         glPopMatrix();
  393.         //glPushMatrix();
  394.         glTranslatef(0,0,0);
  395.         glRotated(60,0,0,1);
  396.         glRotated(angle,1,0,0);
  397.         DrawTriangle(P1,P2,P3);
  398.         //glPopMatrix();
  399.         glPushMatrix();
  400.         glTranslatef(0,0,0);
  401.         glRotated(60,0,0,1);
  402.         glRotated(angle,1,0,0);
  403.         DrawTriangle(P1,P2,P3);
  404.         glPopMatrix();
  405. }
  406.  
  407. void DrawTTPOrigami(float seitenlaenge, float angle){//flächen richtig aber es muss verschiedene winkel gefaltet werden
  408.  
  409.         float hoehe=sqrt(seitenlaenge*seitenlaenge-(seitenlaenge/2)*(seitenlaenge/2));
  410.         Vec3 P1(0,0,0);
  411.         Vec3 P2(seitenlaenge,0,0);
  412.         Vec3 P3(seitenlaenge/2,hoehe,0);
  413.         //Root
  414.         //draw tri 1
  415.         DrawTriangle(P1,P2,P3);
  416.         //draw group 2 3 4
  417.         // draw 2
  418.         glPushMatrix();
  419.         glTranslatef(0,0,0);
  420.         glRotated(60,0,0,1);
  421.         glRotated(angle,1,0,0);
  422.         DrawTriangle(P1,P2,P3);
  423.         // draw 3
  424.         glTranslatef(0,0,0);
  425.         glRotated(60,0,0,1);
  426.         glRotated(angle,1,0,0);
  427.         DrawTriangle(P1,P2,P3);
  428.         // draw 4
  429.         glTranslatef(seitenlaenge/2,hoehe,0);
  430.         glRotated(-60,0,0,1);
  431.         glRotated(angle,1,0,0);
  432.         DrawTriangle(P1,P2,P3);
  433.         glPopMatrix();
  434.         // draw 5
  435.         glPushMatrix();
  436.         glTranslatef(seitenlaenge,0,0);
  437.         glRotated(180,0,0,1);
  438.         glRotated(angle,1,0,0);
  439.         DrawTriangle(P1,P2,P3);
  440.         glPopMatrix();
  441.         //draw group 6 7 8 9 10 11 12 13 14
  442.         //draw 6
  443.  
  444.         glTranslatef(seitenlaenge/2,hoehe,0);
  445.         glRotated(-60,0,0,1);
  446.         glRotated(angle,1,0,0);
  447.         DrawTriangle(P1,P2,P3);
  448.  
  449.         //draw group 7 8 9 10
  450.         //draw 7
  451.         glPushMatrix();
  452.         glTranslatef(0,0,0);
  453.         glRotated(60,0,0,1);
  454.         glRotated(angle,1,0,0);
  455.         DrawTriangle(P1,P2,P3);
  456.  
  457.         //draw 10
  458.         glPushMatrix();
  459.         glTranslatef(0,0,0);
  460.         glRotated(60,0,0,1);
  461.         glRotated(angle,1,0,0);
  462.         DrawTriangle(P1,P2,P3);
  463.         glPopMatrix();
  464.         //draw group 8 9
  465.         //draw 8
  466.  
  467.         glTranslatef(seitenlaenge/2,hoehe,0);
  468.         glRotated(-60,0,0,1);
  469.         glRotated(angle,1,0,0);
  470.         DrawTriangle(P1,P2,P3);
  471.         //draw 9
  472.  
  473.         glTranslatef(0,0,0);
  474.         glRotated(60,0,0,1);
  475.         glRotated(angle,1,0,0);
  476.         DrawTriangle(P1,P2,P3);
  477.         glPopMatrix();
  478.         glPopMatrix();
  479.         glPopMatrix();
  480.         glPopMatrix();
  481.         SetMaterialColor(3,1,1,1);
  482.         //draw group 11 12 13 14
  483.         //draw 11
  484.         glPushMatrix();
  485.         glTranslatef(seitenlaenge/2,hoehe,0);
  486.         glRotated(-60,0,0,1);
  487.         glRotated(angle,1,0,0);
  488.         DrawTriangle(P1,P2,P3);
  489.  
  490.         //draw 12
  491.  
  492.         glTranslatef(seitenlaenge/2,hoehe,0);
  493.         glRotated(-60,0,0,1);
  494.         glRotated(angle,1,0,0);
  495.         DrawTriangle(P1,P2,P3);
  496.  
  497.         //draw 13
  498.  
  499.         glTranslatef(0,0,0);
  500.         glRotated(60,0,0,1);
  501.         glRotated(angle,1,0,0);
  502.         DrawTriangle(P1,P2,P3);
  503.  
  504.         //draw 14
  505.  
  506.         glTranslatef(0,0,0);
  507.         glRotated(60,0,0,1);
  508.         glRotated(angle,1,0,0);
  509.         DrawTriangle(P1,P2,P3);
  510.         glPopMatrix();
  511.  
  512.  
  513.  
  514. }
  515. void DrawCubeOrigami(float seitenlaenge, float angle){
  516.         Vec3 P1(0,0,0);
  517.         Vec3 P2(0,seitenlaenge,0);
  518.         Vec3 P3(seitenlaenge,seitenlaenge,0);
  519.         Vec3 P4(seitenlaenge,0,0);
  520.  
  521.         DrawQuad(P1,P2,P3,P4);
  522.         glPushMatrix();
  523.         glTranslatef(0,0,0);
  524.         glRotated(90,0,0,1);
  525.         glRotated(angle,1,0,0);
  526.         DrawQuad(P1,P2,P3,P4);
  527.         glPopMatrix();
  528.  
  529.         glPushMatrix();
  530.         glTranslatef(0,seitenlaenge,0);
  531.         glRotated(0,0,0,1);
  532.         glRotated(angle,1,0,0);
  533.         DrawQuad(P1,P2,P3,P4);
  534.  
  535.         glTranslatef(0,seitenlaenge,0);
  536.         glRotated(0,0,0,1);
  537.         glRotated(angle,1,0,0);
  538.         DrawQuad(P1,P2,P3,P4);
  539.         glPopMatrix();
  540.  
  541.         glPushMatrix();
  542.         glTranslatef(seitenlaenge,seitenlaenge,0);
  543.         glRotated(-90,0,0,1);
  544.         glRotated(angle,1,0,0);
  545.         DrawQuad(P1,P2,P3,P4);
  546.         glPopMatrix();
  547.  
  548.         glPushMatrix();
  549.         glTranslatef(seitenlaenge,0,0);
  550.         glRotated(180,0,0,1);
  551.         glRotated(angle,1,0,0);
  552.         DrawQuad(P1,P4,P3,P4);
  553.         glPopMatrix();
  554.  
  555. }
  556. void DrawCube(double seitenlaenge){
  557.         //Eckpunkte
  558.         Vec3 P1(-seitenlaenge/2,seitenlaenge/2,-seitenlaenge/2);
  559.         Vec3 P2(seitenlaenge/2,seitenlaenge/2,-seitenlaenge/2);
  560.         Vec3 P3(seitenlaenge/2,seitenlaenge/2,seitenlaenge/2);
  561.         Vec3 P4(-seitenlaenge/2,seitenlaenge/2,seitenlaenge/2);
  562.         Vec3 P5(-seitenlaenge/2,-seitenlaenge/2,-seitenlaenge/2);
  563.         Vec3 P6(seitenlaenge/2,-seitenlaenge/2,-seitenlaenge/2);
  564.         Vec3 P7(seitenlaenge/2,-seitenlaenge/2,seitenlaenge/2);
  565.         Vec3 P8(-seitenlaenge/2,-seitenlaenge/2,seitenlaenge/2);
  566.         //Seiten
  567.         DrawQuad(P1,P2,P3,P4);
  568.         DrawQuad(P3,P2,P6,P7);
  569.         DrawQuad(P4,P3,P7,P8);
  570.         DrawQuad(P1,P4,P8,P5);
  571.         DrawQuad(P2,P1,P5,P6);
  572.         DrawQuad(P5,P6,P7,P8);
  573. }
  574. void DrawBox(double seitenlaenge){
  575.         //Eckpunkte
  576.         Vec3 P1(-seitenlaenge/2,seitenlaenge/2,-seitenlaenge/2);
  577.         Vec3 P2(seitenlaenge/2,seitenlaenge/2,-seitenlaenge/2);
  578.         Vec3 P3(seitenlaenge/2,seitenlaenge/2,seitenlaenge/2);
  579.         Vec3 P4(-seitenlaenge/2,seitenlaenge/2,seitenlaenge/2);
  580.         Vec3 P5(-seitenlaenge/2,-seitenlaenge/2,-seitenlaenge/2);
  581.         Vec3 P6(seitenlaenge/2,-seitenlaenge/2,-seitenlaenge/2);
  582.         Vec3 P7(seitenlaenge/2,-seitenlaenge/2,seitenlaenge/2);
  583.         Vec3 P8(-seitenlaenge/2,-seitenlaenge/2,seitenlaenge/2);
  584.         //Die 6 seiten zeichnen
  585.         glPushMatrix();
  586.         glTranslated(-seitenlaenge/2,seitenlaenge/2,-seitenlaenge/2);
  587.         glRotated(beta_, 0, 0, 1);
  588.         DrawQuad(Vec3 (0,0,0),Vec3 (0,0,seitenlaenge),Vec3 (seitenlaenge/2,0,seitenlaenge),Vec3 (seitenlaenge/2,0,0));
  589.         glPushMatrix();
  590.         glTranslated(seitenlaenge/2,0,0);
  591.         glRotated(-2*beta_, 0, 0, 1);
  592.         DrawQuad(Vec3 (0,0,0),Vec3 (0,0,seitenlaenge),Vec3 (seitenlaenge/2,0,seitenlaenge),Vec3 (seitenlaenge/2,0,0));
  593.         glPopMatrix();
  594.         glPopMatrix();
  595.         DrawQuad(P3,P2,P6,P7);
  596.         DrawQuad(P4,P3,P7,P8);
  597.         DrawQuad(P1,P4,P8,P5);
  598.         DrawQuad(P2,P1,P5,P6);
  599.         DrawQuad(P5,P8,P7,P6);
  600. }
  601. void DrawZylinder(double radius,double hoehe,double res){
  602.         int i;
  603.         double a1=2* M_PI /res;
  604.         Vec3 M1(0,0,0);
  605.         Vec3 M2(0,0,hoehe);
  606.         for(i=0; i<=res; i++){
  607.                 Vec3 P0(radius*sin(a1*(i+0)),radius*cos(a1*(i+0)),hoehe);
  608.                 Vec3 P1(radius*sin(a1*(i+0.5)),radius*cos(a1*(i+0.5)),0);
  609.                 Vec3 P2(radius*sin(a1*(i+1)),radius*cos(a1*(i+1)),hoehe);
  610.                 Vec3 P3(radius*sin(a1*(i+1.5)),radius*cos(a1*(i+1.5)),0);
  611.                 DrawTriangle(P0,P1,P2);
  612.                 DrawTriangle(P1,P2,P3);
  613.                 DrawTriangle(P0,M2,P2);
  614.                 DrawTriangle(P3,P1,M1);
  615.         }
  616. }
  617. void DrawKrane(){
  618.         double baseSize=2;
  619.         double radius=1;
  620.         double firstArmLenght=5;
  621.         double secondArmLenght=5;
  622.         double thirdArmLength=5;
  623.         double greifer=3;
  624.         glPushMatrix();
  625.         glRotated(theta.p[0],0,0,1);
  626.         DrawCube(baseSize);
  627.         glTranslated(0,0,baseSize/2);
  628.         glRotated(theta.p[0],0,1,0);
  629.         DrawSphere(Vec3(0,0,0),radius*1.2);
  630.         DrawZylinder(radius,firstArmLenght,100);
  631.         glTranslated(0,0,firstArmLenght);
  632.         glRotated(theta.p[0],0,1,0);
  633.         DrawSphere(Vec3(0,0,0),radius*1.2);
  634.         DrawZylinder(radius,secondArmLenght,100);
  635.  
  636.         glPopMatrix();
  637. }
  638. bool cFCC(double seite,double punkt, double radius){
  639.         return abs(punkt-seite/2)-radius<0;
  640. }
  641. bool cFC2D(double seitenLaenge, double radius, double px, double py){
  642.         //test ob im x schlauch
  643.         if(py<seitenLaenge/2&&py>-seitenLaenge/2){
  644.                 if(abs(px-seitenLaenge/2)-radius<0)return true;
  645.                 if(abs(-px-seitenLaenge/2)-radius<0)return true;
  646.         }
  647.         //test ob im y schlauch
  648.         if(px<seitenLaenge/2&&px>-seitenLaenge/2){
  649.                 if(abs(py-seitenLaenge/2)-radius<0)return true;
  650.                 if(abs(-py-seitenLaenge/2)-radius<0)return true;
  651.         }
  652.         //testen nach Ecken
  653.         if(px>seitenLaenge/2&&py>seitenLaenge/2&&sqrt(pow(px-seitenLaenge/2,2)+pow(py-seitenLaenge/2,2))-radius<0)return true;
  654.         if(px>seitenLaenge/2&&py<-seitenLaenge/2&&sqrt(pow(px-seitenLaenge/2,2)+pow(-py-seitenLaenge/2,2))-radius<0)return true;
  655.         if(px<-seitenLaenge/2&&py<-seitenLaenge/2&&sqrt(pow(-px-seitenLaenge/2,2)+pow(-py-seitenLaenge/2,2))-radius<0)return true;
  656.         if(px<-seitenLaenge/2&&py>seitenLaenge/2&&sqrt(pow(-px-seitenLaenge/2,2)+pow(py-seitenLaenge/2,2))-radius<0)return true;
  657.         return false;
  658. }
  659. bool cFC3D(double seitenLaenge, double radius, double posX, double posY,double posZ){
  660.         int ccounter=0;
  661.         if(cFC2D(seitenLaenge,radius,posX, posY))ccounter++;
  662.         if(cFC2D(seitenLaenge,radius,posZ, posY))ccounter++;
  663.         if(cFC2D(seitenLaenge,radius,posZ, posX))ccounter++;
  664.         if(ccounter>=2)return true;
  665.         return false;
  666. }
  667. double kugelrotation;
  668. void DrawBillardtisch(){
  669.         double x=20+beta_;
  670.         double z=15+alpha_;
  671.         double h=2+delta_;
  672.         double rb=1+gamma_;
  673.         double kugelradius=1+epsilon_;
  674.         double scaling=0.0001;
  675.         double friction=1-0.0000;
  676.  
  677.         Vec3 hoehe(0,h,0);
  678.         Vec3 P1(-x,0,z);
  679.         Vec3 P2(x,0,z);
  680.         Vec3 P3(x,0,-z);
  681.         Vec3 P4(-x,0,-z);
  682.  
  683.         //Boden
  684.         SetMaterialColor(3, 0, 0.5, 0);
  685.         DrawQuad(P1,P2,P3,P4);
  686.         //seiten
  687.         SetMaterialColor(3, 0, 0.6, 0);
  688.         DrawQuad(P1+e2*h,P2+e2*h,P2,P1);
  689.         DrawQuad(P2+e2*h,P3+e2*h,P3,P2);
  690.         DrawQuad(P3+e2*h,P4+e2*h,P4,P3);
  691.         DrawQuad(P4+e2*h,P1+e2*h,P1,P4);
  692.         //rahmen
  693.         SetMaterialColor(3, 0.6, 0.6, 0);
  694.         DrawQuad(P1+e2*h-e1*rb+e3*rb,  P2+e2*h+e1*rb+e3*rb,  P2+e2*h,  P1+e2*h);
  695.         DrawQuad(P2+e2*h+e1*rb+e3*rb,  P3+e2*h+e1*rb-e3*rb,  P3+e2*h,  P2+e2*h);
  696.         DrawQuad(P3+e2*h+e1*rb-e3*rb,  P4+e2*h-e1*rb-e3*rb,  P4+e2*h,  P3+e2*h);
  697.         DrawQuad(P4+e2*h-e1*rb-e3*rb,  P1+e2*h-e1*rb+e3*rb,  P1+e2*h,  P4+e2*h);
  698.  
  699.         DrawQuad(P2+e2*h+e1*rb+e3*rb,  P1+e2*h-e1*rb+e3*rb,  P1-e1*rb+e3*rb,  P2+e1*rb+e3*rb);
  700.         DrawQuad(P3+e2*h+e1*rb-e3*rb,  P2+e2*h+e1*rb+e3*rb,  P2+e1*rb+e3*rb,  P3+e1*rb-e3*rb);
  701.         DrawQuad(P4+e2*h-e1*rb-e3*rb,  P3+e2*h+e1*rb-e3*rb,  P3+e1*rb-e3*rb,  P4-e1*rb-e3*rb);
  702.         DrawQuad(P1+e2*h-e1*rb+e3*rb,  P4+e2*h-e1*rb-e3*rb,  P4-e1*rb-e3*rb,  P1-e1*rb+e3*rb);
  703.  
  704.         DrawQuad(P1-e1*rb+e3*rb,  P2+e1*rb+e3*rb,  P2,  P1);
  705.         DrawQuad(P2+e1*rb+e3*rb,  P3+e1*rb-e3*rb,  P3,  P2);
  706.         DrawQuad(P3+e1*rb-e3*rb,  P4-e1*rb-e3*rb,  P4,  P3);
  707.         DrawQuad(P4-e1*rb-e3*rb,  P1-e1*rb+e3*rb,  P1,  P4);
  708.  
  709.         Vec3 W1(-x,0,z/2);
  710.         Vec3 W2(x,0,z/2);
  711.         DrawQuad(W1,W1+e2*h,W2+e2*h,W2);
  712.  
  713.         Vec3 W3(bla_,0,-z);
  714.         Vec3 W4(-x,0,zetta_);
  715.         DrawQuad(W3,W3+e2*h,W4+e2*h,W4);
  716.  
  717.         Vec3 W5(x,0,z);
  718.         Vec3 W6(-x,0,0);
  719.         DrawQuad(W5,W5+e2*h,W6+e2*h,W6);
  720.  
  721.         Vec3 Pfeiler(x/2+posX2_,0,-z/2+posZ2_);
  722.         double pfeilerRadius=2;
  723.         glPushMatrix();
  724.         glTranslated(Pfeiler.p[0],Pfeiler.p[1],Pfeiler.p[2]);
  725.         glRotated(-90,1,0,0);
  726.         DrawZylinder(pfeilerRadius,h,100);
  727.         glPopMatrix();
  728.  
  729.         mouseSpeed.p[0]=mouseSpeed.p[0]*friction;
  730.         mouseSpeed.p[2]=mouseSpeed.p[2]*friction;
  731.  
  732.         posX_+=mouseSpeed.p[0]*scaling;
  733.         posZ_+=mouseSpeed.p[2]*scaling;
  734.  
  735.         if(abs(posX_-x)-kugelradius<0){
  736.                 mouseSpeed.p[0]=-mouseSpeed.p[0];
  737.         }
  738.         if(abs(-posX_-x)-kugelradius<0){
  739.                 mouseSpeed.p[0]=-mouseSpeed.p[0];
  740.         }
  741.         if(abs(posZ_-z)-kugelradius<0){
  742.                 mouseSpeed.p[2]=-mouseSpeed.p[2];
  743.         }
  744.         if(abs(-posZ_-z)-kugelradius<0){
  745.                 mouseSpeed.p[2]=-mouseSpeed.p[2];
  746.         }
  747.  
  748.         Vec3 W1W2ORTHO((W1-W2).p[2],0,-(W1-W2).p[0]);
  749.         if(getDistanceToLine(W1W2ORTHO,Vec3(posX_,0,posZ_),W1W2ORTHO/W1W2ORTHO.Length()*W1)<=0){
  750.                                 //mouseSpeed=spiegelungUrsprungsgerade(getAngle2D((W1-W2).p[0],(W1-W2).p[2],1,0),mouseSpeed);
  751.                                 mouseSpeed=spiegelungUmNomrale(mouseSpeed,W1W2ORTHO);
  752.                 }
  753.  
  754.         Vec3 W3W4ORTHO((W3-W4).p[2],0,-(W3-W4).p[0]);
  755.         if(getDistanceToLine(W3W4ORTHO,Vec3(posX_,0,posZ_),W3W4ORTHO/W3W4ORTHO.Length()*W3)<=0){
  756.                                 //mouseSpeed=spiegelungUrsprungsgerade(getAngle2D((W3-W4).p[0],(W3-W4).p[2],1,0),mouseSpeed);
  757.                                 mouseSpeed=spiegelungUmNomrale(mouseSpeed,W3W4ORTHO);
  758.                 }
  759.         Vec3 W5W6ORTHO((W5-W6).p[2],0,-(W5-W6).p[0]);
  760.         if(getDistanceToLine(W5W6ORTHO,Vec3(posX_,0,posZ_),W5W6ORTHO/W5W6ORTHO.Length()*W5)<=0){
  761.                                 //mouseSpeed=spiegelungUrsprungsgerade(getAngle2D((W5-W6).p[0],(W5-W6).p[2],1,0),mouseSpeed);
  762.                                 mouseSpeed=spiegelungUmNomrale(mouseSpeed,W5W6ORTHO);
  763.                 }
  764.  
  765.         if((Pfeiler-Vec3(posX_,0,posZ_)).Length()-kugelradius-pfeilerRadius<=0){
  766.                 mouseSpeed=spiegelungUrsprungsgerade(getAngle2D(-(Pfeiler-Vec3(posX_,0,posZ_)).p[2],(Pfeiler-Vec3(posX_,0,posZ_)).p[0],1,0),mouseSpeed);
  767.  
  768.         }
  769.  
  770.  
  771.  
  772.         glPushMatrix();
  773.         kugelrotation+=(sqrt(pow(mouseSpeed.p[0],2)+pow(mouseSpeed.p[2],2))/50)/(2*M_PI*kugelradius);
  774.  
  775.         glTranslated(posX_,kugelradius,posZ_);
  776.         //glRotated(getAngleToXAxis(mouseSpeed.p[0],mouseSpeed.p[2]),0,1,0);
  777.         glRotated(kugelrotation,mouseSpeed.p[2],0,-mouseSpeed.p[0]);
  778.         DrawSphere(Vec3(0,0,0),kugelradius);
  779.         glPopMatrix();
  780.         //getAngleToXAxis(1,0);
  781.  
  782. }
  783. void DrawCubeKugel(double seitenLaenge,double kugelradius){
  784.           DrawCube(seitenLaenge);
  785.           if(cFC3D(seitenLaenge, kugelradius, posX_, posY_,posZ_))SetMaterialColor(3, 1, 0, 0.5);
  786.           DrawSphere(Vec3(posX_,posY_,posZ_),kugelradius);
  787. }
  788.  
  789.  
  790.  
  791. void IK(){
  792.     Vec3 p(50,0,0);
  793.     DrawSphere(p,10);
  794.  
  795.  
  796.  
  797. // TODO!
  798.  
  799.     for(int i = 0; i <= 100000; i++){
  800.  
  801.         Vec3 r=a[0]*Vec3(cos(theta.p[0]) * cos(theta.p[2]),
  802.                         cos(theta.p[0]) * sin(theta.p[2]),
  803.                         sin(theta.p[0]));
  804.  
  805.         Vec3 s=a[1]*Vec3(cos(theta.p[0] + theta.p[1]) * cos(theta.p[2]),
  806.                         cos(theta.p[0] + theta.p[1]) * sin(theta.p[2]),
  807.                         sin(theta.p[0] + theta.p[1]));
  808.  
  809.         Vec3 f = q + r + s;
  810.  
  811.         Vec3 F_theta1(-a[0] * sin(theta.p[0]) * cos(theta.p[2]) - a[1] * sin(theta.p[0] + theta.p[1]) * cos(theta.p[2]),
  812.                         -a[0] * sin(theta.p[0]) * sin(theta.p[2]) - a[1] * sin(theta.p[0] + theta.p[1]) * sin(theta.p[2]),
  813.                          a[0] * cos(theta.p[0]) + a[1] * cos(theta.p[0] + theta.p[1]));
  814.  
  815.  
  816.         Vec3 F_theta2(-a[1] * sin(theta.p[0] + theta.p[1]) * cos(theta.p[2]),
  817.                             -a[1] * sin(theta.p[0] + theta.p[1]) * sin(theta.p[2]),
  818.                             a[1] * cos(theta.p[0] + theta.p[1]));
  819.  
  820.  
  821.         Vec3 F_theta3(-a[0]*cos(theta.p[0]) *sin(theta.p[2]) - a[1]*cos(theta.p[0] + theta.p[1] ) * sin(theta.p[2]),
  822.                             a[0]*cos(theta.p[0]) *cos(theta.p[2]) + a[1]*cos(theta.p[0] + theta.p[1] ) * cos(theta.p[2]),
  823.                             0);
  824.  
  825.  
  826.         J[0][0] = F_theta1.p[0];
  827.         J[1][0] = F_theta1.p[1];
  828.         J[2][0] = F_theta1.p[2];
  829.  
  830.         J[0][1] = F_theta2.p[0];
  831.         J[1][1] = F_theta2.p[1];
  832.         J[2][1] = F_theta2.p[2];
  833.  
  834.         J[0][2] = F_theta3.p[0];
  835.         J[1][2] = F_theta3.p[1];
  836.         J[2][2] = F_theta3.p[2];
  837.  
  838.         JTrans[0][0] = J[0][0];
  839.         JTrans[1][0] = J[0][1];
  840.         JTrans[2][0] = J[0][2];
  841.  
  842.         JTrans[0][1] = J[1][0];
  843.         JTrans[1][1] = J[1][1];
  844.         JTrans[2][1] = J[1][2];
  845.  
  846.         JTrans[0][2] = J[2][0];
  847.         JTrans[1][2] = J[2][1];
  848.         JTrans[2][2] = J[2][2];
  849.  
  850.  
  851.         for(int i = 0; i < 3; i++){
  852.             for(int j = 0; j < 3; j++){
  853.                 JTemp[i][j]=0;
  854.                 for(int k = 0; k < 3; k++){
  855.                     JTemp[i][j] +=J[i][k] *JTrans[k][j];
  856.                 }
  857.             //cout << i << " " << j << " " << JTemp[i][j] << endl;
  858.             }
  859.         }
  860.  
  861.  
  862.         double determinant =  (JTemp[0][0] * (JTemp[1][1] * JTemp[2][2] - JTemp[2][1] * JTemp[1][2]))
  863.                                 - (JTemp[0][1] * (JTemp[1][0] * JTemp[2][2] - JTemp[1][2] * JTemp[2][0]))
  864.                                 + (JTemp[0][2] * (JTemp[1][0] * JTemp[2][1] - JTemp[1][1] * JTemp[2][0]));
  865.  
  866.         double invdet = 1/determinant;
  867.  
  868.         result[0][0] =  (JTemp[1][1]*JTemp[2][2]-JTemp[2][1]*JTemp[1][2])*invdet;
  869.         result[1][0] = -(JTemp[0][1]*JTemp[2][2]-JTemp[0][2]*JTemp[2][1])*invdet;
  870.         result[2][0] =  (JTemp[0][1]*JTemp[1][2]-JTemp[0][2]*JTemp[1][1])*invdet;
  871.         result[0][1] = -(JTemp[1][0]*JTemp[2][2]-JTemp[1][2]*JTemp[2][0])*invdet;
  872.         result[1][1] =  (JTemp[0][0]*JTemp[2][2]-JTemp[0][2]*JTemp[2][0])*invdet;
  873.         result[2][1] = -(JTemp[0][0]*JTemp[1][2]-JTemp[1][0]*JTemp[0][2])*invdet;
  874.         result[0][2] =  (JTemp[1][0]*JTemp[2][1]-JTemp[2][0]*JTemp[1][1])*invdet;
  875.         result[1][2] = -(JTemp[0][0]*JTemp[2][1]-JTemp[2][0]*JTemp[0][1])*invdet;
  876.         result[2][2] =  (JTemp[0][0]*JTemp[1][1]-JTemp[1][0]*JTemp[0][1])*invdet;
  877.  
  878.  
  879.         for(int i = 0; i < 3; i++){
  880.             for(int j = 0; j < 3; j++){
  881.                 JTemp2[i][j]=0;
  882.                 for(int k = 0; k < 3; k++){
  883.                     JTemp2[i][j] +=JTemp[i][k] *result[k][j];
  884.                 }
  885.             //cout << i << " " << j << " " << JTemp2[i][j] << endl;
  886.             }
  887.         }
  888.  
  889.  
  890.         Vec3 dtheta(0,0,0);
  891.         for(int i = 0; i < 3; i++){
  892.             for(int j = 0; j < 3; j++){
  893.                 dtheta.p[i]+=JTemp2[i][j]*(p-f).p[j];
  894.             }
  895.         }
  896.         theta = theta + dtheta;
  897.  
  898.  
  899.     }
  900.     DrawKrane();
  901.  
  902.  
  903.     /*
  904.  
  905.  
  906.         J = [F_theta1  F_theta2  F_theta3] ;
  907.  
  908.         dtheta = (J'*J) \ J' * (p-f);
  909.         theta = theta + dtheta;
  910.  
  911.         */
  912. }
  913.  
  914.  
  915.  
  916.  
  917. // draw the entire scene
  918. void Preview() {
  919.   glMatrixMode(GL_MODELVIEW);
  920.   glLoadIdentity();                                                 // Reset The Current Modelview Matrix
  921.   glTranslated(0, 0, -30.0);      // Move 10 units backwards in z,
  922.                                   // since camera is at origin
  923.  
  924.   //glPushMatrix();
  925.   glRotated(angleXAxis_,0,1,0);
  926.   glRotated(angleYAxis_,1,0,0);
  927.   SetMaterialColor(3, 1, 0.5, 0);
  928.   //DrawKrane();
  929.   //DrawBillardtisch();
  930.   //DrawZylinder(10,10,100);
  931.   //DrawCubeKugel(5,2);
  932.   IK();
  933.  
  934.   glPopMatrix();
  935.  
  936. }
  937. void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
  938. {
  939.     if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS){
  940.  
  941.            double xpos, ypos;
  942.            glfwGetCursorPos(window, &xpos, &ypos);
  943.            mouseSpeed.p[0] = xpos;
  944.            mouseSpeed.p[2] = ypos;
  945.  
  946.     }
  947.  
  948.     if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE){
  949.  
  950.            double xpos, ypos;
  951.            glfwGetCursorPos(window, &xpos, &ypos);
  952.            mouseSpeed.p[0] = xpos - mouseSpeed.p[0];
  953.            mouseSpeed.p[2] = ypos - mouseSpeed.p[2];
  954.  
  955. //         cout << mouseSpeed.p[0] << endl << mouseSpeed.p[2] << endl;
  956. //
  957. //        SpherePos.p[0] = mouseSpeed.p[0];
  958. //        SpherePos.p[2] = mouseSpeed.p[2];
  959.     }
  960.  
  961.  
  962. }
  963. void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
  964. {
  965.           if (key == GLFW_KEY_N)dt_+=0.1;
  966.           if (key == GLFW_KEY_M)dt_-=0.1;
  967.           if (key == GLFW_KEY_UP)angleYAxis_+=dt_;
  968.           if (key == GLFW_KEY_DOWN)angleYAxis_-=dt_;
  969.           if (key == GLFW_KEY_LEFT)angleXAxis_+=dt_;
  970.           if (key == GLFW_KEY_RIGHT)angleXAxis_-=dt_;
  971.           if (key == GLFW_KEY_W)posZ2_+=dt_;
  972.           if (key == GLFW_KEY_S)posZ2_-=dt_;
  973.           if (key == GLFW_KEY_A)posX2_-=dt_;
  974.           if (key == GLFW_KEY_D)posX2_+=dt_;
  975.           if (key == GLFW_KEY_Q)posY2_+=dt_;
  976.           if (key == GLFW_KEY_E)posY2_-=dt_;
  977.       if (key == GLFW_KEY_1)alpha_+=dt_;
  978.       if (key == GLFW_KEY_2)alpha_-=dt_;
  979.       if (key == GLFW_KEY_3)beta_+=dt_;
  980.       if (key == GLFW_KEY_4)beta_-=dt_;
  981.       if (key == GLFW_KEY_5)gamma_+=dt_;
  982.       if (key == GLFW_KEY_6)gamma_-=dt_;
  983.       if (key == GLFW_KEY_7)delta_+=dt_;
  984.       if (key == GLFW_KEY_8)delta_-=dt_;
  985.       if (key == GLFW_KEY_9)epsilon_+=dt_;
  986.       if (key == GLFW_KEY_0)epsilon_-=dt_;
  987.       if (key == GLFW_KEY_B)zetta_+=0.10;
  988.       if (key == GLFW_KEY_V)zetta_-=0.10;
  989.       if (key == GLFW_KEY_F)bla_+=0.1;
  990.       if (key == GLFW_KEY_G)bla_-=0.1;
  991.  
  992.           if (key == GLFW_KEY_O){
  993. //                if(beta_<90)beta_ +=1;
  994.                   beta_ +=1;
  995.           }
  996.           if (key == GLFW_KEY_C){
  997. //                if(beta_>0)beta_ -=5;
  998.                   beta_ -=1;
  999.           }
  1000.           if (key == GLFW_KEY_R){
  1001.                   alpha_=0;
  1002.                   beta_ =0;
  1003.                   gamma_=0;
  1004.                   delta_=0;
  1005.                   epsilon_=0;
  1006.                   zetta_=0;
  1007.                   angleXAxis_=20;
  1008.                   angleYAxis_=45;
  1009.                   posX_=0;
  1010.                   posY_=0;
  1011.                   posZ_=0;
  1012.                   dt_=1;
  1013.                   alpha_=0;
  1014.  
  1015.           }
  1016.           if(key == GLFW_KEY_ESCAPE)exit(0);
  1017. }
  1018.  
  1019.  
  1020. int main() {
  1021.   GLFWwindow* window = NULL;
  1022.  
  1023.   printf("Here we go!\n");
  1024.  
  1025.   if(!glfwInit()){
  1026.     return -1;
  1027.   }
  1028.  
  1029.   window = glfwCreateWindow(window_width_, window_height_,
  1030.                             "Simple 3D Animation", NULL, NULL);
  1031.   if(!window) {
  1032.     glfwTerminate();
  1033.     return -1;
  1034.   }
  1035.  
  1036.   glfwMakeContextCurrent(window);
  1037.  
  1038.   while(!glfwWindowShouldClose(window)) {
  1039.     // switch on lighting (or you don't see anything)
  1040.     InitLighting();
  1041.  
  1042.     // set background color
  1043.     glClearColor(0.8, 0.8, 0.8, 1.0);
  1044.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1045.     //KeyFunctions
  1046.     glfwSetMouseButtonCallback(window, mouse_button_callback);
  1047.     glfwSetKeyCallback(window, key_callback);
  1048.     // draw the scene
  1049.     Preview();
  1050.  
  1051.     // make it appear (before this, it's hidden in the rear buffer)
  1052.     glfwSwapBuffers(window);
  1053.  
  1054.     glfwPollEvents();
  1055.   }
  1056.  
  1057.   glfwTerminate();
  1058.  
  1059.   printf("Goodbye!\n");
  1060.  
  1061.   return 0;
  1062. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!