/*
* set the actor shape to the module and assign defaults to other attributes
*/
void actor_init(Actor *a, Leader *boss, Module* shape){
a->dispersion = 0.5;
a->minDist = 4;
a->thresholdDist = 6;
a->id = 0;
point_set3D(&(a->location), 0.0, 0.0, 0.0);
a->boss = boss;
a->shape = shape;
}
void view_rotate_circle(Polygon* poly_vrp, Point* center, int sides, double scale, double thetax, double thetay, double thetaz){
if(NULL != poly_vrp){
//make a unit circle of "sides" number fo sides and store the points in the poly_vrp
int i;
double x, z;
polygon_init(poly_vrp);
Point p[sides];
Matrix LTM;
matrix_identity(<M);
matrix_scale(<M, scale, scale, scale);
matrix_rotateX(<M, cos(thetax*M_PI/180), sin(thetax*M_PI/180));
matrix_rotateY(<M, cos(thetay*M_PI/180), sin(thetay*M_PI/180));
matrix_rotateZ(<M, cos(thetaz*M_PI/180), sin(thetaz*M_PI/180));
matrix_translate(<M, center->val[0], center->val[1], center->val[2]);
for(i=0; i<sides; i++){
x = cos( i * M_PI * 2.0 / sides );
z = sin( i * M_PI * 2.0 / sides );
point_set3D(&p[i], x, 0.1, z);
}
polygon_set(poly_vrp, sides, &p[0]);
matrix_xformPolygon(<M, poly_vrp);
}
}
int main(int argc, char *argv[]) {
const int rows = 1000;
const int cols = 1000;
View3D view;
Matrix vtm;
Polygon side[4];
Polygon tpoly;
Point tv[3];
Point v[4];
Color color[4];
Image *src;
char filename[100];
double x;
int i;
// set some colors
Color_set( &color[0], 0, 0, 1 );
Color_set( &color[1], 0, 1, 0 );
Color_set( &color[2], 1, 0, 0 );
Color_set( &color[3], 1, 0, 1 );
// initialize polygons
for(i=0;i<4;i++) {
polygon_init( &side[i] );
}
// corners of a cube, centered at (0, 0, 0)
point_set3D( &v[0], 0, 1, 0 );
point_set3D( &v[1], 1, -1, 0);
point_set3D( &v[2], -1, -1, 0 );
point_set3D( &v[3], 0, 0, 1 );
//base of the pyramid
polygon_set(&side[3], 3, &(v[0]));
//side1
point_copy(&tv[0], &v[0]);
point_copy(&tv[1], &v[2]);
point_copy(&tv[2], &v[3]);
polygon_set(&side[0], 3, tv);
//side2
point_copy(&tv[0], &v[0]);
point_copy(&tv[1], &v[1]);
point_copy(&tv[2], &v[3]);
polygon_set(&side[1], 3, tv);
//side3
point_copy(&tv[0], &v[1]);
point_copy(&tv[1], &v[2]);
point_copy(&tv[2], &v[3]);
polygon_set(&side[2], 3, tv);
point_set3D( &(view.vrp), 1, 0, 0);
vector_set( &(view.vpn), -view.vrp.val[0], -view.vrp.val[1], -view.vrp.val[2] );
vector_set( &(view.vup), 0, 0, 1 );
view.d = 1; // focal length
view.du = 2;
view.dv = view.du * (float)rows / cols;
view.f = 0; // front clip plane
view.b = 4; // back clip plane
view.screenx = cols;
view.screeny = rows;
matrix_setView3D( &vtm, &view );
// use a temprary polygon to transform stuff
polygon_init( &tpoly );
printf("Drawing pyramid\n");
x = -2;
int j;
for (j=0; j<50; j++){
// create image
src = image_create( rows, cols );
point_set3D(&(view.vrp), x , 2, 0.5);
vector_set( &(view.vpn), -x, -2, -0.5);
matrix_setView3D(&vtm, &view);
i=0;
for(i=0;i<4;i++) {
polygon_copy( &tpoly, &side[i] );
matrix_xformPolygon( &vtm, &tpoly );
// normalize by homogeneous coordinate before drawing
polygon_normalize( &tpoly );
polygon_draw( &tpoly, src, color[i] );
//polygon_print( &tpoly, stdout );
}
printf("Writing image\n");
sprintf(filename, "pyramid_%04d.ppm", j);
image_write( src, filename);
free(src);
if(j<25){
x += 0.08;
}else{
x -= 0.08;
}
}
printf("Making the .gif file...\n");
system("convert -delay 10 pyramid_*.ppm ../images/ext1.gif");
system("rm -f pyramid*");
return(0);
}
/*
* set the actor location
*/
void actor_setLocation(Actor *a, float x, float y, float z){
point_set3D(&(a->location), x, y, z);
}
/*
* set the leader location
*/
void leader_setLocation(Leader *l, float x, float y, float z){
point_set3D(&(l->location), x, y, z);
}
int main( int argc, char *argv[]){
//set up the images
Image *src;
Image *myImage;
//set up the modules!!
Module *basket;
Module *connector;
Module *connector1;
Line l;
Point pts[2];
Module *circle;
Module *hotAirBalloon;
Module *teamOfBalloons;
Module *scene;
//pick the colors
Color colors[6];
Color brown;
Color blue;
Color green;
Color grey;
//set up view stuff, and image file stuff
Matrix vtm, gtm;
int rows;
int cols;
View3D view;
DrawState *ds;
char filename[256];
int i, j, k, m, n;
//Set the colors up
color_set(&brown, 0.2, 0.1, 0.0);
color_set(&blue, 0.6, 0.8, 1.0);
color_set(&green, 0.1, 0.4, 0.0);
color_set(&grey, 0.3, 0.3, 0.3);
color_set(&colors[0], 1.0, 0.0, 0.0);//Red
color_set(&colors[1],1.0, 0.5, 0.0);//orange
color_set(&colors[2],1.0, 1.0, 0.1);//yellow
color_set(&colors[3], 0.0, 1.0, 0.0);//green
color_set(&colors[4], 0.0, 0.0, 1.0);//blue
color_set(&colors[5], 0.4, 0.0, 0.8);//purple
//if you want to supply a background image you can, otherwise I set a default sky blue background!
if(argc>1){
printf("you supplied an image\n");
myImage = image_read(argv[1]);
rows = myImage->rows;
cols = myImage->cols;
printf("%d %d\n", rows, cols);
}else{
printf("We are giving your image a default size!\n");
rows = 500;
cols = 500;
myImage = image_create(rows, cols);
for(m = 0; m< rows; m++){
for(n = 0; n<cols; n++){
image_setColor(myImage, m, n, blue);
}
}
}
//Loop over the scene 300 times moving the scene around!!
for(k = 0; k<300; k++){
//Set up the view
point_set( &(view.vrp), 150, 100, 200, 1.0);
vector_set( &(view.vpn), -view.vrp.val[0], -view.vrp.val[1], -view.vrp.val[2]);
vector_set( &(view.vup), 0, 1.0, 0);
view.d = 20;
view.du = 10;
view.dv = view.du* (float)rows/cols;
view.f = 0;
view.b = 5;
view.screenx = rows;
view.screeny = cols;
matrix_setView3D( &vtm, &view);
matrix_identity( >m );
// basket: cube (will need 1 in hot air balloon module)
basket = module_create();
module_color(basket, &brown);
module_cube(basket, 1);
//connectors: lines need 4
connector = module_create();
point_set3D(&pts[0],1,1,1 );
point_set3D(&pts[1],2,4.2,1);
line_set(&l, pts[0], pts[1]);
module_line(connector, &l);
connector1 = module_create();
point_set3D(&pts[0], 1,1 , 1);
point_set3D(&pts[1], 0,4.2 ,1 );
line_set(&l, pts[0], pts[1]);
module_line(connector1, &l);
// balloon: circles nested on top of eachother
circle = module_create();
module_color(circle, &colors[0]);
module_rotateX(circle, 0, 1);
module_translate2D(circle, 0, 3);
module_circle(circle, 1);
module_color(circle, &colors[1]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 2.5);
module_color(circle, &colors[2]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 3);
module_color(circle, &colors[3]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 4);
module_color(circle, &colors[4]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 5);
module_color(circle, &colors[5]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 6);
module_color(circle, &colors[0]);
module_rotateX(circle, 1,0);
module_translate2D(circle, 0, 1);
module_circle(circle, 7);
module_color(circle, &colors[1]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 7);
module_color(circle, &colors[2]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0,1);
module_circle(circle, 7);
module_color(circle, &colors[3]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 7);
module_color(circle, &colors[4]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 6);
module_color(circle, &colors[5]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 5);
module_color(circle, &colors[0]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 1);
module_circle(circle, 4);
module_color(circle, &colors[1]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 0.5);
module_circle(circle, 3);
module_color(circle, &colors[2]);
module_rotateX(circle, 1, 0);
module_translate2D(circle, 0, 0.5);
module_circle(circle, 2);
//hotAirBalloon: put the above parts together
hotAirBalloon = module_create();
module_module(hotAirBalloon, basket);
module_module(hotAirBalloon, connector);
module_translate(hotAirBalloon, -2,0 ,0 );
module_module(hotAirBalloon, connector1);
module_translate(hotAirBalloon, 0, 0, -2);
module_module(hotAirBalloon, connector1);
module_translate(hotAirBalloon, 2, 0, 0);
module_module(hotAirBalloon, connector);
module_module(hotAirBalloon, circle);
//make a team of balloons
teamOfBalloons = module_create();
module_translate(teamOfBalloons, 0,-30,-15);
module_module(teamOfBalloons, hotAirBalloon);
module_translate(teamOfBalloons, 0, 0+(k*0.1),15);
module_module(teamOfBalloons, hotAirBalloon);
module_translate(teamOfBalloons, 0, 0+(k*0.1),15);
module_module(teamOfBalloons, hotAirBalloon);
//make a scene of balloons
scene = module_create();
module_translate(scene, -40, 10+(k*0.1), 10);
module_module(scene, teamOfBalloons);
module_translate(scene, 140, 10, 55);
module_module(scene, teamOfBalloons);
module_translate(scene, -50, 10+(k*0.1), -40);
module_module(scene, teamOfBalloons);
module_translate(scene, 30, 10+(k*0.2) , -55);
module_module(scene, teamOfBalloons);
//set up the image
src = image_create(rows, cols);
//Either draw the background image you supplied or use my default background
for (i = 0; i<rows; i++){
for (j = 0; j<cols; j++){
blue = image_getColor(myImage, i, j);
image_setColor(src,i, j, blue);
}
}
//set up the draw state if you want filled polygons need to use ShadeConstant instead of ShadeFrame
ds = drawstate_create();
ds->shade = ShadeFrame;
//draw the modules!
module_draw( scene, &vtm, >m, ds, NULL, src);
//put the files in the right place with the right name!!
sprintf(filename, "/export/home/vedwards/Desktop/Graphics/images/hotAirBalloons3/frame-%04d.ppm", k );
printf("Writing image\n");
image_write( src, filename );
}
//Clean up, delete all of the modules, images, and drawState
module_delete(basket);
module_delete(connector);
module_delete(connector1);
module_delete(circle);
module_delete(hotAirBalloon);
module_delete(teamOfBalloons);
free(ds);
image_free( src );
image_free( myImage );
return(0);
}
/*
* set the leader shape to the module and assign defaults to other attributes
*/
void leader_init(Leader *l, Module* shape){
point_set3D(&(l->location), 0.0, 0.0, 0.0);
vector_set(&(l->velocity), 0.0, 0.0, 0.0);
l->shape = shape;
}
/*
* Sourced from coursework file test6b.c (Bruce Maxwell)
*/
void module_cone( Module *mod, int sides, int fill, int size, float x, float y, float z) {
Polygon p;
Point xtop, xbot;
Element *e;
Line l;
double x1, x2, z1, z2;
int i;
if(!mod){
printf("Null md passed to module_cylinder\n");
return;
}
// set cone parameters
module_scale(mod, (int)size, (int)size, (int)size);
module_translate(mod, (float)x, (float)y, (float)z);
printf("parameters set\n");
polygon_init( &p );
point_set3D( &xtop, 0, 1.0, 0.0 );
point_set3D( &xbot, 0, 0.0, 0.0 );
if (fill == 1){
// make a fan for the top and bottom sides
// and quadrilaterals for the sides
for(i=0;i<sides;i++) {
Point pt[6];
x1 = cos( i * M_PI * 2.0 / sides );
z1 = sin( i * M_PI * 2.0 / sides );
x2 = cos( ( (i+1)%sides ) * M_PI * 2.0 / sides );
z2 = sin( ( (i+1)%sides ) * M_PI * 2.0 / sides );
point_copy( &pt[0], &xbot );
point_set3D( &pt[1], x1, 0.0, z1 );
point_set3D( &pt[2], x2, 0.0, z2 );
polygon_set( &p, 3, pt );
e = element_init(ObjPolygon, &p);
module_insert(mod, e);
point_set3D( &pt[3], x1, 0.0, z1 );
point_set3D( &pt[4], x2, 0.0, z2 );
point_copy( &pt[5], &xtop);
polygon_set( &p, 3, &pt[3] );
e = element_init(ObjPolygon, &p);
module_insert(mod, e);
}
} else{
// make a fan for the top and bottom sides
// and quadrilaterals for the sides
for(i=0;i<sides;i++) {
Point pt[8];
x1 = cos( i * M_PI * 2.0 / sides );
z1 = sin( i * M_PI * 2.0 / sides );
x2 = cos( ( (i+1)%sides ) * M_PI * 2.0 / sides );
z2 = sin( ( (i+1)%sides ) * M_PI * 2.0 / sides );
point_copy( &pt[0], &xbot );
point_set3D( &pt[1], x1, 0.0, z1 );
point_set3D( &pt[2], x2, 0.0, z2 );
line_set( &l, pt[0], pt[1] );
e = element_init(ObjLine, &l);
module_insert(mod, e);
line_set( &l, pt[1], pt[2] );
e = element_init(ObjLine, &l);
module_insert(mod, e);
line_set( &l, pt[2], pt[0]);
e = element_init(ObjLine, &l);
module_insert(mod, e);
point_set3D( &pt[3], x1, 0.0, z1 );
point_set3D( &pt[4], x2, 0.0, z2 );
point_set3D( &pt[5], x2, 1.0, z2 );
point_set3D( &pt[6], x1, 1.0, z1 );
point_copy( &pt[7], &xtop);
line_set( &l, pt[0], pt[7] );
e = element_init(ObjLine, &l);
module_insert(mod, e);
line_set( &l, pt[1], pt[7] );
e = element_init(ObjLine, &l);
module_insert(mod, e);
line_set( &l, pt[2], pt[7]);
e = element_init(ObjLine, &l);
module_insert(mod, e);
line_set( &l, pt[3], pt[7]);
e = element_init(ObjLine, &l);
module_insert(mod, e);
}
}
polygon_clear( &p );
}
int main(int argc, char *argv[]) {
int frame;
Color blue, green, purple, red, white;
Point p[16];
BezierSurface bc;
DrawState ds;
Module *curve;
View3D view;
Matrix VTM, GTM;
int divisions = 4;
int rows = 300, cols = 400;
Image *src = image_create(rows, cols);
// grab the command line argument, if one exists
if(argc > 1) {
int tmp = atoi(argv[1]);
if( tmp >= 0 && tmp < 10 )
divisions = tmp;
}
printf("Creating Bezier surface with %d subdivisions\n", divisions);
color_set(&white, 1.0, 1.0, 1.0 );
color_set(&blue, .1, .2, .8);
color_set(&green, .2, 0.7, 0.3 );
color_set(&purple, 0.6, 0.1, 0.7 );
color_set(&red, 0.75, 0.3, 0.3 );
curve = module_create();
// create a flat plane
point_set3D(&p[0], 0.0, -0.2, 0.0); // first row, constant x, even spacing in z
point_set3D(&p[1], 0.0, -0.2, 0.33);
point_set3D(&p[2], 0.0, -0.2, 0.66);
point_set3D(&p[3], 0.0, -0.2, 1.0);
point_set3D(&p[4], 0.33, -0.2, 0.0); // second row
point_set3D(&p[5], 0.33, -0.2, 0.33);
point_set3D(&p[6], 0.33, -0.2, 0.66);
point_set3D(&p[7], 0.33, -0.2, 1.0);
point_set3D(&p[8], 0.66, -0.2, 0.0); // third row
point_set3D(&p[9], 0.66, -0.2, 0.33);
point_set3D(&p[10], 0.66, -0.2, 0.66);
point_set3D(&p[11], 0.66, -0.2, 1.0);
point_set3D(&p[12], 1.0, -0.2, 0.0); // fourth row
point_set3D(&p[13], 1.0, -0.2, 0.33);
point_set3D(&p[14], 1.0, -0.2, 0.66);
point_set3D(&p[15], 1.0, -0.2, 1.0);
bezierSurface_set(&bc, p);
// put the curve into a module
module_color(curve, &red);
module_bezierSurface(curve, &bc, divisions, 0);
// create a curved surface sitting above the plane
point_set3D(&p[0], 0.0, 0.0, 0.0); // first row, constant x, even spacing in z
point_set3D(&p[1], 0.0, 0.2, 0.33);
point_set3D(&p[2], 0.0, 0.5, 0.66);
point_set3D(&p[3], 0.0, 0.1, 1.0);
point_set3D(&p[4], 0.33, 0.8, 0.0); // second row
point_set3D(&p[5], 0.33, -0.1, 0.33);
point_set3D(&p[6], 0.33, 0.0, 0.66);
point_set3D(&p[7], 0.33, 0.3, 1.0);
point_set3D(&p[8], 0.66, 0.3, 0.0); // third row
point_set3D(&p[9], 0.66, 0.8, 0.33);
point_set3D(&p[10], 0.66, 0.9, 0.66);
point_set3D(&p[11], 0.66, 0.5, 1.0);
point_set3D(&p[12], 1.0, 0.4, 0.0); // fourth row
point_set3D(&p[13], 1.0, 0.2, 0.33);
point_set3D(&p[14], 1.0, 0.5, 0.66);
point_set3D(&p[15], 1.0, 1.0, 1.0);
bezierSurface_set(&bc, p);
// put the curve into a module
module_color(curve, &green);
module_bezierSurface(curve, &bc, divisions, 1);
// set up the drawstate
drawstate_setColor(&ds, white);
ds.shade = ShadeFrame;
// set up the view
point_set3D(&(view.vrp), 0.0, 1.2, -3.0 );
vector_set( &(view.vpn), 0.0, -0.8, 2.5 );
vector_set( &(view.vup), 0.0, 1.0, 0.0 );
view.d = 1.5;
view.du = 1.0;
view.dv = 1.0*rows/cols;
view.screeny = rows;
view.screenx = cols;
view.f = 0.0;
view.b = 3.0;
matrix_setView3D( &VTM, &view );
matrix_identity( >M );
// Create the animation by adjusting the GTM
for(frame=0;frame<60;frame++) {
char buffer[256];
matrix_rotateY(>M, cos(M_PI/30.0), sin(M_PI/30.0) );
module_draw( curve, &VTM, >M, &ds, NULL, src );
sprintf(buffer, "bezSurf-frame%03d.ppm", frame);
image_write(src, buffer);
image_reset(src);
}
printf("converting to gif...\n");
system("convert -delay 1.5 -loop 0 bezSurf-frame*.ppm bezSurf.gif");
system("rm bezSurf-frame*.ppm");
// clean up
image_free( src );
module_delete( curve );
return(0);
}
/*
* insert a pyramid into the module
*/
void module_pyramid(Module *md, int solid, float size, float x, float y, float z){
if(!md){
printf("Null md passed to module_pyramid\n");
return;
}
Polygon side;
Point tv[3];
Point v[5];
Line l;
Element *e;
int i;
polygon_init(&side);
// corners of the pyramid
point_set3D(&v[0], -1, -1, -1 );
point_set3D(&v[1], 1, -1, -1 );
point_set3D(&v[2], 1, -1, 1 );
point_set3D(&v[3], -1, -1, 1 );
point_set3D(&v[4], 0, 0, 0);
//printf("points created\n");
// set pyramid parameters
module_scale(md, (int)size, (int)size, (int)size);
module_translate(md, (float)x, (float)y, (float)z);
//printf("parameters set\n");
if (solid == 0){
// add only lines
// foundation
for(i=0;i<3;i++){
line_set( &l, v[i], v[i+1] );
e = element_init(ObjLine, &l);
module_insert(md, e);
}
line_set( &l, v[3], v[0] );
e = element_init(ObjLine, &l);
module_insert(md, e);
// connecting lines
line_set( &l, v[4], v[0] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[1], v[4] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[2], v[4] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[3], v[4] );
e = element_init(ObjLine, &l);
module_insert(md, e);
//printf("successfully passed to module\n");
} else{
// front side
point_copy(&tv[0], &v[0]);
point_copy(&tv[1], &v[1]);
point_copy(&tv[2], &v[4]);
polygon_set(&side, 3, tv);
e = element_init(ObjPolygon, &side);
module_insert(md, e);
// back side
point_copy(&tv[0], &v[3]);
point_copy(&tv[1], &v[2]);
point_copy(&tv[2], &v[4]);
polygon_set(&side, 3, tv);
e = element_init(ObjPolygon, &side);
module_insert(md, e);
// bottom side
polygon_set(&side, 4, &(v[0]));
e = element_init(ObjPolygon, &side);
module_insert(md, e);
// left side
point_copy(&tv[0], &v[0]);
point_copy(&tv[1], &v[3]);
point_copy(&tv[2], &v[4]);
polygon_set(&side, 3, tv);
e = element_init(ObjPolygon, &side);
module_insert(md, e);
// right side
point_copy(&tv[0], &v[1]);
point_copy(&tv[1], &v[2]);
point_copy(&tv[2], &v[4]);
polygon_set(&side, 3, tv);
e = element_init(ObjPolygon, &side);
module_insert(md, e);
//printf("successfully passed to module\n");
}
polygon_clear(&side);
}
/*
* Adds a unit cube, axis-aligned and centered on zero to the Module.
* If solid is zero, add only lines. If solid is non-zero, use polygons.
* Make sure each polygon has surface normals defined for it.
*/
void module_cube(Module *md, int solid){
if(!md){
printf("Null md passed to module_cube\n");
return;
}
Element *e;
Polygon p;
Point v[8];
Point tv[4];
Line l;
int i;
// initialize polygon
polygon_init( &p );
// corners of a cube, centered at (0, 0, 0)
point_set3D( &v[0], -0.5, -0.5, -0.5 );
point_set3D( &v[1], 0.5, -0.5, -0.5 );
point_set3D( &v[2], 0.5, 0.5, -0.5 );
point_set3D( &v[3], -0.5, 0.5, -0.5 );
point_set3D( &v[4], -0.5, -0.5, 0.5 );
point_set3D( &v[5], 0.5, -0.5, 0.5 );
point_set3D( &v[6], 0.5, 0.5, 0.5 );
point_set3D( &v[7], -0.5, 0.5, 0.5 );
if(solid == 0){
// add only lines ( 12 of them )
// front face lines
for(i=0;i<3;i++){
line_set( &l, v[i], v[i+1] );
e = element_init(ObjLine, &l);
module_insert(md, e);
}
line_set( &l, v[3], v[0] );
e = element_init(ObjLine, &l);
module_insert(md, e);
// back face lines
for(i=4;i<7;i++){
line_set( &l, v[i], v[i+1] );
e = element_init(ObjLine, &l);
module_insert(md, e);
}
line_set( &l, v[7], v[4] );
e = element_init(ObjLine, &l);
module_insert(md, e);
// connecting lines
line_set( &l, v[2], v[6] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[3], v[7] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[0], v[4] );
e = element_init(ObjLine, &l);
module_insert(md, e);
line_set( &l, v[1], v[5] );
e = element_init(ObjLine, &l);
module_insert(md, e);
}
else{
// use polygons ( 6 of them )
// front side
polygon_set( &p, 4, &(v[0]) );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
// back side
polygon_set( &p, 4, &(v[4]) );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
// top side
point_copy( &tv[0], &v[2] );
point_copy( &tv[1], &v[3] );
point_copy( &tv[2], &v[7] );
point_copy( &tv[3], &v[6] );
polygon_set( &p, 4, tv );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
// bottom side
point_copy( &tv[0], &v[0] );
point_copy( &tv[1], &v[1] );
point_copy( &tv[2], &v[5] );
point_copy( &tv[3], &v[4] );
polygon_set( &p, 4, tv );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
// left side
point_copy( &tv[0], &v[0] );
point_copy( &tv[1], &v[3] );
point_copy( &tv[2], &v[7] );
point_copy( &tv[3], &v[4] );
polygon_set( &p, 4, tv );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
// right side
point_copy( &tv[0], &v[1] );
point_copy( &tv[1], &v[2] );
point_copy( &tv[2], &v[6] );
point_copy( &tv[3], &v[5] );
polygon_set( &p, 4, tv );
e = element_init(ObjPolygon, &p);
module_insert(md, e);
}
// clean up
polygon_clear(&p);
}
// makes 3 X-wing fighters in a loose formation
int main(int argc, char *argv[]) {
int i, j; //loop variables
Image *src;
Module* wall;
Module* ray;
Module* ray2;
Module *scene1;
Module* scene2;
Polygon p;
Line l;
Point point[4];
Point point2[2];
View3D view;
Matrix vtm, gtm;
DrawState *ds;
char filename[100];
Color Flame = { { 1.0, 0.7, 0.2 } };
Color Red = { { 1.0, 0.2, 0.1 } };
Color Grey = { { 0.745, 0.745, 0.745} };
Color Blue = {{0.117647, 0.564706, 1}};
// Color Grey = {{1, 1, 1}};
// set up the view
point_set3D( &(view.vrp), 4, 4, 4 );
vector_set( &(view.vpn), -view.vrp.val[0], -view.vrp.val[1], -view.vrp.val[2] );
vector_set( &(view.vup), 0, 1, 0 );
view.d = 1;
view.du = 1.6;
view.dv = 0.9;
view.f = 1;
view.b = 50;
view.screenx = 640;
view.screeny = 360;
matrix_setView3D( &vtm, &view );
matrix_identity( >m );
// //wall
wall = module_create();
module_color(wall, &Red);
polygon_init(&p);
point_set3D(&point[0], 1,1,2);
point_set3D(&point[1], 1,0,2);
point_set3D(&point[2], 0,0,2);
point_set3D(&point[3], 0,1,2);
polygon_set(&p, 4, &point[0]);
module_polygon(wall, &p);
//ray
ray = module_create();
module_color(ray, &Blue);
for(i=0; i< 5; i++){
point_set3D(&point2[0], -1+0.01*i, -1, 1);
point_set3D(&point2[1], 1+0.01*i, 1, 1);
line_set(&l, point2[0], point2[1]);
module_line(ray, &l);
}
//ray2
ray2 = module_create();
module_color(ray2, &Red);
for(i=0; i< 5; i++){
point_set3D(&point2[0], -1+0.01*i, 1, -1);
point_set3D(&point2[1], 1+0.01*i, -1, -1);
line_set(&l, point2[0], point2[1]);
// line_zBuffer(&l, 0);
module_line(ray2, &l);
}
//scene
// scene = module_create();
// module_module(scene, wall);
// module_module(scene, ray);
// module_module(scene, ray2);
// module_module(scene, wall);
for(i=0; i< 36; i++){
//scene
scene1 = module_create();
scene2 = module_create();
module_rotateZ(scene1, cos(i*10 * M_PI/180), sin(i*10 * M_PI/180));
module_scale( scene1, 3, 1, 2 );
module_color( scene1, &Blue );
module_cube( scene1, 1);
module_scale(scene2, 0.5, 0.5, 0.5);
module_cylinder(scene2, 30);
// create the image and drawstate
src = image_create( 360, 640 );
ds = drawstate_create();
drawstate_setAlpha(ds, 1);
ds->shade = ShadeDepth;
// draw into the scene
// module_draw( scene1, &vtm, >m, ds, src );
drawstate_setAlpha(ds, 1 );
module_draw( scene1, &vtm, >m, ds, src );
// write out the scene
sprintf(filename, "frame_%.2d.ppm", i);
image_write( src, filename );
module_delete( scene1);
}
//free the polygon data
// polygon_clear( &p );
// free the modules
// module_delete( scene);
// module_delete( wall );
// free the drawstate
free(ds);
// free the image
image_free( src );
return(0);
}
int main(int argc, char *argv[]) {
int i, frame;
Color blue, green, purple, red, white;
Point p[4];
BezierCurve bc;
DrawState ds;
Module *curveA;
Module *curveB;
Module *curves;
View3D view;
Matrix VTM, GTM;
int divisions = 4;
int rows = 300, cols = 400;
Image *src = image_create(rows, cols);
// grab the command line argument, if one exists
if(argc > 1) {
int tmp = atoi(argv[1]);
if( tmp >= 0 && tmp < 10 )
divisions = tmp;
}
printf("Creating Bezier curves with %d subdivisions\n", divisions);
color_set(&white, 1.0, 1.0, 1.0 );
color_set(&blue, .1, .2, .8);
color_set(&green, .2, 0.7, 0.3 );
color_set(&purple, 0.6, 0.1, 0.7 );
color_set(&red, 0.75, 0.3, 0.3 );
// set one curve
point_set3D(&p[0], 0.0, 0.0, 0.0);
point_set3D(&p[1], 1.0, 0.2, 0.0);
point_set3D(&p[2], 0.7, 0.5, 0.2);
point_set3D(&p[3], 1.0, 1.0, 1.0);
bezierCurve_set(&bc, p);
// put the curve into a module
curveA = module_create();
module_color(curveA, &blue);
module_bezierCurve(curveA, &bc, divisions);
// set the second curve
point_set3D(&p[0], 0.0, 0.0, 0.0);
point_set3D(&p[1], 0.0, 0.2, 1.0);
point_set3D(&p[2], 0.2, 0.5, 0.7);
point_set3D(&p[3], 1.0, 1.0, 1.0);
bezierCurve_set(&bc, p);
// put the curve into a module
curveB = module_create();
module_color(curveB, &green);
module_bezierCurve(curveB, &bc, divisions);
// create a module with six curves
curves = module_create();
for(i=0;i<3;i++) {
module_module( curves, curveA );
module_module( curves, curveB );
module_rotateY( curves, cos(2.0*M_PI/3.0), sin(2.0*M_PI/3.0) );
}
// set up the drawstate
drawstate_setColor(&ds, white);
// set up the view
point_set3D(&(view.vrp), 0.0, 0.5, -3.0 );
vector_set( &(view.vpn), 0.0, 0.0, 1.0 );
vector_set( &(view.vup), 0.0, 1.0, 0.0 );
view.d = 1.0;
view.du = 1.0;
view.dv = 1.0*rows/cols;
view.screeny = rows;
view.screenx = cols;
view.f = 0.0;
view.b = 3.0;
matrix_setView3D( &VTM, &view );
matrix_identity( >M );
// Create the animation by adjusting the GTM
for(frame=0;frame<60;frame++) {
char buffer[256];
matrix_rotateY(>M, cos(M_PI/30.0), sin(M_PI/30.0) );
module_draw( curves, &VTM, >M, &ds, NULL, src );
sprintf(buffer, "bez3d-frame%03d.ppm", frame);
image_write(src, buffer);
image_reset(src);
}
printf("converting to gif...\n");
system("convert -delay 1.5 -loop 0 bez3d-frame*.ppm bez3d.gif");
system("rm bez3d-frame*.ppm");
// clean up
image_free( src );
module_delete( curveA );
module_delete( curveB );
module_delete( curves );
return(0);
}
int main(int argc, char* argv[]){
Image* src;
Module *scene;
Module* GRAPHICS;
View3D view;
Matrix vtm, gtm;
DrawState *ds;
Lighting *light;
Point center;//center of animation
Polygon poly;//polygon that holds the animation path points
int frameNum;//holds the frame number for animation
char filename[100];//holds the frame name
Color Red;
Color Blue;
Color Green;
Color Grey;
Color Lemon;
Color Black;
Color White;
Color Yellow;
Color DarkAmbiant;
Color randColor[10];
//setting colors
Color_set(&Red, 1.0, 0.2, 0.1 );
Color_set(&Blue, 0.1, 0.1, 1.0);
Color_set(&Green, 0.1, 1, 0.1 );
Color_set(&White, 1, 1, 1 );
Color_set(&Grey, 0.7, 0.7, 0.7 );
Color_set(&Lemon, 1.0, 1.0, 0.8);
Color_set(&Black, 0.05, 0.05, 0.05);
Color_set(&Yellow, 1, 0.894118, 0.709804);
Color_set(&DarkAmbiant, 0.3, 0.3, 0.3);
Color_set(&randColor[0], 0, 1, 1);
Color_set(&randColor[1], 0.498039, 1, 0);
Color_set(&randColor[2], 1, 0.54902, 0);
Color_set(&randColor[3], 1, 0.0784314, 0.576471);
Color_set(&randColor[4], 1, 0.843137, 0);
Color_set(&randColor[5], 0.960784, 1, 0.980392);
Color_set(&randColor[6], 1, 0.647059, 0);
Color_set(&randColor[7], 1, 0.270588, 0);
Color_set(&randColor[8], 0, 1, 0.498039);
Color_set(&randColor[9], 1, 1, 0);
// setting the view
point_set3D( &(view.vrp), 35, 60, 30 );
vector_set( &(view.vpn), -view.vrp.val[0]+35, -view.vrp.val[1], -view.vrp.val[2]);
vector_set( &(view.vup), 0, 1, 0 );
view.d = 1;
view.du = 1.6;
view.dv = 0.9;
view.f = 1;
view.b = 200;
view.screenx = 1280;
view.screeny = 720;
matrix_setView3D( &vtm, &view );
matrix_identity( >m );
//creating GRAPHICS module
GRAPHICS = module_create();
module_alphabet_G(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 10, 0, 0);
module_alphabet_R(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 20, 0, 0);
module_alphabet_A(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 30, 0, 0);
module_alphabet_P(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 40, 0, 0);
module_alphabet_H(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 50, 0, 0);
module_alphabet_I(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 56, 0, 0);
module_alphabet_C(GRAPHICS);
module_identity(GRAPHICS);
module_translate(GRAPHICS, 68, 0, 0);
module_alphabet_S(GRAPHICS);
// setting the light
light = lighting_create();
lighting_add( light, LightAmbient, &Lemon, NULL, NULL, 0, 0);
lighting_add(light, LightPoint, &White , NULL, &view.vrp, 0, 0);
lighting_add(light, LightSpot, &White, &view.vpn, &view.vrp, cos(10*M_PI/180), 40);
//setting drawstate
ds = drawstate_create();
point_copy(&(ds->viewer), &(view.vrp) );
ds->shade = ShadePhong;
// ds->shade = ShadeDepth;
drawstate_setBody(ds, Black);
drawstate_setSurface(ds, Red);
drawstate_setSurfaceCoeff(ds, 10);
//Animation
frameNum =0;
//path #1
point_set3D(¢er, 40, 0, -10);
view_rotate_circle(&poly, ¢er, 100, 50, 0, 0, 0);
polygon_print(&poly, stdout);
for(int k=0; k<100; k++){
frameNum++;
point_set3D( &(view.vrp), poly.vertex[k].val[0], poly.vertex[k].val[1], poly.vertex[k].val[2]);
vector_set( &(view.vpn), -view.vrp.val[0], -view.vrp.val[1], -view.vrp.val[2] );
matrix_setView3D( &vtm, &view );
//creating scene module
scene = module_create();
module_module(scene, GRAPHICS);
// image
src = image_create( view.screeny, view.screenx );
image_fillrgb(src, 1.0, 1.0, 0.8);
//Drawing
module_draw( scene, &vtm, >m, ds, light, src );
sprintf(filename, "../images/frame_%.4d.ppm",frameNum);
image_write( src, filename);
}
//path #2
point_set3D(¢er, 40, 0, -10);
view_rotate_circle(&poly, ¢er, 100, 90, 0, 0 , 0);
// polygon_print(&poly, stdout);
for(int k=0; k<100; k++){
if(frameNum == 119){
point_print(&view.vrp, stdout);
break;
}
view_rotate_circle(&poly, ¢er, 50, 50+k, 0-2*k, 0 , 0);
frameNum++;
point_set3D( &(view.vrp), poly.vertex[k].val[0], poly.vertex[k].val[1], poly.vertex[k].val[2]);
vector_set( &(view.vpn), -view.vrp.val[0], -view.vrp.val[1], -view.vrp.val[2] );
matrix_setView3D( &vtm, &view );
//creating scene module
scene = module_create();
module_module(scene, GRAPHICS);
// image
src = image_create( view.screeny, view.screenx );
image_fillrgb(src, 1.0, 1.0, 0.8);
//Drawing
module_draw( scene, &vtm, >m, ds, light, src );
sprintf(filename, "../images/frame_%.4d.ppm",frameNum);
image_write( src, filename);
}
//path #3
for(int k=0; k<120; k++){
frameNum++;
if(frameNum <= 160){
point_set3D( &(view.vrp), -3.345+(k), 36.298+(k), 28.391-(k/2.0));
vector_set( &(view.vpn), -view.vrp.val[0]+k, -view.vrp.val[1], -view.vrp.val[2]);
matrix_setView3D( &vtm, &view );
}
//creating scene module
scene = module_create();
module_module(scene, GRAPHICS);
if(frameNum == 160){
light = lighting_create();
lighting_add( light, LightAmbient, &Grey, NULL, NULL, 0, 0);
}
// setting the light
if(frameNum == 165){
Point plight1;
point_set3D(&plight1, -5, 10, -10);
lighting_add(light, LightSpot, &White, &view.vpn, &plight1, cos(10*M_PI/180), 40);
}
if(frameNum == 175){
Point plight2;
point_set3D(&plight2, 85, 10, -10);
lighting_add(light, LightSpot, &White, &view.vpn, &plight2, cos(10*M_PI/180), 40);
}
if(frameNum == 180){
lighting_add(light, LightSpot, &White, &view.vpn, &view.vrp, cos(10*M_PI/180), 40);
}
if(frameNum >= 183){
light = lighting_create();
lighting_add( light, LightAmbient, &Grey, NULL, NULL, 0, 0);
int output1 = 0 + (rand() % (int)(10 - 0 + 1));
int output2 = 0 + (rand() % (int)(10 - 0 + 1));
int output3 = 0 + (rand() % (int)(10 - 0 + 1));
Point plight1;
point_set3D(&plight1, -5, 10, -10);
lighting_add(light, LightSpot, &randColor[output1], &view.vpn, &plight1, cos(10*M_PI/180), 40);
Point plight2;
point_set3D(&plight2, 85, 10, -10);
lighting_add(light, LightSpot, &randColor[output2], &view.vpn, &plight2, cos(10*M_PI/180), 40);
lighting_add(light, LightSpot, &randColor[output3], &view.vpn, &view.vrp, cos(10*M_PI/180), 40);
}
// image
src = image_create( view.screeny, view.screenx );
image_fillrgb(src, 1.0, 1.0, 0.8);
//setting drawstate
ds = drawstate_create();
point_copy(&(ds->viewer), &(view.vrp) );
ds->shade = ShadePhong;
// ds->shade = ShadeDepth;
drawstate_setBody(ds, Black);
drawstate_setSurface(ds, Red);
drawstate_setSurfaceCoeff(ds, 10);
//Drawing
module_draw( scene, &vtm, >m, ds, light, src );
sprintf(filename, "../images/frame_%.4d.ppm",frameNum);
image_write( src, filename);
}
//***Uncomment for making the .gif animation***
printf("Making the demo.gif file....\n");
system("convert -delay 10 ../images/frame_*.ppm ../images/demo.gif");
printf("Cleaning up...\n");
system("rm -f ../images/frame_*.ppm");
printf("Finished Successfully :)\n");
return(0);
}
