home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / freedraft.tar.gz / freedraft.tar / FREEdraft-050298 / VIEWPORT / canvasglstate.cpp next >
C/C++ Source or Header  |  1998-04-22  |  5KB  |  163 lines
  1. //canvasglstate.cpp
  2.  
  3.  
  4. // Copyright (C) 1997  Cliff Johnson                                       //
  5. //                                                                         //
  6. // This program is free software; you can redistribute it and/or           //
  7. // modify it under the terms of the GNU  General Public                    //
  8. // License as published by the Free Software Foundation; either            //
  9. // version 2 of the License, or (at your option) any later version.        //
  10. //                                                                         //
  11. // This software is distributed in the hope that it will be useful,        //
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of          //
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       //
  14. // General Public License for more details.                                //
  15. //                                                                         //
  16. // You should have received a copy of the GNU General Public License       //
  17. // along with this software (see COPYING.LIB); if not, write to the        //
  18. // Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. //
  19.  
  20. #include <canvasglstate.h>
  21. #include <GL/gl.h>
  22. #include <GL/glu.h>
  23. #include <math.h>
  24.  
  25. #include <iostream.h>
  26.  
  27. //---------------------------CanvasGLState::SetOrtho2D(int h, int w)--------------------
  28.  
  29.  
  30. CanvasGLState::CanvasGLState(const Point& center, float scale, float ppmm)
  31. {
  32.     viewCenter = center;
  33.     viewScale = scale;
  34.     pixelsPerMillimeter = ppmm;
  35. //    GLStateModified++;
  36. }
  37.  
  38. void CanvasGLState::SetOrtho2D(int w, int h)
  39. {
  40.         float sw =   static_cast<float>( w ) /  (viewScale * pixelsPerMillimeter) ;
  41.         float sh =   static_cast<float>( h ) /  (viewScale * pixelsPerMillimeter) ;
  42.  
  43.     // limit sw and sh to MAXVIEWDIMENSION
  44.     float maxdim;
  45.     if(sw > sh) maxdim = sw;
  46.     else maxdim = sh;
  47.  
  48.     if(maxdim > MAXVIEWDIMENSION )
  49.     {
  50.         sw = sw * (static_cast<float>(MAXVIEWDIMENSION) / maxdim);
  51.         sh = sh * (static_cast<float>(MAXVIEWDIMENSION)/ maxdim);
  52.     }
  53.         
  54. //    glMatrixMode(GL_PROJECTION);
  55. //      glLoadIdentity();
  56.     gluOrtho2D(    viewCenter[0]-sw/2., 
  57.                viewCenter[0]+sw/2.,
  58.             viewCenter[1]-sh/2.,
  59.             viewCenter[1]+sh/2.);
  60. //    glMatrixMode(GL_MODELVIEW);
  61. }
  62.  
  63. //---------------------------CanvasGLState::SetScale()--------------------
  64.  
  65. void CanvasGLState::SetScale(float s)
  66. {
  67.     if(s> .001)if(s<10000.)viewScale = s;  // refuse unreasonable values
  68. }
  69.  
  70.  
  71. //---------------------------CanvasGLState::SetPPMM(float ppmm)--------------------
  72.  
  73. void CanvasGLState::SetPPMM(float ppmm)
  74. {
  75.     if(ppmm > 1) if(ppmm < 10)pixelsPerMillimeter=ppmm;     // refuse unreasonable values
  76. }
  77.  
  78.  
  79. //---------------------------CanvasGLState::SetSenter(const Point& p)--------------------
  80.  
  81. void CanvasGLState::SetCenter(const Point& p)
  82. {
  83.     if(Distance(Point(),p)<10000.) viewCenter = p;     // maximum distance of center from origin
  84. }
  85.  
  86. Point CanvasGLState::GetCoord(int x,int y,int w, int h)
  87. {
  88. // convert to real coordinates of pick relative to center
  89.         float rx =   static_cast<float>( x - w/2 ) /  (viewScale * pixelsPerMillimeter) ;
  90.         float ry =   static_cast<float>( y - h/2 ) /  (viewScale * pixelsPerMillimeter) ;
  91.  
  92.     return Point(viewCenter + Point(rx,-ry));
  93. }
  94.  
  95.  
  96. //=====================CanvasGLState::ZoomIn===========================
  97.  
  98. void CanvasGLState::ZoomIn(const Point& p1, const Point& p2, int w, int h) 
  99. {
  100.     // get window dimensions in real coordinates
  101.         float sw =   static_cast<float>( w ) /  (viewScale * pixelsPerMillimeter) ;
  102.         float sh =   static_cast<float>( h ) /  (viewScale * pixelsPerMillimeter) ;
  103.  
  104.     // calculate ratio's of h/w
  105.     float dx = fabs(p2[0]-p1[0]);
  106.     float dy = fabs(p2[1]-p1[1]);
  107.  
  108.     float zoomFactor;
  109.     if(dy / dx  > sh / sw )        // height dominates
  110.     {                         
  111.          zoomFactor  = sh / dy; 
  112.     } 
  113.     else                // width dominates
  114.     {
  115.         zoomFactor = sw / dx ;
  116.     }
  117.  
  118.     // limit scale change to a factor of MAXZOOMFACTOR
  119.     if ( zoomFactor > MAXZOOMFACTOR) zoomFactor = MAXZOOMFACTOR;
  120.  
  121.     viewScale = viewScale * zoomFactor;
  122.     
  123.     // new center point is half way between p1 and p2
  124.  
  125.     viewCenter =  p1 +  (( p2 - p1 ) * .5  );
  126. }
  127.  
  128.  
  129. //=====================CanvasGLState::ZoomOut===========================
  130.  
  131. void CanvasGLState::ZoomOut(const Point& p1, const Point& p2, int w, int h)
  132. {
  133.     // get window dimensions in real coordinates
  134.         float sw =   static_cast<float>( w ) /  (viewScale * pixelsPerMillimeter) ;
  135.         float sh =   static_cast<float>( h ) /  (viewScale * pixelsPerMillimeter) ;
  136.  
  137.     // calculate ratio's of h/w
  138.     float dx = fabs(p2[0]-p1[0]);
  139.     float dy = fabs(p2[1]-p1[1]);
  140.     float zoomFactor;
  141.  
  142.     if(dy / dx  > sh / sw )        // width dominates
  143.     {                         
  144.         zoomFactor = dx / sw; 
  145.     } 
  146.     else                // height dominates
  147.     {
  148.         zoomFactor = dy / sh;
  149.     }
  150.     // limit scale change to a factor of 1/MAXZOOMFACTOR
  151.     float mz = MAXZOOMFACTOR;
  152.     if ( zoomFactor < 1./mz) zoomFactor = 1./mz;
  153.  
  154.     viewScale = viewScale * zoomFactor;
  155.     
  156.     // calculate new center point -
  157.     // current point moves to halfway between p1 and p2
  158.  
  159.     Point px =  p1 +  (( p2 - p1 ) * .5  );
  160.     Point vx = (px - viewCenter) * (1/zoomFactor);
  161.     viewCenter = viewCenter - vx;
  162. }
  163.