Changes:

+ Adds the ability to determine whether hands and crosshairs disappear or not. This can be changed in the mod configuration.
* Reduces the chance of the mod crashing the game for ordinary events (any errors will be reported to the console, though).
Bug Fixes
* Fixes crash when mounting boat or minecart (#1 thanks, @theFuzzyWarble!)

.gitattributes

@@ -0,0 +1,5 @@
+# Disable autocrlf on generated files, they always generate with LF
+# Add any extra files or paths here to make git stop saying they
+# are changed when only line endings change.
+src/generated/**/.cache/cache text eol=lf
+src/generated/**/*.json text eol=lf

build.gradle

@@ -0,0 +1,165 @@
+buildscript {
+    repositories {
+        maven { url = 'https://files.minecraftforge.net/maven' }
+        jcenter()
+        mavenCentral()
+    }
+    dependencies {
+        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
+    }
+}
+apply plugin: 'net.minecraftforge.gradle'
+// Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
+apply plugin: 'eclipse'
+apply plugin: 'maven-publish'
+
+repositories {
+    maven { url "https://maven.shedaniel.me/" }
+}
+
+archivesBaseName = project.archives_base_name
+version = project.mod_version + "-" + project.minecraft_version + "-forge"
+group = project.maven_group // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
+
+println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
+minecraft {
+    // The mappings can be changed at any time, and must be in the following format.
+    // snapshot_YYYYMMDD   Snapshot are built nightly.
+    // stable_#            Stables are built at the discretion of the MCP team.
+    // Use non-default mappings at your own risk. they may not always work.
+    // Simply re-run your setup task after changing the mappings to update your workspace.
+    mappings channel: 'snapshot', version: project.mappings
+    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
+    
+    // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+
+    // Default run configurations.
+    // These can be tweaked, removed, or duplicated as needed.
+    runs {
+        client {
+            workingDirectory project.file('run')
+
+            // Recommended logging data for a userdev environment
+            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
+
+            // Recommended logging level for the console
+            property 'forge.logging.console.level', 'debug'
+
+            mods {
+                examplemod {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        server {
+            workingDirectory project.file('run')
+
+            // Recommended logging data for a userdev environment
+            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
+
+            // Recommended logging level for the console
+            property 'forge.logging.console.level', 'debug'
+
+            mods {
+                examplemod {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        data {
+            workingDirectory project.file('run')
+
+            // Recommended logging data for a userdev environment
+            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
+
+            // Recommended logging level for the console
+            property 'forge.logging.console.level', 'debug'
+
+            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
+            args '--mod', 'examplemod', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+
+            mods {
+                examplemod {
+                    source sourceSets.main
+                }
+            }
+        }
+    }
+}
+
+// Include resources generated by data generators.
+sourceSets.main.resources { srcDir 'src/generated/resources' }
+
+dependencies {
+    // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
+    // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
+    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
+    minecraft "net.minecraftforge:forge:${project.minecraft_version}-${project.forge_version}"
+
+//    compile(fg.deobf("me.shedaniel.cloth:cloth-config-forge:${project.cloth_version}"))
+    // You may put jars on which you depend on in ./libs or you may define them like so..
+    // compile "some.group:artifact:version:classifier"
+    // compile "some.group:artifact:version"
+
+    // Real examples
+    // compile 'com.mod-buildcraft:buildcraft:6.0.8:dev'  // adds buildcraft to the dev env
+    // compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env
+
+    // The 'provided' configuration is for optional dependencies that exist at compile-time but might not at runtime.
+    // provided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+
+    // These dependencies get remapped to your current MCP mappings
+    // deobf 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+
+    // For more info...
+    // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
+    // http://www.gradle.org/docs/current/userguide/dependency_management.html
+
+}
+
+task sourcesJar(type: Jar, dependsOn: classes) {
+    classifier = 'sources'
+    from sourceSets.main.allSource
+}
+
+artifacts {
+    archives sourcesJar
+}
+
+// Example for how to get properties into the manifest for reading by the runtime..
+jar {
+    manifest {
+        attributes([
+            "Specification-Title": project.archivesBaseName,
+            "Specification-Vendor": "Markil 3",
+            "Specification-Version": project.version,
+            "Implementation-Title": project.name,
+            "Implementation-Version": "${version}",
+            "Implementation-Vendor" :"Markil 3",
+            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
+        ])
+    }
+}
+
+// Example configuration to allow publishing using the maven-publish task
+// This is the preferred method to reobfuscate your jar file
+jar.finalizedBy('reobfJar') 
+// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
+//publish.dependsOn('reobfJar')
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            artifact jar
+        }
+    }
+    repositories {
+        maven {
+            url "file:///${project.projectDir}/mcmodsrepo"
+        }
+    }
+}

gradle.properties

@@ -0,0 +1,15 @@
+# Sets default memory used for gradle commands. Can be overridden by user or command line properties.
+# This is required to provide enough memory for the Minecraft decompilation process.
+org.gradle.jvmargs=-Xmx3G
+org.gradle.daemon=false
+
+# Forge Properties
+minecraft_version=1.14.2
+mappings=20190621-1.14.2
+forge_version=26.0.63
+
+
+# Mod Properties
+mod_version = 1.1
+maven_group = markil3
+archives_base_name = immersive_hud

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip

gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

src/main/java/markil3/immersive_hud/ConfigManager.java

@@ -0,0 +1,435 @@
+package markil3.immersive_hud;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.electronwill.nightconfig.core.io.WritingMode;
+
+import net.minecraft.util.math.MathHelper;
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.fml.common.Mod;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static markil3.immersive_hud.Main.TICKS_PER_SECOND;
+
+/**
+ * Configuration manager of this mod, which reads from and writes to this mod's
+ * configuration file.
+ * <p>
+ * The methods that change this mod's configuration do not automatically write
+ * those changes to the configuration file on disk. Instead, they only update
+ * the configuration in memory.
+ *
+ * @author Markil 3
+ */
+public class ConfigManager
+{
+    /**
+     * The only instance of this class
+     */
+    private static final ConfigManager INSTANCE;
+
+    /**
+     * The {@link ForgeConfigSpec} instance for this mod's configuration
+     */
+    private static final ForgeConfigSpec SPEC;
+
+    /**
+     * {@link Path} to the configuration file of this mod
+     */
+    private static final Path CONFIG_PATH =
+            Paths.get("config",
+                    Main.class.getAnnotation(Mod.class).value() + ".toml");
+
+    static
+    {
+        Pair<ConfigManager, ForgeConfigSpec> specPair =
+                new ForgeConfigSpec.Builder().configure(ConfigManager::new);
+        INSTANCE = specPair.getLeft();
+        SPEC = specPair.getRight();
+        CommentedFileConfig config = CommentedFileConfig.builder(CONFIG_PATH)
+                .sync()
+                .autoreload()
+                .writingMode(WritingMode.REPLACE)
+                .build();
+        config.load();
+        config.save();
+        SPEC.setConfig(config);
+    }
+
+    public static class TimeValues
+    {
+        private static final int SHOW_TIME = 6 * TICKS_PER_SECOND;
+        private static final int FADE_IN = TICKS_PER_SECOND / 4;
+        private static final int FADE_OUT = TICKS_PER_SECOND / 2;
+
+        private final String name;
+        private final ForgeConfigSpec.IntValue maxTime;
+        private final ForgeConfigSpec.IntValue fadeIn;
+        private final ForgeConfigSpec.IntValue fadeOut;
+
+        TimeValues(String name, ForgeConfigSpec.Builder configSpecBuilder)
+        {
+            final int MAX_TIME = 10 * 60 * TICKS_PER_SECOND;
+
+            this.name = name;
+            this.maxTime =
+                    configSpecBuilder.translation("immersive_hud.configGui." + name + "Time.title")
+                            .defineInRange(name + "Time.maxTime",
+                                    SHOW_TIME,
+                                    0,
+                                    MAX_TIME);
+            this.fadeIn =
+                    configSpecBuilder.translation("immersive_hud.configGui." + name + "FadeIn.title")
+                            .defineInRange(name + "Time.fadeIn",
+                                    FADE_IN,
+                                    0,
+                                    MAX_TIME);
+            this.fadeOut =
+                    configSpecBuilder.translation("immersive_hud.configGui." + name + "FadeOut.title")
+                            .defineInRange(name + "Time.fadeOut",
+                                    FADE_OUT,
+                                    0,
+                                    MAX_TIME);
+        }
+
+        public String getName()
+        {
+            return this.name;
+        }
+
+        /**
+         * Obtains the maximum time that the hotbar can be on the screen,
+         * including fading.
+         *
+         * @return The maximum hotbar display time.
+         */
+        public int getMaxTime()
+        {
+            return this.maxTime.get();
+        }
+
+        /**
+         * Obtains the time that the hotbar takes to fade in.
+         *
+         * @return The hotbar fade in time.
+         */
+        public int getFadeInTime()
+        {
+            return this.fadeIn.get();
+        }
+
+        /**
+         * Obtains the time that the hotbar takes to fade out.
+         *
+         * @return The hotbar fade out time.
+         */
+        public int getFadeOutTime()
+        {
+            return this.fadeOut.get();
+        }
+
+//        public void setMaxTime(int time)
+//        {
+//            this.maxTime.set(time);
+//        }
+//
+//        public void setFadeInTime(int time)
+//        {
+//            this.fadeIn.set(time);
+//        }
+//
+//        public void setFadeOutTime(int time)
+//        {
+//            this.fadeOut.set(time);
+//        }
+    }
+
+    private final TimeValues hotbarTime;
+    private final TimeValues experienceTime;
+    private final TimeValues jumpTime;
+    private final TimeValues healthTime;
+    private final TimeValues hungerTime;
+    private final TimeValues effectTime;
+    private final ForgeConfigSpec.IntValue crosshairTime;
+    private final ForgeConfigSpec.BooleanValue hideCrosshair;
+    private final ForgeConfigSpec.IntValue handTime;
+    private final ForgeConfigSpec.BooleanValue hideHands;
+    private final ForgeConfigSpec.BooleanValue showArmor;
+    private final ForgeConfigSpec.DoubleValue minHealth;
+    private final ForgeConfigSpec.IntValue minHunger;
+
+    /**
+     * Implementation of Singleton design pattern, which allows only one
+     * instance of this class to be created.
+     */
+    private ConfigManager(ForgeConfigSpec.Builder configSpecBuilder)
+    {
+        // Comments are not added because there was no way to translate
+        // descriptions from translate keys here
+
+        this.hotbarTime = new TimeValues("hotbar", configSpecBuilder);
+        this.experienceTime = new TimeValues("experience", configSpecBuilder);
+        this.jumpTime = new TimeValues("jump", configSpecBuilder);
+        this.healthTime = new TimeValues("health", configSpecBuilder);
+        this.hungerTime = new TimeValues("hunger", configSpecBuilder);
+        this.effectTime = new TimeValues("effect", configSpecBuilder);
+        this.crosshairTime =
+                configSpecBuilder.translation(
+                        "immersive_hud.configGui.crosshairTime.title")
+                        .defineInRange("crosshairTime",
+                                6 * TICKS_PER_SECOND,
+                                0,
+                                10 * 60 * TICKS_PER_SECOND);
+        this.hideCrosshair =
+                configSpecBuilder.translation(
+                        "immersive_hud.configGui.hideCrosshair.title")
+                        .define("hideCrosshair", true);
+        this.handTime =
+                configSpecBuilder.translation(
+                        "immersive_hud.configGui.handTime.title")
+                        .defineInRange("handTime",
+                                30 * TICKS_PER_SECOND,
+                                0,
+                                10 * 60 * TICKS_PER_SECOND);
+        this.hideHands =
+                configSpecBuilder.translation(
+                        "immersive_hud.configGui.hideHands.title")
+                        .define("hideHands", true);
+        this.showArmor = configSpecBuilder.translation(
+                "immersive_hud.configGui.showArmor.title")
+                .define("showArmor", true);
+        this.minHealth = configSpecBuilder.translation(
+                "immersive_hud.configGui.minHealth.title")
+                .defineInRange("minHealth", 0.5, 0.0, 1.0);
+        this.minHunger = configSpecBuilder.translation(
+                "immersive_hud.configGui.minHunger.title")
+                .defineInRange("minHunger", 17, 0, 20);
+    }
+
+    /**
+     * Returns the instance of this class.
+     *
+     * @return the instance of this class
+     */
+    public static ConfigManager getInstance()
+    {
+        return INSTANCE;
+    }
+
+    // Validations
+
+    /**
+     * Obtains time values related to the hotbar.
+     *
+     * @return The hotbar display time values.
+     */
+    public TimeValues getHotbarTime()
+    {
+        return this.hotbarTime;
+    }
+
+    /**
+     * Obtains time values related to the experience bar.
+     *
+     * @return The experience bar display time values.
+     */
+    public TimeValues getExperenceTime()
+    {
+        return this.experienceTime;
+    }
+
+    /**
+     * Obtains time values related to the jump bar.
+     *
+     * @return The jump display time values.
+     */
+    public TimeValues getJumpTime()
+    {
+        return this.jumpTime;
+    }
+
+    /**
+     * Obtains time values related to the health bar.
+     *
+     * @return The health display time values.
+     */
+    public TimeValues getHealthTime()
+    {
+        return this.healthTime;
+    }
+
+    /**
+     * Obtains time values related to the hunger bar.
+     *
+     * @return The hunger display time values.
+     */
+    public TimeValues getHungerTime()
+    {
+        return this.hungerTime;
+    }
+
+    /**
+     * Obtains time values related to potion effects.
+     *
+     * @return Potion display time values.
+     */
+    public TimeValues getPotionTime()
+    {
+        return this.effectTime;
+    }
+
+    /**
+     * Obtains the time that the crosshairs are allowed to display.
+     *
+     * @return The crosshair display time values.
+     */
+    public int getCrosshairTime()
+    {
+        return this.crosshairTime.get();
+    }
+
+    /**
+     * Checks whether the crosshairs should be hidden after a period of time.
+     *
+     * @return - Whether or not crosshairs will be hidden.
+     */
+    public boolean hideCrosshair()
+    {
+        return this.hideCrosshair.get();
+    }
+
+    /**
+     * Obtains the time that the hands are allowed to display.
+     *
+     * @return The hand display time values.
+     */
+    public int getHandTime()
+    {
+        return this.handTime.get();
+    }
+
+    /**
+     * Checks whether hands should be hidden after a period of time.
+     *
+     * @return - Whether or not hands will be hidden.
+     */
+    public boolean hideHands()
+    {
+        return this.hideHands.get();
+    }
+
+    /**
+     * Checks whether the armor bar should render.
+     *
+     * @return Whether or not armor shows on the HUD.
+     */
+    public boolean shouldShowArmor()
+    {
+        return this.showArmor.get();
+    }
+
+    /**
+     * Obtains the minimum health for fading. Anything below that and the health
+     * always displays.
+     *
+     * @return The health boundary, from 0 to 1.
+     */
+    public double getMinHealth()
+    {
+        return this.minHealth.get();
+    }
+
+    /**
+     * Obtains the minimum hunger for fading. Anything below that and the hunger
+     * always displays.
+     *
+     * @return The hunger boundary, from 0 to 20.
+     */
+    public int getMinHunger()
+    {
+        return this.minHunger.get();
+    }
+
+//    /**
+//     * Sets the time that the hands are allowed to display.
+//     *
+//     * @param time - The hand display time values.
+//     */
+//    public void setCrosshairTime(int time)
+//    {
+//        this.crosshairTime.set(time);
+//    }
+//
+//    /**
+//     * Sets whether the crosshairs should be hidden after a period of time.
+//     *
+//     * @param hide - Whether or not crosshairs will be hidden.
+//     */
+//    public void hideCrosshair(boolean hide)
+//    {
+//        this.hideCrosshair.set(hide);
+//    }
+//
+//    /**
+//     * Sets the time that the hands are allowed to display.
+//     *
+//     * @param time - The hand display time values.
+//     */
+//    public void setHandTime(int time)
+//    {
+//        this.handTime.set(time);
+//    }
+//
+//    /**
+//     * Sets whether hands should be hidden after a period of time.
+//     *
+//     * @param hide - Whether or not hands will be hidden.
+//     */
+//    public void hideHands(boolean hide)
+//    {
+//        this.hideHands.set(hide);
+//    }
+//
+//    /**
+//     * Determines whether the armor bar should render.
+//     *
+//     * @param show - Whether or not armor shows on the HUD.
+//     */
+//    public void shouldShowArmor(boolean show)
+//    {
+//        this.showArmor.set(show);
+//    }
+//
+//    /**
+//     * Sets the minimum health for fading. Anything below that and the health
+//     * always displays.
+//     *
+//     * @param boundary - The health boundary, from 0 to 1.
+//     */
+//    public void setMinHealth(double boundary)
+//    {
+//        this.minHealth.set(MathHelper.clamp(boundary, 0, 1));
+//    }
+//
+//    /**
+//     * Sets the minimum hunger for fading. Anything below that and the hunger
+//     * always displays.
+//     *
+//     * @param boundary - The hunger boundary, from 0 to 20.
+//     */
+//    public void setMinHunger(int boundary)
+//    {
+//        this.minHunger.set(MathHelper.clamp(boundary, 0, 20));
+//    }
+
+    /**
+     * Saves changes to this mod's configuration.
+     */
+//    public void save()
+//    {
+//        SPEC.save();
+//    }
+}

src/main/java/markil3/immersive_hud/EventBus.java

@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2021 Markil 3
+ * <p>
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ * <p>
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package markil3.immersive_hud;
+
+import com.mojang.blaze3d.platform.GlStateManager;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.client.event.RenderSpecificHandEvent;
+import net.minecraftforge.event.entity.EntityMountEvent;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.fml.common.Mod;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+import static markil3.immersive_hud.TimerUtils.resetAlpha;
+
+/**
+ * Contains the logic for changing the HUD.
+ *
+ * @author Markil 3
+ * @version 0.1-1.16.4-forge
+ */
+@Mod.EventBusSubscriber(Dist.CLIENT)
+public class EventBus
+{
+    /**
+     * Class logger
+     */
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    /**
+     * Run whenever the player clicks a mouse button. This brings the hands into
+     * view, and briefly brings the health and hunger into view if the held item
+     * is food.
+     *
+     * @param event - event data
+     */
+    @SubscribeEvent
+    public static void onClick(final PlayerInteractEvent event)
+    {
+        try
+        {
+            DistExecutor.runWhenOn(Dist.CLIENT, () -> () ->
+            {
+                Item item =
+                        Optional.ofNullable(event.getItemStack())
+                                .map(ItemStack::getItem)
+                                .orElse(null);
+                TimerUtils.onClick(event.getHand(), item);
+            });
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running markil3.immersive_hud.EventBus#onClick " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Run whenever the player mounts something. This brings the mount's health
+     * bar into view.
+     * <p>
+     * While this event is called on both client and server, only on the client
+     * will anything happen.
+     *
+     * @param event - event data
+     */
+    @SubscribeEvent
+    public static void onMount(final EntityMountEvent event)
+    {
+        try
+        {
+            DistExecutor.runWhenOn(Dist.CLIENT, () -> () ->
+            {
+                TimerUtils.resetMountHealth();
+            });
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running markil3.immersive_hud.EventBus#onMount " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Run whenever a hand is rendered in 1st person. This brings the player
+     * hands into and out of view as needed.
+     *
+     * @param event - event data
+     */
+    @SubscribeEvent
+    public static void onRenderHand(final RenderSpecificHandEvent event)
+    {
+        try
+        {
+            if (TimerUtils.onRenderHand(event.getHand(),
+                    event.getPartialTicks()))
+            {
+                event.setCanceled(true);
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running markil3.immersive_hud" +
+                            ".EventBus#onRenderHand event",
+                    e);
+        }
+    }
+
+    /**
+     * Called whenever we are drawing a part of the GUI. This is where most of
+     * the change checks are made and adjustments or overrides are done.
+     *
+     * @param event - event data
+     */
+    @SubscribeEvent
+    public static void onGUIDraw(final RenderGameOverlayEvent event)
+    {
+        try
+        {
+            Minecraft mc = Minecraft.getInstance();
+            boolean fadeIn = false;
+
+            switch (event.getType())
+            {
+            case CROSSHAIRS:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawCrosshair(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                /*
+                 * Reset the transparency.
+                 */
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    resetAlpha();
+                }
+                break;
+            case POTION_ICONS:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    TimerUtils.updatePotions(mc.player);
+                    event.setCanceled(true);
+                    RenderUtils.renderPotionIcons(mc,
+                            mc.ingameGUI, event.getPartialTicks());
+                    resetAlpha();
+                }
+                break;
+            case HOTBAR:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    event.setCanceled(true);
+                    if (!TimerUtils.drawHotbar(event.getPartialTicks()))
+                    {
+                        RenderUtils.renderHotbar(mc, mc.ingameGUI,
+                                event.getPartialTicks(), TimerUtils.hotbarTime);
+                    }
+                }
+                break;
+            case HEALTH:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawHealth(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    GlStateManager.popMatrix();
+                    resetAlpha();
+                }
+                break;
+            case FOOD:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawHunger(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                /*
+                 * Reset the transparency.
+                 */
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    GlStateManager.popMatrix();
+                    resetAlpha();
+                }
+                break;
+            case ARMOR:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawArmor(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                /*
+                 * Reset the transparency.
+                 */
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    GlStateManager.popMatrix();
+                    resetAlpha();
+                }
+                break;
+            case AIR:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawAir(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                /*
+                 * Reset the transparency.
+                 */
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    GlStateManager.popMatrix();
+                    resetAlpha();
+                }
+                break;
+            case HEALTHMOUNT:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    if (TimerUtils.drawMountHealth(event.getPartialTicks()))
+                    {
+                        event.setCanceled(true);
+                    }
+                }
+                else if (event instanceof RenderGameOverlayEvent.Post)
+                {
+                    GlStateManager.popMatrix();
+                    resetAlpha();
+                }
+                break;
+            case JUMPBAR:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    event.setCanceled(true);
+                    if (!TimerUtils.drawJumpbar(event.getPartialTicks()))
+                    {
+                        RenderUtils.renderHorseJumpBar(mc,
+                                mc.ingameGUI,
+                                event.getPartialTicks(),
+                                TimerUtils.jumpTime);
+                    }
+                }
+                break;
+            case EXPERIENCE:
+                if (event instanceof RenderGameOverlayEvent.Pre)
+                {
+                    event.setCanceled(true);
+                    if (!TimerUtils.drawExperience(event.getPartialTicks()))
+                    {
+                        RenderUtils.renderExperience(mc,
+                                mc.ingameGUI,
+                                event.getPartialTicks(),
+                                TimerUtils.experienceTime);
+                    }
+                }
+                break;
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running markil3.immersive_hud.EventBus#onGUIDraw event",
+                    e);
+        }
+    }
+}

src/main/java/markil3/immersive_hud/Main.java

@@ -0,0 +1,100 @@
+/**
+ * This Minecraft mod aims to move the ingame HUD out of the way whenever
+ * possible. Copyright (C) 2021 Markil 3
+ * <p>
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ * <p>
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package markil3.immersive_hud;
+
+import net.minecraftforge.fml.ExtensionPoint;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.fml.network.FMLNetworkConstants;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * The main entry point for the Immersive HUD mod.
+ *
+ * @author Markil 3
+ * @version 0.1-1.16.4-forge
+ */
+@Mod("immersive_hud")
+public class Main
+{
+    /**
+     * Class logger.
+     */
+    private static final Logger LOGGER = LogManager.getLogger();
+    public static final int TICKS_PER_SECOND = 20;
+
+    public Main()
+    {
+        FMLJavaModLoadingContext.get()
+                .getModEventBus()
+                .addListener(this::setup);
+
+        try
+        {
+            if (Class.forName("me.shedaniel.clothconfig2.api.ConfigBuilder") != null)
+            {
+//                ModMenu.setupScreen();
+            }
+        }
+        catch (ClassNotFoundException e)
+        {
+            // Do nothing
+        }
+        //Make sure the mod being absent on the other network side does not
+        // cause the client to display the server as incompatible
+        ModLoadingContext.get()
+                .registerExtensionPoint(ExtensionPoint.DISPLAYTEST, () -> Pair
+                        .of(() -> FMLNetworkConstants.IGNORESERVERONLY,
+                                (a, b) -> true));
+    }
+
+    private void setup(final FMLClientSetupEvent event)
+    {
+    }
+
+    /**
+     * A utility method to handle the transparency timing. It will (for the most
+     * part), make
+     *
+     * @param renderTime - How many seconds until the element entirely
+     * disappears.
+     * @param maxTime - How many seconds the element can appear.
+     *
+     * @return The proper transparency to render something.
+     */
+    static float getAlpha(double renderTime,
+                          double maxTime,
+                          double fadeInTime,
+                          double fadeOutTime)
+    {
+        if (renderTime <= fadeOutTime)
+        {
+            return (float) (renderTime / fadeOutTime);
+        }
+        else if (renderTime > maxTime - fadeInTime)
+        {
+            return (float) ((maxTime - renderTime) / fadeInTime);
+        }
+        return 1F;
+    }
+}

src/main/java/markil3/immersive_hud/RenderUtils.java

@@ -0,0 +1,644 @@
+/**
+ * Copyright (C) 2009-2021 Mojang Studios
+ * <p>
+ * Players are free to create, build, and mod within Minecraft if the branding
+ * usage guidelines are followed. Fan art, logos, videos, and screen shots are
+ * acceptable as long as they are not used to falsely represent Mojang Minecraft
+ * assets.  If you intend to use any portion of the name in relation to
+ * services, products, or distribution, you must adhere to the following
+ * requirements.
+ * <p>
+ * Mojang's terms of service and brand guidelines are designed to let you know
+ * in plain terms what you can and cannot do with your game, the Mojang brand or
+ * Mojang assets. https://account.mojang.com/documents/minecraft_eula
+ */
+package markil3.immersive_hud;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+import com.mojang.blaze3d.platform.GlStateManager;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.AbstractGui;
+import net.minecraft.client.gui.IngameGui;
+import net.minecraft.client.gui.screen.inventory.ContainerScreen;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.client.renderer.model.ItemCameraTransforms;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.texture.PotionSpriteUploader;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.settings.AttackIndicatorStatus;
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.crash.ReportedException;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Effect;
+import net.minecraft.potion.EffectInstance;
+import net.minecraft.util.HandSide;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Contains methods for rendering various HUD elements. Most of these methods
+ * come from {@link IngameGui} and
+ * {@link net.minecraft.client.renderer.ItemRenderer},
+ * with some tweaks to make the mod work.
+ *
+ * @author Mojang Studios
+ * @version 0.1-1.16.4-forge
+ */
+public class RenderUtils
+{
+    private static int getBlitOffset(IngameGui gui)
+    {
+        Field blitAccessField = null;
+        int blitAccess = 0;
+        try
+        {
+            blitAccessField = AbstractGui.class.getDeclaredField("blitOffset");
+        }
+        catch (NoSuchFieldException e)
+        {
+            e.printStackTrace();
+        }
+        if (!blitAccessField.isAccessible())
+        {
+            blitAccessField.setAccessible(true);
+        }
+        try
+        {
+            blitAccess = (int) blitAccessField.get(gui);
+        }
+        catch (IllegalAccessException e)
+        {
+            e.printStackTrace();
+        }
+
+        return blitAccess;
+    }
+
+    private static boolean setBlitOffset(IngameGui gui, int value)
+    {
+        Field blitAccessField = null;
+        int blitAccess = 0;
+        try
+        {
+            blitAccessField = AbstractGui.class.getDeclaredField("blitOffset");
+        }
+        catch (NoSuchFieldException e)
+        {
+            e.printStackTrace();
+            return false;
+        }
+
+        if (!blitAccessField.isAccessible())
+        {
+            blitAccessField.setAccessible(true);
+        }
+        try
+        {
+            blitAccessField.set(gui, value);
+            return true;
+        }
+        catch (IllegalAccessException e)
+        {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public static void renderPotionIcons(Minecraft mc,
+                                         IngameGui gui,
+                                         float ticks)
+    {
+
+        int scaledWidth = mc.mainWindow.getScaledWidth();
+        int scaledHeight = mc.mainWindow.getScaledHeight();
+
+        Collection<EffectInstance> collection =
+                mc.player.getActivePotionEffects();
+
+
+        if (!collection.isEmpty())
+        {
+            GlStateManager.enableBlend();
+            int i = 0;
+            int j = 0;
+            PotionSpriteUploader potionspriteuploader =
+                    mc.getPotionSpriteUploader();
+            List<Runnable> list =
+                    Lists.newArrayListWithExpectedSize(collection.size());
+            mc.getTextureManager()
+                    .bindTexture(ContainerScreen.INVENTORY_BACKGROUND);
+
+            for (EffectInstance effectinstance : Ordering.natural()
+                    .reverse()
+                    .sortedCopy(collection))
+            {
+                Effect effect = effectinstance.getPotion();
+                float effectAlpha = TimerUtils.getPotionAlpha(mc.player,
+                        effectinstance,
+                        ticks);
+                if (!effectinstance.isShowIcon() || effectAlpha < 0.01F)
+                {
+                    continue;
+                }
+                // Rebind in case previous renderHUDEffect changed texture
+                mc.getTextureManager()
+                        .bindTexture(ContainerScreen.INVENTORY_BACKGROUND);
+                if (effectinstance.isShowIcon())
+                {
+                    int k = scaledWidth;
+                    int l = 1;
+                    if (mc.isDemo())
+                    {
+                        l += 15;
+                    }
+
+                    if (effect.isBeneficial())
+                    {
+                        ++i;
+                        k = k - 25 * i;
+                    }
+                    else
+                    {
+                        ++j;
+                        k = k - 25 * j;
+                        l += 26;
+                    }
+
+                    GlStateManager.color4f(1.0F, 1.0F, 1.0F, effectAlpha);
+                    if (effectinstance.isAmbient())
+                    {
+                        gui.blit(k, l, 165, 166, 24, 24);
+                    }
+                    else
+                    {
+                        gui.blit(k, l, 141, 166, 24, 24);
+                    }
+
+                    float f_f = effectAlpha;
+                    int k_f = k;
+                    int l_f = l;
+
+                    TextureAtlasSprite textureatlassprite =
+                            potionspriteuploader.func_215288_a(effect);
+                    list.add(() -> {
+                        GlStateManager.color4f(1.0F, 1.0F, 1.0F, f_f);
+                        gui.blit(k_f + 3, l_f + 3, getBlitOffset(gui), 18, 18, textureatlassprite);
+                    });
+                    effect.renderHUDEffect(effectinstance, gui,
+                            k,
+                            l,
+                            getBlitOffset(gui),
+                            effectAlpha);
+                }
+            }
+
+            mc.getTextureManager().bindTexture(AtlasTexture.LOCATION_EFFECTS_TEXTURE);
+            list.forEach(Runnable::run);
+        }
+    }
+
+    /**
+     * Renders the horse jump bar.
+     *
+     * @param mc - A Minecraft instance.
+     * @param gui - The GUI.
+     * @param ticks
+     * @param renderTime - How much time before this element becomes fully
+     * transparent.
+     *
+     * @see IngameGui#renderHorseJumpBar(int)
+     */
+    public static void renderHorseJumpBar(Minecraft mc,
+                                          IngameGui gui,
+                                          float ticks, double renderTime)
+    {
+        ConfigManager.TimeValues jump =
+                ConfigManager.getInstance().getJumpTime();
+        if (renderTime <= 0)
+        {
+            return;
+        }
+
+        float alpha = Main.getAlpha(renderTime,
+                jump.getMaxTime(),
+                jump.getFadeInTime(),
+                jump.getFadeOutTime());
+        int scaledWidth = mc.mainWindow.getScaledWidth();
+        int scaledHeight = mc.mainWindow.getScaledHeight();
+        int xPosition = scaledWidth / 2 - 91;
+
+        mc.getProfiler().startSection("jumpBar");
+        GlStateManager.enableBlend();
+        GlStateManager.color4f(1.0F, 1.0F, 1.0F, alpha);
+        mc.getTextureManager().bindTexture(AbstractGui.GUI_ICONS_LOCATION);
+        float f = mc.player.getHorseJumpPower();
+        int i = 182;
+        int j = (int) (f * 183.0F);
+        int k = scaledHeight - TimerUtils.getJumpTranslation();
+        gui.blit(xPosition, k, 0, 84, 182, 5);
+        if (j > 0)
+        {
+            gui.blit(xPosition, k, 0, 89, j, 5);
+        }
+        GlStateManager.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+
+        GlStateManager.disableBlend();
+        mc.getProfiler().endSection();
+    }
+
+    /**
+     * Renders the experience bar.
+     *
+     * @param mc - A Minecraft instance.
+     * @param gui - The GUI.
+     * @param ticks
+     * @param renderTime - How much time before this element becomes fully
+     * transparent.
+     *
+     * @see IngameGui#func_238454_b_(int)
+     */
+    public static void renderExperience(Minecraft mc,
+                                        IngameGui gui,
+                                        float ticks, double renderTime)
+    {
+        ConfigManager.TimeValues experience =
+                ConfigManager.getInstance().getHealthTime();
+        ConfigManager.TimeValues hotbar =
+                ConfigManager.getInstance().getHotbarTime();
+        if (renderTime <= 0)
+        {
+            return;
+        }
+
+        float alpha = Main.getAlpha(renderTime,
+                experience.getMaxTime(),
+                experience.getFadeInTime(),
+                experience.getFadeOutTime());
+        GlStateManager.color4f(1.0F, 1.0F, 1.0F, alpha);
+
+        if (mc.playerController.gameIsSurvivalOrAdventure())
+        {
+            int scaledWidth = mc.mainWindow.getScaledWidth();
+            int scaledHeight = mc.mainWindow.getScaledHeight();
+            int x = scaledWidth / 2 - 91;
+
+            mc.getProfiler().startSection("expBar");
+            GlStateManager.enableBlend();
+            mc.getTextureManager().bindTexture(AbstractGui.GUI_ICONS_LOCATION);
+            int i = mc.player.xpBarCap();
+            if (i > 0)
+            {
+                int j = 182;
+                int k = (int) (mc.player.experience * 183.0F);
+                int l = scaledHeight - TimerUtils.getExperienceTranslation();
+                gui.blit(x, l, 0, 64, 182, 5);
+                if (k > 0)
+                {
+                    gui.blit(x, l, 0, 69, k, 5);
+                }
+            }
+
+            GlStateManager.disableBlend();
+            mc.getProfiler().endSection();
+            if (mc.player.experienceLevel > 0)
+            {
+                mc.getProfiler().startSection("expLevel");
+                GlStateManager.enableBlend();
+                String s = "" + mc.player.experienceLevel;
+                int i1 = (scaledWidth - gui.getFontRenderer()
+                        .getStringWidth(s)) / 2;
+                int j1 =
+                        scaledHeight - (int) ((22F * Main.getAlpha(TimerUtils.hotbarTime,
+                                hotbar.getMaxTime(),
+                                hotbar.getFadeInTime(),
+                                hotbar.getFadeOutTime()) + 9F) * alpha) - (int) (4F * alpha);
+                gui.getFontRenderer()
+                        .drawString(s,
+                                (float) (i1 + 1),
+                                (float) j1,
+                                0);
+                gui.getFontRenderer()
+                        .drawString(s,
+                                (float) (i1 - 1),
+                                (float) j1,
+                                0);
+                gui.getFontRenderer()
+                        .drawString(s,
+                                (float) i1,
+                                (float) (j1 + 1),
+                                0);
+                gui.getFontRenderer()
+                        .drawString(s,
+                                (float) i1,
+                                (float) (j1 - 1),
+                                0);
+                gui.getFontRenderer()
+                        .drawString(s,
+                                (float) i1,
+                                (float) j1,
+                                8453920);
+                GlStateManager.disableBlend();
+                mc.getProfiler().endSection();
+            }
+        }
+        GlStateManager.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+    }
+
+
+    /**
+     * Renders the hotbar and all the items in it.
+     *
+     * @param mc - A Minecraft instance.
+     * @param gui - The GUI.
+     * @param partialTicks
+     * @param renderTime - How much time before this element becomes fully
+     * transparent.
+     *
+     * @see IngameGui#renderHotbar(float)
+     */
+    public static void renderHotbar(Minecraft mc,
+                                    IngameGui gui,
+                                    float partialTicks,
+                                    double renderTime)
+    {
+        ConfigManager.TimeValues hotbar =
+                ConfigManager.getInstance().getHotbarTime();
+        final ResourceLocation WIDGETS_TEX_PATH =
+                new ResourceLocation("textures/gui/widgets.png");
+        PlayerEntity playerentity = mc.player;
+
+        if (renderTime <= 0)
+        {
+            return;
+        }
+
+        float alpha = Main.getAlpha(renderTime,
+                hotbar.getMaxTime(),
+                hotbar.getFadeInTime(),
+                hotbar.getFadeOutTime());
+
+        int scaledWidth = mc.mainWindow.getScaledWidth();
+        int scaledHeight = mc.mainWindow.getScaledHeight();
+        if (playerentity != null)
+        {
+            GlStateManager.color4f(1.0F, 1.0F, 1.0F, alpha);
+            GlStateManager.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+            mc.getTextureManager().bindTexture(WIDGETS_TEX_PATH);
+            ItemStack itemstack = playerentity.getHeldItemOffhand();
+            HandSide handside = playerentity.getPrimaryHand().opposite();
+            int i = scaledWidth / 2;
+            int j = getBlitOffset(gui);
+            int k = 182;
+            int l = 91;
+            setBlitOffset(gui, -90);
+            gui.blit(i - 91, scaledHeight - TimerUtils.getHotbarTranslation(), 0, 0, 182, 22);
+            gui.blit(i - 91 - 1 + playerentity.inventory.currentItem * 20,
+                    scaledHeight - (int) (22F * alpha) - 1,
+                    0,
+                    22,
+                    24,
+                    22);
+            if (!itemstack.isEmpty())
+            {
+                if (handside == HandSide.LEFT)
+                {
+                    gui.blit(i - 91 - 29,
+                            scaledHeight - (int) (23 * alpha),
+                            24,
+                            22,
+                            29,
+                            24);
+                }
+                else
+                {
+                    gui.blit(i + 91, scaledHeight - (int) (23 * alpha), 53, 22, 29, 24);
+                }
+            }
+
+            setBlitOffset(gui, j);
+            GlStateManager.enableRescaleNormal();
+            GlStateManager.enableBlend();
+            GlStateManager.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA,
+                    GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA,
+                    GlStateManager.SourceFactor.ONE,
+                    GlStateManager.DestFactor.ZERO);
+            RenderHelper.enableGUIStandardItemLighting();
+
+            for (int i1 = 0; i1 < 9; ++i1)
+            {
+                int j1 = i - 90 + i1 * 20 + 2;
+                int k1 = scaledHeight - (int) (16 * alpha) - 3;
+                renderHotbarItem(mc,
+                        alpha,
+                        j1,
+                        k1,
+                        partialTicks,
+                        playerentity,
+                        playerentity.inventory.mainInventory.get(i1));
+            }
+
+            if (!itemstack.isEmpty())
+            {
+                int i2 = scaledHeight - (int) (16 * alpha) - 3;
+                if (handside == HandSide.LEFT)
+                {
+                    renderHotbarItem(mc,
+                            alpha,
+                            i - 91 - 26,
+                            i2,
+                            partialTicks,
+                            playerentity,
+                            itemstack);
+                }
+                else
+                {
+                    renderHotbarItem(mc,
+                            alpha,
+                            i + 91 + 10,
+                            i2,
+                            partialTicks,
+                            playerentity,
+                            itemstack);
+                }
+            }
+
+            if (mc.gameSettings.attackIndicator == AttackIndicatorStatus.HOTBAR)
+            {
+                float f = mc.player.getCooledAttackStrength(0.0F);
+                if (f < 1.0F)
+                {
+                    int j2 = scaledHeight - 20;
+                    int k2 = i + 91 + 6;
+                    if (handside == HandSide.RIGHT)
+                    {
+                        k2 = i - 91 - 22;
+                    }
+
+                    mc.getTextureManager()
+                            .bindTexture(AbstractGui.GUI_ICONS_LOCATION);
+                    int l1 = (int) (f * 19.0F);
+                    GlStateManager.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+                    gui.blit(k2, j2, 0, 94, 18, 18);
+                    gui.blit(k2, j2 + 18 - l1, 18, 112 - l1, 18, l1);
+                }
+            }
+
+            RenderHelper.disableStandardItemLighting();
+            GlStateManager.disableRescaleNormal();
+            GlStateManager.disableBlend();
+        }
+    }
+
+    /**
+     * Renders a single item on the HUD.
+     *
+     * @param mc - A Minecraft instance.
+     * @param x - The x position of the item on the screen.
+     * @param y - The y position of the item on the screen
+     * @param partialTicks
+     * @param player - The player that the item is from.
+     * @param stack - The item to render.
+     *
+     * @see IngameGui#renderHotbarItem(int, int, float, PlayerEntity, ItemStack)
+     */
+    static void renderHotbarItem(Minecraft mc, float alpha,
+                                 int x,
+                                 int y,
+                                 float partialTicks,
+                                 PlayerEntity player,
+                                 ItemStack stack)
+    {
+        if (!stack.isEmpty())
+        {
+            GlStateManager.color4f(1.0F, 1.0F, 1.0F, alpha);
+            float f = (float) stack.getAnimationsToGo() - partialTicks;
+            if (f > 0.0F)
+            {
+                GlStateManager.pushMatrix();
+                float f1 = 1.0F + f / 5.0F;
+                GlStateManager.translatef((float) (x + 8),
+                        (float) (y + 12),
+                        0.0F);
+                GlStateManager.scalef(1.0F / f1, (f1 + 1.0F) / 2.0F, 1.0F);
+                GlStateManager.translatef((float) (-(x + 8)),
+                        (float) (-(y + 12)),
+                        0.0F);
+            }
+
+            renderItemAndEffectIntoGUI(mc, player, stack, x, y, alpha);
+            if (f > 0.0F)
+            {
+                GlStateManager.popMatrix();
+            }
+
+            mc.getItemRenderer()
+                    .renderItemOverlays(mc.fontRenderer, stack, x, y);
+        }
+    }
+
+    private static void renderItemAndEffectIntoGUI(Minecraft mc,
+                                                   LivingEntity entityIn,
+                                                   ItemStack itemIn,
+                                                   int x,
+                                                   int y,
+                                                   float alpha)
+    {
+        if (!itemIn.isEmpty())
+        {
+            float zLevel = 50.0F;
+
+            try
+            {
+                IBakedModel bakedmodel = mc.getItemRenderer()
+                        .getItemModelWithOverrides(itemIn,
+                                (World) null,
+                                entityIn);
+                GlStateManager.pushMatrix();
+                mc.getTextureManager()
+                        .bindTexture(AtlasTexture.LOCATION_BLOCKS_TEXTURE);
+                mc.getTextureManager()
+                        .getTexture(AtlasTexture.LOCATION_BLOCKS_TEXTURE)
+                        .setBlurMipmap(false, false);
+                GlStateManager.enableRescaleNormal();
+                GlStateManager.enableAlphaTest();
+                GlStateManager.alphaFunc(516, 0.1F);
+                GlStateManager.enableBlend();
+                GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA,
+                        GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
+                GlStateManager.color4f(1.0F, 1.0F, 1.0F, alpha);
+                Method transformMethod = null;
+                try
+                {
+                    transformMethod = ItemRenderer.class.getDeclaredMethod("setupGuiTransform", int.class, int.class, boolean.class);
+                }
+                catch (NoSuchMethodException e)
+                {
+                    try
+                    {
+                        transformMethod = ItemRenderer.class.getDeclaredMethod("func_180452_a", int.class, int.class, boolean.class);
+                    }
+                    catch (NoSuchMethodException e1)
+                    {
+                        e.printStackTrace();
+                    }
+                }
+                if (transformMethod != null)
+                {
+                    if (!transformMethod.isAccessible())
+                    {
+                        transformMethod.setAccessible(true);
+                    }
+                    transformMethod.invoke(mc.getItemRenderer(), x, y, bakedmodel.isGui3d());
+                }
+                bakedmodel =
+                        net.minecraftforge.client.ForgeHooksClient.handleCameraTransforms(
+                                bakedmodel,
+                                ItemCameraTransforms.TransformType.GUI,
+                                false);
+                mc.getItemRenderer().renderItem(itemIn, bakedmodel);
+                GlStateManager.disableAlphaTest();
+                GlStateManager.disableRescaleNormal();
+                GlStateManager.disableLighting();
+                GlStateManager.popMatrix();
+                mc.textureManager.bindTexture(AtlasTexture.LOCATION_BLOCKS_TEXTURE);
+                mc.textureManager.getTexture(AtlasTexture.LOCATION_BLOCKS_TEXTURE)
+                        .restoreLastBlurMipmap();
+            }
+            catch (Throwable throwable)
+            {
+                CrashReport crashreport = CrashReport.makeCrashReport(throwable,
+                        "Rendering item");
+                CrashReportCategory crashreportcategory =
+                        crashreport.makeCategory("Item being rendered");
+                crashreportcategory.addDetail("Item Type", () -> {
+                    return String.valueOf((Object) itemIn.getItem());
+                });
+                crashreportcategory.addDetail("Registry Name",
+                        () -> String.valueOf(itemIn.getItem()
+                                .getRegistryName()));
+                crashreportcategory.addDetail("Item Damage", () -> {
+                    return String.valueOf(itemIn.getDamage());
+                });
+                crashreportcategory.addDetail("Item NBT", () -> {
+                    return String.valueOf((Object) itemIn.getTag());
+                });
+                crashreportcategory.addDetail("Item Foil", () -> {
+                    return String.valueOf(itemIn.hasEffect());
+                });
+                throw new ReportedException(crashreport);
+            }
+        }
+    }
+}

src/main/resources/META-INF/mods.toml

@@ -0,0 +1,83 @@
+# This is an example mods.toml file. It contains the data relating to the loading mods.
+# There are several mandatory fields (#mandatory), and many more that are optional (#optional).
+# The overall format is standard TOML format, v0.5.0.
+# Note that there are a couple of TOML lists in this file.
+# Find more information on toml format here:  https://github.com/toml-lang/toml
+# The name of the mod loader type to load - for regular FML @Mod mods it should be javafml
+modLoader="javafml" #mandatory
+# A version range to match for said mod loader - for regular FML @Mod it will be the forge version
+loaderVersion="[26,)" #mandatory This is typically bumped every Minecraft version by Forge. See our download page for lists of versions.
+# The license for you mod. This is mandatory metadata and allows for easier comprehension of your redistributive properties.
+# Review your options at https://choosealicense.com/. All rights reserved is the default copyright stance, and is thus the default here.
+license="GPL-3.0-only"
+# A URL to refer people to when problems occur with this mod
+issueTrackerURL="https://github.com/Markil3/MinecraftImmersiveHUD/issues" #optional
+# A list of mods - how many allowed here is determined by the individual mod loader
+[[mods]] #mandatory
+# The modid of the mod
+modId="immersive_hud" #mandatory
+# The version number of the mod - there's a few well known ${} variables useable here or just hardcode it
+# ${file.jarVersion} will substitute the value of the Implementation-Version as read from the mod's JAR file metadata
+# see the associated build.gradle script for how to populate this completely automatically during a build
+version="${file.jarVersion}" #mandatory
+ # A display name for the mod
+displayName="Immersive HUD" #mandatory
+# A URL to query for updates for this mod. See the JSON update specification https://mcforge.readthedocs.io/en/latest/gettingstarted/autoupdate/
+updateJSONURL="https://raw.githubusercontent.com/Markil3/MinecraftImmersiveHUD/master/update-forge.json" #optional
+# A URL for the "homepage" for this mod, displayed in the mod UI
+displayURL="https://www.planetminecraft.com/mod/immersive-hud/" #optional
+# A file name (in the root of the mod JAR) containing a logo for display
+logoFile="immersive_hud_logo.png" #optional
+# A text field displayed in the mod UI
+credits="Minecraft Rendering Code (c) 2009-2021 Mojang Studios" #optional
+# A text field displayed in the mod UI
+authors="Markil 3"
+# The description text for the mod (multi line!) (#mandatory)
+description='''
+This Minecraft mod aims to move the ingame HUD out of the way whenever possible. Whenever an element updates
+(i.e., health changes, you swap items, you look at something, etc.), the respective item will show
+up. However, once you've been able to see the information, it will fade away and allow you to enjoy
+your game without the clutter of unneeded HUD elements.
+The following elements will only show up under certain conditions:
+
+ * The health and armor bars will only show up when your health changes (i.e. after taking damage), when your health is low or when holding food.
+ * The hunger bar will only show up when your hunger level (not your saturation) changes, you are hungry, or when holding food.
+ * The experience bar and level will only show upon gaining experience.
+ * The health of your mount (i.e. your horse) will only show when its health changes.
+ * The horse jump bar will only show when you are getting ready to jump.
+ * The hotbar will only show when an item you are holding changes or you change which slot is selected.
+ * The crosshair will only show when you are looking at something or you are using a bow, crossbow, shield, or trident or holding a throwable item.
+ * The hands will show only when you use an item or are holding/using one of the above specified items, or a map.
+ * Potion icons will only show up when first applied or about to run out.
+'''
+# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
+[[dependencies.immersive_hud]]
+    # the modid of the dependency
+    modId="forge" #mandatory
+    # Does this dependency have to exist - if not, ordering below must be specified
+    mandatory=true #mandatory
+    # The version range of the dependency
+    versionRange="[26,)" #mandatory
+    # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
+    ordering="NONE"
+    # Side this dependency is applied on - BOTH, CLIENT or SERVER
+    side="CLIENT"
+
+[[dependencies.immersive_hud]]
+    # the modid of the dependency
+    modId="cloth-config" #mandatory
+    # Does this dependency have to exist - if not, ordering below must be specified
+    mandatory=false #mandatory
+    # The version range of the dependency
+    versionRange="[4.11,)" #mandatory
+    # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
+    ordering="BEFORE"
+    # Side this dependency is applied on - BOTH, CLIENT or SERVER
+    side="CLIENT"
+# Here's another dependency
+[[dependencies.immersive_hud]]
+    modId="minecraft"
+    mandatory=true
+    versionRange="[1.14,1.15)"
+    ordering="NONE"
+    side="CLIENT"

src/main/resources/assets/immersive_hud/lang/en_us.json

@@ -0,0 +1,53 @@
+{
+  "immersive_hud.configGui.title": "Immersive HUD Configuration",
+  "option.immersive_hud.hotbarMaxTime": "Hotbar Display Time",
+  "option.immersive_hud.hotbarFadeIn": "Hotbar Fade In Time",
+  "option.immersive_hud.hotbarFadeOut": "Hotbar Fade Out Time",
+  "option.immersive_hud.experienceMaxTime": "Experience Display Time",
+  "option.immersive_hud.experienceFadeIn": "Experience Fade In Time",
+  "option.immersive_hud.experienceFadeOut": "Experience Fade Out Time",
+  "option.immersive_hud.jumpMaxTime": "Jump Bar Display Time",
+  "option.immersive_hud.jumpFadeIn": "Jump Bar Fade In Time",
+  "option.immersive_hud.jumpFadeOut": "Jump Bar Fade Out Time",
+  "option.immersive_hud.healthMaxTime": "Health Bar Display Time",
+  "option.immersive_hud.healthFadeIn": "Health Bar Fade In Time",
+  "option.immersive_hud.healthFadeOut": "Health Bar Fade Out Time",
+  "option.immersive_hud.hungerMaxTime": "Hunger Bar Display Time",
+  "option.immersive_hud.hungerFadeIn": "Hunger Bar Fade In Time",
+  "option.immersive_hud.hungerFadeOut": "Hunger Bar Fade Out Time",
+  "option.immersive_hud.effectMaxTime": "Potion Display Time",
+  "option.immersive_hud.effectFadeIn": "Potion Fade In Time",
+  "option.immersive_hud.effectFadeOut": "Potion Fade Out Time",
+  "option.immersive_hud.crosshairTime": "Crosshair Display Time",
+  "option.immersive_hud.hideCrosshair": "Hide Crosshair",
+  "option.immersive_hud.handTime": "Hand Display Time",
+  "option.immersive_hud.hideHands": "Hide Hands",
+  "option.immersive_hud.minHealth": "Minimum Health Fade",
+  "option.immersive_hud.minHunger": "Minimum Hunger Fade",
+  "option.immersive_hud.showArmor": "Show Armor",
+  "tooltip.immersive_hud.hotbarMaxTime": "How long the hotbar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.hotbarFadeIn": "How many seconds it takes for the hotbar to fade in",
+  "tooltip.immersive_hud.hotbarFadeOut": "How many seconds it takes for the hotbar to move out",
+  "tooltip.immersive_hud.experienceMaxTime": "How long the experience bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.experienceFadeIn": "How many seconds it takes for the experience bar to fade in",
+  "tooltip.immersive_hud.experienceFadeOut": "How many seconds it takes for the experience bar to move out",
+  "tooltip.immersive_hud.jumpMaxTime": "How long the horse jump bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.jumpFadeIn": "How many seconds it takes for the horse jump bar to fade in",
+  "tooltip.immersive_hud.jumpFadeOut": "How many seconds it takes for the horse jump bar to fade out",
+  "tooltip.immersive_hud.healthMaxTime": "How long the health bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.healthFadeIn": "How many seconds it takes for the health bar to fade in",
+  "tooltip.immersive_hud.healthFadeOut": "How many seconds it takes for the health bar to fade out",
+  "tooltip.immersive_hud.hungerMaxTime": "How long the hunger bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.hungerFadeIn": "How many seconds it takes for the hunger bar to fade in",
+  "tooltip.immersive_hud.hungerFadeOut": "How many seconds it takes for the hunger bar to fade out",
+  "tooltip.immersive_hud.effectMaxTime": "How long potion icons can be displayed on screen in seconds",
+  "tooltip.immersive_hud.effectFadeIn": "How many seconds it takes for potion icons to fade in",
+  "tooltip.immersive_hud.effectFadeOut": "How many seconds it takes for potion icons to fade out",
+  "tooltip.immersive_hud.crosshairTime": "How many seconds the crosshairs can be on screen",
+  "tooltip.immersive_hud.hideCrosshair": "Whether or not the crosshairs should be hidden after a period of time",
+  "tooltip.immersive_hud.handTime": "How many seconds the hands can be on screen",
+  "tooltip.immersive_hud.hideHands": "Whether or not hands should be hidden after a period of time",
+  "tooltip.immersive_hud.minHealth": "When the percentage of health goes below this level, the health bar won't fade away",
+  "tooltip.immersive_hud.minHunger": "When the hunger level goes below this level, the hunger bar won't fade away",
+  "tooltip.immersive_hud.showArmor": "Whether or not the armor bar should display on the HUD"
+}

src/main/resources/pack.mcmeta

@@ -0,0 +1,7 @@
+{
+    "pack": {
+        "description": "immersive_hud resources",
+        "pack_format": 4,
+        "_comment": "A pack_format of 4 requires json lang files and some texture changes from 1.16.2. Note: we require v6 pack meta for all mods."
+    }
+}