/* the following array simplifies scanline origin offset
   lookup in the hires screen area...
   DHRB stands for Double High-Res Base-Address and is indexed
   sequentially from scanline 0-191 which avoids the
   ubiquituous venetian blind effect that we know and love */
extern unsigned DHRB[];

/*

The following is logically reordered to match the lores
color order...

                                                Repeated
                                                Binary
          Color         aux1  main1 aux2  main2 Pattern
          Black          00    00    00    00    0000
          Magenta        08    11    22    44    0001
          Dark Blue      11    22    44    08    1000
          Violet         19    33    66    4C    1001
          Dark Green     22    44    08    11    0100
          Grey1          2A    55    2A    55    0101
          Medium Blue    33    66    4C    19    1100
          Light Blue     3B    77    6E    5D    1101
          Brown          44    08    11    22    0010
          Orange         4C    19    33    66    0011
          Grey2          55    2A    55    2A    1010
          Pink           5D    3B    77    6E    1011
          Green          66    4C    19    33    0110
          Yellow         6E    5D    3B    77    0111
          Aqua           77    6E    5D    3B    1110
          White          7F    7F    7F    7F    1111

*/

/*

#define LOBLACK   	0
#define LORED     	1
#define LODKBLUE 	2
#define LOPURPLE  	3
#define LODKGREEN	4
#define LOGRAY    	5
#define LOMEDBLUE	6
#define LOLTBLUE 	7
#define LOBROWN   	8
#define LOORANGE  	9
#define LOGREY    	10
#define LOPINK    	11
#define LOLTGREEN	12
#define LOYELLOW  	13
#define LOAQUA    	14
#define LOWHITE   	15

*/

/* the following array is based on the above */
extern unsigned char dhrbytes[16][4];


/* position of pixels in 4 byte pattern */
/* remember that byte 0 and byte 2 are auxmem
   and byte 1 and byte 3 are main mem
   and the 4 bit pattern of the 7 pixels straddle
   the two memory banks */

/* 7 pixels = 4 bytes */

/* left for reference...
unsigned char dhrpattern[7][4] = {
0,0,0,0,
0,0,0,1,
1,1,1,1,
1,1,2,2,
2,2,2,2,
2,3,3,3,
3,3,3,3};

*/

/* mask values to erase previous contents of pixels */
/* for reference

unsigned char dhrmsk[7][2] = {
0x70, 0,
0x0f, 0x7e,
0x61, 0,
0x1f, 0x7c,
0x43, 0,
0x3f, 0x78,
0x07, 0};

*/

/* getpixel mask values - what color to use */
/* for reference

unsigned char dhrgetmsk[7][2] = {
0x0f, 0,
0x70, 0x01,
0x1e, 0,
0x60, 0x03,
0x3c, 0,
0x40, 0x07,
0x78, 0};

*/


/* the following soft switches select between
   upper and lower banks of video memory */
extern char *dhrmain;
extern char *dhraux;


/* offset into memory frame for pixels */
/* double hi-res xbase */
/* for reference

char DHB[140] = {
0,0,0,0,0,0,0,
2,2,2,2,2,2,2,
4,4,4,4,4,4,4,
6,6,6,6,6,6,6,
8,8,8,8,8,8,8,
10,10,10,10,10,10,10,
12,12,12,12,12,12,12,
14,14,14,14,14,14,14,
16,16,16,16,16,16,16,
18,18,18,18,18,18,18,
20,20,20,20,20,20,20,
22,22,22,22,22,22,22,
24,24,24,24,24,24,24,
26,26,26,26,26,26,26,
28,28,28,28,28,28,28,
30,30,30,30,30,30,30,
32,32,32,32,32,32,32,
34,34,34,34,34,34,34,
36,36,36,36,36,36,36,
38,38,38,38,38,38,38};

*/



/* a double hi-res pixel can occur at any one of 7 positions */
/* in a 4 byte block which spans aux and main screen memory */
/* the horizontal resolution is 140 pixels */
int dhrplot(x,y,drawcolor)
int x, y, drawcolor;
{
    int xoff, pattern;
    unsigned char *ptr;


    if (x < 0 || x > 159 || y < 0 || y > 191)return 0;

    pattern = (x%7);

    if (pattern > 3)xoff = ((x/7) * 2) + 1;
    else xoff = (x/7) * 2;

    ptr = (unsigned char *) (DHRB[y] + xoff);


    /* In praise of the common bitmask...

       The following algorithm uses a simple bitmask
       to erase the target pixel "in place". The same technique
       is used to extract the appropriate new target pixel
       value from a color palette array which contains the
       7 possible pixel values (in 4 bit blocks), and this new
       value is inclusively bitwise OR'd "in place" into
       the position where the previous value was erased
       (in the appropriate area of screen memory).

       The tricky part here (if there is a tricky part) is
       understanding that the high bit is skipped
       in each byte and that pixel order direction is from
       bit 0 to bit 6. The other consideration is that
       some of the pixels span the interleaving of aux and
       main memory "pages". It really isn't too hard to
       understand if you look at the binary values in the
       code below using your favourite scientific calculator.

       Keep in mind that when you use a bitwise AND against a
       bitmask, the binary mask will protect the values
       that hide behind the 1's and erase the values that
       hide behind the 0's. Also keep in mind that an inclusive
       OR is like sliding the two values together into a
       single bitwise value (recombinance).

       So there you have it... a simple process to work
       with a convoluted twisted puppy of a hardware display.

       I should note that the reason I chose to work with
       constants below rather than reduce this to an array
       driven function was two-fold... first-off it was easier
       to read and to to test (i.e. to visually organize)
       but more importantly the use of constants seems to me
       to be a tad more efficient... and if I am wrong then
       I admit to being imperfect. */

    *dhrmain = 0; /* set to main memory */

	switch(pattern)
	{
		/* left this here for reference

		unsigned char dhrpattern[7][4] = {
		0,0,0,0,
		0,0,0,1,
		1,1,1,1,
		1,1,2,2,
		2,2,2,2,
		2,3,3,3,
        3,3,3,3};
        */

		case 0: *dhraux = 0; /* select auxilliary memory */
                *ptr &= 0x70;
                *ptr |= (dhrbytes[drawcolor][0] &0x0f);
 		        *dhrmain = 0; /* reset to main memory */
		        break;
		case 1: *dhraux = 0; /* select auxilliary memory */
                *ptr &= 0x0f;
                *ptr |= (dhrbytes[drawcolor][0] & 0x70);
 		        *dhrmain = 0; /* reset to main memory */
		        *ptr &= 0x7e;
		        *ptr |= (dhrbytes[drawcolor][1] & 0x01);
		        break;
		case 2: *ptr &= 0x61;
		        *ptr |= (dhrbytes[drawcolor][1] & 0x1e);
		        break;
		case 3: *ptr &= 0x1f;
		        *ptr |= (dhrbytes[drawcolor][1] & 0x60);
		        *dhraux = 0; /* select auxilliary memory */
		        *ptr++;      /* advance offset in frame */
                *ptr &= 0x7c;
                *ptr |= (dhrbytes[drawcolor][2] & 0x03);
 		        *dhrmain = 0; /* reset to main memory */
		        break;
		case 4: *dhraux = 0; /* select auxilliary memory */
                *ptr &= 0x43;
                *ptr |= (dhrbytes[drawcolor][2] & 0x3c);
 		        *dhrmain = 0; /* reset to main memory */
		        break;
		case 5: *dhraux = 0; /* select auxilliary memory */
                *ptr &= 0x3f;
                *ptr |= (dhrbytes[drawcolor][2] & 0x40);
 		        *dhrmain = 0; /* reset to main memory */
                *ptr &= 0x78;
                *ptr |= (dhrbytes[drawcolor][3] & 0x07);
 		        break;
		case 6: *ptr &= 0x07;
                *ptr |= (dhrbytes[drawcolor][3] & 0x78);
 		        break;
	}

*dhrmain = 0; /* reset to main memory */

return 0;

}
