Horse

What

The task is to draw a very simple "horse" built from cylinders. That means that we will (over)simplify the horse so we can do everything with a glut-object.

We will make the horse walk and nod its head.

We plan the horse like this. Note that all parts are cylinders and thus have a radius and a length.

public static final float BASE=1.0f;
public static final float BODY_LENGTH=BASE*1.0f;
public static final float BODY_RADIUS=BASE*0.3f;
public static final float LEG_UPPER_LENGTH=BASE*0.65f;
public static final float LEG_LOWER_LENGTH=BASE*0.4f;
public static final float LEG_RADIUS=BASE*0.06f;
public static final float NECK_LENGTH=BASE*0.65f;
public static final float NECK_RADIUS=0.06f;
public static final float HEAD_LENGTH=BASE*0.4f;
public static final float HEAD_RADIUS=BASE*0.15f;
private static final int SLICES=10;
private static final int STACKS=10;

and the angels

// the horse know how to walk ?
private static final int[] HIP_V =
{  0,
  5, 10, 15, 20 ,25, 20, 15 ,10,5,
   0,
 -5,-10,-15,-20,-25,-20,-15,-10,-5 };
private static final int[] KNEE_V =
{0,
 0,0,0,10,20,10,0,0,0,
 0,
 0,0,0,0,10,20,10,0,0,0};
// dynamic angle for moves of head
public float m_neck_angle=0.0f;
public float m_head_angle=90.0f;
// when we walk:
private int movePos=0;
private int[]front_left_leg={0,0};
private int[]front_right_leg={0,0};
private int[]back_left_leg={0,0};
private int[]back_right_leg={0,0};

The complete class for the horse, oneHorse:

package animal;
import javax.media.opengl.GL;
import javax.media.opengl.glu.GLU;
import javax.media.opengl.glu.GLUquadric;
/**
 * @author bs
 */
public class oneHorse
{
    // static dimensions
    public static final float BASE=1.0f;
    public static final float BODY_LENGTH=BASE*1.0f;
    public static final float BODY_RADIUS=BASE*0.3f;
    public static final float LEG_UPPER_LENGTH=BASE*0.65f;
    public static final float LEG_LOWER_LENGTH=BASE*0.4f;
    public static final float LEG_RADIUS=BASE*0.06f;
    public static final float NECK_LENGTH=BASE*0.65f;
    public static final float NECK_RADIUS=0.06f;
    public static final float HEAD_LENGTH=BASE*0.4f;
    public static final float HEAD_RADIUS=BASE*0.15f;
    private static final int SLICES=10;
    private static final int STACKS=10;
    // eof static dimensions
    // angles
    // the horse know how to walk ?
    private static final int[] HIP_V =
    {  0,
      5, 10, 15, 20 ,25, 20, 15 ,10,5,
       0,
     -5,-10,-15,-20,-25,-20,-15,-10,-5 };
    private static final int[] KNEE_V =
    {0,
     0,0,0,10,20,10,0,0,0,
     0,
     0,0,0,0,10,20,10,0,0,0};
    // dynamic angle for moves of head
    public float m_neck_angle=0.0f;
    public float m_head_angle=90.0f;
    // when we walk:
    private int movePos=0;
    private int[]front_left_leg={0,0};
    private int[]front_right_leg={0,0};
    private int[]back_left_leg={0,0};
    private int[]back_right_leg={0,0};
    // eof angles

    public oneHorse()
    {
        resetAngles();
    }
    public void drawMe(GL gl)
    {
        // assume origo in bodys center.
        // x:forward, y:twds horses left, z:up
        GLU glu=new GLU();
        GLUquadric q=glu.gluNewQuadric();
        glu.gluQuadricDrawStyle(q, GLU.GLU_FILL);
        //glu.gluQuadricDrawStyle(q, GLU.GLU_SILHOUETTE);
        glu.gluQuadricOrientation(q, GLU.GLU_OUTSIDE);
        glu.gluQuadricNormals(q, GLU.GLU_SMOOTH);
        // set the material
        setMaterial(gl);
        // draw body
        gl.glPushMatrix();
        gl.glTranslatef(-BODY_LENGTH/2.0f, 0.0f, 0.0f);
        gl.glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
        drawClosedCylinder(gl,glu,q,BODY_RADIUS,
                BODY_RADIUS, BODY_LENGTH);
        gl.glPopMatrix();
        // draw head
        gl.glPushMatrix();
        gl.glTranslatef(BODY_LENGTH*0.45f, 0.0f, BODY_RADIUS*0.1f);
        gl.glRotatef(m_neck_angle, 0.0f, 1.0f, 0.0f);
        drawClosedCylinder(gl,glu,q,NECK_RADIUS,
                NECK_RADIUS, NECK_LENGTH);
        gl.glTranslatef(0.0f, 0.0f, NECK_LENGTH);
        gl.glRotatef(m_head_angle, 0.0f, 1.0f, 0.0f);
        gl.glTranslatef(0.0f, 0.0f, -HEAD_LENGTH*0.3f);
        drawClosedCylinder(gl,glu,q,HEAD_RADIUS,
                HEAD_RADIUS, HEAD_LENGTH);
        gl.glPopMatrix();
        // draw left-front leg
        gl.glPushMatrix();
        gl.glTranslatef(BODY_LENGTH*0.3f,
                BODY_RADIUS*0.55f, -BODY_RADIUS*0.25f);
        drawAleg(gl,glu,q,front_left_leg);
        gl.glPopMatrix();
        // draw right-front leg
        gl.glPushMatrix();
        gl.glTranslatef(BODY_LENGTH*0.3f,
                -BODY_RADIUS*0.55f, -BODY_RADIUS*0.25f);
        drawAleg(gl,glu,q,front_right_leg);
        gl.glPopMatrix();
        // draw left-back leg
        gl.glPushMatrix();
        gl.glTranslatef(-BODY_LENGTH*0.3f,
                BODY_RADIUS*0.20f, -BODY_RADIUS*0.25f);
        drawAleg(gl,glu,q,back_left_leg);
        gl.glPopMatrix();
        // draw right-back leg
        gl.glPushMatrix();
        gl.glTranslatef(-BODY_LENGTH*0.3f,
                -BODY_RADIUS*0.20f, -BODY_RADIUS*0.25f);
        drawAleg(gl,glu,q,back_right_leg);
        gl.glPopMatrix();
        // delete the quadric
        glu.gluDeleteQuadric(q);
    }
    private void drawAleg(GL gl,GLU glu,GLUquadric q,int[] v)
    {
        gl.glRotatef(180.0f+v[0], 0.0f, 1.0f, 0.0f);
        drawClosedCylinder(gl,glu,q,LEG_RADIUS,
                LEG_RADIUS, LEG_UPPER_LENGTH);
        gl.glTranslatef(0.0f, 0.0f, LEG_UPPER_LENGTH);
        gl.glRotatef(v[1], 0.0f, 1.0f, 0.0f);
        drawClosedCylinder(gl,glu,q,LEG_RADIUS,
                LEG_RADIUS, LEG_LOWER_LENGTH);
    }
    private void drawClosedCylinder(GL gl,GLU glu,GLUquadric q,
            float r1,float r2,float l)
    {
        gl.glPushMatrix();
        glu.gluDisk(q, 0.0f, r1, SLICES, STACKS);
        glu.gluCylinder(q, r1, r2, l, SLICES, STACKS);
        gl.glTranslatef(0.0f,0.0f,l);
        glu.gluDisk(q, 0.0f, r2, SLICES, STACKS);
        gl.glPopMatrix();
    }
    public void setMaterial(GL gl)
    {
        //whitish
        float amb[]={1.0f,0.86f,0.61f,1.0f};
        float diff[]={1.0f,0.76f,0.94f,1.0f};
        float spec[]={0.16f,0.28f,0.42f,1.0f};
        float shine=128f;
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK,GL.GL_AMBIENT,amb,0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK,GL.GL_DIFFUSE,diff,0);
        gl.glMaterialfv(GL.GL_FRONT_AND_BACK,GL.GL_SPECULAR,spec,0);
        gl.glMaterialf(GL.GL_FRONT_AND_BACK,GL.GL_SHININESS,shine);
    }
    public void updateAngles()
    {
        movePos=(movePos+1)%HIP_V.length;
        int movePos1=movePos;
        int movePos2=(movePos+HIP_V.length/2)%HIP_V.length;
        front_left_leg[0]=HIP_V[movePos1];
        front_left_leg[1]=KNEE_V[movePos1];
        front_right_leg[0]=HIP_V[movePos2];
        front_right_leg[1]=KNEE_V[movePos2];
        back_left_leg[0]=HIP_V[movePos2];
        back_left_leg[1]=KNEE_V[movePos2];
        back_right_leg[0]=HIP_V[movePos1];
        back_right_leg[1]=KNEE_V[movePos1];
    }
    public void resetAngles()
    {
        movePos=0;
        updateAngles();
    }
}

Animation

We want the horse to start walking when we click a walk-button in the interface, and we want it to continue walking until we click again. We do this by letting the main class, Horse, implement Runnable and we generate a new Thread.

private void jToggleButtonWalkActionPerformed(ActionEvent evt) { 
    if(jToggleButtonWalk.isSelected())
    {
        glr.doWalk(true);
        isRunning=true;
        new Thread(new Horse()).start();
    }
    else
    {
         glr.doWalk(false);
         isRunning=false;
    }
}

The run.method is implemented like this:

public void run()
{
   while(isRunning)
   {
        try {
            thePanel.display();
            Thread.sleep(200);
        }
        catch (InterruptedException ex)
        {
            System.out.println(ex.getMessage());
        }
   }
}

For this to work we must make the involved elements static, so they are known across threads:

GLRenderer glr;
// keep these across threads
static boolean isRunning=false;
static GLJPanel thePanel=null;
public Horse() {
    initComponents();
    setTitle("Simple JOGL Application");
    glr=new GLRenderer();
    panel.addGLEventListener(glr);
    if(thePanel==null)
        thePanel=panel;
}

Note that the animator that is introduced in the "standard"-application generated by Netbeans is not of much help here.

Another animal

The Main Class, Horse, does not know what animal we are working with. This is completely administrated by GLRenderer. GLRenderer sets up the horse, rotates it, give it its material and conveys all necessary angles. The complete GLRenderer is like this:

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

/**
 * author: bs
 */
public class GLRenderer implements GLEventListener
{
    // the horse
    oneHorse theHorse=null;
    // mousing
    float m_rotZ=0.0f;
    float m_rotY=0.0f;
    boolean m_isWalking=false;
    GLAutoDrawable this_drawable=null;
    public void init(GLAutoDrawable drawable) {
        this_drawable=drawable;
        GL gl = drawable.getGL();
        // Enable VSync
        gl.setSwapInterval(1); 
        // set up lighting
        float ambient[] = {0.4f,0.4f,0.4f,1.0f };
        float diffuse[] = {1.0f,1.0f,1.0f,1.0f };
        float position[] = {1.0f,1.0f,1.0f,0.0f };
        float lmodel_ambient[] = {0.4f,0.4f,0.4f,1.0f };
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambient,0);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse,0);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, position,0);
        gl.glEnable(GL.GL_LIGHT0);
        gl.glEnable(GL.GL_LIGHTING);
        gl.glEnable(GL.GL_DEPTH_TEST);
        // Setup the drawing area and shading mode
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        gl.glShadeModel(GL.GL_SMOOTH);
        // set up the horse
        theHorse=new oneHorse();
    }
    public void reshape(GLAutoDrawable drawable, int x, int y, 
            int width, int height)
    {
        GL gl = drawable.getGL();
        GLU glu = new GLU();
        if (height <= 0) {  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();
        GLU glu=new GLU();
        // Clear the drawing area
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT );
        gl.glClear(GL.GL_ACCUM_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT );
        // Reset the current matrix to the "identity"
        gl.glLoadIdentity();
        glu.gluLookAt(3.0f, 3.0f, 3.0f,
                      0.0f, 0.0f, 0.0f,
                      0.0f, 0.0f, 1.0f);
        // do basic mousing
        gl.glRotatef(m_rotY, 0.0f, 1.0f,0.0f);
        gl.glRotatef(m_rotZ, 0.0f, 0.0f,1.0f);
        // draw the horse
        theHorse.drawMe(gl);
        
        // Flush all drawing operations to the graphics card
        gl.glFlush();
       if(m_isWalking)
            theHorse.updateAngles();
    }
    public void displayChanged(GLAutoDrawable drawable,
            boolean modeChanged, boolean deviceChanged) {
    }
    public void setBasicRotation(float z,float y)
    {
        m_rotZ=z;
        m_rotY=y;
    }
    public void setHeadAngles(float v1,float v2)
    {
        theHorse.m_neck_angle=v1;
        theHorse.m_head_angle=v2;
    }
    public void  doWalk(boolean on)
    {
        m_isWalking=on;
    }

}

Inspecting this, it should be rather straight-forward to implement a different "pin-figure" with some animation.

The program project: https://svnit.hiof.no/svn/psource/JOGL/horse