int send_create_galaxy(const char *filename, int j)
{
int i;
if ((i = new_galaxy()) >= 0)
{
struct galaxy *g = get_galaxy(i);
/* If the file exists and is successfully read... */
if ((parse_galaxy(filename, g)))
{
g->count = 1;
g->brush = dupe_create_brush(j);
/* Pack the galaxy header. */
send_event(EVENT_CREATE_GALAXY);
send_index(g->brush);
send_index(g->S_num);
send_index(g->N_num);
/* Pack the stars and BSP nodes. */
send_array(g->S, g->S_num, sizeof (struct star));
send_array(g->N, g->N_num, sizeof (struct node));
/* Encapsulate this object in an entity. */
return send_create_entity(TYPE_GALAXY, i);
}
}
return -1;
}
void send_set_brush_frag_shader(int i, const char *text)
{
int n = text ? (strlen(text) + 1) : 0;
struct brush *b = get_brush(i);
send_event(EVENT_SET_BRUSH_FRAG_SHADER);
send_index(i);
send_index(n);
fini_brush(i);
/* Free the old fragment program buffer. */
if (b->frag_text)
{
free(b->frag_text);
b->frag_text = NULL;
}
/* Copy the new fragment program buffer. */
if (n > 0)
{
b->frag_text = memdup(text, n, 1);
send_array(b->frag_text, n, 1);
}
}
void send_set_brush_vert_prog(int i, const char *text)
{
int n = text ? (strlen(text) + 1) : 0;
struct brush *b = get_brush(i);
send_event(EVENT_SET_BRUSH_VERT_PROG);
send_index(i);
send_index(n);
fini_brush(i);
/* Free the old vertex program buffer. */
if (b->vert)
{
free(b->vert);
b->vert = NULL;
}
/* Copy the new vertex program buffer. */
if (n > 0)
{
b->vert = memdup(text, n, 1);
send_array(text, n, 1);
}
}
void send_set_brush_uniform(int i, const char *n,
int r, int c, int d, const float *v)
{
struct brush *b = get_brush(i);
int l = strlen(n);
send_event(EVENT_SET_BRUSH_UNIFORM);
send_index(i);
send_index(r);
send_index(c);
send_index(d);
send_index(l);
send_array(n, l, sizeof (char));
send_array(v, r * c, sizeof (float));
set_brush_uniform(b, n, r, c, d, v);
}
void send_set_brush_color(int i, const float d[4],
const float s[4],
const float a[4],
const float x[1], int f)
{
struct brush *b = get_brush(i);
b->flags |= f;
if (f & BRUSH_DIFFUSE)
{
b->d[0] = d[0];
b->d[1] = d[1];
b->d[2] = d[2];
b->d[3] = d[3];
}
if (f & BRUSH_SPECULAR)
{
b->s[0] = s[0];
b->s[1] = s[1];
b->s[2] = s[2];
b->s[3] = s[3];
}
if (f & BRUSH_AMBIENT)
{
b->a[0] = a[0];
b->a[1] = a[1];
b->a[2] = a[2];
b->a[3] = a[3];
}
if (f & BRUSH_SHINY)
b->x[0] = x[0];
send_event(EVENT_SET_BRUSH_COLOR);
send_index(i);
send_array(b->d, 4, sizeof (float));
send_array(b->s, 4, sizeof (float));
send_array(b->a, 4, sizeof (float));
send_array(b->x, 1, sizeof (float));
send_index(b->flags);
}
void send_set_edge(int i, int j, int k, int vi[2])
{
struct object_edge *e = get_object_edge(i, j, k);
e->vi[0] = vi[0];
e->vi[1] = vi[1];
send_event(EVENT_SET_EDGE);
send_index(i);
send_index(j);
send_index(k);
send_array(e->vi, 2, sizeof (int));
}
void send_set_face(int i, int j, int k, int vi[3])
{
struct object_face *f = get_object_face(i, j, k);
f->vi[0] = vi[0];
f->vi[1] = vi[1];
f->vi[2] = vi[2];
send_event(EVENT_SET_FACE);
send_index(i);
send_index(j);
send_index(k);
send_array(f->vi, 3, sizeof (int));
}
unsigned int send_add_host(const char *name, int x, int y, int w, int h)
{
int n = strlen(name) + 1;
send_event(EVENT_ADD_HOST);
send_value(n);
send_value(x);
send_value(y);
send_value(w);
send_value(h);
send_array(name, n, 1);
return add_host(name, x, y, w, h);
}
void send_set_vert(int i, int j, float v[3], float n[3], float u[2])
{
struct object_vert *p = get_object_vert(i, j);
p->v[0] = v[0];
p->v[1] = v[1];
p->v[2] = v[2];
p->n[0] = n[0];
p->n[1] = n[1];
p->n[2] = n[2];
p->u[0] = u[0];
p->u[1] = u[1];
send_event(EVENT_SET_VERT);
send_index(i);
send_index(j);
send_array(p->v, 3, sizeof (float));
send_array(p->n, 3, sizeof (float));
send_array(p->u, 2, sizeof (float));
fini_object(i);
}
void send_set_brush_vert_param(int i, int p, const float v[4])
{
struct brush *b = get_brush(i);
b->vert_param[p][0] = v[0];
b->vert_param[p][1] = v[1];
b->vert_param[p][2] = v[2];
b->vert_param[p][3] = v[3];
send_event(EVENT_SET_BRUSH_VERT_PARAM);
send_index(i);
send_index(p);
send_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]);
}
}
int send_create_terrain(const char *filename, int w, int h, int n)
{
int l = strlen(filename);
int i;
if ((i = new_terrain()))
{
/* If the file exists and is successfully loaded... */
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 = DEFAULT_SIZE;
terrain[i].o = 3396000;
terrain[i].bias = DEFAULT_BIAS;
terrain[i].magn = DEFAULT_MAGN;
/* Pack the header and data. */
send_event(EVENT_CREATE_TERRAIN);
send_value(terrain[i].w);
send_value(terrain[i].h);
send_value(terrain[i].n);
send_value(terrain[i].m);
send_value(l);
send_array(filename, l + 1, 1);
/* Encapsulate this object in an entity. */
return send_create_entity(TYPE_TERRAIN, i);
}
}
return -1;
}
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);
}
int send_create_brush(const char *file, const char *name)
{
int i, n = vecnum(brush);
/* Scan the current brushes for an existing instance. */
for (i = 0; i < n; ++i)
{
struct brush *b = get_brush(i);
if (file && b->file && strcmp(b->file, file) == 0 &&
name && b->name && strcmp(b->name, name) == 0)
return dupe_create_brush(i);
}
/* Didn't find it. It's new. */
if ((i = new_brush()) >= 0)
{
struct brush *b = get_brush(i);
/* Note the file and material names. */
if (file) b->file = memdup(file, strlen(file) + 1, 1);
if (name) b->name = memdup(name, strlen(name) + 1, 1);
/* Set some default values. */
b->count = 1;
b->state = 0;
b->flags = BRUSH_DIFFUSE | BRUSH_SPECULAR |
BRUSH_AMBIENT | BRUSH_SHINY;
b->d[0] = BRUSH_DIFFUSE_R;
b->d[1] = BRUSH_DIFFUSE_G;
b->d[2] = BRUSH_DIFFUSE_B;
b->d[3] = BRUSH_DIFFUSE_A;
b->s[0] = BRUSH_SPECULAR_R;
b->s[1] = BRUSH_SPECULAR_G;
b->s[2] = BRUSH_SPECULAR_B;
b->s[3] = BRUSH_SPECULAR_A;
b->a[0] = BRUSH_AMBIENT_R;
b->a[1] = BRUSH_AMBIENT_G;
b->a[2] = BRUSH_AMBIENT_B;
b->a[3] = BRUSH_AMBIENT_A;
b->x[0] = BRUSH_SHININESS;
b->line_width = 1;
/* Load and pack the brush. */
if (file && name)
load_brush(b, file, name);
send_event(EVENT_CREATE_BRUSH);
send_index(b->flags);
send_array(b->image, 4, sizeof (int));
send_array(b->d, 4, sizeof (float));
send_array(b->s, 4, sizeof (float));
send_array(b->a, 4, sizeof (float));
send_array(b->x, 1, sizeof (float));
return i;
}
return -1;
}
