C++ – OPENgl – GL/glut.h no such file or directory

copengl

can any one help me with the following error

GL/glut.h no such file or directory

The things I did are

After installation of MinGW i have added the Path to the path
enviornment variable
Added 'glut.h' to C:\MinGW\Include\GL
Added glut32.dll to C:\Windows\SysWOW64
Added glut32.lib to the project folder
COmpiled with 'g++ -o hello.exe -Wall hello.c glee.lib glut32.lib -lopengl32 -lglu32'

and still the error above persist please help

#include<GL/glut.h>
#include<iostream>
//#include<conio.h>

void render(void);

void keyboard(unsigned char c, int x, int y);

void mouse(int button, int state, int x, int y);

int main(int argc, char** atgv)
{
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(640, 480);
glutCreateWindow("Sample GLUT Application");

glutDisplayFunc(render);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);

glutMainLoop();
}

void keyboard(unsigned char c, int x, int y)
{
if(c == 27){
    exit(0);
    }
}

void mouse(int button, int state, int x, int y)
{
if(button == GLUT_RIGHT_BUTTON )
{
    exit(0);
}
}

void render(void)
{   
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

glBegin(GL_TRIANGLES);
    glColor3f(1, 0, 0);
    glVertex2f(-0.5, -0.5);
    glColor3f(0, 1, 0);
    glVertex2f(0.5, -0.5);  
    glColor3f(0, 0, 1);
    glVertex2f(0.0, 0.5);
glEnd();

glutSwapBuffers();
}

Best Answer

some simple things that can cause problems in my experience (so make sure they are set!:) :

check to see if C:\MinGW\bin is in your path variable if not, add C:\MinGW\bin to your PATH (type %path% in a console window to ensure the path property is applied to the window console session you are using)
put glut32.dll into C:\windows\system32 so it can be located at runtime, or place it in the same directory as the executable you wish to run
Just checked and my minGW has glut32.dll in c:\mingw\bin
and libglut32.a in c:\mingw\lib
and glut.h should be in c:\mingw\include\GL

Apologies for the previous omission.

That should see you alright provided there are no other issues at play.

Let me know if you need more info/help :)

Addendum:

I located this link which whilst old may be of use to you in making the files available to mingw's environment.

Related Solutions

How to render primitives as wireframes in OpenGL

glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );

to switch on,

glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

to go back to normal.

Note that things like texture-mapping and lighting will still be applied to the wireframe lines if they're enabled, which can look weird.

C++ – Why can templates only be implemented in the header file

Caveat: It is not necessary to put the implementation in the header file, see the alternative solution at the end of this answer.

Anyway, the reason your code is failing is that, when instantiating a template, the compiler creates a new class with the given template argument. For example:

template<typename T>
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo<int> f;

When reading this line, the compiler will create a new class (let's call it FooInt), which is equivalent to the following:

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
}

Consequently, the compiler needs to have access to the implementation of the methods, to instantiate them with the template argument (in this case int). If these implementations were not in the header, they wouldn't be accessible, and therefore the compiler wouldn't be able to instantiate the template.

A common solution to this is to write the template declaration in a header file, then implement the class in an implementation file (for example .tpp), and include this implementation file at the end of the header.

Foo.h

template <typename T>
struct Foo
{
    void doSomething(T param);
};

#include "Foo.tpp"

Foo.tpp

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

This way, implementation is still separated from declaration, but is accessible to the compiler.

Alternative solution

Another solution is to keep the implementation separated, and explicitly instantiate all the template instances you'll need:

Foo.h

// no implementation
template <typename T> struct Foo { ... };

Foo.cpp

// implementation of Foo's methods

// explicit instantiations
template class Foo<int>;
template class Foo<float>;
// You will only be able to use Foo with int or float

If my explanation isn't clear enough, you can have a look at the C++ Super-FAQ on this subject.

Best Answer

Related Solutions

How to render primitives as wireframes in OpenGL

C++ – Why can templates only be implemented in the header file

Alternative solution

Related Topic