static void DisplayNoDrawDoTest(void) { for (global_iteration = 0; global_iteration < global_num_proc; global_iteration++) { IceTImage image; IceTUByte *color_buffer; printf("Blank image is rank %d\n", global_iteration); image = icetGLDrawFrame(); swap_buffers(); if ( (global_rank == 0) && (global_num_proc > 1) /* This last case covers when there is only 2 processes, * the root, as always, is not drawing anything and the * other process is drawing the clear screen. */ && ((global_num_proc > 2) || (global_iteration != 1)) ) { int p; int bad_count = 0; printf("Checking pixels.\n"); color_buffer = icetImageGetColorub(image); for (p = 0; (p < SCREEN_WIDTH*SCREEN_HEIGHT*4) && (bad_count < 10); p++) { if (color_buffer[p] != 255) { printf("BAD PIXEL %d.%d\n", p/4, p%4); printf(" Expected 255, got %d\n", color_buffer[p]); bad_count++; } } if (bad_count >= 10) { char filename[256]; global_result = TEST_FAILED; sprintf(filename, "DisplayNoDraw_%s_%s_%d.ppm", icetGetStrategyName(), icetGetSingleImageStrategyName(), global_iteration); write_ppm(filename, color_buffer, (int)SCREEN_WIDTH, (int)SCREEN_HEIGHT); break; } } } }
static int SimpleExampleRun() { float angle; /* Normally, the first thing that you do is set up your communication and * then create at least one IceT context. This has already been done in * the calling function (i.e. icetTests_mpi.c). See the init_mpi in * test_mpi.h for an example. */ /* If we had set up the communication layer ourselves, we could have * gotten these parameters directly from it. Since we did not, this * provides an alternate way. */ icetGetIntegerv(ICET_RANK, &rank); icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc); /* We should be able to set any color we want, but we should do it BEFORE * icetGLDrawFrame() is called, not in the callback drawing function. * There may also be limitations on the background color when performing * color blending. */ glClearColor(0.2f, 0.5f, 0.1f, 1.0f); /* Give IceT a function that will issue the OpenGL drawing commands. */ icetGLDrawCallback(draw); /* Give IceT the bounds of the polygons that will be drawn. Note that * we must take into account any transformation that happens within the * draw function (but IceT will take care of any transformation that * happens before icetGLDrawFrame). */ icetBoundingBoxd(-0.5+rank, 0.5+rank, -0.5, 0.5, -0.5, 0.5); /* Set up the tiled display. Normally, the display will be fixed for a * given installation, but since this is a demo, we give two specific * examples. */ if (num_proc < 4) { /* Here is an example of a "1 tile" case. This is functionally * identical to a traditional sort last algorithm. */ icetResetTiles(); icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0); } else { /* Here is an example of a 4x4 tile layout. The tiles are displayed * with the following ranks: * * +---+---+ * | 0 | 1 | * +---+---+ * | 2 | 3 | * +---+---+ * * Each tile is simply defined by grabing a viewport in an infinite * global display screen. The global viewport projection is * automatically set to the smallest region containing all tiles. * * This example also shows tiles abutted against each other. * Mullions and overlaps can be implemented by simply shifting tiles * on top of or away from each other. */ icetResetTiles(); icetAddTile(0, (IceTInt)SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT, 0); icetAddTile((IceTInt)SCREEN_WIDTH, (IceTInt)SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT, 1); icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 2); icetAddTile((IceTInt)SCREEN_WIDTH, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 3); } /* Tell IceT what strategy to use. The REDUCE strategy is an all-around * good performer. */ icetStrategy(ICET_STRATEGY_REDUCE); /* Set up the projection matrix as you normally would. */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-0.75, 0.75, -0.75, 0.75, -0.75, 0.75); /* Other normal OpenGL setup. */ glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); if (rank%8 != 0) { GLfloat color[4]; color[0] = (float)(rank%2); color[1] = (float)((rank/2)%2); color[2] = (float)((rank/4)%2); color[3] = 1.0f; glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color); } /* Here is an example of an animation loop. */ for (angle = 0; angle < 360; angle += 10) { /* We can set up a modelview matrix here and IceT will factor this * in determining the screen projection of the geometry. Note that * there is further transformation in the draw function that IceT * cannot take into account. That transformation is handled in the * application by deforming the bounds before giving them to * IceT. */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotated(angle, 0.0, 1.0, 0.0); glScaled(1.0f/num_proc, 1.0, 1.0); glTranslated(-(num_proc-1)/2.0, 0.0, 0.0); /* Instead of calling draw() directly, call it indirectly through * icetDrawFrame(). IceT will automatically handle image * compositing. */ icetGLDrawFrame(); /* For obvious reasons, IceT should be run in double-buffered frame * mode. After calling icetDrawFrame, the application should do a * synchronize (a barrier is often about as good as you can do) and * then a swap buffers. */ swap_buffers(); } return TEST_PASSED; }
static int BoundsBehindViewerRun() { float mat[16]; IceTImage image; IceTInt rank; icetGetIntegerv(ICET_RANK, &rank); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); icetGLDrawCallback(draw); icetStrategy(ICET_STRATEGY_REDUCE); icetBoundingBoxd(-1.0, 1.0, -1.0, 1.0, -0.0, 0.0); icetSetColorFormat(ICET_IMAGE_COLOR_RGBA_UBYTE); icetSetDepthFormat(ICET_IMAGE_DEPTH_FLOAT); /* We're just going to use one tile. */ icetResetTiles(); icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0); /* Set up the transformation such that the quad in draw should cover the entire screen, but part of it extends behind the viewpoint. Furthermore, a naive division by w will show all points to the right of the screen (which, of course, is wrong). */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslated(0.0, 0.0, -1.5); glRotated(10.0, 0.0, 1.0, 0.0); glScaled(10.0, 10.0, 10.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 2.0); printstat("Modelview matrix:\n"); glGetFloatv(GL_MODELVIEW_MATRIX, mat); PrintMatrix(mat); printstat("Projection matrix:\n"); glGetFloatv(GL_PROJECTION_MATRIX, mat); PrintMatrix(mat); /* Other normal OpenGL setup. */ glEnable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glColor3d(1.0, 1.0, 1.0); /* All the processes have the same data. Go ahead and tell IceT. */ icetDataReplicationGroupColor(0); image = icetGLDrawFrame(); /* Test the resulting image to make sure the polygon was drawn over it. */ if (rank == 0) { IceTUInt *cb = icetImageGetColorui(image); if (cb[0] != 0xFFFFFFFF) { printstat("First pixel in color buffer wrong: 0x%x\n", cb[0]); return TEST_FAILED; } } return TEST_PASSED; }
static int BlankTilesDoTest(void) { int result = TEST_PASSED; int tile_dim; IceTInt rank, num_proc; icetGetIntegerv(ICET_RANK, &rank); icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc); for (tile_dim = 1; tile_dim*tile_dim <= num_proc; tile_dim++) { int x, y; IceTSizeType my_width = -1; IceTSizeType my_height = -1; IceTImage image; printstat("\nRunning on a %d x %d display.\n", tile_dim, tile_dim); icetResetTiles(); for (y = 0; y < tile_dim; y++) { for (x = 0; x < tile_dim; x++) { int tile_rank = y*tile_dim + x; /* Modify the width and height a bit to detect bad image sizes. */ IceTSizeType tile_width = SCREEN_WIDTH - x; IceTSizeType tile_height = SCREEN_HEIGHT - y; icetAddTile((IceTInt)(x*SCREEN_WIDTH), (IceTInt)(y*SCREEN_HEIGHT), tile_width, tile_height, tile_rank); if (tile_rank == rank) { my_width = tile_width; my_height = tile_height; } } } printstat("Rendering frame.\n"); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1, tile_dim*2-1, -1, tile_dim*2-1, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); image = icetGLDrawFrame(); swap_buffers(); if (rank == 0) { /* printrank("Rank == 0, tile should have stuff in it.\n"); */ } else if (rank < tile_dim*tile_dim) { IceTFloat *cb; int color_component; if ( (my_width != icetImageGetWidth(image)) || (my_height != icetImageGetHeight(image)) ) { printrank("Image size is wrong!!!!!!!!!\n"); result = TEST_FAILED; } /* printrank("Checking returned image data.\n"); */ cb = icetImageGetColorf(image); for (color_component = 0; color_component < my_width*my_height*4; color_component++) { if (cb[color_component] != 0.25f) { printrank("Found bad pixel!!!!!!!!\n"); result = TEST_FAILED; break; } } } else { /* printrank("Not a display node. Not testing image.\n"); */ } } return result; }