static {
caps = new GLCapabilities();
caps.setDoubleBuffered(true);
caps.setAlphaBits(8);
caps.setRedBits(8);
caps.setGreenBits(8);
caps.setBlueBits(8);
}
private static GLCapabilities stdcaps() {
GLProfile prof = GLProfile.getDefault();
GLCapabilities cap = new GLCapabilities(prof);
cap.setDoubleBuffered(true);
cap.setAlphaBits(8);
cap.setRedBits(8);
cap.setGreenBits(8);
cap.setBlueBits(8);
cap.setSampleBuffers(true);
cap.setNumSamples(4);
return (cap);
}
GLFrame(JTextArea outputArea) {
this.outputArea = outputArea;
GLCapabilities caps = new GLCapabilities(Configuration.getMaxCompatibleGLProfile());
caps.setAlphaBits(8);
caps.setRedBits(8);
caps.setGreenBits(8);
caps.setBlueBits(8);
GLCanvas glCanvas = new GLCanvas(caps);
glCanvas.addGLEventListener(this);
this.add(glCanvas);
this.setSize(200, 200);
}
private void run(int type, PerfModule pm) {
int width = 800;
int height = 480;
pmod = pm;
System.err.println("Perftst.run()");
try {
GLCapabilities caps = new GLCapabilities(GLProfile.getGL2ES2());
// For emulation library, use 16 bpp
caps.setRedBits(5);
caps.setGreenBits(6);
caps.setBlueBits(5);
caps.setDepthBits(16);
Window nWindow = null;
if (0 != (type & USE_AWT)) {
Display nDisplay =
NewtFactory.createDisplay(NativeWindowFactory.TYPE_AWT, null); // local display
Screen nScreen =
NewtFactory.createScreen(NativeWindowFactory.TYPE_AWT, nDisplay, 0); // screen 0
nWindow = NewtFactory.createWindow(NativeWindowFactory.TYPE_AWT, nScreen, caps);
window = GLWindow.create(nWindow);
} else {
window = GLWindow.create(caps);
}
window.addMouseListener(this);
window.addGLEventListener(this);
// window.setEventHandlerMode(GLWindow.EVENT_HANDLER_GL_CURRENT); // default
// window.setEventHandlerMode(GLWindow.EVENT_HANDLER_GL_NONE); // no current ..
// Size OpenGL to Video Surface
window.setSize(width, height);
window.setFullscreen(true);
window.setVisible(true);
window.display();
// Shut things down cooperatively
window.destroy();
window.getFactory().shutdown();
System.out.println("Perftst shut down cleanly.");
} catch (Throwable t) {
t.printStackTrace();
}
}
private boolean mapAvailableEGLESConfig(
AbstractGraphicsDevice adevice,
int esProfile,
boolean[] hasPBuffer,
GLRendererQuirks[] rendererQuirks,
int[] ctp) {
final String profileString;
switch (esProfile) {
case 3:
profileString = GLProfile.GLES3;
break;
case 2:
profileString = GLProfile.GLES2;
break;
case 1:
profileString = GLProfile.GLES1;
break;
default:
throw new GLException("Invalid ES profile number " + esProfile);
}
if (!GLProfile.isAvailable(adevice, profileString)) {
if (DEBUG) {
System.err.println(
"EGLDrawableFactory.mapAvailableEGLESConfig: " + profileString + " n/a on " + adevice);
}
return false;
}
final GLProfile glp = GLProfile.get(adevice, profileString);
final GLDrawableFactoryImpl desktopFactory =
(GLDrawableFactoryImpl) GLDrawableFactory.getDesktopFactory();
final boolean mapsADeviceToDefaultDevice =
!QUERY_EGL_ES_NATIVE_TK || null == desktopFactory || adevice instanceof EGLGraphicsDevice;
if (DEBUG) {
System.err.println(
"EGLDrawableFactory.mapAvailableEGLESConfig: "
+ profileString
+ " ( "
+ esProfile
+ " ), "
+ "defaultSharedResourceSet "
+ (null != defaultSharedResource)
+ ", mapsADeviceToDefaultDevice "
+ mapsADeviceToDefaultDevice
+ " (QUERY_EGL_ES_NATIVE_TK "
+ QUERY_EGL_ES_NATIVE_TK
+ ", hasDesktopFactory "
+ (null != desktopFactory)
+ ", isEGLGraphicsDevice "
+ (adevice instanceof EGLGraphicsDevice)
+ ")");
}
EGLGraphicsDevice eglDevice = null;
NativeSurface surface = null;
ProxySurface upstreamSurface = null; // X11, GLX, ..
boolean success = false;
boolean deviceFromUpstreamSurface = false;
try {
final GLCapabilities reqCapsAny = new GLCapabilities(glp);
reqCapsAny.setRedBits(5);
reqCapsAny.setGreenBits(5);
reqCapsAny.setBlueBits(5);
reqCapsAny.setAlphaBits(0);
reqCapsAny.setDoubleBuffered(false);
if (mapsADeviceToDefaultDevice) {
// In this branch, any non EGL device is mapped to EGL default shared resources (default
// behavior).
// Only one default shared resource instance is ever be created.
final GLCapabilitiesImmutable reqCapsPBuffer =
GLGraphicsConfigurationUtil.fixGLPBufferGLCapabilities(reqCapsAny);
final List<GLCapabilitiesImmutable> availablePBufferCapsL =
getAvailableEGLConfigs(defaultDevice, reqCapsPBuffer);
hasPBuffer[0] = availablePBufferCapsL.size() > 0;
// 1st case: adevice is not the EGL default device, map default shared resources
if (adevice != defaultDevice) {
if (null == defaultSharedResource) {
return false;
}
switch (esProfile) {
case 3:
if (!defaultSharedResource.wasES3ContextCreated) {
return false;
}
rendererQuirks[0] = defaultSharedResource.rendererQuirksES3ES2;
ctp[0] = defaultSharedResource.ctpES3ES2;
break;
case 2:
if (!defaultSharedResource.wasES2ContextCreated) {
return false;
}
rendererQuirks[0] = defaultSharedResource.rendererQuirksES3ES2;
ctp[0] = defaultSharedResource.ctpES3ES2;
break;
case 1:
if (!defaultSharedResource.wasES1ContextCreated) {
return false;
}
rendererQuirks[0] = defaultSharedResource.rendererQuirksES1;
ctp[0] = defaultSharedResource.ctpES1;
break;
}
EGLContext.mapStaticGLVersion(adevice, esProfile, 0, ctp[0]);
return true;
}
// attempt to created the default shared resources ..
eglDevice = defaultDevice; // reuse
if (hasPBuffer[0]) {
// 2nd case create defaultDevice shared resource using pbuffer surface
surface =
createDummySurfaceImpl(
eglDevice,
false,
reqCapsPBuffer,
reqCapsPBuffer,
null,
64,
64); // egl pbuffer offscreen
upstreamSurface = (ProxySurface) surface;
upstreamSurface.createNotify();
deviceFromUpstreamSurface = false;
} else {
// 3rd case fake creation of defaultDevice shared resource, no pbuffer available
final List<GLCapabilitiesImmutable> capsAnyL =
getAvailableEGLConfigs(eglDevice, reqCapsAny);
if (capsAnyL.size() > 0) {
final GLCapabilitiesImmutable chosenCaps = capsAnyL.get(0);
EGLContext.mapStaticGLESVersion(eglDevice, chosenCaps);
success = true;
}
if (DEBUG) {
System.err.println(
"EGLDrawableFactory.mapAvailableEGLESConfig() no pbuffer config available, detected !pbuffer config: "
+ success);
EGLGraphicsConfigurationFactory.printCaps("!PBufferCaps", capsAnyL, System.err);
}
}
} else {
// 4th case always creates a true mapping of given device to EGL
surface =
desktopFactory.createDummySurface(
adevice, reqCapsAny, null, 64, 64); // X11, WGL, .. dummy window
upstreamSurface = (surface instanceof ProxySurface) ? (ProxySurface) surface : null;
if (null != upstreamSurface) {
upstreamSurface.createNotify();
}
eglDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(surface);
deviceFromUpstreamSurface = true;
hasPBuffer[0] = true;
}
if (null != surface) {
final EGLDrawable drawable =
(EGLDrawable)
createOnscreenDrawableImpl(
surface); // works w/ implicit pbuffer surface via proxy-hook
drawable.setRealized(true);
final EGLContext context = (EGLContext) drawable.createContext(null);
if (null != context) {
try {
context.makeCurrent(); // could cause exception
if (context.isCurrent()) {
final String glVersion = context.getGL().glGetString(GL.GL_VERSION);
if (null != glVersion) {
context.mapCurrentAvailableGLVersion(eglDevice);
if (eglDevice != adevice) {
context.mapCurrentAvailableGLVersion(adevice);
}
rendererQuirks[0] = context.getRendererQuirks();
ctp[0] = context.getContextOptions();
success = true;
} else {
// Oops .. something is wrong
if (DEBUG) {
System.err.println(
"EGLDrawableFactory.mapAvailableEGLESConfig: "
+ eglDevice
+ ", "
+ context.getGLVersion()
+ " - VERSION is null, dropping availability!");
}
}
}
} catch (GLException gle) {
if (DEBUG) {
System.err.println(
"EGLDrawableFactory.mapAvailableEGLESConfig: INFO: context create/makeCurrent failed");
gle.printStackTrace();
}
} finally {
context.destroy();
}
}
drawable.setRealized(false);
}
} catch (Throwable t) {
if (DEBUG) {
System.err.println("Catched Exception on thread " + getThreadName());
t.printStackTrace();
}
success = false;
} finally {
if (eglDevice == defaultDevice) {
if (null != upstreamSurface) {
upstreamSurface.destroyNotify();
}
} else if (deviceFromUpstreamSurface) {
if (null != eglDevice) {
eglDevice.close();
}
if (null != upstreamSurface) {
upstreamSurface.destroyNotify();
}
} else {
if (null != upstreamSurface) {
upstreamSurface.destroyNotify();
}
if (null != eglDevice) {
eglDevice.close();
}
}
}
return success;
}
public Sculptnect() {
// Set up Kinect
kinectContext = Freenect.createContext();
if (kinectContext.numDevices() > 0) {
kinect = kinectContext.openDevice(0);
} else {
System.err.println("Error, no Kinect detected.");
}
GLProfile.initSingleton();
GLProfile glp = GLProfile.getDefault();
// Set the OpenGL canvas creation parameters
GLCapabilities caps = new GLCapabilities(glp);
caps.setRedBits(8);
caps.setGreenBits(8);
caps.setBlueBits(8);
caps.setDepthBits(32);
final SculptScene scene = new SculptScene();
final Frame frame = new Frame();
final GLCanvas canvas = new GLCanvas(caps);
canvas.addGLEventListener(scene);
// Add and start a display link
final FPSAnimator animator = new FPSAnimator(canvas, 60, true);
frame.add(canvas);
frame.setSize(800, 800);
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice device = environment.getDefaultScreenDevice();
frame.setUndecorated(true);
device.setFullScreenWindow(frame);
frame.setVisible(true);
canvas.requestFocus();
animator.start();
// Add listener to respond to window closing
frame.addWindowListener(
new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
exit(0);
}
});
// Add key listener
canvas.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent event) {
switch (event.getKeyCode()) {
case KeyEvent.VK_ESCAPE:
exit(0);
break;
case KeyEvent.VK_SPACE:
dump = true;
break;
case 'R':
if (depthRecord == null) {
try {
String file = new Date().getTime() + ".raw.gz";
depthRecord = new KinectDepthRecord(file);
System.out.println("Recording started to " + file);
} catch (Exception e) {
e.printStackTrace();
}
} else {
depthRecord.close();
depthRecord = null;
System.out.println("Recording stopped");
}
break;
case KeyEvent.VK_LEFT:
scene.modifyModelRotationY(-1.0f);
break;
case KeyEvent.VK_RIGHT:
scene.modifyModelRotationY(1.0f);
break;
case KeyEvent.VK_UP:
scene.modifyModelRotationX(1.0f);
break;
case KeyEvent.VK_DOWN:
scene.modifyModelRotationX(-1.0f);
break;
case 'O':
scene.removeRandomSphere();
break;
case 'K':
scene.resetModel();
break;
case 'F':
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice device = environment.getDefaultScreenDevice();
if (device.getFullScreenWindow() != null) {
device.setFullScreenWindow(null);
frame.dispose();
frame.setUndecorated(false);
frame.setVisible(true);
} else {
frame.dispose();
frame.setUndecorated(true);
device.setFullScreenWindow(frame);
}
canvas.requestFocus();
break;
case 'T':
scene.toggleTurningMode();
break;
case 'I':
insertKinectPlaceholder(scene);
break;
case 'M':
scene.toggleRenderMode();
break;
case 'D':
scene.dumpMesh();
break;
}
}
});
// Create mouse listener
MouseAdapter mouseAdapter =
new MouseAdapter() {
int prevX, prevY;
@Override
public void mousePressed(MouseEvent e) {
prevX = e.getX();
prevY = e.getY();
}
@Override
public void mouseDragged(MouseEvent e) {
scene.mouseDragged(prevX, prevY, e.getX(), e.getY());
prevX = e.getX();
prevY = e.getY();
}
};
// Add the mouse listener
canvas.addMouseMotionListener(mouseAdapter);
canvas.addMouseListener(mouseAdapter);
if (kinect != null) {
kinect.setDepthFormat(DepthFormat.D10BIT);
kinect.startDepth(
new DepthHandler() {
@Override
public void onFrameReceived(FrameMode arg0, ByteBuffer arg1, int arg2) {
if (dump) {
// Dump a raw depth image
arg1.rewind();
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new Date().getTime() + ".raw");
while (arg1.remaining() > 0) {
fos.write(arg1.get());
}
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
dump = false;
}
scene.updateKinect(arg1);
if (depthRecord != null) {
try {
depthRecord.addFrame(arg1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
});
} else {
insertKinectPlaceholder(scene);
}
// Set up Playstation 2 controller
Joystick joystick = JoystickManager.getJoystick(Controller.Type.STICK);
if (joystick != null) {
joystick.setJoystickListener(scene);
}
}
