PDA

View Full Version : programming in openGL usin c language



garg
05-26-2009, 09:53 AM
below is the partial code in opengl for displaying very large data sets >10^7 points and moving (rotating) them.
this i have created using the glui interface, instead of writing the application
myself. I have not been able to run this code on the LINUX machine with the
graphical accelerators.

please help me write a new code which can be implemented on a linux box.

the full code :


#include <GL/gl.h>
#include <GL/glui.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

/* define a polygon with some structures for code readability */
typedef struct
{ /* structure for a 3d point, height and 2 normal components */
float z;
float n1;
float n2;
float n3;
} POIN;

GLfloat light_diffuse_R[] = {1.0, 0.0, 0.0, 1.0}; /* Red diffuse light. */
GLfloat light_diffuse_B[] = {0.0, 0.0, 1.0, 1.0}; /* Blue diffuse light. */

GLfloat light0_position[] = {1.0, 1.0, 1.0, 0.0}; /* Infinite light location. */
GLfloat light1_position[] = {-1.0, -1.0, -1.0, 0.0};


int type,nt,t,ii,jj; /* number of points */
float y, dy, /* position and increment along y axis */
x, dx; /* position and increment along x axis */
float xa,ya,xb,yb,ylength,magn;
POIN q[4100][4100]; /* array of points */

float zoom=1;
float X=0, Y=0, Z=0; /* for translation*/
float angle=0;
float a,b,c; /* axis for rotation */

int inc;
int abc, pqr;

float obj_pos[] = { 0.0, 0.0, 0.0 };

float view_rotate[16] = { 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };

/*********************************************************/

void read_surface()
{
int i,j; /* indices for x and y position */
float a1,a2,a3,b1,b2,b3,n1,n2,n3,nn; /* values for outer product */
float average, rdumx, rdumy, rdum;
FILE *fp;
char *fn = "d://sdas//opengl//P.dat";

printf("start make-surface\n");
/* read in values from file data file */

printf("\ngive filename ");
//scanf("%s",fn);
printf("\ngive file-type 1=P, 2=H ");
//scanf("%d",&type);

type = 1;
if (type==2)
{
printf("\ngive H magnification ");
scanf("%f",&magn);
}

if ((fp=fopen(fn,"r"))==NULL)
{
printf(" \n INPUT-FILE NON-EXISTENT\n");
exit(1);}

fscanf(fp,"%d %f %d %f\n",&ii,&dx,&jj,&dy);
fscanf(fp,"%f %f\n",&rdum,&rdum);
fscanf(fp,"%f %f\n",&xa,&ylength);

printf("ii=%d hx=%5.5e jj=%d hy=%5.5e\n",ii,dx,jj,dy);
ya=ylength;
xb=xa+(ii-1)*dx;
yb=ylength+(jj-1)*dy;
for (i =0; i <= ii; i++ )
{
for (j =0; j <= jj; j++ )
{
fscanf(fp,"%f %f %f",&rdumx,&rdumy,&rdum);
/* printf("%4d %4d %f %f %f\n",i,j,rdumx,rdumy,rdum); */
if (type==1) q[i][j].z=rdum; else q[i][j].z=1.0-magn*rdum;
}
}
/* now compute polygon values */
for (i=0; i<=ii; i++)
{
for (j=0; j<=jj; j++)
{
/* calculate the normal of unit length */
a1=dx ; a2=0.0; a3=q[i+1][j ].z-q[i ][j ].z;
b1=0.0; b2=dy ; b3=q[i ][j+1].z-q[i ][j ].z;
n1=a2*b3-a3*b2; n2=a3*b1-a1*b3; n3=a1*b2-a2*b1;
nn=sqrt(n1*n1+n2*n2+n3*n3);
q[i][j].n1 = n1/nn;
q[i][j].n2 = n2/nn;
q[i][j].n3 = n3/nn;
}
}
printf(" finished calculating normals\n");
printf("\noperation 1 : zoom in left click, zoom out right click, original figure middle click \n");

printf("\noperation 2 : x translate 't','y'; y translate 'g','h'; z translate 'b','n'; original position ' '\n ");

printf("\noperation 3 : to rotate press 'u', and to get back to original position press 'i'\n\n");
}

/******************************************************/

void
drawBox(void)
{
/* draw the surface by incrementing through ii and jj, with increments s */
int i,j,kk,ic,jc;
float normal1[3], normal2[3], normal3[3], normal4[3];
float vertex1[3], vertex2[3], vertex3[3], vertex4[3], vertex5[3];
char timestr[8];

/* ic, jc, central values */
ic=(ii)/2; jc=(jj)/2;

/* draw data onto screen */
printf("start draw-surface\n");

printf("%3d %3d %3d %3d \n",ii,jj,ic,jc);

for (i=0; i<ii; i +=inc)
{
x= -4.5+i*dx;
for (j=0; j<jj; j+=inc)
{
y= -3.0+j*dy;
if (x*x+y*y<2.0)
{
/* printf("%3d %3d %f %f %f %f\n",i,j,x,y,dx,dy); */
vertex1[0]=vertex2[0]=x;
vertex3[0]=vertex4[0]=x+inc*dx;
vertex1[1]=vertex4[1]=y;
vertex2[1]=vertex3[1]=y+inc*dy;
vertex1[2]=q[i ][j ].z;
vertex2[2]=q[i ][j+inc].z;
vertex3[2]=q[i+inc][j+inc].z;
vertex4[2]=q[i+inc][j ].z;
normal1[0]=q[i ][j ].n1;
normal1[1]=q[i ][j ].n2;
normal1[2]=q[i ][j ].n3;
/*normal2[0]=q[i ][j+inc].n1;
normal2[1]=q[i ][j+inc].n2;
normal2[2]=q[i ][j+inc].n3;
normal3[0]=q[i+inc][j+inc].n1;
normal3[1]=q[i+inc][j+inc].n2;
normal3[2]=q[i+inc][j+inc].n3;
normal4[0]=q[i+inc][j ].n1;
normal4[1]=q[i+inc][j ].n2;
normal4[2]=q[i+inc][j ].n3;*/



glBegin(GL_POLYGON);
glNormal3fv(normal1);
glVertex3fv(vertex1);
/* glNormal3fv(normal2); */
glVertex3fv(vertex2);
/* glNormal3fv(normal3); */
glVertex3fv(vertex3);
/* glNormal3fv(normal4); */
glVertex3fv(vertex4);
glEnd();
}
}
}
}

/************************************************/



void display(void)
{

glClearColor( .5f, .5f, .5f, 1.0f );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();
gluLookAt(0.0, 0.0, 10.0, /* eye is at (0,0,10) */
0.0, 0.0, 1.0, /* center is at (0,0,1) */
0.0, 1.0, 0.0); /* up is in positive Z direction */

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective (25.0/zoom, 1, 1, 100);
glMatrixMode(GL_MODELVIEW);


glTranslatef(X,Y,Z);
glRotatef(angle,a,b,c);

glTranslatef( obj_pos[0], obj_pos[1], obj_pos[2] );

glMultMatrixf( view_rotate );


inc = 1;
drawBox();
glutSwapBuffers();

glFlush();
}

/*************************************************/

void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective (25.0/zoom, (int)w/(int)h, 4, 100);

glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();

glFlush ();

}

/*************************************************/

void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 'r':
zoom = 1.0;
glutPostRedisplay();
printf ("zoom reset to 1.0\n");
break;

case 'z':
zoom = zoom + 0.5;
if (zoom >= 3.0)
zoom = 3.0;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
break;

case 'Z':
zoom = zoom - 0.5;
if (zoom <= 0.5)
zoom = 0.5;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
break;


/***************/

case 't' :
X = X - 0.5;
glutPostRedisplay();
printf ("translated by %f in x axis\n", X);
break;

case 'y' :
X = X + 0.5;
glutPostRedisplay();
printf ("translated by %f in x axis\n", X);
break;



case 'g' :
Y = Y - 0.5;
glutPostRedisplay();
printf ("translated by %f in y axis\n", Y);
break;

case 'h' :
Y = Y + 0.5;
glutPostRedisplay();
printf ("translated by %f in y axis\n", Y);
break;




case 'b' :
Z = Z - 0.5;
glutPostRedisplay();
printf ("translated by %f in z axis\n", Z);
break;

case 'n' :
Z = Z + 0.5;
glutPostRedisplay();
printf ("translated by %f in z axis\n", Z);
break;



case ' ' :
X=Y=Z=0;
glutPostRedisplay();
printf ("original position with no translation\n");
break;

/***********/

case 'u' :
printf("\n rotate command - enter angle, axis(x,y,z) of rotation\n");
scanf("%f %f %f %f", &angle,&a,&b,&c);
glutPostRedisplay();
printf ("rotated by angle %f, along axis (%f,%f,%f)\n", angle,a,b,c);
break;


case 'i' :
angle=a=b=c=0;
glutPostRedisplay();
printf ("original position\n");
break;


/***********/


case 27:
exit(0);
break;



default:
break;
}
}


/*************************************************************/

void mouse(int button, int state, int x, int y)
{
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
{zoom = zoom + 0.25;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
}
break;

case GLUT_RIGHT_BUTTON:
if (state == GLUT_DOWN)
{zoom = zoom - 0.25;
if (zoom<= 0.25)
zoom=0.25;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
}
break;

case GLUT_MIDDLE_BUTTON:
if (state == GLUT_DOWN)
{zoom = 1.0;
glutPostRedisplay();
printf ("zoom reset to 1.0, original image (no zoom)\n");
}


/* mouse scroll button */
/* else if (state == GLUT_UP)
{

if (button == GLUT_WHEEL_UP)
{
zoom = zoom + 0.5;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
}
break;

if (button == GLUT_WHEEL_DOWN)
{
zoom = zoom - 0.5;
glutPostRedisplay();
printf ("zoom is now %4.1f\n", zoom);
}
break;
}
*/

default:
break;
}
}



/***************************************** myGlutIdle() ***********/

void myGlutIdle( void )
{
/* According to the GLUT specification, the current window is
undefined during an idle callback. So we need to explicitly change
it if necessary */

if ( glutGetWindow() != abc )
glutSetWindow(abc);



inc = 1;
drawBox();
glutSwapBuffers();

glFlush();

}


/***************************************************************/

void init(void)
{

glShadeModel(GL_FLAT);

GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat_shininess[] = {100.0};

glEnable(GL_LIGHTING);
//glEnable( GL_NORMALIZE );

/* Enable a single OpenGL light. */
if (type==1)
{ glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse_R);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse_R);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glEnable(GL_LIGHT1);
}

else

{glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse_B);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse_B);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glEnable(GL_LIGHT1);

}


glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular );
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);

/* Use depth buffering for hidden surface elimination. */
glEnable(GL_DEPTH_TEST);

/* Setup the view of the cube. */

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective( /* field of view in degree */ 25.0,
/* aspect ratio */ 1.0,
/* Z near */ 1.0, /* Z far */ 100);
glMatrixMode(GL_MODELVIEW);

}

/*******************************************************/

int
main(int argc, char **argv)
{
read_surface();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

glutInitWindowSize(800,800);
glutInitWindowPosition(20,20);
abc = glutCreateWindow("red Pressure disribution");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);

/* GLUI CODE */
//GLUI *glui = GLUI_Master.create_glui("GLUI TOOLBAR", 0, 400, 50);

GLUI *glui = GLUI_Master.create_glui_subwindow(abc, GLUI_SUBWINDOW_RIGHT );

glui->add_statictext( " TOOLBAR" );
glui->add_separator();
/**********/
GLUI_Panel *obj_panel = glui->add_panel ( "Operation 1" );

GLUI_Rotation *view_rot = glui->add_rotation_to_panel( obj_panel, "ROTATION", view_rotate);
view_rot->set_spin( 0.0);
glui->add_separator_to_panel(obj_panel);

/*************/

GLUI_Panel *obj_panel1 = glui->add_panel ( "Operation 2" );


GLUI_Translation *trans_xy =
glui->add_translation_to_panel( obj_panel1, "XY translation", GLUI_TRANSLATION_XY, obj_pos );
trans_xy->set_speed( .05);
glui->add_separator_to_panel(obj_panel1);
/*************/

GLUI_Translation *trans_x =
glui->add_translation_to_panel( obj_panel1, "X translation", GLUI_TRANSLATION_X, obj_pos );
trans_x->set_speed( .05);
glui->add_separator_to_panel(obj_panel1);
/*************/

GLUI_Translation *trans_y =
glui->add_translation_to_panel( obj_panel1, "Y translation", GLUI_TRANSLATION_Y, &obj_pos[1] );
trans_y->set_speed( .05);
glui->add_separator_to_panel(obj_panel1);

/****************/

GLUI_Translation *trans_z =
glui->add_translation_to_panel( obj_panel1, "Z translation", GLUI_TRANSLATION_Z, &obj_pos[2] );
trans_z->set_speed( .05);


glui->set_main_gfx_window( abc );

/* We register the idle callback with GLUI, *not* with GLUT */
GLUI_Master.set_glutIdleFunc( myGlutIdle );

glutMainLoop();

return 0; /* ANSI C requires main to return int. */
}

satchel
05-26-2009, 10:57 AM
For starters, it doesn't work on linux because of this:

#include <windows.h>
You could rewrite the sections of the code which use this header file to make a linux version... or you could be lazy and just run it in wine, it should work.
Here's a link : http://www.winehq.org/
Also, to make it run in linux, you'd need to compile it in linux, not just transfer it over which it sounds like you've done

oracleguy
05-26-2009, 05:12 PM
If you want to build on an OpenGL app on Linux it is obviously possible, just use different header files. I didn't really see any code that relies on Windows.h in your code example, the solution might be as simple as removing the include directive.