summaryrefslogtreecommitdiff
path: root/src/glu/mesa/nurbscrv.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/glu/mesa/nurbscrv.c')
-rw-r--r--src/glu/mesa/nurbscrv.c500
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);
+}
+
+