QuotesetGLFiltering(false);

This seems to fix the problem although the regions I pick from the texture need to be readjusted, they seem to have changed in size.

QuotesetGLMipmap(false);

This doesn't appear to have any effect.

What do you think was happening?

I've tried it on three different machines with different video cards: nVidia 5200, nVidia Geforce2 GTS, ATi Radeon x300. They all have this color fading problem, but not in the exact same way. What's interesting is that not all regions of the texture has this problem. It seems to only happen when small regions are selected. For example, here's my character/number texture:

The large font shows properly, but the small font does not. So this problem is more apparent with small areas of the texture.

I'm using the latest release of jPCT (v1.09)

Didn't work    I tried turning down all the the settings and still no difference

It's an nVidia GeForce2 GTS with 32MB of VRAM. Supersampling? I'll try to turn off the Antialiasing.

I'm using two textures. One with characters/numbers which is 512x128 and the other with lines 512x256. So I'm respecting the 2^X rule, what else can it be  :?

I'm using .gif files to blit this GUI. It looks different in software and hardware mode. For some reason it only renders properly in software mode. In hardware, the colors seem to fade.

Software:


Hardware:


Any idea why this may be happening?

Ok, thank-you for the feedback :mrgreen:

That first post was mine    Didn't notice that I wasn't logged in  :oops:

So "Java Perspective Correct Texturemapping" . I would've never been able to derive "Java 3D Engine" from that. Good thing you write "jPCT - a free 3D engine for JAVA" in the title of the forum and jPCT site  

Sorry if this sounds like a dumb question but I've tried searching and have not found an answer. Has no one asked this before? I'm assuming the "j" in "jPCT" is for "Java" but what's "PCT" :?:

Melssj5,

Yes, you're absolutely right. I didn't write my statement properly. I meant that there are no 'Canvas-type' components that are returned by a class in the jpct lib into which a software renderer will automatically draw a rendered frame; i.e. without calling a FrameBuffer.draw(Graphics).

Just to add to your post: any subclass of java.awt.Component can be potentially used as a rendering host for FrameBuffer.draw(Graphics)  :wink:

I think I understand now. After reviewing the javadoc for the IRenderer class I see that the "mode" only determines what type of lighting model the renderer will use. So enableGLCanvasRenderer will always be rendering in hardware and never in software. Therefore there are no 'Canvas-type' components in which software rendering can be done. It seems the only way to render via software is to use the FrameBuffer.draw(Graphics). Furthermore, there are exactly two ways to render via hardware; using enableGLCanvasRenderer, or using FrameBuffer.displayGLOnly() (with a FrameBuffer.enableRenderer(IRenderer.RENDERER_OPENGL, IRenderer.MODE_OPENGL) call).

What if I create the  Canvas like this:
Canvas myCanvas = frameBuffer.enableGLCanvasRenderer(IRenderer.RENDERER_SOFTWARE);
Won't this imply software rendering into the Canvas object?

EgonOlsen,

I'm sorry if my question was unclear, I will try to elaborate. Is there a "best" way for doing software rendering? I noticed that using a Canvas:
Canvas myCanvas = frameBuffer.enableGLCanvasRenderer(IRenderer.MODE_OPENGL);
JPanel panel = new JPanel();
panel.add(myCanvas);
.
.
.
private void display()
{
   frameBuffer.clear();
   theWorld.renderScene(frameBuffer);
   theWorld.draw(frameBuffer);
   frameBuffer.update();

   myCanvas.refresh();
}
and using the Graphics context:
JPanel panel = new JPanel();
Graphics g = panel.getGraphics();
.
.
.
private void display()
{
   frameBuffer.clear();
   theWorld.renderScene(frameBuffer);
   theWorld.draw(frameBuffer);
   frameBuffer.update();

   frameBuffer.display(g);
}
do exactly the same thing. Which is the "better" way?

I need to render into a JPanel component, so I'm using the following code:

Canvas myCanvas = frameBuffer.enableGLCanvasRenderer(IRenderer.MODE_OPENGL);
JPanel panel = new JPanel();
panel.add(myCanvas);

Now if I want to switch to a software renderer I can do the following:

frameBuffer.disableRenderer(IRenderer.RENDERER_OPENGL);
frameBuffer.enableRenderer(IRenderer.RENDERER_SOFTWARE, IRenderer.MODE_OPENGL);

My question is what's the difference, when using software rendering, to render to a Canvas or to a Graphics object such as:

Graphics g = panel.getGraphics();
frameBuffer.display(g);

Is one method better than the other in terms of performance?