Java 在JOGL应用程序中使用纹理时，ati图形卡最终都会崩溃

我有一个用Java和JOGL编写的应用程序，可以在nvidia卡上正常工作，但当我在ati卡上运行它时，它可以完美工作，直到我在一个或多个面上添加纹理为止。最终，java虚拟机严重崩溃，它要么说是ati驱动程序线程崩溃，要么说是内核系统线程崩溃。我设法用一段更简单的代码重新创建了它，但需要几分钟才能得到崩溃。上/下旋转图像，返回切换纹理。用ati卡继续这样做几分钟，它就会崩溃。我已经在大约10或15台机器上试过了

package org.yourorghere;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.texture.Texture;
import com.sun.opengl.util.texture.TextureIO;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics2D;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;

/**
 * SimpleJOGL.java <BR>
 * author: Brian Paul (converted to Java by Ron Cemer and Sven Goethel) <P>
 *
 * This version is equal to Brian Paul's version 1.2 1999/10/21
 */
public class SimpleJOGL implements GLEventListener, KeyListener {

    GLCanvas canvas;
    int lists;
    float angle = 0.f;
    boolean needsRotate = false;
    boolean needsTexture = false;
    Texture texture1;
    Texture texture2;

    Color c1 = Color.red;
    Color c2 = Color.green;

    public SimpleJOGL(GLCanvas canvas) {
        this.canvas = canvas;
    }

    public static void main(String[] args) {
        Frame frame = new Frame("Simple JOGL Application");
        GLCanvas canvas = new GLCanvas();

        SimpleJOGL sjogl = new SimpleJOGL(canvas);
        canvas.addKeyListener(sjogl);

        canvas.addGLEventListener(sjogl);
        frame.add(canvas);
        frame.setSize(640, 480);
        final Animator animator = new Animator(canvas);
        frame.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                // Run this on another thread than the AWT event queue to
                // make sure the call to Animator.stop() completes before
                // exiting
                new Thread(new Runnable() {

                    public void run() {
                        animator.stop();
                        System.exit(0);
                    }
                }).start();
            }
        });
        // Center frame
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();
    }

    public void init(GLAutoDrawable drawable) {
        // Use debug pipeline
        // drawable.setGL(new DebugGL(drawable.getGL()));

        GL gl = drawable.getGL();
        System.err.println("INIT GL IS: " + gl.getClass().getName());

        // Enable VSync
        gl.setSwapInterval(1);

        // double buffer
        gl.glEnable(GL.GL_DOUBLEBUFFER);
        drawable.setAutoSwapBufferMode(false);

        // Enable VSync
        gl.setSwapInterval(1);

        // Setup the drawing area and shading mode
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.

        gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
        gl.glEnable(GL.GL_TEXTURE_2D);
        gl.glDisable(GL.GL_BLEND);

                // -- lighting --
        gl.glEnable(GL.GL_COLOR_MATERIAL);
        gl.glLightModelf(GL.GL_LIGHT_MODEL_TWO_SIDE, 1.0f);
        gl.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE);
        gl.glEnable(GL.GL_MAP1_VERTEX_3);
        gl.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, new float[]{.3f,.3f,.3f,1.f},0);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, new float[]{.55f,.55f,.55f,1.f},0);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, new float[]{.05f,.05f,.05f,1.f}, 0);
        gl.glFrontFace(GL.GL_CCW);
        gl.glEnable(GL.GL_LIGHT0);
        gl.glEnable(GL.GL_LIGHTING);
        gl.glEnable(GL.GL_DEPTH_TEST);

        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE, new float[]{.5f,.5f,.5f,1.0f}, 0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, new float[]{.05f, .05f, .05f, 1.0f}, 0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_EMISSION, new float[]{0.01f, 0.01f, 0.01f, 1.f}, 0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, new float[]{30}, 0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_COLOR_INDEXES, new float[]{1.0f, 0.0f, 0.0f, 1.0f}, 0);

        gl.glCullFace(GL.GL_BACK);
        gl.glDisable(GL.GL_BLEND);
        gl.glEnable(GL.GL_RESCALE_NORMAL);


        lists = gl.glGenLists(3);
        this.needsRotate = true;
        this.needsTexture = true;
    }

    private void reTexture(GL gl) {
        BufferedImage image1 = makeImage(c1);
        BufferedImage image2 = makeImage(c2);
        makeShape(gl, image1, image2);
    }
    private BufferedImage makeImage(Color c) {
        int y = 1200;
        int x = 1024;
        BufferedImage image = new BufferedImage(y, y, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = image.createGraphics();
        g.setBackground(Color.white);
        g.clearRect(0, 0, y,y);
        Rectangle2D r = new Rectangle2D.Float(128,128,x-256,x-256);
        g.setColor(c);
        g.fill(r);
        g.dispose();
        return image;
    }

    private void makeShape(GL gl, BufferedImage image1, BufferedImage image2) {
        float x = 1024.f/1200.f;

        texture1 = TextureIO.newTexture(image1, false) ;
        texture2 = TextureIO.newTexture(image2, false) ;

        gl.glNewList(lists+1, GL.GL_COMPILE);

        gl.glColor3f(0f, .8f, .4f);
        // Drawing Using Triangles

        gl.glBegin(GL.GL_POLYGON);
            gl.glTexCoord2f(0, 0);
            gl.glVertex3f(0.0f, 0.0f, 0.0f);   // Top
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(x, 0);
            gl.glVertex3f(1.0f, 0.0f, 0.0f); // Bottom Left
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(x, x);
            gl.glVertex3f(1.0f, 1.0f, 0.0f);  // Bottom Right
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(0, x);
            gl.glVertex3f(0f, 1.0f, 0.0f);  // Bottom Right
            gl.glNormal3f(0, 0, 1);
        gl.glEnd();
        texture1.disable();

        gl.glEndList();

        gl.glNewList(lists+2, GL.GL_COMPILE);

        texture2.enable();
        texture2.bind();
        gl.glBegin(GL.GL_POLYGON);
            gl.glTexCoord2f(0, 0);
            gl.glVertex3f(0.0f, 0.0f, 0.0f);   // Top
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(x, 0);
            gl.glVertex3f(1.0f, 0.0f, 0.0f); // Bottom Left
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(x, x);
            gl.glVertex3f(1.0f, -1.0f, 0.0f);  // Bottom Right
            gl.glNormal3f(0, 0, 1);

            gl.glTexCoord2f(0, x);
            gl.glVertex3f(0f, -1.0f, 0.0f);  // Bottom Right
            gl.glNormal3f(0, 0, 1);
        gl.glEnd();
        texture2.disable();

        gl.glEndList();


    }

    public void rotate(GL gl) {
        gl.glNewList(lists, GL.GL_COMPILE);

        gl.glLoadIdentity();
        gl.glTranslatef(-2.f, 0.f, -6.f);
        gl.glRotatef(angle, 1.0f, 0.f, 0.f);

        gl.glCallList(lists+1);

        gl.glRotatef(-45, 1.f, 0.f, 0.f);

        gl.glCallList(lists+2);        
        gl.glEndList();
    }

    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();

        if (height <= 0) { // avoid a divide by zero error!

            height = 1;
        }
        final float h = (float) width / (float) height;
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, h, 1.0, 20.0);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }

    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();

        if (needsTexture) {
            reTexture(gl);
            needsTexture = false;
        }


        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

        gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[]{1.f, 1.f, 1.f, 0.f}, 0);


        gl.glLoadIdentity();
        gl.glTranslatef(-2.f, 0.f, -6.f);
        gl.glRotatef(angle, 1.0f, 0.f, 0.f);

                texture1.enable();
        texture1.bind();
        gl.glCallList(lists+1);
        texture1.disable();

        gl.glRotatef(-45, 1.f, 0.f, 0.f);

        gl.glCallList(lists+2);      


        // Flush all drawing operations to the graphics card
        drawable.swapBuffers();
    }

    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {
    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            angle -= 5;
            needsRotate = true;

        } 
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            angle += 5;
            needsRotate = true;
        }
        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
            Color c = c1;
            c1 = c2;
            c2 = c;
            needsTexture = true;
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public void keyTyped(KeyEvent e) {
        canvas.repaint();
    }
}

package org.yourorghere；
导入com.sun.opengl.util.Animator；
导入com.sun.opengl.util.texture.texture；
导入com.sun.opengl.util.texture.TextureIO；
导入java.awt.Color；
导入java.awt.Frame；
导入java.awt.Graphics2D；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
导入java.awt.event.WindowAdapter；
导入java.awt.event.WindowEvent；
导入java.awt.geom.Rectangle2D；
导入java.awt.image.buffereImage；
导入javax.media.opengl.GL；
导入javax.media.opengl.GLAutoDrawable；
导入javax.media.opengl.GLCanvas；
导入javax.media.opengl.GLEventListener；
导入javax.media.opengl.glu.glu；
/**
*SimpleJOGL.java

*作者：Brian Paul（由Ron Cemer和Sven Goetel转换成Java）

*
*此版本与Brian Paul的1.2 1999/10/21版本相同
*/
公共类SimpleLog实现了GLEventListener、KeyListener{
帆布；
int列表；
浮动角度=0.f；
布尔值needsRotate=false；
布尔值needsTexture=false；
纹理1；
纹理2；
颜色c1=颜色。红色；
颜色c2=颜色。绿色；
公共SimpleJOGL（GLCanvas画布）{
this.canvas=画布；
}
公共静态void main（字符串[]args）{
框架=新框架（“简单JOGL应用”）；
GLCanvas canvas=新的GLCanvas（）；
SimpleJOGL sjogl=新的SimpleJOGL（画布）；
canvas.addKeyListener（sjogl）；
canvas.addGLEventListener（sjogl）；
frame.add（画布）；
帧设置大小（640480）；
最终动画师动画师=新动画师（画布）；
frame.addWindowListener（新的WindowAdapter（）{
@凌驾
公共无效窗口关闭（WindowEvent e）{
//在AWT事件队列之外的另一个线程上运行此命令，以
//确保对Animator.stop（）的调用在
//退出
新线程（newrunnable（））{
公开募捐{
停止（）；
系统出口（0）；
}
}).start（）；
}
});
//中心框架
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
animator.start（）；
}
公共void init（GLAutoDrawable）{
//使用调试管道
//setGL（新的DebugGL（drawable.getGL（））；
GL=drawable.getGL（）；
System.err.println（“INIT GL IS:+GL.getClass（）.getName（））；
//启用VSync
总帐setSwapInterval（1）；
//双缓冲器
glEnable总帐（gl.Glu DOUBLEBUFFER总帐）；
drawable.setAutoSwapBufferMode（假）；
//启用VSync
总帐setSwapInterval（1）；
//设置绘图区域和着色模式
gl.glClearColor（0.0f，0.0f，0.0f，0.0f）；
gl.glShadeModel（gl.gl_SMOOTH）；//尝试将其设置为gl_FLAT，看看会发生什么。
gl.glTexEnvi（gl.gl_纹理_环境，gl.gl_纹理_环境模式，gl.gl_替换）；
gl.glEnable（gl.gl\U纹理\U 2D）；
gl.glDisable（gl.gl\u混合）；
//--照明--
glEnable总包（gl.Glu颜色材料）；
gl.glLightModelf（gl.gl\u LIGHT\u MODEL\u双面，1.0f）；
gl.glColorMaterial（gl.gl\u前和后，gl.gl\u环境和漫反射）；
glEnable总图（总图Glu地图1顶点3）；
gl.glHint（gl.gl\u多边形\u平滑\u提示，gl.gl\u最佳）；
gl.glLightfv（gl.gl_LIGHT0，gl.gl_环境光，新浮点[]{.3f，.3f，.3f，1.f}，0）；
gl.glLightfv（gl.gl_LIGHT0，gl.gl_DIFFUSE，newfloat[]{.55f，.55f，.55f，1.f}，0）；
gl.glLightfv（gl.gl_LIGHT0，gl.gl_镜面反射，新浮点[]{.05f，.05f，.05f，1.f}，0）；
gl.gl正面（gl.gl_CCW）；
glEnable总帐（gl.Glu LIGHT0）；
glEnable总图（glEnable总图照明）；
gl.glEnable（gl.gl\U深度测试）；
gl.glmaterialsv（gl.gl_前_和后，gl.gl_环境_和漫反射，新浮点[]{.5f、.5f、.5f、1.0f}，0）；
gl.glmaterialsv（gl.gl_前_和后，gl.gl_镜面反射，新浮点[]{.05f、.05f、.05f、1.0f}，0）；
gl.glMaterialfv（gl.gl_前_和后_，gl.gl_发射，新浮动[]{0.01f，0.01f，0.01f，1.f}，0）；
gl.glmaterialsv（gl.gl_前_和_后，gl.gl_反光，新浮动[]{30}，0）；
gl.glmaterialsv（gl.gl_FRONT_和_BACK，gl.gl_COLOR_索引，新浮点[]{1.0f，0.0f，0.0f，1.0f}，0）；
gl.glCullFace（gl.GLU背面）；
gl.glDisable（gl.gl\u混合）；
glEnable总包（总包重缩放正常）；
列表=总账。总账列表（3）；
this.needsRotate=true；
this.needsTexture=true；
}
私人空间重新构造（GL）{
BuffereImage image1=makeImage（c1）；
BuffereImage image2=makeImage（c2）；
makeShape（gl、图像1、图像2）；
}
专用缓冲区映像生成映像（c色）{
int y=1200；
int x=1024；
BuffereImage=新的BuffereImage（y，y，BuffereImage.TYPE_INT_RGB）；
Graphics2D g=image.createGraphics（）；
g、 挫折地面（颜色：白色）；
g、 clearRect（0，0，y，y）；
矩形2D器=新矩形2D.Float（128128，x-256，x-256）；
g、 setColor（c）；
g、 填充（r）；
g、 处置（）；
返回图像；
}
专用void生成形状（总账、BuffereImage image1、BuffereImage image2）{
浮动x=1024.f/1200.f；
texture1=TextureIO.newTexture（图1，假）；
texture2=TextureIO.newTexture
private void makeShape(GL gl, BufferedImage image1, BufferedImage image2) {
    if (texture1 != null) {
        texture1.dispose();
    }
    texture1 = TextureIO.newTexture(image1, false) ;
    if (texture2 != null) {
        texture2.dispose();
    }
    texture2 = TextureIO.newTexture(image2, false) ;
    // ...
}