-- Draw ring on native pixel plane
         pixelv := vcount - 000;
         pixelh := hcount - 000;
         IF pixelv >= 0 AND pixelv <= 511 AND pixelh >= 0 AND pixelh <= 511 THEN
            xytemp1 := NOT pixelh(7 DOWNTO 0) XOR pixelh(8)&pixelh(8)&pixelh(8)&pixelh(8)&pixelh(8)&pixelh(8)&pixelh(8)&pixelh(8);
            xytemp2 := NOT pixelv(7 DOWNTO 0) XOR pixelv(8)&pixelv(8)&pixelv(8)&pixelv(8)&pixelv(8)&pixelv(8)&pixelv(8)&pixelv(8);
            radius := (xytemp1 * xytemp1 / 256) + (xytemp2 * xytemp2 / 256);
            IF radius >= 52 AND radius <= 62 THEN
               Pixel_Colour <= "011111111101110000001111111111";
            END IF;
         END IF;

module ColorCvt6to4(rst,clk7x,ri,ro);
input rst;
input clk7x;
input [5:0] ri;
output reg [3:0] ro;

reg [6:0] power17,power27,power37,power47,power57,power67;
always @(posedge clk7x)
if (rst) begin
   power17 <= 7'b0001000;
   power27 <= 7'b0100010;
   power37 <= 7'b1010100;
   power47 <= 7'b1010101;
   power57 <= 7'b1101011;
   power67 <= 7'b1110111;
end
else begin
   power17 <= {power17[5:0],power17[6]};
   power27 <= {power27[5:0],power27[6]};
   power37 <= {power37[5:0],power37[6]};
   power47 <= {power47[5:0],power47[6]};
   power57 <= {power57[5:0],power57[6]};
   power67 <= {power67[5:0],power67[6]};
end


always @(posedge clk7x)
   ro[3:1] <= ri[5:3];
always @(posedge clk7x)
case(ri[2:0])
3'b000:   ro[0] <= 1'b0;
3'b001: ro[0] <= power17[6];
3'b010: ro[0] <= power27[6];
3'b011:   ro[0] <= power37[6];
3'b100:   ro[0] <= power47[6];
3'b101:   ro[0] <= power57[6];
3'b110:   ro[0] <= power67[6];
3'b111:   ro[0] <= 1'b1;
endcase

endmodule

// General:
// The blitter image and bitmap registers must be setup, then the blitter
// will accept commands to be performed between images. The status register
// must be polled to determine when the blitter is finished an operation.
//
// The blitter command format is:
// | opcode2 | opcode1 | target,source1,source2 |
// |    6    |    6    |   6       6       6    |
//
// opcode 1 is applied between target and source1
// opcode 2 is applied to the result of opcode 1 and source 2
//
// opcode
// abrrrr
// ||++++ = raster operation
// |+---- = 1 = invert b operand
// +----- = 1 = invert a operand
//
// Raster operations
//
// rrrr
// 0000 all zereo's
// 0001 A
// 0010 B
// 0011 A AND B
// 0100 A OR B
// 0101 A XOR B
// 0110 A ADD B
// 0111 A SUB B
// 1000 A MUL B
// 1111 all ones
//
// Image Descriptors
// - Normally there are numerous images associated with an application.
// - The blitter allows for 64 image descriptors to be registered at once.
// - The most time critical images may be resident others will have to be
//   swapped with memory.
//
// Regno
// 0x000   [12: 0] image x position within bitmap
//         [28:16] image y position within bitmap
// 0x004   [12: 0] image width in pixels
//         [28:16] image height in pixels
// 0x008   [31: 0] reserved
// 0x00C   [ 3: 0] image bitmap descriptor index
//         [ 9: 8] image corner
//         [16:16] pattern indicator
//
// 0x010 to 0x3FC   repeat of 0x000 to 0x00C for 63 more images
//
// Bitmap Desciptors
// - Bitmap descriptors describe the size and location of the bitmap in memory
// - Usually multiple images are stored in a bitmap and there may be multiple
//   bitmaps associated with an application.
// - The blitter stores descriptor information for up to 16 bitmaps.
// - There is usually a single target bitmap from which the display is rendered.
//
// Regno
// 0x800   [12: 0] bitmap width
//         [28:16] bitmap height
// 0x804   [31: 0] bitmap base address
// 0x808   [ 3: 0] bitmap color depth
//
// 0x810 to 0x8FC
//         Same as 0x800-0x80C but for 15 more bitmap descriptors
//
// GLobal Registers
// 0xF00   [31: 0] command reg
// 0xF10   [31: 0] status reg
//
// Image Corner:
// - Determines which corner of the image to begin the transfer at. Useful when
//   source and destination images overlap.
//
// Pattern Indicator:
// - Indicates that the image is a pattern to be used to fill an area. In the
//   case of a pattern the pattern size may be smaller than the target fill
//   area. Indexes into the pattern will wrap around so that the pattern repeats
//   in the target fill area.
//
// 3200 LUTs (5120 LC's)
//