SbViewportRegion.h

Go to the documentation of this file.

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef  _SB_VIEWPORT_REGION_
#define  _SB_VIEWPORT_REGION_
 
//
//  Class: SbViewportRegion
//
//  Class that represents the active viewport region in a display
//  window. It contains the screen-space size of the window as well as
//  the origin and size of the viewport within the window. By default,
//  the viewport is the same as the full window. Methods allow the
//  viewport to be set either in terms of screen space pixels or as
//  normalized coordinates, where (0,0) is the lower-left corner of
//  the window and (1,1) is the upper-right corner.
//
 
#include <Inventor/SbLinear.h>
 
class  SbViewportRegion {
 
 public:
  SbViewportRegion();
  
  SbViewportRegion(short width, short height, float newScale = 1.0);
 
  SbViewportRegion(SbVec2s   winSize, float newScale = 1.0);
 
  SbViewportRegion(SbVec2i32 winSize, float newScale = 1.0);
  
  SbViewportRegion(const SbViewportRegion &vpReg);
  
  void setWindowSize(short width, short height)
    { setWindowSize(SbVec2i32(width, height)); }
 
  void setWindowSize(SbVec2s winSize);
 
  void setWindowSize(SbVec2i32 winSize);
  
  void setViewport(float left, float bottom, float width, float height)
    { setViewport(SbVec2f(left, bottom), SbVec2f(width, height)); }
  
  void setViewport(SbVec2f origin, SbVec2f size);
  
  void setViewportPixels(short left, short bottom, short width, short height)
    { setViewportPixels(SbVec2i32(left, bottom), SbVec2i32(width, height)); }
 
  void setViewportPixels(SbVec2s origin, SbVec2s size);
 
  void setViewportPixels(SbVec2i32 origin, SbVec2i32 size);
  
  const SbVec2s &getWindowSize() const;
 
  const SbVec2i32 &getWindowSize_i32() const;
 
  const SbVec2f &getViewportOrigin() const
    { return vpOrigin; }
 
  const SbVec2s &getViewportOriginPixels() const;
 
  const SbVec2i32 &getViewportOriginPixels_i32() const;
 
  const SbVec2f &getViewportSize() const
    { return vpSize; }
  
  const SbVec2s &getViewportSizePixels() const;
 
  const SbVec2i32 &getViewportSizePixels_i32() const;
 
  float getViewportAspectRatio() const;
 
  void scaleWidth(float ratio);
 
  void scaleHeight(float ratio);
  
  void setPixelsPerInch(float ppi)
    { pixelsPerInch = ppi; }
 
  float getPixelsPerInch() const
    { return pixelsPerInch; }
  
  float getPixelsPerPoint() const
    { return (pixelsPerInch / s_historicalPixelPerInch); }
 
  SbVec2f normalize( const SbVec2s& position ) const;
 
   friend int operator ==(const SbViewportRegion &reg1,
                         const SbViewportRegion &reg2);
 
   friend int operator !=( const SbViewportRegion &reg1, const SbViewportRegion &reg2 )
  {
    return !operator==( reg1, reg2 );
  }
 
 private:
 
  SbViewportRegion(SbVec2s viewSize, SbVec2s winSize, float newScale = 1.0);
 
  void setViewportScale(float vpScale)
    { viewportScale = vpScale; }
 
  float getViewportScale() const
    {return viewportScale; }
 
  static const float s_historicalPixelPerInch;
  static float s_defaultPixelsPerInch;
  static void setDefaultPixelsPerInch(float ppi)
    { s_defaultPixelsPerInch = ppi; }
  
 private:
  SbVec2i32 windowSize_i32;  // Window size in pixels
  SbVec2s   windowSize;      // Window size in pixels
  SbVec2f   vpOrigin;        // Viewport origin, normalized
  SbVec2s   vpOriginPix;     // Viewport origin in pixels
  SbVec2i32 vpOriginPix_i32; // Viewport origin in pixels
  SbVec2f   vpSize;          // Viewport size, normalized
  SbVec2s   vpSizePix;       // Viewport size in pixels
  SbVec2i32 vpSizePix_i32;   // Viewport size in pixels
  SbBool    vpSet;           // TRUE if viewport was set explicitly
  float     pixelsPerInch;   // Number of pixels per inch
  float     viewportScale;   // Viewport scale (used for remote rendering)
  
  // Sets viewport to be full window
  void setFullViewport();
  
  // Adjusts viewport pixel size based on new window size or new viewport
  void adjustViewport();
};
 
class  SoGetView {
 public:
  SoGetView();
  virtual ~SoGetView() {};
 
  virtual SbBool getViewportIsEnabled() const;
 
  virtual const SbVec2f getViewportOrigin() const;
 
  virtual const SbVec2f getViewportSize() const;
};
 
#endif /* _SB_VIEWPORT_REGION_ */