/*
 * Copyright (C) 1997-2008, R3vis Corporation.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA,
 * or visit http://www.gnu.org/copyleft/gpl.html.
 *
 * Contributor(s):
 *   Wes Bethel, R3vis Corporation, Marin County, California
 *
 * The OpenRM project is located at http://openrm.sourceforge.net/.
 */
/*
 * $Id: vis3d.c,v 1.18 2008/11/09 14:37:04 wes Exp $
 * $Revision: 1.18 $
 * $Name: v180-alpha-01 $
 * $Log: vis3d.c,v $
 * Revision 1.18  2008/11/09 14:37:04  wes
 * Update dates to 2008
 *
 * Revision 1.17  2007/07/22 17:37:47  wes
 * Added usrData and usrCallback parameters to all rmv routines
 *
 * Revision 1.16  2006/08/08 03:49:21  wes
 * Updates to reflect ergonomic changes to rmaux
 *
 * Revision 1.15  2005/06/08 15:52:18  wes
 * Code cleanup to eliminate compiler warnings.
 *
 * Revision 1.14  2005/05/16 01:18:56  wes
 * Use RMpipe-level fbclear operators.
 *
 * Revision 1.13  2004/01/17 03:20:31  wes
 * Added command line arguments [-fr NN] and [-spin] to enable constant-rate
 * rendering and auto-spin mode, respectively. Also, turned off the printing
 * of per-frame statistics because the timings aren't correct on all platforms.
 *
 * Revision 1.12  2003/10/15 05:46:34  wes
 * Added -flip command line argument to enable normal flipping on
 * certain visualization techniques.
 *
 * Revision 1.11  2003/04/13 18:13:23  wes
 * Updated copyright dates.
 *
 * Revision 1.10  2003/01/27 05:07:07  wes
 * Changes to RMpipe initialization sequence APIs. Tested for GLX, but not WGL.
 *
 * Revision 1.9  2003/01/16 22:22:45  wes
 * Updated all source files to reflect new organization of header files: all
 * headers that were formerly located in include/rmaux, include/rmv and
 * include/rmi are now located in include/rm.
 *
 * Revision 1.8  2002/06/17 00:47:21  wes
 * Added -noauto command line flag. This will turn off auto normalization
 * of surface normals.
 *
 * Revision 1.7  2001/07/15 22:33:19  wes
 * Added rmPipeDelete to the end of all demo progs. For those that use
 * an initfunc, added a new RMnode * parm (which is unused, except for rm2screen).
 *
 * Revision 1.6  2001/06/03 19:44:05  wes
 * Add calls to new rmaux routines to handle window resize events, and
 * for keyboard event handling.
 *
 * Revision 1.5  2001/03/31 16:55:18  wes
 * Added procmode.h, which defines an RMpipe processing mode used in
 * most demonstration programs. The default processing mode is
 * RM_PIPE_MULTISTAGE_VIEW_PARALLEL.
 *
 * Revision 1.4  2000/12/02 17:24:32  wes
 * Version 1.4.0-alpha-1 checkin. See the RELEASENOTES file for
 * a summary of changes. With this checkin, these demo programs
 * are no longer compatible with versions of the OpenRM API that
 * are pre-1.4.0.
 *
 * Revision 1.3  2000/08/28 01:38:18  wes
 * Updated rmaux* interfaces - rmauxEventLoop now takes two additional
 * parameters (keypress and window resize app callbacks); replaced
 * rmauxUI with rmauxSetGeomTransform and, where appropriate,
 * rmauxSetCamera3DTransform.
 *
 * Revision 1.2  2000/04/20 18:04:34  wes
 * Minor tweaks and reorg for OpenRM 1.2.1.
 *
 * Revision 1.1.1.1  2000/02/28 21:55:30  wes
 * OpenRM 1.2 Release
 *
 * Revision 1.11  2000/02/28 17:21:56  wes
 * RM 1.2, pre-OpenRM
 *
 */

#include <rm/rm.h>
#include <rm/rmaux.h>
#include <rm/rmv.h>
#include "libdio.h"
#include "procmode.h"

static char MyRootName[]={"MyRoot"};
static RMnode *MyRoot;
int img_width=400,img_height=300;
char datafilename[256]={"data/func10.dio"};
dioDataObject *mydataobj=NULL;
int do_color=0;
int do_print=0;
int do_backstop=0;
int vis_technique=0;
int doAutoNormalize=1;
RMenum my_linewidth = RM_LINEWIDTH_MEDIUM;
RMenum my_linestyle = RM_LINES_SOLID;
int do_bg_image=0;
RMimage *bgimage=NULL;
RMenum flipNormalsBool = RM_FALSE;
RMenum spinModeEnabled = RM_FALSE;
int frameRate = -1;

void
usage(char *av[])
{
    char buf[2048];
    sprintf(buf," usage: %s [-i datafilename (defaults to data/func10.dio) [-w img_width] [-h img_height] [-c (use default vis colormap to 'colorize' the plot') [-v n (where n=0..11, and indicates which visualization technique to use)] [-bs (make a 'vanishing backstop') [-bg (tile the background with the AVS image data/orangegrid.x))] [-p (print the scene graph to stderr)] [-noauto (turn off autonormalization of mesh surface generated by vis technique] [-flip (flip the normals generated by vis techniques 0 and 8, default is to not flip normals)] [-spin (turns on auto-spin mode, default is off)] [-fr NN (set frame rendering rate to NN frames per second, NN should be > 0; default is no constant-rate rendering)] \n",av[0]);

#ifdef RM_WIN
    MessageBox(NULL,buf,"vis3d",MB_OK);
#else
    rmError(buf);
#endif
}

void
parse_args(int ac,
	   char *av[])
{
    int i;

    i = 1;
    while (i < ac)
    {
	if (strcmp(av[i],"-w") == 0)
	{
	    i++;
	    sscanf(av[i],"%d",&img_width);
	}
	else if (strcmp(av[i],"-h") == 0)
        {
	    i++;
	    sscanf(av[i],"%d",&img_height);
	}
	else if (strcmp(av[i],"-i") == 0)
	{
	    i++;
	    strcpy(datafilename,av[i]);
	}
	else if (strcmp(av[i],"-c") == 0)
	{
	    do_color=1;
	}
	else if (strcmp(av[i],"-v") == 0)
	{
	    i++;
	    sscanf(av[i],"%d",&vis_technique);

	    if ((vis_technique < 0) || (vis_technique > 11))
	    {
		usage(av);
		exit(0);
	    }
	}
	else if (strcmp(av[i],"-bs") == 0)
	{
	    do_backstop = 1;
	}
	else if (strcmp(av[i],"-bg") == 0)
	{
	    do_bg_image = 1;
	    bgimage = dioReadAVSImage("data/orangegrid.x");   
	    if (bgimage == NULL)
	    {
		fprintf(stderr," there was some kind of error reading the image file. skipping it and continuing..\n");
		do_bg_image = 0;
	    }
	}
	else if (strcmp(av[i],"-p") == 0)
	    do_print = 1;
	else if (strcmp(av[i],"-noauto") == 0)
	{
	    fprintf(stderr," turning off autonormalization of surface normals when using visualization technique #1. \n");
	    doAutoNormalize = 0;
	}
	else if (strcmp(av[i],"-flip") == 0)
	{
	    fprintf(stderr," will flip any surface normals computed during visualization \n");
	    flipNormalsBool = RM_TRUE;
	}
	else if (strcmp(av[i],"-spin") == 0)
	{
	    spinModeEnabled = RM_TRUE;
	}
	else if (strcmp(av[i],"-fr") == 0)
	{
	    i++;
	    sscanf(av[i],"%d",&frameRate);
	}
	else
	{
	    usage(av);
	    exit(-1);
	}
	i++;
    }
}


void
my_read_data(char *datafilename)
{
    mydataobj = dioReadDataObject(datafilename);
    if (mydataobj == NULL)
    {
	fprintf(stderr," error reading input data file. exiting. \n");
	exit(-1);
    }
    dioObjectConditioner(mydataobj);
}

void
my_set_scene(RMnode *camNode,
	     int stereo_format,
	     RMpipe *p)
{
      
    RMcamera3D *c=rmCamera3DNew();
    
    rmDefaultCamera3D(c);		/* assign it some default values. */

    /* adjust default view so all geom is visible */
    rmCamera3DComputeViewFromGeometry(c,MyRoot, img_width, img_height);
    /*
     * uncomment the following line to get orthographic projection
     */
/*    rmCamera3DSetProjection(c,RM_PROJECTION_ORTHOGRAPHIC);  */

    if (stereo_format != RM_MONO_CHANNEL)
    {
	rmCamera3DSetStereo(c,RM_TRUE);
	rmCamera3DSetEyeSeparation(c,2.5F);
	rmCamera3DSetFocalDistance (c,0.707F);
    }

    rmNodeSetSceneCamera3D(camNode,c);

    if (do_bg_image==1 && bgimage != NULL)
#if 1
	rmPipeSetSceneBackgroundImage(p, bgimage);
#else
        rmNodeSetSceneBackgroundImage(MyRoot,bgimage);
#endif
    else
    {
	RMcolor4D bgcolor={0.2,0.2,0.3,1.0};
#if 1
	rmPipeSetSceneBackgroundColor(p, &bgcolor);
#else
	rmNodeSetSceneBackgroundColor(MyRoot,&bgcolor);
#endif
    }

    rmCamera3DDelete(c);

    /* use RM's default lighting model */
    /*
     * adding the lights to the root node, but then affecting transformations
     * one level down has the effect of making the lights (directions,
     * position, etc.) immune from interactive transformations. in
     * other words, the lights stay at a fixed point in space regardless
     * of the orientation of the objects in the scene.
     */
	
    rmDefaultLighting(camNode);
}

/*
 * the following two routines are the interface between the RMV
 * vis tools and the local data model. RMV wants us to supply routines
 * which will tell the vis tool what the (x,y,z) point is at some grid
 * location, and what the data point is at some grid location.
 *
 * the local data model is very simple, so we can make simplifying
 * assumptions resulting in very terse routines.
 */
RMvertex3D
mygridfunc_u(int i,
	     void *usrData)
{
    /*
     * tell RMV what this grid (x,y,z) point is at location "i". we assume
     * a one-d grid of (x,y,z) points in the local data model.
     */
    RMvertex3D temp3d;
    
    temp3d.x = mydataobj->xcoords[i];
    temp3d.y = mydataobj->ycoords[i];
    temp3d.z = mydataobj->zcoords[i];
    return(temp3d);
}

RMvertex3D
mygridfunc_uv(int i,
	      int j,
	      void *usrData)
{
    /*
     * tell RMV what this grid (x,y,z) point is at location (i,j).
     * we assume the data model is sufficiently intelligent to know
     * it's own dimensions, and is capable of dealing with a two-dimensional
     * indexing system.
     *
     * we assume that the "i" index maps to width, and that "j"
     * maps to height in the local data model.
     */
    RMvertex3D temp3d;
    int indx;

    /*    indx = mydataobj->width * j + i; */
    indx = mydataobj->dims[0] * j + i;
    
    temp3d.x = mydataobj->xcoords[indx];
    temp3d.y = mydataobj->ycoords[indx];
    temp3d.z = mydataobj->zcoords[indx];
    
    return(temp3d);
}

float
mydatafunc_u(int i,
	     void *usrData)
{
    /*
     * tell RMV what the data value is at grid location "i". we
     * assume a one-d grid.
     */
    return(mydataobj->rawdata[i]);
}

float
mydatafunc_uv(int i,
	      int j,
	      void *usrData)
{
    /*
     * tell RMV what the data value is at grid location (i,j). we
     * assume a one-d grid.
     */
    int indx;

    indx = mydataobj->dims[0] * j + i;
    return(mydataobj->rawdata[indx]);
}

void
my_build_objs(void)
{
/*    MyRoot = rmNodeNew(MyRootName,RM_RENDERPASS_ALL, RM_RENDERPASS_ALL);  */
    MyRoot = rmNodeNew(MyRootName,RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);  
    rmNodeAddChild(rmRootNode(),MyRoot);
    
    /* do the visualization.. */
    {
	RMnode *visnode;
	int offset_flag;
	float *xcoords,*ycoords,*zcoords, *data,*data2;
	int usize,vsize;
	float zeroval=0.0;
	float shrink = 0.8;
	RMvisMap *vmap=NULL;

	/* we assume that one and only one of w,h,d is equal to 1 */
	
	if (mydataobj->height == 1)
	{
	    /* width & depth are != 1, so offset from the y axis */
	    offset_flag = RMV_YAXIS_OFFSET;
	    usize = mydataobj->width;
	    vsize = mydataobj->depth;
	}
	else if (mydataobj->width == 1)
	{
	    /* height & depth are != 1, so offset from the X axis */
	    offset_flag = RMV_XAXIS_OFFSET;
	    usize = mydataobj->height;
	    vsize = mydataobj->depth;
	}
	else			/* assume depth==1, offset from z axis */
	{
	    offset_flag = RMV_ZAXIS_OFFSET;
	    usize = mydataobj->width;
	    vsize = mydataobj->height;
	}

	if (do_color)
	{
	    vmap = rmDefaultVismap();

	    rmVismapSetTfMin(vmap,mydataobj->datamin);
	    rmVismapSetTfMax(vmap,mydataobj->datamax);
	    data2 = mydataobj->rawdata;
	}

	visnode = rmNodeNew("vis", RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);

	xcoords = mydataobj->xcoords;
	ycoords = mydataobj->ycoords;
	zcoords = mydataobj->zcoords;
	data = mydataobj->rawdata;


	switch(vis_technique)
	{
	case 0:
	    rmvJ3MeshSurface(mygridfunc_uv, NULL, 
			     mydatafunc_uv, NULL,
			     (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			     vmap,
			     offset_flag,
			     usize,vsize,
			     flipNormalsBool,
			     visnode);
	    if (doAutoNormalize == 1)
		rmNodeSetNormalizeNormals(visnode, RM_TRUE);
	    else
		rmNodeSetNormalizeNormals(visnode, RM_FALSE);
	    break;


	case 1:
	    {
		int scaling_flag = RMV_SCALE_RELATIVE;
		shrink = 0.6F;
		rmvJ3Bar(mygridfunc_uv, NULL,
			 mydatafunc_uv, NULL,
			 (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			 vmap,
			 offset_flag,
			 usize,vsize,
			 shrink,
			 scaling_flag,
			 visnode);
	        break;
	    }

	case 2:
	    {
		int scaling_flag = RMV_SCALE_ABSOLUTE;
		
		shrink = 0.5;
		
		rmvJ3BarOutline(mygridfunc_uv, NULL,
				mydatafunc_uv, NULL,
				(vmap == NULL) ? NULL : mydatafunc_uv, NULL,
				vmap,
				offset_flag,
				usize,vsize,
				shrink,
				scaling_flag,
				my_linewidth,
				my_linestyle,
				visnode);
	        break;
	    }

	case 3:
	    rmvJ3Impulse(mygridfunc_uv, NULL,
			 mydatafunc_uv, NULL,
			 (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			 vmap,
			 offset_flag,
			 usize,vsize,
			 my_linewidth,
			 my_linestyle,
			 visnode);
	    
	    break;

	    
	case 4:
	    rmvJ3MeshOutline(mygridfunc_uv, NULL,
			     mydatafunc_uv, NULL,
			     (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			     vmap,
			     offset_flag, usize, vsize, my_linewidth,
			     my_linestyle, visnode);
	    break;

	case 5:
	    rmvJ3MeshUHorizon(mygridfunc_uv, NULL,
			      mydatafunc_uv, NULL,
			      (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			      vmap,
			      offset_flag, usize, vsize, zeroval,visnode);


	    rmvJ3MeshUHorizonOutline(mygridfunc_uv, NULL,
				     mydatafunc_uv, NULL,
				     NULL, NULL, NULL,
				     offset_flag, usize, vsize, 
				     my_linewidth, my_linestyle,
				     zeroval, visnode);

	    
	    break;

	case 6:
	    rmvJ3MeshVHorizon(mygridfunc_uv, NULL,
			      mydatafunc_uv, NULL,
			      (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			      vmap,
			      offset_flag, usize, vsize, zeroval,visnode);


	    rmvJ3MeshVHorizonOutline(mygridfunc_uv, NULL,
				     mydatafunc_uv, NULL,
				     NULL, NULL, NULL,
				     offset_flag, usize, vsize, 
				     my_linewidth, my_linestyle,
				     zeroval, visnode);

	    break;

	case 7:
	    {
		shrink = 1.0;
		
		rmvI3ScatterCube(mygridfunc_u, NULL,
				 mydatafunc_u, NULL,
				 (vmap == NULL) ? NULL : mydatafunc_u, NULL,
				 vmap,
				 offset_flag, usize*vsize,
				 shrink,
				 visnode);
	        break;
	    }


	case 8:
	    rmvJ3ScatterPoint(mygridfunc_uv, NULL,
			      mydatafunc_uv, NULL,
			      (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
			      vmap,
			      offset_flag,
			      usize, vsize, RM_TRUE, flipNormalsBool, visnode);
	    
	    rmNodeSetPointSize(visnode,5.0F);
	    
	    break;

	case 9:
	    rmvI3ScatterSphere(mygridfunc_u, NULL,
			       mydatafunc_u, NULL,
			       (vmap == NULL) ? NULL: mydatafunc_u, NULL,
			       vmap,offset_flag, usize*vsize, shrink,
			       visnode);
	    break;

	case 10:
	    {
		shrink = 1.0;
		
		rmvI3ScatterWireCube(mygridfunc_u, NULL,
				     mydatafunc_u, NULL,
				     (vmap == NULL) ? NULL : mydatafunc_u, NULL,
				     vmap, offset_flag, usize* vsize, shrink,
				     my_linewidth,my_linestyle, visnode);
	        break;
	    }

	case 11:
	    {
		float clevels[3];
		int nlevels = 3;
		RMcolor4D colors[3]=
		    {{0.6, 0.5, 0.9,1.0}, {0.8, 0.4, 0.4,1.0},
			 {1.0, 0.25, 0.25,1.0}};

		clevels[0] = mydataobj->datamin + 0.25 * (mydataobj->datamax - mydataobj->datamin);
		clevels[1] = mydataobj->datamin + 0.5 * (mydataobj->datamax - mydataobj->datamin);
		clevels[2] = mydataobj->datamin + 0.75 * (mydataobj->datamax - mydataobj->datamin);

		rmvJ3SliceContour(mygridfunc_uv, NULL,
				  mydatafunc_uv, NULL,
				  offset_flag,
				  usize, vsize, nlevels, clevels, colors,
				  my_linewidth, my_linestyle, visnode);

		rmvJ3MeshSurface(mygridfunc_uv, NULL,
				 mydatafunc_uv, NULL,
				 (vmap == NULL) ? NULL : mydatafunc_uv, NULL,
				 vmap, offset_flag, usize, vsize,
				 flipNormalsBool, visnode);

	        break;
	    }


	default:
	    break;
	}


	if (do_backstop)
        {
	    RMnode *bsnode;
	    RMvertex3D bmin,bmax;
	    float data_min,data_max;

	    bsnode = rmNodeNew("backstop-node",RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);
	    bmin = mygridfunc_uv(0, 0, NULL);
	    bmax = mygridfunc_uv(usize-1, vsize-1, NULL);
	    data_min = mydataobj->datamin;
	    data_max = mydataobj->datamax;

	    if (offset_flag == RMV_ZAXIS_OFFSET)
	    {
		bmin.z = data_min;
		bmax.z = data_max;
		rmv3DRuledBox(&bmin,&bmax,
			      usize,vsize,2,
			      my_linewidth, my_linestyle, 
			      RM_TRUE,
			      bsnode);
	    }
	    if (offset_flag == RMV_YAXIS_OFFSET)
	    {
		bmin.y = data_min;
		bmax.y = data_max;
		rmv3DRuledBox(&bmin,&bmax,
			      usize,2,vsize,
			      my_linewidth, my_linestyle,
			      RM_TRUE,
			      bsnode);
	    }
	    if (offset_flag == RMV_XAXIS_OFFSET)
	    {
		bmin.x = data_min;
		bmax.x = data_max;
		rmv3DRuledBox(&bmin,&bmax,
			      2,usize,vsize,
			      my_linewidth, my_linestyle,
			      RM_TRUE,
			      bsnode);
	    }
	    
	    rmNodeAddChild(MyRoot, bsnode);

	}

	rmNodeAddChild(MyRoot,visnode); 
	rmNodeComputeBoundingBox(visnode);
	rmNodeUnionAllBoxes(MyRoot);
	rmNodeComputeCenterFromBoundingBox(MyRoot);
	
	if (vmap != NULL)
	    rmVismapDelete(vmap);
    }

}

void
my_idle_func(RMpipe *p,
	     int ix,
	     int iy)
{
    RMmatrix m,old;
    double d,c,s;
    rmMatrixIdentity(&m);
    d = RM_DEGREES_TO_RADIANS(1.0);
    c = cos(d);
    s = sin(d);
    m.m[0][0] = m.m[2][2] = c;
    m.m[0][2] = -s;
    m.m[2][0] = s;
    
    if (rmNodeGetRotateMatrix(MyRoot,&old) == RM_WHACKED)
	rmMatrixIdentity(&old);
    rmMatrixMultiply(&old,&m,&old);
    rmNodeSetRotateMatrix(MyRoot,&old);

    /* foil compiler warning */
    ix = iy = 0;

    rmFrame(p, rmRootNode());
}

void
myinitfunc(RMpipe *p,
	   RMnode *n,
	   void *usrData)
{
    my_read_data(datafilename);
    my_build_objs();
    my_set_scene(n, rmPipeGetChannelFormat(p), p);
    rmauxSetGeomTransform(MyRoot, p);
    rmauxSetSpinEnable(spinModeEnabled);
    rmauxSetCamera3DTransform(n, p);

    /*
     * set handler to reset aspect ratio when the window is resized.
     */
    rmauxSetResizeFunc(p, n, rmauxDefaultResizeFunc);
    
    if (do_print == 1)		/* won't see output in win32 unless you change
				 NULL to a char string with a filename, then
				 the output will be written in ASCII format
				 to that file. */
	rmPrintSceneGraph(n, RM_PRINT_VERBOSE, NULL);

    rmStatsComputeDemography(n);
    
    if (rmPipeProcessingModeIsMultithreaded(p) == RM_TRUE)
	rmFrame(p, n);
    
    rmFrame(p, n);
}

int
myrenderfunc(RMpipe *p,
	     RMnode *n,
	     void *usrData)
{
    rmFrame(p, n);
#if 0

    /*
     * for 1.5.1 release, comment out the status stuff; the timing part of
     * the stats isn't always correct as we need to put glFinish() into
     * the mix, and doing so really slows down the app. If you're
     * interested in fps figures, check out the fpsVis3d demo.
     */
    rmStatsStartTime();
    rmFrame(p, n);
    rmStatsEndTime();
    rmStatsPrint();
#endif
    return 1;
}

#ifdef RM_WIN
int WINAPI WinMain (HINSTANCE hInstance,
		    HINSTANCE hPrevInstance,
                    LPSTR lpszCmdLine, int nCmdShow)
{
    MSG      msg; 
    HWND     hWnd; 
    void *fptr;
    RMenum channelFormat;
    RMenum processingMode = DEFAULT_PROCESSING_MODE; /* in procmode.h */
    RMpipe *lone_pipe = NULL;
    RMenum targetPlatform = RM_PIPE_WGL;

    /* 
     * first stage of RM initialization.
     */
    rmInit();
    
    parse_args(__argc, __argv);

#else  /* assume RM_X */
int
main(int ac,
     char *av[])
{
    RMenum channelFormat;
    RMenum processingMode = DEFAULT_PROCESSING_MODE; /* in procmode.h */
    RMpipe *lone_pipe = NULL;
    RMenum targetPlatform = RM_PIPE_GLX;
    void *msg;			/* needed for rmauxEventLoop
				 win32/unix API consistency */

    /* 
     * first stage of RM initialization.
     */
    rmInit();

    parse_args(ac, av);
#endif

    /* 
     * pick a stereo format:
     * RM_MONO_CHANNEL - plain old single-view
     * RM_REDBLUE_STEREO_CHANNEL - left channel in red, right channel in cyan
     * RM_BLUERED_STEREO_CHANNEL - left in cyan, right in red
     * RM_MBUF_STEREO_CHANNEL - multibuffered stereo, requires special
     *    hardware. 
     */
    channelFormat = RM_MONO_CHANNEL;

    /* 
     * create the rendering pipe. this step is required in both
     * Win32 and X.
     */

    lone_pipe = rmPipeNew(targetPlatform);

    rmPipeSetProcessingMode(lone_pipe, processingMode);
    rmPipeSetFrameRate(lone_pipe, frameRate);

#ifdef RM_WIN
    {

        /*
	 * Win32: when a window is created, we have to tell windows the
	 * name of the "WndProc," the procedure that gets called by
	 * windows with events (the event loop) (contrast to the X model 
	 * where the name of the event loop is not part of the window). 
	 * Since we're using RMaux, we know about the event handling 
	 * procedure named "rmauxWndProc" and we provide that here. 
	 */

        fptr = (void *)(rmauxWndProc);
	hWnd = rmauxCreateW32Window(lone_pipe,
			       NULL, /* no parent window */
			       20,20,img_width,img_height,"RM for Windows",
			       hInstance,fptr);
	if (hWnd == 0)
	  exit(-1);

	/* 
	 * assign the new window handle to the rendering pipe.
	 */
	rmPipeSetWindow(lone_pipe,hWnd, img_width, img_height);

    }
#endif
#ifdef RM_X
    {
	Window w;

	w = rmauxCreateXWindow(lone_pipe,
			       (Window)NULL, /* parent window */
			       0,0,img_width,img_height,
			       "RM for X-Windows","icon-title",RM_TRUE);
	/* 
	 * assign the window to the rendering pipe.
	 */
	rmPipeSetWindow(lone_pipe,w,img_width,img_height);

    }
#endif

    /* 
     * specify the name of the "init" function. the "init" function is
     * mandatory in the Win32 world, and optional in the X world. 
     *
     * in Win32, we don't want to call RM services until OpenGL is
     * ready. we can be assured of readiness by using an init function
     * with RMaux. 
     *
     * in X, at this point, the window is mapped and OpenGL is ready,
     * and we could call our init function directly.
     */

    rmauxSetInitCallbackFunc(myinitfunc, NULL); 

    /* uncomment this next line if you want the object to rotate
       while the user is idle. */
    /* rmauxSetIdleFunc(lone_pipe,my_idle_func); */
    
    /* 
     * X-ism: once the window is created and assigned to the 
     * rendering pipe, rmUsePipe makes the OpenGL rendering context
     * current for the pipe+window combination. 
     *
     * this step is required for X. in these demo programs, it is not 
     * strictly required by Win32, as the newly created context is made
     * current as part of the OpenGL initialization sequence.
     */
    rmPipeMakeCurrent(lone_pipe);	

    rmauxSetRenderCallbackFunc(myrenderfunc, NULL);
    
    /*
     * set key handler function so this prog will exit on "q" key.
     */
    rmauxSetKeypressCallbackFunc(rmauxDefaultKeyFunc, NULL);
    
    rmauxEventLoop(lone_pipe, rmRootNode(), &msg);

    rmPipeDelete(lone_pipe);
    rmFinish();

#ifdef RM_WIN
    return( msg.wParam );
#else
    return(1);
#endif
}
/* EOF */ 
