język C, glut, DevC++

Question

Witam :) Za zadanie mam dodanie opcji menu do zmiany koloru wyświetlanego tekstu. Jednak przy zmianie koloru tekstu zmienia się także kolor figury i na odwrót. Jeśli ktoś zauważa mój błąd, proszę o pomoc. Pozdrawiam

#include <GL/glut.h>    // Nagłówek do GLUT
#include <stdio.h>
#include <string.h>
 
//Inicjalizacja OpenGL - funkcja wywolywana po utworzeniu okna
void InitGL(int Width, int Height)               
{
  glClearColor(0.0, 0.0, 1.0, 0.0); // czyszczenie okna kolorem RGBA (czarny)           
  //glClearDepth(1.0);                // czyszczenie bufora glebokosci            
  //glDepthFunc(GL_LESS);             // ustawienie funkcji bufora glebokosci     
  //glEnable(GL_DEPTH_TEST);          // wlaczenie testu bufora glebokosci        
  //glShadeModel(GL_SMOOTH);          // wlaczenie cieniownia koloru              
 
  glMatrixMode(GL_PROJECTION);  // przejscie do trybu rzutowania
  glLoadIdentity();             // Reset macirzy rzutowania
 
  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1,10.0);  // ustawienie parametrow rzutowania
 
  glMatrixMode(GL_MODELVIEW);   // przejscie do trybu modelowania
}
 
 
// funkcja reakcji na zmiane rozmiaru okna 
// - pierwszy raz wywolywana po utworzeniu okna
void ReSizeGLScene(int Width, int Height)
{
  if (Height==0) Height=1;          // zabezpieczenie przed dzieleniem przez zero 
  glViewport(0, 0, Width, Height);  // ustawienie viewportu na pelny rozmiar okna 
                                                                                 
  glMatrixMode(GL_PROJECTION);      // przejscie do trybu rzutowania             
  glLoadIdentity();                 // Reset The Projection Matrix               
 
  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1,10.0); // ustawienie parametrow rzutowania
  glMatrixMode(GL_MODELVIEW); // przejscie do trybu modelowania
}
 

int window;  // identyfikator glownego okna
 
//Zmienne globalne uzywane do tworzenia sceny (rysunku w oknie graficznym)
#define triangle 1
#define quad 2      
int color=4; 
int figure=triangle;
int showing=1;
int autoRot = 0; // gdy 0 to brak automatycznego obrotu, gdy 1 to sie obracachar kolorTlo[64] = " tle czarnym"; // tablica znakowa do przechowywania nazwy koloru 
char kolor[64]= "bialy ";
char kfigura[64]= " trojkat ";
char kolorTlo[64] = " na tle niebieskim"; // tablica znakowa do przechowywania nazwy koloru 
int submenu1, submenu2, submenu3, submenu4, submenu5, submenu6, submenu7, submenu8; //Uchwyty menu
float rotX = 0.0, rotXTemp;
float rotY = 0.0, rotYTemp;
float rotZ = 0.0, rotZTemp; 
int clickX, clickY;
float mRotSens = 0.2;
int mRotAxis = 1;
float d= 0.01;
float krok = 1.0;
int l=1;
 
//Główna funkcja rysująca
void DrawGLScene()
  {

  glutSetWindow(window);
  glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);        // czyszczenie buforow
  glLoadIdentity();       
  glutPostRedisplay();                                   // Reset macierzy przeksztalcen geometr.
  //OpenGL scene goes here///////////////////////////////////////
  if (showing)
    {
    glTranslatef(0.0, 0.0, -1.0); //rzesuniecie rysowanych obiektow o -1 wzdloz osi z
  
    glPushMatrix(); // zapamietanie stanu przekszt. geom. przed obrotem

    glRotatef(rotX, 1.0, 0.0, 0.0); // obrot wokol osi OZ
    glRotatef(rotY, 0.0, 1.0, 0.0);
    glRotatef(rotZ, 0.0, 0.0, 1.0);
  
  
   switch (color)  // PUNKT 1
      {
      case 1: glColor3f(1,0,0); // czerwony
      break;
      case 2: glColor3f(0,1,0); // zielony
      break;
      case 3: glColor3f(0,0,1); // niebieski
      break;
      case 4: glColor3f(1,1,1); // bialy
      break;
      case 5: glColor3f(0.5,0.5,0.5); // szary
      break;
      } 
      
   switch (l)  // PUNKT 1
      {
      case 1: glColor3f(1,0,0); // czerwony
      break;
      case 2: glColor3f(0,1,0); // zielony
      break;
      case 3: glColor3f(0,0,1); // niebieski
      break;
      case 4: glColor3f(1,1,1); // bialy
      break;
      case 5: glColor3f(0.5,0.5,0.5); // szary
      break;
      } 
 

   if (figure==triangle)
     {
     glBegin(GL_TRIANGLES);  // start rysowania trojkata // punkt 2
        glVertex3f( 0.0+d, 0.2+d, 0.0+d); // wspolrzedne xyz 1-go wierzcholka
        glVertex3f( 0.2+d,-0.2+d, 0.0+d); // wspolrzedne xyz 2-go wierzcholka
        glVertex3f(-0.2+d,-0.2+d, 0.0+d); // wspolrzedne xyz 3-go wierzcholka
     glEnd();               // koniec
     } 
   else
     {
     glBegin(GL_QUADS);   // start rysowania czworokata
        glVertex3f(-0.2+d,-0.2+d, 0.0+d); // wspolrzedne xyz 1-go wierzcholka
        glVertex3f( 0.2+d,-0.2+d, 0.0+d); // wspolrzedne xyz 2-go wierzcholka
        glVertex3f( 0.2+d, 0.2+d, 0.0+d); // wspolrzedne xyz 3-go wierzcholka
        glVertex3f(-0.2+d, 0.2+d, 0.0+d); // wspolrzedne xyz 4-go wierzcholka
     glEnd();
     }
   }
   glPopMatrix();
   // ponizej - sposob wypisania tekstu zapamietanego w tablicy 'kolor' w oknie graficznym (GLUT)
   int l, len;

    switch (l)  // PUNKT 1
      {
      case 1: glColor3f(1,0,0); // czerwony
      break;
      case 2: glColor3f(0,1,0); // zielony
      break;
      case 3: glColor3f(0,0,1); // niebieski
      break;
      case 4: glColor3f(1,1,1); // bialy
      break;
     
      } // kolor tekstu (pomaranczowy)
       
     
         
   glTranslatef(0.0, 0.0, 0.5); // ustalenie pozycji tekstu wzdluz osi z
   
   glRasterPos2f(-0.18, -0.18); // polozenie 1-go znaku tekstu (wspolrzedne xy sceny)
      
   len = (int) strlen(kolor);   // wyznaczenie dlugosci tekstu (ilosc znakow)
   //  ... i wypisanie w petli znak po znaku
   for (l = 0; l < len; l ++) glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, kolor[l]); 
   
   
   len = (int) strlen(kfigura);   // wyznaczenie dlugosci tekstu (ilosc znakow)  // PUNKT 1
   //  ... i wypisanie w petli znak po znaku
   for (l = 0; l < len; l ++) glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, kfigura[l]); 
   len = (int) strlen(kolorTlo);   // wyznaczenie dlugosci tekstu (ilosc znakow)
   //  ... i wypisanie w petli znak po znaku
   for (l = 0; l < len; l ++)
       glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, kolorTlo[l]); 
  ///////////////////////////////////////////////////////////////
  // inne dostepne czcionki:
  //GLUT_BITMAP_8_BY_13
  //GLUT_BITMAP_9_BY_15
  //GLUT_BITMAP_TIMES_ROMAN_10
  //GLUT_BITMAP_TIMES_ROMAN_24
  //GLUT_BITMAP_HELVETICA_10
  //GLUT_BITMAP_HELVETICA_12
  //GLUT_BITMAP_HELVETICA_18
  
  glutSwapBuffers(); // zamiana buforow koloru po narysowaniu sceny
  }
 
 
//Funkcje obslugujace poszczegolne pozycje z menu:
  void selectcoloroftext(int i){
     l=i;
     switch (l)
     {
      case 1: glColor3f (1, 0, 0);
      break;
      case 2: glColor3f(0,1,0); // zielony
      break;
      case 3: glColor3f(0,0,1); // niebieski
      break;
      case 4: glColor3f(1,1,1); // bialy
      break;
   }} 
void selectShowing(int i)  //flip-flop widoczny-niewidoczny
{
 showing=i;  // nadanie wartosci zmiennej globalnej 'showing' uzywanej przez DrawGLScene()
 if (i==0) glutChangeToMenuEntry(2,"Rysuj :)", 1); // funkcja zamiany zawartosci w pozycji menu
 else      glutChangeToMenuEntry(2,"Ukryj", 0);
}
 
 void selectFigure(int i)
{
 switch (i)
 {
  case 1: figure=triangle, sprintf(kfigura, "trojkat"); break; // nadanie wartosci zmiennej globalnej 'figure' uzywanej przez DrawGLScene() 
  case 2: figure=quad,  sprintf(kfigura, "kwadrtat");   break;
 }
}


void selectColor(int i)   // PUNKT 1
{
 color=i;  // nadanie wartosci zmiennej globalnej 'color' uzywanej przez DrawGLScene()
 switch (color)
      {
    case 1: sprintf(kolor, "czerwony"); // ... i wpisanie nazwy koloru do tablicy 'kolor'
         break;
    case 2: sprintf(kolor, "zielony"); 
         break;
    case 3: sprintf(kolor, "niebieski"); 
         break;
    case 4: sprintf(kolor, "bialy"); 
         break;
    case 5: sprintf(kolor, "szary"); 
         break;    
      }
} 
/*void selectcoloroftext(int i)   // PUNKT 1
{
 l=i;  // nadanie wartosci zmiennej globalnej 'color' uzywanej przez DrawGLScene()
 switch (l)
      {
    case 1: czerwony; // ... i wpisanie nazwy koloru do tablicy 'kolor'
         break;
    case 2: zielony; 
         break;
    case 3: sprintf(l, "niebieski"); 
         break;
    case 4: sprintf(l, "bialy"); 
         break;
    case 5: sprintf(l, "szary"); 
         break;    
      }
} */
void selectBackground(int i)
{
   switch (i)
   {
    case 1: glClearColor(1.0, 0.0, 0.0, 0.0);
         sprintf(kolorTlo, " na czerwonym tle"); // ... i wpisanie nazwy koloru do tablicy 'kolor'
         break;
    case 2: glClearColor(0.0, 1.0, 0.0, 0.0);
         sprintf(kolorTlo, " na zielonym tle"); 
         break;
    case 3: glClearColor(0.0, 0.0, 1.0, 0.0);
         sprintf(kolorTlo, " na niebieskim tle"); 
         break;
   } 
}


void SpecialKeys(int key, int x, int y) //klawisz i pozycja kursora
{  
     if (key == GLUT_KEY_UP) rotX += krok;     
     if (key == GLUT_KEY_DOWN) rotX -= krok;
     if (key == GLUT_KEY_F1) rotY += krok;
     if (key == GLUT_KEY_F2) rotY -= krok;
     if (key == GLUT_KEY_RIGHT) rotZ += krok;
     if (key == GLUT_KEY_LEFT) rotZ -= krok; 
     if (key == GLUT_KEY_F10) autoRot = 0.0;   // PUNKT 4
     glutPostRedisplay();
} 

void KeyboardKeys(unsigned char key, int x, int y)  // punkt 2
  {
  if (key == 'm') d -= 0.1;                    
  if (key == 'n') d += 0.1; 
  if (key == 's') autoRot = 1.0; 
  }
  
void click(int przycisk, int stan, int x, int y)
  {
    clickX = x; //zapamietanie pozycji Xowej klikniecia myszka
    clickY = y;
    rotXTemp = rotX; //zapamietanie kata obrotu
    rotYTemp = rotY; //zapamietanie kata obrotu
    rotZTemp = rotZ; //zapamietanie kata obrotu
  }
  
void drag(int x, int y)
  {
    if (mRotAxis == 1) {
        rotX = rotXTemp + mRotSens * (y - clickY);
        rotY = rotYTemp + mRotSens * (x - clickX);
    } else {
        rotZ = rotZTemp + mRotSens * (x - clickX);    
    }
  } 
  
void selectMRotAxis(int i){
     mRotAxis = i;
     }
     
void selectMRotSens(int i){
   switch (i)
   {
    case 1: mRotSens = 0.05;
         break;
    case 2: mRotSens = 0.2;
         break;
    case 3: mRotSens = 2.0;
         break;
   }     
}
void selectMRot(int i){}


void timerRot(int i) {
     if (autoRot == 1) {
        rotZ += 1.0; //obrot 
        //powtorne wywolanie funkcji
        glutTimerFunc(5, timerRot, 2);
     }    
}


void selectAutoRot(int i)
{
 autoRot=i;
 if (i==0) glutChangeToMenuEntry(1,"Start", 1); // funkcja zamiany zawartosci w pozycji menu
 else  {
      glutChangeToMenuEntry(1,"Stop", 0);
      glutTimerFunc(5, timerRot, 2);
 }
}

//void klawiatura(unsigned char klawisz, int x, int y){} 

//Podstawowa funkcja każdego programu
int main(int argc, char **argv)
{
  glutInit(&argc, argv);        //Inicjalizacja GLUT
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);  //Ustalenie trybu wyświetlania
 
  //Inicjalizacja i ustawienia dla okna renderingu;
  glutInitWindowSize(280, 280);         //rozmiar okna w pikselach
  glutInitWindowPosition(30, 10);         //położenie okna wzgledem lewego-gornego rogu ekranu
  window = glutCreateWindow("Zadanie Sprawdzajace 1 v0"); //utworzenie okna i ustalenie napisu na gornym pasku okna
  glutDisplayFunc(DrawGLScene);           //okreslenie funkcji wyświetlania sceny
  glutReshapeFunc(ReSizeGLScene);         //okreslenie funkcji reakcji na zmiane rozmiaru okna
  InitGL(480, 480);                       //Inicjalizacja OpenGL
  
    
  //glutKeyboardFunc(klawiatura);
  
  glutMouseFunc(click);   //okreslenie funkcji reakcji na przyciski myszy
  glutMotionFunc(drag);  //okreslenie funkcni reakcji na przeciaganie mysza
  
  glutTimerFunc(1000, timerRot, 2); //okreslenie funkcji timera
  //pierwszy parametr to opoxnienie w milisekundach
  //drugi to funkcja obsł. timer,
  //trzeci to argument przekazywany do funkcji
  
        // najpierw worzymy pod-menu oraz ustalamy wywoływane po wybraniu pozycji funkcje
        submenu1 = glutCreateMenu(selectFigure); // submenu1- uchwyt pod-menu, selectFigure - funkcja obslugujaca
        glutAddMenuEntry("Trojkat", 1); // napis w menu i wartosc przekazywana do funkcji obslugujacej
        glutAddMenuEntry("Kwadrat", 2);
    
        submenu2 = glutCreateMenu(selectColor);  // analogicznia jak wyzej
        glutAddMenuEntry("Czerwony", 1);
        glutAddMenuEntry("Zielony", 2);
        glutAddMenuEntry("Niebieski", 3);
        glutAddMenuEntry("Biały", 4);
        glutAddMenuEntry("Szary", 5);
        
        
        submenu3 = glutCreateMenu(selectBackground);  // analogicznia jak wyzej
        glutAddMenuEntry("Czerwony", 1);
        glutAddMenuEntry("Zielony", 2);
        glutAddMenuEntry("Niebieski", 3);  

        submenu5 = glutCreateMenu(selectMRotAxis);
        glutAddMenuEntry("OX i OY", 1);
        glutAddMenuEntry("OZ", 2);        

        submenu6 = glutCreateMenu(selectMRotSens);
        glutAddMenuEntry("0.05", 1);
        glutAddMenuEntry("0.2", 2);
        glutAddMenuEntry("2.0", 3);        
        
        submenu4 = glutCreateMenu(selectMRot);
        glutAddSubMenu("Osie", submenu5);
        glutAddSubMenu("Czulosc", submenu6); 
        
        submenu7 = glutCreateMenu(selectAutoRot);
        glutAddMenuEntry("Start", 1);        
                
        submenu8 = glutCreateMenu(selectcoloroftext);
        glutAddMenuEntry("Czerwony", 1);
        glutAddMenuEntry("Zielony", 2);
        glutAddMenuEntry("Niebieski", 3);
        
        
        
        glutCreateMenu(selectShowing);   // menu glowne i funkcja obslugujaca
        glutAddSubMenu("Figura", submenu1);  // na 1-szej pozycji jest pod-menu
        glutAddMenuEntry("Ukryj", 0);        // 2-ga pozycja jest obslugiwana przez 'selectShowing'
        glutAddSubMenu("Tlo", submenu3);
        glutAddSubMenu("Kolor figury", submenu2);
        glutAddSubMenu("Obroty mysza", submenu4);
        glutAddSubMenu("Automatyczne obroty", submenu7);
        glutAddSubMenu("Kolor tekstu", submenu8);
 
        glutAttachMenu(GLUT_RIGHT_BUTTON);   // podlaczenie menu do prawego klawisza muszy
 
  glutIdleFunc(DrawGLScene);                //Funkcja wywołana w przypadku braku żadnych zdarzeń
 glutSpecialFunc(SpecialKeys);
  glutKeyboardFunc(KeyboardKeys);   // punkt 2
  glutMainLoop();                           //Główna pętla
 
  glutDestroyWindow(window);                //Usunięcie okna
  return 1;
}

 

Answer 1

Wrzucaj mniej kodu. Mało komu chce się przeglądać 400 linii [kiepsko sformatowanego] kodu.

glColor3f zmienia kolor w całym kontekście. Więc jeśli chcesz narysować np. zielony tekst i niebieski prostokat, to 1) ustawiasz kolor dla tekstu; 2) rysujesz tekst; 3) ustawiasz kolor dla prostokąta; 4) rysujesz postokąt.

glColor3f(0, 1, 0);
// rysuj tekst
glColor3f(0, 0, 1);
// rysuj figure

Cały OpenGL traktuj jako jedną wielką maszyne stanów.

Comments

Dziękuje za odpowiedź, ale nie bardzo rozumiem. Nie mogę przecież wrzucić funkcji void obsługującej określoną pozycje w menu gdzieś w tym miejscu:

 int l, len;

    switch (l)  // PUNKT 1
      {
      case 1: glColor3f(1,0,0); // czerwony
      break;
      case 2: glColor3f(0,1,0); // zielony
      break;
      case 3: glColor3f(0,0,1); // niebieski
      break;
      case 4: glColor3f(1,1,1); // bialy
      break;
     
      } // kolor tekstu (pomaranczowy) 
         
   glTranslatef(0.0, 0.0, 0.5); // ustalenie pozycji tekstu wzdluz osi z

 

---

To napisz to tak, żebyś mógł. OpenGL działa tak a nie inaczej i tego nie przeskoczysz.

---

Oczywiście że możesz. Wystarczy jak zrobisz tablicę z tymi kolorami a wartość wyboru to będzie indeks do tej tablicy.

Jesteś już na etapie gdzie można Ci powiedzieć: "Staraj się unikać switch/case" :-)

Answer 2

Na marginesie i obok tematu. Powinieneś mieć jakiś bardzo ważki powód by używać jeszcze DevC++. Radzę rozejrzeć się za nowszym środowiskiem.