Setup.sh

#!/bin/sh
CurrentDir=$(cd $(dirname $0); pwd)
CurrentSystem=$(uname)
CurrentKernel=$(uname -r)
CheckCmakeExe=$(command -v cmake)
CMakeExe=$(printf "cmake -DCMAKE_BUILD_TYPE=Release")
QuietMode=0
UsingWSL=0
UsingGles2=0
UseWasmOption=1
SkipCMakeConfig=0
SkipOsgBuild=0

# Android related variables
GradleLocalPropFile=$CurrentDir/android/local.properties
GradleSettingsFile=$CurrentDir/android/settings.gradle
AndroidBuildType="Debug"    # Debug or Release: Gradle task and build result paths used by mode 5
AndroidAbi="arm64-v8a"      # passed to Gradle as -Pabi (ABI_FILTER in android/build.gradle)
Sdl2Version="release-2.24.0"  # tag cloned into ../SDL2 when it does not exist yet
AndroidDebugPostfix=""      # OSG appends 'd' to library names in Debug builds
if [ "$AndroidBuildType" = "Debug" ]; then
    AndroidDebugPostfix="d"
fi

MingwSystem=$(echo $CurrentSystem | grep "MINGW")
WslKernel=$(echo $CurrentKernel | grep "Microsoft")
if [ "$WslKernel" != "" ]; then
    echo "Using Windows subsystem for Linux..."
    UsingWSL=1
elif [ "$MingwSystem" != "" ]; then
    # Should install MinGW-CMake first: pacman -S mingw-w64-x86_64-cmake
    echo "Using MinGW system..."
    CMakeExe=$(printf 'cmake -DCYGWIN=ON -DCMAKE_BUILD_TYPE=Release')
fi

# Pre-build Checks
if [ "$CheckCmakeExe" = "" ]; then
    echo "CMake not found. Please run 'apt install cmake'."
    exit 1
fi

if [ ! -d "../OpenSceneGraph" ]; then
    git clone https://gitee.com/mirrors/OpenSceneGraph.git --depth 1 --branch OpenSceneGraph-3.6.5 ../OpenSceneGraph
    if [ ! -d "../OpenSceneGraph" ]; then
        echo "OSG source folder not found. Please download and unzip it in ../OpenSceneGraph."
        exit 1
    fi
fi

# Check for Emscripten/NDK location
QuietModeString="$1"
case "$QuietModeString" in
    "DEFAULT")   BuildMode="0"
                 QuietMode=1 ;;
    "CORE")      BuildMode="1"
                 QuietMode=1 ;;
    "GLES2")     BuildMode="2"
                 UsingGles2=1
                 QuietMode=1 ;;
    "GLES3")     BuildMode="2"
                 UsingGles2=0
                 QuietMode=1 ;;
    "WEBGL1")    BuildMode="3"
                 QuietMode=1 ;;
    "WEBGL2")    BuildMode="4"
                 QuietMode=1 ;;
    "ANDROID")   BuildMode="5"
                 QuietMode=1 ;;
esac

if [ -z "$BuildMode" ]; then
    GLES_LibPath="$1/libGLESv2.so"
    EGL_LibPath="$1/libEGL.so"
    EmsdkToolchain="$1/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
else
    GLES_LibPath="$2/libGLESv2.so"
    EGL_LibPath="$2/libEGL.so"
    EmsdkToolchain="$2/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
fi

# Select how to compile
if [ "$QuietMode" = 0 ]; then
    echo "
    How do you like to compile OSG and osgVerse?
    -----------------------------------
    Please Select:

    0. Desktop / OpenGL Compatible Mode
    1. Desktop / OpenGL Core Mode
    2. Desktop / OpenGL ES
    3. WASM / WebGL 1.0
    4. WASM / WebGL 2.0 (optional with osgEarth)
    5. Android / OpenGLES 3
    q. Quit
    -----------------------------------"
    read -p "Enter selection [0-5] > " BuildMode
fi

case "$BuildMode" in
    1)  echo "OpenGL Core Mode."
        BuildResultChecker=build/sdk_core/bin/osgviewer
        CMakeResultChecker=build/osg_core/CMakeCache.txt
        ;;
    2)  echo "OpenGL ES Mode."
        BuildResultChecker=build/sdk_es/bin/osgviewer
        CMakeResultChecker=build/osg_es/CMakeCache.txt
        ;;
    3)  echo "WebAssembly WebGL 1."
        BuildResultChecker=build/sdk_wasm/lib/libosgViewer.a
        CMakeResultChecker=build/osg_wasm/CMakeCache.txt
        ;;
    4)  echo "WebAssembly WebGL 2."
        BuildResultChecker=build/sdk_wasm2/lib/libosgViewer.a
        CMakeResultChecker=build/osg_wasm2/CMakeCache.txt
        ;;
    5)  echo "Android GLES 3."
        BuildResultChecker=build/osg_android/${AndroidBuildType}/${AndroidAbi}/lib/libosgViewer${AndroidDebugPostfix}.a
        CMakeResultChecker=build/osg_android/CMakeCache.txt
        ;;
    q)  exit 0
        ;;
    *)  echo "OpenGL Compatible Mode."
        BuildResultChecker=build/sdk/bin/osgviewer
        CMakeResultChecker=build/osg_def/CMakeCache.txt
        ;;
esac

if [ "$BuildMode" = '2' ]; then
    # GLES toolchain
    if [ ! -f "$GLES_LibPath" ] || [ ! -f "$EGL_LibPath" ]; then
        echo "libEGL.so or libGLESv2.so not found. Please run as follows: ./Setup.sh <path_of_libEGL>"
        exit 1
    fi
elif [ "$BuildMode" = '3' ] || [ "$BuildMode" = '4' ]; then
    # WASM toolchain
    if [ ! -f "$EmsdkToolchain" ]; then
        echo "Emscripten.cmake not found. Please run as follows: ./Setup.sh <your_path>/emsdk-3.?.?/"
        exit 1
    fi
elif [ "$BuildMode" = '5' ]; then
    # Android toolchain: Gradle 8.5 with AGP 7.4.2 only accepts JDK 11 or 17,
    # so automatically pick a usable one instead of relying on the default java
    AndroidJavaHome=""
    JavaFoundVersions=""
    JavaCandidateList="$JAVA_HOME/bin/java"
    for JavaRootDir in /usr/lib/jvm /usr/java /opt/java /opt/jdk \
                        "$HOME/.sdkman/candidates/java" "$HOME/.jdks" \
                        /Library/Java/JavaVirtualMachines; do
        if [ -d "$JavaRootDir" ]; then
            for JavaSubDir in "$JavaRootDir"/*; do
                for JavaHomeDir in "$JavaSubDir" "$JavaSubDir/Contents/Home"; do
                    if [ -x "$JavaHomeDir/bin/java" ]; then
                        JavaCandidateList="$JavaCandidateList $JavaHomeDir/bin/java"
                    fi
                done
            done
        fi
    done
    JavaCandidateList="$JavaCandidateList $(command -v java)"

    for JavaCandidate in $JavaCandidateList; do
        if [ ! -x "$JavaCandidate" ]; then
            continue
        fi

        JavaVersionInfo=$("$JavaCandidate" -version 2>&1 | head -n 1)
        JavaMajorVersion=$(echo "$JavaVersionInfo" | sed -n 's/.*version "\([0-9][0-9]*\)[.\"].*/\1/p')
        if [ "$JavaMajorVersion" = "1" ]; then
            JavaMajorVersion=$(echo "$JavaVersionInfo" | sed -n 's/.*version "1\.\([0-9][0-9]*\).*/\1/p')
        fi
        JavaFoundVersions="$JavaFoundVersions $JavaMajorVersion"

        if [ "$JavaMajorVersion" = "17" ]; then
            AndroidJavaHome=$(cd "$(dirname "$JavaCandidate")/.." && pwd)
            break
        elif [ "$JavaMajorVersion" = "11" ] && [ "$AndroidJavaHome" = "" ]; then
            # JDK 11 works as well, but keep looking for a preferred JDK 17
            AndroidJavaHome=$(cd "$(dirname "$JavaCandidate")/.." && pwd)
        fi
    done

    if [ "$AndroidJavaHome" = "" ]; then
        echo "No usable JDK found for the Android build. Gradle 8.5 with AGP 7.4.2"
        echo "requires JDK 11 or 17, but only found these versions: $JavaFoundVersions"
        echo "Please install JDK 17 and try again."
        exit 1
    fi

    JAVA_HOME=$AndroidJavaHome
    export JAVA_HOME
    PATH="$JAVA_HOME/bin:$PATH"
    export PATH
    echo "Android toolchain will use JDK: $JAVA_HOME"

    # Fetch SDL2 in the same way as OpenSceneGraph above when it is not there yet.
    # The sources come with both the native library and the Java classes used by
    # the Android application, which therefore always share one version
    if [ ! -d "../SDL2" ]; then
        echo "SDL2 source folder not found. Cloning $Sdl2Version in ../SDL2..."
        git clone --depth 1 --branch $Sdl2Version \
            https://github.com/libsdl-org/SDL.git ../SDL2
        if [ ! -d "../SDL2" ]; then
            echo "SDL2 source folder not found. Please download and unzip it in ../SDL2."
            exit 1
        fi
    fi

    # Migrate the deprecated ndk.dir entry to ndk.path (read by gradle.ext.ndkPath)
    if [ -f "$GradleLocalPropFile" ] && grep -q '^ndk\.dir=' "$GradleLocalPropFile"; then
        sed -i 's/^ndk\.dir=/ndk.path=/' "$GradleLocalPropFile"
        echo "Replaced deprecated ndk.dir with ndk.path in local.properties..."
    fi

    if [ ! -f "$GradleLocalPropFile" ]; then
        if [ ! -n "$ANDROID_SDK" ]; then
            echo "Environment variable ANDROID_SDK not set. Unable to create local.properties."
            exit 1
        fi

        if [ ! -n "$ANDROID_NDK" ]; then
            echo "Environment variable ANDROID_NDK not set. Unable to create local.properties."
            exit 1
        fi

        cat > $GradleLocalPropFile <<EOF
sdk.dir=$ANDROID_SDK
ndk.path=$ANDROID_NDK
EOF

        if [ "$QuietMode" = 0 ]; then
            read -p "Would you like to set a specific SDK version (default: no)? (y/n) " AndroidCheckingFlag
            if [ "$AndroidCheckingFlag" = 'y' ]; then
                read -p "Please set build-tools version (e.g. 32.0.0) > " BuildToolsVersion
                read -p "Please set target SDK version (e.g. 32) > " TargetSdkVersion
                read -p "Please set minimum SDK version (e.g. 21) > " MinimumSdkVersion
                cat > $GradleSettingsFile <<EOF
gradle.ext.buildToolsVersion = '$BuildToolsVersion'
gradle.ext.sdkVersion = $TargetSdkVersion
gradle.ext.minSdkVersion = $MinimumSdkVersion
gradle.ext.targetSdkVersion = $TargetSdkVersion
gradle.ext.libDistributionRoot = '../build'
include ':thirdparty'
include ':sdl2'
include ':osg'
include ':osgverse'
include ':app'
EOF
           fi
        else
            # TODO: auto check and create $GradleSettingsFile?
            echo "Ignore creation of $GradleSettingsFile..."
        fi
    fi
fi

# Check if CMake is already configured, or OSG is already built
if [ -f "$CurrentDir/$BuildResultChecker" ]; then
    if [ "$QuietMode" = 0 ]; then
        read -p "Would you like to use current OSG built (default: yes)? (y/n) > " RebuildFlag
        if [ "$RebuildFlag" = 'n' ]; then
            SkipOsgBuild=0
        else
            SkipOsgBuild=1
        fi
    else
        SkipOsgBuild=1
    fi
fi

if [ "$SkipOsgBuild" = 0 ]; then
    if [ "$BuildMode" = '2' ]; then
        read -p "Would you like to compile GLES2 version (default: GLES3)? (y/n) > " Gles2Flag
        if [ "$Gles2Flag" = 'y' ]; then
            UsingGles2=1
        fi
    fi
fi

echo "*** Building 3rdparty libraries..."
if [ ! -d "$CurrentDir/build" ]; then
    mkdir $CurrentDir/build
fi

# Compile 3rdparty libraries
ThirdPartyBuildDir="$CurrentDir/build/3rdparty"
if [ "$BuildMode" = '3' ] || [ "$BuildMode" = '4' ]; then
    if [ "$QuietMode" = 0 ]; then
        read -p "Would you like to use WASM 64bit (experimental, default: no)? (y/n) > " Wasm64Flag
        if [ "$Wasm64Flag" = 'y' ]; then
            UseWasmOption=2
        fi
    fi

    # WASM toolchain
    ThirdPartyBuildDir="$CurrentDir/build/3rdparty_wasm"
    if [ ! -d "$ThirdPartyBuildDir" ]; then
        mkdir $ThirdPartyBuildDir
    fi

    if [ "$SkipOsgBuild" = 0 ]; then
        cd $ThirdPartyBuildDir
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe -DCMAKE_TOOLCHAIN_FILE="$EmsdkToolchain" -DUSE_WASM_OPTIONS=$UseWasmOption $CurrentDir/helpers/toolchain_builder
        fi
        cmake --build . -j8 || exit 1
    fi

elif [ "$BuildMode" = '5' ]; then

    # Android toolchain
    echo "The compilation will be processed by Gradle..."

else

    # Default toolchain for desktop builds
    if [ ! -d "$ThirdPartyBuildDir" ]; then
        mkdir $ThirdPartyBuildDir
    fi

    if [ "$SkipOsgBuild" = 0 ]; then
        cd $ThirdPartyBuildDir
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe $CurrentDir/helpers/toolchain_builder
        fi
        cmake --build . -j8 || exit 1
    fi

fi

# Generate 3rdparty options
ThirdDepOptions="
    -DFREETYPE_INCLUDE_DIR_freetype2=$CurrentDir/helpers/toolchain_builder/freetype/include
    -DFREETYPE_INCLUDE_DIR_ft2build=$CurrentDir/helpers/toolchain_builder/freetype/include
    -DFREETYPE_LIBRARY_RELEASE=$ThirdPartyBuildDir/freetype/libfreetype.a
    -DJPEG_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/jpeg
    -DJPEG_LIBRARY_RELEASE=$ThirdPartyBuildDir/jpeg/libjpeg.a
    -DPNG_PNG_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/png
    -DPNG_LIBRARY_RELEASE=$ThirdPartyBuildDir/png/libpng.a
    -DZLIB_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/zlib
    -DZLIB_LIBRARY_RELEASE=$ThirdPartyBuildDir/zlib/libzlib.a
    -DVERSE_BUILD_3RDPARTIES=OFF -DCMAKE_POLICY_VERSION_MINIMUM=3.5"
if [ "$BuildMode" = '3' ] || [ "$BuildMode" = '4' ]; then
    if [ -e "$CurrentDir/../Dependencies/wasm/lib/libtiff.a" ]; then
        ThirdDepOptions="
            $ThirdDepOptions
            -DTIFF_INCLUDE_DIR=$CurrentDir/../Dependencies/wasm/include
            -DTIFF_LIBRARY_RELEASE=$CurrentDir/../Dependencies/wasm/lib/libtiff.a"
    fi
else
    if [ -e "$ThirdPartyBuildDir/tiff/libtiff.a" ]; then
        ThirdDepOptions="
            $ThirdDepOptions
            -DTIFF_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/tiff;$ThirdPartyBuildDir/tiff
            -DTIFF_LIBRARY_RELEASE=$ThirdPartyBuildDir/tiff/libtiff.a"
    fi
fi

# Rewrite a source file in place while keeping its original timestamp, so that
# patching and unpatching never look like a source change to CMake/Ninja.
# Otherwise the modified timestamp would force a re-configure (and a recompile
# of every touched file) on the next run, even though the content is unchanged.
PatchFileSafely()
{
    PatchRule="$1"
    PatchPath="$2"
    if [ -f "$PatchPath" ]; then
        sed -i.bak "$PatchRule" "$PatchPath"
        if [ -f "$PatchPath.bak" ]; then
            touch -r "$PatchPath.bak" "$PatchPath"
        fi
    fi
}

# Fix some OpenSceneGraph compile errors
if [ "$SkipOsgBuild" = 0 ]; then
    echo "*** Automatically patching source code..."
    OpenSceneGraphRoot=$CurrentDir/../OpenSceneGraph
    PatchFileSafely 's/std::mem_fun_ref/std::mem_fn/g' "$OpenSceneGraphRoot/src/osgUtil/tristripper/include/detail/graph_array.h"
    PatchFileSafely 's/if defined(__ANDROID__)/if defined(__EMSCRIPTEN__) || defined(__ANDROID__)/g' "$OpenSceneGraphRoot/src/osgDB/FileUtils.cpp"
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(cfg)/#ADD_PLUGIN_DIRECTORY(#cfg)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(obj)/#ADD_PLUGIN_DIRECTORY(#obj)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(ffmpeg)/#ADD_PLUGIN_DIRECTORY(#ffmpeg)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/TIFF_FOUND AND OSG_CPP_EXCEPTIONS_AVAILABLE/TIFF_FOUND/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/ANDROID_3RD_PARTY()/#ANDROID_3RD_PARTY(#)/g' "$OpenSceneGraphRoot/CMakeLists.txt"

    # Fix OpenSceneGraph build warnings and errors
    if [ "$BuildMode" = '3' ] || [ "$BuildMode" = '4' ]; then
        PatchFileSafely 's#dlopen(#NULL;\/\/dlopen\/\/(#g' "$OpenSceneGraphRoot/src/osgDB/DynamicLibrary.cpp"
    else
        PatchFileSafely 's#NULL;\/\/dlopen\/\/(#dlopen(#g' "$OpenSceneGraphRoot/src/osgDB/DynamicLibrary.cpp"
    fi
    PatchFileSafely 's/#ifndef GL_EXT_texture_compression_s3tc/#if !defined(GL_EXT_texture_compression_s3tc) || !defined(GL_EXT_texture_compression_s3tc_srgb)/g' "$OpenSceneGraphRoot/include/osg/Texture"
    PatchFileSafely 's#glTexParameterf(target, GL_TEXTURE_LOD_BIAS, _lodbias)#;\/\/glTexParameterf(target, \/\/GL_TEXTURE_LOD_BIAS, _lodbias)#g' "$OpenSceneGraphRoot/src/osg/Texture.cpp"
    PatchFileSafely 's#case(GL_HALF_FLOAT):#case GL_HALF_FLOAT: case 0x8D61:#g' "$OpenSceneGraphRoot/src/osg/Image.cpp"
    # Fix a static destruction order problem: an osg::GLExtensions object can outlive the static
    # per-context buffers it resets in its destructor. When the last reference is released by a
    # static destructor of another translation unit (the VertexArrayStates kept in ContextData),
    # the buffers may already be destroyed, and ~GLExtensions() then writes into freed memory.
    # This corrupts the heap at process exit: the crash surfaces in _dl_fini afterwards, e.g. a
    # SIGSEGV in the Moore Threads driver's teardown when the bloom / eye-adaptation stages are
    # enabled. Leaking a few kilobytes once removes the dependency on the destruction order.
    PatchFileSafely 's#static osg::buffered_object<ExtensionSet> s_glExtensionSetList;#static osg::buffered_object<ExtensionSet>\& s_glExtensionSetList = *new osg::buffered_object<ExtensionSet>;#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
    PatchFileSafely 's#static osg::buffered_object<std::string> s_glRendererList;#static osg::buffered_object<std::string>\& s_glRendererList = *new osg::buffered_object<std::string>;#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
    PatchFileSafely 's#static osg::buffered_value<int> s_glInitializedList;#static osg::buffered_value<int>\& s_glInitializedList = *new osg::buffered_value<int>;#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
    PatchFileSafely 's#static BufferedExtensions s_extensions;#static BufferedExtensions\& s_extensions = *new BufferedExtensions;#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
    if [ "$BuildMode" = '3' ] || [ "$BuildMode" = '4' ]; then
        PatchFileSafely 's#isTexture2DArraySupported = validContext#isTexture2DArraySupported = isTexture3DSupported;\/\/validContext#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
    fi
fi

# Compile OpenSceneGraph
echo "*** Building OpenSceneGraph..."
if [ "$BuildMode" = '1' ]; then

    # OpenGL Core
    if [ ! -d "$CurrentDir/build/osg_core" ]; then
        mkdir $CurrentDir/build/osg_core
    fi

    ExtraOptions="
        -DCMAKE_INSTALL_RPATH=$CurrentDir/build/sdk_core/lib
        -DGLCORE_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/opengl
        -DOPENGL_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/opengl
        -DCMAKE_INSTALL_PREFIX=$CurrentDir/build/sdk_core
        -DOPENGL_PROFILE=GLCORE"
    if [ "$SkipOsgBuild" = 0 ]; then
        cd $CurrentDir/build/osg_core
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe $ThirdDepOptions $ExtraOptions $OpenSceneGraphRoot
        fi
        cmake --build . -j8 --target install --config Release || exit 1
    fi

elif [ "$BuildMode" = '2' ]; then

    # OpenGL ES
    if [ ! -d "$CurrentDir/build/osg_es" ]; then
        mkdir $CurrentDir/build/osg_es
    fi

    ExtraOptions="
        -DCMAKE_INSTALL_RPATH=$CurrentDir/build/sdk_es/lib
        -DOPENGL_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/opengl
        -DCMAKE_INSTALL_PREFIX=$CurrentDir/build/sdk_es
        -DEGL_LIBRARY=$EGL_LibPath -DOPENGL_gl_LIBRARY=$GLES_LibPath
        -DOSG_WINDOWING_SYSTEM=None"
    if [ "$SkipOsgBuild" = 0 ]; then
        cd $CurrentDir/build/osg_es
        if [ "$SkipCMakeConfig" = 0 ]; then
            if [ "$UsingGles2" = 0 ]; then
                $CMakeExe $ThirdDepOptions $ExtraOptions -DOPENGL_PROFILE=GLES3 $OpenSceneGraphRoot
            else
                $CMakeExe $ThirdDepOptions $ExtraOptions -DOPENGL_PROFILE=GLES2 $OpenSceneGraphRoot
            fi
        fi
        cmake --build . -j8 --target install --config Release || exit 1
    fi

elif [ "$BuildMode" = '3' ]; then

    # WASM toolchain (WebGL 1)
    if [ ! -d "$CurrentDir/build/osg_wasm" ]; then
        mkdir $CurrentDir/build/osg_wasm
    fi

    ExtraOptions="
        -DCMAKE_TOOLCHAIN_FILE="$EmsdkToolchain"
        -DCMAKE_INCLUDE_PATH=$CurrentDir/helpers/toolchain_builder/opengl
        -DCMAKE_INSTALL_PREFIX=$CurrentDir/build/sdk_wasm
        -DUSE_WASM_OPTIONS=$UseWasmOption
        -DOSG_SOURCE_DIR=$OpenSceneGraphRoot
        -DOSG_BUILD_DIR=$CurrentDir/build/osg_wasm/osg"
    if [ "$SkipOsgBuild" = 0 ]; then
        cd $CurrentDir/build/osg_wasm
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe $ThirdDepOptions $ExtraOptions $CurrentDir/helpers/osg_builder/wasm
        fi
        cmake --build . -j8 --target install --config Release || exit 1
    fi

elif [ "$BuildMode" = '4' ]; then

    # WASM toolchain (WebGL 2)
    if [ ! -d "$CurrentDir/build/osg_wasm2" ]; then
        mkdir $CurrentDir/build/osg_wasm2
    fi

    ExtraOptions="
        -DCMAKE_TOOLCHAIN_FILE="$EmsdkToolchain"
        -DCMAKE_INCLUDE_PATH=$CurrentDir/helpers/toolchain_builder/opengl
        -DCMAKE_INSTALL_PREFIX=$CurrentDir/build/sdk_wasm2
        -DUSE_WASM_OPTIONS=$UseWasmOption
        -DOSG_SOURCE_DIR=$OpenSceneGraphRoot
        -DOSG_BUILD_DIR=$CurrentDir/build/osg_wasm2/osg"
    if [ "$SkipOsgBuild" = 0 ]; then
        cd $CurrentDir/build/osg_wasm2
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe $ThirdDepOptions $ExtraOptions $CurrentDir/helpers/osg_builder/wasm2
        fi
        cmake --build . -j8 --target install --config Release || exit 1
    fi

elif [ "$BuildMode" = '5' ]; then

    # Android toolchain
    echo "The compilation will be processed by Gradle..."

else

    # OpenGL default
    if [ ! -d "$CurrentDir/build/osg_def" ]; then
        mkdir $CurrentDir/build/osg_def
    fi

    ExtraOptions="
        -DCMAKE_INSTALL_RPATH=$CurrentDir/build/sdk/lib
        -DCMAKE_INSTALL_PREFIX=$CurrentDir/build/sdk"
    if [ "$SkipOsgBuild" = 0 ]; then
        cd $CurrentDir/build/osg_def
        if [ "$SkipCMakeConfig" = 0 ]; then
            $CMakeExe $ThirdDepOptions $ExtraOptions $OpenSceneGraphRoot
        fi
        cmake --build . -j8 --target install --config Release || exit 1
    fi

fi

# Build osgEarth (Optional)
WithOsgEarth=0
if [ "$BuildMode" = '4' ]; then

    if [ -d "$CurrentDir/../osgearth-wasm" ]; then

        # WASM toolchain (WebGL 2)
        if [ ! -d "$CurrentDir/build/osgearth_wasm2" ]; then
            mkdir $CurrentDir/build/osgearth_wasm2
        fi

        echo "*** Building osgEarth 2.10..."
        ExtraOptions2="
            -DOSG_DIR=$CurrentDir/build/sdk_wasm2
            -DTHIRDPARTY_ROOT=$CurrentDir/../Dependencies/wasm
            -DUSE_WASM_OPTIONS=$UseWasmOption
            -DOSGEARTH_SOURCE_DIR=$CurrentDir/../osgearth-wasm
            -DOSGEARTH_BUILD_DIR=$CurrentDir/build/osgearth_wasm2/osgearth"
        cd $CurrentDir/build/osgearth_wasm2
        $CMakeExe $ExtraOptions $ExtraOptions2 $CurrentDir/helpers/osg_builder/wasm2_oe
        make install || exit 1
        WithOsgEarth=1

    else
        echo "osgEarth-WASM not found. Please download it and unzip in ../osgearth-wasm if you wish."
    fi

fi

# Build osgVerse
echo "*** Building osgVerse..."
if [ "$BuildMode" = '3' ]; then

    # WASM toolchain (WebGL 1)
    if [ ! -d "$CurrentDir/build/verse_wasm" ]; then
        mkdir $CurrentDir/build/verse_wasm
    fi

    OsgRootLocation="$CurrentDir/build/sdk_wasm"
    cd $CurrentDir/build/verse_wasm
    $CMakeExe -DUSE_WASM_OPTIONS=$UseWasmOption -DOSG_ROOT="$OsgRootLocation" $ThirdDepOptions $ExtraOptions $CurrentDir
    cmake --build . -j8 --target install --config Release || exit 1

elif [ "$BuildMode" = '4' ]; then

    # WASM toolchain (WebGL 2)
    if [ ! -d "$CurrentDir/build/verse_wasm2" ]; then
        mkdir $CurrentDir/build/verse_wasm2
    fi

    OsgRootLocation="$CurrentDir/build/sdk_wasm2"
    cd $CurrentDir/build/verse_wasm2
    $CMakeExe -DUSE_WASM_OPTIONS=$UseWasmOption -DUSE_WASM_OSGEARTH=$WithOsgEarth -DOSG_ROOT="$OsgRootLocation" $ThirdDepOptions $ExtraOptions $CurrentDir
    cmake --build . -j8 --target install --config Release || exit 1

elif [ "$BuildMode" = '5' ]; then

    # Android toolchain
    cd $CurrentDir/android
    ./gradlew assemble${AndroidBuildType} -Pabi=$AndroidAbi || exit 1
    # adb install -r android/app/build/outputs/apk/debug/app-debug.apk
    # adb logcat -s osgVerse SDL

else

    # Default toolchain
    if [ "$BuildMode" = '1' ]; then
        ExtraOptions2="-DOPENGL_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/opengl"
        OsgRootLocation="$CurrentDir/build/sdk_core"
        if [ ! -d "$CurrentDir/build/verse_core" ]; then
            mkdir $CurrentDir/build/verse_core
        fi
        cd $CurrentDir/build/verse_core
    elif [ "$BuildMode" = '2' ]; then
        ExtraOptions2="-DOPENGL_INCLUDE_DIR=$CurrentDir/helpers/toolchain_builder/opengl
                       -DOSG_EGL_LIBRARY=$EGL_LibPath -DOSG_GLES_LIBRARY=$GLES_LibPath"
        OsgRootLocation="$CurrentDir/build/sdk_es"
        if [ ! -d "$CurrentDir/build/verse_es" ]; then
            mkdir $CurrentDir/build/verse_es
        fi
        cd $CurrentDir/build/verse_es
    else
        ExtraOptions2=""
        OsgRootLocation="$CurrentDir/build/sdk"
        if [ ! -d "$CurrentDir/build/verse_def" ]; then
            mkdir $CurrentDir/build/verse_def
        fi
        cd $CurrentDir/build/verse_def
    fi
    $CMakeExe -DOSG_ROOT="$OsgRootLocation" $ThirdDepOptions $ExtraOptions $ExtraOptions2 $CurrentDir
    cmake --build . -j8 --target install --config Release || exit 1

fi

# Reset some OpenSceneGraph source code
if [ "$SkipOsgBuild" = 0 ]; then
    echo "*** Automatically unpatching source code..."
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(#cfg)/#ADD_PLUGIN_DIRECTORY(cfg)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(#obj)/#ADD_PLUGIN_DIRECTORY(obj)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/ADD_PLUGIN_DIRECTORY(#ffmpeg)/#ADD_PLUGIN_DIRECTORY(ffmpeg)/g' "$OpenSceneGraphRoot/src/osgPlugins/CMakeLists.txt"
    PatchFileSafely 's/#ANDROID_3RD_PARTY(#)/ANDROID_3RD_PARTY()/g' "$OpenSceneGraphRoot/CMakeLists.txt"
    PatchFileSafely 's#NULL;\/\/dlopen\/\/(#dlopen(#g' "$OpenSceneGraphRoot/src/osgDB/DynamicLibrary.cpp"
    PatchFileSafely 's#;\/\/glTexParameterf(target, \/\/GL_TEXTURE_LOD_BIAS, _lodbias)#glTexParameterf(target, GL_TEXTURE_LOD_BIAS, _lodbias)#g' "$OpenSceneGraphRoot/src/osg/Texture.cpp"
    PatchFileSafely 's#isTexture2DArraySupported = isTexture3DSupported;\/\/validContext#isTexture2DArraySupported = validContext#g' "$OpenSceneGraphRoot/src/osg/GLExtensions.cpp"
fi