void recv_set_vert(void)
{
int i = recv_index();
int j = recv_index();
struct object_vert *p = get_object_vert(i, j);
recv_array(p->v, 3, sizeof (float));
recv_array(p->n, 3, sizeof (float));
recv_array(p->u, 2, sizeof (float));
fini_object(i);
}
void recv_set_brush_color(void)
{
int i = recv_index();
struct brush *b = get_brush(i);
recv_array(b->d, 4, sizeof (float));
recv_array(b->s, 4, sizeof (float));
recv_array(b->a, 4, sizeof (float));
recv_array(b->x, 1, sizeof (float));
b->flags = recv_index();
}
void recv_create_brush(void)
{
struct brush *b = get_brush(new_brush());
b->flags = recv_index();
b->count = 1;
b->line_width = 1;
recv_array(b->image, 4, sizeof (int));
recv_array(b->d, 4, sizeof (float));
recv_array(b->s, 4, sizeof (float));
recv_array(b->a, 4, sizeof (float));
recv_array(b->x, 1, sizeof (float));
}
void recv_set_brush_frag_shader(void)
{
int i = recv_index();
int n = recv_index();
struct brush *b = get_brush(i);
fini_brush(i);
/* Free the old fragment program buffer. */
if (b->frag_text)
{
free(b->frag_text);
b->frag_text = NULL;
}
/* Receive the new fragment program buffer. */
if (n > 0)
{
b->frag_text = (char *) malloc(n);
recv_array(b->frag_text, n, 1);
}
}
void recv_set_brush_vert_prog(void)
{
int i = recv_index();
int n = recv_index();
struct brush *b = get_brush(i);
fini_brush(i);
/* Free the old vertex program buffer. */
if (b->vert)
{
free(b->vert);
b->vert = NULL;
}
/* Receive the new vertex program buffer. */
if (n > 0)
{
b->vert = (char *) malloc(n);
recv_array(b->vert, n, 1);
}
}
void recv_create_terrain(void)
{
int i;
if ((i = new_terrain()))
{
char filename[MAXSTR];
int w = recv_value();
int h = recv_value();
int n = recv_value();
int m = recv_value();
int l = recv_value();
recv_array(filename, l + 1, 1);
/* HACK: Clients load data from disk instead of broadcast. */
if (load_terrain(i, filename, w, h))
{
terrain[i].count = 1;
terrain[i].w = w;
terrain[i].h = h;
terrain[i].n = n;
terrain[i].m = m;
terrain[i].o = 3396000;
terrain[i].bias = DEFAULT_BIAS;
terrain[i].magn = DEFAULT_MAGN;
/* Encapsulate this object in an entity. */
recv_create_entity();
}
}
}
void recv_set_edge(void)
{
int i = recv_index();
int j = recv_index();
int k = recv_index();
recv_array(get_object_edge(i, j, k)->vi, 2, sizeof (int));
}
void recv_set_brush_uniform(void)
{
struct brush *b = get_brush(recv_index());
int r = recv_index();
int c = recv_index();
int d = recv_index();
int l = recv_index();
float v[MAX_UNIFORM];
char n[MAX_NAME];
memset(n, 0, MAX_NAME * sizeof (char));
memset(v, 0, MAX_UNIFORM * sizeof (float));
recv_array(n, l, sizeof (char));
recv_array(v, r * c, sizeof (float));
set_brush_uniform(b, n, r, c, d, v);
}
void recv_set_brush_vert_param(void)
{
struct brush *b = get_brush(recv_index());
int p = recv_index();
recv_array(b->vert_param[p], 4, sizeof (float));
if (b->vert_prog && GL_has_vertex_program)
{
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, b->vert_prog);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,
p, b->vert_param[p]);
}
}
void recv_set_brush_frag_param(void)
{
struct brush *b = get_brush(recv_index());
int p = recv_index();
recv_array(b->frag_param[p], 4, sizeof (float));
if (b->frag_prog && GL_has_fragment_program)
{
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, b->frag_prog);
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
p, b->frag_param[p]);
}
}
void recv_add_host(void)
{
char name[MAXNAME];
int n = recv_value();
int x = recv_value();
int y = recv_value();
int w = recv_value();
int h = recv_value();
recv_array(name, n, 1);
add_host(name, x, y, w, h);
}
void recv_create_galaxy(void)
{
struct galaxy *g = get_galaxy(new_galaxy());
g->count = 1;
/* Receive the object header. */
g->brush = recv_index();
g->S_num = recv_index();
g->N_num = recv_index();
/* Receive the stars and BSP nodes. */
g->S = (struct star *) malloc(g->S_num * sizeof (struct star));
g->N = (struct node *) malloc(g->N_num * sizeof (struct node));
recv_array(g->S, g->S_num, sizeof (struct star));
recv_array(g->N, g->N_num, sizeof (struct node));
/* Encapsulate this object in an entity. */
recv_create_entity();
}
void
exch_boundary (Box_t dir, const hydroparam_t H, hydrovar_t * Hv, int tag)
{
int i, j, ivar, size, err;
hydro_real_t sendbuf[ExtraLayerTot * H.nxyt * H.nvar];
hydro_real_t recvbuf[ExtraLayerTot * H.nxyt * H.nvar];
MPI_Status st;
switch (dir)
{
case LEFT_BOX:
i = ExtraLayer;
size = pack_arrayv (i, H, Hv, sendbuf);
fprintf (stderr, "%d WAIT requestW LEFT %d \n", H.mype,
H.box[LEFT_BOX]);
send_array (H.box[LEFT_BOX], sendbuf, size, LEFT_BOX);
fprintf (stderr, "%d WAIT requestR LEFT %d \n", H.mype,
H.box[LEFT_BOX]);
recv_array (H.box[LEFT_BOX], recvbuf, size, LEFT_BOX);
i = 0;
size = unpack_arrayv (i, H, Hv, recvbuf);
break;
case RIGHT_BOX:
i = H.nx;
size = pack_arrayv (i, H, Hv, sendbuf);
fprintf (stderr, "%d WAIT requestR RIGHT %d \n", H.mype,
H.box[RIGHT_BOX]);
recv_array (H.box[RIGHT_BOX], recvbuf, size, LEFT_BOX);
fprintf (stderr, "%d WAIT requestW RIGHT %d \n", H.mype,
H.box[RIGHT_BOX]);
send_array (H.box[RIGHT_BOX], sendbuf, size, LEFT_BOX);
i = H.nx + ExtraLayer;
size = unpack_arrayv (i, H, Hv, recvbuf);
break;
case UP_BOX:
//fprintf(stderr, "UP%d\n", H.mype);
j = H.ny;
size = pack_arrayh (j, H, Hv, sendbuf);
fprintf (stderr, "%d WAIT requestW UP %d \n", H.mype, H.box[UP_BOX]);
send_array (H.box[UP_BOX], sendbuf, size, UP_BOX);
fprintf (stderr, "%d WAIT requestR UP %d \n", H.mype, H.box[UP_BOX]);
recv_array (H.box[UP_BOX], recvbuf, size, UP_BOX);
j = H.ny + ExtraLayer;
size = unpack_arrayh (j, H, Hv, recvbuf);
break;
case DOWN_BOX:
//fprintf(stderr, "DOWN%d\n", H.mype);
j = ExtraLayer;
size = pack_arrayh (j, H, Hv, sendbuf);
fprintf (stderr, "%d WAIT requestR DOWN %d \n", H.mype,
H.box[DOWN_BOX]);
recv_array (H.box[DOWN_BOX], recvbuf, size, UP_BOX);
fprintf (stderr, "%d WAIT requestW DOWN %d \n", H.mype,
H.box[DOWN_BOX]);
send_array (H.box[DOWN_BOX], sendbuf, size, UP_BOX);
j = 0;
size = unpack_arrayh (j, H, Hv, recvbuf);
break;
}
MPI_Barrier (MPI_COMM_WORLD);
}
