imgui | free Immediate Mode Graphical User interface for JVM | Frontend Framework library

You can simply use ImGui::Begin and ImGui::End with the appropriate window title again if you want to append to a window.

The following works:

It is not clear from the question what exactly might be happening here, as lots of GL states - both at the time the rendering to the gbuffer, and at that time the gbuffer texture is rendered for visualization - are just unknown. However, from the images given in the question, one can not conclude that the actual color output for attachments 1 and 2 is not working.

One issue which comes to mind is alpha blending. The color values processed by the per-fragment operations after the vertex shader are always working with RGBA values - although the value of the A channel only matters if you enabled blending and use a blend function which somehow depends on the source alpha.

If you declare a custom fragment shader output as float, vec2, vec3, the remaining components stay undefined (undefined value, not undefined behavior). This does not impose a problem unless some other operations you do depend on those values.

What we also have here is a GL_RGBA16F output format (which is the right choice, because none of the 3-component RGB formats are required as color-renderable by the spec).

What might happen here is either:

• Alpha blending is already turned on during rendering into the g-buffer. The fragment shader's alpha output happens to be zero, so that it appears as 100% transparent and the contents of the texture are not changed.
• Alpha blending is not used during rendering into the g-buffer, so the correct contents end up in the texture, the alpha channel just happens to end up with all zeros. Now the texture might be visualized with alpha blending enbaled, ending up in a 100% transparent view.

If it is the first option, turn off blending when rendering the into the g-buffer. It would not work with deferred shading anyway. You might still run into the second option then.

If this is the second option, there is no issue at all - the lighting passes which follow will read the data they need (and ultimately, you will want to put useful information into the alpha channel to not waste it and be able to reduce the number of attachments). It is just your visualization (which I assume is for debug purposed only) is wrong. You can try to fix the visualization.

As a side note: Storing the world space position in the G-Buffer is a huge waste of bandwidth. All you need to be able to reconstruct the world space position is the depth value and the inverse of your view and projection matrices. Also storing world space position in GL_RGB16F will very easily run into precision issues if you move your camera away from world space origin.

This is a common issue if you are building directly onto the external drive. Try to build directly on your hard drive.

This may or may not be your issue, but here:

All of those libraries in some way interact with OpenGL and therefore are very sensitive to what thread they're being executed on. The current OpenGL context is thread-specific; each thread has its own current context, and a context can only be current within one thread at any time.

Creating a GLFW window creates an OpenGL context. If you then switch to another thread, that context will not be current in that thread unless you tell GLFW to make it current in that thread.

The problem is, that the method main_loop takes ownership of system. System will never be available for you afterwards.

A quick fix would be to update the method main_loop to pass renderer and display to the closure. Something like this:

I managed to get this to work by symlinking libopengl32.a with libOpenGL32.a. Maybe its dirty but atleast it works. I don't know if that is typo in imgui/sfml packages or what.

C++ doesn't provide a + operator for strings by default for const char*s. If your goal is to concatenate strings, you either have to define a + operator or simply use std::string,

The issue is imgui-js is trashing the attribute state.

You might want to consider running imgui-js in another canvas overlayed on top of the three.js canvas, each with their own WebGL context. Then they don't have to worry about each other.

A quick hack is this