static int CompressionSizeRun()
{
int result;
icetStrategy(ICET_STRATEGY_REDUCE);
printstat("Compress depth only.\n");
result = DoCompressionTest(ICET_IMAGE_COLOR_NONE, ICET_IMAGE_DEPTH_FLOAT,
ICET_COMPOSITE_MODE_Z_BUFFER);
printstat("\n\nCompress 8-bit color only.\n");
if (result == TEST_PASSED) {
result = DoCompressionTest(ICET_IMAGE_COLOR_RGBA_UBYTE,
ICET_IMAGE_DEPTH_NONE,
ICET_COMPOSITE_MODE_BLEND);
} else {
DoCompressionTest(ICET_IMAGE_COLOR_RGBA_UBYTE,
ICET_IMAGE_DEPTH_NONE,
ICET_COMPOSITE_MODE_BLEND);
}
printstat("\n\nCompress 32-bit color only.\n");
if (result == TEST_PASSED) {
result = DoCompressionTest(ICET_IMAGE_COLOR_RGBA_FLOAT,
ICET_IMAGE_DEPTH_NONE,
ICET_COMPOSITE_MODE_BLEND);
} else {
DoCompressionTest(ICET_IMAGE_COLOR_RGBA_FLOAT,
ICET_IMAGE_DEPTH_NONE,
ICET_COMPOSITE_MODE_BLEND);
}
printstat("\n\nCompress depth and 8-bit color.\n");
if (result == TEST_PASSED) {
result = DoCompressionTest(ICET_IMAGE_COLOR_RGBA_UBYTE,
ICET_IMAGE_DEPTH_FLOAT,
ICET_COMPOSITE_MODE_Z_BUFFER);
} else {
DoCompressionTest(ICET_IMAGE_COLOR_RGBA_UBYTE,
ICET_IMAGE_DEPTH_FLOAT,
ICET_COMPOSITE_MODE_Z_BUFFER);
}
printstat("\n\nCompress depth and 32-bit color.\n");
if (result == TEST_PASSED) {
result = DoCompressionTest(ICET_IMAGE_COLOR_RGBA_FLOAT,
ICET_IMAGE_DEPTH_FLOAT,
ICET_COMPOSITE_MODE_Z_BUFFER);
} else {
DoCompressionTest(ICET_IMAGE_COLOR_RGBA_FLOAT,
ICET_IMAGE_DEPTH_FLOAT,
ICET_COMPOSITE_MODE_Z_BUFFER);
}
return result;
}
static int BlankTilesRun()
{
int result = TEST_PASSED;
int strategy_index;
glClearColor(0.25f, 0.25f, 0.25f, 0.25f);
icetGLDrawCallback(draw);
icetBoundingBoxd(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5);
/* Turn on blending and colored background collection. Even though in
general this would not work unless you also ordered the compositing, we
just want to make sure we get the right color in empty tiles for this
test. */
icetSetColorFormat(ICET_IMAGE_COLOR_RGBA_FLOAT);
icetSetDepthFormat(ICET_IMAGE_DEPTH_NONE);
icetCompositeMode(ICET_COMPOSITE_MODE_BLEND);
icetEnable(ICET_CORRECT_COLORED_BACKGROUND);
for (strategy_index = 0;
strategy_index < STRATEGY_LIST_SIZE; strategy_index++) {
IceTEnum strategy = strategy_list[strategy_index];
int single_image_strategy_index;
int num_single_image_strategy;
icetStrategy(strategy);
printstat("\n\nUsing %s strategy.\n", icetGetStrategyName());
if (strategy_uses_single_image_strategy(strategy)) {
num_single_image_strategy = SINGLE_IMAGE_STRATEGY_LIST_SIZE;
} else {
/* Set to one since single image strategy does not matter. */
num_single_image_strategy = 1;
}
for (single_image_strategy_index = 0;
single_image_strategy_index < num_single_image_strategy;
single_image_strategy_index++) {
IceTEnum single_image_strategy
= single_image_strategy_list[single_image_strategy_index];
int test_result;
icetSingleImageStrategy(single_image_strategy);
printstat("Using %s single image sub-strategy.\n",
icetGetSingleImageStrategyName());
test_result = BlankTilesDoTest();
if (test_result != TEST_PASSED) {
result = test_result;
}
}
}
return result;
}
static int BackgroundCorrectTryStrategy()
{
int result = TEST_PASSED;
int strategy_idx;
for (strategy_idx = 0; strategy_idx < STRATEGY_LIST_SIZE; strategy_idx++) {
icetStrategy(strategy_list[strategy_idx]);
printstat("Trying strategy %s\n", icetGetStrategyName());
result += BackgroundCorrectTryRender();
}
return result;
}
static int DisplayNoDrawRun(void)
{
int strategy_index;
icetGetIntegerv(ICET_RANK, &global_rank);
icetGetIntegerv(ICET_NUM_PROCESSES, &global_num_proc);
printf("Starting DisplayNoDraw.\n");
global_result = TEST_PASSED;
DisplayNoDrawInit();
for (strategy_index = 0;
strategy_index < STRATEGY_LIST_SIZE; strategy_index++) {
IceTEnum strategy = strategy_list[strategy_index];
int single_image_strategy_index;
int num_single_image_strategy;
icetStrategy(strategy);
printf("\n\nUsing %s strategy.\n", icetGetStrategyName());
if (strategy_uses_single_image_strategy(strategy)) {
num_single_image_strategy = SINGLE_IMAGE_STRATEGY_LIST_SIZE;
} else {
/* Set to one since single image strategy does not matter. */
num_single_image_strategy = 1;
}
for (single_image_strategy_index = 0;
single_image_strategy_index < num_single_image_strategy;
single_image_strategy_index++) {
IceTEnum single_image_strategy
= single_image_strategy_list[single_image_strategy_index];
icetSingleImageStrategy(single_image_strategy);
printf("Using %s single image sub-strategy.\n",
icetGetSingleImageStrategyName());
DisplayNoDrawDoTest();
}
}
return global_result;
}
// ****************************************************************************
// Method: IceTNetworkManager default constructor
//
// Programmer: Tom Fogal
// Creation: June 17, 2008
//
// Modifications:
//
// Tom Fogal, Wed May 18 11:57:34 MDT 2011
// Initialize 'renderings'.
//
// ****************************************************************************
IceTNetworkManager::IceTNetworkManager(void): NetworkManager(), renderings(0)
{
this->comm = icetCreateMPICommunicator(VISIT_MPI_COMM);
DEBUG_ONLY(ICET_CHECK_ERROR);
this->context = icetCreateContext(comm);
DEBUG_ONLY(ICET_CHECK_ERROR);
ICET(icetSetContext(this->context));
DEBUG_ONLY(ICET(icetDiagnostics(ICET_DIAG_FULL)));
ICET(icetStrategy(ICET_STRATEGY_REDUCE));
ICET(icetDrawFunc(render));
ICET(icetDisable(ICET_DISPLAY));
ICET(icetInputOutputBuffers(
ICET_COLOR_BUFFER_BIT | ICET_DEPTH_BUFFER_BIT, /* inputs */
ICET_COLOR_BUFFER_BIT | ICET_DEPTH_BUFFER_BIT /* outputs */
));
DEBUG_ONLY(PR_ICET_MPI);
}
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;
}
avtDataObject_p
IceTNetworkManager::Render(
bool checkThreshold, intVector networkIds,
bool getZBuffer, int annotMode, int windowID,
bool leftEye)
{
int t0 = visitTimer->StartTimer();
DataNetwork *origWorkingNet = workingNet;
avtDataObject_p retval;
EngineVisWinInfo &viswinInfo = viswinMap[windowID];
viswinInfo.markedForDeletion = false;
VisWindow *viswin = viswinInfo.viswin;
std::vector<avtPlot_p>& imageBasedPlots = viswinInfo.imageBasedPlots;
renderings = 0;
TRY
{
this->StartTimer();
RenderSetup(windowID, networkIds, getZBuffer,
annotMode, leftEye, checkThreshold);
bool plotDoingTransparencyOutsideTransparencyActor = false;
for(size_t i = 0 ; i < networkIds.size() ; i++)
{
workingNet = NULL;
UseNetwork(networkIds[i]);
if(this->workingNet->GetPlot()->ManagesOwnTransparency())
{
plotDoingTransparencyOutsideTransparencyActor = true;
}
}
workingNet = NULL;
// We can't easily figure out a compositing order, which IceT requires
// in order to properly composite transparent geometry. Thus if there
// is some transparency, fallback to our parent implementation.
avtTransparencyActor* trans = viswin->GetTransparencyActor();
bool transparenciesExist = trans->TransparenciesExist()
|| plotDoingTransparencyOutsideTransparencyActor;
if (transparenciesExist)
{
debug2 << "Encountered transparency: falling back to old "
"SR / compositing routines." << std::endl;
retval = NetworkManager::RenderInternal();
}
else
{
bool needZB = !imageBasedPlots.empty() ||
renderState.shadowMap ||
renderState.depthCues;
// Confusingly, we need to set the input to be *opposite* of what VisIt
// wants. This is due to (IMHO) poor naming in the IceT case; on the
// input side:
// ICET_DEPTH_BUFFER_BIT set: do Z-testing
// ICET_DEPTH_BUFFER_BIT not set: do Z-based compositing.
// On the output side:
// ICET_DEPTH_BUFFER_BIT set: readback of Z buffer is allowed
// ICET_DEPTH_BUFFER_BIT not set: readback of Z does not work.
// In VisIt's case, we calculated a `need Z buffer' predicate based
// around the idea that we need the Z buffer to do Z-compositing.
// However, IceT \emph{always} needs the Z buffer internally -- the
// flag only differentiates between `compositing' methodologies
// (painter-style or `over' operator) on input.
GLenum inputs = ICET_COLOR_BUFFER_BIT;
GLenum outputs = ICET_COLOR_BUFFER_BIT;
// Scratch all that, I guess. That might be the correct way to go
// about things in the long run, but IceT only gives us back half an
// image if we don't set the depth buffer bit. The compositing is a
// bit wrong, but there's not much else we can do..
// Consider removing the `hack' if a workaround is found.
if (/*hack*/true/*hack*/) // || !this->MemoMultipass(viswin))
{
inputs |= ICET_DEPTH_BUFFER_BIT;
}
if(needZB)
{
outputs |= ICET_DEPTH_BUFFER_BIT;
}
ICET(icetInputOutputBuffers(inputs, outputs));
// If there is a backdrop image, we need to tell IceT so that it can
// composite correctly.
if(viswin->GetBackgroundMode() != AnnotationAttributes::Solid)
{
ICET(icetEnable(ICET_CORRECT_COLORED_BACKGROUND));
}
else
{
ICET(icetDisable(ICET_CORRECT_COLORED_BACKGROUND));
}
if (renderState.renderOnViewer)
{
RenderCleanup();
avtDataObject_p dobj = NULL;
CATCH_RETURN2(1, dobj);
}
debug5 << "Rendering " << viswin->GetNumPrimitives()
<< " primitives." << endl;
int width, height, width_start, height_start;
// This basically gets the width and the height.
// The distinction is for 2D rendering, where we only want the
// width and the height of the viewport.
viswin->GetCaptureRegion(width_start, height_start, width, height,
renderState.viewportedMode);
this->TileLayout(width, height);
CallInitializeProgressCallback(this->RenderingStages());
// IceT mode is different from the standard network manager; we don't
// need to create any compositor or anything: it's all done under the
// hood.
// Whether or not to do multipass rendering (opaque first, translucent
// second) is all handled in the callback; from our perspective, we
// just say draw, read back the image, and post-process it.
// IceT sometimes omits large parts of Curve plots when using the
// REDUCE strategy. Use a different compositing strategy for Curve
// plots to avoid the problem.
if(viswin->GetWindowMode() == WINMODE_CURVE)
ICET(icetStrategy(ICET_STRATEGY_VTREE));
else
ICET(icetStrategy(ICET_STRATEGY_REDUCE));
ICET(icetDrawFunc(render));
ICET(icetDrawFrame());
// Now that we're done rendering, we need to post process the image.
debug3 << "IceTNM: Starting readback." << std::endl;
avtImage_p img = this->Readback(viswin, needZB);
// Now its essentially back to the same behavior as our parent:
// shadows
// depth cueing
// post processing
if (renderState.shadowMap)
this->RenderShadows(img);
if (renderState.depthCues)
this->RenderDepthCues(img);
// If the engine is doing more than just 3D annotations,
// post-process the composited image.
RenderPostProcess(img);
CopyTo(retval, img);
}
RenderCleanup();
}
CATCHALL
{
RenderCleanup();
RETHROW;
}
ENDTRY
workingNet = origWorkingNet;
visitTimer->StopTimer(t0, "Ice-T Render");
return retval;
}
int BlankTiles(int argc, char *argv[])
{
int i, j, x, y;
GLubyte *cb;
int result = TEST_PASSED;
GLint rank, num_proc;
/* To remove warning */
(void)argc;
(void)argv;
icetGetIntegerv(ICET_RANK, &rank);
icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc);
glClearColor(0.0, 0.0, 0.0, 0.0);
icetDrawFunc(draw);
icetBoundingBoxf(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5);
for (i = 0; i < STRATEGY_LIST_SIZE; i++) {
int tile_dim;
icetStrategy(strategy_list[i]);
printf("\n\nUsing %s strategy.\n", icetGetStrategyName());
for (tile_dim = 1; tile_dim*tile_dim <= num_proc; tile_dim++) {
printf("\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++) {
icetAddTile(x*SCREEN_WIDTH, y*SCREEN_HEIGHT,
SCREEN_WIDTH, SCREEN_HEIGHT, y*tile_dim + x);
}
}
printf("Rendering frame.\n");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, tile_dim*2-1, -1, tile_dim*2-1, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
icetDrawFrame();
swap_buffers();
if (rank == 0) {
printf("Rank == 0, tile should have stuff in it.\n");
} else if (rank < tile_dim*tile_dim) {
printf("Checking returned image.\n");
cb = icetGetColorBuffer();
for (j = 0; j < SCREEN_WIDTH*SCREEN_HEIGHT*4; j++) {
if (cb[j] != 0) {
printf("Found bad pixel!!!!!!!!\n");
result = TEST_FAILED;
break;
}
}
} else {
printf("Not a display node. Not testing image.\n");
}
}
}
printf("Cleaning up.\n");
finalize_test(result);
return result;
}
int DisplayNoDraw(int argc, char *argv[])
{
int result = TEST_PASSED;
int i;
GLint rank, num_proc;
/* To remove warning */
(void)argc;
(void)argv;
icetGetIntegerv(ICET_RANK, &rank);
icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc);
printf("Starting DisplayNoDraw.\n");
global_rank = rank;
printf("Setting tile.");
icetResetTiles();
icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
icetDrawFunc(draw);
if (rank == 0) {
icetBoundingBoxf(100.0, 101.0, 100.0, 101.0, 100.0, 101.0);
} else {
icetBoundingBoxf(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_LIGHTING);
glColor4f(1.0, 1.0, 1.0, 1.0);
for (i = 0; i < STRATEGY_LIST_SIZE; i++) {
GLubyte *color_buffer;
icetStrategy(strategy_list[i]);
printf("\n\nUsing %s strategy.\n", icetGetStrategyName());
for (iteration = 0; iteration < num_proc; iteration++) {
printf("Blank tile is rank %d\n", iteration);
icetDrawFrame();
swap_buffers();
if ( (rank == 0)
&& (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. */
&& ((num_proc > 2) || (iteration != 1)) ) {
int p;
int bad_count = 0;
printf("Checking pixels.\n");
color_buffer = icetGetColorBuffer();
for (p = 0; p < SCREEN_WIDTH*SCREEN_HEIGHT*4; p++) {
if (color_buffer[p] != 255) {
char filename[256];
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) {
result = TEST_FAILED;
sprintf(filename, "DisplayNoDraw_%s_%d.ppm",
icetGetStrategyName(), iteration);
write_ppm(filename, color_buffer,
SCREEN_WIDTH, SCREEN_HEIGHT);
break;
}
}
}
}
}
}
finalize_test(result);
return result;
}
int BoundsBehindViewer(int argc, char * argv[])
{
float mat[16];
/* To remove warning */
(void)argc;
(void)argv;
GLint rank;
icetGetIntegerv(ICET_RANK, &rank);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
icetDrawFunc(draw);
icetStrategy(ICET_STRATEGY_REDUCE);
icetBoundingBoxf(-1.0, 1.0, -1.0, 1.0, -0.0, 0.0);
/* 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();
glTranslatef(0.0, 0.0, -1.5);
glRotatef(10.0, 0.0, 1.0, 0.0);
glScalef(10.0, 10.0, 10.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 2.0);
printf("Modelview matrix:\n");
glGetFloatv(GL_MODELVIEW_MATRIX, mat);
PrintMatrix(mat);
printf("Projection matrix:\n");
glGetFloatv(GL_PROJECTION_MATRIX, mat);
PrintMatrix(mat);
/* Other normal OpenGL setup. */
glEnable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glColor3f(1.0, 1.0, 1.0);
/* All the processes have the same data. Go ahead and tell IceT. */
icetDataReplicationGroupColor(0);
icetDrawFrame();
/* Test the resulting image to make sure the polygon was drawn over it. */
if (rank == 0) {
GLuint *cb = (GLuint *)icetGetColorBuffer();
if (cb[0] != 0xFFFFFFFF) {
printf("First pixel in color buffer wrong: 0x%x\n", cb[0]);
finalize_test(TEST_FAILED);
return TEST_FAILED;
}
}
finalize_test(TEST_PASSED);
return TEST_PASSED;
}
