GL/GLX est ne pas lier correctement

Question

Caractéristiques techniques du système et la tâche

J'utilise Code :: Blocks sur Ubuntu 10.10 et jouer avec OpenGL et GLX. Je suis en train d'apprendre le C++ (à partir d'un arrière-plan en C et en Java), donc le code de tout code ne correspond pas à de bonnes normes (mais je suis ouvert aux suggestions pour améliorer, même si vous ne pas répondre à la question)

Edit:

Réalisation énorme: la valeur par défaut OpenGL code du projet :: Blocks crée est C, pas C++. Je regarde dans ceci maintenant.

J'essaye actuellement de modifier le projet OpenGL par défaut sur Code :: Blocks dans un moteur 3d simple. Je reçois actuellement l'erreur:

expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before 'Draw'

qui disparaît dès que je commente le #include pour < GL/glx.h>

J'ai lu sur un forum quelque part que Code :: Blocks n » t regardez dans usr/include/par défaut, mais j'ai ajouté cela aux répertoires de recherche du compilateur dans les options de construction du projet et il ne semblait pas y avoir de solution.

code:

main.cpp: main.c:

#include <time.h> 
#include "Draw.h" 

#include <stdio.h> 
#include <stdlib.h> 

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

/*draw init here*/ 

Draw::Draw renderer = Draw::Draw.getDraw(); 

printf("Press left mouse button to rotate around X axis\n"); 
printf("Press middle mouse button to rotate around Y axis\n"); 
printf("Press right mouse button to rotate around Z axis\n"); 
printf("Press ESC to quit the application\n"); 

/* timing variable*/ 
/* Set it to delay half a second before rendering the first frame*/ 
clock_t flip_time = clock() + 0.5f * CLOCKS_PER_SEC; 

while (1) 
{ 


    /* Update models */ 


    /* Draw scene */ 

    /* wait until it's been 1/60th of a second*/ 
    while(clock() < flip_time){} 

    flip_time = clock() + (1.0f/60.0f) * CLOCKS_PER_SEC; 
    /* Actually flip the frame */ 

} 
} 

Draw.h:

#ifndef DRAW_H 
#define DRAW_H 

#include <GL/glx.h> /* This is the problem line */ 
#include <GL/gl.h> 

#include <X11/X.h> /* X11 constant (e.g. TrueColor) */ 
#include <X11/keysym.h> 

class Draw 
{ 
public: 
    static Draw getDraw(); 
    virtual ~Draw(); 
    void update(); 
    void render(); 

protected: 
private: 
    Draw(); 
    bool init(); 

    /* The singleton*/ 
    static Draw *instance; 
    static bool exists; 

    /* X Window values */ 
    Display    *dpy; 
    Window    win; 
    GLboolean   doubleBuffer; 

    /* X Parameters*/ 
    XVisualInfo   *vi; 
    Colormap    cmap; 
    XSetWindowAttributes swa; 
    GLXContext   cx; 
    XEvent    event; 
    int     dummy; 

}; 

#endif // DRAW_H 

dernier, mais pas moins Draw.cpp:

#include "Draw.h" 

/* Set up the singleton*/ 
bool Draw::exists = false; 
Draw* Draw::instance = NULL; 

Draw::Draw() 
{ 
/*TODO: make this constructor */ 
} 

Draw::~Draw() 
{ 
//dtor 
} 

Draw Draw::getDraw() 
{ 
if(!exists) 
{ 
    instance = new Draw(); 
    instance->init(); 
    exists = true; //Thanks mat, This line was accidentally removed with extraneous comments 
} 

return *instance; 
} 

bool Draw::init() 
{ 
/* Get the buffers ready */ 
static int snglBuf[] = {GLX_RGBA, GLX_DEPTH_SIZE, 16, None}; 
static int dblBuf[] = {GLX_RGBA, GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None}; 

/* Double Buffered is best*/ 
doubleBuffer = GL_TRUE; 

/*TODO: add constructor if it hasn't been constructed already*/ 

dpy = XOpenDisplay(NULL); 
if (dpy == NULL) 
{ 
    return false; 
} 

/* make sure OpenGL's GLX extension supported */ 
if(!glXQueryExtension(dpy, &dummy, &dummy)) 
{ 
    return false; 
} 

/* find an appropriate visual */ 
/* find an OpenGL-capable RGB visual with depth buffer */ 
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf); 

if (vi == NULL) 
{ 
    vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf); 
    if (vi == NULL) 
    { 
     return false; 
    } 

    doubleBuffer = GL_FALSE; 
} 


/* 
TODO: Fix or remove this 
if(vi->class != TrueColor) 
{ 
    return false; 
} 
*/ 
/* create an OpenGL rendering context */ 

/* create an OpenGL rendering context */ 
cx = glXCreateContext(dpy, vi, /* no shared dlists */ None, 
        /* direct rendering if possible */ GL_TRUE); 
if (cx == NULL) 
{ 
    return false; 
} 

/* create an X window with the selected visual */ 

/* create an X colormap since probably not using default visual */ 
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone); 
swa.colormap = cmap; 
swa.border_pixel = 0; 
swa.event_mask = KeyPressMask | ExposureMask 
      | ButtonPressMask | StructureNotifyMask; 
win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 
        300, 300, 0, vi->depth, InputOutput, vi->visual, 
        CWBorderPixel | CWColormap | CWEventMask, &swa); 
XSetStandardProperties(dpy, win, "main", "main", None, 
        NULL, NULL, NULL); 

/* bind the rendering context to the window */ 
glXMakeCurrent(dpy, win, cx); 

/* request the X window to be displayed on the screen */ 
XMapWindow(dpy, win); 

/* configure the OpenGL context for rendering */ 
glEnable(GL_DEPTH_TEST); /* enable depth buffering */ 
glDepthFunc(GL_LESS); /* pedantic, GL_LESS is the default */ 
glClearDepth(1.0);  /* pedantic, 1.0 is the default */ 

/* frame buffer clears should be to black */ 
glClearColor(0.0, 0.0, 0.0, 0.0); 

/* set up projection transform */ 
glMatrixMode(GL_PROJECTION); 
glLoadIdentity(); 
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 10.0); 
/* establish initial viewport */ 

/* pedantic, full window size is default viewport */ 
glViewport(0, 0, 300, 300); 

return true; 
} 

void Draw::update() 
{ 
/*TODO: Add things to draw here*/ 
} 

void Draw::render() 
{ 
    /* actually flip buffers here */ 
} 

J'ai enlevé une tonne de commentaires avant de poster ceci ici, mais cela ne devrait pas affecter si oui ou non il compile.

Merci!

Answer 1

J'ai trouvé le problème avec la liaison.

Le projet par défaut pour OpenGL dans Code :: Blocks est PAS C++, c'est C. Je l'ai configuré pour utiliser g ++ et il a corrigé le problème avec glx ne pas lier correctement. J'ai révisé mon singleton pour regarder un peu plus comme this et cela fonctionne correctement maintenant aussi. J'ai un problème maintenant avec la fenêtre n'apparaissant pas, mais je devrais être en mesure de comprendre cela.

Merci!

Answer 2

Cette ligne dans votre fichier principal est erroné:

Draw::Draw renderer = Draw::Draw.getDraw(); 

Draw::Draw est pas un type. Pour obtenir ceci à compiler, vous avez juste besoin de:

Draw renderer = Draw.getDraw(); 

On dirait que vous essayez de construire un singleton. Votre code ne le fait pas du tout, vous recevrez une copie à chaque fois. (Notez que vous ne définissez pas exists n'importe où, mais c'est juste un bug supplémentaire.) Vous devriez retourner un pointeur ou une référence à l'instance partagée. Voir par exemple cet article pour obtenir la syntaxe correcte: C++ Singleton design pattern.