Vai al contenuto
lauke

Opengl Problemi E Suggerimenti

Recommended Posts

Salve ragazzi ri-salve, mi chiamo Luca e sono uno studente del terzo anno di ingegneria informatica. Sto preparando una tesi di laurea sulla modellazione 3D. Tuttavia è un campo che non ho mai studiato se non da una settimana a questa parte...per cui al minimo problema non so come reagire. Allora...faccio prima a mostrarvi il codice che mi da problemi, nella sostanza volevo gestire due immagini su due finestre distinte ciascuna con un proprio event handler.


/*

Si scriva un programma C, che permetta di visualizzare su due finestre distinte

due figure geometriche distinte. Ambo le finestre dovranno reagire ad input

esterni:

        Evento:

                  Se viene premuto 'a': rotazione in verso antiorario

                  Se viene premuto 'd': rotazione in verso orario

*/


#include <stdio.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glut.h>

#include <malloc.h>

#include <pthread.h>

#include <semaphore.h>


/*

Variabili globali...

*/

int teta, teta1; //angolazione del primo disegno per la rotazione...

int X; int Y; //posizione del secondo disegno per lo spostamento...

int argcp;

char **argvp;


/*

Per l'inizializazzione di sistema...

*/

void init(); //Inizializazzione di sistema...


/*

Per i disegni su schermo...

*/

void display1(); //primo disegno, con i suoi eventi...

void display2(); //secondo disegno con i suoi eventi...


/*

Per la gestione delle finestre e dei relativi eventi...

*/

void* window1(void* arg);

void* window2(void* arg);

void keyboardEvent(unsigned char key, int x, int y); //handler per la tastiera

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


int main(int argc, char** argv) {


    argcp = argc;

    argvp = argv;


    pthread_t thread1, thread2;

    pthread_create(&thread1,NULL,&window1,NULL);

    pthread_create(&thread2,NULL,&window2,NULL);


    pthread_join(thread1,NULL);

    pthread_join(thread2,NULL);

    system("pause");

    return 0;


    }


void init() {


     /*

     Colore di pulizia della finestra

     */

     glClearColor(0.0,0.0,0.0,0.0);


     /*

     Impostazioni iniziali di viewport

     */

     teta = 0; //angolo iniziale per la prima finestra

     teta1 = 0;

     glMatrixMode(GL_PROJECTION);

     glLoadIdentity();

     glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);


     }


void display1() {


     glClear(GL_COLOR_BUFFER_BIT); //pulisco il buffer...


     /*

     Qui disegno un triangolo...a tre colori

     */

     GLfloat pt[] = {

             0.25,0.25,0.0,

             0.75,0.25,0.0,

             0.5,0.80,0.0

             };


     GLfloat color[] = {

             1.0,0.0,0.0,

             0.0,1.0,0.0,

             0.0,0.0,1.0

             };


     glEnableClientState(GL_VERTEX_ARRAY);

     glEnableClientState(GL_COLOR_ARRAY);


     glVertexPointer(3,GL_FLOAT,0,pt);

     glColorPointer(3,GL_FLOAT,0,color);


     GLubyte index[] = {0,1,2};


     /*

     Vai col disegno...devo ricordarmi delle trasformazioni,

     in questo caso rotazioni...

     */


     glMatrixMode(GL_MODELVIEW);

     glTranslatef(0.5,0.5,0.0);

     glRotatef((GLfloat)teta,0.0,0.0,1.0); //il teta varierà con un evento I/O, il mutex su teta non sarà necessario...

     glTranslatef(-0.5,-0.5,0.0);

     glDrawElements(GL_POLYGON,3,GL_UNSIGNED_BYTE,index);

     glLoadIdentity(); //ricarico la matrice identità, per evitare schifezze...


     glutSwapBuffers();


     }


void display2() {


     glClear(GL_COLOR_BUFFER_BIT);


     GLfloat pt[] = {

             0.25,0.25,0.0,

             0.75,0.75,0.0

             };


     GLfloat color[] = {

             1.0,0.0,0.0,

             0.0,0.0,1.0

             };


     glEnableClientState(GL_VERTEX_ARRAY);

     glEnableClientState(GL_COLOR_ARRAY);


     glVertexPointer(3,GL_FLOAT,0,pt);

     glColorPointer(3,GL_FLOAT,0,color);


     GLubyte index[] = {0,1};


     glMatrixMode(GL_MODELVIEW);

     glTranslatef(0.5,0.5,0.0);

     glRotatef((GLfloat)teta1,0.0,0.0,1.0); //il teta varierà con un evento I/O, il mutex su teta non sarà necessario...

     glTranslatef(-0.5,-0.5,0.0);

     glDrawElements(GL_LINES,2,GL_UNSIGNED_BYTE,index);

     glLoadIdentity();


     glutSwapBuffers();


     }


void* window1(void* arg) {


      glutInit(&argcp,argvp);

      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

      glutInitWindowSize(512,384);

      glutInitWindowPosition(50,50);

      glutCreateWindow("Window 1");


      init();


      glutDisplayFunc(&display1);

      glutKeyboardFunc(&keyboardEvent);

      glutMainLoop();


      }


void* window2(void* arg) {


      glutInit(&argcp,argvp);

      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

      glutInitWindowSize(512,384);

      glutInitWindowPosition(100,100);

      glutCreateWindow("Window 2");


      init();


      glutDisplayFunc(&display2);

      glutKeyboardFunc(&keyboardEvent2);

      glutMainLoop();


      }


void keyboardEvent(unsigned char key, int x, int y) {


     switch(key) {

                 case 'a':

                      teta = (teta + 10)%360;

                      glutPostRedisplay();

                      break;

                 case 'd':

                      teta = (teta - 10)%360;

                      glutPostRedisplay();

                      break;

                 default:

                         break;

                 }


     }


void keyboardEvent2(unsigned char key, int x, int y) {


     switch(key) {

                 case 'a':

                      teta1 = (teta1 + 10)%360;

                      glutPostRedisplay();

                      break;

                 case 'd':

                      teta1 = (teta1 - 10)%360;

                      glutPostRedisplay();

                      break;

                 default:

                         break;

                 }


     }


Solo che ho un problema con le glut, la glut init è il problema, se lo fate partire vi darà, non sempre, qualke errore, il "non sempre" è dovuta alla gestione delle finestre tramite thread probabilmente... allora la mia domanda è...

Come risolvo il problema?

Altra cosa...per il tipo di operazioni che sto facendo con questo programma, vi sembra un "buon" codice? mi date qualke dritta in caso per scrivere codici migliori?

Note:

1. Ripeto sono nuovo nell'ambiente...per cui magari l'errore è una fesseria, ma non so reagire

2. Quanto so sull'argomento l'ho studiato nei primi 3 capitoli di questo libro http://www.glprogramming.com/red/.

Proprio se volete sapere cosa so, basta che guardate i primi tre capitoli, essendo in inglese però tenete conto che potrei non aver afferrato qualcosa.

Grazie tante per l'attenzione

Saluti Luca.

P.S. Ho scritto lo stesso forum sulla sezione tuturial programmazione, perchè non sapevo di preciso dove inserirmi. Non si arrabbino (bhu..) gli amministratori, chiedo scusa...

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

ciao

il 99% degli utenti che sono qui non programmano mai nulla e usano i programmi pronti con gui evolute, quindi difficilemte ti si potra rispondere, in ogni caso benvenuto

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Che tipo di errore ti da'?

Io ho ri-iniziato da poco con il visual c++ 6 e le open gl, prima facevo in directx, e sinceramente non ho avuto errori, ma non includo glut ma glaux.

Semmai prima di utilizzare glut, prova con le funzioni base, quando tutto ti funziona prova ad usarle

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

ciao, ti ho unito le due discussioni.

come ti diceva giustamente algosuk è una questione molto specifica, per cui è meglio lasciare in piedi solo il thread nella sezione corretta, difficilmente in principianti troverai qualcuno in grado di aiutarti ;)

in futuro evita di aprire diverse discussioni uguali, se per caso sbagli e te ne rendi conto contatta un moderatore e si provvederà a spostarla nella sezione corretta.

benvenuto e buona permanenza.

:)

Condividi questo messaggio


Link al messaggio
Condividi su altri siti
Inviata (modificato)

Che tipo di errore ti da'?

Io ho ri-iniziato da poco con il visual c++ 6 e le open gl, prima facevo in directx, e sinceramente non ho avuto errori, ma non includo glut ma glaux.

Semmai prima di utilizzare glut, prova con le funzioni base, quando tutto ti funziona prova ad usarle

Ma l'errore è quello di invocare due volte la init delle glut, l'errore è quello, io non so se programmi in windows, se prendi il DEV C++ e gli infili questa roba, installando pthread e glut, vedrai l'errore che ti da. Riguardo le glaux, non le ho mai usate, vedevo nei tutorial Nehe che usava queste, le glaux, se non sbaglio...però non si capisce bene come funzionano, a sintassi invece le glut mi sono sembrate più semplici, e poi non è che debba fare il 3D studio max...quindi andavano bene. Tra l'altro il red book, di cui ho riportato il link, usa le glut quindi mi sono rifatto ad esse... Cosa intendi per "funzioni di base"?

Cmq l'errore in sintesi è... che viene invocata due volte le glut, in realtà piu che errore me lo da come warning. Ecco qua:

glutInit being called a second time

P.S. Fare grafica da 0...è una gran fatica...

P.P.S. Io ho il visual C++ 2005 express edition, al suo interno ci sono le glaux? le glut non ci sono per sicuro...

Grazie per le risposte in ogni caso.


Modificato da lauke

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

per funzioni di base intendo un po' come la differenza tra la programmazione standard e le mfc...le mfc non sono altro che classi che richiamano le api standard...e siccome a me piace soffrire ed avere più controllo...non le uso :)

ti metto a questo indirizzo Mio collegamento

una voce 'Prova di OpenGL', un mini programmino che stavo facendo per provare le openGL.

Una volta unzippato nel file C_MaxGLWindow.h trovi la riga di codice o.Load("i:\\complesso.obj");

tu sostituiscila con il percorso nel quale metterai il file 'complesso.obj' che trovi nel .rar.

Nel programma c'è un mini loader per file obj che ti carica appunto 'complesso.obj', te lo texturizza con la bmp che è sempre nel file e lo fa ruotare continuamente(fino a che non vomita :) ).

Guardati un po' il codice e dimmi se c'è qualche cosa di oscuro

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Andiamo un pò sul pesante...non ho mai programmato api windows...nella sostanza del codice non so manco orientarmi...per questo sto partendo con le glut, ma mi sa che "a tempo libero" studierò le windows.h ecc... Non ho capito però bene quanto dovrebbe essere correlato questo codice a quello che chiedevo io...cioè quello che volevo capire io è come gestire più finestre contemporaneamente. Mi è sembrata la strada più giusta gestirmi ogni finestra tramite un thread...per si presentano svariati problemi, e non so come uscirmene, ho letto la documentazione delle glut e ho visto che c'è la questione della finestra corrente o meno, tramite uno stack. Forse può aiutarmi a risolvere il problema. Rielenco cmq quali sono i problemi che mi si possono presentare in base ai vari context switch.

1. Mi si renderizzano ambo le finestre, ma posso interagire solo con una di queste, cioè una è bloccata, questo dipende

da come metto i mainLoop(), se per esempio metto un mainLoop() a thread allora almeno una mi si blocca.

2. Mi dice che non posso fare il rendering, questo bhu non ho capito a cosa potrebbe essere dovuto...

Forse la soluzione sarebbe, se è possibile, che qualcuno che conosce le glut, e magari i pthread per essere "al mio passo

svolgesse l'esercizietto che ho riportato in cima al mio codice, commentandolo così io posso afferrare i miei errori.

P.S. Non ho capito cmq la correlazione del codice che hai postato con la questione, cioè non l'ho afferrata. Riguardo i punti oscuri quindi...è tutto un punto oscuro, non conosco le windows.h, e poi è oggetti quindi a maggior ragione non vedo correlazione. In ogni caso ti ringrazio perchè ti stai interessando.

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

abbiamo due maniere diverse di programmare, quindi è difficile capirsi, il codice che ti ho postato io era per farti vedere un'altra maniera di inizializzare le gl senza passare per quell'init, e quindi gestirtelo un po' come ti pareva...quando feci io un editor 3d, avevo la classica videata con le 4 viste, ogni finestra figlia della finestra principale, e in ognuna erano attive le directx(penso che per le opengl sia lo stesso)...

Per quanto riguarda il loop, avendo finestre figlie della principale tutto scorreva liscio.

Prova anche tu magari a creare non due finestre distinte e staccate ma una (non gl)che le contiene tutte e due(gl)

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Non credo siano maniere diverse, semplicemente è che tu hai più esperienza di me, il codice che mi hai fatto vedere lo dimostra, a me mancano gli strumenti per comprenderli. Potrei provare a cambiare strada, e la cosa male non mi farebbe sicuro, visto che cmq le glut hanno forti limiti come interfacce, tanto l'implementazione delle open GL non cambia, quel che cambia è dove vado a disegnare. Qualche buona guida, tipo red book, si trova in giro sulle windows.h? Tu dove hai studiato per imparare a usarle? a me tanto servono poche cose, non credo ci metterò molto a capirle...anche se vedo dal codice che cmq è un pò prolisso...farò del mio meglio.

Grazie cmq...mi fornirò di qualche strumento per comprendere ciò che hai scritto, penso cmq che continuerò a usare il C e non C++, il mio intento infatti è mantenermi ad un livello molto basso.

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Imparare le openGL? ho solo aperto google e letto le prime 2000 pagine cercando openGL tutorial :)

Per il resto della programmazione...a suo tempo...libri,l'help di vc++ e tante tante prove su tutto...internet non era così come ora...ancora si programmava su tavolette d'argilla in scrittura cuneiforme...

mantenerti a livello basso...se intendi come programmatore è una tua scelta :) , se intendi livello basso come istruzioni...io ero andato anche più in basso con l'asm, ma poi la maggior parte delle chiamate erano ad API di windows...quindi tanto valeva rimanere nel vc++...

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Sono un esperto in OpenGL.

Il tuo codice ha una brutta indentazione, ti consglio di guardare come vengono indentati di solito i programmi in C (io considero errore un codice mal indentato).

Usi "system("pause")", cosa orribile e da evitare assolutamente.

Il programma è concepito male infatti non funziona (sotto Linux salta con un brutto codice d'errore), usi i thread nel modo sbagliato, è possibile farlo senza scomodare i thread.

Ti consiglio prima di imparare meglio il C, poi passare alle OpenGL.

Per imparare le OpenGL puoi iniziare da "The Redbook" disponibile online:

http://www.opengl.org/documentation/red_book/

Ti consiglio di imparare anche le GLUT:

http://www.opengl.org/resources/libraries/glut/

hanno le funzioni per creare finestre OpenGL indipendenti attraverso la funzione "glutCreateWindow".

Un esempio di finestre multiple in OpenGL senza thread o lanciare il comando "pause".

http://www.opengl.org/resources/code/samples/glut_examples/examples/sphere.c

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Vabè...la pause era messa per abitudine...non ho capito cos'ha il mio C che non va, tra l'altro ho risolto era un problema di mutex, non sapevo su cosa metterli. Sul red book ho studiato i primi tre capitoli, i miei pthread cos'hanno che non vanno? associare un thread a finestra è sbagliato? (solo quello ho fatto...). Se mi dici perchè dovrei farlo senza thread e non con, non ci vedo nulla di male nel farmi il programma con multiprogrammazione. E poi scusa funzioni indipendenti, basta usare piu volte la createWindow sul main, devo però tener conto di quella che è la finestra corrente con le operazioni che faccio. Con i thread invece ciascuno ha un proprio spazio di memoria il problema della finestra corrente non si pone, esclusa la creazione che va messa in esclusione mutua. Il codice che volevo io funzionante alla fine è questo:


#include <stdio.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glut.h>

#include <malloc.h>

#include <pthread.h>

#include <semaphore.h>


pthread_mutex_t mtx;


void init();

void display1();

void display2();


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

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


void* window1(void* arg);

void* window2(void* arg);


int teta1;

int teta2;


int main(int argc, char** argv) {


    /*

    Inizializzo il sistema...

    */

    pthread_mutex_init(&mtx,NULL);

    glutInit(&argc,argv);

    pthread_t th_1, th_2;

    pthread_create(&th_1,NULL,&window1,NULL);

    pthread_create(&th_2,NULL,&window2,NULL);


    pthread_join(th_1,NULL);

    pthread_join(th_2,NULL);

    return 0;


    }


void init1() {

     teta1 = 0;

     glClearColor(0.0,0.0,0.0,0.0);

     glMatrixMode(GL_PROJECTION);

     glLoadIdentity();

     glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

     }


void init2() {

     teta2 = 0;

     glClearColor(0.0,0.0,0.0,0.0);

     glMatrixMode(GL_PROJECTION);

     glLoadIdentity();

     glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

     }


void display1() {

     glClear(GL_COLOR_BUFFER_BIT);


     glColor3f(1.0,1.0,1.0);


     GLfloat pt[] = {

             0.25,0.25,0.0,

             0.75,0.75,0.0

             };


     glEnableClientState(GL_VERTEX_ARRAY);

     glVertexPointer(3,GL_FLOAT,0,pt);


     GLubyte index[] = {0,1};


     glMatrixMode(GL_MODELVIEW);

     glTranslatef(0.5,0.5,0.0);

     glRotatef((GLfloat)teta1,0.0,0.0,1.0);

     glTranslatef(-0.5,-0.5,0.0);

     glDrawElements(GL_LINES,2,GL_UNSIGNED_BYTE,index);

     glLoadIdentity();


     glutSwapBuffers();

     }


void display2() {

     glClear(GL_COLOR_BUFFER_BIT);


     glColor3f(1.0,1.0,1.0);


     GLfloat pt[] = {

             0.25,0.25,0.0,

             0.75,0.25,0.0,

             0.75,0.75,0.0,

             0.25,0.75,0.0

             };


     glEnableClientState(GL_VERTEX_ARRAY);

     glVertexPointer(3,GL_FLOAT,0,pt);


     GLubyte index[] = {0,1,2,3};


     glMatrixMode(GL_MODELVIEW);

     glTranslatef(0.5,0.5,0.0);

     glRotatef((GLfloat)teta2,0.0,1.0,0.0);

     glTranslatef(-0.5,-0.5,0.0);

     glDrawElements(GL_POLYGON,4,GL_UNSIGNED_BYTE,index);

     glLoadIdentity();


     glutSwapBuffers();

     }


void keyboardEvent1(unsigned char key, int x, int y) {


     switch(key) {

                 case 'a':

                      teta1 = (teta1 + 5)%360;

                      glutPostRedisplay();

                      break;

                 case 'd':

                      teta1 = (teta1 - 5)%360;

                      glutPostRedisplay();

                      break;

                 }


     }


void keyboardEvent2(unsigned char key, int x, int y) {


     switch(key) {

                 case 'a':

                      teta2 = (teta2 + 5)%360;

                      glutPostRedisplay();

                      break;

                 case 'd':

                      teta2 = (teta2 - 5)%360;

                      glutPostRedisplay();

                      break;

                 }


     }


void* window1(void* arg) {


      pthread_mutex_lock(&mtx); //(!)

      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

      glutInitWindowSize(800,600);

      glutInitWindowPosition(100,100);

      glutCreateWindow("Window 1");

      pthread_mutex_unlock(&mtx); //(!)


      init1();


      glutDisplayFunc(&display1);

      glutKeyboardFunc(&keyboardEvent1);

      glutMainLoop();


      }


void* window2(void* arg) {


      pthread_mutex_lock(&mtx); //(!)

      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

      glutInitWindowSize(800,600);

      glutInitWindowPosition(100,100);

      glutCreateWindow("Window 2");

      pthread_mutex_unlock(&mtx); //(!)


      init2();


      glutDisplayFunc(&display2);

      glutKeyboardFunc(&keyboardEvent2);

      glutMainLoop();


      }

Fermo restando che sono aperto alle critiche. Soprattutto alla luce che c'è un'esperto, mia fortuna. Fammi sapere su quest'ultimo codice cos'è che non va.

Grazie cmq

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Il nuovo codice sotto Linux salta ancora con un brutto errore.

Programmare i thread non è facile, lo sconsiglio per un principiante, introduce solo problemi se vengono usati male. Se è possibile scrivere il codice senza thread è meglio farlo, si elimina una possibile fonte di bachi difficilmente individuabile anche con un debug.

Le librerie che gestiscono le GUI di solito non sono thread safe se non esplicitamente progettate. Un buon programmatore di solito fa' gestire la GUI ad un solo thread per evitare problemi di implementazioni.

Con i thread invece ciascuno ha un proprio spazio di memoria il problema della finestra corrente non si pone

Sbagliato i thread condividono lo stesso spazio di memoria, se un thread scrive una variabile letta da un altro thread, se non opportunamente gestita, si introduce un baco, di solito il programma esegue qualcosa di non valido e il sistema operativo termina il programma.

Se leggi la manuale della "glutMainLoop":

....

glutMainLoop enters the GLUT event processing loop. This routine should

be called at most once in a GLUT program.

...

deve essere chiamata una sola volta in tutto il programma, nel tuo codice è presente due volte.

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Riguardo i thread...

I thread condividono variabili globali e file aperti, ma relativamente al loro blocco ciascuno ha il suo spazio di memoria. La mutua esclusione va applicata in ciò che è condiviso, e in scrittura soprattutto. Nei miei thread l'unico accesso condiviso si ha quando viene chiamata la "CreateWindow". Che non so di preciso cosa vada a toccare, ma credo riguardi la finestra corrente, fatto sta che mettendo la chiamata in un mutex il problema s'è risolto.

Riguardo la MainLoop...si è vero va chiamata una volta in tutto il programma, ma va fatto così se il programma è monothread. Se ad ogni finestra associ un proprio thread, il problema si ripresenta, cioè una chiude prima del tempo. Per cui la mainLoop è necessaria.

In ogni caso gentilmente mi fai vedere questo errore "brutto" sotto linux? e se gentilmente posti la tua soluzione al problema. Così mi miglioro... grazie

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

I thread condividono variabili globali e file aperti, ma relativamente al loro blocco ciascuno ha il suo spazio di memoria. La mutua esclusione va applicata in ciò che è condiviso, e in scrittura soprattutto. Nei miei thread l'unico accesso condiviso si ha quando viene chiamata la "CreateWindow". Che non so di preciso cosa vada a toccare, ma credo riguardi la finestra corrente, fatto sta che mettendo la chiamata in un mutex il problema s'è risolto.

Tu non sai se poi le chiamate alle librerie esterne usano delle variabili globali le quali possono generare dei problemi tra i thread, il semplice lock che hai messo riguarda l'inizializzazione delle finestre, il resto delle chiamate possono interferirsi.

Riguardo la MainLoop...si è vero va chiamata una volta in tutto il programma, ma va fatto così se il programma è monothread. Se ad ogni finestra associ un proprio thread, il problema si ripresenta, cioè una chiude prima del tempo. Per cui la mainLoop è necessaria.

Questo è uno dei motivi per cui è meglio far gestire la GUI ad un thread.

In ogni caso gentilmente mi fai vedere questo errore "brutto" sotto linux? e se gentilmente posti la tua soluzione al problema. Così mi miglioro... grazie

L'errore è questo:

XIO: fatal IO error 11 (Resource temporarily unavailable) on X server ":0.0"

after 53 requests (49 known processed) with 10 events remaining.

Segmentation fault

(gdb) where

#0 0x000000357c631f45 in *__GI_raise (sig=<value optimized out>) at ../nptl/sysdeps/unix/sysv/linux/raise.c:64

#1 0x000000357c634d80 in *__GI_abort () at abort.c:88

#2 0x000000357c62b08a in *__GI___assert_fail (assertion=<value optimized out>, file=<value optimized out>, line=<value optimized out>, function=<value optimized out>) at assert.c:78

#3 0x000000357e24f043 in ?? () from /usr/lib/libX11.so.6

#4 0x000000357e24f897 in _XEventsQueued () from /usr/lib/libX11.so.6

#5 0x000000357e23823d in XPending () from /usr/lib/libX11.so.6

#6 0x000000324b81fb68 in glutMainLoopEvent () from /usr/lib/libglut.so.3

#7 0x000000324b820507 in glutMainLoop () from /usr/lib/libglut.so.3

#8 0x0000000000401496 in window2 ()

#9 0x000000357d20673a in start_thread (arg=<value optimized out>) at pthread_create.c:300

#10 0x000000357c6cb69d in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:112

#11 0x0000000000000000 in ?? ()

La soluzione per me è non usare i thread, è facile basta guardare il codice d'esempio riportato prima.

Condividi questo messaggio


Link al messaggio
Condividi su altri siti

Crea un account o accedi per commentare

Devi essere un utente per poter lasciare un commento

Crea un account

Registrati per un nuovo account nella nostra comunità. è facile!

Registra un nuovo account

Accedi

Hai già un account? Accedi qui.

Accedi ora

  • Navigazione recente   0 utenti

    Non ci sono utenti registrati da visualizzare in questa pagina.

×