How to rotate a 2d square using maths equations through OpenGL

[Michelle Ruth]

So I need to create a square and make it rotate when the letter R is pressed and then make it stop when the letter R is pressed again. I need make it rotate using a maths equation that I can't figure it out myself right this moment and would greatly appreciate any help.

Code for square:

package lab2;
 
 
public class Square {
 
    public double [][] vertices = new double[4][2]; //not good to make this public but heh!
 
 
    public Square(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
    {
        vertices[0][0]=x1;
        vertices[0][1]=y1;
        vertices[1][0]=x2;
        vertices[1][1]=y2;
        vertices[2][0]=x3;
        vertices[2][1]=y3;
        vertices[3][0]=x4;
        vertices[3][1]=y4;
    }
 
    public double area()
    {
        return (vertices[1][0]-vertices[0][0])*(vertices[1][0]-vertices[0][0])+(vertices[1][1]-vertices[0][1])*(vertices[1][1]-vertices[0][1]);
    }
 
    public void translate(double tx, double ty)
    {
        for(int i=0;i<vertices.length;i++)
        {
            vertices[i][0]+=tx;
            vertices[i][1]+=ty;
        }
    }
    public void rotate(double theta)
    {
        for(int i =0; i<vertices.length;i++)
        {
            vertices[i][0] += theta;
            vertices[i][1] += theta;
            vertices[i][1] += theta;
            vertices[i][0] += theta;
        }
 
    }
 
    public void scale(double sx, double sy)
    {
 
 
    }
 
}

Code to control the square with Key Events

package lab2;
 
import java.awt.Frame;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
import javax.media.opengl.*;
import javax.media.opengl.awt.GLCanvas;
 
import com.sun.opengl.util.Animator;
import com.sun.opengl.util.FPSAnimator;
 
public class Square_Control implements GLEventListener, KeyListener {
     
    Square square = new Square(100,100,200,100,200,200,100,200);
    boolean rotating = false;
    boolean scaling = false;
    boolean enlarge = true;
    double theta = 0.03;
    double sx = 1.01, sy = 1.01;
    GLProfile glp;
    GLCapabilities caps;
    GLCanvas canvas;
     
    public Square_Control()
    {
        glp = GLProfile.getDefault();
            caps = new GLCapabilities(glp);
            canvas = new GLCanvas(caps);
         
            Frame frame = new Frame("AWT Window Test");
            frame.setSize(300, 300);
            frame.add(canvas);
            frame.setVisible(true);
 
            frame.addWindowListener(new WindowAdapter() {
                    public void windowClosing(WindowEvent e) {
                    System.exit(0);
                    }
            });
 
            canvas.addGLEventListener(this);
            canvas.addKeyListener(this);
            canvas.requestFocus();
            Animator animator = new FPSAnimator(canvas,60);
            animator.add(canvas);
            animator.start();
         
    }
     
    public static void main(String[] args) {
         
        Square_Control sqc = new Square_Control();
         
    }
     
    public void update()
    {
        if (rotating)
            square.rotate(theta);
        if (scaling)
        {
            //scale square, but make sure it goes bigger then smaller, then bigger, smaller etc 
         
        }
    }
 
    @Override
    public void display(GLAutoDrawable drawable) {
        update();
        GL2 gl = drawable.getGL().getGL2();
        gl.glClear(GL.GL_COLOR_BUFFER_BIT);
        gl.glColor3f(1, 0, 0);
        gl.glBegin(GL.GL_LINE_LOOP);
                gl.glVertex2d(square.vertices[0][0], square.vertices[0][1]);
                gl.glVertex2d(square.vertices[1][0], square.vertices[1][1]);
                gl.glVertex2d(square.vertices[2][0], square.vertices[2][1]);
                gl.glVertex2d(square.vertices[3][0], square.vertices[3][1]);
            gl.glEnd();
         
         
         
    }
 
    @Override
    public void dispose(GLAutoDrawable drawable) {
        // TODO Auto-generated method stub
         
    }
 
    @Override
    public void init(GLAutoDrawable drawable) {
        // TODO Auto-generated method stub
        GL2 gl = drawable.getGL().getGL2();
            gl.glMatrixMode(gl.GL_PROJECTION);
            gl.glLoadIdentity();
            gl.glOrtho(0, 300, 0, 300, -1, 1);
            gl.glViewport(0, 0, 300, 300);
         
    }
 
    @Override
    public void reshape(GLAutoDrawable drawable, int x, int y, int width,
            int height) {
        // TODO Auto-generated method stub
         
    }
 
    @Override
    public void keyPressed(KeyEvent arg0) {
         
        if (arg0.getKeyCode() == KeyEvent.VK_RIGHT)
            square.translate(4, 0);
        else if (arg0.getKeyCode() == KeyEvent.VK_LEFT)
            square.translate(-4, 0);
        else if (arg0.getKeyCode() == KeyEvent.VK_UP)
            square.translate(0, 4);
        else if (arg0.getKeyCode() == KeyEvent.VK_DOWN)
            square.translate(0, -4);
 
        //also add code to toggle rotation/scaling
        else if(arg0.getKeyCode() == KeyEvent.VK_R)
            square.rotate(theta);
        if(arg0.getKeyCode() == KeyEvent.VK_S)
            square.scale(sx, sy);
    }
 
    @Override
    public void keyReleased(KeyEvent arg0) {
        // TODO Auto-generated method stub
         
    }
 
    @Override
    public void keyTyped(KeyEvent arg0) {
        // TODO Auto-generated method stub
         
    }   
}

In the Square code there is a method to write an equation to rotate it but I can't figure that part out and would appreciate if anyone can shed some light on this and help me out. Thanks in advance.

[Piet Souris]

hi Michelle,

you can rotate your square, no problem, but apart from the rotation angle, you will also need a center of rotation.
Since your square can have any four points as its vertices, I don't think you can assume this center to be always (0,0).
Let us know if you need any help with getting that matrix set up.

Another way to make your square rotate in opengl is to simply let opengl do all the work. You would then specify
a rotation matrix and use that in your opengl 'display' method, or even easier, use the glRotated(angle, x, y, z)
or the glRotatef(angle, x,y,z) functions.

Greetz,
Piet