picrate 0.0.2-java

data/src/main/java/processing/opengl/FontTexture.java

@@ -0,0 +1,379 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.opengl;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PFont;
+import processing.core.PGraphics;
+import processing.core.PImage;
+
+import java.util.HashMap;
+
+/**
+ * All the infrastructure needed for optimized font rendering
+ * in OpenGL. Basically, this special class is needed because
+ * fonts in Processing are handled by a separate PImage for each
+ * glyph. For performance reasons, all these glyphs should be
+ * stored in a single OpenGL texture (otherwise, rendering a
+ * string of text would involve binding and un-binding several
+ * textures.
+ * PFontTexture manages the correspondence between individual
+ * glyphs and the large OpenGL texture containing them. Also,
+ * in the case that the font size is very large, one single
+ * OpenGL texture might not be enough to store all the glyphs,
+ * so PFontTexture also takes care of spreading a single font
+ * over several textures.
+ * @author Andres Colubri
+ */
+class FontTexture implements PConstants {
+  protected PGL pgl;
+  protected boolean is3D;
+
+  protected int minSize;
+  protected int maxSize;
+  protected int offsetX;
+  protected int offsetY;
+  protected int lineHeight;
+  protected Texture[] textures = null;
+  protected PImage[] images = null;
+  protected int lastTex;
+  protected TextureInfo[] glyphTexinfos;
+  protected HashMap<PFont.Glyph, TextureInfo> texinfoMap;
+
+  public FontTexture(PGraphicsOpenGL pg, PFont font, boolean is3D) {
+    pgl = pg.pgl;
+    this.is3D = is3D;
+
+    initTexture(pg, font);
+  }
+
+
+  protected void allocate() {
+    // Nothing to do here: the font textures will allocate
+    // themselves.
+  }
+
+
+  protected void dispose() {
+    for (int i = 0; i < textures.length; i++) {
+      textures[i].dispose();
+    }
+  }
+
+
+  protected void initTexture(PGraphicsOpenGL pg, PFont font) {
+    lastTex = -1;
+
+    int spow = PGL.nextPowerOfTwo(font.getSize());
+    minSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
+                          PApplet.max(PGL.MIN_FONT_TEX_SIZE, spow));
+    maxSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
+                          PApplet.max(PGL.MAX_FONT_TEX_SIZE, 2 * spow));
+
+    if (maxSize < spow) {
+      PGraphics.showWarning("The font size is too large to be properly " +
+                            "displayed with OpenGL");
+    }
+
+    addTexture(pg);
+
+    offsetX = 0;
+    offsetY = 0;
+    lineHeight = 0;
+
+    texinfoMap = new HashMap<PFont.Glyph, TextureInfo>();
+    glyphTexinfos = new TextureInfo[font.getGlyphCount()];
+    addAllGlyphsToTexture(pg, font);
+  }
+
+
+  public boolean addTexture(PGraphicsOpenGL pg) {
+    int w, h;
+    boolean resize;
+
+    w = maxSize;
+    if (-1 < lastTex && textures[lastTex].glHeight < maxSize) {
+      // The height of the current texture is less than the maximum, this
+      // means we can replace it with a larger texture.
+      h = PApplet.min(2 * textures[lastTex].glHeight, maxSize);
+      resize = true;
+    } else {
+      h = minSize;
+      resize = false;
+    }
+
+    Texture tex;
+    if (is3D) {
+      // Bilinear sampling ensures that the texture doesn't look pixelated
+      // either when it is magnified or minified...
+      tex = new Texture(pg, w, h,
+                        new Texture.Parameters(ARGB, Texture.BILINEAR, false));
+    } else {
+      // ...however, the effect of bilinear sampling is to add some blurriness
+      // to the text in its original size. In 2D, we assume that text will be
+      // shown at its original size, so linear sampling is chosen instead (which
+      // only affects minimized text).
+      tex = new Texture(pg, w, h,
+                        new Texture.Parameters(ARGB, Texture.LINEAR, false));
+    }
+
+    if (textures == null) {
+      textures = new Texture[1];
+      textures[0] = tex;
+      images = new PImage[1];
+      images[0] = pg.wrapTexture(tex);
+      lastTex = 0;
+    } else if (resize) {
+      // Replacing old smaller texture with larger one.
+      // But first we must copy the contents of the older
+      // texture into the new one.
+      Texture tex0 = textures[lastTex];
+      tex.put(tex0);
+      textures[lastTex] = tex;
+
+      pg.setCache(images[lastTex], tex);
+      images[lastTex].width = tex.width;
+      images[lastTex].height = tex.height;
+    } else {
+      // Adding new texture to the list.
+      lastTex = textures.length;
+      Texture[] tempTex = new Texture[lastTex + 1];
+      PApplet.arrayCopy(textures, tempTex, textures.length);
+      tempTex[lastTex] = tex;
+      textures = tempTex;
+
+      PImage[] tempImg = new PImage[textures.length];
+      PApplet.arrayCopy(images, tempImg, images.length);
+      tempImg[lastTex] = pg.wrapTexture(tex);
+      images = tempImg;
+    }
+
+    // Make sure that the current texture is bound.
+    tex.bind();
+
+    return resize;
+  }
+
+
+  public void begin() {
+  }
+
+
+  public void end() {
+    for (int i = 0; i < textures.length; i++) {
+      pgl.disableTexturing(textures[i].glTarget);
+    }
+  }
+
+
+  public PImage getTexture(TextureInfo info) {
+    return images[info.texIndex];
+  }
+
+
+  // Add all the current glyphs to opengl texture.
+  public void addAllGlyphsToTexture(PGraphicsOpenGL pg, PFont font) {
+    // loop over current glyphs.
+    for (int i = 0; i < font.getGlyphCount(); i++) {
+      addToTexture(pg, i, font.getGlyph(i));
+    }
+  }
+
+
+  public void updateGlyphsTexCoords() {
+    // loop over current glyphs.
+    for (int i = 0; i < glyphTexinfos.length; i++) {
+      TextureInfo tinfo = glyphTexinfos[i];
+      if (tinfo != null && tinfo.texIndex == lastTex) {
+        tinfo.updateUV();
+      }
+    }
+  }
+
+
+  public TextureInfo getTexInfo(PFont.Glyph glyph) {
+    TextureInfo info = texinfoMap.get(glyph);
+    return info;
+  }
+
+
+  public TextureInfo addToTexture(PGraphicsOpenGL pg, PFont.Glyph glyph) {
+    int n = glyphTexinfos.length;
+    if (n == 0) {
+      glyphTexinfos = new TextureInfo[1];
+    }
+    addToTexture(pg, n, glyph);
+    return glyphTexinfos[n];
+  }
+
+
+  public boolean contextIsOutdated() {
+    boolean outdated = false;
+    for (int i = 0; i < textures.length; i++) {
+      if (textures[i].contextIsOutdated())  {
+        outdated = true;
+      }
+    }
+    if (outdated) {
+      for (int i = 0; i < textures.length; i++) {
+        textures[i].dispose();
+      }
+    }
+    return outdated;
+  }
+
+//  public void draw() {
+//    Texture tex = textures[lastTex];
+//    pgl.drawTexture(tex.glTarget, tex.glName,
+//                    tex.glWidth, tex.glHeight,
+//                    0, 0, tex.glWidth, tex.glHeight);
+//  }
+
+
+  // Adds this glyph to the opengl texture in PFont.
+  protected void addToTexture(PGraphicsOpenGL pg, int idx, PFont.Glyph glyph) {
+    // We add one pixel to avoid issues when sampling the font texture at
+    // fractional screen positions. I.e.: the pixel on the screen only contains
+    // half of the font rectangle, so it would sample half of the color from the
+    // glyph area in the texture, and the other half from the contiguous pixel.
+    // If the later contains a portion of the neighbor glyph and the former
+    // doesn't, this would result in a shaded pixel when the correct output is
+    // blank. This is a consequence of putting all the glyphs in a common
+    // texture with bilinear sampling.
+    int w = 1 + glyph.width + 1;
+    int h = 1 + glyph.height + 1;
+
+    // Converting the pixels array from the PImage into a valid RGBA array for
+    // OpenGL.
+    int[] rgba = new int[w * h];
+    int t = 0;
+    int p = 0;
+    if (PGL.BIG_ENDIAN)  {
+      java.util.Arrays.fill(rgba, 0, w, 0xFFFFFF00); // Set the first row to blank pixels.
+      t = w;
+      for (int y = 0; y < glyph.height; y++) {
+        rgba[t++] = 0xFFFFFF00; // Set the leftmost pixel in this row as blank
+        for (int x = 0; x < glyph.width; x++) {
+          rgba[t++] = 0xFFFFFF00 | glyph.image.pixels[p++];
+        }
+        rgba[t++] = 0xFFFFFF00; // Set the rightmost pixel in this row as blank
+      }
+      java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0xFFFFFF00); // Set the last row to blank pixels.
+    } else {
+      java.util.Arrays.fill(rgba, 0, w, 0x00FFFFFF); // Set the first row to blank pixels.
+      t = w;
+      for (int y = 0; y < glyph.height; y++) {
+        rgba[t++] = 0x00FFFFFF; // Set the leftmost pixel in this row as blank
+        for (int x = 0; x < glyph.width; x++) {
+          rgba[t++] = (glyph.image.pixels[p++] << 24) | 0x00FFFFFF;
+        }
+        rgba[t++] = 0x00FFFFFF; // Set the rightmost pixel in this row as blank
+      }
+      java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0x00FFFFFF); // Set the last row to blank pixels.
+    }
+
+    // Is there room for this glyph in the current line?
+    if (offsetX + w > textures[lastTex].glWidth) {
+      // No room, go to the next line:
+      offsetX = 0;
+      offsetY += lineHeight;
+    }
+    lineHeight = Math.max(lineHeight, h);
+
+    boolean resized = false;
+    if (offsetY + lineHeight > textures[lastTex].glHeight) {
+      // We run out of space in the current texture, so we add a new texture:
+      resized = addTexture(pg);
+      if (resized) {
+        // Because the current texture has been resized, we need to
+        // update the UV coordinates of all the glyphs associated to it:
+        updateGlyphsTexCoords();
+      } else {
+        // A new texture has been created. Reseting texture coordinates
+        // and line.
+        offsetX = 0;
+        offsetY = 0;
+        lineHeight = 0;
+      }
+    }
+
+    TextureInfo tinfo = new TextureInfo(lastTex, offsetX, offsetY, w, h, rgba);
+    offsetX += w;
+
+    if (idx == glyphTexinfos.length) {
+      TextureInfo[] temp = new TextureInfo[glyphTexinfos.length + 1];
+      System.arraycopy(glyphTexinfos, 0, temp, 0, glyphTexinfos.length);
+      glyphTexinfos = temp;
+    }
+
+    glyphTexinfos[idx] = tinfo;
+    texinfoMap.put(glyph, tinfo);
+  }
+
+
+  class TextureInfo {
+    int texIndex;
+    int width;
+    int height;
+    int[] crop;
+    float u0, u1;
+    float v0, v1;
+    int[] pixels;
+
+    TextureInfo(int tidx, int cropX, int cropY, int cropW, int cropH,
+                int[] pix) {
+      texIndex = tidx;
+      crop = new int[4];
+      // The region of the texture corresponding to the glyph is surrounded by a
+      // 1-pixel wide border to avoid artifacts due to bilinear sampling. This
+      // is why the additions and subtractions to the crop values.
+      crop[0] = cropX + 1;
+      crop[1] = cropY + 1 + cropH - 2;
+      crop[2] = cropW - 2;
+      crop[3] = -cropH + 2;
+      pixels = pix;
+      updateUV();
+      updateTex();
+    }
+
+
+    void updateUV() {
+      width = textures[texIndex].glWidth;
+      height = textures[texIndex].glHeight;
+
+      u0 = (float)crop[0] / (float)width;
+      u1 = u0 + (float)crop[2] / (float)width;
+      v0 = (float)(crop[1] + crop[3]) / (float)height;
+      v1 = v0 - (float)crop[3] / (float)height;
+    }
+
+
+    void updateTex() {
+      textures[texIndex].setNative(pixels, crop[0] - 1, crop[1] + crop[3] - 1,
+                                           crop[2] + 2, -crop[3] + 2);
+    }
+  }
+}

data/src/main/java/processing/opengl/FrameBuffer.java

@@ -0,0 +1,503 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.opengl;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.opengl.PGraphicsOpenGL.GLResourceFrameBuffer;
+
+import java.nio.IntBuffer;
+
+/**
+ * Encapsulates a Frame Buffer Object for offscreen rendering.
+ * When created with onscreen == true, it represents the normal
+ * framebuffer. Needed by the stack mechanism in OPENGL2 to return
+ * to onscreen rendering after a sequence of pushFramebuffer calls.
+ * It transparently handles the situations when the FBO extension is
+ * not available.
+ *
+ * By Andres Colubri.
+ */
+
+public class FrameBuffer implements PConstants {
+  protected PGraphicsOpenGL pg;
+  protected PGL pgl;
+  protected int context;   // The context that created this framebuffer.
+
+  public int glFbo;
+  public int glDepth;
+  public int glStencil;
+  public int glDepthStencil;
+  public int glMultisample;
+  public int width;
+  public int height;
+  private GLResourceFrameBuffer glres;
+
+  protected int depthBits;
+  protected int stencilBits;
+  protected boolean packedDepthStencil;
+
+  protected boolean multisample;
+  protected int nsamples;
+
+  protected int numColorBuffers;
+  protected Texture[] colorBufferTex;
+
+  protected boolean screenFb;
+  protected boolean noDepth;
+
+  protected IntBuffer pixelBuffer;
+
+
+  FrameBuffer(PGraphicsOpenGL pg) {
+    this.pg = pg;
+    pgl = pg.pgl;
+    context = pgl.createEmptyContext();
+  }
+
+
+  FrameBuffer(PGraphicsOpenGL pg, int w, int h, int samples, int colorBuffers,
+              int depthBits, int stencilBits, boolean packedDepthStencil,
+              boolean screen) {
+    this(pg);
+
+    glFbo = 0;
+    glDepth = 0;
+    glStencil = 0;
+    glDepthStencil = 0;
+    glMultisample = 0;
+
+    if (screen) {
+      // If this framebuffer is used to represent a on-screen buffer,
+      // then it doesn't make it sense for it to have multisampling,
+      // color, depth or stencil buffers.
+      depthBits = stencilBits = samples = colorBuffers = 0;
+    }
+
+    width = w;
+    height = h;
+
+    if (1 < samples) {
+      multisample = true;
+      nsamples = samples;
+    } else {
+      multisample = false;
+      nsamples = 1;
+    }
+
+    numColorBuffers = colorBuffers;
+    colorBufferTex = new Texture[numColorBuffers];
+    for (int i = 0; i < numColorBuffers; i++) {
+      colorBufferTex[i] = null;
+    }
+
+    if (depthBits < 1 && stencilBits < 1) {
+      this.depthBits = 0;
+      this.stencilBits = 0;
+      this.packedDepthStencil = false;
+    } else {
+      if (packedDepthStencil) {
+        // When combined depth/stencil format is required, the depth and stencil
+        // bits are overriden and the 24/8 combination for a 32 bits surface is
+        // used.
+        this.depthBits = 24;
+        this.stencilBits = 8;
+        this.packedDepthStencil = true;
+      } else {
+        this.depthBits = depthBits;
+        this.stencilBits = stencilBits;
+        this.packedDepthStencil = false;
+      }
+    }
+
+    screenFb = screen;
+
+    allocate();
+    noDepth = false;
+
+    pixelBuffer = null;
+  }
+
+
+  FrameBuffer(PGraphicsOpenGL pg, int w, int h) {
+    this(pg, w, h, 1, 1, 0, 0, false, false);
+  }
+
+
+  FrameBuffer(PGraphicsOpenGL pg, int w, int h, boolean screen) {
+    this(pg, w, h, 1, 1, 0, 0, false, screen);
+  }
+
+
+  public void clear() {
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+    pgl.clearDepth(1);
+    pgl.clearStencil(0);
+    pgl.clearColor(0, 0, 0, 0);
+    pgl.clear(PGL.DEPTH_BUFFER_BIT |
+              PGL.STENCIL_BUFFER_BIT |
+              PGL.COLOR_BUFFER_BIT);
+    pg.popFramebuffer();
+  }
+
+  public void copyColor(FrameBuffer dest) {
+    copy(dest, PGL.COLOR_BUFFER_BIT);
+  }
+
+  public void copyDepth(FrameBuffer dest) {
+    copy(dest, PGL.DEPTH_BUFFER_BIT);
+  }
+
+  public void copyStencil(FrameBuffer dest) {
+    copy(dest, PGL.STENCIL_BUFFER_BIT);
+  }
+
+  public void copy(FrameBuffer dest, int mask) {
+    pgl.bindFramebufferImpl(PGL.READ_FRAMEBUFFER, this.glFbo);
+    pgl.bindFramebufferImpl(PGL.DRAW_FRAMEBUFFER, dest.glFbo);
+    pgl.blitFramebuffer(0, 0, this.width, this.height,
+                        0, 0, dest.width, dest.height, mask, PGL.NEAREST);
+    pgl.bindFramebufferImpl(PGL.READ_FRAMEBUFFER, pg.getCurrentFB().glFbo);
+    pgl.bindFramebufferImpl(PGL.DRAW_FRAMEBUFFER, pg.getCurrentFB().glFbo);
+  }
+
+  public void bind() {
+    pgl.bindFramebufferImpl(PGL.FRAMEBUFFER, glFbo);
+  }
+
+  public void disableDepthTest() {
+    noDepth = true;
+  }
+
+  public void finish() {
+    if (noDepth) {
+      // No need to clear depth buffer because depth testing was disabled.
+      if (pg.getHint(ENABLE_DEPTH_TEST)) {
+        pgl.enable(PGL.DEPTH_TEST);
+      } else {
+        pgl.disable(PGL.DEPTH_TEST);
+      }
+    }
+  }
+
+  public void readPixels() {
+    if (pixelBuffer == null) createPixelBuffer();
+    pixelBuffer.rewind();
+    pgl.readPixels(0, 0, width, height, PGL.RGBA, PGL.UNSIGNED_BYTE,
+                   pixelBuffer);
+  }
+
+  public void getPixels(int[] pixels) {
+    if (pixelBuffer != null) {
+      pixelBuffer.get(pixels, 0, pixels.length);
+      pixelBuffer.rewind();
+    }
+  }
+
+  public IntBuffer getPixelBuffer() {
+    return pixelBuffer;
+  }
+
+  public boolean hasDepthBuffer() {
+    return 0 < depthBits;
+  }
+
+  public boolean hasStencilBuffer() {
+    return 0 < stencilBits;
+  }
+
+  public void setFBO(int id) {
+    if (screenFb) {
+      glFbo = id;
+    }
+  }
+
+  ///////////////////////////////////////////////////////////
+
+  // Color buffer setters.
+
+
+  public void setColorBuffer(Texture tex) {
+    setColorBuffers(new Texture[] { tex }, 1);
+  }
+
+
+  public void setColorBuffers(Texture[] textures) {
+    setColorBuffers(textures, textures.length);
+  }
+
+
+  public void setColorBuffers(Texture[] textures, int n) {
+    if (screenFb) return;
+
+    if (numColorBuffers != PApplet.min(n, textures.length)) {
+      throw new RuntimeException("Wrong number of textures to set the color " +
+                                 "buffers.");
+    }
+
+    for (int i = 0; i < numColorBuffers; i++) {
+      colorBufferTex[i] = textures[i];
+    }
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+
+    // Making sure nothing is attached.
+    for (int i = 0; i < numColorBuffers; i++) {
+      pgl.framebufferTexture2D(PGL.FRAMEBUFFER, PGL.COLOR_ATTACHMENT0 + i,
+                               PGL.TEXTURE_2D, 0, 0);
+    }
+
+    for (int i = 0; i < numColorBuffers; i++) {
+      pgl.framebufferTexture2D(PGL.FRAMEBUFFER, PGL.COLOR_ATTACHMENT0 + i,
+                               colorBufferTex[i].glTarget,
+                               colorBufferTex[i].glName, 0);
+    }
+
+    pgl.validateFramebuffer();
+
+    pg.popFramebuffer();
+  }
+
+
+  public void swapColorBuffers() {
+    for (int i = 0; i < numColorBuffers - 1; i++) {
+      int i1 = (i + 1);
+      Texture tmp = colorBufferTex[i];
+      colorBufferTex[i] = colorBufferTex[i1];
+      colorBufferTex[i1] = tmp;
+    }
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+    for (int i = 0; i < numColorBuffers; i++) {
+      pgl.framebufferTexture2D(PGL.FRAMEBUFFER, PGL.COLOR_ATTACHMENT0 + i,
+                               colorBufferTex[i].glTarget,
+                               colorBufferTex[i].glName, 0);
+    }
+    pgl.validateFramebuffer();
+
+    pg.popFramebuffer();
+  }
+
+
+  public int getDefaultReadBuffer() {
+    if (screenFb) {
+      return pgl.getDefaultReadBuffer();
+    } else {
+      return PGL.COLOR_ATTACHMENT0;
+    }
+  }
+
+
+  public int getDefaultDrawBuffer() {
+    if (screenFb) {
+      return pgl.getDefaultDrawBuffer();
+    } else {
+      return PGL.COLOR_ATTACHMENT0;
+    }
+  }
+
+
+  ///////////////////////////////////////////////////////////
+
+  // Allocate/release framebuffer.
+
+
+  protected void allocate() {
+    dispose(); // Just in the case this object is being re-allocated.
+
+    context = pgl.getCurrentContext();
+    glres = new GLResourceFrameBuffer(this); // create the FBO resources...
+
+    if (screenFb) {
+      glFbo = 0;
+    } else {
+      if (multisample) {
+        initColorBufferMultisample();
+      }
+
+      if (packedDepthStencil) {
+        initPackedDepthStencilBuffer();
+      } else {
+        if (0 < depthBits) {
+          initDepthBuffer();
+        }
+        if (0 < stencilBits) {
+          initStencilBuffer();
+        }
+      }
+    }
+  }
+
+
+  protected void dispose() {
+    if (screenFb) return;
+    if (glres != null) {
+      glres.dispose();
+      glFbo = 0;
+      glDepth = 0;
+      glStencil = 0;
+      glMultisample = 0;
+      glDepthStencil = 0;
+      glres = null;
+    }
+  }
+
+
+  protected boolean contextIsOutdated() {
+    if (screenFb) return false;
+
+    boolean outdated = !pgl.contextIsCurrent(context);
+    if (outdated) {
+      dispose();
+      for (int i = 0; i < numColorBuffers; i++) {
+        colorBufferTex[i] = null;
+      }
+    }
+    return outdated;
+  }
+
+
+  protected void initColorBufferMultisample() {
+    if (screenFb) return;
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+
+    pgl.bindRenderbuffer(PGL.RENDERBUFFER, glMultisample);
+    pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples,
+                                       PGL.RGBA8, width, height);
+    pgl.framebufferRenderbuffer(PGL.FRAMEBUFFER, PGL.COLOR_ATTACHMENT0,
+                                PGL.RENDERBUFFER, glMultisample);
+
+    pg.popFramebuffer();
+  }
+
+
+  protected void initPackedDepthStencilBuffer() {
+    if (screenFb) return;
+
+    if (width == 0 || height == 0) {
+      throw new RuntimeException("PFramebuffer: size undefined.");
+    }
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+
+    pgl.bindRenderbuffer(PGL.RENDERBUFFER, glDepthStencil);
+
+    if (multisample) {
+      pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples,
+                                         PGL.DEPTH24_STENCIL8, width, height);
+    } else {
+      pgl.renderbufferStorage(PGL.RENDERBUFFER, PGL.DEPTH24_STENCIL8,
+                              width, height);
+    }
+
+    pgl.framebufferRenderbuffer(PGL.FRAMEBUFFER, PGL.DEPTH_ATTACHMENT,
+                                PGL.RENDERBUFFER, glDepthStencil);
+    pgl.framebufferRenderbuffer(PGL.FRAMEBUFFER, PGL.STENCIL_ATTACHMENT,
+                                PGL.RENDERBUFFER, glDepthStencil);
+
+    pg.popFramebuffer();
+  }
+
+
+  protected void initDepthBuffer() {
+    if (screenFb) return;
+
+    if (width == 0 || height == 0) {
+      throw new RuntimeException("PFramebuffer: size undefined.");
+    }
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+
+    pgl.bindRenderbuffer(PGL.RENDERBUFFER, glDepth);
+
+    int glConst = PGL.DEPTH_COMPONENT16;
+    if (depthBits == 16) {
+      glConst = PGL.DEPTH_COMPONENT16;
+    } else if (depthBits == 24) {
+      glConst = PGL.DEPTH_COMPONENT24;
+    } else if (depthBits == 32) {
+      glConst = PGL.DEPTH_COMPONENT32;
+    }
+
+    if (multisample) {
+      pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples, glConst,
+                                         width, height);
+    } else {
+      pgl.renderbufferStorage(PGL.RENDERBUFFER, glConst, width, height);
+    }
+
+    pgl.framebufferRenderbuffer(PGL.FRAMEBUFFER, PGL.DEPTH_ATTACHMENT,
+                                PGL.RENDERBUFFER, glDepth);
+
+    pg.popFramebuffer();
+  }
+
+
+  protected void initStencilBuffer() {
+    if (screenFb) return;
+
+    if (width == 0 || height == 0) {
+      throw new RuntimeException("PFramebuffer: size undefined.");
+    }
+
+    pg.pushFramebuffer();
+    pg.setFramebuffer(this);
+
+    pgl.bindRenderbuffer(PGL.RENDERBUFFER, glStencil);
+
+    int glConst = PGL.STENCIL_INDEX1;
+    if (stencilBits == 1) {
+      glConst = PGL.STENCIL_INDEX1;
+    } else if (stencilBits == 4) {
+      glConst = PGL.STENCIL_INDEX4;
+    } else if (stencilBits == 8) {
+      glConst = PGL.STENCIL_INDEX8;
+    }
+    if (multisample) {
+      pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples, glConst,
+                                         width, height);
+    } else {
+      pgl.renderbufferStorage(PGL.RENDERBUFFER, glConst, width, height);
+    }
+
+    pgl.framebufferRenderbuffer(PGL.FRAMEBUFFER, PGL.STENCIL_ATTACHMENT,
+                                PGL.RENDERBUFFER, glStencil);
+
+    pg.popFramebuffer();
+  }
+
+
+  protected void createPixelBuffer() {
+    pixelBuffer = IntBuffer.allocate(width * height);
+    pixelBuffer.rewind();
+  }
+}