Jonne Valola
PokittoLib is the library needed for programming the Pokitto DIY game console (www.pokitto.com)
Dependents: YATTT sd_map_test cPong SnowDemo ... more
PokittoLib
Library for programming Pokitto hardware
How to Use
- Import this library to online compiler (see button "import" on the right hand side
- DO NOT import mbed-src anymore, a better version is now included inside PokittoLib
- Change My_settings.h according to your project
- Start coding!
POKITTO_HW/HWLCD.cpp
- Committer:
- Pokitto
- Date:
- 2018-05-21
- Revision:
- 46:e7e438368e16
- Child:
- 48:30b068b0d9e8
File content as of revision 46:e7e438368e16:
/**************************************************************************/
/*!
@file HWLCD.cpp
@author Jonne Valola
@section LICENSE
Software License Agreement (BSD License)
Copyright (c) 2016, Jonne Valola
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**************************************************************************/
#include "HWLCD.h" //HWLCD.h" #include "HWLCD.h"
#include "Pokitto_settings.h"
#ifndef DISABLEAVRMIN
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#endif // DISABLEAVRMIN
#ifdef DISABLEAVRMIN
#include <algorithm>
using std::min;
using std::max;
#endif // DISABLEAVRMIN
#define AB_JUMP 1024 // jump one 1-bit Arduboy screen forward to get next color bit
#define GB_JUMP 504 // jump one 1-bit Gamebuino screen forward to get next color bit
using namespace Pokitto;
uint16_t prevdata=0; // if data does not change, do not adjust LCD bus lines
#if POK_BOARDREV == 2
pwmout_t backlightpwm;
#endif
/**************************************************************************/
/*!
@brief set up the 16-bit bus
*/
/**************************************************************************/
static inline void setup_data_16(uint16_t data)
{
//uint32_t p2=0;
//if (data != prevdata) {
//
//prevdata=data;
/** D0...D16 = P2_3 ... P2_18 **/
//p2 = data << 3;
//__disable_irq(); // Disable Interrupts
SET_MASK_P2;
LPC_GPIO_PORT->MPIN[2] = (data<<3); // write bits to port
CLR_MASK_P2;
//__enable_irq(); // Enable Interrupts
//}
}
/**************************************************************************/
/*!
@brief Write a command to the lcd, 16-bit bus
*/
/**************************************************************************/
inline void write_command_16(uint16_t data)
{
CLR_CS; // select lcd
CLR_CD; // clear CD = command
SET_RD; // RD high, do not read
setup_data_16(data); // function that inputs the data into the relevant bus lines
CLR_WR_SLOW; // WR low
SET_WR; // WR low, then high = write strobe
SET_CS; // de-select lcd
}
/**************************************************************************/
/*!
@brief Write data to the lcd, 16-bit bus
*/
/**************************************************************************/
inline void write_data_16(uint16_t data)
{
CLR_CS;
SET_CD;
SET_RD;
setup_data_16(data);
CLR_WR;
SET_WR;
SET_CS;
}
/**************************************************************************/
/*!
@brief Pump data to the lcd, 16-bit bus, public function
*/
/**************************************************************************/
void Pokitto::pumpDRAMdata(uint16_t* data,uint16_t counter)
{
while (counter--) {
CLR_CS;
SET_CD;
SET_RD;
setup_data_16(*data++);
CLR_WR;
SET_WR;
SET_CS;
}
}
/**************************************************************************/
/*!
@brief Point to a (x,y) location in the LCD DRAM
*/
/**************************************************************************/
static inline void setDRAMptr(uint8_t xptr, uint8_t yoffset)
{
write_command(0x20); // Vertical DRAM Address
write_data(yoffset);
write_command(0x21); // Horizontal DRAM Address
write_data(xptr); //
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
}
/**************************************************************************/
/*!
@brief Point to a (x,y) location in the LCD DRAM, public function
*/
/**************************************************************************/
void Pokitto::setDRAMpoint(uint8_t xptr, uint8_t yoffset)
{
write_command(0x20); // Vertical DRAM Address
write_data(yoffset);
write_command(0x21); // Horizontal DRAM Address
write_data(xptr); //
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
}
void Pokitto::initBacklight() {
#if POK_BOARDREV == 2
pwmout_init(&backlightpwm,POK_BACKLIGHT_PIN);
pwmout_period_us(&backlightpwm,5);
pwmout_write(&backlightpwm,POK_BACKLIGHT_INITIALVALUE);
#endif
}
void Pokitto::setBacklight(float value) {
if (value>0.999f) value = 0.999f;
pwmout_write(&backlightpwm,value);
}
void Pokitto::lcdInit() {
initBacklight();
SET_RESET;
wait_ms(10);
CLR_RESET;
wait_ms(10);
SET_RESET;
wait_ms(10);
//************* Start Initial Sequence **********//
write_command(0x01); // driver output control, this also affects direction
write_data(0x11C); // originally: 0x11C 100011100 SS,NL4,NL3,NL2
// NL4...0 is the number of scan lines to drive the screen !!!
// so 11100 is 1c = 220 lines, correct
// test 1: 0x1C 11100 SS=0,NL4,NL3,NL2 -> no effect
// test 2: 0x31C 1100011100 GS=1,SS=1,NL4,NL3,NL2 -> no effect
// test 3: 0x51C 10100011100 SM=1,GS=0,SS=1,NL4,NL3,NL2 -> no effect
// test 4: 0x71C SM=1,GS=1,SS=1,NL4,NL3,NL2
// test 5: 0x
// seems to have no effect... is this perhaps only for RGB mode ?
write_command(0x02); // LCD driving control
write_data(0x0100); // INV = 1
write_command(0x03); // Entry mode... lets try if this affects the direction
write_data(0x1030); // originally 0x1030 1000000110000 BGR,ID1,ID0
// test 1: 0x1038 1000000111000 BGR,ID1,ID0,AM=1 ->drawing DRAM horizontally
// test 4: am=1, id0=0, id1=0, 1000000001000,0x1008 -> same as above, but flipped on long
// test 2: am=0, id0=0, 1000000100000, 0x1020 -> flipped on long axis
// test 3: am=0, id1=0, 1000000010000, 0x1010 -> picture flowed over back to screen
write_command(0x08); // Display control 2
write_data(0x0808); // 100000001000 FP2,BP2
write_command(0x0C); // RGB display interface
write_data(0x0000); // all off
write_command(0x0F); // Frame marker position
write_data(0x0001); // OSC_EN
write_command(0x20); // Horizontal DRAM Address
write_data(0x0000); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0x0000); // 0
//*************Power On sequence ****************//
write_command(0x10);
write_data(0x0000);
write_command(0x11);
write_data(0x1000);
wait_ms(10);
//------------------------ Set GRAM area --------------------------------//
write_command(0x30); // Gate scan position
write_data(0x0000); // if GS=0, 00h=G1, else 00h=G220
write_command(0x31); // Vertical scroll control
write_data(0x00DB); // scroll start line 11011011 = 219
write_command(0x32); // Vertical scroll control
write_data(0x0000); // scroll end line 0
write_command(0x33); // Vertical scroll control
write_data(0x0000); // 0=vertical scroll disabled
write_command(0x34); // Partial screen driving control
write_data(0x00DB); // db = full screen (end)
write_command(0x35); // partial screen
write_data(0x0000); // 0 = start
write_command(0x36); // Horizontal and vertical RAM position
write_data(0x00AF); //end address 175
write_command(0x37);
write_data(0x0000); // start address 0
write_command(0x38);
write_data(0x00DB); //end address 219
write_command(0x39); // start address 0
write_data(0x0000);
wait_ms(10);
write_command(0xff); // start gamma register control
write_data(0x0003);
// ----------- Adjust the Gamma Curve ----------//
write_command(0x50);
write_data(0x0203);
write_command(0x051);
write_data(0x0A09);
write_command(0x52);
write_data(0x0005);
write_command(0x53);
write_data(0x1021);
write_command(0x54);
write_data(0x0602);
write_command(0x55);
write_data(0x0003);
write_command(0x56);
write_data(0x0703);
write_command(0x57);
write_data(0x0507);
write_command(0x58);
write_data(0x1021);
write_command(0x59);
write_data(0x0703);
write_command(0xB0);
write_data(0x2501);
write_command(0xFF);
write_data(0x0000);
write_command(0x07);
write_data(0x1017);
wait_ms(200);
write_command(0x22);
lcdClear();
}
void Pokitto::lcdSleep(void){
write_command(0xFF);
write_data(0x0000);
write_command(0x07);
write_data(0x0000);
wait_ms(50);
write_command(0x10);// Enter Standby mode
write_data(0x0003);
wait_ms(200);
}
void Pokitto::lcdWakeUp (void){
wait_ms(200);
write_command(0xFF);
write_data(0x0000);
write_command(0x10);// Exit Sleep/ Standby mode
write_data(0x0000);
wait_ms(50);
write_command(0x07);
write_data(0x0117);
wait_ms(200);
}
void Pokitto::lcdFillSurface(uint16_t c) {
uint32_t i;
write_command(0x20); // Horizontal DRAM Address
write_data(0x0000); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0);
write_command(0x22); // write data to DRAM
setup_data_16(c);
CLR_CS_SET_CD_RD_WR;
for(i=0;i<220*176;i++)
{
CLR_WR;
SET_WR;
}
}
void Pokitto::lcdClear() {
uint32_t i;
write_command(0x20); // Horizontal DRAM Address
write_data(0x0000); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0);
write_command(0x22); // write data to DRAM
setup_data_16(0x0000);
CLR_CS_SET_CD_RD_WR;
for(i=0;i<220*176;i++)
{
CLR_WR;
SET_WR;
}
}
void Pokitto::lcdPixel(int16_t x, int16_t y, uint16_t color) {
if ((x < 0) || (x >= POK_LCD_W) || (y < 0) || (y >= POK_LCD_H))
return;
write_command(0x20); // Horizontal DRAM Address
write_data(y); // 0
write_command(0x21); // Vertical DRAM Address
write_data(x);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
setup_data_16(color);
CLR_WR;SET_WR;
}
void Pokitto::setWindow(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2) {
write_command(0x37); write_data(x1);
write_command(0x36); write_data(x2);
write_command(0x39); write_data(y1);
write_command(0x38); write_data(y2);
write_command(0x20); write_data(x1);
write_command(0x21); write_data(y1);
}
void Pokitto::lcdTile(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t* gfx){
int width=x1-x0;
int height=y1-y0;
if (x0 > POK_LCD_W) return;
if (y0 > POK_LCD_H) return;
if (x0 < 0) x0=0;
if (y0 < 0) y0=0;
setWindow(y0, x0, y1-1, x1-1);
write_command(0x22);
for (int x=0; x<=width*height-1;x++) {
write_data(gfx[x]);
}
setWindow(0, 0, 175, 219);
}
void Pokitto::lcdRectangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
int16_t temp;
if (x0>x1) {temp=x0;x0=x1;x1=temp;}
if (y0>y1) {temp=y0;y0=y1;y1=temp;}
if (x0 > POK_LCD_W) return;
if (y0 > POK_LCD_H) return;
if (x1 > POK_LCD_W) x1=POK_LCD_W;
if (y1 > POK_LCD_H) y1=POK_LCD_H;
if (x0 < 0) x0=0;
if (y0 < 0) y0=0;
int16_t x,y;
for (x=x0; x<=x1;x++) {
write_command(0x20); // Horizontal DRAM Address (=y on pokitto screen)
write_data(y0);
write_command(0x21); // Vertical DRAM Address (=x on pokitto screen)
write_data(x);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR; // go to vram write mode
for (y=y0; y<y1;y++) {
setup_data_16(color); // setup the data (flat color = no change between pixels)
CLR_WR;SET_WR; //CLR_WR;SET_WR;//toggle writeline, pokitto screen writes a column up to down
}
}
}
/***
* Update the screen buffer of 220x176 pixels, 4 colors to LCD.
*
* The update rect is used for drawing only part of the screen buffer to LCD. Because of speed optimizations, the
* x, y, and width of the update rect must be dividable by 4 pixels, and the height must be dividable by 8 pixels.
* Note: The update rect is currently used for 220x176, 4 colors, screen mode only.
* @param scrbuf The screen buffer.
* @param updRectX The update rect.
* @param updRectY The update rect.
* @param updRectW The update rect.
* @param updRectH The update rect.
* @param paletteptr The screen palette.
*/
void Pokitto::lcdRefreshMode1(uint8_t * scrbuf, uint8_t updRectX, uint8_t updRectY, uint8_t updRectW, uint8_t updRectH, uint16_t* paletteptr) {
uint16_t x,y,xptr;
uint16_t scanline[4][176]; // read 4 half-nibbles = 4 pixels at a time
uint8_t *d, yoffset=0;
// If not the full screen is updated, check the validity of the update rect.
if ( updRectX != 0 || updRectY != 0 ||updRectW != LCDWIDTH ||updRectH != LCDHEIGHT ) {
uint8_t org_screenx = updRectX;
updRectX &= 0xfc; // Make the value dividable by 4.
updRectW += org_screenx - updRectX;
updRectW = (updRectW + 3) & 0xfc; // Make the value dividable by 4, round up.
uint8_t org_screeny = updRectY;
updRectY &= 0xfc; // Make the value dividable by 4.
updRectH += org_screeny - updRectY;
updRectH = (updRectH + 7) & 0xf8; // Make the value dividable by 8 (because of loop unroll optimization), round up.
}
#ifdef PROJ_SHOW_FPS_COUNTER
xptr = 8;
setDRAMptr(8, 0);
#else
xptr = 0;
setDRAMptr(0, 0);
#endif
for (x=updRectX; x<updRectX+updRectW; x+=4) {
d = scrbuf+(x>>2);// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
d += (updRectY * 220/4);
for (y=updRectY; y<updRectY+updRectH; y++) {
uint8_t tdata = *d;
uint8_t t4 = tdata & 0x03; tdata >>= 2;// lowest half-nibble
uint8_t t3 = tdata & 0x03; tdata >>= 2;// second lowest half-nibble
uint8_t t2 = tdata & 0x03; tdata >>= 2;// second highest half-nibble
uint8_t t = tdata & 0x03;// highest half-nibble
/** put nibble values in the scanlines **/
scanline[0][y] = paletteptr[t];
scanline[1][y] = paletteptr[t2];
scanline[2][y] = paletteptr[t3];
scanline[3][y] = paletteptr[t4];
d += 220/4; // jump to read byte directly below in screenbuffer
}
#ifdef PROJ_SHOW_FPS_COUNTER
if (x>=8 ) {
#else
{
#endif
// Draw 8 vertical pixels at a time for performance reasons
setDRAMptr(x, updRectY);
for (uint8_t s=updRectY; s<updRectY+updRectH;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+1, updRectY);
for (uint8_t s=updRectY; s<updRectY+updRectH;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+2, updRectY);
for (uint8_t s=updRectY; s<updRectY+updRectH;) {
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+3, updRectY);
for (uint8_t s=updRectY; s<updRectY+updRectH;) {
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
}
}
}
#ifdef POK_SIM
simulator.refreshDisplay();
#endif
}
// Copy sprite pixels to the scanline
#define SPRITE_2BPP_INNER_LOOP(n)\
\
/* If the sprite is enabled and contained in this vertical scanline, copy 4 pixels. */\
if (sprScanlineAddr[(n)] &&\
y >= sprites[(n)].y && y < sprites[(n)].y + sprites[(n)].h ) {\
\
int16_t sprx = sprites[(n)].x;\
uint16_t s_data16b = 0; /* sprite data, 2 bytes */\
\
/* Get pixel block, 4 or 8 pixels horizontally. Use the predefined bitshift mode. */\
/* Note:it is cheapest to compare to 0 first. */\
if (sprScanlineBitshiftMode[(n)] == BITSHIFT_MODE_MIDDLE_BYTE) {\
s_data16b = *(sprScanlineAddr[(n)]);\
uint16_t leftByte = *(sprScanlineAddr[(n)]-1);\
s_data16b = (leftByte << 8) | s_data16b;\
}\
else if (sprScanlineBitshiftMode[(n)] == BITSHIFT_MODE_FIRST_BYTE) {\
s_data16b = *(sprScanlineAddr[(n)]);\
}\
else { /* BITSHIFT_MODE_LAST_BYTE */\
uint16_t leftByte = *(sprScanlineAddr[(n)]-1);\
s_data16b = (leftByte << 8) | s_data16b;\
}\
\
/* Shift sprite pixels according to sprite x. After shifting we have only 4 pixels. */\
uint8_t shiftRight = (sprx&0x3) << 1;\
s_data16b = (s_data16b >> shiftRight);\
\
/* Get individual pixels */\
uint8_t s_t4 = s_data16b & 0x03; s_data16b >>= 2; /* lowest half-nibble */\
uint8_t s_t3 = s_data16b & 0x03; s_data16b >>= 2; /* second lowest half-nibble */\
uint8_t s_t2 = s_data16b & 0x03; s_data16b >>= 2; /* second highest half-nibble */\
uint8_t s_t1 = s_data16b & 0x03; /* highest half-nibble */\
\
/* Store pixels as 16-bit colors from the palette */\
if (s_t4 != transparentColor) p4 = sprites[(n)].palette[s_t4];\
if (s_t3 != transparentColor) p3 = sprites[(n)].palette[s_t3];\
if (s_t2 != transparentColor) p2 = sprites[(n)].palette[s_t2];\
if (s_t1 != transparentColor) p = sprites[(n)].palette[s_t1];\
\
/* Advance scanline address */\
sprScanlineAddr[(n)] += (sprites[(n)].w >> 2);\
}
// Loop unrolling macros
#define UNROLLED_LOOP_1() SPRITE_2BPP_INNER_LOOP(0)
#define UNROLLED_LOOP_2() UNROLLED_LOOP_1() SPRITE_2BPP_INNER_LOOP(1)
#define UNROLLED_LOOP_3() UNROLLED_LOOP_2() SPRITE_2BPP_INNER_LOOP(2)
#define UNROLLED_LOOP_4() UNROLLED_LOOP_3() SPRITE_2BPP_INNER_LOOP(3)
#define UNROLLED_LOOP_5() UNROLLED_LOOP_4() SPRITE_2BPP_INNER_LOOP(4)
#define UNROLLED_LOOP_6() UNROLLED_LOOP_5() SPRITE_2BPP_INNER_LOOP(5)
#define UNROLLED_LOOP_7() UNROLLED_LOOP_6() SPRITE_2BPP_INNER_LOOP(6)
#define UNROLLED_LOOP_8() UNROLLED_LOOP_7() SPRITE_2BPP_INNER_LOOP(7)
#define UNROLLED_LOOP_9() UNROLLED_LOOP_8() SPRITE_2BPP_INNER_LOOP(8)
#define UNROLLED_LOOP_10() UNROLLED_LOOP_9() SPRITE_2BPP_INNER_LOOP(9)
#define UNROLLED_LOOP_11() UNROLLED_LOOP_10() SPRITE_2BPP_INNER_LOOP(10)
#define UNROLLED_LOOP_12() UNROLLED_LOOP_11() SPRITE_2BPP_INNER_LOOP(11)
#define UNROLLED_LOOP_13() UNROLLED_LOOP_12() SPRITE_2BPP_INNER_LOOP(12)
#define UNROLLED_LOOP_14() UNROLLED_LOOP_13() SPRITE_2BPP_INNER_LOOP(13)
#define UNROLLED_LOOP_15() UNROLLED_LOOP_14() SPRITE_2BPP_INNER_LOOP(14)
#define UNROLLED_LOOP_16() UNROLLED_LOOP_15() SPRITE_2BPP_INNER_LOOP(15)
#define UNROLLED_LOOP_N_(n) UNROLLED_LOOP_##n()
#define UNROLLED_LOOP_N(n) UNROLLED_LOOP_N_(n)
/***
* Update the screen buffer of 220x176 pixels, 4 colors and free size 4 color sprites to LCD.
*
* The update rect is used for drawing only part of the screen buffer to LCD. Because of speed optimizations, the
* x, y, and width of the update rect must be dividable by 4 pixels, and the height must be dividable by 8 pixels.
* Note: The update rect is currently used for 220x176, 4 colors, screen mode only.
* If drawSpritesOnly=true, only sprites are fully updated to LCD. However, the dirty rect of the screen buffer is
* drawn behind the sprite current and previous location.
* Note: Sprite is enabled if sprite.bitmapData is not NULL. Also all enabled sprites must be at the beginning of
* the sprites array. No gaps are allowed in the array.
* @param scrbuf The screen buffer.
* @param updRectX The update rect.
* @param updRectY The update rect.
* @param updRectW The update rect.
* @param updRectH The update rect.
* @param paletteptr The screen palette.
* @param sprites The sprite array.
* @param drawSpritesOnly True, if only sprites are drawn. False, if both sprites and the screen buffer are drawn.
*/
void Pokitto::lcdRefreshMode1Spr(
uint8_t * scrbuf, uint8_t updRectX, uint8_t updRectY, uint8_t updRectW, uint8_t updRectH, uint16_t* paletteptr,
SpriteInfo* sprites, bool drawSpritesOnly) {
// In direct mode draw only sprites and their dirty rects. Return now if there are no sprites
if (drawSpritesOnly && (sprites == NULL || sprites[0].bitmapData == NULL))
return;
uint16_t x,y;
uint16_t scanline[4][176]; // read 4 half-nibbles (= 4 pixels) at a time
const uint8_t transparentColor = 0; // fixed palette index 0 for transparency
// If not the full screen is updated, check the validity of the update rect.
if ( updRectX != 0 || updRectY != 0 ||updRectW != LCDWIDTH ||updRectH != LCDHEIGHT ) {
uint8_t org_screenx = updRectX;
updRectX &= 0xfc; // Make the value dividable by 4.
updRectW += org_screenx - updRectX;
updRectW = (updRectW + 3) & 0xfc; // Make the value dividable by 4, round up.
uint8_t org_screeny = updRectY;
updRectY &= 0xfc; // Make the value dividable by 4.
updRectH += org_screeny - updRectY;
updRectH = (updRectH + 7) & 0xf8; // Make the value dividable by 8 (because of loop unroll optimization), round up.
}
// Calculate the current amount of sprites
// Note: Sprites must be taken into use from index 0 upwards, because the first sprite with bitmapData==NULL is considered as the last sprite
uint8_t spriteCount = 0;
if (sprites != NULL)
for (;sprites[spriteCount].bitmapData != NULL && spriteCount < SPRITE_COUNT; spriteCount++);
// If drawing the screen buffer, set the start pos to LCD commands only here.
#ifdef PROJ_SHOW_FPS_COUNTER
if (!drawSpritesOnly) setDRAMptr(8, 0);
#else
if (!drawSpritesOnly) setDRAMptr(0, 0);
#endif
//*** GO THROUGH EACH VERTICAL GROUP OF 4 SCANLINES.***
for (x=0; x<LCDWIDTH; x+=4) {
uint8_t *screenBufScanlineAddr = scrbuf + (x>>2);// point to beginning of line in data
/*Prepare scanline start address for sprites that are visible in this vertical scanline. Sprite width cannot exceed the screen width*/
uint8_t *sprScanlineAddr[SPRITE_COUNT]; // Sprite start address for the scanline
uint8_t sprScanlineBitshiftMode[SPRITE_COUNT]; // Sprite bitshift mode for the scanline
const uint8_t BITSHIFT_MODE_MIDDLE_BYTE = 0;
const uint8_t BITSHIFT_MODE_FIRST_BYTE = 1;
const uint8_t BITSHIFT_MODE_LAST_BYTE = 2;
uint8_t scanlineMinY = 255; // Init to uninitialized value. Do not draw by default.
uint8_t scanlineMaxY = 0; // Init to uninitialized value. Do not draw by default.
//*** CALCULATE DIRTY RECTS AND RESOLVE WHICH SPRITES BELONG TO THIS SCANLINE GROUP ***
if (sprites != NULL) {
// Check all the sprites for this scanline. That is used for handling the given update rect
// Note that the last round is when (sprindex == spriteCount). That is used to add the screen buffer
// update rect to the dirty rect.
for (int sprindex = 0; sprindex <= spriteCount; sprindex++) {
int16_t sprx, spry, sprOldX, sprOldY;
uint8_t sprw, sprh;
bool isCurrentSpriteOutOfScreen = false;
bool isOldSpriteOutOfScreen = false;
if (sprindex < spriteCount) {
sprx = sprites[sprindex].x;
spry = sprites[sprindex].y;
sprw = sprites[sprindex].w;
sprh = sprites[sprindex].h;
sprOldX = sprites[sprindex].oldx;
sprOldY = sprites[sprindex].oldy;
}
// Handle the screen buffer update rect after all sprites
else if(!drawSpritesOnly){
sprx = updRectX;
spry = updRectY;
sprw = updRectW;
sprh = updRectH;
sprOldX = updRectX;
sprOldY = updRectY;
isCurrentSpriteOutOfScreen = false;
isOldSpriteOutOfScreen = false;
}
// Check for out-of-screen
if (sprx >= LCDWIDTH || spry >= LCDHEIGHT)
isCurrentSpriteOutOfScreen = true;
if (sprOldX >= LCDWIDTH || sprOldY >= LCDHEIGHT)
isOldSpriteOutOfScreen = true;
// Skip if current and old sprites are out-of-screen
if (isCurrentSpriteOutOfScreen && isOldSpriteOutOfScreen)
continue;
// Detect the dirty rect x-span by combining the previous and current sprite position.
int16_t sprDirtyXMin = min(sprx, sprOldX);
int16_t sprDirtyXMax = max(sprx, sprOldX);
if (isCurrentSpriteOutOfScreen)
sprDirtyXMax = sprOldX;
if (isOldSpriteOutOfScreen)
sprDirtyXMax = sprx;
// Is current x inside the sprite combined dirty rect ?
int16_t sprDirtyXMaxEnd = sprDirtyXMax + sprw - 1 + 4; // Add 4 pixels to dirty rect width (needed?)
if (sprDirtyXMin <= x+3 && x <= sprDirtyXMaxEnd) {
// *** COMBINE DIRTY RECTS FOR THIS SCANLINE GROUP ***
// Dirty rect
int sprDirtyYMin = std::min(spry, sprOldY);
sprDirtyYMin = std::max((int)sprDirtyYMin, 0);
int sprDirtyYMax = std::max(spry, sprOldY);
if (isCurrentSpriteOutOfScreen)
sprDirtyYMax = sprOldY;
if (isOldSpriteOutOfScreen)
sprDirtyYMax = spry;
int sprDirtyYMaxEnd = sprDirtyYMax + sprh - 1;
sprDirtyYMaxEnd = std::min(sprDirtyYMaxEnd, LCDHEIGHT - 1); // Should use LCDHEIGHT instead of screenH? Same with other screen* ?
// Get the scanline min and max y values for drawing
if (sprDirtyYMin < scanlineMinY)
scanlineMinY = sprDirtyYMin;
if (sprDirtyYMaxEnd > scanlineMaxY)
scanlineMaxY = sprDirtyYMaxEnd;
// *** PREPARE SPRITE FOR DRAWING ***
// Check if the sprite should be active for this vertical scanline group.
if (sprindex < spriteCount && // not for update rect
!isCurrentSpriteOutOfScreen && //out-of-screen
sprx <= x+3 && x < sprx + sprw) { // note: cover group of 4 pixels of the scanline (x+3)
// Find the byte number in the sprite data
int16_t byteNum = ((x+3) - sprx)>>2;
// Get the start addres of the spite data in this scanline.
sprScanlineAddr[sprindex] = const_cast<uint8_t*>(sprites[sprindex].bitmapData + byteNum);
// If the sprite goes over the top, it must be clipped from the top.
if(spry < 0)
sprScanlineAddr[sprindex] += (-spry) * (sprw >> 2);
// Select the bitshift mode for the blit algorithm
if (byteNum == 0)
sprScanlineBitshiftMode[sprindex] = BITSHIFT_MODE_FIRST_BYTE;
else if (byteNum >= (sprw >> 2))
sprScanlineBitshiftMode[sprindex] = BITSHIFT_MODE_LAST_BYTE;
else
sprScanlineBitshiftMode[sprindex] = BITSHIFT_MODE_MIDDLE_BYTE;
}
else
sprScanlineAddr[sprindex] = NULL; // Deactive sprite for this scanline
}
else
sprScanlineAddr[sprindex] = NULL; // Deactive sprite for this scanline
}
}
// *** ADJUST THE SCANLINE GROUP HEIGHT ***
// The height must dividable by 8. That is needed because later we copy 8 pixels at a time to the LCD.
if (scanlineMaxY - scanlineMinY + 1 > 0) {
uint8_t scanlineH = scanlineMaxY - scanlineMinY + 1;
uint8_t addW = 8 - (scanlineH & 0x7);
// if height is not dividable by 8, make it be.
if (addW != 0) {
if (scanlineMinY > addW )
scanlineMinY -= addW;
else if( scanlineMaxY + addW < updRectY+updRectH)
scanlineMaxY += addW;
else {
// Draw full height scanline
scanlineMinY = updRectY;
scanlineMaxY = updRectY+updRectH-1;
}
}
}
// *** COMBINE THE SCANLINE GROUP OF THE SCREEN BUFFER AND ALL SPRITES ***
// Find colours in this group of 4 scanlines
screenBufScanlineAddr += (scanlineMinY * 220/4);
for (y=scanlineMinY; y<=scanlineMaxY; y++)
{
// get the screen buffer data first
uint8_t tdata = *screenBufScanlineAddr;
uint8_t t4 = tdata & 0x03; tdata >>= 2;// lowest half-nibble
uint8_t t3 = tdata & 0x03; tdata >>= 2;// second lowest half-nibble
uint8_t t2 = tdata & 0x03; tdata >>= 2;// second highest half-nibble
uint8_t t = tdata & 0x03;// highest half-nibble
// Convert to 16-bit colors in palette
uint16_t p = paletteptr[t];
uint16_t p2 = paletteptr[t2];
uint16_t p3 = paletteptr[t3];
uint16_t p4 = paletteptr[t4];
#if 0
// Dirty rect visual test
p = COLOR_BLUE >> (Core::frameCount % 5);
p2 = COLOR_BLUE >> (Core::frameCount % 5);
p3 = COLOR_BLUE >> (Core::frameCount % 5);
p4 = COLOR_BLUE >> (Core::frameCount % 5);
#endif
// Add active sprite pixels
if (sprites != NULL) {
// Use loop unrolling for speed optimization
UNROLLED_LOOP_N(SPRITE_COUNT)
}
// put the result nibble values in the scanline
scanline[0][y] = p;
scanline[1][y] = p2;
scanline[2][y] = p3;
scanline[3][y] = p4;
screenBufScanlineAddr += 220>>2; // jump to read byte directly below in screenbuffer
}
// *** DRAW THE SCANLINE GROUP TO LCD
#ifdef PROJ_SHOW_FPS_COUNTER
if (x>=8 && scanlineMaxY - scanlineMinY +1 > 0) {
#else
if (scanlineMaxY - scanlineMinY +1 > 0) {
#endif
// Draw 8 vertical pixels at a time for performance reasons
setDRAMptr(x, scanlineMinY);
for (uint8_t s=scanlineMinY;s<=scanlineMaxY;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+1, scanlineMinY);
for (uint8_t s=scanlineMinY;s<=scanlineMaxY;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+2, scanlineMinY);
for (uint8_t s=scanlineMinY;s<=scanlineMaxY;) {
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
}
setDRAMptr(x+3, scanlineMinY);
for (uint8_t s=scanlineMinY;s<=scanlineMaxY;) {
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
}
}
}
// Update old x and y for the sprites
if (sprites != NULL) {
for (int sprindex = 0; sprindex < spriteCount; sprindex++) {
sprites[sprindex].oldx = sprites[sprindex].x;
sprites[sprindex].oldy = sprites[sprindex].y;
}
}
#ifdef POK_SIM
simulator.refreshDisplay();
#endif
}
void Pokitto::lcdRefreshMode2(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y;
uint16_t scanline[2][88]; // read two nibbles = pixels at a time
uint8_t *d;
write_command(0x20); // Horizontal DRAM Address
write_data(0); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
for(x=0;x<110;x+=2)
{
d = scrbuf+(x>>1);// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
for(y=0;y<88;y++)
{
uint8_t t = *d >> 4; // higher nibble
uint8_t t2 = *d & 0xF; // lower nibble
/** higher nibble = left pixel in pixel pair **/
scanline[0][s] = paletteptr[t];
scanline[1][s++] = paletteptr[t2];
/** testing only **/
//scanline[0][s] = 0xFFFF*(s&1);
//scanline[1][s] = 0xFFFF*(!(s&1));
//s++;
/** until here **/
d+=110/2; // jump to read byte directly below in screenbuffer
}
s=0;
/** draw scanlines **/
/** leftmost scanline twice**/
#ifdef PROJ_SHOW_FPS_COUNTER
if (x<4) continue;
setDRAMptr(x<<1, 0);
#endif
for (s=0;s<88;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
for (s=0;s<88;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
/** rightmost scanline twice**/
//setDRAMptr(xptr++,yoffset);
for (s=0;s<88;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
for (s=0;s<88;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
}
}
void Pokitto::lcdRefreshMode3(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y;
uint16_t scanline[2][176]; // read two nibbles = pixels at a time
uint8_t *d;
write_command(0x20); // Horizontal DRAM Address
write_data(0); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
for(x=0;x<220;x+=2)
{
d = scrbuf+(x>>1);// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
for(y=0;y<176;y++)
{
uint8_t t = *d >> 4; // higher nibble
uint8_t t2 = *d & 0xF; // lower nibble
/** higher nibble = left pixel in pixel pair **/
scanline[0][s] = paletteptr[t];
scanline[1][s++] = paletteptr[t2];
/** testing only **/
//scanline[0][s] = 0xFFFF*(s&1);
//scanline[1][s] = 0xFFFF*(!(s&1));
//s++;
/** until here **/
d+=220/2; // jump to read byte directly below in screenbuffer
}
s=0;
/** draw scanlines **/
/** leftmost scanline**/
#ifdef PROJ_SHOW_FPS_COUNTER
if (x<8) continue;
setDRAMptr(x, 0);
#endif
for (s=0;s<176;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
}
/** rightmost scanline**/
//setDRAMptr(xptr++,yoffset);
for (s=0;s<176;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
}
}
}
void Pokitto::lcdRefreshGB(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y;
uint16_t scanline[48];
uint8_t * d;
#if POK_STRETCH
//uint16_t xptr = 8;
#else
//xptr = 26;
#endif
write_command(0x20); // Horizontal DRAM Address
write_data(0); // 0
write_command(0x21); // Vertical DRAM Address
write_data(0);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
/** draw border **/
for (int s=0;s<5*176;) {
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;s++;
}
for(x=0;x<84;x++)
{
d = scrbuf + x;// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
for(y=0;y<6;y++)
{
uint8_t t = *d;
#if POK_COLORDEPTH > 1
uint8_t t2 = *(d+504);
#endif
#if POK_COLORDEPTH > 2
uint8_t t3 = *(d+504+504);
#endif
#if POK_COLORDEPTH > 3
uint8_t t4 = *(d+504+504+504);
#endif
uint8_t paletteindex = 0;
/** bit 1 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x1);
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x1)) | ((t2 & 0x01)<<1);
#elif POK_COLORDEPTH == 3
paletteindex = (t & 0x1) | ((t2 & 0x1)<<1) | ((t3 & 0x1)<<2);
#elif POK_COLORDEPTH == 4
paletteindex = (t & 0x1) | ((t2 & 0x1)<<1) | ((t3 & 0x1)<<2) | ((t4 & 0x1)<<3);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 2 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x2)>>1;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x02));
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x2)) | ((t3 & 0x2)<<1);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x2)) | ((t3 & 0x2)<<1) | ((t4 & 0x2)<<2);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 3 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x4)>>2;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 4)>>2) | ((t2 & 0x04)>>1);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x4)>>2) | ((t2 & 0x4)>>1) | (t3 & 0x4);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x4)>>2) | ((t2 & 0x4)>>1) | (t3 & 0x4) | ((t4 & 0x4)<<1);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 4 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x8)>>3;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x08)>>2);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x8)>>2) | ((t3 & 0x8)>>1);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x8)>>2) | ((t3 & 0x8)>>1) | (t4 & 0x8);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 5 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x10)>>4;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3) | ((t3 & 0x10)>>2);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3) | ((t3 & 0x10)>>2) | ((t4 & 0x10)>>1);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 6 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x20)>>5;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4) | ((t3 & 0x20)>>3);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4) | ((t3 & 0x20)>>3) | ((t4 & 0x20)>>2);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 7 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x40)>>6;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5) | ((t3 & 0x40)>>4) ;
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5) | ((t3 & 0x40)>>4) | ((t4 & 0x40)>>3);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 8 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x80)>>7;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6) | ((t3 & 0x80)>>5);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6) | ((t3 & 0x80)>>5) | ((t4 & 0x80)>>4);
#endif
scanline[s++] = paletteptr[paletteindex];
d+=84; // jump to byte directly below
}
/*write_command(0x20); // Horizontal DRAM Address
write_data(0x10); // 0
write_command(0x21); // Vertical DRAM Address
write_data(xptr++);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;*/
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
s=0;
/** draw scanlines **/
for (s=0;s<48;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
}
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
/*write_command(0x20); // Horizontal DRAM Address
write_data(0x10); // 0
write_command(0x21); // Vertical DRAM Address
write_data(xptr++);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;*/
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
for (s=0;s<48;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
}
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
#if POK_STRETCH
//if (x>16 && x<68)
if (x&2)// && x&2)
{
/*write_command(0x20); // Horizontal DRAM Address
write_data(0x10); // 0
write_command(0x21); // Vertical DRAM Address
write_data(xptr++);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;*/
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
for (s=0;s<48;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
}
/** draw border **/
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR; CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;CLR_WR;SET_WR;
}
#endif
}
/** draw border **/
for (int s=0;s<5*176;) {
setup_data_16(COLOR_BLACK);CLR_WR;SET_WR;s++;
}
}
void Pokitto::lcdRefreshAB(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y;
uint16_t scanline[64];
uint8_t *d;
//lcdClear();
#if POK_STRETCH
uint16_t xptr = 14;
uint8_t yoffset = 24;
#else
uint16_t xptr = 0;
uint8_t yoffset = 0;
#endif
for(x=0;x<128;x++)
{
write_command(0x20); // Horizontal DRAM Address
write_data(yoffset); // 0
write_command(0x21); // Vertical DRAM Address
write_data(xptr++);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
//setDRAMptr(xptr++,yoffset);
d = scrbuf + x;// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
for(y=0;y<8;y++)
{
uint8_t t = *d;
#if POK_COLORDEPTH > 1
uint8_t t2 = *(d+AB_JUMP);
#endif // POK_COLORDEPTH
#if POK_COLORDEPTH > 2
uint8_t t3 = *(d+AB_JUMP+AB_JUMP);
#endif // POK_COLORDEPTH
#if POK_COLORDEPTH > 3
uint8_t t4 = *(d+AB_JUMP+AB_JUMP+AB_JUMP);
#endif // POK_COLORDEPTH
uint8_t paletteindex = 0;
/** bit 1 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x1);
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x1)) | ((t2 & 0x01)<<1);
#elif POK_COLORDEPTH == 3
paletteindex = (t & 0x1) | ((t2 & 0x1)<<1) | ((t3 & 0x1)<<2);
#elif POK_COLORDEPTH == 4
paletteindex = (t & 0x1) | ((t2 & 0x1)<<1) | ((t3 & 0x1)<<2) | ((t4 & 0x1)<<3);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 2 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x2)>>1;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x02));
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x2)) | ((t3 & 0x2)<<1);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x2)>>1) | ((t2 & 0x2)) | ((t3 & 0x2)<<1) | ((t4 & 0x2)<<2);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 3 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x4)>>2;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 4)>>2) | ((t2 & 0x04)>>1);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x4)>>2) | ((t2 & 0x4)>>1) | (t3 & 0x4);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x4)>>2) | ((t2 & 0x4)>>1) | (t3 & 0x4) | ((t4 & 0x4)<<1);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 4 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x8)>>3;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x08)>>2);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x8)>>2) | ((t3 & 0x8)>>1);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x8)>>3) | ((t2 & 0x8)>>2) | ((t3 & 0x8)>>1) | (t4 & 0x8);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 5 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x10)>>4;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3) | ((t3 & 0x10)>>2);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x10)>>4) | ((t2 & 0x10)>>3) | ((t3 & 0x10)>>2) | ((t4 & 0x10)>>1);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 6 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x20)>>5;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4) | ((t3 & 0x20)>>3);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x20)>>5) | ((t2 & 0x20)>>4) | ((t3 & 0x20)>>3) | ((t4 & 0x20)>>2);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 7 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x40)>>6;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5) | ((t3 & 0x40)>>4) ;
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x40)>>6) | ((t2 & 0x40)>>5) | ((t3 & 0x40)>>4) | ((t4 & 0x40)>>3);
#endif
scanline[s++] = paletteptr[paletteindex];
/** bit 8 **/
#if POK_COLORDEPTH == 1
paletteindex = (t & 0x80)>>7;
#elif POK_COLORDEPTH == 2
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6);
#elif POK_COLORDEPTH == 3
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6) | ((t3 & 0x80)>>5);
#elif POK_COLORDEPTH == 4
paletteindex = ((t & 0x80)>>7) | ((t2 & 0x80)>>6) | ((t3 & 0x80)>>5) | ((t4 & 0x80)>>4);
#endif
scanline[s++] = paletteptr[paletteindex];
d+=128; // jump to byte directly below
}
s=0;
/** draw scanlines **/
for (s=0;s<64;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
#if POK_STRETCH
if (x&1) {
write_command(0x20); // Horizontal DRAM Address
write_data(yoffset); // 0
write_command(0x21); // Vertical DRAM Address
write_data(xptr++);
write_command(0x22); // write data to DRAM
CLR_CS_SET_CD_RD_WR;
//setDRAMptr(xptr++,yoffset);
for (s=0;s<64;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
}
#endif
}
}
void Pokitto::lcdRefreshModeGBC(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y,xptr;
uint16_t scanline[4][144]; // read 4 half-nibbles = 4 pixels at a time
uint8_t *d, yoffset=0;
xptr = 0;
setDRAMptr(xptr,yoffset);
for(x=0;x<160;x+=4)
{
d = scrbuf+(x>>2);// point to beginning of line in data
/** find colours in one scanline **/
uint8_t s=0;
for(y=0;y<144;y++)
{
uint8_t tdata = *d;
uint8_t t4 = tdata & 0x03; tdata >>= 2;// lowest half-nibble
uint8_t t3 = tdata & 0x03; tdata >>= 2;// second lowest half-nibble
uint8_t t2 = tdata & 0x03; tdata >>= 2;// second highest half-nibble
uint8_t t = tdata & 0x03;// highest half-nibble
/** put nibble values in the scanlines **/
scanline[0][s] = paletteptr[t];
scanline[1][s] = paletteptr[t2];
scanline[2][s] = paletteptr[t3];
scanline[3][s++] = paletteptr[t4];
d+=160/4; // jump to read byte directly below in screenbuffer
}
s=0;
/** draw scanlines **/
for (s=0;s<144;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
}
setDRAMptr(++xptr,yoffset);
for (s=0;s<144;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
}
setDRAMptr(++xptr,yoffset);
for (s=0;s<144;) {
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[2][s++]);CLR_WR;SET_WR;
}
setDRAMptr(++xptr,yoffset);
for (s=0;s<144;) {
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[3][s++]);CLR_WR;SET_WR;
}
setDRAMptr(++xptr,yoffset);
}
}
void Pokitto::lcdRefreshT1(uint8_t* tilebuf, uint8_t* tilecolorbuf, uint8_t* tileset, uint16_t* paletteptr) {
#ifdef POK_TILEMODE
uint16_t x,y,data,xptr;
uint16_t scanline[176];
uint8_t yoffset=0, tilebyte, tileindex, tilex=0, tiley=0,xcount;
if (!tileset) return;
#if LCDWIDTH < POK_LCD_W
xptr = (POK_LCD_W-LCDWIDTH)/2;
#else
xptr = 0;
#endif
#if LCDHEIGHT < POK_LCD_H
yoffset = (POK_LCD_H-LCDHEIGHT)/2;
#else
yoffset = 0;
#endif
for(x=0, xcount=0 ;x<LCDWIDTH;x++,xcount++) // loop through vertical columns
{
setDRAMptr(xptr++,yoffset); //point to VRAM
/** find colours in one scanline **/
uint8_t s=0, tiley=0;
//tileindex = tilebuf[tilex*POK_TILES_Y];
if (xcount==POK_TILE_W) {
tilex++;
xcount=0;
}
for(y=0;y<LCDHEIGHT;)
{
uint8_t tileval = tilebuf[tilex+tiley*POK_TILES_X]; //get tile number
uint16_t index = tileval*POK_TILE_W+xcount;
uint8_t tilebyte = tileset[index]; //get bitmap data
for (uint8_t ycount=0, bitcount=0; ycount<POK_TILE_H; ycount++, y++, bitcount++) {
if (bitcount==8) {
bitcount=0;
index += 176; //jump to byte below in the tileset bitmap
tilebyte = tileset[index]; //get bitmap data
}
//tilebyte = tile[(tileindex>>4)+*POK_TILE_W]; //tilemaps are 16x16
//uint8_t paletteindex = ((tilebyte>>(bitcount&0x7)) & 0x1);
if (!tileval) scanline[s++] = COLOR_MAGENTA*((tilebyte>>bitcount)&0x1);//paletteptr[paletteindex];
else scanline[s++] = paletteptr[((tilebyte>>bitcount)&0x1)*tileval];//paletteptr[paletteindex];
}
tiley++; //move to next tile
}
s=0;
/** draw scanlines **/
for (s=0;s<LCDHEIGHT;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
}
}
#endif
}
void Pokitto::lcdRefreshMode13(uint8_t * scrbuf, uint16_t* paletteptr, uint8_t offset){
uint16_t x,y;
uint16_t scanline[2][110]; // read two nibbles = pixels at a time
uint8_t *d;
write_command(0x20); write_data(0);
write_command(0x21); write_data(0);
write_command(0x22);
CLR_CS_SET_CD_RD_WR;
for(x=0;x<110;x+=2)
{
d = scrbuf+x;// point to beginning of line in data
uint8_t s=0;
for(y=0;y<88;y++)
{
uint8_t t = *d;
uint8_t t1 = *(d+1);
scanline[0][s] = paletteptr[(t+offset)&255];
scanline[1][s++] = paletteptr[(t1+offset)&255];
d+=110; // jump to read byte directly below in screenbuffer
}
s=0;
for (s=0;s<88;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
for (s=0;s<88;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
for (s=0;s<88;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
for (s=0;s<88;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;CLR_WR;SET_WR;
}
}
}
void Pokitto::lcdRefreshMode14(uint8_t * scrbuf, uint16_t* paletteptr) {
uint16_t x,y,data,xptr;
uint16_t scanline[176]; uint16_t* scptr;
uint8_t *d;
write_command(0x20); write_data(0);
write_command(0x21); write_data(0);
write_command(0x22);
CLR_CS_SET_CD_RD_WR;
for(x=0;x<220;x++)
{
d = scrbuf+x;
scptr = &scanline[0];
/** find colours in one scanline **/
/*for(y=0;y<22;y++)
{
uint16_t t = *d;
uint16_t t2 = *(d+POK_BITFRAME);
uint16_t t3 = *(d+POK_BITFRAME+POK_BITFRAME);
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
*scptr++ = (t & 0x1)*R_MASK | (t2 & 0x1)*G_MASK | (t3 & 0x1)*B_MASK; t >>= 1;t2 >>= 1;t3 >>= 1;
d+=220; // jump to word directly below
}
*/
/** alternative way: go through one color at a time **/
scptr = &scanline[0]; // set to beginning of scanline
for(y=0;y<22;y++, d +=220)
{
uint16_t t = *d & 0xFF;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1); t >>= 1;
*scptr++ = R_MASK * (t&0x1);
}
scptr = &scanline[0]; // set to beginning of scanline
d = scrbuf+x+POK_BITFRAME;
for(y=0;y<22;y++, d +=220)
{
uint16_t t = *d & 0xFF;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1); t >>= 1;
*scptr++ |= G_MASK * (t&0x1);
}
scptr = &scanline[0]; // set to beginning of scanline
d = scrbuf+x+POK_BITFRAME*2;
for(y=0;y<22;y++, d +=220)
{
uint16_t t = *d & 0xFF;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1); t >>= 1;
*scptr++ |= B_MASK * (t&0x1);
}
#ifdef PROJ_SHOW_FPS_COUNTER
if (x<8) continue;
setDRAMptr(x, 0);
#endif
/** draw scanlines **/
for (int s=0;s<176;) {
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
setup_data_16(scanline[s++]);CLR_WR;SET_WR;
}
}
}
//#define ADEKTOSMODE15
#ifdef ADEKTOSMODE15
void Pokitto::lcdRefreshMode15(uint16_t* pal, uint8_t* scrbuf){
write_command(0x03); write_data(0x1038); //realy only need to call this once
write_command(0x20); write_data(0);
write_command(0x21); write_data(0);
write_command(0x22);
#ifdef PROJ_SHOW_FPS_COUNTER
for (int x=0,xt=0; x<0x4BA0;x++,xt++) {
if (xt==110) xt=0;
if (xt<8) {
write_data(0);
write_data(0);
} else {
write_data(pal[(((scrbuf[x]) & 0xf0) >> 4)]);
write_data(pal[( (scrbuf[x]) & 0x0f)]);
}
}
#else
for (int x=0; x<0x4BA0;x++) {
write_data(pal[(((scrbuf[x]) & 0xf0) >> 4)]);
write_data(pal[( (scrbuf[x]) & 0x0f)]);
}
#endif //PROJ_SHOW_FPS_COUNTER
}
#else
void Pokitto::lcdRefreshMode15(uint16_t* paletteptr, uint8_t* scrbuf){
uint16_t x,y,xptr;
uint16_t scanline[2][176]; // read two nibbles = pixels at a time
uint8_t *d, yoffset=0;
xptr = 0;
//setDRAMptr(xptr,yoffset);
write_command(0x20); write_data(0);
write_command(0x21); write_data(0);
write_command(0x22);
CLR_CS_SET_CD_RD_WR;
for(x=0;x<220;x+=2)
{
d = scrbuf+(x>>1);// point to beginning of line in data
// find colours in one scanline
uint8_t s=0;
for(y=0;y<176;y++)
{
uint8_t t = *d >> 4; // higher nibble
uint8_t t2 = *d & 0xF; // lower nibble
// higher nibble = left pixel in pixel pair
scanline[0][s] = paletteptr[t];
scanline[1][s++] = paletteptr[t2];
d+=220/2; // jump to read byte directly below in screenbuffer
}
s=0;
// draw scanlines
#ifdef PROJ_SHOW_FPS_COUNTER
if (x<8) continue;
setDRAMptr(x, 0);
#endif
for (s=0;s<176;) {
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[0][s++]);CLR_WR;SET_WR;
}
for (s=0;s<176;) {
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
setup_data_16(scanline[1][s++]);CLR_WR;SET_WR;
}
}
}
#endif //ADEKTOSMODE15
void Pokitto::blitWord(uint16_t c) {
setup_data_16(c);CLR_WR;SET_WR;
}