Java-Gaming.org Hi !
Featured games (83)
games approved by the League of Dukes
Games in Showcase (523)
Games in Android Showcase (127)
games submitted by our members
Games in WIP (592)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: [1]
  ignore  |  Print  
  FBO and overlay  (Read 1445 times)
0 Members and 1 Guest are viewing this topic.
Offline loicus

Senior Newbie





« Posted 2011-12-04 18: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
Offline gouessej
« Reply #1 - Posted 2011-12-05 11:53:24 »

Hi

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

Offline loicus

Senior Newbie





« Reply #2 - Posted 2011-12-05 17: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,
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline loicus

Senior Newbie





« Reply #3 - Posted 2011-12-06 07: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;
          }
        }
   
   }
   
   
   
   

Pages: [1]
  ignore  |  Print  
 
 
You cannot reply to this message, because it is very, very old.

 

Add your game by posting it in the WIP section,
or publish it in Showcase.

The first screenshot will be displayed as a thumbnail.

Gibbo3771 (12 views)
2014-11-24 19:59:16

trollwarrior1 (35 views)
2014-11-22 12:13:56

xFryIx (74 views)
2014-11-13 12:34:49

digdugdiggy (52 views)
2014-11-12 21:11:50

digdugdiggy (46 views)
2014-11-12 21:10:15

digdugdiggy (40 views)
2014-11-12 21:09:33

kovacsa (66 views)
2014-11-07 19:57:14

TehJavaDev (70 views)
2014-11-03 22:04:50

BurntPizza (68 views)
2014-11-03 18:54:52

moogie (83 views)
2014-11-03 06:22:04
Understanding relations between setOrigin, setScale and setPosition in libGdx
by mbabuskov
2014-10-09 22:35:00

Definite guide to supporting multiple device resolutions on Android (2014)
by mbabuskov
2014-10-02 22:36:02

List of Learning Resources
by Longor1996
2014-08-16 10:40:00

List of Learning Resources
by SilverTiger
2014-08-05 19:33:27

Resources for WIP games
by CogWheelz
2014-08-01 16:20:17

Resources for WIP games
by CogWheelz
2014-08-01 16:19:50

List of Learning Resources
by SilverTiger
2014-07-31 16:29:50

List of Learning Resources
by SilverTiger
2014-07-31 16:26:06
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!