开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
hv_ARtk_demo.cpp
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：17k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

hv_ARtk_demo.cpp：源码内容
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <GL/glut.h>
  4. #include <vector>
  5. #include <float.h>
  6. #include "hv_ARtk_demo.h"
  7. #include <math.h>
  9. bool render_select( int x, int y, int* selected,  
  10.     d3* selected_win);
  11. //void unproject(double winx, double winy, double winz,
  12. //        double* objx, double* objy, double* objz);
  13. void drawBullseye( double radius, int rings );
  16. /*
  17.  * store OpenGL state matrices
  18.  */
  19. extern GLint viewport[ 4 ];
  21. // for unproject
  22. GLdouble modelview[ 16 ];
  23. GLdouble projection[ 16 ];
  24. GLdouble selected_view[16];
  27. /*
  28.  * UI state
  29.  */
  30. bool dragging = false;
  31. bool rotating = false;
  32. bool hovering = false;
  33. bool show_ptr = false;
  34.  
  35. /*
  36.  * information about selected point - id of object,
  37.  * window coordinates and coordinates relative to the multi-marker
  38.  * (anchor)
  39.  */
  40. int selected = -1;
  41. d3 selected_win;
  42. d3 selected_rel;
  43. d3 selected_world; // relative to modelview
  45. double anchor[16];
  46. bool anchor_visible = false;
  47. std::vector<bool> floater_visible;
  48. typedef std::vector<double> dvec;
  49. typedef std::vector<dvec> dmat;
  50. dmat floaterpositions;
  52. const unsigned int IDX_ANCHORED_LIGHT = 1;
  53. const unsigned int IDX_FLOATER_LIGHT = 3;
  55. //----------------------------------------------------------------------
  58. /*
  59.  * information about a set of objects
  60.  */
  61. std::vector< d3 > positions;
  62. std::vector< d3 > rotations;
  63. std::vector< d3 > colors;
  65. // the first num_anchored objects are positioned relative to
  66. // the "anchor" (multiMarker), the others on one floater each
  67. unsigned int num_anchored = 0; 
  69. d3 ptr_col;
  71. int ptr_x, ptr_y;
  72. int hv_pointer_dist = 120;
  74. /*
  75.  * assign positions and colors of objects and lights
  76.  */
  77. void initObjs ()
  78. {
  79.   positions.clear(); 
  80.   rotations.clear();
  81.   colors.clear();
  83.   // anchored object
  84.   d3 p;
  85.   p.x = 50; p.y = -50; p.z = 30;
  86.   positions.push_back( p );
  88.   // object representing the anchored light
  89.   p.x = 0; p.y = 200; p.z = 80;
  90.   positions.push_back( p );
  92.   num_anchored = positions.size();
  94.   // floating object
  95.   p.x = 70; p.y = -80; p.z = 30;
  96.   positions.push_back( p );
  98.   // object representing the floating light
  99.   p.x = 0; p.y = 0; p.z = 40;
  100.   positions.push_back( p );
  102.   positions.push_back( p );
  103.   positions.push_back( p );
  104.   positions.push_back( p );
  105.   positions.push_back( p );
  106.   positions.push_back( p );
  107.   positions.push_back( p );
  109.   // we're being lazy - these are too many vector entries for
  110.   // floaters, but that way we don't have to translate indices
  111.   floaterpositions.reserve(positions.size());
  112.   floater_visible.reserve(positions.size());
  114.   //  srand((unsigned)time(NULL));
  115.   for( unsigned int i = 0 ; i < positions.size() ; ++i )
  116.   {
  117.     d3 c;
  118.     c.x = (float)rand() / ( float )RAND_MAX;
  119.     c.y = (float)rand() / ( float )RAND_MAX;
  120.     c.z = (float)rand() / ( float )RAND_MAX;
  122.     colors.push_back( c );
  124.     d3 r;
  125.     r.x = r.y = r.z = 0;
  126.     rotations.push_back( r );
  128.     dvec d16( 16 );
  129.     floaterpositions.push_back( d16 );
  130.     floater_visible.push_back(false);
  131.   }
  133.   // pointer
  134.   ptr_col.x = 0;
  135.   ptr_col.y = 0;
  136.   ptr_col.z = 255;
  137. }
  140. /*
  141.  * draw teapots (with names for selection)
  142.  */
  143. void drawObjs ()
  144. {
  145.   glMatrixMode( GL_MODELVIEW );
  147.   // for unproject
  148.   glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
  149.   glGetDoublev( GL_PROJECTION_MATRIX, projection );
  150.   
  151.   float spec[] = {1, 1, 1, 1};
  152.   float shine[] = {70};
  153.   glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
  154.   glMaterialfv(GL_FRONT, GL_SHININESS, shine);
  156.   if (anchor_visible) {
  157.     glPushMatrix();
  158.     glMultMatrixd(anchor);
  159.     
  160.     for( unsigned int i = 0 ; i < num_anchored ; ++i )
  161.     {
  162.       glPushMatrix();
  163.         if (selected==(int)i) {
  164.   glGetDoublev( GL_MODELVIEW_MATRIX, selected_view );
  165. }
  166. float col[] = {colors[ i ].x, colors[ i ].y, colors[ i ].z, 1};
  167. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, col);
  169. glLoadName( i + 1 );
  170. if (i==IDX_ANCHORED_LIGHT) {
  171.   // direct lamp shade towards teapot
  172.   glTranslated( positions[i].x, positions[i].y, positions[i].z );
  174. #if 0
  175.   double upx = 0, upy = 1, upz = 1;
  176.   // todo : should check for singularity here
  177.   GLdouble curr[16];
  178.   glGetDoublev( GL_MODELVIEW_MATRIX, curr );
  179.   double w0x, w0y, w0z;
  180.   {  // world coordinates for object 0
  181.     double x = positions[0].x;
  182.     double y = positions[0].y;
  183.     double z = positions[0].z;
  184.     w0x = curr[0]*x + curr[4]*y + curr[8]*z + curr[12]*1;
  185.     w0y = curr[1]*x + curr[5]*y + curr[9]*z + curr[13]*1;
  186.     w0z = curr[2]*x + curr[6]*y + curr[10]*z + curr[14]*1;
  187.   }
  188.   //w0x = curr[13]+positions[0].x;
  189.   //w0y = curr[14]+positions[0].y;
  190.   //w0z = curr[15]+positions[0].z;
  191.   //glLoadIdentity();
  192.   double wLx = curr[13]+positions[i].x;
  193.   double wLy = curr[14]+positions[i].y;
  194.   double wLz = curr[15]+positions[i].z;
  195.   {  // world coordinates for object i
  196.     double x = positions[i].x;
  197.     double y = positions[i].y;
  198.     double z = positions[i].z;
  199.     wLx = curr[0]*x + curr[4]*y + curr[8]*z + curr[12]*1;
  200.     wLy = curr[1]*x + curr[5]*y + curr[9]*z + curr[13]*1;
  201.     wLz = curr[2]*x + curr[6]*y + curr[10]*z + curr[14]*1;
  202.   }
  203.   /*
  204.   gluLookAt(wLx, wLy, wLz,
  205.     w0x, w0y, w0z,
  206.     upx, upy, upz);
  207.          -positions[0].x, 
  208.     -positions[0].y, 
  209.     -positions[0].z, 
  210.     upx, upy, upz);
  211.      gluLookAt(positions[IDX_ANCHORED_LIGHT].x, 
  212.     positions[IDX_ANCHORED_LIGHT].y, 
  213.     positions[IDX_ANCHORED_LIGHT].z,
  214.     positions[0].x, positions[0].y, positions[0].z,
  215.     upx, upy, upz);*/
  216. #endif
  217.   double cx, cy, cz;
  218.   double angle;
  219.   {
  220.     double x = positions[0].x-positions[i].x;
  221.     double y = positions[0].y-positions[i].y;
  222.     double z = positions[0].z-positions[i].z;
  223.     double a = 0; //positions[i].x;
  224.     double b = 0; //positions[i].y;
  225.     double c = 1; //positions[i].z;
  226.     cx = y*c - z*b;
  227.     cy = z*a - x*c;
  228.     cz = x*b - y*a;
  229.     double len0 = sqrt(x*x+y*y+z*z);
  230.     double leni = sqrt(a*a+b*b+c*c);
  231.     double dot = (a*x + b*y + c*z)/len0/leni;
  232.     angle = acos(dot)*180/M_PI;
  233.   }
  234.   glRotated(angle, cx, cy, cz);
  235.   //   glutSolidTeapot(40);
  236.   glutSolidSphere(40, 60, 60);
  237. } else {
  238.   glTranslated( positions[i].x, positions[i].y, positions[i].z );
  239.   glRotated(90+rotations[i].x, 1, 0, 0);
  240.   glRotated(90+rotations[i].y, 0, 1, 0);
  241.   glRotated(rotations[i].z, 0, 0, 1);
  242.   glutSolidTeapot(70);
  243.   //   glutSolidSphere(50, 100, 100);
  244. }
  245.       glPopMatrix();
  246.     }
  247.     glPopMatrix();
  248.   }
  250.   for( unsigned int i = num_anchored ; i < positions.size() ; ++i )
  251.   {
  252.     if (floater_visible[i]) {
  253.       glPushMatrix();
  254.         glMultMatrixd(&floaterpositions[ i ][0]);
  255. if (selected==(int)i) {
  256.   glGetDoublev( GL_MODELVIEW_MATRIX, selected_view );
  257. }
  258. float col[] = {colors[ i ].x, colors[ i ].y, colors[ i ].z, 1};
  259. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, col);
  261. glLoadName( i + 1 );
  262. glTranslated( positions[i].x, positions[i].y, positions[i].z );
  263. if (i==IDX_FLOATER_LIGHT) {
  264.   glutWireSphere(20, 10, 10);
  265. } else {
  266.   glRotated(90+rotations[i].x, 1, 0, 0);
  267.   glRotated(90+rotations[i].y, 0, 1, 0);
  268.   glRotated(rotations[i].z, 0, 0, 1);
  269.   glutSolidTeapot(60);
  270. }
  271.       glPopMatrix();
  272.     }
  273.   }
  274. }
  276. void drawPointer()
  277. {
  278.   if (!show_ptr) return;
  280.   glDisable(GL_LIGHTING);
  282.   d3 ptr_win;
  283.   ptr_win.x = ptr_x;
  284.   ptr_win.y = viewport[ 3 ] - ptr_y - 1;
  285.   ptr_win.z = .1;
  287.   /*
  288.    * calculate new world coordinates
  289.    */
  290.   d3 ptr_start;
  291.   gluUnProject(ptr_win.x, ptr_win.y, ptr_win.z,
  292.        modelview, projection, viewport,
  293.        &ptr_start.x, &ptr_start.y, &ptr_start.z );
  295.   d3 ptr_end;
  296.   if (true || selected==-1) {
  297.     gluUnProject(ptr_win.x, ptr_win.y-hv_pointer_dist, ptr_win.z,
  298.  modelview, projection, viewport,
  299.  &ptr_end.x, &ptr_end.y, &ptr_end.z );
  300.   } else {
  301.     ptr_end = selected_world;
  302.   }
  304.   glColor4d( ptr_col.x, ptr_col.y, ptr_col.z, 0.5 );
  305.   glEnable(GL_BLEND);
  306.   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  308.   glMatrixMode( GL_MODELVIEW );
  309.   glPushMatrix();
  311.   glTranslated( ptr_start.x, ptr_start.y, ptr_start.z );
  313.   glBegin( GL_QUADS );
  314.     const double w = 1;
  315.     double x = ptr_end.x-ptr_start.x;
  316.     double y = ptr_end.y-ptr_start.y;
  317.     double z = ptr_end.z-ptr_start.z;
  318.     glVertex3d(w, 0, 0);
  319.     glVertex3d(x+w, -y/2, z/2);
  320.     glVertex3d(x-w, -y/2, z/2);
  321.     glVertex3d(-w, 0, 0);
  322.   
  323.     if (dragging || hovering) {
  324.       // draw first links of claws
  325.       glVertex3d(x+w, -y/2, z/2);
  326.       glVertex3d(x+w*2, -y/1.5, z/1.5);
  327.       glVertex3d(x+w, -y/1.5, z/1.5);
  328.       glVertex3d(x, -y/2, z/2);
  330.       glVertex3d(x-w, -y/2, z/2);
  331.       glVertex3d(x-w*2, -y/1.5, z/1.5);
  332.       glVertex3d(x-w, -y/1.5, z/1.5);
  333.       glVertex3d(x, -y/2, z/2);
  334.     }
  336.     if (dragging) {
  337.       // draw closed claws
  338.       glVertex3d(x+w*2, -y/1.5, z/1.5);
  339.       glVertex3d(x+w, -y, z);
  340.       glVertex3d(x, -y, z);
  341.       glVertex3d(x+w, -y/1.5, z/1.5);
  343.       glVertex3d(x-w*2, -y/1.5, z/1.5);
  344.       glVertex3d(x-w, -y, z);
  345.       glVertex3d(x, -y, z);
  346.       glVertex3d(x-w, -y/1.5, z/1.5);
  348.     } else if (hovering) {
  349.       // draw open claws
  350.       glVertex3d(x+w*2, -y/1.5, z/1.5);
  351.       glVertex3d(x+w*2, -y, z);
  352.       glVertex3d(x+w, -y, z);
  353.       glVertex3d(x+w, -y/1.5, z/1.5);
  355.       glVertex3d(x-w*2, -y/1.5, z/1.5);
  356.       glVertex3d(x-w*2, -y, z);
  357.       glVertex3d(x-w, -y, z);
  358.       glVertex3d(x-w, -y/1.5, z/1.5);
  360.     } else if (rotating) {
  361.       // draw little points in 3 directions
  362.       glVertex3d(x+w, -y/2, z/2);
  363.       glVertex3d(x, -y, z);
  364.       glVertex3d(x, -y, z);
  365.       glVertex3d(x-w, -y/2, z/2);
  367.       glVertex3d(x, -y/2, z/2);
  368.       glVertex3d(x+y/2, -y, z);
  369.       glVertex3d(x+y/2, -y, z);
  370.       glVertex3d(x, -y/2-w, z/2);
  372.       glVertex3d(x, -y/2, z/2);
  373.       glVertex3d(x-y/2, -y, z);
  374.       glVertex3d(x-y/2, -y, z);
  375.       glVertex3d(x, -y/2-w, z/2);
  377.     } else {
  378.       // draw pointy top
  379.       glVertex3d(x+w, -y/2, z/2);
  380.       glVertex3d(x, -y, z);
  381.       glVertex3d(x, -y, z);
  382.       glVertex3d(x-w, -y/2, z/2);
  384.     }
  385.   glEnd();
  387.   glDisable(GL_BLEND);
  388.   glPopMatrix();
  389. }
  392. void drawLights() {
  394.   glMatrixMode(GL_MODELVIEW);
  396.   // "ambient" light from behind
  397.   GLenum use_light = GL_LIGHT0;
  398.   {
  399.     glEnable(use_light);
  400.     float diffuse[] = {.8, .8, .8, .8};
  401.     float specular[] = {0, 0, 0, 1};
  402.     float ambient[] = {0.2, 0.2, 0.2, 1};
  403.     glLightfv(use_light, GL_DIFFUSE, diffuse);
  404.     glLightfv(use_light, GL_SPECULAR, specular);
  405.     glLightfv(use_light, GL_AMBIENT, ambient);
  406.     //    float pos[4] = {0, 0, -1, 0};
  407.     //    glLightfv(use_light, GL_POSITION, pos);
  408.   }  
  410.   use_light = GL_LIGHT1;
  411.   if (anchor_visible) {
  412.     glPushMatrix();
  413.     {
  414.       glEnable(use_light);
  415.       float diffuse[] = {1, 1, 1, 1};
  416.       float specular[] = {1, 1, 1, 1};
  417.       float ambient[] = {0, 0, 0, 1};
  418.       glLightfv(use_light, GL_DIFFUSE, diffuse);
  419.       glLightfv(use_light, GL_SPECULAR, specular);
  420.       glLightfv(use_light, GL_AMBIENT, ambient);
  422.       glMultMatrixd(anchor);
  423.       glTranslated(positions[IDX_ANCHORED_LIGHT].x,
  424.    positions[IDX_ANCHORED_LIGHT].y,
  425.    positions[IDX_ANCHORED_LIGHT].z);
  426.       float pos[4] = {0, 0, 0, 1};
  427.       glLightfv(use_light, GL_POSITION, pos);
  428.       //    glLightf(use_light, GL_CONSTANT_ATTENUATION, 2.0);
  429.       //    glLightf(use_light, GL_LINEAR_ATTENUATION, 2.0);
  430.       //    glLightf(use_light, GL_QUADRATIC_ATTENUATION, 2.0);
  431.       float dir[3];
  432.       dir[0] = positions[0].x-positions[IDX_ANCHORED_LIGHT].x;
  433.       dir[1] = positions[0].y-positions[IDX_ANCHORED_LIGHT].y;
  434.       dir[2] = positions[0].z-positions[IDX_ANCHORED_LIGHT].z;
  435.       glLightfv(use_light, GL_SPOT_DIRECTION, dir);
  436.       glLightf(use_light, GL_SPOT_CUTOFF, 45);
  437.       //    glLightf(use_light, GL_SPOT_EXPONENT, 3);
  438.       //    glRotatef(dir);
  439.     }
  440.     glPopMatrix();
  441.   } else {
  442.     glDisable(use_light);
  443.   }
  445.   use_light = GL_LIGHT2;
  446.   if (floater_visible[IDX_FLOATER_LIGHT]) {
  447.     glPushMatrix();
  448.     {
  449.       glEnable(use_light);
  450.       float diffuse[] = {.5, .5, 1, 1};
  451.       float specular[] = {.5, .5, 1, 1};
  452.       float ambient[] = {0, 0, 0, 1};
  453.       glLightfv(use_light, GL_DIFFUSE, diffuse);
  454.       glLightfv(use_light, GL_SPECULAR, specular);
  455.       glLightfv(use_light, GL_AMBIENT, ambient);
  457.       glMultMatrixd(&floaterpositions[IDX_FLOATER_LIGHT][0]);
  458.       glTranslated( positions[IDX_FLOATER_LIGHT].x, 
  459.     positions[IDX_FLOATER_LIGHT].y, 
  460.     positions[IDX_FLOATER_LIGHT].z );
  461.       float pos[4] = {0, 0, 0, 1};
  462.       glLightfv(use_light, GL_POSITION, pos);
  463.       float dir[3];
  464.       dir[0] = positions[2].x-positions[IDX_FLOATER_LIGHT].x;
  465.       dir[1] = positions[2].y-positions[IDX_FLOATER_LIGHT].y;
  466.       dir[2] = positions[2].z-positions[IDX_FLOATER_LIGHT].z;
  467.       glLightfv(use_light, GL_SPOT_DIRECTION, dir);
  468.       //      glLightf(use_light, GL_SPOT_CUTOFF, 45);
  469.     }
  470.     glPopMatrix();
  471.   } else {
  472.     glDisable(use_light);
  473.   }
  474. }
  476. void hv_draw(bool rendering)
  477. {
  478.   drawObjs();
  479.   if (rendering) {
  480.     drawLights();
  481.     drawPointer();
  482.   }
  483. }
  485. void hv_set_anchor_transform(bool visible, double m[16])
  486. {
  487.   anchor_visible = visible;
  488.   if (visible && m!=NULL) {
  489.     memcpy(anchor, m, 16*sizeof(double));
  490.     //for (int i = 0; i<16; i++) printf("%e, ", anchor[i]); printf("n");
  491.   }
  492. }
  494. void hv_set_floater_transform(int id, bool visible, double m[16])
  495. {
  496.   id += num_anchored;
  497.   if (id>=(int) floater_visible.size()) {
  498.     fprintf(stderr, "invalid floater id: %dn", id);
  499.     exit(-1);
  500.   }
  501.   floater_visible[id] = visible;
  502.   if (visible && m!=NULL) {
  503.     memcpy(&floaterpositions[id][0], m, 16*sizeof(double));
  504.   }
  505. }
  509. //----------------------------------------------------------------------
  512. static const int SELECT_BUF_SIZE = 1024 * 10;
  515. void drag( int x, int y )
  516. {
  517.   /*
  518.    * new window coords are x,y plus old z
  519.    */
  520.   d3 new_win = selected_win;
  521.   new_win.x = x;
  522.   new_win.y = viewport[ 3 ] - y - 1;
  524.   /*
  525.    * calculate new world coordinates
  526.    */
  527.   d3 new_world;
  528.   gluUnProject(new_win.x, new_win.y, new_win.z,
  529.        selected_view, projection, viewport,        
  530.        &new_world.x, &new_world.y, &new_world.z );
  532.   /*
  533.    * delta vector is new world minus old world
  534.    */
  535.   d3 offset;
  536.   offset.x = new_world.x - selected_rel.x;
  537.   offset.y = new_world.y - selected_rel.y;
  538.   offset.z = new_world.z - selected_rel.z;
  540.   /*
  541.    * update selected teapot position with delta vector
  542.    */
  543.   positions[ selected ].x += offset.x;
  544.   positions[ selected ].y += offset.y;
  545.   positions[ selected ].z += offset.z;
  547.   selected_win   = new_win;
  548.   selected_rel = new_world;
  549. }
  551. void rotate( int x, int y )
  552. {
  553.   /*
  554.    * new window coords are x,y plus old z
  555.    */
  556.   rotations[ selected ].x = x - selected_win.x;
  557.   rotations[ selected ].y = (viewport[3]-y-1) - selected_win.y;
  558. }
  560. void hv_pointer_update(bool show, int button, int x, int y)
  561. {
  562.   ptr_x = x;
  563.   ptr_y = y;
  565.   show_ptr = show;
  566.   if (!show) {
  567.     dragging = false;
  568.     rotating = false;
  569.     selected = -1;
  570.     return;
  571.   }
  573.   if (button == HV_PTR_LBUTTON_PRESSED) {
  574.     if (!dragging) {
  575.       if( render_select( x, y-hv_pointer_dist, &selected, &selected_win ) ) 
  576.       {
  577. gluUnProject(selected_win.x, selected_win.y, selected_win.z,
  578.      selected_view, projection, viewport,
  579.      &selected_rel.x, &selected_rel.y, &selected_rel.z);
  581. gluUnProject(selected_win.x, selected_win.y-hv_pointer_dist, selected_win.z,
  582.      modelview, projection, viewport,
  583.      &selected_world.x, &selected_world.y, &selected_world.z);
  585. dragging = true;
  586. rotating = false;
  587.       }
  589.     } else {
  590.       drag( x, y-hv_pointer_dist );
  591.     }
  593.   } else if (button == HV_PTR_RBUTTON_PRESSED) {
  594.     if (!rotating) {
  595.       if( render_select( x, y-hv_pointer_dist, &selected, &selected_win ) ) 
  596.       {
  597. gluUnProject(selected_win.x, selected_win.y, selected_win.z,
  598.      selected_view, projection, viewport,
  599.      &selected_rel.x, &selected_rel.y, &selected_rel.z);
  601. gluUnProject(selected_win.x, selected_win.y-hv_pointer_dist, selected_win.z,
  602.      modelview, projection, viewport,
  603.      &selected_world.x, &selected_world.y, &selected_world.z);
  605. rotating = true;
  606. dragging = false; 
  607.      }
  609.     } else {
  610.       rotate( x, y-hv_pointer_dist );
  611.     }
  613.   } else if (button == HV_PTR_BUTTON_RELEASED) {
  614.     dragging = false;
  615.     rotating = false;
  616.     selected = -1;
  618.   } else if (button == HV_PTR_NO_BUTTON_ACTION) {
  619.     if (dragging) {
  620.       drag( x, y-hv_pointer_dist );
  621.     }
  622.     if (rotating) {
  623.       rotate( x, y-hv_pointer_dist );
  624.     }
  626.   } else {
  627.     fprintf(stderr, "wrong 'button' value in hv_pointer_updaten");
  628.     exit(-1);
  629.   }
  631.   //  printf("selected: %dn", selected);
  633.   if (!dragging && !rotating && 
  634.       render_select( x, y-hv_pointer_dist, &selected, &selected_win ) ) 
  635.   {
  636.     gluUnProject(selected_win.x, selected_win.y, selected_win.z,
  637.  selected_view, projection, viewport,
  638.  &selected_rel.x, &selected_rel.y, &selected_rel.z);
  639.     
  640.     gluUnProject(selected_win.x, selected_win.y-hv_pointer_dist, selected_win.z,
  641.  modelview, projection, viewport,
  642.  &selected_world.x, &selected_world.y, &selected_world.z);
  644.     hovering = true;
  645.   } else {
  646.     hovering = false;
  647.   }
  648. }
  651. void ChangeObjectColor()
  652. {
  653.   if (selected!=-1) {
  654.     colors[selected].x = (float)rand() / ( float )RAND_MAX;
  655.     colors[selected].y = (float)rand() / ( float )RAND_MAX;
  656.     colors[selected].z = (float)rand() / ( float )RAND_MAX;
  657.   }
  658. }