--- ray/src/hd/rholo3.c	1998/01/05 16:46:34	3.18
+++ ray/src/hd/rholo3.c	1998/08/12 17:56:06	3.23
@@ -20,7 +20,7 @@ static int	lastin= -1;	/* last ordered position in lis
 
 
 int
-beamcmp(b0, b1)			/* comparison for descending compute order */
+beamcmp(b0, b1)				/* comparison for compute order */
 register PACKHEAD	*b0, *b1;
 {
 	return(	b1->nr*(b0->nc+1) - b0->nr*(b1->nc+1) );
@@ -28,10 +28,20 @@ register PACKHEAD	*b0, *b1;
 
 
 int
-dispbeam(b, hp, bi)			/* display a holodeck beam */
+beamidcmp(b0, b1)			/* comparison for beam searching */
+register PACKHEAD	*b0, *b1;
+{
+	register int	c = b0->hd - b1->hd;
+
+	if (c) return(c);
+	return(b0->bi - b1->bi);
+}
+
+
+int
+dispbeam(b, hb)				/* display a holodeck beam */
 register BEAM	*b;
-HOLO	*hp;
-int	bi;
+register HDBEAMI	*hb;
 {
 	static int	n = 0;
 	static PACKHEAD	*p = NULL;
@@ -48,70 +58,86 @@ int	bi;
 					/* assign packet fields */
 	bcopy((char *)hdbray(b), (char *)packra(p), b->nrm*sizeof(RAYVAL));
 	p->nr = p->nc = b->nrm;
-	for (p->hd = 0; hdlist[p->hd] != hp; p->hd++)
+	for (p->hd = 0; hdlist[p->hd] != hb->h; p->hd++)
 		if (hdlist[p->hd] == NULL)
 			error(CONSISTENCY, "unregistered holodeck in dispbeam");
-	p->bi = bi;
+	p->bi = hb->b;
 	disp_packet(p);			/* display it */
 }
 
 
 bundle_set(op, clist, nents)	/* bundle set operation */
 int	op;
-register PACKHEAD	*clist;
+PACKHEAD	*clist;
 int	nents;
 {
-	register int	i, n;
-
+	int	oldnr, n;
+	HDBEAMI	*hbarr;
+	register PACKHEAD	*csm;
+	register int	i;
+					/* search for common members */
+	qsort((char *)clist, nents, sizeof(PACKHEAD), beamidcmp);
+	for (csm = clist+nents; csm-- > clist; )
+		csm->nc = -1;
+	for (i = 0; i < complen; i++) {
+		csm = (PACKHEAD *)bsearch((char *)(complist+i), (char *)clist,
+				nents, sizeof(PACKHEAD), beamidcmp);
+		if (csm == NULL)
+			continue;
+		oldnr = complist[i].nr;
+		csm->nc = complist[i].nc;
+		switch (op) {
+		case BS_ADD:		/* add to count */
+			complist[i].nr += csm->nr;
+			csm->nr = 0;
+			break;
+		case BS_ADJ:		/* reset count */
+			complist[i].nr = csm->nr;
+			csm->nr = 0;
+			break;
+		case BS_DEL:		/* delete count */
+			if (csm->nr == 0 || csm->nr >= complist[i].nr)
+				complist[i].nr = 0;
+			else
+				complist[i].nr -= csm->nr;
+			break;
+		}
+		if (complist[i].nr != oldnr)
+			lastin = -1;	/* flag sort */
+	}
+				/* computed rays for each uncommon beams */
+	for (csm = clist+nents; csm-- > clist; )
+		if (csm->nc < 0)
+			csm->nc = bnrays(hdlist[csm->hd], csm->bi);
+				/* complete list operations */
 	switch (op) {
 	case BS_NEW:			/* new computation set */
-		if (complen)
+		listpos = 0; lastin = -1;
+		if (complen)		/* free old list */
 			free((char *)complist);
-		if (nents <= 0) {
-			complist = NULL;
-			listpos = complen = 0;
-			lastin = -1;
+		complist = NULL;
+		if (!(complen = nents))
 			return;
-		}
 		complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
 		if (complist == NULL)
 			goto memerr;
 		bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
-		complen = nents;	/* finish initialization below */
 		break;
 	case BS_ADD:			/* add to computation set */
 	case BS_ADJ:			/* adjust set quantities */
 		if (nents <= 0)
 			return;
-					/* merge any common members */
-		for (n = 0; n < nents; n++) {
-			for (i = 0; i < complen; i++)
-				if (clist[n].bi == complist[i].bi &&
-						clist[n].hd == complist[i].hd) {
-					int	oldnr = complist[i].nr;
-					if (op == BS_ADD)
-						complist[i].nr += clist[n].nr;
-					else /* op == BS_ADJ */
-						complist[i].nr = clist[n].nr;
-					clist[n].nr = 0;
-					clist[n].nc = complist[i].nc;
-					if (complist[i].nr != oldnr)
-						lastin = -1;	/* flag sort */
-					break;
-				}
-			if (i >= complen)
-				clist[n].nc = bnrays(hdlist[clist[n].hd],
-						clist[n].bi);
-		}
-					/* sort updated list */
-		sortcomplist();
-					/* sort new entries */
+		sortcomplist();		/* sort updated list & new entries */
 		qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
 					/* what can't we satisfy? */
-		for (n = 0; n < nents && clist[n].nr > clist[n].nc; n++)
+		for (i = nents, csm = clist; i-- && csm->nr > csm->nc; csm++)
 			;
-		if (op == BS_ADJ)
-			nents = n;
+		n = csm - clist;
+		if (op == BS_ADJ) {	/* don't regenerate adjusted beams */
+			for (i = n; i < nents && clist[i].nr > 0; i++)
+				;
+			nents = i;
+		}
 		if (n) {		/* allocate space for merged list */
 			PACKHEAD	*newlist;
 			newlist = (PACKHEAD *)malloc(
@@ -129,44 +155,20 @@ int	nents;
 		lastin = complen-1;	/* list is now sorted */
 		break;
 	case BS_DEL:			/* delete from computation set */
-		if (nents <= 0)
-			return;
-					/* find each member */
-		for (i = 0; i < complen; i++)
-			for (n = 0; n < nents; n++)
-				if (clist[n].bi == complist[i].bi &&
-						clist[n].hd == complist[i].hd) {
-					if (clist[n].nr == 0 ||
-						clist[n].nr >= complist[i].nr)
-						complist[i].nr = 0;
-					else
-						complist[i].nr -= clist[n].nr;
-					lastin = -1;	/* flag full sort */
-					break;
-				}
-		return;			/* no display */
+		return;			/* already done */
 	default:
 		error(CONSISTENCY, "bundle_set called with unknown operation");
 	}
-	if (outdev != NULL) {		/* load and display beams we have */
-		register HDBEAMI	*hb;
-
-		hb = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
-		for (i = 0; i < nents; i++) {
-			hb[i].h = hdlist[clist[i].hd];
-			hb[i].b = clist[i].bi;
-		}
-		hdloadbeams(hb, nents, dispbeam);
-		free((char *)hb);
+	if (outdev == NULL)		/* nothing to display? */
+		return;
+					/* load and display beams we have */
+	hbarr = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
+	for (i = nents; i--; ) {
+		hbarr[i].h = hdlist[clist[i].hd];
+		hbarr[i].b = clist[i].bi;
 	}
-	if (op == BS_NEW) {
-		done_packets(flush_queue());	/* empty queue, so we can... */
-		for (i = 0; i < complen; i++)	/* ...get number computed */
-			complist[i].nc = bnrays(hdlist[complist[i].hd],
-						complist[i].bi);
-		listpos = 0;
-		lastin = -1;		/* flag for initial sort */
-	}
+	hdloadbeams(hbarr, nents, dispbeam);
+	free((char *)hbarr);
 	return;
 memerr:
 	error(SYSTEM, "out of memory in bundle_set");
@@ -227,9 +229,9 @@ init_global()			/* initialize global ray computation *
 					/* compute beam weights */
 	k = 0;
 	for (j = 0; hdlist[j] != NULL; j++) {
-		frac = 512. * hdlist[j]->wg[0] *
-				hdlist[j]->wg[1] * hdlist[j]->wg[2];
-		if (frac < 0.) frac = -frac;
+		frac = 512. * VLEN(hdlist[j]->wg[0]) *
+				VLEN(hdlist[j]->wg[1]) *
+				VLEN(hdlist[j]->wg[2]);
 		for (i = nbeams(hdlist[j]); i > 0; i--) {
 			complist[k].hd = j;
 			complist[k].bi = i;
@@ -245,7 +247,8 @@ init_global()			/* initialize global ray computation *
 		frac = 1024.*1024.*16384. / (wtotal*sizeof(RAYVAL));
 	while (k--)
 		complist[k].nr = frac * complist[k].nr;
-	listpos = 0; lastin = -1;	/* flag initial sort */
+	listpos = 0; lastin = -1;	/* perform initial sort */
+	sortcomplist();
 }