//----------------------------
  //----------------------------
  // Common.js
  //----------------------------
  //----------------------------


console.println( "* The Javascript 'Common.js' is now being read..." );



  var ONE_HALF = 0.5;
  var PI       = 3.14159;

  var verbose = false;

  var theBackground = null;

  var backgroundRed   = 0.7;
  var backgroundGreen = 0.7;
  var backgroundBlue  = 0.7;


  //---------------------------------------------------------------------
  function printNamesOfAllTheMeshes()
   {
    var numberOfMeshes = scene.meshes.count;

    console.println( "Printing names of all the meshes in the scene..." );
    console.println( "(there are " + numberOfMeshes + " meshes in this Scene)" );

    for (m=0; m<numberOfMeshes; m++)
     {
      var modelMesh = scene.meshes.getByIndex(m);
      console.println( "mesh " + m + " is named '" + modelMesh.name + "'" );
     }


  }//---------------------------------------------------------------------





  //---------------------------------------------------------------------
  function printOutNodeParentalHierarchies()
   {
    console.println( "" );
    console.println( "* printing out the parental hierarchies of all the nodes..." );

     for (m=0; m<scene.nodes.count; m++)
      {
       var indentation = 0;
       var node = scene.nodes.getByIndex( m );
       console.println( "" );
       console.println( "" );
       console.println( "-----------------------------------------" );
       console.print( "Node " + m + " is " );
       traverseParentalTree( node, indentation );
      }

     console.println( "" );

  }//---------------------------------------------------------------------




  //---------------------------------------------------------------------
  function traverseParentalTree( node, indentation )
   {      
    //----------------------------------------------------------     
    // print it  
    //---------------------------------------------------------- 
    var kindOfNode = node.constructor.name;

    console.print( "named '" + node.name + "', and is " );

    if (( kindOfNode == "Scene" )
    ||  ( kindOfNode == "Dummy" )
    ||  ( kindOfNode == "Mesh"  ))
     { 
      console.print( "of type " + kindOfNode ); 
     }
    else 
     { 
      console.print( "an unknown type of node." );
     }

    if ( kindOfNode != "Scene" )
     {
      console.println( node.transform ); 
     }



    //----------------------------------------------------------     
    // recurse
    //----------------------------------------------------------     
    if ( kindOfNode != "Scene" )
     {
      console.println("");

      indentation ++;
      //----------------------------------------------------------     
      // do the indentation   
      //----------------------------------------------------------     
      for (var i=0; i<indentation; i++ ) 
       { 
        console.print( "  " ); 
       }

      console.print( "The parent of '" + node.name + "' is " );

      traverseParentalTree( node.parent, indentation )
     }

  }//---------------------------------------------------------------------




  //---------------------------------------------------------------------
  function setBackgroundColor( r, g, b )
   {      
    backgroundRed   = r;
    backgroundGreen = g;
    backgroundBlue  = b;

    theBackground.setColor(new Color( backgroundRed, backgroundGreen, backgroundBlue ));
   }




  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  // Creating a Background using the Render Event Handler
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  renderEventHandler = new RenderEventHandler();
  renderEventHandler.onEvent = function( event )
   {
    runtime.removeEventHandler( this );
    theBackground = event.canvas.background;

  //theBackground.setColor( new Color( backgroundRed, backgroundGreen, backgroundBlue ) );
   }

  runtime.addEventHandler( renderEventHandler );


console.println( "* OK, the Javascript 'Common.js' was successfully read to the end." );






  //------------------------------------------------------------
  //------------------------------------------------------------
  // FloatingBalls.js
  //
  // Author: JJ Ventrella
  // Adobe Systems, Inc. 2005
  //------------------------------------------------------------
  //------------------------------------------------------------


console.println( "* The Javascript 'FloatingBalls.js' is now being read..." );


  var MAX_RESOURCE_MODELS		= 40;
  var NUM_VERTICES			= 8;
  var ONE_HALF 				= 0.5;
  var DEFAULT_GRAVITY 			= 6.0;
  var BOUNCE  				= 0.4;
  var MOUSE_ROTATION_FORCE		= 27.0;
  var SPAN 				= 17.0;
  var BALL_RADIUS 			= 4;
  var AIR_FRICTION			= 0.2;
  var ROTATION_FRICTION		= 10.0;
  var STICK_WIDTH 			= 2.0;
  var BALL_TO_BALL_COLLISION_FORCE	= 0.3;
  var BALL_TO_BALL_COLLISION_FRICTION	= 0.2;
  var UP_DIRECTION			= new Vector3( 0.0, 0.0, 1.0 );

  var a = -1;
  var NULL_ACTION          	= a; a++;
  var DRAGGING_BALL_ACTION 	= a; a++;
  var ROTATING_CUBE_ACTION 	= a; a++;
  var MOVING_CUBE_ACTION   	= a; a++;
  var NUM_ACTIONS   		= a;

  var stickResourceModel	= new Array( MAX_RESOURCE_MODELS )
  var ballResourceModel		= new Array( MAX_RESOURCE_MODELS )
  var squareResourceModel	= new Array( MAX_RESOURCE_MODELS )
  var ballPosition		= new Array( MAX_RESOURCE_MODELS )
  var ballVelocity		= new Array( MAX_RESOURCE_MODELS )
  var ballInside		= new Array( MAX_RESOURCE_MODELS )
  var gravity 			= DEFAULT_GRAVITY;
  var numStickResourceModels	= 0;
  var numBallResourceModels	= 0;
  var numSquareResourceModels	= 0;
  var minCollisionLimit 	= -SPAN + BALL_RADIUS;
  var maxCollisionLimit		=  SPAN - BALL_RADIUS;
  var vertex			= new Array( MAX_RESOURCE_MODELS );
  var cubePosition		= new Vector3( 0.0, 0.0, 0.0 );
  var rotationAxis 		= new Vector3( 1.0, 0.0, 0.0 );
  var camera             	= scene.cameras.getByIndex( 0 );
  var generalMouseEventHandler	= new MouseEventHandler();
  var squareResourceAdded	= false;
  var stickResourceAdded	= false;
  var ballResourceAdded		= false;
  var firstResourceModelIndex	= -1;
  var lastResourceModelIndex	= -1;
  var mouse_X			= 0;
  var mouse_Y	 		= 0;
  var mouse_XPrevious 		= 0;
  var mouse_YPrevious 		= 0;
  var canvasPixelWidth          = 0;
  var canvasPixelHeight         = 0;
  var mouseMotionVector 	= new Vector3();
  var rotation 			= new Matrix4x4();
  var right 			= new Vector3( 1.0, 0.0, 0.0 );
  var up    			= new Vector3( 0.0, 1.0, 0.0 );
  var front 			= new Vector3( 0.0, 0.0, 1.0 );
  var rotatedRight 		= right;
  var rotatedUp    		= up;
  var rotatedFront 		= front;
  var verbose 			= true;
  var testClock 		= 0.0;
  var action 			= NULL_ACTION;
  var grabbedBall               = -1;
  var grabDistance		= 0.0;

  var currentNumberOfMeshesInScene = scene.meshes.count;

  for (var v=0; v<NUM_VERTICES; v++)
   {
    vertex[v] = new Vector3( 0.0, 0.0, 0.0 );
   }

  for (var i=0; i<MAX_RESOURCE_MODELS; i++)
   {
    ballPosition[i] = new Vector3( 0.0, 0.0, 0.0 );
    ballVelocity[i] = new Vector3( 0.0, 0.0, 0.0 );
    ballInside  [i] = true;
   }

    //----------------------------------------------------------
    // Time Event Handler
    //----------------------------------------------------------
      timeEventHandler = new TimeEventHandler();
      timeEventHandler.onTimeChange = true;
      timeEventHandler.onEvent = function( event )
       {
        testClock += event.deltaTime;

        camera.position.set3( 0.0, -130.0, 0.0 );
        camera.targetPosition.set3( 0.0, 0.0, 0.0 );
        camera.up.set(front);
        camera.up.addInPlace(camera.position);


        var f = ROTATION_FRICTION * event.deltaTime;
        if ( f > 1.0 )
         {
          f = 1.0;
         }

        rotationAxis.scaleInPlace( 1.0 - f );
        var rotationRate = rotationAxis.length * MOUSE_ROTATION_FORCE * event.deltaTime;

        if ( rotationRate > 0.000001 )
         {
          rotation.rotateAboutVectorInPlace( rotationRate, rotationAxis );
         }


        rotatedRight = rotation.transformDirection( right );
        rotatedUp    = rotation.transformDirection( up    );
        rotatedFront = rotation.transformDirection( front );



        //----------------------------------------------------------
        // Here is where the resource models are updated....
        //----------------------------------------------------------
        if ( stickResourceAdded )
         {
          updateSticks( testClock );
         }
        if ( ballResourceAdded )
         {
          updateBalls( event.deltaTime );
         }
        if ( squareResourceAdded )
         {
          updateSquares( event.deltaTime );
         }

        //-------------------------------------------------------
        // rotating
        //-------------------------------------------------------
        if ( action == ROTATING_CUBE_ACTION )
         {
          var mousePointingVector         = new Vector3();
          var mousePreviousPointingVector = new Vector3();

          mousePointingVector.set        ( camera.getDirectionFromScreen( mouse_X,         mouse_Y,         canvasPixelWidth, canvasPixelHeight ) );
          mousePreviousPointingVector.set( camera.getDirectionFromScreen( mouse_XPrevious, mouse_YPrevious, canvasPixelWidth, canvasPixelHeight ) );

          mouse_XPrevious = mouse_X;
          mouse_YPrevious = mouse_Y;

          mouseMotionVector.set( mousePointingVector );
          mouseMotionVector.subtractInPlace( mousePreviousPointingVector );
          
          var cameraVector = new Vector3();
          cameraVector.set( camera.position );
          cameraVector.subtractInPlace( camera.targetPosition );
          cameraVector.scaleInPlace( 1.0 / cameraVector.length );

          var newAxis = new Vector3( cameraVector.cross( mouseMotionVector ) );
          rotationAxis.addScaledInPlace( newAxis, 3.0 );
         }
        else ( action == DRAGGING_BALL_ACTION )
         {
          if ( grabbedBall != -1 )
           {
            var previousPosition = new Vector3( ballPosition[ grabbedBall ] );
            var v = new Vector3( camera.getDirectionFromScreen( mouse_X, mouse_Y, canvasPixelWidth, canvasPixelHeight ) );

            ballPosition[ grabbedBall ].set( camera.position );
            ballPosition[ grabbedBall ].addScaledInPlace( v, grabDistance );

            ballVelocity[ grabbedBall ].set( ballPosition[ grabbedBall ] );
            ballVelocity[ grabbedBall ].subtractInPlace( previousPosition );
           }
         }
       }
      runtime.addEventHandler( timeEventHandler );



  //------------------------------------------------------
  // General Mouse Event Handler for whole 3D Annotation
  //------------------------------------------------------
  generalMouseEventHandler.onMouseDown	= true;
  generalMouseEventHandler.onMouseMove	= true;
  generalMouseEventHandler.onMouseUp	= true;
  generalMouseEventHandler.onEvent 	= function( event )
   {

    //-----------------------------------------------
    // mouse is moving
    //-----------------------------------------------
    if ( event.isMouseMove )
     {
      mouse_X = event.mouseX;
      mouse_Y = event.mouseY;
      canvasPixelWidth  = event.canvasPixelWidth;
      canvasPixelHeight = event.canvasPixelHeight;
     }


    //-----------------------------------------------
    // mouse just down
    //-----------------------------------------------
    if ( event.isMouseDown )
     {
      rotating = false;
      mouse_X = event.mouseX;
      mouse_Y = event.mouseY;
      mouse_XPrevious = mouse_X;
      mouse_YPrevious = mouse_Y;
      canvasPixelWidth  = event.canvasPixelWidth;
      canvasPixelHeight = event.canvasPixelHeight;

      grabbedBall = detectMouseOverBall();
      if ( grabbedBall != -1 )
       {
        action = DRAGGING_BALL_ACTION;
       }
      else
       {
        action = ROTATING_CUBE_ACTION;
       }
     }

    //-----------------------------------------------
    // mouse just up
    //-----------------------------------------------
    if ( event.isMouseUp )
     {
      rotating = false;
      mouse_X = event.mouseX;
      mouse_Y = event.mouseY;
      mouse_XPrevious = mouse_X;
      mouse_YPrevious = mouse_Y;
      canvasPixelWidth  = event.canvasPixelWidth;
      canvasPixelHeight = event.canvasPixelHeight;

      releaseGrabbedBall();
      action = NULL_ACTION;
     }

   } // generalMouseEventHandler.onEvent method


  runtime.addEventHandler( generalMouseEventHandler );




  //------------------------------------------------------
  function detectMouseOverBall()
   {
    var ball = -1;
    var cursorDirection = new Vector3( camera.getDirectionFromScreen( mouse_X, mouse_Y, canvasPixelWidth, canvasPixelHeight ) );

    for (var i=0; i<numBallResourceModels; i++)
     {
      var cameraToBall = new Vector3( ballPosition[i] );
      cameraToBall.subtractInPlace( camera.position );
      var distanceToBall = cameraToBall.length;

      var cursor3D = new Vector3( camera.position );
      cursor3D.addScaledInPlace( cursorDirection, distanceToBall );
      
      var vectorBetween = new Vector3( ballPosition[i] );
      vectorBetween.subtractInPlace( cursor3D );
      var distanceBetween = vectorBetween.length;

      if ( distanceBetween < BALL_RADIUS )
       {
        ball = i; 
        grabDistance = distanceToBall;
       }
     }

    return ball;

   }//---------------------------------------------------------------



  //------------------------------------------------------
  function releaseGrabbedBall()
   {
    if ( grabbedBall != -1 )
     {
      var centerToBall = new Vector3( ballPosition[ grabbedBall ] );
      centerToBall.subtractInPlace( cubePosition ); 

      var rightExtent = centerToBall.dot( rotatedRight );
      var upExtent    = centerToBall.dot( rotatedUp    );
      var frontExtent = centerToBall.dot( rotatedFront );

      if (( rightExtent <  SPAN  )
      &&  ( rightExtent > -SPAN  )
      &&  (    upExtent <  SPAN  )
      &&  (    upExtent > -SPAN  )
      &&  ( frontExtent <  SPAN  )
      &&  ( frontExtent > -SPAN  ))
       {
        ballInside[ grabbedBall ] = true;
       }
      else
       {
        ballInside[ grabbedBall ] = false;        
       }

      //--------------------------------
      // keep this at the end
      //--------------------------------
      grabbedBall = -1;
     }

   }//---------------------------------------------------------------






  //------------------------------------------------------
  function updateSquares( deltaTime )
   {
    if ( squareResourceAdded )
     {
      squareResourceModel[0].transform.setIdentity();

      var shift = new Vector3( 0.0, 0.0, -130.0 );
      squareResourceModel[0].transform.translateInPlace( shift );

      squareResourceModel[0].transform.scaleInPlace( 4.0, 4.0, 4.0 );
      squareResourceModel[0].transform.rotateAboutXInPlace( Math.PI * ONE_HALF );

     }

   }//---------------------------------------------------------------





  //------------------------------------------------------
  function updateSticks( clock )
   {
    for (var v=0; v<NUM_VERTICES; v++)
     {
      vertex[v].set( cubePosition );
     } 

    vertex[0].addScaledInPlace( rotatedRight, -SPAN );
    vertex[1].addScaledInPlace( rotatedRight, -SPAN );
    vertex[2].addScaledInPlace( rotatedRight, -SPAN );
    vertex[3].addScaledInPlace( rotatedRight, -SPAN );
    vertex[4].addScaledInPlace( rotatedRight,  SPAN );
    vertex[5].addScaledInPlace( rotatedRight,  SPAN );
    vertex[6].addScaledInPlace( rotatedRight,  SPAN );
    vertex[7].addScaledInPlace( rotatedRight,  SPAN );

    vertex[0].addScaledInPlace( rotatedUp,    -SPAN );
    vertex[1].addScaledInPlace( rotatedUp,     SPAN );
    vertex[2].addScaledInPlace( rotatedUp,     SPAN );
    vertex[3].addScaledInPlace( rotatedUp,    -SPAN );
    vertex[4].addScaledInPlace( rotatedUp,    -SPAN );
    vertex[5].addScaledInPlace( rotatedUp,     SPAN );
    vertex[6].addScaledInPlace( rotatedUp,     SPAN );
    vertex[7].addScaledInPlace( rotatedUp,    -SPAN );

    vertex[0].addScaledInPlace( rotatedFront, -SPAN );
    vertex[1].addScaledInPlace( rotatedFront, -SPAN );
    vertex[2].addScaledInPlace( rotatedFront,  SPAN );
    vertex[3].addScaledInPlace( rotatedFront,  SPAN );
    vertex[4].addScaledInPlace( rotatedFront, -SPAN );
    vertex[5].addScaledInPlace( rotatedFront, -SPAN );
    vertex[6].addScaledInPlace( rotatedFront,  SPAN );
    vertex[7].addScaledInPlace( rotatedFront,  SPAN );

    showStick( 0,  vertex[0], vertex[1], STICK_WIDTH );
    showStick( 1,  vertex[1], vertex[2], STICK_WIDTH );
    showStick( 2,  vertex[2], vertex[3], STICK_WIDTH );
    showStick( 3,  vertex[3], vertex[0], STICK_WIDTH );

    showStick( 4,  vertex[4], vertex[5], STICK_WIDTH );
    showStick( 5,  vertex[5], vertex[6], STICK_WIDTH );
    showStick( 6,  vertex[6], vertex[7], STICK_WIDTH );
    showStick( 7,  vertex[7], vertex[4], STICK_WIDTH );

    showStick( 8,  vertex[0], vertex[4], STICK_WIDTH );
    showStick( 9,  vertex[1], vertex[5], STICK_WIDTH );
    showStick( 10, vertex[2], vertex[6], STICK_WIDTH );
    showStick( 11, vertex[3], vertex[7], STICK_WIDTH );

   }//---------------------------------------------------------------






  //--------------------------------------------------------------------------------
  //
  // This method shows a "stick" in 3-space whose endpoints can be specified 
  // in world coordinates, and whose thickness can also be specified. It requires
  // a model which is roughly cylindrical in nature, oriented with the ____ axis 
  // along it's axis of symmetry, of height 1.0, and of diameter 1.0. This method 
  // requires that these dimensions be normalized as such. The model could of course 
  // be something other than a cylinder, in case a special effect is desired. 
  //
  //--------------------------------------------------------------------------------
  function showStick( index, position1, position2, width )
   {
    if ( stickResourceAdded )
     {
      //------------------------------------------------------------
      // calculate length
      //------------------------------------------------------------
      var vector = new Vector3();
      vector.set( position2 );
      vector.subtractInPlace( position1 );
      var length = vector.length;

      //------------------------------------------------------------
      // set to identity
      //------------------------------------------------------------
      stickResourceModel[ index ].transform.setIdentity();


      //------------------------------------------------------------
      // initial rotation to aim stick down the Y axis
      //------------------------------------------------------------
      var initialRotationMatrix = new Matrix4x4();
      initialRotationMatrix.rotateAboutXInPlace( Math.PI * ONE_HALF );
      stickResourceModel[ index ].transform.multiplyInPlace( initialRotationMatrix );


      //------------------------------------------------------------
      // shift over to place one end at the origin
      //------------------------------------------------------------
      var shiftMatrix = new Matrix4x4();
      var offsetVector = new Vector3();
      offsetVector.set( 0.0, 1.0, 0.0 );
      shiftMatrix.translateInPlace( offsetVector );
      stickResourceModel[ index ].transform.multiplyInPlace( shiftMatrix );


      //------------------------------------------------------------
      // scale
      //------------------------------------------------------------
      var scaleMatrix = new Matrix4x4();
      scaleMatrix.scaleInPlace( width, length, width );
      stickResourceModel[ index ].transform.multiplyInPlace( scaleMatrix );
 

      //------------------------------------------------------------
      // rotate
      //------------------------------------------------------------
      var dx = position2.x - position1.x;
      var dy = position2.y - position1.y;
      var dz = position2.z - position1.z;
      var radius  =  Math.sqrt ( dx*dx + dy*dy );
      var pitch   =  Math.atan2( dz, radius    );
      var yaw     = -Math.atan2( dx, dy        );
      var rotationMatrix = new Matrix4x4();
      rotationMatrix.rotateAboutXInPlace( pitch );
      rotationMatrix.rotateAboutZInPlace( yaw );
      stickResourceModel[ index ].transform.multiplyInPlace( rotationMatrix );


      //------------------------------------------------------------
      // translate
      //------------------------------------------------------------
      var translationMatrix = new Matrix4x4();
      translationMatrix.translateInPlace( position1 );
      stickResourceModel[ index ].transform.multiplyInPlace( translationMatrix );


    } // if ( stickResourceAdded )


   }//------------------------------------------------------





  //------------------------------------------------------
  function updateBalls( deltaTime )
   {
    if ( ballResourceAdded )
     {
      for (var i=0; i<numBallResourceModels; i++)
       {
        if ( i != grabbedBall )
         { 
          updateBallPhysics( i, deltaTime );
         }

        //-----------------------------------------------------------------------
        // put the rendered balls in place
        //-----------------------------------------------------------------------
        showBall( i, ballPosition[i], BALL_RADIUS );
       }
     }

   }//------------------------------------------------------




  //------------------------------------------------------
  function updateBallPhysics( i, deltaTime )
   {
    //-----------------------------------------------------------------------
    // gravity
    //-----------------------------------------------------------------------
    ballVelocity[i].addScaledInPlace( UP_DIRECTION, deltaTime * -gravity );

    //-----------------------------------------------------------------------
    // air friction
    //-----------------------------------------------------------------------
    var f = AIR_FRICTION * deltaTime
    if ( f > 1.0 )
     {
      f = 1.0;
     }
    ballVelocity[i].scaleInPlace( 1.0 - f );

    //-----------------------------------------------------------------------
    // update position by velocity
    //-----------------------------------------------------------------------
    ballPosition[i].addInPlace( ballVelocity[i] );

    //-----------------------------------------------------------------------
    // cube collisions
    //-----------------------------------------------------------------------
    updateCubeCollisions( i );

    //-----------------------------------------------------------------------
    // other-ball collisions
    //-----------------------------------------------------------------------
    updateBallCollisions( i );

   }//------------------------------------------------------



  //------------------------------------------------------
  function updateCubeCollisions( i )
   {
    var centerToBall = new Vector3( ballPosition[i] );
    centerToBall.subtractInPlace( cubePosition ); 

    var rightExtent = centerToBall.dot( rotatedRight );
    var upExtent    = centerToBall.dot( rotatedUp    );
    var frontExtent = centerToBall.dot( rotatedFront );

    if ( ballInside[i] )
     {
      var minCollisionLimit = -SPAN + BALL_RADIUS;
      var maxCollisionLimit =  SPAN - BALL_RADIUS;

      if ( rightExtent < minCollisionLimit )
       {
        bounceOffFace( i, rightExtent, rotatedRight, minCollisionLimit );
       }
      else if ( rightExtent > maxCollisionLimit )
       {
        bounceOffFace( i, rightExtent, rotatedRight, maxCollisionLimit );
       }

      if ( upExtent < minCollisionLimit )
       {
        bounceOffFace( i, upExtent, rotatedUp, minCollisionLimit );
       }
      else if ( upExtent > maxCollisionLimit )
       {
        bounceOffFace( i, upExtent, rotatedUp, maxCollisionLimit );
       }


      if ( frontExtent < minCollisionLimit )
       {
        bounceOffFace( i, frontExtent, rotatedFront, minCollisionLimit );
       }
      else if ( frontExtent > maxCollisionLimit )
       {
        bounceOffFace( i, frontExtent, rotatedFront, maxCollisionLimit );
       }
     }

    else
    //-----------------------------------------------------------------------
    // ball is outside! 
    //-----------------------------------------------------------------------
     {
      var minCollisionLimit = -SPAN - BALL_RADIUS;
      var maxCollisionLimit =  SPAN + BALL_RADIUS;

      //---------------------------------------------
      // top
      //---------------------------------------------
      if (( upExtent < SPAN + BALL_RADIUS )
      &&  ( upExtent > SPAN ))
       {
        if (( rightExtent <  SPAN )
        &&  ( rightExtent > -SPAN )
        &&  ( frontExtent <  SPAN )
        &&  ( frontExtent > -SPAN ))
         {
          bounceOffFace( i, upExtent, rotatedUp, maxCollisionLimit );
         }
       }

      //---------------------------------------------
      // bottom
      //---------------------------------------------
      else if (( upExtent > -SPAN - BALL_RADIUS )
      &&  ( upExtent < -SPAN ))
       {
        if (( rightExtent <  SPAN )
        &&  ( rightExtent > -SPAN )
        &&  ( frontExtent <  SPAN )
        &&  ( frontExtent > -SPAN ))
         {
          bounceOffFace( i, upExtent, rotatedUp, minCollisionLimit );
         }
       }



      //---------------------------------------------
      // right
      //---------------------------------------------
      if (( rightExtent < SPAN + BALL_RADIUS )
      &&  ( rightExtent > SPAN ))
       {
        if (( upExtent    <  SPAN )
        &&  ( upExtent    > -SPAN )
        &&  ( frontExtent <  SPAN )
        &&  ( frontExtent > -SPAN ))
         {
          bounceOffFace( i, rightExtent, rotatedRight, maxCollisionLimit );
         }
       }

      //---------------------------------------------
      // left
      //---------------------------------------------
      else if (( rightExtent > -SPAN - BALL_RADIUS )
      &&  ( rightExtent < -SPAN ))
       {
        if (( upExtent    <  SPAN )
        &&  ( upExtent    > -SPAN )
        &&  ( frontExtent <  SPAN )
        &&  ( frontExtent > -SPAN ))
         {
          bounceOffFace( i, rightExtent, rotatedRight, minCollisionLimit );
         }
       }




      //---------------------------------------------
      // front
      //---------------------------------------------
      if (( frontExtent < SPAN + BALL_RADIUS )
      &&  ( frontExtent > SPAN ))
       {
        if (( upExtent    <  SPAN )
        &&  ( upExtent    > -SPAN )
        &&  ( rightExtent <  SPAN )
        &&  ( rightExtent > -SPAN ))
         {
          bounceOffFace( i, frontExtent, rotatedFront, maxCollisionLimit );
         }
       }

      //---------------------------------------------
      // back
      //---------------------------------------------
      else if (( frontExtent > -SPAN - BALL_RADIUS )
      &&  ( frontExtent < -SPAN ))
       {
        if (( upExtent    <  SPAN )
        &&  ( upExtent    > -SPAN )
        &&  ( rightExtent <  SPAN )
        &&  ( rightExtent > -SPAN ))
         {
          bounceOffFace( i, frontExtent, rotatedFront, minCollisionLimit );
         }
       }

     }


   }//------------------------------------------------------







  //-----------------------------------------------------------------
  function bounceOffFace( i, extent, directionVector, limit )
   {
    var componentOfVelocity = ballVelocity[i].dot( directionVector );
    var bounceForce = new Vector3( directionVector );
    bounceForce.scaleInPlace( -( componentOfVelocity + componentOfVelocity * BOUNCE ) );
    ballVelocity[i].addInPlace( bounceForce );
    ballPosition[i].addScaledInPlace( directionVector, ( limit - extent ) );

   }//------------------------------------------------------







  //------------------------------------------------------
  function updateBallCollisions( i )
   {
    for (var o=i+1; o<numBallResourceModels; o++)
     {
      var v = new Vector3();

      v.set( ballPosition[o] );
      v.subtractInPlace( ballPosition[i] );

      var distance = v.length;
      if ( distance < BALL_RADIUS * 2.0 )
       {
        if ( distance > 0.00001 )
         {
          var f = new Vector3();
          f.set( v );
          f.scaleInPlace( 1 / distance );
          f.scaleInPlace( BALL_TO_BALL_COLLISION_FORCE );

          ballVelocity[o].scaleInPlace( 1.0 - BALL_TO_BALL_COLLISION_FRICTION );
          ballVelocity[i].scaleInPlace( 1.0 - BALL_TO_BALL_COLLISION_FRICTION );
          ballVelocity[o].addInPlace     ( f );
          ballVelocity[i].subtractInPlace( f );
         }
       }
     }

   }//------------------------------------------------------





  //------------------------------------------------------
  function showBall( index, position, radius )
   {
    if (( ballResourceAdded )
    &&  ( index < numBallResourceModels ))
     {
      //------------------------------------------------------------
      // set to identity
      //------------------------------------------------------------
      ballResourceModel[ index ].transform.setIdentity();

      //------------------------------------------------------------
      // scale
      //------------------------------------------------------------
      var scaleMatrix = new Matrix4x4();
      scaleMatrix.setIdentity();
      scaleMatrix.scaleInPlace( radius / 10.0, radius / 10.0, radius / 10.0);
      ballResourceModel[ index ].transform.multiplyInPlace( scaleMatrix );

      //------------------------------------------------------------
      // translate
      //------------------------------------------------------------
      var translationMatrix = new Matrix4x4();
      translationMatrix.setIdentity();
      translationMatrix.translateInPlace( position );
      ballResourceModel[ index ].transform.multiplyInPlace( translationMatrix );

     } //if ( ballResourceAdded )

   }//------------------------------------------------------





   //-------------------------------------------------------------------------
   function addStickResource( resourceName, modelFileName, imageFileName, howMany )
    {
     var kindOfResource = "stick";

     success = addResource( resourceName, modelFileName, imageFileName, howMany, kindOfResource );

     if ( success )
      {
       stickResourceAdded = true;
      }

    }//---------------------------------------------------------------------





   //-------------------------------------------------------------------------
   function addSquareResource( resourceName, modelFileName, imageFileName, howMany )
    {
     var kindOfResource = "square";

     success = addResource( resourceName, modelFileName, imageFileName, howMany, kindOfResource );

     if ( success )
      {
       squareResourceAdded = true;
      }

    }//---------------------------------------------------------------------





   //-------------------------------------------------------------------------
   function addBallResource( resourceName, modelFileName, imageFileName, howMany )
    {
     var kindOfResource = "ball";

     success = addResource( resourceName, modelFileName, imageFileName, howMany, kindOfResource );

     if ( success )
      {
       ballResourceAdded = true;
      }

     arrangeBallsOrderlyInCube( howMany );


    }//---------------------------------------------------------------------


   //-------------------------------------------------------------------------
   function dynamicallyAddBall()
    {
     success = addResource( "balls",    "hi_res_sphere.u3d", "blue_gray.jpg", 1, "ball");
     arrangeBallsRandomlyInCube(numBallResourceModels-1, 1);
    }//---------------------------------------------------------------------




   //-------------------------------------------------------------------------
   function arrangeBallsRandomlyInCube( startIndex, howMany )
    {
     for ( var i=startIndex; i<(howMany + startIndex); i++)
      {
       var x = -SPAN + BALL_RADIUS + Math.random() * ( SPAN * 2.0 - BALL_RADIUS );
       var y = -SPAN + BALL_RADIUS + Math.random() * ( SPAN * 2.0 - BALL_RADIUS );
       var z = -SPAN + BALL_RADIUS + Math.random() * ( SPAN * 2.0 - BALL_RADIUS );

       ballPosition[i].set3( x, y, z );
       ballInside  [i] = true;
       ballVelocity[i].set3( 0.0, 0.0, 0.0 );
      }

    }//---------------------------------------------------------------------






   //-------------------------------------------------------------------------
   function arrangeBallsOrderlyInCube( howMany )
    {
     for ( var i=0; i<howMany; i++)
      {
       ballInside  [i] = true;
       ballVelocity[i].set3( 0.0, 0.0, 0.0 );

       


      }

     ballPosition[ 0].set3( -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS );
     ballPosition[ 1].set3( -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS );
     ballPosition[ 2].set3( -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS );
     ballPosition[ 3].set3( -SPAN + BALL_RADIUS * 7, -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS );

     ballPosition[ 4].set3( -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS );
     ballPosition[ 5].set3( -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS );
     ballPosition[ 6].set3( -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS );
     ballPosition[ 7].set3( -SPAN + BALL_RADIUS * 7, -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS );

     ballPosition[ 8].set3( -SPAN + BALL_RADIUS * 1, -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS );
     ballPosition[ 9].set3( -SPAN + BALL_RADIUS * 3, -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS );
     ballPosition[10].set3( -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS );
     ballPosition[11].set3( -SPAN + BALL_RADIUS * 7, -SPAN + BALL_RADIUS * 5, -SPAN + BALL_RADIUS );



    }//---------------------------------------------------------------------




   //-------------------------------------------------------------------------
   function setGravity( g )
    {
     gravity = g;

    }//---------------------------------------------------------------------

   //-------------------------------------------------------------------------
   function resetBalls()
    {
     arrangeBallsOrderlyInCube( numBallResourceModels );

    }//---------------------------------------------------------------------





   //------------------------------------------------------------------------------------------
   function addResource( resourceName, modelFileName, imageFileName, howMany, kindOfResource )
    {
     var success = false;

     if ( verbose ) 
      {
       console.println( " " );
       console.print  ( "* I have been requested to add a resource of kind: '" + kindOfResource + "', called '" + resourceName + "' ");
       console.print  ( "consisting of " + howMany + " copies of the model: '" + modelFileName + "' " );
       console.println( "textured with the image file: '" + imageFileName + "'." );
      }


     var numResourceModels = howMany;

     if ( (numResourceModels + numBallResourceModels) > MAX_RESOURCE_MODELS )
      {
       console.println( " ");
       console.print  ( "Oops - I cannot create more than " + MAX_RESOURCE_MODELS + " resource models. ");
       console.println( "You asked me to create " + howMany + ". I will only generate " + MAX_RESOURCE_MODELS + " of them." );
       numResourceModels = MAX_RESOURCE_MODELS - numBallResourceModels;
      }


     var extendedModelFileName = "pdf://" + modelFileName;
     var extendedImageFileName = "pdf://" + imageFileName;

     var modelResource = new Resource( extendedModelFileName );

     if ( modelResource.valid ) 
      {   
       var position = new Vector3();

       //----------------------------------------------------------------------------------------
       if ( verbose ) console.println( " " );
       if ( verbose ) console.print( "* adding " + numResourceModels + " models..." );

       for (var i=0; i<numResourceModels; i++)
        {
         if ( verbose )
          { 
           console.print( i );
           if ( i < numResourceModels-1 ) console.print( "," );
           else console.println( " " );
          }


         if ( kindOfResource == "stick" )
          {
           stickResourceModel[i] = scene.addModel( modelResource );
          }
         else if ( kindOfResource == "ball" )
          {
           scene.addModel( modelResource );
           ballResourceModel[numBallResourceModels + i] = scene.meshes.getByIndex(scene.meshes.count-1);
          }
         else if ( kindOfResource == "square" )
          {
           squareResourceModel[i] = scene.addModel( modelResource );
          }
         else
          {
           scene.addModel( modelResource );
           ballResourceModel[numBallResourceModels + i] = scene.meshesgetByIndex(scene.meshes.count-1);
          }
 
         success = true;
        }


       if ( kindOfResource == "stick" )
        {
         numStickResourceModels = numResourceModels;
        }
       else if ( kindOfResource == "square" )
        {
         numSquareResourceModels = numResourceModels;
        }
       else if ( kindOfResource == "ball" )
        {
         numBallResourceModels += numResourceModels;
        }
       else
        {
         numBallResourceModels += numResourceModels;
        }


       if ( verbose ) console.println( " " );
       if ( verbose ) console.print( "* adding image resource, '" + imageFileName + "' to each of the model mesh materials... " );
       imageResource = new Resource( extendedImageFileName );
       image = new Image( imageResource );
 
       firstResourceModelIndex = currentNumberOfMeshesInScene; //the number of model parts (IMPORTANT)


       //-----------------------------------------------------------
       for (var i=firstResourceModelIndex; i<scene.meshes.count; i++)
        {
         if ( verbose )
          { 
           console.print( i );
           if ( i < scene.meshes.count-1 ) console.print( "," );
           else console.println( " " );
          }

         theMaterial = scene.meshes.getByIndex(i).material

         if ( theMaterial )
          {
           theMaterial.diffuseTexture.setImage( image );
          }

        }//---------------------------------------------------------
       if ( verbose ) console.println( " " );

     } // if ( modelResource.valid ) 
    else
     {
      if ( verbose ) console.println( " " );
      if ( verbose ) console.print( "* Oops - you have requested to add a model resource but it " );
      if ( verbose ) console.print( "has to be specifically added to the PDF document by " );
      if ( verbose ) console.print( "'Attaching Resource to Selected 3D Annotation'. I cannot" );
      if ( verbose ) console.print( "add this resource until you have done this." );
      if ( verbose ) console.print( "(see Grayson Lang for details)." );
     }

    currentNumberOfMeshesInScene = scene.meshes.count;

    return success;

   }//--------------------------------------------------------


      setBackgroundColor( 1.0, 1.0, 1.0 );
      addStickResource ( "sticks",      "stick.u3d",         "brown.jpg",     12 );
      addBallResource  ( "balls",       "hi_res_sphere.u3d", "blue_gray.jpg", 12 );
      addSquareResource( "background",  "square.u3d",        "clouds.jpg",     1 );


console.println( "* OK, the Javascript 'FloatingBalls.js' was successfully read to the end." );