This is nurbscrv.c in view mode; [Download] [Up]
/* $Id: nurbscrv.c,v 1.2 1996/09/27 23:12:22 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 2.0
* Copyright (C) 1995-1996 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.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.
*/
#include <math.h>
#include <stdlib.h>
#include "nurbs.h"
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_2D(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);
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.