Merge 098a8c1697 into d11cb3779b

Win32: Remove support for Windows XP and Vista
It's increasingly difficult to maintain a safe testing environment for Windows XP, and so increasingly a burden on contributors to maintain support for it. Windows XP has been out of of support since 2014 and should not be used as a desktop OS. Fixes #2505
2025-12-20 14:11:55 +00:00 · 2025-07-15 11:01:54 +02:00 · 2025-07-11 16:49:23 +02:00 · 2025-07-10 17:59:12 +02:00 · 2024-07-17 11:05:30 -04:00
16 changed files with 825 additions and 2963 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@ -29,7 +29,7 @@ for:
        only:
            - GENERATOR: MinGW Makefiles
    build_script:
-        - set PATH=%PATH:C:\Program Files\Git\usr\bin=C:\MinGW\bin%
+        - set PATH=C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;%PATH:C:\Program Files\Git\usr\bin=%
        - cmake -B build -G "%GENERATOR%" -DBUILD_SHARED_LIBS=%BUILD_SHARED_LIBS%
        - cmake --build build
 -
--- a/.editorconfig
+++ b/.editorconfig
@ -41,12 +41,6 @@ indent_size = 2
 indent_style = tab
 indent_size = unset

-[deps/mingw/*.h]
-indent_style = space
-indent_size = 4
-tab_width = 8
-trim_trailing_whitespace = false
-
 [deps/getopt.{c,h}]
 indent_style = space
 indent_size = 2
--- a/README.md
+++ b/README.md
@ -52,7 +52,7 @@ and window system.  It does not need any additional headers for context creation
 APIs (WGL, GLX, EGL, NSGL, OSMesa) or rendering APIs (OpenGL, OpenGL ES, Vulkan)
 to enable support for them.

-GLFW supports compilation on Windows with Visual C++ 2013 and later, MinGW and
+GLFW supports compilation on Windows with Visual C++ (2013 and later) and
 MinGW-w64, on macOS with Clang and on Linux and other Unix-like systems with GCC
 and Clang.  It will likely compile in other environments as well, but this is
 not regularly tested.
@ -79,7 +79,7 @@ more information.

 ## System requirements

-GLFW supports Windows XP and later and macOS 10.11 and later.  Linux and other
+GLFW supports Windows 7 and later and macOS 10.11 and later.  Linux and other
 Unix-like systems running the X Window System are supported even without
 a desktop environment or modern extensions, although some features require
 a running window or clipboard manager.  The OSMesa backend requires Mesa 6.3.
@ -124,6 +124,8 @@ information on what to include when reporting a bug.
 - Added `GLFW_UNLIMITED_MOUSE_BUTTONS` input mode that allows mouse buttons beyond
   the limit of the mouse button tokens to be reported (#2423)
 - Updated minimum CMake version to 3.16 (#2541)
+ - Removed support for building with original MinGW (#2540)
+ - [Win32] Removed support for Windows XP and Vista (#2505)
 - [Cocoa] Added `QuartzCore` framework as link-time dependency
 - [Cocoa] Removed support for OS X 10.10 Yosemite and earlier (#2506)
 - [Wayland] Bugfix: The fractional scaling related objects were not destroyed
--- a/deps/mingw/_mingw_dxhelper.h
+++ b/deps/mingw/_mingw_dxhelper.h
@ -1,117 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER within this package.
- */
-
-#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
-#define NONAMELESSUNION		1
-#endif
-#if defined(NONAMELESSSTRUCT) && \
-   !defined(NONAMELESSUNION)
-#define NONAMELESSUNION		1
-#endif
-#if defined(NONAMELESSUNION)  && \
-   !defined(NONAMELESSSTRUCT)
-#define NONAMELESSSTRUCT	1
-#endif
-#if !defined(__GNU_EXTENSION)
-#if defined(__GNUC__) || defined(__GNUG__)
-#define __GNU_EXTENSION		__extension__
-#else
-#define __GNU_EXTENSION
-#endif
-#endif /* __extension__ */
-
-#ifndef __ANONYMOUS_DEFINED
-#define __ANONYMOUS_DEFINED
-#if defined(__GNUC__) || defined(__GNUG__)
-#define _ANONYMOUS_UNION	__extension__
-#define _ANONYMOUS_STRUCT	__extension__
-#else
-#define _ANONYMOUS_UNION
-#define _ANONYMOUS_STRUCT
-#endif
-#ifndef NONAMELESSUNION
-#define _UNION_NAME(x)
-#define _STRUCT_NAME(x)
-#else /* NONAMELESSUNION */
-#define _UNION_NAME(x)  x
-#define _STRUCT_NAME(x) x
-#endif
-#endif	/* __ANONYMOUS_DEFINED */
-
-#ifndef DUMMYUNIONNAME
-# ifdef NONAMELESSUNION
-#  define DUMMYUNIONNAME  u
-#  define DUMMYUNIONNAME1 u1	/* Wine uses this variant */
-#  define DUMMYUNIONNAME2 u2
-#  define DUMMYUNIONNAME3 u3
-#  define DUMMYUNIONNAME4 u4
-#  define DUMMYUNIONNAME5 u5
-#  define DUMMYUNIONNAME6 u6
-#  define DUMMYUNIONNAME7 u7
-#  define DUMMYUNIONNAME8 u8
-#  define DUMMYUNIONNAME9 u9
-# else /* NONAMELESSUNION */
-#  define DUMMYUNIONNAME
-#  define DUMMYUNIONNAME1	/* Wine uses this variant */
-#  define DUMMYUNIONNAME2
-#  define DUMMYUNIONNAME3
-#  define DUMMYUNIONNAME4
-#  define DUMMYUNIONNAME5
-#  define DUMMYUNIONNAME6
-#  define DUMMYUNIONNAME7
-#  define DUMMYUNIONNAME8
-#  define DUMMYUNIONNAME9
-# endif
-#endif	/* DUMMYUNIONNAME */
-
-#if !defined(DUMMYUNIONNAME1)	/* MinGW does not define this one */
-# ifdef NONAMELESSUNION
-#  define DUMMYUNIONNAME1 u1	/* Wine uses this variant */
-# else
-#  define DUMMYUNIONNAME1	/* Wine uses this variant */
-# endif
-#endif	/* DUMMYUNIONNAME1 */
-
-#ifndef DUMMYSTRUCTNAME
-# ifdef NONAMELESSUNION
-#  define DUMMYSTRUCTNAME  s
-#  define DUMMYSTRUCTNAME1 s1	/* Wine uses this variant */
-#  define DUMMYSTRUCTNAME2 s2
-#  define DUMMYSTRUCTNAME3 s3
-#  define DUMMYSTRUCTNAME4 s4
-#  define DUMMYSTRUCTNAME5 s5
-# else
-#  define DUMMYSTRUCTNAME
-#  define DUMMYSTRUCTNAME1	/* Wine uses this variant */
-#  define DUMMYSTRUCTNAME2
-#  define DUMMYSTRUCTNAME3
-#  define DUMMYSTRUCTNAME4
-#  define DUMMYSTRUCTNAME5
-# endif
-#endif /* DUMMYSTRUCTNAME */
-
-/* These are for compatibility with the Wine source tree */
-
-#ifndef WINELIB_NAME_AW
-# ifdef __MINGW_NAME_AW
-#   define WINELIB_NAME_AW  __MINGW_NAME_AW
-# else
-#  ifdef UNICODE
-#   define WINELIB_NAME_AW(func) func##W
-#  else
-#   define WINELIB_NAME_AW(func) func##A
-#  endif
-# endif
-#endif	/* WINELIB_NAME_AW */
-
-#ifndef DECL_WINELIB_TYPE_AW
-# ifdef __MINGW_TYPEDEF_AW
-#  define DECL_WINELIB_TYPE_AW  __MINGW_TYPEDEF_AW
-# else
-#  define DECL_WINELIB_TYPE_AW(type)  typedef WINELIB_NAME_AW(type) type;
-# endif
-#endif	/* DECL_WINELIB_TYPE_AW */
-
--- a/deps/mingw/dinput.h
+++ b/deps/mingw/dinput.h
--- a/deps/mingw/xinput.h
+++ b/deps/mingw/xinput.h
@ -1,239 +0,0 @@
-/*
- * The Wine project - Xinput Joystick Library
- * Copyright 2008 Andrew Fenn
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#ifndef __WINE_XINPUT_H
-#define __WINE_XINPUT_H
-
-#include <windef.h>
-
-/*
- * Bitmasks for the joysticks buttons, determines what has
- * been pressed on the joystick, these need to be mapped
- * to whatever device you're using instead of an xbox 360
- * joystick
- */
-
-#define XINPUT_GAMEPAD_DPAD_UP          0x0001
-#define XINPUT_GAMEPAD_DPAD_DOWN        0x0002
-#define XINPUT_GAMEPAD_DPAD_LEFT        0x0004
-#define XINPUT_GAMEPAD_DPAD_RIGHT       0x0008
-#define XINPUT_GAMEPAD_START            0x0010
-#define XINPUT_GAMEPAD_BACK             0x0020
-#define XINPUT_GAMEPAD_LEFT_THUMB       0x0040
-#define XINPUT_GAMEPAD_RIGHT_THUMB      0x0080
-#define XINPUT_GAMEPAD_LEFT_SHOULDER    0x0100
-#define XINPUT_GAMEPAD_RIGHT_SHOULDER   0x0200
-#define XINPUT_GAMEPAD_A                0x1000
-#define XINPUT_GAMEPAD_B                0x2000
-#define XINPUT_GAMEPAD_X                0x4000
-#define XINPUT_GAMEPAD_Y                0x8000
-
-/*
- * Defines the flags used to determine if the user is pushing
- * down on a button, not holding a button, etc
- */
-
-#define XINPUT_KEYSTROKE_KEYDOWN        0x0001
-#define XINPUT_KEYSTROKE_KEYUP          0x0002
-#define XINPUT_KEYSTROKE_REPEAT         0x0004
-
-/*
- * Defines the codes which are returned by XInputGetKeystroke
- */
-
-#define VK_PAD_A                        0x5800
-#define VK_PAD_B                        0x5801
-#define VK_PAD_X                        0x5802
-#define VK_PAD_Y                        0x5803
-#define VK_PAD_RSHOULDER                0x5804
-#define VK_PAD_LSHOULDER                0x5805
-#define VK_PAD_LTRIGGER                 0x5806
-#define VK_PAD_RTRIGGER                 0x5807
-#define VK_PAD_DPAD_UP                  0x5810
-#define VK_PAD_DPAD_DOWN                0x5811
-#define VK_PAD_DPAD_LEFT                0x5812
-#define VK_PAD_DPAD_RIGHT               0x5813
-#define VK_PAD_START                    0x5814
-#define VK_PAD_BACK                     0x5815
-#define VK_PAD_LTHUMB_PRESS             0x5816
-#define VK_PAD_RTHUMB_PRESS             0x5817
-#define VK_PAD_LTHUMB_UP                0x5820
-#define VK_PAD_LTHUMB_DOWN              0x5821
-#define VK_PAD_LTHUMB_RIGHT             0x5822
-#define VK_PAD_LTHUMB_LEFT              0x5823
-#define VK_PAD_LTHUMB_UPLEFT            0x5824
-#define VK_PAD_LTHUMB_UPRIGHT           0x5825
-#define VK_PAD_LTHUMB_DOWNRIGHT         0x5826
-#define VK_PAD_LTHUMB_DOWNLEFT          0x5827
-#define VK_PAD_RTHUMB_UP                0x5830
-#define VK_PAD_RTHUMB_DOWN              0x5831
-#define VK_PAD_RTHUMB_RIGHT             0x5832
-#define VK_PAD_RTHUMB_LEFT              0x5833
-#define VK_PAD_RTHUMB_UPLEFT            0x5834
-#define VK_PAD_RTHUMB_UPRIGHT           0x5835
-#define VK_PAD_RTHUMB_DOWNRIGHT         0x5836
-#define VK_PAD_RTHUMB_DOWNLEFT          0x5837
-
-/*
- * Deadzones are for analogue joystick controls on the joypad
- * which determine when input should be assumed to be in the
- * middle of the pad. This is a threshold to stop a joypad
- * controlling the game when the player isn't touching the
- * controls.
- */
-
-#define XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE  7849
-#define XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE 8689
-#define XINPUT_GAMEPAD_TRIGGER_THRESHOLD    30
-
-
-/*
- * Defines what type of abilities the type of joystick has
- * DEVTYPE_GAMEPAD is available for all joysticks, however
- * there may be more specific identifiers for other joysticks
- * which are being used.
- */
-
-#define XINPUT_DEVTYPE_GAMEPAD          0x01
-#define XINPUT_DEVSUBTYPE_GAMEPAD       0x01
-#define XINPUT_DEVSUBTYPE_WHEEL         0x02
-#define XINPUT_DEVSUBTYPE_ARCADE_STICK  0x03
-#define XINPUT_DEVSUBTYPE_FLIGHT_SICK   0x04
-#define XINPUT_DEVSUBTYPE_DANCE_PAD     0x05
-#define XINPUT_DEVSUBTYPE_GUITAR        0x06
-#define XINPUT_DEVSUBTYPE_DRUM_KIT      0x08
-
-/*
- * These are used with the XInputGetCapabilities function to
- * determine the abilities to the joystick which has been
- * plugged in.
- */
-
-#define XINPUT_CAPS_VOICE_SUPPORTED     0x0004
-#define XINPUT_FLAG_GAMEPAD             0x00000001
-
-/*
- * Defines the status of the battery if one is used in the
- * attached joystick. The first two define if the joystick
- * supports a battery. Disconnected means that the joystick
- * isn't connected. Wired shows that the joystick is a wired
- * joystick.
- */
-
-#define BATTERY_DEVTYPE_GAMEPAD         0x00
-#define BATTERY_DEVTYPE_HEADSET         0x01
-#define BATTERY_TYPE_DISCONNECTED       0x00
-#define BATTERY_TYPE_WIRED              0x01
-#define BATTERY_TYPE_ALKALINE           0x02
-#define BATTERY_TYPE_NIMH               0x03
-#define BATTERY_TYPE_UNKNOWN            0xFF
-#define BATTERY_LEVEL_EMPTY             0x00
-#define BATTERY_LEVEL_LOW               0x01
-#define BATTERY_LEVEL_MEDIUM            0x02
-#define BATTERY_LEVEL_FULL              0x03
-
-/*
- * How many joysticks can be used with this library. Games that
- * use the xinput library will not go over this number.
- */
-
-#define XUSER_MAX_COUNT                 4
-#define XUSER_INDEX_ANY                 0x000000FF
-
-/*
- * Defines the structure of an xbox 360 joystick.
- */
-
-typedef struct _XINPUT_GAMEPAD {
-    WORD wButtons;
-    BYTE bLeftTrigger;
-    BYTE bRightTrigger;
-    SHORT sThumbLX;
-    SHORT sThumbLY;
-    SHORT sThumbRX;
-    SHORT sThumbRY;
-} XINPUT_GAMEPAD, *PXINPUT_GAMEPAD;
-
-typedef struct _XINPUT_STATE {
-    DWORD dwPacketNumber;
-    XINPUT_GAMEPAD Gamepad;
-} XINPUT_STATE, *PXINPUT_STATE;
-
-/*
- * Defines the structure of how much vibration is set on both the
- * right and left motors in a joystick. If you're not using a 360
- * joystick you will have to map these to your device.
- */
-
-typedef struct _XINPUT_VIBRATION {
-    WORD wLeftMotorSpeed;
-    WORD wRightMotorSpeed;
-} XINPUT_VIBRATION, *PXINPUT_VIBRATION;
-
-/*
- * Defines the structure for what kind of abilities the joystick has
- * such abilities are things such as if the joystick has the ability
- * to send and receive audio, if the joystick is in fact a driving
- * wheel or perhaps if the joystick is some kind of dance pad or
- * guitar.
- */
-
-typedef struct _XINPUT_CAPABILITIES {
-    BYTE Type;
-    BYTE SubType;
-    WORD Flags;
-    XINPUT_GAMEPAD Gamepad;
-    XINPUT_VIBRATION Vibration;
-} XINPUT_CAPABILITIES, *PXINPUT_CAPABILITIES;
-
-/*
- * Defines the structure for a joystick input event which is
- * retrieved using the function XInputGetKeystroke
- */
-typedef struct _XINPUT_KEYSTROKE {
-    WORD VirtualKey;
-    WCHAR Unicode;
-    WORD Flags;
-    BYTE UserIndex;
-    BYTE HidCode;
-} XINPUT_KEYSTROKE, *PXINPUT_KEYSTROKE;
-
-typedef struct _XINPUT_BATTERY_INFORMATION
-{
-    BYTE BatteryType;
-    BYTE BatteryLevel;
-} XINPUT_BATTERY_INFORMATION, *PXINPUT_BATTERY_INFORMATION;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void WINAPI XInputEnable(WINBOOL);
-DWORD WINAPI XInputSetState(DWORD, XINPUT_VIBRATION*);
-DWORD WINAPI XInputGetState(DWORD, XINPUT_STATE*);
-DWORD WINAPI XInputGetKeystroke(DWORD, DWORD, PXINPUT_KEYSTROKE);
-DWORD WINAPI XInputGetCapabilities(DWORD, DWORD, XINPUT_CAPABILITIES*);
-DWORD WINAPI XInputGetDSoundAudioDeviceGuids(DWORD, GUID*, GUID*);
-DWORD WINAPI XInputGetBatteryInformation(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __WINE_XINPUT_H */
--- a/docs/compile.md
+++ b/docs/compile.md
@ -36,9 +36,9 @@ specific to GLFW.  It may be a useful companion to this one.

 ### Installing dependencies {#compile_deps}

-The C/C++ development environments in Visual Studio, Xcode and MinGW come with
-all necessary dependencies for compiling GLFW, but on Unix-like systems like
-Linux and FreeBSD you will need a few extra packages.
+The C/C++ development environments in Visual Studio, Xcode and MinGW-w64 come
+with all necessary dependencies for compiling GLFW, but on Unix-like systems
+like Linux and FreeBSD you will need a few extra packages.


 #### Dependencies for Wayland and X11 {#compile_deps_wayland}
@ -180,7 +180,7 @@ cd path/to/build
 make
 ```

-With MinGW, it is `mingw32-make`.
+With MinGW-w64, it is `mingw32-make`.

 ```sh
 cd path/to/build
@ -299,12 +299,12 @@ library.  This option is only available when compiling for Linux and other Unix-
 systems other than macOS.  This is enabled by default.


-## Cross-compilation with CMake and MinGW {#compile_mingw_cross}
+## Cross-compilation with CMake and MinGW-w64 {#compile_mingw_cross}

-Both Cygwin and many Linux distributions have MinGW or MinGW-w64 packages.  For
-example, Cygwin has the `mingw64-i686-gcc` and `mingw64-x86_64-gcc` packages
-for 32- and 64-bit version of MinGW-w64, while Debian GNU/Linux and derivatives
-like Ubuntu have the `mingw-w64` package for both.
+Both Cygwin and many Linux distributions have MinGW-w64 packages.  For example,
+Cygwin has the `mingw64-i686-gcc` and `mingw64-x86_64-gcc` packages for 32- and
+64-bit version of MinGW-w64, while Debian GNU/Linux and derivatives like Ubuntu
+have the `mingw-w64` package for both.

 GLFW has CMake toolchain files in the `CMake` subdirectory that set up
 cross-compilation of Windows binaries.  To use these files you set the
@ -315,9 +315,9 @@ configuring and generating the build files.
 cmake -S path/to/glfw -B path/to/build -D CMAKE_TOOLCHAIN_FILE=path/to/file
 ```

-The exact toolchain file to use depends on the prefix used by the MinGW or
-MinGW-w64 binaries on your system.  You can usually see this in the /usr
-directory.  For example, both the Ubuntu and Cygwin MinGW-w64 packages have
+The exact toolchain file to use depends on the prefix used by the MinGW-w64
+binaries on your system.  You can usually see this in the /usr directory.  For
+example, both the Ubuntu and Cygwin MinGW-w64 packages have
 `/usr/x86_64-w64-mingw32` for the 64-bit compilers, so the correct invocation
 would be:

--- a/docs/intro.md
+++ b/docs/intro.md
@ -621,11 +621,11 @@ The format of the string is as follows:
 - The names of the always supported context creation APIs EGL and OSMesa
 - Any additional compile-time options, APIs and (on Windows) what compiler was used

-For example, compiling GLFW 3.5 with MinGW as a DLL for Windows, may result in a version string
-like this:
+For example, compiling GLFW 3.5 with MinGW-64 as a DLL for Windows, may result
+in a version string like this:

 ```c
-3.5.0 Win32 WGL Null EGL OSMesa MinGW DLL
+3.5.0 Win32 WGL Null EGL OSMesa MinGW-w64 DLL
 ```

 Compiling GLFW as a static library for Linux, with both Wayland and X11 enabled, may
--- a/docs/news.md
+++ b/docs/news.md
@ -20,6 +20,21 @@ this.

 ## Removals {#removals}

+### Windows XP and Vista support has been removed {#winxp_vista}
+
+Support for Windows XP and Vista has been removed.  Windows XP has been out of extended
+support since 2014.
+
+
+### Original MinGW support has been removed {#original_mingw}
+
+Support for the now unmaintained original MinGW distribution has been removed.
+
+This does not apply to the much more capable [MinGW-w64](https://www.mingw-w64.org/),
+which remains fully supported.  MinGW-w64 can build both 32- and 64-bit binaries, is
+actively maintained and available on many platforms.
+
+
 ## New symbols {#new_symbols}

 ### New functions {#new_functions}
--- a/examples/boing-opengles.c
+++ b/examples/boing-opengles.c
@ -0,0 +1,775 @@
+/*****************************************************************************
+ * Title:   OpenGL ES Boing
+ * Desc:    Tribute to Amiga Boing.
+ * Author:  Jim Brooks  <gfx@jimbrooks.org>
+ *          Original Amiga authors were R.J. Mical and Dale Luck.
+ *          GLFW conversion by Marcus Geelnard
+ *          OpenGL ES port by Mike Gorchak
+ * Notes:   - 360' = 2*PI [radian]
+ *
+ *          - Distances between objects are created by doing a relative
+ *            Z translations.
+ *
+ *          - Although OpenGL ES enticingly supports alpha-blending,
+ *            the shadow of the original Boing didn't affect the color
+ *            of the grid.
+ *
+ *          - [Marcus] Changed timing scheme from interval driven to frame-
+ *            time based animation steps (which results in much smoother
+ *            movement)
+ *
+ * History of Amiga Boing:
+ *
+ * Boing was demonstrated on the prototype Amiga (codenamed "Lorraine") in
+ * 1985. According to legend, it was written ad-hoc in one night by
+ * R. J. Mical and Dale Luck. Because the bouncing ball animation was so fast
+ * and smooth, attendees did not believe the Amiga prototype was really doing
+ * the rendering. Suspecting a trick, they began looking around the booth for
+ * a hidden computer or VCR.
+ *****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include <math.h>
+
+#define GLAD_GLES2_IMPLEMENTATION
+#include <glad/gles2.h>
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+#include <linmath.h>
+
+/*****************************************************************************
+ * Various declarations and macros
+ *****************************************************************************/
+
+/* Draw ball, or its shadow */
+typedef enum
+{
+   DRAW_BALL,
+   DRAW_BALL_SHADOW
+} DRAW_BALL_ENUM;
+
+/* Prototypes */
+void init(void);
+void display(void);
+void reshape(GLFWwindow* window, int w, int h);
+void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
+void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);
+void cursor_position_callback(GLFWwindow* window, double x, double y);
+void GenerateBoingBall(void);
+void GenerateGrid(void);
+void DrawBoingBall(DRAW_BALL_ENUM drawBallHow);
+void DrawGrid(void);
+void BounceBall(float dt);
+
+#define RADIUS           70.0f
+#define STEP_LONGITUDE   22.5f                   /* 22.5 makes 8 bands like original Boing */
+#define STEP_LATITUDE    22.5f
+
+#define DIST_BALL        (RADIUS * 2.0f + RADIUS * 0.1f)
+
+#define VIEW_SCENE_DIST  (DIST_BALL * 3.0f + 200.0f) /* distance from viewer to middle of boing area */
+#define GRID_SIZE        (RADIUS * 4.5f)             /* length (width) of grid */
+#define BOUNCE_HEIGHT    (RADIUS * 2.1f)
+#define BOUNCE_WIDTH     (RADIUS * 2.1f)
+
+#define SHADOW_OFFSET_X  -20.0f
+#define SHADOW_OFFSET_Y  10.f
+#define SHADOW_OFFSET_Z  0.0f
+
+#define WALL_L_OFFSET    0.0f
+#define WALL_R_OFFSET    5.0f
+
+/* Animation speed (50.0 mimics the original GLUT demo speed) */
+#define ANIMATION_SPEED  50.0f
+
+/* Maximum allowed delta time per physics iteration */
+#define MAX_DELTA_T      0.02f
+
+/* Global vars */
+int windowed_xpos, windowed_ypos, windowed_width, windowed_height;
+int width, height;
+int override_pos      = GLFW_FALSE;
+
+float deg_rot_y       = 0.0f;
+float deg_rot_y_inc   = 2.0f;
+float cursor_x        = 0.0f;
+float cursor_y        = 0.0f;
+float ball_x          = -RADIUS;
+float ball_y          = -RADIUS;
+float ball_x_inc      = 1.0f;
+float ball_y_inc      = 2.0f;
+float t;
+float t_old           = 0.0f;
+float dt;
+
+/* Random number generator */
+#ifndef RAND_MAX
+   #define RAND_MAX 4095
+#endif
+
+static mat4x4 projection;
+static mat4x4 modelview_orig;
+static mat4x4 modelview;
+static mat4x4 mvp;
+
+static vec3* ball_color1_vertices = NULL;
+static vec3* ball_color2_vertices = NULL;
+static vec3* grid_vertices = NULL;
+static vec3 color1 = {0.8f, 0.1f, 0.1f};            /* reddish      */
+static vec3 color2 = {0.95f, 0.95f, 0.95f};         /* almost white */
+static vec3 color_shadow = {0.35f, 0.35f, 0.35f};   /* dark grey    */
+static vec3 grid_color = {0.6f, 0.1f, 0.6f};        /* purple       */
+
+static int facet_array_size = 0;
+static int grid_array_size = 0;
+
+static GLuint buffer;
+static GLuint program;
+static GLuint mvp_matrix_loc = -1;
+static GLuint vertex_color_loc = -1;
+static GLuint vertex_attr_index = -1;
+
+/*****************************************************************************
+ * Truncate a degree.
+ *****************************************************************************/
+float TruncateDeg(float deg)
+{
+   if (deg >= 360.0f)
+      return (deg - 360.0f);
+   else
+      return deg;
+}
+
+/*****************************************************************************
+ * Convert a degree (360-based) into a radian.
+ * 360' = 2 * PI
+ *****************************************************************************/
+float deg2rad(float deg)
+{
+   return deg / 360.0f * (2.0f * M_PI);
+}
+
+/*****************************************************************************
+ * 360' sin().
+ *****************************************************************************/
+float sin_deg(float deg)
+{
+   return sin(deg2rad(deg));
+}
+
+/*****************************************************************************
+ * 360' cos().
+ *****************************************************************************/
+float cos_deg(float deg)
+{
+   return cos(deg2rad(deg));
+}
+
+/*****************************************************************************
+ * init_shaders()
+ *****************************************************************************/
+static int init_shaders(void)
+{
+   GLenum error;
+   GLuint vertex_shader, fragment_shader;
+   char log[8192];
+   GLsizei len;
+   GLint processing_done = GL_TRUE;
+
+   error = glGetError();
+
+   const char *vtx_shdr_src =
+      "attribute vec3 vertex_position;                            \n"
+      "                                                           \n"
+      "uniform mat4 mvp_matrix;                                   \n"
+      "uniform vec4 vertex_color;                                 \n"
+      "                                                           \n"
+      "varying vec4 fs_color;                                     \n"
+      "                                                           \n"
+      "void main()                                                \n"
+      "{                                                          \n"
+      "    fs_color = vertex_color;                               \n"
+      "    gl_Position = mvp_matrix * vec4(vertex_position, 1.0); \n"
+      "}                                                          \n";
+
+   const char *frg_shdr_src =
+      "varying vec4 fs_color;                                     \n"
+      "                                                           \n"
+      "void main(void)                                            \n"
+      "{                                                          \n"
+      "    gl_FragColor = fs_color;                               \n"
+      "}                                                          \n";
+
+   program = glCreateProgram();
+
+   vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+   glAttachShader(program, vertex_shader);
+   glShaderSource(vertex_shader, 1, (const char**)&vtx_shdr_src, NULL);
+   glCompileShader(vertex_shader);
+   glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &processing_done);
+   if (processing_done != GL_TRUE)
+   {
+      glGetShaderInfoLog(vertex_shader, sizeof(log), &len, log);
+      fprintf(stderr, "Vertex Shader: %s", log);
+      return -1;
+   }
+
+   fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+   glAttachShader(program, fragment_shader);
+   glShaderSource(fragment_shader, 1, (const char**)&frg_shdr_src, NULL);
+   glCompileShader(fragment_shader);
+   glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &processing_done);
+   if (processing_done != GL_TRUE)
+   {
+      glGetShaderInfoLog(fragment_shader, sizeof(log), &len, log);
+      fprintf(stderr, "Fragment Shader: %s", log);
+      return -1;
+   }
+
+   glLinkProgram(program);
+   glGetProgramiv(program, GL_LINK_STATUS, &processing_done);
+   if (processing_done != GL_TRUE)
+   {
+      glGetProgramInfoLog(program, sizeof(log), &len, log);
+      fprintf(stderr, "Linker: %s", log);
+      return -1;
+   }
+
+   glUseProgram(program);
+
+   mvp_matrix_loc = glGetUniformLocation(program, "mvp_matrix");
+   if ((mvp_matrix_loc == -1))
+   {
+      fprintf(stderr, "Can't locate location of MVP matrix uniform!\n");
+      return -1;
+   }
+
+   vertex_color_loc = glGetUniformLocation(program, "vertex_color");
+   if (vertex_color_loc == -1)
+   {
+      fprintf(stderr, "Can't locate location of fog color uniform!\n");
+      return -1;
+   }
+
+   vertex_attr_index = glGetAttribLocation(program, "vertex_position");
+   if (vertex_attr_index == -1)
+   {
+      fprintf(stderr, "Can't locate location of vertex attribute!\n");
+      return -1;
+   }
+
+   /* We do not change VBO and use index offsets to the array elements */
+   glEnableVertexAttribArray(vertex_attr_index);
+   glVertexAttribPointer(vertex_attr_index, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)(uintptr_t)0);
+
+   error = glGetError();
+   if (error != GL_NO_ERROR)
+   {
+      fprintf(stderr, "GL Error: 0x%04X in shaders setup\n", error);
+      return -1;
+   }
+
+   return 0;
+}
+
+/*****************************************************************************
+ * init()
+ *****************************************************************************/
+void init(void)
+{
+   int offset = 0;
+
+   /* Clear background. */
+   glClearColor(0.55f, 0.55f, 0.55f, 0.0f);
+
+   /* Generate initial modelview matrix */
+   vec3 eye = {0.0f, 0.0f, VIEW_SCENE_DIST};
+   vec3 center = {0.0f, 0.0f, 0.0f};
+   vec3 up = {0.0f, -1.0f, 0.0f};
+   mat4x4_look_at(modelview_orig, eye, center, up);
+
+   GenerateBoingBall();
+   GenerateGrid();
+
+   /* Setup VBO */
+   glGenBuffers(1, &buffer);
+   glBindBuffer(GL_ARRAY_BUFFER, buffer);
+   glBufferData(GL_ARRAY_BUFFER, facet_array_size + facet_array_size + grid_array_size,
+      NULL, GL_STATIC_DRAW);
+   glBufferSubData(GL_ARRAY_BUFFER, offset, facet_array_size, ball_color1_vertices);
+   offset += facet_array_size;
+   glBufferSubData(GL_ARRAY_BUFFER, offset, facet_array_size, ball_color2_vertices);
+   offset += facet_array_size;
+   glBufferSubData(GL_ARRAY_BUFFER, offset, grid_array_size, grid_vertices);
+   offset += grid_array_size;
+
+   /* We don't need vertices in a heap, they were uploaded as VBO */
+   free(ball_color1_vertices);
+   free(ball_color2_vertices);
+   free(grid_vertices);
+
+   init_shaders();
+}
+
+/*****************************************************************************
+ * display()
+ *****************************************************************************/
+void display(void)
+{
+   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+   DrawBoingBall(DRAW_BALL_SHADOW);
+   DrawGrid();
+   DrawBoingBall(DRAW_BALL);
+}
+
+/*****************************************************************************
+ * reshape()
+ *****************************************************************************/
+void reshape(GLFWwindow* window, int w, int h)
+{
+   width = w;
+   height = h;
+
+   glViewport(0, 0, (GLsizei)w, (GLsizei)h);
+
+   mat4x4_perspective(projection, 2.0f * (float)atan2(RADIUS, 200.0f), (float)w / (float)h, 1.0f, VIEW_SCENE_DIST);
+}
+
+void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action != GLFW_PRESS)
+        return;
+
+    if (key == GLFW_KEY_ESCAPE && mods == 0)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+    if ((key == GLFW_KEY_ENTER && mods == GLFW_MOD_ALT) ||
+        (key == GLFW_KEY_F11 && mods == GLFW_MOD_ALT))
+    {
+        if (glfwGetWindowMonitor(window))
+        {
+            glfwSetWindowMonitor(window, NULL,
+                                 windowed_xpos, windowed_ypos,
+                                 windowed_width, windowed_height, 0);
+        }
+        else
+        {
+            GLFWmonitor* monitor = glfwGetPrimaryMonitor();
+            if (monitor)
+            {
+                const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+                glfwGetWindowPos(window, &windowed_xpos, &windowed_ypos);
+                glfwGetWindowSize(window, &windowed_width, &windowed_height);
+                glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
+            }
+        }
+    }
+}
+
+static void set_ball_pos(float x, float y)
+{
+   ball_x = (width / 2) - x;
+   ball_y = y - (height / 2);
+}
+
+void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
+{
+   if (button != GLFW_MOUSE_BUTTON_LEFT)
+      return;
+
+   if (action == GLFW_PRESS)
+   {
+      override_pos = GLFW_TRUE;
+      set_ball_pos(cursor_x, cursor_y);
+   }
+   else
+   {
+      override_pos = GLFW_FALSE;
+   }
+}
+
+void cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+   cursor_x = (float)x;
+   cursor_y = (float)y;
+
+   if (override_pos)
+      set_ball_pos(cursor_x, cursor_y);
+}
+
+/*****************************************************************************
+ * Generate the Boing ball.
+ *
+ * The Boing ball is sphere in which each facet is a rectangle.
+ * Facet colors alternate between red and white.
+ * The ball is built by stacking latitudinal circles.  Each circle is composed
+ * of a widely-separated set of points, so that each facet is noticeably large.
+ *****************************************************************************/
+void GenerateBoingBall(void)
+{
+   /* degree of longitude */
+   float lon_deg;
+   float lat_deg;
+   int vertex_idx_c1 = 0;
+   int vertex_idx_c2 = 0;
+   bool colorToggle = 0;
+
+   /* "ne" means south-east, so on */
+   vec3 vert_ne;
+   vec3 vert_nw;
+   vec3 vert_sw;
+   vec3 vert_se;
+
+   /* "/ 2" - half facets of one color              */
+   /* "* 6" - 6 vertices per facet (two triangles)  */
+   facet_array_size = (int)((180.0f / STEP_LONGITUDE) * (360.0f / STEP_LATITUDE) / 2) * 6 * sizeof(vec3);
+   ball_color1_vertices = calloc(1, facet_array_size);
+   ball_color2_vertices = calloc(1, facet_array_size);
+   if ((ball_color1_vertices == NULL) || (ball_color2_vertices == NULL))
+   {
+       fprintf(stderr, "Can't allocate memory for ball vertices!\n");
+       glfwTerminate();
+       exit(EXIT_FAILURE);
+   }
+
+   /*
+    * Build a faceted latitude slice of the Boing ball,
+    * stepping same-sized vertical bands of the sphere.
+    */
+   for (lon_deg = 0; lon_deg < 180; lon_deg += STEP_LONGITUDE)
+   {
+      /*
+       * Iterate through the points of a latitude circle.
+       * A latitude circle is a 2D set of X,Z points.
+       */
+      for (lat_deg = 0; lat_deg <= (360 - STEP_LATITUDE); lat_deg += STEP_LATITUDE)
+      {
+         /* Assign each Y. */
+         vert_ne[1] = vert_nw[1] = (float) cos_deg((lon_deg + STEP_LONGITUDE)) * RADIUS;
+         vert_sw[1] = vert_se[1] = (float) cos_deg(lon_deg) * RADIUS;
+
+         /*
+          * Assign each X,Z with sin,cos values scaled by latitude radius indexed by longitude.
+          * Eg, long=0 and long=180 are at the poles, so zero scale is sin(longitude),
+          * while long=90 (sin(90)=1) is at equator.
+          */
+         vert_ne[0] = (float)cos_deg(lat_deg                ) * (RADIUS * (float)sin_deg(lon_deg + STEP_LONGITUDE));
+         vert_se[0] = (float)cos_deg(lat_deg                ) * (RADIUS * (float)sin_deg(lon_deg                 ));
+         vert_nw[0] = (float)cos_deg(lat_deg + STEP_LATITUDE) * (RADIUS * (float)sin_deg(lon_deg + STEP_LONGITUDE));
+         vert_sw[0] = (float)cos_deg(lat_deg + STEP_LATITUDE) * (RADIUS * (float)sin_deg(lon_deg                 ));
+
+         vert_ne[2] = (float)sin_deg(lat_deg                ) * (RADIUS * (float)sin_deg(lon_deg + STEP_LONGITUDE));
+         vert_se[2] = (float)sin_deg(lat_deg                ) * (RADIUS * (float)sin_deg(lon_deg                 ));
+         vert_nw[2] = (float)sin_deg(lat_deg + STEP_LATITUDE) * (RADIUS * (float)sin_deg(lon_deg + STEP_LONGITUDE));
+         vert_sw[2] = (float)sin_deg(lat_deg + STEP_LATITUDE) * (RADIUS * (float)sin_deg(lon_deg                 ));
+
+         /*
+          * Color this polygon with red or white. Replace polygons with
+          * triangles to perform a batch draw operation.
+          */
+         if (colorToggle)
+         {
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 0], vert_ne, sizeof(vec3)); /* V0 */
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 1], vert_nw, sizeof(vec3)); /* V1 */
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 2], vert_sw, sizeof(vec3)); /* V2 */
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 3], vert_ne, sizeof(vec3)); /* V0 */
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 4], vert_sw, sizeof(vec3)); /* V2 */
+            memcpy(ball_color1_vertices[vertex_idx_c1 + 5], vert_se, sizeof(vec3)); /* V3 */
+            vertex_idx_c1 += 6;
+         }
+         else
+         {
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 0], vert_ne, sizeof(vec3)); /* V0 */
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 1], vert_nw, sizeof(vec3)); /* V1 */
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 2], vert_sw, sizeof(vec3)); /* V2 */
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 3], vert_ne, sizeof(vec3)); /* V0 */
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 4], vert_sw, sizeof(vec3)); /* V2 */
+            memcpy(ball_color2_vertices[vertex_idx_c2 + 5], vert_se, sizeof(vec3)); /* V3 */
+            vertex_idx_c2 += 6;
+         }
+
+         colorToggle = ! colorToggle;
+      }
+
+      /* Toggle color so that next band will opposite red/white colors than this one. */
+      colorToggle = ! colorToggle;
+   }
+}
+
+/*****************************************************************************
+ * Bounce the ball.
+ *****************************************************************************/
+void BounceBall(float delta_t)
+{
+   float sign;
+   float deg;
+
+   if (override_pos)
+     return;
+
+   /* Bounce on walls */
+   if (ball_x > (BOUNCE_WIDTH / 2 + WALL_R_OFFSET))
+   {
+      ball_x_inc = -0.5f - 0.75f * (float)rand() / (float)RAND_MAX;
+      deg_rot_y_inc = -deg_rot_y_inc;
+   }
+   if (ball_x < -(BOUNCE_HEIGHT / 2 + WALL_L_OFFSET))
+   {
+      ball_x_inc = 0.5f + 0.75f * (float)rand() / (float)RAND_MAX;
+      deg_rot_y_inc = -deg_rot_y_inc;
+   }
+
+   /* Bounce on floor / roof */
+   if (ball_y > BOUNCE_HEIGHT / 2)
+   {
+      ball_y_inc = -0.75f - 1.0f * (float)rand() / (float)RAND_MAX;
+   }
+   if (ball_y < -BOUNCE_HEIGHT / 2 * 0.85)
+   {
+      ball_y_inc =  0.75f + 1.0f * (float)rand() / (float)RAND_MAX;
+   }
+
+   /* Update ball position */
+   ball_x += ball_x_inc * ((float)delta_t * ANIMATION_SPEED);
+   ball_y += ball_y_inc * ((float)delta_t * ANIMATION_SPEED);
+
+   /* Simulate the effects of gravity on Y movement. */
+   if (ball_y_inc < 0) sign = -1.0; else sign = 1.0;
+
+   deg = (ball_y + BOUNCE_HEIGHT / 2) * 90 / BOUNCE_HEIGHT;
+   if (deg > 80) deg = 80;
+   if (deg < 10) deg = 10;
+
+   ball_y_inc = sign * 4.0f * (float)sin_deg(deg);
+}
+
+/*****************************************************************************
+ * Draw the ball.
+ *****************************************************************************/
+void DrawBoingBall(DRAW_BALL_ENUM drawBallHow)
+{
+   float dt_total, dt2;
+   GLenum error;
+
+   /* Reset error */
+   error = glGetError();
+
+   memcpy(modelview, modelview_orig, sizeof(modelview));
+
+   /* Another relative Z translation to separate objects. */
+   mat4x4_translate_in_place(modelview, 0.0f, 0.0f, DIST_BALL);
+
+   /* Update ball position and rotation (iterate if necessary) */
+   dt_total = dt;
+   while (dt_total > 0.0)
+   {
+       dt2 = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
+       dt_total -= dt2;
+       BounceBall(dt2);
+       deg_rot_y = TruncateDeg(deg_rot_y + deg_rot_y_inc * ((float)dt2 * ANIMATION_SPEED));
+   }
+
+   /* Set ball position */
+   mat4x4_translate_in_place(modelview, ball_x, ball_y, 0.0f);
+
+   /* Offset the shadow. */
+   if (drawBallHow == DRAW_BALL_SHADOW)
+   {
+      mat4x4_translate_in_place(modelview, SHADOW_OFFSET_X, SHADOW_OFFSET_Y, SHADOW_OFFSET_Z);
+   }
+
+   /* Tilt the ball. */
+   mat4x4_rotate(modelview, modelview, 0.0f, 0.0f, 1.0f, deg2rad(-20.0f));
+
+   /* Continually rotate ball around Y axis. */
+   mat4x4_rotate(modelview, modelview, 0.0f, 1.0f, 0.0f, deg2rad(deg_rot_y));
+
+   /* Set OpenGL state for Boing ball. */
+   glCullFace(GL_FRONT);
+   glEnable(GL_CULL_FACE);
+
+   mat4x4_mul(mvp, projection, modelview);
+   glUniformMatrix4fv(mvp_matrix_loc, 1, GL_FALSE, (GLfloat*)mvp);
+
+   if (drawBallHow == DRAW_BALL_SHADOW)
+   {
+       glUniform4fv(vertex_color_loc, 1, color_shadow);
+   }
+   else
+   {
+       glUniform4fv(vertex_color_loc, 1, color1);
+   }
+
+   glDrawArrays(GL_TRIANGLES, 0, facet_array_size / sizeof(vec3));
+
+   if (drawBallHow == DRAW_BALL_SHADOW)
+   {
+       glUniform4fv(vertex_color_loc, 1, color_shadow);
+   }
+   else
+   {
+       glUniform4fv(vertex_color_loc, 1, color2);
+   }
+
+   glDrawArrays(GL_TRIANGLES, facet_array_size / sizeof(vec3), facet_array_size / sizeof(vec3));
+
+   error = glGetError();
+   if (error != GL_NO_ERROR)
+   {
+      fprintf(stderr, "GL Error: 0x%04X in ball draw function\n", error);
+   }
+
+   return;
+}
+
+/*****************************************************************************
+ * Generate grid of lines
+ *****************************************************************************/
+void GenerateGrid(void)
+{
+   const int   rowTotal  = 12;                   /* must be divisible by 2 */
+   const int   colTotal  = rowTotal;             /* must be same as rowTotal */
+   const float widthLine = 2.0f;                 /* should be divisible by 2 */
+   const float sizeCell  = GRID_SIZE / rowTotal;
+   const float z_offset  = -40.0f;
+   int         row, col;
+   float       xl, xr;
+   float       yt, yb;
+   int         grid_idx = 0;
+
+   /* "* 6" - 6 vertices per line (two triangles) */
+   grid_array_size = ((rowTotal + 1) + (colTotal + 1)) * 6 * sizeof(vec3);
+   grid_vertices = calloc(1, facet_array_size);
+   if (grid_vertices == NULL)
+   {
+       fprintf(stderr, "Can't allocate memory for grid vertices!\n");
+       glfwTerminate();
+       exit(EXIT_FAILURE);
+   }
+
+   /* Generate vertical lines (as skinny 3D rectangles). */
+   for (col = 0; col <= colTotal; col++)
+   {
+      /* Compute coords of line. */
+      xl = -GRID_SIZE / 2 + col * sizeCell;
+      xr = xl + widthLine;
+
+      yt =  GRID_SIZE / 2;
+      yb = -GRID_SIZE / 2 - widthLine;
+
+      memcpy(grid_vertices[grid_idx + 0], (vec3){xr, yt, z_offset}, sizeof(vec3)); /* NE, V0 */
+      memcpy(grid_vertices[grid_idx + 1], (vec3){xl, yt, z_offset}, sizeof(vec3)); /* NW, V1 */
+      memcpy(grid_vertices[grid_idx + 2], (vec3){xl, yb, z_offset}, sizeof(vec3)); /* SW, V2 */
+      memcpy(grid_vertices[grid_idx + 3], (vec3){xr, yt, z_offset}, sizeof(vec3)); /* NE, V0 */
+      memcpy(grid_vertices[grid_idx + 4], (vec3){xl, yb, z_offset}, sizeof(vec3)); /* SW, V2 */
+      memcpy(grid_vertices[grid_idx + 5], (vec3){xr, yb, z_offset}, sizeof(vec3)); /* SE, V3 */
+      grid_idx += 6;
+   }
+
+   /* Generate horizontal lines (as skinny 3D rectangles). */
+   for (row = 0; row <= rowTotal; row++)
+   {
+      /* Compute coords of line. */
+      yt = GRID_SIZE / 2 - row * sizeCell;
+      yb = yt - widthLine;
+
+      xl = -GRID_SIZE / 2;
+      xr =  GRID_SIZE / 2 + widthLine;
+
+      memcpy(grid_vertices[grid_idx + 0], (vec3){xr, yt, z_offset}, sizeof(vec3)); /* NE, V0 */
+      memcpy(grid_vertices[grid_idx + 1], (vec3){xl, yt, z_offset}, sizeof(vec3)); /* NW, V1 */
+      memcpy(grid_vertices[grid_idx + 2], (vec3){xl, yb, z_offset}, sizeof(vec3)); /* SW, V2 */
+      memcpy(grid_vertices[grid_idx + 3], (vec3){xr, yt, z_offset}, sizeof(vec3)); /* NE, V0 */
+      memcpy(grid_vertices[grid_idx + 4], (vec3){xl, yb, z_offset}, sizeof(vec3)); /* SW, V2 */
+      memcpy(grid_vertices[grid_idx + 5], (vec3){xr, yb, z_offset}, sizeof(vec3)); /* SE, V3 */
+      grid_idx += 6;
+   }
+}
+
+/*****************************************************************************
+ * Draw the purple grid of lines, behind the Boing ball.
+ * When the Workbench is dropped to the bottom, Boing shows 12 rows.
+ *****************************************************************************/
+void DrawGrid(void)
+{
+   memcpy(modelview, modelview_orig, sizeof(modelview));
+
+   glDisable(GL_CULL_FACE);
+
+   /* Another relative Z translation to separate objects. */
+   mat4x4_translate_in_place(modelview, 0.0f, 0.0f, DIST_BALL);
+
+   mat4x4_mul(mvp, projection, modelview);
+   glUniformMatrix4fv(mvp_matrix_loc, 1, GL_FALSE, (GLfloat*)mvp);
+
+   glUniform4fv(vertex_color_loc, 1, grid_color);
+   glDrawArrays(GL_TRIANGLES, (facet_array_size + facet_array_size) / sizeof(vec3),
+      (facet_array_size + facet_array_size) / sizeof(vec3));
+
+   return;
+}
+
+/*======================================================================*
+ * main()
+ *======================================================================*/
+
+int main(void)
+{
+   GLFWwindow* window;
+
+   /* Init GLFW */
+   if (!glfwInit())
+      exit(EXIT_FAILURE);
+
+   window = glfwCreateWindow(400, 400, "Boing OpenGL ES 2.x (classic Amiga demo)", NULL, NULL);
+   if (!window)
+   {
+       glfwTerminate();
+       exit(EXIT_FAILURE);
+   }
+
+   glfwSetWindowAspectRatio(window, 1, 1);
+
+   glfwSetFramebufferSizeCallback(window, reshape);
+   glfwSetKeyCallback(window, key_callback);
+   glfwSetMouseButtonCallback(window, mouse_button_callback);
+   glfwSetCursorPosCallback(window, cursor_position_callback);
+
+   glfwMakeContextCurrent(window);
+   gladLoadGLES2(glfwGetProcAddress);
+   glfwSwapInterval(1);
+
+   glfwGetFramebufferSize(window, &width, &height);
+   reshape(window, width, height);
+
+   glfwSetTime(0.0);
+
+   init();
+
+   /* Main loop */
+   for (;;)
+   {
+       /* Timing */
+       t = glfwGetTime();
+       dt = t - t_old;
+       t_old = t;
+
+       /* Draw one frame */
+       display();
+
+       /* Swap buffers */
+       glfwSwapBuffers(window);
+       glfwPollEvents();
+
+       /* Check if we are still running */
+       if (glfwWindowShouldClose(window))
+           break;
+   }
+
+   glfwTerminate();
+   exit(EXIT_SUCCESS);
+}
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -255,24 +255,6 @@ if (GLFW_BUILD_WIN32)
    target_compile_definitions(glfw PRIVATE UNICODE _UNICODE)
 endif()

-# HACK: When building on MinGW, WINVER and UNICODE need to be defined before
-# the inclusion of stddef.h (by glfw3.h), which is itself included before
-# win32_platform.h.  We define them here until a saner solution can be found
-# NOTE: MinGW-w64 and Visual C++ do /not/ need this hack.
-if (MINGW)
-    target_compile_definitions(glfw PRIVATE WINVER=0x0501)
-endif()
-
-# Workaround for legacy MinGW not providing XInput and DirectInput
-if (MINGW)
-    include(CheckIncludeFile)
-    check_include_file(dinput.h DINPUT_H_FOUND)
-    check_include_file(xinput.h XINPUT_H_FOUND)
-    if (NOT DINPUT_H_FOUND OR NOT XINPUT_H_FOUND)
-        target_include_directories(glfw PRIVATE "${GLFW_SOURCE_DIR}/deps/mingw")
-    endif()
-endif()
-
 # Workaround for the MS CRT deprecating parts of the standard library
 if (MSVC OR CMAKE_C_SIMULATE_ID STREQUAL "MSVC")
    target_compile_definitions(glfw PRIVATE _CRT_SECURE_NO_WARNINGS)
@ -286,10 +268,6 @@ endif()
 if (GLFW_BUILD_SHARED_LIBRARY)
    if (WIN32)
        if (MINGW)
-            # Remove the dependency on the shared version of libgcc
-            # NOTE: MinGW-w64 has the correct default but MinGW needs this
-            target_link_libraries(glfw PRIVATE "-static-libgcc")
-
            # Remove the lib prefix on the DLL (but not the import library)
            set_target_properties(glfw PROPERTIES PREFIX "")

--- a/src/platform.c
+++ b/src/platform.c
@ -187,8 +187,6 @@ GLFWAPI const char* glfwGetVersionString(void)
        " OSMesa"
 #if defined(__MINGW64_VERSION_MAJOR)
        " MinGW-w64"
-#elif defined(__MINGW32__)
-        " MinGW"
 #elif defined(_MSC_VER)
        " VisualC"
 #endif
--- a/src/wgl_context.c
+++ b/src/wgl_context.c
@ -327,8 +327,8 @@ static void swapBuffersWGL(_GLFWwindow* window)
 {
    if (!window->monitor)
    {
-        // HACK: Use DwmFlush when desktop composition is enabled on Windows Vista and 7
-        if (!IsWindows8OrGreater() && IsWindowsVistaOrGreater())
+        // HACK: Use DwmFlush when desktop composition is enabled on Windows 7
+        if (!IsWindows8OrGreater())
        {
            BOOL enabled = FALSE;

@ -353,9 +353,9 @@ static void swapIntervalWGL(int interval)

    if (!window->monitor)
    {
-        // HACK: Disable WGL swap interval when desktop composition is enabled on Windows
-        //       Vista and 7 to avoid interfering with DWM vsync
-        if (!IsWindows8OrGreater() && IsWindowsVistaOrGreater())
+        // HACK: Disable WGL swap interval when desktop composition is enabled on
+        //       Windows 7 to avoid interfering with DWM vsync
+        if (!IsWindows8OrGreater())
        {
            BOOL enabled = FALSE;

--- a/src/win32_init.c
+++ b/src/win32_init.c
@ -89,10 +89,6 @@ static GLFWbool loadLibraries(void)
        return GLFW_FALSE;
    }

-    _glfw.win32.user32.SetProcessDPIAware_ = (PFN_SetProcessDPIAware)
-        _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "SetProcessDPIAware");
-    _glfw.win32.user32.ChangeWindowMessageFilterEx_ = (PFN_ChangeWindowMessageFilterEx)
-        _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
    _glfw.win32.user32.EnableNonClientDpiScaling_ = (PFN_EnableNonClientDpiScaling)
        _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "EnableNonClientDpiScaling");
    _glfw.win32.user32.SetProcessDpiAwarenessContext_ = (PFN_SetProcessDpiAwarenessContext)
@ -692,7 +688,7 @@ int _glfwInitWin32(void)
        SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
    else if (IsWindows8Point1OrGreater())
        SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
-    else if (IsWindowsVistaOrGreater())
+    else
        SetProcessDPIAware();

    if (!createHelperWindow())
--- a/src/win32_platform.h
+++ b/src/win32_platform.h
@ -48,14 +48,14 @@
 #define UNICODE
 #endif

-// GLFW requires Windows XP or later
-#if WINVER < 0x0501
+// GLFW requires Windows 7 or later
+#if WINVER < 0x0601
 #undef WINVER
- #define WINVER 0x0501
+ #define WINVER 0x0601
 #endif
-#if _WIN32_WINNT < 0x0501
+#if _WIN32_WINNT < 0x0601
 #undef _WIN32_WINNT
- #define _WIN32_WINNT 0x0501
+ #define _WIN32_WINNT 0x0601
 #endif

 // GLFW uses DirectInput8 interfaces
@ -66,41 +66,21 @@

 #include <wctype.h>
 #include <windows.h>
+#include <dwmapi.h>
 #include <dinput.h>
 #include <xinput.h>
 #include <dbt.h>

 // HACK: Define macros that some windows.h variants don't
-#ifndef WM_MOUSEHWHEEL
- #define WM_MOUSEHWHEEL 0x020E
-#endif
-#ifndef WM_DWMCOMPOSITIONCHANGED
- #define WM_DWMCOMPOSITIONCHANGED 0x031E
-#endif
-#ifndef WM_DWMCOLORIZATIONCOLORCHANGED
- #define WM_DWMCOLORIZATIONCOLORCHANGED 0x0320
-#endif
 #ifndef WM_COPYGLOBALDATA
 #define WM_COPYGLOBALDATA 0x0049
 #endif
-#ifndef WM_UNICHAR
- #define WM_UNICHAR 0x0109
-#endif
-#ifndef UNICODE_NOCHAR
- #define UNICODE_NOCHAR 0xFFFF
-#endif
 #ifndef WM_DPICHANGED
 #define WM_DPICHANGED 0x02E0
 #endif
-#ifndef GET_XBUTTON_WPARAM
- #define GET_XBUTTON_WPARAM(w) (HIWORD(w))
-#endif
 #ifndef EDS_ROTATEDMODE
 #define EDS_ROTATEDMODE 0x00000004
 #endif
-#ifndef DISPLAY_DEVICE_ACTIVE
- #define DISPLAY_DEVICE_ACTIVE 0x00000001
-#endif
 #ifndef _WIN32_WINNT_WINBLUE
 #define _WIN32_WINNT_WINBLUE 0x0603
 #endif
@ -113,34 +93,6 @@
 #ifndef USER_DEFAULT_SCREEN_DPI
 #define USER_DEFAULT_SCREEN_DPI 96
 #endif
-#ifndef OCR_HAND
- #define OCR_HAND 32649
-#endif
-
-#if WINVER < 0x0601
-typedef struct
-{
-    DWORD cbSize;
-    DWORD ExtStatus;
-} CHANGEFILTERSTRUCT;
-#ifndef MSGFLT_ALLOW
- #define MSGFLT_ALLOW 1
-#endif
-#endif /*Windows 7*/
-
-#if WINVER < 0x0600
-#define DWM_BB_ENABLE 0x00000001
-#define DWM_BB_BLURREGION 0x00000002
-typedef struct
-{
-    DWORD dwFlags;
-    BOOL fEnable;
-    HRGN hRgnBlur;
-    BOOL fTransitionOnMaximized;
-} DWM_BLURBEHIND;
-#else
- #include <dwmapi.h>
-#endif /*Windows Vista*/

 #ifndef DPI_ENUMS_DECLARED
 typedef enum
@ -165,12 +117,6 @@ typedef enum
 // Replacement for versionhelpers.h macros, as we cannot rely on the
 // application having a correct embedded manifest
 //
-#define IsWindowsVistaOrGreater()                                     \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_VISTA),   \
-                                        LOBYTE(_WIN32_WINNT_VISTA), 0)
-#define IsWindows7OrGreater()                                         \
-    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN7),    \
-                                        LOBYTE(_WIN32_WINNT_WIN7), 0)
 #define IsWindows8OrGreater()                                         \
    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN8),    \
                                        LOBYTE(_WIN32_WINNT_WIN8), 0)
@ -281,15 +227,11 @@ typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*
 #define DirectInput8Create _glfw.win32.dinput8.Create

 // user32.dll function pointer typedefs
-typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
-typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,CHANGEFILTERSTRUCT*);
 typedef BOOL (WINAPI * PFN_EnableNonClientDpiScaling)(HWND);
 typedef BOOL (WINAPI * PFN_SetProcessDpiAwarenessContext)(HANDLE);
 typedef UINT (WINAPI * PFN_GetDpiForWindow)(HWND);
 typedef BOOL (WINAPI * PFN_AdjustWindowRectExForDpi)(LPRECT,DWORD,BOOL,DWORD,UINT);
 typedef int (WINAPI * PFN_GetSystemMetricsForDpi)(int,UINT);
-#define SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware_
-#define ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx_
 #define EnableNonClientDpiScaling _glfw.win32.user32.EnableNonClientDpiScaling_
 #define SetProcessDpiAwarenessContext _glfw.win32.user32.SetProcessDpiAwarenessContext_
 #define GetDpiForWindow _glfw.win32.user32.GetDpiForWindow_
@ -475,8 +417,6 @@ typedef struct _GLFWlibraryWin32

    struct {
        HINSTANCE                       instance;
-        PFN_SetProcessDPIAware          SetProcessDPIAware_;
-        PFN_ChangeWindowMessageFilterEx ChangeWindowMessageFilterEx_;
        PFN_EnableNonClientDpiScaling   EnableNonClientDpiScaling_;
        PFN_SetProcessDpiAwarenessContext SetProcessDpiAwarenessContext_;
        PFN_GetDpiForWindow             GetDpiForWindow_;
--- a/src/win32_window.c
+++ b/src/win32_window.c
@ -374,9 +374,6 @@ static void updateFramebufferTransparency(const _GLFWwindow* window)
    BOOL composition, opaque;
    DWORD color;

-    if (!IsWindowsVistaOrGreater())
-        return;
-
    if (FAILED(DwmIsCompositionEnabled(&composition)) || !composition)
       return;

@ -983,7 +980,6 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM l

        case WM_MOUSEHWHEEL:
        {
-            // This message is only sent on Windows Vista and later
            // NOTE: The X-axis is inverted for consistency with macOS and X11
            _glfwInputScroll(window, -((SHORT) HIWORD(wParam) / (double) WHEEL_DELTA), 0.0);
            return 0;
@ -1407,15 +1403,9 @@ static int createNativeWindow(_GLFWwindow* window,

    SetPropW(window->win32.handle, L"GLFW", window);

-    if (IsWindows7OrGreater())
-    {
-        ChangeWindowMessageFilterEx(window->win32.handle,
-                                    WM_DROPFILES, MSGFLT_ALLOW, NULL);
-        ChangeWindowMessageFilterEx(window->win32.handle,
-                                    WM_COPYDATA, MSGFLT_ALLOW, NULL);
-        ChangeWindowMessageFilterEx(window->win32.handle,
-                                    WM_COPYGLOBALDATA, MSGFLT_ALLOW, NULL);
-    }
+    ChangeWindowMessageFilterEx(window->win32.handle, WM_DROPFILES, MSGFLT_ALLOW, NULL);
+    ChangeWindowMessageFilterEx(window->win32.handle, WM_COPYDATA, MSGFLT_ALLOW, NULL);
+    ChangeWindowMessageFilterEx(window->win32.handle, WM_COPYGLOBALDATA, MSGFLT_ALLOW, NULL);

    window->win32.scaleToMonitor = wndconfig->scaleToMonitor;
    window->win32.keymenu = wndconfig->win32.keymenu;
@ -1981,9 +1971,6 @@ GLFWbool _glfwFramebufferTransparentWin32(_GLFWwindow* window)
    if (!window->win32.transparent)
        return GLFW_FALSE;

-    if (!IsWindowsVistaOrGreater())
-        return GLFW_FALSE;
-
    if (FAILED(DwmIsCompositionEnabled(&composition)) || !composition)
        return GLFW_FALSE;
Author	SHA1	Message	Date
Mike Gorchak	ea25d9e8b6	Merge `098a8c1697` into `d11cb3779b`	2025-07-15 11:01:54 +02:00
Camilla Löwy	d11cb3779b	Win32: Remove support for Windows XP and Vista It's increasingly difficult to maintain a safe testing environment for Windows XP, and so increasingly a burden on contributors to maintain support for it. Windows XP has been out of of support since 2014 and should not be used as a desktop OS. Fixes #2505	2025-07-11 16:49:23 +02:00
Camilla Löwy	d1b87143bc	Win32: Remove support for original MinGW The original MinGW distribution appears to no longer be maintained and should not be used. Anyone still using MinGW should consider switching to the MinGW-w64 fork or another actively maintained toolchain. MinGW-w64 supports 64-bit binaries and provides much newer compilers and Win32 headers. Fixes #2540	2025-07-10 17:59:12 +02:00
Mike Gorchak	098a8c1697	Add OpenGL ES variant of Boing demo.	2024-07-17 11:05:30 -04:00