/*
 * Copyright (C) 1997-2005, 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: pdb.c,v 1.12 2005/06/08 17:00:37 wes Exp $
 * $Revision: 1.12 $
 * $Name: OpenRM-1-6-0-2-c $
 * $Log: pdb.c,v $
 * Revision 1.12  2005/06/08 17:00:37  wes
 * Code cleanup to eliminate compiler warnings.
 *
 * 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:40:26  wes
 * Added -s command line flag to generate per-frame statistics. replaced
 * rmSubtreeFrame with rmFrame.
 *
 * 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.9  2000/02/28 17:21:55  wes
 * RM 1.2, pre-OpenRM
 *
 */

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


static RMnode *MyRoot;
int img_width=400,img_height=300;
static char pdbfname[256] = {"data/1a30.pdb"};
static RMnode *sticknode, *spherenode;
RMenum static_stereo_format;
static int doStats = 0;

void
usage(char *s)
{
    char buf[128];
    sprintf(buf," usage: %s [-i pdbfilename (defaults to data/1a30.pdb)] [-w xxx (set image width, default is 400)] [-h yyy (set image height, default is 300)] [-s (turn on frame rate statistics)]\n",s);
    rmError(buf);
}

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

    while (i < ac)
    {
	if (strcmp(av[i],"-i") == 0)
	{
	    i++;
	    strcpy(pdbfname,av[i]);
	}
	if (strcmp(av[i],"-w") == 0)
	{
	    i++;
	    sscanf(av[i],"%d",&img_width);
	}
	if (strcmp(av[i],"-h") == 0)
	{
	    i++;
	    sscanf(av[i],"%d",&img_height);
	}
	if (strcmp(av[i], "-s") == 0)
	{
	    doStats = 1;
	}

	i++;
    }

    if (pdbfname == NULL)
    {
	usage(av[0]);
	exit(0);
    }
}

static RMimage *bg_image=NULL;

void
mycolorbuffunc(const RMimage *img,
	       RMenum whichbuffer_enum)
{
    bg_image = rmImageDup(img);
    rmImageMirror(bg_image,RM_IMAGE_MIRROR_HEIGHT);

    /* set the background image..this is the spheres */
    rmNodeSetSceneBackgroundImage(MyRoot, bg_image);

    /* turn off the background color */
    rmNodeSetSceneBackgroundColor(MyRoot, NULL);
    
    /* foil compiler warning */
    whichbuffer_enum = RM_TRUE;
}

static RMimage *depth_buffer_image=NULL;

void
mydepthbuffunc(const RMimage *img,
	       RMenum  whichbuffer_enum)
{
    depth_buffer_image = rmImageDup(img);
    rmImageMirror(depth_buffer_image,RM_IMAGE_MIRROR_HEIGHT);
    
    /* set the depth image at the root node.. */
    rmNodeSetSceneDepthImage(MyRoot,depth_buffer_image);

    /* and turn off depth clears */
    rmNodeSetSceneDepthValue(MyRoot, NULL);

    /* foil compiler warning */
    whichbuffer_enum = RM_TRUE;
}


void
my_set_scene(RMnode *camNode,
	     int stereo_format)
{
    /*
     * here, we compute the camera parameters such that all of
     * the geometry is visible.
     */
      
    RMcamera3D *c=rmCamera3DNew();

    /* assign a default view.. */
    rmDefaultCamera3D(c);

    /* adjust the default view so all geom is visible */
    rmCamera3DComputeViewFromGeometry(c,MyRoot,img_width,img_height);

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

    }

    rmNodeSetSceneCamera3D(camNode, c); 
    rmCamera3DDelete(c);		
    
    /* use RM's default lighting model */
    rmDefaultLighting(camNode);
}

void
my_build_objs(void)
{

    MyRoot = rmNodeNew("MyRoot", RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);
    
    rmNodeAddChild(rmRootNode(),MyRoot);

    /*
     * read the PDB file
     */
    {
	FILE *f;
	extern void readPDB(FILE *in);
	extern void buildPDBModel(RMnode *out,char *display);
	
	f = fopen(pdbfname,"r");
	if (f == NULL)
	{
	    rmError("can't 0pen the specified PDB file. ");
	    exit(-1);
	}

	readPDB(f);

	fclose(f);

	sticknode = rmNodeNew("sticks",RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);
	buildPDBModel(sticknode, "Sticks");
	rmNodeAddChild(MyRoot, sticknode);
	rmNodeComputeBoundingBox(sticknode);

	spherenode = rmNodeNew("spheres", RM_RENDERPASS_3D, RM_RENDERPASS_OPAQUE);
	buildPDBModel(spherenode,"Balls");
	rmNodeComputeBoundingBox(spherenode);
	rmNodeAddChild(MyRoot, spherenode);
	
    }
    

    rmNodeUnionAllBoxes(MyRoot); /* this does union of bounding boxes in the
				 entire tree, starting from the leaf nodes
				 and going upwards.*/
    rmNodeComputeCenterFromBoundingBox(MyRoot);
    
    {
	RMcolor4D bgcolor={0.2,0.2,0.3,1.0};
	/*
	 * assign a background color to take effect at "MyRoot"
	 */
	rmNodeSetSceneBackgroundColor(MyRoot,&bgcolor);
    }
}

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);

    rmFrame(p, rmRootNode());

    /* foil compile warning */
    ix = iy = 0;
}


int toggle=0;

int
myb1downfunc(RMpipe *p,
	     int ix,
	     int iy)
{
    if (toggle == 0)
    {

	rmPipeSetPostRenderFunc(p,mycolorbuffunc);
	rmPipeSetPostRenderDepthFunc(p,mydepthbuffunc);

	/* disable the rendering of sticks */

	rmNodeSetTraverseEnable(spherenode,RM_TRUE);
	rmNodeSetTraverseEnable(sticknode,RM_FALSE);

	/* render the spheres, saving the depth & bg image buffers. */
	rmFrame(p, rmRootNode());
	
	rmPipeSetPostRenderFunc(p,NULL);
	rmPipeSetPostRenderDepthFunc(p,NULL); 

	/* now, turn off rendering of spheres, turn on rendering of
	 sticks. */

	rmNodeSetTraverseEnable(spherenode,RM_FALSE);
	rmNodeSetTraverseEnable(sticknode, RM_TRUE);

	rmFrame(p, rmRootNode());

	toggle = 1;
    }
    else
    {
	float dval = 1.0F;
	RMcolor4D bgcolor = {0.19, 0.19, 0.3, 0.0};
	
	rmImageDelete(depth_buffer_image);
	depth_buffer_image = NULL;

	/* turn off depth image */
	rmNodeSetSceneDepthImage(MyRoot, NULL);

	/* and set depth clear value */
	rmNodeSetSceneDepthValue(MyRoot, &dval);

	/* turn off the bg image */
	rmNodeSetSceneBackgroundImage(MyRoot, NULL);

	/* turn on bg color */
	rmNodeSetSceneBackgroundColor(MyRoot, &bgcolor);

	/* enable rendering of both balls & sticks */
	rmNodeSetTraverseEnable(sticknode, RM_TRUE);
	rmNodeSetTraverseEnable(spherenode,RM_TRUE);
	
	rmPipeSetPostRenderFunc(p,NULL);
	rmPipeSetPostRenderDepthFunc(p,NULL);

	toggle = 0;
	
	rmFrame(p, rmRootNode());
    }

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

    return(1);
}

int
myb1motionfunc(RMpipe *p,
	       int ix,
	       int iy)
{
    /* foil compiler warnings */
    p = NULL;
    ix = iy = 0;
    
    return(1);
}

int
myb1upfunc(RMpipe *p,
	   int ix,
	   int iy)
{
    /* foil compiler warnings */
    p = NULL;
    ix = iy = 0;
    
    return(1);
}

void
myinitfunc(RMpipe *p,
	   RMnode *n)
{
    my_build_objs();
    my_set_scene(n, rmPipeGetChannelFormat(p));

    /*
     * set up the event handler to apply geometric transformations at
     * MyRoot. note that the lights and cameras are placed at rmRootNode().
     * therefore, the rotations & scaling applied at MyRoot do not affect
     * the cameras & lights since they are at a higher level in the
     * scene graph than MyRoot.
     */
    rmauxSetGeomTransform(MyRoot,p);
    rmauxSetCamera3DTransform(n, p);

    /*
     * set handler to reset aspect ratio when the window is resized.
     */
    rmauxSetResizeFunc(p, n, rmauxDefaultResizeFunc);
    

    /* 8/27/2000 - changed from b1 (only) to shift+b1 to invoke
	depth & color buffers background image tiles */
    rmauxSetButtonDownFunc(RM_BUTTON1, RM_SHIFT_MODIFIER, myb1downfunc);
    rmauxSetButtonMotionFunc (RM_BUTTON1, RM_SHIFT_MODIFIER, myb1motionfunc);
    rmauxSetButtonUpFunc (RM_BUTTON1, RM_SHIFT_MODIFIER, myb1upfunc);

    if (doStats != 0)
	rmStatsComputeDemography(n);

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

void
myRenderFunc(RMpipe *p,
	     RMnode *n)
{
    if (doStats != 0)
	rmStatsStartTime();
    
    rmFrame(p, n);

    if (doStats != 0)
    {
	rmStatsEndTime();
	rmStatsPrint();
    }
}

#ifdef RM_WIN
int WINAPI WinMain (HINSTANCE hInstance,
		    HINSTANCE hPrevInstance,
                    LPSTR lpszCmdLine, int nCmdShow)
{
    MSG      msg; 
    HWND     hWnd;
    RMenum   channelFormat;
    RMpipe *myPipe = NULL;
    RMenum   processingMode = RM_PIPE_MULTISTAGE; /* don't use MP! */
    RMenum  targetPlatform = RM_PIPE_WGL;
    void *fptr;

    parse_args(__argc,__argv);
#else  /* assume RM_X */
int
main(int ac,
     char *av[])
{
    RMenum channelFormat;
    RMenum   processingMode = RM_PIPE_MULTISTAGE; /* don't use MP! */
    RMpipe *myPipe = NULL;
    RMenum  targetPlatform = RM_PIPE_GLX;
    void *msg;			/* needed for rmauxEventLoop
				 win32/unix API consistency */
    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; 

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

    /* 
     * create the rendering pipe. this step is required in both
     * Win32 and X.
     */
    myPipe = rmPipeNew(targetPlatform);
    
    /* this program should not be run with MULTISTAGE_PARALLEL */
    rmPipeSetProcessingMode(myPipe, processingMode);

#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(myPipe,
			       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(myPipe,hWnd, img_width, img_height);
    }
#endif
#ifdef RM_X
    {
	Window w;

	w = rmauxCreateXWindow(myPipe,
			       (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(myPipe,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.
     */

    rmauxSetInitFunc(myinitfunc); 

    rmauxSetRenderFunc(myRenderFunc);

    /* uncomment this next line if you want the object to rotate
       while the user is idle. */
    /* rmauxSetIdleFunc(myPipe,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(myPipe);	

    /*
     * set key handler function so this prog will exit on "q" key.
     */
    rmauxSetKeyFunc(myPipe, rmauxDefaultKeyFunc);
    
    rmauxEventLoop(myPipe,rmRootNode(), &msg);

    rmPipeDelete(myPipe);
    rmFinish();
#ifdef RM_WIN
    return( msg.wParam );
#else
    return(1);
#endif
}
