v2

.github/workflows/build.yml

@@ -8,46 +8,47 @@ on:
 jobs:
 
   linux-gl:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:bionic
+      env: { LANG: "C.UTF-8" }
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
-          sudo apt-get update
-          sudo apt-get install g++ cmake libxi-dev libgl1-mesa-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
+          apt-get update
+          apt-get install g++ cmake libxi-dev libgl1-mesa-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
 
       - name: Build
         run: |
-          cmake . -DUSE_SDL2=OFF
+          cmake .
           make VERBOSE=1 -j2
 
-      - name: Test
-        run: |
-          ctest --output-on-failure
-
       - name: Package
         run: |
           make DESTDIR=$PWD/_install install
           tar -c -I "gzip -9" -f irrlicht-linux.tar.gz -C ./_install/usr/local .
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v3
         with:
           name: irrlicht-linux
           path: ./irrlicht-linux.tar.gz
 
   linux-gles:
-    # Xvfb test is broken on 20.04 for unknown reasons (not our bug)
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:bionic
+      env: { LANG: "C.UTF-8" }
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
-          sudo apt-get update
-          sudo apt-get install g++ cmake libxi-dev libgles2-mesa-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
+          apt-get update
+          apt-get install g++ cmake libxi-dev libgles2-mesa-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
 
       - name: Build
         run: |
-          cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=OFF -DENABLE_OPENGL=OFF -DENABLE_GLES2=ON
+          cmake . -DBUILD_EXAMPLES=1 -DENABLE_OPENGL=OFF -DENABLE_GLES2=ON
           make -j2
 
       - name: Test (headless)
@@ -61,18 +62,20 @@ jobs:
           LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2
 
   linux-sdl:
-    # something is wrong with the SDL cmake files on 20.04
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:jammy
+      env: { LANG: "C.UTF-8" }
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
-          sudo apt-get update
-          sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
+          apt-get update
+          apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
 
       - name: Build
         run: |
-          cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DCMAKE_BUILD_TYPE=Debug
+          cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON
           make -j2
 
       - name: Test (headless)
@@ -81,14 +84,16 @@ jobs:
           ./AutomatedTest null
 
   linux-sdl-gl3:
-    # Xvfb test is broken on 20.04 for unknown reasons (not our bug)
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:jammy
+      env: { LANG: "C.UTF-8" }
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
-          sudo apt-get update
-          sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
+          apt-get update
+          apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
 
       - name: Build
         run: |
@@ -106,14 +111,16 @@ jobs:
           LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest opengl3
 
   linux-sdl-gles2:
-    # something is wrong with the SDL cmake files on 20.04
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:jammy
+      env: { LANG: "C.UTF-8" }
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
-          sudo apt-get update
-          sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
+          apt-get update
+          apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
 
       - name: Build
         run: |
@@ -132,7 +139,7 @@ jobs:
 
   mingw:
     name: "MinGW ${{matrix.config.variant}}${{matrix.config.extras}}"
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
@@ -142,21 +149,22 @@ jobs:
           - {variant: win32, arch: i686, extras: "-sdl"}
           - {variant: win64, arch: x86_64, extras: "-sdl"}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install compiler
         run: |
           sudo apt-get update && sudo apt-get install cmake -qyy
-          ./scripts/ci-get-mingw.sh
+          wget http://minetest.kitsunemimi.pw/mingw-w64-${{matrix.config.arch}}_11.2.0_ubuntu20.04.tar.xz -O mingw.tar.xz
+          sudo tar -xaf mingw.tar.xz -C /usr
 
       - name: Build
         run: |
           ./scripts/ci-build-mingw.sh package
         env:
-          CC: ${{matrix.config.arch}}-w64-mingw32-clang
-          CXX: ${{matrix.config.arch}}-w64-mingw32-clang++
+          CC: ${{matrix.config.arch}}-w64-mingw32-gcc
+          CXX: ${{matrix.config.arch}}-w64-mingw32-g++
           extras: ${{matrix.config.extras}}
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v3
         with:
           name: irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}
           path: ./irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}.zip
@@ -164,7 +172,7 @@ jobs:
   macos:
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install deps
         run: |
           brew update
@@ -179,27 +187,13 @@ jobs:
         run: |
           ./bin/OSX/AutomatedTest null
 
-  macos-sdl:
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install deps
-        run: |
-          brew update
-          brew install cmake libpng jpeg sdl2
-
-      - name: Build
-        run: |
-          cmake . -DCMAKE_FIND_FRAMEWORK=LAST -DBUILD_EXAMPLES=1 -DUSE_SDL2=1
-          make -j3
-
   msvc:
     name: VS 2019 ${{ matrix.config.arch }} ${{ matrix.sdl.label }}
     runs-on: windows-2019
     env:
-      VCPKG_VERSION: 8eb57355a4ffb410a2e94c07b4dca2dffbee8e50
-      # 2023.10.19
-      vcpkg_packages: zlib libpng libjpeg-turbo
+      VCPKG_VERSION: 14e7bb4ae24616ec54ff6b2f6ef4e8659434ea44
+        # 2022.05.10
+      vcpkg_packages: zlib libpng libjpeg-turbo opengl-registry
     strategy:
       fail-fast: false
       matrix:
@@ -216,7 +210,6 @@ jobs:
           -
             use: FALSE
             label: '(no SDL)'
-            vcpkg_packages: opengl-registry
           -
             use: TRUE
             label: '(with SDL)'
@@ -224,7 +217,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Restore from cache and run vcpkg
         uses: lukka/run-vcpkg@v7
@@ -257,50 +250,7 @@ jobs:
         run: move include artifact/
 
       - name: Upload Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: msvc-${{ matrix.config.arch }}-${{matrix.sdl.use}}
+          name: msvc-${{ matrix.config.arch }}
           path: artifact/
-
-  android:
-    name: Android ${{ matrix.arch }}
-    runs-on: ubuntu-20.04
-    env:
-       ndk_version: "r25c"
-       ANDROID_NDK: ${{ github.workspace }}/android-ndk
-    strategy:
-      matrix:
-        arch: [armeabi-v7a, arm64-v8a, x86, x86_64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install deps
-        run: |
-          sudo rm /var/lib/man-db/auto-update
-          sudo apt-get update
-          sudo apt-get install -qyy wget unzip zip gcc-multilib make cmake
-
-      - name: Cache NDK
-        id: cache-ndk
-        uses: actions/cache@v4
-        with:
-          key: android-ndk-${{ env.ndk_version }}-linux
-          path: ${{ env.ANDROID_NDK }}
-
-      - name: Install NDK
-        run: |
-          wget --progress=bar:force "http://dl.google.com/android/repository/android-ndk-${ndk_version}-linux.zip"
-          unzip -q "android-ndk-${ndk_version}-linux.zip"
-          rm "android-ndk-${ndk_version}-linux.zip"
-          mv "android-ndk-${ndk_version}" "${ANDROID_NDK}"
-        if: ${{ steps.cache-ndk.outputs.cache-hit != 'true' }}
-
-      - name: Build
-        run: ./scripts/ci-build-android.sh ${{ matrix.arch }}
-
-      #- name: Upload Artifact
-      #  uses: actions/upload-artifact@v4
-      #  with:
-      #    name: irrlicht-android-${{ matrix.arch }}
-      #    path: ${{ runner.temp }}/pkg/${{ matrix.arch }}

.gitignore

@@ -5,7 +5,6 @@ install_manifest.txt
 IrrlichtMtConfig.cmake
 IrrlichtMtConfigVersion.cmake
 IrrlichtMtTargets.cmake
-CTestTestfile.cmake
 Makefile
 libs/*
 *.so*

CMakeLists.txt

@@ -1,6 +1,13 @@
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.5)
 
-set(IRRLICHTMT_REVISION 15)
+# >=3.9 enables IPO; >=3.11 prefers GLVND
+if(${CMAKE_VERSION} VERSION_LESS 3.11)
+	cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+else()
+	cmake_policy(VERSION 3.11)
+endif()
+
+set(IRRLICHTMT_REVISION 12)
 
 project(Irrlicht
 	VERSION 1.9.0.${IRRLICHTMT_REVISION}
@@ -9,9 +16,6 @@ project(Irrlicht
 
 message(STATUS "*** Building IrrlichtMt ${PROJECT_VERSION} ***")
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
 include(GNUInstallDirs)
 
 if(ANDROID)
@@ -34,9 +38,7 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-enable_testing()
 add_subdirectory(source/Irrlicht)
-add_subdirectory(test)
 
 option(BUILD_EXAMPLES "Build example applications" FALSE)
 if(BUILD_EXAMPLES)

Config.cmake.in

@@ -1,11 +1,5 @@
 @PACKAGE_INIT@
 
-include(CMakeFindDependencyMacro)
-
 if(NOT TARGET IrrlichtMt::IrrlichtMt)
-	# private dependency only explicitly needed with static libs
-	if(@USE_SDL2@ AND NOT @BUILD_SHARED_LIBS@)
-		find_dependency(SDL2)
-	endif()
 	include("${CMAKE_CURRENT_LIST_DIR}/IrrlichtMtTargets.cmake")
 endif()

LICENSE

@@ -1,26 +0,0 @@
-Copyright (C) 2002-2012 Nikolaus Gebhardt
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Please note that the Irrlicht Engine is based in part on the work of the
-  Independent JPEG Group, the zlib, libPng and aesGladman. This means that if you use
-  the Irrlicht Engine in your product, you must acknowledge somewhere in your
-  documentation that you've used the IJPG code. It would also be nice to mention
-  that you use the Irrlicht Engine, the zlib, libPng and aesGladman. See the
-  corresponding license files for further informations. It is also possible to disable
-  usage of those additional libraries by defines in the IrrCompileConfig.h header and
-  recompiling the engine.

LICENSE

@@ -0,0 +1 @@
+doc/irrlicht-license.txt

README.md

@@ -1,8 +1,9 @@
 IrrlichtMt version 1.9
 ======================
 
-IrrlichtMt is the 3D engine of [Minetest](https://github.com/minetest).
-It is based on the [Irrlicht Engine](https://irrlicht.sourceforge.io/) but is now developed independently.
+The Irrlicht Engine is an open source realtime 3D engine written in C++.
+
+This is a fork by the [Minetest](https://github.com/minetest) developers that was stripped-down and customized specifically for use in Minetest.
 It is intentionally not compatible to upstream and is planned to be eventually absorbed into Minetest.
 
 Build
@@ -15,7 +16,6 @@ The following libraries are required to be installed:
 * OpenGL
   * or on mobile: OpenGL ES (can be optionally enabled on desktop too)
 * on Unix: X11
-* SDL2 (see below)
 
 Aside from standard search options (`ZLIB_INCLUDE_DIR`, `ZLIB_LIBRARY`, ...) the following options are available:
 * `BUILD_SHARED_LIBS` (default: `ON`) - Build IrrlichtMt as a shared library
@@ -24,7 +24,7 @@ Aside from standard search options (`ZLIB_INCLUDE_DIR`, `ZLIB_LIBRARY`, ...) the
 * `ENABLE_OPENGL3` (default: `OFF`) - Enable OpenGL 3+ driver
 * `ENABLE_GLES1` - Enable OpenGL ES driver, legacy
 * `ENABLE_GLES2` - Enable OpenGL ES 2+ driver
-* `USE_SDL2` (default: platform-dependent, usually `ON`) - Use SDL2 instead of older native device code
+* `USE_SDL2` (default: `OFF`) - Use SDL2 instead of native platform device
 
 e.g. on a Linux system you might want to build for local use like this:
 
@@ -41,7 +41,7 @@ It is highly recommended to use vcpkg as package manager.
 
 After you successfully built vcpkg you can easily install the required libraries:
 
-	vcpkg install zlib libjpeg-turbo libpng sdl2 --triplet x64-windows
+	vcpkg install zlib libjpeg-turbo libpng opengl-registry --triplet x64-windows
 	
 Run the following script in PowerShell:
 

bin/Linux/readme.txt

@@ -0,0 +1,4 @@
+If you wish to compile the engine in linux yourself, 
+goto the \source directory. Run a 'make' in the subfolder 'Irrlicht'.
+After this, you should be able to make all example applications in \examples.
+Then just start an X Server and run them, from the directory where they are.

bin/OSX/readme.txt

@@ -0,0 +1 @@
+If you want to compile only the Irrlicht Engine you should use XCode project available at source/Irrlicht/ directory. You can also use examples/BuildAllExamples.xcworkspace file to build the Irrlicht Engine + all examples.

bin/Win32-VisualStudio/readme.txt

@@ -0,0 +1,25 @@
+The Win32-VisualStudio version is currently (Irrlicht 1.8) compiled with VS 2010 using the Windows 7.1 SDK as platform toolset.
+You might get the necessary Windows Platform SDK here: http://msdn.microsoft.com/en-us/windows/bb980924.aspx
+
+To link to that Irrlicht.dll you need to set platform toolset in your VS version to the same target or re-compile the Irrlicht.dll using another platform toolset.
+
+To re-compile Irrlicht for Win32-VisualStudio:
+There are several project files for different VS versions in source/Irrlicht.
+Irrlicht10.0.sln is for VS 2010
+Irrlicht11.0.sln is for VS 2012
+Irrlicht12.0.sln is for VS 2013
+
+To compile Irrlicht + all examples and all tools check the BuildAllExamples_*.sln files in the examples folder.
+
+For newer VS versions you have update one of those projects (VS usually can do that automatically when you open an older solution file).
+
+Currently each of those solutions does set the platform toolset "Windows 7.1 SDK" (to be compatible to each other). 
+You might want to change that in the project settings and set it to your current version.
+Make sure you use the same platform toolset in your application and in the engine.
+Also when compiling examples each example has to use the same platform toolset as was used for the engine.
+
+Platform should be Win32
+Configuration is by default "Release"
+But you can also chose "Debug" if you want Irrlicht with Debug information.
+Static builds are possible but you have to additionally set the _IRR_STATIC_LIB_ define in the application when linking to a static Irrlicht.lib
+

bin/Win32-gcc/readme.txt

@@ -0,0 +1,16 @@
+If you wish to compile Irrlicht for Win32-gcc you have several choices.
+
+1. You can work from within a MinGW shell.
+Go to the folder source/Irrlicht and run the Makefile with:
+make win32 
+Examples can be build by going into the folder of the example (for example examples/01.HelloWorld) and running the Makefile with:
+make all_win32
+
+2. Use the Code::Blocks IDE
+There is a project file called Irrlicht-gcc.cbp in source/Irrlicht to compile just the engine.
+Be sure to select a Windows target like "Win32 - release - accurate math - dll"
+
+There is also Code::Blocks workspace file in the examples folder called BuildAllExamples.workspace
+Again be sure to select a Windows target like "Win32 - release - accurate math - dll"
+This workspace allows you to compile the engine together with all examples and tools.
+

bin/emscripten/readme.txt

@@ -0,0 +1 @@
+If you wish to compile Irrlicht for emscripten please check the documenation in examples/01.HelloWorld_emscripten.

build.sh

@@ -0,0 +1,27 @@
+#!/bin/bash -e
+args=(-DBUILD_EXAMPLES=ON -DENABLE_OPENGL=OFF -DBUILD_SHARED_LIBS=OFF)
+
+export CC=afl-clang-fast
+export CXX=afl-clang-fast++
+export LD=$CXX
+unset AFL_USE_ASAN
+if ! grep -Fq '/afl-' build2/CMakeCache.txt; then
+	rm -rf build2
+	cmake -S . -B build2 "${args[@]}"
+fi
+nice make -C build2 clean
+nice make -C build2 -j10
+for f in build2/bin/Linux/*; do
+	ln -snfv "../../$f" "bin/Linux/${f##*/}_noasan"
+done
+
+export CC=afl-clang-lto
+export CXX=afl-clang-lto++
+export LD=$CXX
+export AFL_USE_ASAN=1
+if ! grep -Fq '/afl-' CMakeCache.txt; then
+	rm -f CMakeCache.txt
+	cmake . "${args[@]}"
+fi
+nice make clean
+nice make -j10

doc/irrlicht-license.txt

@@ -0,0 +1,26 @@
+Copyright (C) 2002-2012 Nikolaus Gebhardt
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Please note that the Irrlicht Engine is based in part on the work of the
+  Independent JPEG Group, the zlib, libPng and aesGladman. This means that if you use
+  the Irrlicht Engine in your product, you must acknowledge somewhere in your
+  documentation that you've used the IJPG code. It would also be nice to mention
+  that you use the Irrlicht Engine, the zlib, libPng and aesGladman. See the 
+  corresponding license files for further informations. It is also possible to disable
+  usage of those additional libraries by defines in the IrrCompileConfig.h header and 
+  recompiling the engine.

doc/release_checklist.txt

@@ -0,0 +1,63 @@
+Checklist for Irrlicht developers doing releases.
+
+Note: Generally the more platforms, compilers, settings you can test the better. Ask for help for platforms which you don't own.
+
+- PRE-BUILD TESTS:
+- - Run tests in the tests folder
+- - Compile and run examples.
+- - Compile and run the tools. Note that some tools are in the buildall-examples VS project files on Windows, 
+    but on Linux command line you have to compile them individually.
+
+- VERSION UPDATES:
+- - check IRRLICHT_SDK_VERSION (in IrrCompileConfig.h)
+- - check version number in the Makefile
+- - update readme.txt (version number, supported compilers)
+- - Add new release information (date+version-number) in changes.txt
+- - go through folders if other .txt files still make sense (things change and updating those files tends to be forgotten)
+
+- DOCUMENTATION UPDATES:
+- - run makedocumentation.sh in scripts\doc\irrlicht
+- - run maketutorial.sh in scripts\doc\irrlicht (commit changed tutorial.html's)
+
+- BUILDING THE RELEASE
+  (TBD - should we still release dll's? Newer and older VS builds are no longer compatible anyway)
+- - run a clean build for buildAllExamples in the examples folder with the 
+    target compiler for 32-bit and for release (old VS compiler - so far VS2010)
+- - when possible compile the dll for MinGW on Windows (in release and with -s for smaller size)
+- - when possible compile the dll for 64 bit (again with Visual Studio and release)
+- - create a target directory, like irrlicht-1.8.1 for example
+- - svn export to the target directory
+- - copy the subfolders of doctemp into the doc folder of the target directory
+    careful, this should only be one(!) subfolder (we ended up with copies before, maybe Windows/Linux builds use different names?)
+- - copy all .exe files (except test.exe) from bin\Win32-VisualStudio (.pdb's are not necessary)
+- - copy Irrlicht.dll from bin\Win32-visualstudio 
+- - copy the files in lib\Win32-visualstudio
+- - copy Irrlicht.dll from bin\Win64-VisualStudio 
+- - copy the files in lib\Win64-visualstudio 
+- - copy Irrlicht.dll from bin\Win32-gcc 
+- - copy the files in lib\Win32-gcc
+- - remove the tests folder
+- - remove scripts folder (if the release comes with docs, if you do a release 
+without docs for smaller filesizes then the script folder has to stay in).
+- - create a zip file 
+- - figure out how to fix unix access right for shell-scripts in the zip file (my 
+trick so far is: unzip in Linux, set +x for all .sh files, zip again)
+
+RELEASING:
+- - upload the zip-file somewhere, then download it again on all platforms and do 
+  another quick test with that file (do examples still run, can you compile)
+- - give the link to the zip out on the mailinglist for others to look at
+- - Upload new documentation (the content of doc/html) to: web.sourceforge.net 
+  (sftp protocol, user and passwd are your sourceforge account, the folder 
+  might not be shown - but you can still cd into it!):
+  /home/project-web/i/ir/irrlicht/htdocs 
+  Best create first a folder with a new name, copy stuff in there, test (just 
+  check the website), rename old folder and give new folder the "docu" name. 
+  Then you can delete the old folder if you want.
+- - upload the zip by logging in to sourceforge and using the "Files" menu (needs 
+	admin privileges and it's the 'Files' menu between 'Summary' and 'Reviews'). 
+	The target is in one of the Irrlicht SDK subfolders. Then click the "i" beside 
+	the file and "select all" to make it the active download.
+- - write a forum post, tell everyone in facebook, reddit, your friends...
+- - login to wordpress at http://irrlicht.sourceforge.net/wp-login.php, update the 
+	downloads section and write a release post.

examples/AutomatedTest/test_string.cpp

@@ -168,32 +168,22 @@ static void test_methods()
 
 static void test_conv()
 {
-	// locale-independent
+	// assumes Unicode and UTF-8 locale
+	setlocale(LC_CTYPE, "");
 
 	stringw out;
-	utf8ToWString(out, "†††");
+	multibyteToWString(out, "†††");
 	UASSERTEQ(out.size(), 3);
 	for (int i = 0; i < 3; i++)
 		UASSERTEQ(static_cast<u16>(out[i]), 0x2020);
-
 	stringc out2;
-	wStringToUTF8(out2, L"†††");
+	wStringToMultibyte(out2, L"†††");
 	UASSERTEQ(out2.size(), 9);
 	for (int i = 0; i < 3; i++) {
 		UASSERTEQ(static_cast<u8>(out2[3*i]), 0xe2);
 		UASSERTEQ(static_cast<u8>(out2[3*i+1]), 0x80);
 		UASSERTEQ(static_cast<u8>(out2[3*i+2]), 0xa0);
 	}
-
-	// locale-dependent
-	if (!setlocale(LC_CTYPE, "C.UTF-8"))
-		setlocale(LC_CTYPE, "UTF-8"); // macOS
-
-	stringw out3;
-	multibyteToWString(out3, "†††");
-	UASSERTEQ(out3.size(), 3);
-	for (int i = 0; i < 3; i++)
-		UASSERTEQ(static_cast<u16>(out3[i]), 0x2020);
 }
 
 void test_irr_string()

examples/CMakeLists.txt

@@ -1,7 +1,11 @@
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 set(IRREXAMPLES
-	# removed
+	LoadTexture
+	LoadMesh
 )
-if(UNIX)
+if(FALSE)
 	list(APPEND IRREXAMPLES AutomatedTest)
 endif()
 

examples/LoadMesh/main.cpp

@@ -0,0 +1,44 @@
+#include <irrlicht.h>
+#include <iostream>
+
+using namespace irr;
+
+int main(int argc, char *argv[])
+{
+	if (argc < 2)
+		return 1;
+
+	SIrrlichtCreationParameters p;
+	p.DriverType = video::EDT_NULL;
+	p.WindowSize = core::dimension2du(640, 480);
+	p.LoggingLevel = ELL_DEBUG;
+
+	auto *device = createDeviceEx(p);
+	if (!device)
+		return 1;
+	auto *smgr = device->getSceneManager();
+
+	while (__AFL_LOOP(10000)) {
+		auto *mfile = device->getFileSystem()->createAndOpenFile(argv[1]);
+		if (!mfile)
+			continue;
+		scene::IAnimatedMesh *mesh;
+		// Irrlicht matches on file extension so we have to do this by hand
+		for (u32 i = 0; i < smgr->getMeshLoaderCount(); i++) {
+			mfile->seek(0);
+			mesh = smgr->getMeshLoader(i)->createMesh(mfile);
+			if (mesh) {
+				core::stringc msg("Loaded using loader #");
+				msg += core::stringc(i);
+				device->getLogger()->log(msg.c_str(), ELL_DEBUG);
+				break;
+			}
+		}
+		if (mesh)
+			mesh->drop();
+		mfile->drop();
+	}
+
+	device->drop();
+	return 0;
+}

examples/LoadTexture/main.cpp

@@ -0,0 +1,29 @@
+#include <irrlicht.h>
+#include <iostream>
+
+using namespace irr;
+
+int main(int argc, char *argv[])
+{
+	if (argc < 2)
+		return 1;
+
+	SIrrlichtCreationParameters p;
+	p.DriverType = video::EDT_NULL;
+	p.WindowSize = core::dimension2du(640, 480);
+	p.LoggingLevel = ELL_DEBUG;
+
+	auto *device = createDeviceEx(p);
+	if (!device)
+		return 1;
+	auto *driver = device->getVideoDriver();
+
+	while (__AFL_LOOP(10000)) {
+		auto *tex = driver->getTexture(argv[1]);
+		if (tex)
+			driver->removeTexture(tex);
+	}
+
+	device->drop();
+	return 0;
+}

include/CIndexBuffer.h

@@ -0,0 +1,226 @@
+// Copyright (C) 2008-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_INDEX_BUFFER_H_INCLUDED__
+#define __C_INDEX_BUFFER_H_INCLUDED__
+
+#include "IIndexBuffer.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	class CIndexBuffer : public IIndexBuffer
+	{
+
+		class IIndexList
+		{
+		public:
+			virtual ~IIndexList(){};
+
+			virtual u32 stride() const =0;
+			virtual u32 size() const =0;
+			virtual void push_back(const u32 &element) =0;
+			virtual u32 operator [](u32 index) const =0;
+			virtual u32 getLast() =0;
+			virtual void setValue(u32 index, u32 value) =0;
+			virtual void set_used(u32 usedNow) =0;
+			virtual void reallocate(u32 new_size) =0;
+			virtual u32 allocated_size() const =0;
+			virtual void* pointer() =0;
+			virtual video::E_INDEX_TYPE getType() const =0;
+		};
+
+		template <class T>
+		class CSpecificIndexList : public IIndexList
+		{
+		public:
+			core::array<T> Indices;
+
+			u32 stride() const override {return sizeof(T);}
+
+			u32 size() const override {return Indices.size();}
+
+			void push_back(const u32 &element) override
+			{
+				// push const ref due to compiler problem with gcc 4.6, big endian
+				Indices.push_back((const T&)element);
+			}
+
+			u32 operator [](u32 index) const override
+			{
+				return (u32)(Indices[index]);
+			}
+
+			u32 getLast() override {return (u32)Indices.getLast();}
+
+			void setValue(u32 index, u32 value) override
+			{
+				Indices[index]=(T)value;
+			}
+
+			void set_used(u32 usedNow) override
+			{
+				Indices.set_used(usedNow);
+			}
+
+			void reallocate(u32 new_size) override
+			{
+				Indices.reallocate(new_size);
+			}
+
+			u32 allocated_size() const override
+			{
+				return Indices.allocated_size();
+			}
+
+			void* pointer() override  {return Indices.pointer();}
+
+			video::E_INDEX_TYPE getType() const override
+			{
+				if (sizeof(T)==sizeof(u16))
+					return video::EIT_16BIT;
+				else
+					return video::EIT_32BIT;
+			}
+		};
+
+	public:
+		IIndexList *Indices;
+
+		CIndexBuffer(video::E_INDEX_TYPE IndexType) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			setType(IndexType);
+		}
+
+		CIndexBuffer(const IIndexBuffer &IndexBufferCopy) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			setType(IndexBufferCopy.getType());
+			reallocate(IndexBufferCopy.size());
+
+			for (u32 n=0;n<IndexBufferCopy.size();++n)
+				push_back(IndexBufferCopy[n]);
+		}
+
+		virtual ~CIndexBuffer()
+		{
+			delete Indices;
+		}
+
+		//virtual void setType(video::E_INDEX_TYPE IndexType);
+		void setType(video::E_INDEX_TYPE IndexType) override
+		{
+			IIndexList *NewIndices=0;
+
+			switch (IndexType)
+			{
+				case video::EIT_16BIT:
+				{
+					NewIndices=new CSpecificIndexList<u16>;
+					break;
+				}
+				case video::EIT_32BIT:
+				{
+					NewIndices=new CSpecificIndexList<u32>;
+					break;
+				}
+			}
+
+			if (Indices)
+			{
+				NewIndices->reallocate( Indices->size() );
+
+				for(u32 n=0;n<Indices->size();++n)
+					NewIndices->push_back((*Indices)[n]);
+
+				delete Indices;
+			}
+
+			Indices=NewIndices;
+		}
+
+		void* getData() override {return Indices->pointer();}
+
+		video::E_INDEX_TYPE getType() const override {return Indices->getType();}
+
+		u32 stride() const override {return Indices->stride();}
+
+		u32 size() const override
+		{
+			return Indices->size();
+		}
+
+		void push_back(const u32 &element) override
+		{
+			Indices->push_back(element);
+		}
+
+		u32 operator [](u32 index) const override
+		{
+			return (*Indices)[index];
+		}
+
+		u32 getLast() override
+		{
+			return Indices->getLast();
+		}
+
+		void setValue(u32 index, u32 value) override
+		{
+			Indices->setValue(index, value);
+		}
+
+		void set_used(u32 usedNow) override
+		{
+			Indices->set_used(usedNow);
+		}
+
+		void reallocate(u32 new_size) override
+		{
+			Indices->reallocate(new_size);
+		}
+
+		u32 allocated_size() const override
+		{
+			return Indices->allocated_size();
+		}
+
+		void* pointer() override
+		{
+			return Indices->pointer();
+		}
+
+		//! get the current hardware mapping hint
+		E_HARDWARE_MAPPING getHardwareMappingHint() const override
+		{
+			return MappingHint;
+		}
+
+		//! set the hardware mapping hint, for driver
+		void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override
+		{
+			MappingHint=NewMappingHint;
+		}
+
+		//! flags the mesh as changed, reloads hardware buffers
+		void setDirty() override
+		{
+			++ChangedID;
+		}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		u32 getChangedID() const override {return ChangedID;}
+
+		E_HARDWARE_MAPPING MappingHint;
+		u32 ChangedID;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/CMeshBuffer.h

@@ -206,6 +206,37 @@ namespace scene
 		}
 
 
+		//! Append the meshbuffer to the current buffer
+		/** Only works for compatible types, i.e. either the same type
+		or the main buffer is of standard type. Otherwise, behavior is
+		undefined.
+		\param other Meshbuffer to be appended to this one.
+		*/
+		void append(const IMeshBuffer* const other) override
+		{
+			/*
+			if (this==other)
+				return;
+
+			const u32 vertexCount = getVertexCount();
+			u32 i;
+
+			Vertices.reallocate(vertexCount+other->getVertexCount());
+			for (i=0; i<other->getVertexCount(); ++i)
+			{
+				Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
+			}
+
+			Indices.reallocate(getIndexCount()+other->getIndexCount());
+			for (i=0; i<other->getIndexCount(); ++i)
+			{
+				Indices.push_back(other->getIndices()[i]+vertexCount);
+			}
+			BoundingBox.addInternalBox(other->getBoundingBox());
+			*/
+		}
+
+
 		//! get the current hardware mapping hint
 		E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
 		{

include/CVertexBuffer.h

@@ -0,0 +1,213 @@
+// Copyright (C) 2008-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_VERTEX_BUFFER_H_INCLUDED__
+#define __C_VERTEX_BUFFER_H_INCLUDED__
+
+#include "IVertexBuffer.h"
+
+
+namespace irr
+{
+namespace scene
+{
+
+	class CVertexBuffer : public IVertexBuffer
+	{
+		class IVertexList
+		{
+		public:
+			virtual ~IVertexList(){};
+
+			virtual u32 stride() const =0;
+
+			virtual u32 size() const =0;
+
+			virtual void push_back (const video::S3DVertex &element) =0;
+			virtual video::S3DVertex& operator [](const u32 index) const =0;
+			virtual video::S3DVertex& getLast() =0;
+			virtual void set_used(u32 usedNow) =0;
+			virtual void reallocate(u32 new_size) =0;
+			virtual u32 allocated_size() const =0;
+			virtual video::S3DVertex* pointer() =0;
+			virtual video::E_VERTEX_TYPE getType() const =0;
+		};
+
+		template <class T>
+		class CSpecificVertexList : public IVertexList
+		{
+		public:
+			core::array<T> Vertices;
+
+			u32 stride() const override {return sizeof(T);}
+
+			u32 size() const override {return Vertices.size();}
+
+			void push_back (const video::S3DVertex &element) override
+			{Vertices.push_back((T&)element);}
+
+			video::S3DVertex& operator [](const u32 index) const override
+			{return (video::S3DVertex&)Vertices[index];}
+
+			video::S3DVertex& getLast() override
+			{return (video::S3DVertex&)Vertices.getLast();}
+
+			void set_used(u32 usedNow) override
+			{Vertices.set_used(usedNow);}
+
+			void reallocate(u32 new_size) override
+			{Vertices.reallocate(new_size);}
+
+			u32 allocated_size() const override
+			{
+				return Vertices.allocated_size();
+			}
+
+			video::S3DVertex* pointer() override {return Vertices.pointer();}
+
+			video::E_VERTEX_TYPE getType() const override {return T::getType();}
+		};
+
+	public:
+		IVertexList *Vertices;
+
+		CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),
+				MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			CVertexBuffer::setType(vertexType);
+		}
+
+		CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :
+				Vertices(0), MappingHint(EHM_NEVER),
+				ChangedID(1)
+		{
+			CVertexBuffer::setType(VertexBufferCopy.getType());
+			CVertexBuffer::reallocate(VertexBufferCopy.size());
+
+			for (u32 n=0;n<VertexBufferCopy.size();++n)
+				CVertexBuffer::push_back(VertexBufferCopy[n]);
+		}
+
+		virtual ~CVertexBuffer()
+		{
+			delete Vertices;
+		}
+
+
+		void setType(video::E_VERTEX_TYPE vertexType) override
+		{
+			if ( Vertices && Vertices->getType() == vertexType )
+				return;
+
+			IVertexList *NewVertices=0;
+
+			switch (vertexType)
+			{
+				case video::EVT_STANDARD:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertex>;
+					break;
+				}
+				case video::EVT_2TCOORDS:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;
+					break;
+				}
+				case video::EVT_TANGENTS:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;
+					break;
+				}
+			}
+			if (Vertices)
+			{
+				NewVertices->reallocate( Vertices->size() );
+
+				for(u32 n=0;n<Vertices->size();++n)
+					NewVertices->push_back((*Vertices)[n]);
+
+				delete Vertices;
+			}
+
+			Vertices=NewVertices;
+		}
+
+		void* getData() override {return Vertices->pointer();}
+
+		video::E_VERTEX_TYPE getType() const override {return Vertices->getType();}
+
+		u32 stride() const override {return Vertices->stride();}
+
+		u32 size() const override
+		{
+			return Vertices->size();
+		}
+
+		void push_back (const video::S3DVertex &element) override
+		{
+			Vertices->push_back(element);
+		}
+
+		video::S3DVertex& operator [](const u32 index) const override
+		{
+			return (*Vertices)[index];
+		}
+
+		video::S3DVertex& getLast() override
+		{
+			return Vertices->getLast();
+		}
+
+		void set_used(u32 usedNow) override
+		{
+			Vertices->set_used(usedNow);
+		}
+
+		void reallocate(u32 new_size) override
+		{
+			Vertices->reallocate(new_size);
+		}
+
+		u32 allocated_size() const override
+		{
+			return Vertices->allocated_size();
+		}
+
+		video::S3DVertex* pointer() override
+		{
+			return Vertices->pointer();
+		}
+
+		//! get the current hardware mapping hint
+		E_HARDWARE_MAPPING getHardwareMappingHint() const override
+		{
+			return MappingHint;
+		}
+
+		//! set the hardware mapping hint, for driver
+		void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override
+		{
+			MappingHint=NewMappingHint;
+		}
+
+		//! flags the mesh as changed, reloads hardware buffers
+		void setDirty() override
+		{
+			++ChangedID;
+		}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		u32 getChangedID() const override  {return ChangedID;}
+
+		E_HARDWARE_MAPPING MappingHint;
+		u32 ChangedID;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/EAttributes.h

@@ -19,9 +19,75 @@ enum E_ATTRIBUTE_TYPE
 	// float attribute
 	EAT_FLOAT,
 
+	// string attribute
+	EAT_STRING,
+
 	// boolean attribute
 	EAT_BOOL,
 
+	// enumeration attribute
+	EAT_ENUM,
+
+	// color attribute
+	EAT_COLOR,
+
+	// floating point color attribute
+	EAT_COLORF,
+
+	// 3d vector attribute
+	EAT_VECTOR3D,
+
+	// 2d position attribute
+	EAT_POSITION2D,
+
+	// vector 2d attribute
+	EAT_VECTOR2D,
+
+	// rectangle attribute
+	EAT_RECT,
+
+	// matrix attribute
+	EAT_MATRIX,
+
+	// quaternion attribute
+	EAT_QUATERNION,
+
+	// 3d bounding box
+	EAT_BBOX,
+
+	// plane
+	EAT_PLANE,
+
+	// 3d triangle
+	EAT_TRIANGLE3D,
+
+	// line 2d
+	EAT_LINE2D,
+
+	// line 3d
+	EAT_LINE3D,
+
+	// array of stringws attribute
+	EAT_STRINGWARRAY,
+
+	// array of float
+	EAT_FLOATARRAY,
+
+	// array of int
+	EAT_INTARRAY,
+
+	// binary data attribute
+	EAT_BINARY,
+
+	// texture reference attribute
+	EAT_TEXTURE,
+
+	// user pointer void*
+	EAT_USER_POINTER,
+
+	// dimension attribute
+	EAT_DIMENSION2D,
+
 	// known attribute type count
 	EAT_COUNT,
 

include/EDriverFeatures.h

@@ -121,6 +121,21 @@ namespace video
 		//! Support for texture coord transformation via texture matrix
 		EVDF_TEXTURE_MATRIX,
 
+		//! Support for DXTn compressed textures.
+		EVDF_TEXTURE_COMPRESSED_DXT,
+
+		//! Support for PVRTC compressed textures.
+		EVDF_TEXTURE_COMPRESSED_PVRTC,
+
+		//! Support for PVRTC2 compressed textures.
+		EVDF_TEXTURE_COMPRESSED_PVRTC2,
+
+		//! Support for ETC1 compressed textures.
+		EVDF_TEXTURE_COMPRESSED_ETC1,
+
+		//! Support for ETC2 compressed textures.
+		EVDF_TEXTURE_COMPRESSED_ETC2,
+
 		//! Support for cube map textures.
 		EVDF_TEXTURE_CUBEMAP,
 

include/EMaterialTypes.h

@@ -5,8 +5,6 @@
 #ifndef __E_MATERIAL_TYPES_H_INCLUDED__
 #define __E_MATERIAL_TYPES_H_INCLUDED__
 
-#include "irrTypes.h"
-
 namespace irr
 {
 namespace video
@@ -69,9 +67,6 @@ namespace video
 		0
 	};
 
-	constexpr u32 numBuiltInMaterials =
-		sizeof(sBuiltInMaterialTypeNames) / sizeof(char*) - 1;
-
 } // end namespace video
 } // end namespace irr
 

include/IAttributes.h

@@ -6,10 +6,25 @@
 #define __I_ATTRIBUTES_H_INCLUDED__
 
 #include "IReferenceCounted.h"
-#include "EAttributes.h"
-
-// not needed here but I can't be bothered to clean the transitive includes up.
+#include "SColor.h"
+#include "vector3d.h"
+#include "vector2d.h"
+#include "line2d.h"
+#include "line3d.h"
+#include "triangle3d.h"
+#include "position2d.h"
+#include "rect.h"
+#include "dimension2d.h"
+#include "matrix4.h"
 #include "quaternion.h"
+#include "plane3d.h"
+#include "triangle3d.h"
+#include "line2d.h"
+#include "line3d.h"
+#include "irrString.h"
+#include "irrArray.h"
+#include "EAttributes.h"
+#include "path.h"
 
 namespace irr
 {
@@ -40,6 +55,16 @@ public:
 	//! \param index: Index value, must be between 0 and getAttributeCount()-1.
 	virtual E_ATTRIBUTE_TYPE getAttributeType(s32 index) const = 0;
 
+	//! Returns the type string of the attribute
+	//! \param attributeName: String for the attribute type
+	//! \param defaultNotFound Value returned when attributeName was not found
+	virtual const wchar_t* getAttributeTypeString(const c8* attributeName, const wchar_t* defaultNotFound = L"unknown") const = 0;
+
+	//! Returns the type string of the attribute by index.
+	//! \param index: Index value, must be between 0 and getAttributeCount()-1.
+	//! \param defaultNotFound Value returned for an invalid index
+	virtual const wchar_t* getAttributeTypeString(s32 index, const wchar_t* defaultNotFound = L"unknown") const = 0;
+
 	//! Returns if an attribute with a name exists
 	virtual bool existsAttribute(const c8* attributeName) const = 0;
 

include/IContextManager.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_I_CONTEXT_MANAGER_H_INCLUDED__
+#define __IRR_I_CONTEXT_MANAGER_H_INCLUDED__
 
 #include "SExposedVideoData.h"
 #include "SIrrCreationParameters.h"
@@ -59,3 +60,4 @@ namespace video
 } // end namespace irr
 
 
+#endif

include/ICursorControl.h

@@ -26,7 +26,7 @@ namespace gui
 		ECI_HELP,	// Arrow and question mark
 		ECI_IBEAM,	// typical text-selection cursor
 		ECI_NO,		// should not click icon
-		ECI_WAIT,	// hourglass
+		ECI_WAIT,	// hourclass
 		ECI_SIZEALL,	// arrow in all directions
 		ECI_SIZENESW,	// resizes in direction north-east or south-west
 		ECI_SIZENWSE,	// resizes in direction north-west or south-east

include/IEventReceiver.h

@@ -263,10 +263,6 @@ namespace irr
 			//! A checkbox has changed its check state.
 			EGET_CHECKBOX_CHANGED,
 
-			//! A listbox would like to open.
-			/** You can prevent the listbox from opening by absorbing the event. */
-			EGET_LISTBOX_OPENED,
-
 			//! A new item in a listbox was selected.
 			/** NOTE: You also get this event currently when the same item was clicked again after more than 500 ms. */
 			EGET_LISTBOX_CHANGED,

include/IGPUProgrammingServices.h

@@ -155,7 +155,7 @@ public:
 			callback, baseMaterial, userData);
 	}
 
-	//! Like addHighLevelShaderMaterial(), but loads from files.
+	//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
 	/** \param vertexShaderProgramFileName Text file containing the source
 	of the vertex shader program. Set to empty string if no vertex shader
 	shall be created.
@@ -279,7 +279,7 @@ public:
 			callback, baseMaterial, userData);
 	}
 
-	//! Like addHighLevelShaderMaterial(), but loads from files.
+	//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
 	/** \param vertexShaderProgram Text file handle containing the source
 	of the vertex shader program. Set to 0 if no vertex shader shall be
 	created.
@@ -357,14 +357,94 @@ public:
 			callback, baseMaterial, userData);
 	}
 
-	//! Delete a shader material and associated data.
-	/**
-	After you have deleted a material it is invalid to still use and doing
-	so might result in a crash. The ID may be reused in the future when new
-	materials are added.
-	\param material Number of the material type. Must not be a built-in
-	material. */
-	virtual void deleteShaderMaterial(s32 material) = 0;
+	//! Adds a new ASM shader material renderer to the VideoDriver
+	/** Note that it is a good idea to call IVideoDriver::queryFeature() in
+	advance to check if the IVideoDriver supports the vertex and/or pixel
+	shader version your are using.
+
+	The material is added to the VideoDriver like with
+	IVideoDriver::addMaterialRenderer() and can be used like it had been
+	added with that method.
+	\param vertexShaderProgram String containing the source of the vertex
+	shader program. This can be 0 if no vertex program shall be used.
+
+	For DX8 programs, the will always input registers look like this: v0:
+	position, v1: normal, v2: color, v3: texture coordinates, v4: texture
+	coordinates 2 if available.
+
+	For DX9 programs, you can manually set the registers using the dcl_
+	statements.
+	\param pixelShaderProgram String containing the source of the pixel
+	shader program. This can be 0 if you don't want to use a pixel shader.
+	\param callback Pointer to an implementation of
+	IShaderConstantSetCallBack in which you can set the needed vertex and
+	pixel shader program constants. Set this to 0 if you don't need this.
+	\param baseMaterial Base material which renderstates will be used to
+	shade the material.
+	\param userData a user data int. This int can be set to any value and
+	will be set as parameter in the callback method when calling
+	OnSetConstants(). In this way it is easily possible to use the same
+	callback method for multiple materials and distinguish between them
+	during the call.
+	\return Returns the number of the material type which can be set in
+	SMaterial::MaterialType to use the renderer. -1 is returned if an
+	error occurred. -1 is returned for example if a vertex or pixel shader
+	program could not be compiled, the error strings are then printed out
+	into the error log, and can be caught with a custom event receiver. */
+	virtual s32 addShaderMaterial(const c8* vertexShaderProgram = 0,
+		const c8* pixelShaderProgram = 0,
+		IShaderConstantSetCallBack* callback = 0,
+		E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
+		s32 userData = 0) = 0;
+
+	//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
+	/** \param vertexShaderProgram Text file containing the source of the
+	vertex shader program. Set to 0 if no shader shall be created.
+	\param pixelShaderProgram Text file containing the source of the pixel
+	shader program. Set to 0 if no shader shall be created.
+	\param callback Pointer to an IShaderConstantSetCallback object to
+	which the OnSetConstants function is called.
+	\param baseMaterial baseMaterial
+	\param userData a user data int. This int can be set to any value and
+	will be set as parameter in the callback method when calling
+	OnSetConstants(). In this way it is easily possible to use the same
+	callback method for multiple materials and distinguish between them
+	during the call.
+	\return Returns the number of the material type which can be set in
+	SMaterial::MaterialType to use the renderer. -1 is returned if an
+	error occurred. -1 is returned for example if a vertex or pixel shader
+	program could not be compiled, the error strings are then printed out
+	into the error log, and can be caught with a custom event receiver. */
+	virtual s32 addShaderMaterialFromFiles(io::IReadFile* vertexShaderProgram,
+		io::IReadFile* pixelShaderProgram,
+		IShaderConstantSetCallBack* callback = 0,
+		E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
+		s32 userData = 0) = 0;
+
+	//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
+	/** \param vertexShaderProgramFileName Text file name containing the
+	source of the vertex shader program. Set to 0 if no shader shall be
+	created.
+	\param pixelShaderProgramFileName Text file name containing the source
+	of the pixel shader program. Set to 0 if no shader shall be created.
+	\param callback Pointer to an IShaderConstantSetCallback object on
+	which the OnSetConstants function is called.
+	\param baseMaterial baseMaterial
+	\param userData a user data int. This int can be set to any value and
+	will be set as parameter in the callback method when calling
+	OnSetConstants(). In this way it is easily possible to use the same
+	callback method for multiple materials and distinguish between them
+	during the call.
+	\return Returns the number of the material type which can be set in
+	SMaterial::MaterialType to use the renderer. -1 is returned if an
+	error occurred. -1 is returned for example if a vertex or pixel shader
+	program could not be compiled, the error strings are then printed out
+	into the error log, and can be caught with a custom event receiver. */
+	virtual s32 addShaderMaterialFromFiles(const io::path& vertexShaderProgramFileName,
+		const io::path& pixelShaderProgramFileName,
+		IShaderConstantSetCallBack* callback = 0,
+		E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
+		s32 userData = 0) = 0;
 };
 
 

include/IGUIComboBox.h

@@ -52,10 +52,6 @@ namespace gui
 		//! Sets the selected item. Set this to -1 if no item should be selected
 		virtual void setSelected(s32 idx) = 0;
 
-		//! Sets the selected item and emits a change event.
-		/** Set this to -1 if no item should be selected */
-		virtual void setAndSendSelected(s32 idx) = 0;
-
 		//! Sets text justification of the text area
 		/** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
 		EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.

include/IImage.h

@@ -362,6 +362,28 @@ public:
 			return 24;
 		case ECF_A8R8G8B8:
 			return 32;
+		case ECF_DXT1:
+			return 16;
+		case ECF_DXT2:
+		case ECF_DXT3:
+		case ECF_DXT4:
+		case ECF_DXT5:
+			return 32;
+		case ECF_PVRTC_RGB2:
+			return 12;
+		case ECF_PVRTC_ARGB2:
+		case ECF_PVRTC2_ARGB2:
+			return 16;
+		case ECF_PVRTC_RGB4:
+			return 24;
+		case ECF_PVRTC_ARGB4:
+		case ECF_PVRTC2_ARGB4:
+			return 32;
+		case ECF_ETC1:
+		case ECF_ETC2_RGB:
+			return 24;
+		case ECF_ETC2_ARGB:
+			return 32;
 		case ECF_D16:
 			return 16;
 		case ECF_D32:
@@ -396,18 +418,75 @@ public:
 	//! calculate image data size in bytes for selected format, width and height.
 	static u32 getDataSizeFromFormat(ECOLOR_FORMAT format, u32 width, u32 height)
 	{
-		// non-compressed formats
-		u32 imageSize = getBitsPerPixelFromFormat(format) / 8 * width;
+		u32 imageSize = 0;
+
+		switch (format)
+		{
+		case ECF_DXT1:
+			imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 8;
+			break;
+		case ECF_DXT2:
+		case ECF_DXT3:
+		case ECF_DXT4:
+		case ECF_DXT5:
+			imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 16;
+			break;
+		case ECF_PVRTC_RGB2:
+		case ECF_PVRTC_ARGB2:
+			imageSize = (core::max_<u32>(width, 16) * core::max_<u32>(height, 8) * 2 + 7) / 8;
+			break;
+		case ECF_PVRTC_RGB4:
+		case ECF_PVRTC_ARGB4:
+			imageSize = (core::max_<u32>(width, 8) * core::max_<u32>(height, 8) * 4 + 7) / 8;
+			break;
+		case ECF_PVRTC2_ARGB2:
+			imageSize = core::ceil32(width / 8.0f) * core::ceil32(height / 4.0f) * 8;
+			break;
+		case ECF_PVRTC2_ARGB4:
+		case ECF_ETC1:
+		case ECF_ETC2_RGB:
+			imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 8;
+			break;
+		case ECF_ETC2_ARGB:
+			imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 16;
+			break;
+		default: // uncompressed formats
+			imageSize = getBitsPerPixelFromFormat(format) / 8 * width;
 			imageSize *= height;
+			break;
+		}
 
 		return imageSize;
 	}
 
+// Define to check for all compressed image formats cases in a switch
+#define IRR_CASE_IIMAGE_COMPRESSED_FORMAT\
+	case ECF_DXT1:\
+	case ECF_DXT2:\
+	case ECF_DXT3:\
+	case ECF_DXT4:\
+	case ECF_DXT5:\
+	case ECF_PVRTC_RGB2:\
+	case ECF_PVRTC_ARGB2:\
+	case ECF_PVRTC2_ARGB2:\
+	case ECF_PVRTC_RGB4:\
+	case ECF_PVRTC_ARGB4:\
+	case ECF_PVRTC2_ARGB4:\
+	case ECF_ETC1:\
+	case ECF_ETC2_RGB:\
+	case ECF_ETC2_ARGB:
+
 	//! check if this is compressed color format
 	static bool isCompressedFormat(const ECOLOR_FORMAT format)
 	{
+		switch(format)
+		{
+			IRR_CASE_IIMAGE_COMPRESSED_FORMAT
+				return true;
+			default:
 				return false;
 		}
+	}
 
 	//! check if the color format is only viable for depth/stencil textures
 	static bool isDepthFormat(const ECOLOR_FORMAT format)
@@ -444,6 +523,22 @@ public:
 		return false;
 	}
 
+#if defined(PATCH_SUPERTUX_8_0_1_with_1_9_0)
+	static bool isRenderTargetOnlyFormat(const ECOLOR_FORMAT format)
+	{
+		switch (format)
+		{
+		case ECF_A1R5G5B5:
+		case ECF_R5G6B5:
+		case ECF_R8G8B8:
+		case ECF_A8R8G8B8:
+			return false;
+		default:
+			return true;
+		}
+	}
+#endif
+
 protected:
 	ECOLOR_FORMAT Format;
 	core::dimension2d<u32> Size;

include/ILogger.h

@@ -19,7 +19,7 @@ enum ELOG_LEVEL
 	//! Used for printing information helpful in debugging
 	ELL_DEBUG,
 
-	//! Useful information to print. For example hardware info or something started/stopped.
+	//! Useful information to print. For example hardware infos or something started/stopped.
 	ELL_INFORMATION,
 
 	//! Warnings that something isn't as expected and can cause oddities
@@ -73,6 +73,27 @@ public:
 	filtered with these levels. If you want to be a text displayed,
 	independent on what level filter is set, use ELL_NONE. */
 	virtual void log(const c8* text, const c8* hint, ELOG_LEVEL ll=ELL_INFORMATION) = 0;
+	virtual void log(const c8* text, const wchar_t* hint, ELOG_LEVEL ll=ELL_INFORMATION) = 0;
+
+	//! Prints out a text into the log
+	/** \param text: Text to print out.
+	\param hint: Additional info. This string is added after a " :" to the
+	string.
+	\param ll: Log level of the text. If the text is an error, set
+	it to ELL_ERROR, if it is warning set it to ELL_WARNING, and if it
+	is just an informational text, set it to ELL_INFORMATION. Texts are
+	filtered with these levels. If you want to be a text displayed,
+	independent on what level filter is set, use ELL_NONE. */
+	virtual void log(const wchar_t* text, const wchar_t* hint, ELOG_LEVEL ll=ELL_INFORMATION) = 0;
+
+	//! Prints out a text into the log
+	/** \param text: Text to print out.
+	\param ll: Log level of the text. If the text is an error, set
+	it to ELL_ERROR, if it is warning set it to ELL_WARNING, and if it
+	is just an informational text, set it to ELL_INFORMATION. Texts are
+	filtered with these levels. If you want to be a text displayed,
+	independent on what level filter is set, use ELL_NONE. */
+	virtual void log(const wchar_t* text, ELOG_LEVEL ll=ELL_INFORMATION) = 0;
 };
 
 } // end namespace

include/IMaterialRendererServices.h

@@ -38,11 +38,30 @@ public:
 		const SMaterial& lastMaterial,
 		bool resetAllRenderstates) = 0;
 
-	//! Return an index constant for the vertex shader based on a uniform variable name.
+	//! Return an index constant for the vertex shader based on a name.
 	virtual s32 getVertexShaderConstantID(const c8* name) = 0;
 
-	//! Sets a value for a vertex shader uniform variable.
-	/** \param index Index of the variable (as received from getVertexShaderConstantID)
+	//! Sets a constant for the vertex shader based on a name.
+	/** This can be used if you used a high level shader language like GLSL
+	or HLSL to create a shader. Example: If you created a shader which has
+	variables named 'mWorldViewProj' (containing the WorldViewProjection
+	matrix) and another one named 'fTime' containing one float, you can set
+	them in your IShaderConstantSetCallBack derived class like this:
+	\code
+	virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
+	{
+		video::IVideoDriver* driver = services->getVideoDriver();
+
+		f32 time = (f32)os::Timer::getTime()/100000.0f;
+		services->setVertexShaderConstant("fTime", &time, 1);
+
+		core::matrix4 worldViewProj(driver->getTransform(video::ETS_PROJECTION));
+		worldViewProj *= driver->getTransform(video::ETS_VIEW);
+		worldViewProj *= driver->getTransform(video::ETS_WORLD);
+		services->setVertexShaderConstant("mWorldViewProj", worldViewProj.M, 16);
+	}
+	\endcode
+	\param index Index of the variable
 	\param floats Pointer to array of floats
 	\param count Amount of floats in array.
 	\return True if successful.
@@ -53,16 +72,27 @@ public:
 	virtual bool setVertexShaderConstant(s32 index, const s32* ints, int count) = 0;
 
 	//! Uint interface for the above.
+	/* NOTE: UINT only works with GLSL, not supported for other shaders.
+	         Also GLES drivers in Irrlicht do not support it as this needs at least GLES 3.0.
+	*/
 	virtual bool setVertexShaderConstant(s32 index, const u32* ints, int count) = 0;
 
-	//! Return an index constant for the pixel shader for the given uniform variable name
+	//! Sets a vertex shader constant.
+	/** Can be used if you created a shader using pixel/vertex shader
+	assembler or ARB_fragment_program or ARB_vertex_program.
+	\param data: Data to be set in the constants
+	\param startRegister: First register to be set
+	\param constantAmount: Amount of registers to be set. One register consists of 4 floats. */
+	virtual void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) = 0;
+
+	//! Return an index constant for the pixel shader based on a name.
 	virtual s32 getPixelShaderConstantID(const c8* name) = 0;
 
-	//! Sets a value for the given pixel shader uniform variable
+	//! Sets a constant for the pixel shader based on a name.
 	/** This can be used if you used a high level shader language like GLSL
 	or HLSL to create a shader. See setVertexShaderConstant() for an
 	example on how to use this.
-	\param index Index of the variable (as received from getPixelShaderConstantID)
+	\param index Index of the variable
 	\param floats Pointer to array of floats
 	\param count Amount of floats in array.
 	\return True if successful. */
@@ -72,8 +102,19 @@ public:
 	virtual bool setPixelShaderConstant(s32 index, const s32* ints, int count) = 0;
 
 	//! Uint interface for the above.
+	/* NOTE: UINT only works with GLSL, not supported for other shaders.
+	         Also GLES drivers in Irrlicht do not support it as this needs at least GLES 3.0.
+	*/
 	virtual bool setPixelShaderConstant(s32 index, const u32* ints, int count) = 0;
 
+	//! Sets a pixel shader constant.
+	/** Can be used if you created a shader using pixel/vertex shader
+	assembler or ARB_fragment_program or ARB_vertex_program.
+	\param data Data to be set in the constants
+	\param startRegister First register to be set.
+	\param constantAmount Amount of registers to be set. One register consists of 4 floats. */
+	virtual void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) = 0;
+
 	//! Get pointer to the IVideoDriver interface
 	/** \return Pointer to the IVideoDriver interface */
 	virtual IVideoDriver* getVideoDriver() = 0;

include/IMeshBuffer.h

@@ -120,6 +120,11 @@ namespace scene
 		\param numIndices Number of indices in array. */
 		virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) = 0;
 
+		//! Append the meshbuffer to the current buffer
+		/** Only works for compatible vertex types
+		\param other Buffer to append to this one. */
+		virtual void append(const IMeshBuffer* const other) = 0;
+
 		//! get the current hardware mapping hint
 		virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const = 0;
 

include/IMeshWriter.h

@@ -2,7 +2,9 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_I_MESH_WRITER_H_INCLUDED__
+#define __IRR_I_MESH_WRITER_H_INCLUDED__
+
 #include "IReferenceCounted.h"
 #include "EMeshWriterEnums.h"
 
@@ -52,4 +54,5 @@ namespace scene
 } // end namespace
 } // end namespace
 
+#endif
 

include/IOSOperator.h

@@ -11,11 +11,11 @@
 namespace irr
 {
 
-//! The OSOperator provides OS-specific methods and information.
+//! The Operating system operator provides operation system specific methods and information.
 class IOSOperator : public virtual IReferenceCounted
 {
 public:
-	//! Get the current OS version as string.
+	//! Get the current operation system version as string.
 	virtual const core::stringc& getOperatingSystemVersion() const = 0;
 
 	//! Copies text to the clipboard

include/ISceneManager.h

@@ -130,7 +130,7 @@ namespace scene
 	{
 	public:
 
-		//! Get pointer to an animatable mesh. Loads the file if not loaded already.
+		//! Get pointer to an animateable mesh. Loads the file if not loaded already.
 		/**
 		 * If you want to remove a loaded mesh from the cache again, use removeMesh().
 		 *  Currently there are the following mesh formats supported:
@@ -509,7 +509,7 @@ namespace scene
 
 		//! Clear all nodes which are currently registered for rendering
 		/** Usually you don't have to care about this as drawAll will clear nodes
-		after rendering them. But sometimes you might have to manually reset this.
+		after rendering them. But sometimes you might have to manully reset this.
 		For example when you deleted nodes between registering and rendering. */
 		virtual void clearAllRegisteredNodesForRendering() = 0;
 

include/ISceneNode.h

@@ -14,9 +14,7 @@
 #include "aabbox3d.h"
 #include "matrix4.h"
 #include "IAttributes.h"
-
 #include <list>
-#include <optional>
 
 namespace irr
 {
@@ -67,7 +65,7 @@ namespace scene
 
 		//! This method is called just before the rendering process of the whole scene.
 		/** Nodes may register themselves in the render pipeline during this call,
-		precalculate the geometry which should be rendered, and prevent their
+		precalculate the geometry which should be renderered, and prevent their
 		children from being able to register themselves if they are clipped by simply
 		not calling their OnRegisterSceneNode method.
 		If you are implementing your own scene node, you should overwrite this method
@@ -118,14 +116,23 @@ namespace scene
 
 		//! Returns the name of the node.
 		/** \return Name as character string. */
-		virtual const std::optional<std::string> &getName() const
+		virtual const c8* getName() const
 		{
-			return Name;
+			return Name.c_str();
 		}
 
+
 		//! Sets the name of the node.
 		/** \param name New name of the scene node. */
-		virtual void setName(const std::optional<std::string> &name)
+		virtual void setName(const c8* name)
+		{
+			Name = name;
+		}
+
+
+		//! Sets the name of the node.
+		/** \param name New name of the scene node. */
+		virtual void setName(const core::stringc& name)
 		{
 			Name = name;
 		}
@@ -268,33 +275,33 @@ namespace scene
 
 				child->grab();
 				child->remove(); // remove from old parent
-				// Note: This iterator is not invalidated until we erase it.
-				child->ThisIterator = Children.insert(Children.end(), child);
+				Children.push_back(child);
 				child->Parent = this;
 			}
 		}
 
 
 		//! Removes a child from this scene node.
-		/**
+		/** If found in the children list, the child pointer is also
+		dropped and might be deleted if no other grab exists.
 		\param child A pointer to the child which shall be removed.
 		\return True if the child was removed, and false if not,
-		e.g. because it belongs to a different parent or no parent. */
+		e.g. because it couldn't be found in the children list. */
 		virtual bool removeChild(ISceneNode* child)
 		{
-			if (child->Parent != this)
-				return false;
-
-			// The iterator must be set since the parent is not null.
-			_IRR_DEBUG_BREAK_IF(!child->ThisIterator.has_value());
-			auto it = *child->ThisIterator;
-			child->ThisIterator = std::nullopt;
-			child->Parent = nullptr;
-			child->drop();
+			ISceneNodeList::iterator it = Children.begin();
+			for (; it != Children.end(); ++it)
+				if ((*it) == child)
+				{
+					(*it)->Parent = 0;
+					(*it)->drop();
 					Children.erase(it);
 					return true;
 				}
 
+			return false;
+		}
+
 
 		//! Removes all children of this scene node
 		/** The scene nodes found in the children list are also dropped
@@ -302,11 +309,13 @@ namespace scene
 		*/
 		virtual void removeAll()
 		{
-			for (auto &child : Children) {
-				child->Parent = nullptr;
-				child->ThisIterator = std::nullopt;
-				child->drop();
+			ISceneNodeList::iterator it = Children.begin();
+			for (; it != Children.end(); ++it)
+			{
+				(*it)->Parent = 0;
+				(*it)->drop();
 			}
+
 			Children.clear();
 		}
 
@@ -499,8 +508,10 @@ namespace scene
 			grab();
 			remove();
 
-			if (newParent)
-				newParent->addChild(this);
+			Parent = newParent;
+
+			if (Parent)
+				Parent->addChild(this);
 
 			drop();
 		}
@@ -593,7 +604,7 @@ namespace scene
 		}
 
 		//! Name of the scene node.
-		std::optional<std::string> Name;
+		core::stringc Name;
 
 		//! Absolute transformation of the node.
 		core::matrix4 AbsoluteTransformation;
@@ -607,15 +618,12 @@ namespace scene
 		//! Relative scale of the scene node.
 		core::vector3df RelativeScale;
 
-		//! List of all children of this node
-		std::list<ISceneNode*> Children;
-
-		//! Iterator pointing to this node in the parent's child list.
-		std::optional<ISceneNodeList::iterator> ThisIterator;
-
 		//! Pointer to the parent
 		ISceneNode* Parent;
 
+		//! List of all children of this node
+		std::list<ISceneNode*> Children;
+
 		//! Pointer to the scene manager
 		ISceneManager* SceneManager;
 

include/ISkinnedMesh.h

@@ -10,8 +10,6 @@
 #include "IAnimatedMesh.h"
 #include "SSkinMeshBuffer.h"
 
-#include <optional>
-
 namespace irr
 {
 namespace scene
@@ -43,12 +41,12 @@ namespace scene
 		/** \param number: Zero based index of joint. The last joint
 		has the number getJointCount()-1;
 		\return Name of joint and null if an error happened. */
-		virtual const std::optional<std::string> &getJointName(u32 number) const = 0;
+		virtual const c8* getJointName(u32 number) const = 0;
 
 		//! Gets a joint number from its name
 		/** \param name: Name of the joint.
-		\return Number of the joint or std::nullopt if not found. */
-		virtual std::optional<u32> getJointNumber(const std::string &name) const = 0;
+		\return Number of the joint or -1 if not found. */
+		virtual s32 getJointNumber(const c8* name) const = 0;
 
 		//! Use animation from another mesh
 		/** The animation is linked (not copied) based on joint names
@@ -138,7 +136,7 @@ namespace scene
 			}
 
 			//! The name of this joint
-			std::optional<std::string> Name;
+			core::stringc Name;
 
 			//! Local matrix of this joint
 			core::matrix4 LocalMatrix;

include/ITexture.h

@@ -292,6 +292,11 @@ public:
 		{
 		case ECF_A8R8G8B8:
 		case ECF_A1R5G5B5:
+		case ECF_DXT1:
+		case ECF_DXT2:
+		case ECF_DXT3:
+		case ECF_DXT4:
+		case ECF_DXT5:
 		case ECF_A16B16G16R16F:
 		case ECF_A32B32G32R32F:
 			status = true;

include/IVideoDriver.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_I_VIDEO_DRIVER_H_INCLUDED__
+#define __IRR_I_VIDEO_DRIVER_H_INCLUDED__
 
 #include "rect.h"
 #include "SColor.h"
@@ -869,7 +870,7 @@ namespace video
 		//! Gets name of this video driver.
 		/** \return Returns the name of the video driver, e.g. in case
 		of the Direct3D8 driver, it would return "Direct3D 8.1". */
-		virtual const char* getName() const =0;
+		virtual const wchar_t* getName() const =0;
 
 		//! Adds an external image loader to the engine.
 		/** This is useful if the Irrlicht Engine should be able to load
@@ -1046,7 +1047,7 @@ namespace video
 		E_MATERIAL_TYPE enum or a value which was returned by
 		addMaterialRenderer().
 		\return String with the name of the renderer, or 0 if not
-		existing */
+		exisiting */
 		virtual const c8* getMaterialRendererName(u32 idx) const =0;
 
 		//! Sets the name of a material renderer.
@@ -1210,3 +1211,4 @@ namespace video
 } // end namespace irr
 
 
+#endif

include/IrrCompileConfig.h

@@ -2,11 +2,12 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_COMPILE_CONFIG_H_INCLUDED__
+#define __IRR_COMPILE_CONFIG_H_INCLUDED__
 
 //! Identifies the IrrlichtMt fork customized for the Minetest engine
-#define IRRLICHT_VERSION_MT_REVISION 15
-#define IRRLICHT_VERSION_MT "mt15"
+#define IRRLICHT_VERSION_MT_REVISION 12
+#define IRRLICHT_VERSION_MT "mt12"
 
 //! Irrlicht SDK Version
 #define IRRLICHT_VERSION_MAJOR 1
@@ -28,3 +29,5 @@
 #ifndef IRRLICHT_API
 #define IRRLICHT_API
 #endif
+
+#endif // __IRR_COMPILE_CONFIG_H_INCLUDED__

include/IrrlichtDevice.h

@@ -76,17 +76,13 @@ namespace irr
 		virtual bool run() = 0;
 
 		//! Cause the device to temporarily pause execution and let other processes run.
-		/** This should bring down processor usage without major performance loss for Irrlicht.
-		But this is system dependent, so there's a chance your thread won't get control back quickly.
-		*/
+		/** This should bring down processor usage without major
+		performance loss for Irrlicht */
 		virtual void yield() = 0;
 
 		//! Pause execution and let other processes to run for a specified amount of time.
-		/** It may not wait the full given time, as sleep may be interrupted and also may wait longer on some OS.
-		\param timeMs: Time to sleep for in milliseconds. Note that the OS can round up this number.
-                       On Windows you usually get at least 15ms sleep time minium for any value > 0. 
-					   So if you call this in your main loop you can't get more than 65 FPS anymore in your game.
-					   On most Linux systems it's relatively exact, but also no guarantee.
+		/** It may not wait the full given time, as sleep may be interrupted
+		\param timeMs: Time to sleep for in milliseconds.
 		\param pauseTimer: If true, pauses the device timer while sleeping
 		*/
 		virtual void sleep(u32 timeMs, bool pauseTimer=false) = 0;
@@ -177,13 +173,6 @@ namespace irr
 		/** \return True if window is fullscreen. */
 		virtual bool isFullscreen() const = 0;
 
-		//! Checks if the window could possibly be visible.
-		//! Currently, this only returns false when the activity is stopped on
-		//! Android. Note that for Android activities, "stopped" means something
-		//! different than you might expect (and also something different than
-		//! "paused"). Read the Android lifecycle documentation.
-		virtual bool isWindowVisible() const { return true; };
-
 		//! Get the current color format of the window
 		/** \return Color format of the window. */
 		virtual video::ECOLOR_FORMAT getColorFormat() const = 0;

include/Keycodes.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_KEY_CODES_H_INCLUDED__
+#define __IRR_KEY_CODES_H_INCLUDED__
 
 namespace irr
 {
@@ -89,7 +90,7 @@ namespace irr
 		KEY_KEY_X            = 0x58,  // X key
 		KEY_KEY_Y            = 0x59,  // Y key
 		KEY_KEY_Z            = 0x5A,  // Z key
-		KEY_LWIN             = 0x5B,  // Left Windows key (Microsoft Natural keyboard)
+		KEY_LWIN             = 0x5B,  // Left Windows key (Microsoft<EFBFBD> Natural<EFBFBD> keyboard)
 		KEY_RWIN             = 0x5C,  // Right Windows key (Natural keyboard)
 		KEY_APPS             = 0x5D,  // Applications key (Natural keyboard)
 		KEY_SLEEP            = 0x5F,  // Computer Sleep key
@@ -184,4 +185,5 @@ namespace irr
 
 } // end namespace irr
 
+#endif
 

include/SColor.h

@@ -37,6 +37,50 @@ namespace video
 		//! Warning: This tends to be BGRA in memory (it's ARGB on file, but with usual big-endian memory it's flipped)
 		ECF_A8R8G8B8,
 
+		/** Compressed image formats. **/
+
+		//! DXT1 color format.
+		ECF_DXT1,
+
+		//! DXT2 color format.
+		ECF_DXT2,
+
+		//! DXT3 color format.
+		ECF_DXT3,
+
+		//! DXT4 color format.
+		ECF_DXT4,
+
+		//! DXT5 color format.
+		ECF_DXT5,
+
+		//! PVRTC RGB 2bpp.
+		ECF_PVRTC_RGB2,
+
+		//! PVRTC ARGB 2bpp.
+		ECF_PVRTC_ARGB2,
+
+		//! PVRTC RGB 4bpp.
+		ECF_PVRTC_RGB4,
+
+		//! PVRTC ARGB 4bpp.
+		ECF_PVRTC_ARGB4,
+
+		//! PVRTC2 ARGB 2bpp.
+		ECF_PVRTC2_ARGB2,
+
+		//! PVRTC2 ARGB 4bpp.
+		ECF_PVRTC2_ARGB4,
+
+		//! ETC1 RGB.
+		ECF_ETC1,
+
+		//! ETC2 RGB.
+		ECF_ETC2_RGB,
+
+		//! ETC2 ARGB.
+		ECF_ETC2_ARGB,
+
 		/** The following formats may only be used for render target textures. */
 
 		/** Floating point formats. */
@@ -95,6 +139,20 @@ namespace video
 		"R5G6B5",
 		"R8G8B8",
 		"A8R8G8B8",
+		"DXT1",
+		"DXT2",
+		"DXT3",
+		"DXT4",
+		"DXT5",
+		"PVRTC_RGB2",
+		"PVRTC_ARGB2",
+		"PVRTC_RGB4",
+		"PVRTC_ARGB4",
+		"PVRTC2_ARGB2",
+		"PVRTC2_ARGB4",
+		"ETC1",
+		"ETC2_RGB",
+		"ETC2_ARGB",
 		"R16F",
 		"G16R16F",
 		"A16B16G16R16F",

include/SMaterial.h

@@ -193,9 +193,16 @@ namespace video
 		EAAM_SIMPLE=1,
 		//! High-quality anti-aliasing, not always supported, automatically enables SIMPLE mode
 		EAAM_QUALITY=3,
+		//! Line smoothing
+		//! Careful, enabling this can lead to software emulation under OpenGL
+		EAAM_LINE_SMOOTH=4,
+		//! point smoothing, often in software and slow, only with OpenGL
+		EAAM_POINT_SMOOTH=8,
+		//! All typical anti-alias and smooth modes
+		EAAM_FULL_BASIC=15,
 		//! Enhanced anti-aliasing for transparent materials
 		/** Usually used with EMT_TRANSPARENT_ALPHA_CHANNEL_REF and multisampling. */
-		EAAM_ALPHA_TO_COVERAGE=4
+		EAAM_ALPHA_TO_COVERAGE=16
 	};
 
 	//! These flags allow to define the interpretation of vertex color when lighting is enabled

include/SSkinMeshBuffer.h

@@ -330,6 +330,9 @@ struct SSkinMeshBuffer : public IMeshBuffer
 	//! append the vertices and indices to the current buffer
 	void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) override {}
 
+	//! append the meshbuffer to the current buffer
+	void append(const IMeshBuffer* const other) override {}
+
 	//! get the current hardware mapping hint for vertex buffers
 	E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
 	{

include/aabbox3d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_AABBOX_3D_H_INCLUDED__
+#define __IRR_AABBOX_3D_H_INCLUDED__
 
 #include "irrMath.h"
 #include "plane3d.h"
@@ -363,3 +364,6 @@ class aabbox3d
 
 } // end namespace core
 } // end namespace irr
+
+#endif
+

include/coreutil.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_CORE_UTIL_H_INCLUDED__
+#define __IRR_CORE_UTIL_H_INCLUDED__
 
 #include "irrString.h"
 #include "path.h"
@@ -201,3 +202,4 @@ inline bool isupper(s32 c) { return c >= 'A' && c <= 'Z'; }
 } // end namespace core
 } // end namespace irr
 
+#endif

include/dimension2d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_DIMENSION2D_H_INCLUDED__
+#define __IRR_DIMENSION2D_H_INCLUDED__
 
 #include "irrTypes.h"
 #include "irrMath.h" // for irr::core::equals()
@@ -219,4 +220,5 @@ namespace core
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/irrArray.h

@@ -2,7 +2,9 @@
 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
 // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
 
-#pragma once
+#ifndef __IRR_ARRAY_H_INCLUDED__
+#define __IRR_ARRAY_H_INCLUDED__
+
 #include <algorithm>
 #include <iterator>
 #include <vector>
@@ -241,7 +243,7 @@ public:
 	/** \return Size of elements in the array which are actually occupied. */
 	u32 size() const
 	{
-		return static_cast<u32>(m_data.size());
+		return m_data.size();
 	}
 
 
@@ -317,7 +319,7 @@ public:
 		// *it = first element in [first, last) that is >= element, or last if not found.
 		if (*it < element || element < *it)
 			return -1;
-		return static_cast<u32>(it - m_data.begin());
+		return it - m_data.begin();
 	}
 
 
@@ -335,8 +337,8 @@ public:
 		auto iters = std::equal_range(m_data.begin(), m_data.end(), element);
 		if (iters.first == iters.second)
 			return -1;
-		last = static_cast<s32>((iters.second - m_data.begin()) - 1);
-		return static_cast<s32>(iters.first - m_data.begin());
+		last = (iters.second - m_data.begin()) - 1;
+		return iters.first - m_data.begin();
 	}
 
 
@@ -351,7 +353,7 @@ public:
 		auto it = std::find(m_data.begin(), m_data.end(), element);
 		if (it == m_data.end())
 			return -1;
-		return static_cast<u32>(it - m_data.begin());
+		return it - m_data.begin();
 	}
 
 
@@ -436,4 +438,5 @@ private:
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/irrMath.h

@@ -2,14 +2,14 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_MATH_H_INCLUDED__
+#define __IRR_MATH_H_INCLUDED__
 
 #include "irrTypes.h"
-#include <cmath>
+#include <math.h>
 #include <float.h>
-#include <cstdlib> // for abs() etc.
+#include <stdlib.h> // for abs() etc.
 #include <limits.h> // For INT_MAX / UINT_MAX
-#include <type_traits>
 
 namespace irr
 {
@@ -18,6 +18,9 @@ namespace core
 
 	//! Rounding error constant often used when comparing f32 values.
 
+	const s32 ROUNDING_ERROR_S32 = 0;
+
+	const s64 ROUNDING_ERROR_S64 = 0;
 	const f32 ROUNDING_ERROR_f32 = 0.000001f;
 	const f64 ROUNDING_ERROR_f64 = 0.00000001;
 
@@ -168,6 +171,30 @@ namespace core
 		return ROUNDING_ERROR_f64;
 	}
 
+	template <>
+	inline s32 roundingError()
+	{
+		return ROUNDING_ERROR_S32;
+	}
+
+	template <>
+	inline u32 roundingError()
+	{
+		return ROUNDING_ERROR_S32;
+	}
+
+	template <>
+	inline s64 roundingError()
+	{
+		return ROUNDING_ERROR_S64;
+	}
+
+	template <>
+	inline u64 roundingError()
+	{
+		return ROUNDING_ERROR_S64;
+	}
+
 	template <class T>
 	inline T relativeErrorFactor()
 	{
@@ -186,20 +213,14 @@ namespace core
 		return 8;
 	}
 
-	//! returns if a equals b, for types without rounding errors
-	template <class T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
-	inline bool equals(const T a, const T b)
-	{
-		return a == b;
-	}
-
 	//! returns if a equals b, taking possible rounding errors into account
-	template <class T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
+	template <class T>
 	inline bool equals(const T a, const T b, const T tolerance = roundingError<T>())
 	{
-		return std::abs(a - b) <= tolerance;
+		return (a + tolerance >= b) && (a - tolerance <= b);
 	}
 
+
 	//! returns if a equals b, taking relative error in form of factor
 	//! this particular function does not involve any division.
 	template <class T>
@@ -458,3 +479,4 @@ namespace core
 using irr::core::IR;
 using irr::core::FR;
 
+#endif

include/irrString.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
 // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
 
-#pragma once
+#ifndef __IRR_STRING_H_INCLUDED__
+#define __IRR_STRING_H_INCLUDED__
 
 #include "irrTypes.h"
 #include <string>
@@ -10,8 +11,6 @@
 #include <cstdio>
 #include <cstring>
 #include <cwchar>
-#include <codecvt>
-#include <locale>
 
 namespace irr
 {
@@ -36,13 +35,8 @@ outside the string class for explicit use.
 // forward declarations
 template <typename T>
 class string;
-
-//! Typedef for character strings
-typedef string<c8> stringc;
-
-//! Typedef for wide character strings
-typedef string<wchar_t> stringw;
-
+static size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize);
+static size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize);
 
 //! Returns a character converted to lower case
 static inline u32 locale_lower ( u32 x )
@@ -266,7 +260,7 @@ public:
 	the trailing NUL. */
 	u32 size() const
 	{
-		return static_cast<u32>(str.size());
+		return str.size();
 	}
 
 	//! Informs if the string is empty or not.
@@ -834,7 +828,7 @@ public:
 		if (!delimiter)
 			return 0;
 
-		const u32 oldSize=static_cast<u32>(ret.size());
+		const u32 oldSize=ret.size();
 
 		u32 tokenStartIdx = 0;
 		for (u32 i=0; i<size()+1; ++i)
@@ -862,14 +856,11 @@ public:
 		else if (!ignoreEmptyTokens)
 			ret.push_back(string<T>());
 
-		return static_cast<u32>(ret.size()-oldSize);
+		return ret.size()-oldSize;
 	}
 
-	// This function should not be used and is only kept for "CGUIFileOpenDialog::pathToStringW".
-	friend size_t multibyteToWString(stringw& destination, const stringc &source);
-
-	friend size_t utf8ToWString(stringw &destination, const char *source);
-	friend size_t wStringToUTF8(stringc &destination, const wchar_t *source);
+	friend size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize);
+	friend size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize);
 
 private:
 
@@ -888,10 +879,10 @@ private:
 		return len;
 	}
 	static inline u32 calclen(const char* p) {
-		return static_cast<u32>(strlen(p));
+		return strlen(p);
 	}
 	static inline u32 calclen(const wchar_t* p) {
-		return static_cast<u32>(wcslen(p));
+		return wcslen(p);
 	}
 
 	//! strcmp wrapper
@@ -922,18 +913,38 @@ private:
 };
 
 
+//! Typedef for character strings
+typedef string<c8> stringc;
+
+//! Typedef for wide character strings
+typedef string<wchar_t> stringw;
+
 //! Convert multibyte string to wide-character string
 /** Wrapper around mbstowcs from standard library, but directly using Irrlicht string class.
 What the function does exactly depends on the LC_CTYPE of the current c locale.
 \param destination Wide-character string receiving the converted source
 \param source multibyte string
-\return The number of wide characters written to destination, not including the eventual terminating null character or -1 when conversion failed
-
-This function should not be used and is only kept for "CGUIFileOpenDialog::pathToStringW". */
-inline size_t multibyteToWString(stringw& destination, const core::stringc& source)
+\return The number of wide characters written to destination, not including the eventual terminating null character or -1 when conversion failed */
+static inline size_t multibyteToWString(string<wchar_t>& destination, const core::string<c8>& source)
 {
-	u32 sourceSize = source.size();
+	return multibyteToWString(destination, source.c_str(), (u32)source.size());
+}
 
+//! Convert multibyte string to wide-character string
+/** Wrapper around mbstowcs from standard library, but directly writing to Irrlicht string class.
+What the function does exactly depends on the LC_CTYPE of the current c locale.
+\param destination Wide-character string receiving the converted source
+\param source multibyte string
+\return The number of wide characters written to destination, not including the eventual terminating null character  or -1 when conversion failed. */
+static inline size_t multibyteToWString(string<wchar_t>& destination, const char* source)
+{
+	const u32 s = source ? (u32)strlen(source) : 0;
+	return multibyteToWString(destination, source, s);
+}
+
+//! Internally used by the other multibyteToWString functions
+static size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize)
+{
 	if ( sourceSize )
 	{
 		destination.str.resize(sourceSize+1);
@@ -941,7 +952,53 @@ inline size_t multibyteToWString(stringw& destination, const core::stringc& sour
 #pragma warning(push)
 #pragma warning(disable: 4996)	// 'mbstowcs': This function or variable may be unsafe. Consider using mbstowcs_s instead.
 #endif
-		const size_t written = mbstowcs(&destination[0], source.c_str(), (size_t)sourceSize);
+		const size_t written = mbstowcs(&destination[0], source, (size_t)sourceSize);
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+		if ( written != (size_t)-1 )
+		{
+			destination.str.resize(written);
+		}
+		else
+		{
+			// Likely character which got converted until the invalid character was encountered are in destination now.
+			// And it seems even 0-terminated, but I found no documentation anywhere that this (the 0-termination) is guaranteed :-(
+			destination.clear();
+		}
+		return written;
+	}
+	else
+	{
+		destination.clear();
+		return 0;
+	}
+}
+
+//! Same as multibyteToWString, but the other way around
+static inline size_t wStringToMultibyte(string<c8>& destination, const core::string<wchar_t>& source)
+{
+	return wStringToMultibyte(destination, source.c_str(), (u32)source.size());
+}
+
+//! Same as multibyteToWString, but the other way around
+static inline size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source)
+{
+	const u32 s = source ? (u32)wcslen(source) : 0;
+	return wStringToMultibyte(destination, source, s);
+}
+
+//! Same as multibyteToWString, but the other way around
+static size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize)
+{
+	if ( sourceSize )
+	{
+		destination.str.resize(sizeof(wchar_t)*sourceSize+1);
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4996)	// 'wcstombs': This function or variable may be unsafe. Consider using wcstombs_s instead.
+#endif
+		const size_t written = wcstombs(&destination[0], source, destination.size());
 #if defined(_MSC_VER)
 #pragma warning(pop)
 #endif
@@ -965,32 +1022,8 @@ inline size_t multibyteToWString(stringw& destination, const core::stringc& sour
 }
 
 
-inline size_t utf8ToWString(stringw &destination, const char *source)
-{
-	std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
-	destination = conv.from_bytes(source);
-	return destination.size();
-}
-
-inline size_t utf8ToWString(stringw &destination, const stringc &source)
-{
-	return utf8ToWString(destination, source.c_str());
-}
-
-inline size_t wStringToUTF8(stringc &destination, const wchar_t *source)
-{
-	std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
-	destination = conv.to_bytes(source);
-	return destination.size();
-}
-
-inline size_t wStringToUTF8(stringc &destination, const stringw &source)
-{
-	return wStringToUTF8(destination, source.c_str());
-}
-
-
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/irrTypes.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_TYPES_H_INCLUDED__
+#define __IRR_TYPES_H_INCLUDED__
 
 #include <stdint.h>
 
@@ -119,3 +120,4 @@ code like 'code', but some generate warnings so we use this macro here */
 		((irr::u32)(irr::u8)(c0) | ((irr::u32)(irr::u8)(c1) << 8) | \
 		((irr::u32)(irr::u8)(c2) << 16) | ((irr::u32)(irr::u8)(c3) << 24 ))
 
+#endif // __IRR_TYPES_H_INCLUDED__

include/irrlicht.h

@@ -30,8 +30,10 @@
 #define __IRRLICHT_H_INCLUDED__
 
 #include "aabbox3d.h"
+#include "CIndexBuffer.h"
 #include "CMeshBuffer.h"
 #include "coreutil.h"
+#include "CVertexBuffer.h"
 #include "dimension2d.h"
 #include "ECullingTypes.h"
 #include "EDebugSceneTypes.h"

include/line2d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_LINE_2D_H_INCLUDED__
+#define __IRR_LINE_2D_H_INCLUDED__
 
 #include "irrTypes.h"
 #include "vector2d.h"
@@ -65,7 +66,7 @@ class line2d
 		vector2d<T> getVector() const { return vector2d<T>( end.X - start.X, end.Y - start.Y); }
 
 		/*! Check if this segment intersects another segment,
-			or if segments are coincident (colinear). */
+			or if segments are coincindent (colinear). */
 		bool intersectAsSegments( const line2d<T>& other) const
 		{
 			// Taken from:
@@ -82,7 +83,7 @@ class line2d
 			if (o1 != o2 && o3 != o4)
 				return true;
 
-			// Special Cases to check if segments are colinear
+			// Special Cases to check if segments are coolinear
 			if (o1 == 0 && other.start.isBetweenPoints( start, end)) return true;
 			if (o2 == 0 && other.end.isBetweenPoints( start, end)) return true;
 			if (o3 == 0 && start.isBetweenPoints( other.start, other.end)) return true;
@@ -354,4 +355,5 @@ class line2d
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/line3d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_LINE_3D_H_INCLUDED__
+#define __IRR_LINE_3D_H_INCLUDED__
 
 #include "irrTypes.h"
 #include "vector3d.h"
@@ -139,4 +140,5 @@ class line3d
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/matrix4.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_MATRIX_H_INCLUDED__
+#define __IRR_MATRIX_H_INCLUDED__
 
 #include "irrMath.h"
 #include "vector3d.h"
@@ -2056,7 +2057,7 @@ namespace core
 		core::vector3df v(vs);
 		v.normalize();
 
-		// cosine angle
+		// cosinus angle
 		T ca = f.dotProduct(t);
 
 		core::vector3df vt(v * (1 - ca));
@@ -2117,7 +2118,7 @@ namespace core
 		// axis multiplication by sin
 		const core::vector3df vs = look.crossProduct(from);
 
-		// cosine angle
+		// cosinus angle
 		const f32 ca = from.dotProduct(look);
 
 		core::vector3df vt(up * (1.f - ca));
@@ -2362,4 +2363,5 @@ namespace core
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/mt_opengl.h

@@ -11,7 +11,7 @@
 #include <KHR/khrplatform.h>
 
 #ifndef APIENTRY
-	#define APIENTRY KHRONOS_APIENTRY
+	#define APIENTRY
 #endif
 #ifndef APIENTRYP
 	#define APIENTRYP APIENTRY *
@@ -705,6 +705,7 @@ private:
 	typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC_MT) (GLenum mode, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
 	typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC_MT) (GLenum mode, GLenum type, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
 	typedef void (APIENTRYP PFNGLPOLYGONOFFSETCLAMPPROC_MT) (GLfloat factor, GLfloat units, GLfloat clamp);
+	typedef void (APIENTRYP PFNGLGENPERFMONITORSEXPROC_MT) (GLsizei n, GLuint * monitors);
 	typedef void (APIENTRYP PFNGLPRIMITIVEBOUNDINGBOXPROC_MT) (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
 	typedef GLuint64 (APIENTRYP PFNGLGETTEXTUREHANDLEPROC_MT) (GLuint texture);
 	typedef GLuint64 (APIENTRYP PFNGLGETTEXTURESAMPLERHANDLEPROC_MT) (GLuint texture, GLuint sampler);
@@ -780,9 +781,9 @@ public:
 	// Call this once after creating the context.
 	void LoadAllProcedures(irr::video::IContextManager *cmgr);
 	// Check if an extension is supported.
-	inline bool IsExtensionPresent(const std::string &ext) const
+	inline bool IsExtensionPresent(const std::string &ext)
 	{
-		return extensions.count(ext) > 0;
+		return extensions.find(ext) != extensions.end();
 	}
 
 	PFNGLCULLFACEPROC_MT CullFace = NULL;
@@ -1435,6 +1436,7 @@ public:
 	PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC_MT MultiDrawArraysIndirectCount = NULL;
 	PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC_MT MultiDrawElementsIndirectCount = NULL;
 	PFNGLPOLYGONOFFSETCLAMPPROC_MT PolygonOffsetClamp = NULL;
+	PFNGLGENPERFMONITORSEXPROC_MT GenPerfMonitorsEX = NULL;
 	PFNGLPRIMITIVEBOUNDINGBOXPROC_MT PrimitiveBoundingBox = NULL;
 	PFNGLGETTEXTUREHANDLEPROC_MT GetTextureHandle = NULL;
 	PFNGLGETTEXTURESAMPLERHANDLEPROC_MT GetTextureSamplerHandle = NULL;
@@ -3018,16 +3020,6 @@ public:
 	static constexpr const GLenum TEXTURE_SRGB_DECODE = 0x8A48;
 	static constexpr const GLenum DECODE = 0x8A49;
 	static constexpr const GLenum SKIP_DECODE = 0x8A4A;
-	static constexpr const GLenum ALPHA8 = 0x803C;
-	static constexpr const GLenum LUMINANCE8 = 0x8040;
-	static constexpr const GLenum LUMINANCE8_ALPHA8 = 0x8045;
-	static constexpr const GLenum ALPHA32F = 0x8816;
-	static constexpr const GLenum LUMINANCE32F = 0x8818;
-	static constexpr const GLenum LUMINANCE_ALPHA32F = 0x8819;
-	static constexpr const GLenum ALPHA16F = 0x881C;
-	static constexpr const GLenum LUMINANCE16F = 0x881E;
-	static constexpr const GLenum LUMINANCE_ALPHA16F = 0x881F;
-	static constexpr const GLenum BGRA8 = 0x93A1;
 	static constexpr const GLenum INCLUSIVE = 0x8F10;
 	static constexpr const GLenum EXCLUSIVE = 0x8F11;
 	static constexpr const GLenum WINDOW_RECTANGLE = 0x8F12;
@@ -3052,7 +3044,10 @@ public:
 	static constexpr const GLenum GEOMETRY_LINKED_VERTICES_OUT = 0x8916;
 	static constexpr const GLenum GEOMETRY_LINKED_INPUT_TYPE = 0x8917;
 	static constexpr const GLenum GEOMETRY_LINKED_OUTPUT_TYPE = 0x8918;
+	static constexpr const GLenum ALPHA8 = 0x803C;
 	static constexpr const GLenum LUMINANCE4_ALPHA4 = 0x8043;
+	static constexpr const GLenum LUMINANCE8_ALPHA8 = 0x8045;
+	static constexpr const GLenum LUMINANCE8 = 0x8040;
 	static constexpr const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = 0x8CD4;
 	static constexpr const GLenum COMPRESSED_RGBA_ASTC_3x3x3 = 0x93C0;
 	static constexpr const GLenum COMPRESSED_RGBA_ASTC_4x3x3 = 0x93C1;
@@ -3075,6 +3070,7 @@ public:
 	static constexpr const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5 = 0x93E8;
 	static constexpr const GLenum COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6 = 0x93E9;
 	static constexpr const GLenum INT_10_10_10_2 = 0x8DF7;
+	static constexpr const GLenum BGRA8 = 0x93A1;
 	static constexpr const GLenum MALI_PROGRAM_BINARY_ARM = 0x8F61;
 	static constexpr const GLenum MALI_SHADER_BINARY_ARM = 0x8F60;
 	static constexpr const GLenum FETCH_PER_SAMPLE_ARM = 0x8F65;
@@ -3084,37 +3080,8 @@ public:
 	static constexpr const GLenum SMAPHS_PROGRAM_BINARY_DMP = 0x9252;
 	static constexpr const GLenum DMP_PROGRAM_BINARY_DMP = 0x9253;
 	static constexpr const GLenum SHADER_BINARY_DMP = 0x9250;
-	static constexpr const GLenum SURFACE_COMPRESSION = 0x96C0;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_NONE = 0x96C1;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_DEFAULT = 0x96C2;
 	static constexpr const GLenum SAMPLER_EXTERNAL_2D_Y2Y = 0x8BE7;
 	static constexpr const GLenum GPU_DISJOINT = 0x8FBB;
-	static constexpr const GLenum SHADING_RATE_1X1_PIXELS = 0x96A6;
-	static constexpr const GLenum SHADING_RATE_1X2_PIXELS = 0x96A7;
-	static constexpr const GLenum SHADING_RATE_2X1_PIXELS = 0x96A8;
-	static constexpr const GLenum SHADING_RATE_2X2_PIXELS = 0x96A9;
-	static constexpr const GLenum SHADING_RATE_1X4_PIXELS = 0x96AA;
-	static constexpr const GLenum SHADING_RATE_4X1_PIXELS = 0x96AB;
-	static constexpr const GLenum SHADING_RATE_4X2_PIXELS = 0x96AC;
-	static constexpr const GLenum SHADING_RATE_2X4_PIXELS = 0x96AD;
-	static constexpr const GLenum SHADING_RATE_4X4_PIXELS = 0x96AE;
-	static constexpr const GLenum SHADING_RATE = 0x96D0;
-	static constexpr const GLenum SHADING_RATE_ATTACHMENT = 0x96D1;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP = 0x96D2;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE = 0x96D3;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_COMBINER_OP_MIN = 0x96D4;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_COMBINER_OP_MAX = 0x96D5;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_COMBINER_OP_MUL = 0x96D6;
-	static constexpr const GLenum MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH = 0x96D7;
-	static constexpr const GLenum MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH = 0x96D8;
-	static constexpr const GLenum MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT = 0x96D9;
-	static constexpr const GLenum MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT = 0x96DA;
-	static constexpr const GLenum MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO = 0x96DB;
-	static constexpr const GLenum MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS = 0x96DC;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED = 0x96DD;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED = 0x96DE;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED = 0x96DF;
-	static constexpr const GLenum FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED = 0x8F6F;
 	static constexpr const GLenum TEXTURE_TILING = 0x9580;
 	static constexpr const GLenum DEDICATED_MEMORY_OBJECT = 0x9581;
 	static constexpr const GLenum PROTECTED_MEMORY_OBJECT = 0x959B;
@@ -3169,19 +3136,12 @@ public:
 	static constexpr const GLenum COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = 0x8C4E;
 	static constexpr const GLenum COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = 0x8C4F;
 	static constexpr const GLenum TEXTURE_FORMAT_SRGB_OVERRIDE = 0x8FBF;
-	static constexpr const GLenum NUM_SURFACE_COMPRESSION_FIXED_RATES = 0x8F6E;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_1BPC = 0x96C4;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_2BPC = 0x96C5;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_3BPC = 0x96C6;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_4BPC = 0x96C7;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_5BPC = 0x96C8;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_6BPC = 0x96C9;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_7BPC = 0x96CA;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_8BPC = 0x96CB;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_9BPC = 0x96CC;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_10BPC = 0x96CD;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_11BPC = 0x96CE;
-	static constexpr const GLenum SURFACE_COMPRESSION_FIXED_RATE_12BPC = 0x96CF;
+	static constexpr const GLenum ALPHA32F = 0x8816;
+	static constexpr const GLenum LUMINANCE32F = 0x8818;
+	static constexpr const GLenum LUMINANCE_ALPHA32F = 0x8819;
+	static constexpr const GLenum ALPHA16F = 0x881C;
+	static constexpr const GLenum LUMINANCE16F = 0x881E;
+	static constexpr const GLenum LUMINANCE_ALPHA16F = 0x881F;
 	static constexpr const GLenum GCCSO_SHADER_BINARY_FJ = 0x9260;
 	static constexpr const GLenum STATE_RESTORE = 0x8BDC;
 	static constexpr const GLenum SHADER_BINARY_VIV = 0x8FC4;

include/path.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_PATH_H_INCLUDED__
+#define __IRR_PATH_H_INCLUDED__
 
 #include "irrString.h"
 
@@ -17,9 +18,6 @@ namespace io
 */
 typedef core::string<fschar_t> path;
 
-// Type only exists for historcal reasons, paths are always char now.
-static_assert(sizeof(fschar_t) == sizeof(char));
-
 //! Used in places where we identify objects by a filename, but don't actually work with the real filename
 /** Irrlicht is internally not case-sensitive when it comes to names.
     Also this class is a first step towards support for correctly serializing renamed objects.
@@ -65,6 +63,11 @@ struct SNamedPath
 	{
 		return core::stringc(getPath());
 	}
+	//! Implicit cast to io::path
+	operator core::stringw() const
+	{
+		return core::stringw(getPath());
+	}
 
 protected:
 	// convert the given path string to a name string.
@@ -84,3 +87,4 @@ private:
 } // io
 } // irr
 
+#endif // __IRR_PATH_H_INCLUDED__

include/plane3d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_PLANE_3D_H_INCLUDED__
+#define __IRR_PLANE_3D_H_INCLUDED__
 
 #include "irrMath.h"
 #include "vector3d.h"
@@ -240,4 +241,5 @@ typedef plane3d<s32> plane3di;
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/position2d.h

@@ -5,7 +5,8 @@
 //! As of Irrlicht 1.6, position2d is a synonym for vector2d.
 /** You should consider position2d to be deprecated, and use vector2d by preference. */
 
-#pragma once
+#ifndef __IRR_POSITION_H_INCLUDED__
+#define __IRR_POSITION_H_INCLUDED__
 
 #include "vector2d.h"
 
@@ -27,4 +28,5 @@ typedef vector2d<s32> position2di;
 // ...and use a #define to catch the rest, for (e.g.) position2d<f64>
 #define position2d vector2d
 
+#endif // __IRR_POSITION_H_INCLUDED__
 

include/quaternion.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_QUATERNION_H_INCLUDED__
+#define __IRR_QUATERNION_H_INCLUDED__
 
 #include "irrTypes.h"
 #include "irrMath.h"
@@ -719,8 +720,6 @@ inline core::quaternion& quaternion::makeIdentity()
 inline core::quaternion& quaternion::rotationFromTo(const vector3df& from, const vector3df& to)
 {
 	// Based on Stan Melax's article in Game Programming Gems
-	// Optimized by Robert Eisele: https://raw.org/proof/quaternion-from-two-vectors
-
 	// Copy, since cannot modify local
 	vector3df v0 = from;
 	vector3df v1 = to;
@@ -745,12 +744,15 @@ inline core::quaternion& quaternion::rotationFromTo(const vector3df& from, const
 		return set(axis.X, axis.Y, axis.Z, 0).normalize();
 	}
 
-	const vector3df c = v0.crossProduct(v1);
-	return set(c.X, c.Y, c.Z, 1 + d).normalize();
+	const f32 s = sqrtf( (1+d)*2 ); // optimize inv_sqrt
+	const f32 invs = 1.f / s;
+	const vector3df c = v0.crossProduct(v1)*invs;
+	return set(c.X, c.Y, c.Z, s * 0.5f).normalize();
 }
 
 
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/rect.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_RECT_H_INCLUDED__
+#define __IRR_RECT_H_INCLUDED__
 
 #include "irrTypes.h"
 #include "dimension2d.h"
@@ -283,4 +284,5 @@ namespace core
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/triangle3d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_TRIANGLE_3D_H_INCLUDED__
+#define __IRR_TRIANGLE_3D_H_INCLUDED__
 
 #include "vector3d.h"
 #include "line3d.h"
@@ -273,4 +274,5 @@ namespace core
 } // end namespace core
 } // end namespace irr
 
+#endif
 

include/vector2d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_POINT_2D_H_INCLUDED__
+#define __IRR_POINT_2D_H_INCLUDED__
 
 #include "irrMath.h"
 #include "dimension2d.h"
@@ -75,47 +76,47 @@ public:
 		return *(&X+index);
 	}
 
-	//! sort in order X, Y.
+	//! sort in order X, Y. Equality with rounding tolerance.
 	bool operator<=(const vector2d<T>&other) const
 	{
-		return !(*this > other);
+		return (X<other.X || core::equals(X, other.X)) ||
+				(core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y)));
 	}
 
-	//! sort in order X, Y.
+	//! sort in order X, Y. Equality with rounding tolerance.
 	bool operator>=(const vector2d<T>&other) const
 	{
-		return !(*this < other);
+		return (X>other.X || core::equals(X, other.X)) ||
+				(core::equals(X, other.X) && (Y>other.Y || core::equals(Y, other.Y)));
 	}
 
-	//! sort in order X, Y.
+	//! sort in order X, Y. Difference must be above rounding tolerance.
 	bool operator<(const vector2d<T>&other) const
 	{
-		return X < other.X || (X == other.X && Y < other.Y);
+		return (X<other.X && !core::equals(X, other.X)) ||
+				(core::equals(X, other.X) && Y<other.Y && !core::equals(Y, other.Y));
 	}
 
-	//! sort in order X, Y.
+	//! sort in order X, Y. Difference must be above rounding tolerance.
 	bool operator>(const vector2d<T>&other) const
 	{
-		return X > other.X || (X == other.X && Y > other.Y);
+		return (X>other.X && !core::equals(X, other.X)) ||
+				(core::equals(X, other.X) && Y>other.Y && !core::equals(Y, other.Y));
 	}
 
-	bool operator==(const vector2d<T>& other) const {
-		return X == other.X && Y == other.Y;
-	}
-
-	bool operator!=(const vector2d<T>& other) const {
-		return !(*this == other);
-	}
+	bool operator==(const vector2d<T>& other) const { return equals(other); }
+	bool operator!=(const vector2d<T>& other) const { return !equals(other); }
 
 	// functions
 
 	//! Checks if this vector equals the other one.
 	/** Takes floating point rounding errors into account.
 	\param other Vector to compare with.
+	\param tolerance Epsilon value for both - comparing X and Y.
 	\return True if the two vector are (almost) equal, else false. */
-	bool equals(const vector2d<T>& other) const
+	bool equals(const vector2d<T>& other, const T tolerance = (T)ROUNDING_ERROR_f32 ) const
 	{
-		return core::equals(X, other.X) && core::equals(Y, other.Y);
+		return core::equals(X, other.X, tolerance) && core::equals(Y, other.Y, tolerance);
 	}
 
 	vector2d<T>& set(T nx, T ny) {X=nx; Y=ny; return *this; }
@@ -142,7 +143,7 @@ public:
 	bool nearlyParallel( const vector2d<T> & other, const T factor = relativeErrorFactor<T>()) const
 	{
 		// https://eagergames.wordpress.com/2017/04/01/fast-parallel-lines-and-vectors-test/
-		// if a || b then  a.x/a.y = b.x/b.y (similar triangles)
+		// if a || b then  a.x/a.y = b.x/b.y (similiar triangles)
 		// if a || b then either both x are 0 or both y are 0.
 
 		return  equalsRelative( X*other.Y, other.X* Y, factor)
@@ -431,4 +432,5 @@ struct hash<irr::core::vector2d<T> >
 
 }
 
+#endif
 

include/vector3d.h

@@ -2,7 +2,8 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
-#pragma once
+#ifndef __IRR_POINT_3D_H_INCLUDED__
+#define __IRR_POINT_3D_H_INCLUDED__
 
 #include "irrMath.h"
 
@@ -68,51 +69,57 @@ namespace core
 			return *(&X+index);
 		}
 
-		//! sort in order X, Y, Z.
+		//! sort in order X, Y, Z. Equality with rounding tolerance.
 		bool operator<=(const vector3d<T>&other) const
 		{
-			return !(*this > other);
+			return (X<other.X || core::equals(X, other.X)) ||
+					(core::equals(X, other.X) && (Y<other.Y || core::equals(Y, other.Y))) ||
+					(core::equals(X, other.X) && core::equals(Y, other.Y) && (Z<other.Z || core::equals(Z, other.Z)));
 		}
 
-		//! sort in order X, Y, Z.
+		//! sort in order X, Y, Z. Equality with rounding tolerance.
 		bool operator>=(const vector3d<T>&other) const
 		{
-			return !(*this < other);
+			return (X>other.X || core::equals(X, other.X)) ||
+					(core::equals(X, other.X) && (Y>other.Y || core::equals(Y, other.Y))) ||
+					(core::equals(X, other.X) && core::equals(Y, other.Y) && (Z>other.Z || core::equals(Z, other.Z)));
 		}
 
-		//! sort in order X, Y, Z.
+		//! sort in order X, Y, Z. Difference must be above rounding tolerance.
 		bool operator<(const vector3d<T>&other) const
 		{
-			return X < other.X || (X == other.X && Y < other.Y) ||
-					(X == other.X && Y == other.Y && Z < other.Z);
+			return (X<other.X && !core::equals(X, other.X)) ||
+					(core::equals(X, other.X) && Y<other.Y && !core::equals(Y, other.Y)) ||
+					(core::equals(X, other.X) && core::equals(Y, other.Y) && Z<other.Z && !core::equals(Z, other.Z));
 		}
 
-		//! sort in order X, Y, Z.
+		//! sort in order X, Y, Z. Difference must be above rounding tolerance.
 		bool operator>(const vector3d<T>&other) const
 		{
-			return X > other.X || (X == other.X && Y > other.Y) ||
-					(X == other.X && Y == other.Y && Z > other.Z);
+			return (X>other.X && !core::equals(X, other.X)) ||
+					(core::equals(X, other.X) && Y>other.Y && !core::equals(Y, other.Y)) ||
+					(core::equals(X, other.X) && core::equals(Y, other.Y) && Z>other.Z && !core::equals(Z, other.Z));
 		}
 
+		//! use weak float compare
 		bool operator==(const vector3d<T>& other) const
 		{
-			return X == other.X && Y == other.Y && Z == other.Z;
+			return this->equals(other);
 		}
 
 		bool operator!=(const vector3d<T>& other) const
 		{
-			return !(*this == other);
+			return !this->equals(other);
 		}
 
 		// functions
 
-		//! Checks if this vector equals the other one.
-		/** Takes floating point rounding errors into account.
-		\param other Vector to compare with.
-		\return True if the two vector are (almost) equal, else false. */
-		bool equals(const vector3d<T>& other) const
+		//! returns if this vector equals the other one, taking floating point rounding errors into account
+		bool equals(const vector3d<T>& other, const T tolerance = (T)ROUNDING_ERROR_f32 ) const
 		{
-			return core::equals(X, other.X) && core::equals(Y, other.Y) && core::equals(Z, other.Z);
+			return core::equals(X, other.X, tolerance) &&
+				core::equals(Y, other.Y, tolerance) &&
+				core::equals(Z, other.Z, tolerance);
 		}
 
 		vector3d<T>& set(const T nx, const T ny, const T nz) {X=nx; Y=ny; Z=nz; return *this;}
@@ -200,10 +207,7 @@ namespace core
 		}
 
 		//! Rotates the vector by a specified number of degrees around the Y axis and the specified center.
-		/** CAREFUL: For historical reasons rotateXZBy uses a right-handed rotation
-		(maybe to make it more similar to the 2D vector rotations which are counterclockwise).
-		To have this work the same way as rest of Irrlicht (nodes, matrices, other rotateBy functions) pass -1*degrees in here.
-		\param degrees Number of degrees to rotate around the Y axis.
+		/** \param degrees Number of degrees to rotate around the Y axis.
 		\param center The center of the rotation. */
 		void rotateXZBy(f64 degrees, const vector3d<T>& center=vector3d<T>())
 		{
@@ -481,4 +485,5 @@ struct hash<irr::core::vector3d<T> >
 
 }
 
+#endif
 

irr-readme.txt

@@ -0,0 +1,235 @@
+==========================================================================
+The Irrlicht Engine SDK version 1.9
+==========================================================================
+
+  Welcome to the Irrlicht Engine SDK.
+
+  Content of this file:
+
+  1. Directory Structure Overview
+  2. How To Start
+  3. Requirements
+  4. Release Notes
+  5. License
+  6. Contact
+
+
+==========================================================================
+1. Directory Structure Overview
+==========================================================================
+
+  You will find some directories after uncompressing the archive of the
+  SDK. These are:
+
+  \bin         The compiled library Irrlicht.DLL and some compiled demo
+               and example applications, just start them to see the
+               Irrlicht Engine in action. Windows only.
+  \doc         Documentation of the Irrlicht Engine.
+  \examples    Examples and tutorials showing how to use the engine with
+               C++.
+  \include     Header files to include when programming with the engine.
+  \lib         Libs to link with your programs when using the engine.
+  \media       Graphics and sound resources for the demo applications and
+               examples.
+  \source      The source code of the Irrlicht Engine. This code is
+               not needed to develop applications with the engine,
+               but it is included to enable recompilation and
+               debugging, if necessary.
+  \tools       Useful tools (with sourcecode) for the engine.
+
+
+
+==========================================================================
+2. How to start
+==========================================================================
+
+  To see the engine in action in Windows, just go to the \bin\Win32-VisualStudio
+  directory, and start some applications. There should also be an
+  application named Demo.exe which should show the most
+  interesting features of Irrlicht.
+
+  To start developing own applications and games with the engine take
+  a look at the 01.HelloWorld example in the \examples directory.
+  There is also a .html file with a tutorial which should be
+  easily comprehensible.
+
+  The Irrlicht Engine is a static lib under linux. A precompiled version can be
+  generated from the sources using the Makefile in source/Irrlicht. Run 'make' in 
+  that subfolder. After this you should be able to 'make' all
+  example applications in /examples by calling the buildAllExamples script. You 
+  can run the examples then from the bin folder.
+
+  It is also possible to use Irrlicht as shared object
+  (libIrrlicht.so.versionNumber). Use the proper makefile target for this by
+  running 'make sharedlib' in the source folder. See the Makefile for details.
+
+  For OSX you can find an XCode project file in source/Irrlicht/MacOSX. This will
+  build the libIrrlicht.a library necessary to create the apps.
+
+==========================================================================
+3. Requirements
+==========================================================================
+
+  You can use one of the following compilers/IDEs to develop applications
+  with Irrlicht or recompile the engine. However, other compilers/IDEs may
+  work as well, we simply didn't test them.
+
+  * gcc 4.x
+  * Visual Studio 2010(10.0)-2013(12.0)
+  * Code::Blocks (& gcc or visual studio toolkit)
+  
+  If you ever want to (re)compile the engine yourself (which means you don't
+  want to use the precompiled version) you need the following:
+
+  * Windows:
+	* Needed: PlatformSDK (which usually comes with all IDEs, download
+			it separately for MSVC Express 2005)
+	* Optional: DirectX SDK, for D3D9 support
+	* Optional: DirectX SDK prior to May 2006, for D3D8 support
+
+  * Linux:
+	* Needed: XServer with include files
+	* Optional: OpenGL headers and libraries (libGL.so) for OpenGL support
+		GLX +
+		XF86VidMode [package x11proto-xf86vidmode-dev] or XRandr
+		(X11 support libraries, the latter two for fullscreen mode)
+
+  * OSX:
+	* Needed: XCode and Cocoa framework
+	* Needed: OpenGL headers and libraries
+
+==========================================================================
+4. Release Notes
+==========================================================================
+
+  Informations about changes in this new version of the engine can be
+  found in changes.txt.
+
+  Please note that the textures, 3D models and levels are copyright
+  by their authors and not covered by the Irrlicht engine license.
+
+==========================================================================
+5. License
+==========================================================================
+
+  The license of the Irrlicht Engine is based on the zlib/libpng license.
+  Even though this license does not require you to mention that you are
+  using the Irrlicht Engine in your product, an acknowledgement
+  would be highly appreciated.
+
+  Please note that the Irrlicht Engine is based in part on the work of
+  the Independent JPEG Group, the zlib, and libpng. This means that if you use
+  the Irrlicht Engine in your product, you must acknowledge somewhere
+  in your documentation that you've used the IJG code and libpng. It would
+  also be nice to mention that you use the Irrlicht Engine and the zlib.
+  See the README files in the jpeglib and the zlib for
+  further informations.
+
+
+  The Irrlicht Engine License
+  ===========================
+
+  Copyright (C) 2002-2012 Nikolaus Gebhardt
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgement in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be clearly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+==========================================================================
+6. Contact
+==========================================================================
+
+  If you have problems, questions or suggestions, please visit the
+  official homepage of the Irrlicht Engine:
+
+  http://irrlicht.sourceforge.net
+
+  You will find forums, bugtrackers, patches, tutorials, and other stuff
+  which will help you out.
+
+  If want to contact the team of the engine, please send an email to
+  Nikolaus Gebhardt:
+
+  irrlicht@users.sourceforge.net
+
+  Please also not that parts of the engine have been written or contributed
+  by other people. Especially: (There are probably more people, sorry if I forgot one.
+  See http://irrlicht.sourceforge.net/author.html for more informations)
+
+  Christian Stehno (hybrid)   Contribution Coordinator/Developer
+  Michael Zeilfelder (cutealien) Developer
+  Patryk Nadrowski (Nadro)    Developer  
+  Yoran Bosman (Yoran)        Webserver administrator
+  Gareth Davidson (bitplane)  Developer/ Forum admin
+  Thomas Alten (burningwater) Wrote the burningsvideo software rasterizer
+  Luke P. Hoschke (luke)      Wrote the b3d loader, the new animation system, VBOs and other things
+  Colin MacDonald (rogerborg) All hands person
+  Ahmed Hilali (blindside)    The shader and advanced effects man
+  Dean Wadsworth (varmint)    OSX port maintainer and game developer
+  Alvaro F. Celis (afecelis)  Lots of work in the community, for example video tutorials about Irrlicht, forum admin
+  John Goewert (Saigumi)      Wrote some tutorials for the Irrlicht Engine and doing admin stuff
+  Jam                         Takes care of moderating the forums and keeps them clean from those evil spammers.
+
+  Many others (this list hasn't been updated in a while, but they are often mentioned in changes.txt)
+  Etienne Petitjean wrote the MacPort of the engine
+  Mark Jeacocke	Wrote lots of helpful comments and ideas in the forums and per email.
+  Julio Gorg<72>	Created the 'Unofficial DirectX 9.0 Driver for the Irrlicht Engine'
+  Andy Spurgeon	Wrote the Dev-Cpp tutorial.
+  Andr<64> Simon	Wrote the Codewarrior tutorial.
+  KnightToFlight	Created the unoffical terrain renderer addon for the Irrlicht Engine.
+  Jon Pry	Wrote the code to load compressed TGA files.
+  Matthew Couch	Wrote the tokamak integration tutorial.
+  Max Winkel	Wrote the splitscreen tutorial.
+  Gorgon Zola	Wrote the ODE integration tutorial.
+  Dean P. Macri	Sent in code for curved surfaces and PCX Loading.
+  Sirshane	Made several bug fixes, sent in code for making the mouse cursor invisible in Linux.
+  Matthias Gall	Sent in code for a spline scene node animator and reported lots of bugs.
+  Mario Gruber	Suggested triangle fan drawing and sent in code for this.
+  Ariaci	Spotted out a bug in the ATI driver.
+  Dr Andros C Bragianos	Improved texture mapping in cube scene node.
+  Philipp Dortmann	Sent in code for stencil buffer support for OpenGL.
+  Jerome Nichols	Created the Irrlicht/Ruby interface located at irr.rubyforge.org
+  Vash TheStampede	Sent code for missing Draw2DLine() implementations
+  MattyBoy	XBOX support suggestions
+  Oliver Klems	createImageFromData() method suggestion/implementation
+  Jox	really, really a lot of bug fixes, and the LMTS file loader
+  Zola	Quaternion method additions
+  Tomasz Nowakowski	various bug fixes
+  Nicholas Bray	stencil shadow bug fixes with OpenGL
+  REAPER	mouswheel events for scrollbar
+  Calimero	various bug fixes like vector2d operators
+  Haddock	bugfix in the linked list
+  G.o.D	XML parser fix
+  Erik Zilli	Translated some of the tutorials from my stuttering english into real english. :)
+  Martin Piskernig	Linux bugfixing and testing
+  Soconne	Wrote the original terrain renderer were Irrlichts terrain renderer of Irrlicht is based on it.
+  Spintz	GeoMipMap scene node, terrain renderer of Irrlicht is based on it.
+  Murphy McCauley	OCT file loader, MIM tools
+  Saurav Mohapatra	IrrCSM, and lots of addons, suggestions and bug reports
+  Zhuck Dimitry	My3D Tools
+  Terry Welsh	Allowed me to use the textures of his 'Parallax Mapping with Offset Limiting' paper for the parallax demo of Irrlicht
+  rt	Wrote the original .png loader for Irrlicht
+  Salvatore Russo	Wrote the original .dmf loader for Irrlicht
+  Vox	Various bug reports and fixes
+  atomice	Contributed code for a ms3d loader enhancement
+  William Finlayson	OpenGL RTT, GLSL support and the reflection 2 layer material for OpenGL.
+  Delight	Various code contributions for Irrlicht.NET (particle system, basic shader support and more)
+  Michael Zoech	Improved GLSL support
+  Jean-loup Gailly, Mark Adler	Created the zlib and libpng
+  Guy Eric Schalnat, Andreas Dilger, Glenn Randers-Pehrson and others	Created libpng
+  The Independent JPEG Group	Created JPEG lib
+  Dr Brian Gladman AES Created aesGladman
+  

lib/Linux/readme.txt

@@ -0,0 +1,2 @@
+You might have to recompile the engine to get library files in here.
+Check the readme.txt in the corresponding bin folders for more information.

lib/OSX/readme.txt

@@ -0,0 +1,2 @@
+You might have to recompile the engine to get library files in here.
+Check the readme.txt in the corresponding bin folders for more information.

lib/Win32-gcc/readme.txt

@@ -0,0 +1,2 @@
+You might have to recompile the engine to get library files in here.
+Check the readme.txt in the corresponding bin folders for more information.

lib/Win32-visualstudio/readme.txt

@@ -0,0 +1,2 @@
+You might have to recompile the engine to get library files in here.
+Check the readme.txt in the corresponding bin folders for more information.

media/Shaders/COGLES2OneTextureBlend.fsh

@@ -0,0 +1,75 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uBlendType;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vVertexColor;
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color1 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	vec4 FinalColor = Color0 * Color1;
+	FinalColor += vSpecularColor;
+
+	if (uBlendType == 1)
+	{
+		FinalColor.w = Color0.w;
+	}
+	else if (uBlendType == 2)
+	{
+		FinalColor.w = Color1.w;
+	}
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}

media/Shaders/COGLES2Renderer2D.fsh

@@ -0,0 +1,21 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage;
+uniform sampler2D uTextureUnit;
+
+/* Varyings */
+
+varying vec2 vTextureCoord;
+varying vec4 vVertexColor;
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage))
+		Color *= texture2D(uTextureUnit, vTextureCoord);
+
+	gl_FragColor = Color;
+}

media/Shaders/COGLES2Renderer2D.vsh

@@ -0,0 +1,22 @@
+/* Attributes */
+
+attribute vec4 inVertexPosition;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+
+/* Uniforms */
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord;
+varying vec4 vVertexColor;
+
+void main()
+{
+	gl_Position = inVertexPosition;
+	gl_PointSize = uThickness;
+	vTextureCoord = inTexCoord0;
+	vVertexColor = inVertexColor.bgra;
+}

media/Shaders/COGLES2Renderer2D_noTex.fsh

@@ -0,0 +1,9 @@
+precision mediump float;
+
+/* Varyings */
+varying vec4 vVertexColor;
+
+void main()
+{
+	gl_FragColor = vVertexColor;
+}

media/Shaders/COGLES2Solid.fsh

@@ -0,0 +1,62 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}

media/Shaders/COGLES2Solid.vsh

@@ -0,0 +1,45 @@
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+
+/* Uniforms */
+
+uniform mat4 uWVPMatrix;
+uniform mat4 uWVMatrix;
+uniform mat4 uNMatrix;
+uniform mat4 uTMatrix0;
+
+uniform vec4 uGlobalAmbient;
+uniform vec4 uMaterialAmbient;
+uniform vec4 uMaterialDiffuse;
+uniform vec4 uMaterialEmissive;
+uniform vec4 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+void main()
+{
+	gl_Position = uWVPMatrix * vec4(inVertexPosition, 1.0);
+	gl_PointSize = uThickness;
+
+	vec4 TextureCoord0 = vec4(inTexCoord0.x, inTexCoord0.y, 1.0, 1.0);
+	vTextureCoord0 = vec4(uTMatrix0 * TextureCoord0).xy;
+
+	vVertexColor = inVertexColor.bgra;
+	vSpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+	vec3 Position = (uWVMatrix * vec4(inVertexPosition, 1.0)).xyz;
+
+	vFogCoord = length(Position);
+}

media/Shaders/COGLES2TransparentAlphaChannel.fsh

@@ -0,0 +1,69 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform float uAlphaRef;
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+	{
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+		
+		// TODO: uAlphaRef should rather control sharpness of alpha, don't know how to do that right now and this works in most cases.
+		if (Color.a < uAlphaRef)
+			discard;
+	}
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}

media/Shaders/COGLES2TransparentAlphaChannelRef.fsh

@@ -0,0 +1,67 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform float uAlphaRef;
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (Color.a < uAlphaRef)
+		discard;
+		
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}

media/Shaders/COGLES2TransparentVertexAlpha.fsh

@@ -0,0 +1,62 @@
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}

ogles-readme.txt

@@ -0,0 +1,6 @@
+This branch is used for development of the OpenGL-ES drivers for Irrlicht.
+There will be drivers for ogl-es 1.x and 2.x at some time, but we'll start
+with 1.x first. Both drivers will be separate drivers, loosely based on the
+OpenGL driver.
+The branch is based on SVN/trunk and will be updated only very slowly. It's
+not intended for regular use besides when working with ogl-es development.

repro.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+aflout=out/default
+myout=out_rep
+exe=./bin/Linux/LoadMesh
+rm -rf "$myout" && mkdir -p "$myout"
+find $aflout/crashes -name 'id:*' -print | \
+while read file; do
+	echo "➤ Testing $file..."
+	short=${file##*/}
+	short=${short%%,*}
+	fout=$myout/$short.txt
+	$exe "$file" >"$fout" 2>&1
+	r=$?
+	if grep -Fq '==ERROR: AddressSanitizer: SEGV on unknown address' "$fout"; then
+		gdb -q --batch -iex 'set confirm off' -ex r -ex bt --args \
+			${exe}_noasan "$file" >"$fout" 2>&1
+		if grep -Eq '^(Thread|Program).*received signal' "$fout"; then
+			cp "$file" "$myout/$short.bin"
+			echo "✔ Reproduced (gdb)"
+		else
+			echo "✗ Not reproduced (gdb)"
+			rm -f "$fout"
+		fi
+		continue
+	fi
+	grep -Fq '==ABORTING' "$fout" && r=1
+	if [ $r -eq 0 ]; then
+		echo "✗ Not reproduced (asan)"
+		rm -f "$fout"
+		continue
+	fi
+	cp "$file" "$myout/$short.bin"
+	echo "✔ Reproduced (asan)"
+done

run.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+export AFL_SKIP_CPUFREQ=1
+export AFL_TMPDIR=/dev/shm
+exe=./bin/Linux/LoadMesh
+opts=(
+	-t 100
+	-i sample_u/
+	-o out/
+)
+if ! [ -d sample_u ]; then
+	mkdir sample_u
+	afl-cmin.bash -T 4 -i sample/ -o sample_u/ -- $exe @@
+	echo; echo
+fi
+exec afl-fuzz \
+	"${opts[@]}" "$@" \
+	-- $exe @@

scripts/BindingGenerator.lua

@@ -355,7 +355,7 @@ f:write[[
 #include <KHR/khrplatform.h>
 
 #ifndef APIENTRY
-	#define APIENTRY KHRONOS_APIENTRY
+	#define APIENTRY
 #endif
 #ifndef APIENTRYP
 	#define APIENTRYP APIENTRY *
@@ -387,9 +387,9 @@ public:
 	// Call this once after creating the context.
 	void LoadAllProcedures(irr::video::IContextManager *cmgr);
 	// Check if an extension is supported.
-	inline bool IsExtensionPresent(const std::string &ext) const
+	inline bool IsExtensionPresent(const std::string &ext)
 	{
-		return extensions.count(ext) > 0;
+		return extensions.find(ext) != extensions.end();
 	}
 
 ]];
@@ -410,9 +410,6 @@ f:close();
 -- Write loader implementation
 f = io.open( sourceTreePath .. "/source/Irrlicht/mt_opengl_loader.cpp", "wb" );
 f:write[[
-// This code was generated by scripts/BindingGenerator.lua
-// Do not modify it, modify and run the generator instead.
-
 #include "mt_opengl.h"
 #include <string>
 #include <sstream>
@@ -426,24 +423,9 @@ void OpenGLProcedures::LoadAllProcedures(irr::video::IContextManager *cmgr)
 f:write( loader:Concat() );
 f:write[[
 
-	// OpenGL 3 way to enumerate extensions
-	GLint ext_count = 0;
-	GetIntegerv(NUM_EXTENSIONS, &ext_count);
-	extensions.reserve(ext_count);
-	for (GLint k = 0; k < ext_count; k++) {
-		auto tmp = GetStringi(EXTENSIONS, k);
-		if (tmp)
-			extensions.emplace((char*)tmp);
-	}
-	if (!extensions.empty())
-		return;
-
-	// OpenGL 2 / ES 2 way to enumerate extensions
-	auto ext_str = GetString(EXTENSIONS);
-	if (!ext_str)
-		return;
 	// get the extension string, chop it up
-	std::stringstream ext_ss((char*)ext_str);
+	std::string ext_string = std::string((char*)GetString(EXTENSIONS));
+	std::stringstream ext_ss(ext_string);
 	std::string tmp;
 	while (std::getline(ext_ss, tmp, ' '))
 		extensions.emplace(tmp);

scripts/ci-build-android.sh

@@ -1,123 +0,0 @@
-#!/bin/bash -e
-
-# NOTE: this code is mostly copied from minetest_android_deps
-# <https://github.com/minetest/minetest_android_deps>
-
-png_ver=1.6.40
-jpeg_ver=3.0.1
-
-download () {
-	get_tar_archive libpng "https://download.sourceforge.net/libpng/libpng-${png_ver}.tar.gz"
-	get_tar_archive libjpeg "https://download.sourceforge.net/libjpeg-turbo/libjpeg-turbo-${jpeg_ver}.tar.gz"
-}
-
-build () {
-	# Build libjpg and libpng first because Irrlicht needs them
-	mkdir -p libpng
-	pushd libpng
-	$srcdir/libpng/configure --host=$CROSS_PREFIX
-	make && make DESTDIR=$PWD install
-	popd
-
-	mkdir -p libjpeg
-	pushd libjpeg
-	cmake $srcdir/libjpeg "${CMAKE_FLAGS[@]}" -DENABLE_SHARED=OFF
-	make && make DESTDIR=$PWD install
-	popd
-
-	local libpng=$PWD/libpng/usr/local/lib/libpng.a
-	local libjpeg=$(echo $PWD/libjpeg/opt/libjpeg-turbo/lib*/libjpeg.a)
-	cmake $srcdir/irrlicht "${CMAKE_FLAGS[@]}" \
-		-DBUILD_SHARED_LIBS=OFF \
-		-DPNG_LIBRARY=$libpng \
-		-DPNG_PNG_INCLUDE_DIR=$(dirname "$libpng")/../include \
-		-DJPEG_LIBRARY=$libjpeg \
-		-DJPEG_INCLUDE_DIR=$(dirname "$libjpeg")/../include
-	make
-
-	cp -p lib/Android/libIrrlichtMt.a $libpng $libjpeg $pkgdir/
-	cp -a $srcdir/irrlicht/include $pkgdir/include
-	cp -a $srcdir/irrlicht/media/Shaders $pkgdir/Shaders
-}
-
-get_tar_archive () {
-	# $1: folder to extract to, $2: URL
-	local filename="${2##*/}"
-	[ -d "$1" ] && return 0
-	wget -c "$2" -O "$filename"
-	mkdir -p "$1"
-	tar -xaf "$filename" -C "$1" --strip-components=1
-	rm "$filename"
-}
-
-_setup_toolchain () {
-	local toolchain=$(echo "$ANDROID_NDK"/toolchains/llvm/prebuilt/*)
-	if [ ! -d "$toolchain" ]; then
-		echo "Android NDK path not specified or incorrect"; return 1
-	fi
-	export PATH="$toolchain/bin:$ANDROID_NDK:$PATH"
-
-	unset CFLAGS CPPFLAGS CXXFLAGS
-
-	TARGET_ABI="$1"
-	API=21
-	if [ "$TARGET_ABI" == armeabi-v7a ]; then
-		CROSS_PREFIX=armv7a-linux-androideabi
-		CFLAGS="-mthumb"
-		CXXFLAGS="-mthumb"
-	elif [ "$TARGET_ABI" == arm64-v8a ]; then
-		CROSS_PREFIX=aarch64-linux-android
-	elif [ "$TARGET_ABI" == x86 ]; then
-		CROSS_PREFIX=i686-linux-android
-		CFLAGS="-mssse3 -mfpmath=sse"
-		CXXFLAGS="-mssse3 -mfpmath=sse"
-	elif [ "$TARGET_ABI" == x86_64 ]; then
-		CROSS_PREFIX=x86_64-linux-android
-	else
-		echo "Invalid ABI given"; return 1
-	fi
-	export CC=$CROSS_PREFIX$API-clang
-	export CXX=$CROSS_PREFIX$API-clang++
-	export AR=llvm-ar
-	export RANLIB=llvm-ranlib
-	export CFLAGS="-fPIC ${CFLAGS}"
-	export CXXFLAGS="-fPIC ${CXXFLAGS}"
-
-	CMAKE_FLAGS=(
-		"-DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake"
-		"-DANDROID_ABI=$TARGET_ABI" "-DANDROID_NATIVE_API_LEVEL=$API"
-		"-DCMAKE_BUILD_TYPE=Release"
-	)
-
-	# make sure pkg-config doesn't interfere
-	export PKG_CONFIG=/bin/false
-
-	export MAKEFLAGS="-j$(nproc)"
-}
-
-_run_build () {
-	local abi=$1
-	irrdir=$PWD
-
-	mkdir -p $RUNNER_TEMP/src
-	cd $RUNNER_TEMP/src
-	srcdir=$PWD
-	[ -d irrlicht ] || ln -s $irrdir irrlicht
-	download
-
-	builddir=$RUNNER_TEMP/build/irrlicht-$abi
-	pkgdir=$RUNNER_TEMP/pkg/$abi/Irrlicht
-	rm -rf "$pkgdir"
-	mkdir -p "$builddir" "$pkgdir"
-
-	cd "$builddir"
-	build
-}
-
-if [ $# -lt 1 ]; then
-	echo "Usage: ci-build-android.sh <ABI>"
-	exit 1
-fi
-
-_setup_toolchain $1
-_run_build $1

scripts/ci-build-mingw.sh

@@ -1,7 +1,7 @@
 #!/bin/bash -e
-topdir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
 [[ -z "$CC" || -z "$CXX" ]] && exit 255
+
 variant=win32
 [[ "$(basename "$CXX")" == "x86_64-"* ]] && variant=win64
 with_sdl=0
@@ -9,30 +9,26 @@ with_sdl=0
 #with_gl3=0
 #[[ "$extras" == *"-gl3"* ]] && with_gl3=1
 
-libjpeg_version=3.0.1
-libpng_version=1.6.40
-sdl2_version=2.28.5
-zlib_version=1.3.1
+libjpeg_version=2.1.5.1
+libpng_version=1.6.39
+sdl2_version=2.28.1
+zlib_version=1.2.13
 
-download () {
-	local url=$1
-	local filename=${url##*/}
-	local foldername=${filename%%[.-]*}
-
-	[ -d "./$foldername" ] && return 0
-    [ -e "$filename" ] || wget "$url" -O "$filename"
-	sha256sum -w -c <(grep -F "$filename" "$topdir/sha256sums.txt")
-	unzip -o "$filename" -d "$foldername"
-}
-
-libs=$PWD/libs
 mkdir -p libs
 pushd libs
-libhost="http://minetest.kitsunemimi.pw"
-download "$libhost/llvm/libjpeg-$libjpeg_version-$variant.zip"
-download "$libhost/llvm/libpng-$libpng_version-$variant.zip"
-[ $with_sdl -eq 1 ] && download "$libhost/llvm/sdl2-$sdl2_version-$variant.zip"
-download "$libhost/llvm/zlib-$zlib_version-$variant.zip"
+libs=$PWD
+[ -e libjpeg.zip ] || \
+	wget "http://minetest.kitsunemimi.pw/libjpeg-$libjpeg_version-$variant.zip" -O libjpeg.zip
+[ -e libpng.zip ] || \
+	wget "http://minetest.kitsunemimi.pw/libpng-$libpng_version-$variant.zip" -O libpng.zip
+[[ $with_sdl -eq 0 || -e sdl2.zip ]] || \
+	wget "http://minetest.kitsunemimi.pw/sdl2-$sdl2_version-$variant.zip" -O sdl2.zip
+[ -e zlib.zip ] || \
+	wget "http://minetest.kitsunemimi.pw/zlib-$zlib_version-$variant.zip" -O zlib.zip
+[ -d libjpeg ] || unzip -o libjpeg.zip -d libjpeg
+[ -d libpng ] || unzip -o libpng.zip -d libpng
+[[ $with_sdl -eq 0 || -d sdl2 ]] || unzip -o sdl2.zip -d sdl2
+[ -d zlib ] || unzip -o zlib.zip -d zlib
 popd
 
 tmp=(
@@ -44,14 +40,10 @@ tmp=(
 	-DZLIB_LIBRARY=$libs/zlib/lib/libz.dll.a \
 	-DZLIB_INCLUDE_DIR=$libs/zlib/include
 )
-if [ $with_sdl -eq 1 ]; then
-	tmp+=(
+[ $with_sdl -eq 1 ] && tmp+=(
 	-DUSE_SDL2=ON
 	-DCMAKE_PREFIX_PATH=$libs/sdl2/lib/cmake
 )
-else
-	tmp+=(-DUSE_SDL2=OFF)
-fi
 #[ $with_gl3 -eq 1 ] && tmp+=(-DENABLE_OPENGL=OFF -DENABLE_OPENGL3=ON)
 
 cmake . "${tmp[@]}"

scripts/ci-get-mingw.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-topdir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-name=llvm-mingw-20231128-ucrt-ubuntu-20.04-x86_64.tar.xz
-wget "https://github.com/mstorsjo/llvm-mingw/releases/download/20231128/$name" -O "$name"
-sha256sum -w -c <(grep -F "$name" "$topdir/sha256sums.txt")
-sudo tar -xaf "$name" -C /usr --strip-components=1
-rm -f "$name"

scripts/sha256sums.txt

@@ -1,9 +0,0 @@
-0f21ff3be90311092fe32e0e30878ef3ae9d9437b8d9ac25ef279e0d84e9bb8e  llvm-mingw-20231128-ucrt-ubuntu-20.04-x86_64.tar.xz
-53dfd31285f470fcf0dca88217c5cf9c557729af6d103afae5936e72ddc38d3c  libjpeg-3.0.1-win32.zip
-3d44e0740914e6878300e30653aad39e974821b5d7f6c2567e246b4eb04a5324  libjpeg-3.0.1-win64.zip
-6baf4e819bfb3573760524b5dc9a04b5e479090d6d2046b86cf39a3107c0071f  libpng-1.6.40-win32.zip
-c02e029f01fce44baea7f4aecfd2564bd8a03507c0c6af8b03339ae0452c8b7d  libpng-1.6.40-win64.zip
-f9f890af960e92fd3f532f2e9ac00681c33bc67a722e000dfdaeb41b0064f1a0  sdl2-2.28.5-win32.zip
-8dde2c6963544b7d8a2e87c128ebbdf51ad0e70c7e2df986ff4e963ce9996d9b  sdl2-2.28.5-win64.zip
-8af10515d57dbfee5d2106cd66cafa2adeb4270d4c6047ccbf7e8b5d2d50681c  zlib-1.3.1-win32.zip
-ad43f5d23052590c65633530743e5d622cc76b33c109072e6fd7b487aff56bca  zlib-1.3.1-win64.zip

source/Irrlicht/Android/CAndroidAssetFileArchive.cpp

@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
 
+#ifdef   _IRR_COMPILE_ANDROID_ASSET_READER_
 
 #include "CAndroidAssetReader.h"
 
@@ -105,3 +106,4 @@ void CAndroidAssetFileArchive::addDirectoryToFileList(const io::path &dirname_)
 } // end namespace io
 } // end namespace irr
 
+#endif //  _IRR_COMPILE_ANDROID_ASSET_READER_

source/Irrlicht/Android/CAndroidAssetFileArchive.h

@@ -4,6 +4,9 @@
 
 #pragma once
 
+#ifdef  _IRR_COMPILE_ANDROID_ASSET_READER_
+
+
 #include "IReadFile.h"
 #include "IFileArchive.h"
 #include "CFileList.h"
@@ -58,3 +61,4 @@ namespace io
 } // end namespace io
 } // end namespace irr
 
+#endif //   _IRR_COMPILE_ANDROID_ASSET_READER_

source/Irrlicht/Android/CAndroidAssetReader.cpp

@@ -2,6 +2,9 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in irrlicht.h
 
+
+#ifdef   _IRR_COMPILE_ANDROID_ASSET_READER_
+
 #include "CAndroidAssetReader.h"
 
 #include "CReadFile.h"
@@ -66,3 +69,4 @@ const io::path& CAndroidAssetReader::getFileName() const
 } // end namespace io
 } // end namespace irr
 
+#endif //  _IRR_COMPILE_ANDROID_ASSET_READER_

source/Irrlicht/Android/CAndroidAssetReader.h

@@ -4,6 +4,9 @@
 
 #pragma once
 
+#ifdef  _IRR_COMPILE_ANDROID_ASSET_READER_
+
+
 #include "IReadFile.h"
 
 struct AAssetManager;
@@ -63,3 +66,4 @@ namespace io
 } // end namespace io
 } // end namespace irr
 
+#endif //   _IRR_COMPILE_ANDROID_ASSET_READER_

source/Irrlicht/Android/CIrrDeviceAndroid.cpp

@@ -5,6 +5,8 @@
 
 #include "CIrrDeviceAndroid.h"
 
+#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
+
 #include "os.h"
 #include "CFileSystem.h"
 #include "CAndroidAssetReader.h"
@@ -31,8 +33,7 @@ namespace irr
 {
 
 CIrrDeviceAndroid::CIrrDeviceAndroid(const SIrrlichtCreationParameters& param)
-	: CIrrDeviceStub(param), Accelerometer(0), Gyroscope(0), Initialized(false),
-	  Stopped(true), Paused(true), Focused(false), JNIEnvAttachedToVM(0)
+	: CIrrDeviceStub(param), Accelerometer(0), Gyroscope(0), Focused(false), Initialized(false), Paused(true), JNIEnvAttachedToVM(0)
 {
 #ifdef _DEBUG
 	setDebugName("CIrrDeviceAndroid");
@@ -65,7 +66,7 @@ CIrrDeviceAndroid::CIrrDeviceAndroid(const SIrrlichtCreationParameters& param)
 		s32 Events = 0;
 		android_poll_source* Source = 0;
 
-		while ((ALooper_pollAll((!Initialized || isWindowActive()) ? 0 : -1, 0, &Events, (void**)&Source)) >= 0)
+		while ((ALooper_pollAll(((Focused && !Paused) || !Initialized) ? 0 : -1, 0, &Events, (void**)&Source)) >= 0)
 		{
 			if(Source)
 				Source->process(Android, Source);
@@ -107,7 +108,7 @@ bool CIrrDeviceAndroid::run()
 	s32 Events = 0;
 	android_poll_source* Source = 0;
 
-	while ((id = ALooper_pollAll(0, 0, &Events, (void**)&Source)) >= 0)
+	while ((id = ALooper_pollAll(((Focused && !Paused) || !Initialized) ? 0 : -1, 0, &Events, (void**)&Source)) >= 0)
 	{
 		if(Source)
 			Source->process(Android, Source);
@@ -181,7 +182,7 @@ void CIrrDeviceAndroid::setWindowCaption(const wchar_t* text)
 
 bool CIrrDeviceAndroid::isWindowActive() const
 {
-	return (Focused && !Paused && !Stopped);
+	return (Focused && !Paused);
 }
 
 bool CIrrDeviceAndroid::isWindowFocused() const
@@ -194,11 +195,6 @@ bool CIrrDeviceAndroid::isWindowMinimized() const
 	return !Focused;
 }
 
-bool CIrrDeviceAndroid::isWindowVisible() const
-{
-	return !Stopped;
-}
-
 void CIrrDeviceAndroid::closeDevice()
 {
 	ANativeActivity_finish(Android->activity);
@@ -266,7 +262,6 @@ void CIrrDeviceAndroid::handleAndroidCommand(android_app* app, int32_t cmd)
 		break;
 		case APP_CMD_START:
 			os::Printer::log("Android command APP_CMD_START", ELL_DEBUG);
-			device->Stopped = false;
 		break;
 		case APP_CMD_INIT_WINDOW:
 			os::Printer::log("Android command APP_CMD_INIT_WINDOW", ELL_DEBUG);
@@ -324,7 +319,6 @@ void CIrrDeviceAndroid::handleAndroidCommand(android_app* app, int32_t cmd)
 			break;
 		case APP_CMD_STOP:
 			os::Printer::log("Android command APP_CMD_STOP", ELL_DEBUG);
-			device->Stopped = true;
 			break;
 		case APP_CMD_RESUME:
 			os::Printer::log("Android command APP_CMD_RESUME", ELL_DEBUG);
@@ -864,3 +858,5 @@ bool CIrrDeviceAndroid::isGyroscopeAvailable()
 }
 
 } // end namespace irr
+
+#endif

source/Irrlicht/Android/CIrrDeviceAndroid.h

@@ -5,6 +5,7 @@
 #pragma once
 
 
+#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
 
 #include "CIrrDeviceStub.h"
 #include "IrrlichtDevice.h"
@@ -36,8 +37,6 @@ namespace irr
 
 		virtual bool isWindowMinimized() const;
 
-		virtual bool isWindowVisible() const;
-
 		virtual void closeDevice();
 
 		virtual void setResizable(bool resize = false);
@@ -86,10 +85,9 @@ namespace irr
 		const ASensor* Accelerometer;
 		const ASensor* Gyroscope;
 
-		bool Initialized;
-		bool Stopped;
-		bool Paused;
 		bool Focused;
+		bool Initialized;
+		bool Paused;
 
 		JNIEnv* JNIEnvAttachedToVM;
 
@@ -100,3 +98,4 @@ namespace irr
 
 } // end namespace irr
 
+#endif // _IRR_COMPILE_WITH_ANDROID_DEVICE_