Attachment 41 Details for Bug 137 – Test case

Test case

Gears.java (text/plain), 16.87 KB, created by Sven Gothel on 2005-02-09 12:09:00 CET

(hide)

Description:

Filename:

MIME Type:

Creator: Sven Gothel

Created: 2005-02-09 12:09:00 CET

Size: 16.87 KB

patch

obsolete

>import java.awt.*;
>import java.awt.event.*;
>import java.util.*;
>import javax.swing.*;
>import net.java.games.jogl.*;
>/**
> *  Gears.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 This version is
> *  modified from Gears.java from JOGL demo to compare the resource management
> *  issues with ATI's driver. Scott Hong
> */
>
>public class Gears {
>    JFrame mainFrame;
>    JTabbedPane tabbedPane;
>    int index = 0;
>    int delay = 1000;
>    javax.swing.Timer timer;
>    Hashtable animatorTable = new Hashtable();
>
>    /**
>     *  The main program for the Gears class
>     *
>     * @param  args  The command line arguments
>     */
>    public static void main(String[] args) {
>        Gears test = new Gears();
>        test.addCanvas();
>    }
>
>    /**
>     *  Creates a new instance of TestCanvasPanel
>     */
>    public Gears() {
>        tabbedPane = new JTabbedPane();
>        mainFrame = new JFrame();
>        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
>        mainFrame.getContentPane().add(tabbedPane);
>        mainFrame.pack();
>        mainFrame.setSize(300, 300);
>        mainFrame.show();
>
>        timer = new javax.swing.Timer(delay, new TaskPerformer());
>        timer.setRepeats(true);
>        timer.start();
>    }
>
>
>    /**
>     *  Adds a feature to the Canvas attribute of the TestCanvasPanel object
>     */
>    public void addCanvas() {
>        GLCanvas canvas = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
>        String title = "C-" + index;
>        canvas.addGLEventListener(new GearRenderer());
>        Animator animator = new Animator(canvas);
>        animatorTable.put(title, animator);
>        synchronized (tabbedPane) {
>            tabbedPane.add(title, canvas);
>            animator.start();
>            index++;
>        }
>    }
>
>    /**
>     *  Description of the Method
>     */
>    public void removeCanvas() {
>        synchronized (tabbedPane) {
>            if (tabbedPane.getComponentCount() > 0) {
>                String key = tabbedPane.getTitleAt(0);
>                Animator animator = (Animator) animatorTable.remove(key);
>                if (animator != null) {
>                    System.out.println("Stoping : " + key);
>                    animator.stop();
>                }
>                tabbedPane.remove(0);
>                animator = null;
>            }
>        }
>        System.gc();
>    }
>
>    /**
>     *  The timer task performer
>     */
>    class TaskPerformer implements ActionListener {
>        /**
>         *  Description of the Method
>         *
>         * @param  evt  Description of the Parameter
>         */
>        public void actionPerformed(ActionEvent evt) {
>            SwingUtilities.invokeLater(
>                new Runnable() {
>                    public void run() {
>                        if (tabbedPane.getComponentCount() > 0) {
>                            removeCanvas();
>                        }
>                        addCanvas();
>                    }
>                }
>                );
>        }
>    }
>
>    /**
>     *  Description of the Class
>     */
>    static class GearRenderer implements GLEventListener, MouseListener, MouseMotionListener {
>        private float view_rotx = 20.0f, view_roty = 30.0f, view_rotz = 0.0f;
>        private int gear1, gear2, gear3;
>        private float angle = 0.0f;
>
>        private int prevMouseX, prevMouseY;
>        private boolean mouseRButtonDown = false;
>
>        private GL gl;
>        private GLDrawable gldrawable;
>
>        /**
>         *  Description of the Method
>         *
>         * @param  drawable  Description of the Parameter
>         */
>        public void init(GLDrawable drawable) {
>            gl = drawable.getGL();
>            this.gldrawable = drawable;
>            //System.err.println("INIT GL IS: " + gl.getClass().getName());
>
>            float pos[] = {5.0f, 5.0f, 10.0f, 0.0f};
>            float red[] = {0.8f, 0.1f, 0.0f, 1.0f};
>            float green[] = {0.0f, 0.8f, 0.2f, 1.0f};
>            float blue[] = {0.2f, 0.2f, 1.0f, 1.0f};
>
>            gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
>            gl.glEnable(GL.GL_CULL_FACE);
>            gl.glEnable(GL.GL_LIGHTING);
>            gl.glEnable(GL.GL_LIGHT0);
>            gl.glEnable(GL.GL_DEPTH_TEST);
>
>            /*
>                make the gears
>              */
>            gear1 = gl.glGenLists(1);
>            gl.glNewList(gear1, GL.GL_COMPILE);
>            gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, red);
>            gear(1.0f, 4.0f, 1.0f, 20, 0.7f);
>            gl.glEndList();
>
>            gear2 = gl.glGenLists(1);
>            gl.glNewList(gear2, GL.GL_COMPILE);
>            gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, green);
>            gear(0.5f, 2.0f, 2.0f, 10, 0.7f);
>            gl.glEndList();
>
>            gear3 = gl.glGenLists(1);
>            gl.glNewList(gear3, GL.GL_COMPILE);
>            gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, blue);
>            gear(1.3f, 2.0f, 0.5f, 10, 0.7f);
>            gl.glEndList();
>
>            gl.glEnable(GL.GL_NORMALIZE);
>
>            drawable.addMouseListener(this);
>            drawable.addMouseMotionListener(this);
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  drawable  Description of the Parameter
>         * @param  x         Description of the Parameter
>         * @param  y         Description of the Parameter
>         * @param  width     Description of the Parameter
>         * @param  height    Description of the Parameter
>         */
>        public void reshape(GLDrawable drawable, int x, int y, int width, int height) {
>            float h = (float) height / (float) width;
>
>            gl.glMatrixMode(GL.GL_PROJECTION);
>            /*
>                System.err.println("GL_VENDOR: " + gl.glGetString(GL.GL_VENDOR));
>                System.err.println("GL_RENDERER: " + gl.glGetString(GL.GL_RENDERER));
>                System.err.println("GL_VERSION: " + gl.glGetString(GL.GL_VERSION));
>                System.err.println();
>                System.err.println("glLoadTransposeMatrixfARB() supported: " +
>                gl.isFunctionAvailable("glLoadTransposeMatrixfARB"));
>              */
>            if (!gl.isFunctionAvailable("glLoadTransposeMatrixfARB")) {
>                // --- not using extensions
>                gl.glLoadIdentity();
>            }
>            else {
>                // --- using extensions
>                final float[] identityTranspose = new float[]{
>                    1, 0, 0, 0,
>                    0, 1, 0, 0,
>                    0, 0, 1, 0,
>                    0, 0, 0, 1
>                    };
>                gl.glLoadTransposeMatrixfARB(identityTranspose);
>            }
>            gl.glFrustum(-1.0f, 1.0f, -h, h, 5.0f, 60.0f);
>            gl.glMatrixMode(GL.GL_MODELVIEW);
>            gl.glLoadIdentity();
>            gl.glTranslatef(0.0f, 0.0f, -40.0f);
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  drawable  Description of the Parameter
>         */
>        public void display(GLDrawable drawable) {
>            angle += 2.0f;
>
>            gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
>
>            gl.glPushMatrix();
>            gl.glRotatef(view_rotx, 1.0f, 0.0f, 0.0f);
>            gl.glRotatef(view_roty, 0.0f, 1.0f, 0.0f);
>            gl.glRotatef(view_rotz, 0.0f, 0.0f, 1.0f);
>
>            gl.glPushMatrix();
>            gl.glTranslatef(-3.0f, -2.0f, 0.0f);
>            gl.glRotatef(angle, 0.0f, 0.0f, 1.0f);
>            gl.glCallList(gear1);
>            gl.glPopMatrix();
>
>            gl.glPushMatrix();
>            gl.glTranslatef(3.1f, -2.0f, 0.0f);
>            gl.glRotatef(-2.0f * angle - 9.0f, 0.0f, 0.0f, 1.0f);
>            gl.glCallList(gear2);
>            gl.glPopMatrix();
>
>            gl.glPushMatrix();
>            gl.glTranslatef(-3.1f, 4.2f, 0.0f);
>            gl.glRotatef(-2.0f * angle - 25.0f, 0.0f, 0.0f, 1.0f);
>            gl.glCallList(gear3);
>            gl.glPopMatrix();
>
>            gl.glPopMatrix();
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  drawable       Description of the Parameter
>         * @param  modeChanged    Description of the Parameter
>         * @param  deviceChanged  Description of the Parameter
>         */
>        public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) { }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  inner_radius  Description of the Parameter
>         * @param  outer_radius  Description of the Parameter
>         * @param  width         Description of the Parameter
>         * @param  teeth         Description of the Parameter
>         * @param  tooth_depth   Description of the Parameter
>         */
>        private void gear(float inner_radius,
>            float outer_radius,
>            float width,
>            int teeth,
>            float tooth_depth) {
>            int i;
>            float r0;
>            float r1;
>            float r2;
>            float angle;
>            float da;
>            float u;
>            float v;
>            float len;
>
>            r0 = inner_radius;
>            r1 = outer_radius - tooth_depth / 2.0f;
>            r2 = outer_radius + tooth_depth / 2.0f;
>
>            da = 2.0f * (float) Math.PI / teeth / 4.0f;
>
>            gl.glShadeModel(GL.GL_FLAT);
>
>            gl.glNormal3f(0.0f, 0.0f, 1.0f);
>
>            /*
>                draw front face
>              */
>            gl.glBegin(GL.GL_QUAD_STRIP);
>            for (i = 0; i <= teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
>                if (i < teeth) {
>                    gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
>                    gl.glVertex3f(r1 * (float) Math.cos(angle + 3.0f * da), r1 * (float) Math.sin(angle + 3.0f * da), width * 0.5f);
>                }
>            }
>            gl.glEnd();
>
>            /*
>                draw front sides of teeth
>              */
>            gl.glBegin(GL.GL_QUADS);
>            for (i = 0; i < teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + 2.0f * da), r2 * (float) Math.sin(angle + 2.0f * da), width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle + 3.0f * da), r1 * (float) Math.sin(angle + 3.0f * da), width * 0.5f);
>            }
>            gl.glEnd();
>
>            /*
>                draw back face
>              */
>            gl.glBegin(GL.GL_QUAD_STRIP);
>            for (i = 0; i <= teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
>                gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
>                gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
>            }
>            gl.glEnd();
>
>            /*
>                draw back sides of teeth
>              */
>            gl.glBegin(GL.GL_QUADS);
>            for (i = 0; i < teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), -width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), -width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
>            }
>            gl.glEnd();
>
>            /*
>                draw outward faces of teeth
>              */
>            gl.glBegin(GL.GL_QUAD_STRIP);
>            for (i = 0; i < teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
>                u = r2 * (float) Math.cos(angle + da) - r1 * (float) Math.cos(angle);
>                v = r2 * (float) Math.sin(angle + da) - r1 * (float) Math.sin(angle);
>                len = (float) Math.sqrt(u * u + v * v);
>                u /= len;
>                v /= len;
>                gl.glNormal3f(v, -u, 0.0f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), -width * 0.5f);
>                gl.glNormal3f((float) Math.cos(angle), (float) Math.sin(angle), 0.0f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), width * 0.5f);
>                gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), -width * 0.5f);
>                u = r1 * (float) Math.cos(angle + 3 * da) - r2 * (float) Math.cos(angle + 2 * da);
>                v = r1 * (float) Math.sin(angle + 3 * da) - r2 * (float) Math.sin(angle + 2 * da);
>                gl.glNormal3f(v, -u, 0.0f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), width * 0.5f);
>                gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
>                gl.glNormal3f((float) Math.cos(angle), (float) Math.sin(angle), 0.0f);
>            }
>            gl.glVertex3f(r1 * (float) Math.cos(0), r1 * (float) Math.sin(0), width * 0.5f);
>            gl.glVertex3f(r1 * (float) Math.cos(0), r1 * (float) Math.sin(0), -width * 0.5f);
>            gl.glEnd();
>
>            gl.glShadeModel(GL.GL_SMOOTH);
>
>            /*
>                draw inside radius cylinder
>              */
>            gl.glBegin(GL.GL_QUAD_STRIP);
>            for (i = 0; i <= teeth; i++) {
>                angle = i * 2.0f * (float) Math.PI / teeth;
>                gl.glNormal3f(-(float) Math.cos(angle), -(float) Math.sin(angle), 0.0f);
>                gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
>                gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
>            }
>            gl.glEnd();
>        }
>
>        // Methods required for the implementation of MouseListener
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseEntered(MouseEvent e) { }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseExited(MouseEvent e) { }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mousePressed(MouseEvent e) {
>            prevMouseX = e.getX();
>            prevMouseY = e.getY();
>            if ((e.getModifiers() & e.BUTTON3_MASK) != 0) {
>                mouseRButtonDown = true;
>            }
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseReleased(MouseEvent e) {
>            if ((e.getModifiers() & e.BUTTON3_MASK) != 0) {
>                mouseRButtonDown = false;
>            }
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseClicked(MouseEvent e) { }
>
>        // Methods required for the implementation of MouseMotionListener
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseDragged(MouseEvent e) {
>            int x = e.getX();
>            int y = e.getY();
>            Dimension size = e.getComponent().getSize();
>
>            float thetaY = 360.0f * ((float) (x - prevMouseX) / (float) size.width);
>            float thetaX = 360.0f * ((float) (prevMouseY - y) / (float) size.height);
>
>            prevMouseX = x;
>            prevMouseY = y;
>
>            view_rotx += thetaX;
>            view_roty += thetaY;
>        }
>
>        /**
>         *  Description of the Method
>         *
>         * @param  e  Description of the Parameter
>         */
>        public void mouseMoved(MouseEvent e) { }
>    }
>}
>

Actions: View

Attachments on bug 137: 41