diff options
Diffstat (limited to 'src/glu/mesa/tess.c')
| -rw-r--r-- | src/glu/mesa/tess.c | 1235 |
1 files changed, 257 insertions, 978 deletions
diff --git a/src/glu/mesa/tess.c b/src/glu/mesa/tess.c index 919643cb8e..7e05dbb0d0 100644 --- a/src/glu/mesa/tess.c +++ b/src/glu/mesa/tess.c @@ -1,1038 +1,317 @@ -/* $Id: tess.c,v 1.24 2000/02/10 17:45:52 brianp Exp $ */ +/* $Id: tess.c,v 1.25 2000/07/11 14:11:04 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 3.3 + * Copyright (C) 1995-2000 Brian Paul * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. + * 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. * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: + * 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. * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * 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. */ -/***************************************************************************** - * - * GLU 1.3 Polygon Tessellation by Gareth Hughes <garethh@bell-labs.com> - * - *****************************************************************************/ -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <math.h> +/* + * This file is part of the polygon tesselation code contributed by + * Bogdan Sikorski + */ -#include "gluP.h" +#ifdef PC_HEADER +#include "all.h" +#else +#include <math.h> +#include <stdlib.h> #include "tess.h" -#include "tess_macros.h" -#include "tess_fist.h" -#if 0 -#include "tess_grid.h" #endif -#define TESS_CHECK_ERRORS(t) if ( (t)->error != GLU_NO_ERROR ) goto cleanup - -#ifdef DEBUG -GLint tess_dbg_level; -#endif - - -/***************************************************************************** - * tess_error_callback - * - * Internal error handler. Call the user-registered error callback. - * - * 2nd arg changed from 'errno' to 'errnum' since MSVC defines errnum as - * a macro (of all things) and thus breaks the build -tjump - *****************************************************************************/ -void tess_error_callback( GLUtesselator *tobj, GLenum errnum ) -{ - if ( tobj->error == GLU_NO_ERROR ) - { - tobj->error = errnum; - } - - if ( tobj->callbacks.errorData != NULL ) - { - ( tobj->callbacks.errorData )( errnum, tobj->data ); - } - else if ( tobj->callbacks.error != NULL ) - { - ( tobj->callbacks.error )( errnum ); - } -} - - -/***************************************************************************** - * init_callbacks - *****************************************************************************/ -static void init_callbacks( tess_callbacks_t *callbacks ) -{ - callbacks->begin = ( void (GLCALLBACKPCAST)(GLenum) ) NULL; - callbacks->beginData = ( void (GLCALLBACKPCAST)(GLenum, void *) ) NULL; - callbacks->edgeFlag = ( void (GLCALLBACKPCAST)(GLboolean) ) NULL; - callbacks->edgeFlagData = ( void (GLCALLBACKPCAST)(GLboolean, void *) ) NULL; - callbacks->vertex = ( void (GLCALLBACKPCAST)(void *) ) NULL; - callbacks->vertexData = ( void (GLCALLBACKPCAST)(void *, void *) ) NULL; - callbacks->end = ( void (GLCALLBACKPCAST)(void) ) NULL; - callbacks->endData = ( void (GLCALLBACKPCAST)(void *) ) NULL; - callbacks->error = ( void (GLCALLBACKPCAST)(GLenum) ) NULL; - callbacks->errorData = ( void (GLCALLBACKPCAST)(GLenum, void *) ) NULL; - callbacks->combine = ( void (GLCALLBACKPCAST)(GLdouble [3], void *[4], - GLfloat [4], void **) ) NULL; - callbacks->combineData = ( void (GLCALLBACKPCAST)(GLdouble [3], void *[4], - GLfloat [4], void **, - void *) ) NULL; -} - - -/***************************************************************************** - * find_normal - *****************************************************************************/ -static GLenum find_normal( GLUtesselator *tobj ) -{ - tess_contour_t *contour = tobj->current_contour; - tess_vertex_t *va, *vb, *vc; - GLdouble a[3], b[3], c[3]; - - MSG( 15, " --> find_normal( tobj:%p )\n", tobj ); - - if ( contour == NULL ) { return GLU_ERROR; } - - va = contour->vertices; - vb = va->next; - - /* If va and vb are the same point, keep looking for a different vertex. */ - - while ( IS_EQUAL_3DV( va->coords, vb->coords ) && ( vb != va ) ) { - vb = vb->next; - } - - if ( vb == va ) { - /* FIXME: What error is this? */ - tess_error_callback( tobj, GLU_TESS_ERROR7 ); - } - - SUB_3V( a, vb->coords, va->coords ); - - for ( vc = vb->next; vc != va; vc = vc->next ) - { - SUB_3V( b, vc->coords, va->coords ); - - CROSS_3V( c, a, b ); - - if ( ! IS_ZERO_3DV( c ) ) - { - MSG( 15, " using (%.2f,%.2f) -> (%.2f,%.2f) -> (%.2f,%.2f)\n", - va->coords[X], va->coords[Y], - vb->coords[X], vb->coords[Y], - vc->coords[X], vc->coords[Y] ); - - COPY_3V( contour->plane.normal, c ); - NORMALIZE_3DV( contour->plane.normal ); - - contour->plane.dist = - DOT_3V( contour->plane.normal, - va->coords ); - - MSG( 15, " <-- find_normal( tobj:%p ) n: (%.2f, %.2f, %.2f)\n", tobj, contour->plane.normal[X], contour->plane.normal[Y], contour->plane.normal[Z] ); - return GLU_NO_ERROR; - } - } - /* FIXME: What error is this? */ - tess_error_callback( tobj, GLU_TESS_ERROR7 ); - - return GLU_ERROR; -} - -/***************************************************************************** - * twice_contour_area - * - * Calculate the twice the signed area of the given contour. Used to - * determine the contour's orientation amongst other things. - *****************************************************************************/ -GLdouble twice_contour_area( tess_contour_t *contour ) -{ - tess_vertex_t *vertex = contour->vertices; - GLdouble area, x, y; - - area = 0.0; - - x = vertex->v[X]; - y = vertex->v[Y]; - - vertex = vertex->next; - - do - { - area += ( (vertex->v[X] - x) * (vertex->next->v[Y] - y) - - (vertex->v[Y] - y) * (vertex->next->v[X] - x) ); - vertex = vertex->next; - } - while ( vertex != contour->vertices ); - - return area; -} - -/***************************************************************************** - * project_current_contour - * - * Project the contour's vertices onto the tessellation plane. We perform - * a complex rotation here to allow non-axis-aligned tessellation normals. - *****************************************************************************/ -static void project_current_contour( GLUtesselator *tobj ) -{ - tess_contour_t *current = tobj->current_contour; - tess_vertex_t *vertex; - GLdouble zaxis[3] = { 0.0, 0.0, 1.0 }, znormal[3], xnormal[3]; - GLdouble dot, rotx, roty; - GLint i; - - MSG( 15, " --> project_current_contour( tobj:%p )\n", tobj ); - - if ( current == NULL ) { return; } - - /* Rotate the plane normal around the y-axis. */ - - znormal[X] = current->plane.normal[X]; - znormal[Y] = 0.0; - znormal[Z] = current->plane.normal[Z]; - - dot = DOT_3V( znormal, zaxis ); - current->roty = roty = acos( dot ); - - /* Rotate the plane normal around the x-axis. */ - - xnormal[X] = cos( roty ) * znormal[X] - sin( roty ) * znormal[Z]; - xnormal[Y] = znormal[Y]; - xnormal[Z] = sin( roty ) * znormal[X] + cos( roty ) * znormal[Z]; - - dot = DOT_3V( xnormal, zaxis ); - current->rotx = rotx = acos( dot ); - - for ( vertex = current->vertices, i = 0; - i < current->num_vertices; vertex = vertex->next, i++ ) - { - tess_plane_t *plane = ¤t->plane; - GLdouble proj[3], yrot[3], xrot[3]; - - /* FIXME: This needs a cleanup, 'cos I'm sure it's inefficient. */ - - proj[X] = vertex->coords[X] - plane->dist * plane->normal[X]; - proj[Y] = vertex->coords[Y] - plane->dist * plane->normal[Y]; - proj[Z] = vertex->coords[Z] - plane->dist * plane->normal[Z]; - - yrot[X] = cos( roty ) * proj[X] - sin( roty ) * proj[Z]; - yrot[Y] = proj[Y]; - yrot[Z] = sin( roty ) * proj[X] + cos( roty ) * proj[Z]; - - xrot[X] = yrot[X]; - xrot[Y] = cos( rotx ) * yrot[Y] - sin( rotx ) * yrot[Z]; - xrot[Z] = sin( rotx ) * yrot[Y] + cos( rotx ) * yrot[Z]; - - vertex->v[X] = xrot[X]; - vertex->v[Y] = xrot[Y]; - - ACC_BBOX_2V( vertex->v, tobj->mins, tobj->maxs ); - ACC_BBOX_2V( vertex->v, current->mins, current->maxs ); - } - - current->area = twice_contour_area( current ); - current->orientation = ( current->area >= 0.0 ) ? GLU_CCW : GLU_CW; - - MSG( 15, " area: %.2f orientation: %s\n", - current->area, ( current->orientation == GLU_CCW ) ? "CCW" : "CW" ); - - MSG( 15, " <-- project_current_contour( tobj:%p )\n", tobj ); -} - -/***************************************************************************** - * save_current_contour - *****************************************************************************/ -static GLenum save_current_contour( GLUtesselator *tobj ) -{ - tess_contour_t *current = tobj->current_contour; - tess_vertex_t *vertex; - GLint i; - - if ( current == NULL ) { return GLU_ERROR; } - - if ( tobj->contours == NULL ) - { - tobj->contours = tobj->last_contour = current; - current->next = current->prev = NULL; - - tobj->orientation = current->orientation; - } - else - { - current->prev = tobj->last_contour; - - tobj->last_contour->next = current; - tobj->last_contour = current; - - current->next = NULL; - } - - for ( vertex = current->vertices, i = 0; - i < current->num_vertices; vertex = vertex->next, i++ ) - { - vertex->edge_flag = GL_TRUE; - } - - current->type = GLU_UNKNOWN; - - tobj->num_contours++; - tobj->current_contour = NULL; - - return GLU_NO_ERROR; -} - -/***************************************************************************** - * inspect_current_contour - *****************************************************************************/ -static void inspect_current_contour( GLUtesselator *tobj ) -{ - tess_contour_t *current = tobj->current_contour; - GLdouble origin[3] = { 0.0, 0.0, 0.0 }; - GLboolean calc_normal = GL_FALSE; - - MSG( 15, " --> inspect_current_contour( tobj:%p )\n", tobj ); - - if ( current->num_vertices < 3 ) - { - MSG( 15, " count %d < 3, deleting\n", current->num_vertices ); - delete_contour( &tobj->current_contour ); - return; - } - - current->last_vertex->next = current->vertices; - current->vertices->prev = current->last_vertex; - - MSG( 15, " current normal: (%.2f, %.2f, %.2f)\n", current->plane.normal[X], current->plane.normal[Y], current->plane.normal[Z] ); - - if ( IS_EQUAL_3DV( current->plane.normal, origin ) ) - { - /* We haven't been given a normal, so let's take a guess. */ - if ( find_normal( tobj ) == GLU_ERROR ) { - return; - } - - COPY_3V( tobj->plane.normal, current->plane.normal ); - tobj->plane.dist = current->plane.dist; - - calc_normal = GL_TRUE; - } - - project_current_contour( tobj ); - - if ( calc_normal && ( tobj->current_contour->orientation == GLU_CW ) ) - { - MSG( 15, " oops, let's try that again...\n" ); - - /* - * FIXME: We've used a reflex angle to calculate the normal. At - * the moment, we simply reverse the normal and re-project the - * contour, but this is sloooow... - */ - NEG_3V( tobj->plane.normal ); - NEG_3V( tobj->current_contour->plane.normal ); - - project_current_contour( tobj ); - } - - if ( save_current_contour( tobj ) == GLU_ERROR ) { - return; - } - - MSG( 15, " <-- inspect_current_contour( tobj:%p )\n", tobj ); -} - -/***************************************************************************** - * reverse_contour - *****************************************************************************/ -void reverse_contour( tess_contour_t *contour ) -{ - tess_vertex_t *current = contour->vertices; - GLint i; - - for ( i = 0 ; i < contour->num_vertices ; i++ ) - { - tess_vertex_t *next = current->next; - tess_vertex_t *prev = current->prev; - - current->next = prev; - current->prev = next; - - current = next; - } - - contour->orientation = - ( contour->orientation == GLU_CCW ) ? GLU_CW : GLU_CCW; - - contour->last_vertex = contour->vertices->prev; -} - -/***************************************************************************** - * orient_contours - * - * Sum the signed areas of the contours, and orient the contours such that - * this sum is nonnegative. - *****************************************************************************/ -static void orient_contours( GLUtesselator *tobj ) -{ - tess_contour_t *contour = tobj->contours; - GLdouble sum = 0.0; - GLint i; - - MSG( 15, " --> orient_contours( tobj:%p )\n", tobj ); - - /* Sum the signed areas of all contours */ - for ( i = 0 ; i < tobj->num_contours ; i++ ) - { - sum += contour->area; - contour = contour->next; - } - - MSG( 15, " signed area: %.2f\n", sum ); - - if ( sum < -GLU_TESS_EPSILON ) - { - for ( i = 0 ; i < tobj->num_contours ; i++ ) - { - contour->area = ABSD( contour->area ); - reverse_contour( contour ); - - contour = contour->next; - } - } - else - { - for ( i = 0 ; i < tobj->num_contours ; i++ ) - { - contour->area = ABSD( contour->area ); - - contour = contour->next; - } - } - - tobj->orientation = tobj->contours->orientation; - - MSG( 15, " <-- orient_contours( tobj:%p ) orient: %s\n", - tobj, ( tobj->orientation == GLU_CCW ) ? "GLU_CCW" : "GLU_CW" ); -} - - -/***************************************************************************** - * delete_contour - * - * Delete the given contour and set the pointer to NULL. - *****************************************************************************/ -void delete_contour( tess_contour_t **contour ) -{ - tess_vertex_t *vertex, *next; - GLint i; - - if ( *contour == NULL ) { return; } - - vertex = (*contour)->vertices; - - for ( i = 0 ; i < (*contour)->num_vertices ; i++ ) - { - next = vertex->next; - free( vertex ); - vertex = next; - } - - free( *contour ); - *contour = NULL; -} - -/***************************************************************************** - * delete_all_contours - *****************************************************************************/ -static void delete_all_contours( GLUtesselator *tobj ) -{ - tess_contour_t *current, *next_contour; - GLint i; - - if ( tobj->current_contour != NULL ) { - delete_contour( &tobj->current_contour ); - } - - for ( current = tobj->contours, i = 0 ; i < tobj->num_contours ; i++ ) - { - tess_vertex_t *vertex = current->vertices, *next_vertex; - GLint j; - - for ( j = 0 ; j < current->num_vertices ; j ++ ) - { - next_vertex = vertex->next; - free( vertex ); - vertex = next_vertex; - } - next_contour = current->next; - - free( current ); - current = next_contour; - } - - tobj->num_contours = tobj->num_vertices = 0; - tobj->contours = tobj->last_contour = NULL; - - CLEAR_BBOX_2DV( tobj->mins, tobj->maxs ); -} - - -/***************************************************************************** - * tess_cleanup - *****************************************************************************/ -static void tess_cleanup( GLUtesselator *tobj ) -{ - MSG( 15, " -> tess_cleanup( tobj:%p )\n", tobj ); - - if ( tobj->current_contour != NULL ) { - delete_contour( &tobj->current_contour ); - } - if ( tobj->contours != NULL ) { - delete_all_contours( tobj ); - } - - MSG( 15, " <- tess_cleanup( tobj:%p )\n", tobj ); -} - - -/***************************************************************************** - * tess_msg - *****************************************************************************/ -INLINE void tess_msg( GLint level, char *format, ... ) -{ -#ifdef DEBUG - va_list ap; - va_start( ap, format ); - - if ( level <= tess_dbg_level ) { - vfprintf( DBG_STREAM, format, ap ); - fflush( DBG_STREAM ); - } - - va_end( ap ); -#endif -} - -INLINE void tess_info( char *file, GLint line ) -{ -#ifdef DEBUG - fprintf( DBG_STREAM, "%9.9s:%d:\t ", file, line ); -#endif -} - - - -/***************************************************************************** - * - * GLU TESSELLATION FUNCTIONS - * - *****************************************************************************/ - - -/***************************************************************************** - * gluNewTess - *****************************************************************************/ -GLUtesselator* GLAPIENTRY gluNewTess( void ) -{ - GLUtesselator *tobj; - -#ifdef DEBUG - if ( getenv( "MESA_TESS_DBG_LEVEL" ) ) { - tess_dbg_level = atoi( getenv( "MESA_TESS_DBG_LEVEL" ) ); - } else { - tess_dbg_level = DBG_LEVEL_BASE; - } +/* + * This is ugly, but seems the easiest way to do things to make the + * code work under YellowBox for Windows + */ +#if defined(OPENSTEP) && defined(CALLBACK) +#undef CALLBACK +#define CALLBACK #endif - MSG( 15, "-> gluNewTess()\n" ); - - tobj = malloc( sizeof(GLUtesselator) ); - if ( tobj == NULL ) { - return NULL; - } - - init_callbacks( &tobj->callbacks ); - - tobj->winding_rule = GLU_TESS_WINDING_ODD; - tobj->boundary_only = GL_FALSE; - tobj->tolerance = GLU_TESS_EPSILON; - tobj->orientation = GLU_UNKNOWN; - - tobj->data = NULL; - tobj->num_contours = 0; - tobj->contours = tobj->last_contour = NULL; - tobj->current_contour = NULL; +static void delete_contours(GLUtriangulatorObj *); - CLEAR_BBOX_2DV( tobj->mins, tobj->maxs ); - - tobj->num_vertices = 0; - tobj->sorted_vertices = NULL; -#if 0 - tobj->grid = NULL; +#ifdef __CYGWIN32__ +#define _CALLBACK +#else +#define _CALLBACK GLCALLBACK #endif - tobj->edge_flag = GL_FALSE; - tobj->label = 0; - - ZERO_3V( tobj->plane.normal ); - tobj->plane.dist = 0.0; - - tobj->error = GLU_NO_ERROR; - - MSG( 15, "<- gluNewTess() tobj:%p\n", tobj ); - return tobj; -} - - -/***************************************************************************** - * gluDeleteTess - *****************************************************************************/ -void GLAPIENTRY gluDeleteTess( GLUtesselator *tobj ) -{ - MSG( 15, "-> gluDeleteTess( tobj:%p )\n", tobj ); - if ( ( tobj->error == GLU_NO_ERROR ) && ( tobj->num_contours > 0 ) ) - { - /* gluEndPolygon was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR3 ); - } - /* Delete all internal structures. */ - tess_cleanup( tobj ); - free( tobj ); - - MSG( 15, "<- gluDeleteTess()\n" ); -} - - -/***************************************************************************** - * gluTessBeginPolygon - *****************************************************************************/ -void GLAPIENTRY gluTessBeginPolygon( GLUtesselator *tobj, void *polygon_data ) +static void +init_callbacks(tess_callbacks * callbacks) { - MSG( 15, "-> gluTessBeginPolygon( tobj:%p data:%p )\n", tobj, polygon_data ); - - tobj->error = GLU_NO_ERROR; - - if ( tobj->current_contour != NULL ) - { - /* gluEndPolygon was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR3 ); - tess_cleanup( tobj ); - } - - tobj->data = polygon_data; - tobj->num_vertices = 0; - tobj->edge_flag = GL_FALSE; - tobj->label = 0; - - MSG( 15, "<- gluTessBeginPolygon( tobj:%p data:%p )\n", tobj, polygon_data ); + callbacks->begin = (void (_CALLBACK *) (GLenum)) 0; + callbacks->edgeFlag = (void (_CALLBACK *) (GLboolean)) 0; + callbacks->vertex = (void (_CALLBACK *) (void *)) 0; + callbacks->end = (void (_CALLBACK *) (void)) 0; + callbacks->error = (void (_CALLBACK *) (GLenum)) 0; } - -/***************************************************************************** - * gluTessBeginContour - *****************************************************************************/ -void GLAPIENTRY gluTessBeginContour( GLUtesselator *tobj ) +void +tess_call_user_error(GLUtriangulatorObj * tobj, GLenum gluerr) { - MSG( 15, " -> gluTessBeginContour( tobj:%p )\n", tobj ); - TESS_CHECK_ERRORS( tobj ); - - if ( tobj->current_contour != NULL ) - { - /* gluTessEndContour was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR4 ); - return; - } - - tobj->current_contour = malloc( sizeof(tess_contour_t) ); - if ( tobj->current_contour == NULL ) { - tess_error_callback( tobj, GLU_OUT_OF_MEMORY ); - return; - } - - COPY_3V( tobj->current_contour->plane.normal, tobj->plane.normal ); - tobj->current_contour->plane.dist = tobj->plane.dist; - - tobj->current_contour->area = 0.0; - tobj->current_contour->orientation = GLU_UNKNOWN; - - tobj->current_contour->label = 0; - tobj->current_contour->winding = 0; - - /*tobj->current_contour->rotx = tobj->current_contour->roty = 0.0;*/ - - CLEAR_BBOX_2DV( tobj->current_contour->mins, - tobj->current_contour->maxs ); - - tobj->current_contour->num_vertices = 0; - tobj->current_contour->vertices = - tobj->current_contour->last_vertex = NULL; - - tobj->current_contour->reflex_vertices = NULL; - - cleanup: - MSG( 15, " <- gluTessBeginContour( tobj:%p )\n", tobj ); - return; + if (tobj->error == GLU_NO_ERROR) + tobj->error = gluerr; + if (tobj->callbacks.error != NULL) + (tobj->callbacks.error) (gluerr); } - -/***************************************************************************** - * gluTessVertex - *****************************************************************************/ -void GLAPIENTRY gluTessVertex( GLUtesselator *tobj, GLdouble coords[3], - void *vertex_data ) +GLUtriangulatorObj *GLAPIENTRY +gluNewTess(void) { - tess_contour_t *current = tobj->current_contour; - tess_vertex_t *last_vertex; - - MSG( 15, " -> gluTessVertex( tobj:%p coords:(%.2f,%.2f,%.2f) )\n", tobj, coords[0], coords[1], coords[2] ); - TESS_CHECK_ERRORS( tobj ); - - if ( current == NULL ) - { - /* gluTessBeginContour was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR2 ); - return; - } - - tobj->num_vertices++; - - last_vertex = current->last_vertex; - - if ( last_vertex == NULL ) - { - last_vertex = malloc( sizeof(tess_vertex_t) ); - if ( last_vertex == NULL ) { - tess_error_callback( tobj, GLU_OUT_OF_MEMORY ); - return; - } - - current->vertices = last_vertex; - current->last_vertex = last_vertex; - - last_vertex->index = -1; - last_vertex->data = vertex_data; - - last_vertex->coords[X] = coords[X]; - last_vertex->coords[Y] = coords[Y]; - last_vertex->coords[Z] = coords[Z]; - - last_vertex->v[X] = 0.0; - last_vertex->v[Y] = 0.0; - - last_vertex->edge_flag = GL_TRUE; - - last_vertex->side = 0.0; - - last_vertex->next = NULL; - last_vertex->prev = NULL; - - current->num_vertices++; - } - else - { - tess_vertex_t *vertex; - - vertex = malloc( sizeof(tess_vertex_t) ); - if ( vertex == NULL ) { - tess_error_callback( tobj, GLU_OUT_OF_MEMORY ); - return; - } - - vertex->index = -1; - vertex->data = vertex_data; - - vertex->coords[X] = coords[X]; - vertex->coords[Y] = coords[Y]; - vertex->coords[Z] = coords[Z]; - - vertex->v[X] = 0.0; - vertex->v[Y] = 0.0; - - vertex->edge_flag = GL_TRUE; - - vertex->side = 0.0; - - vertex->next = NULL; - vertex->prev = last_vertex; - - current->num_vertices++; - - last_vertex->next = vertex; - current->last_vertex = vertex; - } - - cleanup: - MSG( 15, " <- gluTessVertex( tobj:%p )\n", tobj ); - return; + GLUtriangulatorObj *tobj; + + if ((tobj = (GLUtriangulatorObj *) + malloc(sizeof(struct GLUtriangulatorObj))) == NULL) + return NULL; + tobj->contours = tobj->last_contour = NULL; + init_callbacks(&tobj->callbacks); + tobj->error = GLU_NO_ERROR; + tobj->current_polygon = NULL; + tobj->contour_cnt = 0; + return tobj; } -/***************************************************************************** - * gluTessEndContour - *****************************************************************************/ -void GLAPIENTRY gluTessEndContour( GLUtesselator *tobj ) +void GLAPIENTRY +gluTessCallback(GLUtriangulatorObj * tobj, GLenum which, + void (GLCALLBACK * fn) ()) { - MSG( 15, " -> gluTessEndContour( tobj:%p )\n", tobj ); - TESS_CHECK_ERRORS( tobj ); - - if ( tobj->current_contour == NULL ) - { - /* gluTessBeginContour was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR2 ); - return; - } - - if ( tobj->current_contour->num_vertices > 0 ) { - inspect_current_contour( tobj ); - } else { - delete_contour( &tobj->current_contour ); - } - - cleanup: - MSG( 15, " <- gluTessEndContour( tobj:%p )\n", tobj ); - return; + switch (which) { + case GLU_BEGIN: + tobj->callbacks.begin = (void (_CALLBACK *) (GLenum)) fn; + break; + case GLU_EDGE_FLAG: + tobj->callbacks.edgeFlag = (void (_CALLBACK *) (GLboolean)) fn; + break; + case GLU_VERTEX: + tobj->callbacks.vertex = (void (_CALLBACK *) (void *)) fn; + break; + case GLU_END: + tobj->callbacks.end = (void (_CALLBACK *) (void)) fn; + break; + case GLU_ERROR: + tobj->callbacks.error = (void (_CALLBACK *) (GLenum)) fn; + break; + default: + tobj->error = GLU_INVALID_ENUM; + break; + } } -/***************************************************************************** - * gluTessEndPolygon - *****************************************************************************/ -void GLAPIENTRY gluTessEndPolygon( GLUtesselator *tobj ) -{ - MSG( 15, "-> gluTessEndPolygon( tobj:%p )\n", tobj ); - TESS_CHECK_ERRORS( tobj ); - - if ( tobj->current_contour != NULL ) - { - /* gluTessBeginPolygon was not called. */ - tess_error_callback( tobj, GLU_TESS_ERROR1 ); - return; - } - TESS_CHECK_ERRORS( tobj ); - - /* - * Ensure we have at least one contour to tessellate. If we have none, - * clean up and exit gracefully. - */ - if ( tobj->num_contours == 0 ) { - tess_cleanup( tobj ); - return; - } - - /* Wrap the contour list. */ - - tobj->last_contour->next = tobj->contours; - tobj->contours->prev = tobj->last_contour; - - TESS_CHECK_ERRORS( tobj ); - - /* Orient the contours correctly */ - orient_contours( tobj ); - - /* - * Before we tessellate the contours, ensure we have the appropriate - * callbacks registered. We at least need the begin, vertex and end - * callbacks to do any meaningful work. - */ - if ( ( ( tobj->callbacks.begin != NULL ) || - ( tobj->callbacks.beginData != NULL ) ) && - ( ( tobj->callbacks.vertex != NULL ) || - ( tobj->callbacks.vertexData != NULL ) ) && - ( ( tobj->callbacks.end != NULL ) || - ( tobj->callbacks.endData != NULL ) ) ) - { - fist_tessellation( tobj ); - } - - cleanup: - delete_all_contours( tobj ); - MSG( 15, "<- gluTessEndPolygon( tobj:%p )\n", tobj ); -} - -/***************************************************************************** - * gluTessCallback - *****************************************************************************/ -void GLAPIENTRY gluTessCallback( GLUtesselator *tobj, GLenum which, - void (GLCALLBACKP fn)() ) +void GLAPIENTRY +gluDeleteTess(GLUtriangulatorObj * tobj) { - switch ( which ) - { - /* Register the begin callbacks. */ - case GLU_TESS_BEGIN: - tobj->callbacks.begin = (void (GLCALLBACKPCAST)(GLenum)) fn; - break; - case GLU_TESS_BEGIN_DATA: - tobj->callbacks.beginData = (void (GLCALLBACKPCAST)(GLenum, void *)) fn; - break; - - /* Register the edge flag callbacks. */ - case GLU_TESS_EDGE_FLAG: - tobj->callbacks.edgeFlag = (void (GLCALLBACKPCAST)(GLboolean)) fn; - break; - case GLU_TESS_EDGE_FLAG_DATA: - tobj->callbacks.edgeFlagData = (void (GLCALLBACKPCAST)(GLboolean, void *)) fn; - break; - - /* Register the vertex callbacks. */ - case GLU_TESS_VERTEX: - tobj->callbacks.vertex = (void (GLCALLBACKPCAST)(void *)) fn; - break; - case GLU_TESS_VERTEX_DATA: - tobj->callbacks.vertexData = (void (GLCALLBACKPCAST)(void *, void *)) fn; - break; - - /* Register the end callbacks. */ - case GLU_TESS_END: - tobj->callbacks.end = (void (GLCALLBACKPCAST)(void)) fn; - break; - case GLU_TESS_END_DATA: - tobj->callbacks.endData = (void (GLCALLBACKPCAST)(void *)) fn; - break; - - /* Register the error callbacks. */ - case GLU_TESS_ERROR: - tobj->callbacks.error = (void (GLCALLBACKPCAST)(GLenum)) fn; - break; - case GLU_TESS_ERROR_DATA: - tobj->callbacks.errorData = (void (GLCALLBACKPCAST)(GLenum, void *)) fn; - break; - - /* Register the combine callbacks. */ - case GLU_TESS_COMBINE: - tobj->callbacks.combine = (void (GLCALLBACKPCAST)(GLdouble[3], void *[4], GLfloat [4], void **)) fn; - break; - case GLU_TESS_COMBINE_DATA: - tobj->callbacks.combineData = (void (GLCALLBACKPCAST)(GLdouble[3], void *[4], GLfloat [4], void **, void *)) fn; - break; - - default: - MSG( 1, " gluTessCallback( tobj:%p which:%d ) invalid enum\n", tobj, which ); - tobj->error = GLU_INVALID_ENUM; - break; - } + if (tobj->error == GLU_NO_ERROR && tobj->contour_cnt) + /* was gluEndPolygon called? */ + tess_call_user_error(tobj, GLU_TESS_ERROR1); + /* delete all internal structures */ + delete_contours(tobj); + free(tobj); } -/***************************************************************************** - * gluTessProperty - * - * Set the current value of the given property. - *****************************************************************************/ -void GLAPIENTRY gluTessProperty( GLUtesselator *tobj, GLenum which, - GLdouble value ) +void GLAPIENTRY +gluBeginPolygon(GLUtriangulatorObj * tobj) { - switch ( which ) - { - case GLU_TESS_BOUNDARY_ONLY: - tobj->boundary_only = (GLboolean) value; - break; - - case GLU_TESS_TOLERANCE: - MSG( 15, " gluTessProperty( tobj:%p ) tolerance: %0.9f\n", tobj, value ); - tobj->tolerance = value; - break; - - case GLU_TESS_WINDING_RULE: - tobj->winding_rule = (GLenum) value; - break; - - default: - MSG( 1, " gluTessProperty( tobj:%p which:%d ) invalid enum\n", tobj, which ); - tobj->error = GLU_INVALID_ENUM; - break; - } +/* + if(tobj->error!=GLU_NO_ERROR) + return; +*/ + tobj->error = GLU_NO_ERROR; + if (tobj->current_polygon != NULL) { + /* gluEndPolygon was not called */ + tess_call_user_error(tobj, GLU_TESS_ERROR1); + /* delete all internal structures */ + delete_contours(tobj); + } + else { + if ((tobj->current_polygon = + (tess_polygon *) malloc(sizeof(tess_polygon))) == NULL) { + tess_call_user_error(tobj, GLU_OUT_OF_MEMORY); + return; + } + tobj->current_polygon->vertex_cnt = 0; + tobj->current_polygon->vertices = + tobj->current_polygon->last_vertex = NULL; + } } -/***************************************************************************** - * gluGetTessProperty - * - * Return the current value of the given property. - *****************************************************************************/ -void GLAPIENTRY gluGetTessProperty( GLUtesselator *tobj, GLenum which, - GLdouble *value ) +void GLAPIENTRY +gluEndPolygon(GLUtriangulatorObj * tobj) { - switch ( which ) - { - case GLU_TESS_BOUNDARY_ONLY: - *value = tobj->boundary_only; - break; - - case GLU_TESS_TOLERANCE: - *value = tobj->tolerance; - break; - - case GLU_TESS_WINDING_RULE: - *value = tobj->winding_rule; - break; - - default: - MSG( 1, " gluGetTessProperty( tobj:%p which:%d ) invalid enum\n", tobj, which ); - tobj->error = GLU_INVALID_ENUM; - break; - } + /*tess_contour *contour_ptr; */ + + /* there was an error */ + if (tobj->error != GLU_NO_ERROR) + goto end; + + /* check if gluBeginPolygon was called */ + if (tobj->current_polygon == NULL) { + tess_call_user_error(tobj, GLU_TESS_ERROR2); + return; + } + tess_test_polygon(tobj); + /* there was an error */ + if (tobj->error != GLU_NO_ERROR) + goto end; + + /* any real contours? */ + if (tobj->contour_cnt == 0) { + /* delete all internal structures */ + delete_contours(tobj); + return; + } + tess_find_contour_hierarchies(tobj); + /* there was an error */ + if (tobj->error != GLU_NO_ERROR) + goto end; + + tess_handle_holes(tobj); + /* there was an error */ + if (tobj->error != GLU_NO_ERROR) + goto end; + + /* if no callbacks, nothing to do */ + if (tobj->callbacks.begin != NULL && tobj->callbacks.vertex != NULL && + tobj->callbacks.end != NULL) { + if (tobj->callbacks.edgeFlag == NULL) + tess_tesselate(tobj); + else + tess_tesselate_with_edge_flag(tobj); + } + + end: + /* delete all internal structures */ + delete_contours(tobj); } -/***************************************************************************** - * gluTessNormal - * - * Set the current tessellation normal. - *****************************************************************************/ -void GLAPIENTRY gluTessNormal( GLUtesselator *tobj, GLdouble x, - GLdouble y, GLdouble z ) +void GLAPIENTRY +gluNextContour(GLUtriangulatorObj * tobj, GLenum type) { - MSG( 15, " gluTessNormal( tobj:%p n:(%.2f,%.2f,%.2f) )\n", tobj, x, y, z ); - - ASSIGN_3V( tobj->plane.normal, x, y, z ); + if (tobj->error != GLU_NO_ERROR) + return; + if (tobj->current_polygon == NULL) { + tess_call_user_error(tobj, GLU_TESS_ERROR2); + return; + } + /* first contour? */ + if (tobj->current_polygon->vertex_cnt) + tess_test_polygon(tobj); } - -/***************************************************************************** - * - * OBSOLETE TESSELLATION FUNCTIONS - * - *****************************************************************************/ - -void GLAPIENTRY gluBeginPolygon( GLUtesselator *tobj ) +void GLAPIENTRY +gluTessVertex(GLUtriangulatorObj * tobj, GLdouble v[3], void *data) { - gluTessBeginPolygon( tobj, NULL ); - gluTessBeginContour( tobj ); + tess_polygon *polygon = tobj->current_polygon; + tess_vertex *last_vertex_ptr; + + if (tobj->error != GLU_NO_ERROR) + return; + if (polygon == NULL) { + tess_call_user_error(tobj, GLU_TESS_ERROR2); + return; + } + last_vertex_ptr = polygon->last_vertex; + if (last_vertex_ptr == NULL) { + if ((last_vertex_ptr = (tess_vertex *) + malloc(sizeof(tess_vertex))) == NULL) { + tess_call_user_error(tobj, GLU_OUT_OF_MEMORY); + return; + } + polygon->vertices = last_vertex_ptr; + polygon->last_vertex = last_vertex_ptr; + last_vertex_ptr->data = data; + last_vertex_ptr->location[0] = v[0]; + last_vertex_ptr->location[1] = v[1]; + last_vertex_ptr->location[2] = v[2]; + last_vertex_ptr->next = NULL; + last_vertex_ptr->previous = NULL; + ++(polygon->vertex_cnt); + } + else { + tess_vertex *vertex_ptr; + + /* same point twice? */ + if (fabs(last_vertex_ptr->location[0] - v[0]) < EPSILON && + fabs(last_vertex_ptr->location[1] - v[1]) < EPSILON && + fabs(last_vertex_ptr->location[2] - v[2]) < EPSILON) { + tess_call_user_error(tobj, GLU_TESS_ERROR6); + return; + } + if ((vertex_ptr = (tess_vertex *) + malloc(sizeof(tess_vertex))) == NULL) { + tess_call_user_error(tobj, GLU_OUT_OF_MEMORY); + return; + } + vertex_ptr->data = data; + vertex_ptr->location[0] = v[0]; + vertex_ptr->location[1] = v[1]; + vertex_ptr->location[2] = v[2]; + vertex_ptr->next = NULL; + vertex_ptr->previous = last_vertex_ptr; + ++(polygon->vertex_cnt); + last_vertex_ptr->next = vertex_ptr; + polygon->last_vertex = vertex_ptr; + } } -void GLAPIENTRY gluNextContour( GLUtesselator *tobj, GLenum type ) -{ - gluTessEndContour( tobj ); - gluTessBeginContour( tobj ); -} -void GLAPIENTRY gluEndPolygon( GLUtesselator *tobj ) +static void +delete_contours(GLUtriangulatorObj * tobj) { - gluTessEndContour( tobj ); - gluTessEndPolygon( tobj ); + tess_polygon *polygon = tobj->current_polygon; + tess_contour *contour, *contour_tmp; + tess_vertex *vertex, *vertex_tmp; + + /* remove current_polygon list - if exists due to detected error */ + if (polygon != NULL) { + if (polygon->vertices) { + for (vertex = polygon->vertices; vertex != polygon->last_vertex;) { + vertex_tmp = vertex->next; + free(vertex); + vertex = vertex_tmp; + } + free(vertex); + } + free(polygon); + tobj->current_polygon = NULL; + } + /* remove all contour data */ + for (contour = tobj->contours; contour != NULL;) { + for (vertex = contour->vertices; vertex != contour->last_vertex;) { + vertex_tmp = vertex->next; + free(vertex); + vertex = vertex_tmp; + } + free(vertex); + contour_tmp = contour->next; + free(contour); + contour = contour_tmp; + } + tobj->contours = tobj->last_contour = NULL; + tobj->contour_cnt = 0; } |