CS 491 -- Fall Quarter 2022

Project #7: Mesh of Springs

Due: December 6

100 Points

Note: You cannot use Bonus Days to extend this due date !

This page was last updated: September 5, 2022

Requirements

You get to create a chain spring mesh (like the example in the notes), where all nodes can move in 2D. Its motion will be like a Slinky dangling from your hand.

I have a wrapper program that will give you the basic program, including sliders to control the X and Y locations of the top node. Other sliders will let you control the spring constant, gravity, mass, and damping. Here it is: Coming soon.

struct state
{
	float  x;
	float vx;
	float  y;
	float vy;
};

struct derivatives
{
	float vx;
	float ax;
	float vy;
	float ay;
};

In the GetDerivs( ) function, fill in the equation for the force on each node, taking into account weights, springs, and damping.

Hints

• The damping at each node is equal to the damping coefficient times each velocity. It acts in a direction opposite to the velocity, and so has a minus sign in front of the multiplication. (In physics, this is called Coulomb Damping.)

• Most of the work takes place in the GetDerivs( ) function.
  1. Node #0 (the top node) has forces on it due to Gravity, Damping, its spring distance from X0,Y0, and its spring distance from Node #1.
  2. Node #1 has forces on it due to Gravity, Damping, its spring distance from Node #0, and its spring distance from Node #2.
  3. Node #2 has forces on it due to Gravity, Damping, its spring distance from Node #1, and its spring distance from Node #3.
  4. ...
  5. The bottom node has forces on it due to Gravity, Damping, and its spring distance from the node above it.

• Animate( ) is this program's "Idle Function". An Idle Function is what gets called when there is nothing else going on (which is most of the time).

• Be sure the lines:

  
  glutSetWindow( MainWindow );
  glutPostRedisplay();
  

  stay at the end of Animate( ). They are what force the graphics system to redraw your scene with the newly-computed values.

• All drawing takes place in the Display( ) function. The basic drawing of the lines in the chain looks like this:

  
  glBegin( GL_LINE_STRIP );
  glVertex2f( X0, Y0 );
  for( int node = 0; node < NUMNODES; node++ )
  {
  	glVertex2f( State[i].x, State[i].y );
  }
  glEnd( );
  

• A lines's width can be changed by inserting the line:

  
  glLineWidth( 2. );
  

  before the call to glBegin( ). size is a floating point number. A size of 1.0 is a single pixel-wide line.

Structure of the GetDerivs( ) Function:

void
GetDerivs( struct state state[NUMNODES], struct derivatives derivs[NUMNODES] )
{
        for( int node = 0; node < NUMNODES; node++ )
        {
                float xm, ym;           // vector from bottom of node #node to preious node
                float xp, yp;           // vector from bottom of node #node to next node

                float sumfx = 0.;
                float sumfy = Mass*Gravity;

                if( node == 0 )  // node #0 is attached to node Y0 by a spring
                {
                        xm = ?????
                        ym = ?????
                }
                else
                {
                        xm = ?????
                        ym = ?????
                }

                float length = sqrtf( xm*xm + ym*ym );          // to normailze the vector
                float stretch = length - LENGTH0;               // amount spring is stretched
                float force = K * stretch;
                sumfx += ?????
                sumfy += ?????

                if( node < NUMNODES-1 )
                {
                        xp = ?????
                        yp = ?????
                        length = sqrtf( xp*xp + yp*yp );
                        stretch = length - LENGTH0;
                        force = K * stretch;
                        sumfx += ?????
                        sumfy += ?????
                }

                float vx = state[node].vx;
                float vy = state[node].vy;
                float v = sqrtf(vx*vx + vy*vy);
                if( v > 0. )
                {
                        force = Cd * v;
                        sumfx -= ?????
                        sumfy -= ?????
                }

                derivs[node].vx = vx;
                derivs[node].ax = sumfx / Mass;
                derivs[node].vy = vy;
                derivs[node].ay = sumfy / Mass;
        }
}

Testing and Debugging

You will definitely need to see if your program is working. Here is the file: Chain2019Wrapper.zip, a graphics wrapper program and all the Visual Studio stuff that goes with it. Just unzip all of this into a separate folder and double click on the .sln file.

Warning #1: This will not compile as-is. There are question marks indicating things you need to fill in.

Warning #2: You might need to tune the key parameters (Mass, K, Cd, Dt) for the speed of the system you are on. (The given values are tuned for my laptop.)

Turn-In

Your electronic turnin will be done at http://engr.oregonstate.edu/teach and will consist of:

1. Your .cpp file.
2. A one-page PDF with a title, your name, your email address, a nice screen shot from your program, and the link to the video demonstrating that your project does what the requirements ask for. If you narrate your video, then you get to tell us what it is doing, and we can grade it more accurately.
   Be sure that your Kaltura video is flagged as unlisted.
   A good way to test this is to ask a friend to try to open the same video link that you are giving us.
3. Leave your PDF file out by itself -- do not place it in any zip files.
4. Be sure your video convinces me that your chain properly responds to:
   • X0 and Y0
   • Changes in Mass
   • Changes in Spring Constant
   • Changes in Damping
   • Changes in Gravity

This is due at 23:59:59 on the listed due date.

Grading