static void writeReg(lcd_data_t reg, lcd_data_t data)
{
setRS(0);
writeLcd(reg);
setRS(1);
writeLcd(data);
}
void lcdTest(void)
{
for(int y=0; y<240; y++) {
lcdPixel(0, y, COLOR_WHITE);
lcdPixel(319, y, COLOR_WHITE);
}
for(int x=0; x<320; x++) {
lcdPixel(x, 0, COLOR_WHITE);
lcdPixel(x, 239, COLOR_WHITE);
}
lcdStr(2, 2, "Hello world!", COLOR_GREEN, COLOR_BLUE);
return;
writeReg(0x004f, 0); // Set GDDRAM X address counter
writeReg(0x004e, 0); // Set GDDRAM Y address counter
setRS(0);
writeLcd(0x22); // RAM data write register
setRS(1);
for(int y=0; y<240; y++) {
for(int x=0; x<320; x++) {
writeLcd(lcdColor(y, x, 0));
/*
if((y & 0x10) ^ (x & 0x10)) {
writeLcd(lcdColor(0xff, 0, 0));
} else {
writeLcd(lcdColor(0, 0xff, 0));
}
*/
}
}
}
void gxScene::setFogRange( float nr,float fr ) {
if( nr==fogrange_nr && fr==fogrange_fr ) return;
fogrange_nr=nr;
fogrange_fr=fr;
setRS( D3DRENDERSTATE_FOGSTART,*(DWORD*)&fogrange_nr );
setRS( D3DRENDERSTATE_FOGEND,*(DWORD*)&fogrange_fr );
}
void gxScene::setTriCull(){
if( fx & FX_DOUBLESIDED ){
setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_NONE );
}else if( flipped ){
setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_CW );
}else{
setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_CCW );
}
}
void lcdFill(lcd_color_t color)
{
writeReg(0x004f, 0); // Set GDDRAM X address counter
writeReg(0x004e, 0); // Set GDDRAM Y address counter
setRS(0); writeLcd(0x22); // RAM data write register
setRS(1);
for(int i=0; i<320*240; i++) {
writeLcd(color);
}
}
void gxScene::setDither(bool n)
{
if (n == dither)
return;
dither = n;
setRS(D3DRENDERSTATE_DITHERENABLE, dither ? true : false);
}
void gxScene::setAntialias(bool n)
{
if (n == antialias)
return;
antialias = n;
setRS(D3DRENDERSTATE_ANTIALIAS, antialias ? D3DANTIALIAS_SORTINDEPENDENT : D3DANTIALIAS_NONE);
}
void gxScene::setWireframe(bool n)
{
if (n == wireframe)
return;
wireframe = n;
setRS(D3DRENDERSTATE_FILLMODE, wireframe ? D3DFILL_WIREFRAME : D3DFILL_SOLID);
}
void gxScene::setFogColor(const float rgb[3])
{
int n = (int(rgb[0] * 255.0f) << 16) | (int(rgb[1] * 255.0f) << 8) | int(rgb[2] * 255.0f);
if (n == fogcolor)
return;
fogcolor = n;
setRS(D3DRENDERSTATE_FOGCOLOR, fogcolor);
}
void Lcd::printChar(const char c){
setRS();
setE();
setBits(c);
Timer::wait_ms(1);
resetE();
Timer::wait_ms(1);
}
void gxScene::render(gxMesh* m, int first_vert, int vert_cnt, int first_tri, int tri_cnt)
{
m->render(first_vert, vert_cnt, first_tri, tri_cnt);
tris_drawn += tri_cnt;
if (n_texs <= tex_stages)
return;
setTSS(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
setTSS(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
if (tex_stages > 1) {
setTSS(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
setTSS(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
setRS(D3DRENDERSTATE_LIGHTING, false);
setRS(D3DRENDERSTATE_ALPHABLENDENABLE, true);
for (int k = tex_stages; k < n_texs; ++k) {
const TexState& state = texstate[k];
switch (state.blend) {
case BLEND_ALPHA:
setRS(D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
setRS(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
break;
case BLEND_MULTIPLY:
case BLEND_DOT3:
setRS(D3DRENDERSTATE_SRCBLEND, D3DBLEND_DESTCOLOR);
setRS(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
break;
case BLEND_ADD:
setRS(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
setRS(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
break;
}
setTexState(0, state, false);
m->render(first_vert, vert_cnt, first_tri, tri_cnt);
tris_drawn += tri_cnt;
}
setRS(D3DRENDERSTATE_ALPHABLENDENABLE, false);
setRS(D3DRENDERSTATE_LIGHTING, true);
if (tex_stages > 1)
setTexState(1, texstate[1], true);
setTexState(0, texstate[0], true);
}
void lcdChar(int x, int y, char c, lcd_color_t fg, lcd_color_t bg)
{
uint8_t* ptr = fnt8x8 + (unsigned int)c*8;
for(int py=y; py<y+FONT_H; py++)
{
writeReg(0x004f, x); // Set GDDRAM X address counter
writeReg(0x004e, py); // Set GDDRAM Y address counter
setRS(0); writeLcd(0x22); // RAM data write register
setRS(1);
uint8_t l = *ptr++;
for(int px=x; px<x+FONT_W; px++)
{
if (l & 0x80) {
writeLcd(fg);
} else {
writeLcd(bg);
}
l <<= 1;
}
}
}
void gxScene::setZMode(){
switch( zmode ){
case ZMODE_NORMAL:
setRS( D3DRENDERSTATE_ZENABLE,wbuffer ? D3DZB_USEW : D3DZB_TRUE );
setRS( D3DRENDERSTATE_ZWRITEENABLE,true );
break;
case ZMODE_DISABLE:
setRS( D3DRENDERSTATE_ZENABLE,D3DZB_FALSE );
setRS( D3DRENDERSTATE_ZWRITEENABLE,false );
break;
case ZMODE_CMPONLY:
setRS( D3DRENDERSTATE_ZENABLE,wbuffer ? D3DZB_USEW : D3DZB_TRUE );
setRS( D3DRENDERSTATE_ZWRITEENABLE,false );
break;
}
}
void gxScene::setFogMode(){
bool fog= fogmode==FOG_LINEAR && !(fx&FX_NOFOG);
setRS( D3DRENDERSTATE_FOGENABLE,fog );
}
gxScene::gxScene( gxGraphics *g,gxCanvas *t ):
graphics(g),target(t),dir3dDev( g->dir3dDev ),
n_texs(0),tris_drawn(0){
memset( d3d_rs,0x55,sizeof(d3d_rs) );
memset( d3d_tss,0x55,sizeof(d3d_tss) );
//nomalize normals
setRS( D3DRENDERSTATE_NORMALIZENORMALS,TRUE );
//vertex coloring
setRS( D3DRENDERSTATE_COLORVERTEX,FALSE );
setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,D3DMCS_COLOR1 );
setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,D3DMCS_COLOR1 );
setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,D3DMCS_MATERIAL );
setRS( D3DRENDERSTATE_SPECULARMATERIALSOURCE,D3DMCS_MATERIAL );
//Alpha test
setRS( D3DRENDERSTATE_ALPHATESTENABLE,false );
setRS( D3DRENDERSTATE_ALPHAFUNC,D3DCMP_GREATER );
setRS( D3DRENDERSTATE_ALPHAREF,128 );
//source/dest blending modes
setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );
//suss out caps
can_wb=false;
hw_tex_stages=1;
D3DDEVICEDESC7 devDesc={0};
if( dir3dDev->GetCaps( &devDesc )>=0 ){
DWORD caps=devDesc.dpcTriCaps.dwRasterCaps;
//texture stages
hw_tex_stages=devDesc.wMaxSimultaneousTextures;
//depth buffer mode
if( (caps & D3DPRASTERCAPS_WBUFFER) && graphics->zbuffFmt.dwRGBBitCount==16 ) can_wb=true;
//fog mode
if( (caps&D3DPRASTERCAPS_FOGTABLE)&&(caps&D3DPRASTERCAPS_WFOG) ){
setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_NONE );
setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_LINEAR );
}else{
setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_NONE );
setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_LINEAR );
}
}
tex_stages=hw_tex_stages;
caps_level=100;
if( devDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_CUBEMAP ){
caps_level=110;
}
//default texture states
for( int n=0;n<hw_tex_stages;++n ){
setTSS( n,D3DTSS_COLORARG1,D3DTA_TEXTURE );
setTSS( n,D3DTSS_COLORARG2,D3DTA_CURRENT );
setTSS( n,D3DTSS_ALPHAARG1,D3DTA_TEXTURE );
setTSS( n,D3DTSS_ALPHAARG2,D3DTA_CURRENT );
setTSS( n,D3DTSS_MINFILTER,D3DTFN_LINEAR );
setTSS( n,D3DTSS_MAGFILTER,D3DTFG_LINEAR );
setTSS( n,D3DTSS_MIPFILTER,D3DTFP_LINEAR );
}
setHWMultiTex( true );
//ATI lighting hack
dir3dDev->LightEnable( 0,true );
dir3dDev->LightEnable( 0,false );
//globals
sphere_mat._11=.5f;sphere_mat._22=-.5f;sphere_mat._33=.5f;
sphere_mat._41=.5f;sphere_mat._42=.5f;sphere_mat._43=.5f;
nullmatrix._11=nullmatrix._22=nullmatrix._33=nullmatrix._44=1;
//set null renderstate
memset(&material,0,sizeof(material));
shininess=0;blend=BLEND_REPLACE;fx=0;
for( int k=0;k<MAX_TEXTURES;++k ) memset( &texstate[k],0,sizeof(texstate[k]) );
wbuffer=can_wb;
dither=false;setDither( true );
antialias=true;setAntialias( false );
wireframe=true;setWireframe( false );
flipped=true;setFlippedTris( false );
ambient=~0;setAmbient( GRAY );
ambient2=~0;setAmbient2( BLACK );
fogcolor=~0;setFogColor( BLACK );
fogrange_nr=fogrange_fr=0;setFogRange( 1,1000 );
fogmode=FOG_LINEAR;setFogMode( FOG_NONE );
zmode=-1;setZMode( ZMODE_NORMAL );
memset(&projmatrix,0,sizeof(projmatrix));
ortho_proj=true;frustum_nr=frustum_fr=frustum_w=frustum_h=0;setPerspProj( 1,1000,1,1 );
memset(&viewport,0,sizeof(viewport));viewport.dvMaxZ=1;setViewport( 0,0,target->getWidth(),target->getHeight() );
viewmatrix=nullmatrix;setViewMatrix( 0 );
worldmatrix=nullmatrix;setWorldMatrix( 0 );
//set default renderstate
blend=fx=~0;shininess=1;
RenderState state;memset(&state,0,sizeof(state));
state.color[0]=state.color[1]=state.color[2]=state.alpha=1;
state.blend=BLEND_REPLACE;
setRenderState( state );
}
void gxScene::setAmbient(){
int n=(fx & FX_FULLBRIGHT) ? 0xffffff : ((fx & FX_CONDLIGHT) ? ambient2 : ambient);
setRS( D3DRENDERSTATE_AMBIENT,n );
}
int lcdInit(void)
{
setRS(0);
lcd_data_t status = readLcdOnce();
if (status != 0x8989) {
return (1<<31) | status; // unknow lcd
}
dataOut();
// power supply setting
// set R07h at 0021h (GON=1,DTE=0,D[1:0]=01)
writeReg(0x0007,0x0021);
// set R00h at 0001h (OSCEN=1)
writeReg(0x0000,0x0001);
// set R07h at 0023h (GON=1,DTE=0,D[1:0]=11)
writeReg(0x0007,0x0023);
// set R10h at 0000h (Exit sleep mode)
writeReg(0x0010,0x0000);
// Wait 30ms
chThdSleepMilliseconds(30);
// set R07h at 0033h (GON=1,DTE=1,D[1:0]=11)
writeReg(0x0007,0x0033);
// Entry mode setting (R11h)
// R11H Entry mode
// vsmode DFM1 DFM0 TRANS OEDef WMode DMode1 DMode0 TY1 TY0 ID1 ID0 AM LG2 LG2 LG0
// 0 1 1 0 0 0 0 0 0 1 1 1 * 0 0 0
writeReg(0x0011, 0x6078); // 0x6070
// LCD driver AC setting (R02h)
writeReg(0x0002,0x0600);
// power control 1
// DCT3 DCT2 DCT1 DCT0 BT2 BT1 BT0 0 DC3 DC2 DC1 DC0 AP2 AP1 AP0 0
// 1 0 1 0 1 0 0 0 1 0 1 0 0 1 0 0
// DCT[3:0] fosc/4 BT[2:0] DC{3:0] fosc/4
writeReg(0x0003,0x0804);//0xA8A4
writeReg(0x000C,0x0000);//
writeReg(0x000D,0x0808);// 0x080C --> 0x0808
// power control 4
// 0 0 VCOMG VDV4 VDV3 VDV2 VDV1 VDV0 0 0 0 0 0 0 0 0
// 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0
writeReg(0x000E, 0x2900);
writeReg(0x001E, 0x00B8);
writeReg(0x0001, 0x293F); // 0x2B3F); // Driver output control 320*240 0x6B3F
writeReg(0x0010, 0x0000);
writeReg(0x0005, 0x0000);
writeReg(0x0006, 0x0000);
writeReg(0x0016, 0xEF1C);
writeReg(0x0017, 0x0003);
writeReg(0x0007, 0x0233); // 0x0233
writeReg(0x000B, 0x0000|(3<<6));
writeReg(0x000F, 0x0000); // Gate scan start position
writeReg(0x0041, 0x0000);
writeReg(0x0042, 0x0000);
writeReg(0x0048, 0x0000);
writeReg(0x0049, 0x013F);
writeReg(0x004A, 0x0000);
writeReg(0x004B, 0x0000);
writeReg(0x0044, 0xEF00);
writeReg(0x0045, 0x0000);
writeReg(0x0046, 0x013F);
writeReg(0x0030, 0x0707);
writeReg(0x0031, 0x0204);
writeReg(0x0032, 0x0204);
writeReg(0x0033, 0x0502);
writeReg(0x0034, 0x0507);
writeReg(0x0035, 0x0204);
writeReg(0x0036, 0x0204);
writeReg(0x0037, 0x0502);
writeReg(0x003A, 0x0302);
writeReg(0x003B, 0x0302);
writeReg(0x0023, 0x0000);
writeReg(0x0024, 0x0000);
writeReg(0x0025, 0x8000); // 65hz
writeReg(0x004f, 0); // Set GDDRAM X address counter
writeReg(0x004e, 0); // Set GDDRAM Y address counter
lcdFill(COLOR_BLACK);
return 0;
}
void gxScene::setRenderState( const RenderState &rs ){
bool setmat=false;
if( memcmp( rs.color,&material.diffuse.r,12 ) ){
memcpy( &material.diffuse.r,rs.color,12 );
memcpy( &material.ambient.r,rs.color,12 );
setmat=true;
}
if( rs.alpha!=material.diffuse.a ){
material.diffuse.a=rs.alpha;
if( rs.fx&FX_ALPHATEST ){
int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha;
setRS( D3DRENDERSTATE_ALPHAREF,alpharef );
}
setmat=true;
}
if( rs.shininess!=shininess ){
shininess=rs.shininess;
float t=shininess>0 ? (shininess<1 ? shininess : 1) : 0;
material.specular.r=material.specular.g=material.specular.b=t;
material.power=shininess*128;
setRS( D3DRENDERSTATE_SPECULARENABLE,shininess>0 ? true : false );
setmat=true;
}
if( rs.blend!=blend ){
blend=rs.blend;
switch( blend ){
case BLEND_REPLACE:
setRS( D3DRENDERSTATE_ALPHABLENDENABLE,false );
break;
case BLEND_ALPHA:
setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );
break;
case BLEND_MULTIPLY:
setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_DESTCOLOR );
setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ZERO );
break;
case BLEND_ADD:
setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ONE );
break;
}
}
if( rs.fx!=fx ){
int t=rs.fx^fx;fx=rs.fx;
if( t & (FX_FULLBRIGHT|FX_CONDLIGHT) ){
setLights();
setAmbient();
}
if( t&FX_VERTEXCOLOR ){
setRS( D3DRENDERSTATE_COLORVERTEX,fx & FX_VERTEXCOLOR ? true : false );
}
if( t&FX_FLATSHADED ){
setRS( D3DRENDERSTATE_SHADEMODE,fx & FX_FLATSHADED ? D3DSHADE_FLAT : D3DSHADE_GOURAUD );
}
if( t&FX_NOFOG ){
setFogMode();
}
if( t&FX_DOUBLESIDED ){
setTriCull();
}
if( t&FX_EMISSIVE ){
//Q3 Hack!
int n=fx & FX_EMISSIVE;
setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 );
setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 );
setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,n ? D3DMCS_COLOR1 : D3DMCS_MATERIAL );
setRS( D3DRENDERSTATE_COLORVERTEX,n ? true : false );
}
if( t&FX_ALPHATEST ){
if( fx&FX_ALPHATEST ){
int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha;
setRS( D3DRENDERSTATE_ALPHAREF,alpharef );
}
setRS( D3DRENDERSTATE_ALPHATESTENABLE,fx & FX_ALPHATEST ? true : false );
}
}
if( setmat ){
dir3dDev->SetMaterial( &material );
}
n_texs=0;
TexState *hw=texstate;
for( int k=0;k<MAX_TEXTURES;++k ){
const RenderState::TexState &ts=rs.tex_states[k];
if( !ts.canvas || !ts.blend ) continue;
bool settex=false;
ts.canvas->getTexSurface(); //force mipmap rebuild
if( ts.canvas!=hw->canvas ){ hw->canvas=ts.canvas;settex=true; }
if( ts.blend!=hw->blend ){ hw->blend=ts.blend;settex=true; }
if( ts.flags!=hw->flags ){ hw->flags=ts.flags;settex=true; }
if( ts.matrix || hw->mat_valid ){
if( ts.matrix ){
memcpy( &hw->matrix._11,ts.matrix->elements[0],12 );
memcpy( &hw->matrix._21,ts.matrix->elements[1],12 );
memcpy( &hw->matrix._31,ts.matrix->elements[2],12 );
memcpy( &hw->matrix._41,ts.matrix->elements[3],12 );
hw->mat_valid=true;
}else{
hw->mat_valid=false;
}
settex=true;
}
if( settex && n_texs<tex_stages ){
setTexState( n_texs,*hw,true );
}
++hw;++n_texs;
}
if( n_texs<tex_stages && hw->canvas ){
hw->canvas=0;
setTSS( n_texs,D3DTSS_COLOROP,D3DTOP_DISABLE );
setTSS( n_texs,D3DTSS_ALPHAOP,D3DTOP_DISABLE );
dir3dDev->SetTexture( n_texs,0 );
}
}
/**
* @brief Sendet ein Zeichen an das Display
*
* void writeData(char data)
* @param data Zu sendendes Zeichen
*/
void writeData(char data) {
setRS();
write4Bit((data&0xf0)>>4);
write4Bit(data&0x0f);
resetRS();
}
