mesh File Reference

#include "_glu"
#include <cstddef>
#include <cassert>
#include "memalloc"

Include dependency graph for mesh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	GLUvertex
struct	GLUface
struct	GLUhalfEdge
struct	GLUmesh
struct	EdgePair

Macros
#define	tools_glutess_mesh
#define	Rface   Sym->Lface
#define	Dst   Sym->Org
#define	Oprev   Sym->Lnext
#define	Lprev   Onext->Sym
#define	Dprev   Lnext->Sym
#define	Rprev   Sym->Onext
#define	Dnext   Rprev->Sym /* 3 pointers */
#define	Rnext   Oprev->Sym /* 3 pointers */

Typedefs
typedef struct GLUmesh	GLUmesh
typedef struct GLUvertex	GLUvertex
typedef struct GLUface	GLUface
typedef struct GLUhalfEdge	GLUhalfEdge
typedef struct ActiveRegion	ActiveRegion

Functions
inline GLUvertex *	static_allocVertex ()
	inlined C code : /////////////////////////////////// More...
inline GLUface *	static_allocFace ()
inline GLUhalfEdge *	static_MakeEdge (GLUhalfEdge *eNext)
inline void	static_Splice (GLUhalfEdge *a, GLUhalfEdge *b)
inline void	static_MakeVertex (GLUvertex *newVertex, GLUhalfEdge *eOrig, GLUvertex *vNext)
inline void	static_MakeFace (GLUface *newFace, GLUhalfEdge *eOrig, GLUface *fNext)
inline void	static_KillEdge (GLUhalfEdge *eDel)
inline void	static_KillVertex (GLUvertex *vDel, GLUvertex *newOrg)
inline void	static_KillFace (GLUface *fDel, GLUface *newLface)
GLUhalfEdge *	__gl_meshMakeEdge (GLUmesh *mesh)
int	__gl_meshSplice (GLUhalfEdge *eOrg, GLUhalfEdge *eDst)
int	__gl_meshDelete (GLUhalfEdge *eDel)
GLUhalfEdge *	__gl_meshAddEdgeVertex (GLUhalfEdge *eOrg)
GLUhalfEdge *	__gl_meshSplitEdge (GLUhalfEdge *eOrg)
GLUhalfEdge *	__gl_meshConnect (GLUhalfEdge *eOrg, GLUhalfEdge *eDst)
void	__gl_meshZapFace (GLUface *fZap)
GLUmesh *	__gl_meshNewMesh (void)
GLUmesh *	__gl_meshUnion (GLUmesh *mesh1, GLUmesh *mesh2)
void	__gl_meshDeleteMesh (GLUmesh *mesh)
void	__gl_meshCheckMesh (GLUmesh *mesh)

Macro Definition Documentation

Dnext

#define Dnext   Rprev->Sym /* 3 pointers */

Definition at line 127 of file mesh.

Dprev

#define Dprev   Lnext->Sym

Definition at line 125 of file mesh.

Dst

#define Dst   Sym->Org

Definition at line 121 of file mesh.

Lprev

#define Lprev   Onext->Sym

Definition at line 124 of file mesh.

Oprev

#define Oprev   Sym->Lnext

Definition at line 123 of file mesh.

Rface

#define Rface   Sym->Lface

Definition at line 120 of file mesh.

Rnext

#define Rnext   Oprev->Sym /* 3 pointers */

Definition at line 128 of file mesh.

Rprev

#define Rprev   Sym->Onext

Definition at line 126 of file mesh.

tools_glutess_mesh

#define tools_glutess_mesh

Definition at line 4 of file mesh.

Typedef Documentation

ActiveRegion

typedef struct ActiveRegion ActiveRegion

Definition at line 1 of file mesh.

GLUface

typedef struct GLUface GLUface

Definition at line 1 of file mesh.

GLUhalfEdge

typedef struct GLUhalfEdge GLUhalfEdge

Definition at line 1 of file mesh.

GLUmesh

typedef struct GLUmesh GLUmesh

Definition at line 1 of file mesh.

GLUvertex

typedef struct GLUvertex GLUvertex

Definition at line 1 of file mesh.

Function Documentation

__gl_meshAddEdgeVertex()

GLUhalfEdge* __gl_meshAddEdgeVertex ( GLUhalfEdge *  eOrg )

inline

Definition at line 625 of file mesh.

{
  GLUhalfEdge *eNewSym;
  GLUhalfEdge *eNew = static_MakeEdge( eOrg );
  if (eNew == NULL) return NULL;
 
  eNewSym = eNew->Sym;
 
  /* Connect the new edge appropriately */
  static_Splice( eNew, eOrg->Lnext );
 
  /* Set the vertex and face information */
  eNew->Org = eOrg->Dst;
  {
    GLUvertex *newVertex= static_allocVertex();
    if (newVertex == NULL) return NULL;
 
    static_MakeVertex( newVertex, eNewSym, eNew->Org );
  }
  eNew->Lface = eNewSym->Lface = eOrg->Lface;
 
  return eNew;
}

__gl_meshCheckMesh()

void __gl_meshCheckMesh ( GLUmesh *  mesh )

inline

Definition at line 917 of file mesh.

{
  GLUface *fHead = &mesh->fHead;
  GLUvertex *vHead = &mesh->vHead;
  GLUhalfEdge *eHead = &mesh->eHead;
  GLUface *f, *fPrev;
  GLUvertex *v, *vPrev;
  GLUhalfEdge *e, *ePrev;
 
  fPrev = fHead;
  for( fPrev = fHead ; (f = fPrev->next) != fHead; fPrev = f) {
    assert( f->prev == fPrev );
    e = f->anEdge;
    do {
      assert( e->Sym != e );
      assert( e->Sym->Sym == e );
      assert( e->Lnext->Onext->Sym == e );
      assert( e->Onext->Sym->Lnext == e );
      assert( e->Lface == f );
      e = e->Lnext;
    } while( e != f->anEdge );
  }
  assert( f->prev == fPrev && f->anEdge == NULL && f->data == NULL );
 
  vPrev = vHead;
  for( vPrev = vHead ; (v = vPrev->next) != vHead; vPrev = v) {
    assert( v->prev == vPrev );
    e = v->anEdge;
    do {
      assert( e->Sym != e );
      assert( e->Sym->Sym == e );
      assert( e->Lnext->Onext->Sym == e );
      assert( e->Onext->Sym->Lnext == e );
      assert( e->Org == v );
      e = e->Onext;
    } while( e != v->anEdge );
  }
  assert( v->prev == vPrev && v->anEdge == NULL && v->data == NULL );
 
  ePrev = eHead;
  for( ePrev = eHead ; (e = ePrev->next) != eHead; ePrev = e) {
    assert( e->Sym->next == ePrev->Sym );
    assert( e->Sym != e );
    assert( e->Sym->Sym == e );
    assert( e->Org != NULL );
    assert( e->Dst != NULL );
    assert( e->Lnext->Onext->Sym == e );
    assert( e->Onext->Sym->Lnext == e );
  }
  assert( e->Sym->next == ePrev->Sym
       && e->Sym == &mesh->eHeadSym
       && e->Sym->Sym == e
       && e->Org == NULL && e->Dst == NULL
       && e->Lface == NULL && e->Rface == NULL );
}

__gl_meshConnect()

GLUhalfEdge* __gl_meshConnect ( GLUhalfEdge *  eOrg, GLUhalfEdge *  eDst  )

inline

Definition at line 687 of file mesh.

{
  GLUhalfEdge *eNewSym;
  int joiningLoops = TOOLS_GLU_FALSE;  
  GLUhalfEdge *eNew = static_MakeEdge( eOrg );
  if (eNew == NULL) return NULL;
 
  eNewSym = eNew->Sym;
 
  if( eDst->Lface != eOrg->Lface ) {
    /* We are connecting two disjoint loops -- destroy eDst->Lface */
    joiningLoops = TOOLS_GLU_TRUE;
    static_KillFace( eDst->Lface, eOrg->Lface );
  }
 
  /* Connect the new edge appropriately */
  static_Splice( eNew, eOrg->Lnext );
  static_Splice( eNewSym, eDst );
 
  /* Set the vertex and face information */
  eNew->Org = eOrg->Dst;
  eNewSym->Org = eDst->Org;
  eNew->Lface = eNewSym->Lface = eOrg->Lface;
 
  /* Make sure the old face points to a valid half-edge */
  eOrg->Lface->anEdge = eNewSym;
 
  if( ! joiningLoops ) {
    GLUface *newFace= static_allocFace();
    if (newFace == NULL) return NULL;
 
    /* We split one loop into two -- the new loop is eNew->Lface */
    static_MakeFace( newFace, eNew, eOrg->Lface );
  }
  return eNew;
}

__gl_meshDelete()

int __gl_meshDelete ( GLUhalfEdge *  eDel )

inline

Definition at line 560 of file mesh.

{
  GLUhalfEdge *eDelSym = eDel->Sym;
  int joiningLoops = TOOLS_GLU_FALSE;
 
  /* First step: disconnect the origin vertex eDel->Org.  We make all
   * changes to get a consistent mesh in this "intermediate" state.
   */
  if( eDel->Lface != eDel->Rface ) {
    /* We are joining two loops into one -- remove the left face */
    joiningLoops = TOOLS_GLU_TRUE;
    static_KillFace( eDel->Lface, eDel->Rface );
    /* G.Barrand : note : Coverity says that there is a problem using eDel->Lface->anEdge in the below,
       but it appears that at the out of the upper static_KillFace() call (then here), eDel->Lface before
       (the pointer freeed) is not the same than after (then here). */
  }
 
  if( eDel->Onext == eDel ) {
    static_KillVertex( eDel->Org, NULL );
  } else {
    /* Make sure that eDel->Org and eDel->Rface point to valid half-edges */
    eDel->Rface->anEdge = eDel->Oprev;
    eDel->Org->anEdge = eDel->Onext;
 
    static_Splice( eDel, eDel->Oprev );
    if( ! joiningLoops ) {
      GLUface *newFace= static_allocFace();
      if (newFace == NULL) return 0; 
 
      /* We are splitting one loop into two -- create a new loop for eDel. */
      static_MakeFace( newFace, eDel, eDel->Lface );
    }
  }
 
  /* Claim: the mesh is now in a consistent state, except that eDel->Org
   * may have been deleted.  Now we disconnect eDel->Dst.
   */
  if( eDelSym->Onext == eDelSym ) {
    static_KillVertex( eDelSym->Org, NULL );
    static_KillFace( eDelSym->Lface, NULL );
  } else {
    /* Make sure that eDel->Dst and eDel->Lface point to valid half-edges */
    eDel->Lface->anEdge = eDelSym->Oprev;
    eDelSym->Org->anEdge = eDelSym->Onext;
    static_Splice( eDelSym, eDelSym->Oprev );
  }
 
  /* Any isolated vertices or faces have already been freed. */
  static_KillEdge( eDel );
 
  return 1;
}

__gl_meshDeleteMesh()

void __gl_meshDeleteMesh ( GLUmesh *  mesh )

inline

Definition at line 890 of file mesh.

{
  GLUface *f, *fNext;
  GLUvertex *v, *vNext;
  GLUhalfEdge *e, *eNext;
 
  for( f = mesh->fHead.next; f != &mesh->fHead; f = fNext ) {
    fNext = f->next;
    memFree( f );
  }
 
  for( v = mesh->vHead.next; v != &mesh->vHead; v = vNext ) {
    vNext = v->next;
    memFree( v );
  }
 
  for( e = mesh->eHead.next; e != &mesh->eHead; e = eNext ) {
    /* One call frees both e and e->Sym (see EdgePair above) */
    eNext = e->next;
    memFree( e );
  }
 
  memFree( mesh );
}

__gl_meshMakeEdge()

GLUhalfEdge* __gl_meshMakeEdge ( GLUmesh *  mesh )

inline

Definition at line 451 of file mesh.

{
  GLUvertex *newVertex1= static_allocVertex();
  GLUvertex *newVertex2= static_allocVertex();
  GLUface *newFace= static_allocFace();
  GLUhalfEdge *e;
 
  /* if any one is null then all get freed */
  if (newVertex1 == NULL || newVertex2 == NULL || newFace == NULL) {
     if (newVertex1 != NULL) memFree(newVertex1);
     if (newVertex2 != NULL) memFree(newVertex2);
     if (newFace != NULL) memFree(newFace);     
     return NULL;
  } 
 
  e = static_MakeEdge( &mesh->eHead );
  if (e == NULL) {
     memFree(newVertex1);
     memFree(newVertex2);
     memFree(newFace);
     return NULL;
  }
 
  static_MakeVertex( newVertex1, e, &mesh->vHead );
  static_MakeVertex( newVertex2, e->Sym, &mesh->vHead );
  static_MakeFace( newFace, e, &mesh->fHead );
  return e;
}

__gl_meshNewMesh()

GLUmesh* __gl_meshNewMesh ( void  )

inline

Definition at line 782 of file mesh.

{
  GLUvertex *v;
  GLUface *f;
  GLUhalfEdge *e;
  GLUhalfEdge *eSym;
  GLUmesh *mesh = (GLUmesh *)memAlloc( sizeof( GLUmesh ));
  if (mesh == NULL) {
     return NULL;
  }
  
  v = &mesh->vHead;
  f = &mesh->fHead;
  e = &mesh->eHead;
  eSym = &mesh->eHeadSym;
 
  v->next = v->prev = v;
  v->anEdge = NULL;
  v->data = NULL;
 
  f->next = f->prev = f;
  f->anEdge = NULL;
  f->data = NULL;
  f->trail = NULL;
  f->marked = TOOLS_GLU_FALSE;
  f->inside = TOOLS_GLU_FALSE;
 
  e->next = e;
  e->Sym = eSym;
  e->Onext = NULL;
  e->Lnext = NULL;
  e->Org = NULL;
  e->Lface = NULL;
  e->winding = 0;
  e->activeRegion = NULL;
 
  eSym->next = eSym;
  eSym->Sym = e;
  eSym->Onext = NULL;
  eSym->Lnext = NULL;
  eSym->Org = NULL;
  eSym->Lface = NULL;
  eSym->winding = 0;
  eSym->activeRegion = NULL;
 
  return mesh;
}

__gl_meshSplice()

int __gl_meshSplice ( GLUhalfEdge *  eOrg, GLUhalfEdge *  eDst  )

inline

Definition at line 504 of file mesh.

{
  int joiningLoops = TOOLS_GLU_FALSE;
  int joiningVertices = TOOLS_GLU_FALSE;
 
  if( eOrg == eDst ) return 1;
 
  if( eDst->Org != eOrg->Org ) {
    /* We are merging two disjoint vertices -- destroy eDst->Org */
    joiningVertices = TOOLS_GLU_TRUE;
    static_KillVertex( eDst->Org, eOrg->Org );
  }
  if( eDst->Lface != eOrg->Lface ) {
    /* We are connecting two disjoint loops -- destroy eDst->Lface */
    joiningLoops = TOOLS_GLU_TRUE;
    static_KillFace( eDst->Lface, eOrg->Lface );
  }
 
  /* Change the edge structure */
  static_Splice( eDst, eOrg );
 
  if( ! joiningVertices ) {
    GLUvertex *newVertex= static_allocVertex();
    if (newVertex == NULL) return 0;
 
    /* We split one vertex into two -- the new vertex is eDst->Org.
     * Make sure the old vertex points to a valid half-edge.
     */
    static_MakeVertex( newVertex, eDst, eOrg->Org );
    eOrg->Org->anEdge = eOrg;
  }
  if( ! joiningLoops ) {
    GLUface *newFace= static_allocFace();  
    if (newFace == NULL) return 0;
 
    /* We split one loop into two -- the new loop is eDst->Lface.
     * Make sure the old face points to a valid half-edge.
     */
    static_MakeFace( newFace, eDst, eOrg->Lface );
    eOrg->Lface->anEdge = eOrg;
  }
 
  return 1;
}

__gl_meshSplitEdge()

GLUhalfEdge* __gl_meshSplitEdge ( GLUhalfEdge *  eOrg )

inline

Definition at line 654 of file mesh.

{
  GLUhalfEdge *eNew;
  GLUhalfEdge *tempHalfEdge= __gl_meshAddEdgeVertex( eOrg );
  if (tempHalfEdge == NULL) return NULL;
 
  eNew = tempHalfEdge->Sym;
 
  /* Disconnect eOrg from eOrg->Dst and connect it to eNew->Org */
  static_Splice( eOrg->Sym, eOrg->Sym->Oprev );
  static_Splice( eOrg->Sym, eNew );
 
  /* Set the vertex and face information */
  eOrg->Dst = eNew->Org;
  eNew->Dst->anEdge = eNew->Sym;    /* may have pointed to eOrg->Sym */
  eNew->Rface = eOrg->Rface;
  eNew->winding = eOrg->winding;    /* copy old winding information */
  eNew->Sym->winding = eOrg->Sym->winding;
 
  return eNew;
}

__gl_meshUnion()

GLUmesh* __gl_meshUnion ( GLUmesh *  mesh1, GLUmesh *  mesh2  )

inline

Definition at line 834 of file mesh.

{
  GLUface *f1 = &mesh1->fHead;
  GLUvertex *v1 = &mesh1->vHead;
  GLUhalfEdge *e1 = &mesh1->eHead;
  GLUface *f2 = &mesh2->fHead;
  GLUvertex *v2 = &mesh2->vHead;
  GLUhalfEdge *e2 = &mesh2->eHead;
 
  /* Add the faces, vertices, and edges of mesh2 to those of mesh1 */
  if( f2->next != f2 ) {
    f1->prev->next = f2->next;
    f2->next->prev = f1->prev;
    f2->prev->next = f1;
    f1->prev = f2->prev;
  }
 
  if( v2->next != v2 ) {
    v1->prev->next = v2->next;
    v2->next->prev = v1->prev;
    v2->prev->next = v1;
    v1->prev = v2->prev;
  }
 
  if( e2->next != e2 ) {
    e1->Sym->next->Sym->next = e2->next;
    e2->next->Sym->next = e1->Sym->next;
    e2->Sym->next->Sym->next = e1;
    e1->Sym->next = e2->Sym->next;
  }
 
  memFree( mesh2 );
  return mesh1;
}

__gl_meshZapFace()

void __gl_meshZapFace ( GLUface *  fZap )

inline

Definition at line 734 of file mesh.

{
  GLUhalfEdge *eStart = fZap->anEdge;
  GLUhalfEdge *e, *eNext, *eSym;
  GLUface *fPrev, *fNext;
 
  /* walk around face, deleting edges whose right face is also NULL */
  eNext = eStart->Lnext;
  do {
    e = eNext;
    eNext = e->Lnext;
 
    e->Lface = NULL;
    if( e->Rface == NULL ) {
      /* delete the edge -- see __gl_MeshDelete above */
 
      if( e->Onext == e ) {
    static_KillVertex( e->Org, NULL );
      } else {
    /* Make sure that e->Org points to a valid half-edge */
    e->Org->anEdge = e->Onext;
    static_Splice( e, e->Oprev );
      }
      eSym = e->Sym;
      if( eSym->Onext == eSym ) {
    static_KillVertex( eSym->Org, NULL );
      } else {
    /* Make sure that eSym->Org points to a valid half-edge */
    eSym->Org->anEdge = eSym->Onext;
    static_Splice( eSym, eSym->Oprev );
      }
      static_KillEdge( e );
    }
  } while( e != eStart );
 
  /* delete from circular doubly-linked list */
  fPrev = fZap->prev;
  fNext = fZap->next;
  fNext->prev = fPrev;
  fPrev->next = fNext;
 
  memFree( fZap );
}

static_allocFace()

inline GLUface* static_allocFace

(

)

Definition at line 229 of file mesh.

{
   return (GLUface *)memAlloc( sizeof( GLUface ));
}

static_allocVertex()

inline GLUvertex* static_allocVertex

(

)

inlined C code : ///////////////////////////////////

Definition at line 224 of file mesh.

{
   return (GLUvertex *)memAlloc( sizeof( GLUvertex ));
}

static_KillEdge()

inline void static_KillEdge

(

GLUhalfEdge *

eDel

)

Definition at line 380 of file mesh.

{
  GLUhalfEdge *ePrev, *eNext;
 
  /* Half-edges are allocated in pairs, see EdgePair above */
  if( eDel->Sym < eDel ) { eDel = eDel->Sym; }
 
  /* delete from circular doubly-linked list */
  eNext = eDel->next;
  ePrev = eDel->Sym->next;
  eNext->Sym->next = ePrev;
  ePrev->Sym->next = eNext;
 
  memFree( eDel );
}

static_KillFace()

inline void static_KillFace	(	GLUface *	fDel,
		GLUface *	newLface
	)

Definition at line 424 of file mesh.

{
  GLUhalfEdge *e, *eStart = fDel->anEdge;
  GLUface *fPrev, *fNext;
 
  /* change the left face of all affected edges */
  e = eStart;
  do {
    e->Lface = newLface;
    e = e->Lnext;
  } while( e != eStart );
 
  /* delete from circular doubly-linked list */
  fPrev = fDel->prev;
  fNext = fDel->next;
  fNext->prev = fPrev;
  fPrev->next = fNext;
 
  memFree( fDel );
}

static_KillVertex()

inline void static_KillVertex	(	GLUvertex *	vDel,
		GLUvertex *	newOrg
	)

Definition at line 400 of file mesh.

{
  GLUhalfEdge *e, *eStart = vDel->anEdge;
  GLUvertex *vPrev, *vNext;
 
  /* change the origin of all affected edges */
  e = eStart;
  do {
    e->Org = newOrg;
    e = e->Onext;
  } while( e != eStart );
 
  /* delete from circular doubly-linked list */
  vPrev = vDel->prev;
  vNext = vDel->next;
  vNext->prev = vPrev;
  vPrev->next = vNext;
 
  memFree( vDel );
}

static_MakeEdge()

inline GLUhalfEdge* static_MakeEdge

(

GLUhalfEdge *

eNext

)

Definition at line 245 of file mesh.

{
  GLUhalfEdge *e;
  GLUhalfEdge *eSym;
  GLUhalfEdge *ePrev;
  EdgePair *pair = (EdgePair *)memAlloc( sizeof( EdgePair ));
  if (pair == NULL) return NULL;
 
  e = &pair->e;
  eSym = &pair->eSym;
 
  /* Make sure eNext points to the first edge of the edge pair */
  if( eNext->Sym < eNext ) { eNext = eNext->Sym; }
 
  /* Insert in circular doubly-linked list before eNext.
   * Note that the prev pointer is stored in Sym->next.
   */
  ePrev = eNext->Sym->next;
  eSym->next = ePrev;
  ePrev->Sym->next = e;
  e->next = eNext;
  eNext->Sym->next = eSym;
 
  e->Sym = eSym;
  e->Onext = e;
  e->Lnext = eSym;
  e->Org = NULL;
  e->Lface = NULL;
  e->winding = 0;
  e->activeRegion = NULL;
 
  eSym->Sym = e;
  eSym->Onext = eSym;
  eSym->Lnext = e;
  eSym->Org = NULL;
  eSym->Lface = NULL;
  eSym->winding = 0;
  eSym->activeRegion = NULL;
 
  return e;
}

static_MakeFace()

inline void static_MakeFace	(	GLUface *	newFace,
		GLUhalfEdge *	eOrig,
		GLUface *	fNext
	)

Definition at line 344 of file mesh.

{
  GLUhalfEdge *e;
  GLUface *fPrev;
  GLUface *fNew = newFace;
 
  assert(fNew != NULL); 
 
  /* insert in circular doubly-linked list before fNext */
  fPrev = fNext->prev;
  fNew->prev = fPrev;
  fPrev->next = fNew;
  fNew->next = fNext;
  fNext->prev = fNew;
 
  fNew->anEdge = eOrig;
  fNew->data = NULL;
  fNew->trail = NULL;
  fNew->marked = TOOLS_GLU_FALSE;
 
  /* The new face is marked "inside" if the old one was.  This is a
   * convenience for the common case where a face has been split in two.
   */
  fNew->inside = fNext->inside;
 
  /* fix other edges on this face loop */
  e = eOrig;
  do {
    e->Lface = fNew;
    e = e->Lnext;
  } while( e != eOrig );
}

static_MakeVertex()

inline void static_MakeVertex	(	GLUvertex *	newVertex,
		GLUhalfEdge *	eOrig,
		GLUvertex *	vNext
	)

Definition at line 310 of file mesh.

{
  GLUhalfEdge *e;
  GLUvertex *vPrev;
  GLUvertex *vNew = newVertex;
 
  assert(vNew != NULL);
 
  /* insert in circular doubly-linked list before vNext */
  vPrev = vNext->prev;
  vNew->prev = vPrev;
  vPrev->next = vNew;
  vNew->next = vNext;
  vNext->prev = vNew;
 
  vNew->anEdge = eOrig;
  vNew->data = NULL;
  /* leave coords, s, t undefined */
 
  /* fix other edges on this vertex loop */
  e = eOrig;
  do {
    e->Org = vNew;
    e = e->Onext;
  } while( e != eOrig );
}

static_Splice()

inline void static_Splice	(	GLUhalfEdge *	a,
		GLUhalfEdge *	b
	)

Definition at line 293 of file mesh.

{
  GLUhalfEdge *aOnext = a->Onext;
  GLUhalfEdge *bOnext = b->Onext;
 
  aOnext->Sym->Lnext = b;
  bOnext->Sym->Lnext = a;
  a->Onext = bOnext;
  b->Onext = aOnext;
}