Coverage Report

Coverage Report - uk.co.javagear.Vdp

Classes in this File
3.964
 /*
  * Vdp.java
  *
  * This file is part of JavaGear.
  *
  * JavaGear is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * JavaGear is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with JavaGear; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 package uk.co.javagear;
 
 import java.util.Arrays;
 import org.apache.log4j.Logger;
 
 /**
  * SMS and GG VDP Emulation.
  *
  * @author Copyright (C) 2002-2003 Chris White
  * @version 18th January 2003
  * @see "JavaGear Final Project Report"
  */
 public final class Vdp {
     
     /**
      * Connection to Z80 interrupt line.
      */
     private InterruptLine irq;
     
     /**
      * Pointer to general parameters.
      */
     private Setup setup;
     
     /**
      * Video RAM.
      */
     private byte[] vRam;
     
     /**
      * Colour RAM.
      */
     private int[] cRam;
     
     /**
      * VDP Registers.
      */
     private int[] vdpreg;
     
     /**
      * Status Register.
      */
     private int status;
     
     /**
      * First or second byte of command word.
      */
     private boolean firstByte;
     
     /**
      * Command word first byte latch.
      */
     private int commandByte;
     
     /**
      * Location in VRAM.
      */
     private int location;
     
     /**
      * Store type of operation taking place.
      */
     private int operation;
     
     /**
      * Buffer VRAM reads.
      */
     private int readBuffer;
     
     /**
      * Current line number.
      */
     private int line;
     
     /**
      * Vertical line interrupt counter.
      */
     private int counter;
     
     /**
      * Line interrupt pending.
      */
     private boolean lineint;
     
     /**
      * Frame interrupt pending.
      */
     private boolean frameint;
     
     /**
      * Background priorites.
      */
     private boolean[] bgPriority;
     
     /**
      * Sprite collisions.
      */
     private boolean[] spritecol;
     
     /**
      * Pointer to current display.
      */
     private int[] display;
     
     /**
      * Pointer to previous frame.
      */
     private int[] oldDisplay;
     
     /**
      * Frame 1.
      */
     private int[] display1;
     
     /**
      * Frame 2.
      */
     private int[] display2; 
     
     /**
      * Generate background layer.
      */
     private boolean displayBackgroundLayer = true;
     
     /**
      * Generate sprite layer.
      */
     private boolean displaySpriteLayer = true;
     
     /**
      * NTSC/PAL.
      */
     private boolean ntsc;
     
     
     /**
      * Vdp Constructor.
      *
      * @param set pointer to general parameters
      * @param i pointer to Z80 interrupt line
      */
     public Vdp(Setup set, InterruptLine i) {
         this.irq = i;
         this.setup = set;
         
         display1 = new int[setup.SMS_WIDTH * (setup.SMS_HEIGHT + 1)];
         display2 = new int[setup.SMS_WIDTH * (setup.SMS_HEIGHT + 1)];
         
         // 16K of Video RAM
         vRam = new byte[0x4000];
         
         // 64 Bytes of Colour RAM (32 on SMS)
         cRam = new int[0x40];
         
         // 15 Registers, (0-10) used by SMS, but some programs write > 10
         vdpreg = new int[16];
         
         bgPriority = new boolean[setup.SMS_WIDTH + 7];
         spritecol   = new boolean[setup.SMS_WIDTH];
         
         reset();
     }
     
     /**
      * Reset VDP.
      */
     public void reset() {
         display   = display1;
         oldDisplay = display2;
         firstByte = true;
         lineint = false;
         frameint = false;
         location = 0;
         counter = 0;
         status = 0;
         operation = 0;
         vdpreg[0] = 0;
         vdpreg[1] = 0;
         vdpreg[2] = 0x0E; // B1-B3 high on startup
         vdpreg[3] = 0;
         vdpreg[4] = 0;
         vdpreg[5] = 0x7E; // B1-B6 high on startup
         vdpreg[6] = 0;
         vdpreg[7] = 0;
         vdpreg[8] = 0;
         vdpreg[9] = 0;
         vdpreg[10] = 0;
         
         // Clear Memory
         Arrays.fill(display1, 0);
         Arrays.fill(display2, 0);
         Arrays.fill(vRam, (byte) 0);
         Arrays.fill(cRam, 0);
         Arrays.fill(bgPriority, false);
         Arrays.fill(spritecol, false);
         
         irq.setLine(false);
     }
     
     
     /**
      * Set NTSC / PAL VDP Mode.
      *
      * @param b <code>true</code> if NTSC, <code>false</code> if PAL.
      */
     public void setNTSC(boolean b) {
         ntsc = b;
     }
     
     /**
      * Returns the value of property <code>display</code>. The pointer to the current display.
      *
      * @return the value of property <code>display</code>.
      */
     public int[] getDisplay() {
         return display;
     }
     
     /**
      * Sets the value of property <code>display</code>. The pointer to the current display.
      *
      * @param display the new value of property <code>display</code>.
      */
     public void setDisplay(int[] display) {
         this.display = display;
     }
     
     /**
      * Toggle background layer generation on/off.
      */
     public void setBackgroundLayer() {
         displayBackgroundLayer = !displayBackgroundLayer;
     }
     
     /**
      * Toggle Sprite Layer Generation On/Off.
      */
     public void setSpriteLayer() {
         displaySpriteLayer = !displaySpriteLayer;
     }
     
     
     /**
      * Get a VDP register.
      *
      * @param index index of register.
      *
      * @return register data.
      */
     public int getReg(int index) {
         return vdpreg[index];
     }
     
     
     /**
      * Get line number under generation.
      *
      * @return line number.
      */
     
     public int getLineNo() {
         return line;
     }
     
     
     /**
      * Get line interrupt counter.
      *
      * @return line interrupt counter.
      */
     
     public int getCounter() {
         return counter;
     }
     
     
     /**
      * Get line interrupt pending flag.
      *
      * @return <code>true</code> if pending.
      */
     public boolean getLineIntPending() {
         return lineint;
     }
     
     
     /**
      * Get frame interrupt pending flag.
      *
      * @return <code>true</code> if pending.
      */
     public boolean getFrameIntPending() {
         return frameint;
     }
     
     
     /**
      * Get interruptLine status.
      *
      * @return <code>true</code> if pending.
      */
     public boolean getIrqStatus() {
         return irq.getLine();
     }
     
     
     /**
      * Get sprite overflow status.
      *
      * @return <code>true</code> if overflow has occurred.
      */
     public boolean getSpriteOverflow() {
         return (status & 0x40) == 0x40;
     }
     
     /**
      * Read vertical port.
      *
      * @return VCounter value
      */
     public int getVCount() {
         if (ntsc) {
             if (line > 0xDA) { // Values from 00 to DA, then jump to D5-FF
                 return line - 6;
             }
         } else if (!ntsc) {
             if (line > 0xF2) {
                 return line - 0x39;
             }
         }
         return line;
     }
     
     
     /**
      * Write to VDP control port (<code>0xBF</code>).
      *
      * @param value value to write.
      */
     
     public void controlWrite(int value) {
         // Store First Byte of Command Word
         if (firstByte) {
             firstByte = false;
             commandByte = value;
         } else {
             firstByte = true;
             
             // Set VDP Register
             if ((value >> 4) == 0x08) {
                 vdpreg[(value & 0x0F)] = commandByte; // Set reg to previous byte
                 
                 // Interrupt Control IE1/IE0,
                 // Verified using test program by Charles MacDonald
                 if (lineint) {
                     if (((value & 0x0F) == 0) && ((commandByte & 0x10) == 0x0)) {
                         irq.setLine(false);
                     } else if (((value & 0x0F) == 0) && ((commandByte & 0x10) == 0x10)) {
                         irq.setLine(true);
                     }
                 }
                 
                 if (frameint) {
                     if (((value & 0x0F) == 1) && ((commandByte & 0x20) == 0x0)) {
                         irq.setLine(false);
                     } else if (((value & 0x0F) == 1) && ((commandByte & 0x20) == 0x20)) {
                         irq.setLine(true);
                     }
                 }
             } else {
                 // Operation from B6 + B7
                 operation = (value >> 6);
                 // Set location in VRAM
                 location = commandByte + ((value & 0x3F) << 8);
                 
                 if (operation == 0) {
                     readBuffer = unsigned(vRam[location]);
                     if (++location > 0x3FFF) {
                         location = 0;
                     }
                 }
             }
         }
     }
     
     
     /**
      * Read VDP control port (<code>0xBF</code>).
      *
      * @return copy of status register.
      */
     public int controlRead() {
         // Reset flag
         firstByte = true;
         
         // Create copy, as we'll need to clear bits of status reg
         int statuscopy = status;
         
         // Clear b7, b6, b5 when status register read
         status &= ~0x80 & ~0x40 & ~0x20;
         
         // Clear pending interrupts
         lineint = false;
         frameint = false;
         
         // Clear IRQ Line
         irq.setLine(false);
         
         return statuscopy;
     }
     
     
     /**
      * Write to VDP data port (<code>0xBE</code>).
      *
      * @param value value to write
      */
     public void dataWrite(int value) {
         // Reset flag
         firstByte = true;
         
         switch(operation) {
             // VRAM Write
             case 0x00:
             case 0x01:
             case 0x02:
                 vRam[location] = (byte) value;
                 break;
                 /* CRAM Write
                  * Instead of writing real colour to CRAM, write converted Java palette colours for
                  * speed. Slightly inaccurate, as CRAM doesn't contain real values, but it is never
                  * read by software. */
             case 0x03:
                 switch (setup.getSystem()) {
                     case SMS:
                         cRam[location & 0x1F] = SMS_JAVA[value & 0x3F]; // SMS
                         break;
                     case GG:
                         if ((location & 1) == 0) { // first byte
                             cRam[(location & 0x3F) >> 1] = GG_JAVA1[value]; // GG
                         } else {
                             cRam[((location & 0x3F) - 1) >> 1] |= GG_JAVA2[value & 0x0F];
                         }
                         break;
                     default:
                         Logger.getLogger(this.getClass()).fatal("Invalid system: " 
                                 + setup.getSystem());
                 }
                 break;
             default:
                 break;
         }
         
         if (++location > 0x3FFF) {
             location = 0;
         }
     }
     
     
     /**
      * Read VDP data port (<code>0xBE</code>).
      *
      * @return buffered read from VRAM
      */
     public int dataRead() {
         int value = 0; // Stores value to be returned
         firstByte = true; // Reset flag
         
         switch(operation) {
             // VRAM Read
             case 0x00:
             case 0x01:
             case 0x02:
                 value = readBuffer;
                 readBuffer = unsigned(vRam[location]);
                 break;
                 // CRAM Read
                 // Shouldn't occur but GameGear 'NBA Action' tries this.
             case 0x03:
                 break;
             default:
                 break;
         }
         
         if (++location > 0x3FFF) {
             location = 0;
         }
         
         return value;
     }
     
     
     /**
      * Generate VDP interrupts.
      * Assert the IRQ line as necessary for a particular scanline.
      *
      * @param lineno line to check for interrupts.
      */
     public void interrupts(int lineno) {
         line = lineno;
         
         if (lineno <= 192) {
             // Frame Interrupt Pending
             if (lineno == 192) {
                 status |= 0x80;
                 frameint = true;
             }
             
             // Counter Expired = Line Interrupt Pending
             if (counter == 0) {
                 // Reload Counter
                 counter = vdpreg[10];
                 lineint = true;
             } else { // Otherwise Decrement Counter
                 counter--;
             }
             
             // Line Interrupts Enabled and Pending. Assert IRQ Line.
             if (lineint && ((vdpreg[0] & 0x10) == 0x10)) {
                 irq.setLine(true);
             }
         } else { // lineno >= 193
             // Reload counter on every line outside active display + 1
             counter = vdpreg[10];
             
             // Frame Interrupts Enabled and Pending. Assert IRQ Line.
             if (frameint && ((vdpreg[1] & 0x20) == 0x20) && (lineno < 224)) {
                 irq.setLine(true);
             }
         }
     }
     
     
     /**
      * Render line of SMS/GG display.
      *
      * @param lineno line number to render.
      */
     public void drawLine(int lineno) {
         if (lineno > 191) {
             return;
         }
         
         // Clear Collision Array at start of line
         for (int i = spritecol.length; i-- != 0;) {
             spritecol[i] = false;
         }
         
         if (lineno == 0) {
             // Swap buffers
             if (display == display1) {
                 display = display2;
                 oldDisplay = display1;
             } else {
                 display = display1;
                 oldDisplay = display2;
             }
         }
         
         // Blank Display
         if ((vdpreg[1] & 0x40) != 0) {
             // Draw Background Layer
             if (displayBackgroundLayer) {
                 drawBg(lineno);
             } else {
                 drawBGColour(lineno);
             }
             
             // Draw Sprite Layer
             if (displaySpriteLayer) {
                 drawSprite(lineno);
             }
         } else { // Blank Display
             drawBGColour(lineno);
         }
         
         // Blank Leftmost Column (SMS Only)
         if (Setup.System.SMS == setup.getSystem() 
                 && (vdpreg[0] & 0x20) == 0x20) {
             blankColumn(lineno);
         }
     }
     
     
     /**
      * Render line of sprite layer.
      *
      * @param lineno line number to render.
      */
     private void drawSprite(int lineno) {
         // Sprite Attribute Table Address
         int sat = (vdpreg[5] & ~0x01 & ~0x80) << 7;
         
         // Number of Sprites drawn on this line (max 8)
         int count = 0;
         
         // Height of Sprites
         int height = 8;
         
         // Zoom Sprites
         boolean zoomed = false;
         
         // Enable 8x16 Sprites
         if ((vdpreg[1] & 0x02) == 0x02) {
             height = 16;
         }
         
         // Enable Zoomed Sprites
         if ((vdpreg[1] & 0x01) == 0x01) {
             height <<= 1;
             zoomed = true;
         }
         
         // Search Sprite Attribute Table (64 Bytes)
         for (int spriteno = 0; spriteno < 0x40; spriteno++) {
             // Sprite Overflow (more than 8 sprites on line)
             if (count >= 8) {
                 status |= 0x40;
                 return;
             }
             // Sprite Y Position
             int y = vRam[sat + spriteno] & 0xFF;
             // Address of Sprite in Sprite Attribute Table
             int address = sat + (spriteno << 1);
             // Sprite X Position
             int x = vRam[address + 0x80] & 0xFF;
             // Sprite Pattern Index
             int i = vRam[address + 0x81] & 0xFF;
             
             // VDP stops drawing if y == 208
             if (y == 208) {
                 return;
             }
             
             // y is actually at +1 of value
             y++;
             
             // Use Pattern Index from 100 - 1FFh
             if ((vdpreg[6] & 0x04) == 0x04) {
                 i |= 0x100;
             }
             
             // When using 8x16 sprites LSB has no effect
             if ((vdpreg[1] & 0x02) == 0x02) {
                 i &= ~0x01;
             }
             
             // Shift pixels left by 8
             if ((vdpreg[0] & 0x08) == 0x08) {
                 x -= 8;
             }
             
             // If off screen, draw from negative 16 onwards
             if (y > 240) {
                 y -= 256;
             }
             
             // If Sprite Falls on this line
             if ((lineno >= y) && ((lineno - y) < height)) {
                 int rowPrecal = lineno << 8;
                 
                 // Plot Normal Sprites (Width = 8)
                 if (!zoomed) {
                     // Address of 8 Pixels in VRAM
                     int adr = (i << 5) + ((lineno - y) << 2);
                     
                     // Cycle through 8 Pixels
                     for (int bit = 0x80; bit != 0; bit >>= 1) {
                         // Make sure we're in the valid viewing area
                         if ((x >= 0) && (y >= 0) && (x <= 255)) {
                             // Plot Single Pixel
                             plotSpritePixel(x, lineno, x + rowPrecal, adr, bit);
                         }
                         // Increement X Position
                         x++;
                     }
                 } else { // Plot Zoomed Sprites (Width = 16)
                     int adr = (i << 5) + (((lineno - y) >> 1) << 2);
                     
                     int pixel = 0;
                     
                     for (int bit = 0x80; bit != 0; bit >>= 1) {
                         if ((x + pixel + 1 >= 0) && (y >= 0) && (x <= 255)) {
                             // Plot Two Pixels
                             plotSpritePixel(x + pixel, lineno, x + pixel + rowPrecal, adr, bit);
                             plotSpritePixel(x + pixel + 1, lineno, x + pixel + 1 + rowPrecal
                                     , adr, bit);
                         }
                         x++;
                         pixel++;
                     }
                 }
                 // Increment number of sprites drawn
                 count++;
             }
         } // end for loop
     }
     
     
     /**
      * Plot single sprite pixel.
      *
      * @param x <i>x</i> coordinate of pixel (for location array).
      * @param y <i>y</i> coordinate of pixel.
      * @param location coordinates to plot pixel at <code>x+(y*256)</code>.
      * @param address VRAM address of pixel plane.
      * @param bit bit of plane to plot.
      */
     private void plotSpritePixel(int x, int y, int location, int address, int bit) {
         // Colour of pixel
         int colour = 0;
         
         // Set Colour of Pixel (0-15)
         if ((vRam[address + 0] & bit) != 0) {
             colour |= 0x01;
         }
         if ((vRam[address + 1] & bit) != 0) {
             colour |= 0x02;
         }
         if ((vRam[address + 2] & bit) != 0) {
             colour |= 0x04;
         }
         if ((vRam[address + 3] & bit) != 0) {
             colour |= 0x08;
         }
         
         // Plot Pixel, check background priority for location
         if (!(bgPriority[x]) && (colour != 0)) {
             // Check for existing sprite collision
             if (!spritecol[x]) {
                 spritecol[x] = true;
                 display[location] = cRam[colour + 16];
             } else {
                 status |= 0x20; // set bit 5 of status flag
             }
         }
     }
     
     
     /**
      * Render line of background layer.
      *
      * @param lineno line number to render.
      */
     private void drawBg(int lineno) {
         // Backup the _real_ line number to be plotted
         int y = lineno;
         
         // Vertical Scroll Fine Tune
         if (vdpreg[9] != 0) {
             lineno += vdpreg[9] & 0x07;
         }
         
         // Address of Background Table in VRAM
         int bgt = (vdpreg[2] & 0x0f & ~0x01) << 10;
         
         // Tile Pattern Number
         int pattern = 0;
         
         // Palette To Use
         int pal = 0;
         
         // Horizontal Scroll Value
         int hscroll = 0;
         
         // Start Column (for Horizontal Scroll)
         int startColumn = 0;
         
         // Start Row (For Vertical Scroll)
         int startRow = lineno;
         
         // Tile Row Count
         int tilex = 0;
         
         // Row of Tile to Plot
         int tiley = (lineno & 7);
         
         // Adjust Horizontal Scroll
         
         // Top Two Rows Not Affected by Horizontal Scrolling (SMS Only)
         if (((vdpreg[0] & 0x40) == 0x40) && (y < 16) 
                 && Setup.System.SMS == setup.getSystem()) {
             hscroll = 0;
         } else if (vdpreg[8] != 0) {
             // Horizontal Scroll Fine Tune Value
             hscroll = vdpreg[8] & 0x07;
             // Horizontal Scroll Starting Column
             startColumn = 32 - (vdpreg[8] >> 3);
         }
         
         // Omit First 5 Columns on Game Gear
         if (setup.getSystem() == Setup.System.GG) {
             startColumn = (startColumn + 5) & 0x1F;
         }
         
         // Adjust Vertical Scroll
         if (vdpreg[9] != 0) {
             // Vertical Scroll Starting Row
             startRow += vdpreg[9] & 0xF8;
             if (startRow > 223) {
                 startRow -= 224;
             }
         }
         
         // Cycle through background table
         for (int x = setup.getHStart(); x < setup.getHEnd(); x += 8) {
             // wraps at 32
             if (startColumn == 32) {
                 startColumn = 0;
             }
             
             // Rightmost 8 columns Not Affected by Vertical Scrolling
             if (((vdpreg[0] & 0x80) == 0x80) && (x > 184)) {
                 startRow = y;
                 tiley = (y & 7);
             }
             
             // Get the two bytes from VRAM containing the tile's properties
             int tileProps = bgt + (startColumn << 1) + ((startRow - tiley) << 3);
             int firstbyte =  vRam[tileProps] & 0xFF;
             int secondbyte = vRam[tileProps + 1] & 0xFF;
             
             // Priority of tile
             int priority = secondbyte & 0x10;
             
             // Select Palette
             pal = ((secondbyte & 0x08) == 0x08) ? 16 : 0;
             
             // Pattern Number
             pattern = (firstbyte + ((secondbyte & 0x01) << 8)) << 5;
             
             // Address in VRAM of tile
             int address;
             
             address = ((secondbyte & 0x04) == 0) ? (tiley << 2) + pattern
                     : ((7 - tiley) << 2) + pattern;
             
             // Rowcount
             tilex = 0;
             
             // X Position on Screen
             int xpos;
             
             // Precalculate Y Position
             int rowPrecal = y << 8;
             
             int address0 = vRam[address + 0];
             int address1 = vRam[address + 1];
             int address2 = vRam[address + 2];
             int address3 = vRam[address + 3];
             
             // Plots row of 8 pixels
             for (int bit = 0x80; bit != 0; bit >>= 1) {
                 xpos = ((secondbyte & 0x02) == 0) ? (tilex + hscroll + x)
                         // Horizontal Tile Flip
                         : (7 - tilex + hscroll + x);
                 
                 int colour = 0;
                 
                 // Set Colour of Pixel (0-15)
                 if ((address0 & bit) != 0) {
                     colour |= 0x01;
                 }
                 if ((address1 & bit) != 0) {
                     colour |= 0x02;
                 }
                 if ((address2 & bit) != 0) {
                     colour |= 0x04;
                 }
                 if ((address3 & bit) != 0) {
                     colour |= 0x08;
                 }
                 
                 // Set Priority Array (Sprites over background tile)
                 bgPriority[xpos] = (priority == 0x10) && (colour != 0);
                 
                 display[xpos + rowPrecal] = cRam[colour + pal];
                 
                 tilex++;
             }
             startColumn++;
         } // end loop
     }
     
     
     /**
      * Draw a line of the current background colour.
      *
      * @param lineno line number to render.
      */
     private void drawBGColour(int lineno) {
         int colour = cRam[16 + (vdpreg[7] & 0x0F)];
         int rowPrecal = lineno << 8;
         Arrays.fill(display, rowPrecal, rowPrecal + setup.SMS_WIDTH, colour);
     }
     
     
     /**
      * Blank leftmost column of a particular line.
      *
      * @param lineno line number to render.
      * @deprecated now, faster <code>fillRect</code> method used.
      */
     private void blankColumn(int lineno) {
         int colour = cRam[16 + (vdpreg[7] & 0x0F)];
         int rowPrecal = lineno << 8;
         Arrays.fill(display, rowPrecal, rowPrecal + 8, colour);
     }
     
     /**
      * Unsign an integer.
      *
      * @param b value to unsign.
      * @return unsigned value.
      */
     private int unsigned(byte b) {
         return b & 0xFF;
     }
     
     /**
      * Compare this frame with the previous frame, and flag what lines have been changed.
      *
      * @param pixelUpdate array to flag changes in.
      */
     public void flagChanges(boolean[] pixelUpdate) {
         for (int y = setup.getVEnd(); y-- != 0; ) {
             int rowPrecal = y << 8;
             boolean updateRow = false;
             for (int x = setup.getHEnd(); x-- != 0; ) {
                 if (display[x + rowPrecal] != oldDisplay[x + rowPrecal]) {
                     updateRow = true;
                     break;
                 }
             }
             pixelUpdate[y] = updateRow;
         }
     }
     
     /**
      * SMS Colours converted into Java RGB for speed purposes.
      */
     private static final int[] SMS_JAVA = {
         -16777216, -11206656, -5636096, -65536, -16755456, -11184896, -5614336, -43776,
         -16733696, -11163136, -5592576, -22016, -16711936, -11141376, -5570816,   -256,
         -16777131, -11206571, -5636011, -65451, -16755371, -11184811, -5614251, -43691,
         -16733611, -11163051, -5592491, -21931, -16711851, -11141291, -5570731,   -171,
         -16777046, -11206486, -5635926, -65366, -16755286, -11184726, -5614166, -43606,
         -16733526, -11162966, -5592406, -21846, -16711766, -11141206, -5570646,    -86,
         -16776961, -11206401, -5635841, -65281, -16755201, -11184641, -5614081, -43521,
         -16733441, -11162881, -5592321, -21761, -16711681, -11141121, -5570561,     -1};
     
     /**
      * GG Colours.
      */
     private static final int[] GG_JAVA1 = {
         -16777216, -15728640, -14680064, -13631488, -12582912, -11534336, -10485760,
          -9437184,  -8388608,  -7340032,  -6291456,  -5242880,  -4194304,  -3145728,
          -2097152,  -1048576, -16773120, -15724544, -14675968, -13627392, -12578816,
         -11530240, -10481664,  -9433088,  -8384512,  -7335936,  -6287360,  -5238784,
          -4190208,  -3141632,  -2093056,  -1044480, -16769024, -15720448, -14671872,
         -13623296, -12574720, -11526144, -10477568,  -9428992,  -8380416,  -7331840,
          -6283264,  -5234688,  -4186112,  -3137536,  -2088960,  -1040384, -16764928,
         -15716352, -14667776, -13619200, -12570624, -11522048, -10473472,  -9424896,
          -8376320,  -7327744,  -6279168,  -5230592,  -4182016,  -3133440,  -2084864,
          -1036288, -16760832, -15712256, -14663680, -13615104, -12566528, -11517952,
         -10469376,  -9420800,  -8372224,  -7323648,  -6275072,  -5226496,  -4177920,
          -3129344,  -2080768,  -1032192, -16756736, -15708160, -14659584, -13611008,
         -12562432, -11513856, -10465280,  -9416704,  -8368128,  -7319552,  -6270976,
          -5222400,  -4173824,  -3125248,  -2076672,  -1028096, -16752640, -15704064,
         -14655488, -13606912, -12558336, -11509760, -10461184,  -9412608,  -8364032,
          -7315456,  -6266880,  -5218304,  -4169728,  -3121152,  -2072576,  -1024000,
         -16748544, -15699968, -14651392, -13602816, -12554240, -11505664, -10457088,
          -9408512,  -8359936,  -7311360,  -6262784,  -5214208,  -4165632,  -3117056,
          -2068480,  -1019904, -16744448, -15695872, -14647296, -13598720, -12550144,
         -11501568, -10452992,  -9404416,  -8355840,  -7307264,  -6258688,  -5210112,
          -4161536,  -3112960,  -2064384,  -1015808, -16740352, -15691776, -14643200,
         -13594624, -12546048, -11497472, -10448896,  -9400320,  -8351744,  -7303168,
          -6254592,  -5206016,  -4157440,  -3108864,  -2060288,  -1011712, -16736256,
         -15687680, -14639104, -13590528, -12541952, -11493376, -10444800,  -9396224,
          -8347648,  -7299072,  -6250496,  -5201920,  -4153344,  -3104768,  -2056192,
          -1007616, -16732160, -15683584, -14635008, -13586432, -12537856, -11489280,
         -10440704,  -9392128,  -8343552,  -7294976,  -6246400,  -5197824,  -4149248,
          -3100672,  -2052096,  -1003520, -16728064, -15679488, -14630912, -13582336,
         -12533760, -11485184, -10436608,  -9388032,  -8339456,  -7290880,  -6242304,
          -5193728,  -4145152,  -3096576,  -2048000,   -999424, -16723968, -15675392,
         -14626816, -13578240, -12529664, -11481088, -10432512,  -9383936,  -8335360,
          -7286784,  -6238208,  -5189632,  -4141056,  -3092480,  -2043904,   -995328,
         -16719872, -15671296, -14622720, -13574144, -12525568, -11476992, -10428416,
          -9379840,  -8331264,  -7282688,  -6234112,  -5185536,  -4136960,  -3088384,
          -2039808,   -991232, -16715776, -15667200, -14618624, -13570048, -12521472,
         -11472896, -10424320,  -9375744,  -8327168,  -7278592,  -6230016,  -5181440,
          -4132864,  -3084288,  -2035712, -987136};
     
     private static final int[] GG_JAVA2 = {
         0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240};
     
 }