Exemple #1
0
void GLAPIENTRY
gluBeginTrim(GLUnurbsObj * nobj)
{
#if 0
   nurbs_trim *ptr;
#endif

   if (nobj->nurbs_type != GLU_NURBS_TRIM_DONE)
      if (nobj->nurbs_type != GLU_NURBS_NO_TRIM) {
	 call_user_error(nobj, GLU_NURBS_ERROR15);
	 return;
      }
   nobj->nurbs_type = GLU_NURBS_TRIM;
   fprintf(stderr, "NURBS - trimming not supported yet\n");
#if 0
   if ((ptr = (nurbs_trim *) malloc(sizeof(nurbs_trim))) == NULL) {
      call_user_error(nobj, GLU_OUT_OF_MEMORY);
      return;
   }
   if (nobj->trim) {
      nurbs_trim *tmp_ptr;

      for (tmp_ptr = nobj->trim; tmp_ptr->next; tmp_ptr = tmp_ptr->next);
      tmp_ptr->next = ptr;
   }
   else
      nobj->trim = ptr;
   ptr->trim_loop = NULL;
   ptr->segments = NULL;
   ptr->next = NULL;
#endif
}
Exemple #2
0
void GLAPIENTRY
gluEndCurve(GLUnurbsObj * nobj)
{
   if (nobj->nurbs_type == GLU_NURBS_NONE) {
      call_user_error(nobj, GLU_NURBS_ERROR7);
      return;
   }
   if (nobj->curve.geom.type == GLU_INVALID_ENUM) {
      call_user_error(nobj, GLU_NURBS_ERROR8);
      nobj->nurbs_type = GLU_NURBS_NONE;
      return;
   }
   glPushAttrib((GLbitfield) (GL_EVAL_BIT | GL_ENABLE_BIT));
   glDisable(GL_MAP1_VERTEX_3);
   glDisable(GL_MAP1_VERTEX_4);
   glDisable(GL_MAP1_INDEX);
   glDisable(GL_MAP1_COLOR_4);
   glDisable(GL_MAP1_NORMAL);
   glDisable(GL_MAP1_TEXTURE_COORD_1);
   glDisable(GL_MAP1_TEXTURE_COORD_2);
   glDisable(GL_MAP1_TEXTURE_COORD_3);
   glDisable(GL_MAP1_TEXTURE_COORD_4);
   glDisable(GL_MAP2_VERTEX_3);
   glDisable(GL_MAP2_VERTEX_4);
   glDisable(GL_MAP2_INDEX);
   glDisable(GL_MAP2_COLOR_4);
   glDisable(GL_MAP2_NORMAL);
   glDisable(GL_MAP2_TEXTURE_COORD_1);
   glDisable(GL_MAP2_TEXTURE_COORD_2);
   glDisable(GL_MAP2_TEXTURE_COORD_3);
   glDisable(GL_MAP2_TEXTURE_COORD_4);
   do_nurbs_curve(nobj);
   glPopAttrib();
   nobj->nurbs_type = GLU_NURBS_NONE;
}
Exemple #3
0
static GLenum
test_nurbs_surface(GLUnurbsObj *nobj, surface_attribs *attrib)
{
	GLenum err;
	GLint tmp_int;

	if(attrib->sorder < 0 || attrib->torder < 0)
	{
		call_user_error(nobj,GLU_INVALID_VALUE);
		return GLU_ERROR;
	}
	glGetIntegerv(GL_MAX_EVAL_ORDER,&tmp_int);
	if(attrib->sorder > tmp_int || attrib->sorder < 2)
	{
		call_user_error(nobj,GLU_NURBS_ERROR1);
		return GLU_ERROR;
	}
	if(attrib->torder > tmp_int || attrib->torder < 2)
	{
		call_user_error(nobj,GLU_NURBS_ERROR1);
		return GLU_ERROR;
	}
	if(attrib->sknot_count < attrib->sorder +2)
	{
		call_user_error(nobj,GLU_NURBS_ERROR2);
		return GLU_ERROR;
	}
	if(attrib->tknot_count < attrib->torder +2)
	{
		call_user_error(nobj,GLU_NURBS_ERROR2);
		return GLU_ERROR;
	}
	if(attrib->s_stride < 0 || attrib->t_stride < 0)
	{
		call_user_error(nobj,GLU_NURBS_ERROR34);
		return GLU_ERROR;
	}
	if(attrib->sknot==NULL || attrib->tknot==NULL || attrib->ctrlarray==NULL)
	{
		call_user_error(nobj,GLU_NURBS_ERROR36);
		return GLU_ERROR;
	}
	if((err=test_knot(attrib->tknot_count,attrib->tknot,attrib->torder))
		!=GLU_NO_ERROR)
	{
		call_user_error(nobj,err);
		return GLU_ERROR;
	}
	if((err=test_knot(attrib->sknot_count,attrib->sknot,attrib->sorder))
		!=GLU_NO_ERROR)
	{
		call_user_error(nobj,err);
		return GLU_ERROR;
	}
	return GLU_NO_ERROR;
}
Exemple #4
0
void GLAPIENTRY
gluPwlCurve(GLUnurbsObj * nobj, GLint count, GLfloat * array, GLint stride,
	    GLenum type)
{
#if 0
   nurbs_trim *ptr1;
   trim_list *ptr2;
#endif
   if (nobj->nurbs_type == GLU_NURBS_CURVE) {
      call_user_error(nobj, GLU_NURBS_ERROR9);
      return;
   }
   if (nobj->nurbs_type == GLU_NURBS_NONE) {
      call_user_error(nobj, GLU_NURBS_ERROR19);
      return;
   }
   if (type != GLU_MAP1_TRIM_2 && type != GLU_MAP1_TRIM_3) {
      call_user_error(nobj, GLU_NURBS_ERROR14);
      return;
   }
#if 0
   for (ptr1 = nobj->trim; ptr1->next; ptr1 = ptr1->next);
   if (ptr1->trim_loop) {
      for (ptr2 = ptr1->trim_loop; ptr2->next; ptr2 = ptr2->next);
      if ((ptr2->next = (trim_list *) malloc(sizeof(trim_list))) == NULL) {
	 call_user_error(nobj, GLU_OUT_OF_MEMORY);
	 return;
      }
      ptr2 = ptr2->next;
   }
   else {
      if ((ptr2 = (trim_list *) malloc(sizeof(trim_list))) == NULL) {
	 call_user_error(nobj, GLU_OUT_OF_MEMORY);
	 return;
      }
      ptr1->trim_loop = ptr2;
   }
   ptr2->trim_type = GLU_TRIM_PWL;
   ptr2->curve.pwl_curve.pt_count = count;
   ptr2->curve.pwl_curve.ctrlarray = array;
   ptr2->curve.pwl_curve.stride = stride;
   ptr2->curve.pwl_curve.dim = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
   ptr2->curve.pwl_curve.type = type;
   ptr2->next = NULL;
#endif
}
Exemple #5
0
void GLAPIENTRY
gluNurbsCallback(GLUnurbsObj * nobj, GLenum which, void (GLCALLBACK * fn) ())
{
   nobj->error_callback = (void (GLCALLBACKPCAST) (GLenum)) fn;

   if (which != GLU_ERROR)
      call_user_error(nobj, GLU_INVALID_ENUM);
}
Exemple #6
0
void GLAPIENTRY
gluEndSurface(GLUnurbsObj * nobj)
{
   switch (nobj->nurbs_type) {
   case GLU_NURBS_NONE:
      call_user_error(nobj, GLU_NURBS_ERROR13);
      break;
   case GLU_NURBS_TRIM:
      call_user_error(nobj, GLU_NURBS_ERROR12);
      break;
   case GLU_NURBS_TRIM_DONE:
/*            if(nobj->trim->trim_loop==NULL)
            {
                call_user_error(nobj,GLU_NURBS_ERROR18);
                return;
            }*/
      /* no break - fallthrough */
   case GLU_NURBS_NO_TRIM:
      glPushAttrib((GLbitfield)
		   (GL_EVAL_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT));
      glDisable(GL_MAP2_VERTEX_3);
      glDisable(GL_MAP2_VERTEX_4);
      glDisable(GL_MAP2_INDEX);
      glDisable(GL_MAP2_COLOR_4);
      glDisable(GL_MAP2_NORMAL);
      glDisable(GL_MAP2_TEXTURE_COORD_1);
      glDisable(GL_MAP2_TEXTURE_COORD_2);
      glDisable(GL_MAP2_TEXTURE_COORD_3);
      glDisable(GL_MAP2_TEXTURE_COORD_4);
/*            glDisable(GL_MAP1_VERTEX_3);
            glDisable(GL_MAP1_VERTEX_4);
            glDisable(GL_MAP1_INDEX);
            glDisable(GL_MAP1_COLOR_4);
            glDisable(GL_MAP1_NORMAL);
            glDisable(GL_MAP1_TEXTURE_COORD_1);
            glDisable(GL_MAP1_TEXTURE_COORD_2);
            glDisable(GL_MAP1_TEXTURE_COORD_3);
            glDisable(GL_MAP1_TEXTURE_COORD_4);*/
      do_nurbs_surface(nobj);
      glPopAttrib();
      break;
   default:
      call_user_error(nobj, GLU_NURBS_ERROR8);
   }
   nobj->nurbs_type = GLU_NURBS_NONE;
}
Exemple #7
0
void GLAPIENTRY
gluEndTrim(GLUnurbsObj * nobj)
{
   if (nobj->nurbs_type != GLU_NURBS_TRIM) {
      call_user_error(nobj, GLU_NURBS_ERROR17);
      return;
   }
   nobj->nurbs_type = GLU_NURBS_TRIM_DONE;
}
Exemple #8
0
void GLAPIENTRY
gluBeginCurve(GLUnurbsObj * nobj)
{
   if (nobj->nurbs_type == GLU_NURBS_CURVE) {
      call_user_error(nobj, GLU_NURBS_ERROR6);
      return;
   }
   nobj->nurbs_type = GLU_NURBS_CURVE;
   nobj->curve.geom.type = GLU_INVALID_ENUM;
   nobj->curve.color.type = GLU_INVALID_ENUM;
   nobj->curve.texture.type = GLU_INVALID_ENUM;
   nobj->curve.normal.type = GLU_INVALID_ENUM;
}
Exemple #9
0
void GLAPIENTRY
gluBeginSurface(GLUnurbsObj * nobj)
{
   switch (nobj->nurbs_type) {
   case GLU_NURBS_NONE:
      nobj->nurbs_type = GLU_NURBS_SURFACE;
      nobj->surface.geom.type = GLU_INVALID_ENUM;
      nobj->surface.color.type = GLU_INVALID_ENUM;
      nobj->surface.texture.type = GLU_INVALID_ENUM;
      nobj->surface.normal.type = GLU_INVALID_ENUM;
      break;
   case GLU_NURBS_TRIM:
      call_user_error(nobj, GLU_NURBS_ERROR16);
      break;
   case GLU_NURBS_SURFACE:
   case GLU_NURBS_NO_TRIM:
   case GLU_NURBS_TRIM_DONE:
      call_user_error(nobj, GLU_NURBS_ERROR27);
      break;
   case GLU_NURBS_CURVE:
      call_user_error(nobj, GLU_NURBS_ERROR6);
      break;
   }
}
Exemple #10
0
void GLAPIENTRY
gluGetNurbsProperty(GLUnurbsObj * nobj, GLenum property, GLfloat * value)
{
   switch (property) {
   case GLU_SAMPLING_TOLERANCE:
      *value = nobj->sampling_tolerance;
      break;
   case GLU_DISPLAY_MODE:
      *value = (GLfloat) (GLint) nobj->display_mode;
      break;
   case GLU_CULLING:
      *value = nobj->culling ? 1.0 : 0.0;
      break;
   case GLU_AUTO_LOAD_MATRIX:
      *value = nobj->auto_load_matrix ? 1.0 : 0.0;
      break;
   default:
      call_user_error(nobj, GLU_INVALID_ENUM);
   }
}
Exemple #11
0
/* sequence of adjacent Bezier patches */
static GLenum
convert_surfs(GLUnurbsObj *nobj, new_ctrl_type *new_ctrl)
{
	knot_str_type	geom_s_knot,color_s_knot,normal_s_knot,texture_s_knot;
	knot_str_type	geom_t_knot,color_t_knot,normal_t_knot,texture_t_knot;
	GLenum			err;

	if((err=fill_knot_structures(nobj,&geom_s_knot,&geom_t_knot,
		&color_s_knot,&color_t_knot,&normal_s_knot,&normal_t_knot,
		&texture_s_knot,&texture_t_knot)) !=GLU_NO_ERROR)
	{
		return err;
	}
	/* unify knots - all knots should have the same working range */
	if((err=select_knot_working_range(nobj,&geom_s_knot,&color_s_knot,
		&normal_s_knot,&texture_s_knot)) !=GLU_NO_ERROR)
	{
		call_user_error(nobj,err);
		return err;
	}
	if((err=select_knot_working_range(nobj,&geom_t_knot,&color_t_knot,
		&normal_t_knot,&texture_t_knot)) !=GLU_NO_ERROR)
	{
		free_unified_knots(&geom_s_knot,&color_s_knot,&normal_s_knot,
			&texture_s_knot);
		call_user_error(nobj,err);
		return err;
	}

	/* convert the geometry surface */
	nobj->surface.geom.dim=get_surface_dim(nobj->surface.geom.type);
	if((err=convert_surf(&geom_s_knot,&geom_t_knot,&(nobj->surface.geom),
		&(new_ctrl->geom_ctrl),&(new_ctrl->geom_s_pt_cnt),
		&(new_ctrl->geom_t_pt_cnt)))!=GLU_NO_ERROR)
	{
		free_unified_knots(&geom_s_knot,&color_s_knot,&normal_s_knot,
			&texture_s_knot);
		free_unified_knots(&geom_t_knot,&color_t_knot,&normal_t_knot,
			&texture_t_knot);
		call_user_error(nobj,err);
		return err;
	}
	/* if additional attributive surfaces are given convert them as well */
	if(color_s_knot.unified_knot)
	{
		nobj->surface.color.dim=get_surface_dim(nobj->surface.color.type);
		if((err=convert_surf(&color_s_knot,&color_t_knot,&(nobj->surface.color),
			&(new_ctrl->color_ctrl),&(new_ctrl->color_s_pt_cnt),
			&(new_ctrl->color_t_pt_cnt)))!=GLU_NO_ERROR)
		{
			free_unified_knots(&color_s_knot,&color_s_knot,&normal_s_knot,
				&texture_s_knot);
			free_unified_knots(&color_t_knot,&color_t_knot,&normal_t_knot,
				&texture_t_knot);
			free_new_ctrl(new_ctrl);
			call_user_error(nobj,err);
			return err;
		}
	}
	if(normal_s_knot.unified_knot)
	{
		nobj->surface.normal.dim=get_surface_dim(nobj->surface.normal.type);
		if((err=convert_surf(&normal_s_knot,&normal_t_knot,
			&(nobj->surface.normal),
			&(new_ctrl->normal_ctrl),&(new_ctrl->normal_s_pt_cnt),
			&(new_ctrl->normal_t_pt_cnt)))!=GLU_NO_ERROR)
		{
			free_unified_knots(&normal_s_knot,&normal_s_knot,&normal_s_knot,
				&texture_s_knot);
			free_unified_knots(&normal_t_knot,&normal_t_knot,&normal_t_knot,
				&texture_t_knot);
			free_new_ctrl(new_ctrl);
			call_user_error(nobj,err);
			return err;
		}
	}
	if(texture_s_knot.unified_knot)
	{
		nobj->surface.texture.dim=get_surface_dim(nobj->surface.texture.type);
		if((err=convert_surf(&texture_s_knot,&texture_t_knot,
			&(nobj->surface.texture),
			&(new_ctrl->texture_ctrl),&(new_ctrl->texture_s_pt_cnt),
			&(new_ctrl->texture_t_pt_cnt)))!=GLU_NO_ERROR)
		{
			free_unified_knots(&texture_s_knot,&texture_s_knot,&texture_s_knot,
				&texture_s_knot);
			free_unified_knots(&texture_t_knot,&texture_t_knot,&texture_t_knot,
				&texture_t_knot);
			free_new_ctrl(new_ctrl);
			call_user_error(nobj,err);
			return err;
		}
	}
	return GLU_NO_ERROR;
}
Exemple #12
0
/* prepare the knot information structures */
static GLenum
fill_knot_structures(GLUnurbsObj *nobj,
	knot_str_type *geom_s_knot, knot_str_type *geom_t_knot,
	knot_str_type *color_s_knot, knot_str_type *color_t_knot,
	knot_str_type *normal_s_knot,  knot_str_type *normal_t_knot,
	knot_str_type *texture_s_knot, knot_str_type *texture_t_knot)
{
	GLint order;
	GLfloat *knot;
	GLint nknots;
	GLint t_min,t_max;

	geom_s_knot->unified_knot=NULL;
	knot=geom_s_knot->knot=nobj->surface.geom.sknot;
	nknots=geom_s_knot->nknots=nobj->surface.geom.sknot_count;
	order=geom_s_knot->order=nobj->surface.geom.sorder;
	geom_s_knot->delta_nknots=0;
	t_min=geom_s_knot->t_min=order-1;
	t_max=geom_s_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_s_knot->open_at_begin=GL_TRUE;
	}
	else
		geom_s_knot->open_at_begin=GL_FALSE;
	if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
	{
		/* knot open at end */
		geom_s_knot->open_at_end=GL_TRUE;
	}
	else
		geom_s_knot->open_at_end=GL_FALSE;
	geom_t_knot->unified_knot=NULL;
	knot=geom_t_knot->knot=nobj->surface.geom.tknot;
	nknots=geom_t_knot->nknots=nobj->surface.geom.tknot_count;
	order=geom_t_knot->order=nobj->surface.geom.torder;
	geom_t_knot->delta_nknots=0;
	t_min=geom_t_knot->t_min=order-1;
	t_max=geom_t_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_t_knot->open_at_begin=GL_TRUE;
	}
	else
		geom_t_knot->open_at_begin=GL_FALSE;
	if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
	{
		/* knot open at end */
		geom_t_knot->open_at_end=GL_TRUE;
	}
	else
		geom_t_knot->open_at_end=GL_FALSE;

	if(nobj->surface.color.type!=GLU_INVALID_ENUM)
	{
		color_s_knot->unified_knot=(GLfloat *)1;
		knot=color_s_knot->knot=nobj->surface.color.sknot;
		nknots=color_s_knot->nknots=nobj->surface.color.sknot_count;
		order=color_s_knot->order=nobj->surface.color.sorder;
		color_s_knot->delta_nknots=0;
		t_min=color_s_knot->t_min=order-1;
		t_max=color_s_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_s_knot->open_at_begin=GL_TRUE;
		}
		else
			color_s_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			color_s_knot->open_at_end=GL_TRUE;
		}
		else
			color_s_knot->open_at_end=GL_FALSE;
		color_t_knot->unified_knot=(GLfloat *)1;
		knot=color_t_knot->knot=nobj->surface.color.tknot;
		nknots=color_t_knot->nknots=nobj->surface.color.tknot_count;
		order=color_t_knot->order=nobj->surface.color.torder;
		color_t_knot->delta_nknots=0;
		t_min=color_t_knot->t_min=order-1;
		t_max=color_t_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_t_knot->open_at_begin=GL_TRUE;
		}
		else
			color_t_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			color_t_knot->open_at_end=GL_TRUE;
		}
		else
			color_t_knot->open_at_end=GL_FALSE;
	}
	else
	{
		color_s_knot->unified_knot=NULL;
		color_t_knot->unified_knot=NULL;
	}

	if(nobj->surface.normal.type!=GLU_INVALID_ENUM)
	{
		normal_s_knot->unified_knot=(GLfloat *)1;
		knot=normal_s_knot->knot=nobj->surface.normal.sknot;
		nknots=normal_s_knot->nknots=nobj->surface.normal.sknot_count;
		order=normal_s_knot->order=nobj->surface.normal.sorder;
		normal_s_knot->delta_nknots=0;
		t_min=normal_s_knot->t_min=order-1;
		t_max=normal_s_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_s_knot->open_at_begin=GL_TRUE;
		}
		else
			normal_s_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			normal_s_knot->open_at_end=GL_TRUE;
		}
		else
			normal_s_knot->open_at_end=GL_FALSE;
		normal_t_knot->unified_knot=(GLfloat *)1;
		knot=normal_t_knot->knot=nobj->surface.normal.tknot;
		nknots=normal_t_knot->nknots=nobj->surface.normal.tknot_count;
		order=normal_t_knot->order=nobj->surface.normal.torder;
		normal_t_knot->delta_nknots=0;
		t_min=normal_t_knot->t_min=order-1;
		t_max=normal_t_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_t_knot->open_at_begin=GL_TRUE;
		}
		else
			normal_t_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			normal_t_knot->open_at_end=GL_TRUE;
		}
		else
			normal_t_knot->open_at_end=GL_FALSE;
	}
	else
	{
		normal_s_knot->unified_knot=NULL;
		normal_t_knot->unified_knot=NULL;
	}

	if(nobj->surface.texture.type!=GLU_INVALID_ENUM)
	{
		texture_s_knot->unified_knot=(GLfloat *)1;
		knot=texture_s_knot->knot=nobj->surface.texture.sknot;
		nknots=texture_s_knot->nknots=nobj->surface.texture.sknot_count;
		order=texture_s_knot->order=nobj->surface.texture.sorder;
		texture_s_knot->delta_nknots=0;
		t_min=texture_s_knot->t_min=order-1;
		t_max=texture_s_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_s_knot->open_at_begin=GL_TRUE;
		}
		else
			texture_s_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			texture_s_knot->open_at_end=GL_TRUE;
		}
		else
			texture_s_knot->open_at_end=GL_FALSE;
		texture_t_knot->unified_knot=(GLfloat *)1;
		knot=texture_t_knot->knot=nobj->surface.texture.tknot;
		nknots=texture_t_knot->nknots=nobj->surface.texture.tknot_count;
		order=texture_t_knot->order=nobj->surface.texture.torder;
		texture_t_knot->delta_nknots=0;
		t_min=texture_t_knot->t_min=order-1;
		t_max=texture_t_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_t_knot->open_at_begin=GL_TRUE;
		}
		else
			texture_t_knot->open_at_begin=GL_FALSE;
		if(fabs(knot[t_max]-knot[nknots-1])<EPSILON)
		{
			/* knot open at end */
			texture_t_knot->open_at_end=GL_TRUE;
		}
		else
			texture_t_knot->open_at_end=GL_FALSE;
	}
	else
	{
		texture_s_knot->unified_knot=NULL;
		texture_t_knot->unified_knot=NULL;
	}
	return GLU_NO_ERROR;
}
Exemple #13
0
GLenum
augment_new_ctrl(GLUnurbsObj *nobj, new_ctrl_type *p)
{
	GLsizei offset_size;
	GLint	i,j;

	p->s_bezier_cnt=(p->geom_s_pt_cnt)/(nobj->surface.geom.sorder);
	p->t_bezier_cnt=(p->geom_t_pt_cnt)/(nobj->surface.geom.torder);
	offset_size=(p->s_bezier_cnt)*(p->t_bezier_cnt);
	p->geom_t_stride=nobj->surface.geom.dim;
	p->geom_s_stride=(p->geom_t_pt_cnt)*(nobj->surface.geom.dim);
	p->color_t_stride=nobj->surface.color.dim;
	p->color_s_stride=(p->color_t_pt_cnt)*(nobj->surface.color.dim);
	p->normal_t_stride=nobj->surface.normal.dim;
	p->normal_s_stride=(p->normal_t_pt_cnt)*(nobj->surface.normal.dim);
	p->texture_t_stride=nobj->surface.texture.dim;
	p->texture_s_stride=(p->texture_t_pt_cnt)*(nobj->surface.texture.dim);
	if((p->geom_offsets=(GLfloat **)malloc(sizeof(GLfloat *)*offset_size))==NULL)
	{
		call_user_error(nobj,GLU_OUT_OF_MEMORY);
		return GLU_ERROR;
	}
	if(p->color_ctrl)
		if((p->color_offsets=(GLfloat **)malloc(sizeof(GLfloat *)*offset_size))==NULL)
		{
			free_new_ctrl(p);
			call_user_error(nobj,GLU_OUT_OF_MEMORY);
			return GLU_ERROR;
		}
	if(p->normal_ctrl)
		if((p->normal_offsets=(GLfloat **)malloc(sizeof(GLfloat *)*offset_size))==NULL)
		{
			free_new_ctrl(p);
			call_user_error(nobj,GLU_OUT_OF_MEMORY);
			return GLU_ERROR;
		}
	if(p->texture_ctrl)
		if((p->texture_offsets=(GLfloat **)malloc(sizeof(GLfloat *)*offset_size))==NULL)
		{
			free_new_ctrl(p);
			call_user_error(nobj,GLU_OUT_OF_MEMORY);
			return GLU_ERROR;
		}
	for(i=0;i<p->s_bezier_cnt;i++)
		for(j=0;j<p->t_bezier_cnt;j++)
			*(p->geom_offsets + i*(p->t_bezier_cnt) + j) =
				p->geom_ctrl + i*(nobj->surface.geom.sorder)*
				(nobj->surface.geom.dim)*(p->geom_t_pt_cnt) +
				j*(nobj->surface.geom.dim)*(nobj->surface.geom.torder);
	if(p->color_ctrl)
		for(i=0;i<p->s_bezier_cnt;i++)
			for(j=0;j<p->t_bezier_cnt;j++)
				*(p->color_offsets + i*(p->t_bezier_cnt) + j) =
					p->color_ctrl + i*(nobj->surface.color.sorder)*
					(nobj->surface.color.dim)*(p->color_t_pt_cnt) +
					j*(nobj->surface.color.dim)*(nobj->surface.color.torder);
	if(p->normal_ctrl)
		for(i=0;i<p->s_bezier_cnt;i++)
			for(j=0;j<p->t_bezier_cnt;j++)
				*(p->normal_offsets + i*(p->t_bezier_cnt) + j) =
					p->normal_ctrl + i*(nobj->surface.normal.sorder)*
					(nobj->surface.normal.dim)*(p->normal_t_pt_cnt) +
					j*(nobj->surface.normal.dim)*(nobj->surface.normal.torder);
	if(p->texture_ctrl)
		for(i=0;i<p->s_bezier_cnt;i++)
			for(j=0;j<p->t_bezier_cnt;j++)
				*(p->texture_offsets + i*(p->t_bezier_cnt) + j) =
					p->texture_ctrl + i*(nobj->surface.texture.sorder)*
					(nobj->surface.texture.dim)*(p->texture_t_pt_cnt) +
					j*(nobj->surface.texture.dim)*(nobj->surface.texture.torder);
	return GLU_NO_ERROR;
}
Exemple #14
0
void GLAPIENTRY
gluNurbsSurface(GLUnurbsObj * nobj,
		GLint sknot_count, GLfloat * sknot,
		GLint tknot_count, GLfloat * tknot,
		GLint s_stride, GLint t_stride,
		GLfloat * ctrlarray, GLint sorder, GLint torder, GLenum type)
{
   if (nobj->nurbs_type == GLU_NURBS_NO_TRIM
       || nobj->nurbs_type == GLU_NURBS_TRIM
       || nobj->nurbs_type == GLU_NURBS_TRIM_DONE) {
      if (type == GL_MAP2_VERTEX_3 || type == GL_MAP2_VERTEX_4) {
	 call_user_error(nobj, GLU_NURBS_ERROR8);
	 return;
      }
   }
   else if (nobj->nurbs_type != GLU_NURBS_SURFACE) {
      call_user_error(nobj, GLU_NURBS_ERROR11);
      return;
   }
   switch (type) {
   case GL_MAP2_VERTEX_3:
   case GL_MAP2_VERTEX_4:
      nobj->surface.geom.sknot_count = sknot_count;
      nobj->surface.geom.sknot = sknot;
      nobj->surface.geom.tknot_count = tknot_count;
      nobj->surface.geom.tknot = tknot;
      nobj->surface.geom.s_stride = s_stride;
      nobj->surface.geom.t_stride = t_stride;
      nobj->surface.geom.ctrlarray = ctrlarray;
      nobj->surface.geom.sorder = sorder;
      nobj->surface.geom.torder = torder;
      nobj->surface.geom.type = type;
      nobj->nurbs_type = GLU_NURBS_NO_TRIM;
      break;
   case GL_MAP2_INDEX:
   case GL_MAP2_COLOR_4:
      nobj->surface.color.sknot_count = sknot_count;
      nobj->surface.color.sknot = sknot;
      nobj->surface.color.tknot_count = tknot_count;
      nobj->surface.color.tknot = tknot;
      nobj->surface.color.s_stride = s_stride;
      nobj->surface.color.t_stride = t_stride;
      nobj->surface.color.ctrlarray = ctrlarray;
      nobj->surface.color.sorder = sorder;
      nobj->surface.color.torder = torder;
      nobj->surface.color.type = type;
      break;
   case GL_MAP2_NORMAL:
      nobj->surface.normal.sknot_count = sknot_count;
      nobj->surface.normal.sknot = sknot;
      nobj->surface.normal.tknot_count = tknot_count;
      nobj->surface.normal.tknot = tknot;
      nobj->surface.normal.s_stride = s_stride;
      nobj->surface.normal.t_stride = t_stride;
      nobj->surface.normal.ctrlarray = ctrlarray;
      nobj->surface.normal.sorder = sorder;
      nobj->surface.normal.torder = torder;
      nobj->surface.normal.type = type;
      break;
   case GL_MAP2_TEXTURE_COORD_1:
   case GL_MAP2_TEXTURE_COORD_2:
   case GL_MAP2_TEXTURE_COORD_3:
   case GL_MAP2_TEXTURE_COORD_4:
      nobj->surface.texture.sknot_count = sknot_count;
      nobj->surface.texture.sknot = sknot;
      nobj->surface.texture.tknot_count = tknot_count;
      nobj->surface.texture.tknot = tknot;
      nobj->surface.texture.s_stride = s_stride;
      nobj->surface.texture.t_stride = t_stride;
      nobj->surface.texture.ctrlarray = ctrlarray;
      nobj->surface.texture.sorder = sorder;
      nobj->surface.texture.torder = torder;
      nobj->surface.texture.type = type;
      break;
   default:
      call_user_error(nobj, GLU_INVALID_ENUM);
   }
}
Exemple #15
0
void GLAPIENTRY
gluNurbsCurve(GLUnurbsObj * nobj, GLint nknots, GLfloat * knot,
	      GLint stride, GLfloat * ctlarray, GLint order, GLenum type)
{
   if (nobj->nurbs_type == GLU_NURBS_TRIM) {
#if 0
/* TODO: NOT IMPLEMENTED YET */
      nurbs_trim *ptr1;
      trim_list *ptr2;

      if (type != GLU_MAP1_TRIM_2 && type != GLU_MAP1_TRIM_3) {
	 call_user_error(nobj, GLU_NURBS_ERROR14);
	 return;
      }
      for (ptr1 = nobj->trim; ptr1->next; ptr1 = ptr1->next);
      if (ptr1->trim_loop) {
	 for (ptr2 = ptr1->trim_loop; ptr2->next; ptr2 = ptr2->next);
	 if ((ptr2->next = (trim_list *) malloc(sizeof(trim_list))) == NULL) {
	    call_user_error(nobj, GLU_OUT_OF_MEMORY);
	    return;
	 }
	 ptr2 = ptr2->next;
      }
      else {
	 if ((ptr2 = (trim_list *) malloc(sizeof(trim_list))) == NULL) {
	    call_user_error(nobj, GLU_OUT_OF_MEMORY);
	    return;
	 }
	 ptr1->trim_loop = ptr2;
      }
      ptr2->trim_type = GLU_TRIM_NURBS;
      ptr2->curve.nurbs_curve.knot_count = nknots;
      ptr2->curve.nurbs_curve.knot = knot;
      ptr2->curve.nurbs_curve.stride = stride;
      ptr2->curve.nurbs_curve.ctrlarray = ctlarray;
      ptr2->curve.nurbs_curve.order = order;
      ptr2->curve.nurbs_curve.dim = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
      ptr2->curve.nurbs_curve.type = type;
      ptr2->next = NULL;
#endif
   }
   else {
      if (type == GLU_MAP1_TRIM_2 || type == GLU_MAP1_TRIM_3) {
	 call_user_error(nobj, GLU_NURBS_ERROR22);
	 return;
      }
      if (nobj->nurbs_type != GLU_NURBS_CURVE) {
	 call_user_error(nobj, GLU_NURBS_ERROR10);
	 return;
      }
      switch (type) {
      case GL_MAP1_VERTEX_3:
      case GL_MAP1_VERTEX_4:
	 if (nobj->curve.geom.type != GLU_INVALID_ENUM) {
	    call_user_error(nobj, GLU_NURBS_ERROR8);
	    return;
	 }
	 nobj->curve.geom.type = type;
	 nobj->curve.geom.knot_count = nknots;
	 nobj->curve.geom.knot = knot;
	 nobj->curve.geom.stride = stride;
	 nobj->curve.geom.ctrlarray = ctlarray;
	 nobj->curve.geom.order = order;
	 break;
      case GL_MAP1_INDEX:
      case GL_MAP1_COLOR_4:
	 nobj->curve.color.type = type;
	 nobj->curve.color.knot_count = nknots;
	 nobj->curve.color.knot = knot;
	 nobj->curve.color.stride = stride;
	 nobj->curve.color.ctrlarray = ctlarray;
	 nobj->curve.color.order = order;
	 break;
      case GL_MAP1_NORMAL:
	 nobj->curve.normal.type = type;
	 nobj->curve.normal.knot_count = nknots;
	 nobj->curve.normal.knot = knot;
	 nobj->curve.normal.stride = stride;
	 nobj->curve.normal.ctrlarray = ctlarray;
	 nobj->curve.normal.order = order;
	 break;
      case GL_MAP1_TEXTURE_COORD_1:
      case GL_MAP1_TEXTURE_COORD_2:
      case GL_MAP1_TEXTURE_COORD_3:
      case GL_MAP1_TEXTURE_COORD_4:
	 nobj->curve.texture.type = type;
	 nobj->curve.texture.knot_count = nknots;
	 nobj->curve.texture.knot = knot;
	 nobj->curve.texture.stride = stride;
	 nobj->curve.texture.ctrlarray = ctlarray;
	 nobj->curve.texture.order = order;
	 break;
      default:
	 call_user_error(nobj, GLU_INVALID_ENUM);
      }
   }
}
Exemple #16
0
void GLAPIENTRY
gluNurbsProperty(GLUnurbsObj * nobj, GLenum property, GLfloat value)
{
   GLenum val;

   switch (property) {
   case GLU_SAMPLING_TOLERANCE:
      if (value <= 0.0) {
	 call_user_error(nobj, GLU_INVALID_VALUE);
	 return;
      }
      nobj->sampling_tolerance = value;
      break;
   case GLU_PARAMETRIC_TOLERANCE:
      if (value <= 0.0) {
	 call_user_error(nobj, GLU_INVALID_VALUE);
	 return;
      }
      nobj->parametric_tolerance = value;
      break;
   case GLU_U_STEP:
      if (value <= 0.0) {
	 call_user_error(nobj, GLU_INVALID_VALUE);
	 return;
      }
      nobj->u_step = (GLint) value;
      break;
   case GLU_V_STEP:
      if (value <= 0.0) {
	 call_user_error(nobj, GLU_INVALID_VALUE);
	 return;
      }
      nobj->v_step = (GLint) value;
      break;
   case GLU_SAMPLING_METHOD:
      val = (GLenum) value;
      if (val != GLU_PATH_LENGTH && val != GLU_PARAMETRIC_ERROR
	  && val != GLU_DOMAIN_DISTANCE) {
	 call_user_error(nobj, GLU_INVALID_ENUM);
	 return;
      }
      nobj->sampling_method = val;
      break;
   case GLU_DISPLAY_MODE:
      val = (GLenum) value;
      if (val != GLU_FILL && val != GLU_OUTLINE_POLYGON
	  && val != GLU_OUTLINE_PATCH) {
	 call_user_error(nobj, GLU_INVALID_ENUM);
	 return;
      }
      if (nobj->nurbs_type == GLU_NURBS_CURVE) {
	 call_user_error(nobj, GLU_NURBS_ERROR26);
	 return;
      }
      nobj->display_mode = val;
      if (val == GLU_OUTLINE_PATCH)
	 fprintf(stderr,
		 "NURBS, for the moment, can display only in POLYGON mode\n");
      break;
   case GLU_CULLING:
      val = (GLenum) value;
      if (val != GL_TRUE && val != GL_FALSE) {
	 call_user_error(nobj, GLU_INVALID_ENUM);
	 return;
      }
      nobj->culling = (GLboolean) value;
      break;
   case GLU_AUTO_LOAD_MATRIX:
      val = (GLenum) value;
      if (val != GL_TRUE && val != GL_FALSE) {
	 call_user_error(nobj, GLU_INVALID_ENUM);
	 return;
      }
      nobj->auto_load_matrix = (GLboolean) value;
      break;
   default:
      call_user_error(nobj, GLU_NURBS_ERROR26);
   }
}