@Override
protected GLJPanel createDrawable() {
GLCapabilities caps = new GLCapabilities(null);
//
GLJPanel panel = new GLJPanel(caps);
panel.addGLEventListener(this);
panel.addKeyListener(this);
return panel;
}
private void setTitle(
final JFrame frame, final GLJPanel glc, final GLCapabilitiesImmutable caps) {
final String capsA = caps.isBackgroundOpaque() ? "opaque" : "transl";
final java.awt.Rectangle b = glc.getBounds();
final float[] minSurfacePixelScale = glc.getMinimumSurfaceScale(new float[2]);
final float[] maxSurfacePixelScale = glc.getMaximumSurfaceScale(new float[2]);
final float[] reqSurfacePixelScale = glc.getRequestedSurfaceScale(new float[2]);
final float[] hasSurfacePixelScale = glc.getCurrentSurfaceScale(new float[2]);
frame.setTitle(
"GLJPanel["
+ capsA
+ "], swapI "
+ swapInterval
+ ", win: ["
+ b.x
+ "/"
+ b.y
+ " "
+ b.width
+ "x"
+ b.height
+ "], pix: "
+ glc.getSurfaceWidth()
+ "x"
+ glc.getSurfaceHeight()
+ ", scale[min "
+ minSurfacePixelScale[0]
+ "x"
+ minSurfacePixelScale[1]
+ ", max "
+ maxSurfacePixelScale[0]
+ "x"
+ maxSurfacePixelScale[1]
+ ", req "
+ reqSurfacePixelScale[0]
+ "x"
+ reqSurfacePixelScale[1]
+ " -> has "
+ hasSurfacePixelScale[0]
+ "x"
+ hasSurfacePixelScale[1]
+ "]");
}
protected void destroy(final JFrame frame, final GLJPanel glJPanel) {
try {
if (SwingUtilities.isEventDispatchThread()) {
if (null != frame) {
frame.setVisible(false);
if (null != glJPanel) {
frame.getContentPane().remove(glJPanel);
}
frame.remove(glJPanel);
}
if (null != glJPanel) {
glJPanel.destroy();
}
if (null != frame) {
frame.dispose();
}
} else {
SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
if (null != frame) {
frame.setVisible(false);
if (null != glJPanel) {
frame.getContentPane().remove(glJPanel);
}
frame.remove(glJPanel);
}
if (null != glJPanel) {
glJPanel.destroy();
}
if (null != frame) {
frame.dispose();
}
}
});
}
} catch (final Exception e) {
e.printStackTrace();
}
}
protected void runTestGL(final GLCapabilities caps)
throws AWTException, InterruptedException, InvocationTargetException {
final JFrame frame = new JFrame("Swing GLJPanel");
frame.setLocation(xpos, ypos);
Assert.assertNotNull(frame);
final FPSAnimator animator = useAnimator ? new FPSAnimator(60) : null;
final SnapshotGLEventListener snap = new SnapshotGLEventListener();
final GLJPanel glJPanel = newGLJPanel(frame, caps, animator, snap);
if (null != animator) {
animator.start();
Assert.assertEquals(true, animator.isAnimating());
}
final Screen screen = NewtFactoryAWT.createScreen(glJPanel, true);
screen.addReference(); // initial native creation - keep alive!
System.err.println("GetPixelScale: AWT -> Screen: " + screen);
final QuitAdapter quitAdapter = new QuitAdapter();
new AWTKeyAdapter(new TraceKeyAdapter(quitAdapter), glJPanel).addTo(glJPanel);
new AWTWindowAdapter(new TraceWindowAdapter(quitAdapter), glJPanel).addTo(frame);
final JFrame[] frame2 = {null};
final GLJPanel[] glJPanel2 = {null};
final com.jogamp.newt.event.KeyListener kl =
new com.jogamp.newt.event.KeyAdapter() {
@Override
public void keyPressed(final KeyEvent e) {
if (e.isAutoRepeat()) {
return;
}
if (e.getKeySymbol() == KeyEvent.VK_P) {
System.err.println();
{
// Just for manual validation!
final java.awt.Point los = glJPanel.getLocationOnScreen();
final RectangleImmutable r =
new Rectangle(los.x, los.y, glJPanel.getWidth(), glJPanel.getHeight());
System.err.printf("GetPixelScale: Panel Bounds: %s window-units%n", r.toString());
System.err.printf(
"GetPixelScale: Panel Resolution: %d x %d pixel-units%n",
glJPanel.getSurfaceWidth(), glJPanel.getSurfaceHeight());
}
final MonitorDevice monitor = NewtFactoryAWT.getMonitorDevice(screen, glJPanel);
System.err.printf("GetPixelScale: %s%n", monitor.toString());
final float[] pixelPerMM;
final boolean cached;
if (e.isShiftDown()) {
// SHIFT: query current mode!
pixelPerMM = monitor.getPixelsPerMM(monitor.queryCurrentMode(), new float[2]);
cached = false;
} else {
// Default: Use cached mode!
pixelPerMM = monitor.getPixelsPerMM(new float[2]);
cached = true;
}
System.err.println(
" pixel/mm ["
+ pixelPerMM[0]
+ ", "
+ pixelPerMM[1]
+ "], cached-mode "
+ cached);
System.err.println(
" pixel/in ["
+ pixelPerMM[0] * 25.4f
+ ", "
+ pixelPerMM[1] * 25.4f
+ "], cached-mode "
+ cached);
System.err.println();
} else if (e.getKeyChar() == 'x') {
final float[] hadSurfacePixelScale = glJPanel.getCurrentSurfaceScale(new float[2]);
final float[] reqSurfacePixelScale;
if (hadSurfacePixelScale[0] == ScalableSurface.IDENTITY_PIXELSCALE) {
reqSurfacePixelScale =
new float[] {
ScalableSurface.AUTOMAX_PIXELSCALE, ScalableSurface.AUTOMAX_PIXELSCALE
};
} else {
reqSurfacePixelScale =
new float[] {
ScalableSurface.IDENTITY_PIXELSCALE, ScalableSurface.IDENTITY_PIXELSCALE
};
}
System.err.println(
"[set PixelScale pre]: had "
+ hadSurfacePixelScale[0]
+ "x"
+ hadSurfacePixelScale[1]
+ " -> req "
+ reqSurfacePixelScale[0]
+ "x"
+ reqSurfacePixelScale[1]);
glJPanel.setSurfaceScale(reqSurfacePixelScale);
final float[] valReqSurfacePixelScale =
glJPanel.getRequestedSurfaceScale(new float[2]);
final float[] hasSurfacePixelScale1 = glJPanel.getCurrentSurfaceScale(new float[2]);
System.err.println(
"[set PixelScale post]: "
+ hadSurfacePixelScale[0]
+ "x"
+ hadSurfacePixelScale[1]
+ " (had) -> "
+ reqSurfacePixelScale[0]
+ "x"
+ reqSurfacePixelScale[1]
+ " (req) -> "
+ valReqSurfacePixelScale[0]
+ "x"
+ valReqSurfacePixelScale[1]
+ " (val) -> "
+ hasSurfacePixelScale1[0]
+ "x"
+ hasSurfacePixelScale1[1]
+ " (has)");
setTitle(frame, glJPanel, caps);
} else if (e.getKeyChar() == 'm') {
final GLCapabilitiesImmutable capsPre = glJPanel.getChosenGLCapabilities();
final GLCapabilities capsNew = new GLCapabilities(capsPre.getGLProfile());
capsNew.copyFrom(capsPre);
final boolean msaa;
if (capsPre.getSampleBuffers()) {
capsNew.setSampleBuffers(false);
msaa = false;
} else {
capsNew.setSampleBuffers(true);
capsNew.setNumSamples(4);
msaa = true;
}
System.err.println("[set MSAA " + msaa + " Caps had]: " + capsPre);
System.err.println("[set MSAA " + msaa + " Caps new]: " + capsNew);
System.err.println("XXX-A1: " + animator.toString());
glJPanel.setRequestedGLCapabilities(capsNew);
System.err.println("XXX-A2: " + animator.toString());
System.err.println("XXX: " + glJPanel.toString());
} else if (e.getKeyChar() == 'n') {
System.err.println("XXX: frame2: " + frame2[0]);
if (null != frame2[0]) {
System.err.println("XXX: frame2.isShowing: " + frame2[0].isShowing());
}
System.err.println("XXX: glJPanel2: " + glJPanel2[0]);
if (null != frame2[0] && frame2[0].isShowing()) {
destroy(frame2[0], glJPanel2[0]);
frame2[0] = null;
glJPanel2[0] = null;
} else {
frame2[0] = new JFrame("GLJPanel2");
frame2[0].setLocation(frame.getX() + frame.getWidth() + 64, frame.getY());
final FPSAnimator animator2 = useAnimator ? new FPSAnimator(60) : null;
if (null != animator2) {
animator2.start();
}
final SnapshotGLEventListener snap2 = new SnapshotGLEventListener();
try {
glJPanel2[0] = newGLJPanel(frame2[0], caps, animator2, snap2);
} catch (final Exception e2) {
e2.printStackTrace();
destroy(frame2[0], glJPanel2[0]);
frame2[0] = null;
glJPanel2[0] = null;
}
}
}
}
};
new AWTKeyAdapter(kl, glJPanel).addTo(glJPanel);
snap.setMakeSnapshot();
if (null != rwsize) {
Thread.sleep(500); // 500ms delay
setFrameSize(frame, true, rwsize);
System.err.println(
"window resize pos/siz: "
+ glJPanel.getX()
+ "/"
+ glJPanel.getY()
+ " "
+ glJPanel.getSurfaceWidth()
+ "x"
+ glJPanel.getSurfaceHeight());
}
snap.setMakeSnapshot();
final long t0 = System.currentTimeMillis();
long t1 = t0;
boolean triggerSnap = false;
while (!quitAdapter.shouldQuit() && t1 - t0 < duration) {
Thread.sleep(100);
t1 = System.currentTimeMillis();
snap.getDisplayCount();
if (!triggerSnap && snap.getDisplayCount() > 1) {
// Snapshot only after one frame has been rendered to suite FBO MSAA!
snap.setMakeSnapshot();
triggerSnap = true;
}
}
Assert.assertNotNull(frame);
Assert.assertNotNull(glJPanel);
if (useAnimator) {
Assert.assertNotNull(animator);
animator.stop();
Assert.assertEquals(false, animator.isAnimating());
} else {
Assert.assertNull(animator);
}
screen.removeReference(); // final native destroy
destroy(frame, glJPanel);
if (null != frame2[0]) {
destroy(frame2[0], glJPanel2[0]);
}
}
protected GLJPanel newGLJPanel(
final JFrame frame,
final GLCapabilities caps,
final FPSAnimator animator,
final SnapshotGLEventListener snap)
throws AWTException, InterruptedException, InvocationTargetException {
final GLJPanel glJPanel = new GLJPanel(caps);
Assert.assertNotNull(glJPanel);
glJPanel.setSkipGLOrientationVerticalFlip(skipGLOrientationVerticalFlip);
glJPanel.setMinimumSize(wsize);
glJPanel.setPreferredSize(wsize);
glJPanel.setSize(wsize);
glJPanel.setSurfaceScale(reqSurfacePixelScale);
{
final GLEventListener demo = createDemo(caps);
if (null != demo) {
glJPanel.addGLEventListener(demo);
}
}
if (null != snap) {
glJPanel.addGLEventListener(snap);
}
glJPanel.addGLEventListener(
new GLEventListener() {
@Override
public void init(final GLAutoDrawable drawable) {}
@Override
public void dispose(final GLAutoDrawable drawable) {}
@Override
public void display(final GLAutoDrawable drawable) {}
@Override
public void reshape(
final GLAutoDrawable drawable,
final int x,
final int y,
final int width,
final int height) {
setTitle(frame, glJPanel, caps);
}
});
setTitle(frame, glJPanel, caps);
frame.addComponentListener(
new ComponentListener() {
@Override
public void componentResized(final ComponentEvent e) {
setTitle(frame, glJPanel, caps);
}
@Override
public void componentMoved(final ComponentEvent e) {
setTitle(frame, glJPanel, caps);
}
@Override
public void componentShown(final ComponentEvent e) {}
@Override
public void componentHidden(final ComponentEvent e) {}
});
if (SwingUtilities.isEventDispatchThread()) {
frame.getContentPane().add(glJPanel, BorderLayout.CENTER);
frame.getContentPane().validate();
frame.pack();
frame.setVisible(true);
} else {
SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
frame.getContentPane().add(glJPanel, BorderLayout.CENTER);
frame.getContentPane().validate();
frame.pack();
frame.setVisible(true);
}
});
Assert.assertEquals(true, AWTRobotUtil.waitForVisible(frame, true));
Assert.assertEquals(true, AWTRobotUtil.waitForRealized(glJPanel, true));
final float[] minSurfacePixelScale = glJPanel.getMinimumSurfaceScale(new float[2]);
final float[] maxSurfacePixelScale = glJPanel.getMaximumSurfaceScale(new float[2]);
final float[] valReqSurfacePixelScale = glJPanel.getRequestedSurfaceScale(new float[2]);
final float[] hasSurfacePixelScale = glJPanel.getCurrentSurfaceScale(new float[2]);
System.err.println(
"HiDPI PixelScale: min "
+ minSurfacePixelScale[0]
+ "x"
+ minSurfacePixelScale[1]
+ ", max "
+ maxSurfacePixelScale[0]
+ "x"
+ maxSurfacePixelScale[1]
+ ", req "
+ reqSurfacePixelScale[0]
+ "x"
+ reqSurfacePixelScale[1]
+ " -> val "
+ valReqSurfacePixelScale[0]
+ "x"
+ valReqSurfacePixelScale[1]
+ " -> has "
+ hasSurfacePixelScale[0]
+ "x"
+ hasSurfacePixelScale[1]);
setTitle(frame, glJPanel, caps);
}
if (null != animator) {
animator.add(glJPanel);
animator.setUpdateFPSFrames(60, System.err);
}
return glJPanel;
}