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
|
package demos.xtrans;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.beans.*;
import java.nio.*;
import java.util.*;
import javax.swing.*;
import javax.media.opengl.*;
import javax.media.opengl.glu.*;
import com.sun.opengl.impl.*;
/** A desktop manager implementation supporting accelerated
transitions of the components on the desktop via OpenGL. This
class does not need to be instantiated by end users; it is
installed automatically when an XTDesktopPane is constructed. */
public class XTDesktopManager extends OffscreenDesktopManager {
private GLContext j2dContext;
private Object j2dContextSurfaceIdentifier;
private int oglTextureId;
private int prevBackBufferWidth;
private int prevBackBufferHeight;
private int textureTarget = GL.GL_TEXTURE_2D;
/** Returns the OpenGL texture object ID associated with the
off-screen back buffer for all of the components on the
desktop. */
public int getOpenGLTextureObject() {
return oglTextureId;
}
/** Returns a rectangle specifying the OpenGL texture coordinates of
the passed component in the texture object. The x and y
coordinates of the returned rectangle specify the lower left
corner of the component's image. */
public Rectangle2D getOpenGLTextureCoords(Component c) {
Rectangle rect = getBoundsOnBackBuffer(c);
if (rect == null) {
throw new RuntimeException("Unknown component " + c);
}
double offscreenWidth = getOffscreenBackBufferWidth();
double offscreenHeight = getOffscreenBackBufferHeight();
return new Rectangle2D.Double(rect.x / offscreenWidth,
(offscreenHeight - rect.y - rect.height) / offscreenHeight,
rect.width / offscreenWidth,
rect.height / offscreenHeight);
}
/** Updates the off-screen buffer of this desktop manager and makes
the rendering results available to OpenGL in the form of a
texture object. */
public void updateOffscreenBuffer(OffscreenDesktopPane parent) {
boolean needsCopy = needsCopyBack();
boolean hadPrevBackBuffer = false;
super.updateOffscreenBuffer(parent);
Image img = getOffscreenBackBuffer();
final boolean mustResizeOGLTexture = ((oglTextureId == 0) ||
(img == null) ||
(prevBackBufferWidth != img.getWidth(null)) ||
(prevBackBufferHeight != img.getHeight(null)));
if (needsCopy) {
final Graphics g = getOffscreenGraphics();
// Capture off-screen buffer contents into OpenGL texture
Java2D.invokeWithOGLContextCurrent(g, new Runnable() {
public void run() {
// Get valid Java2D context
if (j2dContext == null ||
j2dContextSurfaceIdentifier != Java2D.getOGLSurfaceIdentifier(g)) {
j2dContext = GLDrawableFactory.getFactory().createExternalGLContext();
j2dContext.setGL(new DebugGL(j2dContext.getGL()));
j2dContextSurfaceIdentifier = Java2D.getOGLSurfaceIdentifier(g);
}
j2dContext.makeCurrent(); // No-op
try {
GL gl = j2dContext.getGL();
if (oglTextureId == 0) {
// Set up and initialize texture
int[] tmp = new int[1];
gl.glGenTextures(1, tmp, 0);
oglTextureId = tmp[0];
if (oglTextureId == 0) {
throw new RuntimeException("Error generating OpenGL back buffer texture");
}
assert mustResizeOGLTexture : "Must know we need to resize";
}
gl.glBindTexture(textureTarget, oglTextureId);
int offscreenWidth = getOffscreenBackBufferWidth();
int offscreenHeight = getOffscreenBackBufferHeight();
if (mustResizeOGLTexture) {
prevBackBufferWidth = offscreenWidth;
prevBackBufferHeight = offscreenHeight;
gl.glTexImage2D(textureTarget,
0,
GL.GL_RGBA8,
offscreenWidth,
offscreenHeight,
0,
GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE,
null);
}
// Copy texture from offscreen buffer
// NOTE: assumes read buffer is set up
// FIXME: could be more efficient by copying only bounding rectangle
gl.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, GL.GL_FALSE);
gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, GL.GL_FALSE);
gl.glPixelStorei(GL.GL_UNPACK_LSB_FIRST, GL.GL_FALSE);
gl.glPixelStorei(GL.GL_PACK_LSB_FIRST, GL.GL_FALSE);
gl.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, 0);
gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, 0);
gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, 0);
gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0);
gl.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, 0);
gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0);
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1);
gl.glPixelTransferf(GL.GL_RED_SCALE, 1);
gl.glPixelTransferf(GL.GL_GREEN_SCALE, 1);
gl.glPixelTransferf(GL.GL_BLUE_SCALE, 1);
gl.glPixelTransferf(GL.GL_ALPHA_SCALE, 1);
gl.glPixelTransferf(GL.GL_RED_BIAS, 0);
gl.glPixelTransferf(GL.GL_GREEN_BIAS, 0);
gl.glPixelTransferf(GL.GL_BLUE_BIAS, 0);
gl.glPixelTransferf(GL.GL_ALPHA_BIAS, 0);
// long start = System.currentTimeMillis();
gl.glCopyTexSubImage2D(textureTarget,
0,
0,
0,
0,
0,
offscreenWidth,
offscreenHeight);
// long end = System.currentTimeMillis();
// System.err.println("glCopyTexSubImage2D " + offscreenWidth + "x" + offscreenHeight + " took " + (end - start) + " ms");
} finally {
j2dContext.release();
}
}
});
}
}
// Ideally we would force a repaint only of the 2D bounds of the 3D
// component projected onto the desktop. However for expedience
// we'll currently just repaint the entire desktop to get correct
// results.
protected void repaintPortionOfDesktop(JDesktopPane desktop, Component comp) {
desktop.repaint();
}
}
|
