I'll produce a simple test for you. But it's interesting that it doesn't happen on Intel, right?

I have a surprising piece of information: I've been trying hardware for running offline AI and I got an excellent computer with an Intel GPU. On AMD and NVidia that problem happens. On the Intel GPU it does not. So I asked that very computer and it suggested the following:

// After you have moved the camera or otherwise changed the viewport size:
GL11.glDisable(GL11.GL_SCISSOR_TEST);          // make sure the old scissor is gone
GL11.glViewport(0, 0, canvas.getWidth(), canvas.getHeight());
GL11.glEnable(GL11.GL_SCISSOR_TEST);           // re‑enable with the *new* dimensions
GL11.glScissor(0, 0, canvas.getWidth(), canvas.getHeight());


The code is only the following. Is it possible that the Overlay class needs attention after this change to AWTGlCanvas?

       fullScreenOverlay = new Overlay(theWorld, 0, 50, (int)(buffer.getWidth()), (int)(buffer.getHeight()-50), "FullInterface");
       fullScreenOverlay.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
       fullScreenOverlay.setTransparency(250);


It's bizarre that you compiled. I'll see if I did something weird to the jar.

Yeah, it's like our repair just extended the drawing area. I'll show you the code tomorrow, but it should draw at the ends of the frame, but instead it's not centralized.

That line compiles with old jpct versions and not with the latest one.

What about the canvas?

There's a little problem with the Canvas fix: it's not centering. I've only noticed once I updated jpct on a very centered (fighting) game. Check out the two images. One, naturally, is before the fix, the other one is after. Everything renders in the same place, it's just that the new version doesn't clip on the canvas space.

Also, we're missing a version of blit() because the following line isn't compiling: buffer.blit(splash1, 0, 0, 0, 0, splash1.getWidth(), splash1.getHeight(), buffer.getOutputWidth(), buffer.getOutputHeight(), 200, true);

https://www.dropbox.com/scl/fi/hlz31f7yuhgpusijmhjbw/CanvasFix_before.png?rlkey=rx8al2fz1ani7dz3khprxkgc5&st=cxyi3f3w&dl=0

https://www.dropbox.com/scl/fi/dinizqm379uh1rzaho1qf/CanvasFix_after.png?rlkey=axi07hpkewics8qbfmsgpp65m&st=9ww1q8pb&dl=0

And I'm only using JDK 21 (I never go to bleeding edge purposely). Also: warning: [removal] finalize() in Object has been deprecated and marked for removal.

The good news: I made an OrthographicCamera class which works with minimal changes to AWTGLRenderer and World. I'll add it to SoftGLRenderer also. I'd be more than happy to share it with you if you added it to the official release.

Egon, could you possibly add that to version 1.33? I'm trying to mergeAll without looping but the line Object3D.mergeAll((Object3D[])new SimpleGlbLoader().loadGlbNoSkin(modelFile).toArray()) doesn't work. If I have to loop, we're back to very slow merging.

It works, thanks a lot. I'm glad jpct is back at form. Actually, my standalone GLB importer is nearly perfect now. I have a script for splitting animations inside Blender and exporting multiple clips straight into jpct, so it's better than at form.

Exception in thread "main" java.lang.NoClassDefFoundError: com/threed/jpct/AWTJPCTCanvas$1
        at com.threed.jpct.AWTJPCTCanvas.init(AWTJPCTCanvas.java:53)
        at com.threed.jpct.AWTJPCTCanvas.<init>(AWTJPCTCanvas.java:38)
        at com.threed.jpct.AWTGLRenderer.init(AWTGLRenderer.java:73)
        at com.threed.jpct.FrameBuffer.enableRenderer(FrameBuffer.java:1154)
        at com.threed.jpct.FrameBuffer.enableGLCanvasRenderer(FrameBuffer.java:739)

Thanks very much. I'll let you know before I sleep.

It's software. I managed to recompile just the one class. And the fix worked!

CG proposed the following changes to AWTJPCTCanvas. If you could possibly compile it for me (I've never compiled jpct, only my C# port) so that I could test it I would be very grateful:

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();
      }
}


I tried quoting this line, but it didn't show up for some reason:
Have you actually tried this approach: https://www.jpct.net/wiki/index226d.html?title=Using_jPCT_in_Swing

This example seems to be using software rendering.

This seems to be software. Am I missing something?