如何在OpenGL中创建正方形螺旋？ （JAVA）

Question

I need to create a spiral of squares (same size) which, upon completion of a 360 degree cycle, will change colour. So for instance, I'd like to make a three color spiral. the first part could be blue, after the first cycle the squares turn green and lastly they become red. Here's a visualisation of what I'm looking for:

My code so far (except of the JPanel thingy) is the following:

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;


public class SecondGLEventListener implements GLEventListener {

    /**
     * Interface to the GLU library.
     */
    private GLU glu;

    /**
     * Take care of initialization here.
     */
    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        glu = new GLU();

        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

        gl.glViewport(0, 0, 500, 300);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluOrtho2D(0.0, 500.0, 0.0, 300.0);
    }
    /**
     * Take care of drawing here.
     */
    public void display(GLAutoDrawable drawable)
    {

        GL gl = drawable.getGL();

        gl.glClear(GL.GL_COLOR_BUFFER_BIT);

        for (int i=0; i<50; i++)
        {
            gl.glColor3f(0.0f,0.0f,1.0f);
            gl.glPointSize(3);
            gl.glBegin(GL.GL_POINTS);
            //some code for the spiral thing.  
            gl.glEnd();
        }

    }
    public void reshape(GLAutoDrawable drawable, int x, int y, int width,
     int height) {}

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

}

Do you have any suggestions as to how I could implement this?

Answer 1

Put two and two together:

#include <GL/glut.h>
#include <cmath>

void glSpiral(float a, float b, float thetaStart, float thetaEnd, unsigned int samples = 200 )
{
    glBegin( GL_QUADS );

    const float sz = 1.0f;

    float dt = (thetaEnd - thetaStart) / (float)samples;

    for( unsigned int i = 0; i <= samples; ++i )
    {
        // archimedean spiral
        float theta = thetaStart + (i * dt);
        float r = a + b * theta;

        // polar to cartesian
        float x = r * cos( theta );
        float y = r * sin( theta );

        glVertex2f( x - sz, y - sz );
        glVertex2f( x + sz, y - sz );
        glVertex2f( x + sz, y + sz );
        glVertex2f( x - sz, y + sz );
    }

    glEnd();
}

size_t win_w = 0;
size_t win_h = 0;
double aspect_ratio = 0;
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-100*aspect_ratio, 100*aspect_ratio, -100, 100, -1, 1);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    const float PI = 3.14159;
    for( unsigned int i = 0; i < 6; i++ )
    {
        switch( i )
        {
        case 0: glColor3ub(255,0,0);        break; 
        case 1: glColor3ub(0,255,0);        break; 
        case 2: glColor3ub(0,0,255);        break; 
        case 3: glColor3ub(255,255,0);      break; 
        case 4: glColor3ub(0,255,255);      break; 
        case 5: glColor3ub(255,255,255);    break; 
        default: glColor3ub(128,128,128);   break;
        }

        float beg = (i+0)*2*PI;
        float end = (i+1)*2*PI;
        glSpiral( 0, 3, beg, end, 80 );
    }

    glFlush();
    glutSwapBuffers();
}

void reshape(int w, int h)
{
    win_w = w;
    win_h = h;
    aspect_ratio = (double)win_w / (double)win_h;
    glViewport(0, 0, w, h);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);

    glutInitWindowSize(800,600);
    glutCreateWindow("Spiral");

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return 0;
}

It's in C++ and GLUT but porting the core logic to Java should be easy.

Answer 2

for square spiral if needed:

import java.awt.*;
public class Spiral {
    public static void main(String[] args) {
      DrawingPanel panel = new DrawingPanel(170, 170);
      Graphics g = panel.getGraphics();
      for (int i = 0; i < 8; i++) {
        g.drawLine(      10*i,   10 + 10*i, 160 - 10*i,  10 + 10*i);  // top
        g.drawLine(160 - 10*i,   10 + 10*i, 160 - 10*i, 160 - 10*i);  // right
        g.drawLine( 10 + 10*i,  160 - 10*i, 160 - 10*i, 160 - 10*i);  // bottom
        g.drawLine( 10 + 10*i,   20 + 10*i,  10 + 10*i, 160 - 10*i);  // left
      }
   }
}