API tools faq
paste
dorbird

CG OpenGL

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