/* * This example illustrates annotated GMRFB-to-screen blits. * Annotations are a way to give the device extra information about * the data in a blit. In this case, we're guaranteeing that the * contents of the blit are the result of a fill or copy operation. * * This example cheats a bit, and it actually lies to the SVGA device * in its annotations. This lets you see whether the annotations are * working or not- if the host uses the blit data we supply, we'll see * one result. If it uses the annotation, we'll see something * different. * * This example requires SVGA Screen Object support. */ #include "svga.h" #include "gmr.h" #include "screen.h" #include "intr.h" #include "screen.h" #include "screendraw.h" #include "math.h" #include "mt19937ar.h" #include "timer.h" #define GMRID_SCREEN_DRAW 0 #define GMRID_NOISE 1 #define FRAME_RATE 60 #define SCREEN_ID 0 static volatile uint32 timerTick; /* * prepareNoiseRect -- * * Prepare some noise as the source for a blit. * This defines the GMRFB, and generates a random source origin. */ static void prepareNoiseRect(SVGASignedPoint *origin) // OUT { const uint32 bytesPerLine = 1024; static const SVGAGMRImageFormat format = {{{ 32, 24 }}}; const SVGAGuestPtr gPtr = { GMRID_NOISE, 0 }; const uint32 rand = genrand_int32(); Screen_DefineGMRFB(gPtr, bytesPerLine, format); origin->x = rand & 0x7F; origin->y = (rand >> 8) & 0x7F; } /* * updateBorders -- * * Clean up after the previous frame of animation, and draw the * white border around the current frame. */ static void updateBorders(const SVGASignedRect *pOld, const SVGASignedRect *pNew) { const uint32 color = 0; SVGASignedRect newRect = *pNew; /* * Outset each rectangle by one pixel, to make room for the border. */ newRect.left--; newRect.right++; newRect.top--; newRect.bottom++; /* * Draw the white borders */ ScreenDraw_Border(newRect.left, newRect.top, newRect.right, newRect.bottom, 0xFFFFFF, 1); /* * Clear any pixels from 'oldRect' that are not in 'newRect'. */ if (pOld) { SVGASignedRect oldRect = *pOld; oldRect.left--; oldRect.right++; oldRect.top--; oldRect.bottom++; /* Clear the right edge */ if (newRect.right < oldRect.right) { ScreenDraw_Rectangle(newRect.right, oldRect.top, oldRect.right, oldRect.bottom, color); } /* Clear the left edge */ if (newRect.left > oldRect.left) { ScreenDraw_Rectangle(oldRect.left, oldRect.top, newRect.left, oldRect.bottom, color); } /* Clear the top edge */ if (newRect.top > oldRect.top) { ScreenDraw_Rectangle(oldRect.left, oldRect.top, oldRect.right, newRect.top, color); } /* Clear the bottom edge */ if (newRect.bottom < oldRect.bottom) { ScreenDraw_Rectangle(oldRect.left, newRect.bottom, oldRect.right, oldRect.bottom, color); } } } /* * updateFillRect -- * * Animate the test rectangle which demonstrates fill annotations. */ static void updateFillRect(const SVGASignedRect *oldRect, const SVGASignedRect *newRect) { SVGASignedPoint srcOrigin; static const SVGAColorBGRX color = {{{ 0xFF, 0xCC, 0xCC }}}; // Light blue prepareNoiseRect(&srcOrigin); Screen_AnnotateFill(color); Screen_BlitFromGMRFB(&srcOrigin, newRect, SCREEN_ID); updateBorders(oldRect, newRect); } /* * updateCopyRect -- * * Animate the test rectangle which demonstrates copy annotations. */ static void updateCopyRect(const SVGASignedRect *oldRect, const SVGASignedRect *newRect) { /* * The first time through, draw a checkerboard test pattern. * On subsequent frames, annotate a copy of it from the previous frame. */ if (oldRect) { SVGASignedPoint noiseSrc, copySrc; prepareNoiseRect(&noiseSrc); copySrc.x = oldRect->left; copySrc.y = oldRect->top; Screen_AnnotateCopy(©Src, SCREEN_ID); Screen_BlitFromGMRFB(&noiseSrc, newRect, SCREEN_ID); } else { ScreenDraw_Checkerboard(newRect->left, newRect->top, newRect->right, newRect->bottom); } updateBorders(oldRect, newRect); } /* * allocNoise -- * * Allocates a new GMR, and fills it with random noise. */ static void allocNoise(void) { const uint32 numPages = 500; const uint32 numWords = numPages * PAGE_SIZE / sizeof(uint32); PPN pages = GMR_DefineContiguous(GMRID_NOISE, numPages); uint32 *ptr = PPN_POINTER(pages); int i; init_genrand(0); for (i = 0; i < numWords; i++) { ptr[i] = genrand_int32(); } } /* * timerISR -- * * Trivial timer ISR, just increments our tick counter. */ void timerISR(int vector) { timerTick++; } /* * main -- * * Initialization and main loop. */ int main(void) { uint32 frame = 0; uint32 lastTick = 0; Intr_Init(); Intr_SetFaultHandlers(SVGA_DefaultFaultHandler); Timer_InitPIT(PIT_HZ / FRAME_RATE); Intr_SetMask(PIT_IRQ, TRUE); Intr_SetHandler(IRQ_VECTOR(PIT_IRQ), timerISR); SVGA_Init(); GMR_Init(); Heap_Reset(); SVGA_SetMode(0, 0, 32); Screen_Init(); ScreenDraw_Init(GMRID_SCREEN_DRAW); allocNoise(); /* * Define a screen. */ SVGAScreenObject myScreen = { .structSize = sizeof(SVGAScreenObject), .id = SCREEN_ID, .flags = SVGA_SCREEN_HAS_ROOT | SVGA_SCREEN_IS_PRIMARY, .size = { 800, 600 }, .root = { 0, 0 }, }; Screen_Define(&myScreen); /* * Draw some explanatory text. */ char docString[] = "Annotated Blit Sample:" "\n\n" "You should see two moving rectangles. The left one is animated " "using a fill-annotated blit. The blit itself contains random " "noise, but the annotation is a blue fill. If your host is " "using the annotation, you will see the blue. If not, you'll " "see noise. Either one is correct, but it is often more efficient " "to use the fill." "\n\n" "The right one is a copy-annotated blit. The blit data is again " "random noise, and the copy is a screen-to-screen copy which " "moves the rectangle from its old position to the new position. " "We drew a checkerboard pattern to the screen once, and that " "pattern should be preserved indefinitely if the annotation is " "being executed correctly." "\n\n" "Both rectangles should have a 1-pixel solid white border, and " "in both cases we use a fill-annotated blit to clear the screen " "behind each rectangle. This annotation doesn't lie, its blit data " "matches the advertised fill color."; ScreenDraw_SetScreen(myScreen.id, myScreen.size.width, myScreen.size.height); Console_Clear(); ScreenDraw_WrapText(docString, 770); Console_WriteString(docString); /* * Animate the two rectangles indefinitely, sleeping between frames. */ while (1) { SVGASignedRect oldRect1, oldRect2; SVGASignedRect newRect1, newRect2; /* * Move them around in a circle. */ float theta = frame * 0.01; newRect1.left = 190 + cosf(theta) * 60; newRect1.top = 350 + sinf(theta) * 60; newRect1.right = newRect1.left + 80; newRect1.bottom = newRect1.top + 120; newRect2.left = 530 + sinf(theta) * 60; newRect2.top = 350 + cosf(theta) * 60; newRect2.right = newRect2.left + 80; newRect2.bottom = newRect2.top + 120; /* * Update the position of each. */ updateFillRect(frame ? &oldRect1 : NULL, &newRect1); updateCopyRect(frame ? &oldRect2 : NULL, &newRect2); oldRect1 = newRect1; oldRect2 = newRect2; /* * Wait for the next timer tick. */ while (timerTick == lastTick) { Intr_Halt(); } lastTick = timerTick; frame++; } return 0; }