EDIT Mesa upgraded now supports compatibility profile for 4.5 so this is not a problem any more...

Excerpt from glxinfo with my AMD RX 580 GPU:

OpenGL core profile version string: 4.5 (Core Profile) Mesa 18.0.3
OpenGL core profile shading language version string: 4.50
OpenGL version string: 3.0 Mesa 18.0.3
OpenGL shading language version string: 1.30
What this means: I can only get OpenGL 3.0 / GLSL 130 in Fragmentarium, as higher versions of OpenGL in Mesa amdgpu driver require a "Core Profile" context, something that FragM doesn't yet do (default is compatibility context, which Mesa only supports as high as version 3.0).  And without core profile / opengl 4 I can't use double...

https://wiki.qt.io/How_to_use_OpenGL_Core_Profile_with_Qt has some notes it seems.  I don't know anything about coding Qt so I doubt I could fix all of this without lots of help...


Linkback: https://fractalforums.org/fragmentarium/17/opengl-core-profile/1358/

Hmm... seems ok on nvidia... v4+ I recall setting core profile to the highest available and falling back to compat but its been awhile since ive looked at the init code...

The nvidia shader compiler is more forgiving than amd, it will patch a frag and run it anyways with a  warn where amd will fail with error. I will look at this asap... after ipv6?

Edit: double type works fine on nV.

oh, when you run FragM from a console it will output all of the widgets it creates... some internal program vars and gl specific vars (mislabeled)
shaderProgram
"DOUBLE"         "AAExp" "2"
"DOUBLE"         "AARange" "1"
"DOUBLE"         "B" "0.75"
"DOUBLE"         "Bailout" "45"
"DOUBLE_VEC2"    "Center" "-0.241051197052,0.38701269030571"
"DOUBLE"         "ColDiv" "10"
"INT  "          "Formula" "0"
"DOUBLE"         "G" "0.5"
"DOUBLE"         "Gamma" "2"
"BOOL "          "GaussianAA" "true"
"BOOL "          "Invert" "false"
"DOUBLE_VEC2"    "InvertC" "0,0"
"INT  "          "Iterations" "1000"
"BOOL "          "Julia" "false"
"DOUBLE_VEC2"    "JuliaXY" "-0.22222219407558,0"
"BOOL "          "Meta" "false"
"DOUBLE"         "Power" "2"
"INT  "          "PreIter" "0"
"DOUBLE"         "R" "0.25"
"DOUBLE"         "RetryBias" "0"
"DOUBLE"         "RetryEntry" "0"
"INT  "          "RetryMax" "0"
"BOOL "          "Sin" "false"
"BOOL "          "StalksInside" "false"
"BOOL "          "StalksOutside" "false"
"INT  "          "TrigIter" "5"
"DOUBLE"         "TrigLimit" "1.1"
"DOUBLE"         "Zoom" "0.64841693546845"
"SAMPLER_2D"     "backbuffer" "internal fragment variable"
"FLOAT_VEC2"     "pixelSize" "internal fragment variable"
"INT  "          "subframe" "internal fragment variable"
"FLOAT_MAT4"     "gl_ProjectionMatrix" "internal fragment variable"
 
bufferShaderProgram
"DOUBLE"         "Brightness" "1"
"DOUBLE"         "Contrast" "1"
"DOUBLE"         "Exposure" "1"
"DOUBLE"         "Gamma" "2"
"DOUBLE"         "Saturation" "1"
"INT  "          "ToneMapping" "1"
"SAMPLER_2D"     "frontbuffer" "internal fragment variable"
"FLOAT_MAT4"     "gl_ProjectionMatrix" "internal fragment variable"


I have been hesitant to do that because once FragM is updated to new GL all of the frags will also need to be updated.
As of now we have compatibility mode and still suporting all the legacy stuff, not the best but a reasonable compromise until the engine can be overhauled... on my todo list 

Core vs compatibility is selectable via the #version statement afaik.
I dont think any adjustments are needed in the C++ code.

The NV version uses some nVidia specific features while th non-nV version doesnt, there is a USE_NVIDIA #define NVIDIAGL4PLUS that sets it, try commenting it out, that should make it a bit more compatible with other cards

edit: oops, it's been far too long since I've last played around with it 

here is lines 550 - 580 MainWindow.cpp ...
...
    /// Default QGLFormat settings
    //    Double buffer: Enabled.
    //    Depth buffer: Enabled.
    //    RGBA: Enabled (i.e., color index disabled).
    //    Alpha channel: Disabled.
    //    Accumulator buffer: Disabled.
    //    Stencil buffer: Enabled.
    //    Stereo: Disabled.
    //    Direct rendering: Enabled.
    //    Overlay: Disabled.
    //    Plane: 0 (i.e., normal plane).
    //    Multisample buffers: Disabled.

    QGLFormat fmt;
    fmt.setDoubleBuffer(false);
    fmt.setStencil(false);
    fmt.setDepthBufferSize(32);
    QSettings settings;
    int i = settings.value("refreshRate", 20).toInt();
    fmt.setSwapInterval(i);

    engine = new DisplayWidget(fmt, this, splitter);
    engine->makeCurrent();
    engine->show();
    if(!engine->init()) CRITICAL(tr("Engine failed to start!"));
    engine->updateRefreshRate();
...

the commented lines are the default settings for when created like  engine = new DisplayWidget();
we take care of buffer swap for rendering and accumulation so..  fmt.setDoubleBuffer(false);
we don't use a stencil so...   fmt.setStencil(false);
and we want full 32bit depthbuffer so...  fmt.setDepthBufferSize(32); default is combined 8bit stencil + 24bit depth = 32bits

this sets up our initial context to get things going and it gets modified at fragment compile time as per the #version settings, in core profile, v1.4 and up, none of the shaders will compile, the only thing that lets them work in their current state is compatibility profile.

the "new" way for declaring uniforms is in blocks...

uniform blockname
{
 float someuni;
 float oneuni;
 vec2 twouni;
}
this format lends itself well to describing a tab full of widgets with some adjustments to the parser this should work for both single and blocks of uniforms.

Rebuilding the engine for modern compliance is the next step in my plans for FragM, I've been wanting to do it for quite a while now but just haven't the time to dedicate to the task, something else that makes me hesitant is that once I start reworking the engine I think I will find that the entire thing will need a lot of re-coding to be compliant with the latest Qt and GL libs, not to mention tidying up the coding style.

Hardware sensing and user selectable context profile for nVidia, AMD and intel GPUs at startup might be a good thing to do first.

Perhaps starting with the simplest Qt GL example and building from that, following recommended practice for Qt GL, would make for an overall better program in the end. My main goal would be to preserve Syntopia's original intent: an experimental GLSL development environment that can also be used to render fractals.

Another angle might be to go back to his original code, bring that up to date re:GL (smaller codebase easier to work with) and add all of the features/changes I've made but with a good deal of hindsight that I never had when I started work on this many years ago now.

Your input on this would be most valuable.

fmt.setVersion( 4, 5 );

the version major/minor could be set via "Preferences"

I hoped so, but sadly it's not that simple: the inheritance of DisplayWidget in the C++ depends on the version:
https://github.com/claudeha/FragM/blob/core-profile/Fragmentarium-Source/Fragmentarium/GUI/DisplayWidget.h#L81
(I just added an extra case in this fork)