struct polygon * polygon_create_from_data(float *data, int size)
{
struct polygon *poly = polygon_create(size);
memcpy(poly->data, data, sizeof(float) * COMPONENTS * size);
poly->num_verts = size;
poly->dirty = VG_TRUE;
poly->vbuf = NULL;
return poly;
}
/*
* Draw the module into the image using the given view transformation matrix [VTM],
* Lighting and DrawState by traversing the list of Elements.
* (For now, Lighting can be an empty structure.)
*/
void module_draw(Module *md, Matrix *VTM, Matrix *GTM, DrawState *ds,
Lighting *lighting, Image *src){
/* for antialiasing
Module *thickLineMod = module_create();
Element *thickLineE;
float dx, dy, dz, lineLength;
Vector u, v, w;*/
// all locally needed variables
Matrix LTM, tempGTM;
Line tempLine;
DrawState *tempds = drawstate_create();
Point tempPointLTM, tempPointGTM, tempPointVTM;
Polyline *tempPolyline = polyline_create();
Polygon *tempPolygon = polygon_create();
Element *e = md->head;
matrix_identity(<M);
// loop until the end of the linked list is reached
while(e){
//printf("Handling type %d\n", e->type);
// draw based on type
switch(e->type){
case ObjNone:
break;
case ObjPoint:
//printf("drawing point ");
// copy, xform, normalize, draw
matrix_xformPoint(<M, &(e->obj.point), &tempPointLTM);
matrix_xformPoint(GTM, &tempPointLTM, &tempPointGTM);
matrix_xformPoint(VTM, &tempPointGTM, &tempPointVTM);
point_normalize(&(tempPointVTM));
//point_print(&tempPointVTM, stdout);
point_draw(&tempPointVTM, src, ds->color);
break;
case ObjLine:
line_copy(&tempLine, &(e->obj.line));
//printf("drawing line ");
// copy, xform, normalize, draw
matrix_xformLine(<M, &tempLine);
matrix_xformLine(GTM, &tempLine);
matrix_xformLine(VTM, &tempLine);
line_normalize(&tempLine);
line_draw(&tempLine, src, ds->color);
//line_print(&tempLine, stdout);
/*if(antialias){
dx = tempLine.b.val[0]-tempLine.a.val[0];
dy = tempLine.b.val[1]-tempLine.a.val[1];
dz = tempLine.b.val[2]-tempLine.a.val[2];
lineLength = sqrt(dx*dx+dy*dy+dz*dz);
module_scale( thickLineMod, 1, lineLength, 1 );
vector_set(&v, dx, dy, dz);
vector_normalize(&v);
vector_set(&u, -dz, dx, dy);
vector_cross(&u, &v, &w);
vector_cross(&v, &w, &u);
vector_normalize(&u);
vector_normalize(&w);
module_rotateXYZ( thickLineMod, &u, &v, &w );
module_translate( thickLineMod, tempLine.a.val[0],
tempLine.a.val[1],
tempLine.a.val[2] );
module_cylinder( thickLineMod, 4, 1, 1, 0, 0, 0 );
thickLineE = element_init(ObjModule, thickLineMod);
thickLineE->next = e->next;
e->next = thickLineE;
}*/
break;
case ObjPolyline:
//printf("drawing polyline ");
// copy, xform, normalize, draw
polyline_copy(tempPolyline, &(e->obj.polyline));
matrix_xformPolyline(<M, tempPolyline);
matrix_xformPolyline(GTM, tempPolyline);
matrix_xformPolyline(VTM, tempPolyline);
polyline_normalize(tempPolyline);
//polyline_print(tempPolyline, stdout);
polyline_draw(tempPolyline, src, ds->color);
break;
case ObjPolygon:
//printf("drawing polygon ");
// copy, xform, normalize, draw
polygon_copy(tempPolygon, &(e->obj.polygon));
matrix_xformPolygon(<M, tempPolygon);
matrix_xformPolygon(GTM, tempPolygon);
matrix_xformPolygon(VTM, tempPolygon);
polygon_normalize(tempPolygon);
//polygon_print(tempPolygon, stdout);
polygon_draw(tempPolygon, src, ds);
break;
case ObjColor:
drawstate_setColor(ds, e->obj.color);
break;
case ObjBodyColor:
break;
case ObjSurfaceColor:
break;
case ObjSurfaceCoeff:
break;
case ObjLight:
break;
case ObjIdentity:
matrix_identity(<M);
break;
case ObjMatrix:
matrix_multiply(&(e->obj.matrix), <M, <M);
break;
case ObjModule:
matrix_multiply(GTM, <M, &tempGTM);
drawstate_copy(tempds, ds);
module_draw(e->obj.module, VTM, &tempGTM, tempds, lighting, src);
break;
default:
printf("ObjectType %d is not handled in module_draw\n",e->type);
}
// advance traversal
e = e->next;
}
// clean up
polygon_free(tempPolygon);
polyline_free(tempPolyline);
free(tempds);
}
/*
* use the de Casteljau algorithm to subdivide the Bezier surface divisions times,
* then draw either the lines connecting the control points, if solid is 0,
* or draw triangles connecting the surface.
*/
void module_bezierSurface(Module *m, BezierSurface *b, int divisions, int solid){
int i, j, k, l;
Line tempLine;
Point grid[7][7];
Point controls[7];
Point deCast[7];
Point surfacePoints[16];
BezierSurface tempBezSurf;
Polygon *temptri = polygon_create();
if(!m || !b){
printf("Null passed to module_bezierSurface\n");
return;
}
// base case
if(divisions == 0){
// lines
if(solid == 0){
for(i=0;i<4;i++){
for(j=0;j<3;j++){
line_set(&tempLine, b->c[i][j], b->c[i][j+1]);
module_line(m, &tempLine);
line_set(&tempLine, b->c[j][i], b->c[j+1][i]);
module_line(m, &tempLine);
}
}
}
// triangles
else {
controls[0] = b->c[0][0];
controls[1] = b->c[0][3];
controls[2] = b->c[3][3];
controls[3] = b->c[3][0];
controls[4] = b->c[0][0];
polygon_set(temptri, 3, &(controls[0]));
module_polygon(m, temptri);
polygon_set(temptri, 3, &(controls[2]));
module_polygon(m, temptri);
}
}
// divide and recurse
else {
// compute all avg points for 3 orders, down to just one point 3rd order
// do for each of the four bezier curves
for(i=0;i<4;i++){
deCasteljau(&(deCast[0]), &(b->c[i][0]));
for(j=0;j<7;j++){
grid[2*i][j] = deCast[j];
}
}
// now traverse the other direction, populating grid
for(i=0;i<7;i++){
for(j=0;j<4;j++){
controls[j] = grid[2*j][i];
}
deCasteljau(&(deCast[0]), &(controls[0]));
for(j=0;j<7;j++){
grid[j][i] = deCast[j];
}
}
// now make the four new bezier surfaces by subdividing across
for(i=0;i<2;i++){
for(j=0;j<2;j++){
for(k=0;k<4;k++){
for(l=0;l<4;l++){
surfacePoints[4*k+l] = grid[k+3*i][l+3*j];
}
}
bezierSurface_set(&tempBezSurf, &(surfacePoints[0]));
// recursive call
module_bezierSurface(m, &tempBezSurf, divisions-1, solid);
}
}
}
// clean up
polygon_free(temptri);
}