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 icetSingleImageStrategy(IceTEnum strategy)
{
if (icetSingleImageStrategyValid(strategy)) {
icetStateSetInteger(ICET_SINGLE_IMAGE_STRATEGY, strategy);
} else {
icetRaiseError("Invalid single image strategy.", ICET_INVALID_ENUM);
}
}
void icetCompositeMode(IceTEnum mode)
{
if ( (mode != ICET_COMPOSITE_MODE_Z_BUFFER)
&& (mode != ICET_COMPOSITE_MODE_BLEND) ) {
icetRaiseError("Invalid composite mode.", ICET_INVALID_ENUM);
return;
}
icetStateSetInteger(ICET_COMPOSITE_MODE, mode);
}
void icetStrategy(IceTEnum strategy)
{
if (icetStrategyValid(strategy)) {
icetStateSetInteger(ICET_STRATEGY, strategy);
icetStateSetBoolean(ICET_STRATEGY_SUPPORTS_ORDERING,
icetStrategySupportsOrdering(strategy));
} else {
icetRaiseError("Invalid strategy.", ICET_INVALID_ENUM);
}
}
void icetBoundingVertices(GLint size, GLenum type, GLsizei stride,
GLsizei count, const GLvoid *pointer)
{
GLdouble *verts;
int i, j;
if (stride < 1) {
switch (type) {
case ICET_SHORT: stride = size*sizeof(GLshort); break;
case ICET_INT: stride = size*sizeof(GLint); break;
case ICET_FLOAT: stride = size*sizeof(GLfloat); break;
case ICET_DOUBLE: stride = size*sizeof(GLdouble); break;
default:
icetRaiseError("Bad type to icetBoundingVertices.",
ICET_INVALID_VALUE);
return;
}
}
verts = malloc(count*3*sizeof(GLdouble));
for (i = 0; i < count; i++) {
for (j = 0; j < 3; j++) {
switch (type) {
#define castcopy(ptype) \
if (j < size) { \
verts[i*3+j] = ((ptype *)pointer)[i*stride/sizeof(type)+j]; \
} else { \
verts[i*3+j] = 0.0; \
} \
if (size >= 4) { \
verts[i*3+j] /= ((ptype *)pointer)[i*stride/sizeof(type)+4]; \
} \
break;
case ICET_SHORT:
castcopy(GLshort);
case ICET_INT:
castcopy(GLint);
case ICET_FLOAT:
castcopy(GLfloat);
case ICET_DOUBLE:
castcopy(GLdouble);
default:
icetRaiseError("Bad type to icetBoundingVertices.",
ICET_INVALID_VALUE);
free(verts);
return;
}
}
}
icetUnsafeStateSet(ICET_GEOMETRY_BOUNDS, count*3, ICET_DOUBLE, verts);
icetStateSetInteger(ICET_NUM_BOUNDING_VERTS, count);
}
void icetStateResetTiming(void)
{
icetStateSetDouble(ICET_RENDER_TIME, 0.0);
icetStateSetDouble(ICET_BUFFER_READ_TIME, 0.0);
icetStateSetDouble(ICET_BUFFER_WRITE_TIME, 0.0);
icetStateSetDouble(ICET_COMPRESS_TIME, 0.0);
icetStateSetDouble(ICET_COMPARE_TIME, 0.0);
icetStateSetDouble(ICET_COMPOSITE_TIME, 0.0);
icetStateSetDouble(ICET_TOTAL_DRAW_TIME, 0.0);
icetStateSetInteger(ICET_BYTES_SENT, 0);
}
static void drawUseBackgroundColor(const IceTFloat *background_color)
{
IceTUInt background_color_word;
IceTBoolean use_color_blending
= (IceTBoolean)( *(icetUnsafeStateGetInteger(ICET_COMPOSITE_MODE))
== ICET_COMPOSITE_MODE_BLEND);
((IceTUByte *)&background_color_word)[0]
= (IceTUByte)(255*background_color[0]);
((IceTUByte *)&background_color_word)[1]
= (IceTUByte)(255*background_color[1]);
((IceTUByte *)&background_color_word)[2]
= (IceTUByte)(255*background_color[2]);
((IceTUByte *)&background_color_word)[3]
= (IceTUByte)(255*background_color[3]);
icetStateSetFloatv(ICET_TRUE_BACKGROUND_COLOR, 4, background_color);
icetStateSetInteger(ICET_TRUE_BACKGROUND_COLOR_WORD, background_color_word);
if (use_color_blending) {
IceTInt display_tile;
/* We need to correct the background color by zeroing it out at
* blending it back at the end. */
icetStateSetFloatv(ICET_BACKGROUND_COLOR, 4, black);
icetStateSetInteger(ICET_BACKGROUND_COLOR_WORD, 0);
icetGetIntegerv(ICET_TILE_DISPLAYED, &display_tile);
if ( (background_color_word != 0)
&& icetIsEnabled(ICET_CORRECT_COLORED_BACKGROUND) ) {
icetStateSetBoolean(ICET_NEED_BACKGROUND_CORRECTION, ICET_TRUE);
} else {
icetStateSetBoolean(ICET_NEED_BACKGROUND_CORRECTION, ICET_FALSE);
}
} else {
icetStateSetFloatv(ICET_BACKGROUND_COLOR, 4, background_color);
icetStateSetInteger(ICET_BACKGROUND_COLOR_WORD, background_color_word);
icetStateSetBoolean(ICET_NEED_BACKGROUND_CORRECTION, ICET_FALSE);
}
}
void gl_destroy(void)
{
IceTInt icet_texture;
GLuint gl_texture;
icetRaiseDebug("In OpenGL layer destructor.");
icetGetIntegerv(ICET_GL_INFLATE_TEXTURE, &icet_texture);
gl_texture = icet_texture;
if (gl_texture != 0) {
glDeleteTextures(1, &gl_texture);
}
icetStateSetInteger(ICET_GL_INFLATE_TEXTURE, 0);
}
void icetBoundingBoxd(GLdouble x_min, GLdouble x_max,
GLdouble y_min, GLdouble y_max,
GLdouble z_min, GLdouble z_max)
{
GLdouble vertices[8*3];
vertices[3*0+0] = x_min; vertices[3*0+1] = y_min; vertices[3*0+2] = z_min;
vertices[3*1+0] = x_min; vertices[3*1+1] = y_min; vertices[3*1+2] = z_max;
vertices[3*2+0] = x_min; vertices[3*2+1] = y_max; vertices[3*2+2] = z_min;
vertices[3*3+0] = x_min; vertices[3*3+1] = y_max; vertices[3*3+2] = z_max;
vertices[3*4+0] = x_max; vertices[3*4+1] = y_min; vertices[3*4+2] = z_min;
vertices[3*5+0] = x_max; vertices[3*5+1] = y_min; vertices[3*5+2] = z_max;
vertices[3*6+0] = x_max; vertices[3*6+1] = y_max; vertices[3*6+2] = z_min;
vertices[3*7+0] = x_max; vertices[3*7+1] = y_max; vertices[3*7+2] = z_max;
icetStateSetDoublev(ICET_GEOMETRY_BOUNDS, 8*3, vertices);
icetStateSetInteger(ICET_NUM_BOUNDING_VERTS, 8);
}
void icetGLSetReadBuffer(GLenum mode)
{
if (!icetGLIsInitialized()) {
icetRaiseError("IceT OpenGL layer not initialized."
" Call icetGLInitialize.",
ICET_INVALID_OPERATION);
return;
}
if ( (mode == GL_FRONT_LEFT) || (mode == GL_FRONT_RIGHT)
|| (mode == GL_BACK_LEFT) || (mode == GL_BACK_RIGHT)
|| (mode == GL_FRONT) || (mode == GL_BACK)
|| (mode == GL_LEFT) || (mode == GL_RIGHT)
|| ((mode >= GL_AUX0) && (mode < GL_AUX0 + GL_AUX_BUFFERS)) )
{
icetStateSetInteger(ICET_GL_READ_BUFFER, GL_BACK);
} else {
icetRaiseError("Invalid OpenGL read buffer.", ICET_INVALID_ENUM);
}
}
void icetGLInitialize(void)
{
if (icetGLIsInitialized()) {
icetRaiseWarning("icetGLInitialize called multiple times.",
ICET_INVALID_OPERATION);
}
icetStateSetBoolean(ICET_GL_INITIALIZED, ICET_TRUE);
icetGLSetReadBuffer(GL_BACK);
icetStateSetPointer(ICET_GL_DRAW_FUNCTION, NULL);
icetStateSetInteger(ICET_GL_INFLATE_TEXTURE, 0);
icetEnable(ICET_GL_DISPLAY);
icetDisable(ICET_GL_DISPLAY_COLORED_BACKGROUND);
icetDisable(ICET_GL_DISPLAY_INFLATE);
icetEnable(ICET_GL_DISPLAY_INFLATE_WITH_HARDWARE);
icetStateSetPointer(ICET_RENDER_LAYER_DESTRUCTOR, gl_destroy);
}
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();
}
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();
}
