windows-xp/Source/XPSP1/NT/multimedia/opengl/glu/libtri/msort.c

/**************************************************************************
 *									  *
 * 		 Copyright (C) 1989, Silicon Graphics, Inc.		  *
 *									  *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright law.  They  may  not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *									  *
 **************************************************************************/

/* msort.c */

/*
	Tom Davis - 1988
	Derrick Burns - 1989
 */

#include <glos.h>
#include <GL/gl.h>
#include <GL/glu.h>

#ifndef NT
#include <assert.h>
#include <stdlib.h>
#else
#include "winmem.h"
#endif

#include "monotone.h"
#include "msort.h"

/* code to do a merge sort where we assume that the initial data tends
 * to make long runs, either up or down.
 */

#define INITSORT 50


/*---------------------------------------------------------------------------
 * init_sort - initialize merge sort data structures
 *---------------------------------------------------------------------------
 */

void
__gl_init_sort( GLUtriangulatorObj *tobj, long n )
{
    if( n == 0 ) return;
    if( tobj->minit ) {
	if( n > tobj->size ) {
	    free( tobj->ptrlist );
	    free( tobj->limits );	
	    free( tobj->dirs );
            tobj->size = n * 2;
            tobj->ptrlist = (void **)
		malloc((unsigned int)tobj->size*sizeof(void *) );
            tobj->limits = (long *)
		malloc((unsigned int)(tobj->size+1)*sizeof(long) );
            tobj->dirs = (enum updown *)
                malloc((unsigned int)tobj->size*sizeof(enum updown) );
	} 
    } else {
        tobj->size = n;
        tobj->ptrlist = (void **)
		malloc((unsigned int)tobj->size*sizeof(void *) );
        tobj->limits = (long *)
		malloc((unsigned int)(tobj->size+1)*sizeof(long) );
        tobj->dirs = (enum updown *)
                malloc((unsigned int)tobj->size*sizeof(enum updown) );
        tobj->minit = 1;
    }
}

/*---------------------------------------------------------------------------
 * clear_sort - free merge sort data structures
 *---------------------------------------------------------------------------
 */

void 
__gl_clear_sort( GLUtriangulatorObj *tobj )
{
    if( tobj->minit ) {
        free( tobj->ptrlist );
	free( tobj->limits );	
	free( tobj->dirs );
        tobj->minit = 0;
    }
 }


/*---------------------------------------------------------------------------
 * msort - perform a merge sort on the data
 *---------------------------------------------------------------------------
 */

void
__gl_msort( GLUtriangulatorObj *tobj, 
            void **curptrlist, long count, long width, SortFunc comp )
{
    long i;
    long p1s, p1e, p2s, p2e, d1, d2;
    long q;
    int result;
    void *tmp;
    void **temp;
    void **newptrlist, **saveptrlist;
    void **c1s, **c1e, **c2s, **c2e, **np;

    /* XXX
    ** if comp() returns 0, then vertices are coincident.  That is illegal,
    ** call error.
    */
    if( count <= 1) return;
    if( count == 2) {
	result = comp( &curptrlist[0], &curptrlist[1] );
	if( result < 0 ) {
	    tmp = curptrlist[0];
	    curptrlist[0] = curptrlist[1];
	    curptrlist[1] = tmp;
	} else if (result == 0) {
	    __gl_in_error( tobj, 6 );
	}
	return;
    }

    __gl_init_sort( tobj, count );

    saveptrlist = curptrlist;
    newptrlist = tobj->ptrlist;
    tobj->limitcount = 0;
    tobj->limits[0] = 0;

    i=0;
    while( 1 ) {
	do {
	    i++;
	    if( i == count ) break;
	    result = comp(&curptrlist[i-1], &curptrlist[i]);
	    if (result == 0) {
		__gl_in_error( tobj, 6 );
	    }
	} while( result > 0 );
        tobj->dirs[tobj->limitcount] = down;
        tobj->limits[++tobj->limitcount] = i;
	if( i == count ) break;

	do {
	    i++;
	    if( i == count ) break;
	    result = comp(&curptrlist[i-1], &curptrlist[i]);
	    if (result == 0) {
		__gl_in_error( tobj, 6 );
	    }
	} while( result <= 0 );
        tobj->dirs[tobj->limitcount] = up;
        tobj->limits[++tobj->limitcount] = i;
	if( i == count ) break;
    }

    q = tobj->newlimitcount = 0;
    for (i = 0; i < tobj->limitcount-1; i += 2) {
	if (tobj->dirs[i] == up) {
	    p1s = tobj->limits[i];
	    p1e = tobj->limits[i+1];
	    d1 = 1;
	} else {
	    p1s = tobj->limits[i+1]-1;
	    p1e = tobj->limits[i]-1;
	    d1 = -1;
	}
	if (tobj->dirs[i+1] == up) {
	    p2s = tobj->limits[i+1];
	    p2e = tobj->limits[i+2];
	    d2 = 1;
	} else {
	    p2s = tobj->limits[i+2]-1;
	    p2e = tobj->limits[i+1]-1;
	    d2 = -1;
	}
	while ((p1s != p1e) && (p2s != p2e)) {
	    result = comp(&curptrlist[p1s], &curptrlist[p2s]);
	    if (result == 0) {
		__gl_in_error( tobj, 6 );
	    }
	    if (result > 0) {
		newptrlist[q++] = curptrlist[p2s];
		p2s += d2;
		if (p2s == p2e) do {
		    newptrlist[q++] = curptrlist[p1s];
		    p1s += d1;
		} while (p1s != p1e);
	    } else {
		newptrlist[q++] = curptrlist[p1s];
		p1s += d1;
		if (p1s == p1e) do {
		    newptrlist[q++] = curptrlist[p2s];
		    p2s += d2;
		} while (p2s != p2e);
	    }
	}
	tobj->limits[++tobj->newlimitcount] = q;
    }

    if (tobj->limitcount & 1) {
	if (tobj->dirs[tobj->limitcount-1] == up) {
	    p1s = tobj->limits[tobj->limitcount-1];
	    p1e = tobj->limits[tobj->limitcount];
	    d1 = 1;
	} else {
	    p1s = tobj->limits[tobj->limitcount] - 1;
	    p1e = tobj->limits[tobj->limitcount-1] - 1;
	    d1 = -1;
	}
	do {
	    newptrlist[q++] = curptrlist[p1s];
	    p1s += d1;
	} while (p1s != p1e);
	tobj->limits[++tobj->newlimitcount] = q;
    }

    tobj->limitcount = tobj->newlimitcount;

// The x86 compiler does not deal with this swap properly (though it does
// it fine in the while loop below).  Luckily, at this point saveptrlist
// has the data we want, so do the assignment to newptrlist using it instead.
//
// Meanwhile, lets keep the old code around so we can verify the compiler
// fix when it rolls out.

//!!!XXX -- compiler bug
#ifdef COMPILER_FIXED
    temp = curptrlist;
    curptrlist = newptrlist;
    newptrlist = temp;
#else
    curptrlist = newptrlist;
    newptrlist = saveptrlist;
#endif

    while (tobj->limitcount > 1) {
	np = newptrlist;
	q = tobj->newlimitcount = 0;
	for (i = 0; i < tobj->limitcount-1; i += 2) {
	    c1s = curptrlist + tobj->limits[i];
	    c1e = curptrlist + tobj->limits[i+1];
	    c2s = curptrlist + tobj->limits[i+1];
	    c2e = curptrlist + tobj->limits[i+2];
	    while ((c1s != c1e) && (c2s != c2e)) {
		result = comp(c1s, c2s);
		if (result == 0) {
		    __gl_in_error( tobj, 6 );
		}
		if (result > 0) {
		    *np++ = *c2s++;
		    if (c2s == c2e) do {
			*np++ = *c1s++;
		    } while (c1s != c1e);
		} else {
		    *np++ = *c1s++;
		    if (c1s == c1e) do {
			*np++ = *c2s++;
		    } while (c2s != c2e);
		}
	    }
	    tobj->limits[++tobj->newlimitcount] = np - newptrlist;
	}
	if( tobj->limitcount & 1 ) {
	    p1s = tobj->limits[tobj->limitcount-1];
	    p1e = tobj->limits[tobj->limitcount];
	    do {
	        *np++ = curptrlist[p1s++];
	    } while (p1s != p1e);
	    tobj->limits[++tobj->newlimitcount] = np - newptrlist;
	}
	tobj->limitcount = tobj->newlimitcount;
	temp = curptrlist;
	curptrlist = newptrlist;
	newptrlist = temp;
    }

    if (curptrlist != saveptrlist)
	for (i = 0; i < count; i++)
            saveptrlist[i] = curptrlist[i];
}