static void
plot_ray_img(struct application *ap,
const struct partition *pp,
double dist,
struct bbd_img *bi)
{
static int plot_num;
FILE *pfd;
char name[256];
point_t pt;
sprintf(name, "bbd_%d.plot3", plot_num++);
bu_log("plotting %s\n", name);
if ((pfd = fopen(name, "wb")) == (FILE *)NULL) {
bu_bomb("can't open plot3 file\n");
}
/* red line from ray origin to hit point */
VJOIN1(pp->pt_inhit->hit_point, ap->a_ray.r_pt, pp->pt_inhit->hit_dist,
ap->a_ray.r_dir);
if (VNEAR_EQUAL(ap->a_ray.r_pt, pp->pt_inhit->hit_point, 0.125)) {
/* start and hit point identical, make special allowance */
vect_t vtmp;
pl_color(pfd, 255, 0, 128);
VREVERSE(vtmp, ap->a_ray.r_dir);
VJOIN1(vtmp, ap->a_ray.r_pt, 5.0, vtmp);
pdv_3line(pfd, vtmp, pp->pt_inhit->hit_point);
} else {
pl_color(pfd, 255, 0, 0);
pdv_3line(pfd, ap->a_ray.r_pt, pp->pt_inhit->hit_point);
}
/* yellow line from hit point to plane point */
VJOIN1(pt, ap->a_ray.r_pt, dist, ap->a_ray.r_dir); /* point on plane */
pl_color(pfd, 255, 255, 0);
pdv_3line(pfd, pp->pt_inhit->hit_point, pt);
/* green line from image origin to plane point */
pl_color(pfd, 0, 255, 0);
pdv_3line(pfd, pt, bi->img_origin);
fclose(pfd);
}
void
plotGrid(fastf_t *r_pt)
{
if (plotfp == NULL)
return;
pl_color(plotfp, R_GRID, G_GRID, B_GRID);
pl_3point(plotfp, (int) r_pt[X], (int) r_pt[Y], (int) r_pt[Z]);
return;
}
HIDDEN int
plot_setFGColor(struct dm *dmp, unsigned char r, unsigned char g, unsigned char b, int strict, fastf_t transparency)
{
if (!dmp) {
bu_log("WARNING: NULL display (r/g/b => %d/%d/%d; strict => %d; transparency => %f)\n", r, g, b, strict, transparency);
return TCL_ERROR;
}
pl_color(((struct plot_vars *)dmp->dm_vars.priv_vars)->up_fp, (int)r, (int)g, (int)b);
return TCL_OK;
}
int miss(register struct application *ap)
{
bu_log("missed\n");
if ( R_DEBUG&RDEBUG_RAYPLOT ) {
vect_t out;
VJOIN1( out, ap->a_ray.r_pt,
10000, ap->a_ray.r_dir ); /* to imply direction */
pl_color( plotfp, 190, 0, 0 );
pdv_3line( plotfp, ap->a_ray.r_pt, out );
}
return(0);
}
void
plotRayPoint(struct xray *rayp)
{
int endpoint[3];
if (plotfp == NULL)
return;
VJOIN1(endpoint, rayp->r_pt, cellsz, rayp->r_dir);
bu_semaphore_acquire(BU_SEM_SYSCALL);
pl_color(plotfp, R_BURST, G_BURST, B_BURST);
/* draw point */
pl_3point(plotfp, (int) endpoint[X], (int) endpoint[Y], (int) endpoint[Z]);
bu_semaphore_release(BU_SEM_SYSCALL);
return;
}
void
plot_face(ON_3dPoint *pt1, ON_3dPoint *pt2, ON_3dPoint *pt3, int r, int g, int b, FILE *c_plot)
{
point_t p1, p2, p3;
VSET(p1, pt1->x, pt1->y, pt1->z);
VSET(p2, pt2->x, pt2->y, pt2->z);
VSET(p3, pt3->x, pt3->y, pt3->z);
pl_color(c_plot, r, g, b);
pdv_3move(c_plot, p1);
pdv_3cont(c_plot, p2);
pdv_3move(c_plot, p1);
pdv_3cont(c_plot, p3);
pdv_3move(c_plot, p2);
pdv_3cont(c_plot, p3);
}
HIDDEN
void plot_obr(int test_num, const point_t *pnt_array, int pnt_cnt)
{
int i = 0;
struct bu_vls name;
FILE *plot_file = NULL;
bu_vls_init(&name);
bu_vls_printf(&name, "obr_test_%.3d.pl", test_num);
plot_file = fopen(bu_vls_addr(&name), "w");
pl_color(plot_file, 0, 255, 0);
for (i = 0; i < pnt_cnt; i++) {
pdv_3move(plot_file, pnt_array[i]);
if (i < pnt_cnt - 1) {
pdv_3cont(plot_file, pnt_array[i+1]);
} else {
pdv_3cont(plot_file, pnt_array[0]);
}
}
fclose(plot_file);
bu_vls_free(&name);
}
int
main(int argc, char **argv)
{
int c;
int r, g, b;
if ( argc != 4 || isatty(fileno(stdout)) ) {
bu_exit(1, "%s", usage );
}
if ( !isatty(fileno(stdin)) ) {
/* Permit use in a pipeline -- copy input to output first */
while ( (c = getchar()) != EOF )
putchar( c );
}
r = atoi( argv[1] );
g = atoi( argv[2] );
b = atoi( argv[3] );
pl_color( stdout, r, g, b );
return 0;
}
/*
* R A Y H I T
*
* Rayhit() is called by rt_shootray() when the ray hits one or more objects.
* A per-shotline header record is written, followed by information about
* each object hit.
*
* Note that the GIFT-3 format uses a different convention for the "zero"
* distance along the ray. RT has zero at the ray origin (emanation plain),
* while GIFT has zero at the screen plain translated so that it contains
* the model origin. This difference is compensated for by adding the
* 'dcorrection' distance correction factor.
*
* Also note that the GIFT-3 format requires information about the start
* point of the ray in two formats. First, the h, v coordinates of the
* grid cell CENTERS (in screen space coordinates) are needed.
* Second, the ACTUAL h, v coordinates fired from are needed.
*
* An optional rtg3.pl UnixPlot file is written, permitting a
* color vector display of ray-model intersections.
*/
int
rayhit(struct application *ap, register struct partition *PartHeadp, struct seg *segp)
{
register struct partition *pp = PartHeadp->pt_forw;
int comp_count; /* component count */
fastf_t dfirst, dlast; /* ray distances */
static fastf_t dcorrection = 0; /* RT to GIFT dist corr */
int card_count; /* # comp. on this card */
const char *fmt; /* printf() format string */
struct bu_vls str;
char buf[128]; /* temp. sprintf() buffer */
point_t hv; /* GIFT h, v coords, in inches */
point_t hvcen;
int prev_id=-1;
point_t first_hit;
int first;
if ( pp == PartHeadp )
return(0); /* nothing was actually hit?? */
if ( ap->a_rt_i->rti_save_overlaps )
rt_rebuild_overlaps( PartHeadp, ap, 1 );
part_compact(ap, PartHeadp, TOL);
/* count components in partitions */
comp_count = 0;
for ( pp=PartHeadp->pt_forw; pp!=PartHeadp; pp=pp->pt_forw ) {
if ( pp->pt_regionp->reg_regionid > 0 ) {
prev_id = pp->pt_regionp->reg_regionid;
comp_count++;
} else if ( prev_id <= 0 ) {
/* normally air would be output along with a solid partition, but this will require a '111' partition */
prev_id = pp->pt_regionp->reg_regionid;
comp_count++;
} else
prev_id = pp->pt_regionp->reg_regionid;
}
pp = PartHeadp->pt_back;
if ( pp!=PartHeadp && pp->pt_regionp->reg_regionid <= 0 )
comp_count++; /* a trailing '111' ident */
if ( comp_count == 0 )
return( 0 );
/* Set up variable length string, to buffer this shotline in.
* Note that there is one component per card, and that each card
* (line) is 80 characters long. Hence the parameters given to
* rt-vls-extend().
*/
bu_vls_init( &str );
bu_vls_extend( &str, 80 * (comp_count+1) );
/*
* Find the H, V coordinates of the grid cell center.
* RT uses the lower left corner of each cell.
*/
{
point_t center;
fastf_t dx;
fastf_t dy;
dx = ap->a_x + 0.5;
dy = ap->a_y + 0.5;
VJOIN2( center, viewbase_model, dx, dx_model, dy, dy_model );
MAT4X3PNT( hvcen, model2hv, center );
}
/*
* Find exact h, v coordinates of actual ray start by
* projecting start point into GIFT h, v coordinates.
*/
MAT4X3PNT( hv, model2hv, ap->a_ray.r_pt );
/*
* In RT, rays are launched from the plane of the screen,
* and ray distances are relative to the start point.
* In GIFT-3 output files, ray distances are relative to
* the (H, V) plane translated so that it contains the origin.
* A distance correction is required to convert between the two.
* Since this really should be computed only once, not every time,
* the trip_count flag was added.
*/
{
static int trip_count;
vect_t tmp;
vect_t viewZdir;
if ( trip_count == 0) {
VSET( tmp, 0, 0, -1 ); /* viewing direction */
MAT4X3VEC( viewZdir, view2model, tmp );
VUNITIZE( viewZdir );
/* dcorrection will typically be negative */
dcorrection = VDOT( ap->a_ray.r_pt, viewZdir );
trip_count = 1;
}
}
/* This code is for diagnostics.
* bu_log("dcorrection=%g\n", dcorrection);
*/
/* dfirst and dlast have been made negative to account for GIFT looking
* in the opposite direction of RT.
*/
dfirst = -(PartHeadp->pt_forw->pt_inhit->hit_dist + dcorrection);
dlast = -(PartHeadp->pt_back->pt_outhit->hit_dist + dcorrection);
#if 0
/* This code is to note any occurances of negative distances. */
if ( PartHeadp->pt_forw->pt_inhit->hit_dist < 0) {
bu_log("ERROR: dfirst=%g at partition x%x\n", dfirst, PartHeadp->pt_forw );
bu_log("\tdcorrection = %f\n", dcorrection );
bu_log("\tray start point is ( %f %f %f ) in direction ( %f %f %f )\n", V3ARGS( ap->a_ray.r_pt ), V3ARGS( ap->a_ray.r_dir ) );
VJOIN1( PartHeadp->pt_forw->pt_inhit->hit_point, ap->a_ray.r_pt, PartHeadp->pt_forw->pt_inhit->hit_dist, ap->a_ray.r_dir );
VJOIN1( PartHeadp->pt_back->pt_outhit->hit_point, ap->a_ray.r_pt, PartHeadp->pt_forw->pt_outhit->hit_dist, ap->a_ray.r_dir );
rt_pr_partitions(ap->a_rt_i, PartHeadp, "Defective partion:");
}
/* End of bug trap. */
#endif
/*
* Output the ray header. The GIFT statements that
* would have generated this are:
* 410 write(1, 411) hcen, vcen, h, v, ncomp, dfirst, dlast, a, e
* 411 format(2f7.1, 2f9.3, i3, 2f8.2,' A', f6.1,' E', f6.1)
*/
#define SHOT_FMT "%7.1f%7.1f%9.3f%9.3f%3d%8.2f%8.2f A%6.1f E%6.1f"
if ( rt_perspective > 0 ) {
bn_ae_vec( &azimuth, &elevation, ap->a_ray.r_dir );
}
bu_vls_printf( &str, SHOT_FMT,
hvcen[0], hvcen[1],
hv[0], hv[1],
comp_count,
dfirst * MM2IN, dlast * MM2IN,
azimuth, elevation );
/*
* As an aid to debugging, take advantage of the fact that
* there are more than 80 columns on UNIX "cards", and
* add debugging information to the end of the line to
* allow this shotline to be reproduced offline.
* -b gives the shotline x, y coordinates when re-running RTG3,
* -p and -d are used with RTSHOT
* The easy way to activate this is with the harmless -!1 option
* when running RTG3.
*/
if ( R_DEBUG || bu_debug || RT_G_DEBUG ) {
bu_vls_printf( &str, " -b%d,%d -p %26.20e %26.20e %26.20e -d %26.20e %26.20e %26.20e\n",
ap->a_x, ap->a_y,
V3ARGS(ap->a_ray.r_pt),
V3ARGS(ap->a_ray.r_dir) );
} else {
bu_vls_putc( &str, '\n' );
}
/* loop here to deal with individual components */
card_count = 0;
prev_id = -1;
first = 1;
for ( pp=PartHeadp->pt_forw; pp!=PartHeadp; pp=pp->pt_forw ) {
/*
* The GIFT statements that would have produced
* this output are:
* do 632 i=icomp, iend
* if (clos(icomp).gt.999.99.or.slos(i).gt.999.9) goto 635
* 632 continue
* write(1, 633)(item(i), clos(i), cangi(i), cango(i),
* & kspac(i), slos(i), i=icomp, iend)
* 633 format(1x, 3(i4, f6.2, 2f5.1, i1, f5.1))
* goto 670
* 635 write(1, 636)(item(i), clos(i), cangi(i), cango(i),
* & kspac(i), slos(i), i=icomp, iend)
* 636 format(1x, 3(i4, f6.1, 2f5.1, i1, f5.0))
*/
fastf_t comp_thickness; /* component line of sight thickness */
fastf_t in_obliq; /* in obliquity angle */
fastf_t out_obliq; /* out obliquity angle */
int region_id; /* solid region's id */
int air_id; /* air id */
fastf_t dot_prod; /* dot product of normal and ray dir */
fastf_t air_thickness; /* air line of sight thickness */
vect_t normal; /* surface normal */
register struct partition *nextpp = pp->pt_forw;
region_id = pp->pt_regionp->reg_regionid;
if ( region_id <= 0 && prev_id > 0 )
{
/* air region output with previous partition */
prev_id = region_id;
continue;
}
comp_thickness = pp->pt_outhit->hit_dist -
pp->pt_inhit->hit_dist;
/* The below code is meant to catch components with zero or
* negative thicknesses. This is not supposed to be possible,
* but the condition has been seen.
*/
#if 0
if ( comp_thickness <= 0 ) {
VJOIN1( pp->pt_inhit->hit_point, ap->a_ray.r_pt, pp->pt_inhit->hit_dist, ap->a_ray.r_dir );
VJOIN1( pp->pt_outhit->hit_point, ap->a_ray.r_pt, pp->pt_outhit->hit_dist, ap->a_ray.r_dir );
bu_log("ERROR: comp_thickness=%g for region id = %d at h=%g, v=%g (x=%d, y=%d), partition at x%x\n",
comp_thickness, region_id, hv[0], hv[1], ap->a_x, ap->a_y, pp );
rt_pr_partitions(ap->a_rt_i, PartHeadp, "Defective partion:");
bu_log("Send this output to the BRL-CAD Developers ([email protected])\n");
if ( ! (RT_G_DEBUG & DEBUG_ARB8)) {
rt_g.debug |= DEBUG_ARB8;
rt_shootray(ap);
rt_g.debug &= ~DEBUG_ARB8;
}
}
#endif
if ( nextpp == PartHeadp ) {
if ( region_id <= 0 ) {
/* last partition is air, need a 111 'phantom armor' before AND after */
bu_log( "WARNING: adding 'phantom armor' (id=111) with zero thickness before and after air region %s\n",
pp->pt_regionp->reg_name );
region_id = 111;
air_id = pp->pt_regionp->reg_aircode;
air_thickness = comp_thickness;
comp_thickness = 0.0;
} else {
/* Last partition, no air follows, use code 9 */
air_id = 9;
air_thickness = 0.0;
}
} else if ( region_id <= 0 ) {
/* air region, need a 111 'phantom armor' */
bu_log( "WARNING: adding 'phantom armor' (id=111) with zero thickness before air region %s\n",
pp->pt_regionp->reg_name );
prev_id = region_id;
region_id = 111;
air_id = pp->pt_regionp->reg_aircode;
air_thickness = comp_thickness;
comp_thickness = 0.0;
} else if ( nextpp->pt_regionp->reg_regionid <= 0 &&
nextpp->pt_regionp->reg_aircode != 0 ) {
/* Next partition is air region */
air_id = nextpp->pt_regionp->reg_aircode;
air_thickness = nextpp->pt_outhit->hit_dist -
nextpp->pt_inhit->hit_dist;
prev_id = air_id;
} else {
/* 2 solid regions, maybe with gap */
air_id = 0;
air_thickness = nextpp->pt_inhit->hit_dist -
pp->pt_outhit->hit_dist;
if ( air_thickness < 0.0 )
air_thickness = 0.0;
if ( !NEAR_ZERO( air_thickness, 0.1 ) ) {
air_id = 1; /* air gap */
if ( R_DEBUG & RDEBUG_HITS )
bu_log("air gap added\n");
} else {
air_thickness = 0.0;
}
prev_id = region_id;
}
/*
* Compute the obliquity angles in degrees, ie,
* the "declension" angle down off the normal vector.
* RT normals always point outwards;
* the "inhit" normal points opposite the ray direction,
* the "outhit" normal points along the ray direction.
* Hence the one sign change.
* XXX this should probably be done with atan2()
*/
if ( first ) {
first = 0;
VJOIN1( first_hit, ap->a_ray.r_pt, pp->pt_inhit->hit_dist, ap->a_ray.r_dir );
}
out:
RT_HIT_NORMAL( normal, pp->pt_inhit, pp->pt_inseg->seg_stp, &(ap->a_ray), pp->pt_inflip );
dot_prod = VDOT( ap->a_ray.r_dir, normal );
if ( dot_prod > 1.0 )
dot_prod = 1.0;
if ( dot_prod < -1.0 )
dot_prod = (-1.0);
in_obliq = acos( -dot_prod ) *
bn_radtodeg;
RT_HIT_NORMAL( normal, pp->pt_outhit, pp->pt_outseg->seg_stp, &(ap->a_ray), pp->pt_outflip );
dot_prod = VDOT( ap->a_ray.r_dir, normal );
if ( dot_prod > 1.0 )
dot_prod = 1.0;
if ( dot_prod < -1.0 )
dot_prod = (-1.0);
out_obliq = acos( dot_prod ) *
bn_radtodeg;
/* Check for exit obliquties greater than 90 degrees. */
#if 0
if ( in_obliq > 90 || in_obliq < 0 ) {
bu_log("ERROR: in_obliquity=%g\n", in_obliq);
rt_pr_partitions(ap->a_rt_i, PartHeadp, "Defective partion:");
}
if ( out_obliq > 90 || out_obliq < 0 ) {
bu_log("ERROR: out_obliquity=%g\n", out_obliq);
VPRINT(" r_dir", ap->a_ray.r_dir);
VPRINT("normal", normal);
bu_log("dot=%g, acos(dot)=%g\n",
VDOT( ap->a_ray.r_dir, normal ),
acos( VDOT( ap->a_ray.r_dir, normal ) ) );
/* Print the defective one */
rt_pr_pt( ap->a_rt_i, pp );
/* Print the whole ray's partition list */
rt_pr_partitions(ap->a_rt_i, PartHeadp, "Defective partion:");
}
#endif
if ( in_obliq > 90.0 )
in_obliq = 90.0;
if ( in_obliq < 0.0 )
in_obliq = 0.0;
if ( out_obliq > 90.0 )
out_obliq = 90.0;
if ( out_obliq < 0.0 )
out_obliq = 0.0;
/*
* Handle 3-components per card output format, with
* a leading space in front of the first component.
*/
if ( card_count == 0 ) {
bu_vls_strcat( &str, " " );
}
comp_thickness *= MM2IN;
/* Check thickness fields for format overflow */
if ( comp_thickness > 999.99 || air_thickness*MM2IN > 999.9 )
fmt = "%4d%6.1f%5.1f%5.1f%1d%5.0f";
else
fmt = "%4d%6.2f%5.1f%5.1f%1d%5.1f";
#ifdef SPRINTF_NOT_PARALLEL
bu_semaphore_acquire( BU_SEM_SYSCALL );
#endif
snprintf(buf, 128, fmt,
region_id,
comp_thickness,
in_obliq, out_obliq,
air_id, air_thickness*MM2IN );
#ifdef SPRINTF_NOT_PARALLEL
bu_semaphore_release( BU_SEM_SYSCALL );
#endif
bu_vls_strcat( &str, buf );
card_count++;
if ( card_count >= 3 ) {
bu_vls_strcat( &str, "\n" );
card_count = 0;
}
/* A color rtg3.pl UnixPlot file of output commands
* is generated. This is processed by plot(1)
* plotting filters such as pl-fb or pl-sgi.
* Portions of a ray passing through air within the
* model are represented in blue, while portions
* passing through a solid are assigned green.
* This will always be done single CPU,
* to prevent output garbling. (See view_init).
*/
if (R_DEBUG & RDEBUG_RAYPLOT) {
vect_t inpt;
vect_t outpt;
VJOIN1(inpt, ap->a_ray.r_pt, pp->pt_inhit->hit_dist,
ap->a_ray.r_dir);
VJOIN1(outpt, ap->a_ray.r_pt, pp->pt_outhit->hit_dist,
ap->a_ray.r_dir);
pl_color(plotfp, 0, 255, 0); /* green */
pdv_3line(plotfp, inpt, outpt);
if (air_thickness > 0) {
vect_t air_end;
VJOIN1(air_end, ap->a_ray.r_pt,
pp->pt_outhit->hit_dist + air_thickness,
ap->a_ray.r_dir);
pl_color(plotfp, 0, 0, 255); /* blue */
pdv_3cont(plotfp, air_end);
}
}
if ( nextpp == PartHeadp && air_id != 9 ) {
/* need to output a 111 'phantom armor' at end of shotline */
air_id = 9;
air_thickness = 0.0;
region_id = 111;
comp_thickness = 0.0;
goto out;
}
}
/* If partway through building the line, add a newline */
if ( card_count > 0 ) {
/*
* Note that GIFT zero-fills the unused component slots,
* but neither COVART II nor COVART III require it,
* so just end the line here.
*/
bu_vls_strcat( &str, "\n" );
}
/* Single-thread through file output.
* COVART will accept non-sequential ray data provided the
* ray header and its associated data are not separated. CAVEAT:
* COVART will not accept headers out of sequence.
*/
bu_semaphore_acquire( BU_SEM_SYSCALL );
fputs( bu_vls_addr( &str ), outfp );
if ( shot_fp )
{
fprintf( shot_fp, "%.5f %.5f %.5f %.5f %.5f %.5f %.5f %.5f %ld %.5f %.5f %.5f\n",
azimuth, elevation, V3ARGS( ap->a_ray.r_pt ), V3ARGS( ap->a_ray.r_dir ),
line_num, V3ARGS( first_hit) );
line_num += 1 + (comp_count / 3 );
if ( comp_count % 3 )
line_num++;
}
/* End of single-thread region */
bu_semaphore_release( BU_SEM_SYSCALL );
/* Release vls storage */
bu_vls_free( &str );
return(0);
}
/*
* D O _ R E G I O N _ E N D
*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *do_region_end(register struct db_tree_state *tsp, struct db_full_path *pathp, union tree *curtree, genptr_t client_data)
{
union tree *ret_tree;
struct nmgregion *r;
struct bu_list vhead;
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
BU_LIST_INIT(&vhead);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_done * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
/* Begin bomb protection */
if ( ncpu == 1 ) {
if ( BU_SETJUMP ) {
/* Error, bail out */
BU_UNSETJUMP; /* Relinquish the protection */
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before bombing out.
*/
rt_g.NMG_debug = NMG_debug; /* restore mode */
/* Release the tree memory & input regions */
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
/* Get rid of (m)any other intermediate structures */
if ( (*tsp->ts_m)->magic != -1L )
nmg_km(*tsp->ts_m);
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
goto out;
}
}
(void)nmg_model_fuse(*tsp->ts_m, tsp->ts_tol);
ret_tree = nmg_booltree_evaluate(curtree, tsp->ts_tol, &rt_uniresource); /* librt/nmg_bool.c */
BU_UNSETJUMP; /* Relinquish the protection */
if ( ret_tree )
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
regions_done++;
if (r != 0) {
FILE *fp_psurf;
int i;
struct bu_vls file_base;
struct bu_vls file;
bu_vls_init(&file_base);
bu_vls_init(&file);
bu_vls_strcpy(&file_base, prefix);
bu_vls_strcat(&file_base, DB_FULL_PATH_CUR_DIR(pathp)->d_namep);
/* Dots confuse Jack's Peabody language. Change to '_'. */
for (i = 0; i < file_base.vls_len; i++)
if (file_base.vls_str[i] == '.')
file_base.vls_str[i] = '_';
/* Write color attribute to .fig figure file. */
if (tsp->ts_mater.ma_color_valid != 0) {
fprintf(fp_fig, "\tattribute %s {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\trgb = (%f, %f, %f);\n",
V3ARGS(tsp->ts_mater.ma_color));
fprintf(fp_fig, "\t\tambient = 0.18;\n");
fprintf(fp_fig, "\t\tdiffuse = 0.72;\n");
fprintf(fp_fig, "\t}\n");
}
/* Write segment attributes to .fig figure file. */
fprintf(fp_fig, "\tsegment %s_seg {\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tpsurf=\"%s.pss\";\n", bu_vls_addr(&file_base));
if (tsp->ts_mater.ma_color_valid != 0)
fprintf(fp_fig,
"\t\tattribute=%s;\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tsite base->location=trans(0, 0, 0);\n");
fprintf(fp_fig, "\t}\n");
if ( bu_vls_strlen(&base_seg) <= 0 ) {
bu_vls_vlscat( &base_seg, &file_base );
} else {
fprintf(fp_fig, "\tjoint %s_jt {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig,
"\t\tconnect %s_seg.base to %s_seg.base;\n",
bu_vls_addr(&file_base),
bu_vls_addr(&base_seg) );
fprintf(fp_fig, "\t}\n");
}
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pss"); /* Required Jack suffix. */
/* Write psurf to .pss file. */
if ((fp_psurf = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
nmg_to_psurf(r, fp_psurf);
fclose(fp_psurf);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
/* Also write as UNIX-plot file, if desired */
if ( debug_plots ) {
FILE *fp;
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pl");
if ((fp = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
struct bu_list vhead;
pl_color( fp,
(int)(tsp->ts_mater.ma_color[0] * 255),
(int)(tsp->ts_mater.ma_color[1] * 255),
(int)(tsp->ts_mater.ma_color[2] * 255) );
/* nmg_pl_r( fp, r ); */
BU_LIST_INIT( &vhead );
nmg_r_to_vlist( &vhead, r, 0 );
rt_vlist_to_uplot( fp, &vhead );
fclose(fp);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
}
/* NMG region is no longer necessary */
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
out:
BU_GETUNION(curtree, tree);
curtree->magic = RT_TREE_MAGIC;
curtree->tr_op = OP_NOP;
return(curtree);
}
int hit(register struct application *ap, struct partition *PartHeadp, struct seg *segp)
{
register struct partition *pp;
register struct soltab *stp;
struct curvature cur;
fastf_t out;
point_t inpt, outpt;
vect_t inormal, onormal;
if ( (pp=PartHeadp->pt_forw) == PartHeadp )
return(0); /* Nothing hit?? */
if ( overlap_claimant_handling == 1 )
rt_rebuild_overlaps( PartHeadp, ap, 1 );
else if ( overlap_claimant_handling == 2 )
rt_rebuild_overlaps( PartHeadp, ap, 0 );
/* First, plot ray start to inhit */
if ( R_DEBUG&RDEBUG_RAYPLOT ) {
if ( pp->pt_inhit->hit_dist > 0.0001 ) {
VJOIN1( inpt, ap->a_ray.r_pt,
pp->pt_inhit->hit_dist, ap->a_ray.r_dir );
pl_color( plotfp, 0, 0, 255 );
pdv_3line( plotfp, ap->a_ray.r_pt, inpt );
}
}
for (; pp != PartHeadp; pp = pp->pt_forw ) {
matp_t inv_mat;
Tcl_HashEntry *entry;
bu_log("\n--- Hit region %s (in %s, out %s) reg_bit = %d\n",
pp->pt_regionp->reg_name,
pp->pt_inseg->seg_stp->st_name,
pp->pt_outseg->seg_stp->st_name,
pp->pt_regionp->reg_bit);
entry = Tcl_FindHashEntry( (Tcl_HashTable *)ap->a_rt_i->Orca_hash_tbl,
(const char *)(size_t)pp->pt_regionp->reg_bit );
if ( !entry ) {
inv_mat = (matp_t)NULL;
}
else {
inv_mat = (matp_t)Tcl_GetHashValue( entry );
bn_mat_print( "inv_mat", inv_mat );
}
if ( pp->pt_overlap_reg )
{
struct region *pp_reg;
int j=-1;
bu_log( " Claiming regions:\n" );
while ( (pp_reg=pp->pt_overlap_reg[++j]) )
bu_log( " %s\n", pp_reg->reg_name );
}
/* inhit info */
stp = pp->pt_inseg->seg_stp;
VJOIN1( inpt, ap->a_ray.r_pt, pp->pt_inhit->hit_dist, ap->a_ray.r_dir );
RT_HIT_NORMAL( inormal, pp->pt_inhit, stp, &(ap->a_ray), pp->pt_inflip );
RT_CURVATURE( &cur, pp->pt_inhit, pp->pt_inflip, stp );
rt_pr_hit( " In", pp->pt_inhit );
VPRINT( " Ipoint", inpt );
VPRINT( " Inormal", inormal );
bu_log( " PDir (%g, %g, %g) c1=%g, c2=%g\n",
V3ARGS(cur.crv_pdir), cur.crv_c1, cur.crv_c2);
if ( inv_mat ) {
point_t in_trans;
MAT4X3PNT( in_trans, inv_mat, inpt );
bu_log( "\ttransformed ORCA inhit = (%g %g %g)\n", V3ARGS( in_trans ) );
}
/* outhit info */
stp = pp->pt_outseg->seg_stp;
VJOIN1( outpt, ap->a_ray.r_pt, pp->pt_outhit->hit_dist, ap->a_ray.r_dir );
RT_HIT_NORMAL( onormal, pp->pt_outhit, stp, &(ap->a_ray), pp->pt_outflip );
RT_CURVATURE( &cur, pp->pt_outhit, pp->pt_outflip, stp );
rt_pr_hit( " Out", pp->pt_outhit );
VPRINT( " Opoint", outpt );
VPRINT( " Onormal", onormal );
bu_log( " PDir (%g, %g, %g) c1=%g, c2=%g\n",
V3ARGS(cur.crv_pdir), cur.crv_c1, cur.crv_c2);
if ( inv_mat ) {
point_t out_trans;
vect_t dir_trans;
MAT4X3PNT( out_trans, inv_mat, outpt );
MAT4X3VEC( dir_trans, inv_mat, ap->a_ray.r_dir );
VUNITIZE( dir_trans );
bu_log( "\ttranformed ORCA outhit = (%g %g %g)\n", V3ARGS( out_trans ) );
bu_log( "\ttransformed ORCA ray direction = (%g %g %g)\n", V3ARGS( dir_trans ) );
}
/* Plot inhit to outhit */
if ( R_DEBUG&RDEBUG_RAYPLOT ) {
if ( (out = pp->pt_outhit->hit_dist) >= INFINITY )
out = 10000; /* to imply the direction */
VJOIN1( outpt,
ap->a_ray.r_pt, out,
ap->a_ray.r_dir );
pl_color( plotfp, 0, 255, 255 );
pdv_3line( plotfp, inpt, outpt );
}
{
struct region *regp = pp->pt_regionp;
int i;
if ( ap->attrs ) {
bu_log( "\tattribute values:\n" );
i = 0;
while ( ap->attrs[i] && regp->attr_values[i] ) {
bu_log( "\t\t%s:\n", ap->attrs[i] );
bu_log( "\t\t\tstring rep = %s\n",
BU_MRO_GETSTRING(regp->attr_values[i]));
bu_log( "\t\t\tlong rep = %d\n",
BU_MRO_GETLONG(regp->attr_values[i]));
bu_log( "\t\t\tdouble rep = %f\n",
BU_MRO_GETDOUBLE(regp->attr_values[i]));
i++;
}
}
}
}
return(1);
}
/*
* D O _ R E G I O N _ E N D
*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *do_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, genptr_t UNUSED(client_data))
{
union tree *ret_tree;
struct nmgregion *r;
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_done * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
ret_tree = process_boolean(curtree, tsp, pathp);
if ( ret_tree )
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
regions_done++;
if (r != 0) {
FILE *fp_psurf;
size_t i;
struct bu_vls file_base = BU_VLS_INIT_ZERO;
struct bu_vls file = BU_VLS_INIT_ZERO;
bu_vls_strcpy(&file_base, prefix);
bu_vls_strcat(&file_base, DB_FULL_PATH_CUR_DIR(pathp)->d_namep);
/* Dots confuse Jack's Peabody language. Change to '_'. */
for (i = 0; i < file_base.vls_len; i++)
if (file_base.vls_str[i] == '.')
file_base.vls_str[i] = '_';
/* Write color attribute to .fig figure file. */
if (tsp->ts_mater.ma_color_valid != 0) {
fprintf(fp_fig, "\tattribute %s {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\trgb = (%f, %f, %f);\n",
V3ARGS(tsp->ts_mater.ma_color));
fprintf(fp_fig, "\t\tambient = 0.18;\n");
fprintf(fp_fig, "\t\tdiffuse = 0.72;\n");
fprintf(fp_fig, "\t}\n");
}
/* Write segment attributes to .fig figure file. */
fprintf(fp_fig, "\tsegment %s_seg {\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tpsurf=\"%s.pss\";\n", bu_vls_addr(&file_base));
if (tsp->ts_mater.ma_color_valid != 0)
fprintf(fp_fig,
"\t\tattribute=%s;\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tsite base->location=trans(0, 0, 0);\n");
fprintf(fp_fig, "\t}\n");
if ( bu_vls_strlen(&base_seg) <= 0 ) {
bu_vls_vlscat( &base_seg, &file_base );
} else {
fprintf(fp_fig, "\tjoint %s_jt {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig,
"\t\tconnect %s_seg.base to %s_seg.base;\n",
bu_vls_addr(&file_base),
bu_vls_addr(&base_seg) );
fprintf(fp_fig, "\t}\n");
}
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pss"); /* Required Jack suffix. */
/* Write psurf to .pss file. */
if ((fp_psurf = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
nmg_to_psurf(r, fp_psurf);
fclose(fp_psurf);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
/* Also write as UNIX-plot file, if desired */
if ( debug_plots ) {
FILE *fp;
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pl");
if ((fp = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
struct bu_list vhead;
pl_color( fp,
(int)(tsp->ts_mater.ma_color[0] * 255),
(int)(tsp->ts_mater.ma_color[1] * 255),
(int)(tsp->ts_mater.ma_color[2] * 255) );
/* nmg_pl_r( fp, r ); */
BU_LIST_INIT( &vhead );
nmg_r_to_vlist( &vhead, r, 0 );
rt_vlist_to_uplot( fp, &vhead );
fclose(fp);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
}
/* NMG region is no longer necessary */
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
return curtree;
}
/*
* R R _ R E N D E R
*/
int
rr_render(register struct application *ap,
const struct partition *pp,
struct shadework *swp)
{
struct application sub_ap;
vect_t work;
vect_t incident_dir;
fastf_t shader_fract;
fastf_t reflect;
fastf_t transmit;
#ifdef RT_MULTISPECTRAL
struct bn_tabdata *ms_filter_color = BN_TABDATA_NULL;
struct bn_tabdata *ms_shader_color = BN_TABDATA_NULL;
struct bn_tabdata *ms_reflect_color = BN_TABDATA_NULL;
struct bn_tabdata *ms_transmit_color = BN_TABDATA_NULL;
#else
vect_t filter_color;
vect_t shader_color;
vect_t reflect_color;
vect_t transmit_color;
#endif
fastf_t attenuation;
vect_t to_eye;
int code;
RT_AP_CHECK(ap);
RT_APPLICATION_INIT(&sub_ap);
#ifdef RT_MULTISPECTRAL
sub_ap.a_spectrum = BN_TABDATA_NULL;
ms_reflect_color = bn_tabdata_get_constval(0.0, spectrum);
#endif
/*
* sw_xmitonly is set primarily for light visibility rays.
* Need to compute (partial) transmission through to the light,
* or procedural shaders won't be able to cast shadows
* and light won't be able to get through glass
* (including "stained glass" and "filter glass").
*
* On the other hand, light visibility rays shouldn't be refracted,
* it is pointless to shoot at where the light isn't.
*/
if (swp->sw_xmitonly) {
/* Caller wants transmission term only, don't fire reflected rays */
transmit = swp->sw_transmit + swp->sw_reflect; /* Don't loose energy */
reflect = 0;
} else {
reflect = swp->sw_reflect;
transmit = swp->sw_transmit;
}
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render(%s) START: lvl=%d reflect=%g, transmit=%g, xmitonly=%d\n",
pp->pt_regionp->reg_name,
ap->a_level,
reflect, transmit,
swp->sw_xmitonly);
}
if (reflect <= 0 && transmit <= 0)
goto out;
if (ap->a_level > max_bounces) {
/* Nothing more to do for this ray */
static long count = 0; /* Not PARALLEL, should be OK */
if ((R_DEBUG&(RDEBUG_SHOWERR|RDEBUG_REFRACT)) && (
count++ < MSG_PROLOGUE ||
(count%MSG_INTERVAL) == 3
)) {
bu_log("rr_render: %d, %d MAX BOUNCES=%d: %s\n",
ap->a_x, ap->a_y,
ap->a_level,
pp->pt_regionp->reg_name);
}
/*
* Return the basic color of the object, ignoring the
* the fact that it is supposed to be
* filtering or reflecting light here.
* This is much better than returning just black,
* but something better might be done.
*/
#ifdef RT_MULTISPECTRAL
BN_CK_TABDATA(swp->msw_color);
BN_CK_TABDATA(swp->msw_basecolor);
bn_tabdata_copy(swp->msw_color, swp->msw_basecolor);
#else
VMOVE(swp->sw_color, swp->sw_basecolor);
#endif
ap->a_cumlen += pp->pt_inhit->hit_dist;
goto out;
}
#ifdef RT_MULTISPECTRAL
BN_CK_TABDATA(swp->msw_basecolor);
ms_filter_color = bn_tabdata_dup(swp->msw_basecolor);
#else
VMOVE(filter_color, swp->sw_basecolor);
#endif
if ((swp->sw_inputs & (MFI_HIT|MFI_NORMAL)) != (MFI_HIT|MFI_NORMAL))
shade_inputs(ap, pp, swp, MFI_HIT|MFI_NORMAL);
/*
* If this ray is being fired from the exit point of
* an object, and is directly entering another object,
* (i.e., there is no intervening air-gap), and
* the two refractive indices match, then do not fire a
* reflected ray -- just take the transmission contribution.
* This is important, e.g., for glass gun tubes projecting
* through a glass armor plate. :-)
*/
if (NEAR_ZERO(pp->pt_inhit->hit_dist, AIR_GAP_TOL)
&& ZERO(ap->a_refrac_index - swp->sw_refrac_index))
{
transmit += reflect;
reflect = 0;
}
/*
* Diminish base color appropriately, and add in
* contributions from mirror reflection & transparency
*/
shader_fract = 1 - (reflect + transmit);
if (shader_fract < 0) {
shader_fract = 0;
} else if (shader_fract >= 1) {
goto out;
}
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: lvl=%d start shader=%g, reflect=%g, transmit=%g %s\n",
ap->a_level,
shader_fract, reflect, transmit,
pp->pt_regionp->reg_name);
}
#ifdef RT_MULTISPECTRAL
BN_GET_TABDATA(ms_shader_color, swp->msw_color->table);
bn_tabdata_scale(ms_shader_color, swp->msw_color, shader_fract);
#else
VSCALE(shader_color, swp->sw_color, shader_fract);
#endif
/*
* Compute transmission through an object.
* There may be a mirror reflection, which will be handled
* by the reflection code later
*/
if (transmit > 0) {
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: lvl=%d transmit=%g. Calculate refraction at entrance to %s.\n",
ap->a_level, transmit,
pp->pt_regionp->reg_name);
}
/*
* Calculate refraction at entrance.
*/
sub_ap = *ap; /* struct copy */
#ifdef RT_MULTISPECTRAL
sub_ap.a_spectrum = bn_tabdata_dup((struct bn_tabdata *)ap->a_spectrum);
#endif
sub_ap.a_level = 0; /* # of internal reflections */
sub_ap.a_cumlen = 0; /* distance through the glass */
sub_ap.a_user = -1; /* sanity */
sub_ap.a_rbeam = ap->a_rbeam + swp->sw_hit.hit_dist * ap->a_diverge;
sub_ap.a_diverge = 0.0;
sub_ap.a_uptr = (genptr_t)(pp->pt_regionp);
VMOVE(sub_ap.a_ray.r_pt, swp->sw_hit.hit_point);
VMOVE(incident_dir, ap->a_ray.r_dir);
/* If there is an air gap, reset ray's RI to air */
if (pp->pt_inhit->hit_dist > AIR_GAP_TOL)
sub_ap.a_refrac_index = RI_AIR;
if (!ZERO(sub_ap.a_refrac_index - swp->sw_refrac_index)
&& !rr_refract(incident_dir, /* input direction */
swp->sw_hit.hit_normal, /* exit normal */
sub_ap.a_refrac_index, /* current RI */
swp->sw_refrac_index, /* next RI */
sub_ap.a_ray.r_dir /* output direction */
))
{
/*
* Ray was mirror reflected back outside solid.
* Just add contribution to reflection,
* and quit.
*/
reflect += transmit;
transmit = 0;
#ifdef RT_MULTISPECTRAL
ms_transmit_color = bn_tabdata_get_constval(0.0, spectrum);
#else
VSETALL(transmit_color, 0);
#endif
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: lvl=%d change xmit into reflection %s\n",
ap->a_level,
pp->pt_regionp->reg_name);
}
goto do_reflection;
}
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: lvl=%d begin transmission through %s.\n",
ap->a_level,
pp->pt_regionp->reg_name);
}
/*
* Find new exit point from the inside.
* We will iterate, but not recurse, due to the special
* (non-recursing) hit and miss routines used here for
* internal reflection.
*
* a_onehit is set to 3, so that where possible,
* rr_hit() will be given three accurate hit points:
* the entry and exit points of this glass region,
* and the entry point into the next region.
* This permits calculation of the departing
* refraction angle based on the RI of the current and
* *next* regions along the ray.
*/
sub_ap.a_purpose = "rr first glass transmission ray";
sub_ap.a_flag = 0;
do_inside:
sub_ap.a_hit = rr_hit;
sub_ap.a_miss = rr_miss;
sub_ap.a_logoverlap = ap->a_logoverlap;
sub_ap.a_onehit = 3;
sub_ap.a_rbeam = ap->a_rbeam + swp->sw_hit.hit_dist * ap->a_diverge;
sub_ap.a_diverge = 0.0;
switch (code = rt_shootray(&sub_ap)) {
case 3:
/* More glass to come.
* uvec=exit_pt, vvec=N, a_refrac_index = next RI.
*/
break;
case 2:
/* No more glass to come.
* uvec=exit_pt, vvec=N, a_refrac_index = next RI.
*/
break;
case 1:
/* Treat as escaping ray */
if (R_DEBUG&RDEBUG_REFRACT)
bu_log("rr_refract: Treating as escaping ray\n");
goto do_exit;
case 0:
default:
/* Dreadful error */
#ifdef RT_MULTISPECTRAL
bu_bomb("rr_refract: Stuck in glass. Very green pixel, unsupported in multi-spectral mode\n");
#else
VSET(swp->sw_color, 0, 99, 0); /* very green */
#endif
goto out; /* abandon hope */
}
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: calculating refraction @ exit from %s (green)\n", pp->pt_regionp->reg_name);
bu_log("Start point to exit point:\n\
vdraw open rr;vdraw params c 00ff00; vdraw write n 0 %g %g %g; vdraw wwrite n 1 %g %g %g; vdraw send\n",
V3ARGS(sub_ap.a_ray.r_pt),
V3ARGS(sub_ap.a_uvec));
}
/* NOTE: rr_hit returns EXIT Point in sub_ap.a_uvec,
* and returns EXIT Normal in sub_ap.a_vvec,
* and returns next RI in sub_ap.a_refrac_index
*/
if (R_DEBUG&RDEBUG_RAYWRITE) {
wraypts(sub_ap.a_ray.r_pt,
sub_ap.a_ray.r_dir,
sub_ap.a_uvec,
2, ap, stdout); /* 2 = ?? */
}
if (R_DEBUG&RDEBUG_RAYPLOT) {
/* plotfp */
bu_semaphore_acquire(BU_SEM_SYSCALL);
pl_color(stdout, 0, 255, 0);
pdv_3line(stdout,
sub_ap.a_ray.r_pt,
sub_ap.a_uvec);
bu_semaphore_release(BU_SEM_SYSCALL);
}
/* Advance. Exit point becomes new start point */
VMOVE(sub_ap.a_ray.r_pt, sub_ap.a_uvec);
VMOVE(incident_dir, sub_ap.a_ray.r_dir);
/*
* Calculate refraction at exit point.
* Use "look ahead" RI value from rr_hit.
*/
if (!ZERO(sub_ap.a_refrac_index - swp->sw_refrac_index)
&& !rr_refract(incident_dir, /* input direction */
sub_ap.a_vvec, /* exit normal */
swp->sw_refrac_index, /* current RI */
sub_ap.a_refrac_index, /* next RI */
sub_ap.a_ray.r_dir /* output direction */
))
{
static long count = 0; /* not PARALLEL, should be OK */
/* Reflected internally -- keep going */
if ((++sub_ap.a_level) <= max_ireflect) {
sub_ap.a_purpose = "rr reflected internal ray, probing for glass exit point";
sub_ap.a_flag = 0;
goto do_inside;
}
/*
* Internal Reflection limit exceeded -- just let
* the ray escape, continuing on current course.
* This will cause some energy from somewhere in the
* scene to be received through this glass,
* which is much better than just returning
* grey or black, as before.
*/
if ((R_DEBUG&(RDEBUG_SHOWERR|RDEBUG_REFRACT)) && (
count++ < MSG_PROLOGUE ||
(count%MSG_INTERVAL) == 3
)) {
bu_log("rr_render: %d, %d Int.reflect=%d: %s lvl=%d\n",
sub_ap.a_x, sub_ap.a_y,
sub_ap.a_level,
pp->pt_regionp->reg_name,
ap->a_level);
}
VMOVE(sub_ap.a_ray.r_dir, incident_dir);
goto do_exit;
}
do_exit:
/*
* Compute internal spectral transmittance.
* Bouger's law. pg 30 of "color science"
*
* Apply attenuation factor due to thickness of the glass.
* sw_extinction is in terms of fraction of light absorbed
* per linear meter of glass. a_cumlen is in mm.
*/
/* XXX extinction should be a spectral curve, not scalor */
if (swp->sw_extinction > 0 && sub_ap.a_cumlen > 0) {
attenuation = pow(10.0, -1.0e-3 * sub_ap.a_cumlen *
swp->sw_extinction);
} else {
attenuation = 1;
}
/*
* Process the escaping refracted ray.
* This is the only place we might recurse dangerously,
* so we are careful to use our caller's recursion level+1.
* NOTE: point & direction already filled in
*/
sub_ap.a_hit = ap->a_hit;
sub_ap.a_miss = ap->a_miss;
sub_ap.a_logoverlap = ap->a_logoverlap;
sub_ap.a_onehit = ap->a_onehit;
sub_ap.a_level = ap->a_level+1;
sub_ap.a_uptr = ap->a_uptr;
sub_ap.a_rbeam = ap->a_rbeam + swp->sw_hit.hit_dist * ap->a_diverge;
sub_ap.a_diverge = 0.0;
if (code == 3) {
sub_ap.a_purpose = "rr recurse on next glass";
sub_ap.a_flag = 0;
} else {
sub_ap.a_purpose = "rr recurse on escaping internal ray";
sub_ap.a_flag = 1;
sub_ap.a_onehit = sub_ap.a_onehit > -3 ? -3 : sub_ap.a_onehit;
}
/* sub_ap.a_refrac_index was set to RI of next material by rr_hit().
*/
sub_ap.a_cumlen = 0;
(void) rt_shootray(&sub_ap);
/* a_user has hit/miss flag! */
if (sub_ap.a_user == 0) {
#ifdef RT_MULTISPECTRAL
ms_transmit_color = bn_tabdata_dup(background);
#else
VMOVE(transmit_color, background);
#endif
sub_ap.a_cumlen = 0;
} else {
#ifdef RT_MULTISPECTRAL
ms_transmit_color = bn_tabdata_dup(sub_ap.a_spectrum);
#else
VMOVE(transmit_color, sub_ap.a_color);
#endif
}
transmit *= attenuation;
#ifdef RT_MULTISPECTRAL
bn_tabdata_mul(ms_transmit_color, ms_filter_color, ms_transmit_color);
#else
VELMUL(transmit_color, filter_color, transmit_color);
#endif
if (R_DEBUG&RDEBUG_REFRACT) {
bu_log("rr_render: lvl=%d end of xmit through %s\n",
ap->a_level,
pp->pt_regionp->reg_name);
}
} else {
static int
plot_setFGColor(struct dm *dmp, unsigned char r, unsigned char g, unsigned char b, int strict, fastf_t transparency)
{
pl_color(((struct plot_vars *)dmp->dm_vars.priv_vars)->up_fp, (int)r, (int)g, (int)b);
return TCL_OK;
}
