DomusP45
14-04-2014, 16:33
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...
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...