WindowContext createWindow(final GLProfile glp, final boolean debugGL) {
final GLCapabilities caps = new GLCapabilities(glp);
//
// Create native windowing resources .. X11/Win/OSX
//
final Display display = NewtFactory.createDisplay(null); // local display
Assert.assertNotNull(display);
final Screen screen = NewtFactory.createScreen(display, 0); // screen 0
Assert.assertNotNull(screen);
final Window window = NewtFactory.createWindow(screen, caps);
Assert.assertNotNull(window);
window.setSize(128, 128);
window.setVisible(true);
final GLDrawableFactory factory = GLDrawableFactory.getFactory(glp);
final GLDrawable drawable = factory.createGLDrawable(window);
Assert.assertNotNull(drawable);
drawable.setRealized(true);
final GLContext context = drawable.createContext(null);
Assert.assertNotNull(context);
context.enableGLDebugMessage(debugGL);
final int res = context.makeCurrent();
Assert.assertTrue(GLContext.CONTEXT_CURRENT_NEW == res || GLContext.CONTEXT_CURRENT == res);
return new WindowContext(window, context);
}
public static final GL2 getCurrentGL2() throws GLException {
GLContext curContext = GLContext.getCurrent();
if (curContext == null) {
throw new GLException("No OpenGL context current on this thread");
}
return curContext.getGL().getGL2();
}
/**
* Main program.
*
* @param args Command line arguments
* @throws Exception On errors
*/
public static void main(final String[] args) throws Exception {
if (args.length != 3 && args.length != 4) {
Main.LOG.info("usage: root file.vert [file.geom] file.frag");
System.exit(1);
}
final File root = new File(args[0]);
final R2ShaderPreprocessorType p = R2ShaderPreprocessor.newPreprocessor(root);
List<String> vs = null;
Optional<List<String>> gs = null;
List<String> fs = null;
try {
if (args.length == 4) {
vs = p.preprocessFile(args[1]);
gs = Optional.of(p.preprocessFile(args[2]));
fs = p.preprocessFile(args[3]);
} else {
vs = p.preprocessFile(args[1]);
gs = Optional.empty();
fs = p.preprocessFile(args[2]);
}
} catch (final Exception e) {
Main.LOG.error("Preprocessing failure: ", e);
System.exit(1);
}
final GLProfile pro = GLProfile.get(GLProfile.GL3);
final GLCapabilities caps = new GLCapabilities(pro);
final GLDrawableFactory f = GLDrawableFactory.getFactory(pro);
final GLOffscreenAutoDrawable drawable =
f.createOffscreenAutoDrawable(null, caps, null, 32, 32);
drawable.display();
final GLContext ctx = drawable.getContext();
ctx.makeCurrent();
try {
final JCGLImplementationJOGLType i = JCGLImplementationJOGL.getInstance();
final JCGLContextType jc = i.newContextFrom(ctx, "offscreen");
final JCGLInterfaceGL33Type gi = jc.contextGetGL33();
final R2ShaderCheckerType ch = R2ShaderChecker.newChecker(gi.getShaders());
ch.check(vs, gs, fs);
} finally {
ctx.release();
drawable.destroy();
}
}
@Override
protected final GLDrawableImpl createOffscreenDrawableImpl(final NativeSurface target) {
if (target == null) {
throw new IllegalArgumentException("Null target");
}
final AbstractGraphicsConfiguration config = target.getGraphicsConfiguration();
final GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities();
if (!caps.isPBuffer()) {
return new X11PixmapGLXDrawable(this, target);
}
// PBuffer GLDrawable Creation
GLDrawableImpl pbufferDrawable;
final AbstractGraphicsDevice device = config.getScreen().getDevice();
/**
* Due to the ATI Bug https://bugzilla.mozilla.org/show_bug.cgi?id=486277, we need to have a
* context current on the same Display to create a PBuffer. The dummy context shall also use the
* same Display, since switching Display in this regard is another ATI bug.
*/
final SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
if (null != sr && sr.isGLXVendorATI() && null == GLContext.getCurrent()) {
sr.getContext().makeCurrent();
try {
pbufferDrawable = new X11PbufferGLXDrawable(this, target);
} finally {
sr.getContext().release();
}
} else {
pbufferDrawable = new X11PbufferGLXDrawable(this, target);
}
return pbufferDrawable;
}
public static void setBoundElementVBO(final RendererRecord rendRecord, final int id) {
final GL gl = GLContext.getCurrentGL();
if (!rendRecord.isElementVboValid() || rendRecord.getCurrentElementVboId() != id) {
gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, id);
rendRecord.setCurrentElementVboId(id);
rendRecord.setElementVboValid(true);
}
}
/**
* //! Draw a pretty arrow on the z-axis using a cone and a cylinder (using GLUT)
*
* @param aArrowStart
* @param aArrowTip
* @param aWidth
*/
public static void jDrawArrow(
final JVector3d aArrowStart, final JVector3d aArrowTip, final double aWidth) {
GL2 gl = GLContext.getCurrent().getGL().getGL2();
gl.glPushMatrix();
// We don't really care about the up vector, but it can't
// be parallel to the arrow...
JVector3d up = new JVector3d(0, 1, 0);
// JVector3d arrow = aArrowTip-aArrowStart;
JVector3d arrow = new JVector3d(0, 0, 0);
arrow.normalize();
double d = Math.abs(JMaths.jDot(up, arrow));
if (d > .9) {
up = new JVector3d(1, 0, 0);
}
JMatrixGL.jLookAt(gl, aArrowStart, aArrowTip, up);
double distance = JMaths.jDistance(aArrowTip, aArrowStart);
// This flips the z axis around
gl.glRotatef(180, 1, 0, 0);
// create a new OpenGL quadratic object
GLUquadric quadObj;
quadObj = glu.gluNewQuadric();
// set rendering style
glu.gluQuadricDrawStyle(quadObj, GLU.GLU_FILL);
// set normal-rendering mode
glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
// render a cylinder and a cone
gl.glRotatef(180, 1, 0, 0);
glu.gluDisk(quadObj, 0, aWidth, 10, 10);
gl.glRotatef(180, 1, 0, 0);
glu.gluCylinder(quadObj, aWidth, aWidth, distance * ARROW_CYLINDER_PORTION, 10, 10);
gl.glTranslated(0, 0, ARROW_CYLINDER_PORTION * distance);
gl.glRotatef(180, 1, 0, 0);
glu.gluDisk(quadObj, 0, aWidth * 2.0, 10, 10);
gl.glRotatef(180, 1, 0, 0);
glu.gluCylinder(quadObj, aWidth * 2.0, 0.0, distance * ARRROW_CONE_PORTION, 10, 10);
// delete our quadric object
glu.gluDeleteQuadric(quadObj);
gl.glPopMatrix();
}
private static final GLUgl2ProcAddressTable getGLUProcAddressTable() {
if (gluProcAddressTable == null) {
GLContext curContext = GLContext.getCurrent();
if (curContext == null) {
throw new GLException("No OpenGL context current on this thread");
}
GLDynamicLookupHelper glLookupHelper =
((GLContextImpl) curContext).getGLDynamicLookupHelper();
glLookupHelper.loadGLULibrary();
GLUgl2ProcAddressTable tmp = new GLUgl2ProcAddressTable(new GLProcAddressResolver());
tmp.reset(glLookupHelper);
gluProcAddressTable = tmp;
}
return gluProcAddressTable;
}
public static void applyScissors(final RendererRecord rendRecord) {
final GL gl = GLContext.getCurrentGL();
final Stack<ReadOnlyRectangle2> clips = rendRecord.getScissorClips();
if (clips.size() > 0) {
final Rectangle2 init = Rectangle2.fetchTempInstance();
init.set(-1, -1, -1, -1);
ReadOnlyRectangle2 r;
boolean first = true;
for (int i = clips.size(); --i >= 0; ) {
r = clips.get(i);
if (r == null) {
break;
}
if (first) {
init.set(r);
first = false;
} else {
init.intersect(r, init);
}
if (init.getWidth() <= 0 || init.getHeight() <= 0) {
init.setWidth(0);
init.setHeight(0);
break;
}
}
if (init.getWidth() == -1) {
setClippingEnabled(rendRecord, false);
} else {
setClippingEnabled(rendRecord, true);
gl.glScissor(init.getX(), init.getY(), init.getWidth(), init.getHeight());
}
Rectangle2.releaseTempInstance(init);
} else {
// no clips, so disable
setClippingEnabled(rendRecord, false);
}
}
/**
* Draw a line-based box with sides parallel to the x-y-z axes.
*
* @param aXMin
* @param aXMax
* @param aYMin
* @param aYMax
* @param aZMin
* @param aZMax
*/
public static void jDrawWireBox(
final double aXMin,
final double aXMax,
final double aYMin,
final double aYMax,
final double aZMin,
final double aZMax) {
GL2 gl = GLContext.getCurrent().getGL().getGL2();
// render lines for each edge of the box
gl.glBegin(GL2.GL_LINES);
gl.glVertex3d(aXMin, aYMin, aZMin);
gl.glVertex3d(aXMax, aYMin, aZMin);
gl.glVertex3d(aXMin, aYMax, aZMin);
gl.glVertex3d(aXMax, aYMax, aZMin);
gl.glVertex3d(aXMin, aYMin, aZMax);
gl.glVertex3d(aXMax, aYMin, aZMax);
gl.glVertex3d(aXMin, aYMax, aZMax);
gl.glVertex3d(aXMax, aYMax, aZMax);
gl.glVertex3d(aXMin, aYMin, aZMin);
gl.glVertex3d(aXMin, aYMax, aZMin);
gl.glVertex3d(aXMax, aYMin, aZMin);
gl.glVertex3d(aXMax, aYMax, aZMin);
gl.glVertex3d(aXMin, aYMin, aZMax);
gl.glVertex3d(aXMin, aYMax, aZMax);
gl.glVertex3d(aXMax, aYMin, aZMax);
gl.glVertex3d(aXMax, aYMax, aZMax);
gl.glVertex3d(aXMin, aYMin, aZMin);
gl.glVertex3d(aXMin, aYMin, aZMax);
gl.glVertex3d(aXMax, aYMin, aZMin);
gl.glVertex3d(aXMax, aYMin, aZMax);
gl.glVertex3d(aXMin, aYMax, aZMin);
gl.glVertex3d(aXMin, aYMax, aZMax);
gl.glVertex3d(aXMax, aYMax, aZMin);
gl.glVertex3d(aXMax, aYMax, aZMax);
gl.glEnd();
}
/**
* //! Draw an x-y-z frame.
*
* @param aAxisLengthScale
* @param aAxisThicknessScale
* @param aModifyMaterialState
*/
public static void jDrawFrame(
final double aAxisLengthScale,
final double aAxisThicknessScale,
final boolean aModifyMaterialState) {
// Triangle vertices:
int nTriangles = 8;
// Quad vertices:
int nQuads = 16;
GL2 gl = GLContext.getCurrent().getGL().getGL2();
// set material properties
float[] fnull = {0, 0, 0, 0};
gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, fnull, 0);
gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_EMISSION, fnull, 0);
gl.glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE);
gl.glEnable(GL2.GL_COLOR_MATERIAL);
gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL);
// enable vertex and normal arrays
gl.glEnableClientState(GL2.GL_NORMAL_ARRAY);
gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
if (aModifyMaterialState) {
gl.glEnable(GL2.GL_COLOR_MATERIAL);
gl.glColorMaterial(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE);
gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL);
}
for (int k = 0; k < 3; k++) {
gl.glPushMatrix();
// Rotate to the appropriate axis
if (k == 0) {
gl.glRotatef(-90.0f, 0, 1, 0);
gl.glColor3f(1.0f, 0.0f, 0.0f);
} else if (k == 1) {
gl.glRotatef(90.0f, 1, 0, 0);
gl.glColor3f(0.0f, 1.0f, 0.0f);
} else {
gl.glRotatef(180.0f, 1, 0, 0);
gl.glColor3f(0.0f, 0.0f, 1.0f);
}
// scaling
gl.glScaled(aAxisThicknessScale, aAxisThicknessScale, aAxisLengthScale);
// render frame object
gl.glVertexPointer(3, GL2.GL_FLOAT, 0, triVerticesBuffer);
gl.glNormalPointer(GL2.GL_FLOAT, 0, triNormalsBuffer);
gl.glDrawArrays(GL2.GL_TRIANGLES, 0, nTriangles * 3);
gl.glVertexPointer(3, GL2.GL_FLOAT, 0, quadVerticesBuffer);
gl.glNormalPointer(GL2.GL_FLOAT, 0, quadNormalsBuffer);
gl.glDrawArrays(GL2.GL_QUADS, 0, nQuads * 4);
gl.glPopMatrix();
}
// disable vertex and normal arrays
gl.glDisableClientState(GL2.GL_NORMAL_ARRAY);
gl.glDisableClientState(GL2.GL_VERTEX_ARRAY);
}
GL2 gl() {
if (gl == null) {
gl = GLContext.getCurrentGL().getGL2();
}
return gl;
}
public void asyncEachOneAnimator(final boolean destroyCleanOrder)
throws InterruptedException, InvocationTargetException {
final Frame f1 = new Frame();
final Animator a1 = new Animator();
final GearsES2 g1 = new GearsES2(0);
final GLCanvas c1 = createGLCanvas(f1, 0, 0, g1);
a1.add(c1);
a1.start();
// f1.setVisible(true); // we do this post f2 .. to test pending creation!
final Frame f2 = new Frame();
final Animator a2 = new Animator();
final GearsES2 g2 = new GearsES2(0);
g2.setSharedGears(g1);
final GLCanvas c2 = createGLCanvas(f2, f1.getX() + width, f1.getY() + 0, g2);
c2.setSharedAutoDrawable(c1);
a2.add(c2);
a2.start();
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
f2.setVisible(true);
}
});
Thread.sleep(200); // wait a while ..
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
f1.setVisible(true); // test pending creation of f2
}
});
final Frame f3 = new Frame();
final Animator a3 = new Animator();
final GearsES2 g3 = new GearsES2(0);
g3.setSharedGears(g1);
final GLCanvas c3 = createGLCanvas(f3, f1.getX() + 0, f1.getY() + height, g3);
c3.setSharedAutoDrawable(c1);
a3.add(c3);
a3.start();
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
f3.setVisible(true);
}
});
Thread.sleep(
1000 / 60
* 10); // wait ~10 frames giving a chance to create (blocking until master share is
// valid)
Assert.assertTrue(AWTRobotUtil.waitForRealized(c1, true));
Assert.assertTrue(AWTRobotUtil.waitForVisible(c1, true));
Assert.assertTrue(AWTRobotUtil.waitForContextCreated(c1, true));
Assert.assertTrue("Gears1 not initialized", g1.waitForInit(true));
Assert.assertTrue(AWTRobotUtil.waitForRealized(c2, true));
Assert.assertTrue(AWTRobotUtil.waitForVisible(c2, true));
Assert.assertTrue(AWTRobotUtil.waitForContextCreated(c2, true));
Assert.assertTrue("Gears2 not initialized", g2.waitForInit(true));
Assert.assertTrue(AWTRobotUtil.waitForRealized(c3, true));
Assert.assertTrue(AWTRobotUtil.waitForVisible(c3, true));
Assert.assertTrue(AWTRobotUtil.waitForContextCreated(c3, true));
Assert.assertTrue("Gears3 not initialized", g3.waitForInit(true));
final GLContext ctx1 = c1.getContext();
final GLContext ctx2 = c2.getContext();
final GLContext ctx3 = c3.getContext();
{
final List<GLContext> ctx1Shares = ctx1.getCreatedShares();
final List<GLContext> ctx2Shares = ctx2.getCreatedShares();
final List<GLContext> ctx3Shares = ctx3.getCreatedShares();
MiscUtils.dumpSharedGLContext("XXX-C-3.1", ctx1);
MiscUtils.dumpSharedGLContext("XXX-C-3.2", ctx2);
MiscUtils.dumpSharedGLContext("XXX-C-3.3", ctx3);
Assert.assertTrue("Ctx1 is not shared", ctx1.isShared());
Assert.assertTrue("Ctx2 is not shared", ctx2.isShared());
Assert.assertTrue("Ctx3 is not shared", ctx3.isShared());
Assert.assertEquals("Ctx1 has unexpected number of created shares", 2, ctx1Shares.size());
Assert.assertEquals("Ctx2 has unexpected number of created shares", 2, ctx2Shares.size());
Assert.assertEquals("Ctx3 has unexpected number of created shares", 2, ctx3Shares.size());
}
Assert.assertTrue("Gears1 is shared", !g1.usesSharedGears());
Assert.assertTrue("Gears2 is not shared", g2.usesSharedGears());
Assert.assertTrue("Gears3 is not shared", g3.usesSharedGears());
try {
Thread.sleep(duration);
} catch (final Exception e) {
e.printStackTrace();
}
// Stopped animator allows native windowing system 'repaint' event
// to trigger GLAD 'display'
a1.stop();
Assert.assertEquals(false, a1.isAnimating());
a2.stop();
Assert.assertEquals(false, a2.isAnimating());
a3.stop();
Assert.assertEquals(false, a3.isAnimating());
if (destroyCleanOrder) {
System.err.println("XXX Destroy in clean order NOW");
} else {
System.err.println(
"XXX Destroy in creation order NOW - Driver Impl. Ma trigger driver Bug i.e. not postponing GL ctx destruction after releasing all refs.");
}
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
try {
if (destroyCleanOrder) {
f3.dispose();
} else {
f1.dispose();
}
} catch (final Throwable t) {
throw new RuntimeException(t);
}
}
});
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
try {
f2.dispose();
} catch (final Throwable t) {
throw new RuntimeException(t);
}
}
});
javax.swing.SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
try {
if (destroyCleanOrder) {
f1.dispose();
} else {
f3.dispose();
}
} catch (final Throwable t) {
throw new RuntimeException(t);
}
}
});
Assert.assertTrue(AWTRobotUtil.waitForRealized(c1, false));
Assert.assertTrue(AWTRobotUtil.waitForRealized(c2, false));
Assert.assertTrue(AWTRobotUtil.waitForRealized(c3, false));
}
public static void setClippingEnabled(final RendererRecord rendRecord, final boolean enabled) {
final GL gl = GLContext.getCurrentGL();
if (enabled && (!rendRecord.isClippingTestValid() || !rendRecord.isClippingTestEnabled())) {
gl.glEnable(GL.GL_SCISSOR_TEST);
rendRecord.setClippingTestEnabled(true);
} else if (!enabled
&& (!rendRecord.isClippingTestValid() || rendRecord.isClippingTestEnabled())) {
gl.glDisable(GL.GL_SCISSOR_TEST);
rendRecord.setClippingTestEnabled(false);
}
rendRecord.setClippingTestValid(true);
}