diff --git a/src/main/java/com/seibel/lod/core/Config.java b/src/main/java/com/seibel/lod/core/Config.java index c992a84e5..9e2cdc5c0 100644 --- a/src/main/java/com/seibel/lod/core/Config.java +++ b/src/main/java/com/seibel/lod/core/Config.java @@ -76,8 +76,8 @@ public class Config public static ConfigCategory advanced = new ConfigCategory.Builder().set(Advanced.class).build(); public static ConfigEntry optionsButton = new ConfigEntry.Builder() - .comment(ILodConfigWrapperSingleton.IClient.OPTIONS_BUTTON_DESC) - .set(ILodConfigWrapperSingleton.IClient.OPTIONS_BUTTON_DEFAULT) + .set(true) + .comment("Show the lod button in the options screen next to fov") .build(); @@ -93,38 +93,85 @@ public class Config public static class Quality { public static ConfigEntry drawResolution = new ConfigEntry.Builder() - .comment(IQuality.DRAW_RESOLUTION_DESC) - .set(IQuality.DRAW_RESOLUTION_DEFAULT) + .set(HorizontalResolution.BLOCK) + .comment("" + + "What is the maximum detail fake chunks should be drawn at? \n" + + "This setting will only affect closer chunks.\n" + + "Higher settings will increase memory and GPU usage. \n" + + "\n" + + HorizontalResolution.CHUNK + ": render 1 LOD for each Chunk. \n" + + HorizontalResolution.HALF_CHUNK + ": render 4 LODs for each Chunk. \n" + + HorizontalResolution.FOUR_BLOCKS + ": render 16 LODs for each Chunk. \n" + + HorizontalResolution.TWO_BLOCKS + ": render 64 LODs for each Chunk. \n" + + HorizontalResolution.BLOCK + ": render 256 LODs for each Chunk (width of one block). \n" + + "\n" + + "Lowest Quality: " + HorizontalResolution.CHUNK + "\n" + + "Highest Quality: " + HorizontalResolution.BLOCK) .build(); public static ConfigEntry lodChunkRenderDistance = new ConfigEntry.Builder() - .comment(IQuality.LOD_CHUNK_RENDER_DISTANCE_DESC) - .setMinDefaultMax(IQuality.LOD_CHUNK_RENDER_DISTANCE_MIN_DEFAULT_MAX) + .setMinDefaultMax(32, 128, 4096) + .comment("The radius of the mod's render distance. (measured in chunks)") .build(); public static ConfigEntry verticalQuality = new ConfigEntry.Builder() - .comment(IQuality.VERTICAL_QUALITY_DESC) - .set(IQuality.VERTICAL_QUALITY_DEFAULT) + .set(VerticalQuality.MEDIUM) + .comment("" + + "This indicates how detailed fake chunks will represent \n" + + " overhangs, caves, floating islands, ect. \n" + + "Higher options will make the world more accurate, but" + + " will increase memory and GPU usage. \n" + + "\n" + + VerticalQuality.LOW + ": uses at max 2 columns per position. \n" + + VerticalQuality.MEDIUM + ": uses at max 4 columns per position. \n" + + VerticalQuality.HIGH + ": uses at max 8 columns per position. \n" + + "\n" + + "Lowest Quality: " + VerticalQuality.LOW + "\n" + + "Highest Quality: " + VerticalQuality.HIGH) .build(); public static ConfigEntry horizontalScale = new ConfigEntry.Builder() - .comment(IQuality.HORIZONTAL_SCALE_DESC) - .setMinDefaultMax(IQuality.HORIZONTAL_SCALE_MIN_DEFAULT_MAX) + .setMinDefaultMax(2, 12, 64) + .comment("" + + "This indicates how quickly fake chunks decrease in quality the further away they are. \n" + + "Higher settings will render higher quality fake chunks farther away, \n" + + " but will increase memory and GPU usage.") .build(); public static ConfigEntry horizontalQuality = new ConfigEntry.Builder() - .comment(IQuality.HORIZONTAL_SCALE_DESC) - .set(IQuality.HORIZONTAL_QUALITY_DEFAULT) + .set(HorizontalQuality.MEDIUM) + .comment("" + + "This indicates how quickly fake chunks decrease in quality the further away they are. \n" + + "Higher settings will render higher quality fake chunks farther away, \n" + + " but will increase memory and GPU usage.") .build(); public static ConfigEntry dropoffQuality = new ConfigEntry.Builder() - .comment(IQuality.DROPOFF_QUALITY_DESC) - .set(IQuality.DROPOFF_QUALITY_DEFAULT) + .set(DropoffQuality.AUTO) + .comment("" + + "This determines how lod level drop off will be done. \n" + + "\n" + + DropoffQuality.SMOOTH_DROPOFF + ": \n" + + " The lod level is calculated for each point, making the drop off a smooth circle. \n" + + DropoffQuality.PERFORMANCE_FOCUSED + ": \n" + + " One detail level for an entire region. Minimize CPU usage and \n" + + " improve terrain refresh delay, especially for high Lod render distance. \n" + + DropoffQuality.AUTO + ": \n" + + " Use "+ DropoffQuality.SMOOTH_DROPOFF + " for less then 128 Lod render distance, \n" + + " or "+ DropoffQuality.PERFORMANCE_FOCUSED +" otherwise.") .build(); public static ConfigEntry lodBiomeBlending = new ConfigEntry.Builder() - .comment(IQuality.LOD_BIOME_BLENDING_DESC) - .setMinDefaultMax(IQuality.LOD_BIOME_BLENDING_MIN_DEFAULT_MAX) + .setMinDefaultMax(0,1,7) + .comment("" + + "This is the same as vanilla Biome Blending settings for Lod area. \n" + + " Note that anything other than '0' will greatly effect Lod building time \n" + + " and increase triangle count. The cost on chunk generation speed is also \n" + + " quite large if set too high.\n" + + "\n" + + " '0' equals to Vanilla Biome Blending of '1x1' or 'OFF', \n" + + " '1' equals to Vanilla Biome Blending of '3x3', \n" + + " '2' equals to Vanilla Biome Blending of '5x5'...") .build(); } @@ -132,57 +179,103 @@ public class Config public static class FogQuality { public static ConfigEntry fogDistance = new ConfigEntry.Builder() - .comment(IFogQuality.FOG_DISTANCE_DESC) - .set(IFogQuality.FOG_DISTANCE_DEFAULT) + .set(FogDistance.FAR) + .comment("" + + "At what distance should Fog be drawn on the fake chunks? \n" + + "\n" + + "This setting shouldn't affect performance.") .build(); public static ConfigEntry fogDrawMode = new ConfigEntry.Builder() - .comment(IFogQuality.FOG_DRAW_MODE_DESC) - .set(IFogQuality.FOG_DRAW_MODE_DEFAULT) + .set(FogDrawMode.FOG_ENABLED) + .comment("" + + "When should fog be drawn? \n" + + "\n" + + FogDrawMode.USE_OPTIFINE_SETTING + ": Use whatever Fog setting Optifine is using.\n" + + "If Optifine isn't installed this defaults to " + FogDrawMode.FOG_ENABLED + ". \n" + + FogDrawMode.FOG_ENABLED + ": Never draw fog on the LODs \n" + + FogDrawMode.FOG_DISABLED + ": Always draw fast fog on the LODs \n" + + "\n" + + "Disabling fog will improve GPU performance.") .build(); public static ConfigEntry fogColorMode = new ConfigEntry.Builder() - .comment(IFogQuality.FOG_COLOR_MODE_DESC) - .set(IFogQuality.FOG_COLOR_MODE_DEFAULT) + .set(FogColorMode.USE_WORLD_FOG_COLOR) + .comment("" + + "What color should fog use? \n" + + "\n" + + FogColorMode.USE_WORLD_FOG_COLOR + ": Use the world's fog color. \n" + + FogColorMode.USE_SKY_COLOR + ": Use the sky's color. \n" + + "\n" + + "This setting doesn't affect performance.") .build(); public static ConfigEntry disableVanillaFog = new ConfigEntry.Builder() - .comment(ILodConfigWrapperSingleton.IClient.IGraphics.IFogQuality.DISABLE_VANILLA_FOG_DESC) - .set(ILodConfigWrapperSingleton.IClient.IGraphics.IFogQuality.DISABLE_VANILLA_FOG_DEFAULT) + .set(true) + .comment("" + + "If true disable Minecraft's fog. \n" + + "\n" + + "Experimental! Mod support is not guarantee.") .build(); public static ConfigCategory advancedFog = new ConfigCategory.Builder().set(AdvancedFog.class).build(); public static class AdvancedFog { + private static final Double FOG_RANGE_MIN = 0.0; + private static final Double FOG_RANGE_MAX = Math.sqrt(2.0); + public static ConfigEntry farFogStart = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_START_DESC) - .setMinDefaultMax(IAdvancedFog.FAR_FOG_START_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 0.0, FOG_RANGE_MAX) + .comment("" + + "Where should the far fog start? \n" + + "\n" + + " '0.0': Fog start at player's position.\n" + + " '1.0': The fog-start's circle fit just in the lod render distance square.\n" + + " '1.414': The lod render distance square fit just in the fog-start's circle.") .build(); public static ConfigEntry farFogEnd = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_END_DESC) - .setMinDefaultMax(IAdvancedFog.FAR_FOG_END_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 1.0, FOG_RANGE_MAX) + .comment("" + + "Where should the far fog end? \n" + + "\n" + + " '0.0': Fog end at player's position.\n" + + " '1.0': The fog-end's circle fit just in the lod render distance square.\n" + + " '1.414': The lod render distance square fit just in the fog-end's circle.") .build(); public static ConfigEntry farFogMin = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_MIN_DESC) - .setMinDefaultMax(IAdvancedFog.FAR_FOG_MIN_MIN_DEFAULT_MAX) + .setMinDefaultMax(-5.0,0.0, FOG_RANGE_MAX) + .comment("" + + "What is the minimum fog thickness? \n" + + "\n" + + " '0.0': No fog at all.\n" + + " '1.0': Fully fog color.") .build(); public static ConfigEntry farFogMax = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_MAX_DESC) - .setMinDefaultMax(IAdvancedFog.FAR_FOG_MAX_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 1.0, 5.0) + .comment("" + + "What is the maximum fog thickness? \n" + + "\n" + + " '0.0': No fog at all.\n" + + " '1.0': Fully fog color.") .build(); public static ConfigEntry farFogType = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_TYPE_DESC) - .set(IAdvancedFog.FAR_FOG_TYPE_DEFAULT) + .set(FogSetting.FogType.EXPONENTIAL_SQUARED) + .comment("" + + "How the fog thickness should be calculated from distance? \n" + + "\n" + + FogSetting.FogType.LINEAR + ": Linear based on distance (will ignore 'density')\n" + + FogSetting.FogType.EXPONENTIAL + ": 1/(e^(distance*density)) \n" + + FogSetting.FogType.EXPONENTIAL_SQUARED + ": 1/(e^((distance*density)^2)") .build(); public static ConfigEntry farFogDensity = new ConfigEntry.Builder() - .comment(IAdvancedFog.FAR_FOG_DENSITY_DESC) - .setMinDefaultMax(IAdvancedFog.FAR_FOG_DENSITY_MIN_DEFAULT_MAX) + .setMinDefaultMax(0.01,2.5, 50.0) + .comment("What is the fog density?") .build(); public static ConfigCategory heightFog = new ConfigCategory.Builder().set(HeightFog.class).build(); @@ -190,48 +283,91 @@ public class Config public static class HeightFog { public static ConfigEntry heightFogMixMode = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_MIX_MODE_DESC) - .set(IHeightFog.HEIGHT_FOG_MIX_MODE_DEFAULT) + .set(HeightFogMixMode.BASIC) + .comment("" + + "How the height should effect the fog thickness combined with the normal function? \n" + + "\n" + + HeightFogMixMode.BASIC + ": No special height fog effect. Fog is calculated based on camera distance \n" + + HeightFogMixMode.IGNORE_HEIGHT + ": Ignore height completely. Fog is calculated based on horizontal distance \n" + + HeightFogMixMode.ADDITION + ": heightFog + farFog \n" + + HeightFogMixMode.MAX + ": max(heightFog, farFog) \n" + + HeightFogMixMode.MULTIPLY + ": heightFog * farFog \n" + + HeightFogMixMode.INVERSE_MULTIPLY + ": 1 - (1-heightFog) * (1-farFog) \n" + + HeightFogMixMode.LIMITED_ADDITION + ": farFog + max(farFog, heightFog) \n" + + HeightFogMixMode.MULTIPLY_ADDITION + ": farFog + farFog * heightFog \n" + + HeightFogMixMode.INVERSE_MULTIPLY_ADDITION + ": farFog + 1 - (1-heightFog) * (1-farFog) \n" + + HeightFogMixMode.AVERAGE + ": farFog*0.5 + heightFog*0.5 \n" + + "\n" + + "Note that for 'BASIC' mode and 'IGNORE_HEIGHT' mode, fog settings for height fog has no effect.") .build(); public static ConfigEntry heightFogMode = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_MODE_DESC) - .set(IHeightFog.HEIGHT_FOG_MODE_DEFAULT) + .set(HeightFogMode.ABOVE_AND_BELOW_CAMERA) + .comment("" + + "Where should the height fog be located? \n" + + "\n" + + HeightFogMode.ABOVE_CAMERA + ": Height fog starts from camera to the sky \n" + + HeightFogMode.BELOW_CAMERA + ": Height fog starts from camera to the void \n" + + HeightFogMode.ABOVE_AND_BELOW_CAMERA + ": Height fog starts from camera to both the sky and the void \n" + + HeightFogMode.ABOVE_SET_HEIGHT + ": Height fog starts from a set height to the sky \n" + + HeightFogMode.BELOW_SET_HEIGHT + ": Height fog starts from a set height to the void \n" + + HeightFogMode.ABOVE_AND_BELOW_SET_HEIGHT + ": Height fog starts from a set height to both the sky and the void") .build(); public static ConfigEntry heightFogHeight = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_HEIGHT_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_HEIGHT_MIN_DEFAULT_MAX) + .setMinDefaultMax(-4096.0, 70.0, 4096.0) + .comment("If the height fog is calculated around a set height, what is that height position?") .build(); public static ConfigEntry heightFogStart = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_START_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_START_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 0.0, FOG_RANGE_MAX) + .comment("" + + "How far the start of height fog should offset? \n" + + "\n" + + " '0.0': Fog start with no offset.\n" + + " '1.0': Fog start with offset of the entire world's height. (Include depth)") .build(); public static ConfigEntry heightFogEnd = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_END_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_END_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 1.0, FOG_RANGE_MAX) + .comment("" + + "How far the end of height fog should offset? \n" + + "\n" + + " '0.0': Fog end with no offset.\n" + + " '1.0': Fog end with offset of the entire world's height. (Include depth)") .build(); public static ConfigEntry heightFogMin = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_MIN_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_MIN_MIN_DEFAULT_MAX) + .setMinDefaultMax(-5.0, 0.0, FOG_RANGE_MAX) + .comment("" + + "What is the minimum fog thickness? \n" + + "\n" + + " '0.0': No fog at all.\n" + + " '1.0': Fully fog color.") .build(); public static ConfigEntry heightFogMax = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_MAX_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_MAX_MIN_DEFAULT_MAX) + .setMinDefaultMax(FOG_RANGE_MIN, 1.0, 5.0) + .comment("" + + "What is the maximum fog thickness? \n" + + "\n" + + " '0.0': No fog at all.\n" + + " '1.0': Fully fog color.") .build(); public static ConfigEntry heightFogType = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_TYPE_DESC) - .set(IHeightFog.HEIGHT_FOG_TYPE_DEFAULT) + .set(FogSetting.FogType.EXPONENTIAL_SQUARED) + .comment("" + + "How the fog thickness should be calculated from height? \n" + + "\n" + + FogSetting.FogType.LINEAR + ": Linear based on height (will ignore 'density')\n" + + FogSetting.FogType.EXPONENTIAL + ": 1/(e^(height*density)) \n" + + FogSetting.FogType.EXPONENTIAL_SQUARED + ": 1/(e^((height*density)^2)") .build(); public static ConfigEntry heightFogDensity = new ConfigEntry.Builder() - .comment(IHeightFog.HEIGHT_FOG_DENSITY_DESC) - .setMinDefaultMax(IHeightFog.HEIGHT_FOG_DENSITY_MIN_DEFAULT_MAX) + .setMinDefaultMax(0.01, 2.5, 50.0) + .comment("What is the fog density?") .build(); } @@ -242,48 +378,111 @@ public class Config public static class AdvancedGraphics { public static ConfigEntry disableDirectionalCulling = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.DISABLE_DIRECTIONAL_CULLING_DESC) - .set(IAdvancedGraphics.DISABLE_DIRECTIONAL_CULLING_DEFAULT) + .set(false) + .comment("" + + "If false fake chunks behind the player's camera \n" + + " aren't drawn, increasing GPU performance. \n" + + "\n" + + "If true all LODs are drawn, even those behind \n" + + " the player's camera, decreasing GPU performance. \n" + + "\n" + + "Disable this if you see LODs disappearing at the corners of your vision.") .build(); public static ConfigEntry vanillaOverdraw = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.VANILLA_OVERDRAW_DESC) - .set(IAdvancedGraphics.VANILLA_OVERDRAW_DEFAULT) + .set(VanillaOverdraw.DYNAMIC) + .comment("" + + "How often should LODs be drawn on top of regular chunks? \n" + + "HALF and ALWAYS will prevent holes in the world, \n" + + " but may look odd for transparent blocks or in caves. \n" + + "\n" + + VanillaOverdraw.NEVER + ": \n" + + " LODs won't render on top of vanilla chunks. Use Overdraw offset to change the border offset. \n" + + VanillaOverdraw.DYNAMIC + ": \n" + + " LODs will render on top of distant vanilla chunks to hide delayed loading. \n" + + " Will dynamically decide the border offset based on vanilla render distance. \n" + + VanillaOverdraw.ALWAYS + ": \n" + + " LODs will render on all vanilla chunks preventing all holes in the world. \n" + + "\n" + + "This setting shouldn't affect performance.") .build(); public static ConfigEntry overdrawOffset = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.OVERDRAW_OFFSET_DESC) - .setMinDefaultMax(IAdvancedGraphics.OVERDRAW_OFFSET_MIN_DEFAULT_MAX) + .setMinDefaultMax(-16, 0, 16) + .comment("" + + "If on Vanilla Overdraw mode of NEVER, how much should should the border be offset? \n" + + "\n" + + " '1': The start of lods will be shifted inwards by 1 chunk, causing 1 chunk of overdraw. \n" + + " '-1': The start fo lods will be shifted outwards by 1 chunk, causing 1 chunk of gap. \n" + + "\n" + + "This setting can be used to deal with gaps due to our vanilla rendered chunk \n" + + " detection not being perfect.") .build(); public static ConfigEntry useExtendedNearClipPlane = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.USE_EXTENDED_NEAR_CLIP_PLANE_DESC) - .set(IAdvancedGraphics.USE_EXTENDED_NEAR_CLIP_PLANE_DEFAULT) + .set(true) + .comment("" + + "Will prevent some overdraw issues, but may cause nearby fake chunks to render incorrectly \n" + + " especially when in/near an ocean. \n" + + "\n" + + "This setting shouldn't affect performance.") .build(); public static ConfigEntry brightnessMultiplier = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.BRIGHTNESS_MULTIPLIER_DESC) - .set(IAdvancedGraphics.BRIGHTNESS_MULTIPLIER_DEFAULT) + .set(1.0) + .comment("" + + "How bright fake chunk colors are. \n" + + "\n" + + " 0 = black \n" + + " 1 = normal \n" + + " 2 = near white") .build(); public static ConfigEntry saturationMultiplier = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.SATURATION_MULTIPLIER_DESC) - .set(IAdvancedGraphics.SATURATION_MULTIPLIER_DEFAULT) + .set(1.0) + .comment("" + + "How saturated fake chunk colors are. \n" + + "\n" + + " 0 = black and white \n" + + " 1 = normal \n" + + " 2 = very saturated") .build(); public static ConfigEntry enableCaveCulling = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.ENABLE_CAVE_CULLING_DESC) - .set(IAdvancedGraphics.ENABLE_CAVE_CULLING_DEFAULT) + .set(true) + .comment("" + + "If enabled caves will be culled \n" + + "\n" + + "NOTE: This feature is under development and \n" + + " it is VERY experimental! Please don't report \n" + + " any issues related to this feature. \n" + + "\n" + + "Additional Info: Currently this cull all faces \n" + + " with skylight value of 0 in dimensions that \n" + + " does not have a ceiling.") .build(); public static ConfigEntry caveCullingHeight = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.CAVE_CULLING_HEIGHT_DESC) - .setMinDefaultMax(IAdvancedGraphics.CAVE_CULLING_HEIGHT_MIN_DEFAULT_MAX) + .setMinDefaultMax(-4096,40,4096) + .comment("At what Y value should cave culling start?") .build(); public static ConfigEntry earthCurveRatio = new ConfigEntry.Builder() - .comment(IAdvancedGraphics.EARTH_CURVE_RATIO_DESC) - .setMinDefaultMax(IAdvancedGraphics.EARTH_CURVE_RATIO_MIN_DEFAULT_MAX) + .setMinDefaultMax(0,0,5000) + .comment("" + + "This is the earth size ratio when applying the curvature shader effect. \n" + + "\n" + + "NOTE: This feature is just for fun and is VERY experimental! \n" + + "Please don't report any issues related to this feature. \n" + + "\n" + + " 0 = flat/disabled \n" + + " 1 = 1 to 1 (6,371,000 blocks) \n" + + " 100 = 1 to 100 (63,710 blocks) \n" + + " 10000 = 1 to 10000 (637.1 blocks) \n" + + "\n" + + "NOTE: Due to current limitations, the min value is 50 \n" + + " and the max value is 5000. Any values outside this range \n" + + " will be set to 0(disabled).") .build(); /* @@ -299,33 +498,130 @@ public class Config public static class WorldGenerator { public static ConfigEntry enableDistantGeneration = new ConfigEntry.Builder() - .comment(IWorldGenerator.ENABLE_DISTANT_GENERATION_DESC) - .set(IWorldGenerator.ENABLE_DISTANT_GENERATION_DEFAULT) + .set(true) + .comment("" + + "Whether to enable Distant chunks generator? \n" + + "\n" + + "Turning this on allows Distant Horizons to make lods for chunks \n" + + " that are outside of vanilla view distance. \n" + + "\n" + + "Note that in server, distant generation is always off.") .build(); public static ConfigEntry distanceGenerationMode = new ConfigEntry.Builder() -// .comment(IWorldGenerator.getDistanceGenerationModeDesc()) - .set(IWorldGenerator.DISTANCE_GENERATION_MODE_DEFAULT) + .set(DistanceGenerationMode.FEATURES) + .comment("" + + "How detailed should fake chunks be generated outside the vanilla render distance? \n" + + "\n" + + "The times are the amount of time it took one of the developer's PC to generate \n" + + " one chunk in Minecraft 1.16.5 and may be inaccurate for different Minecraft versions. \n" + + "They are included to give a rough estimate as to how the different options \n" + + " may perform in comparison to each other. \n" + + "(Note that all modes will load in already existing chunks) \n" + + "\n" + + DistanceGenerationMode.NONE + " \n" + + "Only run the Generator to load in already existing chunks. \n" + + "\n" + + DistanceGenerationMode.BIOME_ONLY + " \n" + + "Only generate the biomes and use the biome's \n" + + " grass color, water color, or snow color. \n" + + "Doesn't generate height, everything is shown at sea level. \n" + + " - Fastest (2-5 ms) \n" + + "\n" + + DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT + " \n" + + "Same as " + DistanceGenerationMode.BIOME_ONLY + ", except instead \n" + + " of always using sea level as the LOD height \n" + + " different biome types (mountain, ocean, forest, etc.) \n" + + " use predetermined heights to simulate having height data. \n" + + " - Fastest (2-5 ms) \n" + + "\n" + + DistanceGenerationMode.SURFACE + " \n" + + "Generate the world surface, \n" + + " this does NOT include trees, \n" + + " or structures. \n" + + " - Faster (10-20 ms) \n" + + "\n" + + DistanceGenerationMode.FEATURES + " \n" + + "Generate everything except structures. \n" + + "WARNING: This may cause world generation bugs or instability! \n" + + " - Fast (15-20 ms) \n" + + "\n" + + DistanceGenerationMode.FULL + " \n" + + "Ask the local server to generate/load each chunk. \n" + + "This will show player made structures, which can \n" + + " be useful if you are adding the mod to a pre-existing world. \n" + + "This is the most compatible, but causes server/simulation lag. \n" + + " - Slow (15-50 ms, with spikes up to 200 ms) \n" + + "\n" + + "The multithreaded options may increase CPU load significantly (while generating) \n" + + " depending on how many world generation threads you have allocated.") .build(); public static ConfigEntry lightGenerationMode = new ConfigEntry.Builder() - .comment(IWorldGenerator.LIGHT_GENERATION_MODE_DESC) - .set(IWorldGenerator.LIGHT_GENERATION_MODE_DEFAULT) + .set(LightGenerationMode.FANCY) + .comment("" + + "How should block and sky lights be processed for distant generation? \n" + + "\n" + + "Note that this include already existing chunks since vanilla \n" + + " does not store sky light values to save file. \n" + + "\n" + + LightGenerationMode.FAST + ": Use height map to fake the light values. \n" + + LightGenerationMode.FANCY + ": Use actaul light engines to generate proper values. \n" + + "\n" + + "This will effect generation speed, but not the rendering performance.") .build(); public static ConfigEntry generationPriority = new ConfigEntry.Builder() - .comment(IWorldGenerator.GENERATION_PRIORITY_DESC) - .set(IWorldGenerator.GENERATION_PRIORITY_DEFAULT) + .set(GenerationPriority.NEAR_FIRST) + .comment("" + + "In what priority should fake chunks be generated outside the vanilla render distance? \n" + + "\n" + + GenerationPriority.FAR_FIRST + " \n" + + "Fake chunks are generated from lowest to highest detail \n" + + " with a priority for far away regions. \n" + + "This fills in the world fastest, but you will have large low detail \n" + + " blocks for a while while the generation happens. \n" + + "\n" + + GenerationPriority.NEAR_FIRST + " \n" + + "Fake chunks are generated around the player \n" + + " in a spiral, similar to vanilla minecraft. \n" + + "Best used when on a server since we can't generate \n" + + " fake chunks. \n" + + "\n" + + GenerationPriority.BALANCED + " \n" + + "A mix between "+GenerationPriority.NEAR_FIRST+"and"+GenerationPriority.FAR_FIRST+". \n" + + "First prioritise completing nearby highest detail chunks, \n" + + " then focus on filling in the low detail areas away from the player. \n" + + "\n" + + GenerationPriority.AUTO + " \n" + + "Uses " + GenerationPriority.BALANCED + " when on a single player world \n" + + " and " + GenerationPriority.NEAR_FIRST + " when connected to a server. \n" + + "\n" + + "This shouldn't affect performance.") .build(); public static ConfigEntry blocksToAvoid = new ConfigEntry.Builder() - .comment(IWorldGenerator.BLOCKS_TO_AVOID_DESC) - .set(IWorldGenerator.BLOCKS_TO_AVOID_DEFAULT) + .set(BlocksToAvoid.BOTH) + .comment("" + + "When generating fake chunks, what blocks should be ignored? \n" + + "Ignored blocks don't affect the height of the fake chunk, but might affect the color. \n" + + "So using " + BlocksToAvoid.BOTH + " will prevent snow covered blocks from appearing one block too tall, \n" + + " but will still show the snow's color.\n" + + "\n" + + BlocksToAvoid.NONE + ": Use all blocks when generating fake chunks \n" + + BlocksToAvoid.NON_FULL + ": Only use full blocks when generating fake chunks (ignores slabs, lanterns, torches, tall grass, etc.) \n" + + BlocksToAvoid.NO_COLLISION + ": Only use solid blocks when generating fake chunks (ignores tall grass, torches, etc.) \n" + + BlocksToAvoid.BOTH + ": Only use full solid blocks when generating fake chunks \n" + + "\n" + + "This wont't affect performance.") .build(); public static ConfigEntry tintWithAvoidedBlocks = new ConfigEntry.Builder() - .comment(IWorldGenerator.TINT_WITH_AVOIDED_BLOCKS_DESC) - .set(IWorldGenerator.TINT_WITH_AVOIDED_BLOCKS_DEFAULT) + .set(true) + .comment("" + + "Should the blocks underneath avoided blocks gain the color of the avoided block? \n" + + " True: a red flower on grass will tint the grass below it red" + + " False: skipped blocks will not change color of surface below them") .build(); } @@ -333,13 +629,30 @@ public class Config public static class Multiplayer { public static ConfigEntry serverFolderNameMode = new ConfigEntry.Builder() - .comment(IMultiplayer.SERVER_FOLDER_NAME_MODE_DESC) - .set(IMultiplayer.SERVER_FOLDER_NAME_MODE_DEFAULT) + .set(ServerFolderNameMode.AUTO) + .comment("" + + " What multiplayer save folders should be named. \n" + + "\n" + + " " + ServerFolderNameMode.AUTO + ": " + ServerFolderNameMode.NAME_IP + " for LAN connections, " + ServerFolderNameMode.NAME_IP_PORT + " for all others. \n" + + " " + ServerFolderNameMode.NAME_ONLY + ": Example: \"Minecraft Server\" \n" + + " " + ServerFolderNameMode.NAME_IP + ": Example: \"Minecraft Server IP 192.168.1.40\" \n" + + " " + ServerFolderNameMode.NAME_IP_PORT + ": Example: \"Minecraft Server IP 192.168.1.40:25565\"") .build(); public static ConfigEntry multiDimensionRequiredSimilarity = new ConfigEntry.Builder() - .comment(IMultiplayer.MULTI_DIMENSION_REQUIRED_SIMILARITY_DESC) - .setMinDefaultMax(IMultiplayer.MULTI_DIMENSION_REQUIRED_SIMILARITY_MIN_DEFAULT_MAX) + .setMinDefaultMax(0.0, 0.0, 1.0) + .comment("" + + "When matching worlds of the same dimension type the \n" + + " tested chunks must be at least this percent the same \n" + + " in order to be considered the same world. \n" + + "\n" + + "Note: If you use portals to enter a dimension at two \n" + + " different locations this system may think it is two different worlds. \n" + + "\n" + + " 1.0 (100%) the chunks must be identical. \n" + + " 0.5 (50%) the chunks must be half the same. \n" + + " 0.0 (0%) disables multi-dimension support, \n" + + " only one world will be used per dimension.") .build(); } @@ -354,21 +667,56 @@ public class Config public static ConfigCategory buffers = new ConfigCategory.Builder().set(Buffers.class).build(); public static ConfigEntry lodOnlyMode = new ConfigEntry.Builder() - .comment(IAdvanced.LOD_ONLY_MODE_DESC) - .set(IAdvanced.LOD_ONLY_MODE_DEFAULT) + .set(false) + .comment("" + + "Due to some demand for playing without vanilla terrains, \n" + + " we decided to add this mode for fun. \n" + + "\n" + + "NOTE: Do not report any issues when this mode is on! \n" + + " Again, this setting is only for fun, and mod \n" + + " compatibility is not guaranteed.") .build(); public static class Threading { public static ConfigEntry numberOfWorldGenerationThreads = new ConfigEntry.Builder() - .comment(IThreading.NUMBER_OF_WORLD_GENERATION_THREADS_DESC) - .setMinDefaultMax(IThreading.NUMBER_OF_WORLD_GENERATION_THREADS_DEFAULT) + .setMinDefaultMax(0.1, + (double) Math.min(Runtime.getRuntime().availableProcessors()/2, 4), + (double) Runtime.getRuntime().availableProcessors()) + .comment("" + + "How many threads should be used when generating fake \n" + + " chunks outside the normal render distance? \n" + + "\n" + + "If it's less than 1, it will be treated as a percentage \n" + + " of time single thread can run before going to idle. \n" + + "\n" + + "If you experience stuttering when generating distant LODs, \n" + + " decrease this number. If you want to increase LOD \n" + + " generation speed, increase this number. \n" + + "\n" + + "This and the number of buffer builder threads are independent, \n" + + " so if they add up to more threads than your CPU has cores, \n" + + " that shouldn't cause an issue.") .build(); public static ConfigEntry numberOfBufferBuilderThreads = new ConfigEntry.Builder() - .comment(IThreading.NUMBER_OF_BUFFER_BUILDER_THREADS_DESC) - .setMinDefaultMax(IThreading.NUMBER_OF_BUFFER_BUILDER_THREADS_MIN_DEFAULT_MAX) + .setMinDefaultMax(1, + Math.min(Runtime.getRuntime().availableProcessors()/2, 2), + Runtime.getRuntime().availableProcessors()) + .comment("" + + "How many threads are used when building vertex buffers? \n" + + " (The things sent to your GPU to draw the fake chunks). \n" + + "\n" + + "If you experience high CPU usage when NOT generating distant \n" + + " fake chunks, lower this number. A higher number will make fake\n" + + " fake chunks' transition faster when moving around the world. \n" + + "\n" + + "This and the number of world generator threads are independent, \n" + + " so if they add up to more threads than your CPU has cores, \n" + + " that shouldn't cause an issue. \n" + + "\n" + + "The maximum value is the number of logical processors on your CPU.") .build(); } @@ -376,18 +724,36 @@ public class Config public static class Debugging { public static ConfigEntry rendererType = new ConfigEntry.Builder() - .comment(IDebugging.RENDERER_TYPE_DESC) - .set(IDebugging.RENDERER_TYPE_DEFAULT) + .set(RendererType.DEFAULT) + .comment("" + + "What renderer is active? \n" + + "\n" + + RendererType.DEFAULT + ": Default lod renderer \n" + + RendererType.DEBUG + ": Debug testing renderer \n" + + RendererType.DISABLED + ": Disable rendering") .build(); public static ConfigEntry debugMode = new ConfigEntry.Builder() - .comment(IDebugging.DEBUG_MODE_DESC) - .set(IDebugging.DEBUG_MODE_DEFAULT) + .set(DebugMode.OFF) + .comment("" + + "Should specialized colors/rendering modes be used? \n" + + "\n" + + DebugMode.OFF + ": Fake chunks will be drawn with their normal colors. \n" + + DebugMode.SHOW_WIREFRAME + ": Fake chunks will be drawn as wireframes. \n" + + DebugMode.SHOW_DETAIL + ": Fake chunks color will be based on their detail level. \n" + + DebugMode.SHOW_DETAIL_WIREFRAME + ": Fake chunks color will be based on their detail level, drawn as a wireframe. \n" + + DebugMode.SHOW_GENMODE + ": Fake chunks color will be based on their distant generation mode. \n" + + DebugMode.SHOW_GENMODE_WIREFRAME + ": Fake chunks color will be based on their distant generation mode, drawn as a wireframe. \n" + + DebugMode.SHOW_OVERLAPPING_QUADS + ": Fake chunks will be drawn with total white, but overlapping quads will be drawn with red. \n" + + DebugMode.SHOW_OVERLAPPING_QUADS_WIREFRAME + ": Fake chunks will be drawn with total white, \n" + + " but overlapping quads will be drawn with red, drawn as a wireframe.") .build(); public static ConfigEntry enableDebugKeybindings = new ConfigEntry.Builder() - .comment(IDebugging.DEBUG_KEYBINDINGS_ENABLED_DESC) - .set(IDebugging.DEBUG_KEYBINDINGS_ENABLED_DEFAULT) + .set(false) + .comment("" + + "If true the F8 key can be used to cycle through the different debug modes. \n" + + " and the F6 key can be used to enable and disable LOD rendering.") .build(); public static ConfigCategory debugSwitch = new ConfigCategory.Builder().set(DebugSwitch.class).build(); @@ -406,48 +772,66 @@ public class Config * NetworkEvent //NOT IMPL YET */ public static ConfigEntry logWorldGenEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_WORLDGEN_EVENT_DESC) - .set(IDebugSwitch.LOG_WORLDGEN_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about the world generation process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logWorldGenPerformance = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_WORLDGEN_PERFORMANCE_DESC) - .set(IDebugSwitch.LOG_WORLDGEN_PERFORMANCE_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_FILE) + .comment("" + + "If enabled, the mod will log performance about the world generation process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logWorldGenLoadEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_WORLDGEN_LOAD_EVENT_DESC) - .set(IDebugSwitch.LOG_WORLDGEN_LOAD_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_FILE) + .comment("" + + "If enabled, the mod will log information about the world generation process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logLodBuilderEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_LODBUILDER_EVENT_DESC) - .set(IDebugSwitch.LOG_LODBUILDER_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about the LOD generation process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logRendererBufferEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_RENDERER_BUFFER_EVENT_DESC) - .set(IDebugSwitch.LOG_RENDERER_BUFFER_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about the renderer buffer process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logRendererGLEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_RENDERER_GL_EVENT_DESC) - .set(IDebugSwitch.LOG_RENDERER_GL_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about the renderer OpenGL process. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logFileReadWriteEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_FILE_READWRITE_EVENT_DESC) - .set(IDebugSwitch.LOG_FILE_READWRITE_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about file read/write operations. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logFileSubDimEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_FILE_SUB_DIM_EVENT_DESC) - .set(IDebugSwitch.LOG_FILE_SUB_DIM_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about file sub-dimension operations. \n" + + "This can be useful for debugging.") .build(); public static ConfigEntry logNetworkEvent = new ConfigEntry.Builder() - .comment(IDebugSwitch.LOG_NETWORK_EVENT_DESC) - .set(IDebugSwitch.LOG_NETWORK_EVENT_DEFAULT) + .set(LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE) + .comment("" + + "If enabled, the mod will log information about network operations. \n" + + "This can be useful for debugging.") .build(); } } @@ -456,18 +840,47 @@ public class Config public static class Buffers { public static ConfigEntry gpuUploadMethod = new ConfigEntry.Builder() - .comment(IBuffers.GPU_UPLOAD_METHOD_DESC) - .set(IBuffers.GPU_UPLOAD_METHOD_DEFAULT) + .set(GpuUploadMethod.AUTO) + .comment("" + + "What method should be used to upload geometry to the GPU? \n" + + "\n" + + GpuUploadMethod.AUTO + ": Picks the best option based on the GPU you have. \n" + + GpuUploadMethod.BUFFER_STORAGE + ": Default for NVIDIA if OpenGL 4.5 is supported. \n" + + " Fast rendering, no stuttering. \n" + + GpuUploadMethod.SUB_DATA + ": Backup option for NVIDIA. \n" + + " Fast rendering but may stutter when uploading. \n" + + GpuUploadMethod.BUFFER_MAPPING + ": Slow rendering but won't stutter when uploading. Possibly the best option for integrated GPUs. \n" + + " Default option for AMD/Intel. \n" + + " May end up storing buffers in System memory. \n" + + " Fast rendering if in GPU memory, slow if in system memory, \n" + + " but won't stutter when uploading. \n" + + GpuUploadMethod.DATA + ": Fast rendering but will stutter when uploading. \n" + + " Backup option for AMD/Intel. \n" + + " Fast rendering but may stutter when uploading. \n" + + "\n" + + "If you don't see any difference when changing these settings, or the world looks corrupted: \n" + + "Restart the game to clear the old buffers.") .build(); public static ConfigEntry gpuUploadPerMegabyteInMilliseconds = new ConfigEntry.Builder() - .comment(IBuffers.GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DESC) - .setMinDefaultMax(IBuffers.GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DEFAULT) + .setMinDefaultMax(0, 0, 50) + .comment("" + + "How long should a buffer wait per Megabyte of data uploaded?\n" + + "Helpful resource for frame times: https://fpstoms.com \n" + + "\n" + + "Longer times may reduce stuttering but will make fake chunks \n" + + " transition and load slower. Change this to [0] for no timeout.\n" + + "\n" + + "NOTE:\n" + + "Before changing this config, try changing \"GPU Upload methods\"\n" + + " and determined the best method for your hardware first.") .build(); public static ConfigEntry rebuildTimes = new ConfigEntry.Builder() - .comment(IBuffers.REBUILD_TIMES_DESC) - .set(IBuffers.REBUILD_TIMES_DEFAULT) + .set(BufferRebuildTimes.NORMAL) + .comment("" + + "How frequently should vertex buffers (geometry) be rebuilt and sent to the GPU? \n" + + "Higher settings may cause stuttering, but will prevent holes in the world") .build(); } } diff --git a/src/main/java/com/seibel/lod/core/config/file/ConfigFileHandling.java b/src/main/java/com/seibel/lod/core/config/file/ConfigFileHandling.java index 208e142fe..9ad5d3a3c 100644 --- a/src/main/java/com/seibel/lod/core/config/file/ConfigFileHandling.java +++ b/src/main/java/com/seibel/lod/core/config/file/ConfigFileHandling.java @@ -145,7 +145,9 @@ public class ConfigFileHandling { public static void createComment(ConfigEntry entry, CommentedFileConfig workConfig) { if (!entry.getAppearance().showInFile) return; - workConfig.setComment(entry.getNameWCategory(), entry.getComment()); + if (entry.getComment() != null) { + workConfig.setComment(entry.getNameWCategory(), " " + entry.getComment().replaceAll("\n", "\n ") + "\n "); + } } diff --git a/src/main/java/com/seibel/lod/core/config/types/ConfigEntry.java b/src/main/java/com/seibel/lod/core/config/types/ConfigEntry.java index 1a6d5375a..a04fdabb2 100644 --- a/src/main/java/com/seibel/lod/core/config/types/ConfigEntry.java +++ b/src/main/java/com/seibel/lod/core/config/types/ConfigEntry.java @@ -3,7 +3,6 @@ package com.seibel.lod.core.config.types; import com.seibel.lod.core.config.ConfigBase; import com.seibel.lod.core.config.ConfigEntryAppearance; import com.seibel.lod.core.config.file.ConfigFileHandling; -import com.seibel.lod.core.objects.MinDefaultMax; /** * Use for making the config variables @@ -53,13 +52,6 @@ public class ConfigEntry extends AbstractConfigType> { return value; } - public MinDefaultMax getMinValueMax() { - return new MinDefaultMax(min, value, max); - } - public MinDefaultMax getMinDefaultMax() { - return new MinDefaultMax(min, defaultValue, max); - } - /** Sets the value without saving */ public void setWTSave(T newValue) { this.value = newValue; @@ -149,7 +141,7 @@ public class ConfigEntry extends AbstractConfigType> { } public static class Builder extends AbstractConfigType.Builder> { - private String tmpComment; + private String tmpComment = null; private T tmpMin; private T tmpMax; private boolean tmpUseApiOverwrite; @@ -159,9 +151,9 @@ public class ConfigEntry extends AbstractConfigType> { return this; } - public Builder setMinDefaultMax(MinDefaultMax newMinDefaultMax) { - this.set(newMinDefaultMax.defaultValue); - this.setMinMax(newMinDefaultMax.minValue, newMinDefaultMax.maxValue); + public Builder setMinDefaultMax(T newMin, T newDefault, T newMax) { + this.set(newDefault); + this.setMinMax(newMin, newMax); return this; } diff --git a/src/main/java/com/seibel/lod/core/objects/MinDefaultMax.java b/src/main/java/com/seibel/lod/core/objects/MinDefaultMax.java deleted file mode 100644 index 8c6726df8..000000000 --- a/src/main/java/com/seibel/lod/core/objects/MinDefaultMax.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * This file is part of the Distant Horizons mod (formerly the LOD Mod), - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020-2022 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * 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 Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.lod.core.objects; - -/** - * Used when setting up configuration fields. - * - * @author James Seibel - * @version 11-14-2021 - * @param The data type this object is storing - */ -@Deprecated -public class MinDefaultMax -{ - public final T minValue; - public final T defaultValue; - public final T maxValue; - - public MinDefaultMax(T newMinValue, T newDefaultValue, T newMaxValue) - { - minValue = newMinValue; - defaultValue = newDefaultValue; - maxValue = newMaxValue; - } -} diff --git a/src/main/java/com/seibel/lod/core/objects/a7/data/DataHandler.java b/src/main/java/com/seibel/lod/core/objects/a7/data/DataHandler.java index 6d80a4a97..897577237 100644 --- a/src/main/java/com/seibel/lod/core/objects/a7/data/DataHandler.java +++ b/src/main/java/com/seibel/lod/core/objects/a7/data/DataHandler.java @@ -2,6 +2,7 @@ package com.seibel.lod.core.objects.a7.data; import com.seibel.lod.core.objects.a7.RenderDataContainer; import com.seibel.lod.core.objects.a7.RenderDataSource; +import com.seibel.lod.core.objects.a7.pos.DhSectionPos; import java.io.File; @@ -13,7 +14,7 @@ public class DataHandler implements RenderDataSource { } @Override - public RenderDataContainer createRenderData(byte detailLevel, int x, int z) { + public RenderDataContainer createRenderData(DhSectionPos pos) { //TODO diff --git a/src/main/java/com/seibel/lod/core/wrapperInterfaces/config/ILodConfigWrapperSingleton.java b/src/main/java/com/seibel/lod/core/wrapperInterfaces/config/ILodConfigWrapperSingleton.java index 488b67318..f31f168ba 100644 --- a/src/main/java/com/seibel/lod/core/wrapperInterfaces/config/ILodConfigWrapperSingleton.java +++ b/src/main/java/com/seibel/lod/core/wrapperInterfaces/config/ILodConfigWrapperSingleton.java @@ -23,8 +23,6 @@ import com.seibel.lod.core.enums.config.*; import com.seibel.lod.core.enums.rendering.*; import com.seibel.lod.core.handlers.dependencyInjection.IBindable; import com.seibel.lod.core.handlers.dependencyInjection.SingletonHandler; -import com.seibel.lod.core.objects.MinDefaultMax; -import com.seibel.lod.core.wrapperInterfaces.IVersionConstants; import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; /** @@ -34,8 +32,8 @@ import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; public interface ILodConfigWrapperSingleton extends IBindable { IClient client(); - - + + @Deprecated interface IClient { IGraphics graphics(); @@ -43,10 +41,6 @@ public interface ILodConfigWrapperSingleton extends IBindable IMultiplayer multiplayer(); IAdvanced advanced(); - - boolean OPTIONS_BUTTON_DEFAULT = true; - String OPTIONS_BUTTON_DESC = "" - + " Show the lod button in the options screen next to fov"; boolean getOptionsButton(); void setOptionsButton(boolean newOptionsButton); @@ -54,93 +48,31 @@ public interface ILodConfigWrapperSingleton extends IBindable //==================// // Graphics Configs // //==================// + @Deprecated interface IGraphics { - String DESC = "These settings control how the mod will look in game"; - IQuality quality(); IFogQuality fogQuality(); -// ICloudQuality cloudQuality(); IAdvancedGraphics advancedGraphics(); - - + + @Deprecated interface IQuality { - String DESC = "These settings control how detailed the fake chunks will be."; - - HorizontalResolution DRAW_RESOLUTION_DEFAULT = HorizontalResolution.BLOCK; - String DRAW_RESOLUTION_DESC = "" - + " What is the maximum detail fake chunks should be drawn at? \n" - + " This setting will only affect closer chunks.\n" - + " Higher settings will increase memory and GPU usage. \n" - + "\n" - + " " + HorizontalResolution.CHUNK + ": render 1 LOD for each Chunk. \n" - + " " + HorizontalResolution.HALF_CHUNK + ": render 4 LODs for each Chunk. \n" - + " " + HorizontalResolution.FOUR_BLOCKS + ": render 16 LODs for each Chunk. \n" - + " " + HorizontalResolution.TWO_BLOCKS + ": render 64 LODs for each Chunk. \n" - + " " + HorizontalResolution.BLOCK + ": render 256 LODs for each Chunk (width of one block). \n" - + "\n" - + " Lowest Quality: " + HorizontalResolution.CHUNK - + " Highest Quality: " + HorizontalResolution.BLOCK; HorizontalResolution getDrawResolution(); void setDrawResolution(HorizontalResolution newHorizontalResolution); - - MinDefaultMax LOD_CHUNK_RENDER_DISTANCE_MIN_DEFAULT_MAX = new MinDefaultMax(32, 128, 2048); - String LOD_CHUNK_RENDER_DISTANCE_DESC = "" - + " The radius of the mod's render distance. (measured in chunks) \n"; + int getLodChunkRenderDistance(); void setLodChunkRenderDistance(int newLodChunkRenderDistance); - - VerticalQuality VERTICAL_QUALITY_DEFAULT = VerticalQuality.MEDIUM; - String VERTICAL_QUALITY_DESC = "" - + " This indicates how detailed fake chunks will represent \n" - + " overhangs, caves, floating islands, ect. \n" - + " Higher options will make the world more accurate, but" - + " will increase memory and GPU usage. \n" - + "\n" - + " " + VerticalQuality.LOW + ": uses at max 2 columns per position. \n" - + " " + VerticalQuality.MEDIUM + ": uses at max 4 columns per position. \n" - + " " + VerticalQuality.HIGH + ": uses at max 8 columns per position. \n" - + "\n" - + " Lowest Quality: " + VerticalQuality.LOW - + " Highest Quality: " + VerticalQuality.HIGH; + VerticalQuality getVerticalQuality(); void setVerticalQuality(VerticalQuality newVerticalQuality); - - MinDefaultMax HORIZONTAL_SCALE_MIN_DEFAULT_MAX = new MinDefaultMax(2, 12, 64); - String HORIZONTAL_SCALE_DESC = "" - + " This indicates how quickly fake chunks decrease in quality the further away they are. \n" - + " Higher settings will render higher quality fake chunks farther away, \n" - + " but will increase memory and GPU usage."; + int getHorizontalScale(); void setHorizontalScale(int newHorizontalScale); - - HorizontalQuality HORIZONTAL_QUALITY_DEFAULT = HorizontalQuality.MEDIUM; - String HORIZONTAL_QUALITY_DESC = "" - + " This indicates how much farther away each drop in quality is. \n" - + "\n" - + " " + HorizontalQuality.LOWEST + ": each drop in quality is the same distance away. \n" - + " " + HorizontalQuality.LOW + ": each drop in quality is " + HorizontalQuality.LOW.quadraticBase + " times farther away. \n" - + " " + HorizontalQuality.MEDIUM + ": each drop in quality is " + HorizontalQuality.MEDIUM.quadraticBase + " times farther away. \n" - + " " + HorizontalQuality.HIGH + ": each drop in quality is " + HorizontalQuality.HIGH.quadraticBase + " times farther away. \n" - + "\n" - + " Lowest Quality: " + HorizontalQuality.LOWEST - + " Highest Quality: " + HorizontalQuality.HIGH; + HorizontalQuality getHorizontalQuality(); void setHorizontalQuality(HorizontalQuality newHorizontalQuality); - - DropoffQuality DROPOFF_QUALITY_DEFAULT = DropoffQuality.AUTO; - String DROPOFF_QUALITY_DESC = "" - + " This determines how lod level drop off will be done. \n" - + "\n" - + " " + DropoffQuality.SMOOTH_DROPOFF + ": \n" - + " The lod level is calculated for each point, making the drop off a smooth circle. \n" - + " " + DropoffQuality.PERFORMANCE_FOCUSED + ": \n" - + " One detail level for an entire region. Minimize CPU usage and \n" - + " improve terrain refresh delay, especially for high Lod render distance. \n" - + " " + DropoffQuality.AUTO + ": \n" - + " Use "+ DropoffQuality.SMOOTH_DROPOFF + " for less then 128 Lod render distance, \n" - + " or "+ DropoffQuality.PERFORMANCE_FOCUSED +" otherwise. \n"; + DropoffQuality getDropoffQuality(); void setDropoffQuality(DropoffQuality newDropoffQuality); default DropoffQuality getResolvedDropoffQuality() { @@ -151,222 +83,72 @@ public interface ILodConfigWrapperSingleton extends IBindable return dropoffQuality; } - MinDefaultMax LOD_BIOME_BLENDING_MIN_DEFAULT_MAX = new MinDefaultMax(0,1,7); - String LOD_BIOME_BLENDING_DESC = "" - + " This is the same as vanilla Biome Blending settings for Lod area. \n" + - " Note that anything other than '0' will greatly effect Lod building time \n" + - " and increase triangle count. The cost on chunk generation speed is also \n" + - " quite large if set too high.\n" + - "\n" + - " '0' equals to Vanilla Biome Blending of '1x1' or 'OFF', \n" + - " '1' equals to Vanilla Biome Blending of '3x3', \n" + - " '2' equals to Vanilla Biome Blending of '5x5'... \n"; int getLodBiomeBlending(); void setLodBiomeBlending(int newLodBiomeBlending); } - + @Deprecated interface IFogQuality { - String DESC = "These settings control the fog quality."; - - FogDistance FOG_DISTANCE_DEFAULT = FogDistance.FAR; - String FOG_DISTANCE_DESC = "" - + " At what distance should Fog be drawn on the fake chunks? \n" - + "\n" - + " This setting shouldn't affect performance."; FogDistance getFogDistance(); void setFogDistance(FogDistance newFogDistance); - FogDrawMode FOG_DRAW_MODE_DEFAULT = FogDrawMode.FOG_ENABLED; - String FOG_DRAW_MODE_DESC = "" - + " When should fog be drawn? \n" - + "\n" - + " " + FogDrawMode.USE_OPTIFINE_SETTING + ": Use whatever Fog setting Optifine is using.\n" - + " If Optifine isn't installed this defaults to " + FogDrawMode.FOG_ENABLED + ". \n" - + " " + FogDrawMode.FOG_ENABLED + ": Never draw fog on the LODs \n" - + " " + FogDrawMode.FOG_DISABLED + ": Always draw fast fog on the LODs \n" - + "\n" - + " Disabling fog will improve GPU performance."; FogDrawMode getFogDrawMode(); void setFogDrawMode(FogDrawMode newFogDrawMode); - - FogColorMode FOG_COLOR_MODE_DEFAULT = FogColorMode.USE_WORLD_FOG_COLOR; - String FOG_COLOR_MODE_DESC = "" - + " What color should fog use? \n" - + "\n" - + " " + FogColorMode.USE_WORLD_FOG_COLOR + ": Use the world's fog color. \n" - + " " + FogColorMode.USE_SKY_COLOR + ": Use the sky's color. \n" - + "\n" - + " This setting doesn't affect performance."; + FogColorMode getFogColorMode(); void setFogColorMode(FogColorMode newFogColorMode); - - boolean DISABLE_VANILLA_FOG_DEFAULT = true; - String DISABLE_VANILLA_FOG_DESC = "" - + " If true disable Minecraft's fog. \n" - + "\n" - + " Experimental! Mod support is not guarantee."; + boolean getDisableVanillaFog(); void setDisableVanillaFog(boolean newDisableVanillaFog); IAdvancedFog advancedFog(); - + @Deprecated interface IAdvancedFog { - String DESC = "Advanced settings for fog rendering. Has no effect if Far Fog is not drawn \n" - + "See https://www.desmos.com/calculator/?????? for how setting effect the curve."; - - MinDefaultMax FOG_RANGE = new MinDefaultMax<>(0.0,1.0, Math.sqrt(2.0)); - - MinDefaultMax FAR_FOG_START_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue,0.0, FOG_RANGE.maxValue); - String FAR_FOG_START_DESC = "" - + " Where should the far fog start? \n" - + "\n" - + " '0.0': Fog start at player's position.\n" - + " '1.0': The fog-start's circle fit just in the lod render distance square.\n" - + " '1.414': The lod render distance square fit just in the fog-start's circle.\n"; double getFarFogStart(); void setFarFogStart(double newFarFogStart); - MinDefaultMax FAR_FOG_END_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue,1.0, FOG_RANGE.maxValue); - String FAR_FOG_END_DESC = "" - + " Where should the far fog end? \n" - + "\n" - + " '0.0': Fog end at player's position.\n" - + " '1.0': The fog-end's circle fit just in the lod render distance square.\n" - + " '1.414': The lod render distance square fit just in the fog-end's circle.\n"; double getFarFogEnd(); void setFarFogEnd(double newFarFogEnd); - MinDefaultMax FAR_FOG_MIN_MIN_DEFAULT_MAX = new MinDefaultMax<>(-5.0,0.0, FOG_RANGE.maxValue); - String FAR_FOG_MIN_DESC = "" - + " What is the minimum fog thickness? \n" - + "\n" - + " '0.0': No fog at all.\n" - + " '1.0': Fully fog color.\n"; double getFarFogMin(); void setFarFogMin(double newFarFogMin); - MinDefaultMax FAR_FOG_MAX_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue,1.0, 5.0); - String FAR_FOG_MAX_DESC = "" - + " What is the maximum fog thickness? \n" - + "\n" - + " '0.0': No fog at all.\n" - + " '1.0': Fully fog color.\n"; double getFarFogMax(); void setFarFogMax(double newFarFogMax); - FogSetting.FogType FAR_FOG_TYPE_DEFAULT = FogSetting.FogType.EXPONENTIAL_SQUARED; - String FAR_FOG_TYPE_DESC = "" - + " How the fog thickness should be calculated from distance? \n" - + "\n" - + " "+ FogSetting.FogType.LINEAR + ": Linear based on distance (will ignore 'density')\n" - + " "+ FogSetting.FogType.EXPONENTIAL + ": 1/(e^(distance*density)) \n" - + " "+ FogSetting.FogType.EXPONENTIAL_SQUARED + ": 1/(e^((distance*density)^2) \n"; - //+ " "+ FogSetting.Type.TEXTURE_BASED + ": Use a provided 1D texture mapping (will ignore 'density', 'min', and 'max')\n"; FogSetting.FogType getFarFogType(); void setFarFogType(FogSetting.FogType newFarFogType); - MinDefaultMax FAR_FOG_DENSITY_MIN_DEFAULT_MAX = new MinDefaultMax<>(0.01,2.5, 50.0); - String FAR_FOG_DENSITY_DESC = "" - + " What is the fog density? \n"; double getFarFogDensity(); void setFarFogDensity(double newFarFogDensity); IHeightFog heightFog(); + @Deprecated interface IHeightFog { - String DESC = "Advanced settings for how far fog interacts with height. Has no effect if Far Fog is not drawn \n" - + "See https://www.desmos.com/calculator/drzzlfmur9 for how setting effect the curve."; - - HeightFogMixMode HEIGHT_FOG_MIX_MODE_DEFAULT = HeightFogMixMode.BASIC; - String HEIGHT_FOG_MIX_MODE_DESC = "" - + " How the height should effect the fog thickness combined with the normal function? \n" - + "\n" - + " " + HeightFogMixMode.BASIC + ": No special height fog effect. Fog is calculated based on camera distance \n" - + " " + HeightFogMixMode.IGNORE_HEIGHT + ": Ignore height completely. Fog is calculated based on horizontal distance \n" - + " " + HeightFogMixMode.ADDITION + ": heightFog + farFog \n" - + " " + HeightFogMixMode.MAX + ": max(heightFog, farFog) \n" - + " " + HeightFogMixMode.MULTIPLY + ": heightFog * farFog \n" - + " " + HeightFogMixMode.INVERSE_MULTIPLY + ": 1 - (1-heightFog) * (1-farFog) \n" - + " " + HeightFogMixMode.LIMITED_ADDITION + ": farFog + max(farFog, heightFog) \n" - + " " + HeightFogMixMode.MULTIPLY_ADDITION + ": farFog + farFog * heightFog \n" - + " " + HeightFogMixMode.INVERSE_MULTIPLY_ADDITION + ": farFog + 1 - (1-heightFog) * (1-farFog) \n" - + " " + HeightFogMixMode.AVERAGE + ": farFog*0.5 + heightFog*0.5 \n" - + "\n" - + " Note that for 'BASIC' mode and 'IGNORE_HEIGHT' mode, fog settings for height fog has no effect.\n"; HeightFogMixMode getHeightFogMixMode(); void setHeightFogMixMode(HeightFogMixMode newHeightFogMixMode); - HeightFogMode HEIGHT_FOG_MODE_DEFAULT = HeightFogMode.ABOVE_AND_BELOW_CAMERA; - String HEIGHT_FOG_MODE_DESC = "" - + " Where should the height fog be located? \n" - + "\n" - + " " + HeightFogMode.ABOVE_CAMERA + ": Height fog starts from camera to the sky \n" - + " " + HeightFogMode.BELOW_CAMERA + ": Height fog starts from camera to the void \n" - + " " + HeightFogMode.ABOVE_AND_BELOW_CAMERA + ": Height fog starts from camera to both the sky and the void \n" - + " " + HeightFogMode.ABOVE_SET_HEIGHT + ": Height fog starts from a set height to the sky \n" - + " " + HeightFogMode.BELOW_SET_HEIGHT + ": Height fog starts from a set height to the void \n" - + " " + HeightFogMode.ABOVE_AND_BELOW_SET_HEIGHT + ": Height fog starts from a set height to both the sky and the void \n" - + "\n"; HeightFogMode getHeightFogMode(); void setHeightFogMode(HeightFogMode newHeightFogMode); - MinDefaultMax HEIGHT_FOG_HEIGHT_MIN_DEFAULT_MAX = new MinDefaultMax<>(-4096., 70., 4096.); - String HEIGHT_FOG_HEIGHT_DESC = "" - + " If the height fog is calculated around a set height, what is that height position? \n" - + "\n"; double getHeightFogHeight(); void setHeightFogHeight(double newHeightFogHeight); - MinDefaultMax HEIGHT_FOG_START_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue, 0.0, FOG_RANGE.maxValue); - String HEIGHT_FOG_START_DESC = "" - + " How far the start of height fog should offset? \n" - + "\n" - + " '0.0': Fog start with no offset.\n" - + " '1.0': Fog start with offset of the entire world's height. (Include depth)\n"; double getHeightFogStart(); void setHeightFogStart(double newHeightFogStart); - MinDefaultMax HEIGHT_FOG_END_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue, 1.0, FOG_RANGE.maxValue); - String HEIGHT_FOG_END_DESC = "" - + " How far the end of height fog should offset? \n" - + "\n" - + " '0.0': Fog end with no offset.\n" - + " '1.0': Fog end with offset of the entire world's height. (Include depth)\n"; double getHeightFogEnd(); void setHeightFogEnd(double newHeightFogEnd); - MinDefaultMax HEIGHT_FOG_MIN_MIN_DEFAULT_MAX = new MinDefaultMax<>(-5.0, 0.0, FOG_RANGE.maxValue); - String HEIGHT_FOG_MIN_DESC = "" - + " What is the minimum fog thickness? \n" - + "\n" - + " '0.0': No fog at all.\n" - + " '1.0': Fully fog color.\n"; double getHeightFogMin(); void setHeightFogMin(double newHeightFogMin); - MinDefaultMax HEIGHT_FOG_MAX_MIN_DEFAULT_MAX = new MinDefaultMax<>(FOG_RANGE.minValue, 1.0, 5.0); - String HEIGHT_FOG_MAX_DESC = "" - + " What is the maximum fog thickness? \n" - + "\n" - + " '0.0': No fog at all.\n" - + " '1.0': Fully fog color.\n"; double getHeightFogMax(); void setHeightFogMax(double newHeightFogMax); - FogSetting.FogType HEIGHT_FOG_TYPE_DEFAULT = FogSetting.FogType.EXPONENTIAL_SQUARED; - String HEIGHT_FOG_TYPE_DESC = "" - + " How the fog thickness should be calculated from height? \n" - + "\n" - + " " + FogSetting.FogType.LINEAR + ": Linear based on height (will ignore 'density')\n" - + " " + FogSetting.FogType.EXPONENTIAL + ": 1/(e^(height*density)) \n" - + " " + FogSetting.FogType.EXPONENTIAL_SQUARED + ": 1/(e^((height*density)^2) \n"; - //+ " "+ FogSetting.Type.TEXTURE_BASED + ": Use a provided 1D texture mapping (will ignore 'density', 'min', and 'max')\n"; FogSetting.FogType getHeightFogType(); void setHeightFogType(FogSetting.FogType newFarFogType); - MinDefaultMax HEIGHT_FOG_DENSITY_MIN_DEFAULT_MAX = new MinDefaultMax<>(0.01, 2.5, 50.0); - String HEIGHT_FOG_DENSITY_DESC = "" - + " What is the fog density? \n"; double getHeightFogDensity(); void setHeightFogDensity(double newHeightFogDensity); @@ -393,90 +175,15 @@ public interface ILodConfigWrapperSingleton extends IBindable } } } - - /* - interface ICloudQuality - { - String DESC = "These settings control the clouds."; - - boolean CUSTOM_CLOUDS_DEFAULT = false; - String CUSTOM_CLOUDS_DESC = "" - + " Should we use our own method for rendering clouds \n" - + "\n" - + " If you disable this then the rest of the cloud configs wont work. \n"; - boolean getCustomClouds(); - void setCustomClouds(boolean newCustomClouds); - - boolean COOL_CLOUDS_DEFAULT = false; - String COOL_CLOUDS_DESC = "" - + " THIS IS NOT IMPLEMENTED YET SO DONT USE \n" - + " A complete rework on how clouds work \n" - + " Rather than getting from a texure and rendering that \n" - + " It gets the terrain height and decides how much cloud to put \n" - + " This idea came from this 11 year old(as of when this is being written) \n" - + "reddit post https://www.reddit.com/r/Minecraft/comments/e7xol/this_is_how_clouds_should_work_gif_simulation/ \n"; - boolean getCoolClouds(); - void setCoolClouds(boolean newFabulousClouds); - - boolean EXTEND_CLOUDS_DEFAULT = true; - String EXTEND_CLOUDS_DESC = "" - + " Extends how far the clouds render \n" - + " to the lod render distance \n"; - boolean getExtendClouds(); - void setExtendClouds(boolean newExtendClouds); - - MinDefaultMax CLOUD_HEIGHT_MIN_DEFAULT_MAX = new MinDefaultMax(Double.MIN_VALUE, 0., Double.MAX_VALUE); // make it get minecraft cloud height - String CLOUD_HEIGHT_DESC = "" - + " What y level to render the clouds at \n"; - double getCloudHeight(); - void setCloudHeight(double newCloudHeight); - } - */ - + @Deprecated interface IAdvancedGraphics { - String DESC = "Graphics options that are a bit more technical."; - - boolean DISABLE_DIRECTIONAL_CULLING_DEFAULT = false; - String DISABLE_DIRECTIONAL_CULLING_DESC = "" - + " If false fake chunks behind the player's camera \n" - + " aren't drawn, increasing GPU performance. \n" - + "\n" - + " If true all LODs are drawn, even those behind \n" - + " the player's camera, decreasing GPU performance. \n" - + "\n" - + " Disable this if you see LODs disappearing at the corners of your vision. \n"; boolean getDisableDirectionalCulling(); void setDisableDirectionalCulling(boolean newDisableDirectionalCulling); - VanillaOverdraw VANILLA_OVERDRAW_DEFAULT = VanillaOverdraw.DYNAMIC; - String VANILLA_OVERDRAW_DESC = "" - + " How often should LODs be drawn on top of regular chunks? \n" - + " HALF and ALWAYS will prevent holes in the world, \n" - + " but may look odd for transparent blocks or in caves. \n" - + "\n" - + " " + VanillaOverdraw.NEVER + ": \n" - + " LODs won't render on top of vanilla chunks. Use Overdraw offset to change the border offset. \n" - + " " + VanillaOverdraw.DYNAMIC + ": \n" - + " LODs will render on top of distant vanilla chunks to hide delayed loading. \n" - + " Will dynamically decide the border offset based on vanilla render distance. \n" - + " " + VanillaOverdraw.ALWAYS + ": \n" - + " LODs will render on all vanilla chunks preventing all holes in the world. \n" - + "\n" - + " This setting shouldn't affect performance. \n"; VanillaOverdraw getVanillaOverdraw(); void setVanillaOverdraw(VanillaOverdraw newVanillaOverdraw); - - MinDefaultMax OVERDRAW_OFFSET_MIN_DEFAULT_MAX = new MinDefaultMax(-16, 0, 16); - String OVERDRAW_OFFSET_DESC = "" - + " If on Vanilla Overdraw mode of NEVER, how much should should the border be offset? \n" - + "\n" - + " '1': The start of lods will be shifted inwards by 1 chunk, causing 1 chunk of overdraw. \n" - + " '-1': The start fo lods will be shifted outwards by 1 chunk, causing 1 chunk of gap. \n" - + "\n" - + " This setting can be used to deal with gaps due to our vanilla rendered chunk \n" - + " detection not being perfect. \n"; int getOverdrawOffset(); void setOverdrawOffset(int newOverdrawOffset); @@ -489,72 +196,22 @@ public interface ILodConfigWrapperSingleton extends IBindable + " when changing speeds quickly, but will increase upload times and GPU usage."; int getBacksideCullingRange(); void setBacksideCullingRange(int newBacksideCullingRange);*/ - - boolean USE_EXTENDED_NEAR_CLIP_PLANE_DEFAULT = true; - String USE_EXTENDED_NEAR_CLIP_PLANE_DESC = "" - + " Will prevent some overdraw issues, but may cause nearby fake chunks to render incorrectly \n" - + " especially when in/near an ocean. \n" - + "\n" - + " This setting shouldn't affect performance. \n"; + boolean getUseExtendedNearClipPlane(); void setUseExtendedNearClipPlane(boolean newUseExtendedNearClipPlane); - double BRIGHTNESS_MULTIPLIER_DEFAULT = 1.0; - String BRIGHTNESS_MULTIPLIER_DESC = "" - + " How bright fake chunk colors are. \n" - + "\n" - + " 0 = black \n" - + " 1 = normal \n" - + " 2 = near white \n"; double getBrightnessMultiplier(); void setBrightnessMultiplier(double newBrightnessMultiplier); - double SATURATION_MULTIPLIER_DEFAULT = 1.0; - String SATURATION_MULTIPLIER_DESC = "" - + " How saturated fake chunk colors are. \n" - + "\n" - + " 0 = black and white \n" - + " 1 = normal \n" - + " 2 = very saturated \n"; double getSaturationMultiplier(); void setSaturationMultiplier(double newSaturationMultiplier); - boolean ENABLE_CAVE_CULLING_DEFAULT = true; - String ENABLE_CAVE_CULLING_DESC = "" - + " If enabled caves will be culled \n" - + "\n" - + " NOTE: This feature is under development and \n" - + " it is VERY experimental! Please don't report \n" - + " any issues related to this feature. \n" - + "\n" - + " Additional Info: Currently this cull all faces \n" - + " with skylight value of 0 in dimensions that \n" - + " does not have a ceiling. \n"; boolean getEnableCaveCulling(); void setEnableCaveCulling(boolean newEnableCaveCulling); - MinDefaultMax CAVE_CULLING_HEIGHT_MIN_DEFAULT_MAX = new MinDefaultMax<>(-4096,40,4096); - String CAVE_CULLING_HEIGHT_DESC = "" - + " At what Y value should cave culling start? \n"; int getCaveCullingHeight(); void setCaveCullingHeight(int newCaveCullingHeight); - - MinDefaultMax EARTH_CURVE_RATIO_MIN_DEFAULT_MAX = new MinDefaultMax<>(0,0,5000); - String EARTH_CURVE_RATIO_DESC = "" - + " This is the earth size ratio when applying the curvature shader effect. \n" - + "\n" - + " NOTE: This feature is just for fun and is VERY experimental! \n" - + "Please don't report any issues related to this feature. \n" - + "\n" - + " 0 = flat/disabled \n" - + " 1 = 1 to 1 (6,371,000 blocks) \n" - + " 100 = 1 to 100 (63,710 blocks) \n" - + " 10000 = 1 to 10000 (637.1 blocks) \n" - + "\n" - + " NOTE: Due to current limitations, the min value is 50 \n" - + " and the max value is 5000. Any values outside this range \n" - + " will be set to 0(disabled)."; int getEarthCurveRatio(); void setEarthCurveRatio(int newEarthCurveRatio); @@ -567,36 +224,12 @@ public interface ILodConfigWrapperSingleton extends IBindable //=====================// // Multiplayer Configs // //=====================// + @Deprecated interface IMultiplayer { - String DESC = "These settings control how different systems work when connected to a multiplayer world."; - - ServerFolderNameMode SERVER_FOLDER_NAME_MODE_DEFAULT = ServerFolderNameMode.AUTO; - String SERVER_FOLDER_NAME_MODE_DESC = "" - + " What multiplayer save folders should be named. \n" - + "\n" - + " " + ServerFolderNameMode.AUTO.toString() + ": " + ServerFolderNameMode.NAME_IP.toString() + " for LAN connections, " + ServerFolderNameMode.NAME_IP_PORT.toString() + " for all others. \n" - + " " + ServerFolderNameMode.NAME_ONLY.toString() + ": Example: \"Minecraft Server\" \n" - + " " + ServerFolderNameMode.NAME_IP.toString() + ": Example: \"Minecraft Server IP 192.168.1.40\" \n" - + " " + ServerFolderNameMode.NAME_IP_PORT.toString() + ": Example: \"Minecraft Server IP 192.168.1.40:25565\" \n" - + "\n"; ServerFolderNameMode getServerFolderNameMode(); void setServerFolderNameMode(ServerFolderNameMode newServerFolderNameMode); - MinDefaultMax MULTI_DIMENSION_REQUIRED_SIMILARITY_MIN_DEFAULT_MAX = new MinDefaultMax(0.0, 0.0, 1.0); - String MULTI_DIMENSION_REQUIRED_SIMILARITY_DESC = "" - + " When matching worlds of the same dimension type the \n" - + " tested chunks must be at least this percent the same \n" - + " in order to be considered the same world. \n" - + "\n" - + " Note: If you use portals to enter a dimension at two \n" - + " different locations this system may think it is two different worlds. \n" - + "\n" - + " 1.0 (100%) the chunks must be identical. \n" - + " 0.5 (50%) the chunks must be half the same. \n" - + " 0.0 (0%) disables multi-dimension support, \n" - + " only one world will be used per dimension. \n" - + "\n"; double getMultiDimensionRequiredSimilarity(); void setMultiDimensionRequiredSimilarity(double newMultiDimensionMinimumSimilarityPercent); } @@ -608,114 +241,18 @@ public interface ILodConfigWrapperSingleton extends IBindable //========================// // WorldGenerator Configs // //========================// + @Deprecated interface IWorldGenerator { - String DESC = "These settings control how fake chunks outside your normal view range are generated."; - - boolean ENABLE_DISTANT_GENERATION_DEFAULT = true; - String ENABLE_DISTANT_GENERATION_DESC = "" - + " Whether to enable Distant chunks generator? \n" - + "\n" - + " Turning this on allows Distant Horizons to make lods for chunks \n" - + " that are outside of vanilla view distance. \n" - + "\n" - + " Note that in server, distant generation is always off. \n"; boolean getEnableDistantGeneration(); void setEnableDistantGeneration(boolean newEnableDistantGeneration); - DistanceGenerationMode DISTANCE_GENERATION_MODE_DEFAULT = DistanceGenerationMode.FEATURES; - static String getDistanceGenerationModeDesc(IVersionConstants versionConstants) - { - return "" - + " How detailed should fake chunks be generated outside the vanilla render distance? \n" - + "\n" - + " The times are the amount of time it took one of the developer's PC to generate \n" - + " one chunk in Minecraft 1.16.5 and may be inaccurate for different Minecraft versions. \n" - + " They are included to give a rough estimate as to how the different options \n" - + " may perform in comparison to each other. \n" - + " (Note that all modes will load in already existing chunks) \n" - + "\n" - + " " + DistanceGenerationMode.NONE + " \n" - + " Only run the Generator to load in already existing chunks. \n" - + "\n" - + " " + DistanceGenerationMode.BIOME_ONLY + " \n" - + " Only generate the biomes and use the biome's \n" - + " grass color, water color, or snow color. \n" - + " Doesn't generate height, everything is shown at sea level. \n" - + " - Fastest (2-5 ms) \n" - + "\n" - + " " + DistanceGenerationMode.BIOME_ONLY_SIMULATE_HEIGHT + " \n" - + " Same as " + DistanceGenerationMode.BIOME_ONLY + ", except instead \n" - + " of always using sea level as the LOD height \n" - + " different biome types (mountain, ocean, forest, etc.) \n" - + " use predetermined heights to simulate having height data. \n" - + " - Fastest (2-5 ms) \n" - + "\n" - + " " + DistanceGenerationMode.SURFACE + " \n" - + " Generate the world surface, \n" - + " this does NOT include trees, \n" - + " or structures. \n" - + " - Faster (10-20 ms) \n" - + "\n" - + " " + DistanceGenerationMode.FEATURES + " \n" - + " Generate everything except structures. \n" - + " WARNING: This may cause world generation bugs or instability! \n" - + " - Fast (15-20 ms) \n" - + "\n" - + " " + DistanceGenerationMode.FULL + " \n" - + " Ask the local server to generate/load each chunk. \n" - + " This will show player made structures, which can \n" - + " be useful if you are adding the mod to a pre-existing world. \n" - + " This is the most compatible, but causes server/simulation lag. \n" - + " - Slow (15-50 ms, with spikes up to 200 ms) \n" - + "\n" - + " The multithreaded options may increase CPU load significantly (while generating) \n" - + " depending on how many world generation threads you have allocated. \n"; - } DistanceGenerationMode getDistanceGenerationMode(); void setDistanceGenerationMode(DistanceGenerationMode newDistanceGenerationMode); - - LightGenerationMode LIGHT_GENERATION_MODE_DEFAULT = LightGenerationMode.FANCY; - String LIGHT_GENERATION_MODE_DESC = "" - + " How should block and sky lights be processed for distant generation? \n" - + "\n" - + " Note that this include already existing chunks since vanilla \n" - + " does not store sky light values to save file. \n" - + "\n" - + " " + LightGenerationMode.FAST + ": Use height map to fake the light values. \n" - + " " + LightGenerationMode.FANCY + ": Use actaul light engines to generate proper values. \n" - + "\n" - + " This will effect generation speed, but not the rendering performance."; + LightGenerationMode getLightGenerationMode(); void setLightGenerationMode(LightGenerationMode newLightGenerationMode); - - - GenerationPriority GENERATION_PRIORITY_DEFAULT = GenerationPriority.NEAR_FIRST; - String GENERATION_PRIORITY_DESC = "" - + " In what priority should fake chunks be generated outside the vanilla render distance? \n" - + "\n" - + " " + GenerationPriority.FAR_FIRST + " \n" - + " Fake chunks are generated from lowest to highest detail \n" - + " with a priority for far away regions. \n" - + " This fills in the world fastest, but you will have large low detail \n" - + " blocks for a while while the generation happens. \n" - + "\n" - + " " + GenerationPriority.NEAR_FIRST + " \n" - + " Fake chunks are generated around the player \n" - + " in a spiral, similar to vanilla minecraft. \n" - + " Best used when on a server since we can't generate \n" - + " fake chunks. \n" - + "\n" - + " " + GenerationPriority.BALANCED + " \n" - + " A mix between "+GenerationPriority.NEAR_FIRST+"and"+GenerationPriority.FAR_FIRST+". \n" - + " First prioritise completing nearby highest detail chunks, \n" - + " then focus on filling in the low detail areas away from the player. \n" - + "\n" - + " " + GenerationPriority.AUTO + " \n" - + " Uses " + GenerationPriority.BALANCED + " when on a single player world \n" - + " and " + GenerationPriority.NEAR_FIRST + " when connected to a server. \n" - + "\n" - + " This shouldn't affect performance."; + GenerationPriority getGenerationPriority(); void setGenerationPriority(GenerationPriority newGenerationPriority); @@ -727,28 +264,9 @@ public interface ILodConfigWrapperSingleton extends IBindable return priority; } - BlocksToAvoid BLOCKS_TO_AVOID_DEFAULT = BlocksToAvoid.BOTH; - String BLOCKS_TO_AVOID_DESC = "" - + " When generating fake chunks, what blocks should be ignored? \n" - + " Ignored blocks don't affect the height of the fake chunk, but might affect the color. \n" - + " So using " + BlocksToAvoid.BOTH + " will prevent snow covered blocks from appearing one block too tall, \n" - + " but will still show the snow's color.\n" - + "\n" - + " " + BlocksToAvoid.NONE + ": Use all blocks when generating fake chunks \n" - + " " + BlocksToAvoid.NON_FULL + ": Only use full blocks when generating fake chunks (ignores slabs, lanterns, torches, tall grass, etc.) \n" - + " " + BlocksToAvoid.NO_COLLISION + ": Only use solid blocks when generating fake chunks (ignores tall grass, torches, etc.) \n" - + " " + BlocksToAvoid.BOTH + ": Only use full solid blocks when generating fake chunks \n" - + "\n" - + " This wont't affect performance."; BlocksToAvoid getBlocksToAvoid(); void setBlockToAvoid(BlocksToAvoid newBlockToAvoid); - //TODO: improve wording - Boolean TINT_WITH_AVOIDED_BLOCKS_DEFAULT = true; - String TINT_WITH_AVOIDED_BLOCKS_DESC = "" - + " Should the blocks underneath avoided blocks gain the color of the avoided block? \n" - + " True: a red flower on grass will tint the grass below it red" - + " False: skipped blocks will not change color of surface below them"; Boolean getTintWithAvoidedBlocks(); void setTintWithAvoidedBlocks(Boolean shouldTint); } @@ -759,37 +277,16 @@ public interface ILodConfigWrapperSingleton extends IBindable //============================// // AdvancedModOptions Configs // //============================// + @Deprecated interface IAdvanced { - String DESC = "Advanced mod settings"; - IThreading threading(); IDebugging debugging(); IBuffers buffers(); - - + + @Deprecated interface IThreading { - String DESC = "These settings control how many CPU threads the mod uses for different tasks."; - - MinDefaultMax NUMBER_OF_WORLD_GENERATION_THREADS_DEFAULT - = new MinDefaultMax(0.1, - (double) Math.min(Runtime.getRuntime().availableProcessors()/2, 4), - (double) Runtime.getRuntime().availableProcessors()); - String NUMBER_OF_WORLD_GENERATION_THREADS_DESC = "" - + " How many threads should be used when generating fake \n" - + " chunks outside the normal render distance? \n" - + "\n" - + " If it's less than 1, it will be treated as a percentage \n" - + " of time single thread can run before going to idle. \n" - + "\n" - + " If you experience stuttering when generating distant LODs, \n" - + " decrease this number. If you want to increase LOD \n" - + " generation speed, increase this number. \n" - + "\n" - + " This and the number of buffer builder threads are independent, \n" - + " so if they add up to more threads than your CPU has cores, \n" - + " that shouldn't cause an issue. \n"; double getNumberOfWorldGenerationThreads(); void setNumberOfWorldGenerationThreads(double newNumberOfWorldGenerationThreads); default int _getWorldGenerationThreadPoolSize() @@ -802,72 +299,27 @@ public interface ILodConfigWrapperSingleton extends IBindable return getNumberOfWorldGenerationThreads()>1 ? 1.0 : getNumberOfWorldGenerationThreads(); } - - MinDefaultMax NUMBER_OF_BUFFER_BUILDER_THREADS_MIN_DEFAULT_MAX - = new MinDefaultMax(1, - Math.min(Runtime.getRuntime().availableProcessors()/2, 2), - Runtime.getRuntime().availableProcessors()); - String NUMBER_OF_BUFFER_BUILDER_THREADS_DESC = "" - + " How many threads are used when building vertex buffers? \n" - + " (The things sent to your GPU to draw the fake chunks). \n" - + "\n" - + " If you experience high CPU usage when NOT generating distant \n" - + " fake chunks, lower this number. A higher number will make fake\n" - + " fake chunks' transition faster when moving around the world. \n" - + "\n" - + " This and the number of world generator threads are independent, \n" - + " so if they add up to more threads than your CPU has cores, \n" - + " that shouldn't cause an issue. \n" - + "\n" - + " The maximum value is the number of logical processors on your CPU. \n"; int getNumberOfBufferBuilderThreads(); void setNumberOfBufferBuilderThreads(int newNumberOfWorldBuilderThreads); } - + @Deprecated interface IDebugging { - String DESC = "These settings can be used to look for bugs, or see how certain aspects of the mod work."; - - RendererType RENDERER_TYPE_DEFAULT = RendererType.DEFAULT; - String RENDERER_TYPE_DESC = "" - + " What renderer is active? \n" - + "\n" - + " " + RendererType.DEFAULT + ": Default lod renderer \n" - + " " + RendererType.DEBUG + ": Debug testing renderer \n" - + " " + RendererType.DISABLED + ": Disable rendering \n"; RendererType getRendererType(); void setRendererType(RendererType newRendererType); - - DebugMode DEBUG_MODE_DEFAULT = DebugMode.OFF; - String DEBUG_MODE_DESC = "" - + " Should specialized colors/rendering modes be used? \n" - + "\n" - + " " + DebugMode.OFF + ": Fake chunks will be drawn with their normal colors. \n" - + " " + DebugMode.SHOW_WIREFRAME + ": Fake chunks will be drawn as wireframes. \n" - + " " + DebugMode.SHOW_DETAIL + ": Fake chunks color will be based on their detail level. \n" - + " " + DebugMode.SHOW_DETAIL_WIREFRAME + ": Fake chunks color will be based on their detail level, drawn as a wireframe. \n" - + " " + DebugMode.SHOW_GENMODE + ": Fake chunks color will be based on their distant generation mode. \n" - + " " + DebugMode.SHOW_GENMODE_WIREFRAME + ": Fake chunks color will be based on their distant generation mode, drawn as a wireframe. \n" - + " " + DebugMode.SHOW_OVERLAPPING_QUADS + ": Fake chunks will be drawn with total white, but overlapping quads will be drawn with red. \n" - + " " + DebugMode.SHOW_OVERLAPPING_QUADS_WIREFRAME + ": Fake chunks will be drawn with total white, \n" - + " but overlapping quads will be drawn with red, drawn as a wireframe. \n"; + DebugMode getDebugMode(); void setDebugMode(DebugMode newDebugMode); - - boolean DEBUG_KEYBINDINGS_ENABLED_DEFAULT = false; - String DEBUG_KEYBINDINGS_ENABLED_DESC = "" - + " If true the F8 key can be used to cycle through the different debug modes. \n" - + " and the F6 key can be used to enable and disable LOD rendering."; + boolean getDebugKeybindingsEnabled(); void setDebugKeybindingsEnabled(boolean newEnableDebugKeybindings); IDebugSwitch debugSwitch(); - + @Deprecated interface IDebugSwitch { - String DESC = "These settings can be used to look for bugs by enabling and disabling logging."; - - /* The logging switches available: + /* + * The logging switches available: * WorldGenEvent * WorldGenPerformance * WorldGenLoadEvent @@ -879,130 +331,47 @@ public interface ILodConfigWrapperSingleton extends IBindable * NetworkEvent //NOT IMPL YET */ - LoggerMode LOG_WORLDGEN_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_WORLDGEN_EVENT_DESC = "" - + " If enabled, the mod will log information about the world generation process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogWorldGenEvent(); void setLogWorldGenEvent(LoggerMode newLogWorldGenEvent); - LoggerMode LOG_WORLDGEN_PERFORMANCE_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_FILE; - String LOG_WORLDGEN_PERFORMANCE_DESC = "" - + " If enabled, the mod will log performance about the world generation process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogWorldGenPerformance(); void setLogWorldGenPerformance(LoggerMode newLogWorldGenPerformance); - LoggerMode LOG_WORLDGEN_LOAD_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_FILE; - String LOG_WORLDGEN_LOAD_EVENT_DESC = "" - + " If enabled, the mod will log information about the world generation process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogWorldGenLoadEvent(); void setLogWorldGenLoadEvent(LoggerMode newLogWorldGenLoadEvent); - LoggerMode LOG_LODBUILDER_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_LODBUILDER_EVENT_DESC = "" - + " If enabled, the mod will log information about the LOD generation process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogLodBuilderEvent(); void setLogLodBuilderEvent(LoggerMode newLogLodBuilderEvent); - LoggerMode LOG_RENDERER_BUFFER_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_RENDERER_BUFFER_EVENT_DESC = "" - + " If enabled, the mod will log information about the renderer buffer process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogRendererBufferEvent(); void setLogRendererBufferEvent(LoggerMode newLogRendererBufferEvent); - LoggerMode LOG_RENDERER_GL_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_RENDERER_GL_EVENT_DESC = "" - + " If enabled, the mod will log information about the renderer OpenGL process. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogRendererGLEvent(); void setLogRendererGLEvent(LoggerMode newLogRendererGLEvent); - LoggerMode LOG_FILE_READWRITE_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_FILE_READWRITE_EVENT_DESC = "" - + " If enabled, the mod will log information about file read/write operations. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogFileReadWriteEvent(); void setLogFileReadWriteEvent(LoggerMode newLogFileReadWriteEvent); - LoggerMode LOG_FILE_SUB_DIM_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_FILE_SUB_DIM_EVENT_DESC = "" - + " If enabled, the mod will log information about file sub-dimension operations. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogFileSubDimEvent(); void setLogFileSubDimEvent(LoggerMode newLogFileSubDimEvent); - LoggerMode LOG_NETWORK_EVENT_DEFAULT = LoggerMode.LOG_WARNING_TO_CHAT_AND_INFO_TO_FILE; - String LOG_NETWORK_EVENT_DESC = "" - + " If enabled, the mod will log information about network operations. \n" - + " This can be useful for debugging. \n"; LoggerMode getLogNetworkEvent(); void setLogNetworkEvent(LoggerMode newLogNetworkEvent); } } - + @Deprecated interface IBuffers { - String DESC = "These settings affect how often geometry is rebuilt."; - - GpuUploadMethod GPU_UPLOAD_METHOD_DEFAULT = GpuUploadMethod.AUTO; - String GPU_UPLOAD_METHOD_DESC = "" - + " What method should be used to upload geometry to the GPU? \n" - + "\n" - + " " + GpuUploadMethod.AUTO + ": Picks the best option based on the GPU you have. \n" - + " " + GpuUploadMethod.BUFFER_STORAGE + ": Default for NVIDIA if OpenGL 4.5 is supported. \n" - + " Fast rendering, no stuttering. \n" - + " " + GpuUploadMethod.SUB_DATA + ": Backup option for NVIDIA. \n" - + " Fast rendering but may stutter when uploading. \n" - + " " + GpuUploadMethod.BUFFER_MAPPING + ": Slow rendering but won't stutter when uploading. Possibly the best option for integrated GPUs. \n" - + " Default option for AMD/Intel. \n" - + " May end up storing buffers in System memory. \n" - + " Fast rendering if in GPU memory, slow if in system memory, \n" - + " but won't stutter when uploading. \n" - + " " + GpuUploadMethod.DATA + ": Fast rendering but will stutter when uploading. \n" - + " Backup option for AMD/Intel. \n" - + " Fast rendering but may stutter when uploading. \n" - + "\n" - + " If you don't see any difference when changing these settings, or the world looks corrupted: \n" - + " Restart the game to clear the old buffers. \n"; GpuUploadMethod getGpuUploadMethod(); void setGpuUploadMethod(GpuUploadMethod newGpuUploadMethod); - - MinDefaultMax GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DEFAULT = new MinDefaultMax(0, 0, 50); - String GPU_UPLOAD_PER_MEGABYTE_IN_MILLISECONDS_DESC = "" - + " How long should a buffer wait per Megabyte of data uploaded?\n" - + " Helpful resource for frame times: https://fpstoms.com \n" - + "\n" - + " Longer times may reduce stuttering but will make fake chunks \n" - + " transition and load slower. Change this to [0] for no timeout.\n" - + "\n" - + " NOTE:\n" - + " Before changing this config, try changing \"GPU Upload methods\"\n" - + " and determined the best method for your hardware first. \n"; + int getGpuUploadPerMegabyteInMilliseconds(); void setGpuUploadPerMegabyteInMilliseconds(int newMilliseconds); - - String REBUILD_TIMES_DESC = "" - + " How frequently should vertex buffers (geometry) be rebuilt and sent to the GPU? \n" - + " Higher settings may cause stuttering, but will prevent holes in the world \n"; - BufferRebuildTimes REBUILD_TIMES_DEFAULT = BufferRebuildTimes.NORMAL; + BufferRebuildTimes getRebuildTimes(); void setRebuildTimes(BufferRebuildTimes newBufferRebuildTimes); } - boolean LOD_ONLY_MODE_DEFAULT = false; - String LOD_ONLY_MODE_DESC = "" - + " Due to some demand for playing without vanilla terrains, \n" - + " we decided to add this mode for fun. \n" - + "\n" - + " NOTE: Do not report any issues when this mode is on! \n" - + " Again, this setting is only for fun, and mod \n" - + " compatibility is not guaranteed. \n" - + "\n"; - boolean getLodOnlyMode(); void setLodOnlyMode(boolean newLodOnlyMode); }