Hest

Hva

Vi skal tegne en superenkel pinne-hest og vi skal få den til å bevege seg. Hensikten er ikke å lage noe som er mest mulig likt en hest, men å se litt nærmere på animasjonen. Det er ganske enkelt å legge til noen egenskaper som øyne, man og hale for å få figuren til å bli mer likt det aktuelle husdyret.

Vi planlegger hesten slik. Alle deler er lukkede sylindere og har således en lengde og en radius.

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;

og vinklene

// 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};

Den komplette klassen som beskriver og tegner en hest, 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();
    }
}

Animasjon

Vi vil at hesten skal gå når vi klikker på en knapp og at den fortsetter å gå til vi klikker igjen. Samtidig skal vi kunne endre andre egenskaper ved hesten, eller programmet. Vi gjør dette ved å la mainclass, Horse, implementere Runnable og vi genererer en ny tråd.

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

run-metoden er implementert slik::

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

For at dette skal virke etter hensikten må vi deklarere de involverte egenskapene som statiske slik at de er synlig på tvers av trådene:

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;
}

Merk at animator-klassen som genereres automatisk når NetBeans generer en standard JOGL-applikasjon ikke er til noen nytte her.

En annen figur

Hovedklassen, Horse, vet ikke hva slags dyr vi arbeider med. Alt er fullstendig administrert fra GLRender-klassen. Det er denne som setter opp hesten, gir den farge og sørger for å oppdatere nødvendige vinkler. GLRender er i sin helhet slik:

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;
    }

}

Det bør være ganske rett-fram og erstatte hesten med en annen pinnefigur, eller å lage alternative bevegelsesmønstere for hesten (trav, galopp, passgang, tølt).

Prosjektet: https://svnit.hiof.no/svn/psource/JOGL/horse