char *
getvertid( /* get/set vertex ID for this point */
char *vname,
FVECT vp
)
{
static char vkey[VKLEN];
register LUENT *lp;
register int i, vndx;
vclock++; /* increment counter */
mkvkey(vkey, vp);
if ((lp = lu_find(&vertab, vkey)) == NULL)
goto memerr;
if (lp->data == NULL) { /* allocate new vertex entry */
if (lp->key != NULL) /* reclaim deleted entry */
vertab.ndel--;
else {
if ((lp->key = (char *)malloc(VKLEN)) == NULL)
goto memerr;
strcpy(lp->key, vkey);
}
vndx = 0; /* find oldest vertex */
for (i = 1; i < NVERTS; i++)
if (vert[i].lused < vert[vndx].lused)
vndx = i;
if (vert[vndx].lused) { /* free old entry first */
mkvkey(vkey, vert[vndx].p);
lu_delete(&vertab, vkey);
}
VCOPY(vert[vndx].p, vp); /* assign it */
printf("v v%d =\n\tp %.15g %.15g %.15g\n", /* print it */
vndx, vp[0], vp[1], vp[2]);
lp->data = (char *)&vert[vndx]; /* set it */
} else
vndx = (struct vert *)lp->data - vert;
vert[vndx].lused = vclock; /* record this use */
sprintf(vname, "v%d", vndx);
return(vname);
memerr:
fputs("Out of memory in getvertid!\n", stderr);
exit(1);
}
int OOC_FilterPhoton (void *p, void *fd)
/* Filter callback for photon kNN search, used by OOC_FindNearest() */
{
const Photon *photon = p;
const OOC_FilterData *filtData = fd;
const PhotonMap *pmap = filtData -> pmap;
/* Reject photon if normal faces away (ignored for volume photons) with
* tolerance to account for perturbation; note photon normal is coded
* in range [-127,127], hence we factor this in */
if (filtData -> norm &&
DOT(filtData->norm, photon->norm) <= PMAP_NORM_TOL * 127 * frandom())
return 0;
if (isContribPmap(pmap)) {
/* Lookup in contribution photon map; filter according to emitting
* light source if contrib list set, else accept all */
if (pmap -> srcContrib) {
OBJREC *srcMod;
const int srcIdx = photonSrcIdx(pmap, photon);
if (srcIdx < 0 || srcIdx >= nsources)
error(INTERNAL, "invalid light source index in photon map");
srcMod = findmaterial(source [srcIdx].so);
/* Reject photon if contributions from light source which emitted
* it are not sought */
if (!lu_find(pmap -> srcContrib, srcMod -> oname) -> data)
return 0;
}
/* Reject non-caustic photon if lookup for caustic contribs */
if (pmap -> lookupCaustic && !photon -> caustic)
return 0;
}
/* Accept photon */
return 1;
}
static void cb_receive_layer_unset_value(const uint8_t session_id,
const uint32_t node_id,
const uint16_t layer_id,
const uint32_t item_id)
{
struct Node *node;
struct ParticleSenderNode *sender_node;
struct Particle_Sender *sender;
#if NO_DEBUG_PRINT != 1
printf("%s() session_id: %u, node_id: %u, layer_id: %u, item_id: %u\n",
__FUNCTION__, session_id, node_id, layer_id, item_id);
#else
(void)session_id;
#endif
node = lu_find(ctx->verse.lu_table, node_id);
if(node != NULL &&
node->type == PARTICLE_SENDER_NODE) {
struct ReceivedParticle *rec_particle;
sender_node = (struct ParticleSenderNode*)node;
sender = sender_node->sender;
if(layer_id == sender_node->particle_layer_id) {
pthread_mutex_lock(&sender_node->sender->rec_pd->mutex);
rec_particle = &sender->rec_pd->received_particles[item_id];
rec_particle->first_received_state = NULL;
rec_particle->last_received_state = NULL;
rec_particle->current_received_state = NULL;
pthread_mutex_unlock(&sender_node->sender->rec_pd->mutex);
}
} else {
printf("ERROR: Sender node not found\n");
}
}
static void cb_receive_tag_create(const uint8 session_id,
const uint32 node_id,
const uint16 taggroup_id,
const uint16 tag_id,
const uint8 data_type,
const uint8 count,
const uint16 custom_type)
{
struct Node *node;
struct ParticleSceneNode *scene_node;
struct ParticleSenderNode *sender_node;
/* struct ParticleNode *particle_node; */
#if NO_DEBUG_PRINT != 1
printf("%s() session_id: %d, node_id: %d, taggroup_id: %d, tag_id: %d, data_type: %d, count: %d, custom_type: %d\n",
__FUNCTION__, session_id, node_id, taggroup_id, tag_id, data_type, count, custom_type);
#else
(void)session_id;
#endif
node = lu_find(ctx->verse.lu_table, node_id);
if(node != NULL) {
switch(node->type) {
case PARTICLE_SCENE_NODE:
scene_node = (struct ParticleSceneNode *)node;
if(scene_node->particle_taggroup_id == taggroup_id) {
if(data_type == VRS_VALUE_TYPE_UINT16 &&
custom_type == SENDER_COUNT_TAG)
{
scene_node->sender_count_tag_id = tag_id;
}
}
break;
case PARTICLE_SENDER_NODE:
sender_node = (struct ParticleSenderNode*)node;
if(sender_node->particle_taggroup_id == taggroup_id)
{
if(data_type == VRS_VALUE_TYPE_UINT16 &&
custom_type == PARTICLE_FRAME_TAG)
{
sender_node->particle_frame_tag_id = tag_id;
}
else if(data_type == VRS_VALUE_TYPE_REAL32 &&
count == 3 &&
custom_type == POSITION_TAG)
{
sender_node->pos_tag_id = tag_id;
}
else if(data_type == VRS_VALUE_TYPE_UINT16 &&
custom_type == PARTICLE_COUNT_TAG)
{
sender_node->count_tag_id = tag_id;
}
else if(data_type == VRS_VALUE_TYPE_UINT16 &&
custom_type == SENDER_ID_TAG)
{
sender_node->sender_id_tag_id = tag_id;
}
}
break;
#if 0
case PARTICLE_NODE:
particle_node = (struct ParticleNode*)node;
if(particle_node->particle_taggroup_id == taggroup_id) {
if(data_type == VRS_VALUE_TYPE_REAL32 &&
count == 3 &&
custom_type == POSITION_TAG)
{
particle_node->pos_tag_id = tag_id;
} else if(data_type == VRS_VALUE_TYPE_UINT16 &&
custom_type == PARTICLE_ID_TAG)
{
particle_node->particle_id_tag_id = tag_id;
}
}
break;
#endif
}
} else {
printf("ERROR: node not found\n");
}
}
static void cb_receive_layer_set_value(const uint8_t session_id,
const uint32_t node_id,
const uint16_t layer_id,
const uint32_t item_id,
const uint8_t data_type,
const uint8_t count,
const void *value)
{
struct Node *node;
struct ParticleSenderNode *sender_node;
struct Particle_Sender *sender;
struct RefParticleState *ref_state;
uint16 current_frame;
#if NO_DEBUG_PRINT != 1
printf("%s() session_id: %u, node_id: %u, layer_id: %u, item_id: %u, data_type: %u, count: %u, value: %p\n",
__FUNCTION__, session_id, node_id, layer_id, item_id, data_type, count, value);
#else
(void)session_id;
(void)layer_id;
(void)data_type;
(void)count;
#endif
node = lu_find(ctx->verse.lu_table, node_id);
if(node != NULL && node->type == PARTICLE_SENDER_NODE) {
sender_node = (struct ParticleSenderNode*)node;
sender = sender_node->sender;
pthread_mutex_lock(&sender_node->sender->timer->mutex);
current_frame = sender_node->sender->timer->frame;
pthread_mutex_unlock(&sender_node->sender->timer->mutex);
pthread_mutex_lock(&sender_node->sender->rec_pd->mutex);
/* Find reference state */
ref_state = find_ref_particle_state(ctx->pd,
&ctx->pd->particles[item_id],
sender_node->sender->rec_pd->rec_frame,
(real32*)value);
/* Was reference state found? */
if(ref_state != NULL) {
struct ReceivedParticleState *rec_state;
struct ReceivedParticle *rec_particle;
rec_state = &sender->rec_pd->received_particles[item_id].received_states[ref_state->frame];
rec_particle = &sender->rec_pd->received_particles[item_id];
/* Set up first, last and current received state */
if(rec_particle->first_received_state == NULL) {
rec_particle->first_received_state = rec_state;
rec_particle->last_received_state = rec_state;
} else {
if(rec_particle->first_received_state->ref_particle_state->frame > rec_state->ref_particle_state->frame) {
rec_particle->first_received_state = rec_state;
}
if(rec_particle->last_received_state->ref_particle_state->frame < rec_state->ref_particle_state->frame) {
rec_particle->last_received_state = rec_state;
}
}
/* This state is the current received */
rec_particle->current_received_state = rec_state;
/* At this frame was particle received */
rec_state->received_frame = current_frame;
/* Set up delay of receiving */
rec_state->delay = current_frame - ref_state->frame;
/* Set up state according delay */
if(rec_state->delay == 0 || rec_state->delay == 1) {
rec_state->state = RECEIVED_STATE_INTIME;
} else if( rec_state->delay > 1) {
rec_state->state = RECEIVED_STATE_DELAY;
} else {
rec_state->state = RECEIVED_STATE_AHEAD;
}
} else {
printf("ERROR: Reference particle state not found\n");
}
pthread_mutex_unlock(&sender_node->sender->rec_pd->mutex);
} else {
printf("ERROR: Sender node not found\n");
}
}
/* Recover output if possible */
void
recover_output()
{
off_t lastout = -1;
int outvsiz, recsiz;
char *outvfmt;
int i, j;
MODCONT *mp;
int ofl;
char oname[1024];
LUENT *oent;
STREAMOUT sout;
off_t nvals;
int xr, yr;
switch (outfmt) {
case 'a':
error(USER, "cannot recover ASCII output");
return;
case 'f':
outvsiz = sizeof(float)*3;
break;
case 'd':
outvsiz = sizeof(double)*3;
break;
case 'c':
outvsiz = sizeof(COLR);
break;
default:
error(INTERNAL, "botched output format");
return;
}
outvfmt = formstr(outfmt);
/* check modifier outputs */
for (i = 0; i < nmods; i++) {
mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
if (mp->outspec == NULL)
error(USER, "cannot recover from stdout");
if (mp->outspec[0] == '!')
error(USER, "cannot recover from command");
for (j = 0; ; j++) { /* check each bin's file */
ofl = ofname(oname, mp->outspec, mp->modname, j);
if (ofl < 0)
error(USER, "bad output file specification");
oent = lu_find(&ofiletab, oname);
if (oent->data != NULL) {
sout = *(STREAMOUT *)oent->data;
} else {
sout.reclen = 0;
sout.outpipe = 0;
sout.ofp = NULL;
}
if (sout.ofp != NULL) { /* already open? */
if (ofl & OF_BIN)
continue;
break;
}
/* open output */
sout.ofp = fopen(oname, "rb+");
if (sout.ofp == NULL) {
if (j == mp->nbins)
break; /* assume end of modifier */
sprintf(errmsg, "missing recover file '%s'",
oname);
error(WARNING, errmsg);
break;
}
nvals = lseek(fileno(sout.ofp), 0, SEEK_END);
if (nvals <= 0) {
lastout = 0; /* empty output, quit here */
fclose(sout.ofp);
break;
}
if (!sout.reclen) {
if (!(ofl & OF_BIN)) {
sprintf(errmsg,
"need -bn to recover file '%s'",
oname);
error(USER, errmsg);
}
recsiz = outvsiz;
} else
recsiz = outvsiz * sout.reclen;
lseek(fileno(sout.ofp), 0, SEEK_SET);
if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) {
sprintf(errmsg, "format mismatch for '%s'",
oname);
error(USER, errmsg);
}
sout.xr = xres; sout.yr = yres;
if ((sout.xr > 0) & (sout.yr > 0) &&
(!fscnresolu(&xr, &yr, sout.ofp) ||
(xr != sout.xr) |
(yr != sout.yr))) {
sprintf(errmsg, "resolution mismatch for '%s'",
oname);
error(USER, errmsg);
}
nvals = (nvals - (off_t)ftell(sout.ofp)) / recsiz;
if ((lastout < 0) | (nvals < lastout))
lastout = nvals;
if (oent->key == NULL) /* new entry */
oent->key = strcpy((char *)
malloc(strlen(oname)+1), oname);
if (oent->data == NULL)
oent->data = (char *)malloc(sizeof(STREAMOUT));
*(STREAMOUT *)oent->data = sout;
if (!(ofl & OF_BIN))
break; /* no bin separation */
}
if (!lastout) { /* empty output */
error(WARNING, "no previous data to recover");
lu_done(&ofiletab); /* reclose all outputs */
return;
}
if (j > mp->nbins) { /* check modifier size */
sprintf(errmsg,
"mismatched -bn setting for recovering '%s'",
modname[i]);
error(USER, errmsg);
}
}
if (lastout < 0) {
error(WARNING, "no output files to recover");
return;
}
if (raysleft && lastout >= raysleft/accumulate) {
error(WARNING, "output appears to be complete");
/* XXX should read & discard input? */
quit(0);
}
/* seek on all files */
nvals = lastout * outvsiz;
lu_doall(&ofiletab, &myseeko, &nvals);
/* skip repeated input */
lastout *= accumulate;
for (nvals = 0; nvals < lastout; nvals++) {
FVECT vdummy;
if (getvec(vdummy) < 0 || getvec(vdummy) < 0)
error(USER, "unexpected EOF on input");
}
lastray = lastdone = (RNUMBER)lastout;
if (raysleft)
raysleft -= lastray;
}
/* Load previously accumulated values */
void
reload_output()
{
int i, j;
MODCONT *mp;
int ofl;
char oname[1024];
char *fmode = "rb";
char *outvfmt;
LUENT *oent;
int xr, yr;
STREAMOUT sout;
DCOLOR rgbv;
if (outfmt == 'a')
fmode = "r";
outvfmt = formstr(outfmt);
/* reload modifier values */
for (i = 0; i < nmods; i++) {
mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
if (mp->outspec == NULL)
error(USER, "cannot reload from stdout");
if (mp->outspec[0] == '!')
error(USER, "cannot reload from command");
for (j = 0; ; j++) { /* load each modifier bin */
ofl = ofname(oname, mp->outspec, mp->modname, j);
if (ofl < 0)
error(USER, "bad output file specification");
oent = lu_find(&ofiletab, oname);
if (oent->data != NULL) {
sout = *(STREAMOUT *)oent->data;
} else {
sout.reclen = 0;
sout.outpipe = 0;
sout.xr = xres; sout.yr = yres;
sout.ofp = NULL;
}
if (sout.ofp == NULL) { /* open output as input */
sout.ofp = fopen(oname, fmode);
if (sout.ofp == NULL) {
if (j == mp->nbins)
break; /* assume end of modifier */
sprintf(errmsg, "missing reload file '%s'",
oname);
error(WARNING, errmsg);
break;
}
#ifdef getc_unlocked
flockfile(sout.ofp);
#endif
if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) {
sprintf(errmsg, "format mismatch for '%s'",
oname);
error(USER, errmsg);
}
if ((sout.xr > 0) & (sout.yr > 0) &&
(!fscnresolu(&xr, &yr, sout.ofp) ||
(xr != sout.xr) |
(yr != sout.yr))) {
sprintf(errmsg, "resolution mismatch for '%s'",
oname);
error(USER, errmsg);
}
}
/* read in RGB value */
if (!get_contrib(rgbv, sout.ofp)) {
if (!j) {
fclose(sout.ofp);
break; /* ignore empty file */
}
if (j < mp->nbins) {
sprintf(errmsg, "missing data in '%s'",
oname);
error(USER, errmsg);
}
break;
}
if (j >= mp->nbins) { /* check modifier size */
sprintf(errmsg,
"mismatched -bn setting for reloading '%s'",
modname[i]);
error(USER, errmsg);
}
copycolor(mp->cbin[j], rgbv);
if (oent->key == NULL) /* new file entry */
oent->key = strcpy((char *)
malloc(strlen(oname)+1), oname);
if (oent->data == NULL)
oent->data = (char *)malloc(sizeof(STREAMOUT));
*(STREAMOUT *)oent->data = sout;
}
}
lu_doall(&ofiletab, &myclose, NULL); /* close all files */
}
/* Get output stream pointer (open and write header if new and noopen==0) */
STREAMOUT *
getostream(const char *ospec, const char *mname, int bn, int noopen)
{
static STREAMOUT stdos;
char info[1024];
int ofl;
char oname[1024];
LUENT *lep;
STREAMOUT *sop;
char *cp;
if (ospec == NULL) { /* use stdout? */
if (!noopen & !using_stdout) {
if (outfmt != 'a')
SET_FILE_BINARY(stdout);
if (header) {
cp = info;
if (yres > 0) {
sprintf(cp, "NROWS=%d\n", yres *
(xres + !xres) );
while (*cp) ++cp;
}
if ((xres <= 0) | (stdos.reclen > 1))
sprintf(cp, "NCOLS=%d\n", stdos.reclen);
printheader(stdout, info);
}
if (stdos.reclen == 1)
printresolu(stdout, xres, yres);
if (waitflush > 0)
fflush(stdout);
stdos.xr = xres; stdos.yr = yres;
#ifdef getc_unlocked
flockfile(stdout); /* avoid lock/unlock overhead */
#endif
using_stdout = 1;
}
stdos.ofp = stdout;
stdos.reclen += noopen;
return(&stdos);
}
ofl = ofname(oname, ospec, mname, bn); /* get output name */
if (ofl < 0) {
sprintf(errmsg, "bad output format '%s'", ospec);
error(USER, errmsg);
}
lep = lu_find(&ofiletab, oname); /* look it up */
if (lep->key == NULL) /* new entry */
lep->key = strcpy((char *)malloc(strlen(oname)+1), oname);
sop = (STREAMOUT *)lep->data;
if (sop == NULL) { /* allocate stream */
sop = (STREAMOUT *)malloc(sizeof(STREAMOUT));
if (sop == NULL)
error(SYSTEM, "out of memory in getostream");
sop->outpipe = oname[0] == '!';
sop->reclen = 0;
sop->ofp = NULL; /* open iff noopen==0 */
sop->xr = xres; sop->yr = yres;
lep->data = (char *)sop;
if (!sop->outpipe & !force_open & !recover &&
access(oname, F_OK) == 0) {
errno = EEXIST; /* file exists */
goto openerr;
}
}
if (!noopen && sop->ofp == NULL) { /* open output stream */
if (oname[0] == '!') /* output to command */
sop->ofp = popen(oname+1, "w");
else /* else open file */
sop->ofp = fopen(oname, "w");
if (sop->ofp == NULL)
goto openerr;
if (outfmt != 'a')
SET_FILE_BINARY(sop->ofp);
#ifdef getc_unlocked
flockfile(sop->ofp); /* avoid lock/unlock overhead */
#endif
if (accumulate > 0) { /* global resolution */
sop->xr = xres; sop->yr = yres;
}
if (header) {
cp = info;
if (ofl & OF_MODIFIER || sop->reclen == 1) {
sprintf(cp, "MODIFIER=%s\n", mname);
while (*cp) ++cp;
}
if (ofl & OF_BIN) {
sprintf(cp, "BIN=%d\n", bn);
while (*cp) ++cp;
}
if (sop->yr > 0) {
sprintf(cp, "NROWS=%d\n", sop->yr *
(sop->xr + !sop->xr) );
while (*cp) ++cp;
}
if ((sop->xr <= 0) | (sop->reclen > 1))
sprintf(cp, "NCOLS=%d\n", sop->reclen);
printheader(sop->ofp, info);
}
if (sop->reclen == 1)
printresolu(sop->ofp, sop->xr, sop->yr);
if (waitflush > 0)
fflush(sop->ofp);
}
sop->reclen += noopen; /* add to length if noopen */
return(sop); /* return output stream */
openerr:
sprintf(errmsg, "cannot open '%s' for writing", oname);
error(SYSTEM, errmsg);
return(NULL); /* pro forma return */
}
static void cb_receive_tag_create(const uint8 session_id,
const uint32 node_id,
const uint16 taggroup_id,
const uint16 tag_id,
const uint8 data_type,
const uint8 count,
const uint16 custom_type)
{
struct Node *node;
struct ParticleSceneNode *scene_node;
struct ParticleSenderNode *sender_node;
#if NO_DEBUG_PRINT != 1
printf("%s() session_id: %d, node_id: %d, taggroup_id: %d, tag_id: %d, data_type: %d, count: %d, custom_type: %d\n",
__FUNCTION__, session_id, node_id, taggroup_id, tag_id, data_type, count, custom_type);
#endif
node = lu_find(ctx->verse.lu_table, node_id);
if(node != NULL) {
switch(node->type) {
case PARTICLE_SCENE_NODE:
scene_node = (struct ParticleSceneNode *)node;
if(scene_node->particle_taggroup_id == taggroup_id) {
if(data_type == VRS_VALUE_TYPE_UINT16 &&
count == 1 &&
custom_type == SENDER_COUNT_TAG)
{
scene_node->sender_count_tag_id = tag_id;
}
}
break;
case PARTICLE_SENDER_NODE:
sender_node = (struct ParticleSenderNode*)node;
if(sender_node->particle_taggroup_id == taggroup_id) {
if(data_type == VRS_VALUE_TYPE_UINT16 &&
count == 1 &&
custom_type == PARTICLE_FRAME_TAG)
{
/* Save ID of Tag containing Frame */
sender_node->particle_frame_tag_id = tag_id;
/* Start sending of particles */
pthread_mutex_lock(&sender_node->sender->timer->mutex);
if(sender_node->sender->timer->run == 0) {
sender_node->sender->timer->run = 1;
sender_node->sender->timer->tot_frame = -25;
}
pthread_mutex_unlock(&sender_node->sender->timer->mutex);
}
else if(data_type == VRS_VALUE_TYPE_REAL32 &&
count == 3 &&
custom_type == POSITION_TAG)
{
/* Save ID of Tag containing position of sender */
sender_node->pos_tag_id = tag_id;
if(sender_node->sender != NULL) {
vrs_send_tag_set_value(session_id, VRS_DEFAULT_PRIORITY,
node_id, taggroup_id, tag_id, data_type, count, sender_node->sender->pos);
}
}
else if(data_type == VRS_VALUE_TYPE_UINT16 &&
count == 1 &&
custom_type == PARTICLE_COUNT_TAG)
{
/* Save ID of Tag containing count of particles of this sender */
sender_node->count_tag_id = tag_id;
vrs_send_tag_set_value(session_id, VRS_DEFAULT_PRIORITY, node_id,
taggroup_id, tag_id, data_type, count, &ctx->pd->particle_count);
}
else if(data_type == VRS_VALUE_TYPE_UINT16 && count == 1
&& custom_type == SENDER_ID_TAG)
{
/* Save ID of Tag containing ID od Sender */
sender_node->sender_id_tag_id = tag_id;
if(sender_node->sender != NULL) {
vrs_send_tag_set_value(session_id, VRS_DEFAULT_PRIORITY,
node_id, taggroup_id, tag_id, data_type, count, &sender_node->sender->id);
}
}
}
break;
}
}
}
int32
addmeshvert( /* find/add a mesh vertex */
MESH *mp,
MESHVERT *vp
)
{
LUENT *lvp;
MCVERT cv;
int i;
if (!(vp->fl & MT_V))
return(-1);
/* encode vertex */
for (i = 0; i < 3; i++) {
if (vp->v[i] < mp->mcube.cuorg[i])
return(-1);
if (vp->v[i] >= mp->mcube.cuorg[i] + mp->mcube.cusize)
return(-1);
cv.xyz[i] = (uint32)(4294967296. *
(vp->v[i] - mp->mcube.cuorg[i]) /
mp->mcube.cusize);
}
if (vp->fl & MT_N) /* assumes normalized! */
cv.norm = encodedir(vp->n);
if (vp->fl & MT_UV)
for (i = 0; i < 2; i++) {
if (vp->uv[i] <= mp->uvlim[0][i])
return(-1);
if (vp->uv[i] >= mp->uvlim[1][i])
return(-1);
cv.uv[i] = (uint32)(4294967296. *
(vp->uv[i] - mp->uvlim[0][i]) /
(mp->uvlim[1][i] - mp->uvlim[0][i]));
}
cv.fl = vp->fl;
if (mp->lut.tsiz == 0) {
mp->lut.hashf = cvhash;
mp->lut.keycmp = cvcmp;
mp->lut.freek = free;
if (!lu_init(&mp->lut, 50000))
goto nomem;
}
/* find entry */
lvp = lu_find(&mp->lut, (char *)&cv);
if (lvp == NULL)
goto nomem;
if (lvp->key == NULL) {
lvp->key = (char *)malloc(sizeof(MCVERT)+sizeof(int32));
memcpy((void *)lvp->key, (void *)&cv, sizeof(MCVERT));
}
if (lvp->data == NULL) { /* new vertex */
MESHPATCH *pp;
if (mp->npatches <= 0) {
mp->patch = (MESHPATCH *)calloc(MPATCHBLKSIZ,
sizeof(MESHPATCH));
if (mp->patch == NULL)
goto nomem;
mp->npatches = 1;
} else if (mp->patch[mp->npatches-1].nverts >= 256) {
if (mp->npatches % MPATCHBLKSIZ == 0) {
mp->patch = (MESHPATCH *)realloc(
(void *)mp->patch,
(mp->npatches + MPATCHBLKSIZ)*
sizeof(MESHPATCH));
memset((void *)(mp->patch + mp->npatches), '\0',
MPATCHBLKSIZ*sizeof(MESHPATCH));
}
if (mp->npatches++ >= 1L<<22)
error(INTERNAL, "too many mesh patches");
}
pp = &mp->patch[mp->npatches-1];
if (pp->xyz == NULL) {
pp->xyz = (uint32 (*)[3])calloc(256, 3*sizeof(int32));
if (pp->xyz == NULL)
goto nomem;
}
for (i = 0; i < 3; i++)
pp->xyz[pp->nverts][i] = cv.xyz[i];
if (cv.fl & MT_N) {
if (pp->norm == NULL) {
pp->norm = (int32 *)calloc(256, sizeof(int32));
if (pp->norm == NULL)
goto nomem;
}
pp->norm[pp->nverts] = cv.norm;
}
if (cv.fl & MT_UV) {
if (pp->uv == NULL) {
pp->uv = (uint32 (*)[2])calloc(256,
2*sizeof(uint32));
if (pp->uv == NULL)
goto nomem;
}
for (i = 0; i < 2; i++)
pp->uv[pp->nverts][i] = cv.uv[i];
}
pp->nverts++;
lvp->data = lvp->key + sizeof(MCVERT);
*(int32 *)lvp->data = (mp->npatches-1) << 8 | (pp->nverts-1);
}
return(*(int32 *)lvp->data);
nomem:
error(SYSTEM, "out of memory in addmeshvert");
return(-1);
}
/* Load previously accumulated values */
void
reload_output()
{
int i, j;
MODCONT *mp;
int ofl;
char oname[1024];
char *fmode = "rb";
char *outvfmt;
LUENT *oent;
int xr, yr;
STREAMOUT *sop;
DCOLOR rgbv;
if (outfmt == 'a')
fmode = "r";
outvfmt = formstr(outfmt);
/* reload modifier values */
for (i = 0; i < nmods; i++) {
mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
if (mp->outspec == NULL)
error(USER, "cannot reload from stdout");
if (mp->outspec[0] == '!')
error(USER, "cannot reload from command");
for (j = 0; j < mp->nbins; j++) { /* load each modifier bin */
ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
if (ofl < 0)
error(USER, "bad output file specification");
oent = lu_find(&ofiletab, oname);
if (oent->data == NULL)
error(INTERNAL, "unallocated stream in reload_output()");
sop = (STREAMOUT *)oent->data;
if (sop->ofp == NULL) { /* open output as input */
sop->ofp = fopen(oname, fmode);
if (sop->ofp == NULL) {
sprintf(errmsg, "missing reload file '%s'",
oname);
error(WARNING, errmsg);
break;
}
#ifdef getc_unlocked
flockfile(sop->ofp);
#endif
if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
sprintf(errmsg, "format mismatch for '%s'",
oname);
error(USER, errmsg);
}
if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
(!fscnresolu(&xr, &yr, sop->ofp) ||
(xr != sop->xr) |
(yr != sop->yr))) {
sprintf(errmsg, "resolution mismatch for '%s'",
oname);
error(USER, errmsg);
}
}
/* read in RGB value */
if (!get_contrib(rgbv, sop->ofp)) {
if (!j) {
fclose(sop->ofp);
break; /* ignore empty file */
}
if (j < mp->nbins) {
sprintf(errmsg, "missing data in '%s'",
oname);
error(USER, errmsg);
}
break;
}
copycolor(mp->cbin[j], rgbv);
}
}
lu_doall(&ofiletab, &myclose, NULL); /* close all files */
}
