begin process at 2012 05 29 18:28:36
  Trouver un code source :
 
dans
 
Accueil > Forum > 

C

 > 

Windows

 > 

Autre

 > 

PB POUR LA GESTION MULTIFENETRES


Derniers messages déposésPoser une question dans le forum ou lancer une discussion

PB POUR LA GESTION MULTIFENETRES

mardi 4 juillet 2006 à 14:58:51 | PB POUR LA GESTION MULTIFENETRES

algeros

Voici un code :

////////////////////////////////////////////////////////////////
//                                                         
//   Name: MenuGlut                                      
//   Copyright:                                         
//   Author: Algex                                       
//   Date: 01/07/06 16:13                               
//   Description: programme pour tester les menus avec glut et les fenetres  
//                                                           
////////////////////////////////////////////////////////////////


/*les includes*/
#include        <stdio.h>

#include        <stdlib.h>

#include        <windows.h>

#include        <GL/glut.h>

#include        <stdarg.h>

#include        <string.h>

#include        "tgaload.h"



/*les defines*/
#define         MAX_NO_TEXTURES 3

#define         CUBE_TEXTURE 0

#define         FCUBE_TEXTURE 1

#define         MCUBE_TEXTURE 2


/*les variables globales*/
GLuint          texture_id[MAX_NO_TEXTURES];

int             texture               =  0;

int             idMenuRacine          =  0;

int             idMenuTransformation  =  0;

int             choix                 =  0;


float           xrot   = 0.0;

float           yrot   = 0.0;

float           xspeed = 0.0;           

float           yspeed = 0.0;       

float           ratio  = 0.0;

float           z      =-5.0f;   


GLfloat         LightAmbient[]  =        { 0.5f, 0.5f, 0.5f, 1.0f };

GLfloat         LightDiffuse[]  =        { 1.0f, 1.0f, 1.0f, 1.0f };

GLfloat         LightPosition[] =        { 0.0f, 0.0f, 2.0f, 1.0f };
           

bool            light;               

bool             blend;   

bool            fullscreen;           

bool            lp;                   

bool            fp;                   

bool            bp;

bool            fsp;           


void            LoadGLTextures    (char name[]);

void            InitGL            (void);

void            reshape           (int w, int h);

void            displayMain       (void);

void            arrow_keys        (int a_keys, int x, int y);

void            keyboard          (unsigned char key, int x, int y);

void            menuPrincipal     (int value);

void            menuTransformation(int value);

void            displayFille      (void);

void            bitmap_output     (int x,int y,char *string,void *font);


enum            {TRANSPARENCE, LUMIERE, PLEIN_ECRAN, TEXTURE, QUITTER};

enum            {ATLANTIC, GLASS, VORTEX};

/*fonction principale*/
int main (int argc, char** argv)
{
///////////////////////////INITIALISATION////////////////////////////////////////////
 
  glutInit                 (&argc, argv);
 
  glutInitDisplayMode      (GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
 
  /*on initialise*/
  InitGL                   ();
 

//////////////////////////////FENETRE 1///////////////////////////////////////////////////// 
  glutInitWindowPosition   (0,0);
 
  /*si la fenetre n'est pas en plein écran on se met en taille 500 * 500*/
  glutInitWindowSize       (500, 500);
 
  
 
 
  choix = MessageBoxA      (NULL, "Voulez-vous executer l'application en plein écran?", "Quel mode ?", MB_YESNOCANCEL | MB_ICONQUESTION);
  if(choix == IDYES)
  {
  /*on se met en plein écran*/
  glutFullScreen           ();
 
  fsp = true;
  }
 
  if(choix == IDCANCEL)
  //on quitte
  exit(0);
 
  /*titre de la fenetre*/
  int f1 ;
  f1 = glutCreateWindow         ("application");
 
  /*on fait une fonction d'affichage*/
  glutDisplayFunc            (displayMain);
 
  /*redimensionnement*/
  glutReshapeFunc            (reshape);
 
  /*fonction de gestion des touches*/
  glutKeyboardFunc           (keyboard);
 
  /*fonction spéciale*/
  glutSpecialFunc            (arrow_keys);
 
 
  glutIdleFunc                 (displayMain);
 
  idMenuTransformation  =  glutCreateMenu(menuTransformation);
 
 
  glutAddMenuEntry           ("lumiere", LUMIERE);
 
  glutAddMenuEntry           ("Transparence", TRANSPARENCE);
 
 
  idMenuRacine  =  glutCreateMenu(menuPrincipal);
 
  glutAddSubMenu             ("Transformation", idMenuTransformation);
  
  glutAddMenuEntry           ("plein ecran", PLEIN_ECRAN);
 
  glutAddMenuEntry           ("Quitter", QUITTER);
 
  glutAttachMenu             (GLUT_RIGHT_BUTTON);
 
 
 
 
/////////////////////////////FENETRE 2////////////////////////////////// 
  glutInitWindowPosition   (10,10);
 
  glutInitWindowSize       (350,250);
 
  int f2;
  f2 = glutCreateWindow ("touches");
 
  glClearColor(1.0,1.0,1.0,1.0);
  glColor3f(0,0,0);
  glLineWidth(3.0);
  /*on fait une fonction d'affichage*/
  glutDisplayFunc            (displayFille);
 
 
  /*boucle infinie*/
  glutMainLoop               ();
 
  return 0;
}

void menuPrincipal(int value)
{
  switch(value)
  {
               case PLEIN_ECRAN:  fsp=TRUE; fullscreen = !fullscreen;
              
               if(fullscreen)
               glutFullScreen();
              
               else
               glutReshapeWindow(500, 500); break;
              
               case QUITTER: exit(0); break;
                 
               default: break;
  }
}

/*menu de transformation*/
void menuTransformation(int value)
{
     switch(value)
     {
                  case TRANSPARENCE:  bp=TRUE; blend = !blend;
                 
                  if(blend)
                  {
                  glEnable(GL_BLEND);
                  glDisable(GL_DEPTH_TEST); }
                 
                  else
                  glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); break;
                 
                  case LUMIERE: lp=TRUE; light=!light;
                 
                  if (!light)
                 
                  glDisable(GL_LIGHTING);
                 
                  else
                 
                  glEnable(GL_LIGHTING); break;
     }
}

/*initialisation d'openGL*/
void InitGL()

   /*on se met en mode texturage*/
   glEnable           (GL_TEXTURE_2D);
                     
   glShadeModel       (GL_SMOOTH);
                     
   /*on efface l'écran*/
   glClearColor       (0.0f, 0.0f, 0.0f, 0.5f);               
                     
   /*on initialise la profondeur*/
   glClearDepth       (1.0f);                                   
                     
   /*on se met en mode profondeur*/
   glEnable           (GL_DEPTH_TEST);
                     
   /*on crée une fonction de profondeur*/
   glDepthFunc        (GL_LEQUAL);                           
                     
   glHint             (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
                     
   /*un peu de lumière ça fait du bien*/
   glLightfv          (GL_LIGHT1, GL_AMBIENT, LightAmbient);
                     
   glLightfv          (GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
                     
   glLightfv          (GL_LIGHT1, GL_POSITION,LightPosition);
                     
   /*c'est possible de la voir*/
   glEnable           (GL_LIGHT1);
                     
   /*on a une couleur transparente*/
   glColor4f          (1.0f,1.0f,1.0f,0.5f);
                     
   /*on a une fonction de blending*/
   glBlendFunc        (GL_SRC_ALPHA,GL_ONE);   


/*le chargement des textures avec tga*/
void LoadGLTextures(char name[])
{
   glPixelStorei        (GL_UNPACK_ALIGNMENT, 1);
  
   glGenTextures        (3, texture_id);

   image_t              temp_image;

   glBindTexture        (GL_TEXTURE_2D, texture_id [0]);
  
   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);

   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  
   tgaLoad              (name, &temp_image, TGA_FREE | TGA_LOW_QUALITY );
 
   glBindTexture        (GL_TEXTURE_2D, texture_id [1] );
                       
   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  
   tgaLoad              (name, &temp_image, TGA_FREE | TGA_LOW_QUALITY );
                       
   glBindTexture        (GL_TEXTURE_2D, texture_id [2] );
                       
   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

   glTexParameteri      (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST );
  
   tgaLoad              (name, &temp_image, TGA_FREE | TGA_LOW_QUALITY );
}

/*fonction de redimensionnement*/
void reshape( int w, int h )
{
   if(h == 0)
   h  =  1;

   ratio  =  1.0f * w / h;


   glMatrixMode         (GL_PROJECTION);
  
   glLoadIdentity       ();

   glViewport           (0, 0, w, h);

   gluPerspective       (80,ratio,1,200);
  
   glMatrixMode         (GL_MODELVIEW);
  
   glLoadIdentity       ();
  
   gluLookAt            (0, 0, 30, 0, 0, 10, 0.0f, 1.0f, 0.0f);
}

/*fonction d'affichage*/
void displayMain()
{
   glClear              (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glLoadIdentity       ();
  
   glPushMatrix         ();

   glTranslatef         (0.0, 0.0, z );

   glRotatef            (xrot, 1.0, 0.0, 0.0 );

   glRotatef            (yrot, 0.0, 1.0, 0.0 );
  
   /*on charge les textures*/
   LoadGLTextures     ("glass.tga");
  
   glBindTexture        (GL_TEXTURE_2D, 2);
  
   glBegin              (GL_QUADS);
  
        /*face avant*/
           glTexCoord2f    (0.0f, 0.0f); glVertex3f    (-1.0f, -1.0f,  1.0f);

          glTexCoord2f    (1.0f, 0.0f); glVertex3f    ( 1.0f, -1.0f,  1.0f);

        glTexCoord2f    (1.0f, 1.0f); glVertex3f    ( 1.0f,  1.0f,  1.0f);

        glTexCoord2f    (0.0f, 1.0f); glVertex3f    (-1.0f,  1.0f,  1.0f);
       
        /*face arriere*/
        glTexCoord2f    (1.0f, 0.0f); glVertex3f    (-1.0f, -1.0f, -1.0f);

        glTexCoord2f    (1.0f, 1.0f); glVertex3f    (-1.0f,  1.0f, -1.0f);

        glTexCoord2f    (0.0f, 1.0f); glVertex3f    ( 1.0f,  1.0f, -1.0f);

        glTexCoord2f    (0.0f, 0.0f); glVertex3f    ( 1.0f, -1.0f, -1.0f);
       
        /*face de dessus*/
        glTexCoord2f    (0.0f, 1.0f); glVertex3f    (-1.0f,  1.0f, -1.0f);

        glTexCoord2f    (0.0f, 0.0f); glVertex3f    (-1.0f,  1.0f,  1.0f);

        glTexCoord2f    (1.0f, 0.0f); glVertex3f    ( 1.0f,  1.0f,  1.0f);

        glTexCoord2f    (1.0f, 1.0f); glVertex3f    ( 1.0f,  1.0f, -1.0f);
       
        /*face de dessous*/
        glTexCoord2f    (1.0f, 1.0f); glVertex3f    (-1.0f, -1.0f, -1.0f);

        glTexCoord2f    (0.0f, 1.0f); glVertex3f    ( 1.0f, -1.0f, -1.0f);

        glTexCoord2f    (0.0f, 0.0f); glVertex3f    ( 1.0f, -1.0f,  1.0f);

        glTexCoord2f    (1.0f, 0.0f); glVertex3f    (-1.0f, -1.0f,  1.0f);
       
        /*face de droite*/
        glTexCoord2f    (1.0f, 0.0f); glVertex3f    ( 1.0f, -1.0f, -1.0f);

        glTexCoord2f    (1.0f, 1.0f); glVertex3f    ( 1.0f,  1.0f, -1.0f);

        glTexCoord2f    (0.0f, 1.0f); glVertex3f    ( 1.0f,  1.0f,  1.0f);

        glTexCoord2f    (0.0f, 0.0f); glVertex3f    ( 1.0f, -1.0f,  1.0f);
       
        /*face de gauche*/
        glTexCoord2f    (0.0f, 0.0f); glVertex3f    (-1.0f, -1.0f, -1.0f);

        glTexCoord2f    (1.0f, 0.0f); glVertex3f    (-1.0f, -1.0f,  1.0f);

        glTexCoord2f    (1.0f, 1.0f); glVertex3f    (-1.0f,  1.0f,  1.0f);

        glTexCoord2f    (0.0f, 1.0f); glVertex3f    (-1.0f,  1.0f, -1.0f);
       
    glEnd              ();

   /*on vire la matrice*/
   glPopMatrix         ();
  
   xrot+=xspeed;

   yrot+=yspeed;

   glutSwapBuffers     ();
}

/*fonction de gestion des clés*/
void keyboard (unsigned char key, int x, int y)
{
  switch (key)
  {
    case 27: exit (0); break;
   
    case 'l': lp=TRUE; light=!light;
   
    if (!light)
    glDisable(GL_LIGHTING);
   
    else
    glEnable(GL_LIGHTING);break;
   
    case 'b': bp=TRUE; blend = !blend;
   
    if(blend)
    {glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);}
   
    else
   
    {glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);} break;
     
    default: break;
  }
}

void arrow_keys (int a_keys, int x, int y)
{
  switch (a_keys)
  {
    case GLUT_KEY_UP:        xspeed-=0.1f; break;
   
    case GLUT_KEY_DOWN:      xspeed+=0.1f; break;
   
    case GLUT_KEY_RIGHT:     yspeed+=0.1f; break;
   
    case GLUT_KEY_LEFT:      yspeed-=0.1f; break;
   
    case GLUT_KEY_F1:        glutFullScreen (); break;
   
    case GLUT_KEY_F2:        glutReshapeWindow (500, 500); break;
   
    default: break;
  }
}

void displayFille()
{
    glClear (GL_COLOR_BUFFER_BIT);
   
    bitmap_output(70,240,"appuyez sur F1 pour passer en plein ecran",GLUT_BITMAP_HELVETICA_18);
   
    glutSwapBuffers();
}

void bitmap_output(int x,int y,char *string,void *font)
{
  int len,i;
 
  glRasterPos2f(x,y);
 
  len = (int) strlen(string);
 
  for (i = 0; i < len; i++)
  {
 
    glutBitmapCharacter(font,string[i]);
 
  }
}

Désolé pour la longueur

J'aimerai savoir pourquoi l'ordi m'affiche un cube non texture ?
En plus il ne m'affiche meme pas le texte dans la 2ème fenetre...


Cette discussion est classée dans : int, void, gl, texture, 0f


Répondre à ce message

Sujets en rapport avec ce message

Pb de FRONT et BACK buffer avec texture [ par gastoudou ] Bonjour à tous,Je suis en train de faire un projet en OpenGL pour l'école sur un puzzle 2D. Il y a 16 cases mélangées et on doit les remettre à leur p labyrinthe en 3D sytle ecran veille windows [ par gastoudou ] Bonjour à tous,Et oui encore moi pour une question, que dis-je, une mission pour une âme charitable.Je suis en train de faire un labyrinthe en 3D styl pikcing opengl [ par znb ] J 'ai fait un code et ça marche très bien; il détecte les couleurs des objets. Mais je veux que, pour une valeur particulière de la couleur, dessiner probleme de selection dans opengl [ par oswa ] bonjour, svp j'ai besoin d'un aide urgent. en effet, j'ai realiser un programme en c++ qui utilise opengl. ce programme permet de dessiner plusieurs [opengl] glGenTextures et new [ par gillescpp ] Voila, J'ai un probleme avec opengl. J'explique rapidement : apres un appel de glGenTextures, il m'est impossible d'allouer de la mémoire dynamiquemen Texture transparente [ par F0ra ] Bonjour,Je voudrais aff transparence en OpenGl [ par F0ra ] Bonjour, J'ai un problème en OpenGl Je voudrais rendre uniquement la couleur rose< Problème de placage de texture [ par unrealgun ] Bonjour,Je suis en train de développer uGUI en C++ sous linux avec SDL et OpenGL.Voila mon probleme : je charge une image PNG transparente avec SDL_Im [OpenGL] rotation [ par F0ra ] Bonjour,J'ai un problème pour réaliser une rotation en OpenGL au centre du rectangle.J'ai esayé avec glRotatef(ang,0.0,0.0,1.0);  le problème l'origni Texture d'une glutSphere [ par Dante41 ] Salut à tous, J'ai besoin de votre aide. j'essaie de recréer le système solaire en OpenGL par conséquent , il faut que je fasse toutes les planètes av


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,248 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales