void Draw(Bitmap *surface) {
ClearBitmap(surface);
if (pause_mode)
{
DrawText(surface, "PAUSE", 50, 180);
} else {
for(int i=0;i<NumberOfStars;i++)
{
DrawRLEBitmap(surface,sprites[stars[i].f],(stars[i].x),stars[i].y);
stars[i].y+=stars[i].dy;
if(stars[i].y>=(200))
{
stars[i].y=(0);
stars[i].x=GetRandomInteger()%320;
stars[i].f=(stars[i].f%7)+(GetRandomInteger()%6)*7;
}
const RLEBitmap sprite = *sprites[stars[i].f];
const RLEBitmap spaceBitmap = *spacecraft[0];
if (RectRectIntersection(stars[i].x, stars[i].y, sprite.width, sprite.height, pos_x, pos_y, spaceBitmap.width, spaceBitmap.height))
{
gameOver(surface, pos_x, pos_y);
}
}
}
DrawRLEBitmap(surface, spacecraft[dir+1], pos_x, pos_y);
}
void
scan_heap(char* label, mem_t start, mem_t finish, mem_t top,
Heap_t** legalHeaps, Bitmap_t** legalStarts,
int show, ShowType_t replicaType, Bitmap_t* startMap)
{
mem_t cur = start, next;
if(startMap)
ClearBitmap(startMap);
if(show){
printf("--------------\n");
printf("BEGIN %s HEAP CHECK at GC %d: %lx <= %lx < %lx\n",
label,NumGC,(long)start,(long)finish,(long)top);
printf("--------------\n");
}
while(cur < finish){
ptr_t obj = NULL;
next = show_obj(cur,&obj,show,replicaType,
legalHeaps,legalStarts);
assert(obj != NULL);
assert(next > cur);
if(startMap){
int pos = obj - start;
SetBitmapRange(startMap,pos,1);
}
cur = next;
}
if(show){
printf("--------------\n");
printf("END %s HEAP CHECK at GC %d: %lx <= %lx < %lx\n",
label,NumGC,(long)start,(long)finish,(long)top);
printf("--------------\n");
}
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
CFrameWnd::OnCreate(lpCreateStruct);
m_toolBar.Create(this);
m_toolBar.LoadToolBar(IDR_TOOLBAR1);
m_toolBar.SetBarStyle(m_toolBar.GetBarStyle()|CBRS_TOOLTIPS|CBRS_FLYBY);
static UINT indicators[]=
{
ID_SEPARATOR,
ID_INDICATOR_SPEED,
ID_INDICATOR_GENERATIONS,
ID_INDICATOR_CURGENERATION
};
m_statusBar.Create(this);
m_statusBar.SetIndicators(indicators, 4);
m_statusBar.SetPaneInfo(0,m_statusBar.GetItemID(0),SBPS_STRETCH,0);
m_statusBar.SetPaneText(1,"Speed: 10", TRUE);
m_statusBar.SetPaneText(2,"Max Gens: 500", TRUE);
m_statusBar.SetPaneText(3,"Generation: 0", TRUE);
CClientDC clientDC(this);
m_pBitmap=new CBitmap;
m_pBitmap->CreateCompatibleBitmap(&clientDC,1005,740);
ClearBitmap();
DrawGrid();
return 0;
}
void Draw(Bitmap* surface)
{
ClearBitmap(surface);
DrawFilledRectangle(surface, 30, 30, 100, 100, RGB(0,myframe%256,0));
setFont(fontwhite16);
DrawText(surface, "TEST\nBLA", 10, 10);
setFont(fontblack8);
DrawText(surface, "TEST", 10, 30);
}
void CLCDOutput::Update(DWORD dwTimestamp)
{
if (m_pActiveScreen)
{
m_pActiveScreen->Update(dwTimestamp);
}
// check for expiration
if (m_pActiveScreen && m_pActiveScreen->HasExpired())
{
m_pActiveScreen = NULL;
//m_nPriority = LGLCD_PRIORITY_FYI; -> needs to go so that if a
// program sets priority to LGLCD_PRIORITY_BACKGROUND, that
// priority sticks.
OnScreenExpired(m_pActiveScreen);
// Clear the bitmap
ClearBitmap(m_pLastBitmap);
// find the next active screen
LCD_MGR_LIST::iterator it = m_LCDMgrList.begin();
while(it != m_LCDMgrList.end())
{
CLCDManager *pMgr = *it;
LCDUIASSERT(NULL != pMgr);
if (!pMgr->HasExpired())
{
ActivateScreen(pMgr);
//m_nPriority = LGLCD_PRIORITY_FYI; -> needs to go so that if a
// program sets priority to LGLCD_PRIORITY_BACKGROUND, that
// priority sticks.
break;
}
++it;
}
// if no screen found, empty the screen at idle priority
if (NULL == m_pActiveScreen)
{
if (LGLCD_INVALID_DEVICE != m_hDevice)
{
lgLcdUpdateBitmap(m_hDevice, &CLCDManager::GetLCDScreen()->hdr,
LGLCD_ASYNC_UPDATE(LGLCD_PRIORITY_IDLE_NO_SHOW));
}
}
}
// check for lcd devices
if (LGLCD_INVALID_DEVICE == m_hDevice)
{
EnumerateDevices();
}
}
void CMainFrame::OnClear ()
{
for (UINT row=0;row<NUMBEROFROWS;++row)
for (UINT col=0;col<NUMBEROFCOLS;++col)
m_world[row][col]=DEAD;
ClearBitmap();
DrawGrid();
Invalidate();
}
void CLCDOutput::OnClosingDevice(int hDevice)
{
UNREFERENCED_PARAMETER(hDevice);
LCDUITRACE(_T("CLCDOutput::OnClosingDevice\n"));
if (IsOpened())
{
lgLcdClose(m_hDevice);
m_hDevice = LGLCD_INVALID_DEVICE;
}
ClearBitmap(m_pLastBitmap);
}
void Draw(Bitmap *b)
{
ClearBitmap(b);
if(!run){
DrawFilledRectangle(b, curx*5, cury*5, 5, 5, RGB(100,100,100));
}
for(int i = 0; i < N; i++){
for(int j = 0; j < M; j++){
if(A[i][j]==1){
DrawFilledRectangle(b, i*5, j*5, 5, 5, RGB(255,255,255));
}
}
}
}
BOOL WINAPI ChangeBackground(HBITMAP& hNewBGBitmap, DWORD& dwOverlayBGColor)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
srand(time(NULL)+GetTickCount());
dwOverlayBGColor=COLORKEY;
objSettings.dbBgImage.Destroy();
objSettings.szBitmapSize=GetBitmapSize(hNewBGBitmap);
objSettings.dbBgImage.Create(objSettings.szBitmapSize.cx, objSettings.szBitmapSize.cy);
CDC dcScreen,dcReal;
dcScreen.CreateDC("DISPLAY", NULL, NULL, NULL);
dcReal.CreateCompatibleDC(&dcScreen);
HBITMAP hbmpTmp=(HBITMAP)CopyImage(hNewBGBitmap,IMAGE_BITMAP, objSettings.szBitmapSize.cx, objSettings.szBitmapSize.cy, 0);
objSettings.dbBgImage.SetBitmap(&dcReal,hbmpTmp);
DWORD dwErr=GetLastError();
ClearBitmap(hbmpTmp);
InitImage();
return TRUE;
};
void Draw(Bitmap* surface)
{
ClearBitmap(surface);
DrawFilledRectangle(surface, 30, 30, 50, 50, GetPushbuttonState().A ? RGB(128,128,128) : RGB(255, 255, 255));
setFont(fontwhite16);
char testString[8];
testString[7] = '\0';
testString[0] = GetPushbuttonState().A ? 'A' : ' ';
testString[1] = GetPushbuttonState().B ? 'B' : ' ';
testString[2] = GetPushbuttonState().Up ? 'U' : ' ';
testString[3] = GetPushbuttonState().Down ? 'D' : ' ';
testString[4] = GetPushbuttonState().Left ? 'L' : ' ';
testString[5] = GetPushbuttonState().Right ? 'R' : ' ';
testString[6] = GetPushbuttonState().User ? 'u' : ' ';
setFont(fontwhite8);
DrawText(surface, testString, 10, 100);
}
CLCDOutput::CLCDOutput()
{
m_pActiveScreen = NULL;
m_bLocked = FALSE;
m_hDevice = LGLCD_INVALID_DEVICE;
m_hConnection = LGLCD_INVALID_CONNECTION;
m_nPriority = LGLCD_PRIORITY_NORMAL;
ZeroMemory(&m_lcdConnectCtxEx, sizeof(m_lcdConnectCtxEx));
m_bDisplayLocked = FALSE;
m_bSetAsForeground = FALSE;
// Setup default device families
m_dwDeviceFamiliesSupported = LGLCD_DEVICE_FAMILY_KEYBOARD_G15 |
LGLCD_DEVICE_FAMILY_JACKBOX |
LGLCD_DEVICE_FAMILY_SPEAKERS_Z10;
m_dwDeviceFamiliesSupportedReserved1 = 0;
m_pLastBitmap = DNew lgLcdBitmap160x43x1;
ClearBitmap(m_pLastBitmap);
// Allow the first update to go through
m_bPriorityHasChanged = TRUE;
}
//************************************************************************
//
// CLCDOutput::SetScreenPriority
//
//************************************************************************
void CLCDOutput::SetScreenPriority(DWORD priority)
{
if (priority == m_nPriority)
{
// Nothing to do
return;
}
// Clear the bitmap
ClearBitmap(m_pLastBitmap);
m_nPriority = priority;
m_bPriorityHasChanged = TRUE;
if (LGLCD_PRIORITY_IDLE_NO_SHOW == m_nPriority)
{
// send an empty bitmap at idle priority
if (LGLCD_INVALID_DEVICE != m_hDevice)
{
lgLcdUpdateBitmap(m_hDevice, &m_pLastBitmap->hdr,
LGLCD_ASYNC_UPDATE(LGLCD_PRIORITY_IDLE_NO_SHOW));
}
}
}
void Red_Draw(Bitmap* surface)
{
ClearBitmap(surface);
DrawFilledRectangle(surface, 30, 30, 50, 50, RGB(255,0,0));
}
int main(int argc, char **argv)
{
RANDOM_Initialize();
uint start = 0;
uint end = 0;
printf(" STARTING FRAME : ");
fflush(stdin);
scanf("%d", &start);
printf(" ENDING FRAME : ");
fflush(stdin);
scanf("%d", &end);
fflush(stdin);
if (start == end || start > end) return 0;
SURFACE* marble_d = NULL;
SURFACE* marble_n = NULL;
SURFACE* marble_s = NULL;
ImportBMPFile("data/marble_d.bmp", &marble_d);
ImportBMPFile("data/marble_n.bmp", &marble_n);
ImportBMPFile("data/marble_s.bmp", &marble_s);
printf("\n");
printf("INITIALIZING SCENE\n\n");
VEC4 CameraPosition = VEC4(1.2f, 0.8f, -2.4f, 1.0);
MainCamera = new Camera;
MainCamera->position = CameraPosition;
MainCamera->dimensions = VEC2(ViewWidth, ViewWidth * 0.75f);
MainCamera->focalLength = 16.0f;
MainCamera->sampleSize = Samples;
Entity* diamond1 = new Entity;
Entities.add(diamond1);
diamond1->initialize();
ImportOBJFile("data/topDiamond.obj", &diamond1->mesh);
diamond1->material->specular = 0.4f;
diamond1->material->overlay = COLOR(0.05f, 0.4f, 1.0f, 1.0);
diamond1->material->reflection = 1.0f;
diamond1->material->refIndex = 1.333f;
Entity* diamond2 = new Entity;
Entities.add(diamond2);
diamond2->initialize();
ImportOBJFile("data/bottomDiamond.obj", &diamond2->mesh);
diamond2->material->specular = 0.4f;
diamond2->material->overlay = COLOR(0.2f, 1.0f, 0.9f, 1.0);
diamond2->material->reflection = 1.0f;
diamond2->material->refIndex = 1.333f;
Entity* background = new Entity;
Entities.add(background);
background->initialize();
ImportOBJFile("data/box.obj", &background->mesh);
background->material->overlay = COLOR(0.7f, 1.0f, 0.9f, 1.0);
background->material->reflection = 1.0f;
background->material->specular = 0.4f;
Light* light1 = new Light(VEC4(0.8f, 0.2f, -2.4f, 0.0f), VEC3(0.001f, 0.04f, 0.12f), COLOR(1.0f, 1.0f, 1.0f, 1.0f));
Lights.add(light1);
light1->shadowIntensity = 0.8f;
printf("START RENDERING\n\n");
SURFACE* render = NULL;
CreateSurface(&render, "", Width, Height, PIXELFORMAT_RGB);
char* filename = new char[128];
uint t = (uint)time(0);
for (uint i = start; i < end; i++)
{
printf("RENDERING FRAME : %03d ", i);
ClearBitmap(render, 0x333333);
memset(filename, 0, sizeof(char) * 128);
sprintf(filename, "RaySequence04_720p/RayTrace.%03d.bmp", i);
Theta = float(i) * TurnSpeed;
MainCamera->position = VEC4(
(CameraPosition.x * cos(Theta)) - (CameraPosition.z * sin(Theta)),
CameraPosition.y,
(CameraPosition.x * sin(Theta)) + (CameraPosition.z * cos(Theta)),
1.0f);
#if 0
light1->position = VEC4(
(light1->position.x * cos(-Theta)) - (light1->position.z * sin(-Theta)),
light1->position.y,
(light1->position.x * sin(-Theta)) + (light1->position.z * cos(-Theta)),
1.0f);
#endif
//MainCamera->castRays(render);
MainCamera->castRays(render);
ExportBMPFile(filename, render);
printf("DONE\n");
}
delete [] filename;
FreeSurface(&render);
printf("\n");
//printf("FINISHED RENDERING\n\n");
return 0;
}
void
gc_large_startCollect(void)
{
ClearBitmap(markMap);
}
void
gc_large_endCollect(void)
{
ClearBitmap(allocMap);
typed_swap(Bitmap_t *, allocMap, markMap);
}
OP_STATUS VisualDeviceBackBuffer::InitBitmap(const OpRect& rect, OpPainter* painter, int opacity, BOOL replace_color, BOOL copy_background)
{
INT32 current_width = 0;
INT32 current_height = 0;
if (bitmap)
{
current_width = bitmap->Width();
current_height = bitmap->Height();
if (current_width < rect.width || current_height < rect.height
|| (!replace_color && copy_background)) // TODO: special case that currently is not supported in a cached back buffer
{
OP_DELETE(bitmap);
bitmap = NULL;
}
}
has_background = FALSE;
if (!bitmap)
{
if (!replace_color && copy_background)
bitmap = painter->CreateBitmapFromBackground(rect);
has_background = !!bitmap;
INT32 new_width = MAX(current_width, rect.width);
INT32 new_height = MAX(current_height, rect.height);
OpAutoPtr<OpBitmap> bg_bitmap;
if (bitmap && !bitmap->Supports(OpBitmap::SUPPORTS_PAINTER))
{
bg_bitmap.reset(bitmap);
bitmap = NULL;
}
if (!bitmap)
RETURN_IF_ERROR(OpBitmap::Create(&bitmap, new_width, new_height, FALSE, TRUE, 0, 0, TRUE));
if (bg_bitmap.get())
{
OpRect source(rect);
source.x = 0;
source.y = 0;
/* According to the documentation of SetColor(), color
* must be non-NULL when all_transparent is TRUE. I
* suspect that is a bug in the documentation, but I'll do
* as it says anyway.
*/
UINT8 dummy_color[4] = {0, 0, 0, 0};
if (!bitmap->SetColor(dummy_color, TRUE, NULL))
return OpStatus::ERR;
OpPainter * painter = bitmap->GetPainter();
if (painter->Supports(OpPainter::SUPPORTS_ALPHA))
painter->DrawBitmapClippedAlpha(bg_bitmap.get(), source, OpPoint(0, 0));
else
painter->DrawBitmapClipped(bg_bitmap.get(), source, OpPoint(0, 0));
}
}
bitmap_rect.x = 0;
bitmap_rect.y = 0;
bitmap_rect.width = rect.width;
bitmap_rect.height = rect.height;
if (OpPainter *bitmap_painter = bitmap->GetPainter())
{
bitmap_painter->SetRenderingHint(painter->GetRenderingHint());
bitmap->ReleasePainter();
}
// When using vega oppainter the filters and the painter is always in the same color format
#ifndef VEGA_OPPAINTER_SUPPORT
// We must have a 32 bit bitmap since we assume it's 32 bit in ApplyEffectInternal and EndBackbuffer. Anything else will crash!
// Ideally, we should have a BOOL must_be_32bit in OpBitmap::Create (or a prettier API design)
OP_ASSERT(bitmap->GetBpp() == 32);
if (bitmap->GetBpp() != 32)
return OpStatus::ERR;
#endif // !VEGA_OPPAINTER_SUPPORT
if (replace_color)
{
UINT32 color = REALLY_UGLY_COLOR;
if (!bitmap->SetColor((UINT8*)&color, TRUE, &bitmap_rect))
RETURN_IF_ERROR(ClearBitmap(bitmap, color, bitmap_rect));
bitmap->ForceAlpha();
}
else if (!has_background)
{
if (!bitmap->SetColor(NULL, TRUE, &bitmap_rect))
RETURN_IF_ERROR(ClearBitmap(bitmap, 0, bitmap_rect));
}
this->opacity = opacity;
this->replace_color = replace_color;
return OpStatus::OK;
}
int main()
{
InitializeSystem();
SysTick_Config(HCLKFrequency()/100);
InitializeLEDs();
SetLEDs(0x01);
uint8_t *framebuffer1=(uint8_t *)0x20000000;
uint8_t *framebuffer2=(uint8_t *)0x20010000;
SetLEDs(0x03);
memset(framebuffer1,0,320*200);
memset(framebuffer2,0,320*200);
SetLEDs(0x07);
IntializeVGAScreenMode320x200(framebuffer1);
#define NumberOfStars 1050
static struct Star
{
int x,y,dx,f;
} stars[NumberOfStars];
for(int i=0;i<NumberOfStars;i++)
{
stars[i].x=(RandomInteger()%352-16)<<12;
stars[i].y=RandomInteger()%200;
int z=sqrti((NumberOfStars-1-i)*NumberOfStars)*1000/NumberOfStars;
stars[i].dx=6000*1200/(z+200);
stars[i].f=(6-(z*7)/1000)+(RandomInteger()%6)*7;
}
const RLEBitmap *sprites[7*6]={
&Star1_0,&Star2_0,&Star3_0,&Star4_0,&Star5_0,&Star6_0,&Star7_0,
&Star1_1,&Star2_1,&Star3_1,&Star4_1,&Star5_1,&Star6_1,&Star7_1,
&Star1_2,&Star2_2,&Star3_2,&Star4_2,&Star5_2,&Star6_2,&Star7_2,
&Star1_3,&Star2_3,&Star3_3,&Star4_3,&Star5_3,&Star6_3,&Star7_3,
&Star1_4,&Star2_4,&Star3_4,&Star4_4,&Star5_4,&Star6_4,&Star7_4,
&Star1_5,&Star2_5,&Star3_5,&Star4_5,&Star5_5,&Star6_5,&Star7_5,
};
Bitmap frame1,frame2;
InitializeBitmap(&frame1,320,200,320,framebuffer1);
InitializeBitmap(&frame2,320,200,320,framebuffer2);
int frame=0;
while(1)
{
WaitVBL();
Bitmap *currframe;
if(frame&1) { currframe=&frame2; SetFrameBuffer(framebuffer1); }
else { currframe=&frame1; SetFrameBuffer(framebuffer2); }
ClearBitmap(currframe);
for(int i=0;i<NumberOfStars;i++)
{
DrawRLEBitmap(currframe,sprites[stars[i].f],
(stars[i].x>>12)-16,stars[i].y-16);
stars[i].x-=stars[i].dx;
if(stars[i].x<=-16<<12)
{
stars[i].x=(320+16)<<12;
stars[i].y=RandomInteger()%200;
stars[i].f=(stars[i].f%7)+(RandomInteger()%6)*7;
}
}
frame++;
}
}
/**
* Init the screen
*/
void TViewBoard::ScreenInit()
{
char s[64];//, track_name[16], * psz;
iMaxCarsShown = (int)((m_SizeY-BOARD_Y-16)/8); // 8 pixel for each line, 2 free lines on bottom
if(m_SizeX > 960)
m_bShowMoreInfos = true;
else
m_bShowMoreInfos = false;
ClearBitmap( COLOR_LT_GRAY );
if(m_bShowMoreInfos)
{
DrawStringOpaque(
" time cur time to Laps Laps cur speed best last pit pit pit cur cur late proj. CPU",
1, 1,
oWHITE, oLIGHTGRAY );
DrawStringOpaque(
" Drivers to leader pos next prev d+tog Lead speed avg. Lap Lap num lap time damage fuel m/gl laps time",
1, 10,
oWHITE, oLIGHTGRAY );
}
else
{
DrawStringOpaque(
" time cur time to Laps cur best last pit cur cur CPU",
1, 1,
oWHITE, oLIGHTGRAY );
DrawStringOpaque(
" Drivers to leader pos next prev d+tog speed Lap Lap num damage fuel time",
1, 10,
oWHITE, oLIGHTGRAY );
}
/*
psz = strchr(currentTrack->m_sFileName,'/');
if( psz==NULL )
{
psz=currentTrack->m_sFileName;
}
else
{
psz++;
}
for(i=0; i<8; i++)
{
if(psz[i] == '.' || psz[i] == 0)
{
break;
}
else
{
track_name[i] = psz[i];
}
}
track_name[i] = 0;
*/
sprintf( s,
"Track Length Race Fastest Lap BestView mode");
DrawStringOpaque(s, 1, m_SizeY-16, oWHITE );
sprintf( s, "%-8s %7.2f", currentTrack->m_sShortName , currentTrack->get_track_description().length/5280.0 );
DrawStringOpaque(s, 1, m_SizeY-8 );
}
