OpenGL Discussion and Help Forums - OpenGL under Windows

GLUI Question

corinard — Mon, 20 May 2013 12:28:04 GMT

Hello,

I am rather new to OpenGL, GLUT and GLUI. I have a question regarding GLUI, and until now I did not find an answer for it.
I am using GLUT for rendering cloth items. One of the things that I want to do is, of course, create these cloth items, and for that I need to be able to specify a texture for them. I decided to do this by having a drop-down list with a predefined list of textures, that the user can choose from. The question is the following:
Can I, using GLUI, display an image in the GLUI menu? I want, under the drop-down list with the textures, to have a small image which is refreshed each time the user selects a new item in the drop-down list. If this is not possible, then I was thinking to have the image displayed separately, in a new window, each time the user selects an item from drop-down list. But I don''t know if this is possible either, or how to do it. Any help is greatly appreciated.

Thank you,
Corina

A problem in import 3ds file

lichang12120 — Mon, 20 May 2013 11:35:22 GMT

I am now working on import a 3ds model in my application, but I have a problem. I import the model and show it, but the model have no edge. It just a lump of color. What happened?
Here is my part code.

Code :

BOOL CMyOpenGLView::InitializeOpenGL(CDC *pDC) 
{
 m_pDC=pDC;
 
SetupPixelFormat();  
 
m_hRC=::wglCreateContext(m_pDC->GetSafeHdc()); 
 
::wglMakeCurrent(m_pDC->GetSafeHdc(),m_hRC); 
 
::glShadeModel(GL_FLAT);
 
 ::glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
 
 ::glClearDepth(1.0F);
 
::glEnable(GL_DEPTH_TEST);
 
::glEnable(GL_CULL_FACE);
 
::glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); 
 
GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f};
 GLfloat diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f};
 GLfloat lightPos[]     = {6000.0f,6000.0f,6000.0f, 1.0f};
 
 glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
 glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
 glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);
 
 glEnable(GL_COLOR_MATERIAL);
 glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
 glEnable(GL_LIGHTING);
 glEnable(GL_LIGHT0);
 
 CMyOpenGLApp * app = (CMyOpenGLApp *)AfxGetApp();
 glNewList(app->m_dizuolist,GL_COMPILE); 
BOOL result;
 C3dsReader loader;
 result = loader.Reader("DIZUO.3DS",&m_TriList);    //read the file and save in m_TriList
if (result)
 {
 m_TriList.drawGL();    
m_TriList.doAfterMath(); 
}
glEndList();
 
 
  base_list = app->m_dizuolist; 
return TRUE;
 }
 
 
void CMyOpenGLView::RenderScence() 
{
   static BOOL bBusy = FALSE;   
        if (bBusy) return;
   bBusy=TRUE;
 
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 
glTranslatef(m_SceneTransX,m_SceneTransY,m_SceneTransZ);
 
 glRotatef(m_SceneRotX,1.0,0.0,0.0);
 glRotatef(m_SceneRotY,0.0,1.0,0.0);
 glRotatef(m_SceneRotZ,0.0,0.0,1.0);
 glRotatef(-90.0f,1.0f,0.0f,0.0f); 
glRotatef(-90.0f,0.0f,0.0f,1.0f);
 
glScalef(m_SceneScale,m_SceneScale,m_SceneScale);
 
 glDisable(GL_LIGHTING);
 glPushMatrix();
 glBegin(GL_LINES);
 glColor3f(1.0,0.0,0.0);
 glVertex3f(-200.0,0.0,0.0);
 glVertex3f( 200.0,0.0,0.0);
 
 glColor3f(0.0,1.0,0.0);
 glVertex3f(0.0,-200.0,0.0);
 glVertex3f(0.0, 200.0,0.0);
 
 glColor3f(0.0,0.0,1.0);
 glVertex3f(0.0,0.0,-200.0);
 glVertex3f(0.0,0.0, 200.0);
 glEnd();
 
 glPushMatrix(); 
glColor3f(1.0f,0.0f,0.0f);
 glTranslatef(150.0f,0.0f,0.0f);
 glRotatef(90.0f,0.0f,1.0f,0.0f);
 glutSolidCone(10.0,50.0,50,50);
 glPopMatrix();
 
glPushMatrix();
 glColor3f(0.0f,1.0f,0.0f);
 glTranslatef(0.0f,150.0f,0.0f);
 glRotatef(-90.0f,1.0f,.0.f,0.0f);
 glutSolidCone(10.0,50.0,50,50);
 glPopMatrix();
 
glPushMatrix();
 glColor3f(0.0f,0.0f,1.0f);
 glTranslatef(0.0f,0.0f,150.0f);
 glutSolidCone(10.0,50.0,50,50);
 glPopMatrix();
 
glPopMatrix();
 glEnable(GL_LIGHTING);
 
glDisable(GL_LIGHTING);
 glPushMatrix();
 
 glColor3f(0.0f,0.0f,0.0f);  
 wglUseFontBitmaps(wglGetCurrentDC(),0,255,base);
 glListBase(base);
 
 glRasterPos3f(210.0f,-0.5f,0.0f);
 glCallLists(2,GL_UNSIGNED_BYTE,_T("+x"));
 
 glRasterPos3f(-0.5,210.0f,0.0f);
 glCallLists(2,GL_UNSIGNED_BYTE,_T("+y")); 
 
 glRasterPos3f(-0.5,0.0f,210.0f);
 glCallLists(2,GL_UNSIGNED_BYTE,_T("+z"));
 
 glPopMatrix();
 glEnable(GL_LIGHTING);
 
glDisable(GL_LIGHTING);
 glDisable(GL_LIGHT0);
 glPushMatrix();
 
glRotatef(180.0f,1.0f,0.0f,0.0f);
 glRotatef(180.0f,0.0f,1.0f,0.0f);
 glRotatef(180.0f,0.0f,0.0f,1.0f);
 glCallList(base_list);
 glPopMatrix();
 glEnable(GL_LIGHTING);
 glEnable(GL_LIGHT0);
   ::SwapBuffers(m_pDC->GetSafeHdc()); 
   bBusy = FALSE;
 
 return;
 }

delay instruction

marahalsaidan — Fri, 10 May 2013 16:50:54 GMT

hello
I want from y
to gave me delay instruction in opengl
ex i want to draw sphere in first time then in second time i will draw cube etc.

how can i make this?

perso3D_chung free easy openGL 3D character model animation and edit

nguyenc — Tue, 07 May 2013 10:40:40 GMT

i have written an open source application in freebasic to load and edit custom 3D animated character models directly into openGL1.2 if you are interested .

you can find it there => chungswebsite.blogspot.fr/search/label/perso3D_chung

Consult the OpenGL display character problem

sontu2013 — Tue, 07 May 2013 06:53:31 GMT

Using OpenGL programming, medical image processing, on image above labeled "R", "L", "fracture", referred to as the character. Now the problem:
The program can run on all computers, but in some computers can output the character, and some computer can't output the character. I do not know why?

GLUT problem I think

Squishy — Fri, 03 May 2013 14:23:43 GMT

Hey guys :) hope you're all having a great day

so my issue with my code is kinda driving me mad, its one of those things Ive stared at enough trying to find the issue and so I just cant see it. Honestly, Im not sure what could be causing the problem, I can tell you however that it is most likely to do with GLUT if anyone here knows enough to be able to help me. originally my program drew a blank window but then wouldnt do much else so I commented out glutMainLoop() and then the window didnt even draw

Here is some code anyway, starting with a simple main that will let you compile it if you do help:

Code :

int main(int argc, char** argv){
    window = new GlutWindow(argc, argv, "EcoSphere", 800, 600);
 
 
    GameLoop::get()->init(window);
    GameLoop::get()->run();
 
 
    delete window;
 
 
    return 0;
};

GlutWindow:

Code :

#ifndef GLUTWINDOW_H#define GLUTWINDOW_H
 
 
#include "glut.h"
#include "Window.h"
#include "GameLoop.h"
 
 
void draw(void);
void resize(int, int);
void kybdPressed(unsigned char, int, int);
void kybdReleased(unsigned char, int, int);
 
 
class GlutWindow : public Window
{
private:
    int window;
    static Input* input;
 
 
public:
    GlutWindow(int argc, char** argv, char* title, int w, int h)
    {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
        glutInitWindowSize(w, h);
        glutInitWindowPosition(w/10, h/10);
        window = glutCreateWindow(title);
 
 
        glutDisplayFunc(draw);
        glutReshapeFunc(resize);
        glutKeyboardFunc(kybdPressed);
        glutKeyboardUpFunc(kybdReleased);
 
 
        //glutMainLoop();
    }
 
 
    static void draw()
    {
        glClearColor(0.0, 0.0, 0.0, 1.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 
        glutSolidTeapot(3.0);
 
 
        glFlush(); // Complete Pending Operations
        glutSwapBuffers(); //Switch Buffer (Double Buffering)
    }
 
 
    static void resize(int w, int h)
    {
        glViewport(0, 0, (GLsizei)w, (GLsizei)h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45, (GLfloat)w / (GLfloat)h, 1.0, 100.0);
        glMatrixMode(GL_MODELVIEW);
    }
 
 
    static void kybdPressed(unsigned char key, int x, int y)
    {
        input->keyPressed(key);
    }
 
 
    static void kybdReleased(unsigned char key, int x, int y)
    {
        input->keyReleased(key);
    }
 
 
    void redraw()
    {
        glutPostRedisplay();
    }
 
 
    virtual ~GlutWindow(){}
};
 
 
Entities* GlutWindow::entities = nullptr;
Input* GlutWindow::input = nullptr;
 
 
#endif

GameLoop:

Code :

#ifndef GAMELOOP_H#define GAMELOOP_H
 
 
#include "Input.h"
#include "Window.h"
 
 
class GameLoop
{
private:
    static GameLoop* instance;
    GameLoop(){}
 
 
    Controls* controls;
 
 
    Window* window;
 
 
    static bool running;
 
 
public:
    static GameLoop* get()
    {
        if(instance == nullptr)
        {
            instance = new GameLoop();
        }
        return instance;
    }
 
 
    void init(Window* w)
    {
        window = w;
    }
 
 
    void run()
    {
        bool running = true;
 
 
        while(running)
        {
            bool* keys = Input::get()->getKybdState();
 
                        //use keyboard input and update all entities
 
 
            window->redraw();
        }
    }
 
 
    static void end()
    {
        running = false;
    }
};
 
 
GameLoop* GameLoop::instance = nullptr;
bool GameLoop::running = true;
 
 
#endif

finally the input class:

Code :

#ifndef INPUT_H#define INPUT_H
 
 
class Input
{
private:
    static Input* instance;
    Input(){}
 
 
    static bool * kybdState;
 
 
public:
    static Input* get()
    {
        if(instance == nullptr)
        {
            for(int i = 0; i < 256; i++)
            {
                kybdState[i] = false;
            }
 
 
            instance = new Input();
        }
        return instance;
    }
 
 
    static bool* getKybdState()
    {
        return kybdState;
    }
 
 
    static void keyPressed(unsigned char key)
    {
        kybdState[key] = true;
    }
 
 
    static void keyReleased(unsigned char key)
    {
        kybdState[key] = false;
    }
 
 
    virtual ~Input()
    {
        delete kybdState;
    }
};
 
 
Input* Input::instance = nullptr;
bool * Input::kybdState = new bool[256];
 
 
#endif

Really sorry for the mass of code, there are some things edited out because they would make compiling hard but it should work as is here, if someone is to help me and feel they need any other information, please say and I will get it right away, also, thank you for your time if you read down this far :P

The best way to draw a 2D image directly on a hooked window

alvinhochun — Thu, 02 May 2013 02:37:41 GMT

What is the best way to draw a 2D image directly on a window which I hooked the SwapBuffers (gdi32.dll) function, without changing the existing state?

I am currently doing this:

Get current matrix mode
glPushAttrib(GL_ALL_ATTRIB_BITS)
glViewport(0, height - 64, 64, 64)
Disable a bunch of things
glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5f);
Switch to projection matrix, push, loadidentity
Switch to modelview matrix, push, loadidentity, glOrtho
glRasterPos
glDrawPixels to draw the image with alpha
Restore matrices and attributes
Back to original matrix mode

The reason behind this is that I am trying to draw a fps counter on the top-left corner of the window, just like Fraps or other game recording program. Although I'm not familiar with OpenGL, I believe that using texture on a quad will change the state so I can't use texture.

The drawing of the fps number happens directly before calling `SwapBuffers` in my hook.

Is there a faster/better approach than what I'm doing?

wglSwapMultipleBuffers

dukey — Wed, 01 May 2013 11:09:37 GMT

I just found this function in the header files.
Why is it undocumented ? Does it work ? I assume it works like nvidia swap groups
anyone tried this thing ?

Having weird issues with rendering on computers with amd video cards.

TheZars15 — Tue, 30 Apr 2013 06:09:51 GMT

So I am working on solar system project. Everything seems to work perfectly, but when I tried to test it on other computer, the first scene didn't even show up, leaving me with blank background color, and 2. scene had some things working fine, except for little distance bar, that is holding on your screen like HUD.

I'm pretty sure it only happens on machine, that uses amd GPU, since the program works fine on my and my friends computer, which has nvidia GPU. I've tested it on 3 computers with radeon card.

I don't have a lot of experience, since I've been learning programming all by self. Can't wait for opportunity to learn programming at school.

Edit 1:
I didn't add code, so here you go:

main.cpp

Code :

#include "SDL/sdl.h"
#include "SDL/sdl_opengl.h"
#include "SDL_image.h"
#include 
#include 
#include 
#include 
 
#include "Planet.h"
 
 
const float PI = 3.1415926f;
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 800;
const int SCREEN_BPP = 32;
const float ZoomMax = 10.0;
int  CameraPos[2];
float Zoom;
 
 
int* GUIPosition(int x,int y);
float toDeg(float rad);
float toRad(float deg);
GLuint loadTexture(const std::string &fileName);
 
 
 
 
int main( int argc, char* args[] )
{
    CameraPos[0] = 0;
    CameraPos[1] = 1;
    Zoom = 0.1;
 
    SDL_Init( SDL_INIT_EVERYTHING );
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_WM_SetCaption("Solar system", NULL);
    SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP, SDL_OPENGL);
    glClearColor(0,0,0,1);
    glViewport(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
    glShadeModel(GL_SMOOTH);
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(0,SCREEN_WIDTH,SCREEN_HEIGHT,0,0.1,ZoomMax);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
 
    glDisable(GL_DEPTH_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    SDL_Event event;
    srand(time(NULL));
 
 
    //Variables
    bool Running = true;
    int Tick = 0;
    int Sizes[9] = {1399830,4900,12000,12760,6800,143000,120000,52000,2300};
    float Speed[9] = {0,47.9,35.0,29.8,24.1,13.1,9.6,6.8,5.4};//km/s
    float Scale = 0.01;
    bool isRight=false,isLeft=false;
    bool ShowMarkers = true;
    int Devider = 100;
    int num_segments = 30;
    int CameraSpeed = 20;
    unsigned int Arrow = 0;
    Arrow = loadTexture("Arrow.png");
 
    enum//Scenes
    {
        sceneIntro,
        sceneProp,//Proportional model
        sceneOverview//Overview model
    };
 
    int CurrentScene = sceneOverview;
 
    Planet Sun(Sizes[0]*Scale,0,loadTexture("Sun.png"));
    Sun.SetPosition(0,0);
 
    Planet Mercury(Sizes[1]*Scale,58000000*Scale,loadTexture("Mercury.png"));
    Planet Venus(Sizes[2]*Scale,108000000*Scale,loadTexture("Venus.png"));
    Planet Earth(Sizes[3]*Scale,150000000*Scale,loadTexture("VLd.png"));
    Planet Mars(Sizes[4]*Scale,228000000*Scale,loadTexture("VLd.png"));
    Planet Jupiter(Sizes[5]*Scale,778000000*Scale,loadTexture("VLd.png"));
    Planet Saturn(Sizes[6]*Scale,1427000000*Scale,loadTexture("VLd.png"));
    Planet Uranus(Sizes[7]*Scale,2871000000u*Scale,loadTexture("VLd.png"));
    Planet Neptune(Sizes[8]*Scale,4497000000*Scale,loadTexture("VLd.png"));
    Planet Planets[9] = {Sun,Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune};
    //Gameloop
    while(Running)
    {
        //Events
        while(SDL_PollEvent(&event))
        {
            if(event.type == SDL_KEYDOWN)
            {
                switch(event.key.keysym.sym)
                {
                case SDLK_ESCAPE:
                    Running = false;
                    break;
                case SDLK_LEFT:
                    isLeft = true;
                    break;
                case SDLK_RIGHT:
                    isRight = true;
                    break;
                case SDLK_F1:
                    ShowMarkers = not ShowMarkers;
                    break;
                case SDLK_F2:
                    if(CurrentScene==sceneProp)
                        Zoom = ZoomMax;
                    break;
                case SDLK_F3:
                    if(CurrentScene==sceneProp)
                        Zoom = 0.1;
                    break;
                case SDLK_F4:
                    CurrentScene = sceneOverview;
                    Zoom = 0.1;
                    CameraPos[0] = 0;
                    CameraPos[1] = 0;
                    Devider=100;
                    break;
                case SDLK_F5:
                    CurrentScene = sceneProp;
                    Zoom=10;
                    break;
                default:
                    break;
                }
            }else if(event.type == SDL_QUIT) Running = false;
            else if(event.type == SDL_KEYUP)
            {
                switch(event.key.keysym.sym)
                {
                case SDLK_LEFT:
                    isLeft = false;
                    break;
                case SDLK_RIGHT:
                    isRight = false;
                    break;
                default:
                    break;
                }
            }else if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                switch(event.button.button)
                {
                case 4:
                    if(Zoom>0.2&&CurrentScene==sceneProp)
                        Zoom-=0.1;
                    else if (Devider>1&&CurrentScene==sceneOverview)
                        Devider--;
                    break;
                case 5:
                    if(Zoom-Planets[8].GetDistance())
                {
                    CameraPos[0]-=CameraSpeed*(10*Zoom);
                }else
                {
                    CameraPos[0] = -Planets[8].GetDistance();
                }
            }
            if(isLeft)
            {
                if(CameraPos[0]<0)
                {
                    CameraPos[0]+=CameraSpeed*(10*Zoom);
                }else
                {
                    CameraPos[0] = 0;
                }
            }
 
            for(int x=1;x<9;x++)
            {
                int dist = Planets[x].GetDistance();
                Planets[x].SetPosition(dist,0);
            }
        }
 
 
        //Rendering
        glClear(GL_COLOR_BUFFER_BIT);
        glPushMatrix();
            glTranslatef(CameraPos[0]+SCREEN_WIDTH*(Zoom*5),CameraPos[1]+SCREEN_HEIGHT*(Zoom*5),-Zoom);
            glColor4f(1,1,1,1);
            if(CurrentScene==sceneOverview)
            {///Overview model rendering
                glColor4f(1,1,1,0.5);
                for(int xx=1;xx<9;xx++)
                {
                    int r = 20+(pow(xx,2)+xx*30);
                    int cx = 0;
                    int cy = 0;
 
                    float theta = 2 * 3.1415926 / float(num_segments);
                    float c = cosf(theta);
                    float s = sinf(theta);
                    float t;
                    float x = r;
                    float y = 0;
                    glBegin(GL_LINE_LOOP);
                    for(int ii = 0; ii < num_segments; ii++)
                    {
                        glVertex2f(x + cx, y + cy);
                        t = x;
                        x = c * x - s * y;
                        y = s * t + c * y;
                    }
                    glEnd();
                }
 
                glColor4f(1,1,1,1);
 
                glEnable(GL_TEXTURE_2D);
                    for(int x=0;x<9;x++)
                    {
                        glBindTexture(GL_TEXTURE_2D,Planets[x].GetTexture());
                        glBegin(GL_QUADS);
                            int Pos[2] = {Planets[x].GetX(),Planets[x].GetY()};
                            int rad = Planets[x].GetRadius()/200;
                            if(x==0)
                                rad = 15;
                            else
                                rad = 3+rad;
 
                            glTexCoord2d(0,0); glVertex2f(Pos[0]-rad,Pos[1]-rad);
                            glTexCoord2d(0,1); glVertex2f(Pos[0]-rad,Pos[1]+rad);
                            glTexCoord2d(1,1); glVertex2f(Pos[0]+rad,Pos[1]+rad);
                            glTexCoord2d(1,0); glVertex2f(Pos[0]+rad,Pos[1]-rad);
                        glEnd();
                    }
                glDisable(GL_TEXTURE_2D);
            }else if(CurrentScene==sceneProp)
            {///Proportional model rendering
                glEnable(GL_TEXTURE_2D);
                    for(int x=0;x<9;x++)
                    {
                        glBindTexture(GL_TEXTURE_2D,Planets[x].GetTexture());
                        glBegin(GL_QUADS);
                            int Pos[2] = {Planets[x].GetX(),Planets[x].GetY()};
                            int rad = Planets[x].GetRadius();
 
                            glTexCoord2d(0,0); glVertex2f(Pos[0]-rad,Pos[1]-rad);
                            glTexCoord2d(0,1); glVertex2f(Pos[0]-rad,Pos[1]+rad);
                            glTexCoord2d(1,1); glVertex2f(Pos[0]+rad,Pos[1]+rad);
                            glTexCoord2d(1,0); glVertex2f(Pos[0]+rad,Pos[1]-rad);
                        glEnd();
                    }
                glDisable(GL_TEXTURE_2D);
 
                if(ShowMarkers)
                {
                    glColor4f(1,0,0,0.5);
                    glBegin(GL_QUADS);
                        for(int x=0;x<9;x++)
                        {
                            int Pos[2] = {Planets[x].GetX(),Planets[x].GetY()};
                            int rad = 500*Zoom;
 
                            glVertex2f(Pos[0]-rad,Pos[1]-rad);
                            glVertex2f(Pos[0]-rad,Pos[1]+rad);
                            glVertex2f(Pos[0]+rad,Pos[1]+rad);
                            glVertex2f(Pos[0]+rad,Pos[1]-rad);
                        }
                    glEnd();
                }
 
                glColor4f(1,1,1,1);
 
                glBegin(GL_QUADS);
                    int* Pos;
                    Pos = GUIPosition(50,SCREEN_HEIGHT-50);
                    int xSize=(SCREEN_WIDTH-100)*(10*Zoom),ySize=(10*Zoom);
 
                    glVertex2f(Pos[0],Pos[1]);
                    glVertex2f(Pos[0]+xSize,Pos[1]);
                    glVertex2f(Pos[0]+xSize,Pos[1]+ySize);
                    glVertex2f(Pos[0],Pos[1]+ySize);
 
                    xSize=(10*Zoom);
                    ySize=3*(10*Zoom);
 
                    for(int x=0;x<9;x++)
                    {
                        Pos=GUIPosition(50+((float)Planets[x].GetDistance()/Planets[8].GetDistance())*((SCREEN_WIDTH-100)),SCREEN_HEIGHT-53);
 
                        glVertex2f(Pos[0],Pos[1]);
                        glVertex2f(Pos[0]+xSize,Pos[1]);
                        glVertex2f(Pos[0]+xSize,Pos[1]+ySize);
                        glVertex2f(Pos[0],Pos[1]+ySize);
                    }
                glEnd();
 
                glEnable(GL_TEXTURE_2D);
                glBindTexture(GL_TEXTURE_2D,Arrow);
                glBegin(GL_QUADS);
                    Pos=GUIPosition(36-(SCREEN_WIDTH-100)*((CameraPos[0]+0.1)/Planets[8].GetDistance()),SCREEN_HEIGHT-49);
                    xSize=28*(10*Zoom);
                    ySize=28*(10*Zoom);
 
                    glTexCoord2d(0,0); glVertex2f(Pos[0],Pos[1]);
                    glTexCoord2d(1,0); glVertex2f(Pos[0]+xSize,Pos[1]);
                    glTexCoord2d(1,1); glVertex2f(Pos[0]+xSize,Pos[1]+ySize);
                    glTexCoord2d(0,1); glVertex2f(Pos[0],Pos[1]+ySize);
                glEnd();
                glDisable(GL_TEXTURE_2D);
            }
        glPopMatrix();
        SDL_GL_SwapBuffers();
 
 
        //End
        Tick++;
        SDL_Delay(10);
    }
 
 
    SDL_Quit();
    return 0;
}
 
 
 
 
 
 
 
float toRad(float deg)
{
    return deg*(PI/180);
}
 
float toDeg(float rad)
{
    return rad*(180/PI);
}
 
int* GUIPosition(int x,int y)
{
    int* Info;
    int Cam[2];
    Info = Cam;
    Cam[0] = -(CameraPos[0]+SCREEN_WIDTH*(Zoom*5))+(x*(Zoom*10));
    Cam[1] = -(CameraPos[1]+SCREEN_HEIGHT*(Zoom*5))+(y*(Zoom*10));
    std::cout<<"";
    return Info;
}
 
GLuint loadTexture(const std::string &fileName)
{
  SDL_Surface *image = IMG_Load( fileName.c_str() );
  SDL_DisplayFormatAlpha(image);
  unsigned object(0);
  glGenTextures(1, &object);
  glBindTexture(GL_TEXTURE_2D, object);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->w, image->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
  SDL_FreeSurface(image);
  return object;
}

Planets.h

Code :

#ifndef PLANET_H
#define PLANET_H
 
 
class ID
{
    int id;
    public:
        ID()
        {
            static int counter = 0;
            id = counter++;
        }
 
        int getId()
        {
            return id;
        }
};
 
class Planet
{
    static ID id;
    public:
        Planet(int Rad,int Dist,unsigned int tex);
 
        void SetRadius(int Rad);
        void SetDistance(int Dist);
        void SetPosition(int x, int y);
 
        float GetRadius();
        int GetDistance();
        int GetX();
        int GetY();
        unsigned int GetTexture();
 
        int GetId()
        {
            return id.getId();
        }
    private:
        float Radius;
        int Distance;
        int Position[2];
        unsigned int Texture;
};
 
#endif // PLANET_H

Planets.cpp

Code :

#include "Planet.h"
 
Planet::Planet(int Rad,int Dist,unsigned int tex)
{
    Radius = Rad;
    Distance = Dist;
    Texture = tex;
}
 
void Planet::SetRadius(int Rad)
{
    Radius = Rad;
}
void Planet::SetDistance(int Dist)
{
    Distance = Dist;
}
void Planet::SetPosition(int x, int y)
{
    Position[0] = x;
    Position[1] = y;
}
 
 
 
int Planet::GetDistance()
{
    return Distance;
}
float Planet::GetRadius()
{
    return Radius;
}
int Planet::GetX()
{
    return Position[0];
}
int Planet::GetY()
{
    return Position[1];
}
unsigned int Planet::GetTexture()
{
    return Texture;
}

Link Error: glew

nice87day — Fri, 26 Apr 2013 23:19:02 GMT

Hello,

IDE: code::blocks 10.05
compiler: gnu gcc

code:

#define GLEW_STATIC
#include
#include
#include
#include
#include

using namespace std;

enum VAO_IDs {Triangles,NumVAOs};
enum Buffer_IDs {ArrayBuffer, NumBuffers};
enum Attrib_IDs {vPosition=0};

GLuint VAOs[NumVAOs];
GLuint Buffers[NumBuffers];

const GLuint NumVertices = 6;

/* GLUT callback Handlers */

void resize(int width, int height)
{

}

void display(void)
{

}

void key(unsigned char key, int x, int y)
{

}

void mouse()
{

}

void idle(void)
{

}

void init(void)
{
glGenVertexArrays(NumVAOs,VAOs);
glBindVertexArray(VAOs[Triangles]);

// GLfloat vertices[NumVertices][2]={
// {-0.9,-0.9},{0.85,-0.9},{-0.9,0.85},{0.9,-0.85},{0.9,0.9},{-0.85,0.9}
// };
}
/* Program entry point */

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(640,480);
glutInitWindowPosition(0,0);
glutInitContextVersion(4,0);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutCreateWindow("scientific");

GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
cout << glewGetErrorString(err);

}

init();

glutReshapeFunc(resize);
glutDisplayFunc(display);
glutKeyboardFunc(key);

glutIdleFunc(idle);

glutMainLoop();

return EXIT_SUCCESS;
}

Error:

C:...\main.cpp|48|undefined reference to `__glewGenVertexArrays'|
C:...\main.cpp|49|undefined reference to `__glewBindVertexArray'|

please help

PIXELFORMATDESCTIPTOR problem

sikkiv — Tue, 23 Apr 2013 17:13:22 GMT

Hi everyone,

I'm relatively new to OpenGL programming. I successfully wrote an application with freeGLUT and GLEW displaying some triangles and some textures.
Now I wanted to create an application without freeGLUT.
The problem is that "ChoosePixelFormat()" always returns 0 instead of some matching number.
Here is my PIXELFORMATDESCRIPTOR:

Code :

PIXELFORMATDESCRIPTOR pfd = {
		sizeof(PIXELFORMATDESCRIPTOR),
		1, 
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,
		32, 
		0, 0, 0, 0, 0, 0, 
		0, 
		0, 
		0, 
		0, 0, 0, 0, 
		24, 
		0, 
		0, 
		PFD_MAIN_PLANE, 
		0, 
		0, 0, 0
	};
 
        int matchingPFD;
	matchingPFD = ChoosePixelFormat(hdc, &pfd);

I really have no idea what I am doing wrong here so I hope someone can help me out.
For your information I'm using Windows 8 and Visual Studio 2010.

Thanks and greetz
sikkiv