[OpenGL] Problema di redrawing inspiegabile per me

[DomusP45]

Salve a tutti.

Ho bisogno di rappresentare in una finestra OpenGL tridimensionale, una serie di cubi, di cui ho centro e dimensione memorizzati in una lista multilivello in C++...che man mano durante l'elaborazione aumentano, vengono cancellati o aggiunti, a questa lista, passaggio per passaggio dal programma principale, che si occupa dell'elaborazione. Vorrei quindi che la finestra di OpenGL mi fornisca un output aggiornato ogni volta che c'è un'elaborazione che ha modificato la lista, ma non so come fare.

Ho scritto questo codice che vi posto, dotato di un timer, che è uno stratagemma per aggiornare ogni tot la visualizzazione: mi andrebbe anche bene, ma si verifica una cosa veramente strana: sul mio portatile (che è vecchietto) con un Intel P6100 dual core ed una scheda video schifezza integrata IntelHD il codice in questione produce l'output corretto, aggiornando la visualizzazione della ricostruzione ogni tot millisecondi come da timer e permettendomi di ruotare, ingrandire la rappresentazione col mouse quando voglio. Unico problema è che scatta un pò nello zoom e va lento nella rotazione. Ma considerando la scheda video in questione, pensavo fosse normale sul portatile.

Ora, ho portato questo mio codice sul PC fisso principale, equipaggiato con un i7 2600 3.40Ghz, 8GB DDR3 e una scheda video Nvidia Quadro 4000, ma la finestra di output OpenGL magicamente fa schifo: bloccata, non è possibile nemmeno muoverla, non si aggiorna un bel niente e non visualizza quello che dovrebbe o lanciando il programma a volte si vede solo grigia con l'indicatore di attesa di windows 7 continuo...se apri e chiudi una finestra di windows da sopra, rimane la parte di finestra impressa nella finestra di OpenGL...il resto del programma (quello che si occupa dell'elaborazione della lista) viene eseguito normalmente...

Faccio presente che su entrambi i PC c'è win7 64bit professional e visual c++ 2010 correttamente configurati, e il progetto è stato comunque ricompilato sul PC fisso. Utilizzo freeglut 2.8.1 su entrambi, settato come dovrebbe.

Questo è il codice in questione:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                         PARTE DELLE FUNZIONI OPENGL PER LA RICOSTRUZIONE 3D    
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Premessa delle funzioni di posizionamento con mouse 
void mouseCB(int button, int stat, int x, int y);
void mouseMotionCB(int x, int y);

//funzioni di inizializzazione e pulizia
bool initSharedMem();
void clearSharedMem();
void initLights();
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ);
void toOrtho();
void toPerspective();

//variabili e costanti
const int   SCREEN_WIDTH    = 640;
const int   SCREEN_HEIGHT   = 480;
const float CAMERA_DISTANCE = 10.0f;

int screenWidth;
int screenHeight;
bool mouseLeftDown;
bool mouseRightDown;
bool mouseMiddleDown;
float mouseX, mouseY;
float cameraAngleX;
float cameraAngleY;
float cameraDistance;
int drawMode;

///////////////////////////////////////////////////////////////////////////////
// Funzione inizializzazione OpenGL standard
///////////////////////////////////////////////////////////////////////////////
void init()
{
	glShadeModel(GL_SMOOTH);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
	glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING); 
	glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glEnable(GL_COLOR_MATERIAL);
	initLights();
}

///////////////////////////////////////////////////////////////////////////////
// Funzione di inizializzazione globale delle variabili
///////////////////////////////////////////////////////////////////////////////
bool initSharedMem()
{
    screenWidth = SCREEN_WIDTH;
    screenHeight = SCREEN_HEIGHT;

    mouseLeftDown = mouseRightDown = mouseMiddleDown = false;
    mouseX = mouseY = 0;

    cameraAngleX = cameraAngleY = 0.0f;
    //cameraDistance = CAMERA_DISTANCE;
	cameraDistance = 0.3f;
    drawMode = 0; // 0:pieno, 1: solo contorni, 2:punti

    return true;
}

///////////////////////////////////////////////////////////////////////////////
// Funzione di pulitura variabili globali
///////////////////////////////////////////////////////////////////////////////
void clearSharedMem()
{
}

///////////////////////////////////////////////////////////////////////////////
// Inizializzazione Luci
///////////////////////////////////////////////////////////////////////////////
void initLights()
{
    GLfloat lightKa[] = {.2f, .2f, .2f, 1.0f};  // luce ambientale
    GLfloat lightKd[] = {.7f, .7f, .7f, 1.0f};  // luce diffusa
    GLfloat lightKs[] = {1, 1, 1, 1};           // luce speculare
   
	glLightfv(GL_LIGHT0, GL_AMBIENT, lightKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightKs);

    // posizione delle luci
    float lightPos[4] = {0, 0, 20, 1}; 
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

	//Attiva tutti i settaggi delle luci
    glEnable(GL_LIGHT0);                        }

///////////////////////////////////////////////////////////////////////////////
//  Posizione della telecamera e direzioni
///////////////////////////////////////////////////////////////////////////////
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX, posY, posZ, targetX, targetY, targetZ, 0, 1, 0); // eye(x,y,z), focal(x,y,z), up(x,y,z)
}

///////////////////////////////////////////////////////////////////////////////
// Impostazione proiezione ortogonale
///////////////////////////////////////////////////////////////////////////////
void toOrtho()
{
    // Imposta il viewport di tutta la finestra
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);

    // Imposta il frustum di visione
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, screenWidth, 0, screenHeight, -1, 1);

    // passaggio a modelview per interattività
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}



///////////////////////////////////////////////////////////////////////////////
// Impostazione come perspective
///////////////////////////////////////////////////////////////////////////////
void toPerspective()
{
    // Imposta il viewport di tutta la finestra
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);

    //frustum perspective
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    
	//gluPerspective(60.0f, (float)(screenWidth)/screenHeight, 1.0f, 1000.0f);
	
	gluPerspective(60.0f, (float)(screenWidth)/screenHeight, 10.0f, 0.0f); // FOV, AspectRatio, NearClip, FarClip
    
	// switch to modelview matrix in order to set scene
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione ricorsiva di disegno
///////////////////////////////////////////////////////////////////////////////
void addraw(cubo temp)
{
	//se non ci sono sottocubi
	if (temp.lista_sottocubi.size() == 0)
	{		
			if (temp.livello == LMAXI) {
				 double centro[3]={(temp.V[6].x)/2, (temp.V[6].y)/2,(temp.V[6].z)/2};
				 glPushMatrix();
				 glTranslatef(centro[0],centro[1],centro[2]);
				 glColor3ub(0,0,255);
				 glutSolidCube(temp.lato);
				 glPopMatrix();
			}
	}
//se i sottocubi ci sono
else {
		for (int i=0;i<(int)temp.lista_sottocubi.size();i++){
				addraw(temp.lista_sottocubi[i]);
			}
	 }
}

///////////////////////////////////////////////////////////////////////////////
// Funzione disegno principale
///////////////////////////////////////////////////////////////////////////////
void draw()
{
	
	// clear buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	glPushMatrix();

	//spostamento del disegno
	glTranslatef(0, 0, -cameraDistance);
    glRotatef(cameraAngleX, 1, 0, 0);   // pitch
    glRotatef(cameraAngleY, 0, 1, 0);   // heading
	
	//lancio funzione di disegno vera e propria
	addraw(prova);
	
	//reset
	glPopMatrix();
	glutSwapBuffers();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione di reshape
///////////////////////////////////////////////////////////////////////////////
void reshape(int w, int h)
{
   screenWidth = w;
   screenHeight = h;
   toPerspective();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione di refresh temporizzato della finestra
///////////////////////////////////////////////////////////////////////////////

void timerCB(int millisec){
	glutTimerFunc(millisec, timerCB, millisec);
	glutPostRedisplay();
}

///////////////////////////////////////////////////////////////////////////////
// Funzione rilevamento movimenti del mouse
///////////////////////////////////////////////////////////////////////////////
void Motion(int x,int y)
{
	if(mouseLeftDown)
    {
        cameraAngleY += (x - mouseX);
        cameraAngleX += (y - mouseY);
        mouseX = x;
        mouseY = y;
    }
    if(mouseRightDown)
    {
        cameraDistance -= (y - mouseY) * 0.2f;
        mouseY = y;
    }
}

///////////////////////////////////////////////////////////////////////////////
// Funzione per rilevamento bottoni mouse
///////////////////////////////////////////////////////////////////////////////
void Mouse(int button, int state, int x, int y)
{
	mouseX = x;
    mouseY = y;

    if(button == GLUT_LEFT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseLeftDown = true;
        }
        else if(state == GLUT_UP)
            mouseLeftDown = false;
    }

    else if(button == GLUT_RIGHT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseRightDown = true;
        }
        else if(state == GLUT_UP)
            mouseRightDown = false;
    }

    else if(button == GLUT_MIDDLE_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseMiddleDown = true;
        }
        else if(state == GLUT_UP)
            mouseMiddleDown = false;
    }
}

///////////////////////////////////////////////////////////////////////////////
// Inizializzazione di GLUT
///////////////////////////////////////////////////////////////////////////////
void initGLUT(){
    //parametri fake per il lancio di InitGlut
	char *myargv[1];
	int myargc = 1;
	myargv[0]=strdup("MyOpenGL");
	
	//Inizializzazione Glut basso livello
	glutInit(&myargc,myargv);
	
	//Lancio funzioni di settaggio finestra,visualizzazione ed altro
	glutInitDisplayMode( GLUT_RGBA| GLUT_DOUBLE | GLUT_DEPTH |GLUT_STENCIL);	
	glutInitWindowSize(screenWidth, screenHeight);
    glutInitWindowPosition(850,100);
    glutCreateWindow("Ricostruzione attuale");
	
	    //callback delle funzioni richiamate
		glutDisplayFunc(draw);
		glutTimerFunc(33,timerCB,33);
		glutReshapeFunc(reshape);
		glutMouseFunc(Mouse);
		glutMotionFunc(Motion);

}

///////////////////////////////////////////////////////////////////////////////
//  Thread richiamato per lanciare OPENGL
///////////////////////////////////////////////////////////////////////////////

void DRAW3D (void *param){
		
	//abbassa priorità del thread a backgroud
	if(!SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN))
		{
			dwError = GetLastError();
			if (ERROR_THREAD_MODE_ALREADY_BACKGROUND == dwError)
			_tprintf(TEXT("Gia' in background\n"));
			else _tprintf(TEXT("Errore nell'entrare in modalita' background (%d)\n"), dwError);
	    }

	 	// Lancia funzione di inizializzazione variabili globali
        initSharedMem();
		
		//initiGLUT
		initGLUT();
		init();

		//ciclo OpenGL
		glutMainLoop();
		
		_endthread();
}

La funzione "DRAW3D" viene eseguita come thread, messa in background per non succhiare troppe risorse...ma anche non mettendo il thread in backgroud, sul fisso succede lo stesso.

Faccio presente che "prova" è un oggetto appartenente alla classe cubo, che altro non è che un vector di singoli oggetti cubo, caratterizzati dal "livello" e dal "lato"...è una struttura ad albero, dal cubo padre man mano sono stati aggiunti i cubi figli...andando ad aumentare a livello via via maggiore... A me serve rappresentare solo quello di livello massimo, quindi il resto non scelgo di rappresentarlo, lo vedete nella funzione di disegno ricorsiva "addraw". Mi serve ricorsiva perchè altrimenti non so come fare a prendere tutti i cubi di livello massimo nella lista, essendo ramificata sarebbe davvero un casino di if, else...il primo step sono 496000 cubi. Poi si riducono un pò...

La cosa stranissima per me è che sul portatile almeno si vede e si riesce ad interagirci, anche se a rilento. Sul fisso, no. Si blocca.

Ora, preso dalla rabbia ho provato diverse cose: a cambiare luci, togliere i colori...non serve a niente. Ultimo tentativo e stato quello di togliere la funzione ricorsiva, sostituendola con una che non faceva altro che prendere solo i cubi del primo livello: magicamente la finestra OpenGL sul fisso funzionava...zoom, rotazione, senza scatti di nessun tipo..ovviamente però erano visualizzati pochissimi cubi ed in pratica che non cambiano durante l'elaborazione...

Pertanto: come posso fare per risolvere questo mio problema? La lista dei cubi viene aggiornata ogni passaggio dal programma principale: pensavo che col timer di refresh potevo infischiarmene di mettere semafori o altro perchè in pratica, OpenGL deve solo rappresentare quello che c'è in lista, non modificarla...parlando però con un amico, mi ha detto: "il computer più potente esegue il loop OpenGL più alla svelta, e per questo s'impalla, invece sul portatile PARADOSSALMENTE non succede perchè è più lento..."

Al di la di potergli dare ragione o meno a tal proposito, resta il problema che non capisco come risolvere: sapete aiutarmi?

Come si fa ad ottenere un output OpenGL su una struttura dati del genere? E soprattutto magari vincolato ad aggiornarsi solo quando dico io (cioè ogni fine elaborazione dei threads del programma principale)??

Per favore qualcuno mi aiuti...

[DomusP45]

up

[AnonimoVeneziano]

Originariamente inviato da DomusP45

Salve a tutti.

Ho bisogno di rappresentare in una finestra OpenGL tridimensionale, una serie di cubi, di cui ho centro e dimensione memorizzati in una lista multilivello in C++...che man mano durante l'elaborazione aumentano, vengono cancellati o aggiunti, a questa lista, passaggio per passaggio dal programma principale, che si occupa dell'elaborazione. Vorrei quindi che la finestra di OpenGL mi fornisca un output aggiornato ogni volta che c'è un'elaborazione che ha modificato la lista, ma non so come fare.

Ho scritto questo codice che vi posto, dotato di un timer, che è uno stratagemma per aggiornare ogni tot la visualizzazione: mi andrebbe anche bene, ma si verifica una cosa veramente strana: sul mio portatile (che è vecchietto) con un Intel P6100 dual core ed una scheda video schifezza integrata IntelHD il codice in questione produce l'output corretto, aggiornando la visualizzazione della ricostruzione ogni tot millisecondi come da timer e permettendomi di ruotare, ingrandire la rappresentazione col mouse quando voglio. Unico problema è che scatta un pò nello zoom e va lento nella rotazione. Ma considerando la scheda video in questione, pensavo fosse normale sul portatile.

Ora, ho portato questo mio codice sul PC fisso principale, equipaggiato con un i7 2600 3.40Ghz, 8GB DDR3 e una scheda video Nvidia Quadro 4000, ma la finestra di output OpenGL magicamente fa schifo: bloccata, non è possibile nemmeno muoverla, non si aggiorna un bel niente e non visualizza quello che dovrebbe o lanciando il programma a volte si vede solo grigia con l'indicatore di attesa di windows 7 continuo...se apri e chiudi una finestra di windows da sopra, rimane la parte di finestra impressa nella finestra di OpenGL...il resto del programma (quello che si occupa dell'elaborazione della lista) viene eseguito normalmente...

Faccio presente che su entrambi i PC c'è win7 64bit professional e visual c++ 2010 correttamente configurati, e il progetto è stato comunque ricompilato sul PC fisso. Utilizzo freeglut 2.8.1 su entrambi, settato come dovrebbe.

Questo è il codice in questione:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                         PARTE DELLE FUNZIONI OPENGL PER LA RICOSTRUZIONE 3D    
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Premessa delle funzioni di posizionamento con mouse 
void mouseCB(int button, int stat, int x, int y);
void mouseMotionCB(int x, int y);

//funzioni di inizializzazione e pulizia
bool initSharedMem();
void clearSharedMem();
void initLights();
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ);
void toOrtho();
void toPerspective();

//variabili e costanti
const int   SCREEN_WIDTH    = 640;
const int   SCREEN_HEIGHT   = 480;
const float CAMERA_DISTANCE = 10.0f;

int screenWidth;
int screenHeight;
bool mouseLeftDown;
bool mouseRightDown;
bool mouseMiddleDown;
float mouseX, mouseY;
float cameraAngleX;
float cameraAngleY;
float cameraDistance;
int drawMode;

///////////////////////////////////////////////////////////////////////////////
// Funzione inizializzazione OpenGL standard
///////////////////////////////////////////////////////////////////////////////
void init()
{
	glShadeModel(GL_SMOOTH);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
	glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING); 
	glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glEnable(GL_COLOR_MATERIAL);
	initLights();
}

///////////////////////////////////////////////////////////////////////////////
// Funzione di inizializzazione globale delle variabili
///////////////////////////////////////////////////////////////////////////////
bool initSharedMem()
{
    screenWidth = SCREEN_WIDTH;
    screenHeight = SCREEN_HEIGHT;

    mouseLeftDown = mouseRightDown = mouseMiddleDown = false;
    mouseX = mouseY = 0;

    cameraAngleX = cameraAngleY = 0.0f;
    //cameraDistance = CAMERA_DISTANCE;
	cameraDistance = 0.3f;
    drawMode = 0; // 0:pieno, 1: solo contorni, 2:punti

    return true;
}

///////////////////////////////////////////////////////////////////////////////
// Funzione di pulitura variabili globali
///////////////////////////////////////////////////////////////////////////////
void clearSharedMem()
{
}

///////////////////////////////////////////////////////////////////////////////
// Inizializzazione Luci
///////////////////////////////////////////////////////////////////////////////
void initLights()
{
    GLfloat lightKa[] = {.2f, .2f, .2f, 1.0f};  // luce ambientale
    GLfloat lightKd[] = {.7f, .7f, .7f, 1.0f};  // luce diffusa
    GLfloat lightKs[] = {1, 1, 1, 1};           // luce speculare
   
	glLightfv(GL_LIGHT0, GL_AMBIENT, lightKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightKs);

    // posizione delle luci
    float lightPos[4] = {0, 0, 20, 1}; 
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

	//Attiva tutti i settaggi delle luci
    glEnable(GL_LIGHT0);                        }

///////////////////////////////////////////////////////////////////////////////
//  Posizione della telecamera e direzioni
///////////////////////////////////////////////////////////////////////////////
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX, posY, posZ, targetX, targetY, targetZ, 0, 1, 0); // eye(x,y,z), focal(x,y,z), up(x,y,z)
}

///////////////////////////////////////////////////////////////////////////////
// Impostazione proiezione ortogonale
///////////////////////////////////////////////////////////////////////////////
void toOrtho()
{
    // Imposta il viewport di tutta la finestra
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);

    // Imposta il frustum di visione
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, screenWidth, 0, screenHeight, -1, 1);

    // passaggio a modelview per interattività
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}



///////////////////////////////////////////////////////////////////////////////
// Impostazione come perspective
///////////////////////////////////////////////////////////////////////////////
void toPerspective()
{
    // Imposta il viewport di tutta la finestra
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);

    //frustum perspective
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    
	//gluPerspective(60.0f, (float)(screenWidth)/screenHeight, 1.0f, 1000.0f);
	
	gluPerspective(60.0f, (float)(screenWidth)/screenHeight, 10.0f, 0.0f); // FOV, AspectRatio, NearClip, FarClip
    
	// switch to modelview matrix in order to set scene
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione ricorsiva di disegno
///////////////////////////////////////////////////////////////////////////////
void addraw(cubo temp)
{
	//se non ci sono sottocubi
	if (temp.lista_sottocubi.size() == 0)
	{		
			if (temp.livello == LMAXI) {
				 double centro[3]={(temp.V[6].x)/2, (temp.V[6].y)/2,(temp.V[6].z)/2};
				 glPushMatrix();
				 glTranslatef(centro[0],centro[1],centro[2]);
				 glColor3ub(0,0,255);
				 glutSolidCube(temp.lato);
				 glPopMatrix();
			}
	}
//se i sottocubi ci sono
else {
		for (int i=0;i<(int)temp.lista_sottocubi.size();i++){
				addraw(temp.lista_sottocubi[i]);
			}
	 }
}

///////////////////////////////////////////////////////////////////////////////
// Funzione disegno principale
///////////////////////////////////////////////////////////////////////////////
void draw()
{
	
	// clear buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	glPushMatrix();

	//spostamento del disegno
	glTranslatef(0, 0, -cameraDistance);
    glRotatef(cameraAngleX, 1, 0, 0);   // pitch
    glRotatef(cameraAngleY, 0, 1, 0);   // heading
	
	//lancio funzione di disegno vera e propria
	addraw(prova);
	
	//reset
	glPopMatrix();
	glutSwapBuffers();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione di reshape
///////////////////////////////////////////////////////////////////////////////
void reshape(int w, int h)
{
   screenWidth = w;
   screenHeight = h;
   toPerspective();
}

///////////////////////////////////////////////////////////////////////////////
//  Funzione di refresh temporizzato della finestra
///////////////////////////////////////////////////////////////////////////////

void timerCB(int millisec){
	glutTimerFunc(millisec, timerCB, millisec);
	glutPostRedisplay();
}

///////////////////////////////////////////////////////////////////////////////
// Funzione rilevamento movimenti del mouse
///////////////////////////////////////////////////////////////////////////////
void Motion(int x,int y)
{
	if(mouseLeftDown)
    {
        cameraAngleY += (x - mouseX);
        cameraAngleX += (y - mouseY);
        mouseX = x;
        mouseY = y;
    }
    if(mouseRightDown)
    {
        cameraDistance -= (y - mouseY) * 0.2f;
        mouseY = y;
    }
}

///////////////////////////////////////////////////////////////////////////////
// Funzione per rilevamento bottoni mouse
///////////////////////////////////////////////////////////////////////////////
void Mouse(int button, int state, int x, int y)
{
	mouseX = x;
    mouseY = y;

    if(button == GLUT_LEFT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseLeftDown = true;
        }
        else if(state == GLUT_UP)
            mouseLeftDown = false;
    }

    else if(button == GLUT_RIGHT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseRightDown = true;
        }
        else if(state == GLUT_UP)
            mouseRightDown = false;
    }

    else if(button == GLUT_MIDDLE_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseMiddleDown = true;
        }
        else if(state == GLUT_UP)
            mouseMiddleDown = false;
    }
}

///////////////////////////////////////////////////////////////////////////////
// Inizializzazione di GLUT
///////////////////////////////////////////////////////////////////////////////
void initGLUT(){
    //parametri fake per il lancio di InitGlut
	char *myargv[1];
	int myargc = 1;
	myargv[0]=strdup("MyOpenGL");
	
	//Inizializzazione Glut basso livello
	glutInit(&myargc,myargv);
	
	//Lancio funzioni di settaggio finestra,visualizzazione ed altro
	glutInitDisplayMode( GLUT_RGBA| GLUT_DOUBLE | GLUT_DEPTH |GLUT_STENCIL);	
	glutInitWindowSize(screenWidth, screenHeight);
    glutInitWindowPosition(850,100);
    glutCreateWindow("Ricostruzione attuale");
	
	    //callback delle funzioni richiamate
		glutDisplayFunc(draw);
		glutTimerFunc(33,timerCB,33);
		glutReshapeFunc(reshape);
		glutMouseFunc(Mouse);
		glutMotionFunc(Motion);

}

///////////////////////////////////////////////////////////////////////////////
//  Thread richiamato per lanciare OPENGL
///////////////////////////////////////////////////////////////////////////////

void DRAW3D (void *param){
		
	//abbassa priorità del thread a backgroud
	if(!SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN))
		{
			dwError = GetLastError();
			if (ERROR_THREAD_MODE_ALREADY_BACKGROUND == dwError)
			_tprintf(TEXT("Gia' in background\n"));
			else _tprintf(TEXT("Errore nell'entrare in modalita' background (%d)\n"), dwError);
	    }

	 	// Lancia funzione di inizializzazione variabili globali
        initSharedMem();
		
		//initiGLUT
		initGLUT();
		init();

		//ciclo OpenGL
		glutMainLoop();
		
		_endthread();
}

La funzione "DRAW3D" viene eseguita come thread, messa in background per non succhiare troppe risorse...ma anche non mettendo il thread in backgroud, sul fisso succede lo stesso.

Faccio presente che "prova" è un oggetto appartenente alla classe cubo, che altro non è che un vector di singoli oggetti cubo, caratterizzati dal "livello" e dal "lato"...è una struttura ad albero, dal cubo padre man mano sono stati aggiunti i cubi figli...andando ad aumentare a livello via via maggiore... A me serve rappresentare solo quello di livello massimo, quindi il resto non scelgo di rappresentarlo, lo vedete nella funzione di disegno ricorsiva "addraw". Mi serve ricorsiva perchè altrimenti non so come fare a prendere tutti i cubi di livello massimo nella lista, essendo ramificata sarebbe davvero un casino di if, else...il primo step sono 496000 cubi. Poi si riducono un pò...

La cosa stranissima per me è che sul portatile almeno si vede e si riesce ad interagirci, anche se a rilento. Sul fisso, no. Si blocca.

Ora, preso dalla rabbia ho provato diverse cose: a cambiare luci, togliere i colori...non serve a niente. Ultimo tentativo e stato quello di togliere la funzione ricorsiva, sostituendola con una che non faceva altro che prendere solo i cubi del primo livello: magicamente la finestra OpenGL sul fisso funzionava...zoom, rotazione, senza scatti di nessun tipo..ovviamente però erano visualizzati pochissimi cubi ed in pratica che non cambiano durante l'elaborazione...

Pertanto: come posso fare per risolvere questo mio problema? La lista dei cubi viene aggiornata ogni passaggio dal programma principale: pensavo che col timer di refresh potevo infischiarmene di mettere semafori o altro perchè in pratica, OpenGL deve solo rappresentare quello che c'è in lista, non modificarla...parlando però con un amico, mi ha detto: "il computer più potente esegue il loop OpenGL più alla svelta, e per questo s'impalla, invece sul portatile PARADOSSALMENTE non succede perchè è più lento..."

Al di la di potergli dare ragione o meno a tal proposito, resta il problema che non capisco come risolvere: sapete aiutarmi?

Come si fa ad ottenere un output OpenGL su una struttura dati del genere? E soprattutto magari vincolato ad aggiornarsi solo quando dico io (cioè ogni fine elaborazione dei threads del programma principale)??

Per favore qualcuno mi aiuti...

Prima di tutto metti il thread OpenGL come main thread, e non come thread secondario.

E' noto che ci sono problemi possibili di ogni genere a fare il contrario, quindi come prima cosa fai questo e vedi se ti funziona.

Per il resto dei tuoi problemi non ho letto il codice ancora , ma se dopo ho tempo e riesco a darti qualche consiglio te li posto qui

Cya

[DomusP45]

Originariamente inviato da AnonimoVeneziano

Prima di tutto metti il thread OpenGL come main thread, e non come thread secondario.

E' noto che ci sono problemi possibili di ogni genere a fare il contrario, quindi come prima cosa fai questo e vedi se ti funziona.

Per il resto dei tuoi problemi non ho letto il codice ancora , ma se dopo ho tempo e riesco a darti qualche consiglio te li posto qui

Cya

Aspetto allora un tuo parere..sono veramente disperato..il codice è corretto...gira sul mio portatile anche se a scatti (potrebbe essere migliorato?) ma perchè non funzioni sul PC fisso proprio non lo so...

[DomusP45]

up...nessuno sa aiutarmi?

Nonostante abbia passato il codice OpenGL nel main, è la stessa cosa...

[DomusP45]

up

[DomusP45]

up....non riesco a capire come fare a non utilizzare la funzione ricorsiva in questa situazione...

[DomusP45]

up...

Se avvio l'applicazione da visual C++ (col tasto verde play) funziona...se la lancio da fuori (l'eseguibile .exe) la finestra di opengl "non risponde"

Come mai si verifica una cosa del genere?

[DomusP45]

up

[DomusP45]

up