Context Navigation

main.cpp.stereo @ 4

Revision 4, 27.2 KB checked in by ajaworski, 13 years ago (diff)
Added modified SAGE sources

Rev	Line
[4]	1	#include <string.h>
	2	#include <stdlib.h>
	3	#include <time.h>
	4	#include <vector>
	5	#ifdef WIN32
	6	#include <windows.h> // must be included before any OpenGL
	7	#endif
	8
	9	#include <GL/glut.h> //glut includes gl and glu for you!
	10	#include "Trackball.h" //SGI quaternion trackball
	11	#include "VectorMath.h" //usefull vector/matrix operations
	12	#include "global.h" //global definitions
	13	#include "glUE.h" //gl utilities and extensions
	14	#include "CCmdLine.h"
	15	#include "vFPSText.h"
	16	#include "vRenderer.h" //standard renderer
	17	#include "vPrimitive.h"
	18	#include "vGeometry.h"
	19	#include "vNet.h"
	20	#include "vUI.h"
	21	#include "vSliceView.h"
	22
	23	#if defined(ADDCGGL)
	24	#include "vCG.h"
	25	#endif
	26
	27	#if defined(V_DISTRIBUTED)
	28	#include "mpi.h"
	29	#include "vNet.h"
	30	#endif
	31
	32	#if defined(V_NETTF)
	33	#include "vTF.h"
	34	#endif
	35	vector<vPrimitive*> renderList; //all renderables attatch to this one
	36	vGlobal global; //the global v data structure (global.h)
	37	Trackball cutTrack; //global trackball
	38
	39	#if defined(V_DISTRIBUTED)
	40	vNet* net = 0; //The volvis controller
	41	#endif
	42
	43	#if defined(V_NETTF)
	44	vTF * tfNet = 0; //The tfcontroller
	45	#endif
	46
	47	enum {
	48	MENU_ROAM = 1,
	49	MENU_PROBE,
	50	MENU_CUT,
	51	MENU_ISOSURFACE,
	52	MENU_ISOPOINTS,
	53	MENU_BOUNDBOX,
	54	MENU_FPS,
	55	MENU_SAMPLERATE,
	56	MENU_SAVEVOLUME,
	57	MENU_SAVEGRADIENT,
	58	MENU_HELP,
	59	MENU_EXIT
	60	};
	61
	62	void menuCallback(int idCommand)
	63	{
	64	switch (idCommand)
	65	{
	66	case MENU_ROAM:
	67	setRoam();
	68	break;
	69	case MENU_PROBE:
	70	setProbe();
	71	break;
	72	case MENU_CUT:
	73	toggleCutPlane();
	74	break;
	75	case MENU_ISOSURFACE:
	76	genIsosurface(100,100);
	77	break;
	78	case MENU_ISOPOINTS:
	79	//genIsopoint(100,100);
	80	break;
	81	case MENU_BOUNDBOX:
	82	toggleBoundBox();
	83	break;
	84	case MENU_FPS:
	85	togglePrintFPS();
	86	break;
	87	case MENU_SAMPLERATE:
	88	break;
	89	case MENU_SAVEVOLUME:
	90	if (global.volume)
	91	global.volume->saveVolume("out");
	92	break;
	93	case MENU_SAVEGRADIENT:
	94	saveGradientVolume();
	95	break;
	96	case MENU_HELP:
	97	printUsage();
	98	break;
	99	case MENU_EXIT:
	100	doExit();
	101	break;
	102	}
	103	}
	104
	105	int buildPopupMenu (void)
	106	{
	107	int menu;
	108	menu = glutCreateMenu(menuCallback);
	109	glutAddMenuEntry ("Roam", MENU_ROAM);
	110	glutAddMenuEntry ("Probe", MENU_PROBE);
	111	glutAddMenuEntry ("Enable Cut Plane", MENU_CUT);
	112	glutAddMenuEntry ("Gen Isosurface", MENU_ISOSURFACE);
	113	glutAddMenuEntry ("Boundbox Toggle", MENU_BOUNDBOX);
	114	glutAddMenuEntry ("FPS Toggle", MENU_FPS);
	115	glutAddMenuEntry ("Sample Rate", MENU_SAMPLERATE);
	116	glutAddMenuEntry ("Save Volume", MENU_SAVEVOLUME);
	117	glutAddMenuEntry ("Save Gradient Volume", MENU_SAVEGRADIENT);
	118	glutAddMenuEntry ("Print Help", MENU_HELP);
	119	glutAddMenuEntry ("Exit", MENU_EXIT);
	120	return menu;
	121	}
	122
	123	void calcFrustum() {
	124	float fov = 45.0f*3.1415/180.0f;
	125	float b = global.env.clip[0] * (float) tan(fov * 0.5);
	126	float r = b * global.win.aspect;
	127	global.env.frustum[0] *= r; //left
	128	global.env.frustum[1] *= r; //right
	129	global.env.frustum[2] *= b; //bottom
	130	global.env.frustum[3] *= b; //top
	131	}
	132
	133	//loads the data in dtex to the handle associated with the dependant texture
	134	//sent to CG
	135	void loadDepTex(unsigned int deptexName, unsigned char *dtex)
	136	{
	137	#if defined(ADDCGGL)
	138	if (fprofile == CG_PROFILE_FP30) {
	139	// 1D tex
	140	glEnable(GL_TEXTURE_1D);
	141	glBindTexture(GL_TEXTURE_1D, deptexName);
	142	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	143	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	144	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	145	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	146	glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA8, depX, 0, GL_RGBA, GL_UNSIGNED_BYTE, dtex);
	147	GlErr("vRenderer", "loadDepTex - loading scaled dependant texture");
	148	glDisable(GL_TEXTURE_1D);
	149	}
	150	else if (fprofile == CG_PROFILE_FP20) {
	151	// 2D tex for FP20
	152	glEnable(GL_TEXTURE_2D);
	153	glBindTexture(GL_TEXTURE_2D, deptexName);
	154	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	155	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	156	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	157	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	158	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, depX, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, dtex);
	159	GlErr("vRenderer", "loadDepTex - loading scaled dependant texture");
	160	glDisable(GL_TEXTURE_2D);
	161	}
	162	#endif
	163	}
	164
	165	//takes the data from the 2d texture sent from the UI and copies it to the dependant texture
	166	//that will be passed to CG
	167	//the dependant texture is 1D but the UI texture is 2d, so for now,
	168	//just extract the first row of the UI 2d texture to the dependant texture
	169	void copyScale(float sampleRate, unsigned char *cgTex)
	170	{
	171	float alphaScale = 1.0/sampleRate;
	172	for(int j=0; j<depX; ++j){
	173	cgTex[j4 + 0] = global.volren.deptex[j4 + 0];
	174	cgTex[j4 + 1] = global.volren.deptex[j4 + 1];
	175	cgTex[j4 + 2] = global.volren.deptex[j4 + 2];
	176	cgTex[j4 + 3] = (1.0 - ::pow((1.0-(global.volren.deptex[j4 + 3]/255.0)), alphaScale))*255;
	177
	178	}
	179	}
	180
	181	void update() {
	182	//set the current sampling rate based on the interaction mode
	183	if (global.volren.lowRes)
	184	global.volren.sampleRate = global.volren.interactSamp;
	185	else
	186	global.volren.sampleRate = global.volren.goodSamp;
	187
	188	//Re-Scale Alpha values depending on no of slices
	189	//if we need to load a new TF, load it here (from the remote UI)
	190	if(global.volren.scaleAlphas){
	191	if((global.volren.lastSamp != global.volren.sampleRate)\|\|(global.volren.loadTLUT)){ //see if the sample rate changed
	192	if((global.volren.lastGoodSamp != global.volren.goodSamp) \|\| global.volren.loadTLUT){ //good sample rate changed
	193	copyScale(global.volren.goodSamp * 1/global.volren.gamma, global.volren.gDeptex);
	194	global.volren.lastGoodSamp = global.volren.goodSamp;
	195	}
	196	if((global.volren.lastInteSamp != global.volren.interactSamp) \|\| global.volren.loadTLUT){ //interact samp rate changed
	197	copyScale(global.volren.interactSamp * 1/global.volren.gamma, global.volren.iDeptex);
	198	global.volren.lastInteSamp = global.volren.interactSamp;
	199	}
	200	if(global.volren.sampleRate == global.volren.goodSamp){ //which one do we load (good)
	201	loadDepTex(global.volren.scaledDeptexName,global.volren.gDeptex);
	202	global.volren.lastSamp = global.volren.goodSamp;
	203	}
	204	else if(global.volren.sampleRate == global.volren.interactSamp){ //(interactive)
	205	loadDepTex(global.volren.scaledDeptexName,global.volren.iDeptex);
	206	global.volren.lastSamp = global.volren.interactSamp;
	207	}
	208	copyScale(0.3, global.volren.nDeptex);
	209	loadDepTex(global.volren.origDeptexName, global.volren.nDeptex);
	210	global.volren.loadTLUT = 0;
	211	}
	212	} else { //just do gamma scale, don't update for the sample rate (for testing purposes)
	213	if(global.volren.loadTLUT){
	214	copyScale(1/global.volren.gamma, global.volren.gDeptex);
	215	loadDepTex(global.volren.scaledDeptexName, global.volren.gDeptex);
	216	global.volren.loadTLUT = 0;
	217	}
	218	}
	219
	220	}
	221
	222	void deallocateAll() {
	223	if (global.volume);
	224	delete global.volume;
	225	if (global.fullVolume)
	226	delete global.fullVolume;
	227	for (int i=0;i<renderList.size();i++)
	228	delete renderList[i];
	229
	230	delete [] global.volren.deptex ;
	231	delete [] global.volren.nDeptex;
	232	delete [] global.volren.gDeptex;
	233	delete [] global.volren.iDeptex;
	234
	235	}
	236	int main(int argc, char **argv) {
	237	initGlobal(); //init global variables
	238
	239	//init network related - MPI will change argc and argv
	240	// so pass as ref
	241	QUANTAinit();
	242	srand( (unsigned)time(NULL)); //initialise randon number generator
	243	#if defined(V_DISTRIBUTED)
	244	net = new vNet();
	245	net->init(argc,argv);
	246	#endif
	247
	248	#if defined(V_NETTF) //want transfer functions
	249	#if defined (V_DISTRIBUTED) //in distributed mode, only master has this instance
	250	if (net->isActiveTile()) {
	251	tfNet = new vTF();
	252	tfNet->init();
	253	}
	254	#else //in standalone instantiate it
	255	tfNet = new vTF();
	256	tfNet->init();
	257	#endif
	258	#endif
	259
	260	//command line parsing - stores argumenents in global.*
	261	parseCmdLine(argc,argv);
	262
	263	glutInit(&argc, argv);
	264	glutInitDisplayMode(GLUT_RGBA \| GLUT_DOUBLE \| GLUT_DEPTH);
	265	glutInitWindowSize(global.win.width, global.win.height);
	266	glutInitWindowPosition(global.win.xPos, global.win.yPos);
	267	global.mainWindow = glutCreateWindow("Vol-a-Tile");
	268
	269	#ifdef WIN32
	270	LoadAllExtensions();
	271	#endif
	272
	273	initGL(); //opengl init stuff
	274	//init the dependant textures
	275	//initialize the dependant texture for transfer functions
	276	//copy the good and interactive dependant textures
	277	copyScale(global.volren.goodSamp, global.volren.gDeptex);
	278	copyScale(global.volren.interactSamp, global.volren.iDeptex);
	279	copyScale(0.3, global.volren.nDeptex);
	280	global.volren.lastSamp = global.volren.goodSamp;
	281	global.volren.lastGoodSamp = global.volren.goodSamp;
	282	global.volren.lastInteSamp = global.volren.interactSamp;
	283
	284	loadDepTex(global.volren.scaledDeptexName,global.volren.gDeptex);
	285	loadDepTex(global.volren.origDeptexName,global.volren.nDeptex);
	286	//load the given 1D texture to CG
	287
	288
	289	#if defined(ADDCGGL)
	290	initCG(); //init the CG library
	291	#endif
	292
	293	//start creating our objects
	294	//creating renderer object
	295	if (global.volume) {
	296	vRenderer* renderer = new vRenderer();
	297	renderer->setVolume(global.volume);
	298	renderList.push_back(renderer);
	299
	300	if (global.fullVolume) {
	301	vRenderer* fullRenderer = new vRenderer;
	302	fullRenderer->setVolume(global.fullVolume);
	303	fullRenderer->disableCut();
	304	fullRenderer->enableShowOverview();
	305	fullRenderer->setTranslation(2.0,0.0,0.0);
	306	renderList.push_back(fullRenderer);
	307	}
	308	//slice view
	309	vSliceView* view = new vSliceView;
	310	renderList.push_back(view);
	311	//the info
	312	vVolText* text = new vVolText;
	313	renderList.push_back(text);
	314
	315	}
	316
	317
	318	//now create the FPS text
	319	vFPSText* timerText = new vFPSText;
	320	renderList.push_back(timerText);
	321	//now create the pointer
	322	//vPointer* ptr = new vPointer;
	323	//renderList.push_back(ptr);
	324
	325	//initialise all the objects
	326	for (int i=0;i<renderList.size();i++) {
	327	renderList[i]->init();
	328	}
	329
	330	GlErr("vRenderer", "init");
	331
	332
	333
	334	#ifdef V_DISTRIBUTED
	335	if (net->isActiveTile()) {
	336	global.win.width = 1024;
	337	global.win.height = 1024;
	338	}
	339	else {
	340	glutFullScreen();
	341	glutSetCursor(GLUT_CURSOR_NONE);
	342
	343	}
	344	#else
	345	if (global.env.gameMode )
	346	glutFullScreen();
	347
	348	#endif
	349	glutDisplayFunc(display);
	350	glutReshapeFunc(reshape);
	351	glutMouseFunc(mouse);
	352	glutMotionFunc(motion);
	353	glutPassiveMotionFunc(passiveMotion);
	354	glutKeyboardFunc(key);
	355	glutSpecialFunc(special);
	356	//only use idle when we are in standalone mode
	357	#ifndef V_DISTRIBUTED
	358	glutIdleFunc(idle);
	359	#endif
	360	buildPopupMenu ();
	361	glutAttachMenu (GLUT_RIGHT_BUTTON);
	362	//only master does the update and broadcasts it to client
	363	//so that everyone is syncronized
	364	#ifdef V_DISTRIBUTED
	365	//if (net->isActiveTile())
	366	glutTimerFunc(50, updateAnim, 1);
	367	#else
	368	glutTimerFunc(50, updateAnim, 1);
	369	#endif
	370	glutMainLoop();
	371	return 0;
	372	}
	373
	374	void initGlobal() {
	375	global.volume = 0;
	376	global.fullVolume = 0;
	377
	378	global.win.width = 1024; //size
	379	global.win.height = 768;
	380	global.win.xPos = 0; //position
	381	global.win.yPos = 0;
	382	global.win.aspect = 1.0f;
	383
	384	global.env.eye[0] = 0; //eye
	385	global.env.eye[1] = 0;
	386	global.env.eye[2] = 10.0;
	387	global.env.at[0] = 0; //at
	388	global.env.at[1] = 0;
	389	global.env.at[2] = 0;
	390	global.env.up[0] = 0; //up
	391	global.env.up[1] = 1;
	392	global.env.up[2] = 0;
	393	global.env.renderOn = true;
	394
	395	global.env.frustum[0] = -1.0; //left
	396	global.env.frustum[1] = 1.0; //right
	397	global.env.frustum[2] = -1.0; //bottom
	398	global.env.frustum[3] = 1.0; //top
	399	global.env.clip[0] = 1; //front
	400	global.env.clip[1] = 50; //back
	401	global.env.bgColor = 0; //white background
	402
	403	global.mouse.alt = 0;
	404	global.mouse.ctrl = 0;
	405	global.mouse.shift = 0;
	406
	407	//lighting
	408	global.light.startpos[0] = -1.0f;
	409	global.light.startpos[1] = -1.0f;
	410	global.light.startpos[2] =-1.0f;
	411	global.light.startpos[3] = 0.0f;
	412
	413	global.volren.interactSamp= .05; //Interactive sample rate
	414	global.volren.goodSamp = 1.0; //High quality sample ..
	415	global.volren.sampleRate = global.volren.goodSamp; //samples per voxel
	416	global.volren.lowRes = 0; //highres rendering
	417	global.volren.deptex = new unsigned char[2562564];
	418	for(int j=0; j<256; ++j){
	419	for(int k=0; k<256; ++k){
	420	global.volren.deptex[j2564 + k4 + 0] = (unsigned char)(k/(float)255255);
	421	global.volren.deptex[j2564 + k4 + 1] = (unsigned char)(255 - k/(float)255255);
	422	global.volren.deptex[j2564 + k4 + 2] = (unsigned char)( k/(float)255255);
	423	global.volren.deptex[j2564 + k4 + 3] = (unsigned char)(k/(float)255255/(float)2);
	424	}
	425	}
	426	global.volren.nDeptex = new unsigned char[256*4];
	427	global.volren.gDeptex = new unsigned char[256*4];
	428	global.volren.iDeptex = new unsigned char[256*4];
	429	global.volren.loadTLUT = 1; //first time - need to load LUT
	430	global.volren.loadVolume = 0; //no need to load the volume
	431	global.volren.scaleAlphas = 1; //scale alphas to the sample rate
	432	global.volren.gamma = 1; //gamma identitiy
	433	global.volren.probe[0] = global.volren.probe[1] = global.volren.probe[2] = 0;
	434
	435	identityMatrix(global.cut.transform); //init the rotation
	436	global.cut.user[0] = 1.0;
	437	global.cut.user[1] = global.cut.user[2] = 0.0;
	438	global.cut.user[3] = 0.5f;
	439	global.cut.update = false;
	440
	441	global.ui.printFPS = false;
	442	global.ui.printSlices = false;
	443	global.ui.cutEnabled = false;
	444	global.ui.bboxEnabled = false;
	445	global.ui.navMode = V_ROAM;
	446	global.ui.animate = false;
	447
	448	global.pointerPos[0] = global.pointerPos[1] = 0.0f;
	449	global.pointerPos[2] = 1.0f;
	450	global.curPrimIdx = 0;
	451	cutTrack.clear();
	452	}
	453
	454
	455	void initGL( void )
	456	{
	457	glClearColor(0.0, 0.0, 0.0, 1.0);
	458	glShadeModel(GL_SMOOTH);
	459	glEnable(GL_DEPTH_TEST);
	460	glDepthFunc(GL_LEQUAL);
	461	glLineWidth(3);
	462	glGenTextures(1, &global.volren.scaledDeptexName); //the dep tex that we use for the tf- passed to CG
	463	glGenTextures(1, &global.volren.origDeptexName); //the dep tex that we use for the tf- passed to CG
	464	GlErr("v::","initGL()");
	465	}
	466
	467	void display()
	468	{
	469	#ifdef V_DISTRIBUTED
	470	net->process();
	471	#endif
	472	glEnable (GL_SCISSOR_TEST); //dont draw outside viewpott
	473	glMatrixMode(GL_PROJECTION);
	474	glLoadIdentity();
	475	glFrustum(global.env.frustum[0], //left
	476	global.env.frustum[1], //right
	477	global.env.frustum[2], //top
	478	global.env.frustum[3], //bottom
	479	global.env.clip[0], //front
	480	global.env.clip[1]); //back
	481
	482	//viewport for left eye, in the right half of the screen
	483	if (global.env.stereoType) {
	484	glViewport(global.win.displayWidth,0,global.win.width, global.win.height);
	485	glScissor (global.win.displayWidth, 0, global.win.width, global.win.height);
	486	if (global.env.stereoType == CROSSEYE)
	487	displayOneEye(LEFT);
	488	else
	489	displayOneEye(RIGHT);
	490	}
	491	//viewport for right eye, left half of the screen
	492	glViewport(0, 0, global.win.displayWidth, global.win.height);
	493	glScissor (0, 0, global.win.displayWidth, global.win.height);
	494	if (global.env.stereoType == CROSSEYE)
	495	displayOneEye(RIGHT);
	496	else
	497	displayOneEye(LEFT);
	498	glDisable (GL_SCISSOR_TEST);
	499
	500	#ifdef V_DISTRIBUTED
	501	net->sync();
	502	#endif
	503	glutSwapBuffers();
	504	GlErr("v:","disp()");
	505	}
	506
	507	void displayOneEye(STEREOVIEW eye)
	508	{
	509	//dont draw anything on the master
	510	glPushMatrix();
	511	{
	512	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	513	glMatrixMode(GL_MODELVIEW);
	514	glLoadIdentity();
	515	if (eye == LEFT)
	516	gluLookAt(-global.stereo.halfEyeSep+global.env.eye[0], //eye
	517	global.env.eye[1],
	518	global.env.eye[2],
	519	global.env.at[0], //at
	520	global.env.at[1],
	521	global.env.at[2],
	522	global.env.up[0],
	523	global.env.up[1],
	524	global.env.up[2]); //up
	525	else
	526	gluLookAt(global.stereo.halfEyeSep+global.env.eye[0], //eye
	527	global.env.eye[1], global.env.eye[2],
	528	global.env.at[0],global.env.at[1],global.env.at[2],
	529	global.env.up[0],global.env.up[1],global.env.up[2]);
	530
	531	GLfloat light_pos[] = { 5.0, 5.0, 5.0,1.0 };
	532	glEnable(GL_LIGHTING);
	533	glEnable(GL_LIGHT0);
	534	glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
	535	update();
	536	if (global.env.renderOn) {
	537	for (int i=0;i<renderList.size();i++) {
	538	renderList[i]->draw();
	539	}
	540	}
	541	renderList[global.curPrimIdx]->setSelected(true);
	542
	543	} glPopMatrix();
	544	}
	545
	546	void mouse(int button, int state, int x, int y)
	547	{
	548	y = global.win.height - y;
	549	global.mouse.button = button;
	550	global.mouse.state = state;
	551
	552	if(glutGetModifiers() & GLUT_ACTIVE_CTRL) global.mouse.ctrl = 1;
	553	else global.mouse.ctrl = 0;
	554	if(glutGetModifiers() & GLUT_ACTIVE_SHIFT) global.mouse.shift = 1;
	555	else global.mouse.shift = 0;
	556	if(glutGetModifiers() & GLUT_ACTIVE_ALT) global.mouse.alt = 1;
	557	else global.mouse.alt = 0;
	558	if(state == GLUT_UP){
	559	global.mouse.button = -1;
	560	}
	561	//get the global coords
	562
	563	#if defined(V_DISTRIBUTED)
	564	if (!net->cmdFlushed)
	565	return;
	566	#endif
	567	//standard button actions...
	568	switch(button){
	569	case GLUT_LEFT_BUTTON:
	570	{
	571	if (global.mouse.ctrl) { //emulate right button
	572	switch(state)
	573	{
	574	case GLUT_UP:
	575	endInteract();
	576	break;
	577	case GLUT_DOWN:
	578	startZoom(x,y);
	579	break;
	580	}
	581	}
	582	else {
	583	switch(state)
	584	{
	585	case GLUT_UP:
	586	endInteract();
	587	break;
	588	case GLUT_DOWN:
	589	startRotation(x,y);
	590	break;
	591	}
	592	}
	593	}
	594	break;
	595	case GLUT_RIGHT_BUTTON:
	596	{
	597	switch(state)
	598	{
	599	case GLUT_UP:
	600	endInteract();
	601	break;
	602	case GLUT_DOWN:
	603	startZoom(x,y);
	604	break;
	605	}
	606	}
	607	break;
	608	case GLUT_MIDDLE_BUTTON:
	609	{
	610	switch(state)
	611	{
	612	case GLUT_UP:
	613	endInteract();
	614	break;
	615	case GLUT_DOWN:
	616	startTranslate(x,y);
	617	break;
	618	}
	619	}
	620	break;
	621	default:
	622	break;
	623	}
	624	}
	625
	626	void passiveMotion(int x, int y) {
	627	global.mouse.pos[0] = x;
	628	y = global.win.height-y;
	629
	630	//get the global coords
	631	// doSelect(x,y);
	632	}
	633
	634	void motion(int x, int y)
	635	{
	636	#if defined(V_DISTRIBUTED)
	637	if (!net->cmdFlushed)
	638	return;
	639	#endif
	640	y = global.win.height-y;
	641	//get the global coords
	642	switch(global.mouse.button) {
	643	case GLUT_LEFT_BUTTON:
	644	{
	645	if (global.mouse.ctrl) { //emulate right button
	646	switch(global.mouse.state)
	647	{
	648	case GLUT_DOWN:
	649	doZoom(x,y);
	650	break;
	651	case GLUT_UP:
	652	break;
	653	}
	654	}
	655	else {
	656	switch(global.mouse.state)
	657	{
	658	case GLUT_DOWN:
	659	doRotation(x,y);
	660	break;
	661	case GLUT_UP:
	662	break;
	663	}
	664	}
	665	}
	666	break;
	667	case GLUT_RIGHT_BUTTON:
	668	{
	669	switch(global.mouse.state)
	670	{
	671	case GLUT_DOWN:
	672	doZoom(x,y);
	673	break;
	674	case GLUT_UP:
	675	break;
	676	}
	677	}
	678	break;
	679	case GLUT_MIDDLE_BUTTON:
	680	{
	681	switch(global.mouse.state)
	682	{
	683	case GLUT_DOWN:
	684	doTranslate(x,y);
	685	break;
	686	case GLUT_UP:
	687	break;
	688	}
	689	}
	690	break;
	691	default:
	692	break;
	693	}
	694	}
	695
	696	void key(unsigned char key, int x, int y)
	697	{
	698	#if defined(V_DISTRIBUTED)
	699	if (!net->cmdFlushed)
	700	return;
	701	#endif
	702
	703	y = global.win.height-y;
	704	switch(key) {
	705	case '\033': //escape
	706	doExit();
	707	break;
	708	case 'b':
	709	case 'B':
	710	toggleBoundBox();
	711	break;
	712	case 'c':
	713	case 'C':
	714	toggleCutPlane();
	715	break;
	716	case 'f':
	717	case 'F':
	718	togglePrintFPS();
	719	break;
	720	case 'g':
	721	case 'G':
	722	saveGradientVolume();
	723	break;
	724	case 'h':
	725	case 'H':
	726	printUsage();
	727	break;
	728	case 'i':
	729	case 'I':
	730	genIsosurface(x,y);
	731	break;
	732	case 'j':
	733	case 'J':
	734	//genIsopoint(x,y);
	735	break;
	736	// case 'n':
	737	// case 'N':
	738	// global.ui.printSlices = !global.ui.printSlices;
	739	// break;
	740	case 'o':
	741	case 'O':
	742	global.volume->saveVolume("out");
	743	break;
	744	case 'p': //to probe volumes
	745	case 'P':
	746	setProbe();
	747	break;
	748	case 'r':
	749	case 'R':
	750	setRoam();
	751	break;
	752	case 'x':
	753	case 'X':
	754	animateVolumeRotX();
	755	break;
	756	case '+':
	757	//increase the number of slices
	758	scaleSampleRate(1.1);
	759	break;
	760	case '-':
	761	//decrease the number of slices
	762	scaleSampleRate(0.9);
	763	break;
	764	case '.':
	765	//increase isosurface value
	766	incIsoValue(15);
	767	break;
	768	case ',':
	769	//decrease isosurface value
	770	incIsoValue(-15);
	771	break;
	772	case ' ':
	773	animateVolume();
	774	break;
	775	case 8: //backspace key
	776	global.curPrimIdx--;
	777	if (global.curPrimIdx < 0)
	778	global.curPrimIdx = renderList.size()-1;
	779	doSelect(global.curPrimIdx);
	780	break;
	781
	782	case 9: //tab key
	783	global.curPrimIdx++;
	784	if (global.curPrimIdx >= renderList.size())
	785	global.curPrimIdx = 0;
	786	doSelect(global.curPrimIdx);
	787	break;
	788
	789	}
	790	}
	791
	792
	793	void special(int key, int x, int y)
	794	{
	795	int ROAM = global.volume->maxDim/2;
	796
	797	#if defined(V_DISTRIBUTED)
	798	if (!net->cmdFlushed)
	799	return;
	800	#endif
	801	switch(key){
	802	case GLUT_KEY_UP:
	803	if (global.ui.navMode == V_ROAM)
	804	roamVolume(0,ROAM,0);
	805	else if (global.ui.navMode == V_PROBE) {
	806	probeVolume(0,1,0);
	807	}
	808	else
	809	doAxisRotation(-1.0f,'x');
	810	break;
	811	case GLUT_KEY_DOWN:
	812	if (global.ui.navMode == V_ROAM)
	813	roamVolume(0,-ROAM,0);
	814	else if (global.ui.navMode == V_PROBE)
	815	probeVolume(0,-1,0);
	816	else
	817	doAxisRotation(1.0f,'x');
	818	break;
	819	case GLUT_KEY_RIGHT:
	820	if (global.ui.navMode == V_ROAM)
	821	roamVolume(ROAM,0,0);
	822	else if (global.ui.navMode == V_PROBE)
	823	probeVolume(1,0,0);
	824	else
	825	doAxisRotation(1.0f,'y');
	826	break;
	827	case GLUT_KEY_LEFT:
	828	if (global.ui.navMode == V_ROAM)
	829	roamVolume(-ROAM,0,0);
	830	else if (global.ui.navMode == V_PROBE)
	831	probeVolume(-1,0,0);
	832	else
	833	doAxisRotation(-1.0f,'y');
	834	break;
	835	case GLUT_KEY_PAGE_UP: //increase eye sep
	836	if (global.ui.navMode == V_ROAM)
	837	roamVolume(0,0,-ROAM);
	838	else if (global.ui.navMode == V_PROBE)
	839	probeVolume(0,0,-1);
	840	else if (global.env.stereoType)
	841	global.stereo.halfEyeSep +=0.05;
	842	break;
	843	case GLUT_KEY_PAGE_DOWN: //decrease eye sep
	844	if (global.ui.navMode == V_ROAM)
	845	roamVolume(0,0,ROAM);
	846	else if (global.ui.navMode == V_PROBE)
	847	probeVolume(0,0,1);
	848	else if (global.env.stereoType)
	849	global.stereo.halfEyeSep -=0.05;
	850	break;
	851	}
	852	}
	853
	854	void idle() {
	855	display();
	856	QUANTAusleep(100);
	857	}
	858
	859	void reshape(int w, int h)
	860	{
	861	GlErr("vRenderer","testing");
	862	glViewport(0,0, (GLint) w -1, (GLint) h-1);
	863	// glMatrixMode(GL_PROJECTION);
	864	// glLoadIdentity();
	865
	866
	867	// global.env.frustum[0] *= (float)w/(float)global.win.width;
	868	// global.env.frustum[1] *= (float)w/(float)global.win.width;
	869	// global.env.frustum[2] *= (float)h/(float)global.win.height;
	870	// global.env.frustum[3] *= (float)h/(float)global.win.height;
	871
	872	glFrustum(global.env.frustum[0],
	873	global.env.frustum[1],
	874	global.env.frustum[2],
	875	global.env.frustum[3],
	876	global.env.clip[0],
	877	global.env.clip[1]);
	878
	879	glMatrixMode(GL_MODELVIEW);
	880	global.win.width = w;
	881	global.win.height = h;
	882	glutPostRedisplay();
	883	}
	884
	885	void parseCmdLine(int argc, char **argv)
	886	{
	887	CCmdLine cmdLine; // our cmd line parser object
	888	if (cmdLine.SplitLine(argc, argv) < 1) {
	889	// no switches were given on the command line, abort
	890	exit(-1);
	891	}
	892	// test for the 'help' case
	893	if (cmdLine.HasSwitch("-h")) {
	894	printUsage();
	895	exit(0);
	896	}
	897	#if defined(V_NETDATA)
	898	bool ok = false;
	899	// remote data - get IP and volume symbolic name
	900	if (cmdLine.HasSwitch("-v")) {
	901	//get the symbolic name of the volume
	902	string volName = cmdLine.GetArgument("-v",0);
	903	//get the server IP
	904	string serverIP = cmdLine.GetSafeArgument("-v",1,"localhost");
	905	global.volume = new vOptiVolume(volName.c_str(), serverIP.c_str());
	906	if (cmdLine.GetArgumentCount("-v") > 2) {//also have thumbnail volume
	907	string fullVolName= cmdLine.GetArgument("-v",2);
	908	global.fullVolume = new vOptiVolume(fullVolName.c_str(), serverIP.c_str());
	909	}
	910	ok = true;
	911
	912	}
	913	if (cmdLine.HasSwitch("-i")) {
	914	string wild = cmdLine.GetArgument("-i",0);
	915	cerr <<"wildcard "<<wild<<endl;
	916	//the numFiles arg is the server IP
	917	string serverIP = cmdLine.GetSafeArgument("-i",1,"localhost");
	918	fprintf(stderr,"server IP %s\n",serverIP.c_str());
	919	float scale = 1.0f;
	920	if (cmdLine.GetArgumentCount("-i") > 2) {//also have thumbnail volume
	921	string scaleStr = cmdLine.GetArgument("-i",2);
	922	scale = atof(scaleStr.c_str());
	923	}
	924
	925	vGeometry* newGeom = new vGeometry((char)wild.c_str(),(char)serverIP.c_str(),scale);
	926	renderList.push_back(newGeom);
	927	ok = true;
	928	}
	929	if (!ok) {
	930	fprintf(stderr,"Specify -v or -i option\n");
	931	exit(-1);
	932	}
	933
	934
	935	#else
	936	//local, specify filename and filedimensions
	937	try {
	938	string filename = cmdLine.GetArgument("-f", 0);
	939	string x, y, z;
	940	x = cmdLine.GetArgument( "-f", 1);
	941	y = cmdLine.GetArgument( "-f", 2);
	942	z = cmdLine.GetArgument( "-f", 3);
	943	global.volume = new vFileVolume(filename.c_str(),
	944	atoi(x.c_str()), atoi(y.c_str()), atoi(z.c_str()));
	945	}
	946	catch (...)
	947	{
	948	// one of the required arguments was missing, abort
	949	exit(-1);
	950	}
	951
	952	//load gradient volume
	953	if (cmdLine.HasSwitch("-g")) {
	954	((vFileVolume*)global.volume)->gradientFile = strdup(cmdLine.GetArgument("-g",0).c_str());
	955	}
	956	#endif
	957	if (global.volume) {
	958	//now get the volume offset, if any - 0 by default
	959	global.volume->offsetX= atoi(cmdLine.GetSafeArgument( "-o", 0, "0").c_str());
	960	global.volume->offsetY = atoi(cmdLine.GetSafeArgument( "-o", 1, "0").c_str());
	961	global.volume->offsetZ = atoi(cmdLine.GetSafeArgument( "-o", 2, "0").c_str());
	962	}
	963
	964	//get screen width and height
	965	if (cmdLine.HasSwitch("-w")) {
	966	global.win.width = atoi(cmdLine.GetSafeArgument("-w", 0, "512").c_str());
	967	global.win.height = atoi(cmdLine.GetSafeArgument("-w", 1, "512").c_str());
	968	}
	969	else
	970	global.env.gameMode = true;
	971
	972	if (cmdLine.HasSwitch("-a")) {
	973	global.win.aspect = atof(cmdLine.GetSafeArgument("-a", 0, "1.0").c_str());
	974	}
	975
	976	calcFrustum();
	977	//get the voxel spacing
	978	if (cmdLine.HasSwitch("-sp")) {
	979	if (global.volume) {
	980	//now get the volume offset, if any - 0 by default
	981	global.volume->spacingX= atof(cmdLine.GetSafeArgument( "-sp", 0, "0").c_str());
	982	global.volume->spacingY = atof(cmdLine.GetSafeArgument( "-sp", 1, "0").c_str());
	983	global.volume->spacingZ = atof(cmdLine.GetSafeArgument( "-sp", 2, "0").c_str());
	984	}
	985	if (global.fullVolume) {
	986	//now get the volume offset, if any - 0 by default
	987	global.fullVolume->spacingX= atof(cmdLine.GetSafeArgument( "-sp", 0, "0").c_str());
	988	global.fullVolume->spacingY = atof(cmdLine.GetSafeArgument( "-sp", 1, "0").c_str());
	989	global.fullVolume->spacingZ = atof(cmdLine.GetSafeArgument( "-sp", 2, "0").c_str());
	990	}
	991	}
	992
	993	//get the texture volume dimensions
	994	if (global.volume) {
	995	try
	996	{
	997	string x = cmdLine.GetArgument("-d", 0);
	998	string y = cmdLine.GetArgument( "-d", 1);
	999	string z = cmdLine.GetArgument( "-d", 2);
	1000	global.volume->load(atoi(x.c_str()), atoi(y.c_str()), atoi(z.c_str()));
	1001	}
	1002	catch (...)
	1003	{
	1004	fprintf(stderr,"Missing args to -d command line option\n");
	1005	exit(-1);
	1006	}
	1007	}
	1008	if (global.fullVolume) //load full volume
	1009	global.fullVolume->load();
	1010
	1011
	1012	#if defined(V_DISTRIBUTED)
	1013	char tileConfigFile[256];
	1014	try
	1015	{ // if any of these GetArgument calls fail,
	1016	// we'll end up in the catch() block
	1017	// filename
	1018	strcpy(tileConfigFile, cmdLine.GetArgument("-n", 0).c_str());
	1019	}
	1020	catch (...)
	1021	{
	1022	// one of the required arguments was missing, abort
	1023	exit(-1);
	1024	}
	1025	//init mpi related stuff
	1026	net->readTileConfig(tileConfigFile);
	1027	if (net->isActiveTile()) { //master
	1028	global.env.renderOn = false;
	1029	}
	1030	#endif
	1031
	1032	global.env.stereoType = (vStereoType)(atoi(cmdLine.GetSafeArgument( "-s", 0, "0").c_str()));
	1033	global.stereo.halfEyeSep = 0.25;
	1034	}
	1035

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format