Node.java

import java.util.ArrayList;
import javax.media.opengl.GL;



/**
 * Basic node for a JOGL 3D Application
 * @author Andrew
 */
public class Node
{

 /** Name of this node */
 private String nodeName;

 /** Parent node (if null then this is rootNode - or not attached to scene */
 protected Node parentNode;

 /** A list of all the children nodes below this node */
 private ArrayList<Node> childrenNodes;

 /* Transformations */
 private final float[] scale;
 private final float[] translation;
 private final float[] rotation;

 /** Global Transformation Matrix */
 private final float[] m;
 /** Temp matrix to use to calculate transformation m */
 private final float[] temp;

 /** True when transformation matrix is needed to be recalculated */
 private boolean recalculateTransformMatrix;



 /**
 * Creates a new node
 * @param nodeName the name of this node
 */
 public Node(String nodeName)
 {
 this.nodeName = nodeName;
 parentNode = null;
 childrenNodes = new ArrayList<Node>();

 scale = new float[3];
 translation = new float[3];
 rotation = new float[4];

 resetLocalTransformations();

 m = new float[16];
 temp = new float[16];

 recalculateTransformMatrix = true;
 }

 /**
 * Sets all translations back to original
 */
 protected void resetLocalTransformations()
 {
 scale[0] = 1.0f; scale[1] = 1.0f; scale[2] = 1.0f;
 translation[0] = 0.0f; translation[1] = 0.0f; translation[2] = 0.0f;
 rotation[0] = 0.0f; rotation[1] = 0.0f; rotation[2] = 1.0f; rotation[3] = 0.0f;

 setRecalculateTransformMatrix();
 }

 /**
 * Sets the transformation matrix to be recalculated in this
 * node and children nodes
 */
 protected void setRecalculateTransformMatrix()
 {
 this.recalculateTransformMatrix = true;
 for(Node c : childrenNodes)
 c.setRecalculateTransformMatrix();
 }


 /**
 * Adds a child to this node
 * (Removes it from any other node it was attached to
 * @param child the child to attach
 * @return true if successfully added - false if not.
 */
 public boolean addChild(Node child)
 {
 boolean success = false;

 //if it has a parent already - remove it from the parent
 if(child.parentNode != null)
 {
 child.parentNode.removeChild(child);
 }

 //now add it to this child
 if(childrenNodes.add(child))
 {
 child.parentNode = this;
 //recalculate because changed parent
 child.setRecalculateTransformMatrix();
 success = true;
 }

 return success;
 }

 /**
 * Removes a child from this node
 * @param child the child to remove from this node
 * @return true if successfully removed - false if not.
 */
 public boolean removeChild(Node child)
 {
 return childrenNodes.remove(child);
 }


 /**
 * Sets the scale of this node
 * @param x x scale
 * @param y y scale
 * @param z z scale
 */
 public void setScale(float x, float y, float z)
 {
 scale[0] = x;
 scale[1] = y;
 scale[2] = z;

 setRecalculateTransformMatrix();
 }

 /**
 * Sets the scale of all 3 vertices
 * @param xyz the x, y and z scale
 */
 public void setScale(float xyz)
 {
 setScale(xyz, xyz, xyz);
 }


 /**
 * Sets the translation of this node
 * @param x x translation
 * @param y y translation
 * @param z z translation
 */
 public void setTranslation(float x, float y, float z)
 {
 translation[0] = x;
 translation[1] = y;
 translation[2] = z;

 setRecalculateTransformMatrix();
 }


 /**
 * Sets the translation of x and y, and sets z to 0.0
 * @param x x translation
 * @param y y translation
 */
 public void setTranslation(float x, float y)
 {
 setTranslation(x, y, 0.0f);
 }


 /**
 * Sets the rotation of this node
 * @param degrees how many degrees to rotate this node
 * @param x amount of rotation around x axis
 * @param y amount of rotation around y axis
 * @param z amount of rotation around z axis
 */
 public void setRotation(float degrees, float x, float y, float z)
 {
 rotation[0] = degrees;
 rotation[1] = x;
 rotation[2] = y;
 rotation[3] = z;

 setRecalculateTransformMatrix();
 }


 /**
 * Sets the identify matrix
 * @param matrix the matrix to reset
 */
 private static void identityMatrix(float[] matrix)
 {
 matrix[0] = 1.0f; matrix[4] = 0.0f; matrix[8] = 0.0f; matrix[12] = 0.0f;
 matrix[1] = 0.0f; matrix[5] = 1.0f; matrix[9] = 0.0f; matrix[13] = 0.0f;
 matrix[2] = 0.0f; matrix[6] = 0.0f; matrix[10] = 1.0f; matrix[14] = 0.0f;
 matrix[3] = 0.0f; matrix[7] = 0.0f; matrix[11] = 0.0f; matrix[15] = 1.0f;
 }

 /**
 * Multiplies two matrices and puts result in b
 * @param a first matrix
 * @param b second matrix (and output)
 */
 private static void multiplyMatrix(float[] a, float[] b)
 {
 for (int col = 0; col < 4; col++)
 {
 float p0 = b[col * 4];
 float p1 = b[col * 4 + 1];
 float p2 = b[col * 4 + 2];
 float p3 = b[col * 4 + 3];

 for (int row = 0; row < 4; row++)
 {
 b[col * 4 + row] = a[row] * p0 + a[row + 4] * p1 + a[row + 8] * p2 + a[row + 12] * p3;
 }
 }
 }


 /**
 * Calculates the node global transformation matrix
 * @return this node global transformation matrix
 */
 public float[] getNodeGlobalTransform()
 {
 if(recalculateTransformMatrix)
 {
 identityMatrix(m);
 identityMatrix(temp);

 //scale
 temp[0] = scale[0];
 temp[5] = scale[1];
 temp[10] = scale[2];
 multiplyMatrix(temp, m);

 //rotation
 identityMatrix(temp);
 float cosAngle = (float) Math.cos(Math.toRadians(rotation[0]));
 float sinAngle = (float) Math.sin(Math.toRadians(rotation[0]));
 float oneMinusCos = 1.0f - cosAngle;
 float ux = rotation[1]; float uy = rotation[2]; float uz = rotation[3];

 temp[0] = oneMinusCos*ux*ux + cosAngle;
 temp[1] = oneMinusCos*ux*uy + sinAngle*uz;
 temp[2] = oneMinusCos*ux*uz - sinAngle*uy;
 temp[4] = oneMinusCos*ux*uy - sinAngle*uz;
 temp[5] = oneMinusCos*uy*uy + cosAngle;
 temp[6] = oneMinusCos*uy*uz + sinAngle*ux;
 temp[8] = oneMinusCos*ux*uz + sinAngle*uy;
 temp[9] = oneMinusCos*uy*uz - sinAngle*ux;
 temp[10]= oneMinusCos*uz*uz + cosAngle;
 multiplyMatrix(temp, m);

 //translation
 identityMatrix(temp);
 temp[12] = translation[0];
 temp[13] = translation[1];
 temp[14] = translation[2];
 multiplyMatrix(temp, m);

 //applies parent transform also (if it has a parent)
 if (parentNode != null) //then get the parent node global transform
 multiplyMatrix(parentNode.getNodeGlobalTransform(), m);

 //finished recalculating
 recalculateTransformMatrix = false;
 }

 return m;
 }


 /**
 * Initilisation method.
 * Also inits children nodes
 */
 public void init(GL gl)
 {
 //inits position
 getNodeGlobalTransform();

 for(Node n : childrenNodes)
 n.init(gl);
 }


 /**
 * Updates this node.
 * Also updates children nodes
 */
 public void update()
 {
 //this node does nothing so update children nodes
 for(Node n : childrenNodes)
 n.update();
 }


 /**
 * Function to run before drawing
 * @param gl
 */
 protected void preDraw(GL gl)
 {
 gl.glPushMatrix();

 //push transformation on stack
 gl.glMultMatrixf(getNodeGlobalTransform(), 0);
 }

 /**
 * Function to run after drawing
 * @param gl
 */
 protected void postDraw(GL gl)
 {
 gl.glPopMatrix();
 }

 /**
 * Draws the node.
 * Also draws children nodes
 */
 public void draw(GL gl)
 {
 preDraw(gl);

 //this node does nothing so draw children nodes
 for(Node n : childrenNodes)
 n.draw(gl);

 postDraw(gl);
 }


 /**
 * Gets the shader program of this node.
 * If this is not a shader node then it will get the parent shader program.
 * Default is zero.
 * @return The shader program ID
 */
 public int getShaderProgram()
 {
 if(parentNode != null)
 return parentNode.getShaderProgram();
 //zero is default shader
 return 0;
 }

 /**
 * toString method
 * @return String representation of this 
 */
 @Override
 public String toString()
 {
 return "Node: " + nodeName + " with (" + childrenNodes.size() + ") children";
 }
}