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