FBO and overlay - Java-Gaming.org

loicus

Senior Newbie

« Posted 2011-12-04 19:41:24 »

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

loicus

Senior Newbie

Re: FBO and overlay

« Reply #2 - Posted 2011-12-05 18:02:08 »

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,

loicus

Senior Newbie

Re: FBO and overlay

« Reply #3 - Posted 2011-12-06 08:10:11 »

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;
          }
        }
   
   }