src/glu/mesa/tesselat.c - third_party/mesa - Git at Google


 /*
  * Mesa 3-D graphics library
  * Version:  3.3
  * Copyright (C) 1995-2000  Brian Paul
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this library; if not, write to the Free
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */


 /*
  * This file is part of the polygon tesselation code contributed by
  * Bogdan Sikorski
  */


 #ifdef PC_HEADER
 #include "all.h"
 #else
 #include <stdlib.h>
 #include <math.h>
 #include "tess.h"
 #endif


 static GLboolean edge_flag;

 static void emit_triangle(GLUtriangulatorObj *, tess_vertex *,
 			  tess_vertex *, tess_vertex *);

 static void emit_triangle_with_edge_flag(GLUtriangulatorObj *,
 					 tess_vertex *, GLboolean,
 					 tess_vertex *, GLboolean,
 					 tess_vertex *, GLboolean);

 static GLdouble
 twice_the_triangle_area(tess_vertex * va, tess_vertex * vb, tess_vertex * vc)
 {
    return (vb->x - va->x) * (vc->y - va->y) - (vb->y - va->y) * (vc->x -
 								 va->x);
 }

 static GLboolean
 left(GLdouble A, GLdouble B, GLdouble C, GLdouble x, GLdouble y)
 {
    if (A * x + B * y + C > -EPSILON)
       return GL_TRUE;
    else
       return GL_FALSE;
 }

 static GLboolean
 right(GLdouble A, GLdouble B, GLdouble C, GLdouble x, GLdouble y)
 {
    if (A * x + B * y + C < EPSILON)
       return GL_TRUE;
    else
       return GL_FALSE;
 }

 static GLint
 convex_ccw(tess_vertex * va,
 	   tess_vertex * vb, tess_vertex * vc, GLUtriangulatorObj * tobj)
 {
    GLdouble d;

    d = twice_the_triangle_area(va, vb, vc);

    if (d > EPSILON) {
       return 1;
    }
    else if (d < -EPSILON) {
       return 0;
    }
    else {
       return -1;
    }
 }

 static GLint
 convex_cw(tess_vertex * va,
 	  tess_vertex * vb, tess_vertex * vc, GLUtriangulatorObj * tobj)
 {
    GLdouble d;

    d = twice_the_triangle_area(va, vb, vc);

    if (d < -EPSILON) {
       return 1;
    }
    else if (d > EPSILON) {
       return 0;
    }
    else {
       return -1;
    }
 }

 static GLboolean
 diagonal_ccw(tess_vertex * va,
 	     tess_vertex * vb,
 	     GLUtriangulatorObj * tobj, tess_contour * contour)
 {
    tess_vertex *vc = va->next, *vertex, *shadow_vertex;
    struct
    {
       GLdouble A, B, C;
    }
    ac, cb, ba;
    GLdouble x, y;

    GLint res = convex_ccw(va, vc, vb, tobj);
    if (res == 0)
       return GL_FALSE;
    if (res == -1)
       return GL_TRUE;

    ba.A = vb->y - va->y;
    ba.B = va->x - vb->x;
    ba.C = -ba.A * va->x - ba.B * va->y;
    ac.A = va->y - vc->y;
    ac.B = vc->x - va->x;
    ac.C = -ac.A * vc->x - ac.B * vc->y;
    cb.A = vc->y - vb->y;
    cb.B = vb->x - vc->x;
    cb.C = -cb.A * vb->x - cb.B * vb->y;
    for (vertex = vb->next; vertex != va; vertex = vertex->next) {
       shadow_vertex = vertex->shadow_vertex;
       if (shadow_vertex != NULL &&
 	  (shadow_vertex == va || shadow_vertex == vb || shadow_vertex == vc))
 	 continue;
       x = vertex->x;
       y = vertex->y;
       if (left(ba.A, ba.B, ba.C, x, y) &&
 	  left(ac.A, ac.B, ac.C, x, y) && left(cb.A, cb.B, cb.C, x, y))
 	 return GL_FALSE;
    }
    return GL_TRUE;
 }

 static GLboolean
 diagonal_cw(tess_vertex * va,
 	    tess_vertex * vb,
 	    GLUtriangulatorObj * tobj, tess_contour * contour)
 {
    tess_vertex *vc = va->next, *vertex, *shadow_vertex;
    struct
    {
       GLdouble A, B, C;
    }
    ac, cb, ba;
    GLdouble x, y;

    GLint res = convex_cw(va, vc, vb, tobj);
    if (res == 0)
       return GL_FALSE;
    if (res == -1)
       return GL_TRUE;

    ba.A = vb->y - va->y;
    ba.B = va->x - vb->x;
    ba.C = -ba.A * va->x - ba.B * va->y;
    ac.A = va->y - vc->y;
    ac.B = vc->x - va->x;
    ac.C = -ac.A * vc->x - ac.B * vc->y;
    cb.A = vc->y - vb->y;
    cb.B = vb->x - vc->x;
    cb.C = -cb.A * vb->x - cb.B * vb->y;
    for (vertex = vb->next; vertex != va; vertex = vertex->next) {
       shadow_vertex = vertex->shadow_vertex;
       if (shadow_vertex != NULL &&
 	  (shadow_vertex == va || shadow_vertex == vb || shadow_vertex == vc))
 	 continue;
       x = vertex->x;
       y = vertex->y;
       if (right(ba.A, ba.B, ba.C, x, y) &&
 	  right(ac.A, ac.B, ac.C, x, y) && right(cb.A, cb.B, cb.C, x, y))
 	 return GL_FALSE;
    }
    return GL_TRUE;
 }

 static void
 clip_ear(GLUtriangulatorObj * tobj, tess_vertex * v, tess_contour * contour)
 {
    emit_triangle(tobj, v->previous, v, v->next);
    /* the first in the list */
    if (contour->vertices == v) {
       contour->vertices = v->next;
       contour->last_vertex->next = v->next;
       v->next->previous = contour->last_vertex;
    }
    else
       /* the last ? */
    if (contour->last_vertex == v) {
       contour->vertices->previous = v->previous;
       v->previous->next = v->next;
       contour->last_vertex = v->previous;
    }
    else {
       v->next->previous = v->previous;
       v->previous->next = v->next;
    }
    free(v);
    --(contour->vertex_cnt);
 }

 static void
 clip_ear_with_edge_flag(GLUtriangulatorObj * tobj,
 			tess_vertex * v, tess_contour * contour)
 {
    emit_triangle_with_edge_flag(tobj, v->previous, v->previous->edge_flag,
 				v, v->edge_flag, v->next, GL_FALSE);
    v->previous->edge_flag = GL_FALSE;
    /* the first in the list */
    if (contour->vertices == v) {
       contour->vertices = v->next;
       contour->last_vertex->next = v->next;
       v->next->previous = contour->last_vertex;
    }
    else
       /* the last ? */
    if (contour->last_vertex == v) {
       contour->vertices->previous = v->previous;
       v->previous->next = v->next;
       contour->last_vertex = v->previous;
    }
    else {
       v->next->previous = v->previous;
       v->previous->next = v->next;
    }
    free(v);
    --(contour->vertex_cnt);
 }

 static void
 triangulate_ccw(GLUtriangulatorObj * tobj, tess_contour * contour)
 {
    tess_vertex *vertex;
    GLuint vertex_cnt = contour->vertex_cnt;

    while (vertex_cnt > 3) {
       vertex = contour->vertices;
       while (diagonal_ccw(vertex, vertex->next->next, tobj, contour) ==
 	     GL_FALSE && tobj->error == GLU_NO_ERROR)
 	 vertex = vertex->next;
       if (tobj->error != GLU_NO_ERROR)
 	 return;
       clip_ear(tobj, vertex->next, contour);
       --vertex_cnt;
    }
 }

 static void
 triangulate_cw(GLUtriangulatorObj * tobj, tess_contour * contour)
 {
    tess_vertex *vertex;
    GLuint vertex_cnt = contour->vertex_cnt;

    while (vertex_cnt > 3) {
       vertex = contour->vertices;
       while (diagonal_cw(vertex, vertex->next->next, tobj, contour) ==
 	     GL_FALSE && tobj->error == GLU_NO_ERROR)
 	 vertex = vertex->next;
       if (tobj->error != GLU_NO_ERROR)
 	 return;
       clip_ear(tobj, vertex->next, contour);
       --vertex_cnt;
    }
 }

 static void
 triangulate_ccw_with_edge_flag(GLUtriangulatorObj * tobj,
 			       tess_contour * contour)
 {
    tess_vertex *vertex;
    GLuint vertex_cnt = contour->vertex_cnt;

    while (vertex_cnt > 3) {
       vertex = contour->vertices;
       while (diagonal_ccw(vertex, vertex->next->next, tobj, contour) ==
 	     GL_FALSE && tobj->error == GLU_NO_ERROR)
 	 vertex = vertex->next;
       if (tobj->error != GLU_NO_ERROR)
 	 return;
       clip_ear_with_edge_flag(tobj, vertex->next, contour);
       --vertex_cnt;
    }
 }

 static void
 triangulate_cw_with_edge_flag(GLUtriangulatorObj * tobj,
 			      tess_contour * contour)
 {
    tess_vertex *vertex;
    GLuint vertex_cnt = contour->vertex_cnt;

    while (vertex_cnt > 3) {
       vertex = contour->vertices;
       while (diagonal_cw(vertex, vertex->next->next, tobj, contour) ==
 	     GL_FALSE && tobj->error == GLU_NO_ERROR)
 	 vertex = vertex->next;
       if (tobj->error != GLU_NO_ERROR)
 	 return;
       clip_ear_with_edge_flag(tobj, vertex->next, contour);
       --vertex_cnt;
    }
 }

 void
 tess_tesselate(GLUtriangulatorObj * tobj)
 {
    tess_contour *contour;

    for (contour = tobj->contours; contour != NULL; contour = contour->next) {
       if (contour->orientation == GLU_CCW) {
 	 triangulate_ccw(tobj, contour);
       }
       else {
 	 triangulate_cw(tobj, contour);
       }
       if (tobj->error != GLU_NO_ERROR)
 	 return;

       /* emit the last triangle */
       emit_triangle(tobj, contour->vertices, contour->vertices->next,
 		    contour->vertices->next->next);
    }
 }

 void
 tess_tesselate_with_edge_flag(GLUtriangulatorObj * tobj)
 {
    tess_contour *contour;

    edge_flag = GL_TRUE;
    /* first callback with edgeFlag set to GL_TRUE */
    (tobj->callbacks.edgeFlag) (GL_TRUE);

    for (contour = tobj->contours; contour != NULL; contour = contour->next) {
       if (contour->orientation == GLU_CCW)
 	 triangulate_ccw_with_edge_flag(tobj, contour);
       else
 	 triangulate_cw_with_edge_flag(tobj, contour);
       if (tobj->error != GLU_NO_ERROR)
 	 return;
       /* emit the last triangle */
       emit_triangle_with_edge_flag(tobj, contour->vertices,
 				   contour->vertices->edge_flag,
 				   contour->vertices->next,
 				   contour->vertices->next->edge_flag,
 				   contour->vertices->next->next,
 				   contour->vertices->next->next->edge_flag);
    }
 }

 static void
 emit_triangle(GLUtriangulatorObj * tobj,
 	      tess_vertex * v1, tess_vertex * v2, tess_vertex * v3)
 {
    (tobj->callbacks.begin) (GL_TRIANGLES);
    (tobj->callbacks.vertex) (v1->data);
    (tobj->callbacks.vertex) (v2->data);
    (tobj->callbacks.vertex) (v3->data);
    (tobj->callbacks.end) ();
 }

 static void
 emit_triangle_with_edge_flag(GLUtriangulatorObj * tobj,
 			     tess_vertex * v1,
 			     GLboolean edge_flag1,
 			     tess_vertex * v2,
 			     GLboolean edge_flag2,
 			     tess_vertex * v3, GLboolean edge_flag3)
 {
    (tobj->callbacks.begin) (GL_TRIANGLES);
    if (edge_flag1 != edge_flag) {
       edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
       (tobj->callbacks.edgeFlag) (edge_flag);
    }
    (tobj->callbacks.vertex) (v1->data);
    if (edge_flag2 != edge_flag) {
       edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
       (tobj->callbacks.edgeFlag) (edge_flag);
    }
    (tobj->callbacks.vertex) (v2->data);
    if (edge_flag3 != edge_flag) {
       edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
       (tobj->callbacks.edgeFlag) (edge_flag);
    }
    (tobj->callbacks.vertex) (v3->data);
    (tobj->callbacks.end) ();
 }

	/*
	* Mesa 3-D graphics library
	* Version: 3.3
	* Copyright (C) 1995-2000 Brian Paul
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public
	* License along with this library; if not, write to the Free
	* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/


	/*
	* This file is part of the polygon tesselation code contributed by
	* Bogdan Sikorski
	*/


	#ifdef PC_HEADER
	#include "all.h"
	#else
	#include <stdlib.h>
	#include <math.h>
	#include "tess.h"
	#endif



	static GLboolean edge_flag;

	static void emit_triangle(GLUtriangulatorObj , tess_vertex ,
	tess_vertex , tess_vertex );

	static void emit_triangle_with_edge_flag(GLUtriangulatorObj *,
	tess_vertex *, GLboolean,
	tess_vertex *, GLboolean,
	tess_vertex *, GLboolean);

	static GLdouble
	twice_the_triangle_area(tess_vertex * va, tess_vertex * vb, tess_vertex * vc)
	{
	return (vb->x - va->x) * (vc->y - va->y) - (vb->y - va->y) * (vc->x -
	va->x);
	}

	static GLboolean
	left(GLdouble A, GLdouble B, GLdouble C, GLdouble x, GLdouble y)
	{
	if (A * x + B * y + C > -EPSILON)
	return GL_TRUE;
	else
	return GL_FALSE;
	}

	static GLboolean
	right(GLdouble A, GLdouble B, GLdouble C, GLdouble x, GLdouble y)
	{
	if (A * x + B * y + C < EPSILON)
	return GL_TRUE;
	else
	return GL_FALSE;
	}

	static GLint
	convex_ccw(tess_vertex * va,
	tess_vertex * vb, tess_vertex * vc, GLUtriangulatorObj * tobj)
	{
	GLdouble d;

	d = twice_the_triangle_area(va, vb, vc);

	if (d > EPSILON) {
	return 1;
	}
	else if (d < -EPSILON) {
	return 0;
	}
	else {
	return -1;
	}
	}

	static GLint
	convex_cw(tess_vertex * va,
	tess_vertex * vb, tess_vertex * vc, GLUtriangulatorObj * tobj)
	{
	GLdouble d;

	d = twice_the_triangle_area(va, vb, vc);

	if (d < -EPSILON) {
	return 1;
	}
	else if (d > EPSILON) {
	return 0;
	}
	else {
	return -1;
	}
	}

	static GLboolean
	diagonal_ccw(tess_vertex * va,
	tess_vertex * vb,
	GLUtriangulatorObj * tobj, tess_contour * contour)
	{
	tess_vertex vc = va->next, vertex, *shadow_vertex;
	struct
	{
	GLdouble A, B, C;
	}
	ac, cb, ba;
	GLdouble x, y;

	GLint res = convex_ccw(va, vc, vb, tobj);
	if (res == 0)
	return GL_FALSE;
	if (res == -1)
	return GL_TRUE;

	ba.A = vb->y - va->y;
	ba.B = va->x - vb->x;
	ba.C = -ba.A * va->x - ba.B * va->y;
	ac.A = va->y - vc->y;
	ac.B = vc->x - va->x;
	ac.C = -ac.A * vc->x - ac.B * vc->y;
	cb.A = vc->y - vb->y;
	cb.B = vb->x - vc->x;
	cb.C = -cb.A * vb->x - cb.B * vb->y;
	for (vertex = vb->next; vertex != va; vertex = vertex->next) {
	shadow_vertex = vertex->shadow_vertex;
	if (shadow_vertex != NULL &&
	(shadow_vertex == va \|\| shadow_vertex == vb \|\| shadow_vertex == vc))
	continue;
	x = vertex->x;
	y = vertex->y;
	if (left(ba.A, ba.B, ba.C, x, y) &&
	left(ac.A, ac.B, ac.C, x, y) && left(cb.A, cb.B, cb.C, x, y))
	return GL_FALSE;
	}
	return GL_TRUE;
	}

	static GLboolean
	diagonal_cw(tess_vertex * va,
	tess_vertex * vb,
	GLUtriangulatorObj * tobj, tess_contour * contour)
	{
	tess_vertex vc = va->next, vertex, *shadow_vertex;
	struct
	{
	GLdouble A, B, C;
	}
	ac, cb, ba;
	GLdouble x, y;

	GLint res = convex_cw(va, vc, vb, tobj);
	if (res == 0)
	return GL_FALSE;
	if (res == -1)
	return GL_TRUE;

	ba.A = vb->y - va->y;
	ba.B = va->x - vb->x;
	ba.C = -ba.A * va->x - ba.B * va->y;
	ac.A = va->y - vc->y;
	ac.B = vc->x - va->x;
	ac.C = -ac.A * vc->x - ac.B * vc->y;
	cb.A = vc->y - vb->y;
	cb.B = vb->x - vc->x;
	cb.C = -cb.A * vb->x - cb.B * vb->y;
	for (vertex = vb->next; vertex != va; vertex = vertex->next) {
	shadow_vertex = vertex->shadow_vertex;
	if (shadow_vertex != NULL &&
	(shadow_vertex == va \|\| shadow_vertex == vb \|\| shadow_vertex == vc))
	continue;
	x = vertex->x;
	y = vertex->y;
	if (right(ba.A, ba.B, ba.C, x, y) &&
	right(ac.A, ac.B, ac.C, x, y) && right(cb.A, cb.B, cb.C, x, y))
	return GL_FALSE;
	}
	return GL_TRUE;
	}

	static void
	clip_ear(GLUtriangulatorObj * tobj, tess_vertex * v, tess_contour * contour)
	{
	emit_triangle(tobj, v->previous, v, v->next);
	/* the first in the list */
	if (contour->vertices == v) {
	contour->vertices = v->next;
	contour->last_vertex->next = v->next;
	v->next->previous = contour->last_vertex;
	}
	else
	/* the last ? */
	if (contour->last_vertex == v) {
	contour->vertices->previous = v->previous;
	v->previous->next = v->next;
	contour->last_vertex = v->previous;
	}
	else {
	v->next->previous = v->previous;
	v->previous->next = v->next;
	}
	free(v);
	--(contour->vertex_cnt);
	}

	static void
	clip_ear_with_edge_flag(GLUtriangulatorObj * tobj,
	tess_vertex * v, tess_contour * contour)
	{
	emit_triangle_with_edge_flag(tobj, v->previous, v->previous->edge_flag,
	v, v->edge_flag, v->next, GL_FALSE);
	v->previous->edge_flag = GL_FALSE;
	/* the first in the list */
	if (contour->vertices == v) {
	contour->vertices = v->next;
	contour->last_vertex->next = v->next;
	v->next->previous = contour->last_vertex;
	}
	else
	/* the last ? */
	if (contour->last_vertex == v) {
	contour->vertices->previous = v->previous;
	v->previous->next = v->next;
	contour->last_vertex = v->previous;
	}
	else {
	v->next->previous = v->previous;
	v->previous->next = v->next;
	}
	free(v);
	--(contour->vertex_cnt);
	}

	static void
	triangulate_ccw(GLUtriangulatorObj * tobj, tess_contour * contour)
	{
	tess_vertex *vertex;
	GLuint vertex_cnt = contour->vertex_cnt;

	while (vertex_cnt > 3) {
	vertex = contour->vertices;
	while (diagonal_ccw(vertex, vertex->next->next, tobj, contour) ==
	GL_FALSE && tobj->error == GLU_NO_ERROR)
	vertex = vertex->next;
	if (tobj->error != GLU_NO_ERROR)
	return;
	clip_ear(tobj, vertex->next, contour);
	--vertex_cnt;
	}
	}

	static void
	triangulate_cw(GLUtriangulatorObj * tobj, tess_contour * contour)
	{
	tess_vertex *vertex;
	GLuint vertex_cnt = contour->vertex_cnt;

	while (vertex_cnt > 3) {
	vertex = contour->vertices;
	while (diagonal_cw(vertex, vertex->next->next, tobj, contour) ==
	GL_FALSE && tobj->error == GLU_NO_ERROR)
	vertex = vertex->next;
	if (tobj->error != GLU_NO_ERROR)
	return;
	clip_ear(tobj, vertex->next, contour);
	--vertex_cnt;
	}
	}

	static void
	triangulate_ccw_with_edge_flag(GLUtriangulatorObj * tobj,
	tess_contour * contour)
	{
	tess_vertex *vertex;
	GLuint vertex_cnt = contour->vertex_cnt;

	while (vertex_cnt > 3) {
	vertex = contour->vertices;
	while (diagonal_ccw(vertex, vertex->next->next, tobj, contour) ==
	GL_FALSE && tobj->error == GLU_NO_ERROR)
	vertex = vertex->next;
	if (tobj->error != GLU_NO_ERROR)
	return;
	clip_ear_with_edge_flag(tobj, vertex->next, contour);
	--vertex_cnt;
	}
	}

	static void
	triangulate_cw_with_edge_flag(GLUtriangulatorObj * tobj,
	tess_contour * contour)
	{
	tess_vertex *vertex;
	GLuint vertex_cnt = contour->vertex_cnt;

	while (vertex_cnt > 3) {
	vertex = contour->vertices;
	while (diagonal_cw(vertex, vertex->next->next, tobj, contour) ==
	GL_FALSE && tobj->error == GLU_NO_ERROR)
	vertex = vertex->next;
	if (tobj->error != GLU_NO_ERROR)
	return;
	clip_ear_with_edge_flag(tobj, vertex->next, contour);
	--vertex_cnt;
	}
	}

	void
	tess_tesselate(GLUtriangulatorObj * tobj)
	{
	tess_contour *contour;

	for (contour = tobj->contours; contour != NULL; contour = contour->next) {
	if (contour->orientation == GLU_CCW) {
	triangulate_ccw(tobj, contour);
	}
	else {
	triangulate_cw(tobj, contour);
	}
	if (tobj->error != GLU_NO_ERROR)
	return;

	/* emit the last triangle */
	emit_triangle(tobj, contour->vertices, contour->vertices->next,
	contour->vertices->next->next);
	}
	}

	void
	tess_tesselate_with_edge_flag(GLUtriangulatorObj * tobj)
	{
	tess_contour *contour;

	edge_flag = GL_TRUE;
	/* first callback with edgeFlag set to GL_TRUE */
	(tobj->callbacks.edgeFlag) (GL_TRUE);

	for (contour = tobj->contours; contour != NULL; contour = contour->next) {
	if (contour->orientation == GLU_CCW)
	triangulate_ccw_with_edge_flag(tobj, contour);
	else
	triangulate_cw_with_edge_flag(tobj, contour);
	if (tobj->error != GLU_NO_ERROR)
	return;
	/* emit the last triangle */
	emit_triangle_with_edge_flag(tobj, contour->vertices,
	contour->vertices->edge_flag,
	contour->vertices->next,
	contour->vertices->next->edge_flag,
	contour->vertices->next->next,
	contour->vertices->next->next->edge_flag);
	}
	}

	static void
	emit_triangle(GLUtriangulatorObj * tobj,
	tess_vertex * v1, tess_vertex * v2, tess_vertex * v3)
	{
	(tobj->callbacks.begin) (GL_TRIANGLES);
	(tobj->callbacks.vertex) (v1->data);
	(tobj->callbacks.vertex) (v2->data);
	(tobj->callbacks.vertex) (v3->data);
	(tobj->callbacks.end) ();
	}

	static void
	emit_triangle_with_edge_flag(GLUtriangulatorObj * tobj,
	tess_vertex * v1,
	GLboolean edge_flag1,
	tess_vertex * v2,
	GLboolean edge_flag2,
	tess_vertex * v3, GLboolean edge_flag3)
	{
	(tobj->callbacks.begin) (GL_TRIANGLES);
	if (edge_flag1 != edge_flag) {
	edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
	(tobj->callbacks.edgeFlag) (edge_flag);
	}
	(tobj->callbacks.vertex) (v1->data);
	if (edge_flag2 != edge_flag) {
	edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
	(tobj->callbacks.edgeFlag) (edge_flag);
	}
	(tobj->callbacks.vertex) (v2->data);
	if (edge_flag3 != edge_flag) {
	edge_flag = (edge_flag == GL_TRUE ? GL_FALSE : GL_TRUE);
	(tobj->callbacks.edgeFlag) (edge_flag);
	}
	(tobj->callbacks.vertex) (v3->data);
	(tobj->callbacks.end) ();
	}