1loadedlocation = x; //X!
2	loadedlocation &= 0xFFF; //Limit!
3	if (VGA->precalcs.graphicsmode) //Graphics mode?
4	{
5		loadedlocation >>= 3; //We take portions of 8 pixels, so increase our location every 8 pixels!
6	}
7	else //Gotten character width? Just here for safety!
8	{
9		loadedlocation <<= 1; //Multiply by 2 for our index!
10		loadedlocation = VGA->CRTC.charcolstatus[loadedlocation]; //Divide by character width in text mode to get the correct character by using the horizontal clock!
11	}
12
13	loadedlocation >>= VGA->precalcs.characterclockshift; //Apply VGA shift: the shift is the ammount to move at a time!
14	loadedlocation <<= VGA->precalcs.BWDModeShift; //Apply byte/word/doubleword mode at the character level!
15
16	//Row logic
17	loadedlocation += Sequencer->charystart; //Apply the line and start map to retrieve!
18
19	//Now calculate and give the planes to be used!
20	planesbuffer[0] = readVRAMplane(VGA, 0, loadedlocation, 0x80); //Read plane 0!
21	planesbuffer[1] = readVRAMplane(VGA, 1, loadedlocation, 0x80); //Read plane 1!
22	planesbuffer[2] = readVRAMplane(VGA, 2, loadedlocation, 0x80); //Read plane 2!
23	planesbuffer[3] = readVRAMplane(VGA, 3, loadedlocation, 0x80); //Read plane 3!
24	//Now the buffer is ready to be processed into pixels!
25
26	planesdecoder[VGA->precalcs.graphicsmode](VGA); //Use the decoder to get the pixels or characters!

1//Planar access to VRAM
2byte readVRAMplane(VGA_Type *VGA, byte plane, word offset, byte mode) //Read from a VRAM plane!
3{
4	if (!VGA) return 0; //Invalid VGA!
5	if (!VGA->VRAM_size) return 0; //No size!
6	word patchedoffset = offset; //Default offset to use!
7
8	if (mode&1) patchedoffset = addresswrap(VGA,patchedoffset); //Apply address wrap?
9	if (mode&0x80) patchedoffset = patch_map1314(VGA, patchedoffset); //Patch MAP13&14!
10
11	plane &= 3; //Only 4 planes are available! Wrap arround the planes if needed!
12
13	register uint_32 fulloffset2;
14	fulloffset2 = patchedoffset; //Load the offset!
15	fulloffset2 <<= 2; //We cylce through the offsets!
16	fulloffset2 |= plane; //The plane goes from low to high, through all indexes!
17
18	if ((mode & 84) == 0x84) //Special sequencer panning?
19	{
20		fulloffset2 += ((SEQ_DATA *)VGA->Sequencer)->bytepanning; //Apply byte panning at the memory level!
21	}
22
23	if (mode & 2)
24	{
25		if (mode & 0x80) //Apply DW mode only during rendering!
26		{
27			if (VGA->precalcs.BWDModeShift == 2) //DW mode enabled?
28			{
29				fulloffset2 <<= 2; //Apply DW mode!
30			}
31		}
32		else
33		{
34			fulloffset2 <<= VGA->precalcs.BWDModeShift; //Apply B/W/DW mode from CPU!
35		}
36	}
37
38	if (VGA->VRAM_size == 0x40000) fulloffset2 &= 0x3FFFF; //Wrap arround memory!
39
40	if (fulloffset2<VGA->VRAM_size) //VRAM valid, simple check?
41	{
42		return VGA->VRAM[fulloffset2]; //Read the data from VRAM!
43	}
44	return 0; //Nothing there: invalid VRAM!
45}

1//Below patches input addresses for rendering only.
2OPTINLINE word patch_map1314(VGA_Type *VGA, word addresscounter) //Patch full VRAM address!
3{ //Check this!
4	word memoryaddress = addresscounter; //New row scan to use!
5	SEQ_DATA *Sequencer;
6	Sequencer = (SEQ_DATA *)VGA->Sequencer; //The sequencer!
7
8	register word rowscancounter = Sequencer->Scanline; //Load the row scan counter!
9	rowscancounter = VGA->CRTC.charrowstatus[rowscancounter << 1]; //Take the row status as our source!
10	rowscancounter >>= VGA->registers->CRTControllerRegisters.REGISTERS.CRTCMODECONTROLREGISTER.SLDIV; //Apply scanline division!
11	rowscancounter >>= VGA->precalcs.scandoubling; //Apply Scan Doubling here: we take effect on content!
12
13	register word bit; //Load row scan counter!
14	if (!VGA->registers->CRTControllerRegisters.REGISTERS.CRTCMODECONTROLREGISTER.MAP13) //a13=Bit 0 of the row scan counter!
15	{
16		//Row scan counter bit 1 is placed on the memory bus bit 14 during active display time.
17		//Bit 1, placed on memory address bit 14 has the effect of quartering the memory.
18		bit = rowscancounter; //Current row scan counter!
19		bit &= 1; //Bit0 only!
20		bit <<= 13; //Shift to our position (bit 13)!
21		memoryaddress &= 0xDFFF; //Clear bit13!
22		memoryaddress |= bit; //Set bit13 if needed!
23	}
24
25	if (!VGA->registers->CRTControllerRegisters.REGISTERS.CRTCMODECONTROLREGISTER.MAP14) //a14<=Bit 1 of the row scan counter!
26	{
27		bit = rowscancounter; //Current row scan counter!
28		bit &= 2; //Bit1 only!
29		bit <<= 13; //Shift to our position (bit 14)!
30		memoryaddress &= 0xBFFF; //Clear bit14;
31		memoryaddress |= bit; //Set bit14 if needed!
32	}
33	
34	return memoryaddress; //Give the linear address!
35}
36
37OPTINLINE uint_32 addresswrap(VGA_Type *VGA, word memoryaddress) //Wraps memory arround 64k!
38{
39	register word address2; //Load the initial value for calculating!
40	register word result;
41	register byte temp;
42	if (VGA->precalcs.BWDModeShift == 1) //Word mode?
43	{
44		result = memoryaddress; //Default: don't change!
45		address2 = memoryaddress; //Load the address for calculating!
46		temp = 0xD; //Load default location (13)
47		temp |= (VGA->registers->CRTControllerRegisters.REGISTERS.CRTCMODECONTROLREGISTER.AW << 1); //MA15 instead of MA13 when set!
48		address2 >>= temp; //Apply MA15/MA13 to bit 0!
49		address2 &= 1; //Only load bit 0!
50		result &= 0xFFFE; //Clear bit 0!
51		result |= address2; //Add bit MA15/MA13 at bit 0!
52		return result; //Give the result!
53	}
54	return memoryaddress; //Original address!
55}