Lecture 4. Animation: Procedure and Case Studies

Transcription

1 Lecture 4 Animation: Procedure and Case Studies

2 Recall: Representation of 2D entities in OPenGL All the entities are represented using coordinates of the vertices. Therefore, any animation is carried out must be based on the coordinates of the vertices.

3 Procedure i. Describe the situation ii. Represent the situation as OpenGL representation iii. Mathematize the situation using the engineering knowledge iv. Create the pseudo code. This procedure will further clarify the problem prior the actual code writing. Unforeseen problem/s may occur during the actual programming processes.

4 Case I: Simple deflection When the cantilever beam is subjected to load F, the deflection of the beam can be calculated using the following equation, which x is the distance from the wall to specified element. y( x) 2 Fx 6EI ( x 3l) Your task is to animate the physical simulation of the deflection. The color of the elements should be changes according to following condition of the deflection 0 y( x) 1 y x) 1 ( y( x) 2 2 Element color should be Blue (glcolor3f (0,0,1)) Element color should be yellow (glcolor3f(1, 1, 0)) Element color should be red (glcolor3f(1,0,0))

5 Case I: Sliding Collar Figure shows a slider that can move along designated path. When the force is exerted to move the slider, the slider will move to and fro the path without any loss of energy (assumption). Your task is to animate the movement and the user will determine the force exerted.

6 Case I: Sliding Collar i. Describe the situation The slider will travel forward or backward. The direction of the movement will change once the slider hits the wall. The animation will be continuous. ii. Represent the situation as OpenGL representation Wall two straight line (GL_LINE) Slider 4 lines with the end point that connects to the collar will be variable. (only x coordinate) Collar rectangle with 4 vertices that are variables

7 Case I: Sliding Collar iii. Mathematize the situation using the engineering knowledge The collar will travel along the forward and backward. This can be carried out by the changing the x coordinates of the vertices of the color. However, the changing of the x coordinate relies on the direction of the travelling. Therefore flag direction needed and this flag will change its value once the collar hits wall. a. Draw the collar with ( x i + increment, y i ) on all the vertices. b. Set the dir_flag_to_right == 1, increment will be positive c. When the vertices on the right side touches the right wall, the direction of motion will change to left If right_collar_vertices.x >= right_line.x, the dir_to_right will be set to 0 and the increment will be deducted from xi. ( x i - increment, y i ) d. The collar will continue to move to the left until the left side of the collar touches the left wall

8 Case I: Sliding Collar iii. Mathematize the situation using the engineering knowledge d. The collar will continue to move to the left until the left side of the collar touches the left wall. if (left_collar_vertex.x <= left wall.x ) the dir_to_right will be set to 1 and the increment will be deducted from xi. ( x i + increment, y i ) e. The right side silde is drawn by two right from ( right_wall.x, yi ) to (right_collar_vertex.x, yi ) and to left side of the slider is drawn from (left_wall.x, yi ) to (left_collar_vertex.x, yi )

9 Case I: Sliding Collar iv. Create the pseudo code. void myidle() If (dir_to_right == 1) incr_x += 0.001; else incr_x -= 0.001; void display( ) glbegin //draw wall using GL_LINE glend glbegin // draw the collar COLLAR using GL_POLYGON with four vertices (xi + incr+x, yi ) if (collar_right_vertices.x >= right_wall.x ) dir_to_right = 0; glutpostredisplay(); glend if (collar_left_vertices.x <= _left_wall.x ) dir_to_right = 1; glbegin // draw the slide slider on the left from wall_left.x to collar_left.x slider on the righ from collar_right.x TO wall_right.x glend glutswapbuffers();

10 Case II: Simple deflection i. Describe the situation When F is applied on the cantilever beam, the beam will bend and results in bending stresses. The deflection of the beam can be calculated using the given formula. The formula will calculate the deflection as point x. The detail deflection can be calculated by dividing the beam into small segment of dx. dx y(dx)

11 Case II: Simple deflection ii. Represent the situation as OpenGL representation The problem can be represented One line can represent the wall (using GL_LINE) The beam is divided into small segments rectangle. This is because when the deflection is carried out, the translation and the color for each segment can be done individually. The smaller the segments is, the smoother the deflection will be. Entity can be drawing using GL_POLYGON. For each polygon, the vertices will be represented as ( x, y + def[i] ): x and y is set based on the position of the polygon def[i]: variable that can be used for translation of the polygon for animation proposes. Assumption, the deflection is assumed at the center of the polygon 0 1 n (xi, y1 + def[i]) dx (xi + dx, y1 + def[i]) (xi, y2 + def[i]) (xi + dx, y2 + def[i])

12 Case II: Simple deflection iii. Mathematize the situation using the engineering knowledge Firstly, force F must be set either predefined or user input. For each segment i, def[i] is calculated based on the deflection at the center of the polygon. Therefore, the maximum deflection for segment i can be calculated. Set the number iteration needed to complete the animation process, let say L. Therefore for each frame, the increment of the deflection for each segment is def[i]/l. When the animation is carried out, the color of the polygon is based deflection of the segment on that frame. (xi, y1 + def[i]) dx (xi + dx, y1 + def[i]) (xi, y2 + def[i]) (xi + dx, y2 + def[i])

13 Case II: Simple deflection iii. Mathematize the situation using the engineering knowledge a. Calculate the maximum deflection for each segment i def [ i] y( xi 0.5dx) b. Increment for each deflection at segment. inc _ def [ i] def [ i]/ L; if ( inc _ def [ i] def [ i]) inc _ def [ i] def [ i]; c. The polygon can be drawn using the following coordinates of the polygon will be (xi, y1 + inc_def[i]) (xi + dx, y1 + inc_def[i]) (xi, y2 + inc_def[i]) (xi + dx, y2 + inc_def[i])

14 Case II: Simple deflection iv. Mathematize the situation using the engineering knowledge d. Finally, the polygon can colored based on the value of inc_def[i] 0 inc _ def [ i] 1 glcolor3f (0,0,1) 1 inc _ def [ i] 2 glcolor3f (1,1,1) inc _ def [ i] glcolor3f (1,0,0) 2

15 Case II: Simple deflection iv. Create the pseudo code. void display( ) glbegin //draw wall using GL_LINE glend for ( I == 0; I < no_segment ; i++ ) if ( condition to select color )glcolor3f( ); else if ( ) glcolor3f( ); else glbegin // start draw for each segment draw each segment using inc_def[i] variables void myidle() for ( k == 0; k < no_inrement ; k++ ) inc_def[i] += def[i]/no_increment if ( inc_def[i] >= def[i]) inc_def[i] = def[i] glutpostredisplay(); glend glutswapbuffers();

16 Case III: Bouncing ball A ball drops from h height is governed by the following equation. Potential energy at height h = mgh Kinetics energy when the ball reaches the floor = 1/2 m v 2. Therefore v = ( g h ) 0.5 Your task is to animate the physical simulation of the ball dropping until it stops. Assume that 15% of the energy is lost when the ball hits the floor

17 Case III: Bouncing ball i. Describe the situation When the ball is released from height, the speed of the ball increases until it hits the ground. The ball will bounce with the assumption that 15% is lost. Once the ball hits the ground, it will bounce, but can only reach 0.85 of the previous height. The process goes on and the rebound height become smaller. ii. Represent the situation as OpenGL representation The ground can be represented as one line using GL_LINE. The ball is represented using a number of straight lines and the coordinates of the vertices can be calculated using circle equations. The lines can be connected using either GL_LINE_LOOP or GL_POLYGON.

18 Case III: Bouncing ball iii. Mathematize the situation using the engineering knowledge The bouncing of the ball can be animated by varying the y coordinate of the ball using delta time. The ball will be translated downward with delta_y(t) (or negative delta_y(t)) of the y coordinates of the ball.the ball will stop when time is equal is time taken to reach the ground (t_max). Then, the ball will bounce back to the position by delta_y(t) upward until it reached 0.85h. When the ball bounces upward, the delta_y(t) will be 0.85 delta_y(t). The process will continue downward and bounce upward to 0.85 i where i is the number of rebound. The bouncing process can be stop when the bounced height reaches certain height (min_height)

19 Case III: Bouncing ball iii. Mathematize the situation using the engineering knowledge a. The frame is based on the delta_time. Set int no_bounce = 0 b. Calculate the time for the ball to reach ground. t _ max[ no _ bounce] 2(0.85) no_ bounce where r: radius of the ball c. Therefore, for each delta_time (Dt) in upward position delta _ y( Dt) u( Dt) 0.5(9.81)( Dt) where: u = 0 d. The position of the ball will be ( x, y delta_y[dt]) g 2 ( h r) e. When Dt = t_max[], the ball bounces, set no_bounce = no_bounce + 1;

20 Case III: Bouncing ball iii. Mathematize the situation using the engineering knowledge f. The frame is based on the delta_time = 0. b. Calculate the time for the ball to reach ground. t _ max[ no _ bounce] 2(0.85) no_ bounce g ( h r) where r: radius of the ball g. Therefore, for each delta_time (Dt) in downward position delta _ y( Dt) u( Dt) 0.5(9.81)( Dt) 2 where: no_ bounce ( g(0.85 h h. The position of the ball will be ( x, y ( 0.85 no_bounce h -delta_y[dt]) u )) 0.5 i. When Dt = t_max[], the ball reaches the highest point and starts to go downward. Repeat step a h until h_min > (0.85) no_bounce h (Note: flag upward and downward, end_animate are used to differentiate the usage of the formula)

21 Case III: Bouncing ball vi. Create the pseudo code. void display( ) glbegin //draw the floor glend t_max = (setting the value of tmax) if ( downward == 1 && end_animate == 0) delta_y = with u = 0 glbegin draw the vertices of the ball ( x, y delta_y ) glend else ( ward == 1 && end_animate == 0) delta_y = with u!= 0 glbegin draw the vertices of the ball ( x, y (h - r - delta_y ) glend if ( dt >= t_max) //setting all the flags no_bounce = no_bounce + 1; if ( downward == 1) downward = 0; upward = 1; else downward = 1; upward = 0; if ( ball.center.y <= floor.y + rad) no_bounce = no_bounce + 1; if (h_min <= height of bouncing ) end_animate = 1; glutswapbuffers(); void myidle() if ( dt < t_max ) dt += 0.001; else if ( end_animate == 0 ) dt = 0; else dt = t_max; glutpostredisplay();

22 Case IV: Car turning right at T junction (Class discussion) At certain distance from the T junction, a car starts to decelerate and stop at the junction. When it is safe to turn, the car accelerate during taking the turn and finally the car travels at constant speed.