Bdtjtk

I would like to render my scene on different thread. I have classes for buffers and shader.

enum BUFFER

{

    ARRAY,

    ELEMENT_ARRAY

};



enum USAGE

{

    STATIC_DRAW, DYNAMIC_DRAW

};



class Buffer

{

public:

    Buffer() = default;

    virtual ~Buffer() = default;



    Buffer* Create(BUFFER buffer, USAGE usage) 

    {

        return new GLBuffer(buffer, usage);

    }



    virtual void GenBuffer() {}

    virtual void BindBuffer(){}

    virtual void AddData(const void* data, intptr size, intptr offset) {}

    //Data type is an enum 

    virtual void AddAttibute(unsigned int index, int size, DataType type, bool normalize, int stride, const void* offset) {}

};



class GLBuffer : public Buffer

{ 

public:  

    GLBuffer(BUFFER buffer, USAGE usage) 

    { 

        GenBuffer();

        BindBuffer();



        type = BUFFERToOpenGL(buffer);

        usage = USAGEToOpenGL(usage);

    }



    void GenBuffer() override { glGenBuffers(1, &buffer); }

    void BindBuffer() override { glBindBuffer(type, buffer); }



    unsigned int buffer;

    unsigned int type;

    unsigned int usage;

};

I have not shown GLBuffer::AddData() and AddAttribute, but I think you got an idea of this.

The same for VertexArray

class VertexArray

{

public:

    VertexArray* Create() { return GLVertexArray(); }

    virtual void BindVertexArray() {}

}



class GLVertexArray : public VertexArray

{

public:

   ...

}

and so on

Shader is a bit different

enum SHADERTYPE

{

    VERTEX,

    FRAGMENT

};



class Shader

{

public:

    Shader* Create() { return GLShader; }

    virtual const int ShaderFromSource(const char* path, SHADERTYPE type) {}

    virtual void End(const int* shaders, int count) {}



    virtual void UseProgram() {}



    virtual void //add uniforms etc

};



class GLShader : public Shader

{

public:

    GLShader() 

    {

        shaderProgram = glCreateProgram();

    }



    const int GLShader::ShaderFromSource(const char* path, SHADERTYPE type) override 

    {

        unsigned int shaderID = glCreateShader(SHADERTYPEToOpenGL(type));



        glShaderSource(shaderID, 1, &shader, NULL);

        glCompileShader(shaderID);



        glAttachShader(shaderProgram, shaderID);



        return shaderID;

    }



    void GLShader::End(const int ids, int count) override 

    {

        glLinkProgram(shaderProgram);



        for (int i = 0; i < count; ++i) {

            glDetachShader(shaderProgram, ids[i]);

            glDeleteShader(ids[i]);

        }

    }



     void UseProgram() override { glUseProgram(shaderProgram); }



    unsigned int shaderProgram;

};

I want to create vao, vbo and shader in the Cube class ctor in the main thread and call Cube::Render in a render thread Cube::Render calls Use program adds uniforms and call DrawArray.

void mainloop()

{ 

    Cube cube;



    std::thread* thread = nullptr;                                     

    std::mutex mutex;

    std::lock_guard<std::mutex> guard(mutex);

    thread = new std::thread([&]() {

        while (!quit) {

            SDL_GL_MakeCurrent(window, glContext);



            glClearColor(0, 0, static_cast<float>(15) / 255, 1);

            glClear(GL_COLOR_BUFFER_BIT);



            cube.Render();



            SDL_GL_SwapWindow(window);

        }

    });

}

Cube cube - creates vao, vbo, shaders - adds vertices to vbo

class Cube

{ 

    Cube() 

    {

        vao = vao->Create();

        vbo = vbo->Create(ARRAY, STATIC_DRAW);

        vbo->AddData(...);

        vbo->AddAttributes(...);



        shader = shader->Create();

        int shaders[2] = {

            shader->ShaderFromSource(vs, VERTEX),

            shader->ShaderFromSource(fs, FRAGMENT)

        };

        shader->End(shaders, 2);

    }



    VertexArray* vao = nullptr;

    Buffer* vbo = nullptr;

    Shader* shader = nullptr;

};

cube.Render() - uses shader, adds uniforms, call draw arrays

Cube::Render()

{

    shader->UseProgram();

    shader->Uniform(mvp);



    vao->DrawArrays(TRIANGELS, 0, 36);

} 

when Cube gets created in a main thread I got this message

when Cube gets created in a render thread I got this message

Why does it happen? How to support rendering in a different thread?

I see you're using SDL2, so, you have to create 2 SDL_GLContexts, let's say

SDL_GLContext mainContext;

SDL_GLContext renderThreadContext;

if you already enabled SDL_GL_SHARE_WITH_CURRENT_CONTEXT all you need to do is

after creating a window you have to create mainContext context

mainContext = SDL_GL_CreateContext(window);

then create a thread and Create renderThreadContext in this thread!!!

void RenderThread() {

    std::thread* renderThread = nullptr;



    thread = new std::thread([&](){

        renderThreadContext = SDL_GL_CreateContext(window);

        //*** NOW CREATE CUBE OBJECT ***

        Cube cube;

        while(!quit) {

            SDL_GL_Make_Current(window, renderThreadContext);      

             //Opengl Calls

            SDL_GL_SwapWindow(window);

        }

    }); 

}

as tunglt said - Each thread should have its own context, so you have to create a new context in a thread as I showed above.