在＆＃34;开始调试＆＃34;模式应用程序工作正常，如果启动exe文件OpenGL窗口冻结

Question

我创建了一个项目，使用OpenGL在窗口中表示向量中包含的一系列立方体。

在我的笔记本上Fujitsu Lifebook A530，win 7 64bit，4GB RAM，intel P6100双核和visual c ++ 2010年，该项目编译正确，如果我启动exe文件，运行良好（我可以与OpenGL表示，旋转，缩放等等...）慢，但工作。这是由于集成显卡，英特尔高清，如此便宜和低性能卡。

但是，我有一台台式电脑，intel i7 2600 3.40Ghz，8GB DDR3和Nvidia Quadro 4000卡，这个项目编译正确，但是如果我启动exe文件，OpenGL windows会被阻止，＆＃34;没有回应＆＃34; ...

如果我从visual C ++ 2010开始按钮（绿色播放按钮）启动项目，它将在＆＃34;启动调试＆＃34;和项目运行良好，没有OpenGL的问题（我可以旋转，缩放等）.OpenGL窗口不会阻止自己或其他。

为什么呢？ Visual C ++ 2010的环境设置在台式PC和笔记本电脑，同样的Windows 7 64bit专业版，同一个库（freeglut）中都是一样的......

为什么当从他的exe文件启动应用程序时，OpenGL窗口被阻止，冻结......

这是OpenGL应用程序部分的代码：

struct Cpoint
{
    double x;
    double y;
    double z;
    double l;
};

//vettore per disegno
vector<Cpoint> Clist;

//loca è la struct per i punti
Cpoint loca;

/*          PARTE DELLE FUNZIONI THREAD         */

void PrepareVect(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};
             loca.x = centro[0];
             loca.y = centro[1];
             loca.z = centro[2];
             loca.l = temp->lato;
             Clist.push_back(loca);
        }
}
//se i sottocubi ci sono
else {
    for (int i=0;i<(int)temp->lista_sottocubi.size();i++){
            PrepareVect(&temp->lista_sottocubi[i]);
        }
 }
}

void cubelist(){


Clist.clear();
PrepareVect(&prova);
}

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 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
for(int i=0;i<(int)Clist.size();i++){
             glPushMatrix();
             glTranslatef(Clist[i].x,Clist[i].y,Clist[i].z);
             glColor3ub(0,0,255);
             glutSolidCube(Clist[i].l);
             glPopMatrix();  
             }
//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(50,timerCB,50);
    glutReshapeFunc(reshape);
    glutMouseFunc(Mouse);
    glutMotionFunc(Motion);

}

int main(int argc, char **argv)
{
   ....
// Lancia funzione di inizializzazione variabili globali
    initSharedMem();

    //initiGLUT
    initGLUT();
    init();

    //ciclo OpenGL
    glutMainLoop();
....
return 0;
}