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;
}
