CS4390 Fall '98
Programming Assignment 2:
Scan Conversion and Transformations

Due: 
	Friday October 23

Purpose:
	In this program, you will demonstrate your ability to implement
	line, circle, and ellipse scan conversion algorithms, and to
	perform 2D transformations on these primitives.

Task:
	Write a program that renders the specified line, circle, or
	ellipse in a 300x300 interface window, then prompts the user to enter
	transformations to be executed on the object. The program will
	read in an input file (specified on the command line) that will
	denote the type of object, its color, and its position and size.
	YOU MAY NOT USE ANY HIGH-LEVEL OPENGL FUNCTIONALITY ON THIS
	PROGRAM. SEE BELOW. Circles and ellipses need only be rendered as 
	an outline, not as a filled primitive.

Input file format:
	The input file will consist of several components, which will
	be read in by code provided to you in the file 
	~cs4390/project1/read_input.c.

	-the first line denotes the type of object: 1=line, 2=circle, 3=ellipse
	-the next line denotes the object color: r g b (floating point)
	-for a line, there will be 2 more lines giving the endpoints
	-for a circle, there will be 2 more lines giving the center and radius
	-for an ellipse, there will be 3 more lines giving the center,
	major radius, and minor radius.

What's given to you:
	All of these files are in ~cs4390/project2.

	The file read_input.c has a routine to read the input file.

	The provided Makefile will compile everything together if
	your program is called transform.c

	The file transform.h defines circle, line, and ellipse data types.

	The file transform.c is a simple main program that illustrates
	how to call the function to read the input file.  It just
	prints out information about the object in the file.

	Sample input files will be given in ~cs4390/project2/input/.

	Your program should call the function "readObjectFile"
	with the name of the input file and pointers to a line, 
	a circle, and an ellipse data type (defined in the file transform.h). 
	This function will read the input file and return an integer
	specifying the type of object.  The appropriate
	data structure will be filled in with the
	values from the input file.  This is to make your life easier!

	Be sure to include transform.h in your C file.

Transformations:
	Your program should prompt the user for a transformation on
	the command line after the initial drawing of the polygon, and
	after each successive transformation. It should read in and
	execute the following:

	-translations ("t <x-trans> <y-trans>"): translate the object
	by x-trans and y-trans in world coordinates
	-rotations ("r <degrees>"): rotate the line by degrees with
	the first endpoint as a fixed point (rotations do not apply to
	circles or ellipses)
	-scales ("s <x-scale> <y-scale"): scale a circle or ellipse, with 
	its center as a fixed point, or stretch a line (so that its 
	orientation remains constant) with the first endpoint as a fixed 
	point (note that a circle scaled non-uniformly becomes an
	ellipse!)

	The program should not execute the transformations until the user
	enters the 'e' (execute) command. It should then compose all of
	the transformations since the last 'e' and execute them all together.
	The program should be able to handle up to 5 composed transformations.

	The program should exit when 'q' is entered on the command line.

Use of openGL:
	Your program may not use any high-level openGL routines, for
	example to draw a line between 2 endpoints or to draw a circle
	as a many-sided polygon.  Rather, you must write the scan
	conversion algorithms yourself.  The only openGL rendering calls
	that may be made are drawing GL_POINTS, setting colors, and setting
	up the window.

Turn in:
	Your program should consist of a single file which should be commented
	with your name and any instructions needed for compiling and running
	your program.  This should be emailed as ASCII text to
	cs4390@cc.gatech.edu.  The time the mail is received will be used to
	determine whether or not the program is late, so be sure to allow a
	couple of minutes for the mail system to transmit your file if you
	are working right up to the deadline.  If necessary to send multiple
	files, tar them and then uuencode the results before mailing.  (Using
	MIME attachments to turn in files will make the grader VERY crabby
	and result in much tougher program grading!)

	DO NOT TURN IN THE FILE read_input.c unless you have made major
	modifications to it!

	To tar files together, cd to the directory where the files to tar are,
	and type

		tar cvf ../foobar.tar .

	This will collect all files in the current directory and any
	subdirectories and dump them into a file called foobar.tar in
	the parent directory.
	Next, uuencode everything with the command

		uuencode foobar.tar foobar.tar > foobar.uue

	Finally mail this file to cs4390 using the command

		mail cs4390@cc your_acct@cc <foobar.uue

	Note that to simply send one ASCII file this works also:

		mail cs4390@cc your_acct@cc <mycode.c

Due date:
	This program is due on or before Friday, October 23.  This means it must
	be received by 11:59pm EDT on Friday to not be considered late.

Additional Instructions:
	The comments at the start of the program should contain details of how
	to compile and run it.  If possible, please just use the sample
	Makefile (assume that the name sample.c will be changed to be the
	file containing your source).

Getting started:
	As always, the GLUT libraries, documentation, and sample programs can
	be found in ~cs4390/GLUT.  A sample Makefile and main program can be
	found in ~cs4390/sample.

Extra Credit:
	Extra credit will be given for a filled circle or ellipse rendering 
	rather than an outline, for an implementation of rotations on
	ellipses, or for other creative enhancements.

Additional information:
  In assignment 2, ellipses are specified by a center, a major radius, and a
  minor radius.  Here's what is meant by that:

  The center is obviously the center point of the ellipse.  The major radius
  is the distance from the center to the edge of the ellipse along the x-axis.
  The minor radius is the distance from the center to the edge of the ellipse
  along the y-axis.  Thus, our ellipses will always be orthogonal to the x-y
  coordinate system.  You are not required to implement rotations of ellipses
  (but should print an appropriate error message if the user tries to do this).