I've moved the question into a new topic, just in case you are wondering.

I'm not aware of a problem with the location of AWTGLCanvas but then again, I've never really used it in situations where it doesn't use the whole frame. So I never tried to use it as part of an actual UI.

Have to tried to disable Java2D's accelerated rendering pipeline? Maybe it's a problem with that (albeit I doubt it, but it might be worth a try).

This topic has been moved to Support.

https://www.jpct.net/forum2/index.php?topic=5265.0

Nice to see you back in action. Game is still looking great and runs fine in Chrome.

Can you provide a test case that shows that it works uncompiled not not compiled? So that I can see what's actually wrong? I assume that it's a kind of configuration issue, but it's hard to tell without knowing what the actual problem looks like.

How are you applying your animation? In an IVertexController or in some other way?

compile(true) compiles the object to use client side data for the GPU (i.e. it resides in the system's memory) while (false) compiles it to use server side memory (i.e. on the GPU). The former is more suitable for objects that change after compilation while the latter is faster for static objects. Have to tried to compiled it with (true) and indexing disabled?

That's because the GL renderer discards a texture's actual pixel data once it has been uploaded to the GPU. There's a 'keepPixelData()' method in Texture to prevent this.

Yes, a little bit...  It's actually a performance issue. The "old" transparency code is optimized for speed and not accuracy, which is why its results are  not on par with what the GL renderer could do. The alpha stuff has been added much later. It's more flexible but also slower.

setAlpha really means the alpha value as it's represented in the texture, i.e. shifted up by 24. Here's an example of how it works:

import java.awt.*;
import java.awt.event.*;
import com.threed.jpct.*;

public class Transparency extends Frame implements WindowListener {
    private World theWorld;
    private FrameBuffer buffer;
    private Camera cam;
    private Object3D obj;
    private boolean keepGoing, turnRight, turnLeft;
    private com.threed.jpct.util.KeyMapper keyMapper;
    private Texture boxMap;
    private int transparency = 0;

    public Transparency() {
      this.setTitle("BR's");
      theWorld = new World();
      buffer = new FrameBuffer(1440, 900, FrameBuffer.SAMPLINGMODE_NORMAL);
      obj = com.threed.jpct.util.ExtendedPrimitives.createBox(new SimpleVector(2f, 2f, 2f));//Primitives.getCube(1f);
      TextureManager.getInstance().addTexture("boxMap", (boxMap=new Texture("test.jpg", true)));
      obj.setTexture("boxMap");
      obj.setTransparency(0);
      //obj.setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
      obj.build();
      Object3D backgroundPlane = Primitives.getPlane(1, 4f);
      backgroundPlane.build();
      backgroundPlane.translate(0f, -2f, 0f);
      theWorld.addObject(backgroundPlane);
      cam = theWorld.getCamera();
      cam.moveCamera(Camera.CAMERA_MOVEOUT, 8f);
      theWorld.addObject(obj);
      theWorld.setAmbientLight(255, 255, 255);
      keyMapper = new com.threed.jpct.util.KeyMapper(this);
      this.addWindowListener(this);
      this.setSize(buffer.getWidth(), buffer.getHeight());
      this.setVisible(true);
      loop();
    }

    public void loop() {
      keepGoing = true;
      transparency=0;
      int dir = 1;
      int its= 0;
      while (keepGoing) {
          buffer.clear();
          com.threed.jpct.util.KeyState keyState = keyMapper.poll();
          if (keyState.getState() == com.threed.jpct.util.KeyState.PRESSED)
              keyPressed(keyState.getKeyCode());
          else if (keyState.getState() == com.threed.jpct.util.KeyState.RELEASED)
              keyReleased(keyState.getKeyCode());
          if (turnRight)
              obj.rotateY(-.01f);
          if (turnLeft)
              obj.rotateY(.01f);
          theWorld.renderScene(buffer);
          theWorld.draw(buffer);
          //theWorld.drawWireframe(buffer, Color.yellow);
          buffer.display(this.getGraphics());
          its++;
              if (its>10)  {
              transparency+=dir;
              if (Math.abs(transparency)>255 || transparency==0) {
                  dir*=-1;
              }
              //obj.setTransparency(transparency);
              TextureManager.getInstance().getTexture("boxMap").setAlpha(transparency<<24);
              System.out.println("Trans: "+transparency);
              its = 0;
          }
          Thread.yield();
      }
      buffer.dispose();
      this.dispose();
      System.exit(0);
    }

    private void keyPressed(int keyCode) {
      if (keyCode == KeyEvent.VK_RIGHT)
          turnRight = true;
      if (keyCode == KeyEvent.VK_LEFT)
          turnLeft = true;
    }
    private void keyReleased(int keyCode) {
      if (keyCode == KeyEvent.VK_RIGHT)
          turnRight = false;
      if (keyCode == KeyEvent.VK_LEFT)
          turnLeft = false;
    }
    public void windowClosing(WindowEvent e) {
      keepGoing = false;
    }
    public void windowClosed(WindowEvent e) {}
    public void windowOpened(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
    public void windowIconified(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}

    public static void main(String[] args) {
      new Transparency();
    }
}



Either use a texture with no alpha channel and do setTransparency()...but that might look a bit coarse. Or use a texture with alpha and use Texture.setAlpha(). But that will alter the texture, which is slower and might not be feasible if you intend to do that on objects of which some are supposed to fade out while others won't.

That's because the usage of alpha in the texture itself overrides the global transparency setting. Or in other words, if a texture uses an alpha channel, it doesn't allow for setting the global transparency using setTransparency(). IIRC, this is a limitation of the software renderer. However, transpancy using setTransparency is pretty coarse anyway. But that's not related to color depth but to the way in which it's applied.

No, it's working on full 24 bit color depth.

It should work now.

I found the issue, but I can't fix it myself. I have to contact my provider.

I see. That's a bit strange...the forum has a database user configured which works for everything else for some strange reason not for the search. I'm not sure why that it, I'll have a look and try to find something.