glui_translation.cpp
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:16k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /****************************************************************************
  2.   
  3.   GLUI User Interface Toolkit
  4.   ---------------------------
  5.      glui_translation - GLUI_Translation control class
  6.           --------------------------------------------------
  7.   Copyright (c) 1998 Paul Rademacher
  8.   WWW:    http://sourceforge.net/projects/glui/
  9.   Forums: http://sourceforge.net/forum/?group_id=92496
  10.   This library is free software; you can redistribute it and/or
  11.   modify it under the terms of the GNU Lesser General Public
  12.   License as published by the Free Software Foundation; either
  13.   version 2.1 of the License, or (at your option) any later version.
  14.   This library is distributed in the hope that it will be useful,
  15.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.   Lesser General Public License for more details.
  18.   You should have received a copy of the GNU Lesser General Public
  19.   License along with this library; if not, write to the Free Software
  20.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21. *****************************************************************************/
  22. #include "GL/glui.h"
  23. #include "glui_internal.h"
  24. #include "algebra3.h"
  25. /********************** GLUI_Translation::GLUI_Translation() ***/
  26. GLUI_Translation::GLUI_Translation(
  27.   GLUI_Node *parent, const char *name, 
  28.   int trans_t, float *value_ptr,
  29.   int id, GLUI_CB cb )
  30. {
  31.   common_init();
  32.   set_ptr_val( value_ptr );
  33.   user_id    = id;
  34.   set_name( name );
  35.   callback    = cb;
  36.   parent->add_control( this );
  37.   //init_live();
  38.   trans_type = trans_t;
  39.   if ( trans_type == GLUI_TRANSLATION_XY ) {
  40.     float_array_size = 2;
  41.   }
  42.   else if ( trans_type == GLUI_TRANSLATION_X ) {
  43.     float_array_size = 1;
  44.   }
  45.   else if ( trans_type == GLUI_TRANSLATION_Y ) {
  46.     float_array_size = 1;
  47.   }
  48.   else if ( trans_type == GLUI_TRANSLATION_Z ) {
  49.     float_array_size = 1;
  50.   }
  51.   init_live();
  52. }
  53. /********************** GLUI_Translation::iaction_mouse_down_handler() ***/
  54. /*  These are really in local coords (5/10/99)                            */
  55. int    GLUI_Translation::iaction_mouse_down_handler( int local_x, 
  56.      int local_y )
  57. {
  58.   int center_x, center_y;
  59.   down_x = local_x;
  60.   down_y = local_y;
  61.   if ( trans_type == GLUI_TRANSLATION_XY ) {
  62.     orig_x = float_array_val[0];
  63.     orig_y = float_array_val[1];
  64.     /** Check if the Alt key is down, which means lock to an axis **/
  65.     center_x = w/2;
  66.     center_y = (h-18)/2;
  67.     if ( glui->curr_modifiers & GLUT_ACTIVE_ALT ) {
  68.       if ( ABS(local_y-center_y) > ABS(local_x-center_x) ) {
  69.         locked = GLUI_TRANSLATION_LOCK_Y;
  70.         glutSetCursor( GLUT_CURSOR_UP_DOWN );
  71.       }
  72.       else {
  73.         locked = GLUI_TRANSLATION_LOCK_X;
  74.         glutSetCursor( GLUT_CURSOR_LEFT_RIGHT );
  75.       }
  76.     }
  77.     else {
  78.       locked = GLUI_TRANSLATION_LOCK_NONE;
  79.       glutSetCursor( GLUT_CURSOR_SPRAY );
  80.     }
  81.   }
  82.   else if ( trans_type == GLUI_TRANSLATION_X ) {
  83.     glutSetCursor( GLUT_CURSOR_LEFT_RIGHT );
  84.     orig_x = float_array_val[0];
  85.   }
  86.   else if ( trans_type == GLUI_TRANSLATION_Y ) {
  87.     glutSetCursor( GLUT_CURSOR_UP_DOWN );
  88.     orig_y = float_array_val[0];
  89.   }
  90.   else if ( trans_type == GLUI_TRANSLATION_Z ) {
  91.     glutSetCursor( GLUT_CURSOR_UP_DOWN );
  92.     orig_z = float_array_val[0];
  93.   }
  94.   trans_mouse_code = 1;
  95.   redraw();
  96.   return false;
  97. }
  98. /*********************** GLUI_Translation::iaction_mouse_up_handler() **********/
  99. int    GLUI_Translation::iaction_mouse_up_handler( int local_x, int local_y, 
  100.    bool inside )
  101. {
  102.   trans_mouse_code = GLUI_TRANSLATION_MOUSE_NONE;
  103.   locked = GLUI_TRANSLATION_LOCK_NONE;
  104.   redraw();
  105.   return false;
  106. }
  107. /******************* GLUI_Translation::iaction_mouse_held_down_handler() ******/
  108. int    GLUI_Translation::iaction_mouse_held_down_handler( int local_x, int local_y,
  109.   bool inside)
  110. {  
  111.   float x_off, y_off;
  112.   float off_array[2];
  113.   x_off = scale_factor * (float)(local_x - down_x);
  114.   y_off = -scale_factor * (float)(local_y - down_y);
  115.   if ( glui->curr_modifiers & GLUT_ACTIVE_SHIFT ) {
  116.     x_off *= 100.0f;
  117.     y_off *= 100.0f;
  118.   }
  119.   else if ( glui->curr_modifiers & GLUT_ACTIVE_CTRL ) {
  120.     x_off *= .01f;
  121.     y_off *= .01f;
  122.   }
  123.   if ( trans_type == GLUI_TRANSLATION_XY ) {
  124.     if ( locked == GLUI_TRANSLATION_LOCK_X )
  125.       y_off = 0.0;
  126.     else if ( locked == GLUI_TRANSLATION_LOCK_Y )
  127.       x_off = 0.0;
  128.     off_array[0] = x_off + orig_x;
  129.     off_array[1] = y_off + orig_y;
  130.   }
  131.   else if ( trans_type == GLUI_TRANSLATION_X ) {
  132.     off_array[0] = x_off + orig_x;
  133.   }
  134.   else if ( trans_type == GLUI_TRANSLATION_Y ) {
  135.     off_array[0] = y_off + orig_y;
  136.   }
  137.   else if ( trans_type == GLUI_TRANSLATION_Z ) {
  138.     off_array[0] = y_off + orig_z;
  139.   }
  140.   set_float_array_val( (float*) &off_array[0] );
  141.   return false;
  142. }
  143. /******************** GLUI_Translation::iaction_draw_active_area_persp() **************/
  144. void    GLUI_Translation::iaction_draw_active_area_persp( void )
  145. {
  146. }
  147. /******************** GLUI_Translation::iaction_draw_active_area_ortho() **********/
  148. void    GLUI_Translation::iaction_draw_active_area_ortho( void )
  149. {
  150.   /********* Draw emboss circles around arcball control *********/
  151.   float radius;
  152.   radius = (float)(h-22)/2.0;  /*  MIN((float)w/2.0, (float)h/2.0); */
  153.   glLineWidth( 1.0 );
  154.   draw_emboss_box( (int) -radius-2, (int)radius+2, 
  155.    (int)-radius-2, (int)radius+2 );
  156.   glMatrixMode( GL_MODELVIEW );
  157.   glPushMatrix();
  158.   glTranslatef( .5, .5, .5 );
  159.   /*  glScalef( radius-1.0, radius-1.0, radius-1.0 ); */
  160.   if ( trans_type == GLUI_TRANSLATION_Z )
  161.     draw_2d_z_arrows((int)radius-1);
  162.   else if ( trans_type == GLUI_TRANSLATION_XY )
  163.     draw_2d_xy_arrows((int)radius-1);
  164.   else if ( trans_type == GLUI_TRANSLATION_X )
  165.     draw_2d_x_arrows((int)radius-1);
  166.   else if ( trans_type == GLUI_TRANSLATION_Y )
  167.     draw_2d_y_arrows((int)radius-1);
  168.   glPopMatrix();
  169. }
  170. /******************************** GLUI_Translation::iaction_dump() **********/
  171. void     GLUI_Translation::iaction_dump( FILE *output )
  172. {
  173. }
  174. /******************** GLUI_Translation::iaction_special_handler() **********/
  175. int    GLUI_Translation::iaction_special_handler( int key,int modifiers )
  176. {
  177.   return false;
  178. }
  179. /*************************** GLUI_Translation::draw_2d_z_arrows() **************/
  180. void    GLUI_Translation::draw_2d_z_arrows( int radius )
  181. {
  182.   if ( trans_mouse_code != GLUI_TRANSLATION_MOUSE_NONE ) {
  183.     draw_2d_arrow(radius, true, 2);
  184.     draw_2d_arrow(radius, true, 0);
  185.   }
  186.   else {
  187.     draw_2d_arrow(radius, false, 2);
  188.     draw_2d_arrow(radius, false, 0);
  189.   }
  190. }
  191. /*************************** GLUI_Translation::draw_2d_x_arrows() **************/
  192. void    GLUI_Translation::draw_2d_x_arrows( int radius )
  193. {
  194.   if ( trans_mouse_code != GLUI_TRANSLATION_MOUSE_NONE ) {
  195.     draw_2d_arrow(radius, true, 1);
  196.     draw_2d_arrow(radius, true, 3);
  197.   }
  198.   else {
  199.     draw_2d_arrow(radius, false, 1);
  200.     draw_2d_arrow(radius, false, 3);
  201.   }
  202. }
  203. /*************************** GLUI_Translation::draw_2d_y_arrows() **************/
  204. void    GLUI_Translation::draw_2d_y_arrows( int radius )
  205. {
  206.   if ( trans_mouse_code != GLUI_TRANSLATION_MOUSE_NONE ) {
  207.     draw_2d_arrow(radius, true, 0);
  208.     draw_2d_arrow(radius, true, 2);
  209.   }
  210.   else {
  211.     draw_2d_arrow(radius, false, 0);
  212.     draw_2d_arrow(radius, false, 2);
  213.   }
  214. }
  215. /************************** GLUI_Translation::draw_2d_xy_arrows() **************/
  216. void    GLUI_Translation::draw_2d_xy_arrows( int radius)
  217. {
  218.   if ( trans_mouse_code != GLUI_TRANSLATION_MOUSE_NONE ) {
  219.     if ( locked == GLUI_TRANSLATION_LOCK_X ) {
  220.       draw_2d_arrow(radius, false, 0);
  221.       draw_2d_arrow(radius, false, 2);
  222.       draw_2d_arrow(radius, true, 1);
  223.       draw_2d_arrow(radius, true, 3);
  224.     }
  225.     else if ( locked == GLUI_TRANSLATION_LOCK_Y ) {
  226.       draw_2d_arrow(radius, false, 1);
  227.       draw_2d_arrow(radius, false, 3);
  228.       draw_2d_arrow(radius, true, 0);
  229.       draw_2d_arrow(radius, true, 2);
  230.     }
  231.     else {
  232.       draw_2d_arrow(radius, true, 0);
  233.       draw_2d_arrow(radius, true, 1);
  234.       draw_2d_arrow(radius, true, 2);
  235.       draw_2d_arrow(radius, true, 3);
  236.     }
  237.   }
  238.   else {
  239.     draw_2d_arrow(radius, false, 0);
  240.     draw_2d_arrow(radius, false, 1);
  241.     draw_2d_arrow(radius, false, 2);
  242.     draw_2d_arrow(radius, false, 3);
  243.   }
  244.   return;
  245. }
  246. /*************************** GLUI_Translation::draw_2d_arrow() **************/
  247. /* ori: 0=up, 1=left, 2=down, 3=right                                       */
  248. /*                                                                          */
  249. /*                                                                          */
  250. /*                           0, y2                                          */
  251. /*                      /                                                  */
  252. /*                     /                                                   */
  253. /*                    /                                                    */
  254. /*                   /                                                     */
  255. /*                  /                                                      */
  256. /*                 /                                                       */
  257. /*                /                                                        */
  258. /*               /                                                         */
  259. /*            -x2,y1   -x1b,y1   x1b,y1     x2,y1                           */
  260. /*                        |        |                                        */
  261. /*                        |        |                                        */
  262. /*                        |        |                                        */
  263. /*                        |        |                                        */
  264. /*                        |        |                                        */
  265. /*                    -x1a,y0    x1a,y0                                     */
  266. /*                                                                          */
  267. void    GLUI_Translation::draw_2d_arrow( int radius, int filled, int orientation )
  268. {
  269.   float x1 = .2, x2 = .4, y1 = .54, y2 = .94, y0;
  270.   float x1a, x1b;
  271. /*
  272.   vec3  col1( 0.0, 0.0, 0.0 ), col2( .45, .45, .45 ), 
  273.     col3( .7, .7, .7 ), col4( 1.0, 1.0, 1.0 );
  274.   vec3  c1, c2, c3, c4, c5, c6;
  275. */
  276.   vec3  white(1.0,1.0,1.0), black(0.0,0.0,0.0), gray(.45,.45,.45), 
  277.     bkgd(.7,.7,.7);
  278.   int   c_off=0; /* color index offset */
  279.   if ( glui )
  280.     bkgd.set(glui->bkgd_color_f[0],
  281.      glui->bkgd_color_f[1],
  282.      glui->bkgd_color_f[2]);
  283.   /* bkgd[0] = 255.0; bkgd[1] = 0;              */
  284.   /** The following 8 colors define the shading of an octagon, in
  285.     clockwise order, starting from the upstroke on the left  **/
  286.   /** This is for an outside and inside octagons **/
  287.   vec3 colors_out[]={white, white, white, gray, black, black, black, gray};
  288.   vec3 colors_in[] ={bkgd,white,bkgd,gray,gray,gray,gray,gray};
  289. #define SET_COL_OUT(i) glColor3fv((float*) &colors_out[(i)%8][0]);
  290. #define SET_COL_IN(i) glColor3fv((float*) &colors_in[(i)%8][0]);
  291.   x1 = (float)radius * .2;
  292.   x2 = x1 * 2;
  293.   y1 = (float)radius * .54;
  294.   y2 = y1 + x2;
  295.   x1a = x1;
  296.   x1b = x1;
  297.   glMatrixMode(GL_MODELVIEW);
  298.   glPushMatrix();
  299. #define DRAW_SEG( xa,ya,xb,yb ) glVertex2f(xa,ya); glVertex2f(xb,yb);
  300.   glScalef( -1.0, 1.0, 1.0 );
  301.   if ( orientation == 2 ) {
  302.     c_off = 4;
  303.   }
  304.   else if ( orientation == 0 ) {
  305.     c_off = 0;
  306.     glRotatef( 180.0, 0.0, 0.0, 1.0 );
  307.   }
  308.   else if ( orientation == 1 ) {
  309.     c_off = 2;
  310.     glRotatef( 90.0, 0.0, 0.0, 1.0 );
  311.   }
  312.   else if ( orientation == 3 ) {
  313.     c_off = 6;
  314.     glRotatef( -90.0, 0.0, 0.0, 1.0 );
  315.   }
  316.   if ( trans_type == GLUI_TRANSLATION_Z )
  317.     y0 = 0.0;
  318.   else if ( trans_type == GLUI_TRANSLATION_XY )
  319.     y0 = x1;
  320.   else
  321.     y0 = 0.0;
  322.   if ( trans_type == GLUI_TRANSLATION_Z ) {
  323.     if ( orientation == 0 ) {
  324.       y1 += 2.0;
  325.       y2 += 0.0;
  326.       x1b -= 2.0;
  327.       x2  -= 2.0;
  328.       x1a += 2.0;
  329.     }
  330.     else if ( orientation == 2 ) {
  331.       y1 -= 6.0;
  332.       x1a += 2.0;
  333.       x1b += 4.0;
  334.       x2  += 6.0; 
  335.     }
  336.   }
  337.   /*** Fill in inside of arrow  ***/
  338.   if ( NOT filled ) {  /*** Means button is up - control is not clicked ***/
  339.     /*glColor3f( .8, .8, .8 );              */
  340.     set_to_bkgd_color();
  341.     glColor3f( bkgd[0]+.07, bkgd[1]+.07, bkgd[2]+.07 );
  342.   }
  343.   else {               /*** Button is down on control ***/
  344.     glColor3f( .6, .6, .6 );
  345.     c_off += 4;  /* Indents the shadows - goes from a raised look to embossed */
  346.   }
  347.   /*** Check if control is enabled or not ***/
  348.   if ( NOT enabled ) {
  349.     set_to_bkgd_color();
  350.     /*c_off += 4;  -- Indents the shadows - goes from a raised look to embossed */              
  351.     colors_out[0] = colors_out[1] = colors_out[2] = colors_out[7] = gray;
  352.     colors_out[3] = colors_out[4] = colors_out[5] = colors_out[6] = white;
  353.     colors_in[0] = colors_in[1] = colors_in[2] = colors_in[7] = white;
  354.     colors_in[3] = colors_in[4] = colors_in[5] = colors_in[6] = gray;
  355.   }
  356.   glBegin( GL_POLYGON );
  357.   glVertex2f( 0.0, 0.0  );  glVertex2f( -x1a, 0.0 );
  358.   glVertex2f( -x1a, 0.0   );  glVertex2f( -x1b, y1 );
  359.   glVertex2f( x1b, y1);      glVertex2f( x1a, 0.0 );
  360.   glVertex2f( x1a, 0.0 );     glVertex2f( 0.0, 0.0  );
  361.   glEnd();
  362.   glBegin( GL_TRIANGLES );
  363.   glVertex2f( -x2, y1 ); glVertex2f( 0.0, y2 ); glVertex2f( x2, y1 );
  364.   glEnd();
  365.   glLineWidth( 1.0 );
  366.   /*** Draw arrow outline ***/
  367.   glBegin( GL_LINES );
  368.   SET_COL_IN(1+c_off);  DRAW_SEG( 0.0, y2-1.0, -x2, y1-1.0 );
  369.   SET_COL_IN(6+c_off); DRAW_SEG( -x2+2.0, y1+1.0, -x1b+1.0, y1+1.0 );
  370.   SET_COL_IN(0+c_off); DRAW_SEG( -x1b+1.0, y1+1.0, -x1a+1.0, y0 );
  371.   SET_COL_IN(3+c_off); DRAW_SEG( 0.0, y2-1.0, x2, y1-1.0 );
  372.   SET_COL_IN(6+c_off); DRAW_SEG( x2-1.0, y1+1.0, x1b-1.0, y1+1.0 );
  373.   SET_COL_IN(4+c_off); DRAW_SEG( x1b-1.0, y1+1.0, x1a-1.0, y0 );
  374.   SET_COL_OUT(0+c_off);  DRAW_SEG( -x1a, y0, -x1b, y1  );
  375.   SET_COL_OUT(6+c_off);  DRAW_SEG( -x1b, y1,  -x2, y1  );
  376.   SET_COL_OUT(1+c_off);  DRAW_SEG( -x2, y1,  0.0, y2  );
  377.   SET_COL_OUT(3+c_off);  DRAW_SEG( 0.0, y2,   x2, y1  );
  378.   SET_COL_OUT(6+c_off);  DRAW_SEG(  x2, y1,   x1b, y1  );
  379.   SET_COL_OUT(4+c_off);  DRAW_SEG(  x1b, y1,   x1a, y0 );
  380.   glEnd();
  381. #undef DRAW_SEG
  382.   glPopMatrix();
  383. }
  384. /*************************** GLUI_Translation::get_mouse_code() *************/
  385. int    GLUI_Translation::get_mouse_code( int x, int y )
  386. {
  387.   if ( x == 0 AND y < 0 )
  388.     return GLUI_TRANSLATION_MOUSE_DOWN;
  389.   else if ( x == 0 AND y > 0 )
  390.     return GLUI_TRANSLATION_MOUSE_UP;
  391.   else if ( x > 0 AND y == 0 )
  392.     return GLUI_TRANSLATION_MOUSE_LEFT;
  393.   else if ( x < 0 AND y == 0 )
  394.     return GLUI_TRANSLATION_MOUSE_RIGHT;
  395.   else if ( x < 0 AND y < 0 )
  396.     return GLUI_TRANSLATION_MOUSE_DOWN_LEFT;
  397.   else if ( x < 0 AND y > 0 )
  398.     return GLUI_TRANSLATION_MOUSE_DOWN_RIGHT;
  399.   else if ( x > 0 AND y < 0 )
  400.     return GLUI_TRANSLATION_MOUSE_UP_LEFT;
  401.   else if ( x > 0 AND y > 0 )
  402.     return GLUI_TRANSLATION_MOUSE_UP_RIGHT;
  403.   return GLUI_TRANSLATION_MOUSE_NONE;
  404. }
  405. /*********************************** GLUI_Translation::set_x() ******/
  406. void  GLUI_Translation::set_x( float val )
  407. {
  408.   set_one_val( val, 0 );
  409. }
  410. /*********************************** GLUI_Translation::set_y() ******/
  411. void  GLUI_Translation::set_y( float val )
  412. {
  413.   if ( trans_type == GLUI_TRANSLATION_XY )
  414.     set_one_val( val, 1 );
  415.   else
  416.     set_one_val( val, 0 );
  417. }
  418. /*********************************** GLUI_Translation::set_z() ******/
  419. void  GLUI_Translation::set_z( float val )
  420. {
  421.   set_one_val( val, 0 );
  422. }
  423. /******************************* GLUI_Translation::set_one_val() ****/
  424. void  GLUI_Translation::set_one_val( float val, int index )
  425. {
  426.   float *fp;
  427.   float_array_val[index] = val;   /* set value in array              */
  428.   /*** The code below is like output_live, except it only operates on
  429.     a single member of the float array (given by 'index') instead of
  430.     outputting the entire array   ****/
  431.   if ( ptr_val == NULL OR NOT live_inited )
  432.     return;
  433.  
  434.   fp = (float*) ptr_val;
  435.   fp[index]                    = float_array_val[index];
  436.   last_live_float_array[index] = float_array_val[index];
  437.   /** Update the main gfx window? **/
  438.   if ( this->glui != NULL ) {
  439.     this->glui->post_update_main_gfx();
  440.   }
  441. }