Commit 5c765fa1 authored by Kenneth Moreland's avatar Kenneth Moreland

Add test to make sure floating viewport really only renders once.

parent c92b286d
......@@ -45,6 +45,7 @@ ENDIF (NOT ICET_TESTS_USE_OPENGL)
SET(MyTests
BackgroundCorrect.c
CompressionSize.c
FloatingViewport.c
Interlace.c
MaxImageSplit.c
OddImageSizes.c
......@@ -67,6 +68,15 @@ ENDIF (ICET_TESTS_USE_OPENGL)
SET(UTIL_SRCS init.c ppm.c)
SET(TEST_HEADERS
test_codes.h
test-util.h
mpi_comm.h
)
SET_SOURCE_FILES_PROPERTIES(${TEST_HEADERS}
PROPERTIES HEADER_ONLY TRUE
)
CONFIGURE_FILE(
${CMAKE_CURRENT_SOURCE_DIR}/test-config.h.in
${CMAKE_CURRENT_BINARY_DIR}/test-config.h
......@@ -81,7 +91,7 @@ CREATE_TEST_SOURCELIST(Tests icetTests_mpi.c ${MyTests}
EXTRA_INCLUDE mpi_comm.h
FUNCTION init_mpi_comm)
ADD_EXECUTABLE(icetTests_mpi ${Tests} ${UTIL_SRCS})
ADD_EXECUTABLE(icetTests_mpi ${Tests} ${UTIL_SRCS} ${TEST_HEADERS})
TARGET_LINK_LIBRARIES(icetTests_mpi
IceTCore
IceTMPI
......
/* -*- c -*- *****************************************************************
** Copyright (C) 2014 Sandia Corporation
** Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
** the U.S. Government retains certain rights in this software.
**
** This source code is released under the New BSD License.
**
** This test makes sure that the floating viewport feature is working as
** expected. It will make sure that the render is called only once for the
** floating viewport and that the image gets renderd correctly.
*****************************************************************************/
#include <IceT.h>
#include "test_codes.h"
#include "test-util.h"
#include <IceTDevCommunication.h>
#include <IceTDevMatrix.h>
#include <stdlib.h>
#include <stdio.h>
static const IceTFloat g_background_color[4] = { 0.5, 0.5, 0.5, 1.0 };
static const IceTFloat g_foreground_color[4] = { 0.0, 0.25, 0.5, 1.0 };
static IceTInt g_num_render_callbacks;
static IceTBoolean ColorsEqual(const IceTFloat *color1, const IceTFloat *color2)
{
IceTBoolean result;
result = (color1[0] == color2[0]);
result &= (color1[1] == color2[1]);
result &= (color1[2] == color2[2]);
result &= (color1[3] == color2[3]);
return result;
}
static IceTBoolean CheckPixel(const IceTImage image,
IceTSizeType pixel,
const IceTFloat *expected_color)
{
const IceTFloat *colors = icetImageGetColorcf(image);
if (!ColorsEqual(colors + 4*pixel, expected_color)) {
IceTUByte *buffer;
IceTInt rank;
char filename[255];
printrank("BAD PIXEL %d\n", pixel);
printrank(" Expected %f %f %f %f\n",
expected_color[0],
expected_color[1],
expected_color[2],
expected_color[3]);
printrank(" Got %f %f %f %f\n",
colors[4*pixel + 0],
colors[4*pixel + 1],
colors[4*pixel + 2],
colors[4*pixel + 3]);
buffer = malloc(4*icetImageGetWidth(image)*icetImageGetHeight(image));
icetImageCopyColorub(image, buffer, ICET_IMAGE_COLOR_RGBA_UBYTE);
icetGetIntegerv(ICET_RANK, &rank);
sprintf(filename, "FloatingViewport_%d.ppm", rank);
write_ppm(filename,
buffer,
icetImageGetWidth(image),
icetImageGetHeight(image));
free(buffer);
return ICET_FALSE;
} else {
return ICET_TRUE;
}
}
static void RenderFloatingViewport(const IceTDouble *projection_matrix,
const IceTDouble *modelview_matrix,
const IceTFloat *background_color,
const IceTInt *readback_viewport,
IceTImage result)
{
IceTSizeType width;
IceTSizeType height;
IceTFloat *colors;
/* To remove warning. */
(void)projection_matrix;
(void)modelview_matrix;
(void)background_color;
printrank("Rendering viewport %d %d %d %d\n",
readback_viewport[0],
readback_viewport[1],
readback_viewport[2],
readback_viewport[3]);
g_num_render_callbacks++;
width = icetImageGetWidth(result);
height = icetImageGetHeight(result);
colors = icetImageGetColorf(result);
/* Set all pixels in the readback_viewport. IceT will ignore the rest. */
{
IceTSizeType line_start = width*readback_viewport[1];
IceTSizeType line;
for (line = 0; line < readback_viewport[3]; line++) {
IceTSizeType pixel = line_start + readback_viewport[0];
IceTSizeType column;
for (column = 0; column < readback_viewport[2]; column++) {
colors[4*pixel + 0] = g_foreground_color[0];
colors[4*pixel + 1] = g_foreground_color[1];
colors[4*pixel + 2] = g_foreground_color[2];
colors[4*pixel + 3] = g_foreground_color[3];
pixel++;
}
line_start += width;
}
}
}
static void FloatingViewportSetupRender()
{
icetCompositeMode(ICET_COMPOSITE_MODE_BLEND);
icetSetColorFormat(ICET_IMAGE_COLOR_RGBA_FLOAT);
icetSetDepthFormat(ICET_IMAGE_DEPTH_NONE);
icetDisable(ICET_ORDERED_COMPOSITE);
icetEnable(ICET_CORRECT_COLORED_BACKGROUND);
/* The strategy should not matter for this test. */
icetStrategy(ICET_STRATEGY_SEQUENTIAL);
icetDrawCallback(RenderFloatingViewport);
icetResetTiles();
icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
icetAddTile(SCREEN_WIDTH, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 1);
}
static void FloatingViewportGetMatrices(IceTDouble *projection_matrix,
IceTDouble *modelview_matrix)
{
/* Identity matrices make it easy to predict where geometry is projected. */
icetMatrixIdentity(projection_matrix);
icetMatrixIdentity(modelview_matrix);
/* The geometry is a square straddling the two tiles. */
icetBoundingBoxd(-0.25, 0.25, -0.5, 0.5, -0.5, 0.5);
}
static IceTBoolean FloatingViewportCheckImage(const IceTImage image)
{
IceTInt rank;
IceTSizeType pixel;
IceTSizeType count;
IceTSizeType width;
IceTSizeType height;
icetGetIntegerv(ICET_RANK, &rank);
/* Display ranks are 0 and 1. */
if (rank > 1) { return ICET_TRUE; }
width = icetImageGetWidth(image);
height = icetImageGetHeight(image);
/* Not that in these checks we avoid problems with floating point
* inaccuracies by only checking parts well within regions. For example,
* we expect the bottom 25% of an image to be background, but we only
* check the bottom 20%. */
/* Bottom 25% of both images should be background. */
pixel = 0;
for (count = 0; count < width*(height/5); count++) {
if (!CheckPixel(image, pixel, g_background_color)) {return ICET_FALSE;}
pixel++;
}
/* Top 25% of both images should be background. */
pixel = width*(4*height/5);
for (count = 0; count < width*(height/5); count++) {
if (!CheckPixel(image, pixel, g_background_color)) {return ICET_FALSE;}
pixel++;
}
/* In the middle 50%, the left 75% is background on rank 0 and the right
* 75% is background on rank 1. */
pixel = width*(2*height/5);
if (rank == 1) { pixel += width - 3*width/5; }
for (count = 0; count < height/5; count++) {
IceTSizeType count2;
for (count2 = 0; count2 < 3*width/5; count2++) {
if (!CheckPixel(image, pixel+count2, g_background_color)) {
return ICET_FALSE;
}
}
pixel += width;
}
/* In the middle 50%, the right 25% is foreground on rank 0 and the left
* 25% is foreground on rank 1. */
pixel = width*(2*height/5);
if (rank == 0) { pixel += width - width/5; }
for (count = 0; count < height/5; count++) {
IceTSizeType count2;
for (count2 = 0; count2 < width/5; count2++) {
if (!CheckPixel(image, pixel+count2, g_foreground_color)) {
return ICET_FALSE;
}
}
pixel += width;
}
return ICET_TRUE;
}
static IceTBoolean FloatingViewportTryRender()
{
IceTDouble projection_matrix[16];
IceTDouble modelview_matrix[16];
IceTImage image;
FloatingViewportSetupRender();
FloatingViewportGetMatrices(projection_matrix, modelview_matrix);
g_num_render_callbacks = 0;
image = icetDrawFrame(projection_matrix,
modelview_matrix,
g_background_color);
if (g_num_render_callbacks != 1) {
printrank("**** Rendering callback not called expected number of times. ****\n");
printrank("Expected 1 call, got %d\n", g_num_render_callbacks);
return ICET_FALSE;
}
return FloatingViewportCheckImage(image);
}
static int FloatingViewportTryMultipleRenders()
{
IceTBoolean success = ICET_TRUE;
IceTInt trial;
for (trial = 0; trial < 5; trial++) {
printstat("Trial render %d\n", trial);
success &= FloatingViewportTryRender();
}
if (success) {
return TEST_PASSED;
} else {
return TEST_FAILED;
}
}
static int FloatingViewportRun(void)
{
IceTInt num_proc;
/* Check to make sure floating viewport is on by default. */
if (!icetIsEnabled(ICET_FLOATING_VIEWPORT)) {
printstat("The floating viewport option is not on by default.");
return TEST_FAILED;
}
icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc);
if (num_proc < 2) {
printf("Need at least two processes to run FloatingViewport test.");
return TEST_NOT_RUN;
}
return FloatingViewportTryMultipleRenders();
}
int FloatingViewport(int argc, char *argv[])
{
/* To remove warning. */
(void)argc;
(void)argv;
return run_test(FloatingViewportRun);
}
......@@ -6,7 +6,7 @@
** This source code is released under the New BSD License.
**
** This tests the ICET_RENDER_EMPTY_IMAGES option. It makes sure that the
** render callback is invoked even if the option and on and not if the option
** render callback is invoked even if the option is on and not if the option
** is off.
*****************************************************************************/
......@@ -170,7 +170,7 @@ static int RenderEmptyCheckImage(const IceTImage image)
g_background_color[1],
g_background_color[2],
g_background_color[3]);
return ICET_FALSE;
return TEST_FAILED;
}
}
}
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment