Messages

1

Général / Re : OpenGL ne fonctionne plus après avoir recréé une fenêtre

« le: Juillet 26, 2016, 08:48:01 pm »

C'est bon j'ai testé plusieurs combinaisons et il y a juste besoin de reupload les VAO (pour les VBO pas besoin).
Voilà merci pour votre aide.

2

Général / Re : OpenGL ne fonctionne plus après avoir recréé une fenêtre

« le: Juillet 26, 2016, 06:28:45 pm »

Ok ça fonctionne, merci pour ta réponse rapide. Par contre je vois vraiment pas pourquoi les VAO sont détruites... Est ce que c'est la même chose pour les VBO et en fait tout est clean sur la VRAM ?

3

Général / OpenGL ne fonctionne plus après avoir recréé une fenêtre

« le: Juillet 26, 2016, 05:30:49 pm »

Bonjour,

But:
J'essaie d'implémenter dans mon moteur la possibilité de passer en mode pleine écran.

Problème rencontré:
Le rendu d'origine (première création de la fenêtre) fonctionne parfaitement, en revanche lorsque je change d'état en récréant la fenêtre (RenderWindow.create) les fonctions d'OpenGL modern ne fonctionne plus (avec glGetError j'obtiens: "Unknow error") et j'obtiens juste le background avec la couleur correspondante.
Je parle bien de fonctions modern parce que par exemple glClearColor fonctionne.

Je précise que j'ai vérifié le reste du programme et les fonctions Init et ReInit sont bien appelées et que le reste du moteur s'update correctement (coordonnées des objets s'actualisent etc...)
=>Tout fonctionne sauf le rendu.


 Fonction Init (lors du lancement du moteur):

//Setup settings for window
        m_settings = sf::ContextSettings();
        m_settings.depthBits = 24;
        m_settings.stencilBits = 8;
        m_settings.majorVersion = 4;
        m_settings.minorVersion = 0;
        m_settings.antialiasingLevel = m_winsettings.AntiAliasingLevel;

        m_window.create(sf::VideoMode(m_winsettings.Size.x, m_winsettings.Size.y, 32), GetGame()->GetName(), m_winsettings.Style, m_settings);
        m_window.setFramerateLimit(m_winsettings.FrameLimit);
        m_window.setVerticalSyncEnabled(m_winsettings.UseSynchronisation);
        m_window.setKeyRepeatEnabled(true);

        //CenterScreen
        m_centerscreen.x = m_winsettings.Size.x / 2.0f + m_window.getPosition().x;
        m_centerscreen.y = m_winsettings.Size.y / 2.0f + m_window.getPosition().y;

        //Init glew
        glewExperimental = GL_TRUE;
        glewInit();

        //OpenGl settings
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_STENCIL_TEST);
        glDepthFunc(GL_LESS);

        glDisable(GL_CULL_FACE);
        //glEnable(GL_CULL_FACE);
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

Fonction ToggleScreen (appelée pour changer d'état):

if (m_winsettings.Style == sf::Style::Fullscreen)
        {
                m_winsettings.Style = sf::Style::Close;
                m_window.create(sf::VideoMode(m_winsettings.Size.x, m_winsettings.Size.y, 32), GetGame()->GetName(), m_winsettings.Style, m_settings);
        }
        else
        {
          m_winsettings.Style = sf::Style::Fullscreen;
                m_window.create(sf::VideoMode(m_winsettings.Size.x, m_winsettings.Size.y, 32), GetGame()->GetName(), m_winsettings.Style, m_settings);
        }
               
        ReInit();

Et la fonction ReInit (appelée pour "Update" l'état du rendu):

//OpenGl settings
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_STENCIL_TEST);
        glDepthFunc(GL_LESS);
        glDisable(GL_CULL_FACE);
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);

        m_window.setFramerateLimit(m_winsettings.FrameLimit);
        m_window.setVerticalSyncEnabled(m_winsettings.UseSynchronisation);
        m_window.setKeyRepeatEnabled(true);

        m_window.setActive();

        glViewport(0, 0, m_window.getSize().x, m_window.getSize().y);

        m_centerscreen.x = m_window.getPosition().x + m_window.getSize().x / 2.0f;
        m_centerscreen.y = m_window.getPosition().y + m_window.getSize().y / 2.0f;

        GetGame()->GetEvent()->ReInit();

Merci pour votre aide !

 

4

Graphique / Re : RenderWindow::Create() => crash du programme

« le: Juillet 02, 2016, 11:57:44 pm »

Bon ok j'ai trouvé le problème et il est de moi ... 

J'ai une class GameContext qui a comme membre un pointer de renderer. Durant l'initialisation du GameContext un objet Renderer est créé dans la fonction Init() sauf que la portée du Renderer est limitée à la fonction Init().
Du même coup, lors de l'appelle du lancement de la fenêtre Run(), le pointer pointe l'adresse d'un objet qui n'existe plus ...

Du coup j'ai remplacé m_renderer = &Renderer() qui est très moche par m_renderer = new Renderer().

La fenêtre ne pouvait donc pas se créer parce que la fenêtre n'existait plus !

Vraiment désolé pour le dérangement (j'aime pas quand je trouve l'erreur au dernier moment alors que je suis dessus depuis 2 jours).

Si vous voulez supprimer le topic, il n'y a pas de problème !

5

Graphique / Re : RenderWindow::Create() => crash du programme

« le: Juillet 02, 2016, 10:09:44 pm »

J'utilise mon code sous forme de lib dans un autre projet donc je sais pas si le debugger du projet "test" ne donne suffisamment d'informations:

First-chance exception at 0x559B55F0 (sfml-window-d-2.dll) in AxionTest.exe: 0xC0000005: Access violation reading location 0xCCCCCCCC.
Unhandled exception at 0x559B55F0 (sfml-window-d-2.dll) in AxionTest.exe: 0xC0000005: Access violation reading location 0xCCCCCCCC.

J'ai pas plus d'informations mise à part les états de la mémoire. La sf::RenderWindow semble avec ses membres null (c'est logique si la fenêtre n'est pas initialisée):
m_impl = 0x00000000 <NULL>
m_window = 0x00000000 <NULL>

Je sais pas si ça peut aider :/

6

Graphique / RenderWindow::Create() => crash du programme

« le: Juillet 02, 2016, 08:44:23 pm »

Bonsoir,
J'essaie actuellement de créer une RenderWindow dans une classe mais lorsque j'appelle la fonction .create le programme crash (le programme a cessé de fonctionner ...). J'ai vérifié, l'erreur ne vient pas de l'ordre des libs (Graphics avant WWindow). En effet, j'arrive à créer une fenêtre avec le constructeur de classe de base.
Je précise que j'arrive très bien à faire fonctionner le code teste de sfml donc je ne pense pas que le problème vienne d'une erreur d'installation.

Renderer.h

//RENDERER//
        class AXION_API Renderer : public Object
        {
        //Constructor
        public:
                Renderer(GameContext* context);

        //System Functions
        public:
                void Init();                //FONCTION D'INITIALISATION (appellée avant le Run())
                void Run();               //FONCTION POUR LANCER LE RENDU
                void Finish();

                void Update(float DeltaTime);
        private:
                bool bIsRendererActive = false;

        //Settings
        private:
                sf::ContextSettings m_settings;

        //Window
        private:
                sf::RenderWindow m_window;
                WindowSettings m_winsettings = WindowSettings();
        public:
                sf::RenderWindow* GetWindow();
                void SetWindowSettings(WindowSettings winsettings);


        };

Renderer.cpp:

void Renderer::Init()
{
        std::cout << "->Renderer::Init::Start" << std::endl;

        //Init Context
        sf::Context();

        //Init glew
        glewExperimental = GL_TRUE;
        glewInit();

        //OpenGl settings
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LESS);

        std::cout << "->Renderer::Init::End" << std::endl;
}
void Renderer::Run()
{
        std::cout << "->Renderer::Run::Start" << std::endl;

        m_window.create(sf::VideoMode(500, 500), "test");
        std::cout << "RenderWindow created" << std::endl;


        while (true)
        {
             //Boucle vide pour voir laisser apparaître la fenêtre (simple teste)
             //Fonctionne avec l'utilisation du constructeur de base de sf::RenderWindow
        }

        bIsRendererActive = true;

        std::cout << "->Renderer::Run::End" << std::endl;

}

Si vous avez besoin de plus d'informations, n'hésitez pas !

Merci 

7

Général / Re : OpenGL: Created version = 0.0

« le: Mars 25, 2016, 10:44:06 am »

Bonjour,
Je me permet de répondre au problème au cas où ça pourrait aider quelqu'un.

Alors la solution était que je n'utilisais pas un opengl32.dll suffisamment récent (pour mon pc du moins).
Ce .dll était celui que j'utilisais sur mon pc portable. J'ai donc pris le dll directement de windows.

C:/Windows/system32/opengl32.dll

Je tiens à préciser également que le .dll récent fonctionne sur mon pc portable.

Merci pour votre aide !

8

Général / OpenGL: Created version = 0.0

« le: Mars 22, 2016, 09:03:58 pm »

Bonsoir,

Je cherche actuellement à réussir un simple rendu 3D avec OpenGL.

J'ai fais un code très simple sans erreur et qui fonctionne parfaitement.
J'ai donc voulu tester ce code sur un autre pc et je rencontre une erreur (après avoir recompilé le projet):

https://gyazo.com/7aae9d9c6f14e3dcac6b9f4899f212cc

Rien de bien choquant mise à part la version qui est en 0.0 (donc j'imagine que OpenGL ne fonctionne pas).
J'ai vérifié sur pas mal de forum mais rien.
Mes drivers sont à jour (GTX 770) et voici le code:

#include <iostream>
#include <string>

#include "GL\glew.h"

#include "SFML\OpenGL.hpp"
#include "SFML\System.hpp"
#include "SFML\Graphics.hpp"
#include "SFML\Window.hpp"
#include "SFML\Main.hpp"

#include "glm\gtx\transform.hpp"

#include "Camera.h"

using namespace std;

int main(int argc, char *args[])
{
        sf::Context context;
        sf::ContextSettings settings;
        settings.depthBits = 24;
        settings.stencilBits = 8;
        settings.majorVersion = 4;
        settings.minorVersion = 0;
        settings.antialiasingLevel = 8;

        sf::RenderWindow window(sf::VideoMode(1280, 800), "OpenGL",sf::Style::Close, settings);

        glewExperimental = GL_TRUE;
        glewInit();

        sf::Event event;

        Camera camera(glm::vec3(4,4,3),1280.f / 800.f, glm::radians(90.f), 0.0001f, 1000.0f);

        bool IsRunning = true;

        //OPENGL//

        float points[] = {
                0.0f, 0.5f, 0.0f,
                0.5f, -0.5f, 0.0f,
                -0.5f, -0.5f, 0.0f
        };

        GLuint vbo = 0;
        glGenBuffers(1, &vbo);
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

        GLuint vao = 0;
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

        const char* vertex_shader =
                "#version 400\n"
                "in vec3 vp;"
                "uniform mat4 MVP;"
                "void main () {"
                "  gl_Position = MVP * vec4 (vp, 1.0);"
                "}";

        const char* fragment_shader =
                "#version 400\n"
                "out vec4 frag_colour;"
                "void main () {"
                "  frag_colour = vec4 (1.0, 0.0, 0.0, 1.0);"
                "}";

        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vs, 1, &vertex_shader, NULL);
        glCompileShader(vs);
        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fs, 1, &fragment_shader, NULL);
        glCompileShader(fs);

        GLuint shader_programme = glCreateProgram();
        glAttachShader(shader_programme, fs);
        glAttachShader(shader_programme, vs);
        glLinkProgram(shader_programme);



        while (IsRunning)
        {
                while (window.pollEvent(event))
                {
                        if (event.type == sf::Event::Closed) IsRunning = false;
                }

                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                glUseProgram(shader_programme);

                GLuint MVPID = glGetUniformLocation(shader_programme, "MVP");
                glUniformMatrix4fv(MVPID, 1, GL_FALSE, &camera.MVPMatrix()[0][0]);

                glBindVertexArray(vao);
                glDrawArrays(GL_TRIANGLES, 0, 3);

                window.display();
        }

        window.close();

        return 0;
}

Lors que je debug, ça bloque à glGenBuffers (logique).
Merci