void icetStateSetDefaults(void)
{
GLint *int_array;
int i;
icetDiagnostics(ICET_DIAG_ALL_NODES | ICET_DIAG_WARNINGS);
icetStateSetInteger(ICET_RANK, ICET_COMM_RANK());
icetStateSetInteger(ICET_NUM_PROCESSES, ICET_COMM_SIZE());
icetStateSetInteger(ICET_ABSOLUTE_FAR_DEPTH, 1);
/*icetStateSetInteger(ICET_ABSOLUTE_FAR_DEPTH, 0xFFFFFFFF);*/
icetStateSetFloatv(ICET_BACKGROUND_COLOR, 4, black);
icetStateSetInteger(ICET_BACKGROUND_COLOR_WORD, 0);
icetResetTiles();
icetStateSetIntegerv(ICET_DISPLAY_NODES, 0, NULL);
icetStateSetDoublev(ICET_GEOMETRY_BOUNDS, 0, NULL);
icetStateSetInteger(ICET_NUM_BOUNDING_VERTS, 0);
icetStateSetPointer(ICET_STRATEGY_COMPOSE, NULL);
icetInputOutputBuffers(ICET_COLOR_BUFFER_BIT | ICET_DEPTH_BUFFER_BIT,
ICET_COLOR_BUFFER_BIT);
int_array = malloc(ICET_COMM_SIZE() * sizeof(GLint));
for (i = 0; i < ICET_COMM_SIZE(); i++) {
int_array[i] = i;
}
icetStateSetIntegerv(ICET_COMPOSITE_ORDER, ICET_COMM_SIZE(), int_array);
icetStateSetIntegerv(ICET_PROCESS_ORDERS, ICET_COMM_SIZE(), int_array);
free(int_array);
icetStateSetInteger(ICET_DATA_REPLICATION_GROUP, ICET_COMM_RANK());
icetStateSetInteger(ICET_DATA_REPLICATION_GROUP_SIZE, 1);
icetStateSetPointer(ICET_DRAW_FUNCTION, NULL);
icetStateSetInteger(ICET_READ_BUFFER, GL_BACK);
#ifdef _WIN32
icetStateSetInteger(ICET_COLOR_FORMAT, GL_BGRA_EXT);
#else
icetStateSetInteger(ICET_COLOR_FORMAT, GL_RGBA);
#endif
icetStateSetInteger(ICET_FRAME_COUNT, 0);
icetEnable(ICET_FLOATING_VIEWPORT);
icetDisable(ICET_ORDERED_COMPOSITE);
icetDisable(ICET_CORRECT_COLORED_BACKGROUND);
icetEnable(ICET_DISPLAY);
icetDisable(ICET_DISPLAY_COLORED_BACKGROUND);
icetDisable(ICET_DISPLAY_INFLATE);
icetEnable(ICET_DISPLAY_INFLATE_WITH_HARDWARE);
icetStateSetBoolean(ICET_IS_DRAWING_FRAME, 0);
icetStateSetPointer(ICET_COLOR_BUFFER, NULL);
icetStateSetPointer(ICET_DEPTH_BUFFER, NULL);
icetStateSetBoolean(ICET_COLOR_BUFFER_VALID, 0);
icetStateSetBoolean(ICET_DEPTH_BUFFER_VALID, 0);
icetStateResetTiming();
}
void icetResetTiles(void)
{
GLint iarray[4];
icetStateSetInteger(ICET_NUM_TILES, 0);
icetStateSetIntegerv(ICET_TILE_VIEWPORTS, 0, NULL);
icetStateSetInteger(ICET_TILE_DISPLAYED, -1);
icetStateSetIntegerv(ICET_DISPLAY_NODES, 0, NULL);
iarray[0] = 0; iarray[1] = 0; iarray[2] = 0; iarray[3] = 0;
icetStateSetIntegerv(ICET_GLOBAL_VIEWPORT, 4, iarray);
icetStateSetInteger(ICET_TILE_MAX_WIDTH, 0);
icetStateSetInteger(ICET_TILE_MAX_HEIGHT, 0);
icetStateSetInteger(ICET_TILE_MAX_PIXELS, 0);
}
void icetDataReplicationGroup(IceTInt size, const IceTInt *processes)
{
IceTInt rank;
IceTBoolean found_myself = ICET_FALSE;
IceTInt i;
icetGetIntegerv(ICET_RANK, &rank);
for (i = 0; i < size; i++) {
if (processes[i] == rank) {
found_myself = ICET_TRUE;
break;
}
}
if (!found_myself) {
icetRaiseError("Local process not part of data replication group.",
ICET_INVALID_VALUE);
return;
}
icetStateSetIntegerv(ICET_DATA_REPLICATION_GROUP_SIZE, 1, &size);
icetStateSetIntegerv(ICET_DATA_REPLICATION_GROUP, size, processes);
}
static void drawCollectTileInformation(void)
{
IceTBoolean *all_contained_masks;
IceTInt num_proc;
IceTInt num_tiles;
icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc);
icetGetIntegerv(ICET_NUM_TILES, &num_tiles);
all_contained_masks
= icetStateAllocateBoolean(ICET_ALL_CONTAINED_TILES_MASKS,
num_tiles*num_proc);
icetRaiseDebug("Gathering rendering information.");
{
const IceTBoolean *contained_mask;
contained_mask = icetUnsafeStateGetBoolean(ICET_CONTAINED_TILES_MASK);
icetCommAllgather(contained_mask, num_tiles, ICET_BYTE,
all_contained_masks);
}
{
IceTInt *contrib_counts;
IceTInt total_image_count;
IceTInt tile_id;
contrib_counts
= icetStateAllocateInteger(ICET_TILE_CONTRIB_COUNTS, num_tiles);
total_image_count = 0;
for (tile_id = 0; tile_id < num_tiles; tile_id++) {
IceTInt proc_id;
contrib_counts[tile_id] = 0;
for (proc_id = 0; proc_id < num_proc; proc_id++) {
if (all_contained_masks[proc_id*num_tiles + tile_id]) {
contrib_counts[tile_id]++;
}
}
total_image_count += contrib_counts[tile_id];
}
icetStateSetIntegerv(ICET_TOTAL_IMAGE_COUNT, 1, &total_image_count);
}
}
void icetCompositeOrder(const IceTInt *process_ranks)
{
IceTInt num_proc;
IceTInt i;
IceTInt *process_orders;
icetGetIntegerv(ICET_NUM_PROCESSES, &num_proc);
process_orders = icetStateAllocateInteger(ICET_PROCESS_ORDERS, num_proc);
for (i = 0; i < num_proc; i++) {
process_orders[i] = -1;
}
for (i = 0; i < num_proc; i++) {
process_orders[process_ranks[i]] = i;
}
for (i = 0; i < num_proc; i++) {
if (process_orders[i] == -1) {
icetRaiseError("Invalid composite order.", ICET_INVALID_VALUE);
return;
}
}
icetStateSetIntegerv(ICET_COMPOSITE_ORDER, num_proc, process_ranks);
}
static int DoCompressionTest(IceTEnum color_format, IceTEnum depth_format,
IceTEnum composite_mode)
{
IceTInt viewport[4];
IceTSizeType pixels;
IceTImage image;
IceTVoid *imagebuffer;
IceTSizeType imagesize;
IceTSparseImage compressedimage;
IceTVoid *compressedbuffer;
IceTSparseImage interlacedimage;
IceTVoid *interlacedbuffer;
IceTSizeType compressedsize;
IceTSizeType color_pixel_size;
IceTSizeType depth_pixel_size;
IceTSizeType pixel_size;
IceTSizeType size;
int result;
result = TEST_PASSED;
printstat("Using color format of 0x%x\n", (int)color_format);
printstat("Using depth format of 0x%x\n", (int)depth_format);
printstat("Using composite mode of 0x%x\n", (int)composite_mode);
icetSetColorFormat(color_format);
icetSetDepthFormat(depth_format);
icetCompositeMode(composite_mode);
pixels = SCREEN_WIDTH*SCREEN_HEIGHT;
printstat("Allocating memory for %dx%d pixel image.\n",
(int)SCREEN_WIDTH, (int)SCREEN_HEIGHT);
imagesize = icetImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT);
imagebuffer = malloc(imagesize);
image = icetImageAssignBuffer(imagebuffer, SCREEN_WIDTH, SCREEN_HEIGHT);
compressedsize = icetSparseImageBufferSize(SCREEN_WIDTH, SCREEN_HEIGHT);
compressedbuffer = malloc(compressedsize);
compressedimage = icetSparseImageAssignBuffer(compressedbuffer,
SCREEN_WIDTH,
SCREEN_HEIGHT);
interlacedbuffer = malloc(compressedsize);
interlacedimage = icetSparseImageAssignBuffer(interlacedbuffer,
SCREEN_WIDTH,
SCREEN_HEIGHT);
/* Get the number of bytes per pixel. This is used in checking the
size of compressed images. */
icetImageGetColorVoid(image, &color_pixel_size);
icetImageGetDepthVoid(image, &depth_pixel_size);
pixel_size = color_pixel_size + depth_pixel_size;
printstat("Pixel size: color=%d, depth=%d, total=%d\n",
(int)color_pixel_size, (int)depth_pixel_size, (int)pixel_size);
printstat("\nCreating worst possible image"
" (with respect to compression).\n");
InitPathologicalImage(image);
printstat("Compressing image.\n");
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Interlacing image.\n");
icetSparseImageInterlace(compressedimage,
97,
ICET_SI_STRATEGY_BUFFER_0,
interlacedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("\nCreating a different worst possible image.\n");
InitActiveImage(image);
printstat("Compressing image.\n");
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)compressedsize, (int)size);
if ((size > compressedsize) || (size < pixel_size*pixels)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Interlacing image.\n");
icetSparseImageInterlace(compressedimage,
97,
ICET_SI_STRATEGY_BUFFER_0,
interlacedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)(pixel_size*(pixels/2) + 2*sizeof(IceTUShort)*(pixels/2)),
(int)size);
if ( (size > compressedsize)
|| (size < pixel_size*(pixels/2)) ) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("\nCompressing zero size image.\n");
icetImageSetDimensions(image, 0, 0);
icetCompressImage(image, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)icetSparseImageBufferSize(0, 0), (int)size);
if (size > icetSparseImageBufferSize(0, 0)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
/* This test can be a little volatile. The icetGetCompressedTileImage
* expects certain things to be set correctly by the icetDrawFrame
* function. Since we want to call icetGetCompressedTileImage directly,
* we try to set up these parameters by hand. It is possible for this
* test to incorrectly fail if the two functions are mutually changed and
* this scaffolding is not updated correctly. */
printstat("\nSetup for actual render.\n");
icetResetTiles();
icetAddTile(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
icetDrawCallback(drawCallback);
/* Do a perfunctory draw to set other state variables. */
icetDrawFrame(IdentityMatrix, IdentityMatrix, Black);
viewport[0] = viewport[1] = 0;
viewport[2] = (IceTInt)SCREEN_WIDTH; viewport[3] = (IceTInt)SCREEN_HEIGHT;
icetStateSetIntegerv(ICET_CONTAINED_VIEWPORT, 4, viewport);
printstat("Now render and get compressed image.\n");
icetGetCompressedTileImage(0, compressedimage);
size = icetSparseImageGetCompressedBufferSize(compressedimage);
printstat("Expected size: %d. Actual size: %d\n",
(int)compressedsize, (int)size);
if ((size > compressedsize) || (size < pixel_size*pixels)) {
printrank("*** Size differs from expected size!\n");
result = TEST_FAILED;
}
printstat("Cleaning up.\n");
free(imagebuffer);
free(compressedbuffer);
free(interlacedbuffer);
return result;
}
IceTImage icetDrawFrame(const IceTDouble *projection_matrix,
const IceTDouble *modelview_matrix,
const IceTFloat *background_color)
{
IceTInt frame_count;
IceTImage image;
IceTDouble render_time;
IceTDouble buf_read_time;
IceTDouble compose_time;
IceTDouble total_time;
icetRaiseDebug("In icetDrawFrame");
{
IceTBoolean isDrawing;
icetGetBooleanv(ICET_IS_DRAWING_FRAME, &isDrawing);
if (isDrawing) {
icetRaiseError("Recursive frame draw detected.",
ICET_INVALID_OPERATION);
return icetImageNull();
}
}
icetStateResetTiming();
icetTimingDrawFrameBegin();
icetStateSetDoublev(ICET_PROJECTION_MATRIX, 16, projection_matrix);
icetStateSetDoublev(ICET_MODELVIEW_MATRIX, 16, modelview_matrix);
drawUseBackgroundColor(background_color);
icetGetIntegerv(ICET_FRAME_COUNT, &frame_count);
frame_count++;
icetStateSetIntegerv(ICET_FRAME_COUNT, 1, &frame_count);
drawProjectBounds();
{
IceTEnum strategy;
icetGetEnumv(ICET_STRATEGY, &strategy);
/* drawCollectTileInformation does an allgather to get information
* about the tiles in other processes. These variables are
* ICET_ALL_CONTAINED_TILES_MASKS, ICET_TILE_CONTRIB_COUNTS, and
* ICET_TOTAL_IMAGE_COUNT. However, the sequential strategy ignores
* this information and just uses all processes for all tiles. When
* compositing a single tile, this is a fine strategy and we can save
* a significant proportion of frame time by skipping this step. */
if (strategy != ICET_STRATEGY_SEQUENTIAL) {
drawCollectTileInformation();
}
}
{
IceTInt tile_displayed;
icetGetIntegerv(ICET_TILE_DISPLAYED, &tile_displayed);
if (tile_displayed >= 0) {
const IceTInt *tile_viewports
= icetUnsafeStateGetInteger(ICET_TILE_VIEWPORTS);
IceTInt num_pixels = ( tile_viewports[4*tile_displayed+2]
* tile_viewports[4*tile_displayed+3] );
icetStateSetInteger(ICET_VALID_PIXELS_TILE, tile_displayed);
icetStateSetInteger(ICET_VALID_PIXELS_OFFSET, 0);
icetStateSetInteger(ICET_VALID_PIXELS_NUM, num_pixels);
} else {
icetStateSetInteger(ICET_VALID_PIXELS_TILE, -1);
icetStateSetInteger(ICET_VALID_PIXELS_OFFSET, 0);
icetStateSetInteger(ICET_VALID_PIXELS_NUM, 0);
}
}
image = drawInvokeStrategy();
/* Calculate times. */
icetGetDoublev(ICET_RENDER_TIME, &render_time);
icetGetDoublev(ICET_BUFFER_READ_TIME, &buf_read_time);
icetTimingDrawFrameEnd();
icetGetDoublev(ICET_TOTAL_DRAW_TIME, &total_time);
compose_time = total_time - render_time - buf_read_time;
icetStateSetDouble(ICET_COMPOSITE_TIME, compose_time);
icetStateSetDouble(ICET_BUFFER_WRITE_TIME, 0.0);
icetStateCheckMemory();
return image;
}
static void drawProjectBounds(void)
{
IceTInt num_bounding_verts;
IceTInt *contained_list;
IceTBoolean *contained_mask;
IceTInt contained_viewport[4];
IceTDouble znear, zfar;
IceTInt num_tiles;
IceTInt num_contained;
icetGetIntegerv(ICET_NUM_BOUNDING_VERTS, &num_bounding_verts);
icetGetIntegerv(ICET_NUM_TILES, &num_tiles);
contained_list = icetGetStateBuffer(ICET_CONTAINED_LIST_BUF,
sizeof(IceTInt) * num_tiles);
contained_mask = icetGetStateBuffer(ICET_CONTAINED_MASK_BUF,
sizeof(IceTBoolean)*num_tiles);
if (num_bounding_verts < 1) {
/* User never set bounding vertices. Assume image covers all tiles. */
IceTInt i;
for (i = 0; i < num_tiles; i++) {
contained_list[i] = i;
contained_mask[i] = 1;
}
icetGetIntegerv(ICET_GLOBAL_VIEWPORT, contained_viewport);
znear = -1.0;
zfar = 1.0;
num_contained = num_tiles;
} else {
/* Figure out how the geometry projects onto the display. */
drawFindContainedViewport(contained_viewport, &znear, &zfar);
/* Now use this information to figure out which tiles need to be
drawn. */
drawDetermineContainedTiles(contained_viewport,
znear,
zfar,
contained_list,
contained_mask,
&num_contained);
}
icetRaiseDebug4("contained_viewport = %d %d %d %d",
(int)contained_viewport[0], (int)contained_viewport[1],
(int)contained_viewport[2], (int)contained_viewport[3]);
drawAdjustContainedForDataReplication(contained_viewport,
contained_list,
contained_mask,
&num_contained);
icetRaiseDebug4("new contained_viewport = %d %d %d %d",
(int)contained_viewport[0], (int)contained_viewport[1],
(int)contained_viewport[2], (int)contained_viewport[3]);
icetStateSetIntegerv(ICET_CONTAINED_VIEWPORT, 4, contained_viewport);
icetStateSetDoublev(ICET_NEAR_DEPTH, 1, &znear);
icetStateSetDoublev(ICET_FAR_DEPTH, 1, &zfar);
icetStateSetInteger(ICET_NUM_CONTAINED_TILES, num_contained);
icetStateSetIntegerv(ICET_CONTAINED_TILES_LIST, num_contained,
contained_list);
icetStateSetBooleanv(ICET_CONTAINED_TILES_MASK, num_tiles, contained_mask);
}
int icetAddTile(GLint x, GLint y, GLsizei width, GLsizei height,
int display_rank)
{
GLint num_tiles;
GLint *viewports;
GLint gvp[4];
GLint max_width, max_height;
GLint *display_nodes;
GLint rank;
GLint num_processors;
char msg[256];
int i;
/* Get current number of tiles and viewports. */
icetGetIntegerv(ICET_NUM_TILES, &num_tiles);
viewports = malloc((num_tiles+1)*4*sizeof(GLint));
icetGetIntegerv(ICET_TILE_VIEWPORTS, viewports);
/* Get display node information. */
icetGetIntegerv(ICET_RANK, &rank);
icetGetIntegerv(ICET_NUM_PROCESSES, &num_processors);
display_nodes = malloc((num_tiles+1)*4*sizeof(GLint));
icetGetIntegerv(ICET_DISPLAY_NODES, display_nodes);
/* Check and update display ranks. */
if (display_rank >= num_processors) {
sprintf(msg, "icetDisplayNodes: Invalid rank for tile %d.",
(int)num_tiles);
icetRaiseError(msg, ICET_INVALID_VALUE);
free(viewports);
free(display_nodes);
return -1;
}
for (i = 0; i < num_tiles; i++) {
if (display_nodes[i] == display_rank) {
sprintf(msg, "icetDisplayNodes: Rank %d used for tiles %d and %d.",
display_rank, i, (int)num_tiles);
icetRaiseError(msg, ICET_INVALID_VALUE);
free(viewports);
free(display_nodes);
return -1;
}
}
display_nodes[num_tiles] = display_rank;
icetUnsafeStateSet(ICET_DISPLAY_NODES, num_tiles+1,
ICET_INT, display_nodes);
if (display_rank == rank) {
icetStateSetInteger(ICET_TILE_DISPLAYED, num_tiles);
}
/* Figure out current global viewport. */
gvp[0] = x; gvp[1] = y; gvp[2] = x + width; gvp[3] = y + height;
for (i = 0; i < num_tiles; i++) {
gvp[0] = MIN(gvp[0], viewports[i*4+0]);
gvp[1] = MIN(gvp[1], viewports[i*4+1]);
gvp[2] = MAX(gvp[2], viewports[i*4+0] + viewports[i*4+2]);
gvp[3] = MAX(gvp[3], viewports[i*4+1] + viewports[i*4+3]);
}
gvp[2] -= gvp[0];
gvp[3] -= gvp[1];
/* Add new viewport to current viewports. */
viewports[4*num_tiles+0] = x;
viewports[4*num_tiles+1] = y;
viewports[4*num_tiles+2] = width;
viewports[4*num_tiles+3] = height;
/* Set new state. */
icetStateSetInteger(ICET_NUM_TILES, num_tiles+1);
icetUnsafeStateSet(ICET_TILE_VIEWPORTS, (num_tiles+1)*4,
ICET_INT, viewports);
icetStateSetIntegerv(ICET_GLOBAL_VIEWPORT, 4, gvp);
icetGetIntegerv(ICET_TILE_MAX_WIDTH, &max_width);
max_width = MAX(max_width, width);
icetStateSetInteger(ICET_TILE_MAX_WIDTH, max_width);
icetGetIntegerv(ICET_TILE_MAX_HEIGHT, &max_height);
max_height = MAX(max_height, height);
icetStateSetInteger(ICET_TILE_MAX_HEIGHT, max_height);
/* When storing max pixels, leave some padding so that pixels may be
dropped if the image needs to be divided amongst processors. */
icetStateSetInteger(ICET_TILE_MAX_PIXELS,
max_width*max_height + num_processors);
/* Return index to tile. */
return num_tiles;
}
void icetStateSetDefaults(void)
{
IceTInt *int_array;
int i;
int comm_size, comm_rank;
icetDiagnostics(ICET_DIAG_ALL_NODES | ICET_DIAG_WARNINGS);
comm_size = icetCommSize();
comm_rank = icetCommRank();
icetStateSetInteger(ICET_RANK, comm_rank);
icetStateSetInteger(ICET_NUM_PROCESSES, comm_size);
/* icetStateSetInteger(ICET_ABSOLUTE_FAR_DEPTH, 1); */
/*icetStateSetInteger(ICET_ABSOLUTE_FAR_DEPTH, 0xFFFFFFFF);*/
icetStateSetFloatv(ICET_BACKGROUND_COLOR, 4, black);
icetStateSetInteger(ICET_BACKGROUND_COLOR_WORD, 0);
icetStateSetInteger(ICET_COLOR_FORMAT, ICET_IMAGE_COLOR_RGBA_UBYTE);
icetStateSetInteger(ICET_DEPTH_FORMAT, ICET_IMAGE_DEPTH_FLOAT);
icetResetTiles();
icetStateSetIntegerv(ICET_DISPLAY_NODES, 0, NULL);
icetStateSetDoublev(ICET_GEOMETRY_BOUNDS, 0, NULL);
icetStateSetInteger(ICET_NUM_BOUNDING_VERTS, 0);
icetStateSetInteger(ICET_STRATEGY, ICET_STRATEGY_UNDEFINED);
icetSingleImageStrategy(ICET_SINGLE_IMAGE_STRATEGY_AUTOMATIC);
icetCompositeMode(ICET_COMPOSITE_MODE_Z_BUFFER);
int_array = icetStateAllocateInteger(ICET_COMPOSITE_ORDER, comm_size);
for (i = 0; i < comm_size; i++) {
int_array[i] = i;
}
int_array = icetStateAllocateInteger(ICET_PROCESS_ORDERS, comm_size);
for (i = 0; i < comm_size; i++) {
int_array[i] = i;
}
icetStateSetInteger(ICET_DATA_REPLICATION_GROUP, comm_rank);
icetStateSetInteger(ICET_DATA_REPLICATION_GROUP_SIZE, 1);
icetStateSetInteger(ICET_FRAME_COUNT, 0);
if (getenv("ICET_MAGIC_K") != NULL) {
IceTInt magic_k = atoi(getenv("ICET_MAGIC_K"));
if (magic_k > 1) {
icetStateSetInteger(ICET_MAGIC_K, magic_k);
} else {
icetRaiseError("Environment varible ICET_MAGIC_K must be set"
" to an integer greater than 1.",
ICET_INVALID_VALUE);
icetStateSetInteger(ICET_MAGIC_K, ICET_MAGIC_K_DEFAULT);
}
} else {
icetStateSetInteger(ICET_MAGIC_K, ICET_MAGIC_K_DEFAULT);
}
if (getenv("ICET_MAX_IMAGE_SPLIT") != NULL) {
IceTInt max_image_split = atoi(getenv("ICET_MAX_IMAGE_SPLIT"));
if (max_image_split > 0) {
icetStateSetInteger(ICET_MAX_IMAGE_SPLIT, max_image_split);
} else {
icetRaiseError("Environment variable ICET_MAX_IMAGE_SPLIT must be"
" set to an integer greater than 0.",
ICET_INVALID_VALUE);
icetStateSetInteger(ICET_MAX_IMAGE_SPLIT,
ICET_MAX_IMAGE_SPLIT_DEFAULT);
}
} else {
icetStateSetInteger(ICET_MAX_IMAGE_SPLIT, ICET_MAX_IMAGE_SPLIT_DEFAULT);
}
icetStateSetPointer(ICET_DRAW_FUNCTION, NULL);
icetStateSetPointer(ICET_RENDER_LAYER_DESTRUCTOR, NULL);
icetEnable(ICET_FLOATING_VIEWPORT);
icetDisable(ICET_ORDERED_COMPOSITE);
icetDisable(ICET_CORRECT_COLORED_BACKGROUND);
icetEnable(ICET_COMPOSITE_ONE_BUFFER);
icetEnable(ICET_INTERLACE_IMAGES);
icetEnable(ICET_COLLECT_IMAGES);
icetDisable(ICET_RENDER_EMPTY_IMAGES);
icetStateSetBoolean(ICET_IS_DRAWING_FRAME, 0);
icetStateSetBoolean(ICET_RENDER_BUFFER_SIZE, 0);
icetStateSetInteger(ICET_VALID_PIXELS_TILE, -1);
icetStateSetInteger(ICET_VALID_PIXELS_OFFSET, 0);
icetStateSetInteger(ICET_VALID_PIXELS_NUM, 0);
icetStateResetTiming();
}
