WAHAHAHAHAHA

OpenGL 1 backend!!!!!!!!!!!!!!!!1111
TODO: test on old machine

CMakeLists.txt

@@ -74,14 +74,22 @@ else()
 endif()
 if (WIN32)
   set(WITH_RENDER_DX11_DEFAULT ON)
+  set(WITH_RENDER_DX9_DEFAULT ON)
 else()
   set(WITH_RENDER_DX11_DEFAULT OFF)
+  set(WITH_RENDER_DX9_DEFAULT OFF)
 endif()
 
 if (ANDROID)
   set(USE_GLES_DEFAULT ON)
+  set(WITH_RENDER_OPENGL1_DEFAULT OFF)
 else()
   set(USE_GLES_DEFAULT OFF)
+  if (APPLE)
+    set(WITH_RENDER_OPENGL1_DEFAULT OFF)
+  else()
+    set(WITH_RENDER_OPENGL1_DEFAULT ON)
+  endif()
 endif()
 
 option(BUILD_GUI "Build the tracker (disable to build only a headless player)" ${BUILD_GUI_DEFAULT})
@@ -93,7 +101,9 @@ option(WITH_JACK "Whether to build with JACK support. Auto-detects if JACK is av
 option(WITH_PORTAUDIO "Whether to build with PortAudio for audio output." ${WITH_PORTAUDIO_DEFAULT})
 option(WITH_RENDER_SDL "Whether to build with the SDL_Renderer render backend." ${WITH_RENDER_SDL_DEFAULT})
 option(WITH_RENDER_OPENGL "Whether to build with the OpenGL render backend." ${WITH_RENDER_OPENGL_DEFAULT})
+option(WITH_RENDER_OPENGL1 "Whether to build with the OpenGL 1.1 render backend." ${WITH_RENDER_OPENGL1_DEFAULT})
 option(WITH_RENDER_DX11 "Whether to build with the DirectX 11 render backend." ${WITH_RENDER_DX11_DEFAULT})
+option(WITH_RENDER_DX9 "Whether to build with the DirectX 9 render backend." ${WITH_RENDER_DX9_DEFAULT})
 option(USE_GLES "Use OpenGL ES for the OpenGL render backend." ${USE_GLES_DEFAULT})
 option(USE_FREETYPE "Use FreeType for font rendering." ON)
 option(SYSTEM_FFTW "Use a system-installed version of FFTW instead of the vendored one" OFF)
@@ -392,7 +402,7 @@ else()
 endif()
 
 if (BUILD_GUI)
-  if (NOT WITH_RENDER_SDL AND NOT WITH_RENDER_OPENGL AND NOT WITH_RENDER_DX11)
+  if (NOT WITH_RENDER_SDL AND NOT WITH_RENDER_OPENGL AND NOT WITH_RENDER_OPENGL1 AND NOT WITH_RENDER_DX11 AND NOT WITH_RENDER_DX9)
     message(FATAL_ERROR "No render backends selected!")
   endif()
 endif()
@@ -888,7 +898,25 @@ if (WITH_RENDER_OPENGL)
   else()
     list(APPEND DEPENDENCIES_LIBRARIES GL)
   endif()
-  message(STATUS "UI render backend: OpenGL")
+  if (USE_GLES)
+    message(STATUS "UI render backend: OpenGL ES 2.0")
+  else()
+    message(STATUS "UI render backend: OpenGL 3.0/2.0")
+  endif()
+endif()
+
+if (WITH_RENDER_OPENGL1)
+  list(APPEND GUI_SOURCES src/gui/render/renderGL1.cpp)
+  list(APPEND GUI_SOURCES extern/imgui_patched/backends/imgui_impl_opengl2.cpp)
+  list(APPEND DEPENDENCIES_DEFINES HAVE_RENDER_GL1)
+  if (NOT WITH_RENDER_OPENGL)
+    if (WIN32)
+      list(APPEND DEPENDENCIES_LIBRARIES opengl32)
+    else()
+      list(APPEND DEPENDENCIES_LIBRARIES GL)
+    endif()
+  endif()
+  message(STATUS "UI render backend: OpenGL 1.1")
 endif()
 
 if (WITH_RENDER_DX11)
@@ -907,6 +935,18 @@ if (WITH_RENDER_DX11)
   endif()
 endif()
 
+#if (WITH_RENDER_DX9)
+#  if (WIN32)
+#    list(APPEND GUI_SOURCES src/gui/render/renderDX9.cpp)
+#    list(APPEND GUI_SOURCES extern/imgui_patched/backends/imgui_impl_dx9.cpp)
+#    list(APPEND DEPENDENCIES_DEFINES HAVE_RENDER_DX9)
+#    list(APPEND DEPENDENCIES_LIBRARIES d3d9)
+#    message(STATUS "UI render backend: DirectX 9")
+#  else()
+#    message(FATAL_ERROR "DirectX 9 render backend only for Windows!")
+#  endif()
+#endif()
+
 if (NOT WIN32 AND NOT APPLE)
   CHECK_INCLUDE_FILE(sys/io.h SYS_IO_FOUND)
   CHECK_INCLUDE_FILE(linux/input.h LINUX_INPUT_FOUND)

extern/imgui_patched/backends/imgui_impl_opengl2.cpp

@@ -114,13 +114,15 @@ void    ImGui_ImplOpenGL2_Shutdown()
     IM_DELETE(bd);
 }
 
-void    ImGui_ImplOpenGL2_NewFrame()
+bool    ImGui_ImplOpenGL2_NewFrame()
 {
     ImGui_ImplOpenGL2_Data* bd = ImGui_ImplOpenGL2_GetBackendData();
     IM_ASSERT(bd != nullptr && "Did you call ImGui_ImplOpenGL2_Init()?");
 
     if (!bd->FontTexture)
         ImGui_ImplOpenGL2_CreateDeviceObjects();
+
+    return true;
 }
 
 static void ImGui_ImplOpenGL2_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height)

extern/imgui_patched/backends/imgui_impl_opengl2.h

@@ -24,7 +24,7 @@
 
 IMGUI_IMPL_API bool     ImGui_ImplOpenGL2_Init();
 IMGUI_IMPL_API void     ImGui_ImplOpenGL2_Shutdown();
-IMGUI_IMPL_API void     ImGui_ImplOpenGL2_NewFrame();
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL2_NewFrame();
 IMGUI_IMPL_API void     ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
 
 // Called by Init/NewFrame/Shutdown

src/gui/gui.cpp

@@ -7042,9 +7042,6 @@ bool FurnaceGUI::init() {
 
   loadUserPresets(true);
 
-  // NEW CODE - REMOVE WHEN DONE
-  newOscFragment=rend->getStupidFragment();
-
   applyUISettings();
 
   logD("building font...");

src/gui/gui.h

@@ -70,8 +70,11 @@
 
 enum FurnaceGUIRenderBackend {
   GUI_BACKEND_SDL=0,
-  GUI_BACKEND_GL,
+  GUI_BACKEND_GL3,
-  GUI_BACKEND_DX11
+  GUI_BACKEND_GL2,
+  GUI_BACKEND_GL1,
+  GUI_BACKEND_DX11,
+  GUI_BACKEND_DX9
 };
 
 #ifdef HAVE_RENDER_DX11
@@ -79,7 +82,7 @@ enum FurnaceGUIRenderBackend {
 #define GUI_BACKEND_DEFAULT_NAME "DirectX 11"
 #else
 #ifdef HAVE_RENDER_GL
-#define GUI_BACKEND_DEFAULT GUI_BACKEND_GL
+#define GUI_BACKEND_DEFAULT GUI_BACKEND_GL3
 #define GUI_BACKEND_DEFAULT_NAME "OpenGL"
 #else
 #ifdef HAVE_RENDER_SDL
@@ -1441,8 +1444,6 @@ class FurnaceGUIRender {
     virtual void drawOsc(float* data, size_t len, ImVec2 pos0, ImVec2 pos1, ImVec4 color, ImVec2 canvasSize, float lineWidth);
     virtual void present();
     virtual bool supportsDrawOsc();
-    virtual const char* getStupidFragment();
-    virtual bool regenOscShader(const char* fragment);
     virtual bool getOutputSize(int& w, int& h);
     virtual int getWindowFlags();
     virtual void setSwapInterval(int swapInterval);
@@ -1492,7 +1493,6 @@ class FurnaceGUI {
   int sampleTexW, sampleTexH;
   bool updateSampleTex;
 
-  String newOscFragment;
   String workingDir, fileName, clipboard, warnString, errorString, lastError, curFileName, nextFile, sysSearchQuery, newSongQuery, paletteQuery;
   String workingDirSong, workingDirIns, workingDirWave, workingDirSample, workingDirAudioExport;
   String workingDirVGMExport, workingDirZSMExport, workingDirROMExport, workingDirFont, workingDirColors, workingDirKeybinds;

src/gui/render.cpp

@@ -25,6 +25,9 @@
 #ifdef HAVE_RENDER_GL
 #include "render/renderGL.h"
 #endif
+#ifdef HAVE_RENDER_GL1
+#include "render/renderGL1.h"
+#endif
 #ifdef HAVE_RENDER_DX11
 #include "render/renderDX11.h"
 #endif
@@ -34,10 +37,16 @@ bool FurnaceGUI::initRender() {
 
   if (safeMode) {
     renderBackend=GUI_BACKEND_SDL;
-  } else if (settings.renderBackend=="OpenGL") {
+  } else if (settings.renderBackend=="OpenGL" || settings.renderBackend=="OpenGL 3.0" || settings.renderBackend=="OpenGL ES 2.0") {
-    renderBackend=GUI_BACKEND_GL;
+    renderBackend=GUI_BACKEND_GL3;
+  } else if (settings.renderBackend=="OpenGL 2.0") {
+    renderBackend=GUI_BACKEND_GL2;
+  } else if (settings.renderBackend=="OpenGL 1.1") {
+    renderBackend=GUI_BACKEND_GL1;
   } else if (settings.renderBackend=="DirectX 11") {
     renderBackend=GUI_BACKEND_DX11;
+  } else if (settings.renderBackend=="DirectX 9") {
+    renderBackend=GUI_BACKEND_DX9;
   } else if (settings.renderBackend=="SDL") {
     renderBackend=GUI_BACKEND_SDL;
   } else {
@@ -46,9 +55,30 @@ bool FurnaceGUI::initRender() {
   
   switch (renderBackend) {
 #ifdef HAVE_RENDER_GL
-    case GUI_BACKEND_GL:
+#ifdef USE_GLES
-      logI("render backend: OpenGL");
+    case GUI_BACKEND_GL3:
+    case GUI_BACKEND_GL2:
+      logI("render backend: OpenGL ES 2.0");
       rend=new FurnaceGUIRenderGL;
+      ((FurnaceGUIRenderGL*)rend)->setVersion(2);
+      break;
+#else
+    case GUI_BACKEND_GL3:
+      logI("render backend: OpenGL 3.0");
+      rend=new FurnaceGUIRenderGL;
+      ((FurnaceGUIRenderGL*)rend)->setVersion(3);
+      break;
+    case GUI_BACKEND_GL2:
+      logI("render backend: OpenGL 2.0");
+      rend=new FurnaceGUIRenderGL;
+      ((FurnaceGUIRenderGL*)rend)->setVersion(2);
+      break;
+#endif
+#endif
+#ifdef HAVE_RENDER_GL1
+    case GUI_BACKEND_GL1:
+      logI("render backend: OpenGL 1.1");
+      rend=new FurnaceGUIRenderGL1;
       break;
 #endif
 #ifdef HAVE_RENDER_DX11
@@ -57,6 +87,12 @@ bool FurnaceGUI::initRender() {
       rend=new FurnaceGUIRenderDX11;
       break;
 #endif
+#ifdef HAVE_RENDER_DX9
+    case GUI_BACKEND_DX9:
+      logI("render backend: DirectX 9");
+      rend=new FurnaceGUIRenderDX9;
+      break;
+#endif
 #ifdef HAVE_RENDER_SDL
     case GUI_BACKEND_SDL:
       logI("render backend: SDL_Renderer");

src/gui/render/abstract.cpp

@@ -117,13 +117,5 @@ bool FurnaceGUIRender::isDead() {
   return false;
 }
 
-const char* FurnaceGUIRender::getStupidFragment() {
-  return "Only OpenGL";
-}
-
-bool FurnaceGUIRender::regenOscShader(const char* fragment) {
-  return false;
-}
-
 FurnaceGUIRender::~FurnaceGUIRender() {
 }

src/gui/render/renderGL.cpp

@@ -133,14 +133,14 @@ const char* sh_oscRender_srcF=
   "  }\n"
   "}\n";
 #else
-const char* sh_wipe_srcV=
+const char* sh_wipe_srcV_130=
   "#version 130\n"
   "in vec4 fur_position;\n"
   "void main() {\n"
   " gl_Position=fur_position;\n"
   "}\n";
 
-const char* sh_wipe_srcF=
+const char* sh_wipe_srcF_130=
   "#version 130\n"
   "uniform float uAlpha;\n"
   "out vec4 fur_FragColor;\n"
@@ -148,6 +148,20 @@ const char* sh_wipe_srcF=
   "  fur_FragColor=vec4(0.0,0.0,0.0,uAlpha);\n"
   "}\n";
 
+const char* sh_wipe_srcV_110=
+  "#version 110\n"
+  "attribute vec4 fur_position;\n"
+  "void main() {\n"
+  " gl_Position=fur_position;\n"
+  "}\n";
+
+const char* sh_wipe_srcF_110=
+  "#version 110\n"
+  "uniform float uAlpha;\n"
+  "void main() {\n"
+  "  gl_FragColor=vec4(0.0,0.0,0.0,uAlpha);\n"
+  "}\n";
+
 const char* sh_oscRender_srcV=
   "#version 130\n"
   "in vec4 fur_position;\n"
@@ -407,6 +421,7 @@ void FurnaceGUIRenderGL::wipe(float alpha) {
 }
 
 void FurnaceGUIRenderGL::drawOsc(float* data, size_t len, ImVec2 pos0, ImVec2 pos1, ImVec4 color, ImVec2 canvasSize, float lineWidth) {
+  if (!sh_oscRender_have) return;
   if (!furUseProgram) return;
   if (!furUniform4fv) return;
   if (!furUniform1f) return;
@@ -543,20 +558,20 @@ void FurnaceGUIRenderGL::setSwapInterval(int swapInterval) {
 
 void FurnaceGUIRenderGL::preInit() {
 #if defined(USE_GLES)
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,0);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,SDL_GL_CONTEXT_PROFILE_ES);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,2);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,0);
 #elif defined(__APPLE__)
   // not recommended...
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,SDL_GL_CONTEXT_PROFILE_CORE);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,3);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,2);
 #else
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,0);
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,SDL_GL_CONTEXT_PROFILE_CORE);
-  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,3);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,glVer);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,0);
 #endif
 
@@ -628,30 +643,40 @@ bool FurnaceGUIRenderGL::init(SDL_Window* win, int swapInterval) {
 #endif
 
   // texture for osc renderer
-  C(glGenTextures(1,&oscDataTex));
+  if (glVer==3) {
+    C(glGenTextures(1,&oscDataTex));
 #ifdef USE_GLES
-  C(glBindTexture(GL_TEXTURE_2D,oscDataTex));
+    C(glBindTexture(GL_TEXTURE_2D,oscDataTex));
-  C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST));
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST));
-  C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST));
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST));
-  C(glTexImage2D(GL_TEXTURE_2D,0,GL_RED_EXT,2048,1,0,GL_RED_EXT,GL_FLOAT,NULL));
+    C(glTexImage2D(GL_TEXTURE_2D,0,GL_RED_EXT,2048,1,0,GL_RED_EXT,GL_FLOAT,NULL));
 #else
-  C(glBindTexture(GL_TEXTURE_1D,oscDataTex));
+    C(glBindTexture(GL_TEXTURE_1D,oscDataTex));
-  C(glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER,GL_NEAREST));
+    C(glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER,GL_NEAREST));
-  C(glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER,GL_NEAREST));
+    C(glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER,GL_NEAREST));
-  C(glTexImage1D(GL_TEXTURE_1D,0,GL_RED,2048,0,GL_RED,GL_FLOAT,NULL));
+    C(glTexImage1D(GL_TEXTURE_1D,0,GL_RED,2048,0,GL_RED,GL_FLOAT,NULL));
 #endif
-  C(furActiveTexture(GL_TEXTURE0));
+    C(furActiveTexture(GL_TEXTURE0));
-
-  // create shaders
-  if ((sh_wipe_have=createShader(sh_wipe_srcV,sh_wipe_srcF,sh_wipe_vertex,sh_wipe_fragment,sh_wipe_program,sh_wipe_attrib))==true) {
-    sh_wipe_uAlpha=furGetUniformLocation(sh_wipe_program,"uAlpha");
   }
 
-  if ((sh_oscRender_have=createShader(sh_oscRender_srcV,sh_oscRender_srcF,sh_oscRender_vertex,sh_oscRender_fragment,sh_oscRender_program,sh_oscRender_attrib))==true) {
+  // create shaders
-    sh_oscRender_uColor=furGetUniformLocation(sh_oscRender_program,"uColor");
+  if (glVer==3) {
-    sh_oscRender_uLineWidth=furGetUniformLocation(sh_oscRender_program,"uLineWidth");
+    if ((sh_wipe_have=createShader(sh_wipe_srcV_130,sh_wipe_srcF_130,sh_wipe_vertex,sh_wipe_fragment,sh_wipe_program,sh_wipe_attrib))==true) {
-    sh_oscRender_uResolution=furGetUniformLocation(sh_oscRender_program,"uResolution");
+      sh_wipe_uAlpha=furGetUniformLocation(sh_wipe_program,"uAlpha");
-    sh_oscRender_oscVal=furGetUniformLocation(sh_oscRender_program,"oscVal");
+    }
+
+    if ((sh_oscRender_have=createShader(sh_oscRender_srcV,sh_oscRender_srcF,sh_oscRender_vertex,sh_oscRender_fragment,sh_oscRender_program,sh_oscRender_attrib))==true) {
+      sh_oscRender_uColor=furGetUniformLocation(sh_oscRender_program,"uColor");
+      sh_oscRender_uLineWidth=furGetUniformLocation(sh_oscRender_program,"uLineWidth");
+      sh_oscRender_uResolution=furGetUniformLocation(sh_oscRender_program,"uResolution");
+      sh_oscRender_oscVal=furGetUniformLocation(sh_oscRender_program,"oscVal");
+    }
+  } else {
+    if ((sh_wipe_have=createShader(sh_wipe_srcV_110,sh_wipe_srcF_110,sh_wipe_vertex,sh_wipe_fragment,sh_wipe_program,sh_wipe_attrib))==true) {
+      sh_wipe_uAlpha=furGetUniformLocation(sh_wipe_program,"uAlpha");
+    }
+
+    sh_oscRender_have=false;
   }
 
   C(furGenBuffers(1,&quadBuf));
@@ -659,28 +684,6 @@ bool FurnaceGUIRenderGL::init(SDL_Window* win, int swapInterval) {
   return true;
 }
 
-const char* FurnaceGUIRenderGL::getStupidFragment() {
-  return sh_oscRender_srcF;
-}
-
-bool FurnaceGUIRenderGL::regenOscShader(const char* fragment) {
-  if (sh_oscRender_have) {
-    furDeleteProgram(sh_oscRender_program);
-    furDeleteShader(sh_oscRender_vertex);
-    furDeleteShader(sh_oscRender_fragment);
-  }
-  
-  if ((sh_oscRender_have=createShader(sh_oscRender_srcV,fragment,sh_oscRender_vertex,sh_oscRender_fragment,sh_oscRender_program,sh_oscRender_attrib))==true) {
-    sh_oscRender_uColor=furGetUniformLocation(sh_oscRender_program,"uColor");
-    sh_oscRender_uLineWidth=furGetUniformLocation(sh_oscRender_program,"uLineWidth");
-    sh_oscRender_uResolution=furGetUniformLocation(sh_oscRender_program,"uResolution");
-    sh_oscRender_oscVal=furGetUniformLocation(sh_oscRender_program,"oscVal");
-    return true;
-  }
-
-  return false;
-}
-
 void FurnaceGUIRenderGL::initGUI(SDL_Window* win) {
   ImGui_ImplSDL2_InitForOpenGL(win,context);
   ImGui_ImplOpenGL3_Init();
@@ -706,3 +709,7 @@ bool FurnaceGUIRenderGL::isDead() {
    return false;
 #endif
 }
+
+void FurnaceGUIRenderGL::setVersion(unsigned char ver) {
+  glVer=ver;
+}

src/gui/render/renderGL.h

@@ -47,6 +47,7 @@ class FurnaceGUIRenderGL: public FurnaceGUIRender {
   bool sh_oscRender_have;
 
   bool swapIntervalSet;
+  unsigned char glVer;
 
   bool createShader(const char* vertexS, const char* fragmentS, int& vertex, int& fragment, int& program, const char** attribNames);
 
@@ -59,8 +60,6 @@ class FurnaceGUIRenderGL: public FurnaceGUIRender {
     bool destroyTexture(FurnaceGUITexture* which);
     void setTextureBlendMode(FurnaceGUITexture* which, FurnaceGUIBlendMode mode);
     void setBlendMode(FurnaceGUIBlendMode mode);
-    const char* getStupidFragment();
-    bool regenOscShader(const char* fragment);
     void clear(ImVec4 color);
     bool newFrame();
     bool canVSync();
@@ -80,6 +79,7 @@ class FurnaceGUIRenderGL: public FurnaceGUIRender {
     void quitGUI();
     bool quit();
     bool isDead();
+    void setVersion(unsigned char ver);
     FurnaceGUIRenderGL():
       context(NULL),
       sdlWin(NULL),

src/gui/render/renderGL1.cpp

@@ -0,0 +1,276 @@
+/**
+ * Furnace Tracker - multi-system chiptune tracker
+ * Copyright (C) 2021-2024 tildearrow and contributors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "renderGL1.h"
+#include "../../ta-log.h"
+#include "SDL_opengl.h"
+#include "backends/imgui_impl_opengl2.h"
+#include "../engine/bsr.h"
+
+#define C(x) x; if (glGetError()!=GL_NO_ERROR) logW("OpenGL error in %s:%d: " #x,__FILE__,__LINE__);
+
+class FurnaceGL1Texture: public FurnaceGUITexture {
+  public:
+  GLuint id;
+  int width, height, widthReal, heightReal;
+  unsigned char* lockedData;
+  FurnaceGL1Texture():
+    id(0),
+    width(0),
+    height(0),
+    widthReal(0),
+    heightReal(0),
+    lockedData(NULL) {}
+};
+
+ImTextureID FurnaceGUIRenderGL1::getTextureID(FurnaceGUITexture* which) {
+  intptr_t ret=((FurnaceGL1Texture*)which)->id;
+  return (ImTextureID)ret;
+}
+
+bool FurnaceGUIRenderGL1::lockTexture(FurnaceGUITexture* which, void** data, int* pitch) {
+  FurnaceGL1Texture* t=(FurnaceGL1Texture*)which;
+  if (t->lockedData!=NULL) return false;
+  t->lockedData=new unsigned char[t->width*t->height*4];
+
+  *data=t->lockedData;
+  *pitch=t->width*4;
+  return true;
+}
+
+bool FurnaceGUIRenderGL1::unlockTexture(FurnaceGUITexture* which) {
+  FurnaceGL1Texture* t=(FurnaceGL1Texture*)which;
+  if (t->lockedData==NULL) return false;
+
+  C(glBindTexture(GL_TEXTURE_2D,t->id));
+  C(glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,t->width,t->height,0,GL_RGBA,GL_RGBA,t->lockedData));
+  
+  C(glFlush());
+  delete[] t->lockedData;
+  t->lockedData=NULL;
+
+  return true;
+}
+
+bool FurnaceGUIRenderGL1::updateTexture(FurnaceGUITexture* which, void* data, int pitch) {
+  FurnaceGL1Texture* t=(FurnaceGL1Texture*)which;
+
+  if (t->width*4!=pitch) return false;
+
+  C(glBindTexture(GL_TEXTURE_2D,t->id));
+  C(glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,t->width,t->height,0,GL_RGBA,GL_RGBA,data));
+  return true;
+}
+
+FurnaceGUITexture* FurnaceGUIRenderGL1::createTexture(bool dynamic, int width, int height, bool interpolate) {
+  FurnaceGL1Texture* t=new FurnaceGL1Texture;
+  C(glGenTextures(1,&t->id));
+  C(glBindTexture(GL_TEXTURE_2D,t->id));
+  if (interpolate) {
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR));
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR));
+  } else {
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST));
+    C(glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST));
+  }
+
+  int widthReal=width;
+  int heightReal=height;
+
+  if ((widthReal&(widthReal-1))!=0) {
+    widthReal=1<<bsr(width);
+  }
+  if ((heightReal&(heightReal-1))!=0) {
+    heightReal=1<<bsr(height);
+  }
+  logV("width: %d (requested)... %d (actual)",width,widthReal);
+  logV("height: %d (requested)... %d (actual)",height,heightReal);
+
+  C(glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,widthReal,heightReal,0,GL_RGBA,GL_RGBA,NULL));
+  t->width=width;
+  t->height=height;
+  t->widthReal=widthReal;
+  t->heightReal=heightReal;
+  return t;
+}
+
+bool FurnaceGUIRenderGL1::destroyTexture(FurnaceGUITexture* which) {
+  FurnaceGL1Texture* t=(FurnaceGL1Texture*)which;
+  C(glDeleteTextures(1,&t->id));
+  delete t;
+  return true;
+}
+
+void FurnaceGUIRenderGL1::setTextureBlendMode(FurnaceGUITexture* which, FurnaceGUIBlendMode mode) {
+}
+
+void FurnaceGUIRenderGL1::setBlendMode(FurnaceGUIBlendMode mode) {
+  switch (mode) {
+    case GUI_BLEND_MODE_NONE:
+      C(glBlendFunc(GL_ONE,GL_ZERO));
+      C(glDisable(GL_BLEND));
+      break;
+    case GUI_BLEND_MODE_BLEND:
+      C(glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA));
+      C(glEnable(GL_BLEND));
+      break;
+    case GUI_BLEND_MODE_ADD:
+      C(glBlendFunc(GL_SRC_ALPHA,GL_ONE));
+      C(glEnable(GL_BLEND));
+      break;
+    case GUI_BLEND_MODE_MULTIPLY:
+      C(glBlendFunc(GL_ZERO,GL_SRC_COLOR));
+      C(glEnable(GL_BLEND));
+      break;
+  }
+}
+
+void FurnaceGUIRenderGL1::clear(ImVec4 color) {
+  SDL_GL_MakeCurrent(sdlWin,context);
+  C(glClearColor(color.x,color.y,color.z,color.w));
+  C(glClear(GL_COLOR_BUFFER_BIT));
+}
+
+bool FurnaceGUIRenderGL1::newFrame() {
+  return ImGui_ImplOpenGL2_NewFrame();
+}
+
+bool FurnaceGUIRenderGL1::canVSync() {
+  return swapIntervalSet;
+}
+
+void FurnaceGUIRenderGL1::createFontsTexture() {
+  ImGui_ImplOpenGL2_CreateFontsTexture();
+}
+
+void FurnaceGUIRenderGL1::destroyFontsTexture() {
+  ImGui_ImplOpenGL2_DestroyFontsTexture();
+}
+
+void FurnaceGUIRenderGL1::renderGUI() {
+  ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
+}
+
+void FurnaceGUIRenderGL1::wipe(float alpha) {
+  C(glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA));
+  C(glEnable(GL_BLEND));
+
+  C(glBindTexture(GL_TEXTURE_2D,0));
+  C(glBegin(GL_TRIANGLE_STRIP));
+  C(glColor4f(0.0,0.0,0.0,alpha));
+  C(glNormal3f(0.0f,0.0f,0.0f));
+  C(glVertex3f(-1.0f,-1.0f,0.0f));
+  C(glNormal3f(1.0f,0.0f,0.0f));
+  C(glVertex3f(1.0f,-1.0f,0.0f));
+  C(glNormal3f(0.0f,1.0f,0.0f));
+  C(glVertex3f(-1.0f,1.0f,0.0f));
+  C(glNormal3f(1.0f,1.0f,0.0f));
+  C(glVertex3f(1.0f,1.0f,0.0f));
+  C(glEnd());
+}
+
+void FurnaceGUIRenderGL1::present() {
+  SDL_GL_SwapWindow(sdlWin);
+  C(glFlush());
+}
+
+bool FurnaceGUIRenderGL1::getOutputSize(int& w, int& h) {
+  SDL_GL_GetDrawableSize(sdlWin,&w,&h);
+  return true;
+}
+
+int FurnaceGUIRenderGL1::getWindowFlags() {
+  return SDL_WINDOW_OPENGL;
+}
+
+void FurnaceGUIRenderGL1::setSwapInterval(int swapInterval) {
+  SDL_GL_SetSwapInterval(swapInterval);
+  if (swapInterval>0 && SDL_GL_GetSwapInterval()==0) {
+    swapIntervalSet=false;
+    logW("tried to enable VSync but couldn't!");
+  } else {
+    swapIntervalSet=true;
+  }
+}
+
+void FurnaceGUIRenderGL1::preInit() {
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,0);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,0);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,1);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,1);
+
+  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,0);
+  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
+  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,24);
+}
+
+#define LOAD_PROC_MANDATORY(_v,_t,_s) \
+  _v=(_t)SDL_GL_GetProcAddress(_s); \
+  if (!_v) { \
+    logE(_s " not found"); \
+    return false; \
+  }
+
+#define LOAD_PROC_OPTIONAL(_v,_t,_s) \
+  _v=(_t)SDL_GL_GetProcAddress(_s); \
+  if (!_v) { \
+    logW(_s " not found"); \
+  }
+
+bool FurnaceGUIRenderGL1::init(SDL_Window* win, int swapInterval) {
+  sdlWin=win;
+  context=SDL_GL_CreateContext(win);
+  if (context==NULL) {
+    return false;
+  }
+  SDL_GL_MakeCurrent(win,context);
+  SDL_GL_SetSwapInterval(swapInterval);
+  if (swapInterval>0 && SDL_GL_GetSwapInterval()==0) {
+    swapIntervalSet=false;
+    logW("tried to enable VSync but couldn't!");
+  } else {
+    swapIntervalSet=true;
+  }
+
+  return true;
+}
+
+void FurnaceGUIRenderGL1::initGUI(SDL_Window* win) {
+  ImGui_ImplSDL2_InitForOpenGL(win,context);
+  ImGui_ImplOpenGL2_Init();
+}
+
+bool FurnaceGUIRenderGL1::quit() {
+  if (context==NULL) return false;
+  SDL_GL_DeleteContext(context);
+  context=NULL;
+  return true;
+}
+
+void FurnaceGUIRenderGL1::quitGUI() { 
+  ImGui_ImplOpenGL2_Shutdown();
+}
+
+// sadly, OpenGL 1.1 doesn't have the ability to recover from death...
+bool FurnaceGUIRenderGL1::isDead() {
+   return false;
+}

src/gui/render/renderGL1.h

@@ -0,0 +1,60 @@
+/**
+ * Furnace Tracker - multi-system chiptune tracker
+ * Copyright (C) 2021-2024 tildearrow and contributors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "../gui.h"
+
+class FurnaceGUIRenderGL1: public FurnaceGUIRender {
+  SDL_GLContext context;
+  SDL_Window* sdlWin;
+
+  bool swapIntervalSet;
+  unsigned char glVer;
+
+  public:
+    ImTextureID getTextureID(FurnaceGUITexture* which);
+    bool lockTexture(FurnaceGUITexture* which, void** data, int* pitch);
+    bool unlockTexture(FurnaceGUITexture* which);
+    bool updateTexture(FurnaceGUITexture* which, void* data, int pitch);
+    FurnaceGUITexture* createTexture(bool dynamic, int width, int height, bool interpolate=true);
+    bool destroyTexture(FurnaceGUITexture* which);
+    void setTextureBlendMode(FurnaceGUITexture* which, FurnaceGUIBlendMode mode);
+    void setBlendMode(FurnaceGUIBlendMode mode);
+    void clear(ImVec4 color);
+    bool newFrame();
+    bool canVSync();
+    void createFontsTexture();
+    void destroyFontsTexture();
+    void renderGUI();
+    void wipe(float alpha);
+    void present();
+    bool getOutputSize(int& w, int& h);
+    int getWindowFlags();
+    void setSwapInterval(int swapInterval);
+    void preInit();
+    bool init(SDL_Window* win, int swapInterval);
+    void initGUI(SDL_Window* win);
+    void quitGUI();
+    bool quit();
+    bool isDead();
+    FurnaceGUIRenderGL1():
+      context(NULL),
+      sdlWin(NULL),
+      swapIntervalSet(true) {
+    }
+};

src/gui/settings.cpp

@@ -406,8 +406,21 @@ void FurnaceGUI::drawSettings() {
           }
 #endif
 #ifdef HAVE_RENDER_GL
-          if (ImGui::Selectable("OpenGL",curRenderBackend=="OpenGL")) {
+#ifdef USE_GLES
-            settings.renderBackend="OpenGL";
+#else
+          if (ImGui::Selectable("OpenGL 3.0",curRenderBackend=="OpenGL 3.0")) {
+            settings.renderBackend="OpenGL 3.0";
+            settingsChanged=true;
+          }
+          if (ImGui::Selectable("OpenGL 2.0",curRenderBackend=="OpenGL 2.0")) {
+            settings.renderBackend="OpenGL 2.0";
+            settingsChanged=true;
+          }
+#endif
+#endif
+#ifdef HAVE_RENDER_GL1
+          if (ImGui::Selectable("OpenGL 1.1",curRenderBackend=="OpenGL 1.1")) {
+            settings.renderBackend="OpenGL 1.1";
             settingsChanged=true;
           }
 #endif