Inventor/SoOffscreenRenderer.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      : Dave Immel (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)
**               Tristan Mehamli (DEC 2011)
**=======================================================================*/


#ifndef _SO_OFFSCREEN_RENDERER_
#define _SO_OFFSCREEN_RENDERER_

#include <Inventor/SbColorRGBA.h>
#include <Inventor/SbColor.h>
#include <Inventor/SbViewportRegion.h>
#include <Inventor/SbLinear.h>
#include <Inventor/SbPList.h>
#include <Inventor/threads/SbThreadSpinlock.h>
#include <Inventor/components/SoGLGraphicConfigTemplate.h>
#include <Inventor/helpers/SbGlContextHelper.h>
#include <Inventor/sys/SoGLType.h>
#include <Inventor/nodes/SoFullSceneAntialiasing.h>

#include <stdio.h>
  #undef Display

class SoBase;
class SoNode;
class SoPath;
class SoGLRenderAction;
class SoPBuffer;
class SoOffscreenTileObserver;
class SoGLContext;
class SoGLGraphicConfigTemplate;
class SbRasterImage;
class SoRasterImageFile;
class SoRasterImageRW;
class SoOffRenderItem;

//
//  Class: SoOffscreenRenderer
//
//  This file contains the definition of the SoOffscreenRenderer class.
//  This class is used for rendering a scene graph to an offscreen memory
//  buffer which can be used for printing or generating textures.
//
//  The implementation of this class uses the X Pixmap for rendering.
//

class  SoOffscreenRenderer {

 public:
  SoOffscreenRenderer(const SbViewportRegion &viewportRegion);
  SoOffscreenRenderer(SoGLRenderAction *ra);

  ~SoOffscreenRenderer();

  enum Components {
    LUMINANCE = 1,
    LUMINANCE_TRANSPARENCY = 2,
    RGB = 3,
    RGBA = 4,
    RGB_TRANSPARENCY = 4
  };

  enum TIFFCompressionMode {
    NO_COMPRESSION,
    PACKBITS_COMPRESSION
  };

  typedef enum {
    RGB_BUFFER,
    JPEG_BUFFER/*,*/
    /*TIFF_BUFFER,*/
    /*PS_BUFFER,*/
    /*BMP_BUFFER,*/
  } BufferType;

  enum AbortCode {
    CONTINUE,
    ABORT
  };

  typedef AbortCode SoOffscreenAbortCB(void *userData, int numSubimage, int subimageCount);

  void setAbortCallback(SoOffscreenAbortCB *func, void *userData)
    { m_abortCB = func; m_abortData = userData; }

  static float getScreenPixelsPerInch();

  void setComponents(Components components);

  Components getComponents() const { return m_comps; }

  void    setMaxTileSize( SbVec2s size );
  void    setMaxSubimage( SbVec2s size );

  SbVec2s getMaxTileSize() const {
    return SbVec2s((short)m_tileSize[0],(short)m_tileSize[1]); }
  SbVec2s getMaxSubimage() const {
        return SbVec2s((short)m_tileSize[0],(short)m_tileSize[1]); }

  void setNumEdgePixels( int nb );
  int  getNumEdgePixels() const { return m_numEdgePixels; }

  void setViewportRegion(const SbViewportRegion &region);

  const SbViewportRegion &getViewportRegion() const;

  static SbVec2s getMaximumResolution();
  
  void setBackgroundColorRGBA(const SbColorRGBA& c);

  const SbColorRGBA& getBackgroundColorRGBA() const { return m_backgroundColorRGBA; }
  
  void setBackgroundColor(const SbColor &c);
  const SbColor &getBackgroundColor() const { return m_backgroundColor; }

  void setGLRenderAction(SoGLRenderAction *ra);
  SoGLRenderAction *getGLRenderAction() const;

  SbBool render(SoNode *scene);
  SbBool render(SoPath *scene);


  void setRegion(const SbVec2s& origin, const SbVec2s& size);

  void setRegion_i32(const SbVec2i32& origin, const SbVec2i32& size);

  unsigned char *getBuffer(BufferType buffType = SoOffscreenRenderer::RGB_BUFFER);

  size_t getBufferSize(BufferType buffType = SoOffscreenRenderer::RGB_BUFFER);

  SbBool writeToRGB(FILE *fp) const;

  SbBool writeToRGB(const SbString& filename) const;

  SbBool writeToPostScript(FILE *fp) const;

  SbBool writeToPostScript(const SbString& filename) const;

  SbBool writeToPostScript(FILE *fp, const SbVec2f &printSize) const;

  SbBool writeToPostScript(const SbString& filename, const SbVec2f &printSize) const;

  /*************************************************************************************/
  // TIFF output
  /*************************************************************************************/
  // This software is based in part on the work of Sam Leffler / Silicon Graphics Inc.
  // Copyright (c) 1988-1996 Sam Leffler
  // Copyright (c) 1991-1996 Silicon Graphics, Inc.
  SbBool writeToTIFF(FILE *fp, TIFFCompressionMode TIFFcm = PACKBITS_COMPRESSION) const;

  SbBool writeToTIFF(const SbString& filename, TIFFCompressionMode TIFFcm = PACKBITS_COMPRESSION) const;

  /*************************************************************************************/
  // JPEG output
  /*************************************************************************************/
  // This software is based in part on the work of the Independent JPEG Group
  // Copyright (C) 1991-1998, Thomas G. Lane.
  SbBool writeToJPEG(FILE *fp, float quality = 1.0) const;

  SbBool writeToJPEG(const SbString& filename, float quality = 1.0) const;

  SbBool writeToPNG(FILE *fp) const;

  SbBool writeToPNG(const SbString& filename) const;

  SbBool writeToBMP(FILE *fp) const;

  SbBool writeToBMP(const SbString& filename);

  SbBool writeToRaster(FILE *fp, SoRasterImageRW* imageWriter);

  SbBool writeToRaster(const SbString& filename, SoRasterImageRW* imageWriter);

  void setTileObserver(SoOffscreenTileObserver* tileObserver);


  const HDC &getDC() const;

  void setColorDepth(int nbits);

  int getColorDepth() const { return m_nCurrentColorDepth; }

  void setPbufferEnable( SbBool enable );

  SbBool getPbufferEnable() const { return m_pbufferEnable; }


  SoGLGraphicConfigTemplate* getGraphicConfigTemplate();


  void setGraphicConfigTemplate(SoGLGraphicConfigTemplate* gTemplate);


  void setFullSceneAntialiasing( SoGraphicConfigTemplate::Preference pref,
                                 int minFsaaBits = 0,
                                 int maxFsaaBits = INT_MAX );

  void setFullSceneAntialiasing( SbBool enable,
                                 float quality = -1.0,
                                 int filterMask = SoFullSceneAntialiasing::ALL );

  SoGraphicConfigTemplate::Preference getFullSceneAntialiasing( int &minFsaaBits,
                                                                int &maxFsaaBits) const;

  SbBool isFullSceneAntialiasing(float& quality);

  void setShareContext(const SbGLShareContext shareCxt);


  const SbGLShareContext getShareContext() const;



 private:

  SbBool setupPixmap();

  const SoPBuffer *getPBuffer() const { return m_pbuffer; }


 private:
  SbBool isLargeImage() {return m_largeImage;};
  SbBool isMultiTiled() {return m_multiTiled;};

  SoGLContext* m_glContext;

private:
  unsigned char* m_pixelBuffer;
  int m_pixelBufferSize;
  unsigned char* m_jpegBuffer;
  size_t m_jpegBufferSize;
  Components m_comps;
  SbColor m_backgroundColor;
  SbColorRGBA m_backgroundColorRGBA;
  // This indicates the dimensions of the maximum subimage used for rendering
  SbVec2i32 m_tileSize;


  SbVec2i32 m_previousSubTileBufferSize;

  // Number of pixels on the edge of each subimage that are not written on the big image
  int m_numEdgePixels;

  SoOffscreenTileObserver* m_tileObserver;

  // Variables for render abort:
  SoOffscreenAbortCB*    m_abortCB;       // Callback to test abort
  void *m_abortData;      // User data for abort callback

  SbViewportRegion m_vpRegion;

  SbVec2i32 m_regionOrigin;
  SbVec2i32 m_regionSize;
  SbBool  m_isRegion;

  // Share context
  SbGLShareContext m_glShareContext;

  SbGlContextHelper::GLContext m_savedCtx;

#ifdef _WIN32
  // These are used for rendering to the offscreen bitmap
  HDC      m_hDC;        // Memory device context
  HGLRC    m_context;    // Analog of GLXContext
  HBITMAP  m_hBitmap;    // Analog of GLXPixmap
  HBITMAP  m_hOldBitmap;
  HPALETTE m_hOldPalette;


  // Initialize an offscreen bitmap (DIBsection)
  // Note a lot of things have to be returned (eg. theOldBitmap)
  // so we can proper cleanup of the Win32 objects later.
  static SbBool initPixmap(SoOffscreenRenderer* offscreen,
                           HDC &theDC,
                           PIXELFORMATDESCRIPTOR &thePFD,
                           HGLRC &cx,
                           const SbVec2i32 &sz,
                           HBITMAP &theBitmap,
                           HBITMAP &theOldBitmap,
                           HPALETTE &theOldPalette);


#elif defined(__APPLE__)

  //Avoid including OpenGL.h
  typedef struct _CGLPBufferObject* CGLPBufferObj;

  // These are used for rendering to the offscreen pixmap
  CGLContextObj  m_context;

  CGLPBufferObj m_cglPbuffer;

  // Initialize an offscreen pixmap
  static SbBool initPixmap(SoOffscreenRenderer* offscreen,
                           CGLContextObj& cx,
                           const SbVec2i32 &sz,
                           CGLPBufferObj& pbuffer);

#else
  /* UNIX */
  // These are used for rendering to the offscreen pixmap
  SbGlContextHelper::Display    m_display;
  SbGlContextHelper::VisualInfo m_visual;
  GLXContext  m_context;
  GLXPixmap   m_pixmap;
  Pixmap      m_pmap;


  // Initialize an offscreen pixmap
  static SbBool initPixmap(SoOffscreenRenderer* offscreen,
                           Display * &dpy, SbGlContextHelper::VisualInfo &vi,
                           GLXContext &cx, const SbVec2i32 &sz,
                           GLXPixmap &glxPmap, Pixmap &xpmap);


#endif

  SbGlContextHelper::Display  m_pBufferDisplay;


  SoPBuffer *m_pbuffer;
  SbBool     m_pbufferEnable; // are we allowed to use a Pbuffer

  int m_nRequestedColorDepth;
  int m_nCurrentColorDepth;

  // Query OpenGL
  static int    m_maxGlRenderSize;
  static SbBool m_maxGlRenderSizeFlag;
  static SbBool getMaxRenderSize();

  // Initialize a Pbuffer for rendering
  static SbBool initPbuffer( SoOffscreenRenderer* osr, SbGlContextHelper::Display &display,
                             const SbVec2i32 &sz, SoPBuffer* &pbuffer );

  // Read pixels back from the Pixmap
  void readPixels();

  // Compute array size in uncompressed format and set the GL image format
  void getAllocSizeAndFormat(size_t& allocSize, GLenum& format);

  // Set the graphics context
  SbBool bindContext();

  SbBool unbindContext();

  // Return the format used in the rendering
  GLenum getGLformat(void) const;

  // Returns TRUE if render action should abort based on callback
  SbBool checkAbort(int numSubimage, int subimageCount);

  // Function called by both render(SoNode) and render(SoPath) : the code was similar.
  // Render the given scene into a buffer
  SbBool renderNodeOrPath(SoBase *scene);

  SbBool doSubTile(SbVec2i32& pixelOffset, SbVec2i32& offset, SbVec2i32& renderSize, SbVec2i32& subTileBufferSize,
                   SbVec2i32& lastSubTileBufferSize, SbVec2i32& numSubTiles, SoRasterImageRW* imageWriter,
                   unsigned char*& tileBuffer, int totalNumTiles, unsigned char*& edgedSubTileBuffer,
                   SbRasterImage* rasterImage, SoRasterImageFile* imageFile, SbVec2i32& vpSize, GLenum format);

  // Use multiple buffers
  SbBool m_multiTiled;

  SbBool m_largeImage;

  SoBase* m_scene;

  static void putHex(FILE *fp, unsigned char val, int &hexPos);
  int m_savedContextID;

  void commonConstructor(SoGLRenderAction* act, SbBool defaultRA = FALSE);
  SbBool m_shareContextSuccessful;
  SoGLGraphicConfigTemplate* m_currentGraphicConfigTemplate;

  void checkTilingConditions();
  bool evalTilesSizes( SbVec2i32& subTileBufferSize, SbVec2i32& lastSubTileBufferSize, SbVec2i32& numSubTiles ) const;
  void checkTileSizeAgainstConstraints( SbVec2i32& tileSize ) const;
  
  bool m_isCurrentGraphicConfigTemplateOwner;

  SbBool m_currentGraphicConfigTemplateChanged;

  // Anti aliasing
  int m_minFsaaBits;
  int m_maxFsaaBits;
  SoGraphicConfigTemplate::Preference m_fsaaPref;
  SbBool m_isFsaaEnable;

private:
  // The list of offscreen renderers and their render actions
  static SoOffRenderItem* findOffRender(const SoOffscreenRenderer *rnd);
  static const SbViewportRegion& getCorrectVP(const SoOffscreenRenderer *rnd);

  // writeTo* mathods using a SoRasterImageFile
  SbBool writeImageFileToRGB( SoRasterImageFile* imageFile );
  SbBool writeImageFileToBMP( SoRasterImageFile* imageFile );
  SbBool writeImageFileToPNG( SoRasterImageFile* imageFile );
  SbBool writeImageFileToJPEG( SoRasterImageFile* imageFile, float quality );
  SbBool writeImageFileToTIFF( SoRasterImageFile* imageFile, TIFFCompressionMode TIFFcm );
  SbBool writeImageFileToPostScript( SoRasterImageFile* imageFile );
  SbBool writeImageFileToPostScript( SoRasterImageFile* imageFile, const SbVec2f &printSize );
  SbBool writeImageFileToRaster( SoRasterImageFile* imageFile, SoRasterImageRW* imageWriter );

  static SbThreadSpinlock s_renderListMutex;
  static SbPList s_renderList;

  int m_filterMask;
};



#include <Inventor/SoOffscreenRenderer.h>

class  SoOffscreenTileProperty {

public:

  const SbVec2i32& getOrigin() const;


  const SbVec2i32& getSize() const;

  const unsigned char* getBuffer(int& bufferSize) const;


  int getTileCount() const;



private:

  void setOrigin(SbVec2i32& origin);
  void setSize(SbVec2i32& size);
  void setBuffer(const unsigned char* buffer, int bufferSize);
  void setTileCount(int count);

private:
  SbVec2i32 m_origin;
  SbVec2i32 m_size;
  const unsigned char* m_buffer;
  int m_tileCount;
  int m_bufferSize;
};


class  SoOffscreenTileObserver {

public:
  virtual ~SoOffscreenTileObserver() {}

  virtual SoOffscreenRenderer::AbortCode tileUpdated(SoOffscreenRenderer* offscreen,
                                                     SoOffscreenTileProperty* tileProperty,
                                                     int numTiles) = 0;
};




#endif // _SO_OFFSCREEN_RENDERER_

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/