WebSVN - shark - Blame - Rev 1618 - /shark/branches/xen/ports/mesa/src-glu/nurbssrf.c

Rev	Author	Line No.	Line
55	pj	1	/* $Id: nurbssrf.c,v 1.1 2003-02-28 11:42:07 pj Exp $ */
		2
		3	/*
		4	* Mesa 3-D graphics library
		5	* Version: 3.3
		6	* Copyright (C) 1995-2000 Brian Paul
		7	*
		8	* This library is free software; you can redistribute it and/or
		9	* modify it under the terms of the GNU Library General Public
		10	* License as published by the Free Software Foundation; either
		11	* version 2 of the License, or (at your option) any later version.
		12	*
		13	* This library is distributed in the hope that it will be useful,
		14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		16	* Library General Public License for more details.
		17	*
		18	* You should have received a copy of the GNU Library General Public
		19	* License along with this library; if not, write to the Free
		20	* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		21	*/
		22
		23
		24	/*
		25	* NURBS implementation written by Bogdan Sikorski (bogdan@cira.it)
		26	* See README2 for more info.
		27	*/
		28
		29
		30	#ifdef PC_HEADER
		31	#include "all.h"
		32	#else
		33	#include <math.h>
		34	#include <stdlib.h>
		35	#include <string.h>
		36	#include "gluP.h"
		37	#include "nurbs.h"
		38	#endif
		39
		40
		41	static int
		42	get_surface_dim(GLenum type)
		43	{
		44	switch (type) {
		45	case GL_MAP2_VERTEX_3:
		46	return 3;
		47	case GL_MAP2_VERTEX_4:
		48	return 4;
		49	case GL_MAP2_INDEX:
		50	return 1;
		51	case GL_MAP2_COLOR_4:
		52	return 4;
		53	case GL_MAP2_NORMAL:
		54	return 3;
		55	case GL_MAP2_TEXTURE_COORD_1:
		56	return 1;
		57	case GL_MAP2_TEXTURE_COORD_2:
		58	return 2;
		59	case GL_MAP2_TEXTURE_COORD_3:
		60	return 3;
		61	case GL_MAP2_TEXTURE_COORD_4:
		62	return 4;
		63	default:
		64	abort(); /* TODO: is this OK? */
		65	}
		66	return 0; /never get here /
		67	}
		68
		69	static GLenum
		70	test_nurbs_surface(GLUnurbsObj * nobj, surface_attribs * attrib)
		71	{
		72	GLenum err;
		73	GLint tmp_int;
		74
		75	if (attrib->sorder < 0 \|\| attrib->torder < 0) {
		76	call_user_error(nobj, GLU_INVALID_VALUE);
		77	return GLU_ERROR;
		78	}
		79	glGetIntegerv(GL_MAX_EVAL_ORDER, &tmp_int);
		80	if (attrib->sorder > tmp_int \|\| attrib->sorder < 2) {
		81	call_user_error(nobj, GLU_NURBS_ERROR1);
		82	return GLU_ERROR;
		83	}
		84	if (attrib->torder > tmp_int \|\| attrib->torder < 2) {
		85	call_user_error(nobj, GLU_NURBS_ERROR1);
		86	return GLU_ERROR;
		87	}
		88	if (attrib->sknot_count < attrib->sorder + 2) {
		89	call_user_error(nobj, GLU_NURBS_ERROR2);
		90	return GLU_ERROR;
		91	}
		92	if (attrib->tknot_count < attrib->torder + 2) {
		93	call_user_error(nobj, GLU_NURBS_ERROR2);
		94	return GLU_ERROR;
		95	}
		96	if (attrib->s_stride < 0 \|\| attrib->t_stride < 0) {
		97	call_user_error(nobj, GLU_NURBS_ERROR34);
		98	return GLU_ERROR;
		99	}
		100	if (attrib->sknot == NULL \|\| attrib->tknot == NULL
		101	\|\| attrib->ctrlarray == NULL) {
		102	call_user_error(nobj, GLU_NURBS_ERROR36);
		103	return GLU_ERROR;
		104	}
		105	if ((err = test_knot(attrib->tknot_count, attrib->tknot, attrib->torder))
		106	!= GLU_NO_ERROR) {
		107	call_user_error(nobj, err);
		108	return GLU_ERROR;
		109	}
		110	if ((err = test_knot(attrib->sknot_count, attrib->sknot, attrib->sorder))
		111	!= GLU_NO_ERROR) {
		112	call_user_error(nobj, err);
		113	return GLU_ERROR;
		114	}
		115	return GLU_NO_ERROR;
		116	}
		117
		118	static GLenum
		119	test_nurbs_surfaces(GLUnurbsObj * nobj)
		120	{
		121	/* test the geometric data */
		122	if (test_nurbs_surface(nobj, &(nobj->surface.geom)) != GLU_NO_ERROR)
		123	return GLU_ERROR;
		124	/* now test the attributive data */
		125	/* color */
		126	if (nobj->surface.color.type != GLU_INVALID_ENUM)
		127	if (test_nurbs_surface(nobj, &(nobj->surface.color)) != GLU_NO_ERROR)
		128	return GLU_ERROR;
		129	/* normal */
		130	if (nobj->surface.normal.type != GLU_INVALID_ENUM)
		131	if (test_nurbs_surface(nobj, &(nobj->surface.normal)) != GLU_NO_ERROR)
		132	return GLU_ERROR;
		133	/* texture */
		134	if (nobj->surface.texture.type != GLU_INVALID_ENUM)
		135	if (test_nurbs_surface(nobj, &(nobj->surface.texture)) != GLU_NO_ERROR)
		136	return GLU_ERROR;
		137	return GLU_NO_ERROR;
		138	}
		139
		140	static GLenum
		141	convert_surf(knot_str_type * s_knot, knot_str_type * t_knot,
		142	surface_attribs * attrib, GLfloat ** new_ctrl,
		143	GLint * s_n_ctrl, GLint * t_n_ctrl)
		144	{
		145	GLfloat **tmp_ctrl;
		146	GLfloat *ctrl_offset;
		147	GLint tmp_n_control;
		148	GLint i, j, t_cnt, s_cnt;
		149	GLint tmp_stride;
		150	GLint dim;
		151	GLenum err;
		152
		153	/* valid range is empty? */
		154	if ((s_knot->unified_knot != NULL && s_knot->unified_nknots == 0) \|\|
		155	(t_knot->unified_knot != NULL && t_knot->unified_nknots == 0)) {
		156	if (s_knot->unified_knot) {
		157	free(s_knot->unified_knot);
		158	s_knot->unified_knot = NULL;
		159	}
		160	if (t_knot->unified_knot) {
		161	free(t_knot->unified_knot);
		162	t_knot->unified_knot = NULL;
		163	}
		164	*s_n_ctrl = 0;
		165	*t_n_ctrl = 0;
		166	return GLU_NO_ERROR;
		167	}
		168	t_cnt = attrib->tknot_count - attrib->torder;
		169	s_cnt = attrib->sknot_count - attrib->sorder;
		170	if ((tmp_ctrl = (GLfloat *) malloc(sizeof(GLfloat ) * t_cnt)) == NULL)
		171	return GLU_OUT_OF_MEMORY;
		172	if ((err = explode_knot(s_knot)) != GLU_NO_ERROR) {
		173	free(tmp_ctrl);
		174	if (s_knot->unified_knot) {
		175	free(s_knot->unified_knot);
		176	s_knot->unified_knot = NULL;
		177	}
		178	return err;
		179	}
		180	if (s_knot->unified_knot) {
		181	free(s_knot->unified_knot);
		182	s_knot->unified_knot = NULL;
		183	}
		184	if ((err = calc_alphas(s_knot)) != GLU_NO_ERROR) {
		185	free(tmp_ctrl);
		186	free(s_knot->new_knot);
		187	return err;
		188	}
		189	free(s_knot->new_knot);
		190	ctrl_offset = attrib->ctrlarray;
		191	dim = attrib->dim;
		192	for (i = 0; i < t_cnt; i++) {
		193	if ((err = calc_new_ctrl_pts(ctrl_offset, attrib->s_stride, s_knot,
		194	dim, &(tmp_ctrl[i]),
		195	&tmp_n_control)) != GLU_NO_ERROR) {
		196	for (--i; i <= 0; i--)
		197	free(tmp_ctrl[i]);
		198	free(tmp_ctrl);
		199	free(s_knot->alpha);
		200	return err;
		201	}
		202	ctrl_offset += attrib->t_stride;
		203	}
		204	free(s_knot->alpha);
		205	tmp_stride = dim * tmp_n_control;
		206	if ((new_ctrl = (GLfloat ) malloc(sizeof(GLfloat) * tmp_stride * t_cnt))
		207	== NULL) {
		208	for (i = 0; i < t_cnt; i++)
		209	free(tmp_ctrl[i]);
		210	free(tmp_ctrl);
		211	return GLU_OUT_OF_MEMORY;
		212	}
		213	for (i = 0; i < tmp_n_control; i++)
		214	for (j = 0; j < t_cnt; j++)
		215	MEMCPY(new_ctrl + j dim + i * dim * t_cnt, tmp_ctrl[j] + dim * i,
		216	sizeof(GLfloat) * dim);
		217	for (i = 0; i < t_cnt; i++)
		218	free(tmp_ctrl[i]);
		219	free(tmp_ctrl);
		220	*s_n_ctrl = tmp_n_control;
		221
		222	if ((tmp_ctrl = (GLfloat *) malloc(sizeof(GLfloat ) * (*s_n_ctrl))) ==
		223	NULL) {
		224	return GLU_OUT_OF_MEMORY;
		225	}
		226	if ((err = explode_knot(t_knot)) != GLU_NO_ERROR) {
		227	free(tmp_ctrl);
		228	if (t_knot->unified_knot) {
		229	free(t_knot->unified_knot);
		230	t_knot->unified_knot = NULL;
		231	}
		232	return err;
		233	}
		234	if (t_knot->unified_knot) {
		235	free(t_knot->unified_knot);
		236	t_knot->unified_knot = NULL;
		237	}
		238	if ((err = calc_alphas(t_knot)) != GLU_NO_ERROR) {
		239	free(tmp_ctrl);
		240	free(t_knot->new_knot);
		241	return err;
		242	}
		243	free(t_knot->new_knot);
		244	ctrl_offset = *new_ctrl;
		245	for (i = 0; i < (*s_n_ctrl); i++) {
		246	if ((err = calc_new_ctrl_pts(ctrl_offset, dim, t_knot,
		247	dim, &(tmp_ctrl[i]),
		248	&tmp_n_control)) != GLU_NO_ERROR) {
		249	for (--i; i <= 0; i--)
		250	free(tmp_ctrl[i]);
		251	free(tmp_ctrl);
		252	free(t_knot->alpha);
		253	return err;
		254	}
		255	ctrl_offset += dim * t_cnt;
		256	}
		257	free(t_knot->alpha);
		258	free(*new_ctrl);
		259	tmp_stride = dim * tmp_n_control;
		260	if (
		261	(*new_ctrl =
		262	(GLfloat ) malloc(sizeof(GLfloat) tmp_stride * (*s_n_ctrl))) ==
		263	NULL) {
		264	for (i = 0; i < (*s_n_ctrl); i++)
		265	free(tmp_ctrl[i]);
		266	free(tmp_ctrl);
		267	return GLU_OUT_OF_MEMORY;
		268	}
		269	for (i = 0; i < (*s_n_ctrl); i++) {
		270	MEMCPY(new_ctrl + i tmp_stride, tmp_ctrl[i],
		271	sizeof(GLfloat) * tmp_stride);
		272	free(tmp_ctrl[i]);
		273	}
		274	free(tmp_ctrl);
		275	*t_n_ctrl = tmp_n_control;
		276	return GLU_NO_ERROR;
		277	}
		278
		279	/* prepare the knot information structures */
		280	static GLenum
		281	fill_knot_structures(GLUnurbsObj * nobj,
		282	knot_str_type * geom_s_knot, knot_str_type * geom_t_knot,
		283	knot_str_type * color_s_knot,
		284	knot_str_type * color_t_knot,
		285	knot_str_type * normal_s_knot,
		286	knot_str_type * normal_t_knot,
		287	knot_str_type * texture_s_knot,
		288	knot_str_type * texture_t_knot)
		289	{
		290	GLint order;
		291	GLfloat *knot;
		292	GLint nknots;
		293	GLint t_min, t_max;
		294
		295	geom_s_knot->unified_knot = NULL;
		296	knot = geom_s_knot->knot = nobj->surface.geom.sknot;
		297	nknots = geom_s_knot->nknots = nobj->surface.geom.sknot_count;
		298	order = geom_s_knot->order = nobj->surface.geom.sorder;
		299	geom_s_knot->delta_nknots = 0;
		300	t_min = geom_s_knot->t_min = order - 1;
		301	t_max = geom_s_knot->t_max = nknots - order;
		302	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		303	call_user_error(nobj, GLU_NURBS_ERROR3);
		304	return GLU_ERROR;
		305	}
		306	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		307	/* knot open at beggining */
		308	geom_s_knot->open_at_begin = GL_TRUE;
		309	}
		310	else
		311	geom_s_knot->open_at_begin = GL_FALSE;
		312	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		313	/* knot open at end */
		314	geom_s_knot->open_at_end = GL_TRUE;
		315	}
		316	else
		317	geom_s_knot->open_at_end = GL_FALSE;
		318	geom_t_knot->unified_knot = NULL;
		319	knot = geom_t_knot->knot = nobj->surface.geom.tknot;
		320	nknots = geom_t_knot->nknots = nobj->surface.geom.tknot_count;
		321	order = geom_t_knot->order = nobj->surface.geom.torder;
		322	geom_t_knot->delta_nknots = 0;
		323	t_min = geom_t_knot->t_min = order - 1;
		324	t_max = geom_t_knot->t_max = nknots - order;
		325	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		326	call_user_error(nobj, GLU_NURBS_ERROR3);
		327	return GLU_ERROR;
		328	}
		329	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		330	/* knot open at beggining */
		331	geom_t_knot->open_at_begin = GL_TRUE;
		332	}
		333	else
		334	geom_t_knot->open_at_begin = GL_FALSE;
		335	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		336	/* knot open at end */
		337	geom_t_knot->open_at_end = GL_TRUE;
		338	}
		339	else
		340	geom_t_knot->open_at_end = GL_FALSE;
		341
		342	if (nobj->surface.color.type != GLU_INVALID_ENUM) {
		343	color_s_knot->unified_knot = (GLfloat *) 1;
		344	knot = color_s_knot->knot = nobj->surface.color.sknot;
		345	nknots = color_s_knot->nknots = nobj->surface.color.sknot_count;
		346	order = color_s_knot->order = nobj->surface.color.sorder;
		347	color_s_knot->delta_nknots = 0;
		348	t_min = color_s_knot->t_min = order - 1;
		349	t_max = color_s_knot->t_max = nknots - order;
		350	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		351	call_user_error(nobj, GLU_NURBS_ERROR3);
		352	return GLU_ERROR;
		353	}
		354	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		355	/* knot open at beggining */
		356	color_s_knot->open_at_begin = GL_TRUE;
		357	}
		358	else
		359	color_s_knot->open_at_begin = GL_FALSE;
		360	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		361	/* knot open at end */
		362	color_s_knot->open_at_end = GL_TRUE;
		363	}
		364	else
		365	color_s_knot->open_at_end = GL_FALSE;
		366	color_t_knot->unified_knot = (GLfloat *) 1;
		367	knot = color_t_knot->knot = nobj->surface.color.tknot;
		368	nknots = color_t_knot->nknots = nobj->surface.color.tknot_count;
		369	order = color_t_knot->order = nobj->surface.color.torder;
		370	color_t_knot->delta_nknots = 0;
		371	t_min = color_t_knot->t_min = order - 1;
		372	t_max = color_t_knot->t_max = nknots - order;
		373	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		374	call_user_error(nobj, GLU_NURBS_ERROR3);
		375	return GLU_ERROR;
		376	}
		377	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		378	/* knot open at beggining */
		379	color_t_knot->open_at_begin = GL_TRUE;
		380	}
		381	else
		382	color_t_knot->open_at_begin = GL_FALSE;
		383	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		384	/* knot open at end */
		385	color_t_knot->open_at_end = GL_TRUE;
		386	}
		387	else
		388	color_t_knot->open_at_end = GL_FALSE;
		389	}
		390	else {
		391	color_s_knot->unified_knot = NULL;
		392	color_t_knot->unified_knot = NULL;
		393	}
		394
		395	if (nobj->surface.normal.type != GLU_INVALID_ENUM) {
		396	normal_s_knot->unified_knot = (GLfloat *) 1;
		397	knot = normal_s_knot->knot = nobj->surface.normal.sknot;
		398	nknots = normal_s_knot->nknots = nobj->surface.normal.sknot_count;
		399	order = normal_s_knot->order = nobj->surface.normal.sorder;
		400	normal_s_knot->delta_nknots = 0;
		401	t_min = normal_s_knot->t_min = order - 1;
		402	t_max = normal_s_knot->t_max = nknots - order;
		403	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		404	call_user_error(nobj, GLU_NURBS_ERROR3);
		405	return GLU_ERROR;
		406	}
		407	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		408	/* knot open at beggining */
		409	normal_s_knot->open_at_begin = GL_TRUE;
		410	}
		411	else
		412	normal_s_knot->open_at_begin = GL_FALSE;
		413	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		414	/* knot open at end */
		415	normal_s_knot->open_at_end = GL_TRUE;
		416	}
		417	else
		418	normal_s_knot->open_at_end = GL_FALSE;
		419	normal_t_knot->unified_knot = (GLfloat *) 1;
		420	knot = normal_t_knot->knot = nobj->surface.normal.tknot;
		421	nknots = normal_t_knot->nknots = nobj->surface.normal.tknot_count;
		422	order = normal_t_knot->order = nobj->surface.normal.torder;
		423	normal_t_knot->delta_nknots = 0;
		424	t_min = normal_t_knot->t_min = order - 1;
		425	t_max = normal_t_knot->t_max = nknots - order;
		426	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		427	call_user_error(nobj, GLU_NURBS_ERROR3);
		428	return GLU_ERROR;
		429	}
		430	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		431	/* knot open at beggining */
		432	normal_t_knot->open_at_begin = GL_TRUE;
		433	}
		434	else
		435	normal_t_knot->open_at_begin = GL_FALSE;
		436	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		437	/* knot open at end */
		438	normal_t_knot->open_at_end = GL_TRUE;
		439	}
		440	else
		441	normal_t_knot->open_at_end = GL_FALSE;
		442	}
		443	else {
		444	normal_s_knot->unified_knot = NULL;
		445	normal_t_knot->unified_knot = NULL;
		446	}
		447
		448	if (nobj->surface.texture.type != GLU_INVALID_ENUM) {
		449	texture_s_knot->unified_knot = (GLfloat *) 1;
		450	knot = texture_s_knot->knot = nobj->surface.texture.sknot;
		451	nknots = texture_s_knot->nknots = nobj->surface.texture.sknot_count;
		452	order = texture_s_knot->order = nobj->surface.texture.sorder;
		453	texture_s_knot->delta_nknots = 0;
		454	t_min = texture_s_knot->t_min = order - 1;
		455	t_max = texture_s_knot->t_max = nknots - order;
		456	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		457	call_user_error(nobj, GLU_NURBS_ERROR3);
		458	return GLU_ERROR;
		459	}
		460	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		461	/* knot open at beggining */
		462	texture_s_knot->open_at_begin = GL_TRUE;
		463	}
		464	else
		465	texture_s_knot->open_at_begin = GL_FALSE;
		466	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		467	/* knot open at end */
		468	texture_s_knot->open_at_end = GL_TRUE;
		469	}
		470	else
		471	texture_s_knot->open_at_end = GL_FALSE;
		472	texture_t_knot->unified_knot = (GLfloat *) 1;
		473	knot = texture_t_knot->knot = nobj->surface.texture.tknot;
		474	nknots = texture_t_knot->nknots = nobj->surface.texture.tknot_count;
		475	order = texture_t_knot->order = nobj->surface.texture.torder;
		476	texture_t_knot->delta_nknots = 0;
		477	t_min = texture_t_knot->t_min = order - 1;
		478	t_max = texture_t_knot->t_max = nknots - order;
		479	if (fabs(knot[t_min] - knot[t_max]) < EPSILON) {
		480	call_user_error(nobj, GLU_NURBS_ERROR3);
		481	return GLU_ERROR;
		482	}
		483	if (fabs(knot[0] - knot[t_min]) < EPSILON) {
		484	/* knot open at beggining */
		485	texture_t_knot->open_at_begin = GL_TRUE;
		486	}
		487	else
		488	texture_t_knot->open_at_begin = GL_FALSE;
		489	if (fabs(knot[t_max] - knot[nknots - 1]) < EPSILON) {
		490	/* knot open at end */
		491	texture_t_knot->open_at_end = GL_TRUE;
		492	}
		493	else
		494	texture_t_knot->open_at_end = GL_FALSE;
		495	}
		496	else {
		497	texture_s_knot->unified_knot = NULL;
		498	texture_t_knot->unified_knot = NULL;
		499	}
		500	return GLU_NO_ERROR;
		501	}
		502
		503
		504	static void
		505	free_new_ctrl(new_ctrl_type * p)
		506	{
		507	if (p->geom_ctrl)
		508	free(p->geom_ctrl);
		509	if (p->geom_offsets)
		510	free(p->geom_offsets);
		511	if (p->color_ctrl) {
		512	free(p->color_ctrl);
		513	if (p->color_offsets)
		514	free(p->color_offsets);
		515	}
		516	if (p->normal_ctrl) {
		517	free(p->normal_ctrl);
		518	if (p->normal_offsets)
		519	free(p->normal_offsets);
		520	}
		521	if (p->texture_ctrl) {
		522	free(p->texture_ctrl);
		523	if (p->texture_offsets)
		524	free(p->texture_offsets);
		525	}
		526	}
		527
		528	/* convert surfaces - geometry and possible attribute ones into equivalent */
		529	/* sequence of adjacent Bezier patches */
		530	static GLenum
		531	convert_surfs(GLUnurbsObj * nobj, new_ctrl_type * new_ctrl)
		532	{
		533	knot_str_type geom_s_knot, color_s_knot, normal_s_knot, texture_s_knot;
		534	knot_str_type geom_t_knot, color_t_knot, normal_t_knot, texture_t_knot;
		535	GLenum err;
		536
		537	if ((err = fill_knot_structures(nobj, &geom_s_knot, &geom_t_knot,
		538	&color_s_knot, &color_t_knot,
		539	&normal_s_knot, &normal_t_knot,
		540	&texture_s_knot,
		541	&texture_t_knot)) != GLU_NO_ERROR) {
		542	return err;
		543	}
		544	/* unify knots - all knots should have the same working range */
		545	if ((err = select_knot_working_range(nobj, &geom_s_knot, &color_s_knot,
		546	&normal_s_knot,
		547	&texture_s_knot)) != GLU_NO_ERROR) {
		548	call_user_error(nobj, err);
		549	return err;
		550	}
		551	if ((err = select_knot_working_range(nobj, &geom_t_knot, &color_t_knot,
		552	&normal_t_knot,
		553	&texture_t_knot)) != GLU_NO_ERROR) {
		554	free_unified_knots(&geom_s_knot, &color_s_knot, &normal_s_knot,
		555	&texture_s_knot);
		556	call_user_error(nobj, err);
		557	return err;
		558	}
		559
		560	/* convert the geometry surface */
		561	nobj->surface.geom.dim = get_surface_dim(nobj->surface.geom.type);
		562	if ((err = convert_surf(&geom_s_knot, &geom_t_knot, &(nobj->surface.geom),
		563	&(new_ctrl->geom_ctrl), &(new_ctrl->geom_s_pt_cnt),
		564	&(new_ctrl->geom_t_pt_cnt))) != GLU_NO_ERROR) {
		565	free_unified_knots(&geom_s_knot, &color_s_knot, &normal_s_knot,
		566	&texture_s_knot);
		567	free_unified_knots(&geom_t_knot, &color_t_knot, &normal_t_knot,
		568	&texture_t_knot);
		569	call_user_error(nobj, err);
		570	return err;
		571	}
		572	/* if additional attributive surfaces are given convert them as well */
		573	if (color_s_knot.unified_knot) {
		574	nobj->surface.color.dim = get_surface_dim(nobj->surface.color.type);
		575	if (
		576	(err =
		577	convert_surf(&color_s_knot, &color_t_knot, &(nobj->surface.color),
		578	&(new_ctrl->color_ctrl), &(new_ctrl->color_s_pt_cnt),
		579	&(new_ctrl->color_t_pt_cnt))) != GLU_NO_ERROR) {
		580	free_unified_knots(&color_s_knot, &color_s_knot, &normal_s_knot,
		581	&texture_s_knot);
		582	free_unified_knots(&color_t_knot, &color_t_knot, &normal_t_knot,
		583	&texture_t_knot);
		584	free_new_ctrl(new_ctrl);
		585	call_user_error(nobj, err);
		586	return err;
		587	}
		588	}
		589	if (normal_s_knot.unified_knot) {
		590	nobj->surface.normal.dim = get_surface_dim(nobj->surface.normal.type);
		591	if ((err = convert_surf(&normal_s_knot, &normal_t_knot,
		592	&(nobj->surface.normal),
		593	&(new_ctrl->normal_ctrl),
		594	&(new_ctrl->normal_s_pt_cnt),
		595	&(new_ctrl->normal_t_pt_cnt))) !=
		596	GLU_NO_ERROR) {
		597	free_unified_knots(&normal_s_knot, &normal_s_knot, &normal_s_knot,
		598	&texture_s_knot);
		599	free_unified_knots(&normal_t_knot, &normal_t_knot, &normal_t_knot,
		600	&texture_t_knot);
		601	free_new_ctrl(new_ctrl);
		602	call_user_error(nobj, err);
		603	return err;
		604	}
		605	}
		606	if (texture_s_knot.unified_knot) {
		607	nobj->surface.texture.dim = get_surface_dim(nobj->surface.texture.type);
		608	if ((err = convert_surf(&texture_s_knot, &texture_t_knot,
		609	&(nobj->surface.texture),
		610	&(new_ctrl->texture_ctrl),
		611	&(new_ctrl->texture_s_pt_cnt),
		612	&(new_ctrl->texture_t_pt_cnt))) !=
		613	GLU_NO_ERROR) {
		614	free_unified_knots(&texture_s_knot, &texture_s_knot, &texture_s_knot,
		615	&texture_s_knot);
		616	free_unified_knots(&texture_t_knot, &texture_t_knot, &texture_t_knot,
		617	&texture_t_knot);
		618	free_new_ctrl(new_ctrl);
		619	call_user_error(nobj, err);
		620	return err;
		621	}
		622	}
		623	return GLU_NO_ERROR;
		624	}
		625
		626	/* tesselate the "boundary" Bezier edge strips */
		627	static void
		628	tesselate_strip_t_line(GLint top_start, GLint top_end, GLint top_z,
		629	GLint bottom_start, GLint bottom_end, GLint bottom_z,
		630	GLint bottom_domain)
		631	{
		632	GLint top_cnt, bottom_cnt, tri_cnt, k;
		633	GLint direction;
		634
		635	top_cnt = top_end - top_start;
		636	direction = (top_cnt >= 0 ? 1 : -1);
		637	bottom_cnt = bottom_end - bottom_start;
		638	glBegin(GL_LINES);
		639	while (top_cnt) {
		640	if (bottom_cnt)
		641	tri_cnt = top_cnt / bottom_cnt;
		642	else
		643	tri_cnt = abs(top_cnt);
		644	for (k = 0; k <= tri_cnt; k++, top_start += direction) {
		645	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		646	(GLfloat) bottom_start / bottom_domain);
		647	glEvalPoint2(top_z, top_start);
		648	}
		649	if (bottom_cnt) {
		650	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		651	(GLfloat) bottom_start / bottom_domain);
		652	bottom_start += direction;
		653	top_start -= direction;
		654	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		655	(GLfloat) bottom_start / bottom_domain);
		656	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		657	(GLfloat) bottom_start / bottom_domain);
		658	glEvalPoint2(top_z, top_start);
		659	}
		660	top_cnt -= direction * tri_cnt;
		661	bottom_cnt -= direction;
		662	}
		663	glEnd();
		664	}
		665
		666
		667	static void
		668	tesselate_strip_t_fill(GLint top_start, GLint top_end, GLint top_z,
		669	GLint bottom_start, GLint bottom_end, GLint bottom_z,
		670	GLint bottom_domain)
		671	{
		672	GLint top_cnt, bottom_cnt, tri_cnt, k;
		673	GLint direction;
		674
		675	top_cnt = top_end - top_start;
		676	direction = (top_cnt >= 0 ? 1 : -1);
		677	bottom_cnt = bottom_end - bottom_start;
		678	while (top_cnt) {
		679	if (bottom_cnt)
		680	tri_cnt = top_cnt / bottom_cnt;
		681	else
		682	tri_cnt = abs(top_cnt);
		683	glBegin(GL_TRIANGLE_FAN);
		684	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		685	(GLfloat) bottom_start / bottom_domain);
		686	for (k = 0; k <= tri_cnt; k++, top_start += direction)
		687	glEvalPoint2(top_z, top_start);
		688	if (bottom_cnt) {
		689	bottom_start += direction;
		690	top_start -= direction;
		691	glEvalCoord2f((GLfloat) bottom_z / bottom_domain,
		692	(GLfloat) bottom_start / bottom_domain);
		693	}
		694	glEnd();
		695	top_cnt -= direction * tri_cnt;
		696	bottom_cnt -= direction;
		697	}
		698	}
		699
		700
		701	static void
		702	tesselate_strip_t(GLenum display_mode, GLint top_start, GLint top_end,
		703	GLint top_z, GLint bottom_start, GLint bottom_end,
		704	GLint bottom_z, GLint bottom_domain)
		705	{
		706	if (display_mode == GL_FILL)
		707	tesselate_strip_t_fill(top_start, top_end, top_z, bottom_start,
		708	bottom_end, bottom_z, bottom_domain);
		709	else
		710	tesselate_strip_t_line(top_start, top_end, top_z, bottom_start,
		711	bottom_end, bottom_z, bottom_domain);
		712	}
		713
		714
		715	static void
		716	tesselate_strip_s_fill(GLint top_start, GLint top_end, GLint top_z,
		717	GLint bottom_start, GLint bottom_end, GLint bottom_z,
		718	GLfloat bottom_domain)
		719	{
		720	GLint top_cnt, bottom_cnt, tri_cnt, k;
		721	GLint direction;
		722
		723	top_cnt = top_end - top_start;
		724	direction = (top_cnt >= 0 ? 1 : -1);
		725	bottom_cnt = bottom_end - bottom_start;
		726	while (top_cnt) {
		727	if (bottom_cnt)
		728	tri_cnt = top_cnt / bottom_cnt;
		729	else
		730	tri_cnt = abs(top_cnt);
		731	glBegin(GL_TRIANGLE_FAN);
		732	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		733	(GLfloat) bottom_z / bottom_domain);
		734	for (k = 0; k <= tri_cnt; k++, top_start += direction)
		735	glEvalPoint2(top_start, top_z);
		736	if (bottom_cnt) {
		737	bottom_start += direction;
		738	top_start -= direction;
		739	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		740	(GLfloat) bottom_z / bottom_domain);
		741	}
		742	glEnd();
		743	top_cnt -= direction * tri_cnt;
		744	bottom_cnt -= direction;
		745	}
		746	}
		747
		748
		749	static void
		750	tesselate_strip_s_line(GLint top_start, GLint top_end, GLint top_z,
		751	GLint bottom_start, GLint bottom_end, GLint bottom_z,
		752	GLfloat bottom_domain)
		753	{
		754	GLint top_cnt, bottom_cnt, tri_cnt, k;
		755	GLint direction;
		756
		757	top_cnt = top_end - top_start;
		758	direction = (top_cnt >= 0 ? 1 : -1);
		759	bottom_cnt = bottom_end - bottom_start;
		760	glBegin(GL_LINES);
		761	while (top_cnt) {
		762	if (bottom_cnt)
		763	tri_cnt = top_cnt / bottom_cnt;
		764	else
		765	tri_cnt = abs(top_cnt);
		766	for (k = 0; k <= tri_cnt; k++, top_start += direction) {
		767	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		768	(GLfloat) bottom_z / bottom_domain);
		769	glEvalPoint2(top_start, top_z);
		770	}
		771	if (bottom_cnt) {
		772	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		773	(GLfloat) bottom_z / bottom_domain);
		774	bottom_start += direction;
		775	top_start -= direction;
		776	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		777	(GLfloat) bottom_z / bottom_domain);
		778	glEvalPoint2(top_start, top_z);
		779	glEvalCoord2f((GLfloat) bottom_start / bottom_domain,
		780	(GLfloat) bottom_z / bottom_domain);
		781	}
		782	top_cnt -= direction * tri_cnt;
		783	bottom_cnt -= direction;
		784	}
		785	glEnd();
		786	}
		787
		788
		789	static void
		790	tesselate_strip_s(GLenum display_mode, GLint top_start, GLint top_end,
		791	GLint top_z, GLint bottom_start, GLint bottom_end,
		792	GLint bottom_z, GLfloat bottom_domain)
		793	{
		794	if (display_mode == GL_FILL)
		795	tesselate_strip_s_fill(top_start, top_end, top_z, bottom_start,
		796	bottom_end, bottom_z, bottom_domain);
		797	else
		798	tesselate_strip_s_line(top_start, top_end, top_z, bottom_start,
		799	bottom_end, bottom_z, bottom_domain);
		800	}
		801
		802	static void
		803	tesselate_bottom_left_corner(GLenum display_mode, GLfloat s_1, GLfloat t_1)
		804	{
		805	if (display_mode == GL_FILL) {
		806	glBegin(GL_TRIANGLE_FAN);
		807	glEvalPoint2(1, 1);
		808	glEvalCoord2f(s_1, 0.0);
		809	glEvalCoord2f(0.0, 0.0);
		810	glEvalCoord2f(0.0, t_1);
		811	}
		812	else {
		813	glBegin(GL_LINES);
		814	glEvalCoord2f(0.0, 0.0);
		815	glEvalCoord2f(0.0, t_1);
		816	glEvalCoord2f(0.0, 0.0);
		817	glEvalPoint2(1, 1);
		818	glEvalCoord2f(0.0, 0.0);
		819	glEvalCoord2f(s_1, 0.0);
		820	}
		821	glEnd();
		822	}
		823
		824	static void
		825	tesselate_bottom_right_corner(GLenum display_mode, GLint v_top,
		826	GLint v_bottom, GLfloat s_1, GLfloat t_1)
		827	{
		828	if (display_mode == GL_FILL) {
		829	glBegin(GL_TRIANGLE_FAN);
		830	glEvalPoint2(1, v_top);
		831	glEvalCoord2f(0.0, v_bottom * t_1);
		832	glEvalCoord2f(0.0, (v_bottom + 1) * t_1);
		833	glEvalCoord2f(s_1, (v_bottom + 1) * t_1);
		834	}
		835	else {
		836	glBegin(GL_LINES);
		837	glEvalCoord2f(0.0, (v_bottom + 1) * t_1);
		838	glEvalPoint2(1, v_top);
		839	glEvalCoord2f(0.0, (v_bottom + 1) * t_1);
		840	glEvalCoord2f(0.0, v_bottom * t_1);
		841	glEvalCoord2f(0.0, (v_bottom + 1) * t_1);
		842	glEvalCoord2f(s_1, (v_bottom + 1) * t_1);
		843	}
		844	glEnd();
		845	}
		846
		847	static void
		848	tesselate_top_left_corner(GLenum display_mode, GLint u_right, GLint u_left,
		849	GLfloat s_1, GLfloat t_1)
		850	{
		851	if (display_mode == GL_FILL) {
		852	glBegin(GL_TRIANGLE_FAN);
		853	glEvalPoint2(u_right, 1);
		854	glEvalCoord2f((u_left + 1) * s_1, t_1);
		855	glEvalCoord2f((u_left + 1) * s_1, 0.0);
		856	glEvalCoord2f(u_left * s_1, 0.0);
		857	}
		858	else {
		859	glBegin(GL_LINES);
		860	glEvalCoord2f((u_left + 1) * s_1, 0.0);
		861	glEvalPoint2(u_right, 1);
		862	glEvalCoord2f((u_left + 1) * s_1, 0.0);
		863	glEvalCoord2f(u_left * s_1, 0.0);
		864	glEvalCoord2f((u_left + 1) * s_1, 0.0);
		865	glEvalCoord2f((u_left + 1) * s_1, t_1);
		866	}
		867	glEnd();
		868	}
		869
		870	static void
		871	tesselate_top_right_corner(GLenum display_mode, GLint u_left, GLint v_bottom,
		872	GLint u_right, GLint v_top, GLfloat s_1,
		873	GLfloat t_1)
		874	{
		875	if (display_mode == GL_FILL) {
		876	glBegin(GL_TRIANGLE_FAN);
		877	glEvalPoint2(u_left, v_bottom);
		878	glEvalCoord2f((u_right - 1) * s_1, v_top * t_1);
		879	glEvalCoord2f(u_right * s_1, v_top * t_1);
		880	glEvalCoord2f(u_right * s_1, (v_top - 1) * t_1);
		881	}
		882	else {
		883	glBegin(GL_LINES);
		884	glEvalCoord2f(u_right * s_1, v_top * t_1);
		885	glEvalPoint2(u_left, v_bottom);
		886	glEvalCoord2f(u_right * s_1, v_top * t_1);
		887	glEvalCoord2f(u_right * s_1, (v_top - 1) * t_1);
		888	glEvalCoord2f(u_right * s_1, v_top * t_1);
		889	glEvalCoord2f((u_right - 1) * s_1, v_top * t_1);
		890	}
		891	glEnd();
		892	}
		893
		894	/* do mesh mapping of Bezier */
		895	static void
		896	nurbs_map_bezier(GLenum display_mode, GLint * sfactors, GLint * tfactors,
		897	GLint s_bezier_cnt, GLint t_bezier_cnt, GLint s, GLint t)
		898	{
		899	GLint top, bottom, right, left;
		900
		901
		902	if (s == 0) {
		903	top = (tfactors + t 3);
		904	bottom = (tfactors + t 3 + 1);
		905	}
		906	else if (s == s_bezier_cnt - 1) {
		907	top = (tfactors + t 3 + 2);
		908	bottom = (tfactors + t 3);
		909	}
		910	else {
		911	top = bottom = (tfactors + t 3);
		912	}
		913	if (t == 0) {
		914	left = (sfactors + s 3 + 1);
		915	right = (sfactors + s 3);
		916	}
		917	else if (t == t_bezier_cnt - 1) {
		918	left = (sfactors + s 3);
		919	right = (sfactors + s 3 + 2);
		920	}
		921	else {
		922	left = right = (sfactors + s 3);
		923	}
		924
		925	if (top > bottom) {
		926	if (left < right) {
		927	glMapGrid2f(right, 0.0, 1.0, top, 0.0, 1.0);
		928	glEvalMesh2(display_mode, 1, right, 1, top);
		929	tesselate_strip_s(display_mode, 1, right, 1, 1, left, 0,
		930	(GLfloat) left);
		931	tesselate_bottom_left_corner(display_mode, (GLfloat) (1.0 / left),
		932	(GLfloat) (1.0 / bottom));
		933	/* tesselate_strip_t(display_mode,1,top,1,1,bottom,0,(GLfloat)bottom);*/
		934	tesselate_strip_t(display_mode, top, 1, 1, bottom, 1, 0,
		935	(GLfloat) bottom);
		936	}
		937	else if (left == right) {
		938	glMapGrid2f(right, 0.0, 1.0, top, 0.0, 1.0);
		939	glEvalMesh2(display_mode, 1, right, 0, top);
		940	/* tesselate_strip_t(display_mode,0,top,1,0,bottom,0,(GLfloat)bottom);*/
		941	tesselate_strip_t(display_mode, top, 0, 1, bottom, 0, 0,
		942	(GLfloat) bottom);
		943	}
		944	else {
		945	glMapGrid2f(left, 0.0, 1.0, top, 0.0, 1.0);
		946	glEvalMesh2(display_mode, 1, left, 0, top - 1);
		947	/* tesselate_strip_t(display_mode,0,top-1,1,0,bottom-1,0,
		948	(GLfloat)bottom);*/
		949	tesselate_strip_t(display_mode, top - 1, 0, 1, bottom - 1, 0, 0,
		950	(GLfloat) bottom);
		951	tesselate_bottom_right_corner(display_mode, top - 1, bottom - 1,
		952	(GLfloat) (1.0 / right),
		953	(GLfloat) (1.0 / bottom));
		954	/* tesselate_strip_s(display_mode,1,left,top-1,1,right,right,
		955	(GLfloat)right);*/
		956	tesselate_strip_s(display_mode, left, 1, top - 1, right, 1, right,
		957	(GLfloat) right);
		958	}
		959	}
		960	else if (top == bottom) {
		961	if (left < right) {
		962	glMapGrid2f(right, 0.0, 1.0, top, 0.0, 1.0);
		963	glEvalMesh2(display_mode, 0, right, 1, top);
		964	tesselate_strip_s(display_mode, 0, right, 1, 0, left, 0,
		965	(GLfloat) left);
		966	}
		967	else if (left == right) {
		968	glMapGrid2f(right, 0.0, 1.0, top, 0.0, 1.0);
		969	glEvalMesh2(display_mode, 0, right, 0, top);
		970	}
		971	else {
		972	glMapGrid2f(left, 0.0, 1.0, top, 0.0, 1.0);
		973	glEvalMesh2(display_mode, 0, left, 0, top - 1);
		974	/* tesselate_strip_s(display_mode,0,left,top-1,0,right,right,
		975	(GLfloat)right);*/
		976	tesselate_strip_s(display_mode, left, 0, top - 1, right, 0, right,
		977	(GLfloat) right);
		978	}
		979	}
		980	else {
		981	if (left < right) {
		982	glMapGrid2f(right, 0.0, 1.0, bottom, 0.0, 1.0);
		983	glEvalMesh2(display_mode, 0, right - 1, 1, bottom);
		984	tesselate_strip_s(display_mode, 0, right - 1, 1, 0, left - 1, 0,
		985	(GLfloat) left);
		986	tesselate_top_left_corner(display_mode, right - 1, left - 1,
		987	(GLfloat) (1.0 / left),
		988	(GLfloat) (1.0 / top));
		989	tesselate_strip_t(display_mode, 1, bottom, right - 1, 1, top, top,
		990	(GLfloat) top);
		991	}
		992	else if (left == right) {
		993	glMapGrid2f(right, 0.0, 1.0, bottom, 0.0, 1.0);
		994	glEvalMesh2(display_mode, 0, right - 1, 0, bottom);
		995	tesselate_strip_t(display_mode, 0, bottom, right - 1, 0, top, top,
		996	(GLfloat) top);
		997	}
		998	else {
		999	glMapGrid2f(left, 0.0, 1.0, bottom, 0.0, 1.0);
		1000	glEvalMesh2(display_mode, 0, left - 1, 0, bottom - 1);
		1001	tesselate_strip_t(display_mode, 0, bottom - 1, left - 1, 0, top - 1,
		1002	top, (GLfloat) top);
		1003	tesselate_top_right_corner(display_mode, left - 1, bottom - 1, right,
		1004	top, (GLfloat) (1.0 / right),
		1005	(GLfloat) (1.0 / top));
		1006	/* tesselate_strip_s(display_mode,0,left-1,bottom-1,0,right-1,right,
		1007	(GLfloat)right);*/
		1008	tesselate_strip_s(display_mode, left - 1, 0, bottom - 1, right - 1,
		1009	0, right, (GLfloat) right);
		1010	}
		1011	}
		1012	}
		1013
		1014	/* draw NURBS surface in OUTLINE POLYGON mode */
		1015	static void
		1016	draw_polygon_mode(GLenum display_mode, GLUnurbsObj * nobj,
		1017	new_ctrl_type * new_ctrl, GLint * sfactors,
		1018	GLint * tfactors)
		1019	{
		1020	GLsizei offset;
		1021	GLint t_bezier_cnt, s_bezier_cnt;
		1022	GLboolean do_color, do_normal, do_texture;
		1023	GLint i, j;
		1024
		1025	t_bezier_cnt = new_ctrl->t_bezier_cnt;
		1026	s_bezier_cnt = new_ctrl->s_bezier_cnt;
		1027	glEnable(nobj->surface.geom.type);
		1028	if (new_ctrl->color_ctrl) {
		1029	glEnable(nobj->surface.color.type);
		1030	do_color = GL_TRUE;
		1031	}
		1032	else
		1033	do_color = GL_FALSE;
		1034	if (new_ctrl->normal_ctrl) {
		1035	glEnable(nobj->surface.normal.type);
		1036	do_normal = GL_TRUE;
		1037	}
		1038	else
		1039	do_normal = GL_FALSE;
		1040	if (new_ctrl->texture_ctrl) {
		1041	glEnable(nobj->surface.texture.type);
		1042	do_texture = GL_TRUE;
		1043	}
		1044	else
		1045	do_texture = GL_FALSE;
		1046	for (j = 0; j < s_bezier_cnt; j++) {
		1047	for (i = 0; i < t_bezier_cnt; i++) {
		1048	offset = j * t_bezier_cnt + i;
		1049	if (fine_culling_test_3D(nobj, *(new_ctrl->geom_offsets + offset),
		1050	nobj->surface.geom.sorder,
		1051	nobj->surface.geom.torder,
		1052	new_ctrl->geom_s_stride,
		1053	new_ctrl->geom_t_stride,
		1054	nobj->surface.geom.dim)) continue;
		1055	glMap2f(nobj->surface.geom.type, 0.0, 1.0, new_ctrl->geom_s_stride,
		1056	nobj->surface.geom.sorder, 0.0, 1.0, new_ctrl->geom_t_stride,
		1057	nobj->surface.geom.torder,
		1058	*(new_ctrl->geom_offsets + offset));
		1059	if (do_color) {
		1060	glMap2f(nobj->surface.color.type, 0.0, 1.0,
		1061	new_ctrl->color_s_stride, nobj->surface.color.sorder,
		1062	0.0, 1.0, new_ctrl->color_t_stride,
		1063	nobj->surface.color.torder,
		1064	*(new_ctrl->color_offsets + offset));
		1065	}
		1066	if (do_normal) {
		1067	glMap2f(nobj->surface.normal.type, 0.0, 1.0,
		1068	new_ctrl->normal_s_stride, nobj->surface.normal.sorder,
		1069	0.0, 1.0, new_ctrl->normal_t_stride,
		1070	nobj->surface.normal.torder,
		1071	*(new_ctrl->normal_offsets + offset));
		1072	}
		1073	if (do_texture) {
		1074	glMap2f(nobj->surface.texture.type, 0.0, 1.0,
		1075	new_ctrl->texture_s_stride, nobj->surface.texture.sorder,
		1076	0.0, 1.0, new_ctrl->texture_t_stride,
		1077	nobj->surface.texture.torder,
		1078	*(new_ctrl->texture_offsets + offset));
		1079	}
		1080	/* glMapGrid2f(sfactors[j3+0],0.0,1.0,tfactors[i3+0],0.0,1.0);
		1081	glEvalMesh2(display_mode,0,sfactors[j3+0],0,tfactors[i3+0]);*/
		1082	nurbs_map_bezier(display_mode, sfactors, tfactors, s_bezier_cnt,
		1083	t_bezier_cnt, j, i);
		1084	}
		1085	}
		1086	}
		1087
		1088
		1089
		1090	/* draw NURBS surface in OUTLINE POLYGON mode */
		1091	#if 0
		1092	static void
		1093	draw_patch_mode(GLenum display_mode, GLUnurbsObj * nobj,
		1094	new_ctrl_type * new_ctrl, GLint * sfactors, GLint * tfactors)
		1095	{
		1096	GLsizei offset;
		1097	GLint t_bezier_cnt, s_bezier_cnt;
		1098	GLboolean do_color, do_normal, do_texture;
		1099	GLint i, j;
		1100
		1101	t_bezier_cnt = new_ctrl->t_bezier_cnt;
		1102	s_bezier_cnt = new_ctrl->s_bezier_cnt;
		1103	glEnable(nobj->surface.geom.type);
		1104	if (new_ctrl->color_ctrl) {
		1105	glEnable(nobj->surface.color.type);
		1106	do_color = GL_TRUE;
		1107	}
		1108	else
		1109	do_color = GL_FALSE;
		1110	if (new_ctrl->normal_ctrl) {
		1111	glEnable(nobj->surface.normal.type);
		1112	do_normal = GL_TRUE;
		1113	}
		1114	else
		1115	do_normal = GL_FALSE;
		1116	if (new_ctrl->texture_ctrl) {
		1117	glEnable(nobj->surface.texture.type);
		1118	do_texture = GL_TRUE;
		1119	}
		1120	else
		1121	do_texture = GL_FALSE;
		1122	for (j = 0; j < s_bezier_cnt; j++) {
		1123	for (i = 0; i < t_bezier_cnt; i++) {
		1124	offset = j * t_bezier_cnt + i;
		1125	if (fine_culling_test_3D(nobj, *(new_ctrl->geom_offsets + offset),
		1126	nobj->surface.geom.sorder,
		1127	nobj->surface.geom.torder,
		1128	new_ctrl->geom_s_stride,
		1129	new_ctrl->geom_t_stride,
		1130	nobj->surface.geom.dim)) continue;
		1131	glMap2f(nobj->surface.geom.type, 0.0, 1.0, new_ctrl->geom_s_stride,
		1132	nobj->surface.geom.sorder, 0.0, 1.0, new_ctrl->geom_t_stride,
		1133	nobj->surface.geom.torder,
		1134	*(new_ctrl->geom_offsets + offset));
		1135	if (do_color) {
		1136	glMap2f(nobj->surface.color.type, 0.0, 1.0,
		1137	new_ctrl->color_s_stride, nobj->surface.color.sorder,
		1138	0.0, 1.0, new_ctrl->color_t_stride,
		1139	nobj->surface.color.torder,
		1140	*(new_ctrl->color_offsets + offset));
		1141	}
		1142	if (do_normal) {
		1143	glMap2f(nobj->surface.normal.type, 0.0, 1.0,
		1144	new_ctrl->normal_s_stride, nobj->surface.normal.sorder,
		1145	0.0, 1.0, new_ctrl->normal_t_stride,
		1146	nobj->surface.normal.torder,
		1147	*(new_ctrl->normal_offsets + offset));
		1148	}
		1149	if (do_texture) {
		1150	glMap2f(nobj->surface.texture.type, 0.0, 1.0,
		1151	new_ctrl->texture_s_stride, nobj->surface.texture.sorder,
		1152	0.0, 1.0, new_ctrl->texture_t_stride,
		1153	nobj->surface.texture.torder,
		1154	*(new_ctrl->texture_offsets + offset));
		1155	}
		1156	nurbs_map_bezier(display_mode, sfactors, tfactors, s_bezier_cnt,
		1157	t_bezier_cnt, i, j);
		1158	/* glMapGrid2f(sfactors[j],0.0,1.0,tfactors[i],0.0,1.0);
		1159	glEvalMesh2(display_mode,0,sfactors[j],0,tfactors[i]);*/
		1160	}
		1161	}
		1162	}
		1163	#endif
		1164
		1165
		1166
		1167	static void
		1168	init_new_ctrl(new_ctrl_type * p)
		1169	{
		1170	p->geom_ctrl = p->color_ctrl = p->normal_ctrl = p->texture_ctrl = NULL;
		1171	p->geom_offsets = p->color_offsets = p->normal_offsets =
		1172	p->texture_offsets = NULL;
		1173	p->s_bezier_cnt = p->t_bezier_cnt = 0;
		1174	}
		1175
		1176
		1177	static GLenum
		1178	augment_new_ctrl(GLUnurbsObj * nobj, new_ctrl_type * p)
		1179	{
		1180	GLsizei offset_size;
		1181	GLint i, j;
		1182
		1183	p->s_bezier_cnt = (p->geom_s_pt_cnt) / (nobj->surface.geom.sorder);
		1184	p->t_bezier_cnt = (p->geom_t_pt_cnt) / (nobj->surface.geom.torder);
		1185	offset_size = (p->s_bezier_cnt) * (p->t_bezier_cnt);
		1186	p->geom_t_stride = nobj->surface.geom.dim;
		1187	p->geom_s_stride = (p->geom_t_pt_cnt) * (nobj->surface.geom.dim);
		1188	p->color_t_stride = nobj->surface.color.dim;
		1189	p->color_s_stride = (p->color_t_pt_cnt) * (nobj->surface.color.dim);
		1190	p->normal_t_stride = nobj->surface.normal.dim;
		1191	p->normal_s_stride = (p->normal_t_pt_cnt) * (nobj->surface.normal.dim);
		1192	p->texture_t_stride = nobj->surface.texture.dim;
		1193	p->texture_s_stride = (p->texture_t_pt_cnt) * (nobj->surface.texture.dim);
		1194	if (
		1195	(p->geom_offsets =
		1196	(GLfloat *) malloc(sizeof(GLfloat ) * offset_size)) == NULL) {
		1197	call_user_error(nobj, GLU_OUT_OF_MEMORY);
		1198	return GLU_ERROR;
		1199	}
		1200	if (p->color_ctrl)
		1201	if (
		1202	(p->color_offsets =
		1203	(GLfloat *) malloc(sizeof(GLfloat ) * offset_size)) == NULL) {
		1204	free_new_ctrl(p);
		1205	call_user_error(nobj, GLU_OUT_OF_MEMORY);
		1206	return GLU_ERROR;
		1207	}
		1208	if (p->normal_ctrl)
		1209	if (
		1210	(p->normal_offsets =
		1211	(GLfloat *) malloc(sizeof(GLfloat ) * offset_size)) == NULL) {
		1212	free_new_ctrl(p);
		1213	call_user_error(nobj, GLU_OUT_OF_MEMORY);
		1214	return GLU_ERROR;
		1215	}
		1216	if (p->texture_ctrl)
		1217	if (
		1218	(p->texture_offsets =
		1219	(GLfloat *) malloc(sizeof(GLfloat ) * offset_size)) == NULL) {
		1220	free_new_ctrl(p);
		1221	call_user_error(nobj, GLU_OUT_OF_MEMORY);
		1222	return GLU_ERROR;
		1223	}
		1224	for (i = 0; i < p->s_bezier_cnt; i++)
		1225	for (j = 0; j < p->t_bezier_cnt; j++)
		1226	(p->geom_offsets + i (p->t_bezier_cnt) + j) =
		1227	p->geom_ctrl + i * (nobj->surface.geom.sorder) *
		1228	(nobj->surface.geom.dim) * (p->geom_t_pt_cnt) +
		1229	j * (nobj->surface.geom.dim) * (nobj->surface.geom.torder);
		1230	if (p->color_ctrl)
		1231	for (i = 0; i < p->s_bezier_cnt; i++)
		1232	for (j = 0; j < p->t_bezier_cnt; j++)
		1233	(p->color_offsets + i (p->t_bezier_cnt) + j) =
		1234	p->color_ctrl + i * (nobj->surface.color.sorder) *
		1235	(nobj->surface.color.dim) * (p->color_t_pt_cnt) +
		1236	j * (nobj->surface.color.dim) * (nobj->surface.color.torder);
		1237	if (p->normal_ctrl)
		1238	for (i = 0; i < p->s_bezier_cnt; i++)
		1239	for (j = 0; j < p->t_bezier_cnt; j++)
		1240	(p->normal_offsets + i (p->t_bezier_cnt) + j) =
		1241	p->normal_ctrl + i * (nobj->surface.normal.sorder) *
		1242	(nobj->surface.normal.dim) * (p->normal_t_pt_cnt) +
		1243	j * (nobj->surface.normal.dim) * (nobj->surface.normal.torder);
		1244	if (p->texture_ctrl)
		1245	for (i = 0; i < p->s_bezier_cnt; i++)
		1246	for (j = 0; j < p->t_bezier_cnt; j++)
		1247	(p->texture_offsets + i (p->t_bezier_cnt) + j) =
		1248	p->texture_ctrl + i * (nobj->surface.texture.sorder) *
		1249	(nobj->surface.texture.dim) * (p->texture_t_pt_cnt) +
		1250	j * (nobj->surface.texture.dim) *
		1251	(nobj->surface.texture.torder);
		1252	return GLU_NO_ERROR;
		1253	}
		1254
		1255	/* main NURBS surface procedure */
		1256	void
		1257	do_nurbs_surface(GLUnurbsObj * nobj)
		1258	{
		1259	GLint sfactors, tfactors;
		1260	new_ctrl_type new_ctrl;
		1261
		1262	/* test user supplied data */
		1263	if (test_nurbs_surfaces(nobj) != GLU_NO_ERROR)
		1264	return;
		1265
		1266	init_new_ctrl(&new_ctrl);
		1267
		1268	if (convert_surfs(nobj, &new_ctrl) != GLU_NO_ERROR)
		1269	return;
		1270	if (augment_new_ctrl(nobj, &new_ctrl) != GLU_NO_ERROR)
		1271	return;
		1272	switch (nobj->sampling_method) {
		1273	case GLU_PATH_LENGTH:
		1274	if (glu_do_sampling_3D(nobj, &new_ctrl, &sfactors, &tfactors) !=
		1275	GLU_NO_ERROR) {
		1276	free_new_ctrl(&new_ctrl);
		1277	return;
		1278	}
		1279	break;
		1280	case GLU_DOMAIN_DISTANCE:
		1281	if (glu_do_sampling_uv(nobj, &new_ctrl, &sfactors, &tfactors) !=
		1282	GLU_NO_ERROR) {
		1283	free_new_ctrl(&new_ctrl);
		1284	return;
		1285	}
		1286	break;
		1287	case GLU_PARAMETRIC_ERROR:
		1288	if (glu_do_sampling_param_3D(nobj, &new_ctrl, &sfactors, &tfactors) !=
		1289	GLU_NO_ERROR) {
		1290	free_new_ctrl(&new_ctrl);
		1291	return;
		1292	}
		1293	break;
		1294	default:
		1295	abort();
		1296	}
		1297	glFrontFace(GL_CW);
		1298	switch (nobj->display_mode) {
		1299	case GLU_FILL:
		1300	/* if(polygon_trimming(nobj,&new_ctrl,sfactors,tfactors)==GLU_NO_ERROR)*/
		1301	draw_polygon_mode(GL_FILL, nobj, &new_ctrl, sfactors, tfactors);
		1302	break;
		1303	case GLU_OUTLINE_POLYGON:
		1304	/* TODO - missing trimming handeling */
		1305	/* just for now - no OUTLINE_PATCH mode
		1306	draw_patch_mode(GL_LINE,nobj,&new_ctrl,sfactors,tfactors);
		1307	break; */
		1308	case GLU_OUTLINE_PATCH:
		1309	/* if(polygon_trimming(nobj,&new_ctrl,sfactors,tfactors)==GLU_NO_ERROR)*/
		1310	draw_polygon_mode(GL_LINE, nobj, &new_ctrl, sfactors, tfactors);
		1311	break;
		1312	default:
		1313	abort(); /* TODO: is this OK? */
		1314	}
		1315	free(sfactors);
		1316	free(tfactors);
		1317	free_new_ctrl(&new_ctrl);
		1318	}

Subversion Repositories shark

(root)/shark/branches/xen/ports/mesa/src-glu/nurbssrf.c - Rev 1618