Vertex Motion demo

Er, JavaScript doesn't seem to be running, so basically all you're going to see is the bare code...

var loader=new THREE.STLLoader();
loader.load('models/headXYZ.stl', 
 /* everything below is one big callback function */
     function(g) {

sim.g=g; // stash geometry for future modification
// Geometry comes in too big--scale back vertices
for (var i=0;i<g.vertices.length;i++) {
   g.vertices[i].multiplyScalar(0.04);
}
g.verticesNeedUpdate=true;
g.computeVertexNormals(true); // get normals
// g.mergeVertices(); // avoids "shatter" effect

// Make a bunch of heads using the loaded geometry
sim.nspheres=1;
sim.spheres=[];
for (var i=0;i<sim.nspheres;i++) {
  var m=new THREE.MeshLambertMaterial(
    {color: 0x8030ff});
  var s=new THREE.Mesh(g,m);
  s.position.set(0,0,0);
  s.V=new vec3(0,0,0);
  s.P=new vec3(0,0,0);
  s.castShadow=true;
  s.receiveShadow=true;
  scene.add(s); // so it gets rendered
  sim.spheres[i]=s; // so we can animate it
}

// Ground
var groundTex=THREE.ImageUtils.loadTexture( "textures/checkerboard_noisy.jpg" );
groundTex.wrapS=groundTex.wrapT=THREE.RepeatWrapping;
groundTex.repeat=new vec2(25.0,25.0);

sim.ground = new THREE.Mesh(
  new THREE.CubeGeometry(50,50,0.0001),
  new THREE.MeshLambertMaterial(
    {color: 0xffccaa, opacity: 1, map:groundTex})
);
sim.ground.position.z=-1;  /* hack for radius 1 */
sim.ground.receiveShadow=true;
scene.add(sim.ground);

// Sun-like spotlight
var l=new THREE.SpotLight();
sim.light = l;
l.position.set( -50, -100, 100 );
l.castShadow=true;
l.shadowCameraNear = 50; 
l.shadowCameraFar = 500; 
l.shadowCameraFov = 10; // degrees field of view
scene.add(l);

camera.lookAt(scene.position);

}); // end loader callback

/*********** Move geometry ***********/
var g=sim.g;
if (g) {
	// Move each vertex
	var v=new vec3;
	for (var i=0;i<g.vertices.length;i++) {
	  g.vertices[i].pe(v.rand(0.5*lib.dt));
	}
	g.verticesNeedUpdate=true;
	g.computeVertexNormals(true); // get normals

}

/*********** Collisions and Linear Motion ********/
/**
  s: sphere object, with s.P position and s.V velocity.
  N: surface normal, facing out of region.
  P: point on surface of boundary region.
*/
function boundaryBounce(s,N,P) {
  N.normalize();
  var rP=s.P.m(P); // sphere position, relative to boundary
  var d=rP.dot(N);
  if (d>0.0) { // we hit the boundary
    s.P.pe(N.t(-d)); // move inside
    var dV=s.V.dot(N); 
    if (dV>0.0) { // flip velocity
      s.V.pe(N.t(-1.8*dV ));

s.V.te(0.99); // drag
    }
  }
}

// Linear bounce physics
for (var i=0;i<sim.nspheres;i++) {
  var s=sim.spheres[i];
  var A=new vec3(0,0,-9.8); 
  s.V.pe(A.t(lib.dt));
  s.P.pe(s.V.t(lib.dt));

boundaryBounce(s,new vec3(0,0,-1), new vec3()); // floor
  boundaryBounce(s,new vec3(+1,0,0), new vec3(5,0,0));
  boundaryBounce(s,new vec3(-1,0,0), new vec3(-4,0,0));
  boundaryBounce(s,new vec3(0,0,+1), new vec3(0,0,5)); // lid

s.position=s.P; // copy to 3D display
}

// Camera control:

// Update camera coordinate system
var s=camera;
if (!s.X) { // startup: create initial coordinates
    s.X=new vec3(1,0,0);
    s.Y=new vec3(0,0,1);
    s.Z=new vec3(0,-1,0.2); // camera Z is world Y
    s.P=new vec3(0,-4,1.3); // initial location
}

// Move camera via keyboard
var move=new vec3(0,0,0); // sums current frame motion

// X control via A and D
if (lib.key['a']) move.pe(new vec3(-1,0,0));
if (lib.key['d']) move.pe(new vec3(+1,0,0));
// Y control via W and S
if (lib.key['w']) move.pe(new vec3(0,0,-1));
if (lib.key['s']) move.pe(new vec3(0,0,+1));
// Z control via Q and Z
if (lib.key['q']) move.pe(new vec3(0,+1,0));
if (lib.key['z']) move.pe(new vec3(0,-1,0));

move.te(5.0*lib.dt); // meters/second motion rate
s.P.pe(s.X.t(move.x).p(s.Y.t(move.y)).p(s.Z.t(move.z)));

// Rotate camera via mouse
var speed=0.01; // radians per mouse pixel
if (lib.mouseleft) { // move Z with mouse
    s.Z.pe(s.X.t(-lib.mousedx*speed).p(
           s.Y.t( lib.mousedy*speed)));
}

// Keep level: make sure X is horizontal.
s.X.z=0.0;
s.Y.crossVectors(s.Z,s.X.normalize());

// Orthonormalize
s.X.crossVectors(s.Y,s.Z).normalize();
s.Y.crossVectors(s.Z,s.X).normalize();
s.Z.normalize();

// Write coordinate system into matrix
s.matrixAutoUpdate=false; // don't trash
s.matrixWorldNeedsUpdate=true; // show
  
var m=s.matrix; // the camera's matrix

// Utility function: set a matrix column
function setCol(m,col,vec) {
  m.elements[4*col+0]=vec.x;
  m.elements[4*col+1]=vec.y;
  m.elements[4*col+2]=vec.z;
}

setCol(m,0,s.X);
  setCol(m,1,s.Y);
  setCol(m,2,s.Z);
  setCol(m,3,s.P); // position from sim