SoOffscreenRenderer

java.lang.Object
- com.openinventor.inventor.Inventor
- - com.openinventor.inventor.SoOffscreenRenderer

```
public class SoOffscreenRenderer
extends Inventor
```
Renders to an off-screen buffer for printing or generating textures. This class is used to render into an off-screen buffer to create a printable image or to generate a texture image. It uses a Pbuffer (if possible) or an off-screen bitmap for rendering. Methods are provided to write the buffer to a file, as an RGB image, an encapsulated PostScript description, or in one of several other image formats.
<font color="#0000FF">NOTE:</font> This class does not exist in Open Inventor 10.0 and later. Replace with SoOffscreenRenderArea.
The renderer can generate images of any size. If the requested image size exceeds OpenGL rendering capabilities, the image will be created by automatically rendering some number of "tiles" and "stitching" them together. See setMaxTileSize for details. Using tiles allows you to create very large, very high resolution images. For example, a poster size image to be printed at 300 dpi would need to be (approximately) 10,000 pixels wide.
The renderer can generate images with a transparent background (as long as there is an OpenGL render format available that supports an alpha buffer). See setBackgroundColorRGBA(). Note that you must also call setComponents() with the parameter set to RGBA (setBackgroundColorRGBA does not do this automatically).
Some output file formats are much more efficient than others at dealing with tiled output. If you anticipate generating very large images, it may be helpful to chose an output format that can generate tiled output efficiently. The formats in the "WRITE_SCANLINES" column in the following table are more efficient at generating tiled output.
For the WRITE_FULL_IMAGE formats, the entire image must be written at once, so a buffer large enough for the whole image is allocated, and tiles are copied into it. Therefore it must be possible to allocate enough memory for a single tile (num_components * tile_width * tile_height) plus enough memory to assemble the complete image (num_components * width * height).
For the WRITE_SCANLINES formats, the image can be written incrementally, some number of scanlines at a time. Therefore it is only necessary to allocate enough memory for a single tile, which at most will be the size of the maximum OpenGL viewport (typically 2048x2048).
See the documentation for SoRasterImageRW and the individual image classes (SoBMPImageRW, SoGIFImageRW, etc.) for further information.
PBuffers
Beginning with Open Inventor 3.1, this class will automatically try to use an OpenGL Pbuffer for rendering. If a Pbuffer is available, rendering will be accelerated by the 3D graphics hardware. If no Pbuffer is available, rendering will use a software rendered off-screen buffer as before. Pbuffers are a standard feature of OpenGL 1.2 and are often available as an extension on older versions of OpenGL. However it is not guaranteed that Pbuffers will be available or that a Pbuffer of the desired size can be created.
Rendering with a Pbuffer will generally produce the same image as would be rendered on the screen, but this is not guaranteed. In general, software rendering will produce the same image as on-screen if only OpenGL 1.1 features are used. Newer OpenGL features and extensions will generally not be available using software rendering.
Note that Pbuffers are a limited resource. If the application creates multiple instances of SoOffscreenRenderer, it may be desirable to prevent some of them (that are lower priority or render small scene graphs) from using a Pbuffer. See the method setPbufferEnable().
Rendering contexts
The setShareContext method allows you to share an already existing OpenGL context with the offscreen renderer. This avoids the necessity to re-generate textures and display lists if they are already available in another OpenGL context (the viewer context, for instance). This can dramatically reduce offscreen rendering time, depending on your scene graph.
A corresponding query method (getShareContext) is also available.
Here's how you might use these methods to share OpenGL contexts:
```
 renderer.setShareContext( viewer.getArea().getGLSharedContext() );
```
Rendering a "snapshot"
SoOffscreenRenderer is often used to save a snapshot of the image in the viewer window. There are several common pitfalls. First, the scene graph given to the renderer must include the camera node that the viewer is using. If the application allows the viewer to create a camera automatically, the scene graph returned by the viewer's getSceneGraph() method does not include the camera. It's always safer to get the SoSceneManager object then get the scene graph. Second, some rendering options are set on the viewer object, not in the scene graph. These options, which include background color and transparency mode, must be explicitly queried from the viewer and set on the renderer object.
Sample code to make a snapshot, given a viewer object, might look like this:
```
 // Make image same size and shape as viewer image
 SoOffscreenRenderer renderer = new SoOffscreenRenderer( viewer.getArea().getViewportRegion() );
 
 // Transfer viewer settings to renderer
 renderer.setShareContext( viewer.getArea().getGLSharedContext() );
 renderer.setBackgroundColor( viewer.getArea().getBackgroundColor() );
 renderer.getGLRenderAction().setTransparencyType( viewer.getArea().getTransparencyType() );
 
 // Render scene (including camera and headlight)
 renderer.render( viewer.getArea().getSceneManager().getSceneGraph() );
 
 // Write image to a file in PNG format
 renderer.writeToPNG( "output.png" );
```
See: $OIVJHOME/demos/inventor/mentor/print
NOTE: Tiled rendering does not currently work correctly when a camera node's viewportMapping field is set to one of the CROP_ options. It does work correctly with the LEAVE_ALONE and ADJUST_CAMERA (default) settings.
SoOffscreenRenderer is useful because it allows the image size to be specified (e.g. different than the on-screen window) and because it can render images of almost any size (much larger than the physical screen). However it does require an additional render traversal to create the image. For a simple snapshot of an on-screen window it may be more efficient to use the saveSnapshot() method in the So___GLWidget class (e.g. SoWinGLWidget).
See also:
SoRasterImageRW

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`SoOffscreenRenderer.AbortCodes` Possible return codes from a render abort callback.
`static class`	`SoOffscreenRenderer.BufferTypes` Buffer types.
`static class`	`SoOffscreenRenderer.Components` Components.
`static class`	`SoOffscreenRenderer.TIFFCompressionModes` TIFF Compression modes.

Nested classes/interfaces inherited from class com.openinventor.inventor.Inventor
Inventor.ConstructorCommand

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ABORT` Deprecated. Use `SoOffscreenRenderer.AbortCodes.ABORT` instead.
`static int`	`CONTINUE` Deprecated. Use `SoOffscreenRenderer.AbortCodes.CONTINUE` instead.
`static int`	`JPEG_BUFFER` Deprecated. Use `SoOffscreenRenderer.BufferTypes.JPEG_BUFFER` instead.
`static int`	`LUMINANCE` Deprecated. Use `SoOffscreenRenderer.Components.LUMINANCE` instead.
`static int`	`LUMINANCE_TRANSPARENCY` Deprecated. Use `SoOffscreenRenderer.Components.LUMINANCE_TRANSPARENCY` instead.
`static int`	`NO_COMPRESSION` Deprecated. Use `SoOffscreenRenderer.TIFFCompressionModes.NO_COMPRESSION` instead.
`static int`	`PACKBITS_COMPRESSION` Deprecated. Use `SoOffscreenRenderer.TIFFCompressionModes.PACKBITS_COMPRESSION` instead.
`static int`	`RGB` Deprecated. Use `SoOffscreenRenderer.Components.RGB` instead.
`static int`	`RGB_BUFFER` Deprecated. Use `SoOffscreenRenderer.BufferTypes.RGB_BUFFER` instead.
`static int`	`RGB_TRANSPARENCY` Deprecated. Use `SoOffscreenRenderer.Components.RGB_TRANSPARENCY` instead.
`static int`	`RGBA` Deprecated. Use `SoOffscreenRenderer.Components.RGBA` instead.

Fields inherited from class com.openinventor.inventor.Inventor
VERBOSE_LEVEL, ZeroHandle

Constructor Summary

Constructors
Constructor and Description

SoOffscreenRenderer(SbViewportRegion viewportRegion)
Constructor.

SoOffscreenRenderer(SoGLRenderAction ra)
Constructor.

Constructors
Constructor and Description
`SoOffscreenRenderer(SbViewportRegion viewportRegion)` Constructor.
`SoOffscreenRenderer(SoGLRenderAction ra)` Constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SbColor`	`getBackgroundColor()` Returns the background color for rendering.
`SbColorRGBA`	`getBackgroundColorRGBA()` Returns the RGBA background color for rendering.
`byte[]`	`getBuffer()` Calls getBuffer(SoOffscreenRenderer.BufferTypes.valueOf( SoOffscreenRenderer.BufferTypes.RGB_BUFFER.getValue() )).
`byte[]`	`getBuffer(SoOffscreenRenderer.BufferTypes buffType)` Returns a buffer containing the rendered image.
`long`	`getBufferSize()` Calls getBufferSize(SoOffscreenRenderer.BufferTypes.valueOf( SoOffscreenRenderer.BufferTypes.RGB_BUFFER.getValue() )).
`long`	`getBufferSize(SoOffscreenRenderer.BufferTypes buffType)` Returns the buffer size in bytes.
`int`	`getColorDepth()` Gets the color depth to be used for offscreen rendering.
`SoOffscreenRenderer.Components`	`getComponents()` Returns the components to be rendered.
`float`	`getFullSceneAntialiasingQuality()` Returns true if FSAA is currently enabled.
`SoGLRenderAction`	`getGLRenderAction()` Gets the render action to use for rendering.
`static SbVec2s`	`getMaximumResolution()` Gets the maximum supported resolution of the viewport.
`SbVec2s`	`getMaxSubimage()` Synonym for `getMaxTileSize`.
`SbVec2s`	`getMaxTileSize()` Gets the maximum subimage (tile) size for rendering.
`int`	`getNumEdgePixels()` Gets the number of pixels on the edge of each subimage that are not written on the big image (overlapped pixels).
`boolean`	`getPbufferEnable()` Returns true if a Pbuffer may be used for rendering.
`static float`	`getScreenPixelsPerInch()` Returns the number of pixels per inch (in the horizontal direction) of the current X device screen.
`SbGLShareContext`	`getShareContext()` Gets the OpenGL context shared by the `SoOffscreenRenderer`.
`SbViewportRegion`	`getViewportRegion()` Returns the viewport region used for rendering.
`boolean`	`isFullSceneAntialiasing()` Returns true if FSAA is currently enabled.
`boolean`	`render(SoNode scene)` Renders the given scene, specified as a node, into an off-screen buffer.
`boolean`	`render(SoPath scene)` Renders the given scene, specified as a path, into an off-screen buffer.
`void`	`setBackgroundColor(SbColor c)` Sets the RGB background color for rendering.
`void`	`setBackgroundColorRGBA(SbColorRGBA c)` Sets the RGBA background color for rendering.
`void`	`setColorDepth(int nbits)` Sets the color depth to be used for offscreen rendering.
`void`	`setComponents(SoOffscreenRenderer.Components components)` Sets the components to be rendered.
`void`	`setFullSceneAntialiasing(boolean enable)` Calls setFullSceneAntialiasing(enable, (float)-1.0, (int)com.openinventor.inventor.nodes.SoFullSceneAntialiasing.ALL).
`void`	`setFullSceneAntialiasing(boolean enable, float quality)` Calls setFullSceneAntialiasing(enable, quality, (int)com.openinventor.inventor.nodes.SoFullSceneAntialiasing.ALL).
`void`	`setFullSceneAntialiasing(boolean enable, float quality, int filterMask)` Sets the full-scene antialiasing preferences.
`void`	`setGLRenderAction(SoGLRenderAction ra)` Sets the render action to use for rendering.
`void`	`setMaxSubimage(SbVec2s size)` Synonym for `setMaxTileSize`.
`void`	`setMaxTileSize(SbVec2s size)` Sets the maximum subimage (tile) size for rendering.
`void`	`setNumEdgePixels(int nb)` Sets the number of pixels on the edge of each subimage that are not written on the big image (overlapped pixels).
`void`	`setPbufferEnable(boolean enable)` Specifies if a Pbuffer may be used for rendering.
`void`	`setRegion(SbVec2s origin, SbVec2s size)` Sets a subregion of the viewport to be rendered.
`void`	`setRegioni32(SbVec2i32 origin, SbVec2i32 size)` Sets a subregion of the viewport to be rendered.
`void`	`setShareContext(SbGLShareContext shareCxt)` Sets the OpenGL context to be shared by the `SoOffscreenRenderer`.
`void`	`setTileObserver(SoOffscreenTileObserver tileObserver)` Specifies a tile observer object which will be called after each tile is rendered.
`void`	`setViewportRegion(SbViewportRegion region)` Sets the viewport region used for rendering.
`boolean`	`writeToBMP(java.lang.String filename)` This method has no effect on UNIX systems.
`boolean`	`writeToJPEG(java.lang.String filename)` Calls writeToJPEG(filename, (float)1.0).
`boolean`	`writeToJPEG(java.lang.String filename, float quality)` Writes the buffer as a JPEG file to the given filename.
`boolean`	`writeToJPEGBuffer(float quality)` Writes the JPEG compression stream to a buffer.
`boolean`	`writeToPNG(java.lang.String filename)` Writes the buffer as a PNG file to the given filename.
`boolean`	`writeToPostScript(java.lang.String filename)` Writes the buffer as encapsulated PostScript to the given filename.
`boolean`	`writeToPostScript(java.lang.String filename, SbVec2f printSize)` Writes the buffer as encapsulated PostScript to the given filename.
`boolean`	`writeToRaster(java.lang.String fp, SoRasterImageRW imageWriter)` Writes the buffer using the image writer class passed as the second parameter.
`boolean`	`writeToRGB(java.lang.String filename)` Writes the buffer as an .rgb file to the given filename.
`boolean`	`writeToTIFF(java.lang.String filename)` Calls writeToTIFF(filename, SoOffscreenRenderer.TIFFCompressionModes.valueOf( SoOffscreenRenderer.TIFFCompressionModes.PACKBITS_COMPRESSION.getValue() )).
`boolean`	`writeToTIFF(java.lang.String filename, SoOffscreenRenderer.TIFFCompressionModes TIFFcm)` Writes the buffer as a TIFF file to the given filename.

Methods inherited from class com.openinventor.inventor.Inventor
dispose, getAddress, getNativeResourceHandle, startInternalThreads, stopInternalThreads

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LUMINANCE
```
@Deprecated
public static final int LUMINANCE
```
    Deprecated. Use SoOffscreenRenderer.Components.LUMINANCE instead.
  - LUMINANCE_TRANSPARENCY
```
@Deprecated
public static final int LUMINANCE_TRANSPARENCY
```
    Deprecated. Use SoOffscreenRenderer.Components.LUMINANCE_TRANSPARENCY instead.
  - RGB
```
@Deprecated
public static final int RGB
```
    Deprecated. Use SoOffscreenRenderer.Components.RGB instead.
  - RGBA
```
@Deprecated
public static final int RGBA
```
    Deprecated. Use SoOffscreenRenderer.Components.RGBA instead.
  - RGB_TRANSPARENCY
```
@Deprecated
public static final int RGB_TRANSPARENCY
```
    Deprecated. Use SoOffscreenRenderer.Components.RGB_TRANSPARENCY instead.
  - NO_COMPRESSION
```
@Deprecated
public static final int NO_COMPRESSION
```
    Deprecated. Use SoOffscreenRenderer.TIFFCompressionModes.NO_COMPRESSION instead.
  - PACKBITS_COMPRESSION
```
@Deprecated
public static final int PACKBITS_COMPRESSION
```
    Deprecated. Use SoOffscreenRenderer.TIFFCompressionModes.PACKBITS_COMPRESSION instead.
  - RGB_BUFFER
```
@Deprecated
public static final int RGB_BUFFER
```
    Deprecated. Use SoOffscreenRenderer.BufferTypes.RGB_BUFFER instead.
  - JPEG_BUFFER
```
@Deprecated
public static final int JPEG_BUFFER
```
    Deprecated. Use SoOffscreenRenderer.BufferTypes.JPEG_BUFFER instead.
  - CONTINUE
```
@Deprecated
public static final int CONTINUE
```
    Deprecated. Use SoOffscreenRenderer.AbortCodes.CONTINUE instead.
  - ABORT
```
@Deprecated
public static final int ABORT
```
    Deprecated. Use SoOffscreenRenderer.AbortCodes.ABORT instead.
- Constructor Detail
  - SoOffscreenRenderer
```
public SoOffscreenRenderer(SoGLRenderAction ra)
```
    Constructor. The render action passed to the constructor will be used in all subsequent offscreen renderings.
  - SoOffscreenRenderer
```
public SoOffscreenRenderer(SbViewportRegion viewportRegion)
```
    Constructor. An internal instance of an SoGLRenderAction will be maintained with a viewport region set to the one passed in by the constructor.
- Method Detail
  - writeToJPEGBuffer
```
public boolean writeToJPEGBuffer(float quality)
```
    Writes the JPEG compression stream to a buffer.
    Previous JPEG buffers are deleted and a new one is created. getBuffer(JPEG_BUFFER) returns this jpeg buffer, and getBufferSize() returns this buffer size.
    
    Parameters:
    
    quality - 1.0 is the best quality with the least compression, 0.0 is the worst quality with the most compression. A typical value for quality is 0.7.
    
    Since:
    
    Open Inventor 9.1
  - getBuffer
```
public byte[] getBuffer()
```
    Calls getBuffer(SoOffscreenRenderer.BufferTypes.valueOf( SoOffscreenRenderer.BufferTypes.RGB_BUFFER.getValue() )).
  - writeToJPEG
```
public boolean writeToJPEG(java.lang.String filename)
```
    Calls writeToJPEG(filename, (float)1.0).
  - writeToTIFF
```
public boolean writeToTIFF(java.lang.String filename)
```
    Calls writeToTIFF(filename, SoOffscreenRenderer.TIFFCompressionModes.valueOf( SoOffscreenRenderer.TIFFCompressionModes.PACKBITS_COMPRESSION.getValue() )).
  - setFullSceneAntialiasing
```
public void setFullSceneAntialiasing(boolean enable,
                                     float quality)
```
    Calls setFullSceneAntialiasing(enable, quality, (int)com.openinventor.inventor.nodes.SoFullSceneAntialiasing.ALL).
  - setFullSceneAntialiasing
```
public void setFullSceneAntialiasing(boolean enable)
```
    Calls setFullSceneAntialiasing(enable, (float)-1.0, (int)com.openinventor.inventor.nodes.SoFullSceneAntialiasing.ALL).
  - getBufferSize
```
public long getBufferSize()
```
    Calls getBufferSize(SoOffscreenRenderer.BufferTypes.valueOf( SoOffscreenRenderer.BufferTypes.RGB_BUFFER.getValue() )).
  - setBackgroundColor
```
public void setBackgroundColor(SbColor c)
```
    Sets the RGB background color for rendering. The default is (0,0,0) = opaque black. The default value can be set using the environment variable OIV_BACKGROUND_COLOR. Specify three floats (R, G, B) in the range 0. to 1., separated by spaces. See also setBackgroundColorRGBA().
  - setGLRenderAction
```
public void setGLRenderAction(SoGLRenderAction ra)
```
    Sets the render action to use for rendering.
  - getBackgroundColor
```
public SbColor getBackgroundColor()
```
    Returns the background color for rendering.
  - getViewportRegion
```
public SbViewportRegion getViewportRegion()
```
    Returns the viewport region used for rendering.
  - setBackgroundColorRGBA
```
public void setBackgroundColorRGBA(SbColorRGBA c)
```
    Sets the RGBA background color for rendering. The default is (0,0,0,1) = opaque black. The default RGB color (but NOT alpha) can be set using the environment variable OIV_BACKGROUND_COLOR. See also setBackgroundColor().
    Notes:
    - To generate an image with a transparent background (alpha = 0), you must call this method and also call setComponents() with RGBA.
    - Some image file formats, e.g. JPEG, do not support an alpha channel. Use PNG or TIFF to save images with a transparent background.
  - setViewportRegion
```
public void setViewportRegion(SbViewportRegion region)
```
    Sets the viewport region used for rendering. This will NOT be applied to the viewport region of any render action passed in.
  - getBackgroundColorRGBA
```
public SbColorRGBA getBackgroundColorRGBA()
```
    Returns the RGBA background color for rendering.
  - getNumEdgePixels
```
public int getNumEdgePixels()
```
    Gets the number of pixels on the edge of each subimage that are not written on the big image (overlapped pixels).
  - setComponents
```
public void setComponents(SoOffscreenRenderer.Components components)
```
    Sets the components to be rendered.
    Default is RGB. Alpha values will not be available if OpenGL does not provide any pixel formats with an alpha buffer. Some image file formats, for example JPEG, do not support alpha values. If you write to one of these formats only the RGB components will be saved.
  - writeToRaster
```
public boolean writeToRaster(java.lang.String fp,
                             SoRasterImageRW imageWriter)
```
    Writes the buffer using the image writer class passed as the second parameter. This is a general interface for writing the image buffer to a file. All the file format-specific writeTo methods actually call this method. See classes SoXXXImageRW (e.g., SoBMPImageRW, etc.).
  - getFullSceneAntialiasingQuality
```
public float getFullSceneAntialiasingQuality()
```
    Returns true if FSAA is currently enabled. Also returns the current quality value.
  - getComponents
```
public SoOffscreenRenderer.Components getComponents()
```
    Returns the components to be rendered.
  - getMaxSubimage
```
public SbVec2s getMaxSubimage()
```
    Synonym for getMaxTileSize.
  - setNumEdgePixels
```
public void setNumEdgePixels(int nb)
```
    Sets the number of pixels on the edge of each subimage that are not written on the big image (overlapped pixels). The default value is two pixels. Some overlap is usually required to avoid visual "artifacts" at the subimage boundaries. One source of artifacts is that when OpenGL clips lines, it draws a line between the points where the line exits and re-enters the visible region. This additional segment is not part of the actual geometry. A two pixel overlap will hide this undesired segment unless the line width is greater than two, in which case you may need to specify a larger overlap.
  - getMaxTileSize
```
public SbVec2s getMaxTileSize()
```
    Gets the maximum subimage (tile) size for rendering.
  - setMaxTileSize
```
public void setMaxTileSize(SbVec2s size)
```
    Sets the maximum subimage (tile) size for rendering. The default value is 1984 by 1984. This corresponds to the typical maximum image that OpenGL can render, 2048 by 2048 on low end GPU, minus a 32-pixel overlap on each edge.
    The maximum tile size that is set should not exceed the maximum image size that OpenGL can render (implementation and/or hardware dependent) minus two times the number of edge pixels (see below).
    Note that GPU memory consumption of some nodes, like SoVolumeRender, depends on viewport size because they need to allocate Frame buffer objects. If you experiment over GPU memory consumption, try to decrease the MaxTileSize.
  - setMaxSubimage
```
public void setMaxSubimage(SbVec2s size)
```
    Synonym for setMaxTileSize.
  - writeToJPEG
```
public boolean writeToJPEG(java.lang.String filename,
                           float quality)
```
    Writes the buffer as a JPEG file to the given filename.
    If the given file does not exist or cannot be opened, the JPEG compression stream is written to a buffer. Previous JPEG buffers are deleted and a new one is created. The getBuffer method returns this buffer, and getBufferSize returns this buffer size.
    
    Parameters:
    
    filename - the filename to save the result to.
    
    quality - Specifies the quality of the compression. 1.0 is the best quality with the least compression. 0.0 is the worst quality with the most compression. A typical value for quality is 0.7.
    
    Since:
    
    Open Inventor 9.0
  - setFullSceneAntialiasing
```
public void setFullSceneAntialiasing(boolean enable,
                                     float quality,
                                     int filterMask)
```
    Sets the full-scene antialiasing preferences.
    
    Note: Use the SoFullSceneAntialiasing node to control FSAA during render traversal.
    
    Parameters:
    
    enable - Enables or disables FSAA rendering.
    
    quality - Specifies the level of quality of the antialiasing rendering. The number of samples used in the antialiasing computation depends on your graphics hardware and on your video driver. NVidia graphics hardware can support number of samples * 2 levels of quality (assuming the NV_multisample_filter_hint OpenGL extension is available).
    The quality value is in the [0..1] interval. 0 is the lowest quality level and 1 is the highest quality level. When set to -1.0 the quality value is the default value for the pixel format.
    
    filterMask - Specifies the types of shapes that should be antialiased (See SoFullSceneAntialiasing for more info.)
  - getPbufferEnable
```
public boolean getPbufferEnable()
```
    Returns true if a Pbuffer may be used for rendering.
  - writeToTIFF
```
public boolean writeToTIFF(java.lang.String filename,
                           SoOffscreenRenderer.TIFFCompressionModes TIFFcm)
```
    Writes the buffer as a TIFF file to the given filename.
    
    Since:
    
    Open Inventor 9.0
  - isFullSceneAntialiasing
```
public boolean isFullSceneAntialiasing()
```
    Returns true if FSAA is currently enabled. Also returns the current quality value.
  - writeToPNG
```
public boolean writeToPNG(java.lang.String filename)
```
    Writes the buffer as a PNG file to the given filename.
    
    Since:
    
    Open Inventor 9.0
  - setColorDepth
```
public void setColorDepth(int nbits)
```
    Sets the color depth to be used for offscreen rendering. Currently the only values allowed are 8 and 24 (the default is 24). This feature is useful if you want to do 256 color dithered rendering for printing. The change does not take effect until the next render() or setupPixmap () call.
    Note: WriteToBMP does not currently support 256 color bitmaps.
  - setTileObserver
```
public void setTileObserver(SoOffscreenTileObserver tileObserver)
```
    Specifies a tile observer object which will be called after each tile is rendered.
  - setPbufferEnable
```
public void setPbufferEnable(boolean enable)
```
    Specifies if a Pbuffer may be used for rendering. Pbuffers are a limited resource. If an application is using multiple offscreen renderers, it may better to use normal pixmap rendering for some of them. Must be called before the first call to render(). Default is true.
  - getColorDepth
```
public int getColorDepth()
```
    Gets the color depth to be used for offscreen rendering.
  - writeToBMP
```
public boolean writeToBMP(java.lang.String filename)
```
    This method has no effect on UNIX systems. </font> Writes the buffer as a "Windows RGB Encoded" .bmp file to the given filename.
    
    Since:
    
    Open Inventor 9.0
  - setShareContext
```
public void setShareContext(SbGLShareContext shareCxt)
```
    Sets the OpenGL context to be shared by the SoOffscreenRenderer. Its use is strongly recommended, because it can improve performance when switching between on-screen and off-screen rendering. This is because it allows the display lists and texture objects to be shared between the on-screen and off-screen render context. The shared context info is normally obtained by calling the viewer's getShareContext method.
    NOTE: It has no effect when the hardware (or driver) does not allow sharing with the off-screen context, for example if Pbuffers are not supported.
  - setRegion
```
public void setRegion(SbVec2s origin,
                      SbVec2s size)
```
    Sets a subregion of the viewport to be rendered. Units are pixels. For regions greater thatn 32767, use the setRegion_i32 method. The origin is relative to the lower left corner. Only this region will be rendered, returned by getBuffer, or written to a file.
  - setRegioni32
```
public void setRegioni32(SbVec2i32 origin,
                         SbVec2i32 size)
```
    Sets a subregion of the viewport to be rendered. Units are pixels. The origin is relative to the lower left corner. Only this region will be rendered, returned by getBuffer, or written to a file.
  - getBuffer
```
public byte[] getBuffer(SoOffscreenRenderer.BufferTypes buffType)
```
    Returns a buffer containing the rendered image.
    
    If the specified buffer type is RGB_BUFFER, the buffer is an array of bytes. Each pixel is stored sequentially by scanline, starting with the lower left corner. The data stored for each pixel is determined by the Components set before rendering. Pixels are stored in RGBA order and are packed without any padding between pixels or scanlines.
    getBuffer returns null if #writeToJPEGBuffer has not been called yet. The returned buffer is available until #writeToJPEGBuffer is called again.
    The buffer size is returned by the getBufferSize method.
  - getGLRenderAction
```
public SoGLRenderAction getGLRenderAction()
```
    Gets the render action to use for rendering. This will return any render action passed in by the caller.
  - render
```
public boolean render(SoNode scene)
```
    Renders the given scene, specified as a node, into an off-screen buffer. Note: If tiled rendering will be done, the application must call render(), but the actual rendering is not done until one of the writeToXXX() methods or getBuffer() is called.
  - render
```
public boolean render(SoPath scene)
```
    Renders the given scene, specified as a path, into an off-screen buffer. Note: If tiled rendering will be done, the application must call render(), but the actual rendering is not done until one of the writeToXXX() methods or getBuffer() is called.
  - getBufferSize
```
public long getBufferSize(SoOffscreenRenderer.BufferTypes buffType)
```
    Returns the buffer size in bytes.
    If the specified buffer type is JPEG_BUFFER, getBufferSize returns 0 if #writeToJPEGBuffer has not been called yet.
  - getScreenPixelsPerInch
```
public static float getScreenPixelsPerInch()
```
    Returns the number of pixels per inch (in the horizontal direction) of the current X device screen.
  - writeToPostScript
```
public boolean writeToPostScript(java.lang.String filename,
                                 SbVec2f printSize)
```
    Writes the buffer as encapsulated PostScript to the given filename. The print size is specified in inches.
    
    Since:
    
    Open Inventor 9.0
  - getShareContext
```
public SbGLShareContext getShareContext()
```
    Gets the OpenGL context shared by the SoOffscreenRenderer.
  - writeToRGB
```
public boolean writeToRGB(java.lang.String filename)
```
    Writes the buffer as an .rgb file to the given filename.
    
    Since:
    
    Open Inventor 9.0
  - writeToPostScript
```
public boolean writeToPostScript(java.lang.String filename)
```
    Writes the buffer as encapsulated PostScript to the given filename. The size of the image in the buffer is adjusted so it is the same as the apparent size of the viewport region on the current device.
    
    Since:
    
    Open Inventor 9.0
  - getMaximumResolution
```
public static SbVec2s getMaximumResolution()
```
    Gets the maximum supported resolution of the viewport.

Write Capability WRITE_FULL_IMAGE	Write Capability WRITE SCANLINES
BMP JP2 (JPEG2000) PGX PNM PNG SUN TIFF	JPEG PS (PostScript) SGIRGB

Class SoOffscreenRenderer

Nested Class Summary

Nested classes/interfaces inherited from class com.openinventor.inventor.Inventor

Field Summary

Fields inherited from class com.openinventor.inventor.Inventor

Constructor Summary

Method Summary

Methods inherited from class com.openinventor.inventor.Inventor

Methods inherited from class java.lang.Object

Field Detail

LUMINANCE

LUMINANCE_TRANSPARENCY

RGB

RGBA

RGB_TRANSPARENCY

NO_COMPRESSION

PACKBITS_COMPRESSION

RGB_BUFFER

JPEG_BUFFER

CONTINUE

ABORT

Constructor Detail

SoOffscreenRenderer

SoOffscreenRenderer

Method Detail

writeToJPEGBuffer

getBuffer

writeToJPEG

writeToTIFF

setFullSceneAntialiasing

setFullSceneAntialiasing

getBufferSize

setBackgroundColor

setGLRenderAction

getBackgroundColor

getViewportRegion

setBackgroundColorRGBA

setViewportRegion

getBackgroundColorRGBA

getNumEdgePixels

setComponents

writeToRaster

getFullSceneAntialiasingQuality

getComponents

getMaxSubimage

setNumEdgePixels

getMaxTileSize

setMaxTileSize

setMaxSubimage

writeToJPEG

setFullSceneAntialiasing

getPbufferEnable

writeToTIFF

isFullSceneAntialiasing

writeToPNG

setColorDepth

setTileObserver

setPbufferEnable

getColorDepth

writeToBMP

setShareContext

setRegion

setRegioni32

getBuffer

getGLRenderAction

render

render

getBufferSize

getScreenPixelsPerInch

writeToPostScript

getShareContext

writeToRGB

writeToPostScript

getMaximumResolution