/**
* Main Programme
*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
//framebuffer setup
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
// positioning and size of window
glutInitWindowPosition(200, 100);
glutInitWindowSize(WindowSize_X,WindowSize_Y);
glutCreateWindow(argv[0]);
//initialize viewpoint
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-4);
tbInitTransform(); // This is for the trackball, please ignore
tbHelp(); // idem
MyCameraPosition=getCameraPosition();
//activate the light following the camera
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glEnable(GL_COLOR_MATERIAL);
int LightPos[4] = {0,0,2,0};
int MatSpec [4] = {1,1,1,1};
glLightiv(GL_LIGHT0,GL_POSITION,LightPos);
//normals will be normalized in the graphics pipeline
glEnable(GL_NORMALIZE);
//clear color of the background is black.
glClearColor (0.0, 0.0, 0.0, 0.0);
// Activate rendering modes
//activate depth test
glEnable( GL_DEPTH_TEST );
//draw front-facing triangles filled
//and back-facing triangles as wires
glPolygonMode(GL_FRONT,GL_FILL);
glPolygonMode(GL_BACK,GL_LINE);
//interpolate vertex colors over the triangles
glShadeModel(GL_SMOOTH);
// glut setup... to ignore
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutDisplayFunc(display);
glutMouseFunc(tbMouseFunc); // trackball
glutMotionFunc(tbMotionFunc); // uses mouse
glutIdleFunc( animate);
init();
//main loop for glut... this just runs your application
glutMainLoop();
return 0; // execution never reaches this point
}
/****************
*
* routine de (ré)initialisation
*
****************/
void initialisation()
{
glLoadIdentity();
taille=10;
isoVal=0.5;
zoom = 1.0;
mode=GL_POLYGON;
tbInitTransform();
calculIsoSurface();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
// couches du framebuffer utilisees par l'application
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
// position et taille de la fenetre
glutInitWindowPosition(20, 80);
glutInitWindowSize(W_fen,H_fen);
glutCreateWindow(argv[0]);
// Windows only exposes OpenGL 1.1 functions.
// To call more modern functions, we need to load GLEW.
#if defined(_WIN32)
GLenum err = glewInit();
(GLEW_OK != err) ? printf("GLEW init failed!\n") : printf("GLEW init complete\n");
#endif
init( );
// Initialize viewpoint
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-4);
tbInitTransform();
tbHelp();
// cablage des callback
glutReshapeFunc(reshape);
glutIgnoreKeyRepeat(1);
glutKeyboardFunc(keyboard); //call *once* on keydown
glutKeyboardUpFunc(keyboardUp);
glutDisplayFunc(displayInternal);
glutMouseFunc(mouse);
glutMotionFunc(mouseMotion); // traqueboule utilise la souris
glutPassiveMotionFunc(mousePassiveMotion);
glutIdleFunc(animate);
glutTimerFunc(firstEnemySpawnDelay, spawnEnemy, 0);
glutTimerFunc(bossSpawnDelay, spawnBoss, 0);
// lancement de la boucle principale
glutMainLoop();
return 0; // instruction jamais exécutée
}
int main(int argc, char **argv)
{
long i,j,k;
int TailleMax;
float Max;
char *datafile;
FILE *f;
int format=2;
/**************************************/
/* test et récupération des arguments */
/**************************************/
if (argc <7) {
fprintf( stderr, "usage:\n");
fprintf( stderr, "%s filename sx sy sz hz format\n", argv[0]);
fprintf( stderr, " sx sy sz : dimensions des données\n");
fprintf( stderr, " hz : facteur d'échelle en z\n");
fprintf( stderr, " format :\n");
fprintf( stderr, " 1 - valeur sur 1 octet \n");
fprintf( stderr, " 2 - valeur sur 2 octets\n");
exit(-1);
}
/* sx , sy = dimensions des slices */
/* sz = nb de slices */
datafile = argv[1];
sx = atoi(argv[2]);
sy = atoi(argv[3]);
sz = atoi(argv[4]);
hz = atof(argv[5]);
format = atoi(argv[6]);
/*****************************************/
/* lecture et normalisation des données */
/* chaque donnée entre 0 et 65535 */
/*****************************************/
/* tableau des données volumiques */
buffer_vol = (float*) malloc(sizeof(float) * sx*sy*sz );
/* ouverture du fichier de donnée volumique */
if ((f=fopen( datafile, "r")) == 0) {
fprintf( stderr, "Impossible de lire le fichier %s\n", argv[1]);
exit(-1);
}
/* lecture des données binaires : */
/* chaque valeur sur 2 bytes (entier court entre 0 et 65535) */
/* buffer_vol[i + sx*j + sx*sy*k] est la donnée correspondant à */
/* x = i avec 0 <= i <= sx-1 */
/* y = j avec 0 <= j <= sy-1 */
/* z = k avec 0 <= k <= sz-1 */
if (format==2) /* valeur du fichier sur 2 octets */
{
for (i=0; i<sx*sy*sz; i++)
{
unsigned short v;
fread( &v, sizeof(unsigned short), 1, f);
buffer_vol[i] = v;
}
}
else if (format==1) /* valeur du fichier sur 1 octet */
{
for (i=0; i<sx*sy*sz; i++)
{
unsigned char v;
fread( &v, sizeof(unsigned char), 1, f);
buffer_vol[i] = v;
}
}
else
{
fprintf(stderr, "Mauvais format\n");
return -1;
}
fclose(f);
/* multiplication des données par un facteur pour que */
/* min(buffer_vol[i])=0.0 et max(buffer_vol[i])=1.0 */
Max=0.0;
for (i=0;i<sx*sy*sz;i++) {if (Max<buffer_vol[i]) {Max=buffer_vol[i];j=i;}}
fprintf( stderr, "Max VolData = %f, indice=%d\n", Max,j);
Max = 1.0/Max;
for (i=0;i<sx*sy*sz;i++) {buffer_vol[i] *= Max;}
Max=0.0;
for (i=0;i<sx*sy*sz;i++) {if (Max<buffer_vol[i]) {Max=buffer_vol[i];}}
fprintf( stderr, "Nouveau Max VolData = %f\n", Max);
/**********************************************/
/* initialisation de variables du programme */
/**********************************************/
/* sx2 : plus petite puissance de 2 >= sx */
/* sy2 : plus petite puissance de 2 >= sy */
/* sz2 : plus petite puissance de 2 >= sz */
/* utilisés pour la représentation des slices */
sx2 = 1; while (sx2 < sx) {sx2 *= 2;}
sy2 = 1; while (sy2 < sy) {sy2 *= 2;}
sz2 = 1; while (sz2 < sz) {sz2 *= 2;}
// fprintf( stderr, "sz2 = %d\n", sz2);
/* position initiale des coupes */
Ox=sx/2; Oy=sy/2; Oz=sz/2;
/* calcul d'une taille convenable pour le buffer de texture */
TailleMax = sx2;
if (TailleMax < sy2) {TailleMax = sy2;}
if (TailleMax < sz2) {TailleMax = sz2;}
TextureBuffer = (unsigned short*)
malloc(sizeof(unsigned short) * TailleMax * TailleMax);
/**********************************************/
/* infos diverses dans la fenetre de commande */
/**********************************************/
fprintf( stderr, "Dimensions des données %d %d %d\n", sx, sy, sz);
fprintf( stderr, "\nMode d'emploi :\n");
fprintf( stderr, "\n rotation avec la souris (bouton gauche enfoncé)\n");
fprintf( stderr, "\n touches x,y,z,X,Y,Z: modifie la position des 3 plans\n");
fprintf( stderr, " de coupe dans le volume de donnees\n");
fprintf( stderr, " touche d : switch on/off du tracé de la courbe isovaleur'\n");
fprintf( stderr, " touche 0 : copie d'écran dans le fichier 'image0.ppm'\n");
fprintf( stderr, " touches +/- : augmente/diminue l'iso-valeur\n");
fprintf( stderr, " touche i : info\n");
fprintf( stderr, " touches q,ESC : FIN\n");
info();
/*************************************************/
/* création de la fenetre avec la librairie GLUT */
/*************************************************/
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("Visu. de données volumiques");
glMatrixMode(GL_PROJECTION);
glOrtho(-sx/2.,sx/2.,-sy/2., sy/2., -1000.*hz, +1000.*hz);
glMatrixMode(GL_MODELVIEW);
tbInitTransform(); /* initialisation du point de vue */
/* Register GLUT callbacks. */
glutDisplayFunc(redraw);
glutMouseFunc(tbMouseFunc); /* gestion traqueboule */
glutMotionFunc(tbMotionFunc); /* gestion traqueboule */
glutVisibilityFunc(visible);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glClearColor( 1., 1., 1., 0.);
glClearDepth( 1.0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.0, 1.0);
/* calcul des images des 3 coupes */
makeSliceTexture();
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
/**
* Programme principal
*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
// couches du framebuffer utilisees par l'application
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
// position et taille de la fenetre
glutInitWindowPosition(200, 100);
glutInitWindowSize(config.viewportSize_X, config.viewportSize_Y);
glutCreateWindow(argv[0]);
// Initialisation du point de vue
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-4);
tbInitTransform(); // initialisation du point de vue
tbHelp(); // affiche l'aide sur la traqueboule
MyCameraPosition=getCameraPosition();
//
// Active la lumière
// Pour la partie
// ECLAIRAGE
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
glEnable(GL_COLOR_MATERIAL);
int LightPos[4] = {0,0,3,1};
int MatSpec [4] = {1,1,1,1};
glLightiv(GL_LIGHT0,GL_POSITION,LightPos);
//glMaterialiv(GL_FRONT_AND_BACK,GL_SPECULAR,MatSpec);
//glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,10);
glEnable(GL_NORMALIZE);
glClearColor (0.0, 0.0, 0.0, 0.0);
// Details sur le mode de tracé
glEnable( GL_DEPTH_TEST ); // effectuer le test de profondeur
//glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
glPolygonMode(GL_FRONT,GL_FILL);
glPolygonMode(GL_BACK,GL_LINE);
glShadeModel(GL_SMOOTH);
// cablage des callback
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutDisplayFunc(display);
glutMouseFunc(tbMouseFunc); // traqueboule utilise la souris
glutMotionFunc(tbMotionFunc); // traqueboule utilise la souris
glutIdleFunc( animate);
init();
//imidiate render
// lancement de la boucle principale
glutMainLoop();
return 0; // instruction jamais exécutée
}
