private static boolean printToFile(String file, SwSimpleViewer viewer, int printerDPI, int type)
{
  // Calculate size of the images in inches which is equal to
  // the size of the viewport in pixels divided by the number
  // of pixels per inch of the screen device.  This size in
  // inches will be the size of the Postscript image that will
  // be generated.
  SbViewportRegion vp = viewer.getArea().getViewportRegion();
  SbVec2s imagePixSize = vp.getViewportSizePixels();
  SbVec2f imageInches = new SbVec2f();

  float pixPerInch = SoOffscreenRenderer.getScreenPixelsPerInch();
  imageInches.setValue((float)imagePixSize.getX() / pixPerInch,
                       (float)imagePixSize.getY() / pixPerInch);

  // The resolution to render the scene for the printer
  // is equal to the size of the image in inches times
  // the printer DPI;
  SbVec2s postScriptRes = new SbVec2s();
  postScriptRes.setValue((short)(imageInches.getX()*printerDPI),
                         (short)(imageInches.getY()*printerDPI));

  // Create a viewport to render the scene into.
  SbViewportRegion myViewport = new SbViewportRegion();
  myViewport.setWindowSize(postScriptRes);
  myViewport.setPixelsPerInch((float)printerDPI);

  // Render the scene
  SoOffscreenRenderer myRenderer = new SoOffscreenRenderer(myViewport);
  myRenderer.setBackgroundColor(new SbColor(.6f, .7f, .9f));

  if (!myRenderer.render(viewer.getArea().getSceneManager().getSceneGraph()))
    return false;

  // Generate PostScript or BMP and write it to the given file
  if (type == 0) {
    try {
      myRenderer.writeToBMP(file);
    }
    catch (UnsupportedOperationException e) {
      System.err.println();
      e.printStackTrace();
      return false ;
    }
  } else
    myRenderer.writeToPostScript(file);

  System.gc();
  return true;
}

import tools.*;

import com.openinventor.inventor.awt.*;
import com.openinventor.inventor.nodes.*;
import com.openinventor.inventor.*;
import com.openinventor.util.Scene.DrawStyle;

import java.awt.*;

public class Main extends DemoInventor
{

  public static void main(String[] args)
  {
    Main applet = new Main();
    applet.isAnApplet = false;
    applet.start();
    demoMain(applet, "Offscreen Rendered Texture");
  }

  public void start()
  {
    super.start();

    SwSimpleViewer myViewer = new SwSimpleViewer();

    // In Inventor 2.1, if the machine does not have hardware texture
    // mapping, we must override the default drawStyle to display textures.
    myViewer.getArea().setDrawStyle(SwActiveArea.STILL, DrawStyle.VIEW_AS_IS);

    setLayout(new BorderLayout());
    add(myViewer, BorderLayout.CENTER);


    // Make a scene from reading in a file
    SoSeparator texRoot = new SoSeparator();

    SoComplexity nodeComplexity = new SoComplexity();
    nodeComplexity.textureQuality.setValue(0.0f);

    SoInput in = new SoInput();
    in.openFile(m_prefix + "../../../../data/models/jumpyMan.iv");
    SoNode result = SoDB.readNode(in);

    SoPerspectiveCamera myCamera = new SoPerspectiveCamera();
    SoRotationXYZ rot = new SoRotationXYZ();
    rot.axis.setValue(SoRotationXYZ.X);
    rot.angle.setValue((float)java.lang.Math.PI/2.f);
    myCamera.position.setValue(new SbVec3f( -0.2f, -0.2f, 2.0f));
    myCamera.scaleHeight(0.4f);
    {
      texRoot.addChild(nodeComplexity);
      texRoot.addChild(myCamera);
      texRoot.addChild(new SoDirectionalLight());
      texRoot.addChild(rot);
      texRoot.addChild(result);
    }

    // Generate the texture map
    SoTexture2 texture = new SoTexture2();
    if (generateTextureMap(texRoot, texture, (short)64, (short)64))
      System.out.println("Successfully generated texture map\n");
    else
      System.out.println("Could not generate texture map\n");

    // Make a scene with a cube and apply the texture to it
    SoSeparator root = new SoSeparator();

    { // Assemble scene graph
      root.addChild(texture);
      root.addChild(new SoCube());
    }

    myViewer.setSceneGraph(root);

  }

  private boolean generateTextureMap(final SoNode root, SoTexture2 texture,
                         short textureWidth, short textureHeight)
  {

    SbViewportRegion myViewport = new SbViewportRegion(textureWidth, textureHeight);

    // Render the scene
    final SoOffscreenRenderer myRenderer = new SoOffscreenRenderer(myViewport);
    myRenderer.setBackgroundColor(new SbColor(0.3f, 0.3f, 0.3f));
    
    if ( !myRenderer.render(root) )
      return false;

    byte[] buffer_byte = myRenderer.getBuffer();

    // Generate the texture
    texture.image.setValue(new SbVec2s(textureWidth,
                                       textureHeight),
                                       myRenderer.getComponents().getValue(),
                                       buffer_byte);
                                     //SoOffscreenRenderer.RGB,
                                     //myRenderer.getBuffer());

    return true;
  }
}