diff options
Diffstat (limited to 'src/glu/mesa/nurbscrv.c')
| -rw-r--r-- | src/glu/mesa/nurbscrv.c | 500 |
1 files changed, 500 insertions, 0 deletions
diff --git a/src/glu/mesa/nurbscrv.c b/src/glu/mesa/nurbscrv.c new file mode 100644 index 0000000000..022818b73c --- /dev/null +++ b/src/glu/mesa/nurbscrv.c @@ -0,0 +1,500 @@ +/* $Id: nurbscrv.c,v 1.1 1999/08/19 00:55:42 jtg Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 2.4 + * Copyright (C) 1995-1997 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +/* + * $Log: nurbscrv.c,v $ + * Revision 1.1 1999/08/19 00:55:42 jtg + * Initial revision + * + * Revision 1.6 1997/07/24 01:28:44 brianp + * changed precompiled header symbol from PCH to PC_HEADER + * + * Revision 1.5 1997/05/28 02:29:38 brianp + * added support for precompiled headers (PCH), inserted APIENTRY keyword + * + * Revision 1.4 1997/05/27 03:21:22 brianp + * minor clean-up + * + * Revision 1.3 1997/05/27 03:00:16 brianp + * incorporated Bogdan's new NURBS code + * + * Revision 1.2 1996/09/27 23:12:22 brianp + * added return 0 to get_surface_dim() to silence warning + * + * Revision 1.1 1996/09/27 01:19:39 brianp + * Initial revision + * + */ + + +/* + * NURBS implementation written by Bogdan Sikorski (bogdan@cira.it) + * See README2 for more info. + */ + + +#ifdef PC_HEADER +#include "all.h" +#else +#include <math.h> +#include <stdlib.h> +#include "gluP.h" +#include "nurbs.h" +#endif + + +static int +get_curve_dim(GLenum type) +{ + switch(type) + { + case GL_MAP1_VERTEX_3: return 3; + case GL_MAP1_VERTEX_4: return 4; + case GL_MAP1_INDEX: return 1; + case GL_MAP1_COLOR_4: return 4; + case GL_MAP1_NORMAL: return 3; + case GL_MAP1_TEXTURE_COORD_1: return 1; + case GL_MAP1_TEXTURE_COORD_2: return 2; + case GL_MAP1_TEXTURE_COORD_3: return 3; + case GL_MAP1_TEXTURE_COORD_4: return 4; + default: abort(); /* TODO: is this OK? */ + } + return 0; /*never get here*/ +} + +static GLenum +test_nurbs_curve(GLUnurbsObj *nobj, curve_attribs *attribs) +{ + GLenum err; + GLint tmp_int; + + if(attribs->order < 0) + { + call_user_error(nobj,GLU_INVALID_VALUE); + return GLU_ERROR; + } + glGetIntegerv(GL_MAX_EVAL_ORDER,&tmp_int); + if(attribs->order > tmp_int || attribs->order < 2) + { + call_user_error(nobj,GLU_NURBS_ERROR1); + return GLU_ERROR; + } + if(attribs->knot_count < attribs->order +2) + { + call_user_error(nobj,GLU_NURBS_ERROR2); + return GLU_ERROR; + } + if(attribs->stride < 0) + { + call_user_error(nobj,GLU_NURBS_ERROR34); + return GLU_ERROR; + } + if(attribs->knot==NULL || attribs->ctrlarray==NULL) + { + call_user_error(nobj,GLU_NURBS_ERROR36); + return GLU_ERROR; + } + if((err=test_knot(attribs->knot_count,attribs->knot,attribs->order)) + !=GLU_NO_ERROR) + { + call_user_error(nobj,err); + return GLU_ERROR; + } + return GLU_NO_ERROR; +} + +static GLenum +test_nurbs_curves(GLUnurbsObj *nobj) +{ + /* test the geometric data */ + if(test_nurbs_curve(nobj,&(nobj->curve.geom))!=GLU_NO_ERROR) + return GLU_ERROR; + /* now test the attributive data */ + /* color */ + if(nobj->curve.color.type!=GLU_INVALID_ENUM) + if(test_nurbs_curve(nobj,&(nobj->curve.color))!=GLU_NO_ERROR) + return GLU_ERROR; + /* normal */ + if(nobj->curve.normal.type!=GLU_INVALID_ENUM) + if(test_nurbs_curve(nobj,&(nobj->curve.normal))!=GLU_NO_ERROR) + return GLU_ERROR; + /* texture */ + if(nobj->curve.texture.type!=GLU_INVALID_ENUM) + if(test_nurbs_curve(nobj,&(nobj->curve.texture))!=GLU_NO_ERROR) + return GLU_ERROR; + return GLU_NO_ERROR; +} + +/* prepare the knot information structures */ +static GLenum +fill_knot_structures(GLUnurbsObj *nobj,knot_str_type *geom_knot, + knot_str_type *color_knot, knot_str_type *normal_knot, + knot_str_type *texture_knot) +{ + GLint order; + GLfloat *knot; + GLint nknots; + GLint t_min,t_max; + + geom_knot->unified_knot=NULL; + knot=geom_knot->knot=nobj->curve.geom.knot; + nknots=geom_knot->nknots=nobj->curve.geom.knot_count; + order=geom_knot->order=nobj->curve.geom.order; + geom_knot->delta_nknots=0; + t_min=geom_knot->t_min=order-1; + t_max=geom_knot->t_max=nknots-order; + if(fabs(knot[t_min]-knot[t_max])<EPSILON) + { + call_user_error(nobj,GLU_NURBS_ERROR3); + return GLU_ERROR; + } + if(fabs(knot[0]-knot[t_min])<EPSILON) + { + /* knot open at beggining */ + geom_knot->open_at_begin=GL_TRUE; + } + else + geom_knot->open_at_begin=GL_FALSE; + if(fabs(knot[t_max]-knot[nknots-1])<EPSILON) + { + /* knot open at end */ + geom_knot->open_at_end=GL_TRUE; + } + else + geom_knot->open_at_end=GL_FALSE; + if(nobj->curve.color.type!=GLU_INVALID_ENUM) + { + color_knot->unified_knot=(GLfloat *)1; + knot=color_knot->knot=nobj->curve.color.knot; + nknots=color_knot->nknots=nobj->curve.color.knot_count; + order=color_knot->order=nobj->curve.color.order; + color_knot->delta_nknots=0; + t_min=color_knot->t_min=order-1; + t_max=color_knot->t_max=nknots-order; + if(fabs(knot[t_min]-knot[t_max])<EPSILON) + { + call_user_error(nobj,GLU_NURBS_ERROR3); + return GLU_ERROR; + } + if(fabs(knot[0]-knot[t_min])<EPSILON) + { + /* knot open at beggining */ + color_knot->open_at_begin=GL_TRUE; + } + else + color_knot->open_at_begin=GL_FALSE; + if(fabs(knot[t_max]-knot[nknots-1])<EPSILON) + { + /* knot open at end */ + color_knot->open_at_end=GL_TRUE; + } + else + color_knot->open_at_end=GL_FALSE; + } + else + color_knot->unified_knot=NULL; + if(nobj->curve.normal.type!=GLU_INVALID_ENUM) + { + normal_knot->unified_knot=(GLfloat *)1; + knot=normal_knot->knot=nobj->curve.normal.knot; + nknots=normal_knot->nknots=nobj->curve.normal.knot_count; + order=normal_knot->order=nobj->curve.normal.order; + normal_knot->delta_nknots=0; + t_min=normal_knot->t_min=order-1; + t_max=normal_knot->t_max=nknots-order; + if(fabs(knot[t_min]-knot[t_max])<EPSILON) + { + call_user_error(nobj,GLU_NURBS_ERROR3); + return GLU_ERROR; + } + if(fabs(knot[0]-knot[t_min])<EPSILON) + { + /* knot open at beggining */ + normal_knot->open_at_begin=GL_TRUE; + } + else + normal_knot->open_at_begin=GL_FALSE; + if(fabs(knot[t_max]-knot[nknots-1])<EPSILON) + { + /* knot open at end */ + normal_knot->open_at_end=GL_TRUE; + } + else + normal_knot->open_at_end=GL_FALSE; + } + else + normal_knot->unified_knot=NULL; + if(nobj->curve.texture.type!=GLU_INVALID_ENUM) + { + texture_knot->unified_knot=(GLfloat *)1; + knot=texture_knot->knot=nobj->curve.texture.knot; + nknots=texture_knot->nknots=nobj->curve.texture.knot_count; + order=texture_knot->order=nobj->curve.texture.order; + texture_knot->delta_nknots=0; + t_min=texture_knot->t_min=order-1; + t_max=texture_knot->t_max=nknots-order; + if(fabs(knot[t_min]-knot[t_max])<EPSILON) + { + call_user_error(nobj,GLU_NURBS_ERROR3); + return GLU_ERROR; + } + if(fabs(knot[0]-knot[t_min])<EPSILON) + { + /* knot open at beggining */ + texture_knot->open_at_begin=GL_TRUE; + } + else + texture_knot->open_at_begin=GL_FALSE; + if(fabs(knot[t_max]-knot[nknots-1])<EPSILON) + { + /* knot open at end */ + texture_knot->open_at_end=GL_TRUE; + } + else + texture_knot->open_at_end=GL_FALSE; + } + else + texture_knot->unified_knot=NULL; + return GLU_NO_ERROR; +} + +/* covert the NURBS curve into a series of adjacent Bezier curves */ +static GLenum +convert_curve(knot_str_type *the_knot, curve_attribs *attrib, + GLfloat **new_ctrl,GLint *ncontrol) +{ + GLenum err; + + if((err=explode_knot(the_knot))!=GLU_NO_ERROR) + { + if(the_knot->unified_knot) + { + free(the_knot->unified_knot); + the_knot->unified_knot=NULL; + } + return err; + } + if(the_knot->unified_knot) + { + free(the_knot->unified_knot); + the_knot->unified_knot=NULL; + } + if((err=calc_alphas(the_knot))!=GLU_NO_ERROR) + { + free(the_knot->new_knot); + return err; + } + free(the_knot->new_knot); + if((err=calc_new_ctrl_pts(attrib->ctrlarray,attrib->stride,the_knot, + attrib->dim,new_ctrl,ncontrol)) + !=GLU_NO_ERROR) + { + free(the_knot->alpha); + return err; + } + free(the_knot->alpha); + return GLU_NO_ERROR; +} + +/* covert curves - geometry and possible attribute ones into equivalent */ +/* sequence of adjacent Bezier curves */ +static GLenum +convert_curves(GLUnurbsObj *nobj, GLfloat **new_geom_ctrl, + GLint *ncontrol, GLfloat **new_color_ctrl, GLfloat **new_normal_ctrl, + GLfloat **new_texture_ctrl) +{ + knot_str_type geom_knot,color_knot,normal_knot,texture_knot; + GLint junk; + GLenum err; + + *new_color_ctrl=*new_normal_ctrl=*new_texture_ctrl=NULL; + + if(fill_knot_structures(nobj,&geom_knot,&color_knot,&normal_knot, + &texture_knot)!=GLU_NO_ERROR) + return GLU_ERROR; + + /* unify knots - all knots should have the same number of working */ + /* ranges */ + if((err=select_knot_working_range(nobj,&geom_knot,&color_knot,&normal_knot, + &texture_knot))!=GLU_NO_ERROR) + { + return err; + } + /* convert the geometry curve */ + nobj->curve.geom.dim=get_curve_dim(nobj->curve.geom.type); + if((err=convert_curve(&geom_knot,&(nobj->curve.geom),new_geom_ctrl, + ncontrol))!=GLU_NO_ERROR) + { + free_unified_knots(&geom_knot,&color_knot,&normal_knot,&texture_knot); + call_user_error(nobj,err); + return err; + } + /* if additional attributive curves are given convert them as well */ + if(color_knot.unified_knot) + { + nobj->curve.color.dim=get_curve_dim(nobj->curve.color.type); + if((err=convert_curve(&color_knot,&(nobj->curve.color), + new_color_ctrl,&junk))!=GLU_NO_ERROR) + { + free_unified_knots(&geom_knot,&color_knot,&normal_knot,&texture_knot); + free(*new_geom_ctrl); + call_user_error(nobj,err); + return err; + } + } + if(normal_knot.unified_knot) + { + nobj->curve.normal.dim=get_curve_dim(nobj->curve.normal.type); + if((err=convert_curve(&normal_knot,&(nobj->curve.normal), + new_normal_ctrl,&junk))!=GLU_NO_ERROR) + { + free_unified_knots(&geom_knot,&color_knot,&normal_knot,&texture_knot); + free(*new_geom_ctrl); + if(*new_color_ctrl) + free(*new_color_ctrl); + call_user_error(nobj,err); + return err; + } + } + if(texture_knot.unified_knot) + { + nobj->curve.texture.dim=get_curve_dim(nobj->curve.texture.type); + if((err=convert_curve(&texture_knot,&(nobj->curve.texture), + new_texture_ctrl,&junk))!=GLU_NO_ERROR) + { + free_unified_knots(&geom_knot,&color_knot,&normal_knot,&texture_knot); + free(*new_geom_ctrl); + if(*new_color_ctrl) + free(*new_color_ctrl); + if(*new_normal_ctrl) + free(*new_normal_ctrl); + call_user_error(nobj,err); + return err; + } + } + return GLU_NO_ERROR; +} + +/* main NURBS curve procedure */ +void do_nurbs_curve( GLUnurbsObj *nobj) +{ + GLint geom_order,color_order=0,normal_order=0,texture_order=0; + GLenum geom_type; + GLint n_ctrl; + GLfloat *new_geom_ctrl,*new_color_ctrl,*new_normal_ctrl,*new_texture_ctrl; + GLfloat *geom_ctrl,*color_ctrl,*normal_ctrl,*texture_ctrl; + GLint *factors; + GLint i,j; + GLint geom_dim,color_dim=0,normal_dim=0,texture_dim=0; + + /* test the user supplied data */ + if(test_nurbs_curves(nobj)!=GLU_NO_ERROR) + return; + + if(convert_curves(nobj,&new_geom_ctrl,&n_ctrl,&new_color_ctrl, + &new_normal_ctrl,&new_texture_ctrl)!=GLU_NO_ERROR) + return; + + geom_order=nobj->curve.geom.order; + geom_type=nobj->curve.geom.type; + geom_dim=nobj->curve.geom.dim; + + if(glu_do_sampling_crv(nobj,new_geom_ctrl,n_ctrl,geom_order,geom_dim, + &factors) + !=GLU_NO_ERROR) + { + free(new_geom_ctrl); + if(new_color_ctrl) + free(new_color_ctrl); + if(new_normal_ctrl) + free(new_normal_ctrl); + if(new_texture_ctrl) + free(new_texture_ctrl); + return; + } + glEnable(geom_type); + if(new_color_ctrl) + { + glEnable(nobj->curve.color.type); + color_dim=nobj->curve.color.dim; + color_ctrl=new_color_ctrl; + color_order=nobj->curve.color.order; + } + if(new_normal_ctrl) + { + glEnable(nobj->curve.normal.type); + normal_dim=nobj->curve.normal.dim; + normal_ctrl=new_normal_ctrl; + normal_order=nobj->curve.normal.order; + } + if(new_texture_ctrl) + { + glEnable(nobj->curve.texture.type); + texture_dim=nobj->curve.texture.dim; + texture_ctrl=new_texture_ctrl; + texture_order=nobj->curve.texture.order; + } + for(i=0 , j=0, geom_ctrl=new_geom_ctrl; + i<n_ctrl; + i+=geom_order , j++ , geom_ctrl+=geom_order*geom_dim) + { + if(fine_culling_test_2D(nobj,geom_ctrl,geom_order,geom_dim,geom_dim)) + { + color_ctrl+=color_order*color_dim; + normal_ctrl+=normal_order*normal_dim; + texture_ctrl+=texture_order*texture_dim; + continue; + } + glMap1f(geom_type, 0.0, 1.0, geom_dim, geom_order, geom_ctrl); + if(new_color_ctrl) + { + glMap1f(nobj->curve.color.type, 0.0, 1.0, color_dim, + color_order,color_ctrl); + color_ctrl+=color_order*color_dim; + } + if(new_normal_ctrl) + { + glMap1f(nobj->curve.normal.type, 0.0, 1.0, normal_dim, + normal_order,normal_ctrl); + normal_ctrl+=normal_order*normal_dim; + } + if(new_texture_ctrl) + { + glMap1f(nobj->curve.texture.type, 0.0, 1.0, texture_dim, + texture_order,texture_ctrl); + texture_ctrl+=texture_order*texture_dim; + } + glMapGrid1f(factors[j],0.0,1.0); + glEvalMesh1(GL_LINE,0,factors[j]); + } + free(new_geom_ctrl); + free(factors); + if(new_color_ctrl) + free(new_color_ctrl); + if(new_normal_ctrl) + free(new_normal_ctrl); + if(new_texture_ctrl) + free(new_texture_ctrl); +} + + |