static int
isst_load_g(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc,
Tcl_Obj *const *objv)
{
struct isst_s *isst;
char **argv;
int argc;
double az, el;
struct bu_vls tclstr = BU_VLS_INIT_ZERO;
vect_t vec;
Togl *togl;
if (objc < 4) {
Tcl_WrongNumArgs(interp, 1, objv, "load_g pathname object");
return TCL_ERROR;
}
if (Togl_GetToglFromObj(interp, objv[1], &togl) != TCL_OK) {
return TCL_ERROR;
}
isst = (struct isst_s *) Togl_GetClientData(togl);
argv = (char **)malloc(sizeof(char *) * (strlen(Tcl_GetString(objv[3])) + 1)); /* allocate way too much. */
argc = bu_argv_from_string(argv, strlen(Tcl_GetString(objv[3])), Tcl_GetString(objv[3]));
load_g(isst->tie, Tcl_GetString(objv[2]), argc, (const char **)argv, &(isst->meshes));
free(argv);
VSETALL(isst->camera.pos, isst->tie->radius);
VMOVE(isst->camera.focus, isst->tie->mid);
VMOVE(isst->camera_pos_init, isst->camera.pos);
VMOVE(isst->camera_focus_init, isst->camera.focus);
/* Set the initial az and el values in Tcl/Tk */
VSUB2(vec, isst->camera.pos, isst->camera.focus);
VUNITIZE(vec);
AZEL_FROM_V3DIR(az, el, vec);
az = az * -DEG2RAD;
el = el * -DEG2RAD;
bu_vls_sprintf(&tclstr, "%f", az);
Tcl_SetVar(interp, "az", bu_vls_addr(&tclstr), 0);
bu_vls_sprintf(&tclstr, "%f", el);
Tcl_SetVar(interp, "el", bu_vls_addr(&tclstr), 0);
bu_vls_free(&tclstr);
render_phong_init(&isst->camera.render, NULL);
isst->ogl = 1;
isst->w = Togl_Width(togl);
isst->h = Togl_Height(togl);
resize_isst(isst);
isst->t1 = bu_gettime();
isst->t2 = bu_gettime();
return TCL_OK;
}
void
adrt_slave_work(tienet_buffer_t *work, tienet_buffer_t *result)
{
TIE_3 pos, foc;
unsigned char rm, op;
uint32_t ind, wlen;
uint16_t wid;
/* Length of work data */
wlen = work->ind;
ind = 0;
/* Get work type */
TCOPY(uint8_t, work->data, ind, &op, 0);
ind += 1;
/* Workspace ID */
TCOPY(uint16_t, work->data, ind, &wid, 0);
ind += 2;
/* This will get improved later with caching */
TIENET_BUFFER_SIZE((*result), 3); /* Copy op and wid, 3 bytes */
memcpy(result->data, &work->data[0], 3);
result->ind = ind;
switch (op) {
case ADRT_WORK_INIT:
{
render_camera_init (&adrt_workspace_list[wid].camera, adrt_slave_threads);
if ( slave_load (&adrt_workspace_list[wid].tie, (void *)work->data, wlen-ind) != 0 )
bu_exit (1, "Failed to load geometry. Going into a flaming tailspin\n");
tie_prep (&adrt_workspace_list[wid].tie);
render_camera_prep (&adrt_workspace_list[wid].camera);
printf ("ready.\n");
result->ind = 0;
/* Mark the workspace as active so it can be cleaned up when the time comes. */
adrt_workspace_list[wid].active = 1;
}
break;
case ADRT_WORK_STATUS:
{
#ifdef HAVE_GETLOADAVG
double loadavg = -1.0;
getloadavg (&loadavg, 1);
printf ("load average: %f\n", loadavg);
#endif
}
break;
case ADRT_WORK_SELECT:
{
uint8_t c;
char string[255];
uint32_t n, i, num;
ind = 1; /* ind is too far in for some reason, force it back to 1? */
/* reset */
TCOPY(uint8_t, work->data, ind, &c, 0);
ind += 1;
if (c)
for (i = 0; i < slave_load_mesh_num; i++)
slave_load_mesh_list[i].flags = 0;
/* number of strings to match */
TCOPY(uint32_t, work->data, ind, &num, 0);
ind += 4;
for (i = 0; i < num; i++) {
/* string length */
TCOPY(uint8_t, work->data, ind, &c, 0); /* this likes to break, 'num' is way too big. */
ind += 1;
/* string */
memcpy(string, &work->data[ind], c);
ind += c;
/* set select flag */
for (n = 0; n < slave_load_mesh_num; n++)
if (strstr(slave_load_mesh_list[n].name, string) || c == 1)
slave_load_mesh_list[n].flags = (slave_load_mesh_list[n].flags & 0x1) | ((slave_load_mesh_list[n].flags & 0x2) ^ 0x2);
}
/* zero length result */
result->ind = 0;
}
break;
case ADRT_WORK_SHOTLINE:
{
tie_ray_t ray;
void *mesg;
int dlen;
mesg = NULL;
/* coordinates */
TCOPY(TIE_3, work->data, ind, ray.pos.v, 0);
ind += sizeof (TIE_3);
TCOPY(TIE_3, work->data, ind, ray.dir.v, 0);
ind += sizeof (TIE_3);
/* Fire the shot */
ray.depth = 0;
render_util_shotline_list (&adrt_workspace_list[wid].tie, &ray, &mesg, &dlen);
/* Make room for shot data */
TIENET_BUFFER_SIZE((*result), result->ind + dlen + 2*sizeof (TIE_3));
memcpy(&result->data[result->ind], mesg, dlen);
result->ind += dlen;
TCOPY(TIE_3, &ray.pos, 0, result->data, result->ind);
result->ind += sizeof (TIE_3);
TCOPY(TIE_3, &ray.dir, 0, result->data, result->ind);
result->ind += sizeof (TIE_3);
free (mesg);
}
break;
case ADRT_WORK_SPALL:
{
#if 0
tie_ray_t ray;
tfloat angle;
void *mesg;
int dlen;
mesg = NULL;
/* position */
TCOPY(TIE_3, data, ind, &ray.pos, 0);
ind += sizeof (TIE_3);
/* direction */
TCOPY(TIE_3, data, ind, &ray.dir, 0);
ind += sizeof (TIE_3);
/* angle */
TCOPY(tfloat, data, ind, &angle, 0);
ind += sizeof (tfloat);
/* Fire the shot */
ray.depth = 0;
render_util_spall_list(tie, &ray, angle, &mesg, &dlen);
/* Make room for shot data */
*res_len = sizeof (common_work_t) + dlen;
*res_buf = (void *)realloc(*res_buf, *res_len);
ind = 0;
memcpy(&((char *)*res_buf)[ind], mesg, dlen);
free (mesg);
#endif
}
break;
case ADRT_WORK_FRAME_ATTR:
{
uint16_t image_w, image_h, image_format;
/* Image Size */
TCOPY(uint16_t, work->data, ind, &image_w, 0);
ind += 2;
TCOPY(uint16_t, work->data, ind, &image_h, 0);
ind += 2;
TCOPY(uint16_t, work->data, ind, &image_format, 0);
ind += 2;
adrt_workspace_list[wid].camera.w = image_w;
adrt_workspace_list[wid].camera.h = image_h;
render_camera_prep (&adrt_workspace_list[wid].camera);
result->ind = 0;
}
break;
case ADRT_WORK_FRAME:
{
camera_tile_t tile;
uint8_t type;
tfloat fov;
/* Camera type */
TCOPY(uint8_t, work->data, ind, &type, 0);
ind += 1;
/* Camera fov */
TCOPY(tfloat, work->data, ind, &fov, 0);
ind += sizeof (tfloat);
/* Camera position */
TCOPY(TIE_3, work->data, ind, &pos, 0);
ind += sizeof (TIE_3);
/* Camera Focus */
TCOPY(TIE_3, work->data, ind, &foc, 0);
ind += sizeof (TIE_3);
/* Update Rendering Method if it has Changed */
rm = work->data[ind];
ind += 1;
if (rm != adrt_workspace_list[wid].camera.rm || ADRT_MESSAGE_MODE_CHANGEP(rm)) {
rm = ADRT_MESSAGE_MODE(rm);
adrt_workspace_list[wid].camera.render.free (&adrt_workspace_list[wid].camera.render);
switch (rm) {
case RENDER_METHOD_DEPTH:
render_depth_init(&adrt_workspace_list[wid].camera.render, NULL);
break;
case RENDER_METHOD_COMPONENT:
render_component_init(&adrt_workspace_list[wid].camera.render, NULL);
break;
case RENDER_METHOD_FLOS:
{
TIE_3 frag_pos;
char buf[BUFSIZ];
/* Extract shot position and direction */
TCOPY(TIE_3, work->data, ind, &frag_pos, 0);
snprintf(buf, BUFSIZ, "#(%f %f %f)", V3ARGS(frag_pos.v));
ind += sizeof (TIE_3);
render_flos_init(&adrt_workspace_list[wid].camera.render, buf);
}
break;
case RENDER_METHOD_GRID:
render_grid_init(&adrt_workspace_list[wid].camera.render, NULL);
break;
case RENDER_METHOD_NORMAL:
render_normal_init(&adrt_workspace_list[wid].camera.render, NULL);
break;
case RENDER_METHOD_PATH:
render_path_init(&adrt_workspace_list[wid].camera.render, "12");
break;
case RENDER_METHOD_PHONG:
render_phong_init(&adrt_workspace_list[wid].camera.render, NULL);
break;
case RENDER_METHOD_CUT:
render_cut_init(&adrt_workspace_list[wid].camera.render, (char *)work->data + ind);
break;
case RENDER_METHOD_SPALL:
{
TIE_3 shot_pos, shot_dir;
tfloat angle;
char buf[BUFSIZ];
/* Extract shot position and direction */
TCOPY(TIE_3, work->data, ind, &shot_pos, 0);
ind += sizeof (TIE_3);
TCOPY(TIE_3, work->data, ind, &shot_dir, 0);
ind += sizeof (TIE_3);
TCOPY(tfloat, work->data, ind, &angle, 0);
ind += sizeof (tfloat);
snprintf(buf, BUFSIZ, "(%g %g %g) (%g %g %g) %g", V3ARGS(shot_pos.v), V3ARGS(shot_dir.v), angle);
render_spall_init (&adrt_workspace_list[wid].camera.render, buf);
}
break;
default:
break;
}
adrt_workspace_list[wid].camera.rm = rm;
}
/* The portion of the image to be rendered */
ind = work->ind - sizeof (camera_tile_t);
TCOPY(camera_tile_t, work->data, ind, &tile, 0);
ind += sizeof (camera_tile_t);
/* Update camera if different frame */
if (tile.frame != adrt_workspace_list[wid].last_frame) {
adrt_workspace_list[wid].camera.type = type;
adrt_workspace_list[wid].camera.fov = fov;
adrt_workspace_list[wid].camera.pos = pos;
adrt_workspace_list[wid].camera.focus = foc;
render_camera_prep (&adrt_workspace_list[wid].camera);
}
adrt_workspace_list[wid].last_frame = tile.frame;
render_camera_render (&adrt_workspace_list[wid].camera, &adrt_workspace_list[wid].tie, &tile, result);
}
break;
case ADRT_WORK_MINMAX:
{
TCOPY(TIE_3, &adrt_workspace_list[wid].tie.min, 0, result->data, result->ind);
result->ind += sizeof (TIE_3);
TCOPY(TIE_3, &adrt_workspace_list[wid].tie.max, 0, result->data, result->ind);
result->ind += sizeof (TIE_3);
}
break;
default:
break;
}
#if 0
{
struct timeval tv;
static int adrt_slave_completed = 0;
static time_t adrt_slave_startsec = 0;
if (adrt_slave_startsec == 0)
adrt_slave_startsec = time(NULL);
gettimeofday(&tv, NULL);
printf("\t[Work Units Completed: %.6d Rays: %.5d k/sec %lld]\n",
++adrt_slave_completed,
(int) ((tfloat) adrt_workspace_list[wid].tie.rays_fired / (tfloat) (1000 * (tv.tv_sec - adrt_slave_startsec + 1))),
adrt_workspace_list[wid].tie.rays_fired);
fflush(stdout);
}
#endif
return;
}
