/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1994, 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.  *
 *                                                                        *
 *************************************************************************/

/*
 * File:	blink.c
 *
 *  This program changes the color of a specified primitive to magenta
 *  in order to make it stand out in the display.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef __sgi__
#include <bstring.h>
#endif
#include <string.h>
#include <malloc.h>

#include "mbi.h"

#define UsageString	"[-p <prim_spec>] [-c <x> <y>] [-r <radius>] [-x] [-v]  <in.rdp> <out.rdp>"

#define SIGN_EXTEND_16(x)	((x & 0x8000) ? (x | ~0xffff) : (x))
#define MAX_SEL_PRIM		100
#define MAX_SEL_XY		100

#define MAX_BLINK_COLORS	(sizeof(BlinkColor) / sizeof(RGBColor))
#define MAKE_WORD_8(i)		((BlinkColor[i].r << 16) | (BlinkColor[i].g))
#define MAKE_WORD_9(i)		((BlinkColor[i].b << 16) | 0xff)


typedef struct  {
  int x;
  int y;
} CoordElem;

typedef struct {
  int r, g, b;
} RGBColor;

void range_expand (char *range);

static FILE     *Outfp = NULL;

static u32	  NumPrimitives = 0;
static u32	  SelPrimitive[MAX_SEL_PRIM];
static u32        nSelPrim = 0;
static CoordElem  SelXY[MAX_SEL_XY];
static u32        nSelXY = 0;
static u32	  Verbose = 0;
static u32	  Extract = 0;
static float	  Radius = 0.0;
static u32        BlinkColorIndx = 0;
static RGBColor   BlinkColor[] = {
			{ 0xff, 0x00, 0xff }, /* magenta */
			{ 0x00, 0xff, 0xff }, /* cyan */
			{ 0xff, 0xff, 0x00 }, /* yellow */
			{ 0xff, 0xff, 0xff }, /* white */
			{ 0xff, 0x00, 0x00 }, /* red */
			{ 0x00, 0xff, 0x00 }, /* green */
			{ 0x00, 0x00, 0xff }, /* blue */
			{   64,  224,  208 }, /* turquoise */
			{   50,  255,   47 }  /* green-yellow */
};




/*
 *  select_prim() - test primitive number against all in list
 *  to see if matched.
 */
static int
  select_prim( void )
{
  int i;

  for(i = 0; (i < nSelPrim) && (i < MAX_SEL_PRIM); i++)
  {
    if(SelPrimitive[i] == NumPrimitives)
      return(1);
  }
  return(0);
}


/* 
 *  intersect_test - test for intersection of point with poly
 */

static int
  intersection_test(s32 *buf)
{
  int i;
  int left;
  float x[3], y[3]; 
  float dxh, dxm, dxl;
  float yh, ym, yl;
  float xh, xm, xl;
  float x_major, x_minor;

  xl  = (float) buf[2] / 65536.0;
  xh  = (float) buf[4] / 65536.0;
  xm  = (float) buf[6] / 65536.0;
  dxl = (float) buf[3] / 65536.0;
  dxh = (float) buf[5] / 65536.0;
  dxm = (float) buf[7] / 65536.0;
  yl  = (float) SIGN_EXTEND_16(buf[0] & 0xffff) / 4.0;
  ym  = (float) SIGN_EXTEND_16((buf[1] >> 16) & 0xffff) / 4.0;
  yh  = (float) SIGN_EXTEND_16(buf[1] & 0xffff) / 4.0;
  left = (buf[0] & 0x00800000) > 0;

  if(Verbose)
  {
    printf("========================================\n");
    printf("Primitive #%04d\n", NumPrimitives);
    printf(" xl  %f xm  %f xh  %f\n", xl, xm, xh);
    printf(" yl  %f ym  %f yh  %f\n", yl, ym, yh);
    printf(" dxl %f dxm %f dxh %f\n", dxl, dxm, dxh);
    printf(" left %d\n", left);
  }

  for(i = 0; (i < nSelXY) && (i < MAX_SEL_XY); i++)
  {
    if((SelXY[i].y >= (yh-Radius)) && (SelXY[i].y <= (yl+Radius)))
    {
      x_major = xh + (((float)SelXY[i].y - yh) * dxh);
      if(SelXY[i].y > ym) /* use lower minor edge */
      {
        x_minor = xl + (((float)SelXY[i].y - ym) * dxl);
      }
      else  /* use upper minor edge */
      {
        x_minor = xm + (((float)SelXY[i].y - yh) * dxm);
      }

      if(left)
      {
        if(SelXY[i].x >= (x_major-Radius) && SelXY[i].x <= (x_minor+Radius))
          return(1);
      }
      else
      {
        if(SelXY[i].x >= (x_minor-Radius) && SelXY[i].x <= (x_major+Radius))
          return(1);
      }
    }
  }
  return(0);
}

/*
 *  get_nwords
 */
int
  get_nwords(int type)
{
  switch(type)
  {
      case (char) G_TRI_FILL:
	return(6); 
      case (char) G_TRI_SHADE:
      case (char) G_TRI_TXTR:
	return(22); 
      case (char) G_TRI_SHADE_TXTR:
	return(38);
      case (char) G_TRI_FILL_ZBUFF:
	return(10);
      case (char) G_TRI_SHADE_ZBUFF:
      case (char) G_TRI_TXTR_ZBUFF:
	return(26);
      case (char) G_TRI_SHADE_TXTR_ZBUFF:
	return(42);
      default:
	fprintf(stderr,"Error, unrecognized type: %d\n", type);
	break;
  }
}


/*
 * Parse and dump a RDP-type display list command.
 */
static void
read_rdp(u32 gfx0, u32 gfx1, FILE *in)
{
    u32		addr;
    s32		buffer[44];
    char	op, b0, tstring[32];
    int         i, nwords;
    int         blink_en, write_en;

    /* every command has at least 64-bits... */
    buffer[0] = gfx0;
    buffer[1] = gfx1;

    op = (char) ((gfx0 & 0xff000000) >> 24);

    switch (op) {

      case (char) G_SETCIMG:
      case (char) G_SETZIMG:
      case (char) G_SETTIMG:
      case (char) G_SETENVCOLOR:
      case (char) G_SETPRIMCOLOR:
      case (char) G_SETBLENDCOLOR:
      case (char) G_SETFOGCOLOR:
      case (char) G_SETFILLCOLOR:
      case (char) G_FILLRECT:
      case (char) G_SETTILE:
      case (char) G_LOADTILE:
      case (char) G_LOADBLOCK:
      case (char) G_SETTILESIZE:
      case (char) G_LOADTLUT:
      case (char) G_RDPSETOTHERMODE:
      case (char) G_SETPRIMDEPTH:
      case (char) G_SETSCISSOR:
      case (char) G_SETCONVERT:
      case (char) G_SETKEYR:
      case (char) G_SETKEYGB:
      case (char) G_RDPFULLSYNC:
      case (char) G_RDPTILESYNC:
      case (char) G_RDPPIPESYNC:
      case (char) G_NOOP:
      case (char) G_TEXRECTFLIP:
      case (char) G_TEXRECT:
      case (char) G_SETCOMBINE:
        fwrite( &gfx0, sizeof(u32), 1, Outfp);
        fwrite( &gfx1, sizeof(u32), 1, Outfp);
	break;

      case (char) G_TRI_FILL:
      case (char) G_TRI_SHADE:
      case (char) G_TRI_TXTR:
      case (char) G_TRI_SHADE_TXTR:
      case (char) G_TRI_FILL_ZBUFF:
      case (char) G_TRI_SHADE_ZBUFF:
      case (char) G_TRI_TXTR_ZBUFF:
      case (char) G_TRI_SHADE_TXTR_ZBUFF:

	nwords = get_nwords(op);
	fread(&buffer[2], sizeof(u32), nwords, in);
        write_en = 0;
        blink_en = 0;

        if((select_prim()) == 1)
	  blink_en = 1;
        else if((intersection_test(buffer)) == 1)
	  blink_en = 1;
        else if(!Extract)
          write_en = 1;

        if(blink_en)
          printf("Blinked Primitive Number %d\n", NumPrimitives);

        if(write_en || blink_en)
          fwrite( buffer, sizeof(u32), nwords+2, Outfp);

        ++NumPrimitives;
	break;

      default:
	break;
    }

}

/*
 *  Print Usage
 */
void
  print_usage(char *prog)
{
  printf("Usage: %s %s\n", prog, UsageString);
  printf("Where:\n");
  printf("  -p <prim_spec> is a range expression for primitive numbers you\n");
  printf("         wish to select.  For example: \"1-9,13,47\" or 112 are valid\n");
  printf("         range expressions.  Primitives are numbered as they are listed\n");
  printf("         in 'rdp2read'.\n");
  printf("\n");
  printf("  -c <x> <y> is the coordinate point of intersection used to select\n");
  printf("         all primtives which intersect it.\n");
  printf("\n");
  printf("  -r <radius> is used to increase the area around the point defined with\n");
  printf("         the -c option which blink uses to select primitives.\n");
  printf(" \n");
  printf("  -x is used to extract all attributes and selected primitives into the\n");
  printf("         output display list.  Otherwise, selected primitives are only\n");
  printf("         reported and all attributes and primitives are echoed to the output\n");
  printf("         display list.\n");
  printf(" \n");
  printf(" -v is the verbose flag.  blink will report details on why it selected primitives\n");
  printf("         when you set this flag\n");
}



/*
 * main routine.
 */
int
main(int argc, char **argv)
{
    FILE	*bin_file;
    u32		gfx0, gfx1;
    int		i, c;
    extern char *optarg;
    extern int  optind;
    
    while ((c = getopt(argc, argv, "r:p:c:vxC")) != EOF) 
    {
	switch(c) 
        {
	  case 'p':
            range_expand(optarg);
	    break;

	  case 'c':
            SelXY[nSelXY].x   = atoi(optarg);
            SelXY[nSelXY++].y = atoi(argv[optind++]);
	    break;

	  case 'v':
            Verbose = 1;
	    break;

	  case 'r':
            Radius = atof(optarg);
	    break;

	  case 'x':
            Extract = 1;
	    break;

          default:
	    break;
	}
    }

    if (argc < 3) {
        print_usage(argv[0]);
	exit(-1);
    }

    if ((bin_file=fopen(argv[optind++],"r"))==NULL) {
	fprintf(stderr,"can't open bin file [%s].\n",argv[optind-1]);
	exit(-1);
    }

    if ((Outfp=fopen(argv[optind],"w"))==NULL) {
	fprintf(stderr,"can't open output file [%s].\n",argv[optind]);
	exit(-1);
    }

    fread(&gfx0, sizeof(u32), 1, bin_file);
    fread(&gfx1, sizeof(u32), 1, bin_file);
    while (!feof(bin_file)) {

	read_rdp(gfx0, gfx1, bin_file);

	fread(&gfx0, sizeof(u32), 1, bin_file);
	fread(&gfx1, sizeof(u32), 1, bin_file);
    }

    fclose(bin_file);
    fclose(Outfp);
}



/*
 *  isnumber()
 */
static int
isnumber (char c)
{
   if (c >= '0' && c <= '9')
      return 1;
   else
      return 0;
}

/*
 *  add_number_to_list()
 */
static void
add_number_to_list (char *number)
{
  if(nSelPrim < MAX_SEL_PRIM)
    SelPrimitive[nSelPrim++] = atoi(number);
}


/*
 *  range_expand - exapnd simple range expression
 *
 *  returns NULL terminated list of numeric strings
 */
void
range_expand (char *range)
{
   char   *exp, start_num[20], stop_num[20], prnt_num[20];
   int     n, state, next_state, start_n, stop_n, sindx, pindx, cindx;

   sindx = 0;
   pindx = 0;
   cindx = 0;

   for (state = 0, exp = range; *exp != '\0'; exp++)
     {
	switch (state)
	   {
	   case 0:
	      if (isnumber (*exp))
		{
		   start_num[sindx++] = *exp;
		   next_state = 1;
		}
	      else
		{
		   fprintf (stderr, "Syntax Error: character #%d (%c), state = %d\n", cindx, *exp, state);
		   exit (1);
		}
	      break;
	   case 1:
	      if (isnumber (*exp))
		{
		   start_num[sindx++] = *exp;
		   next_state = 1;
		}
	      else if (*exp == ',')
		{
		   start_num[sindx] = '\0';	/*
						   terminate start number 
						 */
		   sindx = 0;	/*
				   reset start number 
				 */
		   start_n = atoi (start_num);
		   sprintf (prnt_num, "%03d\0", start_n);
		   add_number_to_list (prnt_num);
		   next_state = 0;
		}
	      else if (*exp == '-')
		{
		   start_num[sindx] = '\0';	/*
						   terminate start number 
						 */
		   start_n = atoi (start_num);
		   next_state = 2;
		}
	      else
		{
		   fprintf (stderr, "Syntax Error: character #%d (%c), state = %d\n", cindx, *exp, state);
		   exit (1);
		}
	      break;
	   case 2:
	      if (isnumber (*exp))
		{
		   stop_num[pindx++] = *exp;
		   next_state = 3;
		}
	      else
		{
		   fprintf (stderr, "Syntax Error: character #%d (%c), state = %d\n", cindx, *exp, state);
		   exit (1);
		}
	      break;
	   case 3:
	      if (isnumber (*exp))
		{
		   stop_num[pindx++] = *exp;
		   next_state = 3;
		}
	      else if (*exp == ',')
		{
		   stop_num[pindx] = '\0';	/*
						   terminate stop number 
						 */
		   sindx = 0;	/*
				   reset start number 
				 */
		   pindx = 0;	/*
				   reset stop number 
				 */
		   stop_n = atoi (stop_num);
		   if (start_n >= stop_n)
		     {
			fprintf (stderr, "Syntax Error: in range first number(%d) must be smaller than second(%d)\n", start_n, stop_n);
			exit (1);
		     }
		   for (n = start_n; n <= stop_n; n++)
		     {
			sprintf (prnt_num, "%03d\0", n);
			add_number_to_list (prnt_num);
		     }
		   next_state = 0;
		}
	      else
		{
		   fprintf (stderr, "Syntax Error: character #%d (%c), state = %d\n", cindx, *exp, state);
		   exit (1);
		}
	      break;
	   }
	state = next_state;
	cindx++;
     }

   /*
    *  Cleanup
    */
   start_num[sindx] = '\0';
   start_n = atoi (start_num);

   if (pindx)
     {
	stop_num[pindx] = '\0';
	stop_n = atoi (stop_num);
     }

   if (sindx && !pindx)
     {
	sprintf (prnt_num, "%03d\0", start_n);
	add_number_to_list (prnt_num);
     }
   else if (sindx && pindx)
     {
	if (start_n >= stop_n)
	  {
	     fprintf (stderr, "Syntax Error: in range first number(%d) must be smaller than second(%d)\n", start_n, stop_n);
	     exit (1);
	  }
	for (n = start_n; n <= stop_n; n++)
	  {
	     sprintf (prnt_num, "%03d\0", n);
	     add_number_to_list (prnt_num);
	  }
     }

}