FBO and overlay

[loicus]

Dear all,

In my code, I need to take very high resolution (more than 2000x2000 pixels) screenshot of the rendered scene,
Note that in the display function rendering my scene,  I also have some overlay stuff.

My code looks like this:


-------------------------------------------------
//FBO INIT AND BINDING

reshape(canvas, 0, 0, width, height);
display(canvas);         
overlay.markDirty(0, 0, width, height);         
reshape(canvas, 0, 0, canvas.getWidth(), canvas.getHeight());
overlay.markDirty(0, 0, canvas.getWidth(), canvas.getHeight());

// READ FBO PIXELS AND SAVE TO FILE
-------------------------------------------------

the reshape function does nothing except redefining the glViewport and gluPerspectives

My problem is, that the overlay drawing doesn't seem to have been updated...
I still have the overlay from the previous drawing loop (low resolution).
Despite the fact that I have a call to overlay.drawAll() at the very end of my display loop and that I make my objects dirty


I suspect the problems comes from the fact that "overlay.drawAll()" is likely not drawing the overlay when the funciton call but maybe slightly later...
is it correct?
is there a solution to my problem?  or should I rewrite my code to avoid the usage of the overlay

thanks in advance,
Loic

[gouessej]

Hi

Why not using the class com.jogamp.opengl.util.awt.Screenshot to make a screen capture?

[loicus]

1) is it going to solve my problem?  I don' think so... right?
2) as I said, I need to take high resolution screenshot typical size is 5000x5000 pixels, while my program is running with a different resolution rest of the time
3) as far as I understand it, the screenshot utility class is doing nothing but reading the pixel buffer (exactly as I do) and saving it's content (exactly as I do).  So the question is rather... what do I gain if using the screenshot class?
Loic,

Games published by our own members! Check 'em out!

[loicus]

I solved my problem...
I made a MyOverlay Class that is just a copy paste of the standard overlay, except that it stores it's own dimension instead of forcing to use the Drawable dimension...  One simply need to give the right dimension to the overlay after a reshape.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59   60   61   62   63   64   65   66   67   68   69   70   71   72   73   74   75   76   77   78   79   80   81   82   83   84   85   86   87   88   89   90   91   92   93   94   95   96   97   98   99   100   101   102   103   104   105   106   107   108   109   110   111   112   113   114   115   116   117   118   119   120   121   122   123   124   125   126   127   128   129   130   131   132   133   134   135   136   137   138   139   140   141   142   143   144   145   146   147   148   149   150   151   152   153   154   155   156   157   158   159   160   161   162   163   164   165   166   167   168   169   170   171   172   173   174   175   176   177   178   179   180

public class MyOverlay{         private GLDrawable drawable;         private TextureRenderer renderer;         private boolean contentsLost;         private int width;         private int height;         /** Creates a new Java 2D overlay on top of the specified             GLDrawable. */         public MyOverlay(GLDrawable drawable) {           this.drawable = drawable;           this.width = drawable.getWidth();           this.height = drawable.getHeight();         }         /** Creates a {@link java.awt.Graphics2D Graphics2D} instance for             rendering into the overlay. The returned object should be             disposed of using the normal {@link java.awt.Graphics#dispose()             Graphics.dispose()} method once it is no longer being used.             @return a new {@link java.awt.Graphics2D Graphics2D} object for               rendering into the backing store of this renderer         */         public Graphics2D createGraphics() {           // Validate the size of the renderer against the current size of           // the drawable           validateRenderer();           return renderer.createGraphics();         }         /** Indicates whether the Java 2D contents of the overlay were lost             since the last time {@link #createGraphics} was called. This             method should be called immediately after calling {@link             #createGraphics} to see whether the entire contents of the             overlay need to be redrawn or just the region the application is             interested in updating.             @return whether the contents of the overlay were lost since the               last render         */         public boolean contentsLost() {           return contentsLost;         }         /** Marks the given region of the overlay as dirty. This region, and             any previously set dirty regions, will be automatically             synchronized with the underlying Texture during the next {@link             #draw draw} or {@link #drawAll drawAll} operation, at which             point the dirty region will be cleared. It is not necessary for             an OpenGL context to be current when this method is called.             @param x the x coordinate (in Java 2D coordinates -- relative to               upper left) of the region to update             @param y the y coordinate (in Java 2D coordinates -- relative to               upper left) of the region to update             @param width the width of the region to update             @param height the height of the region to update             @throws GLException If an OpenGL context is not current when this method is called */         public void markDirty(int x, int y, int width, int height) {           renderer.markDirty(x, y, width, height);         }         /** Draws the entire contents of the overlay on top of the OpenGL             drawable. This is a convenience method which encapsulates all             portions of the rendering process; if this method is used,             {@link #beginRendering}, {@link #endRendering}, etc. should not             be used. This method should be called while the OpenGL context             for the drawable is current, and after your OpenGL scene has             been rendered.             @throws GLException If an OpenGL context is not current when this method is called         */         public void drawAll() throws GLException {           beginRendering();           draw(0, 0, this.width, this.height);           endRendering();         }         /** Begins the OpenGL rendering process for the overlay. This is             separated out so advanced applications can render independent             pieces of the overlay to different portions of the drawable.             @throws GLException If an OpenGL context is not current when this method is called         */         public void beginRendering() throws GLException {           renderer.beginOrthoRendering(this.width, this.height);         }         /** Ends the OpenGL rendering process for the overlay. This is             separated out so advanced applications can render independent             pieces of the overlay to different portions of the drawable.             @throws GLException If an OpenGL context is not current when this method is called         */         public void endRendering() throws GLException {           renderer.endOrthoRendering();         }         /** Draws the specified sub-rectangle of the overlay on top of the             OpenGL drawable. {@link #beginRendering} and {@link             #endRendering} must be used in conjunction with this method to             achieve proper rendering results. This method should be called             while the OpenGL context for the drawable is current, and after             your OpenGL scene has been rendered.             @param x the lower-left x coordinate (relative to the lower left               of the overlay) of the rectangle to draw             @param y the lower-left y coordinate (relative to the lower left               of the overlay) of the rectangle to draw             @param width the width of the rectangle to draw             @param height the height of the rectangle to draw             @throws GLException If an OpenGL context is not current when this method is called         */         public void draw(int x, int y, int width, int height) throws GLException {           draw(x, y, x, y, width, height);         }         /** Draws the specified sub-rectangle of the overlay at the             specified x and y coordinate on top of the OpenGL drawable.             {@link #beginRendering} and {@link #endRendering} must be used             in conjunction with this method to achieve proper rendering             results. This method should be called while the OpenGL context             for the drawable is current, and after your OpenGL scene has             been rendered.             @param screenx the on-screen x coordinate at which to draw the rectangle             @param screeny the on-screen y coordinate (relative to lower left) at               which to draw the rectangle             @param overlayx the x coordinate of the pixel in the overlay of               the lower left portion of the rectangle to draw             @param overlayy the y coordinate of the pixel in the overlay               (relative to lower left) of the lower left portion of the               rectangle to draw             @param width the width of the rectangle to draw             @param height the height of the rectangle to draw             @throws GLException If an OpenGL context is not current when this method is called         */         public void draw(int screenx, int screeny,                          int overlayx, int overlayy,                          int width, int height) throws GLException {           renderer.drawOrthoRect(screenx, screeny,                                  overlayx, overlayy,                                  width, height);         }                         public void setSize(int width, int height){            this.width  = width;            this.height = height;         }                 //----------------------------------------------------------------------         // Internals only below this point         //         private void validateRenderer() {           if (renderer == null) {             renderer = new TextureRenderer(this.width,                                            this.height,                                            true);             contentsLost = true;           } else if (renderer.getWidth() != this.width ||                      renderer.getHeight() != this.height) {             renderer.setSize(this.width, this.height);             contentsLost = true;           } else {             contentsLost = false;           }         }        }