This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.
package com.threed.jpct;
import org.lwjgl.opengl.*;
import java.awt.GraphicsConfiguration;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.geom.AffineTransform;
class AWTJPCTCanvas extends AWTGLCanvas implements IThreadBuffer {
private static final long serialVersionUID = 1L;
private AWTGLRenderer renderer = null;
private AWTDisplayList[] list = null;
private AWTDisplayList onceList = null;
private int curList = 0;
private Object lock = new Object();
private boolean paintObserver = false;
private Object[] result = null;
AWTJPCTCanvas() throws Exception {
}
AWTJPCTCanvas(AWTGLRenderer myRenderer) throws Exception {
super();
init(myRenderer);
}
AWTJPCTCanvas(AWTGLRenderer myRenderer, PixelFormat pf) throws Exception {
super(pf);
init(myRenderer);
}
public void setSamples(int samples) {
// Bereits im PF erledigt...hier egal...
}
protected void init(AWTGLRenderer myRenderer) {
renderer = myRenderer;
list = new AWTDisplayList[2];
list
[o]= new AWTDisplayList();
list[1] = new AWTDisplayList();
onceList = new AWTDisplayList();
// Reassert viewport after resizes so device-pixel size stays in sync.
addComponentListener(new ComponentAdapter() {
@Override
public void componentResized(ComponentEvent e) {
// Trigger a repaint so paintGL() can recompute the viewport.
repaint();
}
});
}
public void exceptionOccurred(org.lwjgl.LWJGLException e) {
if (e.getMessage().indexOf("No support for") != -1) {
// A hack to take care of missing aa-support in intel. Injects a new
// pixel format into the canvas vie reflection and makes the
// canvas think that it's new...
try {
java.lang.reflect.Field field = AWTGLCanvas.class.getDeclaredField("pixel_format");
field.setAccessible(true);
PixelFormat pf = (PixelFormat) field.get(this);
if (pf == null || pf.getSamples() != 0) {
Logger.log("No support for multi sampling...trying to recover!", Logger.WARNING);
field.set(this, new PixelFormat());
java.lang.reflect.Field count = AWTGLCanvas.class.getDeclaredField("reentry_count");
java.lang.reflect.Field peer = AWTGLCanvas.class.getDeclaredField("peer_info");
count.setAccessible(true);
peer.setAccessible(true);
peer.set(this, (Object[]) null);
} else {
Logger.log(e, Logger.ERROR);
}
} catch (Throwable e1) {
Logger.log(e1, Logger.WARNING);
e.printStackTrace();
Logger.log(e, Logger.ERROR);
}
} else {
Logger.log(e, Logger.ERROR);
}
}
public void dispose() {
setEnabled(false);
}
public final void add(int command, Object params) {
list[curList].add(command, params);
}
public void add(Camera proj, int[] ambient) {
Object[] params = new Object[2];
Camera cam2 = new Camera();
cam2.setBack(proj.getBack().cloneMatrix());
cam2.setPosition(proj.getPosition());
cam2.setFOVLimits(proj.getMinFOV(), proj.getMaxFOV());
cam2.setFOV(proj.getFOV());
params
[o]= cam2;
int[] am = new int[ambient.length];
for (int i = 0; i < am.length; i++) {
am[i] = ambient[i];
}
params[1] = am;
add(GLBase.MODE_SET_CAMERA, params);
}
public final void addOnce(int command, Object params) {
onceList.addOnce(command, params);
}
public Object getLock() {
return lock;
}
public final void add(VisList v, int s, int e, int m) {
list[curList].add(v, s, e, m);
}
public void enableRenderTarget() {
list[curList].enableRenderTarget();
}
public void disableRenderTarget() {
list[curList].disableRenderTarget();
}
public boolean hasRenderTarget() {
return list[curList].hasRenderTarget();
}
public final void setColor(int col) {
list[curList].setColor(col);
}
public final AWTDisplayList getDisplayList() {
return list[curList];
}
/*
* public final void fillInstances() { synchronized (lock) {
* list[curList].fillInstances(); } }
*/
public final void switchList() {
if (Config.synchronizedRendering) {
while (!list[curList ^ 1].rendered) {
Thread.yield();
}
}
synchronized (lock) {
list[curList].switchBuffers();
curList ^= 1;
list[curList].reset();
}
}
public final boolean hasBeenPainted() {
return paintObserver;
}
public final void observePainting() {
paintObserver = false;
}
public final Object[] getPaintResults() {
if (hasBeenPainted()) {
Object[] res = result;
result = null;
return res;
}
return null;
}
// --- HiDPI fix: ensure the GL viewport matches the device-pixel backbuffer ---
/** Ensure GL viewport matches device-pixel backbuffer (fixes HiDPI offset). */
private void ensureHiDPIVP() {
int fbW, fbH;
GraphicsConfiguration gc = getGraphicsConfiguration();
if (gc != null) {
AffineTransform tx = gc.getDefaultTransform();
double sx = tx.getScaleX(), sy = tx.getScaleY();
int lw = Math.max(1, getWidth());
int lh = Math.max(1, getHeight());
fbW = (int)Math.round(lw * sx);
fbH = (int)Math.round(lh * sy);
} else {
fbW = Math.max(1, getWidth());
fbH = Math.max(1, getHeight());
}
GL11.glViewport(0, 0, fbW, fbH);
}
// ------------------------------------------------------------------------------
public void paintGL() {
try {
makeCurrent();
// HiDPI: align viewport to device-pixel framebuffer before any rendering.
ensureHiDPIVP();
if (!renderer.isDisposed()) {
if (!renderer.isInitialized()) {
renderer.init();
}
renderer.execute(GLBase.MODE_START_PAINTING, null);
synchronized (lock) {
// Normales Zeichnen...
int ind = curList ^ 1;
AWTDisplayList al = list[ind];
int end = al.count;
for (int i = 0; i < end; i++) {
int mode = al.mode[i];
switch (mode) {
case (AWTDisplayList.EXECUTE): {
renderer.executeGL(al, i);
break;
}
case (AWTDisplayList.ARRAY): {
renderer.drawVertexArray(al, i);
break;
}
case (AWTDisplayList.STRIP): {
renderer.drawStrip(al, i);
break;
}
case (AWTDisplayList.POLYGON): {
renderer.drawPolygon(al, i);
break;
}
case (AWTDisplayList.WIREFRAME): {
renderer.drawWireframe(al, i);
break;
}
}
}
// "Once"-Befehle ausführen (pixelgrabben und Context
// befragen z.B.)!
boolean po = paintObserver;
if (onceList.count != 0) {
boolean pop = false;
for (int i = 0; i < onceList.count; i++) {
int mode = onceList.mode[i];
if (mode == AWTDisplayList.EXECUTE_ONCE && !po) {
result = renderer.executeGL(onceList, i);
onceList.delete(i);
pop = true;
}
}
paintObserver = pop;
}
al.rendered = true;
}
}
renderer.execute(GLBase.MODE_END_PAINTING, null);
swapBuffers();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public boolean isVisible() {
return super.isVisible();
}
}
if (currentScene instanceof Scene3d && lastScene instanceof Scene2d) {//SWITCH FROM 2D to 3D
frame.setVisible(false);
try{org.lwjgl.opengl.Display.setFullscreen(true);//CRASHING
org.lwjgl.opengl.Display.makeCurrent();}catch(Exception e) {}
keyMapper = new KeyMapper();
}