HIDDEN int
mem_view(FBIO *ifp, int xcenter, int ycenter, int xzoom, int yzoom)
{
fb_sim_view(ifp, xcenter, ycenter, xzoom, yzoom);
if (MI(ifp)->write_thru) {
return fb_view(MI(ifp)->fbp, xcenter, ycenter,
xzoom, yzoom);
}
return 0;
}
int
fb_window(FBIO *ifp, int x, int y)
{
int xcenter, ycenter;
int xzoom, yzoom;
if (ifp) {
FB_CK_FBIO(ifp);
fb_getview(ifp, &xcenter, &ycenter, &xzoom, &yzoom);
xcenter = x;
ycenter = y;
return fb_view(ifp, xcenter, ycenter, xzoom, yzoom);
} else {
return 0;
}
}
/*
* M A I N
*/
int main(int argc, char **argv)
{
struct rt_i *rtip = NULL;
char *title_file = NULL, *title_obj = NULL; /* name of file and first object */
char idbuf[RT_BUFSIZE] = {0}; /* First ID record info */
void application_init();
struct bu_vls times;
int i;
#if defined(_WIN32) && !defined(__CYGWIN__)
setmode(fileno(stdin), O_BINARY);
setmode(fileno(stdout), O_BINARY);
setmode(fileno(stderr), O_BINARY);
#else
bu_setlinebuf( stdout );
bu_setlinebuf( stderr );
#endif
#ifdef HAVE_SBRK
beginptr = (char *) sbrk(0);
#endif
azimuth = 35.0; /* GIFT defaults */
elevation = 25.0;
AmbientIntensity=0.4;
background[0] = background[1] = 0.0;
background[2] = 1.0/255.0; /* slightly non-black */
/* Before option processing, get default number of processors */
npsw = bu_avail_cpus(); /* Use all that are present */
if ( npsw > MAX_PSW ) npsw = MAX_PSW;
/* Before option processing, do application-specific initialization */
RT_APPLICATION_INIT( &ap );
application_init();
/* Process command line options */
if ( !get_args( argc, argv ) ) {
(void)fputs(usage, stderr);
return 1;
}
/* Identify the versions of the libraries we are using. */
if (rt_verbosity & VERBOSE_LIBVERSIONS) {
(void)fprintf(stderr, "%s%s%s%s\n",
brlcad_ident(title),
rt_version(),
bn_version(),
bu_version()
);
}
#if defined(DEBUG)
(void)fprintf(stderr, "Compile-time debug symbols are available\n");
#endif
#if defined(NO_BOMBING_MACROS) || defined(NO_MAGIC_CHECKING) || defined(NO_BADRAY_CECHKING) || defined(NO_DEBUG_CHECKING)
(void)fprintf(stderr, "WARNING: Run-time debugging is disabled and may enhance performance\n");
#endif
/* Identify what host we're running on */
if (rt_verbosity & VERBOSE_LIBVERSIONS) {
char hostname[512] = {0};
#ifndef _WIN32
if ( gethostname( hostname, sizeof(hostname) ) >= 0 &&
hostname[0] != '\0' )
(void)fprintf(stderr, "Running on %s\n", hostname);
#else
sprintf(hostname, "Microsoft Windows");
(void)fprintf(stderr, "Running on %s\n", hostname);
#endif
}
if ( bu_optind >= argc ) {
fprintf(stderr, "%s: MGED database not specified\n", argv[0]);
(void)fputs(usage, stderr);
return 1;
}
if (rpt_overlap)
ap.a_logoverlap = ((void (*)())0);
else
ap.a_logoverlap = rt_silent_logoverlap;
/* If user gave no sizing info at all, use 512 as default */
if ( width <= 0 && cell_width <= 0 )
width = 512;
if ( height <= 0 && cell_height <= 0 )
height = 512;
/* If user didn't provide an aspect ratio, use the image
* dimensions ratio as a default.
*/
if (aspect <= 0.0) {
aspect = (fastf_t)width / (fastf_t)height;
}
if ( sub_grid_mode ) {
/* check that we have a legal subgrid */
if ( sub_xmax >= width || sub_ymax >= height ) {
fprintf( stderr, "rt: illegal values for subgrid %d,%d,%d,%d\n",
sub_xmin, sub_ymin, sub_xmax, sub_ymax );
fprintf( stderr, "\tFor a %d X %d image, the subgrid must be within 0, 0,%d,%d\n",
width, height, width-1, height-1 );
return 1;
}
}
if ( incr_mode ) {
int x = height;
if ( x < width ) x = width;
incr_nlevel = 1;
while ( (1<<incr_nlevel) < x )
incr_nlevel++;
height = width = 1<<incr_nlevel;
if (rt_verbosity & VERBOSE_INCREMENTAL)
fprintf(stderr,
"incremental resolution, nlevels = %d, width=%d\n",
incr_nlevel, width);
}
/*
* Handle parallel initialization, if applicable.
*/
#ifndef PARALLEL
npsw = 1; /* force serial */
#endif
if ( npsw < 0 ) {
/* Negative number means "all but" npsw */
npsw = bu_avail_cpus() + npsw;
}
/* allow debug builds to go higher than the max */
if (!(bu_debug & BU_DEBUG_PARALLEL)) {
if ( npsw > MAX_PSW ) {
npsw = MAX_PSW;
}
}
if (npsw > 1) {
rt_g.rtg_parallel = 1;
if (rt_verbosity & VERBOSE_MULTICPU)
fprintf(stderr, "Planning to run with %d processors\n", npsw );
} else {
rt_g.rtg_parallel = 0;
}
/* Initialize parallel processor support */
bu_semaphore_init( RT_SEM_LAST );
/*
* Do not use bu_log() or bu_malloc() before this point!
*/
if ( bu_debug ) {
bu_printb( "libbu bu_debug", bu_debug, BU_DEBUG_FORMAT );
bu_log("\n");
}
if ( RT_G_DEBUG ) {
bu_printb( "librt rt_g.debug", rt_g.debug, DEBUG_FORMAT );
bu_log("\n");
}
if ( rdebug ) {
bu_printb( "rt rdebug", rdebug, RDEBUG_FORMAT );
bu_log("\n");
}
/* We need this to run rt_dirbuild */
rt_init_resource( &rt_uniresource, MAX_PSW, NULL );
bn_rand_init( rt_uniresource.re_randptr, 0 );
title_file = argv[bu_optind];
title_obj = argv[bu_optind+1];
nobjs = argc - bu_optind - 1;
objtab = &(argv[bu_optind+1]);
if ( nobjs <= 0 ) {
bu_log("%s: no objects specified -- raytrace aborted\n", argv[0]);
return 1;
}
/* Echo back the command line arugments as given, in 3 Tcl commands */
if (rt_verbosity & VERBOSE_MODELTITLE) {
struct bu_vls str;
bu_vls_init(&str);
bu_vls_from_argv( &str, bu_optind, (const char **)argv );
bu_vls_strcat( &str, "\nopendb " );
bu_vls_strcat( &str, title_file );
bu_vls_strcat( &str, ";\ntree " );
bu_vls_from_argv( &str,
nobjs <= 16 ? nobjs : 16,
(const char **)argv+bu_optind+1 );
if ( nobjs > 16 )
bu_vls_strcat( &str, " ...");
else
bu_vls_putc( &str, ';' );
bu_log("%s\n", bu_vls_addr(&str) );
bu_vls_free(&str);
}
/* Build directory of GED database */
bu_vls_init( × );
rt_prep_timer();
if ( (rtip=rt_dirbuild(title_file, idbuf, sizeof(idbuf))) == RTI_NULL ) {
bu_log("rt: rt_dirbuild(%s) failure\n", title_file);
return 2;
}
ap.a_rt_i = rtip;
(void)rt_get_timer( ×, NULL );
if (rt_verbosity & VERBOSE_MODELTITLE)
bu_log("db title: %s\n", idbuf);
if (rt_verbosity & VERBOSE_STATS)
bu_log("DIRBUILD: %s\n", bu_vls_addr(×) );
bu_vls_free( × );
memory_summary();
/* Copy values from command line options into rtip */
rtip->rti_space_partition = space_partition;
rtip->rti_nugrid_dimlimit = nugrid_dimlimit;
rtip->rti_nu_gfactor = nu_gfactor;
rtip->useair = use_air;
rtip->rti_save_overlaps = save_overlaps;
if ( rt_dist_tol > 0 ) {
rtip->rti_tol.dist = rt_dist_tol;
rtip->rti_tol.dist_sq = rt_dist_tol * rt_dist_tol;
}
if ( rt_perp_tol > 0 ) {
rtip->rti_tol.perp = rt_perp_tol;
rtip->rti_tol.para = 1 - rt_perp_tol;
}
if (rt_verbosity & VERBOSE_TOLERANCE)
rt_pr_tol( &rtip->rti_tol );
/* before view_init */
if ( outputfile && strcmp( outputfile, "-") == 0 )
outputfile = (char *)0;
/*
* Initialize application.
* Note that width & height may not have been set yet,
* since they may change from frame to frame.
*/
if ( view_init( &ap, title_file, title_obj, outputfile!=(char *)0, framebuffer!=(char *)0 ) != 0 ) {
/* Framebuffer is desired */
register int xx, yy;
int zoom;
/* Ask for a fb big enough to hold the image, at least 512. */
/* This is so MGED-invoked "postage stamps" get zoomed up big enough to see */
xx = yy = 512;
if ( width > xx || height > yy ) {
xx = width;
yy = height;
}
bu_semaphore_acquire( BU_SEM_SYSCALL );
fbp = fb_open( framebuffer, xx, yy );
bu_semaphore_release( BU_SEM_SYSCALL );
if ( fbp == FBIO_NULL ) {
fprintf(stderr, "rt: can't open frame buffer\n");
return 12;
}
bu_semaphore_acquire( BU_SEM_SYSCALL );
/* If fb came out smaller than requested, do less work */
if ( fb_getwidth(fbp) < width ) width = fb_getwidth(fbp);
if ( fb_getheight(fbp) < height ) height = fb_getheight(fbp);
/* If the fb is lots bigger (>= 2X), zoom up & center */
if ( width > 0 && height > 0 ) {
zoom = fb_getwidth(fbp)/width;
if ( fb_getheight(fbp)/height < zoom )
zoom = fb_getheight(fbp)/height;
} else {
zoom = 1;
}
(void)fb_view( fbp, width/2, height/2,
zoom, zoom );
bu_semaphore_release( BU_SEM_SYSCALL );
}
if ( (outputfile == (char *)0) && (fbp == FBIO_NULL) ) {
/* If not going to framebuffer, or to a file, then use stdout */
if ( outfp == NULL ) outfp = stdout;
/* output_is_binary is changed by view_init, as appropriate */
if ( output_is_binary && isatty(fileno(outfp)) ) {
fprintf(stderr, "rt: attempting to send binary output to terminal, aborting\n");
return 14;
}
}
/*
* Initialize all the per-CPU memory resources.
* The number of processors can change at runtime, init them all.
*/
for ( i=0; i < MAX_PSW; i++ ) {
rt_init_resource( &resource[i], i, rtip );
bn_rand_init( resource[i].re_randptr, i );
}
memory_summary();
#ifdef SIGUSR1
(void)signal( SIGUSR1, siginfo_handler );
#endif
#ifdef SIGINFO
(void)signal( SIGINFO, siginfo_handler );
#endif
if ( !matflag ) {
int frame_retval;
def_tree( rtip ); /* Load the default trees */
do_ae( azimuth, elevation );
frame_retval = do_frame( curframe );
if (frame_retval != 0) {
/* Release the framebuffer, if any */
if ( fbp != FBIO_NULL ) {
fb_close(fbp);
}
return 1;
}
} else if ( !isatty(fileno(stdin)) && old_way( stdin ) ) {
; /* All is done */
} else {
register char *buf;
register int ret;
/*
* New way - command driven.
* Process sequence of input commands.
* All the work happens in the functions
* called by rt_do_cmd().
*/
while ( (buf = rt_read_cmd( stdin )) != (char *)0 ) {
if ( R_DEBUG&RDEBUG_PARSE )
fprintf(stderr, "cmd: %s\n", buf );
ret = rt_do_cmd( rtip, buf, rt_cmdtab );
bu_free( buf, "rt_read_cmd command buffer" );
if ( ret < 0 )
break;
}
if ( curframe < desiredframe ) {
fprintf(stderr,
"rt: Desired frame %d not reached, last was %d\n",
desiredframe, curframe);
}
}
/* Release the framebuffer, if any */
if (fbp != FBIO_NULL) {
fb_close(fbp);
}
return(0);
}
int
main(int argc, char **argv)
{
int y;
FBIO *fbp;
int xout, yout, n, m, xstart, xskip;
if (!get_args(argc, argv)) {
(void)fputs(usage, stderr);
bu_exit(1, NULL);
}
/* autosize input? */
if (fileinput && autosize) {
size_t w, h;
if (fb_common_file_size(&w, &h, file_name, 3)) {
file_width = w;
file_height = h;
} else {
fprintf(stderr, "pix-fb: unable to autosize\n");
}
}
/* If screen size was not set, track the file size */
if (scr_width == 0)
scr_width = file_width;
if (scr_height == 0)
scr_height = file_height;
if ((fbp = fb_open(framebuffer, scr_width, scr_height)) == NULL) {
bu_exit(12, NULL);
}
/* Get the screen size we were given */
scr_width = fb_getwidth(fbp);
scr_height = fb_getheight(fbp);
/* compute number of pixels to be output to screen */
if (scr_xoff < 0) {
xout = scr_width + scr_xoff;
xskip = (-scr_xoff);
xstart = 0;
} else {
xout = scr_width - scr_xoff;
xskip = 0;
xstart = scr_xoff;
}
if (xout < 0)
bu_exit(0, NULL); /* off screen */
if ((size_t)xout > (file_width-file_xoff))
xout = (file_width-file_xoff);
scanpix = xout; /* # pixels on scanline */
if (inverse)
scr_yoff = (-scr_yoff);
yout = scr_height - scr_yoff;
if (yout < 0)
bu_exit(0, NULL); /* off screen */
if ((size_t)yout > (file_height-file_yoff))
yout = (file_height-file_yoff);
/* Only in the simplest case use multi-line writes */
if (!one_line_only
&& multiple_lines > 0
&& !inverse
&& !zoom
&& (size_t)xout == file_width
&& file_width <= (size_t)scr_width)
{
scanpix *= multiple_lines;
}
scanbytes = scanpix * sizeof(RGBpixel);
if ((scanline = (unsigned char *)malloc(scanbytes)) == RGBPIXEL_NULL) {
fprintf(stderr,
"pix-fb: malloc(%d) failure for scanline buffer\n",
scanbytes);
bu_exit(2, NULL);
}
if (clear) {
fb_clear(fbp, PIXEL_NULL);
}
if (zoom) {
/* Zoom in, and center the display. Use square zoom. */
int zoomit;
zoomit = scr_width/xout;
if (scr_height/yout < zoomit) zoomit = scr_height/yout;
if (inverse) {
fb_view(fbp,
scr_xoff+xout/2, scr_height-1-(scr_yoff+yout/2),
zoomit, zoomit);
} else {
fb_view(fbp,
scr_xoff+xout/2, scr_yoff+yout/2,
zoomit, zoomit);
}
}
if (file_yoff != 0) skipbytes(infd, (off_t)file_yoff*(off_t)file_width*sizeof(RGBpixel));
if (multiple_lines) {
/* Bottom to top with multi-line reads & writes */
unsigned long height;
for (y = scr_yoff; y < scr_yoff + yout; y += multiple_lines) {
n = bu_mread(infd, (char *)scanline, scanbytes);
if (n <= 0) break;
height = multiple_lines;
if (n != scanbytes) {
height = (n/sizeof(RGBpixel)+xout-1)/xout;
if (height <= 0) break;
}
/* Don't over-write */
if ((size_t)(y + height) > (size_t)(scr_yoff + yout))
height = scr_yoff + yout - y;
if (height <= 0) break;
m = fb_writerect(fbp, scr_xoff, y,
file_width, height,
scanline);
if ((size_t)m != file_width*height) {
fprintf(stderr,
"pix-fb: fb_writerect(x=%d, y=%d, w=%lu, h=%lu) failure, ret=%d, s/b=%d\n",
scr_xoff, y,
(unsigned long)file_width, height, m, scanbytes);
}
}
} else if (!inverse) {
/* Normal way -- bottom to top */
for (y = scr_yoff; y < scr_yoff + yout; y++) {
if (y < 0 || y > scr_height) {
skipbytes(infd, (off_t)file_width*sizeof(RGBpixel));
continue;
}
if (file_xoff+xskip != 0)
skipbytes(infd, (off_t)(file_xoff+xskip)*sizeof(RGBpixel));
n = bu_mread(infd, (char *)scanline, scanbytes);
if (n <= 0) break;
m = fb_write(fbp, xstart, y, scanline, xout);
if (m != xout) {
fprintf(stderr,
"pix-fb: fb_write(x=%d, y=%d, npix=%d) ret=%d, s/b=%d\n",
scr_xoff, y, xout,
m, xout);
}
/* slop at the end of the line? */
if ((size_t)file_xoff+xskip+scanpix < file_width)
skipbytes(infd, (off_t)(file_width-file_xoff-xskip-scanpix)*sizeof(RGBpixel));
}
} else {
/* Inverse -- top to bottom */
for (y = scr_height-1-scr_yoff; y >= scr_height-scr_yoff-yout; y--) {
if (y < 0 || y >= scr_height) {
skipbytes(infd, (off_t)file_width*sizeof(RGBpixel));
continue;
}
if (file_xoff+xskip != 0)
skipbytes(infd, (off_t)(file_xoff+xskip)*sizeof(RGBpixel));
n = bu_mread(infd, (char *)scanline, scanbytes);
if (n <= 0) break;
m = fb_write(fbp, xstart, y, scanline, xout);
if (m != xout) {
fprintf(stderr,
"pix-fb: fb_write(x=%d, y=%d, npix=%d) ret=%d, s/b=%d\n",
scr_xoff, y, xout,
m, xout);
}
/* slop at the end of the line? */
if ((size_t)file_xoff+xskip+scanpix < file_width)
skipbytes(infd, (off_t)(file_width-file_xoff-xskip-scanpix)*sizeof(RGBpixel));
}
}
sleep(pause_sec);
if (fb_close(fbp) < 0) {
fprintf(stderr, "pix-fb: Warning: fb_close() error\n");
}
return 0;
}
