build: Bumped version to 1.19.1

This is a (hopefully temporary) hack. Fixes #568

.clang-format

@@ -0,0 +1,178 @@
+---
+Language: Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: false
+AlignArrayOfStructures: Left
+AlignConsecutiveMacros: Consecutive
+AlignConsecutiveAssignments: Consecutive
+AlignConsecutiveBitFields: AcrossEmptyLinesAndComments
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  BeforeLambdaBody: false
+  BeforeWhile: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: false
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: AfterComma
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 0
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: false
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: true
+FixNamespaceComments: false
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority: 2
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '^(<|"(gtest|gmock|isl|json)/)'
+    Priority: 3
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '.*'
+    Priority: 1
+    SortPriority: 0
+    CaseSensitive: false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentCaseBlocks: true
+IndentGotoLabels: true
+IndentPPDirectives: BeforeHash
+IndentExternBlock: Indent
+IndentRequires: false
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 4
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+PPIndentWidth: 4
+ReferenceAlignment: Pointer
+ReflowComments: true
+ShortNamespaceLines: 5
+SortIncludes: Never
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 4
+SpacesInAngles: Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum: 1
+  Maximum: -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard: Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth: 4
+UseCRLF: false
+UseTab: Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+

.gitattributes

@@ -0,0 +1,3 @@
+lib/external/** linguist-vendored
+lib/libimhex-rs/imgui-rs/** linguist-vendored
+lib/libimhex-rs/imgui-sys/** linguist-vendored

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,49 @@
+name: Bug Report
+description: Something doesn't work correctly in ImHex.
+title: "[Bug] "
+body:
+- type: dropdown
+  id: os
+  attributes:
+    label: Operating System
+    description: What Operating System are you using ImHex on?
+    options:
+      - Windows
+      - Linux
+      - MacOS
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: What's the issue you encountered?
+    description: |
+      Describe the issue in detail and what you were doing beforehand.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: How can the issue be reproduced?
+    description: Include a detailed step by step process for recreating your issue.
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: ImHex Version
+    description: |
+      The version of ImHex you've been using when encountering the bug. If using a nightly, please add the commit hash as well
+    placeholder: X.X.X
+  validations:
+    required: true
+- type: checkboxes
+  attributes:
+    label: ImHex Build Type
+    options:
+    - label: Nightly or built from sources
+- type: textarea
+  attributes:
+    label: Additional context?
+    value: |
+      - Additional information about your environment.
+      - If possible and useful, please upload the binary you've been editing when the bug occured.
+  validations:
+    required: false

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -0,0 +1,22 @@
+name: Feature Request
+description: Something you'd like to see added to ImHex in the future
+title: "[Feature] "
+body:
+- type: textarea
+  attributes:
+    label: What feature would you like to see?
+    description: |
+      Describe in detail what the feature should do and how it should work.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: How will this feature be useful to you and others?
+    description: Describe how everybody will benefit from this feature if it gets added.
+  validations:
+    required: true
+- type: checkboxes
+  attributes:
+    label: Request Type
+    options:
+      - label: I can provide a PoC for this feature or am willing to work on it myself and submit a PR

.github/workflows/analysis.yml

@@ -0,0 +1,63 @@
+name: "CodeQL"
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch:
+
+jobs:
+  codeql:
+    name: 🐛 CodeQL
+    runs-on: ubuntu-22.04
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: 🧰 Checkout
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+
+    - name: ✋ Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: 'cpp'
+
+    - name: 📜 Restore ccache
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cache/ccache
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+      
+    - name: 📜 Restore CMakeCache
+      uses: actions/cache@v3
+      with:
+        path: |
+          build/CMakeCache.txt
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+      
+    - name: ⬇️ Install dependencies
+      run: |
+        sudo apt update
+        sudo bash dist/get_deps_debian.sh
+
+    - name: 🛠️ Build
+      run: |
+        mkdir -p build
+        cd build
+        CC=gcc-12 CXX=g++-12 cmake              \
+          -DCMAKE_BUILD_TYPE=$BUILD_TYPE        \
+          -DCMAKE_INSTALL_PREFIX="$PWD/install" \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache    \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache  \
+          -DCMAKE_C_FLAGS="-fuse-ld=lld"        \
+          -DCMAKE_CXX_FLAGS="-fuse-ld=lld"      \
+          ..
+        make -j 4 install
+
+    - name: 🗯️ Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/build.yml

@@ -2,171 +2,373 @@ name: Build
 
 on:
   push:
+    branches: ["*"]
   pull_request:
+  workflow_dispatch:
 
 env:
   BUILD_TYPE: Release
 
 jobs:
 
-  linux:
-    runs-on: ubuntu-20.04
-    name: 🐧 Ubuntu 20.04
-    steps:
-
-    - name: 🧰 Checkout
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-
-    - name: ⬇️ Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y \
-          build-essential       \
-          gcc-10                \
-          g++-10                \
-          pkg-config            \
-          cmake                 \
-          make                  \
-          libglfw3-dev          \
-          libglm-dev            \
-          libmagic-dev          \
-          libmbedtls-dev        \
-          libcapstone-dev       \
-          python3-dev           \
-          libfreetype-dev       \
-
-    - name: ✋ Build
-      run: |
-        # Get path to magic db
-        MAGICDB_PATH=$(file --version | grep -oP "(?<=magic file from ).+")
-
-        mkdir build
-        cd build
-        CC=gcc-10 CXX=g++-10 cmake \
-          -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-          -DCMAKE_INSTALL_PREFIX="$PWD/install" \
-          -DEXTRA_MAGICDBS="$MAGICDB_PATH" \
-          ..
-        make -j 4 install
-
-    - name: 📦 Upload ELF
-      uses: actions/upload-artifact@v2
-      with:
-        name: Linux ELF
-        path: |
-          build/install/*
-
+  # Windows build
   win:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { msystem: MINGW64, arch: x86_64 }
-          #- { msystem: MINGW32, arch: i686   } # currently fail
-    name: 🟦 ${{ matrix.msystem }} · ${{ matrix.arch }}
+    runs-on: windows-2022
+    name: 🪟 Windows MINGW64
     defaults:
       run:
         shell: msys2 {0}
     env:
-      MINGW_INSTALLS: ${{ matrix.msystem }}
+      CCACHE_DIR:      "${{ github.workspace }}/.ccache"
+      CCACHE_MAXSIZE:  "1000M"
+      CCACHE_COMPRESS: "true"
     steps:
-
     - name: 🧰 Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
-        fetch-depth: 0
+        submodules: recursive
 
-    - name: ⬇️ Install dependencies
+    - name: 📜 Prepare Cache
+      id:    prep-ccache
+      shell: bash
+      run: |
+        mkdir -p "${CCACHE_DIR}"
+        echo "::set-output name=dir::$CCACHE_DIR"
+
+    - name: 📜 Restore ccache
+      uses:  actions/cache@v3
+      id:    cache-ccache
+      with:
+        path: |
+          ${{ steps.prep-ccache.outputs.dir }}
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+
+    - name: 📜 Restore CMakeCache
+      uses:  actions/cache@v3
+      with:
+        path: |
+          build/CMakeCache.txt
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+
+    - name: 🟦 Install msys2
       uses: msys2/setup-msys2@v2
       with:
-        msystem: ${{ matrix.msystem }}
-        update: true
-        install: >
-          mingw-w64-${{ matrix.arch }}-gcc
-          mingw-w64-${{ matrix.arch }}-cmake
-          mingw-w64-${{ matrix.arch }}-make
-          mingw-w64-${{ matrix.arch }}-capstone
-          mingw-w64-${{ matrix.arch }}-glfw
-          mingw-w64-${{ matrix.arch }}-glm
-          mingw-w64-${{ matrix.arch }}-file
-          mingw-w64-${{ matrix.arch }}-mbedtls
-          mingw-w64-${{ matrix.arch }}-polly
-          mingw-w64-${{ matrix.arch }}-python
-          mingw-w64-${{ matrix.arch }}-dlfcn
-          mingw-w64-${{ matrix.arch }}-freetype
+        msystem: mingw64
+        pacboy: >-
+          gcc:p
+          lld:p
+          cmake:p
+          make:p
+          ccache:p
+          glfw:p
+          file:p
+          mbedtls:p
+          python:p
+          freetype:p
+          dlfcn:p
 
-    - name: ✋ Build
+    - name: ⬇️ Install dependencies
       run: |
-        mkdir build
+        curl --proto '=https' --tlsv1.2 -sSf https://win.rustup.rs > rustup-init.exe
+        ./rustup-init.exe -y --default-host=x86_64-pc-windows-gnu --default-toolchain=none
+        rm rustup-init.exe
+        $USERPROFILE/.cargo/bin/rustup.exe target add x86_64-pc-windows-gnu
+        $USERPROFILE/.cargo/bin/rustup.exe default nightly
+
+    - name: 🛠️ Build
+      run: |
+        mkdir -p build
         cd build
         # Get path to mingw python library
-        PYTHON_LIB_NAME=$(pkg-config --libs-only-l python3 | sed 's/^-l//')
+        PYTHON_LIB_NAME=$(pkg-config --libs-only-l python3 | sed 's/^-l//' | sed 's/ //')
         PYTHON_LIB_PATH=$(cygpath -m $(which lib${PYTHON_LIB_NAME}.dll))
 
-        # Get path to magic db
-        MAGICDB_PATH=$(cygpath -m $(file --version | grep -oP "(?<=magic file from ).+"))
-
-        echo Python_LIBRARY: $PYTHON_LIB_PATH
-        echo MagicDB Path: $MAGICDB_PATH
-
-        cmake -G "MinGW Makefiles" \
-          -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-          -DCMAKE_INSTALL_PREFIX="$PWD/install" \
-          -DCREATE_PACKAGE=ON \
-          -DPython_LIBRARY="$PYTHON_LIB_PATH" \
-          -DEXTRA_MAGICDBS="$MAGICDB_PATH" \
+        cmake -G "MinGW Makefiles"                \
+          -DCMAKE_BUILD_TYPE=$BUILD_TYPE          \
+          -DCMAKE_INSTALL_PREFIX="$PWD/install"   \
+          -DCREATE_PACKAGE=ON                     \
+          -DPython_LIBRARY="$PYTHON_LIB_PATH"     \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache      \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache    \
+          -DCMAKE_C_FLAGS="-fuse-ld=lld"          \
+          -DCMAKE_CXX_FLAGS="-fuse-ld=lld"        \
+          -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache   \
+          -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
+          -DRUST_PATH="$USERPROFILE/.cargo/bin/"  \
           ..
-        mingw32-make -j4
-        mingw32-make install
+        mingw32-make -j4 install
         cpack
 
-    - name: 📦 Upload Portable ZIP
-      uses: actions/upload-artifact@v2
+    - name: ⬆️ Upload Portable ZIP
+      uses: actions/upload-artifact@v3
       with:
-        name: Windows Portable ZIP
+        name: Windows Portable
         path: |
           build/install/*
 
-    - name: 📦 Upload Windows Installer
-      uses: actions/upload-artifact@v2
+    - name: ⬆️ Upload Windows Installer
+      uses: actions/upload-artifact@v3
       with:
         name: Windows Installer
         path: |
           build/*.msi
 
-  macos-build:
-    runs-on: macos-11.0
+  # MacOS build
+  macos:
+    runs-on: macos-11
     name: 🍎 macOS 11.0
     steps:
 
     - name: 🧰 Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
-        fetch-depth: 0
+        submodules: recursive
+        
+    - name: 📜 Restore ccache
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/Library/Caches/ccache
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+
+        
+    - name: 📜 Restore CMakeCache
+      uses: actions/cache@v3
+      with:
+        path: |
+          build/CMakeCache.txt
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
 
     - name: ⬇️ Install dependencies
       run: |
         brew bundle --no-lock --file dist/Brewfile
 
-    - name: ✋ Build
+    - name: 🛠️ Build
       run: |
-        mkdir build
+        mkdir -p build
         cd build
-        CC=$(brew --prefix llvm)/bin/clang \
-        CXX=$(brew --prefix llvm)/bin/clang++ \
+        CC=$(brew --prefix gcc@12)/bin/gcc-12     \
+        CXX=$(brew --prefix gcc@12)/bin/g++-12    \
+        OBJC=$(brew --prefix llvm)/bin/clang      \
+        OBJCXX=$(brew --prefix llvm)/bin/clang++  \
         PKG_CONFIG_PATH="$(brew --prefix openssl)/lib/pkgconfig":"$(brew --prefix)/lib/pkgconfig" \
-        cmake \
-          -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-          -DCREATE_BUNDLE=ON \
-          -DCREATE_PACKAGE=ON \
+        MACOSX_DEPLOYMENT_TARGET="10.15"          \
+        cmake                                     \
+          -DCMAKE_BUILD_TYPE=$BUILD_TYPE          \
+          -DCREATE_BUNDLE=ON                      \
+          -DCREATE_PACKAGE=ON                     \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache      \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache    \
+          -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache   \
+          -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
           ..
-        make -j 4 package
+        make -j4 package
 
-    - name: 📦 Upload DMG
-      uses: actions/upload-artifact@v2
+    - name: ⬆️ Upload DMG
+      uses: actions/upload-artifact@v3
       with:
         name: macOS DMG
         path: build/*.dmg
+
+  # Linux build
+  linux:
+    runs-on: ubuntu-22.04
+    name: 🐧 Ubuntu 22.04
+    steps:
+
+      - name: 🧰 Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: 📜 Restore cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/ccache
+          key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+          restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+          
+      - name: 📜 Restore other caches
+        uses: actions/cache@v3
+        with:
+          path: |
+            build/CMakeCache.txt
+            .flatpak-builder
+          key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+          
+      - name: ⬇️ Install dependencies
+        run: |
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf "/usr/local/share/boost"
+          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
+
+          sudo apt update
+          sudo bash dist/get_deps_debian.sh
+          
+          sudo apt install -y python3-pip python3-setuptools patchelf desktop-file-utils libgdk-pixbuf2.0-dev fakeroot strace fuse
+          sudo wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O /usr/local/bin/appimagetool
+          sudo chmod +x /usr/local/bin/appimagetool
+          sudo pip3 install appimage-builder==1.0.0
+
+          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup-init.sh
+          sh rustup-init.sh -y --default-toolchain none
+          rm rustup-init.sh
+          $HOME/.cargo/bin/rustup install nightly
+          $HOME/.cargo/bin/rustup target add x86_64-unknown-linux-gnu
+          $HOME/.cargo/bin/rustup default nightly
+
+      - name: 🛠️ Build
+        run: |
+          mkdir -p build
+          cd build
+          CC=gcc-12 CXX=g++-12 cmake                  \
+            -DCMAKE_BUILD_TYPE=$BUILD_TYPE            \
+            -DCMAKE_INSTALL_PREFIX="/usr" 	      \
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache        \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache      \
+            -DCMAKE_C_FLAGS="-fuse-ld=lld"            \
+            -DCMAKE_CXX_FLAGS="-fuse-ld=lld"          \
+            -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache   \
+            -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
+            -DRUST_PATH="$HOME/.cargo/bin/"           \
+            ..
+          make -j 4 install DESTDIR=AppDir
+
+      - name: 📜 Set version variable
+        run: |
+          echo "version=`cat VERSION`" >> $GITHUB_ENV
+
+      #- name: 📦 Bundle Flatpak
+      #  run: |
+      #    sudo apt install flatpak flatpak-builder
+      #    flatpak --user remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+      #    flatpak --user install -y flathub org.freedesktop.Platform//20.08
+      #    flatpak --user install -y flathub org.freedesktop.Sdk//20.08
+      #    flatpak-builder --jobs=4 --repo=imhex _flatpak dist/net.werwolv.ImHex.yaml --ccache --keep-build-dirs
+      #    flatpak build-bundle imhex imhex.flatpak net.werwolv.ImHex stable
+
+      - name: 📦 Bundle DEB
+        run: |
+          cp -r build/DEBIAN build/AppDir
+          dpkg-deb --build build/AppDir
+          mv build/AppDir.deb imhex-${{env.version}}.deb
+          rm -rf build/AppDir/DEBIAN
+
+      - name: 📦 Bundle AppImage
+        run: |
+          cd build
+          appimage-builder --recipe ../dist/AppImageBuilder.yml
+          mv ImHex-AppImage-x86_64.AppImage ../imhex-${{env.version}}.AppImage
+          cd ..
+
+      #- name: ⬆️ Upload Flatpak
+      #  uses: actions/upload-artifact@v3
+      #  with:
+      #    name: Linux Flatpak
+      #    path: |
+      #      imhex.flatpak
+
+      - name: ⬆️ Upload DEB
+        uses: actions/upload-artifact@v3
+        with:
+          name: Linux DEB (Ubuntu 22.04)
+          path: '*.deb'
+
+      - name: ⬆️ Upload AppImage
+        uses: actions/upload-artifact@v3
+        with:
+          name: Linux AppImage
+          path: '*.AppImage'
+
+  archlinux-build:
+    name: 🐧 ArchLinux
+    runs-on: ubuntu-latest
+    
+    container:
+      image: archlinux:base-devel
+
+    steps:
+      - name: ⬇️ Update all packages
+        run: |
+          pacman -Syyu --noconfirm
+
+      - name: ⬇️ Install setup dependencies
+        run: |
+          pacman -Syu git ccache --noconfirm
+          
+      - name: 🧰 Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: ⬇️ Install ImHex dependencies
+        run: |
+          dist/get_deps_archlinux.sh --noconfirm
+
+      - name: 📜 Restore ccache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/ccache
+          key: archlinux-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+          restore-keys: archlinux-${{ secrets.CACHE_VERSION }}-build
+        
+      - name: 📜 Restore CMakeCache
+        uses: actions/cache@v3
+        with:
+          path: |
+            build/CMakeCache.txt
+          key: archlinux-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+      
+      - name: 🛠️ Build
+        run: |
+          mkdir -p build
+          cd build
+          CC=gcc CXX=g++ cmake                  \
+          -DCMAKE_BUILD_TYPE=$BUILD_TYPE            \
+          -DCMAKE_INSTALL_PREFIX="/usr" 	      \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache        \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache      \
+          -DCMAKE_C_FLAGS="-fuse-ld=lld"            \
+          -DCMAKE_CXX_FLAGS="-fuse-ld=lld"          \
+          -DRUST_PATH="$HOME/.cargo/bin/"           \
+          ..
+          make -j 4 install DESTDIR=installDir
+
+      - name: 📜 Set version variable
+        run: |
+          echo "version=`cat VERSION`" >> $GITHUB_ENV
+      
+      - name: ✒️ Prepare PKGBUILD
+        run: |
+          cp dist/Arch/PKGBUILD build
+          sed -i 's/%version%/${{env.version}}/g' build/PKGBUILD
+
+    # makepkg doesn't want to run as root, so I had to chmod 777 all over
+      - name: 📦 Package ArchLinux .pkg.tar.zst
+        run: |
+          cd build
+          
+          # the name is a small trick to make makepkg recognize it as the source
+          # else, it would try to download the file from the release
+          tar -cvf imhex-${{env.version}}-ArchLinux.pkg.tar.zst -C installDir .
+          
+          chmod -R 777 .
+          
+          sudo -u nobody makepkg
+
+          # Remplace the old file
+          rm imhex-${{env.version}}-ArchLinux.pkg.tar.zst
+          mv *.pkg.tar.zst imhex-${{env.version}}-ArchLinux.pkg.tar.zst
+      
+      - name: ⬆️ Upload imhex-archlinux.pkg.tar.zst
+        uses: actions/upload-artifact@v3
+        with:
+          name: ArchLinux .pkg.tar.zst
+          path: |
+            build/imhex-${{env.version}}-ArchLinux.pkg.tar.zst
+            

.github/workflows/release.yml

@@ -0,0 +1,92 @@
+permissions:
+  contents: write
+
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    name: Release
+
+    steps:
+      - name: 🧰 Checkout
+        uses: actions/checkout@v3
+        with:
+          path: ImHex
+          submodules: recursive
+
+      - name: 📜 Verify version and set version variable
+        run: |
+          project_version=`cat ImHex/VERSION`
+          tag_version="${{github.event.release.tag_name}}"
+          tag_version="${tag_version:1}"
+          if [ "$project_version" != "$tag_version" ]; then
+            echo "::warning::$project_version and $tag_version are not the same ! Refusing to populate release"
+            exit 1
+          fi
+
+          echo "version=$project_version" >> $GITHUB_ENV
+
+      - name: 🗜️ Create tarball from sources with dependencies
+        run: tar --exclude-vcs -czvf Full.Sources.tar.gz ImHex
+        
+      - name: ⬇️ Download artifacts from latest workflow
+        uses: dawidd6/action-download-artifact@v2
+        with:
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          workflow: build.yml
+          branch: ${{ github.event.release.target_commitish }}
+          workflow_conclusion: success
+          skip_unpack: true
+             
+      - name: 🗜️ Unzip files when needed
+        run: |	
+          for zipfile in ./*.zip
+          do
+              if [ `zipinfo -1 "$zipfile" | wc -l` -eq 1 ];
+              then
+                echo "unzipping $zipfile"
+                unzip "$zipfile"
+                rm "$zipfile"
+              else
+                echo "keeping $zipfile zipped"
+              fi
+          done
+
+      - name: 🟩 Rename Windows Portable Zip
+        run: mv "Windows Portable.zip" imhex-${{env.version}}-Windows-Portable.zip
+
+      - name: ⬆️ Upload everything to release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: '*'
+
+      - name: ✒️ Prepare PKGBUILD
+        run: |
+          cp ImHex/dist/Arch/PKGBUILD .
+          
+          hash=`md5sum imhex-${{env.version}}-ArchLinux.pkg.tar.zst | cut -d ' ' -f 1`
+
+          sed -i 's/%version%/${{env.version}}/g' PKGBUILD
+          sed -i "s/(SKIP)/($hash)/g" PKGBUILD
+
+      - name: ⬆️ Publish AUR package
+        
+        # I couldn't make the condition in the env directly for some reason
+        env:
+          MY_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+        if: "${{ env.MY_KEY != '' }}"
+
+        uses: KSXGitHub/github-actions-deploy-aur@v2
+        with:
+          pkgname: imhex-bin
+          pkgbuild: ./PKGBUILD
+          commit_username: iTrooz
+          commit_email: itrooz@protonmail.com
+          ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          commit_message: Bump to version ${{env.version}}
+          ssh_keyscan_types: rsa,dsa,ecdsa,ed25519

.github/workflows/tests.yml

@@ -0,0 +1,63 @@
+name: "Unit Tests"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  tests:
+    name: 🧪 Unit Tests
+    runs-on: ubuntu-22.04
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: 🧰 Checkout
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+
+    - name: 📜 Restore ccache
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cache/ccache
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+        
+
+    - name: 📜 Restore CMakeCache
+      uses: actions/cache@v3
+      with:
+        path: |
+          build/CMakeCache.txt
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+        
+    - name: ⬇️ Install dependencies
+      run: |
+        sudo apt update
+        sudo bash dist/get_deps_debian.sh
+
+    - name: 🛠️ Build
+      run: |
+        mkdir -p build
+        cd build
+        CC=gcc-12 CXX=g++-12 cmake              \
+          -DCMAKE_BUILD_TYPE=$BUILD_TYPE        \
+          -DCMAKE_INSTALL_PREFIX="$PWD/install" \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache    \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache  \
+          -DCMAKE_C_FLAGS="-fuse-ld=lld"        \
+          -DCMAKE_CXX_FLAGS="-fuse-ld=lld"      \
+          ..
+        make -j4 unit_tests install
+
+    - name: 🧪 Perform Unit Tests
+      run: |
+        cd build
+        ctest

.gitignore

@@ -1,13 +1,16 @@
 .vscode/
 .idea/
 
-cmake-build-debug/
-
-cmake-build-release/
+cmake-build-*/
 
 build-linux/
-build/
+build*/
 
 *.mgc
 imgui.ini
-.DS_Store
+.DS_Store
+plugins/.rustc_info.json
+
+**/target
+
+plugins/example_rust/Cargo.lock

.gitmodules

@@ -0,0 +1,31 @@
+[submodule "lib/external/nativefiledialog"]
+	path = lib/external/nativefiledialog
+	url = https://github.com/btzy/nativefiledialog-extended
+	ignore = dirty
+[submodule "lib/external/yara/yara"]
+	path = lib/external/yara/yara
+	url = https://github.com/VirusTotal/yara
+	ignore = dirty
+[submodule "lib/external/xdgpp"]
+	path = lib/external/xdgpp
+	url = https://git.sr.ht/~danyspin97/xdgpp
+	ignore = dirty
+[submodule "lib/external/fmt"]
+	path = lib/external/fmt
+	url = https://github.com/fmtlib/fmt
+	ignore = dirty
+[submodule "lib/external/curl"]
+	path = lib/external/curl
+	url = https://github.com/curl/curl
+	ignore = dirty
+[submodule "lib/external/capstone"]
+	path = lib/external/capstone
+	url = https://github.com/capstone-engine/capstone
+	ignore = dirty
+[submodule "lib/external/libromfs"]
+	path = lib/external/libromfs
+	url = https://github.com/WerWolv/libromfs
+	ignore = dirty
+[submodule "lib/external/pattern_language"]
+	path = lib/external/pattern_language
+	url = https://github.com/WerWolv/PatternLanguage

.idea/HexEditor.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/vcs.xml

@@ -2,5 +2,14 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/capstone" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/curl" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/fmt" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/libromfs" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/nativefiledialog" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/pattern_language" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/pattern_language/external/fmt" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/xdgpp" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lib/external/yara/yara" vcs="Git" />
   </component>
 </project>

CMakeLists.txt

@@ -1,77 +1,39 @@
 cmake_minimum_required(VERSION 3.16)
 
 # Updating the version here will update it throughout ImHex as well
-project(imhex VERSION 1.7.0)
+file(READ "VERSION" IMHEX_VERSION)
+project(imhex VERSION ${IMHEX_VERSION})
+message("Project version ${IMHEX_VERSION}")
 
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
-include("${CMAKE_SOURCE_DIR}/cmake/build_helpers.cmake")
+set(IMHEX_BASE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR})
+set(CMAKE_MODULE_PATH "${IMHEX_BASE_FOLDER}/cmake/modules")
+include("${IMHEX_BASE_FOLDER}/cmake/build_helpers.cmake")
+
+# Make sure project is configured correctly
 setDefaultBuiltTypeIfUnset()
+detectBadClone()
 
 # List plugin names here. Project name must match folder name
 set(PLUGINS
-        example
-        builtin
-        )
-
-# List extra magic databases to compile here
-set(MAGICDBS
-        magic_dbs/nintendo_magic
-        )
-
-findLibraries()
+    builtin
+    windows
+)
 
+# Add various defines
 detectOS()
 detectArch()
-
-# Add bundled dependencies
-add_subdirectory(external/llvm)
-add_subdirectory(plugins/libimhex)
-
-# Add include directories
-include_directories(include ${MBEDTLS_INCLUDE_DIRS} ${CAPSTONE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS} ${Python_INCLUDE_DIRS})
-
 addVersionDefines()
-configurePackageCreation()
+configurePackingResources()
 
-add_executable(imhex ${application_type}
-        source/main.cpp
-        source/window.cpp
+# Add ImHex sources
+add_subdirectory(lib/libimhex)
+add_subdirectory(main)
+add_custom_target(imhex_all ALL DEPENDS main)
 
-        source/helpers/patches.cpp
-        source/helpers/project_file_handler.cpp
-        source/helpers/loader_script_handler.cpp
-        source/helpers/plugin_handler.cpp
-        source/helpers/encoding_file.cpp
+# Add unit tests
+enable_testing()
+add_subdirectory(tests EXCLUDE_FROM_ALL)
 
-        source/providers/file_provider.cpp
-
-        source/views/view_hexeditor.cpp
-        source/views/view_pattern.cpp
-        source/views/view_pattern_data.cpp
-        source/views/view_hashes.cpp
-        source/views/view_information.cpp
-        source/views/view_help.cpp
-        source/views/view_tools.cpp
-        source/views/view_strings.cpp
-        source/views/view_data_inspector.cpp
-        source/views/view_disassembler.cpp
-        source/views/view_bookmarks.cpp
-        source/views/view_patches.cpp
-        source/views/view_command_palette.cpp
-        source/views/view_settings.cpp
-        source/views/view_data_processor.cpp
-
-        ${imhex_icon}
-        )
-
-set_target_properties(imhex PROPERTIES CXX_VISIBILITY_PRESET hidden)
-target_link_directories(imhex PRIVATE ${CAPSTONE_LIBRARY_DIRS} ${MAGIC_LIBRARY_DIRS})
-
-if (WIN32)
-    target_link_libraries(imhex libdl.a libmagic.a libgnurx.a libtre.a libintl.a libiconv.a libshlwapi.a libcapstone.a LLVMDemangle libimhex ${Python_LIBRARIES} wsock32 ws2_32)
-elseif (UNIX)
-    target_link_libraries(imhex magic ${CMAKE_DL_LIBS} capstone LLVMDemangle libimhex ${Python_LIBRARIES} dl)
-endif()
-
-createPackage()
+# Configure packaging
+createPackage()

README.md

@@ -1,10 +1,11 @@
-<h1 align="center">:mag: ImHex</h1>
+<a href="https://imhex.werwolv.net"><h1 align="center" >:mag: ImHex</h1></a>
 
-<p align="center">A Hex Editor for Reverse Engineers, Programmers and people that value their eye sight when working at 3 AM.</p>
+<p align="center">A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.</p>
 
 <p align="center">
   <a title="'Build' workflow Status" href="https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild"><img alt="'Build' workflow Status" src="https://img.shields.io/github/workflow/status/WerWolv/ImHex/Build?longCache=true&style=for-the-badge&label=Build&logoColor=fff&logo=GitHub%20Actions"></a>
-   <a title="Discord Server" href="https://discord.gg/X63jZ36xBY"><img alt="Discord Server" src="https://img.shields.io/discord/789833418631675954?label=Discord&logo=Discord&style=for-the-badge"></a>
+  <a title="Discord Server" href="https://discord.gg/X63jZ36xBY"><img alt="Discord Server" src="https://img.shields.io/discord/789833418631675954?label=Discord&logo=Discord&style=for-the-badge"></a>
+  <a title="Total Downloads" href="https://github.com/WerWolv/ImHex/releases/latest"><img alt="Total Downloads" src="https://img.shields.io/github/downloads/WerWolv/ImHex/total?longCache=true&style=for-the-badge&label=Downloads&logoColor=fff&logo=GitHub"></a>
 </p>
 
 ## Supporting
@@ -17,6 +18,11 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
 <a href="https://werwolv.net/donate"><img src="https://werwolv.net/assets/paypal_banner.png" alt="PayPal donate button" /> </a>
 </p>
 
+## Screenshots
+
+![Hex editor, patterns and data information](https://user-images.githubusercontent.com/10835354/139717326-8044769d-527b-4d88-8adf-2d4ecafdca1f.png)
+![Bookmarks, disassembler and data processor](https://user-images.githubusercontent.com/10835354/139717323-1f8c9d52-f7eb-4f43-9f11-097ac728ed6c.png)
+
 ## Features
 
 - Featureful hex view
@@ -27,13 +33,13 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
     - Hex string
     - C, C++, C#, Rust, Python, Java & JavaScript array
     - ASCII-Art hex view
-    - HTML self contained div
+    - HTML self-contained div
   - String and hex search
   - Colorful highlighting
   - Goto from start, end and current cursor position
 - Custom C++-like pattern language for parsing highlighting a file's content
   - Automatic loading based on MIME type
-  - arrays, pointers, structs, unions, enums, bitfields, using declarations, little and big endian support, conditionals and much more!
+  - arrays, pointers, structs, unions, enums, bitfields, namespaces, little and big endian support, conditionals and much more!
   - Useful error messages, syntax highlighting and error marking
 - Data importing
   - Base64 files
@@ -49,7 +55,7 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
   - CRC16 and CRC32 with custom initial values and polynomials
   - MD4, MD5
   - SHA-1, SHA-224, SHA-256, SHA-384, SHA-512
-- Disassembler supporting many different architectures
+- Disassembler supporting many architectures (frontend for Capstone)
   - ARM32 (ARM, Thumb, Cortex-M, AArch32)
   - ARM64
   - MIPS (MIPS32, MIPS64, MIPS32R6, Micro)
@@ -62,6 +68,10 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
   - TMS320C64X
   - M680X
   - Ethereum
+  - RISC-V
+  - WebAssembly
+  - MOS565XX
+  - Berkeley Packet Filter
 - Bookmarks
   - Region highlighting
   - Comments
@@ -69,96 +79,82 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
   - File magic-based file parser and MIME type database
   - Byte distribution graph
   - Entropy graph
-  - Highest and avarage entropy
+  - Highest and average entropy
   - Encrypted / Compressed file detection
+- Built-in Content Store
+  - Download all files found in the database directly from within ImHex
+- Yara Rules support
+  - Quickly scan a file for vulnerabilities with official yara rules
 - Helpful tools
   - Itanium and MSVC demangler
   - ASCII table
   - Regex replacer
   - Mathematical expression evaluator (Calculator)
   - Hexadecimal Color picker
+  - Base converter
+  - UNIX Permissions calculator
+  - Anonfiles File upload tool
+  - Wikipedia term definition finder
+  - File utilities
+    - File splitter
+    - File combiner
+    - File shredder
 - Built-in cheat sheet for pattern language and Math evaluator
 - Doesn't burn out your retinas when used in late-night sessions
 
-## Screenshots
-
-![](https://i.imgur.com/xH7xJ4g.png)
-![](https://i.imgur.com/fhVJYEa.png)
-
 ## Pattern Language
 
-The custom C-like Pattern Language developed and used by ImHex is easy to read, understand and learn. A guide with all features of the langauge can be found [in the wiki](https://github.com/WerWolv/ImHex/wiki/Pattern-Language-Guide) or a simpler version in ImHex under `Help -> Pattern Language Cheat Sheet`
+The custom C-like Pattern Language developed and used by ImHex is easy to read, understand and learn. A guide with all features of the language can be found [on the docs page](http://imhex.werwolv.net/docs).
 
-## Additional Files
+## Database
+
+For format patterns, includable libraries magic and constant files, check out the [ImHex-Patterns](https://github.com/WerWolv/ImHex-Patterns) repository. Feel free to PR your own files there as well!
+
+## Plugin development
+
+To develop plugins for ImHex, use one of the following two templates projects to get started. You then have access to the entirety of libimhex as well as the ImHex API and the Content Registry to interact with ImHex or to add new content.
+- [C++ Plugin Template](https://github.com/WerWolv/ImHex-Cpp-Plugin-Template)
+- [Rust Plugin Template](https://github.com/WerWolv/ImHex-Rust-Plugin-Template)
 
-For format patterns, includable libraries and magic files, check out the [ImHex-Patterns](https://github.com/WerWolv/ImHex-Patterns) repository. Feel free to PR your own files there as well!
 
 ## Nightly builds
 
 Nightlies are available via GitHub Actions [here](https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild).
 
 - Windows • __x86_64__
-  - [MSI Installer](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Installer.zip)
-  - [Portable ZIP](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Portable%20ZIP.zip)
+  - [Installer](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Installer.zip)
+  - [Portable](https://nightly.link/WerWolv/ImHex/workflows/build/master/Windows%20Portable%20ZIP.zip)
 - MacOS • __x86_64__
   - [DMG](https://nightly.link/WerWolv/ImHex/workflows/build/master/macOS%20DMG.zip)
 - Linux • __x86_64__
-  - [ELF](https://nightly.link/WerWolv/ImHex/workflows/build/master/Linux%20ELF.zip)
+  - [DEB](https://nightly.link/WerWolv/ImHex/workflows/build/master/Linux%20DEB.zip)
+  - [AppImage](https://nightly.link/WerWolv/ImHex/workflows/build/master/Linux%20AppImage.zip)
+  - [Arch Package](https://nightly.link/WerWolv/ImHex/workflows/build/master/ArchLinux%20.pkg.tar.zst.zip)
 
 ## Compiling
 
-You need a C++20 compatible compiler such as GCC 10.2.0 to compile ImHex. Moreover, the following dependencies are needed for compiling ImHex:
+To compile ImHex, a C++20 compiler is required. Releases are all mainly built using GCC, however on macOS, clang is also required to compile some ObjC code. 
 
-- GLFW3
-- libmagic, libgnurx, libtre, libintl, libiconv
-- libcrypto
-- capstone
-- nlohmann json
-- Python3
-- freetype2
-- Brew (macOS only)
-
-### Windows and Linux
-
-Find all-in-one dependency installation scripts for Arch Linux, Fedora, Debian/Ubuntu and/or MSYS2 in [dist](dist).
-
-After all the dependencies are installed, run the following commands to build ImHex:
-
-```sh
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Release ..
-make -j
-```
-
----
-
-To create a standalone zipfile on Windows, get the Python standard library (e.g. from https://github.com/python/cpython/tree/master/Lib) and place the files and folders in `lib/python3.8` next to your built executable. Don't forget to also copy the `libpython3.8.dll` and `libwinpthread-1.dll` from your mingw setup next to the executable.
-
-On both Windows and Linux:
-
-- Copy the files from `python_libs` in the `lib` folder next to your built executable.
-- Place your magic databases in the `magic` folder next to your built executable
-- Place your patterns in the `pattern` folder next to your built executable
-- Place your include pattern files in the `include` folder next to your built executable
-
-### macOS
-
-To build ImHex on macOS, run the following commands:
-
-```sh
-brew bundle --no-lock --file dist/Brewfile
-mkdir build
-cd build
-CC=$(brew --prefix llvm)/bin/clang CXX=$(brew --prefix llvm)/bin/clang++ PKG_CONFIG_PATH="$(brew --prefix openssl)/lib/pkgconfig":"$(brew --prefix)/lib/pkgconfig" cmake -DCMAKE_BUILD_TYPE=Release ..
-make -j
-```
+Many dependencies are bundled into the repository using submodules so make sure to clone it using the `--recurse-submodules` option.
+All dependencies that aren't bundled, can be installed using the dependency installer scripts found in the `/dist` folder.
 
 ## Credits
 
+### Contributors
+
+- [Mary](https://github.com/Thog) for her immense help porting ImHex to MacOS and help during development
+- [Roblabla](https://github.com/Roblabla) for adding MSI Installer support to ImHex
+- [jam1garner](https://github.com/jam1garner) and [raytwo](https://github.com/raytwo) for their help with adding Rust support to plugins
+- [Mailaender](https://github.com/Mailaender) for getting ImHex onto Flathub
+- [iTrooz](https://github.com/iTrooz) for many improvements related to release packaging and the GitHub Action runners.
+- Everybody else who has reported issues on Discord or GitHub that I had great conversations with :)
+
+### Libraries
+
 - Thanks a lot to ocornut for their amazing [Dear ImGui](https://github.com/ocornut/imgui) which is used for building the entire interface
-  - Thanks to orconut as well for their hex editor view used as base for this project.
+  - Thanks to ocornut as well for their hex editor view used as base for this project.
   - Thanks to BalazsJako for their incredible [ImGuiColorTextEdit](https://github.com/BalazsJako/ImGuiColorTextEdit) used for the pattern language syntax highlighting
-  - Thanks to AirGuanZ for their amazing [imgui-filebrowser](https://github.com/AirGuanZ/imgui-filebrowser) used for loading and saving files
 - Thanks to nlohmann for their [json](https://github.com/nlohmann/json) library used for project files
 - Thanks to aquynh for [capstone](https://github.com/aquynh/capstone) which is the base of the disassembly window
+- Thanks to vitaut for their [libfmt](https://github.com/fmtlib/fmt) library which makes formatting and logging so much better
+- Thanks to rxi for [microtar](https://github.com/rxi/microtar) used for extracting downloaded store assets 

VERSION

@@ -0,0 +1 @@
+1.19.1

cmake/build_helpers.cmake

@@ -1,3 +1,5 @@
+include(FetchContent)
+
 macro(addVersionDefines)
     if (IS_DIRECTORY "${CMAKE_SOURCE_DIR}/.git")
         # Get the current working branch
@@ -16,32 +18,33 @@ macro(addVersionDefines)
                 OUTPUT_STRIP_TRAILING_WHITESPACE
         )
 
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGIT_COMMIT_HASH=\"\\\"${GIT_COMMIT_HASH}\"\\\"")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGIT_BRANCH=\"\\\"${GIT_BRANCH}\"\\\"")
-    endif()
+        add_compile_definitions(GIT_COMMIT_HASH="${GIT_COMMIT_HASH}" GIT_BRANCH="${GIT_BRANCH}")
+    endif ()
+
+    set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -DPROJECT_VERSION_MAJOR=${PROJECT_VERSION_MAJOR} -DPROJECT_VERSION_MINOR=${PROJECT_VERSION_MINOR} -DPROJECT_VERSION_PATCH=${PROJECT_VERSION_PATCH} ")
+
+    if (CMAKE_BUILD_TYPE STREQUAL "Release")
+        set(IMHEX_VERSION_STRING ${IMHEX_VERSION})
+    elseif (CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(IMHEX_VERSION_STRING ${IMHEX_VERSION}-Debug)
+        add_compile_definitions(DEBUG)
+    elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        set(IMHEX_VERSION_STRING ${IMHEX_VERSION}-RelWithDebInfo)
+    elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
+        set(IMHEX_VERSION_STRING ${IMHEX_VERSION}-MinSizeRel)
+    endif ()
+
+    add_compile_definitions(IMHEX_VERSION="${IMHEX_VERSION_STRING}")
 
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DRELEASE -DIMHEX_VERSION=\"\\\"${PROJECT_VERSION}\"\\\"")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -DIMHEX_VERSION=\"\\\"${PROJECT_VERSION}-Debug\"\\\"")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DRELEASE -DIMHEX_VERSION=\"\\\"${PROJECT_VERSION}-ReleaseWithDebugInfo\"\\\"")
-    set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DRELEASE -DIMHEX_VERSION=\"\\\"${PROJECT_VERSION}-ReleaseMinimumSize\"\\\"")
 endmacro()
 
-macro(findLibraries)
+macro(configurePython)
     set(CMAKE_FIND_PACKAGE_SORT_ORDER NATURAL)
     set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
 
     # Enforce that we use non system Python 3 on macOS.
     set(Python_FIND_FRAMEWORK NEVER)
 
-    # Find packages
-    find_package(PkgConfig REQUIRED)
-
-    find_package(mbedTLS REQUIRED)
-
-    pkg_search_module(CAPSTONE REQUIRED capstone)
-
-    find_package(OpenGL REQUIRED)
-
     find_package(Python COMPONENTS Development REQUIRED)
     if(Python_VERSION LESS 3)
         message(STATUS ${PYTHON_VERSION_MAJOR_MINOR})
@@ -57,25 +60,29 @@ macro(findLibraries)
     endif ()
     list(JOIN PYTHON_VERSION_MAJOR_MINOR "." PYTHON_VERSION_MAJOR_MINOR)
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS} -DPYTHON_VERSION_MAJOR_MINOR=\"\\\"${PYTHON_VERSION_MAJOR_MINOR}\"\\\"")
-
-    pkg_search_module(MAGIC libmagic)
-    if(NOT MAGIC_FOUND)
-        find_library(MAGIC magic REQUIRED)
-    else()
-        set(MAGIC_INCLUDE_DIRS ${MAGIC_INCLUDEDIR})
-    endif()
+    add_compile_definitions(PYTHON_VERSION_MAJOR_MINOR="${PYTHON_VERSION_MAJOR_MINOR}")
 endmacro()
 
 # Detect current OS / System
 macro(detectOS)
     if (WIN32)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOS_WINDOWS")
-    elseif(APPLE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOS_MACOS")
-    elseif(UNIX AND NOT APPLE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOS_LINUX")
-    else()
+        add_compile_definitions(OS_WINDOWS)
+        set(CMAKE_INSTALL_BINDIR ".")
+        set(CMAKE_INSTALL_LIBDIR ".")
+        set(PLUGINS_INSTALL_LOCATION "plugins")
+    elseif (APPLE)
+        add_compile_definitions(OS_MACOS)
+        set(CMAKE_INSTALL_BINDIR ".")
+        set(CMAKE_INSTALL_LIBDIR ".")
+        set(PLUGINS_INSTALL_LOCATION "plugins")
+        enable_language(OBJC)
+        enable_language(OBJCXX)
+    elseif (UNIX AND NOT APPLE)
+        add_compile_definitions(OS_LINUX)
+        set(CMAKE_INSTALL_BINDIR "bin")
+        set(CMAKE_INSTALL_LIBDIR "lib")
+        set(PLUGINS_INSTALL_LOCATION "share/imhex/plugins")
+    else ()
         message(FATAL_ERROR "Unknown / unsupported system!")
     endif()
 endmacro()
@@ -83,14 +90,14 @@ endmacro()
 # Detect 32 vs. 64 bit system
 macro(detectArch)
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DARCH_64_BIT")
+        add_compile_definitions(ARCH_64_BIT)
     elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DARCH_32_BIT")
+        add_compile_definitions(ARCH_32_BIT)
     endif()
 endmacro()
 
 
-macro(configurePackageCreation)
+macro(configurePackingResources)
     option (CREATE_PACKAGE "Create a package with CPack" OFF)
 
     if (APPLE)
@@ -98,44 +105,41 @@ macro(configurePackageCreation)
     endif()
 
     if (WIN32)
-        if (CMAKE_BUILD_TYPE EQUAL "DEBUG")
-            set(application_type WIN32)
-        else ()
-            set(application_type)
-        endif ()
-        set(imhex_icon "${PROJECT_SOURCE_DIR}/res/resource.rc")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++ -static-libgcc -Wl,--allow-multiple-definition -static -Wl,-Bstatic,--whole-archive -lwinpthread -Wl,--no-whole-archive")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wl,-subsystem,windows")
+        set(APPLICATION_TYPE)
+        set(IMHEX_ICON "${IMHEX_BASE_FOLDER}/resources/resource.rc")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--allow-multiple-definition")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-subsystem,windows")
 
         if (CREATE_PACKAGE)
             set(CPACK_GENERATOR "WIX")
             set(CPACK_PACKAGE_NAME "ImHex")
+            set(CPACK_PACKAGE_VENDOR "WerWolv")
             set(CPACK_WIX_UPGRADE_GUID "05000E99-9659-42FD-A1CF-05C554B39285")
-            set(CPACK_WIX_PRODUCT_ICON "${PROJECT_SOURCE_DIR}/res/icon.ico")
+            set(CPACK_WIX_PRODUCT_ICON "${PROJECT_SOURCE_DIR}/resources/icon.ico")
             set(CPACK_PACKAGE_INSTALL_DIRECTORY "ImHex")
-            set_property(INSTALL "$<TARGET_FILE_NAME:imhex>"
+            set_property(INSTALL "$<TARGET_FILE_NAME:main>"
                     PROPERTY CPACK_START_MENU_SHORTCUTS "ImHex"
                     )
-            set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/res/LICENSE.rtf")
+            set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/resources/LICENSE.rtf")
         endif()
     elseif (APPLE)
-        set (imhex_icon "${PROJECT_SOURCE_DIR}/res/mac/AppIcon.icns")
+        set (IMHEX_ICON "${IMHEX_BASE_FOLDER}/resources/AppIcon.icns")
 
         if (CREATE_BUNDLE)
-            set(application_type MACOSX_BUNDLE)
-            set_source_files_properties(${imhex_icon} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
+            set(APPLICATION_TYPE MACOSX_BUNDLE)
+            set_source_files_properties(${IMHEX_ICON} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
             set(MACOSX_BUNDLE_ICON_FILE "AppIcon.icns")
             set(MACOSX_BUNDLE_INFO_STRING "WerWolv")
             set(MACOSX_BUNDLE_BUNDLE_NAME "ImHex")
             set(MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
-            set(MACOSX_BUNDLE_GUI_IDENTIFIER "WerWolv.ImHex")
+            set(MACOSX_BUNDLE_GUI_IDENTIFIER "net.WerWolv.ImHex")
             set(MACOSX_BUNDLE_LONG_VERSION_STRING "${PROJECT_VERSION}-${GIT_COMMIT_HASH}")
             set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
             set(MACOSX_BUNDLE_COPYRIGHT "Copyright © 2020 WerWolv and Thog. All rights reserved." )
             if ("${CMAKE_GENERATOR}" STREQUAL "Xcode")
-                set ( bundle_path "${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/imhex.app" )
+                set ( bundle_path "${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/ImHex.app" )
             else ()
-                set ( bundle_path "${CMAKE_BINARY_DIR}/imhex.app" )
+                set ( bundle_path "${CMAKE_BINARY_DIR}/ImHex.app" )
             endif()
         endif()
     endif()
@@ -145,8 +149,34 @@ macro(createPackage)
     file(MAKE_DIRECTORY "plugins")
     foreach (plugin IN LISTS PLUGINS)
         add_subdirectory("plugins/${plugin}")
-        set_target_properties(${plugin} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/plugins)
-        add_dependencies(imhex ${plugin})
+        if (TARGET ${plugin})
+            get_target_property(IS_RUST_PROJECT ${plugin} RUST_PROJECT)
+
+            set_target_properties(${plugin} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/plugins)
+            set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/plugins)
+
+            if (IS_RUST_PROJECT)
+                set_target_properties(${plugin} PROPERTIES CARGO_BUILD_TARGET_DIR  ${CMAKE_BINARY_DIR}/plugins)
+
+                get_target_property(PLUGIN_LOCATION ${plugin} LOCATION)
+
+                install(FILES "${PLUGIN_LOCATION}/../${plugin}.hexplug" DESTINATION "${PLUGINS_INSTALL_LOCATION}")
+            else ()
+                if (WIN32)
+                    install(TARGETS ${plugin} RUNTIME DESTINATION ${PLUGINS_INSTALL_LOCATION})
+                elseif (APPLE)
+                    if (CREATE_BUNDLE)
+                        set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:main>/${PLUGINS_INSTALL_LOCATION})
+                    else ()
+                        set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/plugins)
+                    endif ()
+                else ()
+                    install(TARGETS ${plugin} LIBRARY DESTINATION ${PLUGINS_INSTALL_LOCATION})
+                endif ()
+            endif ()
+
+            add_dependencies(imhex_all ${plugin})
+        endif ()
     endforeach()
 
     set_target_properties(libimhex PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
@@ -157,23 +187,23 @@ macro(createPackage)
 
         # Grab all dynamically linked dependencies.
         INSTALL(CODE "set(CMAKE_INSTALL_BINDIR \"${CMAKE_INSTALL_BINDIR}\")")
-        INSTALL(CODE "get_filename_component(PY_PARENT ${Python_LIBRARIES} DIRECTORY)")
+        INSTALL(CODE "get_filename_component(PY_PARENT \"${Python_LIBRARIES}\" DIRECTORY)")
         INSTALL(CODE "LIST(APPEND DEP_FOLDERS \${PY_PARENT})")
         install(CODE [[
         file(GET_RUNTIME_DEPENDENCIES
-            EXECUTABLES $<TARGET_FILE:imhex>
+            EXECUTABLES $<TARGET_FILE:builtin> $<TARGET_FILE:libimhex> $<TARGET_FILE:main>
             RESOLVED_DEPENDENCIES_VAR _r_deps
             UNRESOLVED_DEPENDENCIES_VAR _u_deps
             CONFLICTING_DEPENDENCIES_PREFIX _c_deps
-            DIRECTORIES ${DEP_FOLDERS}
+            DIRECTORIES ${DEP_FOLDERS} $ENV{PATH}
             POST_EXCLUDE_REGEXES ".*system32/.*\\.dll"
         )
 
         if(_u_deps)
-            message(WARNING "There were unresolved dependencies for binary $<TARGET_FILE:imhex>: \"${_u_deps}\"!")
+            message(WARNING "There were unresolved dependencies for binary: \"${_u_deps}\"!")
         endif()
         if(_c_deps_FILENAMES)
-            message(WARNING "There were conflicting dependencies for library $<TARGET_FILE:imhex>: \"${_c_deps}\"!")
+            message(WARNING "There were conflicting dependencies for library: \"${_c_deps}\"!")
         endif()
 
         foreach(_file ${_r_deps})
@@ -184,68 +214,45 @@ macro(createPackage)
                 FILES "${_file}"
                 )
         endforeach()
-    ]])
+        ]])
+
+        install(FILES "$<TARGET_FILE:libimhex>" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+        downloadImHexPatternsFiles("./")
+    elseif(UNIX AND NOT APPLE)
+    
+        configure_file(${CMAKE_SOURCE_DIR}/dist/DEBIAN/control.in ${CMAKE_BINARY_DIR}/DEBIAN/control)    
+    
+        install(FILES ${CMAKE_SOURCE_DIR}/dist/imhex.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications)
+        install(FILES ${CMAKE_SOURCE_DIR}/resources/icon.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps RENAME imhex.png)
+        install(FILES "$<TARGET_FILE:libimhex>" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+        downloadImHexPatternsFiles("./share/imhex")
     endif()
-
-    if (UNIX AND NOT APPLE)
-        install(TARGETS libimhex DESTINATION ${CMAKE_INSTALL_PREFIX})
-
-        string(REPLACE ":" ";" EXTRA_MAGICDBS "${EXTRA_MAGICDBS}")
-
-    endif ()
-
-    if (NOT EXTRA_MAGICDBS STREQUAL "")
-        list(GET EXTRA_MAGICDBS -1 EXTRA_MAGICDBS)
-
-        if (NOT EXTRA_MAGICDBS STREQUAL "NOTFOUND")
-            if (EXTRA_MAGICDBS MATCHES ".*\\.mgc")
-                install(FILES "${EXTRA_MAGICDBS}" DESTINATION magic/)
-            else ()
-                install(FILES "${EXTRA_MAGICDBS}.mgc" DESTINATION magic/)
-            endif ()
-        endif ()
-    endif ()
-
-    # Compile the imhex-specific magicdb
-    add_custom_target(magic_dbs ALL
-            SOURCES ${MAGICDBS}
-            )
-    add_custom_command(TARGET magic_dbs
-            COMMAND file -C -m ${CMAKE_SOURCE_DIR}/magic_dbs
-            )
-
-    foreach (plugin IN LISTS PLUGINS)
-        install(FILES "$<TARGET_FILE:${plugin}>" DESTINATION plugins/)
-    endforeach ()
-
-    # Install the magicdb files.
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/magic_dbs.mgc DESTINATION magic/ RENAME imhex.mgc)
-
+    
     if (CREATE_BUNDLE)
         include(PostprocessBundle)
 
         # Fix rpath
-        add_custom_command(TARGET imhex POST_BUILD COMMAND ${CMAKE_INSTALL_NAME_TOOL} -add_rpath "@executable_path/../Frameworks/" $<TARGET_FILE:imhex>)
+        add_custom_command(TARGET imhex_all POST_BUILD COMMAND ${CMAKE_INSTALL_NAME_TOOL} -add_rpath "@executable_path/../Frameworks/" $<TARGET_FILE:main>)
 
         # FIXME: Remove this once we move/integrate the plugins directory.
         add_custom_target(build-time-make-plugins-directory ALL COMMAND ${CMAKE_COMMAND} -E make_directory "${bundle_path}/Contents/MacOS/plugins")
+        add_custom_target(build-time-make-resources-directory ALL COMMAND ${CMAKE_COMMAND} -E make_directory "${bundle_path}/Contents/Resources")
+
+        downloadImHexPatternsFiles("${bundle_path}/Contents/MacOS")
+        
+        install(FILES ${IMHEX_ICON} DESTINATION "${bundle_path}/Contents/Resources")
+        install(TARGETS main BUNDLE DESTINATION ".")
+        install(FILES $<TARGET_FILE:main> DESTINATION "${bundle_path}")
 
         # Update library references to make the bundle portable
-        postprocess_bundle(imhex)
+        postprocess_bundle(imhex_all main)
 
         # Enforce DragNDrop packaging.
         set(CPACK_GENERATOR "DragNDrop")
-
-        install(TARGETS imhex BUNDLE DESTINATION .)
     else()
-        if (WIN32)
-            install(TARGETS imhex RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-        else ()
-            install(TARGETS imhex RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
-        endif ()
+        install(TARGETS main RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
     endif()
 
-
     if (CREATE_PACKAGE)
         include(apple)
         include(CPack)
@@ -267,4 +274,32 @@ macro(setDefaultBuiltTypeIfUnset)
         set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Using Release build type as it was left unset" FORCE)
         set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release")
     endif()
-endmacro()
+endmacro()
+
+macro(detectBadClone)
+    file (GLOB EXTERNAL_DIRS "lib/external/*")
+    foreach (EXTERNAL_DIR ${EXTERNAL_DIRS})
+        file(GLOB RESULT "${EXTERNAL_DIR}/*")
+        list(LENGTH RESULT ENTRY_COUNT)
+        if(ENTRY_COUNT LESS_EQUAL 1)
+            message(FATAL_ERROR "External dependency ${EXTERNAL_DIR} is empty!\nMake sure to correctly clone ImHex using the --recurse-submodules git option or initialize the submodules manually.")
+        endif()
+    endforeach ()
+endmacro()
+
+
+function(downloadImHexPatternsFiles dest)
+    FetchContent_Declare(
+        imhex_patterns
+        GIT_REPOSITORY https://github.com/WerWolv/ImHex-Patterns.git
+        GIT_TAG master
+    )
+
+    FetchContent_Populate(imhex_patterns)
+
+    set(PATTERNS_FOLDERS_TO_INSTALL constants encodings includes patterns magic)
+    foreach (FOLDER ${PATTERNS_FOLDERS_TO_INSTALL})
+        install(DIRECTORY "${imhex_patterns_SOURCE_DIR}/${FOLDER}" DESTINATION ${dest})
+    endforeach()
+
+endfunction()

cmake/modules/PostprocessBundle.cmake

@@ -13,9 +13,9 @@
 if(CMAKE_GENERATOR)
 	# Being called as include(PostprocessBundle), so define a helper function.
 	set(_POSTPROCESS_BUNDLE_MODULE_LOCATION "${CMAKE_CURRENT_LIST_FILE}")
-	function(postprocess_bundle target)
-		add_custom_command(TARGET ${target} POST_BUILD
-			COMMAND ${CMAKE_COMMAND} -DBUNDLE_PATH="$<TARGET_FILE_DIR:${target}>/../.." -DCODE_SIGN_CERTIFICATE_ID="${CODE_SIGN_CERTIFICATE_ID}"
+	function(postprocess_bundle out_target in_target)
+		add_custom_command(TARGET ${out_target} POST_BUILD
+			COMMAND ${CMAKE_COMMAND} -DBUNDLE_PATH="$<TARGET_FILE_DIR:${in_target}>/../.." -DCODE_SIGN_CERTIFICATE_ID="${CODE_SIGN_CERTIFICATE_ID}"
 				-P "${_POSTPROCESS_BUNDLE_MODULE_LOCATION}"
 		)
 	endfunction()
@@ -26,9 +26,8 @@ get_filename_component(BUNDLE_PATH "${BUNDLE_PATH}" ABSOLUTE)
 message(STATUS "Fixing up application bundle: ${BUNDLE_PATH}")
 
 
-# Make sure to fix up any additional shared libraries (like plugins) that are
-# needed.
-file(GLOB_RECURSE extra_libs "${BUNDLE_PATH}/Contents/MacOS/*.dylib")
+# Make sure to fix up any included ImHex plugin.
+file(GLOB_RECURSE extra_libs "${BUNDLE_PATH}/Contents/MacOS/plugins/*.hexplug")
 
 message(STATUS "Fixing up application bundle: ${extra_dirs}")
 
@@ -57,3 +56,6 @@ if (CODE_SIGN_CERTIFICATE_ID)
 	execute_process(COMMAND ${CMAKE_COMMAND} -E remove_directory "${BUNDLE_PATH}")
 	execute_process(COMMAND ${CMAKE_COMMAND} -E rename "${BUNDLE_PATH}.temp" "${BUNDLE_PATH}")
 endif()
+
+# Add a necessary rpath to the imhex binary
+get_bundle_main_executable("${BUNDLE_PATH}" IMHEX_EXECUTABLE)

cmake/modules/apple.cmake

@@ -1,3 +1,3 @@
 set (CPACK_BUNDLE_NAME "ImHex")
-set (CPACK_BUNDLE_ICON "${CMAKE_SOURCE_DIR}/res/mac/AppIcon.icns" )
+set (CPACK_BUNDLE_ICON "${CMAKE_SOURCE_DIR}/resources/AppIcon.icns" )
 set (CPACK_BUNDLE_PLIST "${CMAKE_BINARY_DIR}/ImHex.app/Contents/Info.plist")

dist/AppImageBuilder.yml

@@ -0,0 +1,141 @@
+# appimage-builder recipe see https://appimage-builder.readthedocs.io for details
+version: 1
+AppDir:
+  path: .AppDir
+  app_info:
+    id: imhex
+    name: ImHex
+    icon: imhex
+    version: AppImage
+    exec: usr/bin/imhex
+    exec_args: $@
+  apt:
+    arch:
+    - amd64
+    allow_unauthenticated: true
+    sources:
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy main restricted
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy-updates main restricted
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy universe
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy-updates universe
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy multiverse
+    - sourceline: deb http://us.archive.ubuntu.com/ubuntu/ jammy-updates multiverse
+    - sourceline: deb http://.archive.ubuntu.com/ubuntu/ jammy-backports main restricted
+        universe multiverse
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security main restricted
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security universe
+    - sourceline: deb http://security.ubuntu.com/ubuntu jammy-security multiverse
+    include:
+    - adwaita-icon-theme-full
+    - librsvg2-common
+    - libbz2-1.0:amd64
+    - libcap2:amd64
+    - libdbus-1-3:amd64
+    - libgpg-error0:amd64
+    - liblzma5:amd64
+    - libnss-mdns:amd64
+    - libpcre3:amd64
+    - libselinux1:amd64
+    - libtinfo6:amd64
+  files:
+    include:
+    - /lib/x86_64-linux-gnu/libGLX.so.0
+    - /lib/x86_64-linux-gnu/libGLdispatch.so.0
+    - /lib/x86_64-linux-gnu/libLLVM-13.so.1
+    - /lib/x86_64-linux-gnu/libOpenGL.so.0
+    - /lib/x86_64-linux-gnu/libX11.so.6
+    - /lib/x86_64-linux-gnu/libXau.so.6
+    - /lib/x86_64-linux-gnu/libXcomposite.so.1
+    - /lib/x86_64-linux-gnu/libXcursor.so.1
+    - /lib/x86_64-linux-gnu/libXdamage.so.1
+    - /lib/x86_64-linux-gnu/libXdmcp.so.6
+    - /lib/x86_64-linux-gnu/libXext.so.6
+    - /lib/x86_64-linux-gnu/libXfixes.so.3
+    - /lib/x86_64-linux-gnu/libXi.so.6
+    - /lib/x86_64-linux-gnu/libXinerama.so.1
+    - /lib/x86_64-linux-gnu/libXrandr.so.2
+    - /lib/x86_64-linux-gnu/libXrender.so.1
+    - /lib/x86_64-linux-gnu/libXxf86vm.so.1
+    - /lib/x86_64-linux-gnu/libatk-1.0.so.0
+    - /lib/x86_64-linux-gnu/libatk-bridge-2.0.so.0
+    - /lib/x86_64-linux-gnu/libatspi.so.0
+    - /lib/x86_64-linux-gnu/libblkid.so.1
+    - /lib/x86_64-linux-gnu/libbrotlicommon.so.1
+    - /lib/x86_64-linux-gnu/libbrotlidec.so.1
+    - /lib/x86_64-linux-gnu/libbsd.so.0
+    - /lib/x86_64-linux-gnu/libcairo-gobject.so.2
+    - /lib/x86_64-linux-gnu/libcairo.so.2
+    - /lib/x86_64-linux-gnu/libdatrie.so.1
+    - /lib/x86_64-linux-gnu/libedit.so.2
+    - /lib/x86_64-linux-gnu/libelf.so.1
+    - /lib/x86_64-linux-gnu/libepoxy.so.0
+    - /lib/x86_64-linux-gnu/libffi.so.8
+    - /lib/x86_64-linux-gnu/libfontconfig.so.1
+    - /lib/x86_64-linux-gnu/libfreetype.so.6
+    - /lib/x86_64-linux-gnu/libfribidi.so.0
+    - /lib/x86_64-linux-gnu/libgcrypt.so.20
+    - /lib/x86_64-linux-gnu/libgdk-3.so.0
+    - /lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0
+    - /lib/x86_64-linux-gnu/libgio-2.0.so.0
+    - /lib/x86_64-linux-gnu/libglapi.so.0
+    - /lib/x86_64-linux-gnu/libglfw.so.3
+    - /lib/x86_64-linux-gnu/libglib-2.0.so.0
+    - /lib/x86_64-linux-gnu/libgmodule-2.0.so.0
+    - /lib/x86_64-linux-gnu/libgmp.so.10
+    - /lib/x86_64-linux-gnu/libgnutls.so.30
+    - /lib/x86_64-linux-gnu/libgobject-2.0.so.0
+    - /lib/x86_64-linux-gnu/libgraphite2.so.3
+    - /lib/x86_64-linux-gnu/libgtk-3.so.0
+    - /lib/x86_64-linux-gnu/libharfbuzz.so.0
+    - /lib/x86_64-linux-gnu/libhogweed.so.6
+    - /lib/x86_64-linux-gnu/libicudata.so.70
+    - /lib/x86_64-linux-gnu/libicuuc.so.70
+    - /lib/x86_64-linux-gnu/libidn2.so.0
+    - /lib/x86_64-linux-gnu/libjpeg.so.8
+    - /lib/x86_64-linux-gnu/liblber-2.5.so.0
+    - /lib/x86_64-linux-gnu/libldap-2.5.so.0
+    - /lib/x86_64-linux-gnu/liblz4.so.1
+    - /lib/x86_64-linux-gnu/libmagic.so.1
+    - /lib/x86_64-linux-gnu/libmbedcrypto.so.7
+    - /lib/x86_64-linux-gnu/libmbedtls.so.14
+    - /lib/x86_64-linux-gnu/libmbedx509.so.1
+    - /lib/x86_64-linux-gnu/libmd.so.0
+    - /lib/x86_64-linux-gnu/libmount.so.1
+    - /lib/x86_64-linux-gnu/libnettle.so.8
+    - /lib/x86_64-linux-gnu/libp11-kit.so.0
+    - /lib/x86_64-linux-gnu/libpango-1.0.so.0
+    - /lib/x86_64-linux-gnu/libpangocairo-1.0.so.0
+    - /lib/x86_64-linux-gnu/libpangoft2-1.0.so.0
+    - /lib/x86_64-linux-gnu/libpcre2-8.so.0
+    - /lib/x86_64-linux-gnu/libpixman-1.so.0
+    - /lib/x86_64-linux-gnu/libpng16.so.16
+    - /lib/x86_64-linux-gnu/libpython3.10.so.1.0
+    - /lib/x86_64-linux-gnu/libsasl2.so.2
+    - /lib/x86_64-linux-gnu/libsensors.so.5
+    - /lib/x86_64-linux-gnu/libstdc++.so.6
+    - /lib/x86_64-linux-gnu/libsystemd.so.0
+    - /lib/x86_64-linux-gnu/libtasn1.so.6
+    - /lib/x86_64-linux-gnu/libthai.so.0
+    - /lib/x86_64-linux-gnu/libunistring.so.2
+    - /lib/x86_64-linux-gnu/libuuid.so.1
+    - /lib/x86_64-linux-gnu/libvulkan.so.1
+    - /lib/x86_64-linux-gnu/libwayland-client.so.0
+    - /lib/x86_64-linux-gnu/libwayland-cursor.so.0
+    - /lib/x86_64-linux-gnu/libwayland-egl.so.1
+    - /lib/x86_64-linux-gnu/libxcb-dri2.so.0
+    - /lib/x86_64-linux-gnu/libxcb-dri3.so.0
+    - /lib/x86_64-linux-gnu/libxcb-present.so.0
+    - /lib/x86_64-linux-gnu/libxcb-sync.so.1
+    - /lib/x86_64-linux-gnu/libxkbcommon.so.0
+    - /lib/x86_64-linux-gnu/libxml2.so.2
+    - /lib/x86_64-linux-gnu/libxshmfence.so.1
+    - /lib/x86_64-linux-gnu/libzstd.so.1
+    exclude:
+    - usr/share/man
+    - usr/share/doc/*/README.*
+    - usr/share/doc/*/changelog.*
+    - usr/share/doc/*/NEWS.*
+    - usr/share/doc/*/TODO.*
+AppImage:
+  arch: x86_64
+  update-information: guess

dist/Arch/PKGBUILD

@@ -0,0 +1,38 @@
+# Maintainer: iTrooz_ <itrooz at protonmail dot com>
+pkgname=imhex-bin
+pkgver=%version%
+pkgrel=1
+pkgdesc="A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM. "
+arch=("x86_64")
+url="https://github.com/WerWolv/ImHex"
+repo=$url
+license=('GPL 2.0')
+groups=()
+depends=(glfw mbedtls python freetype2 libglvnd gtk3)
+makedepends=(git)
+checkdepends=()
+optdepends=()
+provides=(imhex)
+conflicts=(imhex)
+replaces=()
+backup=()
+options=()
+source=($repo"/releases/download/v$pkgver/imhex-$pkgver-ArchLinux.pkg.tar.zst")
+noextract=()
+md5sums=(SKIP)
+validpgpkeys=()
+
+package() {
+    tar -xf imhex-$pkgver-ArchLinux.pkg.tar.zst
+
+    install -DT $srcdir/usr/bin/imhex $pkgdir/usr/bin/imhex
+    install -DT $srcdir/usr/lib/libimhex.so $pkgdir/usr/lib/libimhex.so
+
+    for plugin in $srcdir/usr/share/imhex/plugins/*.hexplug;
+    do
+	    install -DT $plugin $pkgdir/usr/share/imhex/plugins/`basename $plugin`
+    done
+
+	cp -r $srcdir/usr/share/imhex/{constants,encodings,includes,magic,patterns} $pkgdir/usr/share/imhex
+    install -d $pkgdir/usr/share/imhex
+}

dist/Brewfile

@@ -1,12 +1,11 @@
-brew "glfw3"
+brew "glfw"
 brew "mbedtls"
-brew "capstone"
 brew "nlohmann-json"
-brew "glm"
 brew "cmake"
+brew "ccache"
 brew "python3"
 brew "freetype2"
 brew "libmagic"
-
-# TODO: Remove this when XCode version of clang will support the same level as LLVM 10
-brew "llvm"
+brew "pkg-config"
+brew "llvm"
+brew "gcc@12"

dist/DEBIAN/control.in

@@ -0,0 +1,12 @@
+Package: ImHex
+Version: ${PROJECT_VERSION}
+Section: editors
+Priority: optional
+Architecture: amd64
+License: GNU GPL-2
+Depends: libglfw3, libmagic1, libmbedtls14, libpython3.10, libfreetype6, libopengl0, libgtk-3-0
+Maintainer: WerWolv <hey@werwolv.net>
+Description: ImHex Hex Editor
+ A Hex Editor for Reverse Engineers, Programmers and
+ people who value their retinas when working at 3 AM.
+

dist/DEBIAN/imhex.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Name=ImHex
+Comment=ImHex Hex Editor
+GenericName=Hex Editor
+Exec=/usr/bin/imhex %U
+Icon=/usr/share/pixmaps/imhex.png
+Type=Application
+StartupNotify=true
+Categories=GNOME;GTK;Development;
+StartupWMClass=imhex
+

dist/Dockerfile

@@ -0,0 +1,27 @@
+FROM archlinux:latest
+
+MAINTAINER WerWolv "hey@werwolv.net"
+
+# Install dependencies
+RUN pacman -Syy --needed --noconfirm
+RUN pacman -S --needed --noconfirm      \
+    git                                 \
+    cmake                               \
+    base-devel                          \
+    gcc                                 \
+    pkg-config                          \
+    glfw-x11                            \
+    file                                \
+    mbedtls                             \
+    python3                             \
+    freetype2                           \
+    gtk3
+
+# Clone ImHex
+RUN git clone https://github.com/WerWolv/ImHex --recurse-submodules /root/ImHex
+
+# Build ImHex
+RUN mkdir /root/ImHex/build
+WORKDIR /root/ImHex/build
+RUN cmake .. && make -j
+WORKDIR /root/ImHex

dist/ImHex-9999.ebuild

@@ -26,9 +26,7 @@ RDEPEND="${DEPEND}
 		media-libs/glfw
 		sys-apps/file
 		dev-libs/mbedtls
-		dev-libs/capstone
-		sys-devel/llvm
 		dev-cpp/nlohmann_json
-		media-libs/glm
+		x11-libs/gtk+
 		"
 BDEPEND="${DEPEND}"

dist/compiling/linux.md

@@ -0,0 +1,41 @@
+### Compiling ImHex on Linux
+
+Dependency installation scripts are available for many common Linux distributions in the [/dist](dist) folder.
+After all the dependencies are installed, run the following commands to build ImHex:
+
+```sh
+mkdir -p build
+cd build
+CC=gcc-12 CXX=g++-12 cmake                    \
+    -DCMAKE_BUILD_TYPE=Release                \
+    -DCMAKE_INSTALL_PREFIX="/usr" 	          \
+    -DCMAKE_C_COMPILER_LAUNCHER=ccache        \
+    -DCMAKE_CXX_COMPILER_LAUNCHER=ccache      \
+    -DCMAKE_C_FLAGS="-fuse-ld=lld"            \
+    -DCMAKE_CXX_FLAGS="-fuse-ld=lld"          \
+    -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache     \
+    -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache   \
+    -DRUST_PATH="$HOME/.cargo/bin/"           \
+    ..
+make -j 4 install
+```
+
+---
+
+Put the ImHex executable into the `/usr/bin` folder.
+Put libimhex.so into the `/usr/lib` folder.
+Configuration files go to `/usr/etc/imhex` or `~/.config/imhex`.
+All other files belong in `/usr/share/imhex` or `~/.local/share/imhex`:
+
+```
+Patterns: /usr/share/imhex/patterns
+Pattern Includes: /usr/share/imhex/includes
+Magic files: /usr/share/imhex/magic
+Python: /usr/share/imhex/lib/pythonX.X
+Plugins: /usr/share/imhex/plugins
+Configuration: /etc/xdg/imhex/config
+```
+
+All paths follow the XDG Base Directories standard, and can thus be modified
+with the environment variables `XDG_CONFIG_HOME`, `XDG_CONFIG_DIRS`,
+`XDG_DATA_HOME` and `XDG_DATA_DIRS`.

dist/compiling/macOS.md

@@ -0,0 +1,41 @@
+### Compiling ImHex on macOS
+
+To build ImHex on macOS, run the following commands:
+
+```sh
+brew bundle --no-lock --file dist/Brewfile
+mkdir -p build
+cd build
+CC=$(brew --prefix gcc@12)/bin/gcc-12     \
+CXX=$(brew --prefix gcc@12)/bin/g++-12    \
+OBJC=$(brew --prefix llvm)/bin/clang      \
+OBJCXX=$(brew --prefix llvm)/bin/clang++  \
+PKG_CONFIG_PATH="$(brew --prefix openssl)/lib/pkgconfig":"$(brew --prefix)/lib/pkgconfig" \
+MACOSX_DEPLOYMENT_TARGET="10.15"          \
+cmake                                     \
+  -DCMAKE_BUILD_TYPE=$BUILD_TYPE          \
+  -DCREATE_BUNDLE=ON                      \
+  -DCREATE_PACKAGE=ON                     \
+  -DCMAKE_C_COMPILER_LAUNCHER=ccache      \
+  -DCMAKE_CXX_COMPILER_LAUNCHER=ccache    \
+  -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache   \
+  -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
+  ..
+make -j4 package
+```
+
+Open the generated .dmg file and drag-n-drop the ImHex executable to the Applications folder
+
+All other files belong in `~/Library/Application Support/imhex`:
+```
+Patterns: ~/Library/Application Support/imhex/patterns
+Pattern Includes: ~/Library/Application Support/imhex/includes
+Magic files: ~/Library/Application Support/imhex/magic
+Python: ~/Library/Application Support/imhex/lib/pythonX.X
+Plugins: ~/Library/Application Support/imhex/plugins
+Configuration: ~/Library/Application Support/imhex/config
+```
+
+If the build fails while trying to find the macOS libraries, make sure you have
+XCode installed with `xcode-select --install`. Homebrew will also help get the
+most recent SDK installed and configured with `brew doctor`.

dist/compiling/windows.md

@@ -0,0 +1,23 @@
+### Compiling ImHex on Windows
+
+On Windows, ImHex is built through msys2 / mingw. To install all dependencies, open a mys2 window and run the PKGCONFIG script in the [dist/msys2](dist/msys2) folder.
+After all the dependencies are installed, run the following commands to build ImHex:
+
+```sh
+mkdir build
+cd build
+cmake -G "MinGW Makefiles"                \
+  -DCMAKE_BUILD_TYPE=Release              \
+  -DCMAKE_INSTALL_PREFIX="$PWD/install"   \
+  -DCMAKE_C_COMPILER_LAUNCHER=ccache      \
+  -DCMAKE_CXX_COMPILER_LAUNCHER=ccache    \
+  -DCMAKE_C_FLAGS="-fuse-ld=lld"          \
+  -DCMAKE_CXX_FLAGS="-fuse-ld=lld"        \
+  -DCMAKE_OBJC_COMPILER_LAUNCHER=ccache   \
+  -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
+  -DRUST_PATH="$USERPROFILE/.cargo/bin/"  \
+  ..
+mingw32-make -j install
+```
+
+ImHex will look for any extra resources either in various folders directly next to the executable or in `%localappdata%/imhex`

dist/get_deps_archlinux.sh

@@ -1,12 +1,12 @@
 #!/usr/bin/env sh
 
-pacman -S --needed \
-  cmake \
-  gcc \
-  glfw \
-  file \
-  mbedtls \
-  capstone \
-  glm \
-  python3 \
-  freetype2
+pacman -S $@ --needed \
+  cmake     \
+  gcc       \
+  lld       \
+  glfw      \
+  file      \
+  mbedtls   \
+  python3   \
+  freetype2 \
+  gtk3

dist/get_deps_debian.sh

@@ -1,28 +1,24 @@
 #!/usr/bin/env sh
 
-echo "As of 2020-12, Debian stable does not include g++-10, needs debian testing or unstable."
-
-# Tested on 2020-12-09 with Docker image bitnami/minideb:unstable
-
 # Install pkgconf (adds minimum dependencies) only if the equivalent pkf-config is not already installed.
-if !which pkg-config
+if ! which pkg-config
 then
     PKGCONF="pkgconf"
 fi
 
-apt install \
-  cmake \
-  g++-10 \
-  ${PKGCONF:-} \
-  libcapstone-dev \
-  libmagic-dev \
-  libglfw3-dev \
-  libglm-dev \
-  libjsoncpp-dev \
-  libmbedtls-dev \
-  libstdc++-10-dev \
-  python3-dev \
-  libfreetype-dev
-
-echo "Please consider this before running cmake (useful on e.g. Ubuntu 20.04):"
-echo "export CXX=g++-10"
+apt install -y \
+  build-essential       \
+  gcc-12                \
+  g++-12                \
+  lld                   \
+  ${PKGCONF:-}          \
+  cmake                 \
+  make                  \
+  ccache                \
+  libglfw3-dev          \
+  libglm-dev            \
+  libmagic-dev          \
+  libmbedtls-dev        \
+  python3-dev           \
+  libfreetype-dev       \
+  libgtk-3-dev

dist/get_deps_fedora.sh

@@ -1,13 +1,13 @@
 #!/usr/bin/env sh
 
-dnf install \
-  cmake \
-  gcc-c++ \
-  capstone-devel \
-  file-devel \
-  glfw-devel \
-  glm-devel \
-  mesa-libGL-devel \
-  mbedtls-devel \
-  python-devel \
-  freetype-devel
+dnf install         \
+  cmake             \
+  gcc-c++           \
+  lld               \
+  file-devel        \
+  glfw-devel        \
+  mesa-libGL-devel  \
+  mbedtls-devel     \
+  python-devel      \
+  freetype-devel    \
+  gtk3-devel

dist/get_deps_msys2.sh

@@ -1,15 +1,14 @@
 #!/usr/bin/env sh
 
-pacman -S --needed \
-  mingw-w64-x86_64-gcc \
-  mingw-w64-x86_64-cmake \
-  mingw-w64-x86_64-make \
-  mingw-w64-x86_64-capstone \
-  mingw-w64-x86_64-glfw \
-  mingw-w64-x86_64-glm \
-  mingw-w64-x86_64-file \
-  mingw-w64-x86_64-mbedtls \
-  mingw-w64-x86_64-polly \
-  mingw-w64-x86_64-python \
-  mingw-w64-x86_64-freetype \
+pacman -S --needed --noconfirm  \
+  mingw-w64-x86_64-gcc          \
+  mingw-w64-x86_64-lld          \
+  mingw-w64-x86_64-cmake        \
+  mingw-w64-x86_64-make         \
+  mingw-w64-x86_64-ccache       \
+  mingw-w64-x86_64-glfw         \
+  mingw-w64-x86_64-file         \
+  mingw-w64-x86_64-mbedtls      \
+  mingw-w64-x86_64-python       \
+  mingw-w64-x86_64-freetype     \
   mingw-w64-x86_64-dlfcn

dist/imhex.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Name=ImHex
+Comment=ImHex Hex Editor
+GenericName=Hex Editor
+Exec=imhex %U
+Icon=imhex
+Type=Application
+StartupNotify=true
+Categories=Development;IDE;
+StartupWMClass=imhex

dist/msys2/PKGBUILD

@@ -9,14 +9,13 @@ url="https://github.com/WerWolv/ImHex"
 license=('GPLv2')
 depends=("${MINGW_PACKAGE_PREFIX}-python")
 makedepends=("${MINGW_PACKAGE_PREFIX}-gcc"
+             "${MINGW_PACKAGE_PREFIX}-lld"
              "${MINGW_PACKAGE_PREFIX}-cmake"
              "${MINGW_PACKAGE_PREFIX}-make"
-             "${MINGW_PACKAGE_PREFIX}-dlsym"
-             "${MINGW_PACKAGE_PREFIX}-capstone"
+             "${MINGW_PACKAGE_PREFIX}-dlfcn"
              "${MINGW_PACKAGE_PREFIX}-glfw"
-             "${MINGW_PACKAGE_PREFIX}-glm"
              "${MINGW_PACKAGE_PREFIX}-file"
-             "${MINGW_PACKAGE_PREFIX}-openssl"
+             "${MINGW_PACKAGE_PREFIX}-mbedtls"
              "${MINGW_PACKAGE_PREFIX}-polly"
              "${MINGW_PACKAGE_PREFIX}-python"
              "${MINGW_PACKAGE_PREFIX}-freetype")

dist/net.werwolv.ImHex.yaml

@@ -0,0 +1,61 @@
+app-id: net.werwolv.ImHex
+runtime: org.freedesktop.Platform
+runtime-version: '20.08'
+default-branch: stable
+sdk: org.freedesktop.Sdk
+command: imhex
+
+finish-args:
+  - --share=ipc
+  - --socket=x11
+  - --filesystem=host
+  - --device=all
+
+modules:
+  - name: libiconv
+    sources:
+      - type: archive
+        url: https://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.16.tar.gz
+        sha256: e6a1b1b589654277ee790cce3734f07876ac4ccfaecbee8afa0b649cf529cc04
+
+  - name: glfw
+    buildsystem: cmake-ninja
+    builddir: true
+    config-opts:
+      - -DCMAKE_BUILD_TYPE=RelWithDebInfo
+      - -DBUILD_SHARED_LIBS:BOOL=ON
+    sources:
+      - type: archive
+        url: https://github.com/glfw/glfw/releases/download/3.3.2/glfw-3.3.2.zip
+        sha256: 08a33a512f29d7dbf78eab39bd7858576adcc95228c9efe8e4bc5f0f3261efc7
+    cleanup:
+      - /include
+      - /lib/pkgconfig
+
+  - name: mbedtls
+    buildsystem: cmake-ninja
+    config-opts:
+      - -DCMAKE_C_FLAGS=-fPIC
+    sources:
+      - type: archive
+        url: https://github.com/ARMmbed/mbedtls/archive/refs/tags/v2.27.0.tar.gz
+        sha256: 2a07856e541f0e5f6eaee4f78018c52f25bd244ed76f9020dea54a8b02cac6ea
+
+  - name: nlohmann-json
+    buildsystem: cmake-ninja
+    builddir: true
+    config-opts:
+      - -DCMAKE_BUILD_TYPE=RelWithDebInfo
+      - -DBUILD_TESTING=OFF
+
+    sources:
+      - type: archive
+        url: https://github.com/nlohmann/json/archive/v3.9.1.tar.gz
+        sha256: 4cf0df69731494668bdd6460ed8cb269b68de9c19ad8c27abc24cd72605b2d5b
+
+  - name: imhex
+    buildsystem: cmake
+
+    sources:
+      - type: git
+        url: https://github.com/WerWolv/ImHex.git

external/ImGui/CMakeLists.txt

@@ -1,40 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-project(imgui)
-
-set(CMAKE_CXX_STANDARD 17)
-
-find_package(PkgConfig REQUIRED)
-find_package(Freetype REQUIRED)
-pkg_search_module(GLM REQUIRED glm)
-pkg_search_module(GLFW REQUIRED glfw3)
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-
-add_library(imgui
-        source/imgui.cpp
-        source/imgui_demo.cpp
-        source/imgui_draw.cpp
-        source/imgui_freetype.cpp
-        source/imgui_impl_glfw.cpp
-        source/imgui_impl_opengl3.cpp
-        source/imgui_tables.cpp
-        source/imgui_widgets.cpp
-        source/ImGuiFileBrowser.cpp
-        source/TextEditor.cpp
-        source/imgui_imhex_extensions.cpp
-        source/imnodes.cpp
-)
-
-add_compile_definitions(IMGUI_IMPL_OPENGL_LOADER_GLAD)
-
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../glad ${CMAKE_CURRENT_BINARY_DIR}/external/glad)
-
-target_include_directories(imgui PUBLIC include ${FREETYPE_INCLUDE_DIRS} ${GLFW_INCLUDE_DIRS})
-
-target_link_directories(imgui PUBLIC ${GLM_INCLUDE_DIRS} ${GLFW_LIBRARY_DIRS})
-
-if (WIN32)
-    target_link_libraries(imgui libstdc++.a libgcc.a libharfbuzz.a libfreetype.a libharfbuzz.a libgraphite2.a libpng.a libbrotlidec-static.a libbrotlicommon-static.a libz.a libbz2.a librpcrt4.a glad libglfw3.a)
-elseif (UNIX)
-    target_link_libraries(imgui Freetype::Freetype glad glfw)
-endif()

external/ImGui/include/ImGuiFileBrowser.h

@@ -1,123 +0,0 @@
-#ifndef IMGUIFILEBROWSER_H
-#define IMGUIFILEBROWSER_H
-
-#include <imgui.h>
-#include <string>
-#include <vector>
-
-namespace imgui_addons
-{
-    class ImGuiFileBrowser
-    {
-        public:
-            ImGuiFileBrowser();
-            ~ImGuiFileBrowser();
-
-            enum class DialogMode
-            {
-                SELECT, //Select Directory Mode
-                OPEN,   //Open File mode
-                SAVE    //Save File mode.
-            };
-
-            /* Use this to show an open file dialog. The function takes label for the window,
-             * the size, a DialogMode enum value defining in which mode the dialog should operate and optionally the extensions that are valid for opening.
-             * Note that the select directory mode doesn't need any extensions.
-             */
-            bool showFileDialog(const std::string& label, const DialogMode mode, const ImVec2& sz_xy = ImVec2(0,0), const std::string& valid_types = "*.*");
-
-            /* Store the opened/saved file name or dir name (incase of selectDirectoryDialog) and the absolute path to the selection
-             * Should only be accessed when above functions return true else may contain garbage.
-             */
-            std::string selected_fn;
-            std::string selected_path;
-            std::string ext;    // Store the saved file extension
-
-
-        private:
-            struct Info
-            {
-                Info(std::string name, bool is_hidden) : name(name), is_hidden(is_hidden)
-                {
-                }
-                std::string name;
-                bool is_hidden;
-            };
-
-            //Enum used as bit flags.
-            enum FilterMode
-            {
-                FilterMode_Files = 0x01,
-                FilterMode_Dirs = 0x02
-            };
-
-            //Helper Functions
-            static std::string wStringToString(const wchar_t* wchar_arr);
-            static bool alphaSortComparator(const Info& a, const Info& b);
-            ImVec2 getButtonSize(std::string button_text);
-
-            /* Helper Functions that render secondary modals
-             * and help in validating file extensions and for filtering, parsing top navigation bar.
-             */
-            void setValidExtTypes(const std::string& valid_types_string);
-            bool validateFile();
-            void showErrorModal();
-            void showInvalidFileModal();
-            bool showReplaceFileModal();
-            void showHelpMarker(std::string desc);
-            void parsePathTabs(std::string str);
-            void filterFiles(int filter_mode);
-
-            /* Core Functions that render the 4 different regions making up
-             * a simple file dialog
-             */
-            bool renderNavAndSearchBarRegion();
-            bool renderFileListRegion();
-            bool renderInputTextAndExtRegion();
-            bool renderButtonsAndCheckboxRegion();
-            bool renderInputComboBox();
-            void renderExtBox();
-
-            /* Core Functions that handle navigation and
-             * reading directories/files
-             */
-            bool readDIR(std::string path);
-            bool onNavigationButtonClick(int idx);
-            bool onDirClick(int idx);
-
-            // Functions that reset state and/or clear file list when reading new directory
-            void clearFileList();
-            void closeDialog();
-
-            #if defined (WIN32) || defined (_WIN32) || defined (__WIN32)
-            bool loadWindowsDrives(); // Helper Function for Windows to load Drive Letters.
-            #endif
-
-            #if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__)
-            void initCurrentPath();   // Helper function for UNIX based system to load Absolute path using realpath
-            #endif
-
-            ImVec2 min_size, max_size, input_combobox_pos, input_combobox_sz;
-            DialogMode dialog_mode;
-            int filter_mode, col_items_limit, selected_idx, selected_ext_idx;
-            float col_width, ext_box_width;
-            bool show_hidden, show_inputbar_combobox, is_dir, is_appearing, filter_dirty, validate_file, path_input_enabled;
-            char input_fn[256];
-            char temp_dir_input[256];
-
-            std::vector<std::string> valid_exts;
-            std::vector<std::string> current_dirlist;
-            std::vector<Info> subdirs;
-            std::vector<Info> subfiles;
-            std::string current_path, error_msg, error_title, invfile_modal_id, repfile_modal_id;
-
-            ImGuiTextFilter filter;
-            std::string valid_types;
-            std::vector<const Info*> filtered_dirs; // Note: We don't need to call delete. It's just for storing filtered items from subdirs and subfiles so we don't use PassFilter every frame.
-            std::vector<const Info*> filtered_files;
-            std::vector< std::reference_wrapper<std::string> > inputcb_filter_files;
-    };
-}
-
-
-#endif // IMGUIFILEBROWSER_H

external/ImGui/include/imgui_freetype.h

@@ -1,36 +0,0 @@
-// dear imgui: wrapper to use FreeType (instead of stb_truetype)
-// Get latest version at https://github.com/ocornut/imgui/tree/master/misc/freetype
-// Original code by @Vuhdo (Aleksei Skriabin), maintained by @ocornut
-
-#pragma once
-
-#include "imgui.h"      // IMGUI_API, ImFontAtlas
-
-namespace ImGuiFreeType
-{
-    // Hinting greatly impacts visuals (and glyph sizes).
-    // When disabled, FreeType generates blurrier glyphs, more or less matches the stb's output.
-    // The Default hinting mode usually looks good, but may distort glyphs in an unusual way.
-    // The Light hinting mode generates fuzzier glyphs but better matches Microsoft's rasterizer.
-
-    // You can set those flags on a per font basis in ImFontConfig::RasterizerFlags.
-    // Use the 'extra_flags' parameter of BuildFontAtlas() to force a flag on all your fonts.
-    enum RasterizerFlags
-    {
-        // By default, hinting is enabled and the font's native hinter is preferred over the auto-hinter.
-        NoHinting       = 1 << 0,   // Disable hinting. This generally generates 'blurrier' bitmap glyphs when the glyph are rendered in any of the anti-aliased modes.
-        NoAutoHint      = 1 << 1,   // Disable auto-hinter.
-        ForceAutoHint   = 1 << 2,   // Indicates that the auto-hinter is preferred over the font's native hinter.
-        LightHinting    = 1 << 3,   // A lighter hinting algorithm for gray-level modes. Many generated glyphs are fuzzier but better resemble their original shape. This is achieved by snapping glyphs to the pixel grid only vertically (Y-axis), as is done by Microsoft's ClearType and Adobe's proprietary font renderer. This preserves inter-glyph spacing in horizontal text.
-        MonoHinting     = 1 << 4,   // Strong hinting algorithm that should only be used for monochrome output.
-        Bold            = 1 << 5,   // Styling: Should we artificially embolden the font?
-        Oblique         = 1 << 6,   // Styling: Should we slant the font, emulating italic style?
-        Monochrome      = 1 << 7    // Disable anti-aliasing. Combine this with MonoHinting for best results!
-    };
-
-    IMGUI_API bool BuildFontAtlas(ImFontAtlas* atlas, unsigned int extra_flags = 0);
-
-    // By default ImGuiFreeType will use IM_ALLOC()/IM_FREE().
-    // However, as FreeType does lots of allocations we provide a way for the user to redirect it to a separate memory heap if desired:
-    IMGUI_API void SetAllocatorFunctions(void* (*alloc_func)(size_t sz, void* user_data), void (*free_func)(void* ptr, void* user_data), void* user_data = NULL);
-}

external/ImGui/include/imgui_imhex_extensions.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <functional>
-
-#include <imgui.h>
-
-namespace ImGui {
-
-    bool Hyperlink(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
-    bool BulletHyperlink(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
-    bool DescriptionButton(const char* label, const char* description, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
-
-    void UnderlinedText(const char* label, ImColor color, const ImVec2& size_arg = ImVec2(0, 0));
-
-}

external/ImGui/include/imgui_memory_editor.h

@@ -1,779 +0,0 @@
-// Mini memory editor for Dear ImGui (to embed in your game/tools)
-// Get latest version at http://www.github.com/ocornut/imgui_club
-//
-// Right-click anywhere to access the Options menu!
-// You can adjust the keyboard repeat delay/rate in ImGuiIO.
-// The code assume a mono-space font for simplicity!
-// If you don't use the default font, use ImGui::PushFont()/PopFont() to switch to a mono-space font before caling this.
-//
-// Usage:
-//   // Create a window and draw memory editor inside it:
-//   static MemoryEditor mem_edit_1;
-//   static char data[0x10000];
-//   size_t data_size = 0x10000;
-//   mem_edit_1.DrawWindow("Memory Editor", data, data_size);
-//
-// Usage:
-//   // If you already have a window, use DrawContents() instead:
-//   static MemoryEditor mem_edit_2;
-//   ImGui::Begin("MyWindow")
-//   mem_edit_2.DrawContents(this, sizeof(*this), (size_t)this);
-//   ImGui::End();
-//
-// Changelog:
-// - v0.10: initial version
-// - v0.23 (2017/08/17): added to github. fixed right-arrow triggering a byte write.
-// - v0.24 (2018/06/02): changed DragInt("Rows" to use a %d data format (which is desirable since imgui 1.61).
-// - v0.25 (2018/07/11): fixed wording: all occurrences of "Rows" renamed to "Columns".
-// - v0.26 (2018/08/02): fixed clicking on hex region
-// - v0.30 (2018/08/02): added data preview for common data types
-// - v0.31 (2018/10/10): added OptUpperCaseHex option to select lower/upper casing display [@samhocevar]
-// - v0.32 (2018/10/10): changed signatures to use void* instead of unsigned char*
-// - v0.33 (2018/10/10): added OptShowOptions option to hide all the interactive option setting.
-// - v0.34 (2019/05/07): binary preview now applies endianness setting [@nicolasnoble]
-// - v0.35 (2020/01/29): using ImGuiDataType available since Dear ImGui 1.69.
-// - v0.36 (2020/05/05): minor tweaks, minor refactor.
-// - v0.40 (2020/10/04): fix misuse of ImGuiListClipper API, broke with Dear ImGui 1.79. made cursor position appears on left-side of edit box. option popup appears on mouse release. fix MSVC warnings where _CRT_SECURE_NO_WARNINGS wasn't working in recent versions.
-// - v0.41 (2020/10/05): fix when using with keyboard/gamepad navigation enabled.
-// - v0.42 (2020/10/14): fix for . character in ASCII view always being greyed out.
-//
-// Todo/Bugs:
-// - This is generally old code, it should work but please don't use this as reference!
-// - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text cursor appear at position 1 for one frame.
-// - Using InputText() is awkward and maybe overkill here, consider implementing something custom.
-
-#pragma once
-
-#include <stdio.h>      // sprintf, scanf
-#include <stdint.h>     // uint8_t, etc.
-#include <hex/helpers/utils.hpp>
-
-#include <hex/views/view.hpp>
-
-#include <string>
-
-#ifdef _MSC_VER
-#define _PRISizeT   "I"
-#define ImSnprintf  _snprintf
-#else
-#define _PRISizeT   "z"
-#define ImSnprintf  snprintf
-#endif
-
-#ifdef _MSC_VER
-#pragma warning (push)
-#pragma warning (disable: 4996) // warning C4996: 'sprintf': This function or variable may be unsafe.
-#endif
-
-ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
-
-struct MemoryEditor
-{
-    enum DataFormat
-    {
-        DataFormat_Bin = 0,
-        DataFormat_Dec = 1,
-        DataFormat_Hex = 2,
-        DataFormat_COUNT
-    };
-
-    struct DecodeData {
-        std::string data;
-        size_t advance;
-        ImColor color;
-    };
-
-    // Settings
-    bool            ReadOnly;                                   // = false  // disable any editing.
-    int             Cols;                                       // = 16     // number of columns to display.
-    bool            OptShowOptions;                             // = true   // display options button/context menu. when disabled, options will be locked unless you provide your own UI for them.
-    bool            OptShowHexII;                               // = false  // display values in HexII representation instead of regular hexadecimal: hide null/zero bytes, ascii values as ".X".
-    bool            OptShowAscii;                               // = true   // display ASCII representation on the right side.
-    bool            OptShowAdvancedDecoding;                    // = true   // display advanced decoding data on the right side.
-    bool            OptGreyOutZeroes;                           // = true   // display null/zero bytes using the TextDisabled color.
-    bool            OptUpperCaseHex;                            // = true   // display hexadecimal values as "FF" instead of "ff".
-    int             OptMidColsCount;                            // = 8      // set to 0 to disable extra spacing between every mid-cols.
-    int             OptAddrDigitsCount;                         // = 0      // number of addr digits to display (default calculated based on maximum displayed addr).
-    ImU32           HighlightColor;                             //          // background color of highlighted bytes.
-    ImU8            (*ReadFn)(const ImU8* data, size_t off);    // = 0      // optional handler to read bytes.
-    void            (*WriteFn)(ImU8* data, size_t off, ImU8 d); // = 0      // optional handler to write bytes.
-    bool            (*HighlightFn)(const ImU8* data, size_t off, bool next);//= 0      // optional handler to return Highlight property (to support non-contiguous highlighting).
-    void            (*HoverFn)(const ImU8 *data, size_t off);
-    DecodeData      (*DecodeFn)(const ImU8 *data, size_t off);
-
-    // [Internal State]
-    bool            ContentsWidthChanged;
-    size_t          DataPreviewAddr;
-    size_t          DataPreviewAddrOld;
-    size_t          DataPreviewAddrEnd;
-    size_t          DataPreviewAddrEndOld;
-    size_t          DataEditingAddr;
-    bool            DataEditingTakeFocus;
-    char            DataInputBuf[32];
-    char            AddrInputBuf[32];
-    size_t          GotoAddr;
-    size_t          HighlightMin, HighlightMax;
-    int             PreviewEndianess;
-    ImGuiDataType   PreviewDataType;
-
-    MemoryEditor()
-    {
-        // Settings
-        ReadOnly = false;
-        Cols = 16;
-        OptShowOptions = true;
-        OptShowHexII = false;
-        OptShowAscii = true;
-        OptShowAdvancedDecoding = true;
-        OptGreyOutZeroes = true;
-        OptUpperCaseHex = true;
-        OptMidColsCount = 8;
-        OptAddrDigitsCount = 0;
-        HighlightColor = IM_COL32(255, 255, 255, 50);
-        ReadFn = NULL;
-        WriteFn = NULL;
-        HighlightFn = NULL;
-        HoverFn = NULL;
-        DecodeFn = NULL;
-
-        // State/Internals
-        ContentsWidthChanged = false;
-        DataPreviewAddr = DataEditingAddr = DataPreviewAddrEnd = (size_t)-1;
-        DataPreviewAddrOld = DataPreviewAddrEndOld = (size_t)-1;
-        DataEditingTakeFocus = false;
-        memset(DataInputBuf, 0, sizeof(DataInputBuf));
-        memset(AddrInputBuf, 0, sizeof(AddrInputBuf));
-        GotoAddr = (size_t)-1;
-        HighlightMin = HighlightMax = (size_t)-1;
-        PreviewEndianess = 0;
-        PreviewDataType = ImGuiDataType_S32;
-    }
-
-    void GotoAddrAndHighlight(size_t addr_min, size_t addr_max)
-    {
-        GotoAddr = addr_min;
-        HighlightMin = addr_min;
-        HighlightMax = addr_max;
-    }
-
-    struct Sizes
-    {
-        int     AddrDigitsCount;
-        float   LineHeight;
-        float   GlyphWidth;
-        float   HexCellWidth;
-        float   SpacingBetweenMidCols;
-        float   PosHexStart;
-        float   PosHexEnd;
-        float   PosAsciiStart;
-        float   PosAsciiEnd;
-        float   PosDecodingStart;
-        float   PosDecodingEnd;
-        float   WindowWidth;
-
-        Sizes() { memset(this, 0, sizeof(*this)); }
-    };
-
-    void CalcSizes(Sizes& s, size_t mem_size, size_t base_display_addr)
-    {
-        ImGuiStyle& style = ImGui::GetStyle();
-        s.AddrDigitsCount = OptAddrDigitsCount;
-        if (s.AddrDigitsCount == 0)
-            for (size_t n = base_display_addr + mem_size - 1; n > 0; n >>= 4)
-                s.AddrDigitsCount++;
-        s.LineHeight = ImGui::GetTextLineHeight();
-        s.GlyphWidth = ImGui::CalcTextSize("F").x + 1;                  // We assume the font is mono-space
-        s.HexCellWidth = (float)(int)(s.GlyphWidth * 2.5f);             // "FF " we include trailing space in the width to easily catch clicks everywhere
-        s.SpacingBetweenMidCols = (float)(int)(s.HexCellWidth * 0.25f); // Every OptMidColsCount columns we add a bit of extra spacing
-        s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth;
-        s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols);
-        s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd;
-
-        if (OptShowAscii && OptShowAdvancedDecoding) {
-            s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
-            if (OptMidColsCount > 0)
-                s.PosAsciiStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
-            s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
-
-            s.PosDecodingStart = s.PosAsciiEnd + s.GlyphWidth * 1;
-            if (OptMidColsCount > 0)
-                s.PosDecodingStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
-            s.PosDecodingEnd = s.PosDecodingStart + Cols * s.GlyphWidth;
-        } else if (OptShowAscii) {
-            s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
-            if (OptMidColsCount > 0)
-                s.PosAsciiStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
-            s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
-        } else if (OptShowAdvancedDecoding) {
-            s.PosDecodingStart = s.PosHexEnd + s.GlyphWidth * 1;
-            if (OptMidColsCount > 0)
-                s.PosDecodingStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
-            s.PosDecodingEnd = s.PosDecodingStart + Cols * s.GlyphWidth;
-        }
-        s.WindowWidth = s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
-    }
-
-    // Standalone Memory Editor window
-    void DrawWindow(const char* title, bool *p_open, void* mem_data, size_t mem_size, size_t base_display_addr = 0x0000)
-    {
-        Sizes s;
-        CalcSizes(s, mem_size, base_display_addr);
-
-        if (ImGui::Begin(title, p_open, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoNavInputs))
-        {
-            if (DataPreviewAddr != DataPreviewAddrOld || DataPreviewAddrEnd != DataPreviewAddrEndOld) {
-                hex::Region selectionRegion = { std::min(DataPreviewAddr, DataPreviewAddrEnd), std::max(DataPreviewAddr, DataPreviewAddrEnd) - std::min(DataPreviewAddr, DataPreviewAddrEnd) };
-                hex::View::postEvent(hex::Events::RegionSelected, selectionRegion);
-            }
-
-            DataPreviewAddrOld = DataPreviewAddr;
-            DataPreviewAddrEndOld = DataPreviewAddrEnd;
-
-            DrawContents(mem_data, mem_size, base_display_addr);
-            if (ContentsWidthChanged)
-            {
-                CalcSizes(s, mem_size, base_display_addr);
-                ImGui::SetWindowSize(ImVec2(s.WindowWidth, ImGui::GetWindowSize().y));
-            }
-        }
-        ImGui::End();
-
-    }
-
-    // Memory Editor contents only
-    void DrawContents(void* mem_data_void, size_t mem_size, size_t base_display_addr = 0x0000)
-    {
-        if (Cols < 1)
-            Cols = 1;
-
-        ImU8* mem_data = (ImU8*)mem_data_void;
-        Sizes s;
-        CalcSizes(s, mem_size, base_display_addr);
-        ImGuiStyle& style = ImGui::GetStyle();
-
-        // We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window.
-        // This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move.
-        const float height_separator = style.ItemSpacing.y;
-        float footer_height = 0;
-        if (OptShowOptions)
-            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
-
-        ImGui::BeginChild("offset", ImVec2(0, s.LineHeight), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
-        ImGui::Text("%*c   ", s.AddrDigitsCount, ' ');
-        for (int i = 0; i < Cols; i++) {
-            float byte_pos_x = s.PosHexStart + s.HexCellWidth * i;
-            if (OptMidColsCount > 0)
-                byte_pos_x += (float)(i / OptMidColsCount) * s.SpacingBetweenMidCols;
-            ImGui::SameLine(byte_pos_x);
-            ImGui::Text("%02X", i);
-        }
-        ImGui::EndChild();
-
-        ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
-
-        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
-        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
-
-
-
-        // We are not really using the clipper API correctly here, because we rely on visible_start_addr/visible_end_addr for our scrolling function.
-        ImGuiListClipper clipper;
-        ImDrawList* draw_list = ImGui::GetWindowDrawList();
-
-        const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
-        clipper.Begin(line_total_count, s.LineHeight);
-        clipper.Step();
-        const size_t visible_start_addr = clipper.DisplayStart * Cols;
-        const size_t visible_end_addr = clipper.DisplayEnd * Cols;
-        const size_t visible_count = visible_end_addr - visible_start_addr;
-
-        bool data_next = false;
-
-        if (DataEditingAddr >= mem_size)
-            DataEditingAddr = (size_t)-1;
-        if (DataPreviewAddr >= mem_size)
-            DataPreviewAddr = (size_t)-1;
-        if (DataPreviewAddrEnd >= mem_size)
-            DataPreviewAddrEnd = (size_t)-1;
-
-        size_t data_editing_addr_backup = DataEditingAddr;
-        size_t data_preview_addr_backup = DataPreviewAddr;
-        size_t data_editing_addr_next = (size_t)-1;
-        size_t data_preview_addr_next = (size_t)-1;
-
-        if (ImGui::IsWindowFocused()) {
-            if (DataEditingAddr != (size_t)-1)
-            {
-                // Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
-                if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataEditingAddr >= (size_t)Cols)          { data_editing_addr_next = DataEditingAddr - Cols; DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataEditingAddr < mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataEditingAddr > 0)               { data_editing_addr_next = DataEditingAddr - 1; DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataEditingAddr < mem_size - 1)   { data_editing_addr_next = DataEditingAddr + 1; DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageUp)) && DataEditingAddr > 0)                  { data_editing_addr_next = std::max(s64(0), s64(DataEditingAddr) - s64(visible_count)); DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageDown)) && DataEditingAddr < mem_size - 1)     { data_editing_addr_next = std::min(s64(mem_size - 1), s64(DataEditingAddr) + s64(visible_count)); DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Home)) && DataEditingAddr > 0)                    { data_editing_addr_next = 0; DataEditingTakeFocus = true; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_End)) && DataEditingAddr < mem_size - 1)          { data_editing_addr_next = mem_size - 1; DataEditingTakeFocus = true; }
-            } else if (DataPreviewAddr != -1) {
-                // Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
-                if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataPreviewAddr >= (size_t)Cols)          { DataPreviewAddr = data_preview_addr_next = DataPreviewAddr - Cols; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataPreviewAddr < mem_size - Cols) { DataPreviewAddr = data_preview_addr_next = DataPreviewAddr + Cols; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataPreviewAddr > 0)               { DataPreviewAddr = data_preview_addr_next = DataPreviewAddr - 1; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataPreviewAddr < mem_size - 1)   { DataPreviewAddr = data_preview_addr_next = DataPreviewAddr + 1; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageUp)) && DataPreviewAddr > 0)                  { DataPreviewAddr = data_preview_addr_next = std::max(s64(0), s64(DataPreviewAddr) - s64(visible_count)); if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageDown)) && DataPreviewAddr < mem_size - 1)     { DataPreviewAddr = data_preview_addr_next = std::min(s64(mem_size - 1), s64(DataPreviewAddr) + s64(visible_count)); if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Home)) && DataPreviewAddr > 0)                    { DataPreviewAddr = data_preview_addr_next = 0; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-                else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_End)) && DataPreviewAddr < mem_size - 1)          { DataPreviewAddr = data_preview_addr_next = mem_size - 1; if (!ImGui::GetIO().KeyShift) DataPreviewAddrEnd = DataPreviewAddr; }
-            }
-        }
-
-        if (data_preview_addr_next != (size_t)-1 && (data_preview_addr_next / Cols) != (data_preview_addr_backup / Cols))
-        {
-            // Track cursor movements
-            const int scroll_offset = ((int)(data_preview_addr_next / Cols) - (int)(data_preview_addr_backup / Cols));
-            const bool scroll_desired = (scroll_offset < 0 && data_preview_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_preview_addr_next > visible_end_addr - Cols * 2);
-            if (scroll_desired)
-                ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight);
-        }
-        if (data_editing_addr_next != (size_t)-1 && (data_editing_addr_next / Cols) != (data_editing_addr_backup / Cols))
-        {
-            // Track cursor movements
-            const int scroll_offset = ((int)(data_editing_addr_next / Cols) - (int)(data_editing_addr_backup / Cols));
-            const bool scroll_desired = (scroll_offset < 0 && data_editing_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_editing_addr_next > visible_end_addr - Cols * 2);
-            if (scroll_desired)
-                ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight);
-        }
-
-        // Draw vertical separator
-        ImVec2 window_pos = ImGui::GetWindowPos();
-        if (OptShowAscii)
-            draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));
-        if (OptShowAdvancedDecoding)
-            draw_list->AddLine(ImVec2(window_pos.x + s.PosDecodingStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosDecodingStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));
-
-        const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
-        const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;
-
-        const char* format_address = OptUpperCaseHex ? "%0*" _PRISizeT "X: " : "%0*" _PRISizeT "x: ";
-        const char* format_data = OptUpperCaseHex ? "%0*" _PRISizeT "X" : "%0*" _PRISizeT "x";
-        const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x";
-        const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x ";
-
-        bool tooltipShown = false;
-        for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines
-        {
-            size_t addr = (size_t)(line_i * Cols);
-            ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr);
-
-            // Draw Hexadecimal
-            for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
-            {
-                float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
-                if (OptMidColsCount > 0)
-                    byte_pos_x += (float)(n / OptMidColsCount) * s.SpacingBetweenMidCols;
-                ImGui::SameLine(byte_pos_x);
-
-                // Draw highlight
-                bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
-                bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr, false));
-                bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr <= DataPreviewAddrEnd) || (addr >= DataPreviewAddrEnd && addr <= DataPreviewAddr);
-                if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
-                {
-                    ImVec2 pos = ImGui::GetCursorScreenPos();
-                    float highlight_width = s.GlyphWidth * 2;
-                    bool is_next_byte_highlighted = (addr + 1 < mem_size) &&
-                                                    ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) ||
-                                                    (HighlightFn && HighlightFn(mem_data, addr + 1, true)) ||
-                                                    ((addr + 1) >= DataPreviewAddr && (addr + 1) <= DataPreviewAddrEnd) || ((addr + 1) >= DataPreviewAddrEnd && (addr + 1) <= DataPreviewAddr));
-                    if (is_next_byte_highlighted)
-                    {
-                        highlight_width = s.HexCellWidth;
-                        if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0)
-                            highlight_width += s.SpacingBetweenMidCols;
-                    }
-
-                    ImU32 color = HighlightColor;
-                    if ((is_highlight_from_user_range + is_highlight_from_user_func + is_highlight_from_preview) > 1)
-                        color = (ImAlphaBlendColors(HighlightColor, 0x60C08080) & 0x00FFFFFF) | 0x90000000;
-
-                    draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), color);
-                }
-
-                if (DataEditingAddr == addr)
-                {
-                    // Display text input on current byte
-                    bool data_write = false;
-                    ImGui::PushID((void*)addr);
-                    if (DataEditingTakeFocus)
-                    {
-                        ImGui::SetKeyboardFocusHere();
-                        ImGui::CaptureKeyboardFromApp(true);
-                        sprintf(AddrInputBuf, format_data, s.AddrDigitsCount, base_display_addr + addr);
-                        sprintf(DataInputBuf, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
-                    }
-                    ImGui::PushItemWidth(s.GlyphWidth * 2);
-                    struct UserData
-                    {
-                        // FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here.
-                        static int Callback(ImGuiInputTextCallbackData* data)
-                        {
-                            UserData* user_data = (UserData*)data->UserData;
-                            if (!data->HasSelection())
-                                user_data->CursorPos = data->CursorPos;
-                            if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen)
-                            {
-                                // When not editing a byte, always rewrite its content (this is a bit tricky, since InputText technically "owns" the master copy of the buffer we edit it in there)
-                                data->DeleteChars(0, data->BufTextLen);
-                                data->InsertChars(0, user_data->CurrentBufOverwrite);
-                                data->SelectionStart = 0;
-                                data->SelectionEnd = 2;
-                                data->CursorPos = 0;
-                            }
-                            return 0;
-                        }
-                        char   CurrentBufOverwrite[3];  // Input
-                        int    CursorPos;               // Output
-                    };
-                    UserData user_data;
-                    user_data.CursorPos = -1;
-                    sprintf(user_data.CurrentBufOverwrite, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
-                    ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysInsertMode | ImGuiInputTextFlags_CallbackAlways;
-                    if (ImGui::InputText("##data", DataInputBuf, 32, flags, UserData::Callback, &user_data))
-                        data_write = data_next = true;
-                    else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
-                        DataEditingAddr = data_editing_addr_next = (size_t)-1;
-                    DataEditingTakeFocus = false;
-                    ImGui::PopItemWidth();
-                    if (user_data.CursorPos >= 2)
-                        data_write = data_next = true;
-                    if (data_editing_addr_next != (size_t)-1)
-                        data_write = data_next = false;
-                    unsigned int data_input_value = 0;
-                    if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
-                    {
-                        if (WriteFn)
-                            WriteFn(mem_data, addr, (ImU8)data_input_value);
-                        else
-                            mem_data[addr] = (ImU8)data_input_value;
-                    }
-                    ImGui::PopID();
-                }
-                else
-                {
-                    // NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on.
-                    ImU8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
-
-                    if (OptShowHexII)
-                    {
-                        if ((b >= 32 && b < 128))
-                            ImGui::Text(".%c ", b);
-                        else if (b == 0xFF && OptGreyOutZeroes)
-                            ImGui::TextDisabled("## ");
-                        else if (b == 0x00)
-                            ImGui::Text("   ");
-                        else
-                            ImGui::Text(format_byte_space, b);
-                    }
-                    else
-                    {
-                        if (b == 0 && OptGreyOutZeroes)
-                            ImGui::TextDisabled("00 ");
-                        else
-                            ImGui::Text(format_byte_space, b);
-                    }
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0) && !ImGui::GetIO().KeyShift)
-                    {
-                        if (!ReadOnly && ImGui::IsMouseDoubleClicked(0)) {
-                            DataEditingTakeFocus = true;
-                            data_editing_addr_next = addr;
-                        }
-
-                        DataPreviewAddr = addr;
-                        DataPreviewAddrEnd = addr;
-                    }
-                    if (ImGui::IsItemHovered() && ((ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyShift) || ImGui::IsMouseDragging(0))) {
-                        DataPreviewAddrEnd = addr;
-                    }
-                    if (ImGui::IsItemHovered() && !tooltipShown) {
-                        if (HoverFn) {
-                            HoverFn(mem_data, addr);
-                            tooltipShown = true;
-                        }
-                    }
-                }
-            }
-
-            if (OptShowAscii)
-            {
-                // Draw ASCII values
-                ImGui::SameLine(s.PosAsciiStart);
-                ImVec2 pos = ImGui::GetCursorScreenPos();
-                addr = line_i * Cols;
-
-                ImGui::PushID(-1);
-                ImGui::SameLine();
-                ImGui::Dummy(ImVec2(s.GlyphWidth, s.LineHeight));
-
-                ImGui::PopID();
-
-                for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
-                {
-                    if (addr == DataEditingAddr)
-                    {
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
-                    }
-                    unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
-                    char display_c = (c < 32 || c >= 128) ? '.' : c;
-                    draw_list->AddText(pos, (display_c == c) ? color_text : color_disabled, &display_c, &display_c + 1);
-
-                    // Draw highlight
-                    bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
-                    bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr, false));
-                    bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr <= DataPreviewAddrEnd) || (addr >= DataPreviewAddrEnd && addr <= DataPreviewAddr);
-                    if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
-                    {
-                        ImU32 color = HighlightColor;
-                        if ((is_highlight_from_user_range + is_highlight_from_user_func + is_highlight_from_preview) > 1)
-                            color = (ImAlphaBlendColors(HighlightColor, 0x60C08080) & 0x00FFFFFF) | 0x90000000;
-
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), color);
-                    }
-
-
-                    ImGui::PushID(line_i * Cols + n);
-                    ImGui::SameLine();
-                    ImGui::Dummy(ImVec2(s.GlyphWidth, s.LineHeight));
-
-                    ImGui::PopID();
-
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0) && !ImGui::GetIO().KeyShift)
-                    {
-                        if (!ReadOnly && ImGui::IsMouseDoubleClicked(0)) {
-                            DataEditingTakeFocus = true;
-                            data_editing_addr_next = addr;
-                        }
-
-                        DataPreviewAddr = addr;
-                        DataPreviewAddrEnd = addr;
-
-                    }
-                    if (ImGui::IsItemHovered() && ((ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyShift) || ImGui::IsMouseDragging(0))) {
-                        DataPreviewAddrEnd = addr;
-                    }
-
-                    pos.x += s.GlyphWidth;
-                }
-
-                ImGui::PushID(-1);
-                ImGui::SameLine();
-                ImGui::Dummy(ImVec2(s.GlyphWidth, s.LineHeight));
-
-                ImGui::PopID();
-            }
-
-            if (OptShowAdvancedDecoding && DecodeFn) {
-                // Draw decoded bytes
-                ImGui::SameLine(s.PosDecodingStart);
-                ImVec2 pos = ImGui::GetCursorScreenPos();
-                addr = line_i * Cols;
-
-                ImGui::PushID(-1);
-                ImGui::SameLine();
-                ImGui::Dummy(ImVec2(s.GlyphWidth, s.LineHeight));
-
-                ImGui::PopID();
-
-                for (int n = 0; n < Cols && addr < mem_size;)
-                {
-                    auto decodedData = DecodeFn(mem_data, addr);
-
-                    auto displayData = decodedData.data;
-                    auto glyphWidth = ImGui::CalcTextSize(displayData.c_str()).x + 1;
-
-                    if (addr == DataEditingAddr)
-                    {
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + glyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + glyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
-                    }
-
-                    draw_list->AddText(pos, decodedData.color, displayData.c_str(), displayData.c_str() + displayData.length());
-
-                    // Draw highlight
-                    bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
-                    bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr, false));
-                    bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr <= DataPreviewAddrEnd) || (addr >= DataPreviewAddrEnd && addr <= DataPreviewAddr);
-                    if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
-                    {
-                        ImU32 color = HighlightColor;
-                        if ((is_highlight_from_user_range + is_highlight_from_user_func + is_highlight_from_preview) > 1)
-                            color = (ImAlphaBlendColors(HighlightColor, 0x60C08080) & 0x00FFFFFF) | 0x90000000;
-
-                        draw_list->AddRectFilled(pos, ImVec2(pos.x + glyphWidth, pos.y + s.LineHeight), color);
-                    }
-
-
-                    ImGui::PushID(line_i * Cols + n);
-                    ImGui::SameLine();
-                    ImGui::Dummy(ImVec2(glyphWidth, s.LineHeight));
-
-                    ImGui::PopID();
-
-                    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0) && !ImGui::GetIO().KeyShift)
-                    {
-                        if (!ReadOnly && ImGui::IsMouseDoubleClicked(0)) {
-                            DataEditingTakeFocus = true;
-                            data_editing_addr_next = addr;
-                        }
-
-                        DataPreviewAddr = addr;
-                        DataPreviewAddrEnd = addr;
-
-                    }
-                    if (ImGui::IsItemHovered() && ((ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyShift) || ImGui::IsMouseDragging(0))) {
-                        DataPreviewAddrEnd = addr;
-                    }
-
-                    pos.x += glyphWidth;
-
-                    if (addr <= 1) {
-                        n++;
-                        addr++;
-                    } else {
-                        n += decodedData.advance;
-                        addr += decodedData.advance;
-                    }
-                }
-            }
-        }
-        IM_ASSERT(clipper.Step() == false);
-        clipper.End();
-        ImGui::PopStyleVar(2);
-        ImGui::EndChild();
-
-        if (data_next && DataEditingAddr < mem_size)
-        {
-            DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1;
-            DataEditingTakeFocus = true;
-        }
-        else if (data_editing_addr_next != (size_t)-1)
-        {
-            DataEditingAddr = DataPreviewAddr = DataPreviewAddrEnd = data_editing_addr_next;
-        }
-
-        if (OptShowOptions)
-        {
-            ImGui::Separator();
-            DrawOptionsLine(s, mem_data, mem_size, base_display_addr);
-        }
-
-        // Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child)
-        ImGui::SetCursorPosX(s.WindowWidth);
-    }
-
-    void DrawOptionsLine(const Sizes& s, void* mem_data, size_t mem_size, size_t base_display_addr)
-    {
-        IM_UNUSED(mem_data);
-        ImGuiStyle& style = ImGui::GetStyle();
-        const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
-        const char* format_selection = OptUpperCaseHex ? "Selection %0*" _PRISizeT "X..%0*" _PRISizeT "X (%ld %s)" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x (%ld %s)";
-
-        // Options menu
-        if (ImGui::Button("Options"))
-            ImGui::OpenPopup("options");
-
-        if (ImGui::BeginPopup("options")) {
-            ImGui::PushItemWidth(ImGui::CalcTextSize("00 cols").x * 1.1f);
-            if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) { ContentsWidthChanged = true; if (Cols < 1) Cols = 1; }
-            ImGui::PopItemWidth();
-            ImGui::Checkbox("Show HexII", &OptShowHexII);
-            if (ImGui::Checkbox("Show Ascii", &OptShowAscii)) { ContentsWidthChanged = true; }
-            if (ImGui::Checkbox("Show Advanced Decoding", &OptShowAdvancedDecoding)) { ContentsWidthChanged = true; }
-            ImGui::Checkbox("Grey out zeroes", &OptGreyOutZeroes);
-            ImGui::Checkbox("Uppercase Hex", &OptUpperCaseHex);
-
-            ImGui::EndPopup();
-        }
-
-        ImGui::SameLine();
-        ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1);
-        if (DataPreviewAddr != (size_t)-1 && DataPreviewAddrEnd != (size_t)-1) {
-            ImGui::SameLine();
-            ImGui::Spacing();
-            ImGui::SameLine();
-
-            auto selectionStart = std::min(DataPreviewAddr, DataPreviewAddrEnd);
-            auto selectionEnd = std::max(DataPreviewAddr, DataPreviewAddrEnd);
-
-            size_t regionSize = (selectionEnd - selectionStart) + 1;
-            ImGui::Text(format_selection, s.AddrDigitsCount, base_display_addr + selectionStart, s.AddrDigitsCount, base_display_addr + selectionEnd, regionSize, regionSize == 1 ? "byte" : "bytes");
-        }
-
-        if (GotoAddr != (size_t)-1)
-        {
-            if (GotoAddr < mem_size)
-            {
-                ImGui::BeginChild("##scrolling");
-                ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y + (GotoAddr / Cols) * ImGui::GetTextLineHeight());
-                ImGui::EndChild();
-                DataEditingAddr = DataPreviewAddr = DataPreviewAddrEnd = GotoAddr;
-                DataEditingTakeFocus = true;
-            }
-            GotoAddr = (size_t)-1;
-        }
-    }
-
-    static bool IsBigEndian()
-    {
-        uint16_t x = 1;
-        char c[2];
-        memcpy(c, &x, 2);
-        return c[0] != 0;
-    }
-
-    static void* EndianessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian)
-    {
-        if (is_little_endian)
-        {
-            uint8_t* dst = (uint8_t*)_dst;
-            uint8_t* src = (uint8_t*)_src + s - 1;
-            for (int i = 0, n = (int)s; i < n; ++i)
-                memcpy(dst++, src--, 1);
-            return _dst;
-        }
-        else
-        {
-            return memcpy(_dst, _src, s);
-        }
-    }
-
-    static void* EndianessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian)
-    {
-        if (is_little_endian)
-        {
-            return memcpy(_dst, _src, s);
-        }
-        else
-        {
-            uint8_t* dst = (uint8_t*)_dst;
-            uint8_t* src = (uint8_t*)_src + s - 1;
-            for (int i = 0, n = (int)s; i < n; ++i)
-                memcpy(dst++, src--, 1);
-            return _dst;
-        }
-    }
-
-    void* EndianessCopy(void* dst, void* src, size_t size) const
-    {
-        static void* (*fp)(void*, void*, size_t, int) = NULL;
-        if (fp == NULL)
-            fp = IsBigEndian() ? EndianessCopyBigEndian : EndianessCopyLittleEndian;
-        return fp(dst, src, size, PreviewEndianess);
-    }
-};
-
-#undef _PRISizeT
-#undef ImSnprintf
-
-#ifdef _MSC_VER
-#pragma warning (pop)
-#endif

external/ImGui/source/imgui_imhex_extensions.cpp

@@ -1,144 +0,0 @@
-#include <imgui_imhex_extensions.h>
-
-#include <imgui.h>
-#include <imgui_freetype.h>
-#define IMGUI_DEFINE_MATH_OPERATORS
-#include <imgui_internal.h>
-#undef IMGUI_DEFINE_MATH_OPERATORS
-
-#include <string>
-
-namespace ImGui {
-
-    bool Hyperlink(const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags) {
-        ImGuiWindow* window = GetCurrentWindow();
-        if (window->SkipItems)
-            return false;
-
-        ImGuiContext& g = *GImGui;
-        const ImGuiStyle& style = g.Style;
-        const ImGuiID id = window->GetID(label);
-        const ImVec2 label_size = CalcTextSize(label, NULL, true);
-
-        ImVec2 pos = window->DC.CursorPos;
-        ImVec2 size = CalcItemSize(size_arg, label_size.x, label_size.y);
-
-        const ImRect bb(pos, pos + size);
-        if (!ItemAdd(bb, id))
-            return false;
-
-        if (window->DC.ItemFlags & ImGuiItemFlags_ButtonRepeat)
-            flags |= ImGuiButtonFlags_Repeat;
-        bool hovered, held;
-        bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
-
-        // Render
-        const ImU32 col = hovered ? GetColorU32(ImGuiCol_ButtonHovered) : GetColorU32(ImGuiCol_ButtonActive);
-        PushStyleColor(ImGuiCol_Text, ImU32(col));
-        TextEx(label, NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
-        GetWindowDrawList()->AddLine(ImVec2(pos.x, pos.y + size.y), pos + size, ImU32(col));
-        PopStyleColor();
-
-        IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
-        return pressed;
-    }
-
-    bool BulletHyperlink(const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags) {
-        ImGuiWindow* window = GetCurrentWindow();
-        if (window->SkipItems)
-            return false;
-
-        ImGuiContext& g = *GImGui;
-        const ImGuiStyle& style = g.Style;
-        const ImGuiID id = window->GetID(label);
-        const ImVec2 label_size = CalcTextSize(label, NULL, true);
-
-        ImVec2 pos = window->DC.CursorPos;
-        ImVec2 size = CalcItemSize(size_arg, label_size.x, label_size.y) + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f);
-
-        const ImRect bb(pos, pos + size);
-        if (!ItemAdd(bb, id))
-            return false;
-
-        if (window->DC.ItemFlags & ImGuiItemFlags_ButtonRepeat)
-            flags |= ImGuiButtonFlags_Repeat;
-        bool hovered, held;
-        bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
-
-        // Render
-        const ImU32 col = hovered ? GetColorU32(ImGuiCol_ButtonHovered) : GetColorU32(ImGuiCol_ButtonActive);
-        PushStyleColor(ImGuiCol_Text, ImU32(col));
-        RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, g.FontSize * 0.5f), col);
-        RenderText(bb.Min + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f), label, nullptr, false);
-        GetWindowDrawList()->AddLine(bb.Min + ImVec2(style.FramePadding.x, size.y), pos + size, ImU32(col));
-        ImGui::NewLine();
-        PopStyleColor();
-
-        IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
-        return pressed;
-    }
-
-    bool DescriptionButton(const char* label, const char* description, const ImVec2& size_arg, ImGuiButtonFlags flags) {
-        ImGuiWindow* window = GetCurrentWindow();
-        if (window->SkipItems)
-            return false;
-
-        ImGuiContext& g = *GImGui;
-        const ImGuiStyle& style = g.Style;
-        const ImGuiID id = window->GetID(label);
-        const ImVec2 text_size = CalcTextSize((std::string(label) + "\n  " + std::string(description)).c_str(), NULL, true);
-        const ImVec2 label_size = CalcTextSize(label, NULL, true);
-
-        ImVec2 pos = window->DC.CursorPos;
-        if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrLineTextBaseOffset) // Try to vertically align buttons that are smaller/have no padding so that text baseline matches (bit hacky, since it shouldn't be a flag)
-            pos.y += window->DC.CurrLineTextBaseOffset - style.FramePadding.y;
-        ImVec2 size = CalcItemSize(size_arg, text_size.x + style.FramePadding.x * 4.0f, text_size.y + style.FramePadding.y * 4.0f);
-
-        const ImRect bb(pos, pos + size);
-        ItemSize(size, style.FramePadding.y);
-        if (!ItemAdd(bb, id))
-            return false;
-
-        if (window->DC.ItemFlags & ImGuiItemFlags_ButtonRepeat)
-            flags |= ImGuiButtonFlags_Repeat;
-        bool hovered, held;
-        bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
-
-        ImGui::PushStyleVar(ImGuiStyleVar_ButtonTextAlign, ImVec2(0.0, 0.5));
-
-        // Render
-        const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_TableHeaderBg : hovered ? ImGuiCol_TableBorderLight : ImGuiCol_TableBorderStrong);
-        RenderNavHighlight(bb, id);
-        RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
-        PushStyleColor(ImGuiCol_Text, GetColorU32(ImGuiCol_ButtonActive));
-        RenderTextClipped(bb.Min + style.FramePadding * 2, bb.Max - style.FramePadding * 2, label, NULL, &text_size, style.ButtonTextAlign, &bb);
-        PopStyleColor();
-        PushStyleColor(ImGuiCol_Text, GetColorU32(ImGuiCol_Text));
-        RenderTextClipped(bb.Min + style.FramePadding * 2 + ImVec2(style.FramePadding.x * 2, label_size.y), bb.Max - style.FramePadding, description, NULL, &text_size, style.ButtonTextAlign, &bb);
-        PopStyleColor();
-
-        ImGui::PopStyleVar();
-
-        // Automatically close popups
-        //if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))
-        //    CloseCurrentPopup();
-
-        IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
-        return pressed;
-    }
-
-    void UnderlinedText(const char* label, ImColor color, const ImVec2& size_arg) {
-        ImGuiWindow* window = GetCurrentWindow();
-
-        const ImVec2 label_size = CalcTextSize(label, NULL, true);
-
-        ImVec2 pos = window->DC.CursorPos;
-        ImVec2 size = CalcItemSize(size_arg, label_size.x, label_size.y);
-
-        PushStyleColor(ImGuiCol_Text, ImU32(color));
-        TextEx(label, NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
-        GetWindowDrawList()->AddLine(ImVec2(pos.x, pos.y + size.y), pos + size, ImU32(color));
-        PopStyleColor();
-    }
-
-}

external/glad/CMakeLists.txt

@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-project(glad)
-
-set(CMAKE_CXX_STANDARD 17)
-
-if (WIN32)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++ -static-libgcc")
-endif()
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-
-add_library(glad
-    source/glad.c
-)
-
-target_include_directories(glad PUBLIC include)
-
-if (WIN32)
-    target_link_libraries(glad PRIVATE libdl.a)
-else()
-    target_link_libraries(glad PRIVATE dl)
-endif()

external/glad/include/KHR/khrplatform.h

@@ -1,290 +0,0 @@
-#ifndef __khrplatform_h_
-#define __khrplatform_h_
-
-/*
-** Copyright (c) 2008-2018 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-
-/* Khronos platform-specific types and definitions.
- *
- * The master copy of khrplatform.h is maintained in the Khronos EGL
- * Registry repository at https://github.com/KhronosGroup/EGL-Registry
- * The last semantic modification to khrplatform.h was at commit ID:
- *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
- *
- * Adopters may modify this file to suit their platform. Adopters are
- * encouraged to submit platform specific modifications to the Khronos
- * group so that they can be included in future versions of this file.
- * Please submit changes by filing pull requests or issues on
- * the EGL Registry repository linked above.
- *
- *
- * See the Implementer's Guidelines for information about where this file
- * should be located on your system and for more details of its use:
- *    http://www.khronos.org/registry/implementers_guide.pdf
- *
- * This file should be included as
- *        #include <KHR/khrplatform.h>
- * by Khronos client API header files that use its types and defines.
- *
- * The types in khrplatform.h should only be used to define API-specific types.
- *
- * Types defined in khrplatform.h:
- *    khronos_int8_t              signed   8  bit
- *    khronos_uint8_t             unsigned 8  bit
- *    khronos_int16_t             signed   16 bit
- *    khronos_uint16_t            unsigned 16 bit
- *    khronos_int32_t             signed   32 bit
- *    khronos_uint32_t            unsigned 32 bit
- *    khronos_int64_t             signed   64 bit
- *    khronos_uint64_t            unsigned 64 bit
- *    khronos_intptr_t            signed   same number of bits as a pointer
- *    khronos_uintptr_t           unsigned same number of bits as a pointer
- *    khronos_ssize_t             signed   size
- *    khronos_usize_t             unsigned size
- *    khronos_float_t             signed   32 bit floating point
- *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
- *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
- *                                         nanoseconds
- *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
- *    khronos_boolean_enum_t      enumerated boolean type. This should
- *      only be used as a base type when a client API's boolean type is
- *      an enum. Client APIs which use an integer or other type for
- *      booleans cannot use this as the base type for their boolean.
- *
- * Tokens defined in khrplatform.h:
- *
- *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
- *
- *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
- *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
- *
- * Calling convention macros defined in this file:
- *    KHRONOS_APICALL
- *    KHRONOS_APIENTRY
- *    KHRONOS_APIATTRIBUTES
- *
- * These may be used in function prototypes as:
- *
- *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
- *                                  int arg1,
- *                                  int arg2) KHRONOS_APIATTRIBUTES;
- */
-
-#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
-#   define KHRONOS_STATIC 1
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APICALL
- *-------------------------------------------------------------------------
- * This precedes the return type of the function in the function prototype.
- */
-#if defined(KHRONOS_STATIC)
-    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
-     * header compatible with static linking. */
-#   define KHRONOS_APICALL
-#elif defined(_WIN32)
-#   define KHRONOS_APICALL __declspec(dllimport)
-#elif defined (__SYMBIAN32__)
-#   define KHRONOS_APICALL IMPORT_C
-#elif defined(__ANDROID__)
-#   define KHRONOS_APICALL __attribute__((visibility("default")))
-#else
-#   define KHRONOS_APICALL
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIENTRY
- *-------------------------------------------------------------------------
- * This follows the return type of the function  and precedes the function
- * name in the function prototype.
- */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
-    /* Win32 but not WinCE */
-#   define KHRONOS_APIENTRY __stdcall
-#else
-#   define KHRONOS_APIENTRY
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIATTRIBUTES
- *-------------------------------------------------------------------------
- * This follows the closing parenthesis of the function prototype arguments.
- */
-#if defined (__ARMCC_2__)
-#define KHRONOS_APIATTRIBUTES __softfp
-#else
-#define KHRONOS_APIATTRIBUTES
-#endif
-
-/*-------------------------------------------------------------------------
- * basic type definitions
- *-----------------------------------------------------------------------*/
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
-
-
-/*
- * Using <stdint.h>
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__VMS ) || defined(__sgi)
-
-/*
- * Using <inttypes.h>
- */
-#include <inttypes.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
-
-/*
- * Win32
- */
-typedef __int32                 khronos_int32_t;
-typedef unsigned __int32        khronos_uint32_t;
-typedef __int64                 khronos_int64_t;
-typedef unsigned __int64        khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__sun__) || defined(__digital__)
-
-/*
- * Sun or Digital
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#if defined(__arch64__) || defined(_LP64)
-typedef long int                khronos_int64_t;
-typedef unsigned long int       khronos_uint64_t;
-#else
-typedef long long int           khronos_int64_t;
-typedef unsigned long long int  khronos_uint64_t;
-#endif /* __arch64__ */
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif 0
-
-/*
- * Hypothetical platform with no float or int64 support
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#define KHRONOS_SUPPORT_INT64   0
-#define KHRONOS_SUPPORT_FLOAT   0
-
-#else
-
-/*
- * Generic fallback
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#endif
-
-
-/*
- * Types that are (so far) the same on all platforms
- */
-typedef signed   char          khronos_int8_t;
-typedef unsigned char          khronos_uint8_t;
-typedef signed   short int     khronos_int16_t;
-typedef unsigned short int     khronos_uint16_t;
-
-/*
- * Types that differ between LLP64 and LP64 architectures - in LLP64,
- * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
- * to be the only LLP64 architecture in current use.
- */
-#ifdef _WIN64
-typedef signed   long long int khronos_intptr_t;
-typedef unsigned long long int khronos_uintptr_t;
-typedef signed   long long int khronos_ssize_t;
-typedef unsigned long long int khronos_usize_t;
-#else
-typedef signed   long  int     khronos_intptr_t;
-typedef unsigned long  int     khronos_uintptr_t;
-typedef signed   long  int     khronos_ssize_t;
-typedef unsigned long  int     khronos_usize_t;
-#endif
-
-#if KHRONOS_SUPPORT_FLOAT
-/*
- * Float type
- */
-typedef          float         khronos_float_t;
-#endif
-
-#if KHRONOS_SUPPORT_INT64
-/* Time types
- *
- * These types can be used to represent a time interval in nanoseconds or
- * an absolute Unadjusted System Time.  Unadjusted System Time is the number
- * of nanoseconds since some arbitrary system event (e.g. since the last
- * time the system booted).  The Unadjusted System Time is an unsigned
- * 64 bit value that wraps back to 0 every 584 years.  Time intervals
- * may be either signed or unsigned.
- */
-typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
-typedef khronos_int64_t        khronos_stime_nanoseconds_t;
-#endif
-
-/*
- * Dummy value used to pad enum types to 32 bits.
- */
-#ifndef KHRONOS_MAX_ENUM
-#define KHRONOS_MAX_ENUM 0x7FFFFFFF
-#endif
-
-/*
- * Enumerated boolean type
- *
- * Values other than zero should be considered to be true.  Therefore
- * comparisons should not be made against KHRONOS_TRUE.
- */
-typedef enum {
-    KHRONOS_FALSE = 0,
-    KHRONOS_TRUE  = 1,
-    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
-} khronos_boolean_enum_t;
-
-#endif /* __khrplatform_h_ */

include/helpers/encoding_file.hpp

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <hex.hpp>
-
-#include <map>
-#include <vector>
-
-namespace hex {
-
-    template<typename T>
-    struct SizeSorter {
-        bool operator() (const T& lhs, const T& rhs) const {
-            return lhs.size() < rhs.size();
-        }
-    };
-
-    class EncodingFile {
-    public:
-        enum class Type {
-            Thingy,
-            CSV
-        };
-
-        EncodingFile() = default;
-        EncodingFile(Type type, std::string_view path);
-
-        std::pair<std::string_view, size_t> getEncodingFor(const std::vector<u8> &buffer) const;
-        size_t getLongestSequence() const { return this->m_longestSequence; }
-
-    private:
-        void parseThingyFile(std::ifstream &content);
-
-        std::map<u32, std::map<std::vector<u8>, std::string>> m_mapping;
-        size_t m_longestSequence = 0;
-    };
-
-}

include/helpers/loader_script_handler.hpp

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <string>
-#include <string_view>
-
-struct _object;
-typedef struct _object PyObject;
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    class LoaderScript {
-    public:
-        LoaderScript() = delete;
-
-        static bool processFile(std::string_view scriptPath);
-
-        static void setFilePath(std::string_view filePath) { LoaderScript::s_filePath = filePath; }
-        static void setDataProvider(prv::Provider* provider) { LoaderScript::s_dataProvider = provider; }
-    private:
-        static inline std::string s_filePath;
-        static inline prv::Provider* s_dataProvider;
-
-        static PyObject* Py_getFilePath(PyObject *self, PyObject *args);
-        static PyObject* Py_addPatch(PyObject *self, PyObject *args);
-        static PyObject* Py_addBookmark(PyObject *self, PyObject *args);
-
-        static PyObject* Py_addStruct(PyObject *self, PyObject *args);
-        static PyObject* Py_addUnion(PyObject *self, PyObject *args);
-    };
-
-}

include/helpers/plugin_handler.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <hex.hpp>
-
-#include <hex/views/view.hpp>
-#include <hex/providers/provider.hpp>
-
-#include <string_view>
-
-namespace hex {
-
-    class Plugin {
-    public:
-        Plugin(std::string_view path);
-        Plugin(const Plugin&) = delete;
-        Plugin(Plugin &&other);
-        ~Plugin();
-
-        void initializePlugin() const;
-
-    private:
-        using InitializePluginFunc = void(*)();
-
-        void *m_handle = nullptr;
-
-        InitializePluginFunc m_initializePluginFunction = nullptr;
-    };
-
-    class PluginHandler {
-    public:
-        PluginHandler() = delete;
-
-        static void load(std::string_view pluginFolder);
-        static void unload();
-        static void reload();
-
-        static const auto& getPlugins() {
-            return PluginHandler::s_plugins;
-        }
-
-    private:
-        static inline std::string s_pluginFolder;
-        static inline std::vector<Plugin> s_plugins;
-    };
-
-}

include/helpers/project_file_handler.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <list>
-#include <string>
-#include <string_view>
-
-#include "patches.hpp"
-#include <hex/api/imhex_api.hpp>
-
-namespace hex {
-
-    class ProjectFile {
-    public:
-        ProjectFile() = delete;
-
-        static bool load(std::string_view filePath);
-        static bool store(std::string_view filePath = "");
-
-        [[nodiscard]] static bool hasUnsavedChanges()       { return ProjectFile::s_hasUnsavedChanged; }
-        static void markDirty()                             { if (!ProjectFile::s_currProjectFilePath.empty()) ProjectFile::s_hasUnsavedChanged = true; }
-
-        [[nodiscard]] static std::string getProjectFilePath() { return ProjectFile::s_currProjectFilePath; }
-
-        [[nodiscard]] static std::string getFilePath()      { return ProjectFile::s_filePath; }
-        static void setFilePath(std::string_view filePath)  { ProjectFile::s_hasUnsavedChanged = true; ProjectFile::s_filePath = filePath; }
-
-        [[nodiscard]] static std::string getPattern()       { return ProjectFile::s_pattern; }
-        static void setPattern(std::string_view pattern)    { ProjectFile::s_hasUnsavedChanged = true; ProjectFile::s_pattern = pattern; }
-
-        [[nodiscard]] static const Patches& getPatches()    { return ProjectFile::s_patches; }
-        static void setPatches(const Patches &patches)      { ProjectFile::s_hasUnsavedChanged = true; ProjectFile::s_patches = patches; }
-
-        [[nodiscard]] static const std::list<ImHexApi::Bookmarks::Entry>& getBookmarks()  { return ProjectFile::s_bookmarks; }
-        static void setBookmarks(const std::list<ImHexApi::Bookmarks::Entry> &bookmarks)  { ProjectFile::s_hasUnsavedChanged = true; ProjectFile::s_bookmarks = bookmarks; }
-
-    private:
-        static inline std::string s_currProjectFilePath;
-        static inline bool s_hasUnsavedChanged = false;
-
-        static inline std::string s_filePath;
-        static inline std::string s_pattern;
-        static inline Patches s_patches;
-        static inline std::list<ImHexApi::Bookmarks::Entry> s_bookmarks;
-    };
-
-}

include/providers/file_provider.hpp

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <hex/providers/provider.hpp>
-
-#include <string_view>
-
-#include <sys/stat.h>
-
-#if defined(OS_WINDOWS)
-#include <windows.h>
-#else
-#include <sys/mman.h>
-#include <unistd.h>
-#include <sys/fcntl.h>
-#endif
-
-namespace hex::prv {
-
-    class FileProvider : public Provider {
-    public:
-        explicit FileProvider(std::string_view path);
-        ~FileProvider() override;
-
-        bool isAvailable() override;
-        bool isReadable() override;
-        bool isWritable() override;
-
-        void read(u64 offset, void *buffer, size_t size) override;
-        void write(u64 offset, const void *buffer, size_t size) override;
-
-        void readRaw(u64 offset, void *buffer, size_t size) override;
-        void writeRaw(u64 offset, const void *buffer, size_t size) override;
-        size_t getActualSize() override;
-
-        std::vector<std::pair<std::string, std::string>> getDataInformation() override;
-
-    private:
-        #if defined(OS_WINDOWS)
-        HANDLE m_file;
-        HANDLE m_mapping;
-        #else
-        int m_file;
-        #endif
-        std::string m_path;
-        void *m_mappedFile;
-        size_t m_fileSize;
-
-        bool m_fileStatsValid = false;
-        struct stat m_fileStats = { 0 };
-
-        bool m_readable, m_writable;
-    };
-
-}

include/views/view_data_inspector.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <hex/views/view.hpp>
-
-#include <hex/api/content_registry.hpp>
-
-#include <bit>
-#include <cstdio>
-#include <string>
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    class ViewDataInspector : public View {
-    public:
-        explicit ViewDataInspector();
-        ~ViewDataInspector() override;
-
-        void drawContent() override;
-        void drawMenu() override;
-
-    private:
-        bool m_shouldInvalidate = true;
-
-        std::endian m_endian = std::endian::native;
-        ContentRegistry::DataInspector::NumberDisplayStyle m_numberDisplayStyle =ContentRegistry::DataInspector::NumberDisplayStyle::Decimal;
-
-        u64 m_startAddress = 0;
-        size_t m_validBytes = 0;
-        std::vector<std::pair<std::string, ContentRegistry::DataInspector::DisplayFunction>> m_cachedData;
-    };
-
-}

include/views/view_hashes.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <hex/views/view.hpp>
-
-#include <cstdio>
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    class ViewHashes : public View {
-    public:
-        explicit ViewHashes();
-        ~ViewHashes() override;
-
-        void drawContent() override;
-        void drawMenu() override;
-
-    private:
-        bool m_shouldInvalidate = true;
-        int m_currHashFunction = 0;
-        u64 m_hashRegion[2] = { 0 };
-        bool m_shouldMatchSelection = false;
-
-        static constexpr const char* HashFunctionNames[] = { "CRC16", "CRC32", "MD5", "SHA-1", "SHA-224", "SHA-256", "SHA-384", "SHA-512" };
-    };
-
-}

include/views/view_help.hpp

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <hex.hpp>
-
-#include <imgui.h>
-#include <hex/views/view.hpp>
-#include <hex/lang/pattern_data.hpp>
-
-#include <vector>
-#include <tuple>
-#include <cstdio>
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    class ViewHelp : public View {
-    public:
-        ViewHelp();
-        ~ViewHelp() override;
-
-        void drawContent() override;
-        void drawMenu() override;
-        bool isAvailable() override { return true; }
-
-        bool hasViewMenuItemEntry() override { return false; }
-
-        ImVec2 getMinSize() override {
-            return ImVec2(400, 300);
-        }
-
-    private:
-        bool m_aboutWindowOpen = false;
-        bool m_patternHelpWindowOpen = false;
-        bool m_mathHelpWindowOpen = false;
-
-        void drawAboutPopup();
-        void drawPatternHelpPopup();
-        void drawMathEvaluatorHelp();
-    };
-
-}

include/views/view_hexeditor.hpp

@@ -1,77 +0,0 @@
-#pragma once
-
-#include <hex/helpers/utils.hpp>
-#include <hex/views/view.hpp>
-#include "helpers/encoding_file.hpp"
-
-#include <imgui_memory_editor.h>
-#include <ImGuiFileBrowser.h>
-
-#include <list>
-#include <tuple>
-#include <random>
-#include <vector>
-
-#include <hex/lang/pattern_data.hpp>
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    using SearchFunction = std::vector<std::pair<u64, u64>> (*)(prv::Provider* &provider, std::string string);
-
-    class ViewHexEditor : public View {
-    public:
-        ViewHexEditor(std::vector<lang::PatternData*> &patternData);
-        ~ViewHexEditor() override;
-
-        void drawContent() override;
-        void drawAlwaysVisible() override;
-        void drawMenu() override;
-        bool handleShortcut(int key, int mods) override;
-
-    private:
-        MemoryEditor m_memoryEditor;
-
-        std::vector<lang::PatternData*> &m_patternData;
-
-        std::map<u64, u32> m_highlightedBytes;
-
-        std::vector<char> m_searchStringBuffer;
-        std::vector<char> m_searchHexBuffer;
-        SearchFunction m_searchFunction = nullptr;
-        std::vector<std::pair<u64, u64>> *m_lastSearchBuffer;
-
-        s64 m_lastSearchIndex = 0;
-        std::vector<std::pair<u64, u64>> m_lastStringSearch;
-        std::vector<std::pair<u64, u64>> m_lastHexSearch;
-
-        s64 m_gotoAddress = 0;
-
-        char m_baseAddressBuffer[0x20] = { 0 };
-
-        std::vector<u8> m_dataToSave;
-
-        std::string m_loaderScriptScriptPath;
-        std::string m_loaderScriptFilePath;
-
-        hex::EncodingFile m_currEncodingFile;
-
-        void drawSearchPopup();
-        void drawGotoPopup();
-        void drawEditPopup();
-
-        void openFile(std::string path);
-        bool saveToFile(std::string path, const std::vector<u8>& data);
-        bool loadFromFile(std::string path, std::vector<u8>& data);
-
-        enum class Language { C, Cpp, CSharp, Rust, Python, Java, JavaScript };
-        void copyBytes();
-        void copyString();
-        void copyLanguageArray(Language language);
-        void copyHexView();
-        void copyHexViewHTML();
-
-    };
-
-}

include/views/view_pattern.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <hex/views/view.hpp>
-#include <hex/lang/evaluator.hpp>
-#include <hex/lang/pattern_language.hpp>
-
-#include <hex/providers/provider.hpp>
-
-#include <cstring>
-#include <filesystem>
-#include <string_view>
-#include <thread>
-#include <vector>
-
-#include <ImGuiFileBrowser.h>
-#include <TextEditor.h>
-
-namespace hex {
-
-    class ViewPattern : public View {
-    public:
-        explicit ViewPattern(std::vector<lang::PatternData*> &patternData);
-        ~ViewPattern() override;
-
-        void drawMenu() override;
-        void drawAlwaysVisible() override;
-        void drawContent() override;
-
-    private:
-        lang::PatternLanguage *m_patternLanguageRuntime;
-        std::vector<lang::PatternData*> &m_patternData;
-        std::vector<std::string> m_possiblePatternFiles;
-        int m_selectedPatternFile = 0;
-
-        TextEditor m_textEditor;
-        std::vector<std::pair<lang::LogConsole::Level, std::string>> m_console;
-
-        void loadPatternFile(std::string_view path);
-        void clearPatternData();
-        void parsePattern(char *buffer);
-    };
-
-}

include/views/view_pattern_data.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <hex.hpp>
-
-#include <imgui.h>
-#include <hex/views/view.hpp>
-#include <hex/lang/pattern_data.hpp>
-
-#include <vector>
-#include <tuple>
-#include <cstdio>
-
-namespace hex {
-
-    namespace prv { class Provider; }
-
-    class ViewPatternData : public View {
-    public:
-        ViewPatternData(std::vector<lang::PatternData*> &patternData);
-        ~ViewPatternData() override;
-
-        void drawContent() override;
-        void drawMenu() override;
-
-    private:
-
-        std::vector<lang::PatternData*> &m_patternData;
-        std::vector<lang::PatternData*> m_sortedPatternData;
-    };
-
-}

include/views/view_settings.hpp

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <hex/views/view.hpp>
-
-#include <cstdio>
-#include <string>
-
-namespace hex {
-
-    class ViewSettings : public View {
-    public:
-        explicit ViewSettings();
-        ~ViewSettings() override;
-
-        void drawContent() override;
-        void drawMenu() override;
-        bool isAvailable() override { return true; }
-
-        bool hasViewMenuItemEntry() override { return false; }
-    };
-
-}

include/window.hpp

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <hex/helpers/utils.hpp>
-#include <hex/views/view.hpp>
-
-struct GLFWwindow;
-struct ImGuiSettingsHandler;
-
-namespace hex {
-
-    class Window {
-    public:
-        Window(int &argc, char **&argv);
-        ~Window();
-
-        void loop();
-
-        friend void *ImHexSettingsHandler_ReadOpenFn(ImGuiContext *ctx, ImGuiSettingsHandler *, const char *);
-        friend void ImHexSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler *handler, void *, const char* line);
-        friend void ImHexSettingsHandler_ApplyAll(ImGuiContext *ctx, ImGuiSettingsHandler *handler);
-        friend void ImHexSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandler *handler, ImGuiTextBuffer *buf);
-
-        bool setFont(const std::filesystem::path &font_path);
-
-        void initPlugins();
-        void deinitPlugins();
-    private:
-        void frameBegin();
-        void frameEnd();
-
-        void drawWelcomeScreen();
-
-        void initGLFW();
-        void initImGui();
-        void deinitGLFW();
-        void deinitImGui();
-
-        GLFWwindow* m_window = nullptr;
-
-        float m_globalScale = 1.0f, m_fontScale = 1.0f;
-        bool m_fpsVisible = false;
-        bool m_demoWindowOpen = false;
-
-        static inline std::tuple<int, int> s_currShortcut = { -1, -1 };
-
-        std::list<std::string> m_recentFiles;
-    };
-
-}

lib/external/imgui/CMakeLists.txt

@@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 3.16)
+project(imgui)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(PkgConfig REQUIRED)
+find_package(Freetype REQUIRED)
+find_package(OpenGL REQUIRED)
+pkg_search_module(GLFW REQUIRED glfw3)
+
+if (UNIX)
+    find_package(OpenGL REQUIRED)
+endif ()
+
+add_library(imgui OBJECT
+        source/imgui.cpp
+        source/imgui_demo.cpp
+        source/imgui_draw.cpp
+        source/imgui_freetype.cpp
+        source/imgui_impl_glfw.cpp
+        source/imgui_impl_opengl3.cpp
+        source/imgui_tables.cpp
+        source/imgui_widgets.cpp
+
+        source/cimgui.cpp
+
+        source/TextEditor.cpp
+
+        source/imnodes.cpp
+
+        source/implot.cpp
+        source/implot_items.cpp
+        source/implot_demo.cpp
+
+        fonts/fontawesome_font.c
+        fonts/codicons_font.c
+        fonts/unifont_font.c
+)
+
+add_compile_definitions(IMGUI_IMPL_OPENGL_LOADER_GLAD)
+
+target_include_directories(imgui PUBLIC include fonts ${CMAKE_CURRENT_SOURCE_DIR} ${FREETYPE_INCLUDE_DIRS} ${GLFW_INCLUDE_DIRS})
+
+target_link_directories(imgui PUBLIC ${GLFW_LIBRARY_DIRS})
+
+if (WIN32)
+    target_link_libraries(imgui PUBLIC Freetype::Freetype glfw3 opengl32.lib)
+elseif (UNIX)
+    target_link_libraries(imgui PUBLIC Freetype::Freetype glfw OpenGL::GL)
+endif()

lib/external/imgui/fonts/codicons_font.h

@@ -0,0 +1,475 @@
+// Generated by https://github.com/juliettef/IconFontCppHeaders script GenerateIconFontCppHeaders.py for languages C and C++
+// from https://raw.githubusercontent.com/microsoft/vscode-codicons/main/dist/codicon.css
+// for use with https://github.com/microsoft/vscode-codicons/raw/main/dist/codicon.ttf
+#pragma once
+
+#define FONT_ICON_FILE_NAME_VS "codicon.ttf"
+
+extern const unsigned int codicons_compressed_size;
+extern const unsigned int codicons_compressed_data[52184/4];
+
+#define ICON_MIN_VS 0xea60
+#define ICON_MAX_VS 0xebdd
+#define ICON_VS_ADD "\xee\xa9\xa0"	// U+ea60
+#define ICON_VS_PLUS "\xee\xa9\xa0"	// U+ea60
+#define ICON_VS_GIST_NEW "\xee\xa9\xa0"	// U+ea60
+#define ICON_VS_REPO_CREATE "\xee\xa9\xa0"	// U+ea60
+#define ICON_VS_LIGHTBULB "\xee\xa9\xa1"	// U+ea61
+#define ICON_VS_LIGHT_BULB "\xee\xa9\xa1"	// U+ea61
+#define ICON_VS_REPO "\xee\xa9\xa2"	// U+ea62
+#define ICON_VS_REPO_DELETE "\xee\xa9\xa2"	// U+ea62
+#define ICON_VS_GIST_FORK "\xee\xa9\xa3"	// U+ea63
+#define ICON_VS_REPO_FORKED "\xee\xa9\xa3"	// U+ea63
+#define ICON_VS_GIT_PULL_REQUEST "\xee\xa9\xa4"	// U+ea64
+#define ICON_VS_GIT_PULL_REQUEST_ABANDONED "\xee\xa9\xa4"	// U+ea64
+#define ICON_VS_RECORD_KEYS "\xee\xa9\xa5"	// U+ea65
+#define ICON_VS_KEYBOARD "\xee\xa9\xa5"	// U+ea65
+#define ICON_VS_TAG "\xee\xa9\xa6"	// U+ea66
+#define ICON_VS_TAG_ADD "\xee\xa9\xa6"	// U+ea66
+#define ICON_VS_TAG_REMOVE "\xee\xa9\xa6"	// U+ea66
+#define ICON_VS_PERSON "\xee\xa9\xa7"	// U+ea67
+#define ICON_VS_PERSON_FOLLOW "\xee\xa9\xa7"	// U+ea67
+#define ICON_VS_PERSON_OUTLINE "\xee\xa9\xa7"	// U+ea67
+#define ICON_VS_PERSON_FILLED "\xee\xa9\xa7"	// U+ea67
+#define ICON_VS_GIT_BRANCH "\xee\xa9\xa8"	// U+ea68
+#define ICON_VS_GIT_BRANCH_CREATE "\xee\xa9\xa8"	// U+ea68
+#define ICON_VS_GIT_BRANCH_DELETE "\xee\xa9\xa8"	// U+ea68
+#define ICON_VS_SOURCE_CONTROL "\xee\xa9\xa8"	// U+ea68
+#define ICON_VS_MIRROR "\xee\xa9\xa9"	// U+ea69
+#define ICON_VS_MIRROR_PUBLIC "\xee\xa9\xa9"	// U+ea69
+#define ICON_VS_STAR "\xee\xa9\xaa"	// U+ea6a
+#define ICON_VS_STAR_ADD "\xee\xa9\xaa"	// U+ea6a
+#define ICON_VS_STAR_DELETE "\xee\xa9\xaa"	// U+ea6a
+#define ICON_VS_STAR_EMPTY "\xee\xa9\xaa"	// U+ea6a
+#define ICON_VS_COMMENT "\xee\xa9\xab"	// U+ea6b
+#define ICON_VS_COMMENT_ADD "\xee\xa9\xab"	// U+ea6b
+#define ICON_VS_ALERT "\xee\xa9\xac"	// U+ea6c
+#define ICON_VS_WARNING "\xee\xa9\xac"	// U+ea6c
+#define ICON_VS_SEARCH "\xee\xa9\xad"	// U+ea6d
+#define ICON_VS_SEARCH_SAVE "\xee\xa9\xad"	// U+ea6d
+#define ICON_VS_LOG_OUT "\xee\xa9\xae"	// U+ea6e
+#define ICON_VS_SIGN_OUT "\xee\xa9\xae"	// U+ea6e
+#define ICON_VS_LOG_IN "\xee\xa9\xaf"	// U+ea6f
+#define ICON_VS_SIGN_IN "\xee\xa9\xaf"	// U+ea6f
+#define ICON_VS_EYE "\xee\xa9\xb0"	// U+ea70
+#define ICON_VS_EYE_UNWATCH "\xee\xa9\xb0"	// U+ea70
+#define ICON_VS_EYE_WATCH "\xee\xa9\xb0"	// U+ea70
+#define ICON_VS_CIRCLE_FILLED "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_PRIMITIVE_DOT "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_CLOSE_DIRTY "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_DEBUG_BREAKPOINT "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_DEBUG_BREAKPOINT_DISABLED "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_DEBUG_HINT "\xee\xa9\xb1"	// U+ea71
+#define ICON_VS_PRIMITIVE_SQUARE "\xee\xa9\xb2"	// U+ea72
+#define ICON_VS_EDIT "\xee\xa9\xb3"	// U+ea73
+#define ICON_VS_PENCIL "\xee\xa9\xb3"	// U+ea73
+#define ICON_VS_INFO "\xee\xa9\xb4"	// U+ea74
+#define ICON_VS_ISSUE_OPENED "\xee\xa9\xb4"	// U+ea74
+#define ICON_VS_GIST_PRIVATE "\xee\xa9\xb5"	// U+ea75
+#define ICON_VS_GIT_FORK_PRIVATE "\xee\xa9\xb5"	// U+ea75
+#define ICON_VS_LOCK "\xee\xa9\xb5"	// U+ea75
+#define ICON_VS_MIRROR_PRIVATE "\xee\xa9\xb5"	// U+ea75
+#define ICON_VS_CLOSE "\xee\xa9\xb6"	// U+ea76
+#define ICON_VS_REMOVE_CLOSE "\xee\xa9\xb6"	// U+ea76
+#define ICON_VS_X "\xee\xa9\xb6"	// U+ea76
+#define ICON_VS_REPO_SYNC "\xee\xa9\xb7"	// U+ea77
+#define ICON_VS_SYNC "\xee\xa9\xb7"	// U+ea77
+#define ICON_VS_CLONE "\xee\xa9\xb8"	// U+ea78
+#define ICON_VS_DESKTOP_DOWNLOAD "\xee\xa9\xb8"	// U+ea78
+#define ICON_VS_BEAKER "\xee\xa9\xb9"	// U+ea79
+#define ICON_VS_MICROSCOPE "\xee\xa9\xb9"	// U+ea79
+#define ICON_VS_VM "\xee\xa9\xba"	// U+ea7a
+#define ICON_VS_DEVICE_DESKTOP "\xee\xa9\xba"	// U+ea7a
+#define ICON_VS_FILE "\xee\xa9\xbb"	// U+ea7b
+#define ICON_VS_FILE_TEXT "\xee\xa9\xbb"	// U+ea7b
+#define ICON_VS_MORE "\xee\xa9\xbc"	// U+ea7c
+#define ICON_VS_ELLIPSIS "\xee\xa9\xbc"	// U+ea7c
+#define ICON_VS_KEBAB_HORIZONTAL "\xee\xa9\xbc"	// U+ea7c
+#define ICON_VS_MAIL_REPLY "\xee\xa9\xbd"	// U+ea7d
+#define ICON_VS_REPLY "\xee\xa9\xbd"	// U+ea7d
+#define ICON_VS_ORGANIZATION "\xee\xa9\xbe"	// U+ea7e
+#define ICON_VS_ORGANIZATION_FILLED "\xee\xa9\xbe"	// U+ea7e
+#define ICON_VS_ORGANIZATION_OUTLINE "\xee\xa9\xbe"	// U+ea7e
+#define ICON_VS_NEW_FILE "\xee\xa9\xbf"	// U+ea7f
+#define ICON_VS_FILE_ADD "\xee\xa9\xbf"	// U+ea7f
+#define ICON_VS_NEW_FOLDER "\xee\xaa\x80"	// U+ea80
+#define ICON_VS_FILE_DIRECTORY_CREATE "\xee\xaa\x80"	// U+ea80
+#define ICON_VS_TRASH "\xee\xaa\x81"	// U+ea81
+#define ICON_VS_TRASHCAN "\xee\xaa\x81"	// U+ea81
+#define ICON_VS_HISTORY "\xee\xaa\x82"	// U+ea82
+#define ICON_VS_CLOCK "\xee\xaa\x82"	// U+ea82
+#define ICON_VS_FOLDER "\xee\xaa\x83"	// U+ea83
+#define ICON_VS_FILE_DIRECTORY "\xee\xaa\x83"	// U+ea83
+#define ICON_VS_SYMBOL_FOLDER "\xee\xaa\x83"	// U+ea83
+#define ICON_VS_LOGO_GITHUB "\xee\xaa\x84"	// U+ea84
+#define ICON_VS_MARK_GITHUB "\xee\xaa\x84"	// U+ea84
+#define ICON_VS_GITHUB "\xee\xaa\x84"	// U+ea84
+#define ICON_VS_TERMINAL "\xee\xaa\x85"	// U+ea85
+#define ICON_VS_CONSOLE "\xee\xaa\x85"	// U+ea85
+#define ICON_VS_REPL "\xee\xaa\x85"	// U+ea85
+#define ICON_VS_ZAP "\xee\xaa\x86"	// U+ea86
+#define ICON_VS_SYMBOL_EVENT "\xee\xaa\x86"	// U+ea86
+#define ICON_VS_ERROR "\xee\xaa\x87"	// U+ea87
+#define ICON_VS_STOP "\xee\xaa\x87"	// U+ea87
+#define ICON_VS_VARIABLE "\xee\xaa\x88"	// U+ea88
+#define ICON_VS_SYMBOL_VARIABLE "\xee\xaa\x88"	// U+ea88
+#define ICON_VS_ARRAY "\xee\xaa\x8a"	// U+ea8a
+#define ICON_VS_SYMBOL_ARRAY "\xee\xaa\x8a"	// U+ea8a
+#define ICON_VS_SYMBOL_MODULE "\xee\xaa\x8b"	// U+ea8b
+#define ICON_VS_SYMBOL_PACKAGE "\xee\xaa\x8b"	// U+ea8b
+#define ICON_VS_SYMBOL_NAMESPACE "\xee\xaa\x8b"	// U+ea8b
+#define ICON_VS_SYMBOL_OBJECT "\xee\xaa\x8b"	// U+ea8b
+#define ICON_VS_SYMBOL_METHOD "\xee\xaa\x8c"	// U+ea8c
+#define ICON_VS_SYMBOL_FUNCTION "\xee\xaa\x8c"	// U+ea8c
+#define ICON_VS_SYMBOL_CONSTRUCTOR "\xee\xaa\x8c"	// U+ea8c
+#define ICON_VS_SYMBOL_BOOLEAN "\xee\xaa\x8f"	// U+ea8f
+#define ICON_VS_SYMBOL_NULL "\xee\xaa\x8f"	// U+ea8f
+#define ICON_VS_SYMBOL_NUMERIC "\xee\xaa\x90"	// U+ea90
+#define ICON_VS_SYMBOL_NUMBER "\xee\xaa\x90"	// U+ea90
+#define ICON_VS_SYMBOL_STRUCTURE "\xee\xaa\x91"	// U+ea91
+#define ICON_VS_SYMBOL_STRUCT "\xee\xaa\x91"	// U+ea91
+#define ICON_VS_SYMBOL_PARAMETER "\xee\xaa\x92"	// U+ea92
+#define ICON_VS_SYMBOL_TYPE_PARAMETER "\xee\xaa\x92"	// U+ea92
+#define ICON_VS_SYMBOL_KEY "\xee\xaa\x93"	// U+ea93
+#define ICON_VS_SYMBOL_TEXT "\xee\xaa\x93"	// U+ea93
+#define ICON_VS_SYMBOL_REFERENCE "\xee\xaa\x94"	// U+ea94
+#define ICON_VS_GO_TO_FILE "\xee\xaa\x94"	// U+ea94
+#define ICON_VS_SYMBOL_ENUM "\xee\xaa\x95"	// U+ea95
+#define ICON_VS_SYMBOL_VALUE "\xee\xaa\x95"	// U+ea95
+#define ICON_VS_SYMBOL_RULER "\xee\xaa\x96"	// U+ea96
+#define ICON_VS_SYMBOL_UNIT "\xee\xaa\x96"	// U+ea96
+#define ICON_VS_ACTIVATE_BREAKPOINTS "\xee\xaa\x97"	// U+ea97
+#define ICON_VS_ARCHIVE "\xee\xaa\x98"	// U+ea98
+#define ICON_VS_ARROW_BOTH "\xee\xaa\x99"	// U+ea99
+#define ICON_VS_ARROW_DOWN "\xee\xaa\x9a"	// U+ea9a
+#define ICON_VS_ARROW_LEFT "\xee\xaa\x9b"	// U+ea9b
+#define ICON_VS_ARROW_RIGHT "\xee\xaa\x9c"	// U+ea9c
+#define ICON_VS_ARROW_SMALL_DOWN "\xee\xaa\x9d"	// U+ea9d
+#define ICON_VS_ARROW_SMALL_LEFT "\xee\xaa\x9e"	// U+ea9e
+#define ICON_VS_ARROW_SMALL_RIGHT "\xee\xaa\x9f"	// U+ea9f
+#define ICON_VS_ARROW_SMALL_UP "\xee\xaa\xa0"	// U+eaa0
+#define ICON_VS_ARROW_UP "\xee\xaa\xa1"	// U+eaa1
+#define ICON_VS_BELL "\xee\xaa\xa2"	// U+eaa2
+#define ICON_VS_BOLD "\xee\xaa\xa3"	// U+eaa3
+#define ICON_VS_BOOK "\xee\xaa\xa4"	// U+eaa4
+#define ICON_VS_BOOKMARK "\xee\xaa\xa5"	// U+eaa5
+#define ICON_VS_DEBUG_BREAKPOINT_CONDITIONAL_UNVERIFIED "\xee\xaa\xa6"	// U+eaa6
+#define ICON_VS_DEBUG_BREAKPOINT_CONDITIONAL "\xee\xaa\xa7"	// U+eaa7
+#define ICON_VS_DEBUG_BREAKPOINT_CONDITIONAL_DISABLED "\xee\xaa\xa7"	// U+eaa7
+#define ICON_VS_DEBUG_BREAKPOINT_DATA_UNVERIFIED "\xee\xaa\xa8"	// U+eaa8
+#define ICON_VS_DEBUG_BREAKPOINT_DATA "\xee\xaa\xa9"	// U+eaa9
+#define ICON_VS_DEBUG_BREAKPOINT_DATA_DISABLED "\xee\xaa\xa9"	// U+eaa9
+#define ICON_VS_DEBUG_BREAKPOINT_LOG_UNVERIFIED "\xee\xaa\xaa"	// U+eaaa
+#define ICON_VS_DEBUG_BREAKPOINT_LOG "\xee\xaa\xab"	// U+eaab
+#define ICON_VS_DEBUG_BREAKPOINT_LOG_DISABLED "\xee\xaa\xab"	// U+eaab
+#define ICON_VS_BRIEFCASE "\xee\xaa\xac"	// U+eaac
+#define ICON_VS_BROADCAST "\xee\xaa\xad"	// U+eaad
+#define ICON_VS_BROWSER "\xee\xaa\xae"	// U+eaae
+#define ICON_VS_BUG "\xee\xaa\xaf"	// U+eaaf
+#define ICON_VS_CALENDAR "\xee\xaa\xb0"	// U+eab0
+#define ICON_VS_CASE_SENSITIVE "\xee\xaa\xb1"	// U+eab1
+#define ICON_VS_CHECK "\xee\xaa\xb2"	// U+eab2
+#define ICON_VS_CHECKLIST "\xee\xaa\xb3"	// U+eab3
+#define ICON_VS_CHEVRON_DOWN "\xee\xaa\xb4"	// U+eab4
+#define ICON_VS_CHEVRON_LEFT "\xee\xaa\xb5"	// U+eab5
+#define ICON_VS_CHEVRON_RIGHT "\xee\xaa\xb6"	// U+eab6
+#define ICON_VS_CHEVRON_UP "\xee\xaa\xb7"	// U+eab7
+#define ICON_VS_CHROME_CLOSE "\xee\xaa\xb8"	// U+eab8
+#define ICON_VS_CHROME_MAXIMIZE "\xee\xaa\xb9"	// U+eab9
+#define ICON_VS_CHROME_MINIMIZE "\xee\xaa\xba"	// U+eaba
+#define ICON_VS_CHROME_RESTORE "\xee\xaa\xbb"	// U+eabb
+#define ICON_VS_CIRCLE_OUTLINE "\xee\xaa\xbc"	// U+eabc
+#define ICON_VS_DEBUG_BREAKPOINT_UNVERIFIED "\xee\xaa\xbc"	// U+eabc
+#define ICON_VS_CIRCLE_SLASH "\xee\xaa\xbd"	// U+eabd
+#define ICON_VS_CIRCUIT_BOARD "\xee\xaa\xbe"	// U+eabe
+#define ICON_VS_CLEAR_ALL "\xee\xaa\xbf"	// U+eabf
+#define ICON_VS_CLIPPY "\xee\xab\x80"	// U+eac0
+#define ICON_VS_CLOSE_ALL "\xee\xab\x81"	// U+eac1
+#define ICON_VS_CLOUD_DOWNLOAD "\xee\xab\x82"	// U+eac2
+#define ICON_VS_CLOUD_UPLOAD "\xee\xab\x83"	// U+eac3
+#define ICON_VS_CODE "\xee\xab\x84"	// U+eac4
+#define ICON_VS_COLLAPSE_ALL "\xee\xab\x85"	// U+eac5
+#define ICON_VS_COLOR_MODE "\xee\xab\x86"	// U+eac6
+#define ICON_VS_COMMENT_DISCUSSION "\xee\xab\x87"	// U+eac7
+#define ICON_VS_CREDIT_CARD "\xee\xab\x89"	// U+eac9
+#define ICON_VS_DASH "\xee\xab\x8c"	// U+eacc
+#define ICON_VS_DASHBOARD "\xee\xab\x8d"	// U+eacd
+#define ICON_VS_DATABASE "\xee\xab\x8e"	// U+eace
+#define ICON_VS_DEBUG_CONTINUE "\xee\xab\x8f"	// U+eacf
+#define ICON_VS_DEBUG_DISCONNECT "\xee\xab\x90"	// U+ead0
+#define ICON_VS_DEBUG_PAUSE "\xee\xab\x91"	// U+ead1
+#define ICON_VS_DEBUG_RESTART "\xee\xab\x92"	// U+ead2
+#define ICON_VS_DEBUG_START "\xee\xab\x93"	// U+ead3
+#define ICON_VS_DEBUG_STEP_INTO "\xee\xab\x94"	// U+ead4
+#define ICON_VS_DEBUG_STEP_OUT "\xee\xab\x95"	// U+ead5
+#define ICON_VS_DEBUG_STEP_OVER "\xee\xab\x96"	// U+ead6
+#define ICON_VS_DEBUG_STOP "\xee\xab\x97"	// U+ead7
+#define ICON_VS_DEBUG "\xee\xab\x98"	// U+ead8
+#define ICON_VS_DEVICE_CAMERA_VIDEO "\xee\xab\x99"	// U+ead9
+#define ICON_VS_DEVICE_CAMERA "\xee\xab\x9a"	// U+eada
+#define ICON_VS_DEVICE_MOBILE "\xee\xab\x9b"	// U+eadb
+#define ICON_VS_DIFF_ADDED "\xee\xab\x9c"	// U+eadc
+#define ICON_VS_DIFF_IGNORED "\xee\xab\x9d"	// U+eadd
+#define ICON_VS_DIFF_MODIFIED "\xee\xab\x9e"	// U+eade
+#define ICON_VS_DIFF_REMOVED "\xee\xab\x9f"	// U+eadf
+#define ICON_VS_DIFF_RENAMED "\xee\xab\xa0"	// U+eae0
+#define ICON_VS_DIFF "\xee\xab\xa1"	// U+eae1
+#define ICON_VS_DISCARD "\xee\xab\xa2"	// U+eae2
+#define ICON_VS_EDITOR_LAYOUT "\xee\xab\xa3"	// U+eae3
+#define ICON_VS_EMPTY_WINDOW "\xee\xab\xa4"	// U+eae4
+#define ICON_VS_EXCLUDE "\xee\xab\xa5"	// U+eae5
+#define ICON_VS_EXTENSIONS "\xee\xab\xa6"	// U+eae6
+#define ICON_VS_EYE_CLOSED "\xee\xab\xa7"	// U+eae7
+#define ICON_VS_FILE_BINARY "\xee\xab\xa8"	// U+eae8
+#define ICON_VS_FILE_CODE "\xee\xab\xa9"	// U+eae9
+#define ICON_VS_FILE_MEDIA "\xee\xab\xaa"	// U+eaea
+#define ICON_VS_FILE_PDF "\xee\xab\xab"	// U+eaeb
+#define ICON_VS_FILE_SUBMODULE "\xee\xab\xac"	// U+eaec
+#define ICON_VS_FILE_SYMLINK_DIRECTORY "\xee\xab\xad"	// U+eaed
+#define ICON_VS_FILE_SYMLINK_FILE "\xee\xab\xae"	// U+eaee
+#define ICON_VS_FILE_ZIP "\xee\xab\xaf"	// U+eaef
+#define ICON_VS_FILES "\xee\xab\xb0"	// U+eaf0
+#define ICON_VS_FILTER "\xee\xab\xb1"	// U+eaf1
+#define ICON_VS_FLAME "\xee\xab\xb2"	// U+eaf2
+#define ICON_VS_FOLD_DOWN "\xee\xab\xb3"	// U+eaf3
+#define ICON_VS_FOLD_UP "\xee\xab\xb4"	// U+eaf4
+#define ICON_VS_FOLD "\xee\xab\xb5"	// U+eaf5
+#define ICON_VS_FOLDER_ACTIVE "\xee\xab\xb6"	// U+eaf6
+#define ICON_VS_FOLDER_OPENED "\xee\xab\xb7"	// U+eaf7
+#define ICON_VS_GEAR "\xee\xab\xb8"	// U+eaf8
+#define ICON_VS_GIFT "\xee\xab\xb9"	// U+eaf9
+#define ICON_VS_GIST_SECRET "\xee\xab\xba"	// U+eafa
+#define ICON_VS_GIST "\xee\xab\xbb"	// U+eafb
+#define ICON_VS_GIT_COMMIT "\xee\xab\xbc"	// U+eafc
+#define ICON_VS_GIT_COMPARE "\xee\xab\xbd"	// U+eafd
+#define ICON_VS_COMPARE_CHANGES "\xee\xab\xbd"	// U+eafd
+#define ICON_VS_GIT_MERGE "\xee\xab\xbe"	// U+eafe
+#define ICON_VS_GITHUB_ACTION "\xee\xab\xbf"	// U+eaff
+#define ICON_VS_GITHUB_ALT "\xee\xac\x80"	// U+eb00
+#define ICON_VS_GLOBE "\xee\xac\x81"	// U+eb01
+#define ICON_VS_GRABBER "\xee\xac\x82"	// U+eb02
+#define ICON_VS_GRAPH "\xee\xac\x83"	// U+eb03
+#define ICON_VS_GRIPPER "\xee\xac\x84"	// U+eb04
+#define ICON_VS_HEART "\xee\xac\x85"	// U+eb05
+#define ICON_VS_HOME "\xee\xac\x86"	// U+eb06
+#define ICON_VS_HORIZONTAL_RULE "\xee\xac\x87"	// U+eb07
+#define ICON_VS_HUBOT "\xee\xac\x88"	// U+eb08
+#define ICON_VS_INBOX "\xee\xac\x89"	// U+eb09
+#define ICON_VS_ISSUE_REOPENED "\xee\xac\x8b"	// U+eb0b
+#define ICON_VS_ISSUES "\xee\xac\x8c"	// U+eb0c
+#define ICON_VS_ITALIC "\xee\xac\x8d"	// U+eb0d
+#define ICON_VS_JERSEY "\xee\xac\x8e"	// U+eb0e
+#define ICON_VS_JSON "\xee\xac\x8f"	// U+eb0f
+#define ICON_VS_KEBAB_VERTICAL "\xee\xac\x90"	// U+eb10
+#define ICON_VS_KEY "\xee\xac\x91"	// U+eb11
+#define ICON_VS_LAW "\xee\xac\x92"	// U+eb12
+#define ICON_VS_LIGHTBULB_AUTOFIX "\xee\xac\x93"	// U+eb13
+#define ICON_VS_LINK_EXTERNAL "\xee\xac\x94"	// U+eb14
+#define ICON_VS_LINK "\xee\xac\x95"	// U+eb15
+#define ICON_VS_LIST_ORDERED "\xee\xac\x96"	// U+eb16
+#define ICON_VS_LIST_UNORDERED "\xee\xac\x97"	// U+eb17
+#define ICON_VS_LIVE_SHARE "\xee\xac\x98"	// U+eb18
+#define ICON_VS_LOADING "\xee\xac\x99"	// U+eb19
+#define ICON_VS_LOCATION "\xee\xac\x9a"	// U+eb1a
+#define ICON_VS_MAIL_READ "\xee\xac\x9b"	// U+eb1b
+#define ICON_VS_MAIL "\xee\xac\x9c"	// U+eb1c
+#define ICON_VS_MARKDOWN "\xee\xac\x9d"	// U+eb1d
+#define ICON_VS_MEGAPHONE "\xee\xac\x9e"	// U+eb1e
+#define ICON_VS_MENTION "\xee\xac\x9f"	// U+eb1f
+#define ICON_VS_MILESTONE "\xee\xac\xa0"	// U+eb20
+#define ICON_VS_MORTAR_BOARD "\xee\xac\xa1"	// U+eb21
+#define ICON_VS_MOVE "\xee\xac\xa2"	// U+eb22
+#define ICON_VS_MULTIPLE_WINDOWS "\xee\xac\xa3"	// U+eb23
+#define ICON_VS_MUTE "\xee\xac\xa4"	// U+eb24
+#define ICON_VS_NO_NEWLINE "\xee\xac\xa5"	// U+eb25
+#define ICON_VS_NOTE "\xee\xac\xa6"	// U+eb26
+#define ICON_VS_OCTOFACE "\xee\xac\xa7"	// U+eb27
+#define ICON_VS_OPEN_PREVIEW "\xee\xac\xa8"	// U+eb28
+#define ICON_VS_PACKAGE "\xee\xac\xa9"	// U+eb29
+#define ICON_VS_PAINTCAN "\xee\xac\xaa"	// U+eb2a
+#define ICON_VS_PIN "\xee\xac\xab"	// U+eb2b
+#define ICON_VS_PLAY "\xee\xac\xac"	// U+eb2c
+#define ICON_VS_RUN "\xee\xac\xac"	// U+eb2c
+#define ICON_VS_PLUG "\xee\xac\xad"	// U+eb2d
+#define ICON_VS_PRESERVE_CASE "\xee\xac\xae"	// U+eb2e
+#define ICON_VS_PREVIEW "\xee\xac\xaf"	// U+eb2f
+#define ICON_VS_PROJECT "\xee\xac\xb0"	// U+eb30
+#define ICON_VS_PULSE "\xee\xac\xb1"	// U+eb31
+#define ICON_VS_QUESTION "\xee\xac\xb2"	// U+eb32
+#define ICON_VS_QUOTE "\xee\xac\xb3"	// U+eb33
+#define ICON_VS_RADIO_TOWER "\xee\xac\xb4"	// U+eb34
+#define ICON_VS_REACTIONS "\xee\xac\xb5"	// U+eb35
+#define ICON_VS_REFERENCES "\xee\xac\xb6"	// U+eb36
+#define ICON_VS_REFRESH "\xee\xac\xb7"	// U+eb37
+#define ICON_VS_REGEX "\xee\xac\xb8"	// U+eb38
+#define ICON_VS_REMOTE_EXPLORER "\xee\xac\xb9"	// U+eb39
+#define ICON_VS_REMOTE "\xee\xac\xba"	// U+eb3a
+#define ICON_VS_REMOVE "\xee\xac\xbb"	// U+eb3b
+#define ICON_VS_REPLACE_ALL "\xee\xac\xbc"	// U+eb3c
+#define ICON_VS_REPLACE "\xee\xac\xbd"	// U+eb3d
+#define ICON_VS_REPO_CLONE "\xee\xac\xbe"	// U+eb3e
+#define ICON_VS_REPO_FORCE_PUSH "\xee\xac\xbf"	// U+eb3f
+#define ICON_VS_REPO_PULL "\xee\xad\x80"	// U+eb40
+#define ICON_VS_REPO_PUSH "\xee\xad\x81"	// U+eb41
+#define ICON_VS_REPORT "\xee\xad\x82"	// U+eb42
+#define ICON_VS_REQUEST_CHANGES "\xee\xad\x83"	// U+eb43
+#define ICON_VS_ROCKET "\xee\xad\x84"	// U+eb44
+#define ICON_VS_ROOT_FOLDER_OPENED "\xee\xad\x85"	// U+eb45
+#define ICON_VS_ROOT_FOLDER "\xee\xad\x86"	// U+eb46
+#define ICON_VS_RSS "\xee\xad\x87"	// U+eb47
+#define ICON_VS_RUBY "\xee\xad\x88"	// U+eb48
+#define ICON_VS_SAVE_ALL "\xee\xad\x89"	// U+eb49
+#define ICON_VS_SAVE_AS "\xee\xad\x8a"	// U+eb4a
+#define ICON_VS_SAVE "\xee\xad\x8b"	// U+eb4b
+#define ICON_VS_SCREEN_FULL "\xee\xad\x8c"	// U+eb4c
+#define ICON_VS_SCREEN_NORMAL "\xee\xad\x8d"	// U+eb4d
+#define ICON_VS_SEARCH_STOP "\xee\xad\x8e"	// U+eb4e
+#define ICON_VS_SERVER "\xee\xad\x90"	// U+eb50
+#define ICON_VS_SETTINGS_GEAR "\xee\xad\x91"	// U+eb51
+#define ICON_VS_SETTINGS "\xee\xad\x92"	// U+eb52
+#define ICON_VS_SHIELD "\xee\xad\x93"	// U+eb53
+#define ICON_VS_SMILEY "\xee\xad\x94"	// U+eb54
+#define ICON_VS_SORT_PRECEDENCE "\xee\xad\x95"	// U+eb55
+#define ICON_VS_SPLIT_HORIZONTAL "\xee\xad\x96"	// U+eb56
+#define ICON_VS_SPLIT_VERTICAL "\xee\xad\x97"	// U+eb57
+#define ICON_VS_SQUIRREL "\xee\xad\x98"	// U+eb58
+#define ICON_VS_STAR_FULL "\xee\xad\x99"	// U+eb59
+#define ICON_VS_STAR_HALF "\xee\xad\x9a"	// U+eb5a
+#define ICON_VS_SYMBOL_CLASS "\xee\xad\x9b"	// U+eb5b
+#define ICON_VS_SYMBOL_COLOR "\xee\xad\x9c"	// U+eb5c
+#define ICON_VS_SYMBOL_CONSTANT "\xee\xad\x9d"	// U+eb5d
+#define ICON_VS_SYMBOL_ENUM_MEMBER "\xee\xad\x9e"	// U+eb5e
+#define ICON_VS_SYMBOL_FIELD "\xee\xad\x9f"	// U+eb5f
+#define ICON_VS_SYMBOL_FILE "\xee\xad\xa0"	// U+eb60
+#define ICON_VS_SYMBOL_INTERFACE "\xee\xad\xa1"	// U+eb61
+#define ICON_VS_SYMBOL_KEYWORD "\xee\xad\xa2"	// U+eb62
+#define ICON_VS_SYMBOL_MISC "\xee\xad\xa3"	// U+eb63
+#define ICON_VS_SYMBOL_OPERATOR "\xee\xad\xa4"	// U+eb64
+#define ICON_VS_SYMBOL_PROPERTY "\xee\xad\xa5"	// U+eb65
+#define ICON_VS_WRENCH "\xee\xad\xa5"	// U+eb65
+#define ICON_VS_WRENCH_SUBACTION "\xee\xad\xa5"	// U+eb65
+#define ICON_VS_SYMBOL_SNIPPET "\xee\xad\xa6"	// U+eb66
+#define ICON_VS_TASKLIST "\xee\xad\xa7"	// U+eb67
+#define ICON_VS_TELESCOPE "\xee\xad\xa8"	// U+eb68
+#define ICON_VS_TEXT_SIZE "\xee\xad\xa9"	// U+eb69
+#define ICON_VS_THREE_BARS "\xee\xad\xaa"	// U+eb6a
+#define ICON_VS_THUMBSDOWN "\xee\xad\xab"	// U+eb6b
+#define ICON_VS_THUMBSUP "\xee\xad\xac"	// U+eb6c
+#define ICON_VS_TOOLS "\xee\xad\xad"	// U+eb6d
+#define ICON_VS_TRIANGLE_DOWN "\xee\xad\xae"	// U+eb6e
+#define ICON_VS_TRIANGLE_LEFT "\xee\xad\xaf"	// U+eb6f
+#define ICON_VS_TRIANGLE_RIGHT "\xee\xad\xb0"	// U+eb70
+#define ICON_VS_TRIANGLE_UP "\xee\xad\xb1"	// U+eb71
+#define ICON_VS_TWITTER "\xee\xad\xb2"	// U+eb72
+#define ICON_VS_UNFOLD "\xee\xad\xb3"	// U+eb73
+#define ICON_VS_UNLOCK "\xee\xad\xb4"	// U+eb74
+#define ICON_VS_UNMUTE "\xee\xad\xb5"	// U+eb75
+#define ICON_VS_UNVERIFIED "\xee\xad\xb6"	// U+eb76
+#define ICON_VS_VERIFIED "\xee\xad\xb7"	// U+eb77
+#define ICON_VS_VERSIONS "\xee\xad\xb8"	// U+eb78
+#define ICON_VS_VM_ACTIVE "\xee\xad\xb9"	// U+eb79
+#define ICON_VS_VM_OUTLINE "\xee\xad\xba"	// U+eb7a
+#define ICON_VS_VM_RUNNING "\xee\xad\xbb"	// U+eb7b
+#define ICON_VS_WATCH "\xee\xad\xbc"	// U+eb7c
+#define ICON_VS_WHITESPACE "\xee\xad\xbd"	// U+eb7d
+#define ICON_VS_WHOLE_WORD "\xee\xad\xbe"	// U+eb7e
+#define ICON_VS_WINDOW "\xee\xad\xbf"	// U+eb7f
+#define ICON_VS_WORD_WRAP "\xee\xae\x80"	// U+eb80
+#define ICON_VS_ZOOM_IN "\xee\xae\x81"	// U+eb81
+#define ICON_VS_ZOOM_OUT "\xee\xae\x82"	// U+eb82
+#define ICON_VS_LIST_FILTER "\xee\xae\x83"	// U+eb83
+#define ICON_VS_LIST_FLAT "\xee\xae\x84"	// U+eb84
+#define ICON_VS_LIST_SELECTION "\xee\xae\x85"	// U+eb85
+#define ICON_VS_SELECTION "\xee\xae\x85"	// U+eb85
+#define ICON_VS_LIST_TREE "\xee\xae\x86"	// U+eb86
+#define ICON_VS_DEBUG_BREAKPOINT_FUNCTION_UNVERIFIED "\xee\xae\x87"	// U+eb87
+#define ICON_VS_DEBUG_BREAKPOINT_FUNCTION "\xee\xae\x88"	// U+eb88
+#define ICON_VS_DEBUG_BREAKPOINT_FUNCTION_DISABLED "\xee\xae\x88"	// U+eb88
+#define ICON_VS_DEBUG_STACKFRAME_ACTIVE "\xee\xae\x89"	// U+eb89
+#define ICON_VS_DEBUG_STACKFRAME_DOT "\xee\xae\x8a"	// U+eb8a
+#define ICON_VS_DEBUG_STACKFRAME "\xee\xae\x8b"	// U+eb8b
+#define ICON_VS_DEBUG_STACKFRAME_FOCUSED "\xee\xae\x8b"	// U+eb8b
+#define ICON_VS_DEBUG_BREAKPOINT_UNSUPPORTED "\xee\xae\x8c"	// U+eb8c
+#define ICON_VS_SYMBOL_STRING "\xee\xae\x8d"	// U+eb8d
+#define ICON_VS_DEBUG_REVERSE_CONTINUE "\xee\xae\x8e"	// U+eb8e
+#define ICON_VS_DEBUG_STEP_BACK "\xee\xae\x8f"	// U+eb8f
+#define ICON_VS_DEBUG_RESTART_FRAME "\xee\xae\x90"	// U+eb90
+#define ICON_VS_DEBUG_ALT "\xee\xae\x91"	// U+eb91
+#define ICON_VS_CALL_INCOMING "\xee\xae\x92"	// U+eb92
+#define ICON_VS_CALL_OUTGOING "\xee\xae\x93"	// U+eb93
+#define ICON_VS_MENU "\xee\xae\x94"	// U+eb94
+#define ICON_VS_EXPAND_ALL "\xee\xae\x95"	// U+eb95
+#define ICON_VS_FEEDBACK "\xee\xae\x96"	// U+eb96
+#define ICON_VS_GROUP_BY_REF_TYPE "\xee\xae\x97"	// U+eb97
+#define ICON_VS_UNGROUP_BY_REF_TYPE "\xee\xae\x98"	// U+eb98
+#define ICON_VS_ACCOUNT "\xee\xae\x99"	// U+eb99
+#define ICON_VS_BELL_DOT "\xee\xae\x9a"	// U+eb9a
+#define ICON_VS_DEBUG_CONSOLE "\xee\xae\x9b"	// U+eb9b
+#define ICON_VS_LIBRARY "\xee\xae\x9c"	// U+eb9c
+#define ICON_VS_OUTPUT "\xee\xae\x9d"	// U+eb9d
+#define ICON_VS_RUN_ALL "\xee\xae\x9e"	// U+eb9e
+#define ICON_VS_SYNC_IGNORED "\xee\xae\x9f"	// U+eb9f
+#define ICON_VS_PINNED "\xee\xae\xa0"	// U+eba0
+#define ICON_VS_GITHUB_INVERTED "\xee\xae\xa1"	// U+eba1
+#define ICON_VS_SERVER_PROCESS "\xee\xae\xa2"	// U+eba2
+#define ICON_VS_SERVER_ENVIRONMENT "\xee\xae\xa3"	// U+eba3
+#define ICON_VS_PASS "\xee\xae\xa4"	// U+eba4
+#define ICON_VS_ISSUE_CLOSED "\xee\xae\xa4"	// U+eba4
+#define ICON_VS_STOP_CIRCLE "\xee\xae\xa5"	// U+eba5
+#define ICON_VS_PLAY_CIRCLE "\xee\xae\xa6"	// U+eba6
+#define ICON_VS_RECORD "\xee\xae\xa7"	// U+eba7
+#define ICON_VS_DEBUG_ALT_SMALL "\xee\xae\xa8"	// U+eba8
+#define ICON_VS_VM_CONNECT "\xee\xae\xa9"	// U+eba9
+#define ICON_VS_CLOUD "\xee\xae\xaa"	// U+ebaa
+#define ICON_VS_MERGE "\xee\xae\xab"	// U+ebab
+#define ICON_VS_EXPORT "\xee\xae\xac"	// U+ebac
+#define ICON_VS_GRAPH_LEFT "\xee\xae\xad"	// U+ebad
+#define ICON_VS_MAGNET "\xee\xae\xae"	// U+ebae
+#define ICON_VS_NOTEBOOK "\xee\xae\xaf"	// U+ebaf
+#define ICON_VS_REDO "\xee\xae\xb0"	// U+ebb0
+#define ICON_VS_CHECK_ALL "\xee\xae\xb1"	// U+ebb1
+#define ICON_VS_PINNED_DIRTY "\xee\xae\xb2"	// U+ebb2
+#define ICON_VS_PASS_FILLED "\xee\xae\xb3"	// U+ebb3
+#define ICON_VS_CIRCLE_LARGE_FILLED "\xee\xae\xb4"	// U+ebb4
+#define ICON_VS_CIRCLE_LARGE_OUTLINE "\xee\xae\xb5"	// U+ebb5
+#define ICON_VS_COMBINE "\xee\xae\xb6"	// U+ebb6
+#define ICON_VS_GATHER "\xee\xae\xb6"	// U+ebb6
+#define ICON_VS_TABLE "\xee\xae\xb7"	// U+ebb7
+#define ICON_VS_VARIABLE_GROUP "\xee\xae\xb8"	// U+ebb8
+#define ICON_VS_TYPE_HIERARCHY "\xee\xae\xb9"	// U+ebb9
+#define ICON_VS_TYPE_HIERARCHY_SUB "\xee\xae\xba"	// U+ebba
+#define ICON_VS_TYPE_HIERARCHY_SUPER "\xee\xae\xbb"	// U+ebbb
+#define ICON_VS_GIT_PULL_REQUEST_CREATE "\xee\xae\xbc"	// U+ebbc
+#define ICON_VS_RUN_ABOVE "\xee\xae\xbd"	// U+ebbd
+#define ICON_VS_RUN_BELOW "\xee\xae\xbe"	// U+ebbe
+#define ICON_VS_NOTEBOOK_TEMPLATE "\xee\xae\xbf"	// U+ebbf
+#define ICON_VS_DEBUG_RERUN "\xee\xaf\x80"	// U+ebc0
+#define ICON_VS_WORKSPACE_TRUSTED "\xee\xaf\x81"	// U+ebc1
+#define ICON_VS_WORKSPACE_UNTRUSTED "\xee\xaf\x82"	// U+ebc2
+#define ICON_VS_WORKSPACE_UNKNOWN "\xee\xaf\x83"	// U+ebc3
+#define ICON_VS_TERMINAL_CMD "\xee\xaf\x84"	// U+ebc4
+#define ICON_VS_TERMINAL_DEBIAN "\xee\xaf\x85"	// U+ebc5
+#define ICON_VS_TERMINAL_LINUX "\xee\xaf\x86"	// U+ebc6
+#define ICON_VS_TERMINAL_POWERSHELL "\xee\xaf\x87"	// U+ebc7
+#define ICON_VS_TERMINAL_TMUX "\xee\xaf\x88"	// U+ebc8
+#define ICON_VS_TERMINAL_UBUNTU "\xee\xaf\x89"	// U+ebc9
+#define ICON_VS_TERMINAL_BASH "\xee\xaf\x8a"	// U+ebca
+#define ICON_VS_ARROW_SWAP "\xee\xaf\x8b"	// U+ebcb
+#define ICON_VS_COPY "\xee\xaf\x8c"	// U+ebcc
+#define ICON_VS_PERSON_ADD "\xee\xaf\x8d"	// U+ebcd
+#define ICON_VS_FILTER_FILLED "\xee\xaf\x8e"	// U+ebce
+#define ICON_VS_WAND "\xee\xaf\x8f"	// U+ebcf
+#define ICON_VS_DEBUG_LINE_BY_LINE "\xee\xaf\x90"	// U+ebd0
+#define ICON_VS_INSPECT "\xee\xaf\x91"	// U+ebd1
+#define ICON_VS_LAYERS "\xee\xaf\x92"	// U+ebd2
+#define ICON_VS_LAYERS_DOT "\xee\xaf\x93"	// U+ebd3
+#define ICON_VS_LAYERS_ACTIVE "\xee\xaf\x94"	// U+ebd4
+#define ICON_VS_COMPASS "\xee\xaf\x95"	// U+ebd5
+#define ICON_VS_COMPASS_DOT "\xee\xaf\x96"	// U+ebd6
+#define ICON_VS_COMPASS_ACTIVE "\xee\xaf\x97"	// U+ebd7
+#define ICON_VS_AZURE "\xee\xaf\x98"	// U+ebd8
+#define ICON_VS_ISSUE_DRAFT "\xee\xaf\x99"	// U+ebd9
+#define ICON_VS_GIT_PULL_REQUEST_CLOSED "\xee\xaf\x9a"	// U+ebda
+#define ICON_VS_GIT_PULL_REQUEST_DRAFT "\xee\xaf\x9b"	// U+ebdb
+#define ICON_VS_DEBUG_ALL "\xee\xaf\x9c"	// U+ebdc
+#define ICON_VS_DEBUG_COVERAGE "\xee\xaf\x9d"	// U+ebdd

lib/external/imgui/fonts/unifont_font.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#define FONT_ICON_FILE_NAME_UNIFONT "unifont.ttf"
+
+extern const unsigned int unifont_compressed_size;
+extern const unsigned int unifont_compressed_data[52184/4];

lib/external/imgui/include/imconfig.h

@@ -20,7 +20,9 @@
 //#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
 
 //---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
-// Using dear imgui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
 //#define IMGUI_API __declspec( dllexport )
 //#define IMGUI_API __declspec( dllimport )
 
@@ -31,17 +33,21 @@
 // It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
 //#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
 //#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
-//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger window: ShowMetricsWindow() will be empty.
+//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger and other debug tools: ShowMetricsWindow() and ShowStackToolWindow() will be empty.
 
 //---- Don't implement some functions to reduce linkage requirements.
-//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc.
-//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] Don't implement default IME handler. Won't use and link with ImmGetContext/ImmSetCompositionWindow.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
 //#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
 //#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
 //#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
 //#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
-//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
 //#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+#define IMGUI_DEFINE_MATH_OPERATORS
 
 //---- Include imgui_user.h at the end of imgui.h as a convenience
 //#define IMGUI_INCLUDE_IMGUI_USER_H
@@ -53,7 +59,7 @@
 //#define IMGUI_USE_WCHAR32
 
 //---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
-// By default the embedded implementations are declared static and not available outside of imgui cpp files.
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
 //#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
 //#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
 //#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
@@ -63,6 +69,15 @@
 // Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
 // #define IMGUI_USE_STB_SPRINTF
 
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
 //---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
 // This will be inlined as part of ImVec2 and ImVec4 class declarations.
 /*

lib/external/imgui/include/imgui_freetype.h

@@ -0,0 +1,50 @@
+// dear imgui: FreeType font builder (used as a replacement for the stb_truetype builder)
+// (headers)
+
+#pragma once
+
+#include "imgui.h"      // IMGUI_API
+
+// Forward declarations
+struct ImFontAtlas;
+struct ImFontBuilderIO;
+
+// Hinting greatly impacts visuals (and glyph sizes).
+// - By default, hinting is enabled and the font's native hinter is preferred over the auto-hinter.
+// - When disabled, FreeType generates blurrier glyphs, more or less matches the stb_truetype.h
+// - The Default hinting mode usually looks good, but may distort glyphs in an unusual way.
+// - The Light hinting mode generates fuzzier glyphs but better matches Microsoft's rasterizer.
+// You can set those flags globaly in ImFontAtlas::FontBuilderFlags
+// You can set those flags on a per font basis in ImFontConfig::FontBuilderFlags
+enum ImGuiFreeTypeBuilderFlags
+{
+    ImGuiFreeTypeBuilderFlags_NoHinting     = 1 << 0,   // Disable hinting. This generally generates 'blurrier' bitmap glyphs when the glyph are rendered in any of the anti-aliased modes.
+    ImGuiFreeTypeBuilderFlags_NoAutoHint    = 1 << 1,   // Disable auto-hinter.
+    ImGuiFreeTypeBuilderFlags_ForceAutoHint = 1 << 2,   // Indicates that the auto-hinter is preferred over the font's native hinter.
+    ImGuiFreeTypeBuilderFlags_LightHinting  = 1 << 3,   // A lighter hinting algorithm for gray-level modes. Many generated glyphs are fuzzier but better resemble their original shape. This is achieved by snapping glyphs to the pixel grid only vertically (Y-axis), as is done by Microsoft's ClearType and Adobe's proprietary font renderer. This preserves inter-glyph spacing in horizontal text.
+    ImGuiFreeTypeBuilderFlags_MonoHinting   = 1 << 4,   // Strong hinting algorithm that should only be used for monochrome output.
+    ImGuiFreeTypeBuilderFlags_Bold          = 1 << 5,   // Styling: Should we artificially embolden the font?
+    ImGuiFreeTypeBuilderFlags_Oblique       = 1 << 6,   // Styling: Should we slant the font, emulating italic style?
+    ImGuiFreeTypeBuilderFlags_Monochrome    = 1 << 7,   // Disable anti-aliasing. Combine this with MonoHinting for best results!
+    ImGuiFreeTypeBuilderFlags_LoadColor     = 1 << 8,   // Enable FreeType color-layered glyphs
+    ImGuiFreeTypeBuilderFlags_Bitmap        = 1 << 9    // Enable FreeType bitmap glyphs
+};
+
+namespace ImGuiFreeType
+{
+    // This is automatically assigned when using '#define IMGUI_ENABLE_FREETYPE'.
+    // If you need to dynamically select between multiple builders:
+    // - you can manually assign this builder with 'atlas->FontBuilderIO = ImGuiFreeType::GetBuilderForFreeType()'
+    // - prefer deep-copying this into your own ImFontBuilderIO instance if you use hot-reloading that messes up static data.
+    IMGUI_API const ImFontBuilderIO*    GetBuilderForFreeType();
+
+    // Override allocators. By default ImGuiFreeType will use IM_ALLOC()/IM_FREE()
+    // However, as FreeType does lots of allocations we provide a way for the user to redirect it to a separate memory heap if desired.
+    IMGUI_API void                      SetAllocatorFunctions(void* (*alloc_func)(size_t sz, void* user_data), void (*free_func)(void* ptr, void* user_data), void* user_data = NULL);
+
+    // Obsolete names (will be removed soon)
+    // Prefer using '#define IMGUI_ENABLE_FREETYPE'
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    static inline bool BuildFontAtlas(ImFontAtlas* atlas, unsigned int flags = 0) { atlas->FontBuilderIO = GetBuilderForFreeType(); atlas->FontBuilderFlags = flags; return atlas->Build(); }
+#endif
+}

lib/external/imgui/include/imgui_impl_glfw.h

@@ -1,5 +1,5 @@
 // dear imgui: Platform Backend for GLFW
-// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan..)
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
 // (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
 
 // Implemented features:
@@ -7,8 +7,13 @@
 //  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
 //  [x] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. FIXME: 3 cursors types are missing from GLFW.
 //  [X] Platform: Keyboard arrays indexed using GLFW_KEY_* codes, e.g. ImGui::IsKeyPressed(GLFW_KEY_SPACE).
+//  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
 
-// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Issues:
+//  [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
 // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
 // Read online: https://github.com/ocornut/imgui/tree/master/docs
 
@@ -20,16 +25,21 @@
 #include "imgui.h"      // IMGUI_IMPL_API
 
 struct GLFWwindow;
+struct GLFWmonitor;
 
 IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
 IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
 IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
 IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
 
 // GLFW callbacks
 // - When calling Init with 'install_callbacks=true': GLFW callbacks will be installed for you. They will call user's previously installed callbacks, if any.
 // - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call those function yourself from your own GLFW callbacks.
+IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);
 IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
 IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
 IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
 IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);

lib/external/imgui/include/imgui_impl_opengl3.h

@@ -5,17 +5,14 @@
 
 // Implemented features:
 //  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+//  [X] Renderer: Multi-viewport support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
 //  [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
 
-// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
 // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
 // Read online: https://github.com/ocornut/imgui/tree/master/docs
 
-// About Desktop OpenGL function loaders:
-//  Modern Desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
-//  Helper libraries are often used for this purpose! Here we are supporting a few common ones (gl3w, glew, glad).
-//  You may use another loader/header of your choice (glext, glLoadGen, etc.), or chose to manually implement your own.
-
 // About GLSL version:
 //  The 'glsl_version' initialization parameter should be NULL (default) or a "#version XXX" string.
 //  On computer platform the GLSL version default to "#version 130". On OpenGL ES 3 platform it defaults to "#version 300 es"
@@ -40,19 +37,9 @@ IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
 //#define IMGUI_IMPL_OPENGL_ES2     // Auto-detected on Emscripten
 //#define IMGUI_IMPL_OPENGL_ES3     // Auto-detected on iOS/Android
 
-// Attempt to auto-detect the default Desktop GL loader based on available header files.
-// If auto-detection fails or doesn't select the same GL loader file as used by your application,
-// you are likely to get a crash in ImGui_ImplOpenGL3_Init().
-// You can explicitly select a loader by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
+// You can explicitly select GLES2 or GLES3 API by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
 #if !defined(IMGUI_IMPL_OPENGL_ES2) \
- && !defined(IMGUI_IMPL_OPENGL_ES3) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GL3W) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GLEW) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GLAD) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GLAD2) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3) \
- && !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
+ && !defined(IMGUI_IMPL_OPENGL_ES3)
 
 // Try to detect GLES on matching platforms
 #if defined(__APPLE__)
@@ -62,26 +49,8 @@ IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
 #define IMGUI_IMPL_OPENGL_ES3               // iOS, Android  -> GL ES 3, "#version 300 es"
 #elif defined(__EMSCRIPTEN__)
 #define IMGUI_IMPL_OPENGL_ES2               // Emscripten    -> GL ES 2, "#version 100"
-
-// Otherwise try to detect supported Desktop OpenGL loaders..
-#elif defined(__has_include)
-#if __has_include(<GL/glew.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GLEW
-#elif __has_include(<glad/glad.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GLAD
-#elif __has_include(<glad/gl.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GLAD2
-#elif __has_include(<GL/gl3w.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GL3W
-#elif __has_include(<glbinding/glbinding.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GLBINDING3
-#elif __has_include(<glbinding/Binding.h>)
-    #define IMGUI_IMPL_OPENGL_LOADER_GLBINDING2
 #else
-    #error "Cannot detect OpenGL loader!"
-#endif
-#else
-    #define IMGUI_IMPL_OPENGL_LOADER_GL3W   // Default to GL3W embedded in our repository
+// Otherwise imgui_impl_opengl3_loader.h will be used.
 #endif
 
 #endif

lib/external/imgui/include/imgui_impl_opengl3_loader.h

@@ -0,0 +1,731 @@
+/*
+ * This file was generated with gl3w_gen.py, part of imgl3w
+ * (hosted at https://github.com/dearimgui/gl3w_stripped)
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// We embed our own OpenGL loader to not require user to provide their own or to have to use ours, which proved to be endless problems for users.
+// Our loader is custom-generated, based on gl3w but automatically filtered to only include enums/functions that we use in this source file.
+// Regenerate with: python gl3w_gen.py --imgui-dir /path/to/imgui/
+// see https://github.com/dearimgui/gl3w_stripped for more info.
+#ifndef __gl3w_h_
+#define __gl3w_h_
+
+// Adapted from KHR/khrplatform.h to avoid including entire file.
+typedef          float         khronos_float_t;
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef signed   long long int khronos_ssize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef signed   long  int     khronos_ssize_t;
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+typedef signed   __int64       khronos_int64_t;
+typedef unsigned __int64       khronos_uint64_t;
+#elif (defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)
+#include <stdint.h>
+typedef          int64_t       khronos_int64_t;
+typedef          uint64_t      khronos_uint64_t;
+#else
+typedef signed   long long     khronos_int64_t;
+typedef unsigned long long     khronos_uint64_t;
+#endif
+
+#ifndef __gl_glcorearb_h_
+#define __gl_glcorearb_h_ 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: MIT
+**
+** This header is generated from the Khronos OpenGL / OpenGL ES XML
+** API Registry. The current version of the Registry, generator scripts
+** used to make the header, and the header can be found at
+**   https://github.com/KhronosGroup/OpenGL-Registry
+*/
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#endif
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+/* glcorearb.h is for use with OpenGL core profile implementations.
+** It should should be placed in the same directory as gl.h and
+** included as <GL/glcorearb.h>.
+**
+** glcorearb.h includes only APIs in the latest OpenGL core profile
+** implementation together with APIs in newer ARB extensions which 
+** can be supported by the core profile. It does not, and never will
+** include functionality removed from the core profile, such as
+** fixed-function vertex and fragment processing.
+**
+** Do not #include both <GL/glcorearb.h> and either of <GL/gl.h> or
+** <GL/glext.h> in the same source file.
+*/
+/* Generated C header for:
+ * API: gl
+ * Profile: core
+ * Versions considered: .*
+ * Versions emitted: .*
+ * Default extensions included: glcore
+ * Additional extensions included: _nomatch_^
+ * Extensions removed: _nomatch_^
+ */
+#ifndef GL_VERSION_1_0
+typedef void GLvoid;
+typedef unsigned int GLenum;
+
+typedef khronos_float_t GLfloat;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned int GLbitfield;
+typedef double GLdouble;
+typedef unsigned int GLuint;
+typedef unsigned char GLboolean;
+typedef khronos_uint8_t GLubyte;
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_FALSE                          0
+#define GL_TRUE                           1
+#define GL_TRIANGLES                      0x0004
+#define GL_ONE                            1
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_POLYGON_MODE                   0x0B40
+#define GL_CULL_FACE                      0x0B44
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_VIEWPORT                       0x0BA2
+#define GL_BLEND                          0x0BE2
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_UNPACK_ROW_LENGTH              0x0CF2
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_RGBA                           0x1908
+#define GL_FILL                           0x1B02
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+typedef void (APIENTRYP PFNGLPOLYGONMODEPROC) (GLenum face, GLenum mode);
+typedef void (APIENTRYP PFNGLSCISSORPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+typedef void (APIENTRYP PFNGLCLEARPROC) (GLbitfield mask);
+typedef void (APIENTRYP PFNGLCLEARCOLORPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (APIENTRYP PFNGLDISABLEPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLENABLEPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLPIXELSTOREIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLREADPIXELSPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+typedef void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *data);
+typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
+typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLVIEWPORTPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPolygonMode (GLenum face, GLenum mode);
+GLAPI void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+GLAPI void APIENTRY glClear (GLbitfield mask);
+GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI void APIENTRY glDisable (GLenum cap);
+GLAPI void APIENTRY glEnable (GLenum cap);
+GLAPI void APIENTRY glPixelStorei (GLenum pname, GLint param);
+GLAPI void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint *data);
+GLAPI const GLubyte *APIENTRY glGetString (GLenum name);
+GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
+GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+#endif /* GL_VERSION_1_0 */
+#ifndef GL_VERSION_1_1
+typedef khronos_float_t GLclampf;
+typedef double GLclampd;
+#define GL_TEXTURE_BINDING_2D             0x8069
+typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices);
+typedef void (APIENTRYP PFNGLBINDTEXTUREPROC) (GLenum target, GLuint texture);
+typedef void (APIENTRYP PFNGLDELETETEXTURESPROC) (GLsizei n, const GLuint *textures);
+typedef void (APIENTRYP PFNGLGENTEXTURESPROC) (GLsizei n, GLuint *textures);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices);
+GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
+GLAPI void APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
+GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
+#endif
+#endif /* GL_VERSION_1_1 */
+#ifndef GL_VERSION_1_3
+#define GL_TEXTURE0                       0x84C0
+#define GL_ACTIVE_TEXTURE                 0x84E0
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveTexture (GLenum texture);
+#endif
+#endif /* GL_VERSION_1_3 */
+#ifndef GL_VERSION_1_4
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_FUNC_ADD                       0x8006
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+GLAPI void APIENTRY glBlendEquation (GLenum mode);
+#endif
+#endif /* GL_VERSION_1_4 */
+#ifndef GL_VERSION_1_5
+typedef khronos_ssize_t GLsizeiptr;
+typedef khronos_intptr_t GLintptr;
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_STREAM_DRAW                    0x88E0
+typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
+typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
+typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GLAPI void APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers);
+GLAPI void APIENTRY glGenBuffers (GLsizei n, GLuint *buffers);
+GLAPI void APIENTRY glBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+#endif
+#endif /* GL_VERSION_1_5 */
+#ifndef GL_VERSION_2_0
+typedef char GLchar;
+typedef khronos_int16_t GLshort;
+typedef khronos_int8_t GLbyte;
+typedef khronos_uint16_t GLushort;
+#define GL_BLEND_EQUATION_RGB             0x8009
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+#define GL_FRAGMENT_SHADER                0x8B30
+#define GL_VERTEX_SHADER                  0x8B31
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_LINK_STATUS                    0x8B82
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_CURRENT_PROGRAM                0x8B8D
+#define GL_UPPER_LEFT                     0x8CA2
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha);
+typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
+typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GLAPI void APIENTRY glAttachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glCompileShader (GLuint shader);
+GLAPI GLuint APIENTRY glCreateProgram (void);
+GLAPI GLuint APIENTRY glCreateShader (GLenum type);
+GLAPI void APIENTRY glDeleteProgram (GLuint program);
+GLAPI void APIENTRY glDeleteShader (GLuint shader);
+GLAPI void APIENTRY glDetachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glEnableVertexAttribArray (GLuint index);
+GLAPI GLint APIENTRY glGetAttribLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI void APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI GLint APIENTRY glGetUniformLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glLinkProgram (GLuint program);
+GLAPI void APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+GLAPI void APIENTRY glUseProgram (GLuint program);
+GLAPI void APIENTRY glUniform1i (GLint location, GLint v0);
+GLAPI void APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+#endif
+#endif /* GL_VERSION_2_0 */
+#ifndef GL_VERSION_3_0
+typedef khronos_uint16_t GLhalf;
+#define GL_MAJOR_VERSION                  0x821B
+#define GL_MINOR_VERSION                  0x821C
+#define GL_NUM_EXTENSIONS                 0x821D
+#define GL_FRAMEBUFFER_SRGB               0x8DB9
+#define GL_VERTEX_ARRAY_BINDING           0x85B5
+typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC) (GLenum target, GLuint index, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint *data);
+typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGIPROC) (GLenum name, GLuint index);
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI const GLubyte *APIENTRY glGetStringi (GLenum name, GLuint index);
+GLAPI void APIENTRY glBindVertexArray (GLuint array);
+GLAPI void APIENTRY glDeleteVertexArrays (GLsizei n, const GLuint *arrays);
+GLAPI void APIENTRY glGenVertexArrays (GLsizei n, GLuint *arrays);
+#endif
+#endif /* GL_VERSION_3_0 */
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+#define GL_PRIMITIVE_RESTART              0x8F9D
+#endif /* GL_VERSION_3_1 */
+#ifndef GL_VERSION_3_2
+#define GL_VERSION_3_2 1
+typedef struct __GLsync *GLsync;
+typedef khronos_uint64_t GLuint64;
+typedef khronos_int64_t GLint64;
+typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC) (GLenum target, GLuint index, GLint64 *data);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+#endif
+#endif /* GL_VERSION_3_2 */
+#ifndef GL_VERSION_3_3
+#define GL_VERSION_3_3 1
+#define GL_SAMPLER_BINDING                0x8919
+typedef void (APIENTRYP PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindSampler (GLuint unit, GLuint sampler);
+#endif
+#endif /* GL_VERSION_3_3 */
+#ifndef GL_VERSION_4_1
+typedef void (APIENTRYP PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble *data);
+#endif /* GL_VERSION_4_1 */
+#ifndef GL_VERSION_4_3
+typedef void (APIENTRY  *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+#endif /* GL_VERSION_4_3 */
+#ifndef GL_VERSION_4_5
+#define GL_CLIP_ORIGIN                    0x935C
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint *param);
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI64_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
+#endif /* GL_VERSION_4_5 */
+#ifndef GL_ARB_bindless_texture
+typedef khronos_uint64_t GLuint64EXT;
+#endif /* GL_ARB_bindless_texture */
+#ifndef GL_ARB_cl_event
+struct _cl_context;
+struct _cl_event;
+#endif /* GL_ARB_cl_event */
+#ifndef GL_ARB_clip_control
+#define GL_ARB_clip_control 1
+#endif /* GL_ARB_clip_control */
+#ifndef GL_ARB_debug_output
+typedef void (APIENTRY  *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+#endif /* GL_ARB_debug_output */
+#ifndef GL_EXT_EGL_image_storage
+typedef void *GLeglImageOES;
+#endif /* GL_EXT_EGL_image_storage */
+#ifndef GL_EXT_direct_state_access
+typedef void (APIENTRYP PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, void **params);
+typedef void (APIENTRYP PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint *param);
+typedef void (APIENTRYP PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, void **param);
+#endif /* GL_EXT_direct_state_access */
+#ifndef GL_NV_draw_vulkan_image
+typedef void (APIENTRY  *GLVULKANPROCNV)(void);
+#endif /* GL_NV_draw_vulkan_image */
+#ifndef GL_NV_gpu_shader5
+typedef khronos_int64_t GLint64EXT;
+#endif /* GL_NV_gpu_shader5 */
+#ifndef GL_NV_vertex_buffer_unified_memory
+typedef void (APIENTRYP PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT *result);
+#endif /* GL_NV_vertex_buffer_unified_memory */
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#ifndef GL3W_API
+#define GL3W_API
+#endif
+
+#ifndef __gl_h_
+#define __gl_h_
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GL3W_OK 0
+#define GL3W_ERROR_INIT -1
+#define GL3W_ERROR_LIBRARY_OPEN -2
+#define GL3W_ERROR_OPENGL_VERSION -3
+
+typedef void (*GL3WglProc)(void);
+typedef GL3WglProc (*GL3WGetProcAddressProc)(const char *proc);
+
+/* gl3w api */
+GL3W_API int imgl3wInit(void);
+GL3W_API int imgl3wInit2(GL3WGetProcAddressProc proc);
+GL3W_API int imgl3wIsSupported(int major, int minor);
+GL3W_API GL3WglProc imgl3wGetProcAddress(const char *proc);
+
+/* gl3w internal state */
+union GL3WProcs {
+    GL3WglProc ptr[52];
+    struct {
+        PFNGLACTIVETEXTUREPROC           ActiveTexture;
+        PFNGLATTACHSHADERPROC            AttachShader;
+        PFNGLBINDBUFFERPROC              BindBuffer;
+        PFNGLBINDSAMPLERPROC             BindSampler;
+        PFNGLBINDTEXTUREPROC             BindTexture;
+        PFNGLBINDVERTEXARRAYPROC         BindVertexArray;
+        PFNGLBLENDEQUATIONPROC           BlendEquation;
+        PFNGLBLENDEQUATIONSEPARATEPROC   BlendEquationSeparate;
+        PFNGLBLENDFUNCSEPARATEPROC       BlendFuncSeparate;
+        PFNGLBUFFERDATAPROC              BufferData;
+        PFNGLCLEARPROC                   Clear;
+        PFNGLCLEARCOLORPROC              ClearColor;
+        PFNGLCOMPILESHADERPROC           CompileShader;
+        PFNGLCREATEPROGRAMPROC           CreateProgram;
+        PFNGLCREATESHADERPROC            CreateShader;
+        PFNGLDELETEBUFFERSPROC           DeleteBuffers;
+        PFNGLDELETEPROGRAMPROC           DeleteProgram;
+        PFNGLDELETESHADERPROC            DeleteShader;
+        PFNGLDELETETEXTURESPROC          DeleteTextures;
+        PFNGLDELETEVERTEXARRAYSPROC      DeleteVertexArrays;
+        PFNGLDETACHSHADERPROC            DetachShader;
+        PFNGLDISABLEPROC                 Disable;
+        PFNGLDRAWELEMENTSPROC            DrawElements;
+        PFNGLDRAWELEMENTSBASEVERTEXPROC  DrawElementsBaseVertex;
+        PFNGLENABLEPROC                  Enable;
+        PFNGLENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+        PFNGLGENBUFFERSPROC              GenBuffers;
+        PFNGLGENTEXTURESPROC             GenTextures;
+        PFNGLGENVERTEXARRAYSPROC         GenVertexArrays;
+        PFNGLGETATTRIBLOCATIONPROC       GetAttribLocation;
+        PFNGLGETINTEGERVPROC             GetIntegerv;
+        PFNGLGETPROGRAMINFOLOGPROC       GetProgramInfoLog;
+        PFNGLGETPROGRAMIVPROC            GetProgramiv;
+        PFNGLGETSHADERINFOLOGPROC        GetShaderInfoLog;
+        PFNGLGETSHADERIVPROC             GetShaderiv;
+        PFNGLGETSTRINGPROC               GetString;
+        PFNGLGETSTRINGIPROC              GetStringi;
+        PFNGLGETUNIFORMLOCATIONPROC      GetUniformLocation;
+        PFNGLISENABLEDPROC               IsEnabled;
+        PFNGLLINKPROGRAMPROC             LinkProgram;
+        PFNGLPIXELSTOREIPROC             PixelStorei;
+        PFNGLPOLYGONMODEPROC             PolygonMode;
+        PFNGLREADPIXELSPROC              ReadPixels;
+        PFNGLSCISSORPROC                 Scissor;
+        PFNGLSHADERSOURCEPROC            ShaderSource;
+        PFNGLTEXIMAGE2DPROC              TexImage2D;
+        PFNGLTEXPARAMETERIPROC           TexParameteri;
+        PFNGLUNIFORM1IPROC               Uniform1i;
+        PFNGLUNIFORMMATRIX4FVPROC        UniformMatrix4fv;
+        PFNGLUSEPROGRAMPROC              UseProgram;
+        PFNGLVERTEXATTRIBPOINTERPROC     VertexAttribPointer;
+        PFNGLVIEWPORTPROC                Viewport;
+    } gl;
+};
+
+GL3W_API extern union GL3WProcs gl3wProcs;
+
+/* OpenGL functions */
+#define glActiveTexture                  gl3wProcs.gl.ActiveTexture
+#define glAttachShader                   gl3wProcs.gl.AttachShader
+#define glBindBuffer                     gl3wProcs.gl.BindBuffer
+#define glBindSampler                    gl3wProcs.gl.BindSampler
+#define glBindTexture                    gl3wProcs.gl.BindTexture
+#define glBindVertexArray                gl3wProcs.gl.BindVertexArray
+#define glBlendEquation                  gl3wProcs.gl.BlendEquation
+#define glBlendEquationSeparate          gl3wProcs.gl.BlendEquationSeparate
+#define glBlendFuncSeparate              gl3wProcs.gl.BlendFuncSeparate
+#define glBufferData                     gl3wProcs.gl.BufferData
+#define glClear                          gl3wProcs.gl.Clear
+#define glClearColor                     gl3wProcs.gl.ClearColor
+#define glCompileShader                  gl3wProcs.gl.CompileShader
+#define glCreateProgram                  gl3wProcs.gl.CreateProgram
+#define glCreateShader                   gl3wProcs.gl.CreateShader
+#define glDeleteBuffers                  gl3wProcs.gl.DeleteBuffers
+#define glDeleteProgram                  gl3wProcs.gl.DeleteProgram
+#define glDeleteShader                   gl3wProcs.gl.DeleteShader
+#define glDeleteTextures                 gl3wProcs.gl.DeleteTextures
+#define glDeleteVertexArrays             gl3wProcs.gl.DeleteVertexArrays
+#define glDetachShader                   gl3wProcs.gl.DetachShader
+#define glDisable                        gl3wProcs.gl.Disable
+#define glDrawElements                   gl3wProcs.gl.DrawElements
+#define glDrawElementsBaseVertex         gl3wProcs.gl.DrawElementsBaseVertex
+#define glEnable                         gl3wProcs.gl.Enable
+#define glEnableVertexAttribArray        gl3wProcs.gl.EnableVertexAttribArray
+#define glGenBuffers                     gl3wProcs.gl.GenBuffers
+#define glGenTextures                    gl3wProcs.gl.GenTextures
+#define glGenVertexArrays                gl3wProcs.gl.GenVertexArrays
+#define glGetAttribLocation              gl3wProcs.gl.GetAttribLocation
+#define glGetIntegerv                    gl3wProcs.gl.GetIntegerv
+#define glGetProgramInfoLog              gl3wProcs.gl.GetProgramInfoLog
+#define glGetProgramiv                   gl3wProcs.gl.GetProgramiv
+#define glGetShaderInfoLog               gl3wProcs.gl.GetShaderInfoLog
+#define glGetShaderiv                    gl3wProcs.gl.GetShaderiv
+#define glGetString                      gl3wProcs.gl.GetString
+#define glGetStringi                     gl3wProcs.gl.GetStringi
+#define glGetUniformLocation             gl3wProcs.gl.GetUniformLocation
+#define glIsEnabled                      gl3wProcs.gl.IsEnabled
+#define glLinkProgram                    gl3wProcs.gl.LinkProgram
+#define glPixelStorei                    gl3wProcs.gl.PixelStorei
+#define glPolygonMode                    gl3wProcs.gl.PolygonMode
+#define glReadPixels                     gl3wProcs.gl.ReadPixels
+#define glScissor                        gl3wProcs.gl.Scissor
+#define glShaderSource                   gl3wProcs.gl.ShaderSource
+#define glTexImage2D                     gl3wProcs.gl.TexImage2D
+#define glTexParameteri                  gl3wProcs.gl.TexParameteri
+#define glUniform1i                      gl3wProcs.gl.Uniform1i
+#define glUniformMatrix4fv               gl3wProcs.gl.UniformMatrix4fv
+#define glUseProgram                     gl3wProcs.gl.UseProgram
+#define glVertexAttribPointer            gl3wProcs.gl.VertexAttribPointer
+#define glViewport                       gl3wProcs.gl.Viewport
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef IMGL3W_IMPL
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+#define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
+
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+static HMODULE libgl;
+typedef PROC(__stdcall* GL3WglGetProcAddr)(LPCSTR);
+static GL3WglGetProcAddr wgl_get_proc_address;
+
+static int open_libgl(void)
+{
+    libgl = LoadLibraryA("opengl32.dll");
+    if (!libgl)
+        return GL3W_ERROR_LIBRARY_OPEN;
+    wgl_get_proc_address = (GL3WglGetProcAddr)GetProcAddress(libgl, "wglGetProcAddress");
+    return GL3W_OK;
+}
+
+static void close_libgl(void) { FreeLibrary(libgl); }
+static GL3WglProc get_proc(const char *proc)
+{
+    GL3WglProc res;
+    res = (GL3WglProc)wgl_get_proc_address(proc);
+    if (!res)
+        res = (GL3WglProc)GetProcAddress(libgl, proc);
+    return res;
+}
+#elif defined(__APPLE__)
+#include <dlfcn.h>
+
+static void *libgl;
+static int open_libgl(void)
+{
+    libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL);
+    if (!libgl)
+        return GL3W_ERROR_LIBRARY_OPEN;
+    return GL3W_OK;
+}
+
+static void close_libgl(void) { dlclose(libgl); }
+
+static GL3WglProc get_proc(const char *proc)
+{
+    GL3WglProc res;
+    *(void **)(&res) = dlsym(libgl, proc);
+    return res;
+}
+#else
+#include <dlfcn.h>
+
+static void *libgl;
+static GL3WglProc (*glx_get_proc_address)(const GLubyte *);
+
+static int open_libgl(void)
+{
+    libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_LOCAL);
+    if (!libgl)
+        return GL3W_ERROR_LIBRARY_OPEN;
+    *(void **)(&glx_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB");
+    return GL3W_OK;
+}
+
+static void close_libgl(void) { dlclose(libgl); }
+
+static GL3WglProc get_proc(const char *proc)
+{
+    GL3WglProc res;
+    res = glx_get_proc_address((const GLubyte *)proc);
+    if (!res)
+        *(void **)(&res) = dlsym(libgl, proc);
+    return res;
+}
+#endif
+
+static struct { int major, minor; } version;
+
+static int parse_version(void)
+{
+    if (!glGetIntegerv)
+        return GL3W_ERROR_INIT;
+    glGetIntegerv(GL_MAJOR_VERSION, &version.major);
+    glGetIntegerv(GL_MINOR_VERSION, &version.minor);
+    if (version.major < 3)
+        return GL3W_ERROR_OPENGL_VERSION;
+    return GL3W_OK;
+}
+
+static void load_procs(GL3WGetProcAddressProc proc);
+
+int imgl3wInit(void)
+{
+    int res = open_libgl();
+    if (res)
+        return res;
+    atexit(close_libgl);
+    return imgl3wInit2(get_proc);
+}
+
+int imgl3wInit2(GL3WGetProcAddressProc proc)
+{
+    load_procs(proc);
+    return parse_version();
+}
+
+int imgl3wIsSupported(int major, int minor)
+{
+    if (major < 3)
+        return 0;
+    if (version.major == major)
+        return version.minor >= minor;
+    return version.major >= major;
+}
+
+GL3WglProc imgl3wGetProcAddress(const char *proc) { return get_proc(proc); }
+
+static const char *proc_names[] = {
+    "glActiveTexture",
+    "glAttachShader",
+    "glBindBuffer",
+    "glBindSampler",
+    "glBindTexture",
+    "glBindVertexArray",
+    "glBlendEquation",
+    "glBlendEquationSeparate",
+    "glBlendFuncSeparate",
+    "glBufferData",
+    "glClear",
+    "glClearColor",
+    "glCompileShader",
+    "glCreateProgram",
+    "glCreateShader",
+    "glDeleteBuffers",
+    "glDeleteProgram",
+    "glDeleteShader",
+    "glDeleteTextures",
+    "glDeleteVertexArrays",
+    "glDetachShader",
+    "glDisable",
+    "glDrawElements",
+    "glDrawElementsBaseVertex",
+    "glEnable",
+    "glEnableVertexAttribArray",
+    "glGenBuffers",
+    "glGenTextures",
+    "glGenVertexArrays",
+    "glGetAttribLocation",
+    "glGetIntegerv",
+    "glGetProgramInfoLog",
+    "glGetProgramiv",
+    "glGetShaderInfoLog",
+    "glGetShaderiv",
+    "glGetString",
+    "glGetStringi",
+    "glGetUniformLocation",
+    "glIsEnabled",
+    "glLinkProgram",
+    "glPixelStorei",
+    "glPolygonMode",
+    "glReadPixels",
+    "glScissor",
+    "glShaderSource",
+    "glTexImage2D",
+    "glTexParameteri",
+    "glUniform1i",
+    "glUniformMatrix4fv",
+    "glUseProgram",
+    "glVertexAttribPointer",
+    "glViewport",
+};
+
+GL3W_API union GL3WProcs gl3wProcs;
+
+static void load_procs(GL3WGetProcAddressProc proc)
+{
+    size_t i;
+    for (i = 0; i < ARRAY_SIZE(proc_names); i++)
+        gl3wProcs.ptr[i] = proc(proc_names[i]);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif

lib/external/imgui/include/imnodes.h

@@ -2,174 +2,219 @@
 
 #include <stddef.h>
 
-struct ImVec2;
+typedef int ImNodesCol;             // -> enum ImNodesCol_
+typedef int ImNodesStyleVar;        // -> enum ImNodesStyleVar_
+typedef int ImNodesStyleFlags;      // -> enum ImNodesStyleFlags_
+typedef int ImNodesPinShape;        // -> enum ImNodesPinShape_
+typedef int ImNodesAttributeFlags;  // -> enum ImNodesAttributeFlags_
+typedef int ImNodesMiniMapLocation; // -> enum ImNodesMiniMapLocation_
 
-namespace imnodes
+enum ImNodesCol_
 {
-enum ColorStyle
-{
-    ColorStyle_NodeBackground = 0,
-    ColorStyle_NodeBackgroundHovered,
-    ColorStyle_NodeBackgroundSelected,
-    ColorStyle_NodeOutline,
-    ColorStyle_TitleBar,
-    ColorStyle_TitleBarHovered,
-    ColorStyle_TitleBarSelected,
-    ColorStyle_Link,
-    ColorStyle_LinkHovered,
-    ColorStyle_LinkSelected,
-    ColorStyle_Pin,
-    ColorStyle_PinHovered,
-    ColorStyle_BoxSelector,
-    ColorStyle_BoxSelectorOutline,
-    ColorStyle_GridBackground,
-    ColorStyle_GridLine,
-    ColorStyle_Count
+    ImNodesCol_NodeBackground = 0,
+    ImNodesCol_NodeBackgroundHovered,
+    ImNodesCol_NodeBackgroundSelected,
+    ImNodesCol_NodeOutline,
+    ImNodesCol_TitleBar,
+    ImNodesCol_TitleBarHovered,
+    ImNodesCol_TitleBarSelected,
+    ImNodesCol_Link,
+    ImNodesCol_LinkHovered,
+    ImNodesCol_LinkSelected,
+    ImNodesCol_Pin,
+    ImNodesCol_PinHovered,
+    ImNodesCol_BoxSelector,
+    ImNodesCol_BoxSelectorOutline,
+    ImNodesCol_GridBackground,
+    ImNodesCol_GridLine,
+    ImNodesCol_MiniMapBackground,
+    ImNodesCol_MiniMapBackgroundHovered,
+    ImNodesCol_MiniMapOutline,
+    ImNodesCol_MiniMapOutlineHovered,
+    ImNodesCol_MiniMapNodeBackground,
+    ImNodesCol_MiniMapNodeBackgroundHovered,
+    ImNodesCol_MiniMapNodeBackgroundSelected,
+    ImNodesCol_MiniMapNodeOutline,
+    ImNodesCol_MiniMapLink,
+    ImNodesCol_MiniMapLinkSelected,
+    ImNodesCol_COUNT
 };
 
-enum StyleVar
+enum ImNodesStyleVar_
 {
-    StyleVar_GridSpacing = 0,
-    StyleVar_NodeCornerRounding,
-    StyleVar_NodePaddingHorizontal,
-    StyleVar_NodePaddingVertical,
-    StyleVar_NodeBorderThickness,
-    StyleVar_LinkThickness,
-    StyleVar_LinkLineSegmentsPerLength,
-    StyleVar_LinkHoverDistance,
-    StyleVar_PinCircleRadius,
-    StyleVar_PinQuadSideLength,
-    StyleVar_PinTriangleSideLength,
-    StyleVar_PinLineThickness,
-    StyleVar_PinHoverRadius,
-    StyleVar_PinOffset
+    ImNodesStyleVar_GridSpacing = 0,
+    ImNodesStyleVar_NodeCornerRounding,
+    ImNodesStyleVar_NodePaddingHorizontal,
+    ImNodesStyleVar_NodePaddingVertical,
+    ImNodesStyleVar_NodeBorderThickness,
+    ImNodesStyleVar_LinkThickness,
+    ImNodesStyleVar_LinkLineSegmentsPerLength,
+    ImNodesStyleVar_LinkHoverDistance,
+    ImNodesStyleVar_PinCircleRadius,
+    ImNodesStyleVar_PinQuadSideLength,
+    ImNodesStyleVar_PinTriangleSideLength,
+    ImNodesStyleVar_PinLineThickness,
+    ImNodesStyleVar_PinHoverRadius,
+    ImNodesStyleVar_PinOffset
 };
 
-enum StyleFlags
+enum ImNodesStyleFlags_
 {
-    StyleFlags_None = 0,
-    StyleFlags_NodeOutline = 1 << 0,
-    StyleFlags_GridLines = 1 << 2
+    ImNodesStyleFlags_None = 0,
+    ImNodesStyleFlags_NodeOutline = 1 << 0,
+    ImNodesStyleFlags_GridLines = 1 << 2
 };
 
-// This enum controls the way attribute pins look.
-enum PinShape
+enum ImNodesPinShape_
 {
-    PinShape_Circle,
-    PinShape_CircleFilled,
-    PinShape_Triangle,
-    PinShape_TriangleFilled,
-    PinShape_Quad,
-    PinShape_QuadFilled
+    ImNodesPinShape_Circle,
+    ImNodesPinShape_CircleFilled,
+    ImNodesPinShape_Triangle,
+    ImNodesPinShape_TriangleFilled,
+    ImNodesPinShape_Quad,
+    ImNodesPinShape_QuadFilled
 };
 
 // This enum controls the way the attribute pins behave.
-enum AttributeFlags
+enum ImNodesAttributeFlags_
 {
-    AttributeFlags_None = 0,
+    ImNodesAttributeFlags_None = 0,
     // Allow detaching a link by left-clicking and dragging the link at a pin it is connected to.
     // NOTE: the user has to actually delete the link for this to work. A deleted link can be
     // detected by calling IsLinkDestroyed() after EndNodeEditor().
-    AttributeFlags_EnableLinkDetachWithDragClick = 1 << 0,
+    ImNodesAttributeFlags_EnableLinkDetachWithDragClick = 1 << 0,
     // Visual snapping of an in progress link will trigger IsLink Created/Destroyed events. Allows
     // for previewing the creation of a link while dragging it across attributes. See here for demo:
     // https://github.com/Nelarius/imnodes/issues/41#issuecomment-647132113 NOTE: the user has to
     // actually delete the link for this to work. A deleted link can be detected by calling
     // IsLinkDestroyed() after EndNodeEditor().
-    AttributeFlags_EnableLinkCreationOnSnap = 1 << 1
+    ImNodesAttributeFlags_EnableLinkCreationOnSnap = 1 << 1
 };
 
-struct IO
+struct ImNodesIO
 {
     struct EmulateThreeButtonMouse
     {
         EmulateThreeButtonMouse();
 
-        // Controls whether this feature is enabled or not.
-        bool enabled;
-        const bool* modifier; // The keyboard modifier to use with the mouse left click. Set to
-                              // &ImGuiIO::KeyAlt by default.
-    } emulate_three_button_mouse;
+        // The keyboard modifier to use in combination with mouse left click to pan the editor view.
+        // Set to NULL by default. To enable this feature, set the modifier to point to a boolean
+        // indicating the state of a modifier. For example,
+        //
+        // ImNodes::GetIO().EmulateThreeButtonMouse.Modifier = &ImGui::GetIO().KeyAlt;
+        const bool* Modifier;
+    } EmulateThreeButtonMouse;
 
     struct LinkDetachWithModifierClick
     {
         LinkDetachWithModifierClick();
 
         // Pointer to a boolean value indicating when the desired modifier is pressed. Set to NULL
-        // by default (i.e. this feature is disabled). To enable the feature, set the link to point
-        // to, for example, &ImGuiIO::KeyCtrl.
+        // by default. To enable the feature, set the modifier to point to a boolean indicating the
+        // state of a modifier. For example,
+        //
+        // ImNodes::GetIO().LinkDetachWithModifierClick.Modifier = &ImGui::GetIO().KeyCtrl;
         //
         // Left-clicking a link with this modifier pressed will detach that link. NOTE: the user has
         // to actually delete the link for this to work. A deleted link can be detected by calling
         // IsLinkDestroyed() after EndNodeEditor().
-        const bool* modifier;
-    } link_detach_with_modifier_click;
+        const bool* Modifier;
+    } LinkDetachWithModifierClick;
 
-    IO();
+    // Holding alt mouse button pans the node area, by default middle mouse button will be used
+    // Set based on ImGuiMouseButton values
+    int AltMouseButton;
+
+    ImNodesIO();
 };
 
-struct Style
+struct ImNodesStyle
 {
-    float grid_spacing;
+    float GridSpacing;
 
-    float node_corner_rounding;
-    float node_padding_horizontal;
-    float node_padding_vertical;
-    float node_border_thickness;
+    float NodeCornerRounding;
+    float NodePaddingHorizontal;
+    float NodePaddingVertical;
+    float NodeBorderThickness;
 
-    float link_thickness;
-    float link_line_segments_per_length;
-    float link_hover_distance;
+    float LinkThickness;
+    float LinkLineSegmentsPerLength;
+    float LinkHoverDistance;
 
     // The following variables control the look and behavior of the pins. The default size of each
     // pin shape is balanced to occupy approximately the same surface area on the screen.
 
-    // The circle radius used when the pin shape is either PinShape_Circle or PinShape_CircleFilled.
-    float pin_circle_radius;
-    // The quad side length used when the shape is either PinShape_Quad or PinShape_QuadFilled.
-    float pin_quad_side_length;
-    // The equilateral triangle side length used when the pin shape is either PinShape_Triangle or
-    // PinShape_TriangleFilled.
-    float pin_triangle_side_length;
+    // The circle radius used when the pin shape is either ImNodesPinShape_Circle or
+    // ImNodesPinShape_CircleFilled.
+    float PinCircleRadius;
+    // The quad side length used when the shape is either ImNodesPinShape_Quad or
+    // ImNodesPinShape_QuadFilled.
+    float PinQuadSideLength;
+    // The equilateral triangle side length used when the pin shape is either
+    // ImNodesPinShape_Triangle or ImNodesPinShape_TriangleFilled.
+    float PinTriangleSideLength;
     // The thickness of the line used when the pin shape is not filled.
-    float pin_line_thickness;
+    float PinLineThickness;
     // The radius from the pin's center position inside of which it is detected as being hovered
     // over.
-    float pin_hover_radius;
+    float PinHoverRadius;
     // Offsets the pins' positions from the edge of the node to the outside of the node.
-    float pin_offset;
+    float PinOffset;
 
-    // By default, StyleFlags_NodeOutline and StyleFlags_Gridlines are enabled.
-    StyleFlags flags;
+    // By default, ImNodesStyleFlags_NodeOutline and ImNodesStyleFlags_Gridlines are enabled.
+    ImNodesStyleFlags Flags;
     // Set these mid-frame using Push/PopColorStyle. You can index this color array with with a
-    // ColorStyle enum value.
-    unsigned int colors[ColorStyle_Count];
+    // ImNodesCol value.
+    unsigned int Colors[ImNodesCol_COUNT];
 
-    Style();
+    ImNodesStyle();
 };
 
+enum ImNodesMiniMapLocation_
+{
+    ImNodesMiniMapLocation_BottomLeft,
+    ImNodesMiniMapLocation_BottomRight,
+    ImNodesMiniMapLocation_TopLeft,
+    ImNodesMiniMapLocation_TopRight,
+};
+
+struct ImGuiContext;
+struct ImVec2;
+
+struct ImNodesContext;
+
 // An editor context corresponds to a set of nodes in a single workspace (created with a single
 // Begin/EndNodeEditor pair)
 //
 // By default, the library creates an editor context behind the scenes, so using any of the imnodes
 // functions doesn't require you to explicitly create a context.
-struct EditorContext;
+struct ImNodesEditorContext;
 
-EditorContext* EditorContextCreate();
-void EditorContextFree(EditorContext*);
-void EditorContextSet(EditorContext*);
-ImVec2 EditorContextGetPanning();
-void EditorContextResetPanning(const ImVec2& pos);
-void EditorContextMoveToNode(const int node_id);
+// Callback type used to specify special behavior when hovering a node in the minimap
+typedef void (*ImNodesMiniMapNodeHoveringCallback)(int, void*);
 
-// Initialize the node editor system.
-void Initialize();
-void Shutdown();
+namespace ImNodes
+{
+// Call this function if you are compiling imnodes in to a dll, separate from ImGui. Calling this
+// function sets the GImGui global variable, which is not shared across dll boundaries.
+void SetImGuiContext(ImGuiContext* ctx);
 
-IO& GetIO();
+ImNodesContext* CreateContext();
+void            DestroyContext(ImNodesContext* ctx = NULL); // NULL = destroy current context
+ImNodesContext* GetCurrentContext();
+void            SetCurrentContext(ImNodesContext* ctx);
+
+ImNodesEditorContext* EditorContextCreate();
+void                  EditorContextFree(ImNodesEditorContext*);
+void                  EditorContextSet(ImNodesEditorContext*);
+ImVec2                EditorContextGetPanning();
+void                  EditorContextResetPanning(const ImVec2& pos);
+void                  EditorContextMoveToNode(const int node_id);
+
+ImNodesIO& GetIO();
 
 // Returns the global style struct. See the struct declaration for default values.
-Style& GetStyle();
+ImNodesStyle& GetStyle();
 // Style presets matching the dear imgui styles of the same name.
 void StyleColorsDark(); // on by default
 void StyleColorsClassic();
@@ -180,10 +225,18 @@ void StyleColorsLight();
 void BeginNodeEditor();
 void EndNodeEditor();
 
-// Use PushColorStyle and PopColorStyle to modify Style::colors mid-frame.
-void PushColorStyle(ColorStyle item, unsigned int color);
+// Add a navigable minimap to the editor; call before EndNodeEditor after all
+// nodes and links have been specified
+void MiniMap(
+    const float                              minimap_size_fraction = 0.2f,
+    const ImNodesMiniMapLocation             location = ImNodesMiniMapLocation_TopLeft,
+    const ImNodesMiniMapNodeHoveringCallback node_hovering_callback = NULL,
+    void*                                    node_hovering_callback_data = NULL);
+
+// Use PushColorStyle and PopColorStyle to modify ImNodesStyle::Colors mid-frame.
+void PushColorStyle(ImNodesCol item, unsigned int color);
 void PopColorStyle();
-void PushStyleVar(StyleVar style_item, float value);
+void PushStyleVar(ImNodesStyleVar style_item, float value);
 void PopStyleVar();
 
 // id can be any positive or negative integer, but INT_MIN is currently reserved for internal use.
@@ -208,10 +261,10 @@ void EndNodeTitleBar();
 // Each attribute id must be unique.
 
 // Create an input attribute block. The pin is rendered on left side.
-void BeginInputAttribute(int id, PinShape shape = PinShape_CircleFilled);
+void BeginInputAttribute(int id, ImNodesPinShape shape = ImNodesPinShape_CircleFilled);
 void EndInputAttribute();
 // Create an output attribute block. The pin is rendered on the right side.
-void BeginOutputAttribute(int id, PinShape shape = PinShape_CircleFilled);
+void BeginOutputAttribute(int id, ImNodesPinShape shape = ImNodesPinShape_CircleFilled);
 void EndOutputAttribute();
 // Create a static attribute block. A static attribute has no pin, and therefore can't be linked to
 // anything. However, you can still use IsAttributeActive() and IsAnyAttributeActive() to check for
@@ -220,7 +273,7 @@ void BeginStaticAttribute(int id);
 void EndStaticAttribute();
 
 // Push a single AttributeFlags value. By default, only AttributeFlags_None is set.
-void PushAttributeFlag(AttributeFlags flag);
+void PushAttributeFlag(ImNodesAttributeFlags flag);
 void PopAttributeFlag();
 
 // Render a link between attributes.
@@ -267,10 +320,21 @@ int NumSelectedLinks();
 // returned.
 void GetSelectedNodes(int* node_ids);
 void GetSelectedLinks(int* link_ids);
-
 // Clears the list of selected nodes/links. Useful if you want to delete a selected node or link.
 void ClearNodeSelection();
 void ClearLinkSelection();
+// Use the following functions to add or remove individual nodes or links from the current editors
+// selection. Note that all functions require the id to be an existing valid id for this editor.
+// Select-functions has the precondition that the object is currently considered unselected.
+// Clear-functions has the precondition that the object is currently considered selected.
+// Preconditions listed above can be checked via IsNodeSelected/IsLinkSelected if not already
+// known.
+void SelectNode(int node_id);
+void ClearNodeSelection(int node_id);
+bool IsNodeSelected(int node_id);
+void SelectLink(int link_id);
+void ClearLinkSelection(int link_id);
+bool IsLinkSelected(int link_id);
 
 // Was the previous attribute active? This will continuously return true while the left mouse button
 // is being pressed over the UI content of the attribute.
@@ -292,14 +356,14 @@ bool IsLinkStarted(int* started_at_attribute_id);
 bool IsLinkDropped(int* started_at_attribute_id = NULL, bool including_detached_links = true);
 // Did the user finish creating a new link?
 bool IsLinkCreated(
-    int* started_at_attribute_id,
-    int* ended_at_attribute_id,
+    int*  started_at_attribute_id,
+    int*  ended_at_attribute_id,
     bool* created_from_snap = NULL);
 bool IsLinkCreated(
-    int* started_at_node_id,
-    int* started_at_attribute_id,
-    int* ended_at_node_id,
-    int* ended_at_attribute_id,
+    int*  started_at_node_id,
+    int*  started_at_attribute_id,
+    int*  ended_at_node_id,
+    int*  ended_at_attribute_id,
     bool* created_from_snap = NULL);
 
 // Was an existing link detached from a pin by the user? The detached link's id is assigned to the
@@ -310,14 +374,16 @@ bool IsLinkDestroyed(int* link_id);
 // file. The editor context is serialized in the INI file format.
 
 const char* SaveCurrentEditorStateToIniString(size_t* data_size = NULL);
-const char* SaveEditorStateToIniString(const EditorContext* editor, size_t* data_size = NULL);
+const char* SaveEditorStateToIniString(
+    const ImNodesEditorContext* editor,
+    size_t*                     data_size = NULL);
 
 void LoadCurrentEditorStateFromIniString(const char* data, size_t data_size);
-void LoadEditorStateFromIniString(EditorContext* editor, const char* data, size_t data_size);
+void LoadEditorStateFromIniString(ImNodesEditorContext* editor, const char* data, size_t data_size);
 
 void SaveCurrentEditorStateToIniFile(const char* file_name);
-void SaveEditorStateToIniFile(const EditorContext* editor, const char* file_name);
+void SaveEditorStateToIniFile(const ImNodesEditorContext* editor, const char* file_name);
 
 void LoadCurrentEditorStateFromIniFile(const char* file_name);
-void LoadEditorStateFromIniFile(EditorContext* editor, const char* file_name);
-} // namespace imnodes
+void LoadEditorStateFromIniFile(ImNodesEditorContext* editor, const char* file_name);
+} // namespace ImNodes

lib/external/imgui/include/imnodes_internal.h

@@ -0,0 +1,482 @@
+#pragma once
+
+#include <imgui.h>
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include <imgui_internal.h>
+
+#include <assert.h>
+#include <limits.h>
+
+// the structure of this file:
+//
+// [SECTION] internal enums
+// [SECTION] internal data structures
+// [SECTION] global and editor context structs
+// [SECTION] object pool implementation
+
+struct ImNodesContext;
+
+extern ImNodesContext* GImNodes;
+
+// [SECTION] internal enums
+
+typedef int ImNodesScope;
+typedef int ImNodesAttributeType;
+typedef int ImNodesUIState;
+typedef int ImNodesClickInteractionType;
+typedef int ImNodesLinkCreationType;
+
+enum ImNodesScope_
+{
+    ImNodesScope_None = 1,
+    ImNodesScope_Editor = 1 << 1,
+    ImNodesScope_Node = 1 << 2,
+    ImNodesScope_Attribute = 1 << 3
+};
+
+enum ImNodesAttributeType_
+{
+    ImNodesAttributeType_None,
+    ImNodesAttributeType_Input,
+    ImNodesAttributeType_Output
+};
+
+enum ImNodesUIState_
+{
+    ImNodesUIState_None = 0,
+    ImNodesUIState_LinkStarted = 1 << 0,
+    ImNodesUIState_LinkDropped = 1 << 1,
+    ImNodesUIState_LinkCreated = 1 << 2
+};
+
+enum ImNodesClickInteractionType_
+{
+    ImNodesClickInteractionType_Node,
+    ImNodesClickInteractionType_Link,
+    ImNodesClickInteractionType_LinkCreation,
+    ImNodesClickInteractionType_Panning,
+    ImNodesClickInteractionType_BoxSelection,
+    ImNodesClickInteractionType_MiniMapPanning,
+    ImNodesClickInteractionType_MiniMapZooming,
+    ImNodesClickInteractionType_MiniMapSnapping,
+    ImNodesClickInteractionType_ImGuiItem,
+    ImNodesClickInteractionType_None
+};
+
+enum ImNodesLinkCreationType_
+{
+    ImNodesLinkCreationType_Standard,
+    ImNodesLinkCreationType_FromDetach
+};
+
+// Callback type used to specify special behavior when hovering a node in the minimap
+typedef void (*ImNodesMiniMapNodeHoveringCallback)(int, void*);
+
+// [SECTION] internal data structures
+
+// The object T must have the following interface:
+//
+// struct T
+// {
+//     T();
+//
+//     int id;
+// };
+template<typename T>
+struct ImObjectPool
+{
+    ImVector<T>    Pool;
+    ImVector<bool> InUse;
+    ImVector<int>  FreeList;
+    ImGuiStorage   IdMap;
+
+    ImObjectPool() : Pool(), InUse(), FreeList(), IdMap() {}
+};
+
+// Emulates std::optional<int> using the sentinel value `INVALID_INDEX`.
+struct ImOptionalIndex
+{
+    ImOptionalIndex() : _Index(INVALID_INDEX) {}
+    ImOptionalIndex(const int value) : _Index(value) {}
+
+    // Observers
+
+    inline bool HasValue() const { return _Index != INVALID_INDEX; }
+
+    inline int Value() const
+    {
+        assert(HasValue());
+        return _Index;
+    }
+
+    // Modifiers
+
+    inline ImOptionalIndex& operator=(const int value)
+    {
+        _Index = value;
+        return *this;
+    }
+
+    inline void Reset() { _Index = INVALID_INDEX; }
+
+    inline bool operator==(const ImOptionalIndex& rhs) const { return _Index == rhs._Index; }
+
+    inline bool operator==(const int rhs) const { return _Index == rhs; }
+
+    inline bool operator!=(const ImOptionalIndex& rhs) const { return _Index != rhs._Index; }
+
+    inline bool operator!=(const int rhs) const { return _Index != rhs; }
+
+    static const int INVALID_INDEX = -1;
+
+private:
+    int _Index;
+};
+
+struct ImNodeData
+{
+    int    Id;
+    ImVec2 Origin; // The node origin is in editor space
+    ImRect TitleBarContentRect;
+    ImRect Rect;
+
+    struct
+    {
+        ImU32 Background, BackgroundHovered, BackgroundSelected, Outline, Titlebar, TitlebarHovered,
+            TitlebarSelected;
+    } ColorStyle;
+
+    struct
+    {
+        float  CornerRounding;
+        ImVec2 Padding;
+        float  BorderThickness;
+    } LayoutStyle;
+
+    ImVector<int> PinIndices;
+    bool          Draggable;
+
+    ImNodeData(const int node_id)
+        : Id(node_id), Origin(100.0f, 100.0f), TitleBarContentRect(),
+          Rect(ImVec2(0.0f, 0.0f), ImVec2(0.0f, 0.0f)), ColorStyle(), LayoutStyle(), PinIndices(),
+          Draggable(true)
+    {
+    }
+
+    ~ImNodeData() { Id = INT_MIN; }
+};
+
+struct ImPinData
+{
+    int                  Id;
+    int                  ParentNodeIdx;
+    ImRect               AttributeRect;
+    ImNodesAttributeType Type;
+    ImNodesPinShape      Shape;
+    ImVec2               Pos; // screen-space coordinates
+    int                  Flags;
+
+    struct
+    {
+        ImU32 Background, Hovered;
+    } ColorStyle;
+
+    ImPinData(const int pin_id)
+        : Id(pin_id), ParentNodeIdx(), AttributeRect(), Type(ImNodesAttributeType_None),
+          Shape(ImNodesPinShape_CircleFilled), Pos(), Flags(ImNodesAttributeFlags_None),
+          ColorStyle()
+    {
+    }
+};
+
+struct ImLinkData
+{
+    int Id;
+    int StartPinIdx, EndPinIdx;
+
+    struct
+    {
+        ImU32 Base, Hovered, Selected;
+    } ColorStyle;
+
+    ImLinkData(const int link_id) : Id(link_id), StartPinIdx(), EndPinIdx(), ColorStyle() {}
+};
+
+struct ImClickInteractionState
+{
+    ImNodesClickInteractionType Type;
+
+    struct
+    {
+        int                     StartPinIdx;
+        ImOptionalIndex         EndPinIdx;
+        ImNodesLinkCreationType Type;
+    } LinkCreation;
+
+    struct
+    {
+        ImRect Rect;
+    } BoxSelector;
+
+    ImClickInteractionState() : Type(ImNodesClickInteractionType_None) {}
+};
+
+struct ImNodesColElement
+{
+    ImU32      Color;
+    ImNodesCol Item;
+
+    ImNodesColElement(const ImU32 c, const ImNodesCol s) : Color(c), Item(s) {}
+};
+
+struct ImNodesStyleVarElement
+{
+    ImNodesStyleVar Item;
+    float           Value;
+
+    ImNodesStyleVarElement(const float value, const ImNodesStyleVar variable)
+        : Item(variable), Value(value)
+    {
+    }
+};
+
+// [SECTION] global and editor context structs
+
+struct ImNodesEditorContext
+{
+    ImObjectPool<ImNodeData> Nodes;
+    ImObjectPool<ImPinData>  Pins;
+    ImObjectPool<ImLinkData> Links;
+
+    ImVector<int> NodeDepthOrder;
+
+    // ui related fields
+    ImVec2 Panning;
+
+    ImVector<int> SelectedNodeIndices;
+    ImVector<int> SelectedLinkIndices;
+
+    ImClickInteractionState ClickInteraction;
+
+    ImNodesEditorContext()
+        : Nodes(), Pins(), Links(), Panning(0.f, 0.f), SelectedNodeIndices(), SelectedLinkIndices(),
+          ClickInteraction()
+    {
+    }
+};
+
+struct ImNodesContext
+{
+    ImNodesEditorContext* DefaultEditorCtx;
+    ImNodesEditorContext* EditorCtx;
+
+    // Canvas draw list and helper state
+    ImDrawList*   CanvasDrawList;
+    ImGuiStorage  NodeIdxToSubmissionIdx;
+    ImVector<int> NodeIdxSubmissionOrder;
+    ImVector<int> NodeIndicesOverlappingWithMouse;
+    ImVector<int> OccludedPinIndices;
+
+    // Canvas extents
+    ImVec2 CanvasOriginScreenSpace;
+    ImRect CanvasRectScreenSpace;
+
+    // MiniMap state
+    ImRect                             MiniMapRectScreenSpace;
+    ImVec2                             MiniMapRectSnappingOffset;
+    float                              MiniMapZoom;
+    ImNodesMiniMapNodeHoveringCallback MiniMapNodeHoveringCallback;
+    void*                              MiniMapNodeHoveringCallbackUserData;
+
+    // Debug helpers
+    ImNodesScope CurrentScope;
+
+    // Configuration state
+    ImNodesIO                        Io;
+    ImNodesStyle                     Style;
+    ImVector<ImNodesColElement>      ColorModifierStack;
+    ImVector<ImNodesStyleVarElement> StyleModifierStack;
+    ImGuiTextBuffer                  TextBuffer;
+
+    int           CurrentAttributeFlags;
+    ImVector<int> AttributeFlagStack;
+
+    // UI element state
+    int CurrentNodeIdx;
+    int CurrentPinIdx;
+    int CurrentAttributeId;
+
+    ImOptionalIndex HoveredNodeIdx;
+    ImOptionalIndex HoveredLinkIdx;
+    ImOptionalIndex HoveredPinIdx;
+
+    ImOptionalIndex DeletedLinkIdx;
+    ImOptionalIndex SnapLinkIdx;
+
+    // Event helper state
+    // TODO: this should be a part of a state machine, and not a member of the global struct.
+    // Unclear what parts of the code this relates to.
+    int ImNodesUIState;
+
+    int  ActiveAttributeId;
+    bool ActiveAttribute;
+
+    // ImGui::IO cache
+
+    ImVec2 MousePos;
+
+    bool  LeftMouseClicked;
+    bool  LeftMouseReleased;
+    bool  AltMouseClicked;
+    bool  LeftMouseDragging;
+    bool  AltMouseDragging;
+    float AltMouseScrollDelta;
+};
+
+namespace ImNodes
+{
+static inline ImNodesEditorContext& EditorContextGet()
+{
+    // No editor context was set! Did you forget to call ImNodes::CreateContext()?
+    assert(GImNodes->EditorCtx != NULL);
+    return *GImNodes->EditorCtx;
+}
+
+// [SECTION] ObjectPool implementation
+
+template<typename T>
+static inline int ObjectPoolFind(const ImObjectPool<T>& objects, const int id)
+{
+    const int index = objects.IdMap.GetInt(static_cast<ImGuiID>(id), -1);
+    return index;
+}
+
+template<typename T>
+static inline void ObjectPoolUpdate(ImObjectPool<T>& objects)
+{
+    objects.FreeList.clear();
+    for (int i = 0; i < objects.InUse.size(); ++i)
+    {
+        if (!objects.InUse[i])
+        {
+            objects.IdMap.SetInt(objects.Pool[i].Id, -1);
+            objects.FreeList.push_back(i);
+            (objects.Pool.Data + i)->~T();
+        }
+    }
+}
+
+template<>
+inline void ObjectPoolUpdate(ImObjectPool<ImNodeData>& nodes)
+{
+    nodes.FreeList.clear();
+    for (int i = 0; i < nodes.InUse.size(); ++i)
+    {
+        if (nodes.InUse[i])
+        {
+            nodes.Pool[i].PinIndices.clear();
+        }
+        else
+        {
+            const int previous_id = nodes.Pool[i].Id;
+            const int previous_idx = nodes.IdMap.GetInt(previous_id, -1);
+
+            if (previous_idx != -1)
+            {
+                assert(previous_idx == i);
+                // Remove node idx form depth stack the first time we detect that this idx slot is
+                // unused
+                ImVector<int>&   depth_stack = EditorContextGet().NodeDepthOrder;
+                const int* const elem = depth_stack.find(i);
+                assert(elem != depth_stack.end());
+                depth_stack.erase(elem);
+            }
+
+            nodes.IdMap.SetInt(previous_id, -1);
+            nodes.FreeList.push_back(i);
+            (nodes.Pool.Data + i)->~ImNodeData();
+        }
+    }
+}
+
+template<typename T>
+static inline void ObjectPoolReset(ImObjectPool<T>& objects)
+{
+    if (!objects.InUse.empty())
+    {
+        memset(objects.InUse.Data, 0, objects.InUse.size_in_bytes());
+    }
+}
+
+template<typename T>
+static inline int ObjectPoolFindOrCreateIndex(ImObjectPool<T>& objects, const int id)
+{
+    int index = objects.IdMap.GetInt(static_cast<ImGuiID>(id), -1);
+
+    // Construct new object
+    if (index == -1)
+    {
+        if (objects.FreeList.empty())
+        {
+            index = objects.Pool.size();
+            IM_ASSERT(objects.Pool.size() == objects.InUse.size());
+            const int new_size = objects.Pool.size() + 1;
+            objects.Pool.resize(new_size);
+            objects.InUse.resize(new_size);
+        }
+        else
+        {
+            index = objects.FreeList.back();
+            objects.FreeList.pop_back();
+        }
+        IM_PLACEMENT_NEW(objects.Pool.Data + index) T(id);
+        objects.IdMap.SetInt(static_cast<ImGuiID>(id), index);
+    }
+
+    // Flag it as used
+    objects.InUse[index] = true;
+
+    return index;
+}
+
+template<>
+inline int ObjectPoolFindOrCreateIndex(ImObjectPool<ImNodeData>& nodes, const int node_id)
+{
+    int node_idx = nodes.IdMap.GetInt(static_cast<ImGuiID>(node_id), -1);
+
+    // Construct new node
+    if (node_idx == -1)
+    {
+        if (nodes.FreeList.empty())
+        {
+            node_idx = nodes.Pool.size();
+            IM_ASSERT(nodes.Pool.size() == nodes.InUse.size());
+            const int new_size = nodes.Pool.size() + 1;
+            nodes.Pool.resize(new_size);
+            nodes.InUse.resize(new_size);
+        }
+        else
+        {
+            node_idx = nodes.FreeList.back();
+            nodes.FreeList.pop_back();
+        }
+        IM_PLACEMENT_NEW(nodes.Pool.Data + node_idx) ImNodeData(node_id);
+        nodes.IdMap.SetInt(static_cast<ImGuiID>(node_id), node_idx);
+
+        ImNodesEditorContext& editor = EditorContextGet();
+        editor.NodeDepthOrder.push_back(node_idx);
+    }
+
+    // Flag node as used
+    nodes.InUse[node_idx] = true;
+
+    return node_idx;
+}
+
+template<typename T>
+static inline T& ObjectPoolFindOrCreateObject(ImObjectPool<T>& objects, const int id)
+{
+    const int index = ObjectPoolFindOrCreateIndex(objects, id);
+    return objects.Pool[index];
+}
+} // namespace ImNodes

lib/external/imgui/include/implot.h

@@ -0,0 +1,927 @@
+// MIT License
+
+// Copyright (c) 2021 Evan Pezent
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// ImPlot v0.11 WIP
+
+#pragma once
+#include "imgui.h"
+
+//-----------------------------------------------------------------------------
+// Macros and Defines
+//-----------------------------------------------------------------------------
+
+// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
+// Using ImPlot via a shared library is not recommended, because we don't guarantee
+// backward nor forward ABI compatibility and also function call overhead. If you
+// do use ImPlot as a DLL, be sure to call SetImGuiContext (see Miscellanous section).
+#ifndef IMPLOT_API
+#define IMPLOT_API
+#endif
+
+// ImPlot version string
+#define IMPLOT_VERSION "0.11 WIP"
+// Indicates variable should deduced automatically.
+#define IMPLOT_AUTO -1
+// Special color used to indicate that a color should be deduced automatically.
+#define IMPLOT_AUTO_COL ImVec4(0,0,0,-1)
+
+//-----------------------------------------------------------------------------
+// Forward Declarations and Basic Types
+//-----------------------------------------------------------------------------
+
+// Forward declarations
+struct ImPlotContext;          // ImPlot context (opaque struct, see implot_internal.h)
+
+// Enums/Flags
+typedef int ImPlotFlags;        // -> enum ImPlotFlags_
+typedef int ImPlotAxisFlags;    // -> enum ImPlotAxisFlags_
+typedef int ImPlotSubplotFlags; // -> enum ImPlotSubplotFlags_
+typedef int ImPlotCol;          // -> enum ImPlotCol_
+typedef int ImPlotStyleVar;     // -> enum ImPlotStyleVar_
+typedef int ImPlotMarker;       // -> enum ImPlotMarker_
+typedef int ImPlotColormap;     // -> enum ImPlotColormap_
+typedef int ImPlotLocation;     // -> enum ImPlotLocation_
+typedef int ImPlotOrientation;  // -> enum ImPlotOrientation_
+typedef int ImPlotYAxis;        // -> enum ImPlotYAxis_;
+typedef int ImPlotBin;          // -> enum ImPlotBin_
+
+// Options for plots (see BeginPlot).
+enum ImPlotFlags_ {
+    ImPlotFlags_None          = 0,       // default
+    ImPlotFlags_NoTitle       = 1 << 0,  // the plot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MyPlot")
+    ImPlotFlags_NoLegend      = 1 << 1,  // the legend will not be displayed
+    ImPlotFlags_NoMenus       = 1 << 2,  // the user will not be able to open context menus with right-click
+    ImPlotFlags_NoBoxSelect   = 1 << 3,  // the user will not be able to box-select with right-click drag
+    ImPlotFlags_NoMousePos    = 1 << 4,  // the mouse position, in plot coordinates, will not be displayed inside of the plot
+    ImPlotFlags_NoHighlight   = 1 << 5,  // plot items will not be highlighted when their legend entry is hovered
+    ImPlotFlags_NoChild       = 1 << 6,  // a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications)
+    ImPlotFlags_Equal         = 1 << 7,  // primary x and y axes will be constrained to have the same units/pixel (does not apply to auxiliary y-axes)
+    ImPlotFlags_YAxis2        = 1 << 8,  // enable a 2nd y-axis on the right side
+    ImPlotFlags_YAxis3        = 1 << 9,  // enable a 3rd y-axis on the right side
+    ImPlotFlags_Query         = 1 << 10, // the user will be able to draw query rects with middle-mouse or CTRL + right-click drag
+    ImPlotFlags_Crosshairs    = 1 << 11, // the default mouse cursor will be replaced with a crosshair when hovered
+    ImPlotFlags_AntiAliased   = 1 << 12, // plot lines will be software anti-aliased (not recommended for high density plots, prefer MSAA)
+    ImPlotFlags_CanvasOnly    = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMousePos
+};
+
+// Options for plot axes (see BeginPlot).
+enum ImPlotAxisFlags_ {
+    ImPlotAxisFlags_None          = 0,       // default
+    ImPlotAxisFlags_NoLabel       = 1 << 0,  // the axis label will not be displayed (axis labels also hidden if the supplied string name is NULL)
+    ImPlotAxisFlags_NoGridLines   = 1 << 1,  // no grid lines will be displayed
+    ImPlotAxisFlags_NoTickMarks   = 1 << 2,  // no tick marks will be displayed
+    ImPlotAxisFlags_NoTickLabels  = 1 << 3,  // no text labels will be displayed
+    ImPlotAxisFlags_Foreground    = 1 << 4,  // grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
+    ImPlotAxisFlags_LogScale      = 1 << 5,  // a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time)
+    ImPlotAxisFlags_Time          = 1 << 6,  // axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale)
+    ImPlotAxisFlags_Invert        = 1 << 7,  // the axis will be inverted
+    ImPlotAxisFlags_NoInitialFit  = 1 << 8,  // axis will not be initially fit to data extents on the first rendered frame (also the case if SetNextPlotLimits explicitly called)
+    ImPlotAxisFlags_AutoFit       = 1 << 9,  // axis will be auto-fitting to data extents
+    ImPlotAxisFlags_RangeFit      = 1 << 10, // axis will only fit points if the point is in the visible range of the **orthoganol** axis
+    ImPlotAxisFlags_LockMin       = 1 << 11, // the axis minimum value will be locked when panning/zooming
+    ImPlotAxisFlags_LockMax       = 1 << 12, // the axis maximum value will be locked when panning/zooming
+    ImPlotAxisFlags_Lock          = ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax,
+    ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels
+};
+
+// Options for subplots (see BeginSubplot).
+enum ImPlotSubplotFlags_ {
+    ImPlotSubplotFlags_None        = 0,       // default
+    ImPlotSubplotFlags_NoTitle     = 1 << 0,  // the subplot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MySubplot")
+    ImPlotSubplotFlags_NoLegend    = 1 << 1,  // the legend will not be displayed (only applicable if ImPlotSubplotFlags_ShareItems is enabled)
+    ImPlotSubplotFlags_NoMenus     = 1 << 2,  // the user will not be able to open context menus with right-click
+    ImPlotSubplotFlags_NoResize    = 1 << 3,  // resize splitters between subplot cells will be not be provided
+    ImPlotSubplotFlags_NoAlign     = 1 << 4,  // subplot edges will not be aligned vertically or horizontally
+    ImPlotSubplotFlags_ShareItems  = 1 << 5,  // items across all subplots will be shared and rendered into a single legend entry
+    ImPlotSubplotFlags_LinkRows    = 1 << 6,  // link the y-axis limits of all plots in each row (does not apply auxiliary y-axes)
+    ImPlotSubplotFlags_LinkCols    = 1 << 7,  // link the x-axis limits of all plots in each column
+    ImPlotSubplotFlags_LinkAllX    = 1 << 8,  // link the x-axis limits in every plot in the subplot
+    ImPlotSubplotFlags_LinkAllY    = 1 << 9 , // link the y-axis limits in every plot in the subplot (does not apply to auxiliary y-axes)
+    ImPlotSubplotFlags_ColMajor    = 1 << 10  // subplots are added in column major order instead of the default row major order
+};
+
+// Plot styling colors.
+enum ImPlotCol_ {
+    // item styling colors
+    ImPlotCol_Line,          // plot line/outline color (defaults to next unused color in current colormap)
+    ImPlotCol_Fill,          // plot fill color for bars (defaults to the current line color)
+    ImPlotCol_MarkerOutline, // marker outline color (defaults to the current line color)
+    ImPlotCol_MarkerFill,    // marker fill color (defaults to the current line color)
+    ImPlotCol_ErrorBar,      // error bar color (defaults to ImGuiCol_Text)
+    // plot styling colors
+    ImPlotCol_FrameBg,       // plot frame background color (defaults to ImGuiCol_FrameBg)
+    ImPlotCol_PlotBg,        // plot area background color (defaults to ImGuiCol_WindowBg)
+    ImPlotCol_PlotBorder,    // plot area border color (defaults to ImGuiCol_Border)
+    ImPlotCol_LegendBg,      // legend background color (defaults to ImGuiCol_PopupBg)
+    ImPlotCol_LegendBorder,  // legend border color (defaults to ImPlotCol_PlotBorder)
+    ImPlotCol_LegendText,    // legend text color (defaults to ImPlotCol_InlayText)
+    ImPlotCol_TitleText,     // plot title text color (defaults to ImGuiCol_Text)
+    ImPlotCol_InlayText,     // color of text appearing inside of plots (defaults to ImGuiCol_Text)
+    ImPlotCol_XAxis,         // x-axis label and tick lables color (defaults to ImGuiCol_Text)
+    ImPlotCol_XAxisGrid,     // x-axis grid color (defaults to 25% ImPlotCol_XAxis)
+    ImPlotCol_YAxis,         // y-axis label and tick labels color (defaults to ImGuiCol_Text)
+    ImPlotCol_YAxisGrid,     // y-axis grid color (defaults to 25% ImPlotCol_YAxis)
+    ImPlotCol_YAxis2,        // 2nd y-axis label and tick labels color (defaults to ImGuiCol_Text)
+    ImPlotCol_YAxisGrid2,    // 2nd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis2)
+    ImPlotCol_YAxis3,        // 3rd y-axis label and tick labels color (defaults to ImGuiCol_Text)
+    ImPlotCol_YAxisGrid3,    // 3rd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis3)
+    ImPlotCol_Selection,     // box-selection color (defaults to yellow)
+    ImPlotCol_Query,         // box-query color (defaults to green)
+    ImPlotCol_Crosshairs,    // crosshairs color (defaults to ImPlotCol_PlotBorder)
+    ImPlotCol_COUNT
+};
+
+// Plot styling variables.
+enum ImPlotStyleVar_ {
+    // item styling variables
+    ImPlotStyleVar_LineWeight,         // float,  plot item line weight in pixels
+    ImPlotStyleVar_Marker,             // int,    marker specification
+    ImPlotStyleVar_MarkerSize,         // float,  marker size in pixels (roughly the marker's "radius")
+    ImPlotStyleVar_MarkerWeight,       // float,  plot outline weight of markers in pixels
+    ImPlotStyleVar_FillAlpha,          // float,  alpha modifier applied to all plot item fills
+    ImPlotStyleVar_ErrorBarSize,       // float,  error bar whisker width in pixels
+    ImPlotStyleVar_ErrorBarWeight,     // float,  error bar whisker weight in pixels
+    ImPlotStyleVar_DigitalBitHeight,   // float,  digital channels bit height (at 1) in pixels
+    ImPlotStyleVar_DigitalBitGap,      // float,  digital channels bit padding gap in pixels
+    // plot styling variables
+    ImPlotStyleVar_PlotBorderSize,     // float,  thickness of border around plot area
+    ImPlotStyleVar_MinorAlpha,         // float,  alpha multiplier applied to minor axis grid lines
+    ImPlotStyleVar_MajorTickLen,       // ImVec2, major tick lengths for X and Y axes
+    ImPlotStyleVar_MinorTickLen,       // ImVec2, minor tick lengths for X and Y axes
+    ImPlotStyleVar_MajorTickSize,      // ImVec2, line thickness of major ticks
+    ImPlotStyleVar_MinorTickSize,      // ImVec2, line thickness of minor ticks
+    ImPlotStyleVar_MajorGridSize,      // ImVec2, line thickness of major grid lines
+    ImPlotStyleVar_MinorGridSize,      // ImVec2, line thickness of minor grid lines
+    ImPlotStyleVar_PlotPadding,        // ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
+    ImPlotStyleVar_LabelPadding,       // ImVec2, padding between axes labels, tick labels, and plot edge
+    ImPlotStyleVar_LegendPadding,      // ImVec2, legend padding from plot edges
+    ImPlotStyleVar_LegendInnerPadding, // ImVec2, legend inner padding from legend edges
+    ImPlotStyleVar_LegendSpacing,      // ImVec2, spacing between legend entries
+    ImPlotStyleVar_MousePosPadding,    // ImVec2, padding between plot edge and interior info text
+    ImPlotStyleVar_AnnotationPadding,  // ImVec2, text padding around annotation labels
+    ImPlotStyleVar_FitPadding,         // ImVec2, additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
+    ImPlotStyleVar_PlotDefaultSize,    // ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot
+    ImPlotStyleVar_PlotMinSize,        // ImVec2, minimum size plot frame can be when shrunk
+    ImPlotStyleVar_COUNT
+};
+
+// Marker specifications.
+enum ImPlotMarker_ {
+    ImPlotMarker_None = -1, // no marker
+    ImPlotMarker_Circle,    // a circle marker
+    ImPlotMarker_Square,    // a square maker
+    ImPlotMarker_Diamond,   // a diamond marker
+    ImPlotMarker_Up,        // an upward-pointing triangle marker
+    ImPlotMarker_Down,      // an downward-pointing triangle marker
+    ImPlotMarker_Left,      // an leftward-pointing triangle marker
+    ImPlotMarker_Right,     // an rightward-pointing triangle marker
+    ImPlotMarker_Cross,     // a cross marker (not fillable)
+    ImPlotMarker_Plus,      // a plus marker (not fillable)
+    ImPlotMarker_Asterisk,  // a asterisk marker (not fillable)
+    ImPlotMarker_COUNT
+};
+
+// Built-in colormaps
+enum ImPlotColormap_ {
+    ImPlotColormap_Deep     = 0,   // a.k.a. seaborn deep             (qual=true,  n=10) (default)
+    ImPlotColormap_Dark     = 1,   // a.k.a. matplotlib "Set1"        (qual=true,  n=9 )
+    ImPlotColormap_Pastel   = 2,   // a.k.a. matplotlib "Pastel1"     (qual=true,  n=9 )
+    ImPlotColormap_Paired   = 3,   // a.k.a. matplotlib "Paired"      (qual=true,  n=12)
+    ImPlotColormap_Viridis  = 4,   // a.k.a. matplotlib "viridis"     (qual=false, n=11)
+    ImPlotColormap_Plasma   = 5,   // a.k.a. matplotlib "plasma"      (qual=false, n=11)
+    ImPlotColormap_Hot      = 6,   // a.k.a. matplotlib/MATLAB "hot"  (qual=false, n=11)
+    ImPlotColormap_Cool     = 7,   // a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11)
+    ImPlotColormap_Pink     = 8,   // a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11)
+    ImPlotColormap_Jet      = 9,   // a.k.a. MATLAB "jet"             (qual=false, n=11)
+    ImPlotColormap_Twilight = 10,  // a.k.a. matplotlib "twilight"    (qual=false, n=11)
+    ImPlotColormap_RdBu     = 11,  // red/blue, Color Brewer          (qual=false, n=11)
+    ImPlotColormap_BrBG     = 12,  // brown/blue-green, Color Brewer  (qual=false, n=11)
+    ImPlotColormap_PiYG     = 13,  // pink/yellow-green, Color Brewer (qual=false, n=11)
+    ImPlotColormap_Spectral = 14,  // color spectrum, Color Brewer    (qual=false, n=11)
+    ImPlotColormap_Greys    = 15,  // white/black                     (qual=false, n=2 )
+};
+
+// Used to position items on a plot (e.g. legends, labels, etc.)
+enum ImPlotLocation_ {
+    ImPlotLocation_Center    = 0,                                          // center-center
+    ImPlotLocation_North     = 1 << 0,                                     // top-center
+    ImPlotLocation_South     = 1 << 1,                                     // bottom-center
+    ImPlotLocation_West      = 1 << 2,                                     // center-left
+    ImPlotLocation_East      = 1 << 3,                                     // center-right
+    ImPlotLocation_NorthWest = ImPlotLocation_North | ImPlotLocation_West, // top-left
+    ImPlotLocation_NorthEast = ImPlotLocation_North | ImPlotLocation_East, // top-right
+    ImPlotLocation_SouthWest = ImPlotLocation_South | ImPlotLocation_West, // bottom-left
+    ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East  // bottom-right
+};
+
+// Used to orient items on a plot (e.g. legends, labels, etc.)
+enum ImPlotOrientation_ {
+    ImPlotOrientation_Horizontal, // left/right
+    ImPlotOrientation_Vertical    // up/down
+};
+
+// Enums for different y-axes.
+enum ImPlotYAxis_ {
+    ImPlotYAxis_1 = 0, // left (default)
+    ImPlotYAxis_2 = 1, // first on right side
+    ImPlotYAxis_3 = 2  // second on right side
+};
+
+// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
+enum ImPlotBin_ {
+    ImPlotBin_Sqrt    = -1, // k = sqrt(n)
+    ImPlotBin_Sturges = -2, // k = 1 + log2(n)
+    ImPlotBin_Rice    = -3, // k = 2 * cbrt(n)
+    ImPlotBin_Scott   = -4, // w = 3.49 * sigma / cbrt(n)
+};
+
+// Double precision version of ImVec2 used by ImPlot. Extensible by end users.
+struct ImPlotPoint {
+    double x, y;
+    ImPlotPoint()                         { x = y = 0.0; }
+    ImPlotPoint(double _x, double _y)     { x = _x; y = _y; }
+    ImPlotPoint(const ImVec2& p)          { x = p.x; y = p.y; }
+    double  operator[] (size_t idx) const { return (&x)[idx]; }
+    double& operator[] (size_t idx)       { return (&x)[idx]; }
+#ifdef IMPLOT_POINT_CLASS_EXTRA
+    IMPLOT_POINT_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h
+                                 // to convert back and forth between your math types and ImPlotPoint.
+#endif
+};
+
+// A range defined by a min/max value. Used for plot axes ranges.
+struct ImPlotRange {
+    double Min, Max;
+    ImPlotRange()                         { Min = 0; Max = 0; }
+    ImPlotRange(double _min, double _max) { Min = _min; Max = _max; }
+    bool Contains(double value) const     { return value >= Min && value <= Max; };
+    double Size() const                   { return Max - Min; };
+};
+
+// Combination of two ranges for X and Y axes.
+struct ImPlotLimits {
+    ImPlotRange X, Y;
+    ImPlotLimits()                                                        { }
+    ImPlotLimits(double x_min, double x_max, double y_min, double y_max)  { X.Min = x_min; X.Max = x_max; Y.Min = y_min; Y.Max = y_max; }
+    bool Contains(const ImPlotPoint& p) const                             { return Contains(p.x, p.y); }
+    bool Contains(double x, double y) const                               { return X.Contains(x) && Y.Contains(y); }
+    ImPlotPoint Min() const                                               { return ImPlotPoint(X.Min, Y.Min); }
+    ImPlotPoint Max() const                                               { return ImPlotPoint(X.Max, Y.Max); }
+};
+
+// Plot style structure
+struct ImPlotStyle {
+    // item styling variables
+    float   LineWeight;              // = 1,      item line weight in pixels
+    int     Marker;                  // = ImPlotMarker_None, marker specification
+    float   MarkerSize;              // = 4,      marker size in pixels (roughly the marker's "radius")
+    float   MarkerWeight;            // = 1,      outline weight of markers in pixels
+    float   FillAlpha;               // = 1,      alpha modifier applied to plot fills
+    float   ErrorBarSize;            // = 5,      error bar whisker width in pixels
+    float   ErrorBarWeight;          // = 1.5,    error bar whisker weight in pixels
+    float   DigitalBitHeight;        // = 8,      digital channels bit height (at y = 1.0f) in pixels
+    float   DigitalBitGap;           // = 4,      digital channels bit padding gap in pixels
+    // plot styling variables
+    float   PlotBorderSize;          // = 1,      line thickness of border around plot area
+    float   MinorAlpha;              // = 0.25    alpha multiplier applied to minor axis grid lines
+    ImVec2  MajorTickLen;            // = 10,10   major tick lengths for X and Y axes
+    ImVec2  MinorTickLen;            // = 5,5     minor tick lengths for X and Y axes
+    ImVec2  MajorTickSize;           // = 1,1     line thickness of major ticks
+    ImVec2  MinorTickSize;           // = 1,1     line thickness of minor ticks
+    ImVec2  MajorGridSize;           // = 1,1     line thickness of major grid lines
+    ImVec2  MinorGridSize;           // = 1,1     line thickness of minor grid lines
+    ImVec2  PlotPadding;             // = 10,10   padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
+    ImVec2  LabelPadding;            // = 5,5     padding between axes labels, tick labels, and plot edge
+    ImVec2  LegendPadding;           // = 10,10   legend padding from plot edges
+    ImVec2  LegendInnerPadding;      // = 5,5     legend inner padding from legend edges
+    ImVec2  LegendSpacing;           // = 5,0     spacing between legend entries
+    ImVec2  MousePosPadding;         // = 10,10   padding between plot edge and interior mouse location text
+    ImVec2  AnnotationPadding;       // = 2,2     text padding around annotation labels
+    ImVec2  FitPadding;              // = 0,0     additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
+    ImVec2  PlotDefaultSize;         // = 400,300 default size used when ImVec2(0,0) is passed to BeginPlot
+    ImVec2  PlotMinSize;             // = 200,150 minimum size plot frame can be when shrunk
+    // style colors
+    ImVec4  Colors[ImPlotCol_COUNT]; // Array of styling colors. Indexable with ImPlotCol_ enums.
+    // colormap
+    ImPlotColormap Colormap;         // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
+    // settings/flags
+    bool    AntiAliasedLines;        // = false,  enable global anti-aliasing on plot lines (overrides ImPlotFlags_AntiAliased)
+    bool    UseLocalTime;            // = false,  axis labels will be formatted for your timezone when ImPlotAxisFlag_Time is enabled
+    bool    UseISO8601;              // = false,  dates will be formatted according to ISO 8601 where applicable (e.g. YYYY-MM-DD, YYYY-MM, --MM-DD, etc.)
+    bool    Use24HourClock;          // = false,  times will be formatted using a 24 hour clock
+    IMPLOT_API ImPlotStyle();
+};
+
+//-----------------------------------------------------------------------------
+// ImPlot End-User API
+//-----------------------------------------------------------------------------
+
+namespace ImPlot {
+
+//-----------------------------------------------------------------------------
+// ImPlot Context
+//-----------------------------------------------------------------------------
+
+// Creates a new ImPlot context. Call this after ImGui::CreateContext.
+IMPLOT_API ImPlotContext* CreateContext();
+// Destroys an ImPlot context. Call this before ImGui::DestroyContext. NULL = destroy current context.
+IMPLOT_API void DestroyContext(ImPlotContext* ctx = NULL);
+// Returns the current ImPlot context. NULL if no context has ben set.
+IMPLOT_API ImPlotContext* GetCurrentContext();
+// Sets the current ImPlot context.
+IMPLOT_API void SetCurrentContext(ImPlotContext* ctx);
+
+// Sets the current **ImGui** context. This is ONLY necessary if you are compiling
+// ImPlot as a DLL (not recommended) separate from your ImGui compilation. It
+// sets the global variable GImGui, which is not shared across DLL boundaries.
+// See GImGui documentation in imgui.cpp for more details.
+IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
+
+//-----------------------------------------------------------------------------
+// Begin/End Plot
+//-----------------------------------------------------------------------------
+
+// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
+// be called! You are encouraged to use the following convention:
+//
+// if (BeginPlot(...)) {
+//     ImPlot::PlotLine(...);
+//     ...
+//     EndPlot();
+// }
+//
+// Important notes:
+//
+// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
+//   collisions or don't want to display a title in the plot, use double hashes
+//   (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
+// - If #x_label and/or #y_label are provided, axes labels will be displayed.
+// - #size is the **frame** size of the plot widget, not the plot area. The default
+//   size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle
+//   (default is 400x300 px).
+// - Auxiliary y-axes must be enabled with ImPlotFlags_YAxis2/3 to be displayed.
+// - See ImPlotFlags and ImPlotAxisFlags for more available options.
+
+IMPLOT_API bool BeginPlot(const char* title_id,
+                          const char* x_label      = NULL,
+                          const char* y_label      = NULL,
+                          const ImVec2& size       = ImVec2(-1,0),
+                          ImPlotFlags flags        = ImPlotFlags_None,
+                          ImPlotAxisFlags x_flags  = ImPlotAxisFlags_None,
+                          ImPlotAxisFlags y_flags  = ImPlotAxisFlags_None,
+                          ImPlotAxisFlags y2_flags = ImPlotAxisFlags_NoGridLines,
+                          ImPlotAxisFlags y3_flags = ImPlotAxisFlags_NoGridLines,
+                          const char* y2_label     = NULL,
+                          const char* y3_label     = NULL);
+
+// Only call EndPlot() if BeginPlot() returns true! Typically called at the end
+// of an if statement conditioned on BeginPlot(). See example above.
+IMPLOT_API void EndPlot();
+
+//-----------------------------------------------------------------------------
+// Begin/EndSubplots
+//-----------------------------------------------------------------------------
+
+// Starts a subdivided plotting context. If the function returns true,
+// EndSubplots() MUST be called! Call BeginPlot/EndPlot AT MOST [rows*cols]
+// times in  between the begining and end of the subplot context. Plots are
+// added in row major order.
+//
+// Example:
+//
+// if (BeginSubplots("My Subplot",2,3,ImVec2(800,400)) {
+//     for (int i = 0; i < 6; ++i) {
+//         if (BeginPlot(...)) {
+//             ImPlot::PlotLine(...);
+//             ...
+//             EndPlot();
+//         }
+//     }
+//     EndSubplots();
+// }
+//
+// Procudes:
+//
+// [0][1][2]
+// [3][4][5]
+//
+// Important notes:
+//
+// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
+//   collisions or don't want to display a title in the plot, use double hashes
+//   (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
+// - #rows and #cols must be greater than 0.
+// - #size is the size of the entire grid of subplots, not the individual plots
+// - #row_ratios and #col_ratios must have AT LEAST #rows and #cols elements,
+//   respectively. These are the sizes of the rows and columns expressed in ratios.
+//   If the user adjusts the dimensions, the arrays are updated with new ratios.
+//
+// Important notes regarding BeginPlot from inside of BeginSubplots:
+//
+// - The #title_id parameter of _BeginPlot_ (see above) does NOT have to be
+//   unique when called inside of a subplot context. Subplot IDs are hashed
+//   for your convenience so you don't have call PushID or generate unique title
+//   strings. Simply pass an empty string to BeginPlot unless you want to title
+//   each subplot.
+// - The #size parameter of _BeginPlot_ (see above) is ignored when inside of a
+//   subplot context. The actual size of the subplot will be based on the
+//   #size value you pass to _BeginSubplots_ and #row/#col_ratios if provided.
+
+IMPLOT_API bool BeginSubplots(const char* title_id,
+                             int rows,
+                             int cols,
+                             const ImVec2& size,
+                             ImPlotSubplotFlags flags = ImPlotSubplotFlags_None,
+                             float* row_ratios        = NULL,
+                             float* col_ratios        = NULL);
+
+// Only call EndSubplots() if BeginSubplots() returns true! Typically called at the end
+// of an if statement conditioned on BeginSublots(). See example above.
+IMPLOT_API void EndSubplots();
+
+//-----------------------------------------------------------------------------
+// Plot Items
+//-----------------------------------------------------------------------------
+
+// The template functions below are explicitly instantiated in implot_items.cpp.
+// They are not intended to be used generically with custom types. You will get
+// a linker error if you try! All functions support the following scalar types:
+//
+// float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
+//
+//
+// If you need to plot custom or non-homogenous data you have a few options:
+//
+// 1. If your data is a simple struct/class (e.g. Vector2f), you can use striding.
+//    This is the most performant option if applicable.
+//
+//    struct Vector2f { float X, Y; };
+//    ...
+//    Vector2f data[42];
+//    ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, sizeof(Vector2f)); // or sizeof(float)*2
+//
+// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
+//    an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
+//    cost, but probably not enough to worry about unless your data is very large. Examples:
+//
+//    ImPlotPoint MyDataGetter(void* data, int idx) {
+//        MyData* my_data = (MyData*)data;
+//        ImPlotPoint p;
+//        p.x = my_data->GetTime(idx);
+//        p.y = my_data->GetValue(idx);
+//        return p
+//    }
+//    ...
+//    auto my_lambda = [](void*, int idx) {
+//        double t = idx / 999.0;
+//        return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
+//    };
+//    ...
+//    if (ImPlot::BeginPlot("MyPlot")) {
+//        MyData my_data;
+//        ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
+//        ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
+//        ImPlot::EndPlot();
+//    }
+//
+// NB: All types are converted to double before plotting. You may lose information
+// if you try plotting extremely large 64-bit integral types. Proceed with caution!
+
+// Plots a standard 2D line plot.
+template <typename T> IMPLOT_API void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotLine(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotLineG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
+template <typename T> IMPLOT_API  void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API  void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API  void PlotScatterG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
+template <typename T> IMPLOT_API void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotStairsG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* values, int count, double y_ref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotShadedG(const char* label_id, ImPlotPoint (*getter1)(void* data, int idx), void* data1, ImPlotPoint (*getter2)(void* data, int idx), void* data2, int count, int offset=0);
+
+// Plots a vertical bar graph. #width and #shift are in X units.
+template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* values, int count, double width=0.67, double shift=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double width, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotBarsG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double width, int offset=0);
+
+// Plots a horizontal bar graph. #height and #shift are in Y units.
+template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* values, int count, double height=0.67, double shift=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double height, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double height,  int offset=0);
+
+// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
+template <typename T> IMPLOT_API void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
+
+// Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
+template <typename T> IMPLOT_API void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
+
+/// Plots vertical stems.
+template <typename T> IMPLOT_API void PlotStems(const char* label_id, const T* values, int count, double y_ref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double y_ref=0, int offset=0, int stride=sizeof(T));
+
+/// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
+template <typename T> IMPLOT_API void PlotVLines(const char* label_id, const T* xs, int count, int offset=0, int stride=sizeof(T));
+template <typename T> IMPLOT_API void PlotHLines(const char* label_id, const T* ys, int count, int offset=0, int stride=sizeof(T));
+
+// Plots a pie chart. If the sum of values > 1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
+template <typename T> IMPLOT_API void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize=false, const char* label_fmt="%.1f", double angle0=90);
+
+// Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
+template <typename T> IMPLOT_API void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1));
+
+// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
+// If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
+// If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
+template <typename T> IMPLOT_API double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, bool cumulative=false, bool density=false, ImPlotRange range=ImPlotRange(), bool outliers=true, double bar_scale=1.0);
+
+// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
+// If #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
+// However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
+template <typename T> IMPLOT_API double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, bool density=false, ImPlotLimits range=ImPlotLimits(), bool outliers=true);
+
+// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
+template <typename T> IMPLOT_API void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
+                      IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0);
+
+// Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
+IMPLOT_API void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, const ImVec2& uv0=ImVec2(0,0), const ImVec2& uv1=ImVec2(1,1), const ImVec4& tint_col=ImVec4(1,1,1,1));
+
+// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
+IMPLOT_API void PlotText(const char* text, double x, double y, bool vertical=false, const ImVec2& pix_offset=ImVec2(0,0));
+
+// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
+IMPLOT_API void PlotDummy(const char* label_id);
+
+//-----------------------------------------------------------------------------
+// Plot Utils
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BEFORE BeginPlot!
+
+// Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked.
+IMPLOT_API void SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once);
+// Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the X axis limits will be locked.
+IMPLOT_API void SetNextPlotLimitsX(double xmin, double xmax, ImGuiCond cond = ImGuiCond_Once);
+// Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the Y axis limits will be locked.
+IMPLOT_API void SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once, ImPlotYAxis y_axis = ImPlotYAxis_1);
+// Links the next plot limits to external values. Set to NULL for no linkage. The pointer data must remain valid until the matching call to EndPlot.
+IMPLOT_API void LinkNextPlotLimits(double* xmin, double* xmax, double* ymin, double* ymax, double* ymin2 = NULL, double* ymax2 = NULL, double* ymin3 = NULL, double* ymax3 = NULL);
+// Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks).
+IMPLOT_API void FitNextPlotAxes(bool x = true, bool y = true, bool y2 = true, bool y3 = true);
+
+// Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
+IMPLOT_API void SetNextPlotTicksX(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
+IMPLOT_API void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
+// Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
+IMPLOT_API void SetNextPlotTicksY(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
+IMPLOT_API void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
+
+// Set the format for numeric X axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled.
+IMPLOT_API void SetNextPlotFormatX(const char* fmt);
+// Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.).
+IMPLOT_API void SetNextPlotFormatY(const char* fmt, ImPlotYAxis y_axis=ImPlotYAxis_1);
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Select which Y axis will be used for subsequent plot elements. The default is ImPlotYAxis_1, or the first (left) Y axis. Enable 2nd and 3rd axes with ImPlotFlags_YAxisX.
+IMPLOT_API void SetPlotYAxis(ImPlotYAxis y_axis);
+// Hides or shows the next plot item (i.e. as if it were toggled from the legend). Use ImGuiCond_Always if you need to forcefully set this every frame.
+IMPLOT_API void HideNextItem(bool hidden = true, ImGuiCond cond = ImGuiCond_Once);
+
+// Convert pixels to a position in the current plot's coordinate system. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotPoint PixelsToPlot(const ImVec2& pix, ImPlotYAxis y_axis = IMPLOT_AUTO);
+IMPLOT_API ImPlotPoint PixelsToPlot(float x, float y, ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Convert a position in the current plot's coordinate system to pixels. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImVec2 PlotToPixels(const ImPlotPoint& plt, ImPlotYAxis y_axis = IMPLOT_AUTO);
+IMPLOT_API ImVec2 PlotToPixels(double x, double y, ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Get the current Plot position (top-left) in pixels.
+IMPLOT_API ImVec2 GetPlotPos();
+// Get the curent Plot size in pixels.
+IMPLOT_API ImVec2 GetPlotSize();
+// Returns true if the plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotHovered();
+// Returns true if the XAxis plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotXAxisHovered();
+// Returns true if the YAxis[n] plot area in the current plot is hovered.
+IMPLOT_API bool IsPlotYAxisHovered(ImPlotYAxis y_axis = 0);
+// Returns the mouse position in x,y coordinates of the current plot. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotPoint GetPlotMousePos(ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Returns the current plot axis range. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
+IMPLOT_API ImPlotLimits GetPlotLimits(ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+// Returns true if the current plot is being box selected.
+IMPLOT_API bool IsPlotSelected();
+// Returns the current plot box selection bounds.
+IMPLOT_API ImPlotLimits GetPlotSelection(ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+// Returns true if the current plot is being queried or has an active query. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API bool IsPlotQueried();
+// Returns the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API ImPlotLimits GetPlotQuery(ImPlotYAxis y_axis = IMPLOT_AUTO);
+// Set the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
+IMPLOT_API void SetPlotQuery(const ImPlotLimits& query, ImPlotYAxis y_axis = IMPLOT_AUTO);
+
+//-----------------------------------------------------------------------------
+// Algined Plots
+//-----------------------------------------------------------------------------
+
+// Consider using Begin/EndSubplots first. They are more feature rich and
+// accomplish the same behaviour by default. The functions below offer lower
+// level control of plot alignment.
+
+// Align axis padding over multiple plots in a single row or column. If this function returns true, EndAlignedPlots() must be called. #group_id must be unique.
+IMPLOT_API bool BeginAlignedPlots(const char* group_id, ImPlotOrientation orientation = ImPlotOrientation_Vertical);
+// Only call EndAlignedPlots() if BeginAlignedPlots() returns true!
+IMPLOT_API void EndAlignedPlots();
+
+//-----------------------------------------------------------------------------
+// Plot Tools
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Shows an annotation callout at a chosen point.
+IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const char* fmt, ...)                                       IM_FMTARGS(4);
+IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...)                  IM_FMTARGS(5);
+IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args)                             IM_FMTLIST(4);
+IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args)        IM_FMTLIST(5);
+
+// Same as above, but the annotation will always be clamped to stay inside the plot area.
+IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const char* fmt, ...)                                IM_FMTARGS(4);
+IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...)           IM_FMTARGS(5);
+IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args)                      IM_FMTLIST(4);
+IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(5);
+
+// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragLineX(const char* id, double* x_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
+// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragLineY(const char* id, double* y_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
+// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
+IMPLOT_API bool DragPoint(const char* id, double* x, double* y, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float radius = 4);
+
+//-----------------------------------------------------------------------------
+// Legend Utils and Tools
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Set the location of the current plot's (or subplot's) legend.
+IMPLOT_API void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation = ImPlotOrientation_Vertical, bool outside = false);
+// Set the location of the current plot's mouse position text (default = South|East).
+IMPLOT_API void SetMousePosLocation(ImPlotLocation location);
+// Returns true if a plot item legend entry is hovered.
+IMPLOT_API bool IsLegendEntryHovered(const char* label_id);
+
+// Begin a popup for a legend entry.
+IMPLOT_API bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button = 1);
+// End a popup for a legend entry.
+IMPLOT_API void EndLegendPopup();
+
+//-----------------------------------------------------------------------------
+// Drag and Drop Utils
+//-----------------------------------------------------------------------------
+
+// The following functions MUST be called BETWEEN Begin/EndPlot!
+
+// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTarget();
+// Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetX();
+// Turns the current plot's Y-Axis into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetY(ImPlotYAxis axis = ImPlotYAxis_1);
+// Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
+IMPLOT_API bool BeginDragDropTargetLegend();
+// Ends a drag and drop target (currently just an alias for ImGui::EndDragDropTarget).
+IMPLOT_API void EndDragDropTarget();
+
+// NB: By default, plot and axes drag and drop *sources* require holding the Ctrl modifier to initiate the drag.
+// You can change the modifier if desired. If ImGuiKeyModFlags_None is provided, the axes will be locked from panning.
+
+// Turns the current plot's plotting area into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSource(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns the current plot's X-axis into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceX(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns the current plot's Y-axis into a drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceY(ImPlotYAxis axis = ImPlotYAxis_1, ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
+// Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource!
+IMPLOT_API bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags = 0);
+// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
+IMPLOT_API void EndDragDropSource();
+
+//-----------------------------------------------------------------------------
+// Plot and Item Styling
+//-----------------------------------------------------------------------------
+
+// Styling colors in ImPlot works similarly to styling colors in ImGui, but
+// with one important difference. Like ImGui, all style colors are stored in an
+// indexable array in ImPlotStyle. You can permanently modify these values through
+// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
+// However, by default all style colors in ImPlot default to a special color
+// IMPLOT_AUTO_COL. The behavior of this color depends upon the style color to
+// which it as applied:
+//
+//     1) For style colors associated with plot items (e.g. ImPlotCol_Line),
+//        IMPLOT_AUTO_COL tells ImPlot to color the item with the next unused
+//        color in the current colormap. Thus, every item will have a different
+//        color up to the number of colors in the colormap, at which point the
+//        colormap will roll over. For most use cases, you should not need to
+//        set these style colors to anything but IMPLOT_COL_AUTO; you are
+//        probably better off changing the current colormap. However, if you
+//        need to explicitly color a particular item you may either Push/Pop
+//        the style color around the item in question, or use the SetNextXXXStyle
+//        API below. If you permanently set one of these style colors to a specific
+//        color, or forget to call Pop, then all subsequent items will be styled
+//        with the color you set.
+//
+//     2) For style colors associated with plot styling (e.g. ImPlotCol_PlotBg),
+//        IMPLOT_AUTO_COL tells ImPlot to set that color from color data in your
+//        **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
+//        detailed above, and in general have been mapped to produce plots visually
+//        consistent with your current ImGui style. Of course, you are free to
+//        manually set these colors to whatever you like, and further can Push/Pop
+//        them around individual plots for plot-specific styling (e.g. coloring axes).
+
+// Provides access to plot style structure for permanant modifications to colors, sizes, etc.
+IMPLOT_API ImPlotStyle& GetStyle();
+
+// Style plot colors for current ImGui style (default).
+IMPLOT_API void StyleColorsAuto(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Classic".
+IMPLOT_API void StyleColorsClassic(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Dark".
+IMPLOT_API void StyleColorsDark(ImPlotStyle* dst = NULL);
+// Style plot colors for ImGui "Light".
+IMPLOT_API void StyleColorsLight(ImPlotStyle* dst = NULL);
+
+// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
+// will last until the matching call to PopStyleX. You MUST call a pop for
+// every push, otherwise you will leak memory! This behaves just like ImGui.
+
+// Temporarily modify a style color. Don't forget to call PopStyleColor!
+IMPLOT_API void PushStyleColor(ImPlotCol idx, ImU32 col);
+IMPLOT_API void PushStyleColor(ImPlotCol idx, const ImVec4& col);
+// Undo temporary style color modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopStyleColor(int count = 1);
+
+// Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, float val);
+// Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, int val);
+// Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
+IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val);
+// Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopStyleVar(int count = 1);
+
+// The following can be used to modify the style of the next plot item ONLY. They do
+// NOT require calls to PopStyleX. Leave style attributes you don't want modified to
+// IMPLOT_AUTO or IMPLOT_AUTO_COL. Automatic styles will be deduced from the current
+// values in your ImPlotStyle or from Colormap data.
+
+// Set the line color and weight for the next item only.
+IMPLOT_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO);
+// Set the fill color for the next item only.
+IMPLOT_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);
+// Set the marker style for the next item only.
+IMPLOT_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL);
+// Set the error bar style for the next item only.
+IMPLOT_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO);
+
+// Gets the last item primary color (i.e. its legend icon color)
+IMPLOT_API ImVec4 GetLastItemColor();
+
+// Returns the null terminated string name for an ImPlotCol.
+IMPLOT_API const char* GetStyleColorName(ImPlotCol idx);
+// Returns the null terminated string name for an ImPlotMarker.
+IMPLOT_API const char* GetMarkerName(ImPlotMarker idx);
+
+//-----------------------------------------------------------------------------
+// Colormaps
+//-----------------------------------------------------------------------------
+
+// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
+// IMPLOT_AUTO_COL (default). Several built-in colormaps are available. You can
+// add and then push/pop your own colormaps as well. To permanently set a colormap,
+// modify the Colormap index member of your ImPlotStyle.
+
+// Colormap data will be ignored and a custom color will be used if you have done one of the following:
+//     1) Modified an item style color in your ImPlotStyle to anything other than IMPLOT_AUTO_COL.
+//     2) Pushed an item style color using PushStyleColor().
+//     3) Set the next item style with a SetNextXXXStyle function.
+
+// Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the
+// string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive
+// an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a
+// continuous colormap, set #qual=false. This will treat the colors you provide as keys, and ImPlot will build a linearly
+// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
+IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImVec4* cols, int size, bool qual=true);
+IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImU32*  cols, int size, bool qual=true);
+
+// Returns the number of available colormaps (i.e. the built-in + user-added count).
+IMPLOT_API int GetColormapCount();
+// Returns a null terminated string name for a colormap given an index. Returns NULL if index is invalid.
+IMPLOT_API const char* GetColormapName(ImPlotColormap cmap);
+// Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid.
+IMPLOT_API ImPlotColormap GetColormapIndex(const char* name);
+
+// Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
+IMPLOT_API void PushColormap(ImPlotColormap cmap);
+// Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
+IMPLOT_API void PushColormap(const char* name);
+// Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
+IMPLOT_API void PopColormap(int count = 1);
+
+// Returns the next color from the current colormap and advances the colormap for the current plot.
+// Can also be used with no return value to skip colors if desired. You need to call this between Begin/EndPlot!
+IMPLOT_API ImVec4 NextColormapColor();
+
+// Colormap utils. If cmap = IMPLOT_AUTO (default), the current colormap is assumed.
+// Pass an explicit colormap index (built-in or user-added) to specify otherwise.
+
+// Returns the size of a colormap.
+IMPLOT_API int GetColormapSize(ImPlotColormap cmap = IMPLOT_AUTO);
+// Returns a color from a colormap given an index >= 0 (modulo will be performed).
+IMPLOT_API ImVec4 GetColormapColor(int idx, ImPlotColormap cmap = IMPLOT_AUTO);
+// Sample a color from the current colormap given t between 0 and 1.
+IMPLOT_API ImVec4 SampleColormap(float t, ImPlotColormap cmap = IMPLOT_AUTO);
+
+// Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel").
+IMPLOT_API void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO, const char* fmt = "%g");
+// Shows a horizontal slider with a colormap gradient background. Optionally returns the color sampled at t in [0 1].
+IMPLOT_API bool ColormapSlider(const char* label, float* t, ImVec4* out = NULL, const char* format = "", ImPlotColormap cmap = IMPLOT_AUTO);
+// Shows a button with a colormap gradient brackground.
+IMPLOT_API bool ColormapButton(const char* label, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO);
+
+// When items in a plot sample their color from a colormap, the color is cached and does not change
+// unless explicitly overriden. Therefore, if you change the colormap after the item has already been plotted,
+// item colors will NOT update. If you need item colors to resample the new colormap, then use this
+// function to bust the cached colors. If #plot_title_id is NULL, then every item in EVERY existing plot
+// will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
+// latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
+// need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
+IMPLOT_API void BustColorCache(const char* plot_title_id = NULL);
+
+//-----------------------------------------------------------------------------
+// Miscellaneous
+//-----------------------------------------------------------------------------
+
+// Render icons similar to those that appear in legends (nifty for data lists).
+IMPLOT_API void ItemIcon(const ImVec4& col);
+IMPLOT_API void ItemIcon(ImU32 col);
+IMPLOT_API void ColormapIcon(ImPlotColormap cmap);
+
+// Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
+IMPLOT_API ImDrawList* GetPlotDrawList();
+// Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
+IMPLOT_API void PushPlotClipRect(float expand=0);
+// Pop plot clip rect. Call between Begin/EndPlot.
+IMPLOT_API void PopPlotClipRect();
+
+// Shows ImPlot style selector dropdown menu.
+IMPLOT_API bool ShowStyleSelector(const char* label);
+// Shows ImPlot colormap selector dropdown menu.
+IMPLOT_API bool ShowColormapSelector(const char* label);
+// Shows ImPlot style editor block (not a window).
+IMPLOT_API void ShowStyleEditor(ImPlotStyle* ref = NULL);
+// Add basic help/info block for end users (not a window).
+IMPLOT_API void ShowUserGuide();
+// Shows ImPlot metrics/debug information window.
+IMPLOT_API void ShowMetricsWindow(bool* p_popen = NULL);
+
+//-----------------------------------------------------------------------------
+// Demo (add implot_demo.cpp to your sources!)
+//-----------------------------------------------------------------------------
+
+// Shows the ImPlot demo window.
+IMPLOT_API void ShowDemoWindow(bool* p_open = NULL);
+
+}  // namespace ImPlot

lib/external/imgui/include/imstb_rectpack.h

@@ -34,7 +34,7 @@
 //  Minor features
 //    Martins Mozeiko
 //    github:IntellectualKitty
-//    
+//
 //  Bugfixes / warning fixes
 //    Jeremy Jaussaud
 //    Fabian Giesen
@@ -441,7 +441,7 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt
             }
          }
          tail = tail->next;
-      }         
+      }
    }
 
    fr.prev_link = best;
@@ -602,38 +602,38 @@ This software is available under 2 licenses -- choose whichever you prefer.
 ------------------------------------------------------------------------------
 ALTERNATIVE A - MIT License
 Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of 
-this software and associated documentation files (the "Software"), to deal in 
-the Software without restriction, including without limitation the rights to 
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
-of the Software, and to permit persons to whom the Software is furnished to do 
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all 
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ------------------------------------------------------------------------------
 ALTERNATIVE B - Public Domain (www.unlicense.org)
 This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
-software, either in source code form or as a compiled binary, for any purpose, 
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
 commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this 
-software dedicate any and all copyright interest in the software to the public 
-domain. We make this dedication for the benefit of the public at large and to 
-the detriment of our heirs and successors. We intend this dedication to be an 
-overt act of relinquishment in perpetuity of all present and future rights to 
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
 this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ------------------------------------------------------------------------------
 */

lib/external/imgui/include/imstb_textedit.h

@@ -1,5 +1,5 @@
 // [DEAR IMGUI]
-// This is a slightly modified version of stb_textedit.h 1.13. 
+// This is a slightly modified version of stb_textedit.h 1.13.
 // Those changes would need to be pushed into nothings/stb:
 // - Fix in stb_textedit_discard_redo (see https://github.com/nothings/stb/issues/321)
 // Grep for [DEAR IMGUI] to find the changes.
@@ -19,7 +19,7 @@
 // texts, as its performance does not scale and it has limited undo).
 //
 // Non-trivial behaviors are modelled after Windows text controls.
-// 
+//
 //
 // LICENSE
 //
@@ -217,20 +217,20 @@
 //          call this with the mouse x,y on a mouse down; it will update the cursor
 //          and reset the selection start/end to the cursor point. the x,y must
 //          be relative to the text widget, with (0,0) being the top left.
-//     
+//
 //      drag:
 //          call this with the mouse x,y on a mouse drag/up; it will update the
 //          cursor and the selection end point
-//     
+//
 //      cut:
 //          call this to delete the current selection; returns true if there was
 //          one. you should FIRST copy the current selection to the system paste buffer.
 //          (To copy, just copy the current selection out of the string yourself.)
-//     
+//
 //      paste:
 //          call this to paste text at the current cursor point or over the current
 //          selection if there is one.
-//     
+//
 //      key:
 //          call this for keyboard inputs sent to the textfield. you can use it
 //          for "key down" events or for "translated" key events. if you need to
@@ -241,7 +241,7 @@
 //          clear. STB_TEXTEDIT_KEYTYPE defaults to int, but you can #define it to
 //          anything other type you wante before including.
 //
-//     
+//
 //   When rendering, you can read the cursor position and selection state from
 //   the STB_TexteditState.
 //
@@ -716,9 +716,11 @@ static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditSta
       state->has_preferred_x = 0;
       return 1;
    }
-   // remove the undo since we didn't actually insert the characters
-   if (state->undostate.undo_point)
-      --state->undostate.undo_point;
+   // [DEAR IMGUI]
+   //// remove the undo since we didn't actually insert the characters
+   //if (state->undostate.undo_point)
+   //   --state->undostate.undo_point;
+   // note: paste failure will leave deleted selection, may be restored with an undo (see https://github.com/nothings/stb/issues/734 for details)
    return 0;
 }
 
@@ -764,7 +766,7 @@ retry:
          state->insert_mode = !state->insert_mode;
          break;
 #endif
-         
+
       case STB_TEXTEDIT_K_UNDO:
          stb_text_undo(str, state);
          state->has_preferred_x = 0;
@@ -779,7 +781,7 @@ retry:
          // if currently there's a selection, move cursor to start of selection
          if (STB_TEXT_HAS_SELECTION(state))
             stb_textedit_move_to_first(state);
-         else 
+         else
             if (state->cursor > 0)
                --state->cursor;
          state->has_preferred_x = 0;
@@ -828,7 +830,7 @@ retry:
 
 #ifdef STB_TEXTEDIT_MOVEWORDRIGHT
       case STB_TEXTEDIT_K_WORDRIGHT:
-         if (STB_TEXT_HAS_SELECTION(state)) 
+         if (STB_TEXT_HAS_SELECTION(state))
             stb_textedit_move_to_last(str, state);
          else {
             state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
@@ -922,7 +924,7 @@ retry:
          }
          break;
       }
-         
+
       case STB_TEXTEDIT_K_UP:
       case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT:
       case STB_TEXTEDIT_K_PGUP:
@@ -1014,7 +1016,7 @@ retry:
          }
          state->has_preferred_x = 0;
          break;
-         
+
 #ifdef STB_TEXTEDIT_K_TEXTSTART2
       case STB_TEXTEDIT_K_TEXTSTART2:
 #endif
@@ -1031,7 +1033,7 @@ retry:
          state->select_start = state->select_end = 0;
          state->has_preferred_x = 0;
          break;
-        
+
 #ifdef STB_TEXTEDIT_K_TEXTSTART2
       case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT:
 #endif
@@ -1410,38 +1412,38 @@ This software is available under 2 licenses -- choose whichever you prefer.
 ------------------------------------------------------------------------------
 ALTERNATIVE A - MIT License
 Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of 
-this software and associated documentation files (the "Software"), to deal in 
-the Software without restriction, including without limitation the rights to 
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
-of the Software, and to permit persons to whom the Software is furnished to do 
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all 
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ------------------------------------------------------------------------------
 ALTERNATIVE B - Public Domain (www.unlicense.org)
 This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
-software, either in source code form or as a compiled binary, for any purpose, 
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
 commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this 
-software dedicate any and all copyright interest in the software to the public 
-domain. We make this dedication for the benefit of the public at large and to 
-the detriment of our heirs and successors. We intend this dedication to be an 
-overt act of relinquishment in perpetuity of all present and future rights to 
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
 this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ------------------------------------------------------------------------------
 */

lib/external/imgui/include/imstb_truetype.h

@@ -51,7 +51,7 @@
 //       Rob Loach                  Cort Stratton
 //       Kenney Phillis Jr.         github:oyvindjam
 //       Brian Costabile            github:vassvik
-//       
+//
 // VERSION HISTORY
 //
 //   1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics()
@@ -212,7 +212,7 @@
 //
 //  Advancing for the next character:
 //    Call GlyphHMetrics, and compute 'current_point += SF * advance'.
-// 
+//
 //
 // ADVANCED USAGE
 //
@@ -257,7 +257,7 @@
 //   Curve tessellation                 120 LOC   \__ 550 LOC Bitmap creation
 //   Bitmap management                  100 LOC   /
 //   Baked bitmap interface              70 LOC  /
-//   Font name matching & access        150 LOC  ---- 150 
+//   Font name matching & access        150 LOC  ---- 150
 //   C runtime library abstraction       60 LOC  ----  60
 //
 //
@@ -350,7 +350,7 @@ int main(int argc, char **argv)
    }
    return 0;
 }
-#endif 
+#endif
 //
 // Output:
 //
@@ -364,9 +364,9 @@ int main(int argc, char **argv)
 //  :@@.  M@M
 //   @@@o@@@@
 //   :M@@V:@@.
-//  
+//
 //////////////////////////////////////////////////////////////////////////////
-// 
+//
 // Complete program: print "Hello World!" banner, with bugs
 //
 #if 0
@@ -667,7 +667,7 @@ STBTT_DEF int  stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, cons
 // Calling these functions in sequence is roughly equivalent to calling
 // stbtt_PackFontRanges(). If you more control over the packing of multiple
 // fonts, or if you want to pack custom data into a font texture, take a look
-// at the source to of stbtt_PackFontRanges() and create a custom version 
+// at the source to of stbtt_PackFontRanges() and create a custom version
 // using these functions, e.g. call GatherRects multiple times,
 // building up a single array of rects, then call PackRects once,
 // then call RenderIntoRects repeatedly. This may result in a
@@ -975,7 +975,7 @@ STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, floa
 // and computing from that can allow drop-out prevention).
 //
 // The algorithm has not been optimized at all, so expect it to be slow
-// if computing lots of characters or very large sizes. 
+// if computing lots of characters or very large sizes.
 
 
 
@@ -1732,7 +1732,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s
             if (i != 0)
                num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
 
-            // now start the new one               
+            // now start the new one
             start_off = !(flags & 1);
             if (start_off) {
                // if we start off with an off-curve point, then when we need to find a point on the curve
@@ -1785,7 +1785,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s
          int comp_num_verts = 0, i;
          stbtt_vertex *comp_verts = 0, *tmp = 0;
          float mtx[6] = {1,0,0,1,0,0}, m, n;
-         
+
          flags = ttSHORT(comp); comp+=2;
          gidx = ttSHORT(comp); comp+=2;
 
@@ -1815,7 +1815,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s
             mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
             mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
          }
-         
+
          // Find transformation scales.
          m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
          n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
@@ -2746,7 +2746,7 @@ static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, i
    float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
    STBTT_assert(z != NULL);
    if (!z) return z;
-   
+
    // round dx down to avoid overshooting
    if (dxdy < 0)
       z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
@@ -2824,7 +2824,7 @@ static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__ac
             }
          }
       }
-      
+
       e = e->next;
    }
 }
@@ -3554,7 +3554,7 @@ STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info
 {
    int ix0,iy0,ix1,iy1;
    stbtt__bitmap gbm;
-   stbtt_vertex *vertices;   
+   stbtt_vertex *vertices;
    int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
 
    if (scale_x == 0) scale_x = scale_y;
@@ -3577,7 +3577,7 @@ STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info
    if (height) *height = gbm.h;
    if (xoff  ) *xoff   = ix0;
    if (yoff  ) *yoff   = iy0;
-   
+
    if (gbm.w && gbm.h) {
       gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata);
       if (gbm.pixels) {
@@ -3588,7 +3588,7 @@ STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info
    }
    STBTT_free(vertices, info->userdata);
    return gbm.pixels;
-}   
+}
 
 STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)
 {
@@ -3600,7 +3600,7 @@ STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigne
    int ix0,iy0;
    stbtt_vertex *vertices;
    int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
-   stbtt__bitmap gbm;   
+   stbtt__bitmap gbm;
 
    stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
    gbm.pixels = output;
@@ -3622,7 +3622,7 @@ STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *
 STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
 {
    return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff);
-}   
+}
 
 STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)
 {
@@ -3637,7 +3637,7 @@ STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, uns
 STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
 {
    return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff);
-}   
+}
 
 STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)
 {
@@ -3762,7 +3762,7 @@ static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *no
    con->y = 0;
    con->bottom_y = 0;
    STBTT__NOTUSED(nodes);
-   STBTT__NOTUSED(num_nodes);   
+   STBTT__NOTUSED(num_nodes);
 }
 
 static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
@@ -4147,7 +4147,7 @@ STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char
    n = 0;
    for (i=0; i < num_ranges; ++i)
       n += ranges[i].num_chars;
-         
+
    rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
    if (rects == NULL)
       return 0;
@@ -4158,7 +4158,7 @@ STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char
    n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects);
 
    stbtt_PackFontRangesPackRects(spc, rects, n);
-  
+
    return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects);
 
    STBTT_free(rects, spc->user_allocator_context);
@@ -4302,7 +4302,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
    int winding = 0;
 
    orig[0] = x;
-   //orig[1] = y; // [DEAR IMGUI] commmented double assignment
+   //orig[1] = y; // [DEAR IMGUI] commented double assignment
 
    // make sure y never passes through a vertex of the shape
    y_frac = (float) STBTT_fmod(y, 1.0f);
@@ -4319,7 +4319,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
          int x1 = (int) verts[i  ].x, y1 = (int) verts[i  ].y;
          if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
             float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
-            if (x_inter < x)  
+            if (x_inter < x)
                winding += (y0 < y1) ? 1 : -1;
          }
       }
@@ -4345,7 +4345,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
                y1 = (int)verts[i  ].y;
                if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
                   float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
-                  if (x_inter < x)  
+                  if (x_inter < x)
                      winding += (y0 < y1) ? 1 : -1;
                }
             } else {
@@ -4357,7 +4357,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
                   if (hits[1][0] < 0)
                      winding += (hits[1][1] < 0 ? -1 : 1);
             }
-         } 
+         }
       }
    }
    return winding;
@@ -4438,7 +4438,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc
 
    // invert for y-downwards bitmaps
    scale_y = -scale_y;
-      
+
    {
       int x,y,i,j;
       float *precompute;
@@ -4587,7 +4587,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc
       STBTT_free(verts, info->userdata);
    }
    return data;
-}   
+}
 
 STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)
 {
@@ -4605,7 +4605,7 @@ STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
 //
 
 // check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
-static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) 
+static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)
 {
    stbtt_int32 i=0;
 
@@ -4644,7 +4644,7 @@ static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, s
    return i;
 }
 
-static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) 
+static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)
 {
    return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2);
 }
@@ -4773,7 +4773,7 @@ STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,
 
 STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)
 {
-   return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index);   
+   return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index);
 }
 
 STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
@@ -4866,38 +4866,38 @@ This software is available under 2 licenses -- choose whichever you prefer.
 ------------------------------------------------------------------------------
 ALTERNATIVE A - MIT License
 Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of 
-this software and associated documentation files (the "Software"), to deal in 
-the Software without restriction, including without limitation the rights to 
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
-of the Software, and to permit persons to whom the Software is furnished to do 
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all 
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ------------------------------------------------------------------------------
 ALTERNATIVE B - Public Domain (www.unlicense.org)
 This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
-software, either in source code form or as a compiled binary, for any purpose, 
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
 commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this 
-software dedicate any and all copyright interest in the software to the public 
-domain. We make this dedication for the benefit of the public at large and to 
-the detriment of our heirs and successors. We intend this dedication to be an 
-overt act of relinquishment in perpetuity of all present and future rights to 
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
 this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ------------------------------------------------------------------------------
 */

lib/external/imgui/source/imgui_freetype.cpp

@@ -1,25 +1,33 @@
-// dear imgui: wrapper to use FreeType (instead of stb_truetype)
-// Get latest version at https://github.com/ocornut/imgui/tree/master/misc/freetype
-// Original code by @vuhdo (Aleksei Skriabin). Improvements by @mikesart. Maintained and v0.60+ by @ocornut.
+// dear imgui: FreeType font builder (used as a replacement for the stb_truetype builder)
+// (code)
 
-// Changelog:
-// - v0.50: (2017/08/16) imported from https://github.com/Vuhdo/imgui_freetype into http://www.github.com/ocornut/imgui_club, updated for latest changes in ImFontAtlas, minor tweaks.
-// - v0.51: (2017/08/26) cleanup, optimizations, support for ImFontConfig::RasterizerFlags, ImFontConfig::RasterizerMultiply.
-// - v0.52: (2017/09/26) fixes for imgui internal changes.
-// - v0.53: (2017/10/22) minor inconsequential change to match change in master (removed an unnecessary statement).
-// - v0.54: (2018/01/22) fix for addition of ImFontAtlas::TexUvscale member.
-// - v0.55: (2018/02/04) moved to main imgui repository (away from http://www.github.com/ocornut/imgui_club)
-// - v0.56: (2018/06/08) added support for ImFontConfig::GlyphMinAdvanceX, GlyphMaxAdvanceX.
-// - v0.60: (2019/01/10) re-factored to match big update in STB builder. fixed texture height waste. fixed redundant glyphs when merging. support for glyph padding.
-// - v0.61: (2019/01/15) added support for imgui allocators + added FreeType only override function SetAllocatorFunctions().
-// - v0.62: (2019/02/09) added RasterizerFlags::Monochrome flag to disable font anti-aliasing (combine with ::MonoHinting for best results!)
-// - v0.63: (2020/06/04) fix for rare case where FT_Get_Char_Index() succeed but FT_Load_Glyph() fails.
+// Get the latest version at https://github.com/ocornut/imgui/tree/master/misc/freetype
+// Original code by @vuhdo (Aleksei Skriabin). Improvements by @mikesart. Maintained since 2019 by @ocornut.
 
-// Gamma Correct Blending:
-//  FreeType assumes blending in linear space rather than gamma space.
-//  See https://www.freetype.org/freetype2/docs/reference/ft2-base_interface.html#FT_Render_Glyph
-//  For correct results you need to be using sRGB and convert to linear space in the pixel shader output.
-//  The default imgui styles will be impacted by this change (alpha values will need tweaking).
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2021/03/05: added ImGuiFreeTypeBuilderFlags_Bitmap to load bitmap glyphs.
+//  2021/03/02: set 'atlas->TexPixelsUseColors = true' to help some backends with deciding of a prefered texture format.
+//  2021/01/28: added support for color-layered glyphs via ImGuiFreeTypeBuilderFlags_LoadColor (require Freetype 2.10+).
+//  2021/01/26: simplified integration by using '#define IMGUI_ENABLE_FREETYPE'.
+//              renamed ImGuiFreeType::XXX flags to ImGuiFreeTypeBuilderFlags_XXX for consistency with other API. removed ImGuiFreeType::BuildFontAtlas().
+//  2020/06/04: fix for rare case where FT_Get_Char_Index() succeed but FT_Load_Glyph() fails.
+//  2019/02/09: added RasterizerFlags::Monochrome flag to disable font anti-aliasing (combine with ::MonoHinting for best results!)
+//  2019/01/15: added support for imgui allocators + added FreeType only override function SetAllocatorFunctions().
+//  2019/01/10: re-factored to match big update in STB builder. fixed texture height waste. fixed redundant glyphs when merging. support for glyph padding.
+//  2018/06/08: added support for ImFontConfig::GlyphMinAdvanceX, GlyphMaxAdvanceX.
+//  2018/02/04: moved to main imgui repository (away from http://www.github.com/ocornut/imgui_club)
+//  2018/01/22: fix for addition of ImFontAtlas::TexUvscale member.
+//  2017/10/22: minor inconsequential change to match change in master (removed an unnecessary statement).
+//  2017/09/26: fixes for imgui internal changes.
+//  2017/08/26: cleanup, optimizations, support for ImFontConfig::RasterizerFlags, ImFontConfig::RasterizerMultiply.
+//  2017/08/16: imported from https://github.com/Vuhdo/imgui_freetype into http://www.github.com/ocornut/imgui_club, updated for latest changes in ImFontAtlas, minor tweaks.
+
+// About Gamma Correct Blending:
+// - FreeType assumes blending in linear space rather than gamma space.
+// - See https://www.freetype.org/freetype2/docs/reference/ft2-base_interface.html#FT_Render_Glyph
+// - For correct results you need to be using sRGB and convert to linear space in the pixel shader output.
+// - The default dear imgui styles will be impacted by this change (alpha values will need tweaking).
 
 // FIXME: cfg.OversampleH, OversampleV are not supported (but perhaps not so necessary with this rasterizer).
 
@@ -33,7 +41,8 @@
 #include FT_SYNTHESIS_H         // <freetype/ftsynth.h>
 
 #ifdef _MSC_VER
-#pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff)
+#pragma warning (disable: 4505)     // unreferenced local function has been removed (stb stuff)
+#pragma warning (disable: 26812)    // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
 #endif
 
 #if defined(__GNUC__)
@@ -41,6 +50,23 @@
 #pragma GCC diagnostic ignored "-Wunused-function"          // warning: 'xxxx' defined but not used
 #endif
 
+//-------------------------------------------------------------------------
+// Data
+//-------------------------------------------------------------------------
+
+// Default memory allocators
+static void* ImGuiFreeTypeDefaultAllocFunc(size_t size, void* user_data) { IM_UNUSED(user_data); return IM_ALLOC(size); }
+static void  ImGuiFreeTypeDefaultFreeFunc(void* ptr, void* user_data) { IM_UNUSED(user_data); IM_FREE(ptr); }
+
+// Current memory allocators
+static void* (*GImGuiFreeTypeAllocFunc)(size_t size, void* user_data) = ImGuiFreeTypeDefaultAllocFunc;
+static void  (*GImGuiFreeTypeFreeFunc)(void* ptr, void* user_data) = ImGuiFreeTypeDefaultFreeFunc;
+static void* GImGuiFreeTypeAllocatorUserData = NULL;
+
+//-------------------------------------------------------------------------
+// Code
+//-------------------------------------------------------------------------
+
 namespace
 {
     // Glyph metrics:
@@ -74,7 +100,7 @@ namespace
     //              |                                   |
     //              |------------- advanceX ----------->|
 
-    /// A structure that describe a glyph.
+    // A structure that describe a glyph.
     struct GlyphInfo
     {
         int         Width;              // Glyph's width in pixels.
@@ -82,6 +108,7 @@ namespace
         FT_Int      OffsetX;            // The distance from the origin ("pen position") to the left of the glyph.
         FT_Int      OffsetY;            // The distance from the origin to the top of the glyph. This is usually a value < 0.
         float       AdvanceX;           // The distance from the origin to the origin of the next glyph. This is usually a value > 0.
+        bool        IsColored;          // The glyph is colored
     };
 
     // Font parameters and metrics.
@@ -104,7 +131,7 @@ namespace
         void                    SetPixelHeight(int pixel_height); // Change font pixel size. All following calls to RasterizeGlyph() will use this size
         const FT_Glyph_Metrics* LoadGlyph(uint32_t in_codepoint);
         const FT_Bitmap*        RenderGlyphAndGetInfo(GlyphInfo* out_glyph_info);
-        void                    BlitGlyph(const FT_Bitmap* ft_bitmap, uint8_t* dst, uint32_t dst_pitch, unsigned char* multiply_table = NULL);
+        void                    BlitGlyph(const FT_Bitmap* ft_bitmap, uint32_t* dst, uint32_t dst_pitch, unsigned char* multiply_table = NULL);
         ~FreeTypeFont()         { CloseFont(); }
 
         // [Internals]
@@ -118,7 +145,7 @@ namespace
     // From SDL_ttf: Handy routines for converting from fixed point
     #define FT_CEIL(X)  (((X + 63) & -64) / 64)
 
-    bool FreeTypeFont::InitFont(FT_Library ft_library, const ImFontConfig& cfg, unsigned int extra_user_flags)
+    bool FreeTypeFont::InitFont(FT_Library ft_library, const ImFontConfig& cfg, unsigned int extra_font_builder_flags)
     {
         FT_Error error = FT_New_Memory_Face(ft_library, (uint8_t*)cfg.FontData, (uint32_t)cfg.FontDataSize, (uint32_t)cfg.FontNo, &Face);
         if (error != 0)
@@ -127,30 +154,37 @@ namespace
         if (error != 0)
             return false;
 
-        memset(&Info, 0, sizeof(Info));
-        SetPixelHeight((uint32_t)cfg.SizePixels);
-
         // Convert to FreeType flags (NB: Bold and Oblique are processed separately)
-        UserFlags = cfg.RasterizerFlags | extra_user_flags;
-        LoadFlags = FT_LOAD_NO_BITMAP;
-        if (UserFlags & ImGuiFreeType::NoHinting)
+        UserFlags = cfg.FontBuilderFlags | extra_font_builder_flags;
+
+        LoadFlags = 0;
+        if ((UserFlags & ImGuiFreeTypeBuilderFlags_Bitmap) == 0)
+            LoadFlags |= FT_LOAD_NO_BITMAP;
+
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_NoHinting)
             LoadFlags |= FT_LOAD_NO_HINTING;
-        if (UserFlags & ImGuiFreeType::NoAutoHint)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_NoAutoHint)
             LoadFlags |= FT_LOAD_NO_AUTOHINT;
-        if (UserFlags & ImGuiFreeType::ForceAutoHint)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_ForceAutoHint)
             LoadFlags |= FT_LOAD_FORCE_AUTOHINT;
-        if (UserFlags & ImGuiFreeType::LightHinting)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_LightHinting)
             LoadFlags |= FT_LOAD_TARGET_LIGHT;
-        else if (UserFlags & ImGuiFreeType::MonoHinting)
+        else if (UserFlags & ImGuiFreeTypeBuilderFlags_MonoHinting)
             LoadFlags |= FT_LOAD_TARGET_MONO;
         else
             LoadFlags |= FT_LOAD_TARGET_NORMAL;
 
-        if (UserFlags & ImGuiFreeType::Monochrome)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_Monochrome)
             RenderMode = FT_RENDER_MODE_MONO;
         else
             RenderMode = FT_RENDER_MODE_NORMAL;
 
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_LoadColor)
+            LoadFlags |= FT_LOAD_COLOR;
+
+        memset(&Info, 0, sizeof(Info));
+        SetPixelHeight((uint32_t)cfg.SizePixels);
+
         return true;
     }
 
@@ -169,7 +203,7 @@ namespace
         // is a maximum height of an any given glyph, i.e. it's the sum of font's ascender and descender. Seems strange to me.
         // NB: FT_Set_Pixel_Sizes() doesn't seem to get us the same result.
         FT_Size_RequestRec req;
-        req.type = FT_SIZE_REQUEST_TYPE_REAL_DIM;
+        req.type = (UserFlags & ImGuiFreeTypeBuilderFlags_Bitmap) ? FT_SIZE_REQUEST_TYPE_NOMINAL : FT_SIZE_REQUEST_TYPE_REAL_DIM;
         req.width = 0;
         req.height = (uint32_t)pixel_height * 64;
         req.horiResolution = 0;
@@ -197,12 +231,12 @@ namespace
 
         // Need an outline for this to work
         FT_GlyphSlot slot = Face->glyph;
-        IM_ASSERT(slot->format == FT_GLYPH_FORMAT_OUTLINE);
+        IM_ASSERT(slot->format == FT_GLYPH_FORMAT_OUTLINE || slot->format == FT_GLYPH_FORMAT_BITMAP);
 
         // Apply convenience transform (this is not picking from real "Bold"/"Italic" fonts! Merely applying FreeType helper transform. Oblique == Slanting)
-        if (UserFlags & ImGuiFreeType::Bold)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_Bold)
             FT_GlyphSlot_Embolden(slot);
-        if (UserFlags & ImGuiFreeType::Oblique)
+        if (UserFlags & ImGuiFreeTypeBuilderFlags_Oblique)
         {
             FT_GlyphSlot_Oblique(slot);
             //FT_BBox bbox;
@@ -227,11 +261,12 @@ namespace
         out_glyph_info->OffsetX = Face->glyph->bitmap_left;
         out_glyph_info->OffsetY = -Face->glyph->bitmap_top;
         out_glyph_info->AdvanceX = (float)FT_CEIL(slot->advance.x);
+        out_glyph_info->IsColored = (ft_bitmap->pixel_mode == FT_PIXEL_MODE_BGRA);
 
         return ft_bitmap;
     }
 
-    void FreeTypeFont::BlitGlyph(const FT_Bitmap* ft_bitmap, uint8_t* dst, uint32_t dst_pitch, unsigned char* multiply_table)
+    void FreeTypeFont::BlitGlyph(const FT_Bitmap* ft_bitmap, uint32_t* dst, uint32_t dst_pitch, unsigned char* multiply_table)
     {
         IM_ASSERT(ft_bitmap != NULL);
         const uint32_t w = ft_bitmap->width;
@@ -246,13 +281,14 @@ namespace
                 if (multiply_table == NULL)
                 {
                     for (uint32_t y = 0; y < h; y++, src += src_pitch, dst += dst_pitch)
-                        memcpy(dst, src, w);
+                        for (uint32_t x = 0; x < w; x++)
+                            dst[x] = IM_COL32(255, 255, 255, src[x]);
                 }
                 else
                 {
                     for (uint32_t y = 0; y < h; y++, src += src_pitch, dst += dst_pitch)
                         for (uint32_t x = 0; x < w; x++)
-                            dst[x] = multiply_table[src[x]];
+                            dst[x] = IM_COL32(255, 255, 255, multiply_table[src[x]]);
                 }
                 break;
             }
@@ -268,11 +304,38 @@ namespace
                     {
                         if ((x & 7) == 0)
                             bits = *bits_ptr++;
-                        dst[x] = (bits & 0x80) ? color1 : color0;
+                        dst[x] = IM_COL32(255, 255, 255, (bits & 0x80) ? color1 : color0);
                     }
                 }
                 break;
             }
+        case FT_PIXEL_MODE_BGRA:
+            {
+                // FIXME: Converting pre-multiplied alpha to straight. Doesn't smell good.
+                #define DE_MULTIPLY(color, alpha) (ImU32)(255.0f * (float)color / (float)alpha + 0.5f)
+                if (multiply_table == NULL)
+                {
+                    for (uint32_t y = 0; y < h; y++, src += src_pitch, dst += dst_pitch)
+                        for (uint32_t x = 0; x < w; x++)
+                        {
+                            uint8_t r = src[x * 4 + 2], g = src[x * 4 + 1], b = src[x * 4], a = src[x * 4 + 3];
+                            dst[x] = IM_COL32(DE_MULTIPLY(r, a), DE_MULTIPLY(g, a), DE_MULTIPLY(b, a), a);
+                        }
+                }
+                else
+                {
+                    for (uint32_t y = 0; y < h; y++, src += src_pitch, dst += dst_pitch)
+                    {
+                        for (uint32_t x = 0; x < w; x++)
+                        {
+                            uint8_t r = src[x * 4 + 2], g = src[x * 4 + 1], b = src[x * 4], a = src[x * 4 + 3];
+                            dst[x] = IM_COL32(multiply_table[DE_MULTIPLY(r, a)], multiply_table[DE_MULTIPLY(g, a)], multiply_table[DE_MULTIPLY(b, a)], multiply_table[a]);
+                        }
+                    }
+                }
+                #undef DE_MULTIPLY
+                break;
+            }
         default:
             IM_ASSERT(0 && "FreeTypeFont::BlitGlyph(): Unknown bitmap pixel mode!");
         }
@@ -296,7 +359,9 @@ struct ImFontBuildSrcGlyphFT
 {
     GlyphInfo           Info;
     uint32_t            Codepoint;
-    unsigned char*      BitmapData;         // Point within one of the dst_tmp_bitmap_buffers[] array
+    unsigned int*       BitmapData;         // Point within one of the dst_tmp_bitmap_buffers[] array
+
+    ImFontBuildSrcGlyphFT() { memset(this, 0, sizeof(*this)); }
 };
 
 struct ImFontBuildSrcDataFT
@@ -320,7 +385,7 @@ struct ImFontBuildDstDataFT
     ImBitVector         GlyphsSet;          // This is used to resolve collision when multiple sources are merged into a same destination font.
 };
 
-bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, unsigned int extra_flags)
+bool ImFontAtlasBuildWithFreeTypeEx(FT_Library ft_library, ImFontAtlas* atlas, unsigned int extra_flags)
 {
     IM_ASSERT(atlas->ConfigData.Size > 0);
 
@@ -334,6 +399,7 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
     atlas->ClearTexData();
 
     // Temporary storage for building
+    bool src_load_color = false;
     ImVector<ImFontBuildSrcDataFT> src_tmp_array;
     ImVector<ImFontBuildDstDataFT> dst_tmp_array;
     src_tmp_array.resize(atlas->ConfigData.Size);
@@ -363,6 +429,7 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
             return false;
 
         // Measure highest codepoints
+        src_load_color |= (cfg.FontBuilderFlags & ImGuiFreeTypeBuilderFlags_LoadColor) != 0;
         ImFontBuildDstDataFT& dst_tmp = dst_tmp_array[src_tmp.DstIndex];
         src_tmp.SrcRanges = cfg.GlyphRanges ? cfg.GlyphRanges : atlas->GetGlyphRangesDefault();
         for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2)
@@ -414,7 +481,6 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
                     if (entries_32 & ((ImU32)1 << bit_n))
                     {
                         ImFontBuildSrcGlyphFT src_glyph;
-                        memset(&src_glyph, 0, sizeof(src_glyph));
                         src_glyph.Codepoint = (ImWchar)(((it - it_begin) << 5) + bit_n);
                         //src_glyph.GlyphIndex = 0; // FIXME-OPT: We had this info in the previous step and lost it..
                         src_tmp.GlyphsList.push_back(src_glyph);
@@ -476,7 +542,7 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
             IM_ASSERT(ft_bitmap);
 
             // Allocate new temporary chunk if needed
-            const int bitmap_size_in_bytes = src_glyph.Info.Width * src_glyph.Info.Height;
+            const int bitmap_size_in_bytes = src_glyph.Info.Width * src_glyph.Info.Height * 4;
             if (buf_bitmap_current_used_bytes + bitmap_size_in_bytes > BITMAP_BUFFERS_CHUNK_SIZE)
             {
                 buf_bitmap_current_used_bytes = 0;
@@ -484,9 +550,9 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
             }
 
             // Blit rasterized pixels to our temporary buffer and keep a pointer to it.
-            src_glyph.BitmapData = buf_bitmap_buffers.back() + buf_bitmap_current_used_bytes;
+            src_glyph.BitmapData = (unsigned int*)(buf_bitmap_buffers.back() + buf_bitmap_current_used_bytes);
             buf_bitmap_current_used_bytes += bitmap_size_in_bytes;
-            src_tmp.Font.BlitGlyph(ft_bitmap, src_glyph.BitmapData, src_glyph.Info.Width * 1, multiply_enabled ? multiply_table : NULL);
+            src_tmp.Font.BlitGlyph(ft_bitmap, src_glyph.BitmapData, src_glyph.Info.Width, multiply_enabled ? multiply_table : NULL);
 
             src_tmp.Rects[glyph_i].w = (stbrp_coord)(src_glyph.Info.Width + padding);
             src_tmp.Rects[glyph_i].h = (stbrp_coord)(src_glyph.Info.Height + padding);
@@ -533,11 +599,22 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
     // 7. Allocate texture
     atlas->TexHeight = (atlas->Flags & ImFontAtlasFlags_NoPowerOfTwoHeight) ? (atlas->TexHeight + 1) : ImUpperPowerOfTwo(atlas->TexHeight);
     atlas->TexUvScale = ImVec2(1.0f / atlas->TexWidth, 1.0f / atlas->TexHeight);
-    atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(atlas->TexWidth * atlas->TexHeight);
-    memset(atlas->TexPixelsAlpha8, 0, atlas->TexWidth * atlas->TexHeight);
+    if (src_load_color)
+    {
+        size_t tex_size = (size_t)atlas->TexWidth * atlas->TexHeight * 4;
+        atlas->TexPixelsRGBA32 = (unsigned int*)IM_ALLOC(tex_size);
+        memset(atlas->TexPixelsRGBA32, 0, tex_size);
+    }
+    else
+    {
+        size_t tex_size = (size_t)atlas->TexWidth * atlas->TexHeight * 1;
+        atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(tex_size);
+        memset(atlas->TexPixelsAlpha8, 0, tex_size);
+    }
 
     // 8. Copy rasterized font characters back into the main texture
     // 9. Setup ImFont and glyphs for runtime
+    bool tex_use_colors = false;
     for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
     {
         ImFontBuildSrcDataFT& src_tmp = src_tmp_array[src_i];
@@ -571,14 +648,6 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
             const int tx = pack_rect.x + padding;
             const int ty = pack_rect.y + padding;
 
-            // Blit from temporary buffer to final texture
-            size_t blit_src_stride = (size_t)src_glyph.Info.Width;
-            size_t blit_dst_stride = (size_t)atlas->TexWidth;
-            unsigned char* blit_src = src_glyph.BitmapData;
-            unsigned char* blit_dst = atlas->TexPixelsAlpha8 + (ty * blit_dst_stride) + tx;
-            for (int y = info.Height; y > 0; y--, blit_dst += blit_dst_stride, blit_src += blit_src_stride)
-                memcpy(blit_dst, blit_src, blit_src_stride);
-
             // Register glyph
             float x0 = info.OffsetX + font_off_x;
             float y0 = info.OffsetY + font_off_y;
@@ -589,66 +658,81 @@ bool ImFontAtlasBuildWithFreeType(FT_Library ft_library, ImFontAtlas* atlas, uns
             float u1 = (tx + info.Width) / (float)atlas->TexWidth;
             float v1 = (ty + info.Height) / (float)atlas->TexHeight;
             dst_font->AddGlyph(&cfg, (ImWchar)src_glyph.Codepoint, x0, y0, x1, y1, u0, v0, u1, v1, info.AdvanceX);
+
+            ImFontGlyph* dst_glyph = &dst_font->Glyphs.back();
+            IM_ASSERT(dst_glyph->Codepoint == src_glyph.Codepoint);
+            if (src_glyph.Info.IsColored)
+                dst_glyph->Colored = tex_use_colors = true;
+
+            // Blit from temporary buffer to final texture
+            size_t blit_src_stride = (size_t)src_glyph.Info.Width;
+            size_t blit_dst_stride = (size_t)atlas->TexWidth;
+            unsigned int* blit_src = src_glyph.BitmapData;
+            if (atlas->TexPixelsAlpha8 != NULL)
+            {
+                unsigned char* blit_dst = atlas->TexPixelsAlpha8 + (ty * blit_dst_stride) + tx;
+                for (int y = 0; y < info.Height; y++, blit_dst += blit_dst_stride, blit_src += blit_src_stride)
+                    for (int x = 0; x < info.Width; x++)
+                        blit_dst[x] = (unsigned char)((blit_src[x] >> IM_COL32_A_SHIFT) & 0xFF);
+            }
+            else
+            {
+                unsigned int* blit_dst = atlas->TexPixelsRGBA32 + (ty * blit_dst_stride) + tx;
+                for (int y = 0; y < info.Height; y++, blit_dst += blit_dst_stride, blit_src += blit_src_stride)
+                    for (int x = 0; x < info.Width; x++)
+                        blit_dst[x] = blit_src[x];
+            }
         }
 
         src_tmp.Rects = NULL;
     }
+    atlas->TexPixelsUseColors = tex_use_colors;
 
     // Cleanup
     for (int buf_i = 0; buf_i < buf_bitmap_buffers.Size; buf_i++)
         IM_FREE(buf_bitmap_buffers[buf_i]);
-    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
-        src_tmp_array[src_i].~ImFontBuildSrcDataFT();
+    src_tmp_array.clear_destruct();
 
     ImFontAtlasBuildFinish(atlas);
 
     return true;
 }
 
-// Default memory allocators
-static void* ImFreeTypeDefaultAllocFunc(size_t size, void* user_data)   { IM_UNUSED(user_data); return IM_ALLOC(size); }
-static void  ImFreeTypeDefaultFreeFunc(void* ptr, void* user_data)      { IM_UNUSED(user_data); IM_FREE(ptr); }
-
-// Current memory allocators
-static void* (*GImFreeTypeAllocFunc)(size_t size, void* user_data) = ImFreeTypeDefaultAllocFunc;
-static void  (*GImFreeTypeFreeFunc)(void* ptr, void* user_data) = ImFreeTypeDefaultFreeFunc;
-static void* GImFreeTypeAllocatorUserData = NULL;
-
 // FreeType memory allocation callbacks
 static void* FreeType_Alloc(FT_Memory /*memory*/, long size)
 {
-    return GImFreeTypeAllocFunc((size_t)size, GImFreeTypeAllocatorUserData);
+    return GImGuiFreeTypeAllocFunc((size_t)size, GImGuiFreeTypeAllocatorUserData);
 }
 
 static void FreeType_Free(FT_Memory /*memory*/, void* block)
 {
-    GImFreeTypeFreeFunc(block, GImFreeTypeAllocatorUserData);
+    GImGuiFreeTypeFreeFunc(block, GImGuiFreeTypeAllocatorUserData);
 }
 
 static void* FreeType_Realloc(FT_Memory /*memory*/, long cur_size, long new_size, void* block)
 {
     // Implement realloc() as we don't ask user to provide it.
     if (block == NULL)
-        return GImFreeTypeAllocFunc((size_t)new_size, GImFreeTypeAllocatorUserData);
+        return GImGuiFreeTypeAllocFunc((size_t)new_size, GImGuiFreeTypeAllocatorUserData);
 
     if (new_size == 0)
     {
-        GImFreeTypeFreeFunc(block, GImFreeTypeAllocatorUserData);
+        GImGuiFreeTypeFreeFunc(block, GImGuiFreeTypeAllocatorUserData);
         return NULL;
     }
 
     if (new_size > cur_size)
     {
-        void* new_block = GImFreeTypeAllocFunc((size_t)new_size, GImFreeTypeAllocatorUserData);
+        void* new_block = GImGuiFreeTypeAllocFunc((size_t)new_size, GImGuiFreeTypeAllocatorUserData);
         memcpy(new_block, block, (size_t)cur_size);
-        GImFreeTypeFreeFunc(block, GImFreeTypeAllocatorUserData);
+        GImGuiFreeTypeFreeFunc(block, GImGuiFreeTypeAllocatorUserData);
         return new_block;
     }
 
     return block;
 }
 
-bool ImGuiFreeType::BuildFontAtlas(ImFontAtlas* atlas, unsigned int extra_flags)
+static bool ImFontAtlasBuildWithFreeType(ImFontAtlas* atlas)
 {
     // FreeType memory management: https://www.freetype.org/freetype2/docs/design/design-4.html
     FT_MemoryRec_ memory_rec = {};
@@ -666,15 +750,22 @@ bool ImGuiFreeType::BuildFontAtlas(ImFontAtlas* atlas, unsigned int extra_flags)
     // If you don't call FT_Add_Default_Modules() the rest of code may work, but FreeType won't use our custom allocator.
     FT_Add_Default_Modules(ft_library);
 
-    bool ret = ImFontAtlasBuildWithFreeType(ft_library, atlas, extra_flags);
+    bool ret = ImFontAtlasBuildWithFreeTypeEx(ft_library, atlas, atlas->FontBuilderFlags);
     FT_Done_Library(ft_library);
 
     return ret;
 }
 
+const ImFontBuilderIO* ImGuiFreeType::GetBuilderForFreeType()
+{
+    static ImFontBuilderIO io;
+    io.FontBuilder_Build = ImFontAtlasBuildWithFreeType;
+    return &io;
+}
+
 void ImGuiFreeType::SetAllocatorFunctions(void* (*alloc_func)(size_t sz, void* user_data), void (*free_func)(void* ptr, void* user_data), void* user_data)
 {
-    GImFreeTypeAllocFunc = alloc_func;
-    GImFreeTypeFreeFunc = free_func;
-    GImFreeTypeAllocatorUserData = user_data;
+    GImGuiFreeTypeAllocFunc = alloc_func;
+    GImGuiFreeTypeFreeFunc = free_func;
+    GImGuiFreeTypeAllocatorUserData = user_data;
 }

lib/external/imgui/source/imgui_impl_glfw.cpp

@@ -1,5 +1,5 @@
 // dear imgui: Platform Backend for GLFW
-// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan..)
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
 // (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
 // (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)
 
@@ -13,13 +13,17 @@
 // Issues:
 //  [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
 
-// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
 // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
 // Read online: https://github.com/ocornut/imgui/tree/master/docs
 
 // CHANGELOG
 // (minor and older changes stripped away, please see git history for details)
 //  2021-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
+//  2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
+//  2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
 //  2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
 //  2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
 //  2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
@@ -43,6 +47,7 @@
 //  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
 
 #include "imgui.h"
+#include "imgui_internal.h"
 #include "imgui_impl_glfw.h"
 
 // GLFW
@@ -72,33 +77,56 @@
 #define GLFW_HAS_MOUSE_PASSTHROUGH    (0)
 #endif
 
-// Data
+// GLFW data
 enum GlfwClientApi
 {
     GlfwClientApi_Unknown,
     GlfwClientApi_OpenGL,
     GlfwClientApi_Vulkan
 };
-static GLFWwindow*          g_Window = NULL;    // Main window
-static GlfwClientApi        g_ClientApi = GlfwClientApi_Unknown;
-static double               g_Time = 0.0;
-static bool                 g_MouseJustPressed[ImGuiMouseButton_COUNT] = {};
-static GLFWcursor*          g_MouseCursors[ImGuiMouseCursor_COUNT] = {};
-static bool                 g_InstalledCallbacks = false;
-static bool                 g_WantUpdateMonitors = true;
 
-// Chain GLFW callbacks for main viewport: our callbacks will call the user's previously installed callbacks, if any.
-static GLFWmousebuttonfun   g_PrevUserCallbackMousebutton = NULL;
-static GLFWscrollfun        g_PrevUserCallbackScroll = NULL;
-static GLFWkeyfun           g_PrevUserCallbackKey = NULL;
-static GLFWcharfun          g_PrevUserCallbackChar = NULL;
-static GLFWmonitorfun       g_PrevUserCallbackMonitor = NULL;
+struct ImGui_ImplGlfw_Data
+{
+    GLFWwindow*             Window;
+    GlfwClientApi           ClientApi;
+    double                  Time;
+    GLFWwindow*             MouseWindow;
+    bool                    MouseJustPressed[ImGuiMouseButton_COUNT];
+    GLFWcursor*             MouseCursors[ImGuiMouseCursor_COUNT];
+    GLFWwindow*             KeyOwnerWindows[512];
+    bool                    InstalledCallbacks;
+    bool                    WantUpdateMonitors;
+
+    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+    GLFWwindowfocusfun      PrevUserCallbackWindowFocus;
+    GLFWcursorenterfun      PrevUserCallbackCursorEnter;
+    GLFWmousebuttonfun      PrevUserCallbackMousebutton;
+    GLFWscrollfun           PrevUserCallbackScroll;
+    GLFWkeyfun              PrevUserCallbackKey;
+    GLFWcharfun             PrevUserCallbackChar;
+    GLFWmonitorfun          PrevUserCallbackMonitor;
+
+    ImGui_ImplGlfw_Data()   { memset(this, 0, sizeof(*this)); }
+};
+
+// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
+// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
+//   (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
+// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
+// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
+static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : NULL;
+}
 
 // Forward Declarations
 static void ImGui_ImplGlfw_UpdateMonitors();
 static void ImGui_ImplGlfw_InitPlatformInterface();
 static void ImGui_ImplGlfw_ShutdownPlatformInterface();
 
+// Functions
 static const char* ImGui_ImplGlfw_GetClipboardText(void* user_data)
 {
     return glfwGetClipboardString((GLFWwindow*)user_data);
@@ -109,19 +137,66 @@ static void ImGui_ImplGlfw_SetClipboardText(void* user_data, const char* text)
     glfwSetClipboardString((GLFWwindow*)user_data, text);
 }
 
+#if defined(OS_WINDOWS)
+    static const char* ImGui_ImplWin_GetClipboardText(void*)
+    {
+        ImGuiContext& g = *GImGui;
+        g.ClipboardHandlerData.clear();
+        if (!::OpenClipboard(NULL))
+            return NULL;
+        HANDLE wbuf_handle = ::GetClipboardData(CF_UNICODETEXT);
+        if (wbuf_handle == NULL)
+        {
+            ::CloseClipboard();
+            return NULL;
+        }
+        if (const WCHAR* wbuf_global = (const WCHAR*)::GlobalLock(wbuf_handle))
+        {
+            int buf_len = ::WideCharToMultiByte(CP_UTF8, 0, wbuf_global, -1, NULL, 0, NULL, NULL);
+            g.ClipboardHandlerData.resize(buf_len);
+            ::WideCharToMultiByte(CP_UTF8, 0, wbuf_global, -1, g.ClipboardHandlerData.Data, buf_len, NULL, NULL);
+        }
+        ::GlobalUnlock(wbuf_handle);
+        ::CloseClipboard();
+        return g.ClipboardHandlerData.Data;
+    }
+
+    static void ImGui_ImplWin_SetClipboardText(void*, const char* text)
+    {
+        if (!::OpenClipboard(NULL))
+            return;
+        const int wbuf_length = ::MultiByteToWideChar(CP_UTF8, 0, text, -1, NULL, 0);
+        HGLOBAL wbuf_handle = ::GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)wbuf_length * sizeof(WCHAR));
+        if (wbuf_handle == NULL)
+        {
+            ::CloseClipboard();
+            return;
+        }
+        WCHAR* wbuf_global = (WCHAR*)::GlobalLock(wbuf_handle);
+        ::MultiByteToWideChar(CP_UTF8, 0, text, -1, wbuf_global, wbuf_length);
+        ::GlobalUnlock(wbuf_handle);
+        ::EmptyClipboard();
+        if (::SetClipboardData(CF_UNICODETEXT, wbuf_handle) == NULL)
+            ::GlobalFree(wbuf_handle);
+        ::CloseClipboard();
+    }
+#endif
+
 void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
 {
-    if (g_PrevUserCallbackMousebutton != NULL && window == g_Window)
-        g_PrevUserCallbackMousebutton(window, button, action, mods);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackMousebutton != NULL && window == bd->Window)
+        bd->PrevUserCallbackMousebutton(window, button, action, mods);
 
-    if (action == GLFW_PRESS && button >= 0 && button < IM_ARRAYSIZE(g_MouseJustPressed))
-        g_MouseJustPressed[button] = true;
+    if (action == GLFW_PRESS && button >= 0 && button < IM_ARRAYSIZE(bd->MouseJustPressed))
+        bd->MouseJustPressed[button] = true;
 }
 
 void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
 {
-    if (g_PrevUserCallbackScroll != NULL && window == g_Window)
-        g_PrevUserCallbackScroll(window, xoffset, yoffset);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackScroll != NULL && window == bd->Window)
+        bd->PrevUserCallbackScroll(window, xoffset, yoffset);
 
     ImGuiIO& io = ImGui::GetIO();
     io.MouseWheelH += (float)xoffset;
@@ -130,14 +205,24 @@ void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yo
 
 void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
-    if (g_PrevUserCallbackKey != NULL && window == g_Window)
-        g_PrevUserCallbackKey(window, key, scancode, action, mods);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackKey != NULL && window == bd->Window)
+        bd->PrevUserCallbackKey(window, key, scancode, action, mods);
 
     ImGuiIO& io = ImGui::GetIO();
-    if (action == GLFW_PRESS)
-        io.KeysDown[key] = true;
-    if (action == GLFW_RELEASE)
-        io.KeysDown[key] = false;
+    if (key >= 0 && key < IM_ARRAYSIZE(io.KeysDown))
+    {
+        if (action == GLFW_PRESS)
+        {
+            io.KeysDown[key] = true;
+            bd->KeyOwnerWindows[key] = window;
+        }
+        if (action == GLFW_RELEASE)
+        {
+            io.KeysDown[key] = false;
+            bd->KeyOwnerWindows[key] = NULL;
+        }
+    }
 
     // Modifiers are not reliable across systems
     io.KeyCtrl = io.KeysDown[GLFW_KEY_LEFT_CONTROL] || io.KeysDown[GLFW_KEY_RIGHT_CONTROL];
@@ -150,10 +235,33 @@ void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int a
 #endif
 }
 
+void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackWindowFocus != NULL && window == bd->Window)
+        bd->PrevUserCallbackWindowFocus(window, focused);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddFocusEvent(focused != 0);
+}
+
+void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackCursorEnter != NULL && window == bd->Window)
+        bd->PrevUserCallbackCursorEnter(window, entered);
+
+    if (entered)
+        bd->MouseWindow = window;
+    if (!entered && bd->MouseWindow == window)
+        bd->MouseWindow = NULL;
+}
+
 void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
 {
-    if (g_PrevUserCallbackChar != NULL && window == g_Window)
-        g_PrevUserCallbackChar(window, c);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackChar != NULL && window == bd->Window)
+        bd->PrevUserCallbackChar(window, c);
 
     ImGuiIO& io = ImGui::GetIO();
     io.AddInputCharacter(c);
@@ -161,25 +269,31 @@ void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
 
 void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
 {
-    g_WantUpdateMonitors = true;
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    bd->WantUpdateMonitors = true;
 }
 
 static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
 {
-    g_Window = window;
-    g_Time = 0.0;
+    ImGuiIO& io = ImGui::GetIO();
+    IM_ASSERT(io.BackendPlatformUserData == NULL && "Already initialized a platform backend!");
 
     // Setup backend capabilities flags
-    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplGlfw_Data* bd = IM_NEW(ImGui_ImplGlfw_Data)();
+    io.BackendPlatformUserData = (void*)bd;
+    io.BackendPlatformName = "imgui_impl_glfw";
     io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
     io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
     io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports;    // We can create multi-viewports on the Platform side (optional)
 #if GLFW_HAS_MOUSE_PASSTHROUGH || (GLFW_HAS_WINDOW_HOVERED && defined(_WIN32))
     io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can set io.MouseHoveredViewport correctly (optional, not easy)
 #endif
-    io.BackendPlatformName = "imgui_impl_glfw";
 
-    // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
+    bd->Window = window;
+    bd->Time = 0.0;
+    bd->WantUpdateMonitors = true;
+
+    // Keyboard mapping. Dear ImGui will use those indices to peek into the io.KeysDown[] array.
     io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;
     io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
     io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
@@ -203,47 +317,56 @@ static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, Glfw
     io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
     io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;
 
-    io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
-    io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
-    io.ClipboardUserData = g_Window;
+    #if defined(OS_WINDOWS)
+        io.SetClipboardTextFn = ImGui_ImplWin_SetClipboardText;
+        io.GetClipboardTextFn = ImGui_ImplWin_GetClipboardText;
+        io.ClipboardUserData = bd->Window;
+    #else
+        io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
+        io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
+        io.ClipboardUserData = bd->Window;
+    #endif
 
     // Create mouse cursors
     // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
     // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
     // Missing cursors will return NULL and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
     GLFWerrorfun prev_error_callback = glfwSetErrorCallback(NULL);
-    g_MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
 #if GLFW_HAS_NEW_CURSORS
-    g_MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
 #else
-    g_MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    g_MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
 #endif
     glfwSetErrorCallback(prev_error_callback);
 
     // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
-    g_PrevUserCallbackMousebutton = NULL;
-    g_PrevUserCallbackScroll = NULL;
-    g_PrevUserCallbackKey = NULL;
-    g_PrevUserCallbackChar = NULL;
-    g_PrevUserCallbackMonitor = NULL;
+    bd->PrevUserCallbackWindowFocus = NULL;
+    bd->PrevUserCallbackMousebutton = NULL;
+    bd->PrevUserCallbackScroll = NULL;
+    bd->PrevUserCallbackKey = NULL;
+    bd->PrevUserCallbackChar = NULL;
+    bd->PrevUserCallbackMonitor = NULL;
     if (install_callbacks)
     {
-        g_InstalledCallbacks = true;
-        g_PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
-        g_PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
-        g_PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
-        g_PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
-        g_PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
+        bd->InstalledCallbacks = true;
+        bd->PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback(window, ImGui_ImplGlfw_WindowFocusCallback);
+        bd->PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, ImGui_ImplGlfw_CursorEnterCallback);
+        bd->PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
+        bd->PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
+        bd->PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
+        bd->PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
+        bd->PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
     }
 
     // Update monitors the first time (note: monitor callback are broken in GLFW 3.2 and earlier, see github.com/glfw/glfw/issues/784)
@@ -252,14 +375,14 @@ static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, Glfw
 
     // Our mouse update function expect PlatformHandle to be filled for the main viewport
     ImGuiViewport* main_viewport = ImGui::GetMainViewport();
-    main_viewport->PlatformHandle = (void*)g_Window;
+    main_viewport->PlatformHandle = (void*)bd->Window;
 #ifdef _WIN32
-    main_viewport->PlatformHandleRaw = glfwGetWin32Window(g_Window);
+    main_viewport->PlatformHandleRaw = glfwGetWin32Window(bd->Window);
 #endif
     if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
         ImGui_ImplGlfw_InitPlatformInterface();
 
-    g_ClientApi = client_api;
+    bd->ClientApi = client_api;
     return true;
 }
 
@@ -273,79 +396,94 @@ bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
     return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
 }
 
+bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Unknown);
+}
+
 void ImGui_ImplGlfw_Shutdown()
 {
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+
     ImGui_ImplGlfw_ShutdownPlatformInterface();
 
-    if (g_InstalledCallbacks)
+    if (bd->InstalledCallbacks)
     {
-        glfwSetMouseButtonCallback(g_Window, g_PrevUserCallbackMousebutton);
-        glfwSetScrollCallback(g_Window, g_PrevUserCallbackScroll);
-        glfwSetKeyCallback(g_Window, g_PrevUserCallbackKey);
-        glfwSetCharCallback(g_Window, g_PrevUserCallbackChar);
-        g_InstalledCallbacks = false;
+        glfwSetWindowFocusCallback(bd->Window, bd->PrevUserCallbackWindowFocus);
+        glfwSetCursorEnterCallback(bd->Window, bd->PrevUserCallbackCursorEnter);
+        glfwSetMouseButtonCallback(bd->Window, bd->PrevUserCallbackMousebutton);
+        glfwSetScrollCallback(bd->Window, bd->PrevUserCallbackScroll);
+        glfwSetKeyCallback(bd->Window, bd->PrevUserCallbackKey);
+        glfwSetCharCallback(bd->Window, bd->PrevUserCallbackChar);
+        glfwSetMonitorCallback(bd->PrevUserCallbackMonitor);
     }
 
     for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
-    {
-        glfwDestroyCursor(g_MouseCursors[cursor_n]);
-        g_MouseCursors[cursor_n] = NULL;
-    }
-    g_ClientApi = GlfwClientApi_Unknown;
+        glfwDestroyCursor(bd->MouseCursors[cursor_n]);
+
+    io.BackendPlatformName = NULL;
+    io.BackendPlatformUserData = NULL;
+    IM_DELETE(bd);
 }
 
 static void ImGui_ImplGlfw_UpdateMousePosAndButtons()
 {
-    // Update buttons
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
     ImGuiIO& io = ImGui::GetIO();
-    for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++)
-    {
-        // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
-        io.MouseDown[i] = g_MouseJustPressed[i] || glfwGetMouseButton(g_Window, i) != 0;
-        g_MouseJustPressed[i] = false;
-    }
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
 
-    // Update mouse position
-    const ImVec2 mouse_pos_backup = io.MousePos;
+    const ImVec2 mouse_pos_prev = io.MousePos;
     io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
     io.MouseHoveredViewport = 0;
-    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+
+    // Update mouse buttons
+    // (if a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame)
+    for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++)
+    {
+        io.MouseDown[i] = bd->MouseJustPressed[i] || glfwGetMouseButton(bd->Window, i) != 0;
+        bd->MouseJustPressed[i] = false;
+    }
+
     for (int n = 0; n < platform_io.Viewports.Size; n++)
     {
         ImGuiViewport* viewport = platform_io.Viewports[n];
         GLFWwindow* window = (GLFWwindow*)viewport->PlatformHandle;
-        IM_ASSERT(window != NULL);
+
 #ifdef __EMSCRIPTEN__
         const bool focused = true;
-        IM_ASSERT(platform_io.Viewports.Size == 1);
 #else
         const bool focused = glfwGetWindowAttrib(window, GLFW_FOCUSED) != 0;
 #endif
+        GLFWwindow* mouse_window = (bd->MouseWindow == window || focused) ? window : NULL;
+
+        // Update mouse buttons
         if (focused)
+            for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++)
+                io.MouseDown[i] |= glfwGetMouseButton(window, i) != 0;
+
+        // Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
+        // (When multi-viewports are enabled, all Dear ImGui positions are same as OS positions)
+        if (io.WantSetMousePos && focused)
+            glfwSetCursorPos(window, (double)(mouse_pos_prev.x - viewport->Pos.x), (double)(mouse_pos_prev.y - viewport->Pos.y));
+
+        // Set Dear ImGui mouse position from OS position
+        if (mouse_window != NULL)
         {
-            if (io.WantSetMousePos)
+            double mouse_x, mouse_y;
+            glfwGetCursorPos(mouse_window, &mouse_x, &mouse_y);
+            if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
             {
-                glfwSetCursorPos(window, (double)(mouse_pos_backup.x - viewport->Pos.x), (double)(mouse_pos_backup.y - viewport->Pos.y));
+                // Multi-viewport mode: mouse position in OS absolute coordinates (io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor)
+                int window_x, window_y;
+                glfwGetWindowPos(window, &window_x, &window_y);
+                io.MousePos = ImVec2((float)mouse_x + window_x, (float)mouse_y + window_y);
             }
             else
             {
-                double mouse_x, mouse_y;
-                glfwGetCursorPos(window, &mouse_x, &mouse_y);
-                if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
-                {
-                    // Multi-viewport mode: mouse position in OS absolute coordinates (io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor)
-                    int window_x, window_y;
-                    glfwGetWindowPos(window, &window_x, &window_y);
-                    io.MousePos = ImVec2((float)mouse_x + window_x, (float)mouse_y + window_y);
-                }
-                else
-                {
-                    // Single viewport mode: mouse position in client window coordinates (io.MousePos is (0,0) when the mouse is on the upper-left corner of the app window)
-                    io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);
-                }
+                // Single viewport mode: mouse position in client window coordinates (io.MousePos is (0,0) when the mouse is on the upper-left corner of the app window)
+                io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);
             }
-            for (int i = 0; i < IM_ARRAYSIZE(io.MouseDown); i++)
-                io.MouseDown[i] |= glfwGetMouseButton(window, i) != 0;
         }
 
         // (Optional) When using multiple viewports: set io.MouseHoveredViewport to the viewport the OS mouse cursor is hovering.
@@ -370,7 +508,8 @@ static void ImGui_ImplGlfw_UpdateMousePosAndButtons()
 static void ImGui_ImplGlfw_UpdateMouseCursor()
 {
     ImGuiIO& io = ImGui::GetIO();
-    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(g_Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
         return;
 
     ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
@@ -385,10 +524,12 @@ static void ImGui_ImplGlfw_UpdateMouseCursor()
         }
         else
         {
-            // Show OS mouse cursor
-            // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
-            glfwSetCursor(window, g_MouseCursors[imgui_cursor] ? g_MouseCursors[imgui_cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
-            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            #if !defined(OS_WINDOWS)
+                // Show OS mouse cursor
+                // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
+                glfwSetCursor(window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
+                glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            #endif
         }
     }
 }
@@ -432,6 +573,7 @@ static void ImGui_ImplGlfw_UpdateGamepads()
 
 static void ImGui_ImplGlfw_UpdateMonitors()
 {
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
     ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
     int monitors_count = 0;
     GLFWmonitor** glfw_monitors = glfwGetMonitors(&monitors_count);
@@ -461,29 +603,30 @@ static void ImGui_ImplGlfw_UpdateMonitors()
 #endif
         platform_io.Monitors.push_back(monitor);
     }
-    g_WantUpdateMonitors = false;
+    bd->WantUpdateMonitors = false;
 }
 
 void ImGui_ImplGlfw_NewFrame()
 {
     ImGuiIO& io = ImGui::GetIO();
-    IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer backend. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame().");
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd != NULL && "Did you call ImGui_ImplGlfw_InitForXXX()?");
 
     // Setup display size (every frame to accommodate for window resizing)
     int w, h;
     int display_w, display_h;
-    glfwGetWindowSize(g_Window, &w, &h);
-    glfwGetFramebufferSize(g_Window, &display_w, &display_h);
+    glfwGetWindowSize(bd->Window, &w, &h);
+    glfwGetFramebufferSize(bd->Window, &display_w, &display_h);
     io.DisplaySize = ImVec2((float)w, (float)h);
     if (w > 0 && h > 0)
         io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
-    if (g_WantUpdateMonitors)
+    if (bd->WantUpdateMonitors)
         ImGui_ImplGlfw_UpdateMonitors();
 
     // Setup time step
     double current_time = glfwGetTime();
-    io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f / 60.0f);
-    g_Time = current_time;
+    io.DeltaTime = bd->Time > 0.0 ? (float)(current_time - bd->Time) : (float)(1.0f / 60.0f);
+    bd->Time = current_time;
 
     ImGui_ImplGlfw_UpdateMousePosAndButtons();
     ImGui_ImplGlfw_UpdateMouseCursor();
@@ -499,15 +642,15 @@ void ImGui_ImplGlfw_NewFrame()
 //--------------------------------------------------------------------------------------------------------
 
 // Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data.
-struct ImGuiViewportDataGlfw
+struct ImGui_ImplGlfw_ViewportData
 {
     GLFWwindow* Window;
     bool        WindowOwned;
     int         IgnoreWindowPosEventFrame;
     int         IgnoreWindowSizeEventFrame;
 
-    ImGuiViewportDataGlfw()  { Window = NULL; WindowOwned = false; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; }
-    ~ImGuiViewportDataGlfw() { IM_ASSERT(Window == NULL); }
+    ImGui_ImplGlfw_ViewportData()  { Window = NULL; WindowOwned = false; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; }
+    ~ImGui_ImplGlfw_ViewportData() { IM_ASSERT(Window == NULL); }
 };
 
 static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window)
@@ -526,9 +669,9 @@ static void ImGui_ImplGlfw_WindowPosCallback(GLFWwindow* window, int, int)
 {
     if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
     {
-        if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData)
+        if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
         {
-            bool ignore_event = (ImGui::GetFrameCount() <= data->IgnoreWindowPosEventFrame + 1);
+            bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowPosEventFrame + 1);
             //data->IgnoreWindowPosEventFrame = -1;
             if (ignore_event)
                 return;
@@ -541,9 +684,9 @@ static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int)
 {
     if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
     {
-        if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData)
+        if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
         {
-            bool ignore_event = (ImGui::GetFrameCount() <= data->IgnoreWindowSizeEventFrame + 1);
+            bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowSizeEventFrame + 1);
             //data->IgnoreWindowSizeEventFrame = -1;
             if (ignore_event)
                 return;
@@ -554,58 +697,69 @@ static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int)
 
 static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = IM_NEW(ImGuiViewportDataGlfw)();
-    viewport->PlatformUserData = data;
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
+    viewport->PlatformUserData = vd;
 
     // GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED
     // With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem
     glfwWindowHint(GLFW_VISIBLE, false);
     glfwWindowHint(GLFW_FOCUSED, false);
 #if GLFW_HAS_FOCUS_ON_SHOW
-     glfwWindowHint(GLFW_FOCUS_ON_SHOW, false);
+    glfwWindowHint(GLFW_FOCUS_ON_SHOW, false);
  #endif
     glfwWindowHint(GLFW_DECORATED, (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? false : true);
 #if GLFW_HAS_WINDOW_TOPMOST
     glfwWindowHint(GLFW_FLOATING, (viewport->Flags & ImGuiViewportFlags_TopMost) ? true : false);
 #endif
-    GLFWwindow* share_window = (g_ClientApi == GlfwClientApi_OpenGL) ? g_Window : NULL;
-    data->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", NULL, share_window);
-    data->WindowOwned = true;
-    viewport->PlatformHandle = (void*)data->Window;
+    GLFWwindow* share_window = (bd->ClientApi == GlfwClientApi_OpenGL) ? bd->Window : NULL;
+    vd->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", NULL, share_window);
+    vd->WindowOwned = true;
+    viewport->PlatformHandle = (void*)vd->Window;
 #ifdef _WIN32
-    viewport->PlatformHandleRaw = glfwGetWin32Window(data->Window);
+    viewport->PlatformHandleRaw = glfwGetWin32Window(vd->Window);
 #endif
-    glfwSetWindowPos(data->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);
+    glfwSetWindowPos(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);
 
     // Install GLFW callbacks for secondary viewports
-    glfwSetMouseButtonCallback(data->Window, ImGui_ImplGlfw_MouseButtonCallback);
-    glfwSetScrollCallback(data->Window, ImGui_ImplGlfw_ScrollCallback);
-    glfwSetKeyCallback(data->Window, ImGui_ImplGlfw_KeyCallback);
-    glfwSetCharCallback(data->Window, ImGui_ImplGlfw_CharCallback);
-    glfwSetWindowCloseCallback(data->Window, ImGui_ImplGlfw_WindowCloseCallback);
-    glfwSetWindowPosCallback(data->Window, ImGui_ImplGlfw_WindowPosCallback);
-    glfwSetWindowSizeCallback(data->Window, ImGui_ImplGlfw_WindowSizeCallback);
-    if (g_ClientApi == GlfwClientApi_OpenGL)
+    glfwSetWindowFocusCallback(vd->Window, ImGui_ImplGlfw_WindowFocusCallback);
+    glfwSetCursorEnterCallback(vd->Window, ImGui_ImplGlfw_CursorEnterCallback);
+    glfwSetMouseButtonCallback(vd->Window, ImGui_ImplGlfw_MouseButtonCallback);
+    glfwSetScrollCallback(vd->Window, ImGui_ImplGlfw_ScrollCallback);
+    glfwSetKeyCallback(vd->Window, ImGui_ImplGlfw_KeyCallback);
+    glfwSetCharCallback(vd->Window, ImGui_ImplGlfw_CharCallback);
+    glfwSetWindowCloseCallback(vd->Window, ImGui_ImplGlfw_WindowCloseCallback);
+    glfwSetWindowPosCallback(vd->Window, ImGui_ImplGlfw_WindowPosCallback);
+    glfwSetWindowSizeCallback(vd->Window, ImGui_ImplGlfw_WindowSizeCallback);
+    if (bd->ClientApi == GlfwClientApi_OpenGL)
     {
-        glfwMakeContextCurrent(data->Window);
+        glfwMakeContextCurrent(vd->Window);
         glfwSwapInterval(0);
     }
 }
 
 static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport)
 {
-    if (ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData)
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
     {
-        if (data->WindowOwned)
+        if (vd->WindowOwned)
         {
 #if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
             HWND hwnd = (HWND)viewport->PlatformHandleRaw;
             ::RemovePropA(hwnd, "IMGUI_VIEWPORT");
 #endif
-            glfwDestroyWindow(data->Window);
+
+            // Release any keys that were pressed in the window being destroyed and are still held down,
+            // because we will not receive any release events after window is destroyed.
+            for (int i = 0; i < IM_ARRAYSIZE(bd->KeyOwnerWindows); i++)
+                if (bd->KeyOwnerWindows[i] == vd->Window)
+                    ImGui_ImplGlfw_KeyCallback(vd->Window, i, 0, GLFW_RELEASE, 0); // Later params are only used for main viewport, on which this function is never called.
+
+            glfwDestroyWindow(vd->Window);
         }
-        data->Window = NULL;
-        IM_DELETE(data);
+        vd->Window = NULL;
+        IM_DELETE(vd);
     }
     viewport->PlatformUserData = viewport->PlatformHandle = NULL;
 }
@@ -632,7 +786,7 @@ static LRESULT CALLBACK WndProcNoInputs(HWND hWnd, UINT msg, WPARAM wParam, LPAR
 
 static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
 
 #if defined(_WIN32)
     // GLFW hack: Hide icon from task bar
@@ -666,60 +820,60 @@ static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport)
 #endif
 #endif
 
-    glfwShowWindow(data->Window);
+    glfwShowWindow(vd->Window);
 }
 
 static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
     int x = 0, y = 0;
-    glfwGetWindowPos(data->Window, &x, &y);
+    glfwGetWindowPos(vd->Window, &x, &y);
     return ImVec2((float)x, (float)y);
 }
 
 static void ImGui_ImplGlfw_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    data->IgnoreWindowPosEventFrame = ImGui::GetFrameCount();
-    glfwSetWindowPos(data->Window, (int)pos.x, (int)pos.y);
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    vd->IgnoreWindowPosEventFrame = ImGui::GetFrameCount();
+    glfwSetWindowPos(vd->Window, (int)pos.x, (int)pos.y);
 }
 
 static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
     int w = 0, h = 0;
-    glfwGetWindowSize(data->Window, &w, &h);
+    glfwGetWindowSize(vd->Window, &w, &h);
     return ImVec2((float)w, (float)h);
 }
 
 static void ImGui_ImplGlfw_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
 #if __APPLE__ && !GLFW_HAS_OSX_WINDOW_POS_FIX
     // Native OS windows are positioned from the bottom-left corner on macOS, whereas on other platforms they are
     // positioned from the upper-left corner. GLFW makes an effort to convert macOS style coordinates, however it
     // doesn't handle it when changing size. We are manually moving the window in order for changes of size to be based
     // on the upper-left corner.
     int x, y, width, height;
-    glfwGetWindowPos(data->Window, &x, &y);
-    glfwGetWindowSize(data->Window, &width, &height);
-    glfwSetWindowPos(data->Window, x, y - height + size.y);
+    glfwGetWindowPos(vd->Window, &x, &y);
+    glfwGetWindowSize(vd->Window, &width, &height);
+    glfwSetWindowPos(vd->Window, x, y - height + size.y);
 #endif
-    data->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount();
-    glfwSetWindowSize(data->Window, (int)size.x, (int)size.y);
+    vd->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount();
+    glfwSetWindowSize(vd->Window, (int)size.x, (int)size.y);
 }
 
 static void ImGui_ImplGlfw_SetWindowTitle(ImGuiViewport* viewport, const char* title)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    glfwSetWindowTitle(data->Window, title);
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    glfwSetWindowTitle(vd->Window, title);
 }
 
 static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport)
 {
 #if GLFW_HAS_FOCUS_WINDOW
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    glfwFocusWindow(data->Window);
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    glfwFocusWindow(vd->Window);
 #else
     // FIXME: What are the effect of not having this function? At the moment imgui doesn't actually call SetWindowFocus - we set that up ahead, will answer that question later.
     (void)viewport;
@@ -728,38 +882,40 @@ static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport)
 
 static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    return glfwGetWindowAttrib(data->Window, GLFW_FOCUSED) != 0;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    return glfwGetWindowAttrib(vd->Window, GLFW_FOCUSED) != 0;
 }
 
 static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    return glfwGetWindowAttrib(data->Window, GLFW_ICONIFIED) != 0;
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    return glfwGetWindowAttrib(vd->Window, GLFW_ICONIFIED) != 0;
 }
 
 #if GLFW_HAS_WINDOW_ALPHA
 static void ImGui_ImplGlfw_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    glfwSetWindowOpacity(data->Window, alpha);
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    glfwSetWindowOpacity(vd->Window, alpha);
 }
 #endif
 
 static void ImGui_ImplGlfw_RenderWindow(ImGuiViewport* viewport, void*)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    if (g_ClientApi == GlfwClientApi_OpenGL)
-        glfwMakeContextCurrent(data->Window);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    if (bd->ClientApi == GlfwClientApi_OpenGL)
+        glfwMakeContextCurrent(vd->Window);
 }
 
 static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    if (g_ClientApi == GlfwClientApi_OpenGL)
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    if (bd->ClientApi == GlfwClientApi_OpenGL)
     {
-        glfwMakeContextCurrent(data->Window);
-        glfwSwapBuffers(data->Window);
+        glfwMakeContextCurrent(vd->Window);
+        glfwSwapBuffers(vd->Window);
     }
 }
 
@@ -768,7 +924,7 @@ static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*)
 //--------------------------------------------------------------------------------------------------------
 
 // We provide a Win32 implementation because this is such a common issue for IME users
-#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS) && !defined(__GNUC__)
+#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS)
 #define HAS_WIN32_IME   1
 #include <imm.h>
 #ifdef _MSC_VER
@@ -809,9 +965,11 @@ enum VkResult { VK_RESULT_MAX_ENUM = 0x7FFFFFFF };
 extern "C" { extern GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); }
 static int ImGui_ImplGlfw_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
 {
-    ImGuiViewportDataGlfw* data = (ImGuiViewportDataGlfw*)viewport->PlatformUserData;
-    IM_ASSERT(g_ClientApi == GlfwClientApi_Vulkan);
-    VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, data->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+    IM_UNUSED(bd);
+    IM_ASSERT(bd->ClientApi == GlfwClientApi_Vulkan);
+    VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, vd->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
     return (int)err;
 }
 #endif // GLFW_HAS_VULKAN
@@ -819,6 +977,7 @@ static int ImGui_ImplGlfw_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_inst
 static void ImGui_ImplGlfw_InitPlatformInterface()
 {
     // Register platform interface (will be coupled with a renderer interface)
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
     ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
     platform_io.Platform_CreateWindow = ImGui_ImplGlfw_CreateWindow;
     platform_io.Platform_DestroyWindow = ImGui_ImplGlfw_DestroyWindow;
@@ -846,11 +1005,11 @@ static void ImGui_ImplGlfw_InitPlatformInterface()
     // Register main window handle (which is owned by the main application, not by us)
     // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports.
     ImGuiViewport* main_viewport = ImGui::GetMainViewport();
-    ImGuiViewportDataGlfw* data = IM_NEW(ImGuiViewportDataGlfw)();
-    data->Window = g_Window;
-    data->WindowOwned = false;
-    main_viewport->PlatformUserData = data;
-    main_viewport->PlatformHandle = (void*)g_Window;
+    ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
+    vd->Window = bd->Window;
+    vd->WindowOwned = false;
+    main_viewport->PlatformUserData = vd;
+    main_viewport->PlatformHandle = (void*)bd->Window;
 }
 
 static void ImGui_ImplGlfw_ShutdownPlatformInterface()

lib/external/imgui/source/imgui_impl_opengl3.cpp

@@ -8,13 +8,22 @@
 //  [X] Renderer: Multi-viewport support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
 //  [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
 
-// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
 // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
 // Read online: https://github.com/ocornut/imgui/tree/master/docs
 
 // CHANGELOG
 // (minor and older changes stripped away, please see git history for details)
 //  2021-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
+//  2021-08-19: OpenGL: Embed and use our own minimal GL loader (imgui_impl_opengl3_loader.h), removing requirement and support for third-party loader.
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
+//  2021-06-25: OpenGL: Use OES_vertex_array extension on Emscripten + backup/restore current state.
+//  2021-06-21: OpenGL: Destroy individual vertex/fragment shader objects right after they are linked into the main shader.
+//  2021-05-24: OpenGL: Access GL_CLIP_ORIGIN when "GL_ARB_clip_control" extension is detected, inside of just OpenGL 4.5 version.
+//  2021-05-19: OpenGL: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
+//  2021-04-06: OpenGL: Don't try to read GL_CLIP_ORIGIN unless we're OpenGL 4.5 or greater.
+//  2021-02-18: OpenGL: Change blending equation to preserve alpha in output buffer.
 //  2021-01-03: OpenGL: Backup, setup and restore GL_STENCIL_TEST state.
 //  2020-10-23: OpenGL: Backup, setup and restore GL_PRIMITIVE_RESTART state.
 //  2020-10-15: OpenGL: Use glGetString(GL_VERSION) instead of glGetIntegerv(GL_MAJOR_VERSION, ...) when the later returns zero (e.g. Desktop GL 2.x)
@@ -90,42 +99,44 @@
 // GL includes
 #if defined(IMGUI_IMPL_OPENGL_ES2)
 #include <GLES2/gl2.h>
+#if defined(__EMSCRIPTEN__)
+#ifndef GL_GLEXT_PROTOTYPES
+#define GL_GLEXT_PROTOTYPES
+#endif
+#include <GLES2/gl2ext.h>
+#endif
 #elif defined(IMGUI_IMPL_OPENGL_ES3)
 #if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV))
 #include <OpenGLES/ES3/gl.h>    // Use GL ES 3
 #else
 #include <GLES3/gl3.h>          // Use GL ES 3
 #endif
-#else
-// About Desktop OpenGL function loaders:
-//  Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
-//  Helper libraries are often used for this purpose! Here we are supporting a few common ones (gl3w, glew, glad).
-//  You may use another loader/header of your choice (glext, glLoadGen, etc.), or chose to manually implement your own.
-#if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
-#include <GL/gl3w.h>            // Needs to be initialized with gl3wInit() in user's code
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
-#include <GL/glew.h>            // Needs to be initialized with glewInit() in user's code.
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
-#include <glad/glad.h>          // Needs to be initialized with gladLoadGL() in user's code.
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD2)
-#include <glad/gl.h>            // Needs to be initialized with gladLoadGL(...) or gladLoaderLoadGL() in user's code.
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
-#ifndef GLFW_INCLUDE_NONE
-#define GLFW_INCLUDE_NONE       // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
+#elif !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
+// Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
+// Helper libraries are often used for this purpose! Here we are using our own minimal custom loader based on gl3w.
+// In the rest of your app/engine, you can use another loader of your choice (gl3w, glew, glad, glbinding, glext, glLoadGen, etc.).
+// If you happen to be developing a new feature for this backend (imgui_impl_opengl3.cpp):
+// - You may need to regenerate imgui_impl_opengl3_loader.h to add new symbols. See https://github.com/dearimgui/gl3w_stripped
+// - You can temporarily use an unstripped version. See https://github.com/dearimgui/gl3w_stripped/releases
+// Changes to this backend using new APIs should be accompanied by a regenerated stripped loader version.
+#define IMGL3W_IMPL
+#include "imgui_impl_opengl3_loader.h"
 #endif
-#include <glbinding/Binding.h>  // Needs to be initialized with glbinding::Binding::initialize() in user's code.
-#include <glbinding/gl/gl.h>
-using namespace gl;
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
-#ifndef GLFW_INCLUDE_NONE
-#define GLFW_INCLUDE_NONE       // GLFW including OpenGL headers causes ambiguity or multiple definition errors.
-#endif
-#include <glbinding/glbinding.h>// Needs to be initialized with glbinding::initialize() in user's code.
-#include <glbinding/gl/gl.h>
-using namespace gl;
-#else
-#include IMGUI_IMPL_OPENGL_LOADER_CUSTOM
+
+// Vertex arrays are not supported on ES2/WebGL1 unless Emscripten which uses an extension
+#ifndef IMGUI_IMPL_OPENGL_ES2
+#define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
+#elif defined(__EMSCRIPTEN__)
+#define IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
+#define glBindVertexArray       glBindVertexArrayOES
+#define glGenVertexArrays       glGenVertexArraysOES
+#define glDeleteVertexArrays    glDeleteVertexArraysOES
+#define GL_VERTEX_ARRAY_BINDING GL_VERTEX_ARRAY_BINDING_OES
 #endif
+
+// Desktop GL 2.0+ has glPolygonMode() which GL ES and WebGL don't have.
+#ifdef GL_POLYGON_MODE
+#define IMGUI_IMPL_HAS_POLYGON_MODE
 #endif
 
 // Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
@@ -143,14 +154,35 @@ using namespace gl;
 #define IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
 #endif
 
+// Desktop GL use extension detection
+#if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3)
+#define IMGUI_IMPL_OPENGL_MAY_HAVE_EXTENSIONS
+#endif
+
 // OpenGL Data
-static GLuint       g_GlVersion = 0;                // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
-static char         g_GlslVersionString[32] = "";   // Specified by user or detected based on compile time GL settings.
-static GLuint       g_FontTexture = 0;
-static GLuint       g_ShaderHandle = 0, g_VertHandle = 0, g_FragHandle = 0;
-static GLint        g_AttribLocationTex = 0, g_AttribLocationProjMtx = 0;                                // Uniforms location
-static GLuint       g_AttribLocationVtxPos = 0, g_AttribLocationVtxUV = 0, g_AttribLocationVtxColor = 0; // Vertex attributes location
-static unsigned int g_VboHandle = 0, g_ElementsHandle = 0;
+struct ImGui_ImplOpenGL3_Data
+{
+    GLuint          GlVersion;               // Extracted at runtime using GL_MAJOR_VERSION, GL_MINOR_VERSION queries (e.g. 320 for GL 3.2)
+    char            GlslVersionString[32];   // Specified by user or detected based on compile time GL settings.
+    GLuint          FontTexture;
+    GLuint          ShaderHandle;
+    GLint           AttribLocationTex;       // Uniforms location
+    GLint           AttribLocationProjMtx;
+    GLuint          AttribLocationVtxPos;    // Vertex attributes location
+    GLuint          AttribLocationVtxUV;
+    GLuint          AttribLocationVtxColor;
+    unsigned int    VboHandle, ElementsHandle;
+    bool            HasClipOrigin;
+
+    ImGui_ImplOpenGL3_Data() { memset(this, 0, sizeof(*this)); }
+};
+
+// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+static ImGui_ImplOpenGL3_Data* ImGui_ImplOpenGL3_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplOpenGL3_Data*)ImGui::GetIO().BackendRendererUserData : NULL;
+}
 
 // Forward Declarations
 static void ImGui_ImplOpenGL3_InitPlatformInterface();
@@ -159,6 +191,23 @@ static void ImGui_ImplOpenGL3_ShutdownPlatformInterface();
 // Functions
 bool    ImGui_ImplOpenGL3_Init(const char* glsl_version)
 {
+    ImGuiIO& io = ImGui::GetIO();
+    IM_ASSERT(io.BackendRendererUserData == NULL && "Already initialized a renderer backend!");
+
+    // Initialize our loader
+#if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && !defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
+    if (imgl3wInit() != 0)
+    {
+        fprintf(stderr, "Failed to initialize OpenGL loader!\n");
+        return false;
+    }
+#endif
+
+    // Setup backend capabilities flags
+    ImGui_ImplOpenGL3_Data* bd = IM_NEW(ImGui_ImplOpenGL3_Data)();
+    io.BackendRendererUserData = (void*)bd;
+    io.BackendRendererName = "imgui_impl_opengl3";
+
     // Query for GL version (e.g. 320 for GL 3.2)
 #if !defined(IMGUI_IMPL_OPENGL_ES2)
     GLint major = 0;
@@ -171,70 +220,53 @@ bool    ImGui_ImplOpenGL3_Init(const char* glsl_version)
         const char* gl_version = (const char*)glGetString(GL_VERSION);
         sscanf(gl_version, "%d.%d", &major, &minor);
     }
-    g_GlVersion = (GLuint)(major * 100 + minor * 10);
+    bd->GlVersion = (GLuint)(major * 100 + minor * 10);
 #else
-    g_GlVersion = 200; // GLES 2
+    bd->GlVersion = 200; // GLES 2
 #endif
 
-    // Setup backend capabilities flags
-    ImGuiIO& io = ImGui::GetIO();
-    io.BackendRendererName = "imgui_impl_opengl3";
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
-    if (g_GlVersion >= 320)
+    if (bd->GlVersion >= 320)
         io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;  // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
 #endif
     io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports;  // We can create multi-viewports on the Renderer side (optional)
 
     // Store GLSL version string so we can refer to it later in case we recreate shaders.
     // Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
-#if defined(IMGUI_IMPL_OPENGL_ES2)
     if (glsl_version == NULL)
+    {
+#if defined(IMGUI_IMPL_OPENGL_ES2)
         glsl_version = "#version 100";
 #elif defined(IMGUI_IMPL_OPENGL_ES3)
-    if (glsl_version == NULL)
         glsl_version = "#version 300 es";
 #elif defined(__APPLE__)
-    if (glsl_version == NULL)
         glsl_version = "#version 150";
 #else
-    if (glsl_version == NULL)
         glsl_version = "#version 130";
 #endif
-    IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(g_GlslVersionString));
-    strcpy(g_GlslVersionString, glsl_version);
-    strcat(g_GlslVersionString, "\n");
-
-    // Debugging construct to make it easily visible in the IDE and debugger which GL loader has been selected.
-    // The code actually never uses the 'gl_loader' variable! It is only here so you can read it!
-    // If auto-detection fails or doesn't select the same GL loader file as used by your application,
-    // you are likely to get a crash below.
-    // You can explicitly select a loader by using '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
-    const char* gl_loader = "Unknown";
-    IM_UNUSED(gl_loader);
-#if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
-    gl_loader = "GL3W";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
-    gl_loader = "GLEW";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
-    gl_loader = "GLAD";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD2)
-    gl_loader = "GLAD2";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING2)
-    gl_loader = "glbinding2";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLBINDING3)
-    gl_loader = "glbinding3";
-#elif defined(IMGUI_IMPL_OPENGL_LOADER_CUSTOM)
-    gl_loader = "custom";
-#else
-    gl_loader = "none";
-#endif
+    }
+    IM_ASSERT((int)strlen(glsl_version) + 2 < IM_ARRAYSIZE(bd->GlslVersionString));
+    strcpy(bd->GlslVersionString, glsl_version);
+    strcat(bd->GlslVersionString, "\n");
 
     // Make an arbitrary GL call (we don't actually need the result)
-    // IF YOU GET A CRASH HERE: it probably means that you haven't initialized the OpenGL function loader used by this code.
-    // Desktop OpenGL 3/4 need a function loader. See the IMGUI_IMPL_OPENGL_LOADER_xxx explanation above.
+    // IF YOU GET A CRASH HERE: it probably means the OpenGL function loader didn't do its job. Let us know!
     GLint current_texture;
     glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
+    // Detect extensions we support
+    bd->HasClipOrigin = (bd->GlVersion >= 450);
+#ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_EXTENSIONS
+    GLint num_extensions = 0;
+    glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
+    for (GLint i = 0; i < num_extensions; i++)
+    {
+        const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, i);
+        if (extension != NULL && strcmp(extension, "GL_ARB_clip_control") == 0)
+            bd->HasClipOrigin = true;
+    }
+#endif
+
     if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
         ImGui_ImplOpenGL3_InitPlatformInterface();
 
@@ -243,40 +275,54 @@ bool    ImGui_ImplOpenGL3_Init(const char* glsl_version)
 
 void    ImGui_ImplOpenGL3_Shutdown()
 {
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+
     ImGui_ImplOpenGL3_ShutdownPlatformInterface();
     ImGui_ImplOpenGL3_DestroyDeviceObjects();
+    io.BackendRendererName = NULL;
+    io.BackendRendererUserData = NULL;
+    IM_DELETE(bd);
 }
 
 void    ImGui_ImplOpenGL3_NewFrame()
 {
-    if (!g_ShaderHandle)
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+    IM_ASSERT(bd != NULL && "Did you call ImGui_ImplOpenGL3_Init()?");
+
+    if (!bd->ShaderHandle)
         ImGui_ImplOpenGL3_CreateDeviceObjects();
 }
 
 static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height, GLuint vertex_array_object)
 {
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+
     // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
     glEnable(GL_BLEND);
     glBlendEquation(GL_FUNC_ADD);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glDisable(GL_CULL_FACE);
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_STENCIL_TEST);
     glEnable(GL_SCISSOR_TEST);
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
-    if (g_GlVersion >= 310)
+    if (bd->GlVersion >= 310)
         glDisable(GL_PRIMITIVE_RESTART);
 #endif
-#ifdef GL_POLYGON_MODE
+#ifdef IMGUI_IMPL_HAS_POLYGON_MODE
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 #endif
 
     // Support for GL 4.5 rarely used glClipControl(GL_UPPER_LEFT)
-#if defined(GL_CLIP_ORIGIN) && !defined(__APPLE__)
+#if defined(GL_CLIP_ORIGIN)
     bool clip_origin_lower_left = true;
-    GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)&current_clip_origin);
-    if (current_clip_origin == GL_UPPER_LEFT)
-        clip_origin_lower_left = false;
+    if (bd->HasClipOrigin)
+    {
+        GLenum current_clip_origin = 0; glGetIntegerv(GL_CLIP_ORIGIN, (GLint*)&current_clip_origin);
+        if (current_clip_origin == GL_UPPER_LEFT)
+            clip_origin_lower_left = false;
+    }
 #endif
 
     // Setup viewport, orthographic projection matrix
@@ -286,39 +332,39 @@ static void ImGui_ImplOpenGL3_SetupRenderState(ImDrawData* draw_data, int fb_wid
     float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
     float T = draw_data->DisplayPos.y;
     float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
-#if defined(GL_CLIP_ORIGIN) && !defined(__APPLE__)
+#if defined(GL_CLIP_ORIGIN)
     if (!clip_origin_lower_left) { float tmp = T; T = B; B = tmp; } // Swap top and bottom if origin is upper left
 #endif
     const float ortho_projection[4][4] =
-            {
-                    { 2.0f/(R-L),   0.0f,         0.0f,   0.0f },
-                    { 0.0f,         2.0f/(T-B),   0.0f,   0.0f },
-                    { 0.0f,         0.0f,        -1.0f,   0.0f },
-                    { (R+L)/(L-R),  (T+B)/(B-T),  0.0f,   1.0f },
-            };
-    glUseProgram(g_ShaderHandle);
-    glUniform1i(g_AttribLocationTex, 0);
-    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
+    {
+        { 2.0f/(R-L),   0.0f,         0.0f,   0.0f },
+        { 0.0f,         2.0f/(T-B),   0.0f,   0.0f },
+        { 0.0f,         0.0f,        -1.0f,   0.0f },
+        { (R+L)/(L-R),  (T+B)/(B-T),  0.0f,   1.0f },
+    };
+    glUseProgram(bd->ShaderHandle);
+    glUniform1i(bd->AttribLocationTex, 0);
+    glUniformMatrix4fv(bd->AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
 
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
-    if (g_GlVersion >= 330)
+    if (bd->GlVersion >= 330)
         glBindSampler(0, 0); // We use combined texture/sampler state. Applications using GL 3.3 may set that otherwise.
 #endif
 
     (void)vertex_array_object;
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     glBindVertexArray(vertex_array_object);
 #endif
 
     // Bind vertex/index buffers and setup attributes for ImDrawVert
-    glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
-    glEnableVertexAttribArray(g_AttribLocationVtxPos);
-    glEnableVertexAttribArray(g_AttribLocationVtxUV);
-    glEnableVertexAttribArray(g_AttribLocationVtxColor);
-    glVertexAttribPointer(g_AttribLocationVtxPos,   2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
-    glVertexAttribPointer(g_AttribLocationVtxUV,    2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
-    glVertexAttribPointer(g_AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE,  sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
+    glBindBuffer(GL_ARRAY_BUFFER, bd->VboHandle);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bd->ElementsHandle);
+    glEnableVertexAttribArray(bd->AttribLocationVtxPos);
+    glEnableVertexAttribArray(bd->AttribLocationVtxUV);
+    glEnableVertexAttribArray(bd->AttribLocationVtxColor);
+    glVertexAttribPointer(bd->AttribLocationVtxPos,   2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
+    glVertexAttribPointer(bd->AttribLocationVtxUV,    2, GL_FLOAT,         GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
+    glVertexAttribPointer(bd->AttribLocationVtxColor, 4, GL_UNSIGNED_BYTE, GL_TRUE,  sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
 }
 
 // OpenGL3 Render function.
@@ -332,19 +378,21 @@ void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
     if (fb_width <= 0 || fb_height <= 0)
         return;
 
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+
     // Backup GL state
     GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
     glActiveTexture(GL_TEXTURE0);
     GLuint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&last_program);
     GLuint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&last_texture);
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
-    GLuint last_sampler; if (g_GlVersion >= 330) { glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&last_sampler); } else { last_sampler = 0; }
+    GLuint last_sampler; if (bd->GlVersion >= 330) { glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&last_sampler); } else { last_sampler = 0; }
 #endif
     GLuint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&last_array_buffer);
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     GLuint last_vertex_array_object; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&last_vertex_array_object);
 #endif
-#ifdef GL_POLYGON_MODE
+#ifdef IMGUI_IMPL_HAS_POLYGON_MODE
     GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
 #endif
     GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
@@ -361,14 +409,14 @@ void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
     GLboolean last_enable_stencil_test = glIsEnabled(GL_STENCIL_TEST);
     GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
-    GLboolean last_enable_primitive_restart = (g_GlVersion >= 310) ? glIsEnabled(GL_PRIMITIVE_RESTART) : GL_FALSE;
+    GLboolean last_enable_primitive_restart = (bd->GlVersion >= 310) ? glIsEnabled(GL_PRIMITIVE_RESTART) : GL_FALSE;
 #endif
 
     // Setup desired GL state
     // Recreate the VAO every time (this is to easily allow multiple GL contexts to be rendered to. VAO are not shared among GL contexts)
     // The renderer would actually work without any VAO bound, but then our VertexAttrib calls would overwrite the default one currently bound.
     GLuint vertex_array_object = 0;
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     glGenVertexArrays(1, &vertex_array_object);
 #endif
     ImGui_ImplOpenGL3_SetupRenderState(draw_data, fb_width, fb_height, vertex_array_object);
@@ -413,20 +461,20 @@ void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
                     glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y));
 
                     // Bind texture, Draw
-                    glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                    glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID());
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_VTX_OFFSET
-                    if (g_GlVersion >= 320)
+                    if (bd->GlVersion >= 320)
                         glDrawElementsBaseVertex(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)), (GLint)pcmd->VtxOffset);
                     else
 #endif
-                        glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)));
+                    glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx)));
                 }
             }
         }
     }
 
     // Destroy the temporary VAO
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     glDeleteVertexArrays(1, &vertex_array_object);
 #endif
 
@@ -434,11 +482,11 @@ void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
     glUseProgram(last_program);
     glBindTexture(GL_TEXTURE_2D, last_texture);
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_BIND_SAMPLER
-    if (g_GlVersion >= 330)
+    if (bd->GlVersion >= 330)
         glBindSampler(0, last_sampler);
 #endif
     glActiveTexture(last_active_texture);
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     glBindVertexArray(last_vertex_array_object);
 #endif
     glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
@@ -450,20 +498,23 @@ void    ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data)
     if (last_enable_stencil_test) glEnable(GL_STENCIL_TEST); else glDisable(GL_STENCIL_TEST);
     if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
 #ifdef IMGUI_IMPL_OPENGL_MAY_HAVE_PRIMITIVE_RESTART
-    if (g_GlVersion >= 310) { if (last_enable_primitive_restart) glEnable(GL_PRIMITIVE_RESTART); else glDisable(GL_PRIMITIVE_RESTART); }
+    if (bd->GlVersion >= 310) { if (last_enable_primitive_restart) glEnable(GL_PRIMITIVE_RESTART); else glDisable(GL_PRIMITIVE_RESTART); }
 #endif
 
-#ifdef GL_POLYGON_MODE
+#ifdef IMGUI_IMPL_HAS_POLYGON_MODE
     glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]);
 #endif
     glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
     glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
+    (void)bd; // Not all compilation paths use this
 }
 
 bool ImGui_ImplOpenGL3_CreateFontsTexture()
 {
-    // Build texture atlas
     ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+
+    // Build texture atlas
     unsigned char* pixels;
     int width, height;
     io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bit (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
@@ -471,17 +522,17 @@ bool ImGui_ImplOpenGL3_CreateFontsTexture()
     // Upload texture to graphics system
     GLint last_texture;
     glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
-    glGenTextures(1, &g_FontTexture);
-    glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+    glGenTextures(1, &bd->FontTexture);
+    glBindTexture(GL_TEXTURE_2D, bd->FontTexture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-#ifdef GL_UNPACK_ROW_LENGTH
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+#ifdef GL_UNPACK_ROW_LENGTH // Not on WebGL/ES
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 #endif
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
     // Store our identifier
-    io.Fonts->TexID = (ImTextureID)(intptr_t)g_FontTexture;
+    io.Fonts->SetTexID((ImTextureID)(intptr_t)bd->FontTexture);
 
     // Restore state
     glBindTexture(GL_TEXTURE_2D, last_texture);
@@ -491,23 +542,25 @@ bool ImGui_ImplOpenGL3_CreateFontsTexture()
 
 void ImGui_ImplOpenGL3_DestroyFontsTexture()
 {
-    if (g_FontTexture)
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+    if (bd->FontTexture)
     {
-        ImGuiIO& io = ImGui::GetIO();
-        glDeleteTextures(1, &g_FontTexture);
-        io.Fonts->TexID = 0;
-        g_FontTexture = 0;
+        glDeleteTextures(1, &bd->FontTexture);
+        io.Fonts->SetTexID(0);
+        bd->FontTexture = 0;
     }
 }
 
 // If you get an error please report on github. You may try different GL context version or GLSL version. See GL<>GLSL version table at the top of this file.
 static bool CheckShader(GLuint handle, const char* desc)
 {
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
     GLint status = 0, log_length = 0;
     glGetShaderiv(handle, GL_COMPILE_STATUS, &status);
     glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &log_length);
     if ((GLboolean)status == GL_FALSE)
-        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s!\n", desc);
+        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to compile %s! With GLSL: %s\n", desc, bd->GlslVersionString);
     if (log_length > 1)
     {
         ImVector<char> buf;
@@ -521,11 +574,12 @@ static bool CheckShader(GLuint handle, const char* desc)
 // If you get an error please report on GitHub. You may try different GL context version or GLSL version.
 static bool CheckProgram(GLuint handle, const char* desc)
 {
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
     GLint status = 0, log_length = 0;
     glGetProgramiv(handle, GL_LINK_STATUS, &status);
     glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length);
     if ((GLboolean)status == GL_FALSE)
-        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! (with GLSL '%s')\n", desc, g_GlslVersionString);
+        fprintf(stderr, "ERROR: ImGui_ImplOpenGL3_CreateDeviceObjects: failed to link %s! With GLSL %s\n", desc, bd->GlslVersionString);
     if (log_length > 1)
     {
         ImVector<char> buf;
@@ -538,118 +592,120 @@ static bool CheckProgram(GLuint handle, const char* desc)
 
 bool    ImGui_ImplOpenGL3_CreateDeviceObjects()
 {
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+
     // Backup GL state
     GLint last_texture, last_array_buffer;
     glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
     glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     GLint last_vertex_array;
     glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
 #endif
 
     // Parse GLSL version string
     int glsl_version = 130;
-    sscanf(g_GlslVersionString, "#version %d", &glsl_version);
+    sscanf(bd->GlslVersionString, "#version %d", &glsl_version);
 
     const GLchar* vertex_shader_glsl_120 =
-            "uniform mat4 ProjMtx;\n"
-            "attribute vec2 Position;\n"
-            "attribute vec2 UV;\n"
-            "attribute vec4 Color;\n"
-            "varying vec2 Frag_UV;\n"
-            "varying vec4 Frag_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Frag_UV = UV;\n"
-            "    Frag_Color = Color;\n"
-            "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
-            "}\n";
+        "uniform mat4 ProjMtx;\n"
+        "attribute vec2 Position;\n"
+        "attribute vec2 UV;\n"
+        "attribute vec4 Color;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
 
     const GLchar* vertex_shader_glsl_130 =
-            "uniform mat4 ProjMtx;\n"
-            "in vec2 Position;\n"
-            "in vec2 UV;\n"
-            "in vec4 Color;\n"
-            "out vec2 Frag_UV;\n"
-            "out vec4 Frag_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Frag_UV = UV;\n"
-            "    Frag_Color = Color;\n"
-            "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
-            "}\n";
+        "uniform mat4 ProjMtx;\n"
+        "in vec2 Position;\n"
+        "in vec2 UV;\n"
+        "in vec4 Color;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
 
     const GLchar* vertex_shader_glsl_300_es =
-            "precision mediump float;\n"
-            "layout (location = 0) in vec2 Position;\n"
-            "layout (location = 1) in vec2 UV;\n"
-            "layout (location = 2) in vec4 Color;\n"
-            "uniform mat4 ProjMtx;\n"
-            "out vec2 Frag_UV;\n"
-            "out vec4 Frag_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Frag_UV = UV;\n"
-            "    Frag_Color = Color;\n"
-            "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
-            "}\n";
+        "precision mediump float;\n"
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
 
     const GLchar* vertex_shader_glsl_410_core =
-            "layout (location = 0) in vec2 Position;\n"
-            "layout (location = 1) in vec2 UV;\n"
-            "layout (location = 2) in vec4 Color;\n"
-            "uniform mat4 ProjMtx;\n"
-            "out vec2 Frag_UV;\n"
-            "out vec4 Frag_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Frag_UV = UV;\n"
-            "    Frag_Color = Color;\n"
-            "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
-            "}\n";
+        "layout (location = 0) in vec2 Position;\n"
+        "layout (location = 1) in vec2 UV;\n"
+        "layout (location = 2) in vec4 Color;\n"
+        "uniform mat4 ProjMtx;\n"
+        "out vec2 Frag_UV;\n"
+        "out vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Frag_UV = UV;\n"
+        "    Frag_Color = Color;\n"
+        "    gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "}\n";
 
     const GLchar* fragment_shader_glsl_120 =
-            "#ifdef GL_ES\n"
-            "    precision mediump float;\n"
-            "#endif\n"
-            "uniform sampler2D Texture;\n"
-            "varying vec2 Frag_UV;\n"
-            "varying vec4 Frag_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
-            "}\n";
+        "#ifdef GL_ES\n"
+        "    precision mediump float;\n"
+        "#endif\n"
+        "uniform sampler2D Texture;\n"
+        "varying vec2 Frag_UV;\n"
+        "varying vec4 Frag_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);\n"
+        "}\n";
 
     const GLchar* fragment_shader_glsl_130 =
-            "uniform sampler2D Texture;\n"
-            "in vec2 Frag_UV;\n"
-            "in vec4 Frag_Color;\n"
-            "out vec4 Out_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
-            "}\n";
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
 
     const GLchar* fragment_shader_glsl_300_es =
-            "precision mediump float;\n"
-            "uniform sampler2D Texture;\n"
-            "in vec2 Frag_UV;\n"
-            "in vec4 Frag_Color;\n"
-            "layout (location = 0) out vec4 Out_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
-            "}\n";
+        "precision mediump float;\n"
+        "uniform sampler2D Texture;\n"
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
 
     const GLchar* fragment_shader_glsl_410_core =
-            "in vec2 Frag_UV;\n"
-            "in vec4 Frag_Color;\n"
-            "uniform sampler2D Texture;\n"
-            "layout (location = 0) out vec4 Out_Color;\n"
-            "void main()\n"
-            "{\n"
-            "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
-            "}\n";
+        "in vec2 Frag_UV;\n"
+        "in vec4 Frag_Color;\n"
+        "uniform sampler2D Texture;\n"
+        "layout (location = 0) out vec4 Out_Color;\n"
+        "void main()\n"
+        "{\n"
+        "    Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
+        "}\n";
 
     // Select shaders matching our GLSL versions
     const GLchar* vertex_shader = NULL;
@@ -676,40 +732,46 @@ bool    ImGui_ImplOpenGL3_CreateDeviceObjects()
     }
 
     // Create shaders
-    const GLchar* vertex_shader_with_version[2] = { g_GlslVersionString, vertex_shader };
-    g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
-    glShaderSource(g_VertHandle, 2, vertex_shader_with_version, NULL);
-    glCompileShader(g_VertHandle);
-    CheckShader(g_VertHandle, "vertex shader");
+    const GLchar* vertex_shader_with_version[2] = { bd->GlslVersionString, vertex_shader };
+    GLuint vert_handle = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vert_handle, 2, vertex_shader_with_version, NULL);
+    glCompileShader(vert_handle);
+    CheckShader(vert_handle, "vertex shader");
 
-    const GLchar* fragment_shader_with_version[2] = { g_GlslVersionString, fragment_shader };
-    g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(g_FragHandle, 2, fragment_shader_with_version, NULL);
-    glCompileShader(g_FragHandle);
-    CheckShader(g_FragHandle, "fragment shader");
+    const GLchar* fragment_shader_with_version[2] = { bd->GlslVersionString, fragment_shader };
+    GLuint frag_handle = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(frag_handle, 2, fragment_shader_with_version, NULL);
+    glCompileShader(frag_handle);
+    CheckShader(frag_handle, "fragment shader");
 
-    g_ShaderHandle = glCreateProgram();
-    glAttachShader(g_ShaderHandle, g_VertHandle);
-    glAttachShader(g_ShaderHandle, g_FragHandle);
-    glLinkProgram(g_ShaderHandle);
-    CheckProgram(g_ShaderHandle, "shader program");
+    // Link
+    bd->ShaderHandle = glCreateProgram();
+    glAttachShader(bd->ShaderHandle, vert_handle);
+    glAttachShader(bd->ShaderHandle, frag_handle);
+    glLinkProgram(bd->ShaderHandle);
+    CheckProgram(bd->ShaderHandle, "shader program");
 
-    g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
-    g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
-    g_AttribLocationVtxPos = (GLuint)glGetAttribLocation(g_ShaderHandle, "Position");
-    g_AttribLocationVtxUV = (GLuint)glGetAttribLocation(g_ShaderHandle, "UV");
-    g_AttribLocationVtxColor = (GLuint)glGetAttribLocation(g_ShaderHandle, "Color");
+    glDetachShader(bd->ShaderHandle, vert_handle);
+    glDetachShader(bd->ShaderHandle, frag_handle);
+    glDeleteShader(vert_handle);
+    glDeleteShader(frag_handle);
+
+    bd->AttribLocationTex = glGetUniformLocation(bd->ShaderHandle, "Texture");
+    bd->AttribLocationProjMtx = glGetUniformLocation(bd->ShaderHandle, "ProjMtx");
+    bd->AttribLocationVtxPos = (GLuint)glGetAttribLocation(bd->ShaderHandle, "Position");
+    bd->AttribLocationVtxUV = (GLuint)glGetAttribLocation(bd->ShaderHandle, "UV");
+    bd->AttribLocationVtxColor = (GLuint)glGetAttribLocation(bd->ShaderHandle, "Color");
 
     // Create buffers
-    glGenBuffers(1, &g_VboHandle);
-    glGenBuffers(1, &g_ElementsHandle);
+    glGenBuffers(1, &bd->VboHandle);
+    glGenBuffers(1, &bd->ElementsHandle);
 
     ImGui_ImplOpenGL3_CreateFontsTexture();
 
     // Restore modified GL state
     glBindTexture(GL_TEXTURE_2D, last_texture);
     glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
-#ifndef IMGUI_IMPL_OPENGL_ES2
+#ifdef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
     glBindVertexArray(last_vertex_array);
 #endif
 
@@ -718,14 +780,10 @@ bool    ImGui_ImplOpenGL3_CreateDeviceObjects()
 
 void    ImGui_ImplOpenGL3_DestroyDeviceObjects()
 {
-    if (g_VboHandle)        { glDeleteBuffers(1, &g_VboHandle); g_VboHandle = 0; }
-    if (g_ElementsHandle)   { glDeleteBuffers(1, &g_ElementsHandle); g_ElementsHandle = 0; }
-    if (g_ShaderHandle && g_VertHandle) { glDetachShader(g_ShaderHandle, g_VertHandle); }
-    if (g_ShaderHandle && g_FragHandle) { glDetachShader(g_ShaderHandle, g_FragHandle); }
-    if (g_VertHandle)       { glDeleteShader(g_VertHandle); g_VertHandle = 0; }
-    if (g_FragHandle)       { glDeleteShader(g_FragHandle); g_FragHandle = 0; }
-    if (g_ShaderHandle)     { glDeleteProgram(g_ShaderHandle); g_ShaderHandle = 0; }
-
+    ImGui_ImplOpenGL3_Data* bd = ImGui_ImplOpenGL3_GetBackendData();
+    if (bd->VboHandle)      { glDeleteBuffers(1, &bd->VboHandle); bd->VboHandle = 0; }
+    if (bd->ElementsHandle) { glDeleteBuffers(1, &bd->ElementsHandle); bd->ElementsHandle = 0; }
+    if (bd->ShaderHandle)   { glDeleteProgram(bd->ShaderHandle); bd->ShaderHandle = 0; }
     ImGui_ImplOpenGL3_DestroyFontsTexture();
 }
 
@@ -755,4 +813,4 @@ static void ImGui_ImplOpenGL3_InitPlatformInterface()
 static void ImGui_ImplOpenGL3_ShutdownPlatformInterface()
 {
     ImGui::DestroyPlatformWindows();
-}
+}

lib/external/imgui/source/imgui_tables.cpp

@@ -1,4 +1,4 @@
-// dear imgui, v1.80
+// dear imgui, v1.86
 // (tables and columns code)
 
 /*
@@ -8,6 +8,7 @@ Index of this file:
 // [SECTION] Commentary
 // [SECTION] Header mess
 // [SECTION] Tables: Main code
+// [SECTION] Tables: Simple accessors
 // [SECTION] Tables: Row changes
 // [SECTION] Tables: Columns changes
 // [SECTION] Tables: Columns width management
@@ -73,7 +74,7 @@ Index of this file:
 // (Read carefully because this is subtle but it does make sense!)
 //-----------------------------------------------------------------------------
 // About 'outer_size':
-// Its meaning needs to differ slightly depending of if we are using ScrollX/ScrollY flags.
+// Its meaning needs to differ slightly depending on if we are using ScrollX/ScrollY flags.
 // Default value is ImVec2(0.0f, 0.0f).
 //   X
 //   - outer_size.x <= 0.0f  ->  Right-align from window/work-rect right-most edge. With -FLT_MIN or 0.0f will align exactly on right-most edge.
@@ -90,7 +91,7 @@ Index of this file:
 // Outer size is also affected by the NoHostExtendX/NoHostExtendY flags.
 // Important to that note how the two flags have slightly different behaviors!
 //   - ImGuiTableFlags_NoHostExtendX -> Make outer width auto-fit to columns (overriding outer_size.x value). Only available when ScrollX/ScrollY are disabled and Stretch columns are not used.
-//   - ImGuiTableFlags_NoHostExtendY -> Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY are disabled. Data below the limit will be clipped and not visible.
+//   - ImGuiTableFlags_NoHostExtendY -> Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY is disabled. Data below the limit will be clipped and not visible.
 // In theory ImGuiTableFlags_NoHostExtendY could be the default and any non-scrolling tables with outer_size.y != 0.0f would use exact height.
 // This would be consistent but perhaps less useful and more confusing (as vertically clipped items are not easily noticeable)
 //-----------------------------------------------------------------------------
@@ -126,13 +127,13 @@ Index of this file:
 //   - with Table policy ImGuiTableFlags_SizingFixedSame     --> default Column policy is ImGuiTableColumnFlags_WidthFixed, default Width is max of all contents width
 //   - with Table policy ImGuiTableFlags_SizingStretchSame   --> default Column policy is ImGuiTableColumnFlags_WidthStretch, default Weight is 1.0f
 //   - with Table policy ImGuiTableFlags_SizingStretchWeight --> default Column policy is ImGuiTableColumnFlags_WidthStretch, default Weight is proportional to contents
-// Default Width and default Weight can be overriden when calling TableSetupColumn().
+// Default Width and default Weight can be overridden when calling TableSetupColumn().
 //-----------------------------------------------------------------------------
 // About mixing Fixed/Auto and Stretch columns together:
 //   - the typical use of mixing sizing policies is: any number of LEADING Fixed columns, followed by one or two TRAILING Stretch columns.
 //   - using mixed policies with ScrollX does not make much sense, as using Stretch columns with ScrollX does not make much sense in the first place!
-//     that is, unless 'inner_width' is passed to BeginTable() to explicitely provide a total width to layout columns in.
-//   - when using ImGuiTableFlags_SizingFixedSame with mixed columns, only the Fixed/Auto columns will match their widths to the maximum contents width.
+//     that is, unless 'inner_width' is passed to BeginTable() to explicitly provide a total width to layout columns in.
+//   - when using ImGuiTableFlags_SizingFixedSame with mixed columns, only the Fixed/Auto columns will match their widths to the width of the maximum contents.
 //   - when using ImGuiTableFlags_SizingStretchSame with mixed columns, only the Stretch columns will match their weight/widths.
 //-----------------------------------------------------------------------------
 // About using column width:
@@ -140,9 +141,9 @@ Index of this file:
 //   - you may use GetContentRegionAvail().x to query the width available in a given column.
 //   - right-side alignment features such as SetNextItemWidth(-x) or PushItemWidth(-x) will rely on this width.
 // If the column is not resizable and has no width specified with TableSetupColumn():
-//   - its width will be automatic and be the set to the max of items submitted.
+//   - its width will be automatic and be set to the max of items submitted.
 //   - therefore you generally cannot have ALL items of the columns use e.g. SetNextItemWidth(-FLT_MIN).
-//   - but if the column has one or more item of known/fixed size, this will become the reference width used by SetNextItemWidth(-FLT_MIN).
+//   - but if the column has one or more items of known/fixed size, this will become the reference width used by SetNextItemWidth(-FLT_MIN).
 //-----------------------------------------------------------------------------
 
 
@@ -161,18 +162,18 @@ Index of this file:
 // - Both TableSetColumnIndex() and TableNextColumn() return true when the column is visible or performing
 //   width measurements. Otherwise, you may skip submitting the contents of a cell/column, BUT ONLY if you know
 //   it is not going to contribute to row height.
-//   In many situations, you may skip submitting contents for every columns but one (e.g. the first one).
+//   In many situations, you may skip submitting contents for every column but one (e.g. the first one).
 // - Case A: column is not hidden by user, and at least partially in sight (most common case).
 // - Case B: column is clipped / out of sight (because of scrolling or parent ClipRect): TableNextColumn() return false as a hint but we still allow layout output.
 // - Case C: column is hidden explicitly by the user (e.g. via the context menu, or _DefaultHide column flag, etc.).
 //
-//                        [A]         [B]          [C]         
+//                        [A]         [B]          [C]
 //  TableNextColumn():    true        false        false       -> [userland] when TableNextColumn() / TableSetColumnIndex() return false, user can skip submitting items but only if the column doesn't contribute to row height.
 //          SkipItems:    false       false        true        -> [internal] when SkipItems is true, most widgets will early out if submitted, resulting is no layout output.
 //           ClipRect:    normal      zero-width   zero-width  -> [internal] when ClipRect is zero, ItemAdd() will return false and most widgets will early out mid-way.
 //  ImDrawList output:    normal      dummy        dummy       -> [internal] when using the dummy channel, ImDrawList submissions (if any) will be wasted (because cliprect is zero-width anyway).
 //
-// - We need distinguish those cases because non-hidden columns that are clipped outside of scrolling bounds should still contribute their height to the row.
+// - We need to distinguish those cases because non-hidden columns that are clipped outside of scrolling bounds should still contribute their height to the row.
 //   However, in the majority of cases, the contribution to row height is the same for all columns, or the tallest cells are known by the programmer.
 //-----------------------------------------------------------------------------
 // About clipping/culling of whole Tables:
@@ -209,6 +210,8 @@ Index of this file:
 #if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later
 #pragma warning (disable: 5054)     // operator '|': deprecated between enumerations of different types
 #endif
+#pragma warning (disable: 26451)    // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).
+#pragma warning (disable: 26812)    // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
 #endif
 
 // Clang/GCC warnings with -Weverything
@@ -235,6 +238,19 @@ Index of this file:
 //-----------------------------------------------------------------------------
 // [SECTION] Tables: Main code
 //-----------------------------------------------------------------------------
+// - TableFixFlags() [Internal]
+// - TableFindByID() [Internal]
+// - BeginTable()
+// - BeginTableEx() [Internal]
+// - TableBeginInitMemory() [Internal]
+// - TableBeginApplyRequests() [Internal]
+// - TableSetupColumnFlags() [Internal]
+// - TableUpdateLayout() [Internal]
+// - TableUpdateBorders() [Internal]
+// - EndTable()
+// - TableSetupColumn()
+// - TableSetupScrollFreeze()
+//-----------------------------------------------------------------------------
 
 // Configuration
 static const int TABLE_DRAW_CHANNEL_BG0 = 0;
@@ -272,12 +288,7 @@ inline ImGuiTableFlags TableFixFlags(ImGuiTableFlags flags, ImGuiWindow* outer_w
         flags |= ImGuiTableFlags_NoSavedSettings;
 
     // Inherit _NoSavedSettings from top-level window (child windows always have _NoSavedSettings set)
-#ifdef IMGUI_HAS_DOCK
-    ImGuiWindow* window_for_settings = outer_window->RootWindowDockStop;
-#else
-    ImGuiWindow* window_for_settings = outer_window->RootWindow;
-#endif
-    if (window_for_settings->Flags & ImGuiWindowFlags_NoSavedSettings)
+    if (outer_window->RootWindow->Flags & ImGuiWindowFlags_NoSavedSettings)
         flags |= ImGuiTableFlags_NoSavedSettings;
 
     return flags;
@@ -313,7 +324,7 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     const ImVec2 avail_size = GetContentRegionAvail();
     ImVec2 actual_outer_size = CalcItemSize(outer_size, ImMax(avail_size.x, 1.0f), use_child_window ? ImMax(avail_size.y, 1.0f) : 0.0f);
     ImRect outer_rect(outer_window->DC.CursorPos, outer_window->DC.CursorPos + actual_outer_size);
-    if (use_child_window && IsClippedEx(outer_rect, 0, false))
+    if (use_child_window && IsClippedEx(outer_rect, 0))
     {
         ItemSize(outer_rect);
         return false;
@@ -327,6 +338,15 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     if (instance_no > 0)
         IM_ASSERT(table->ColumnsCount == columns_count && "BeginTable(): Cannot change columns count mid-frame while preserving same ID");
 
+    // Acquire temporary buffers
+    const int table_idx = g.Tables.GetIndex(table);
+    if (++g.TablesTempDataStacked > g.TablesTempData.Size)
+        g.TablesTempData.resize(g.TablesTempDataStacked, ImGuiTableTempData());
+    ImGuiTableTempData* temp_data = table->TempData = &g.TablesTempData[g.TablesTempDataStacked - 1];
+    temp_data->TableIndex = table_idx;
+    table->DrawSplitter = &table->TempData->DrawSplitter;
+    table->DrawSplitter->Clear();
+
     // Fix flags
     table->IsDefaultSizingPolicy = (flags & ImGuiTableFlags_SizingMask_) == 0;
     flags = TableFixFlags(flags, outer_window);
@@ -340,7 +360,7 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     table->ColumnsCount = columns_count;
     table->IsLayoutLocked = false;
     table->InnerWidth = inner_width;
-    table->UserOuterSize = outer_size;
+    temp_data->UserOuterSize = outer_size;
 
     // When not using a child window, WorkRect.Max will grow as we append contents.
     if (use_child_window)
@@ -389,14 +409,14 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     table->HostIndentX = inner_window->DC.Indent.x;
     table->HostClipRect = inner_window->ClipRect;
     table->HostSkipItems = inner_window->SkipItems;
-    table->HostBackupWorkRect = inner_window->WorkRect;
-    table->HostBackupParentWorkRect = inner_window->ParentWorkRect;
-    table->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
-    table->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
-    table->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
-    table->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
-    table->HostBackupItemWidth = outer_window->DC.ItemWidth;
-    table->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
+    temp_data->HostBackupWorkRect = inner_window->WorkRect;
+    temp_data->HostBackupParentWorkRect = inner_window->ParentWorkRect;
+    temp_data->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
+    temp_data->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
+    temp_data->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
+    temp_data->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
+    temp_data->HostBackupItemWidth = outer_window->DC.ItemWidth;
+    temp_data->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
     inner_window->DC.PrevLineSize = inner_window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
 
     // Padding and Spacing
@@ -439,8 +459,6 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     table->BorderColorLight = GetColorU32(ImGuiCol_TableBorderLight);
 
     // Make table current
-    const int table_idx = g.Tables.GetIndex(table);
-    g.CurrentTableStack.push_back(ImGuiPtrOrIndex(table_idx));
     g.CurrentTable = table;
     outer_window->DC.CurrentTableIdx = table_idx;
     if (inner_window != outer_window) // So EndChild() within the inner window can restore the table properly.
@@ -453,13 +471,18 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
     if (table_idx >= g.TablesLastTimeActive.Size)
         g.TablesLastTimeActive.resize(table_idx + 1, -1.0f);
     g.TablesLastTimeActive[table_idx] = (float)g.Time;
+    temp_data->LastTimeActive = (float)g.Time;
     table->MemoryCompacted = false;
 
     // Setup memory buffer (clear data if columns count changed)
-    const int stored_size = table->Columns.size();
-    if (stored_size != 0 && stored_size != columns_count)
+    ImGuiTableColumn* old_columns_to_preserve = NULL;
+    void* old_columns_raw_data = NULL;
+    const int old_columns_count = table->Columns.size();
+    if (old_columns_count != 0 && old_columns_count != columns_count)
     {
-        IM_FREE(table->RawData);
+        // Attempt to preserve width on column count change (#4046)
+        old_columns_to_preserve = table->Columns.Data;
+        old_columns_raw_data = table->RawData;
         table->RawData = NULL;
     }
     if (table->RawData == NULL)
@@ -482,14 +505,24 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
         for (int n = 0; n < columns_count; n++)
         {
             ImGuiTableColumn* column = &table->Columns[n];
-            float width_auto = column->WidthAuto;
-            *column = ImGuiTableColumn();
-            column->WidthAuto = width_auto;
-            column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
+            if (old_columns_to_preserve && n < old_columns_count)
+            {
+                // FIXME: We don't attempt to preserve column order in this path.
+                *column = old_columns_to_preserve[n];
+            }
+            else
+            {
+                float width_auto = column->WidthAuto;
+                *column = ImGuiTableColumn();
+                column->WidthAuto = width_auto;
+                column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
+                column->IsEnabled = column->IsUserEnabled = column->IsUserEnabledNextFrame = true;
+            }
             column->DisplayOrder = table->DisplayOrderToIndex[n] = (ImGuiTableColumnIdx)n;
-            column->IsEnabled = column->IsEnabledNextFrame = true;
         }
     }
+    if (old_columns_raw_data)
+        IM_FREE(old_columns_raw_data);
 
     // Load settings
     if (table->IsSettingsRequestLoad)
@@ -530,6 +563,7 @@ bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImG
 // + 0 (for ImGuiTable instance, we are pooling allocations in g.Tables)
 // + 1 (for table->RawData allocated below)
 // + 1 (for table->ColumnsNames, if names are used)
+// Shared allocations per number of nested tables
 // + 1 (for table->Splitter._Channels)
 // + 2 * active_channels_count (for ImDrawCmd and ImDrawIdx buffers inside channels)
 // Where active_channels_count is variable but often == columns_count or columns_count + 1, see TableSetupDrawChannels() for details.
@@ -538,9 +572,9 @@ void ImGui::TableBeginInitMemory(ImGuiTable* table, int columns_count)
 {
     // Allocate single buffer for our arrays
     ImSpanAllocator<3> span_allocator;
-    span_allocator.ReserveBytes(0, columns_count * sizeof(ImGuiTableColumn));
-    span_allocator.ReserveBytes(1, columns_count * sizeof(ImGuiTableColumnIdx));
-    span_allocator.ReserveBytes(2, columns_count * sizeof(ImGuiTableCellData));
+    span_allocator.Reserve(0, columns_count * sizeof(ImGuiTableColumn));
+    span_allocator.Reserve(1, columns_count * sizeof(ImGuiTableColumnIdx));
+    span_allocator.Reserve(2, columns_count * sizeof(ImGuiTableCellData), 4);
     table->RawData = IM_ALLOC(span_allocator.GetArenaSizeInBytes());
     memset(table->RawData, 0, span_allocator.GetArenaSizeInBytes());
     span_allocator.SetArenaBasePtr(table->RawData);
@@ -635,7 +669,7 @@ static void TableSetupColumnFlags(ImGuiTable* table, ImGuiTableColumn* column, I
     {
         IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiTableColumnFlags_WidthMask_)); // Check that only 1 of each set is used.
     }
-    
+
     // Resize
     if ((table->Flags & ImGuiTableFlags_Resizable) == 0)
         flags |= ImGuiTableColumnFlags_NoResize;
@@ -687,13 +721,14 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
     table->ColumnsEnabledCount = 0;
     table->EnabledMaskByIndex = 0x00;
     table->EnabledMaskByDisplayOrder = 0x00;
+    table->LeftMostEnabledColumn = -1;
     table->MinColumnWidth = ImMax(1.0f, g.Style.FramePadding.x * 1.0f); // g.Style.ColumnsMinSpacing; // FIXME-TABLE
 
     // [Part 1] Apply/lock Enabled and Order states. Calculate auto/ideal width for columns. Count fixed/stretch columns.
     // Process columns in their visible orders as we are building the Prev/Next indices.
     int count_fixed = 0;                // Number of columns that have fixed sizing policies
     int count_stretch = 0;              // Number of columns that have stretch sizing policies
-    int last_visible_column_idx = -1;
+    int prev_visible_column_idx = -1;
     bool has_auto_fit_request = false;
     bool has_resizable = false;
     float stretch_sum_width_auto = 0.0f;
@@ -716,16 +751,18 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
             column->InitStretchWeightOrWidth = -1.0f;
         }
 
-        // Update Enabled state, mark settings/sortspecs dirty
+        // Update Enabled state, mark settings and sort specs dirty
         if (!(table->Flags & ImGuiTableFlags_Hideable) || (column->Flags & ImGuiTableColumnFlags_NoHide))
-            column->IsEnabledNextFrame = true;
-        if (column->IsEnabled != column->IsEnabledNextFrame)
+            column->IsUserEnabledNextFrame = true;
+        if (column->IsUserEnabled != column->IsUserEnabledNextFrame)
         {
-            column->IsEnabled = column->IsEnabledNextFrame;
+            column->IsUserEnabled = column->IsUserEnabledNextFrame;
             table->IsSettingsDirty = true;
-            if (!column->IsEnabled && column->SortOrder != -1)
-                table->IsSortSpecsDirty = true;
         }
+        column->IsEnabled = column->IsUserEnabled && (column->Flags & ImGuiTableColumnFlags_Disabled) == 0;
+
+        if (column->SortOrder != -1 && !column->IsEnabled)
+            table->IsSortSpecsDirty = true;
         if (column->SortOrder > 0 && !(table->Flags & ImGuiTableFlags_SortMulti))
             table->IsSortSpecsDirty = true;
 
@@ -741,14 +778,16 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
         }
 
         // Mark as enabled and link to previous/next enabled column
-        column->PrevEnabledColumn = (ImGuiTableColumnIdx)last_visible_column_idx;
+        column->PrevEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
         column->NextEnabledColumn = -1;
-        if (last_visible_column_idx != -1)
-            table->Columns[last_visible_column_idx].NextEnabledColumn = (ImGuiTableColumnIdx)column_n;
+        if (prev_visible_column_idx != -1)
+            table->Columns[prev_visible_column_idx].NextEnabledColumn = (ImGuiTableColumnIdx)column_n;
+        else
+            table->LeftMostEnabledColumn = (ImGuiTableColumnIdx)column_n;
         column->IndexWithinEnabledSet = table->ColumnsEnabledCount++;
         table->EnabledMaskByIndex |= (ImU64)1 << column_n;
         table->EnabledMaskByDisplayOrder |= (ImU64)1 << column->DisplayOrder;
-        last_visible_column_idx = column_n;
+        prev_visible_column_idx = column_n;
         IM_ASSERT(column->IndexWithinEnabledSet <= column->DisplayOrder);
 
         // Calculate ideal/auto column width (that's the width required for all contents to be visible without clipping)
@@ -778,8 +817,8 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
     }
     if ((table->Flags & ImGuiTableFlags_Sortable) && table->SortSpecsCount == 0 && !(table->Flags & ImGuiTableFlags_SortTristate))
         table->IsSortSpecsDirty = true;
-    table->RightMostEnabledColumn = (ImGuiTableColumnIdx)last_visible_column_idx;
-    IM_ASSERT(table->RightMostEnabledColumn >= 0);
+    table->RightMostEnabledColumn = (ImGuiTableColumnIdx)prev_visible_column_idx;
+    IM_ASSERT(table->LeftMostEnabledColumn >= 0 && table->RightMostEnabledColumn >= 0);
 
     // [Part 2] Disable child window clipping while fitting columns. This is not strictly necessary but makes it possible
     // to avoid the column fitting having to wait until the first visible frame of the child container (may or not be a good thing).
@@ -805,7 +844,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
             // Apply same widths policy
             float width_auto = column->WidthAuto;
             if (table_sizing_policy == ImGuiTableFlags_SizingFixedSame && (column->AutoFitQueue != 0x00 || !column_is_resizable))
-                width_auto = fixed_max_width_auto; 
+                width_auto = fixed_max_width_auto;
 
             // Apply automatic width
             // Latch initial size for fixed columns and update it constantly for auto-resizing column (unless clipped!)
@@ -1084,7 +1123,7 @@ void ImGui::TableUpdateLayout(ImGuiTable* table)
     // Initial state
     ImGuiWindow* inner_window = table->InnerWindow;
     if (table->Flags & ImGuiTableFlags_NoClip)
-        table->DrawSplitter.SetCurrentChannel(inner_window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
+        table->DrawSplitter->SetCurrentChannel(inner_window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
     else
         inner_window->DrawList->PushClipRect(inner_window->ClipRect.Min, inner_window->ClipRect.Max, false);
 }
@@ -1122,9 +1161,8 @@ void ImGui::TableUpdateBorders(ImGuiTable* table)
         if ((table->Flags & ImGuiTableFlags_NoBordersInBody) && table->IsUsingHeaders == false)
             continue;
 
-        if (table->FreezeColumnsCount > 0)
-            if (column->MaxX < table->Columns[table->DisplayOrderToIndex[table->FreezeColumnsCount - 1]].MaxX)
-                continue;
+        if (!column->IsVisibleX && table->LastResizedColumn != column_n)
+            continue;
 
         ImGuiID column_id = TableGetColumnResizeID(table, column_n, table->InstanceCurrent);
         ImRect hit_rect(column->MaxX - hit_half_width, hit_y1, column->MaxX + hit_half_width, border_y2_hit);
@@ -1132,7 +1170,7 @@ void ImGui::TableUpdateBorders(ImGuiTable* table)
         KeepAliveID(column_id);
 
         bool hovered = false, held = false;
-        bool pressed = ButtonBehavior(hit_rect, column_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_AllowItemOverlap | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick);
+        bool pressed = ButtonBehavior(hit_rect, column_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren | ImGuiButtonFlags_AllowItemOverlap | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_NoNavFocus);
         if (pressed && IsMouseDoubleClicked(0))
         {
             TableSetColumnWidthAutoSingle(table, column_n);
@@ -1172,6 +1210,7 @@ void    ImGui::EndTable()
     const ImGuiTableFlags flags = table->Flags;
     ImGuiWindow* inner_window = table->InnerWindow;
     ImGuiWindow* outer_window = table->OuterWindow;
+    ImGuiTableTempData* temp_data = table->TempData;
     IM_ASSERT(inner_window == g.CurrentWindow);
     IM_ASSERT(outer_window == inner_window || outer_window == inner_window->ParentWindow);
 
@@ -1184,9 +1223,9 @@ void    ImGui::EndTable()
             TableOpenContextMenu((int)table->HoveredColumnBody);
 
     // Finalize table height
-    inner_window->DC.PrevLineSize = table->HostBackupPrevLineSize;
-    inner_window->DC.CurrLineSize = table->HostBackupCurrLineSize;
-    inner_window->DC.CursorMaxPos = table->HostBackupCursorMaxPos;
+    inner_window->DC.PrevLineSize = temp_data->HostBackupPrevLineSize;
+    inner_window->DC.CurrLineSize = temp_data->HostBackupCurrLineSize;
+    inner_window->DC.CursorMaxPos = temp_data->HostBackupCursorMaxPos;
     const float inner_content_max_y = table->RowPosY2;
     IM_ASSERT(table->RowPosY2 == inner_window->DC.CursorPos.y);
     if (inner_window != outer_window)
@@ -1233,10 +1272,11 @@ void    ImGui::EndTable()
 #endif
 
     // Flatten channels and merge draw calls
-    table->DrawSplitter.SetCurrentChannel(inner_window->DrawList, 0);
+    ImDrawListSplitter* splitter = table->DrawSplitter;
+    splitter->SetCurrentChannel(inner_window->DrawList, 0);
     if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
         TableMergeDrawChannels(table);
-    table->DrawSplitter.Merge(inner_window->DrawList);
+    splitter->Merge(inner_window->DrawList);
 
     // Update ColumnsAutoFitWidth to get us ahead for host using our size to auto-resize without waiting for next BeginTable()
     const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
@@ -1278,18 +1318,18 @@ void    ImGui::EndTable()
 
     // Pop from id stack
     IM_ASSERT_USER_ERROR(inner_window->IDStack.back() == table->ID + table->InstanceCurrent, "Mismatching PushID/PopID!");
-    IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= table->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
+    IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= temp_data->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
     PopID();
 
     // Restore window data that we modified
     const ImVec2 backup_outer_max_pos = outer_window->DC.CursorMaxPos;
-    inner_window->WorkRect = table->HostBackupWorkRect;
-    inner_window->ParentWorkRect = table->HostBackupParentWorkRect;
+    inner_window->WorkRect = temp_data->HostBackupWorkRect;
+    inner_window->ParentWorkRect = temp_data->HostBackupParentWorkRect;
     inner_window->SkipItems = table->HostSkipItems;
     outer_window->DC.CursorPos = table->OuterRect.Min;
-    outer_window->DC.ItemWidth = table->HostBackupItemWidth;
-    outer_window->DC.ItemWidthStack.Size = table->HostBackupItemWidthStackSize;
-    outer_window->DC.ColumnsOffset = table->HostBackupColumnsOffset;
+    outer_window->DC.ItemWidth = temp_data->HostBackupItemWidth;
+    outer_window->DC.ItemWidthStack.Size = temp_data->HostBackupItemWidthStackSize;
+    outer_window->DC.ColumnsOffset = temp_data->HostBackupColumnsOffset;
 
     // Layout in outer window
     // (FIXME: To allow auto-fit and allow desirable effect of SameLine() we dissociate 'used' vs 'ideal' size by overriding
@@ -1312,20 +1352,20 @@ void    ImGui::EndTable()
         IM_ASSERT((table->Flags & ImGuiTableFlags_ScrollX) == 0);
         outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth);
     }
-    else if (table->UserOuterSize.x <= 0.0f)
+    else if (temp_data->UserOuterSize.x <= 0.0f)
     {
         const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.x : 0.0f;
-        outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth + decoration_size - table->UserOuterSize.x);
+        outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth + decoration_size - temp_data->UserOuterSize.x);
         outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, ImMin(table->OuterRect.Max.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth));
     }
     else
     {
         outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Max.x);
     }
-    if (table->UserOuterSize.y <= 0.0f)
+    if (temp_data->UserOuterSize.y <= 0.0f)
     {
         const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollY) ? inner_window->ScrollbarSizes.y : 0.0f;
-        outer_window->DC.IdealMaxPos.y = ImMax(outer_window->DC.IdealMaxPos.y, inner_content_max_y + decoration_size - table->UserOuterSize.y);
+        outer_window->DC.IdealMaxPos.y = ImMax(outer_window->DC.IdealMaxPos.y, inner_content_max_y + decoration_size - temp_data->UserOuterSize.y);
         outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, ImMin(table->OuterRect.Max.y, inner_content_max_y));
     }
     else
@@ -1341,8 +1381,14 @@ void    ImGui::EndTable()
 
     // Clear or restore current table, if any
     IM_ASSERT(g.CurrentWindow == outer_window && g.CurrentTable == table);
-    g.CurrentTableStack.pop_back();
-    g.CurrentTable = g.CurrentTableStack.Size ? g.Tables.GetByIndex(g.CurrentTableStack.back().Index) : NULL;
+    IM_ASSERT(g.TablesTempDataStacked > 0);
+    temp_data = (--g.TablesTempDataStacked > 0) ? &g.TablesTempData[g.TablesTempDataStacked - 1] : NULL;
+    g.CurrentTable = temp_data ? g.Tables.GetByIndex(temp_data->TableIndex) : NULL;
+    if (g.CurrentTable)
+    {
+        g.CurrentTable->TempData = temp_data;
+        g.CurrentTable->DrawSplitter = &temp_data->DrawSplitter;
+    }
     outer_window->DC.CurrentTableIdx = g.CurrentTable ? g.Tables.GetIndex(g.CurrentTable) : -1;
 }
 
@@ -1367,7 +1413,7 @@ void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, flo
     // Assert when passing a width or weight if policy is entirely left to default, to avoid storing width into weight and vice-versa.
     // Give a grace to users of ImGuiTableFlags_ScrollX.
     if (table->IsDefaultSizingPolicy && (flags & ImGuiTableColumnFlags_WidthMask_) == 0 && (flags & ImGuiTableFlags_ScrollX) == 0)
-        IM_ASSERT(init_width_or_weight <= 0.0f && "Can only specify width/weight if sizing policy is set explicitely in either Table or Column.");
+        IM_ASSERT(init_width_or_weight <= 0.0f && "Can only specify width/weight if sizing policy is set explicitly in either Table or Column.");
 
     // When passing a width automatically enforce WidthFixed policy
     // (whereas TableSetupColumnFlags would default to WidthAuto if table is not Resizable)
@@ -1398,7 +1444,7 @@ void ImGui::TableSetupColumn(const char* label, ImGuiTableColumnFlags flags, flo
 
         // Init default visibility/sort state
         if ((flags & ImGuiTableColumnFlags_DefaultHide) && (table->SettingsLoadedFlags & ImGuiTableFlags_Hideable) == 0)
-            column->IsEnabled = column->IsEnabledNextFrame = false;
+            column->IsUserEnabled = column->IsUserEnabledNextFrame = false;
         if (flags & ImGuiTableColumnFlags_DefaultSort && (table->SettingsLoadedFlags & ImGuiTableFlags_Sortable) == 0)
         {
             column->SortOrder = 0; // Multiple columns using _DefaultSort will be reassigned unique SortOrder values when building the sort specs.
@@ -1425,13 +1471,39 @@ void ImGui::TableSetupScrollFreeze(int columns, int rows)
     IM_ASSERT(columns >= 0 && columns < IMGUI_TABLE_MAX_COLUMNS);
     IM_ASSERT(rows >= 0 && rows < 128); // Arbitrary limit
 
-    table->FreezeColumnsRequest = (table->Flags & ImGuiTableFlags_ScrollX) ? (ImGuiTableColumnIdx)columns : 0;
+    table->FreezeColumnsRequest = (table->Flags & ImGuiTableFlags_ScrollX) ? (ImGuiTableColumnIdx)ImMin(columns, table->ColumnsCount) : 0;
     table->FreezeColumnsCount = (table->InnerWindow->Scroll.x != 0.0f) ? table->FreezeColumnsRequest : 0;
     table->FreezeRowsRequest = (table->Flags & ImGuiTableFlags_ScrollY) ? (ImGuiTableColumnIdx)rows : 0;
     table->FreezeRowsCount = (table->InnerWindow->Scroll.y != 0.0f) ? table->FreezeRowsRequest : 0;
     table->IsUnfrozenRows = (table->FreezeRowsCount == 0); // Make sure this is set before TableUpdateLayout() so ImGuiListClipper can benefit from it.b
+
+    // Ensure frozen columns are ordered in their section. We still allow multiple frozen columns to be reordered.
+    // FIXME-TABLE: This work for preserving 2143 into 21|43. How about 4321 turning into 21|43? (preserve relative order in each section)
+    for (int column_n = 0; column_n < table->FreezeColumnsRequest; column_n++)
+    {
+        int order_n = table->DisplayOrderToIndex[column_n];
+        if (order_n != column_n && order_n >= table->FreezeColumnsRequest)
+        {
+            ImSwap(table->Columns[table->DisplayOrderToIndex[order_n]].DisplayOrder, table->Columns[table->DisplayOrderToIndex[column_n]].DisplayOrder);
+            ImSwap(table->DisplayOrderToIndex[order_n], table->DisplayOrderToIndex[column_n]);
+        }
+    }
 }
 
+//-----------------------------------------------------------------------------
+// [SECTION] Tables: Simple accessors
+//-----------------------------------------------------------------------------
+// - TableGetColumnCount()
+// - TableGetColumnName()
+// - TableGetColumnName() [Internal]
+// - TableSetColumnEnabled()
+// - TableGetColumnFlags()
+// - TableGetCellBgRect() [Internal]
+// - TableGetColumnResizeID() [Internal]
+// - TableGetHoveredColumn() [Internal]
+// - TableSetBgColor()
+//-----------------------------------------------------------------------------
+
 int ImGui::TableGetColumnCount()
 {
     ImGuiContext& g = *GImGui;
@@ -1460,6 +1532,27 @@ const char* ImGui::TableGetColumnName(const ImGuiTable* table, int column_n)
     return &table->ColumnsNames.Buf[column->NameOffset];
 }
 
+// Change user accessible enabled/disabled state of a column (often perceived as "showing/hiding" from users point of view)
+// Note that end-user can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)
+// - Require table to have the ImGuiTableFlags_Hideable flag because we are manipulating user accessible state.
+// - Request will be applied during next layout, which happens on the first call to TableNextRow() after BeginTable().
+// - For the getter you can test (TableGetColumnFlags() & ImGuiTableColumnFlags_IsEnabled) != 0.
+// - Alternative: the ImGuiTableColumnFlags_Disabled is an overriding/master disable flag which will also hide the column from context menu.
+void ImGui::TableSetColumnEnabled(int column_n, bool enabled)
+{
+    ImGuiContext& g = *GImGui;
+    ImGuiTable* table = g.CurrentTable;
+    IM_ASSERT(table != NULL);
+    if (!table)
+        return;
+    IM_ASSERT(table->Flags & ImGuiTableFlags_Hideable); // See comments above
+    if (column_n < 0)
+        column_n = table->CurrentColumn;
+    IM_ASSERT(column_n >= 0 && column_n < table->ColumnsCount);
+    ImGuiTableColumn* column = &table->Columns[column_n];
+    column->IsUserEnabledNextFrame = enabled;
+}
+
 // We allow querying for an extra column in order to poll the IsHovered state of the right-most section
 ImGuiTableColumnFlags ImGui::TableGetColumnFlags(int column_n)
 {
@@ -1639,6 +1732,10 @@ void ImGui::TableEndRow(ImGuiTable* table)
     if (table->CurrentColumn != -1)
         TableEndCell(table);
 
+    // Logging
+    if (g.LogEnabled)
+        LogRenderedText(NULL, "|");
+
     // Position cursor at the bottom of our row so it can be used for e.g. clipping calculation. However it is
     // likely that the next call to TableBeginCell() will reposition the cursor to take account of vertical padding.
     window->DC.CursorPos.y = table->RowPosY2;
@@ -1679,7 +1776,7 @@ void ImGui::TableEndRow(ImGuiTable* table)
             // always followed by a change of clipping rectangle we perform the smallest overwrite possible here.
             if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
                 window->DrawList->_CmdHeader.ClipRect = table->Bg0ClipRectForDrawCmd.ToVec4();
-            table->DrawSplitter.SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_BG0);
+            table->DrawSplitter->SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_BG0);
         }
 
         // Draw row background
@@ -1751,7 +1848,7 @@ void ImGui::TableEndRow(ImGuiTable* table)
 
         // Update cliprect ahead of TableBeginCell() so clipper can access to new ClipRect->Min.y
         SetWindowClipRectBeforeSetChannel(window, table->Columns[0].ClipRect);
-        table->DrawSplitter.SetCurrentChannel(window->DrawList, table->Columns[0].DrawChannelCurrent);
+        table->DrawSplitter->SetCurrentChannel(window->DrawList, table->Columns[0].DrawChannelCurrent);
     }
 
     if (!(table->RowFlags & ImGuiTableRowFlags_Headers))
@@ -1859,21 +1956,30 @@ void ImGui::TableBeginCell(ImGuiTable* table, int column_n)
     window->SkipItems = column->IsSkipItems;
     if (column->IsSkipItems)
     {
-        window->DC.LastItemId = 0;
-        window->DC.LastItemStatusFlags = 0;
+        ImGuiContext& g = *GImGui;
+        g.LastItemData.ID = 0;
+        g.LastItemData.StatusFlags = 0;
     }
 
     if (table->Flags & ImGuiTableFlags_NoClip)
     {
         // FIXME: if we end up drawing all borders/bg in EndTable, could remove this and just assert that channel hasn't changed.
-        table->DrawSplitter.SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
+        table->DrawSplitter->SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_NOCLIP);
         //IM_ASSERT(table->DrawSplitter._Current == TABLE_DRAW_CHANNEL_NOCLIP);
     }
     else
     {
         // FIXME-TABLE: Could avoid this if draw channel is dummy channel?
         SetWindowClipRectBeforeSetChannel(window, column->ClipRect);
-        table->DrawSplitter.SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
+        table->DrawSplitter->SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
+    }
+
+    // Logging
+    ImGuiContext& g = *GImGui;
+    if (g.LogEnabled && !column->IsSkipItems)
+    {
+        LogRenderedText(&window->DC.CursorPos, "|");
+        g.LogLinePosY = FLT_MAX;
     }
 }
 
@@ -1918,6 +2024,7 @@ float ImGui::TableGetMaxColumnWidth(const ImGuiTable* table, int column_n)
     if (table->Flags & ImGuiTableFlags_ScrollX)
     {
         // Frozen columns can't reach beyond visible width else scrolling will naturally break.
+        // (we use DisplayOrder as within a set of multiple frozen column reordering is possible)
         if (column->DisplayOrder < table->FreezeColumnsRequest)
         {
             max_width = (table->InnerClipRect.Max.x - (table->FreezeColumnsRequest - column->DisplayOrder) * min_column_distance) - column->MinX;
@@ -2113,7 +2220,7 @@ void ImGui::TablePushBackgroundChannel()
     // Optimization: avoid SetCurrentChannel() + PushClipRect()
     table->HostBackupInnerClipRect = window->ClipRect;
     SetWindowClipRectBeforeSetChannel(window, table->Bg2ClipRectForDrawCmd);
-    table->DrawSplitter.SetCurrentChannel(window->DrawList, table->Bg2DrawChannelCurrent);
+    table->DrawSplitter->SetCurrentChannel(window->DrawList, table->Bg2DrawChannelCurrent);
 }
 
 void ImGui::TablePopBackgroundChannel()
@@ -2125,7 +2232,7 @@ void ImGui::TablePopBackgroundChannel()
 
     // Optimization: avoid PopClipRect() + SetCurrentChannel()
     SetWindowClipRectBeforeSetChannel(window, table->HostBackupInnerClipRect);
-    table->DrawSplitter.SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
+    table->DrawSplitter->SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
 }
 
 // Allocate draw channels. Called by TableUpdateLayout()
@@ -2151,7 +2258,7 @@ void ImGui::TableSetupDrawChannels(ImGuiTable* table)
     const int channels_for_bg = 1 + 1 * freeze_row_multiplier;
     const int channels_for_dummy = (table->ColumnsEnabledCount < table->ColumnsCount || table->VisibleMaskByIndex != table->EnabledMaskByIndex) ? +1 : 0;
     const int channels_total = channels_for_bg + (channels_for_row * freeze_row_multiplier) + channels_for_dummy;
-    table->DrawSplitter.Split(table->InnerWindow->DrawList, channels_total);
+    table->DrawSplitter->Split(table->InnerWindow->DrawList, channels_total);
     table->DummyDrawChannel = (ImGuiTableDrawChannelIdx)((channels_for_dummy > 0) ? channels_total - 1 : -1);
     table->Bg2DrawChannelCurrent = TABLE_DRAW_CHANNEL_BG2_FROZEN;
     table->Bg2DrawChannelUnfrozen = (ImGuiTableDrawChannelIdx)((table->FreezeRowsCount > 0) ? 2 + channels_for_row : TABLE_DRAW_CHANNEL_BG2_FROZEN);
@@ -2215,7 +2322,7 @@ void ImGui::TableSetupDrawChannels(ImGuiTable* table)
 void ImGui::TableMergeDrawChannels(ImGuiTable* table)
 {
     ImGuiContext& g = *GImGui;
-    ImDrawListSplitter* splitter = &table->DrawSplitter;
+    ImDrawListSplitter* splitter = table->DrawSplitter;
     const bool has_freeze_v = (table->FreezeRowsCount > 0);
     const bool has_freeze_h = (table->FreezeColumnsCount > 0);
     IM_ASSERT(splitter->_Current == 0);
@@ -2226,10 +2333,11 @@ void ImGui::TableMergeDrawChannels(ImGuiTable* table)
         ImRect  ClipRect;
         int     ChannelsCount;
         ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> ChannelsMask;
+
+        MergeGroup() { ChannelsCount = 0; }
     };
     int merge_group_mask = 0x00;
     MergeGroup merge_groups[4];
-    memset(merge_groups, 0, sizeof(merge_groups));
 
     // 1. Scan channels and take note of those which can be merged
     for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
@@ -2307,7 +2415,6 @@ void ImGui::TableMergeDrawChannels(ImGuiTable* table)
         g.DrawChannelsTempMergeBuffer.resize(splitter->_Count - LEADING_DRAW_CHANNELS); // Use shared temporary storage so the allocation gets amortized
         ImDrawChannel* dst_tmp = g.DrawChannelsTempMergeBuffer.Data;
         ImBitArray<IMGUI_TABLE_MAX_DRAW_CHANNELS> remaining_mask;                       // We need 132-bit of storage
-        remaining_mask.ClearAllBits();
         remaining_mask.SetBitRange(LEADING_DRAW_CHANNELS, splitter->_Count);
         remaining_mask.ClearBit(table->Bg2DrawChannelUnfrozen);
         IM_ASSERT(has_freeze_v == false || table->Bg2DrawChannelUnfrozen != TABLE_DRAW_CHANNEL_BG2_FROZEN);
@@ -2337,7 +2444,7 @@ void ImGui::TableMergeDrawChannels(ImGuiTable* table)
                 if ((merge_group_n & 2) != 0 && (table->Flags & ImGuiTableFlags_NoHostExtendY) == 0)
                     merge_clip_rect.Max.y = ImMax(merge_clip_rect.Max.y, host_rect.Max.y);
 #if 0
-                GetOverlayDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 0, 0, 200), 0.0f, ~0, 1.0f);
+                GetOverlayDrawList()->AddRect(merge_group->ClipRect.Min, merge_group->ClipRect.Max, IM_COL32(255, 0, 0, 200), 0.0f, 0, 1.0f);
                 GetOverlayDrawList()->AddLine(merge_group->ClipRect.Min, merge_clip_rect.Min, IM_COL32(255, 100, 0, 200));
                 GetOverlayDrawList()->AddLine(merge_group->ClipRect.Max, merge_clip_rect.Max, IM_COL32(255, 100, 0, 200));
 #endif
@@ -2386,7 +2493,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table)
         return;
 
     ImDrawList* inner_drawlist = inner_window->DrawList;
-    table->DrawSplitter.SetCurrentChannel(inner_drawlist, TABLE_DRAW_CHANNEL_BG0);
+    table->DrawSplitter->SetCurrentChannel(inner_drawlist, TABLE_DRAW_CHANNEL_BG0);
     inner_drawlist->PushClipRect(table->Bg0ClipRectForDrawCmd.Min, table->Bg0ClipRectForDrawCmd.Max, false);
 
     // Draw inner border and resizing feedback
@@ -2406,7 +2513,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table)
             const bool is_hovered = (table->HoveredColumnBorder == column_n);
             const bool is_resized = (table->ResizedColumn == column_n) && (table->InstanceInteracted == table->InstanceCurrent);
             const bool is_resizable = (column->Flags & (ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_NoDirectResize_)) == 0;
-            const bool is_frozen_separator = (table->FreezeColumnsCount != -1 && table->FreezeColumnsCount == order_n + 1);
+            const bool is_frozen_separator = (table->FreezeColumnsCount == order_n + 1);
             if (column->MaxX > table->InnerClipRect.Max.x && !is_resized)
                 continue;
 
@@ -2450,7 +2557,7 @@ void ImGui::TableDrawBorders(ImGuiTable* table)
         const ImU32 outer_col = table->BorderColorStrong;
         if ((table->Flags & ImGuiTableFlags_BordersOuter) == ImGuiTableFlags_BordersOuter)
         {
-            inner_drawlist->AddRect(outer_border.Min, outer_border.Max, outer_col, 0.0f, ~0, border_size);
+            inner_drawlist->AddRect(outer_border.Min, outer_border.Max, outer_col, 0.0f, 0, border_size);
         }
         else if (table->Flags & ImGuiTableFlags_BordersOuterV)
         {
@@ -2502,8 +2609,7 @@ ImGuiTableSortSpecs* ImGui::TableGetSortSpecs()
     if (!table->IsLayoutLocked)
         TableUpdateLayout(table);
 
-    if (table->IsSortSpecsDirty)
-        TableSortSpecsBuild(table);
+    TableSortSpecsBuild(table);
 
     return &table->SortSpecs;
 }
@@ -2642,28 +2748,33 @@ void ImGui::TableSortSpecsSanitize(ImGuiTable* table)
 
 void ImGui::TableSortSpecsBuild(ImGuiTable* table)
 {
-    IM_ASSERT(table->IsSortSpecsDirty);
-    TableSortSpecsSanitize(table);
+    bool dirty = table->IsSortSpecsDirty;
+    if (dirty)
+    {
+        TableSortSpecsSanitize(table);
+        table->SortSpecsMulti.resize(table->SortSpecsCount <= 1 ? 0 : table->SortSpecsCount);
+        table->SortSpecs.SpecsDirty = true; // Mark as dirty for user
+        table->IsSortSpecsDirty = false; // Mark as not dirty for us
+    }
 
     // Write output
-    table->SortSpecsMulti.resize(table->SortSpecsCount <= 1 ? 0 : table->SortSpecsCount);
     ImGuiTableColumnSortSpecs* sort_specs = (table->SortSpecsCount == 0) ? NULL : (table->SortSpecsCount == 1) ? &table->SortSpecsSingle : table->SortSpecsMulti.Data;
-    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
-    {
-        ImGuiTableColumn* column = &table->Columns[column_n];
-        if (column->SortOrder == -1)
-            continue;
-        IM_ASSERT(column->SortOrder < table->SortSpecsCount);
-        ImGuiTableColumnSortSpecs* sort_spec = &sort_specs[column->SortOrder];
-        sort_spec->ColumnUserID = column->UserID;
-        sort_spec->ColumnIndex = (ImGuiTableColumnIdx)column_n;
-        sort_spec->SortOrder = (ImGuiTableColumnIdx)column->SortOrder;
-        sort_spec->SortDirection = column->SortDirection;
-    }
+    if (dirty && sort_specs != NULL)
+        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
+        {
+            ImGuiTableColumn* column = &table->Columns[column_n];
+            if (column->SortOrder == -1)
+                continue;
+            IM_ASSERT(column->SortOrder < table->SortSpecsCount);
+            ImGuiTableColumnSortSpecs* sort_spec = &sort_specs[column->SortOrder];
+            sort_spec->ColumnUserID = column->UserID;
+            sort_spec->ColumnIndex = (ImGuiTableColumnIdx)column_n;
+            sort_spec->SortOrder = (ImGuiTableColumnIdx)column->SortOrder;
+            sort_spec->SortDirection = column->SortDirection;
+        }
+
     table->SortSpecs.Specs = sort_specs;
     table->SortSpecs.SpecsCount = table->SortSpecsCount;
-    table->SortSpecs.SpecsDirty = true; // Mark as dirty for user
-    table->IsSortSpecsDirty = false; // Mark as not dirty for us
 }
 
 //-------------------------------------------------------------------------
@@ -2683,8 +2794,11 @@ float ImGui::TableGetHeaderRowHeight()
     float row_height = GetTextLineHeight();
     int columns_count = TableGetColumnCount();
     for (int column_n = 0; column_n < columns_count; column_n++)
-        if (TableGetColumnFlags(column_n) & ImGuiTableColumnFlags_IsEnabled)
+    {
+        ImGuiTableColumnFlags flags = TableGetColumnFlags(column_n);
+        if ((flags & ImGuiTableColumnFlags_IsEnabled) && !(flags & ImGuiTableColumnFlags_NoHeaderLabel))
             row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(column_n)).y);
+    }
     row_height += GetStyle().CellPadding.y * 2.0f;
     return row_height;
 }
@@ -2721,7 +2835,7 @@ void ImGui::TableHeadersRow()
         // Push an id to allow unnamed labels (generally accidental, but let's behave nicely with them)
         // - in your own code you may omit the PushID/PopID all-together, provided you know they won't collide
         // - table->InstanceCurrent is only >0 when we use multiple BeginTable/EndTable calls with same identifier.
-        const char* name = TableGetColumnName(column_n);
+        const char* name = (TableGetColumnFlags(column_n) & ImGuiTableColumnFlags_NoHeaderLabel) ? "" : TableGetColumnName(column_n);
         PushID(table->InstanceCurrent * table->ColumnsCount + column_n);
         TableHeader(name);
         PopID();
@@ -2803,7 +2917,6 @@ void ImGui::TableHeader(const char* label)
         const ImU32 col = GetColorU32(held ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
         //RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
         TableSetBgColor(ImGuiTableBgTarget_CellBg, col, table->CurrentColumn);
-        RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
     }
     else
     {
@@ -2811,6 +2924,7 @@ void ImGui::TableHeader(const char* label)
         if ((table->RowFlags & ImGuiTableRowFlags_Headers) == 0)
             TableSetBgColor(ImGuiTableBgTarget_CellBg, GetColorU32(ImGuiCol_TableHeaderBg), table->CurrentColumn);
     }
+    RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
     if (held)
         table->HeldHeaderColumn = (ImGuiTableColumnIdx)column_n;
     window->DC.CursorPos.y -= g.Style.ItemSpacing.y * 0.5f;
@@ -2976,16 +3090,19 @@ void ImGui::TableDrawContextMenu(ImGuiTable* table)
         for (int other_column_n = 0; other_column_n < table->ColumnsCount; other_column_n++)
         {
             ImGuiTableColumn* other_column = &table->Columns[other_column_n];
+            if (other_column->Flags & ImGuiTableColumnFlags_Disabled)
+                continue;
+
             const char* name = TableGetColumnName(table, other_column_n);
             if (name == NULL || name[0] == 0)
                 name = "<Unknown>";
 
             // Make sure we can't hide the last active column
             bool menu_item_active = (other_column->Flags & ImGuiTableColumnFlags_NoHide) ? false : true;
-            if (other_column->IsEnabled && table->ColumnsEnabledCount <= 1)
+            if (other_column->IsUserEnabled && table->ColumnsEnabledCount <= 1)
                 menu_item_active = false;
-            if (MenuItem(name, NULL, other_column->IsEnabled, menu_item_active))
-                other_column->IsEnabledNextFrame = !other_column->IsEnabled;
+            if (MenuItem(name, NULL, other_column->IsUserEnabled, menu_item_active))
+                other_column->IsUserEnabledNextFrame = !other_column->IsUserEnabled;
         }
         PopItemFlag();
     }
@@ -3110,7 +3227,7 @@ void ImGui::TableSaveSettings(ImGuiTable* table)
         column_settings->DisplayOrder = column->DisplayOrder;
         column_settings->SortOrder = column->SortOrder;
         column_settings->SortDirection = column->SortDirection;
-        column_settings->IsEnabled = column->IsEnabled;
+        column_settings->IsEnabled = column->IsUserEnabled;
         column_settings->IsStretch = (column->Flags & ImGuiTableColumnFlags_WidthStretch) ? 1 : 0;
         if ((column->Flags & ImGuiTableColumnFlags_WidthStretch) == 0)
             save_ref_scale = true;
@@ -3124,7 +3241,7 @@ void ImGui::TableSaveSettings(ImGuiTable* table)
             settings->SaveFlags |= ImGuiTableFlags_Reorderable;
         if (column->SortOrder != -1)
             settings->SaveFlags |= ImGuiTableFlags_Sortable;
-        if (column->IsEnabled != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0))
+        if (column->IsUserEnabled != ((column->Flags & ImGuiTableColumnFlags_DefaultHide) == 0))
             settings->SaveFlags |= ImGuiTableFlags_Hideable;
     }
     settings->SaveFlags &= table->Flags;
@@ -3182,7 +3299,7 @@ void ImGui::TableLoadSettings(ImGuiTable* table)
         else
             column->DisplayOrder = (ImGuiTableColumnIdx)column_n;
         display_order_mask |= (ImU64)1 << column->DisplayOrder;
-        column->IsEnabled = column->IsEnabledNextFrame = column_settings->IsEnabled;
+        column->IsUserEnabled = column->IsUserEnabledNextFrame = column_settings->IsEnabled;
         column->SortOrder = column_settings->SortOrder;
         column->SortDirection = column_settings->SortDirection;
     }
@@ -3201,8 +3318,9 @@ void ImGui::TableLoadSettings(ImGuiTable* table)
 static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
 {
     ImGuiContext& g = *ctx;
-    for (int i = 0; i != g.Tables.GetSize(); i++)
-        g.Tables.GetByIndex(i)->SettingsOffset = -1;
+    for (int i = 0; i != g.Tables.GetMapSize(); i++)
+        if (ImGuiTable* table = g.Tables.TryGetMapData(i))
+            table->SettingsOffset = -1;
     g.SettingsTables.clear();
 }
 
@@ -3210,12 +3328,12 @@ static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandle
 static void TableSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
 {
     ImGuiContext& g = *ctx;
-    for (int i = 0; i != g.Tables.GetSize(); i++)
-    {
-        ImGuiTable* table = g.Tables.GetByIndex(i);
-        table->IsSettingsRequestLoad = true;
-        table->SettingsOffset = -1;
-    }
+    for (int i = 0; i != g.Tables.GetMapSize(); i++)
+        if (ImGuiTable* table = g.Tables.TryGetMapData(i))
+        {
+            table->IsSettingsRequestLoad = true;
+            table->SettingsOffset = -1;
+        }
 }
 
 static void* TableSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name)
@@ -3288,6 +3406,9 @@ static void TableSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandle
         for (int column_n = 0; column_n < settings->ColumnsCount; column_n++, column++)
         {
             // "Column 0  UserID=0x42AD2D21 Width=100 Visible=1 Order=0 Sort=0v"
+            bool save_column = column->UserID != 0 || save_size || save_visible || save_order || (save_sort && column->SortOrder != -1);
+            if (!save_column)
+                continue;
             buf->appendf("Column %-2d", column_n);
             if (column->UserID != 0)                    buf->appendf(" UserID=%08X", column->UserID);
             if (save_size && column->IsStretch)         buf->appendf(" Weight=%.4f", column->WidthOrWeight);
@@ -3341,10 +3462,9 @@ void ImGui::TableGcCompactTransientBuffers(ImGuiTable* table)
     //IMGUI_DEBUG_LOG("TableGcCompactTransientBuffers() id=0x%08X\n", table->ID);
     ImGuiContext& g = *GImGui;
     IM_ASSERT(table->MemoryCompacted == false);
-    table->DrawSplitter.ClearFreeMemory();
-    table->SortSpecsMulti.clear();
     table->SortSpecs.Specs = NULL;
-    table->IsSortSpecsDirty = true;
+    table->SortSpecsMulti.clear();
+    table->IsSortSpecsDirty = true; // FIXME: shouldn't have to leak into user performing a sort
     table->ColumnsNames.clear();
     table->MemoryCompacted = true;
     for (int n = 0; n < table->ColumnsCount; n++)
@@ -3352,6 +3472,12 @@ void ImGui::TableGcCompactTransientBuffers(ImGuiTable* table)
     g.TablesLastTimeActive[g.Tables.GetIndex(table)] = -1.0f;
 }
 
+void ImGui::TableGcCompactTransientBuffers(ImGuiTableTempData* temp_data)
+{
+    temp_data->DrawSplitter.ClearFreeMemory();
+    temp_data->LastTimeActive = -1.0f;
+}
+
 // Compact and remove unused settings data (currently only used by TestEngine)
 void ImGui::TableGcCompactSettings()
 {
@@ -3861,7 +3987,7 @@ void ImGui::EndColumns()
             const float column_hit_hw = COLUMNS_HIT_RECT_HALF_WIDTH;
             const ImRect column_hit_rect(ImVec2(x - column_hit_hw, y1), ImVec2(x + column_hit_hw, y2));
             KeepAliveID(column_id);
-            if (IsClippedEx(column_hit_rect, column_id, false))
+            if (IsClippedEx(column_hit_rect, column_id)) // FIXME: Can be removed or replaced with a lower-level test
                 continue;
 
             bool hovered = false, held = false;