CS-460/560, Assignment # 4
Due Date : 3-15-2010
  
The only difference in the assignment for CS-460 and CS-560 students is in 
Part A. Here CS-460 students will be working with convex polygons, whereas 
CS-560 students will be working with arbitrary (convex or concave) 
polygons.
  
Part A of this assignment is to be an OpenGL program using Microsoft Visual 
C++ (either MFC using wgl or Win32 API using GLUT). Parts B should be an
MFC application that uses the Windows GDI (not OpenGL).
  
  
Part A.
  
In this part of the assignment, using OpenGL in an MFC (wgl approach) or 
Win32 API (GLUT approach) application, you are to implement the scanline 
polygon fill algorithm discussed in class to fill a polygon with a 
two-color pattern defined by the user. For CS-460 students the polygon 
always will always be be convex, but for CS-560 students the program 
should be able to handle both convex and concave polygons. You are to 
implement the algorithm as a Visual C++ function that takes the following 
parameters: the number of vertices in the polygon, the floating point RGB 
values of the two colors to be displayed in the pattern [values between 0 
and 1, to be used in calls to glColor3f()], a 16-element array of 16-bit 
integers (unsigned) that represents the fill pattern to be used, and an
array of x,y coordinates of successive connected vertices of the polygon 
to be filled. To test your fill routine write a short main function that 
defines the following sample polygon:
  
 int vertices[]=(-190,-190,-20,10,70,-170,100,100,130,-110,220,10,320,-80,
                  320,40,220,100,340,220,70,220,-50,250,-150,110);
                  // CS-560
  
 int vertices[]={-100,50,50,150,130,20,130,-100,60,-190,-50,-190,-150,-100};
                  // CS-460
  
and the following fill pattern:
  
 unsigned pat[]={0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,0x00ff,
                  0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00,0xff00};
  
Here each bit of each element of the pat[] array determines whether the
corresponding pixel inside a 16 X 16 area of the screen is set to the
first RGB value (bit=0) or to that of the second RGB value (bit=1). In other
words, each element defines a row in the pattern matrix, and the value of
each bit in a given element determines which of the two colors the
corresponding pixel in that row will have. If, for example, the two RGB 
values corresponded to red (bit=0 ==> R=1.0, G=0.0, B=0.0) and blue 
(bit=1 ==> R=0.0, G=0.0, B=1.0), in the pattern given above, then the first 
row would have its pixels set as rrrrrrrrbbbbbbbb (r means red, b means 
blue). Thus, when tiled over a polygon, the pattern given above will form 
a checkerboard in which each square is 8 pixels wide and 8 pixels high.
  
The program should call your fill function to perform the patterned area
fill. For example, if we wanted the polygon defined above to be filled
with a red/blue checkerboard pattern (i.e., using the pattern defined
above), the code might be something like the following:
  
   fill(13, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, pat, vertices);  // CS-560
   // 13 vertices, Red (1.0,0.0,0.0), Blue (0.0,0.0,1.0)
  
   fill(6, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, pat, vertices);  // CS-560
   // 6 vertices, Red (1.0,0.0,0.0), Blue (0.0,0.0,1.0)   
  
Your program should define at least one other different polygon and fill
pattern and call the fill function to fill that polygon with the new
pattern.
  
You are to set up your pattern fill in such a way that the pattern
is not "anchored" to a fixed point (e.g., 0,0) on the screen), but
instead to one of the polygon's vertices. Demonstrate that this works by
redrawing and refilling the same polygon translated by some distance that
is not an integral multiple of 16. You should observe that the pattern
"moves with" the polygon.
  
  
Part B.
  
You are to implement a scanline ellipse fill algorithm that will fill
an arbitrary ellipse (oriented along the screen axes) with a pattern
defined by the user. The technique to be used will be a modification of
the scanline polygon fill algorithm discussed in class. The main
difference will be that in moving from one scanline to the next, the
intersection points with the scanline must lie on the arc of the
ellipse. These points can be determined incrementally as in the
midpoint ellipse algorithm discussed in class and that you implemented 
in your last programming assignment.
  
The same pattern-definition scheme is to be used here as in Part A.
  
Your implementation should be a function that takes the following parameters: 
the x,y coordinates of the center of the ellipse, the semimajor and semiminor 
axes (xr, yr), the colors to be used in the pattern, and the fill pattern 
array:
  
   COLORREF r,b;
   r=RGB(255,0,0); g=RGB(0,0,255);
   fillellipse (xcenter, ycenter, xr, yr, r, b, pat);
  
You should include several other calls to fillellipse() using other ellipses 
and at least one other fill pattern.