Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 2 of 2

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

  1. #1
    Newbie Newbie
    Join Date
    Apr 2013
    Posts
    2

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

    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 <string>
    #include <ctime>
    #include <cmath>
    #include <iostream>
     
    #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<ZoomMax&&CurrentScene==sceneProp)
                            Zoom+=0.1;
                        else if(CurrentScene==sceneOverview)
                            Devider++;
                        break;
                    default:
                        break;
                    }
                }
            }
     
     
     
            //Logic
            if(CurrentScene==sceneOverview)
            {
                for(int x=1;x<9;x++)
                {
                    int rad = 20+(pow(x,2)+x*30);
                    float deg = (Speed[x]/Devider)*Tick;
                    Planets[x].SetPosition(cos(toRad(deg))*rad,sin(toRad(deg))*rad);
                }
            }else if(CurrentScene==sceneProp)
            {
                //if(isDown) CameraPos[1]-=100*Zoom;
                //if(isUp) CameraPos[1]+=100*Zoom;
                if(isRight)
                {
                    if(CameraPos[0]>-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;
    }
    Last edited by TheZars15; 04-29-2013 at 11:26 PM.

  2. #2
    Newbie Newbie
    Join Date
    Apr 2013
    Posts
    2
    Okay, I managed to finally find fix for this. It seems like problem was that I set camera to Z axis equally same as Z axis minimum(which was 0.1 in my case). Changing Zoom 0.1 to 0.11 fixed it.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •