Remove deprecated ILodConfigWrapperSingleton, use Config instead

This commit is contained in:
James Seibel
2023-03-06 07:44:49 -06:00
parent 5bb14820b6
commit b63c4b9e7e
4 changed files with 25 additions and 1309 deletions
@@ -19,16 +19,15 @@
package com.seibel.lod.core.dataObjects.render.bufferBuilding;
import com.seibel.lod.core.config.Config;
import com.seibel.lod.core.dataObjects.render.ColumnRenderSource;
import com.seibel.lod.core.util.RenderDataPointUtil;
import com.seibel.lod.api.enums.rendering.EDebugMode;
import com.seibel.lod.core.dependencyInjection.SingletonInjector;
import com.seibel.lod.core.dataObjects.render.columnViews.ColumnArrayView;
import com.seibel.lod.core.pos.DhLodPos;
import com.seibel.lod.core.util.BitShiftUtil;
import com.seibel.lod.core.util.ColorUtil;
import com.seibel.lod.core.util.LodUtil;
import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
/**
* Builds LODs as rectangular prisms.
@@ -37,8 +36,6 @@ import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
*/
public class CubicLodTemplate
{
private static final ILodConfigWrapperSingleton CONFIG = SingletonInjector.INSTANCE.get(ILodConfigWrapperSingleton.class);
public static void addLodToBuffer(long data, long topData, long botData, ColumnArrayView[][] adjData,
byte detailLevel, int offsetPosX, int offsetOosZ, LodQuadBuilder quadBuilder, EDebugMode debugging, ColumnRenderSource.DebugSourceFlag debugSource)
@@ -66,8 +63,8 @@ public class CubicLodTemplate
case OFF:
case SHOW_WIREFRAME:
{
float saturationMultiplier = (float)CONFIG.client().graphics().advancedGraphics().getSaturationMultiplier();
float brightnessMultiplier = (float)CONFIG.client().graphics().advancedGraphics().getBrightnessMultiplier();
float saturationMultiplier = Config.Client.Graphics.AdvancedGraphics.saturationMultiplier.get().floatValue();
float brightnessMultiplier = Config.Client.Graphics.AdvancedGraphics.brightnessMultiplier.get().floatValue();
if (saturationMultiplier == 1.0 && brightnessMultiplier == 1.0) {
color = RenderDataPointUtil.getColor(data);
} else {
@@ -22,9 +22,7 @@ package com.seibel.lod.core.render.fog;
import com.seibel.lod.api.enums.rendering.*;
import com.seibel.lod.core.config.Config;
import com.seibel.lod.core.dependencyInjection.ModAccessorInjector;
import com.seibel.lod.core.dependencyInjection.SingletonInjector;
import com.seibel.lod.core.render.glObject.shader.Shader;
import com.seibel.lod.core.wrapperInterfaces.config.ILodConfigWrapperSingleton;
import com.seibel.lod.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
import java.io.FileOutputStream;
@@ -46,7 +44,6 @@ import static com.seibel.lod.core.render.glObject.GLProxy.GL_LOGGER;
public class LodFogConfig
{
private static final IOptifineAccessor OPTIFINE = ModAccessorInjector.INSTANCE.get(IOptifineAccessor.class);
private static final ILodConfigWrapperSingleton CONFIG = SingletonInjector.INSTANCE.get(ILodConfigWrapperSingleton.class);
public static final boolean DEBUG_DUMP_GENERATED_CODE = false;
@@ -69,7 +66,7 @@ public class LodFogConfig
public static LodFogConfig generateFogConfig()
{
EFogDrawMode fogMode = CONFIG.client().graphics().fogQuality().getFogDrawMode();
EFogDrawMode fogMode = Config.Client.Graphics.FogQuality.fogDrawMode.get();
if (fogMode == EFogDrawMode.USE_OPTIFINE_SETTING && OPTIFINE != null)
{
fogMode = OPTIFINE.getFogDrawMode();
@@ -91,18 +88,23 @@ public class LodFogConfig
if (fogDrawMode != EFogDrawMode.FOG_DISABLED)
{
ILodConfigWrapperSingleton.IClient.IGraphics.IFogQuality fogSettings = CONFIG.client().graphics().fogQuality();
EFogDistance fogDistance = fogSettings.getFogDistance();
EFogDistance fogDistance = Config.Client.Graphics.FogQuality.fogDistance.get();
drawNearFog = (fogDistance == EFogDistance.NEAR || fogDistance == EFogDistance.NEAR_AND_FAR);
if (fogDistance == EFogDistance.FAR || fogDistance == EFogDistance.NEAR_AND_FAR)
{
// far fog should be drawn
farFogSetting = fogSettings.advancedFog().computeFarFogSetting();
farFogSetting = new FogSettings(
Config.Client.Graphics.FogQuality.AdvancedFog.farFogStart.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.farFogEnd.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.farFogMin.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.farFogMax.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.farFogDensity.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.farFogType.get()
);
heightFogMixMode = fogSettings.advancedFog().heightFog().getHeightFogMixMode();
heightFogMixMode = Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMixMode.get();
if (heightFogMixMode == EHeightFogMixMode.IGNORE_HEIGHT || heightFogMixMode == EHeightFogMixMode.BASIC)
{
// basic fog mixing
@@ -115,8 +117,16 @@ public class LodFogConfig
{
// advanced fog mixing
heightFogSetting = fogSettings.advancedFog().heightFog().computeHeightFogSetting();
heightFogMode = fogSettings.advancedFog().heightFog().getHeightFogMode();
heightFogSetting = new FogSettings(
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogEnd.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMin.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMax.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogType.get()
);
heightFogMode = Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMode.get();
if (heightFogMode.basedOnCamera)
{
@@ -124,7 +134,7 @@ public class LodFogConfig
}
else
{
heightFogHeight = (float) fogSettings.advancedFog().heightFog().getHeightFogHeight();
heightFogHeight = Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogHeight.get().floatValue();
}
}
}
@@ -1,377 +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 <https://www.gnu.org/licenses/>.
*/
package com.seibel.lod.core.wrapperInterfaces.config;
import com.seibel.lod.api.enums.config.*;
import com.seibel.lod.api.enums.rendering.*;
import com.seibel.lod.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
import com.seibel.lod.core.config.Config;
import com.seibel.lod.core.interfaces.dependencyInjection.IBindable;
import com.seibel.lod.core.dependencyInjection.SingletonInjector;
import com.seibel.lod.core.render.fog.FogSettings;
import com.seibel.lod.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
/**
* Use the real config rather than these getters
*/
@Deprecated
public interface ILodConfigWrapperSingleton extends IBindable
{
IClient client();
@Deprecated
interface IClient
{
IGraphics graphics();
IWorldGenerator worldGenerator();
IMultiplayer multiplayer();
IAdvanced advanced();
boolean getOptionsButton();
void setOptionsButton(boolean newOptionsButton);
//==================//
// Graphics Configs //
//==================//
@Deprecated
interface IGraphics
{
IQuality quality();
IFogQuality fogQuality();
IAdvancedGraphics advancedGraphics();
@Deprecated
interface IQuality
{
EHorizontalResolution getDrawResolution();
void setDrawResolution(EHorizontalResolution newHorizontalResolution);
int getLodChunkRenderDistance();
void setLodChunkRenderDistance(int newLodChunkRenderDistance);
EVerticalQuality getVerticalQuality();
void setVerticalQuality(EVerticalQuality newVerticalQuality);
int getHorizontalScale();
void setHorizontalScale(int newHorizontalScale);
EHorizontalQuality getHorizontalQuality();
void setHorizontalQuality(EHorizontalQuality newHorizontalQuality);
public void setTransparency(ETransparency newTransparency);
public ETransparency getTransparency();
int getLodBiomeBlending();
void setLodBiomeBlending(int newLodBiomeBlending);
}
@Deprecated
interface IFogQuality
{
EFogDistance getFogDistance();
void setFogDistance(EFogDistance newFogDistance);
EFogDrawMode getFogDrawMode();
void setFogDrawMode(EFogDrawMode newFogDrawMode);
EFogColorMode getFogColorMode();
void setFogColorMode(EFogColorMode newFogColorMode);
boolean getDisableVanillaFog();
void setDisableVanillaFog(boolean newDisableVanillaFog);
IAdvancedFog advancedFog();
@Deprecated
interface IAdvancedFog {
double getFarFogStart();
void setFarFogStart(double newFarFogStart);
double getFarFogEnd();
void setFarFogEnd(double newFarFogEnd);
double getFarFogMin();
void setFarFogMin(double newFarFogMin);
double getFarFogMax();
void setFarFogMax(double newFarFogMax);
EFogFalloff getFarFogType();
void setFarFogType(EFogFalloff newFarFogType);
double getFarFogDensity();
void setFarFogDensity(double newFarFogDensity);
IHeightFog heightFog();
@Deprecated
interface IHeightFog {
EHeightFogMixMode getHeightFogMixMode();
void setHeightFogMixMode(EHeightFogMixMode newHeightFogMixMode);
EHeightFogMode getHeightFogMode();
void setHeightFogMode(EHeightFogMode newHeightFogMode);
double getHeightFogHeight();
void setHeightFogHeight(double newHeightFogHeight);
double getHeightFogStart();
void setHeightFogStart(double newHeightFogStart);
double getHeightFogEnd();
void setHeightFogEnd(double newHeightFogEnd);
double getHeightFogMin();
void setHeightFogMin(double newHeightFogMin);
double getHeightFogMax();
void setHeightFogMax(double newHeightFogMax);
EFogFalloff getHeightFogType();
void setHeightFogType(EFogFalloff newFarFogType);
double getHeightFogDensity();
void setHeightFogDensity(double newHeightFogDensity);
default FogSettings computeHeightFogSetting() {
return new FogSettings(
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogEnd.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMin.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMax.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.get(),
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogType.get()
);
}
}
default FogSettings computeFarFogSetting() {
return new FogSettings(
getFarFogStart(),
getFarFogEnd(),
getFarFogMin(),
getFarFogMax(),
getFarFogDensity(),
getFarFogType()
);
}
}
}
@Deprecated
interface IAdvancedGraphics
{
boolean getDisableDirectionalCulling();
void setDisableDirectionalCulling(boolean newDisableDirectionalCulling);
EVanillaOverdraw getVanillaOverdraw();
void setVanillaOverdraw(EVanillaOverdraw newVanillaOverdraw);
int getOverdrawOffset();
void setOverdrawOffset(int newOverdrawOffset);
/* Disabled for now due to implementation issues.
MinDefaultMax<Integer> VANILLA_CULLING_RANGE_MIN_DEFAULT_MAX = new MinDefaultMax<Integer>(0, 32, 512);
String VANILLA_CULLING_RANGE_DESC = ""
+ " This indicates the minimum range where back sides of blocks start get get culled. \n"
+ " Higher settings will make terrain look good when looking backwards \n"
+ " when changing speeds quickly, but will increase upload times and GPU usage.";
int getBacksideCullingRange();
void setBacksideCullingRange(int newBacksideCullingRange);*/
boolean getUseExtendedNearClipPlane();
void setUseExtendedNearClipPlane(boolean newUseExtendedNearClipPlane);
double getBrightnessMultiplier();
void setBrightnessMultiplier(double newBrightnessMultiplier);
double getSaturationMultiplier();
void setSaturationMultiplier(double newSaturationMultiplier);
boolean getEnableCaveCulling();
void setEnableCaveCulling(boolean newEnableCaveCulling);
int getCaveCullingHeight();
void setCaveCullingHeight(int newCaveCullingHeight);
int getEarthCurveRatio();
void setEarthCurveRatio(int newEarthCurveRatio);
}
}
//=====================//
// Multiplayer Configs //
//=====================//
@Deprecated
interface IMultiplayer
{
EServerFolderNameMode getServerFolderNameMode();
void setServerFolderNameMode(EServerFolderNameMode newServerFolderNameMode);
double getMultiDimensionRequiredSimilarity();
void setMultiDimensionRequiredSimilarity(double newMultiDimensionMinimumSimilarityPercent);
}
//========================//
// WorldGenerator Configs //
//========================//
@Deprecated
interface IWorldGenerator
{
boolean getEnableDistantGeneration();
void setEnableDistantGeneration(boolean newEnableDistantGeneration);
EDhApiDistantGeneratorMode getDistanceGenerationMode();
void setDistanceGenerationMode(EDhApiDistantGeneratorMode newDistanceGenerationMode);
ELightGenerationMode getLightGenerationMode();
void setLightGenerationMode(ELightGenerationMode newLightGenerationMode);
EGenerationPriority getGenerationPriority();
void setGenerationPriority(EGenerationPriority newGenerationPriority);
default EGenerationPriority getResolvedGenerationPriority() {
EGenerationPriority priority = Config.Client.WorldGenerator.generationPriority.get();
IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class);
if (priority == EGenerationPriority.AUTO)
priority = MC.hasSinglePlayerServer() ? EGenerationPriority.FAR_FIRST : EGenerationPriority.BALANCED;
return priority;
}
EBlocksToAvoid getBlocksToAvoid();
void setBlockToAvoid(EBlocksToAvoid newBlockToAvoid);
Boolean getTintWithAvoidedBlocks();
void setTintWithAvoidedBlocks(Boolean shouldTint);
}
//============================//
// AdvancedModOptions Configs //
//============================//
@Deprecated
interface IAdvanced
{
IThreading threading();
IDebugging debugging();
IBuffers buffers();
@Deprecated
interface IThreading
{
double getNumberOfWorldGenerationThreads();
void setNumberOfWorldGenerationThreads(double newNumberOfWorldGenerationThreads);
default int _getWorldGenerationThreadPoolSize()
{
return Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.get()<1 ? 1 :
(int) Math.ceil(Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.get());
}
default double _getWorldGenerationPartialRunTime()
{
return Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.get()>1 ? 1.0 : Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.get();
}
int getNumberOfBufferBuilderThreads();
void setNumberOfBufferBuilderThreads(int newNumberOfWorldBuilderThreads);
}
@Deprecated
interface IDebugging
{
ERendererMode getRendererType();
void setRendererType(ERendererMode newRendererType);
EDebugMode getDebugMode();
void setDebugMode(EDebugMode newDebugMode);
boolean getDebugKeybindingsEnabled();
void setDebugKeybindingsEnabled(boolean newEnableDebugKeybindings);
IDebugSwitch debugSwitch();
@Deprecated
interface IDebugSwitch
{
/*
* The logging switches available:
* WorldGenEvent
* WorldGenPerformance
* WorldGenLoadEvent
* LodBuilderEvent
* RendererBufferEvent
* RendererGLEvent
* FileReadWriteEvent
* FileSubDimEvent
* NetworkEvent //NOT IMPL YET
*/
ELoggerMode getLogWorldGenEvent();
void setLogWorldGenEvent(ELoggerMode newLogWorldGenEvent);
ELoggerMode getLogWorldGenPerformance();
void setLogWorldGenPerformance(ELoggerMode newLogWorldGenPerformance);
ELoggerMode getLogWorldGenLoadEvent();
void setLogWorldGenLoadEvent(ELoggerMode newLogWorldGenLoadEvent);
ELoggerMode getLogLodBuilderEvent();
void setLogLodBuilderEvent(ELoggerMode newLogLodBuilderEvent);
ELoggerMode getLogRendererBufferEvent();
void setLogRendererBufferEvent(ELoggerMode newLogRendererBufferEvent);
ELoggerMode getLogRendererGLEvent();
void setLogRendererGLEvent(ELoggerMode newLogRendererGLEvent);
ELoggerMode getLogFileReadWriteEvent();
void setLogFileReadWriteEvent(ELoggerMode newLogFileReadWriteEvent);
ELoggerMode getLogFileSubDimEvent();
void setLogFileSubDimEvent(ELoggerMode newLogFileSubDimEvent);
ELoggerMode getLogNetworkEvent();
void setLogNetworkEvent(ELoggerMode newLogNetworkEvent);
}
}
@Deprecated
interface IBuffers
{
EGpuUploadMethod getGpuUploadMethod();
void setGpuUploadMethod(EGpuUploadMethod newGpuUploadMethod);
int getGpuUploadPerMegabyteInMilliseconds();
void setGpuUploadPerMegabyteInMilliseconds(int newMilliseconds);
EBufferRebuildTimes getRebuildTimes();
void setRebuildTimes(EBufferRebuildTimes newBufferRebuildTimes);
}
boolean getLodOnlyMode();
void setLodOnlyMode(boolean newLodOnlyMode);
}
}
}
@@ -1,914 +0,0 @@
package com.seibel.lod.core.wrapperInterfaces.config;
import com.seibel.lod.api.enums.config.*;
import com.seibel.lod.api.enums.rendering.*;
import com.seibel.lod.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
import com.seibel.lod.core.config.Config;
/**
* Use config getters rather than this
*/
@Deprecated
public class LodConfigWrapperSingleton implements ILodConfigWrapperSingleton
{
public static final LodConfigWrapperSingleton INSTANCE = new LodConfigWrapperSingleton();
private static final Client client = new Client();
@Override
public IClient client()
{
return client;
}
public static class Client implements IClient
{
public final IGraphics graphics;
public final IWorldGenerator worldGenerator;
public final IMultiplayer multiplayer;
public final IAdvanced advanced;
@Override
public IGraphics graphics()
{
return graphics;
}
@Override
public IWorldGenerator worldGenerator()
{
return worldGenerator;
}
@Override
public IMultiplayer multiplayer() {
return multiplayer;
}
@Override
public IAdvanced advanced()
{
return advanced;
}
@Override
public boolean getOptionsButton()
{
return Config.Client.optionsButton.get();
}
@Override
public void setOptionsButton(boolean newOptionsButton)
{
Config.Client.optionsButton.set(newOptionsButton);
}
//================//
// Client Configs //
//================//
public Client()
{
graphics = new Graphics();
worldGenerator = new WorldGenerator();
multiplayer = new Multiplayer();
advanced = new Advanced();
}
//==================//
// Graphics Configs //
//==================//
public static class Graphics implements IGraphics
{
public final IQuality quality;
public final IFogQuality fogQuality;
public final IAdvancedGraphics advancedGraphics;
@Override
public IQuality quality()
{
return quality;
}
@Override
public IFogQuality fogQuality()
{
return fogQuality;
}
@Override
public IAdvancedGraphics advancedGraphics()
{
return advancedGraphics;
}
Graphics()
{
quality = new Quality();
fogQuality = new FogQuality();
advancedGraphics = new AdvancedGraphics();
}
public static class Quality implements IQuality
{
@Override
public EHorizontalResolution getDrawResolution()
{
return Config.Client.Graphics.Quality.drawResolution.get();
}
@Override
public void setDrawResolution(EHorizontalResolution newHorizontalResolution)
{
Config.Client.Graphics.Quality.drawResolution.set(newHorizontalResolution);
}
@Override
public int getLodChunkRenderDistance()
{
return Config.Client.Graphics.Quality.lodChunkRenderDistance.get();
}
@Override
public void setLodChunkRenderDistance(int newLodChunkRenderDistance)
{
Config.Client.Graphics.Quality.lodChunkRenderDistance.set(newLodChunkRenderDistance);
}
@Override
public EVerticalQuality getVerticalQuality()
{
return Config.Client.Graphics.Quality.verticalQuality.get();
}
@Override
public void setVerticalQuality(EVerticalQuality newVerticalQuality)
{
Config.Client.Graphics.Quality.verticalQuality.set(newVerticalQuality);
}
@Override
public int getHorizontalScale()
{
return Config.Client.Graphics.Quality.horizontalScale.get();
}
@Override
public void setHorizontalScale(int newHorizontalScale)
{
Config.Client.Graphics.Quality.horizontalScale.set(newHorizontalScale);
}
@Override
public EHorizontalQuality getHorizontalQuality()
{
return Config.Client.Graphics.Quality.horizontalQuality.get();
}
@Override
public void setHorizontalQuality(EHorizontalQuality newHorizontalQuality)
{
Config.Client.Graphics.Quality.horizontalQuality.set(newHorizontalQuality);
}
@Override
public void setTransparency(ETransparency newTransparency) {
Config.Client.Graphics.Quality.transparency.set(newTransparency);
}
@Override
public ETransparency getTransparency(){
return Config.Client.Graphics.Quality.transparency.get();
}
@Override
public int getLodBiomeBlending() {
return Config.Client.Graphics.Quality.lodBiomeBlending.get();
}
@Override
public void setLodBiomeBlending(int newLodBiomeBlending) {
Config.Client.Graphics.Quality.lodBiomeBlending.set(newLodBiomeBlending);
}
}
public static class FogQuality implements IFogQuality
{
public final IAdvancedFog advancedFog;
FogQuality()
{
advancedFog = new AdvancedFog();
}
@Override
public EFogDistance getFogDistance()
{
return Config.Client.Graphics.FogQuality.fogDistance.get();
}
@Override
public void setFogDistance(EFogDistance newFogDistance)
{
Config.Client.Graphics.FogQuality.fogDistance.set(newFogDistance);
}
@Override
public EFogDrawMode getFogDrawMode()
{
return Config.Client.Graphics.FogQuality.fogDrawMode.get();
}
@Override
public void setFogDrawMode(EFogDrawMode setFogDrawMode)
{
Config.Client.Graphics.FogQuality.fogDrawMode.set(setFogDrawMode);
}
@Override
public EFogColorMode getFogColorMode()
{
return Config.Client.Graphics.FogQuality.fogColorMode.get();
}
@Override
public void setFogColorMode(EFogColorMode newFogColorMode)
{
Config.Client.Graphics.FogQuality.fogColorMode.set(newFogColorMode);
}
@Override
public boolean getDisableVanillaFog()
{
return Config.Client.Graphics.FogQuality.disableVanillaFog.get();
}
@Override
public void setDisableVanillaFog(boolean newDisableVanillaFog)
{
Config.Client.Graphics.FogQuality.disableVanillaFog.set(newDisableVanillaFog);
}
@Override
public IAdvancedFog advancedFog() {
return advancedFog;
}
public static class AdvancedFog implements IAdvancedFog {
public final IHeightFog heightFog;
public AdvancedFog() {
heightFog = new HeightFog();
}
@Override
public double getFarFogStart() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogStart.get();
}
@Override
public double getFarFogEnd() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogEnd.get();
}
@Override
public double getFarFogMin() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogMin.get();
}
@Override
public double getFarFogMax() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogMax.get();
}
@Override
public EFogFalloff getFarFogType() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogType.get();
}
@Override
public double getFarFogDensity() {
return Config.Client.Graphics.FogQuality.AdvancedFog.farFogDensity.get();
}
@Override
public void setFarFogStart(double newFarFogStart) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogStart.set(newFarFogStart);
}
@Override
public void setFarFogEnd(double newFarFogEnd) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogEnd.set(newFarFogEnd);
}
@Override
public void setFarFogMin(double newFarFogMin) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogMin.set(newFarFogMin);
}
@Override
public void setFarFogMax(double newFarFogMax) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogMax.set(newFarFogMax);
}
@Override
public void setFarFogType(EFogFalloff newFarFogType) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogType.set(newFarFogType);
}
@Override
public void setFarFogDensity(double newFarFogDensity) {
Config.Client.Graphics.FogQuality.AdvancedFog.farFogDensity.set(newFarFogDensity);
}
@Override
public IHeightFog heightFog() {
return heightFog;
}
public static class HeightFog implements IHeightFog {
@Override
public EHeightFogMixMode getHeightFogMixMode() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMixMode.get();
}
@Override
public EHeightFogMode getHeightFogMode() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMode.get();
}
@Override
public double getHeightFogHeight() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogHeight.get();
}
@Override
public double getHeightFogStart() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogStart.get();
}
@Override
public double getHeightFogEnd() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogEnd.get();
}
@Override
public double getHeightFogMin() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMin.get();
}
@Override
public double getHeightFogMax() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMax.get();
}
@Override
public EFogFalloff getHeightFogType() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogType.get();
}
@Override
public double getHeightFogDensity() {
return Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.get();
}
@Override
public void setHeightFogMixMode(EHeightFogMixMode newHeightFogMixMode) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMixMode.set(newHeightFogMixMode);
}
@Override
public void setHeightFogMode(EHeightFogMode newHeightFogMode) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMode.set(newHeightFogMode);
}
@Override
public void setHeightFogHeight(double newHeightFogHeight) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogHeight.set(newHeightFogHeight);
}
@Override
public void setHeightFogStart(double newHeightFogStart) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogStart.set(newHeightFogStart);
}
@Override
public void setHeightFogEnd(double newHeightFogEnd) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogEnd.set(newHeightFogEnd);
}
@Override
public void setHeightFogMin(double newHeightFogMin) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMin.set(newHeightFogMin);
}
@Override
public void setHeightFogMax(double newHeightFogMax) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogMax.set(newHeightFogMax);
}
@Override
public void setHeightFogType(EFogFalloff newHeightFogType) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogType.set(newHeightFogType);
}
@Override
public void setHeightFogDensity(double newHeightFogDensity) {
Config.Client.Graphics.FogQuality.AdvancedFog.HeightFog.heightFogDensity.set(newHeightFogDensity);
}
}
}
}
public static class AdvancedGraphics implements IAdvancedGraphics
{
@Override
public boolean getDisableDirectionalCulling()
{
return Config.Client.Graphics.AdvancedGraphics.disableDirectionalCulling.get();
}
@Override
public void setDisableDirectionalCulling(boolean newDisableDirectionalCulling)
{
Config.Client.Graphics.AdvancedGraphics.disableDirectionalCulling.set(newDisableDirectionalCulling);
}
@Override
public EVanillaOverdraw getVanillaOverdraw()
{
return Config.Client.Graphics.AdvancedGraphics.vanillaOverdraw.get();
}
@Override
public void setVanillaOverdraw(EVanillaOverdraw newVanillaOverdraw)
{
Config.Client.Graphics.AdvancedGraphics.vanillaOverdraw.set(newVanillaOverdraw);
}
@Override
public int getOverdrawOffset() {
return Config.Client.Graphics.AdvancedGraphics.overdrawOffset.get();
}
@Override
public void setOverdrawOffset(int newOverdrawOffset) {
Config.Client.Graphics.AdvancedGraphics.overdrawOffset.set(newOverdrawOffset);
}
/*
@Override
public int getBacksideCullingRange()
{
return Config.Client.Graphics.AdvancedGraphics.backsideCullingRange;
}
@Override
public void setBacksideCullingRange(int newBacksideCullingRange)
{
ConfigGui.editSingleOption.getEntry("client.graphics.advancedGraphics.backsideCullingRange").value = newBacksideCullingRange;
ConfigGui.editSingleOption.saveOption("client.graphics.advancedGraphics.backsideCullingRange");
}*/
@Override
public boolean getUseExtendedNearClipPlane()
{
return Config.Client.Graphics.AdvancedGraphics.useExtendedNearClipPlane.get();
}
@Override
public void setUseExtendedNearClipPlane(boolean newUseExtendedNearClipPlane)
{
Config.Client.Graphics.AdvancedGraphics.useExtendedNearClipPlane.set(newUseExtendedNearClipPlane);
}
@Override
public double getBrightnessMultiplier()
{
return Config.Client.Graphics.AdvancedGraphics.brightnessMultiplier.get();
}
@Override
public void setBrightnessMultiplier(double newBrightnessMultiplier)
{
Config.Client.Graphics.AdvancedGraphics.brightnessMultiplier.set(newBrightnessMultiplier);
}
@Override
public double getSaturationMultiplier()
{
return Config.Client.Graphics.AdvancedGraphics.saturationMultiplier.get();
}
@Override
public void setSaturationMultiplier(double newSaturationMultiplier)
{
Config.Client.Graphics.AdvancedGraphics.saturationMultiplier.set(newSaturationMultiplier);
}
@Override
public boolean getEnableCaveCulling() {
return Config.Client.Graphics.AdvancedGraphics.enableCaveCulling.get();
}
@Override
public void setEnableCaveCulling(boolean newEnableCaveCulling) {
Config.Client.Graphics.AdvancedGraphics.enableCaveCulling.set(newEnableCaveCulling);
}
@Override
public int getCaveCullingHeight() {
return Config.Client.Graphics.AdvancedGraphics.caveCullingHeight.get();
}
@Override
public void setCaveCullingHeight(int newCaveCullingHeight) {
Config.Client.Graphics.AdvancedGraphics.caveCullingHeight.set(newCaveCullingHeight);
}
@Override
public int getEarthCurveRatio()
{
return Config.Client.Graphics.AdvancedGraphics.earthCurveRatio.get();
}
@Override
public void setEarthCurveRatio(int newEarthCurveRatio)
{
// if (newEarthCurveRatio < 50) newEarthCurveRatio = 0; // TODO: Leetom can you please remove this
Config.Client.Graphics.AdvancedGraphics.earthCurveRatio.set(newEarthCurveRatio);
}
}
}
//========================//
// WorldGenerator Configs //
//========================//
public static class WorldGenerator implements IWorldGenerator
{
@Override
public EGenerationPriority getGenerationPriority()
{
return Config.Client.WorldGenerator.generationPriority.get();
}
@Override
public void setGenerationPriority(EGenerationPriority newGenerationPriority)
{
Config.Client.WorldGenerator.generationPriority.set(newGenerationPriority);
}
@Override
public EDhApiDistantGeneratorMode getDistanceGenerationMode()
{
return Config.Client.WorldGenerator.distantGeneratorMode.get();
}
@Override
public void setDistanceGenerationMode(EDhApiDistantGeneratorMode newDistanceGenerationMode)
{
Config.Client.WorldGenerator.distantGeneratorMode.set(newDistanceGenerationMode);
}
/*
@Override
public boolean getAllowUnstableFeatureGeneration()
{
return Config.Client.WorldGenerator.allowUnstableFeatureGeneration;
}
@Override
public void setAllowUnstableFeatureGeneration(boolean newAllowUnstableFeatureGeneration)
{
ConfigGui.editSingleOption.getEntry("client.worldGenerator.allowUnstableFeatureGeneration").value = newAllowUnstableFeatureGeneration;
ConfigGui.editSingleOption.saveOption("client.worldGenerator.allowUnstableFeatureGeneration");
}*/
@Override
public EBlocksToAvoid getBlocksToAvoid()
{
return Config.Client.WorldGenerator.blocksToAvoid.get();
}
@Override
public void setBlockToAvoid(EBlocksToAvoid newBlockToAvoid)
{
Config.Client.WorldGenerator.blocksToAvoid.set(newBlockToAvoid);
}
@Override
public Boolean getTintWithAvoidedBlocks() {
return Config.Client.WorldGenerator.tintWithAvoidedBlocks.get();
}
@Override
public void setTintWithAvoidedBlocks(Boolean shouldTint) {
Config.Client.WorldGenerator.tintWithAvoidedBlocks.set(shouldTint);
}
@Override
public boolean getEnableDistantGeneration()
{
return Config.Client.WorldGenerator.enableDistantGeneration.get();
}
@Override
public void setEnableDistantGeneration(boolean newEnableDistantGeneration)
{
Config.Client.WorldGenerator.enableDistantGeneration.set(newEnableDistantGeneration);
}
@Override
public ELightGenerationMode getLightGenerationMode()
{
return Config.Client.WorldGenerator.lightGenerationMode.get();
}
@Override
public void setLightGenerationMode(ELightGenerationMode newLightGenerationMode)
{
Config.Client.WorldGenerator.lightGenerationMode.set(newLightGenerationMode);
}
}
//=====================//
// Multiplayer Configs //
//=====================//
public static class Multiplayer implements IMultiplayer
{
@Override
public EServerFolderNameMode getServerFolderNameMode()
{
return Config.Client.Multiplayer.serverFolderNameMode.get();
}
@Override
public void setServerFolderNameMode(EServerFolderNameMode newServerFolderNameMode)
{
Config.Client.Multiplayer.serverFolderNameMode.set(newServerFolderNameMode);
}
@Override
public double getMultiDimensionRequiredSimilarity()
{
return Config.Client.Multiplayer.multiDimensionRequiredSimilarity.get();
}
@Override
public void setMultiDimensionRequiredSimilarity(double newMultiDimensionMinimumSimilarityPercent)
{
Config.Client.Multiplayer.multiDimensionRequiredSimilarity.set(newMultiDimensionMinimumSimilarityPercent);
}
}
//============================//
// AdvancedModOptions Configs //
//============================//
public static class Advanced implements IAdvanced
{
public final IThreading threading;
public final IDebugging debugging;
public final IBuffers buffers;
@Override
public IThreading threading()
{
return threading;
}
@Override
public IDebugging debugging()
{
return debugging;
}
@Override
public IBuffers buffers()
{
return buffers;
}
public Advanced()
{
threading = new Threading();
debugging = new Debugging();
buffers = new Buffers();
}
public static class Threading implements IThreading
{
@Override
public double getNumberOfWorldGenerationThreads()
{
return Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.get();
}
@Override
public void setNumberOfWorldGenerationThreads(double newNumberOfWorldGenerationThreads)
{
Config.Client.Advanced.Threading.numberOfWorldGenerationThreads.set(newNumberOfWorldGenerationThreads);
}
@Override
public int getNumberOfBufferBuilderThreads()
{
return Config.Client.Advanced.Threading.numberOfBufferBuilderThreads.get();
}
@Override
public void setNumberOfBufferBuilderThreads(int newNumberOfWorldBuilderThreads)
{
Config.Client.Advanced.Threading.numberOfBufferBuilderThreads.set(newNumberOfWorldBuilderThreads);
}
}
//===============//
// Debug Options //
//===============//
public static class Debugging implements IDebugging
{
public final IDebugSwitch debugSwitch;
@Override
public IDebugSwitch debugSwitch()
{
return debugSwitch;
}
/* RendererType:
* DEFAULT
* DEBUG
* DISABLED
* */
@Override
public ERendererMode getRendererType() {
return Config.Client.Advanced.Debugging.rendererMode.get();
}
@Override
public void setRendererType(ERendererMode newRenderType) {
Config.Client.Advanced.Debugging.rendererMode.set(newRenderType);
}
@Override
public EDebugMode getDebugMode()
{
return Config.Client.Advanced.Debugging.debugMode.get();
}
@Override
public void setDebugMode(EDebugMode newDebugMode)
{
Config.Client.Advanced.Debugging.debugMode.set(newDebugMode);
}
@Override
public boolean getDebugKeybindingsEnabled()
{
return Config.Client.Advanced.Debugging.enableDebugKeybindings.get();
}
@Override
public void setDebugKeybindingsEnabled(boolean newEnableDebugKeybindings)
{
Config.Client.Advanced.Debugging.enableDebugKeybindings.set(newEnableDebugKeybindings);
}
public Debugging()
{
debugSwitch = new DebugSwitch();
}
public static class DebugSwitch implements IDebugSwitch {
/* The logging switches available:
* WorldGenEvent
* WorldGenPerformance
* WorldGenLoadEvent
* LodBuilderEvent
* RendererBufferEvent
* RendererGLEvent
* FileReadWriteEvent
* FileSubDimEvent
* NetworkEvent //NOT IMPL YET
*/
@Override
public ELoggerMode getLogWorldGenEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenEvent.get();
}
@Override
public void setLogWorldGenEvent(ELoggerMode newLogWorldGenEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenEvent.set(newLogWorldGenEvent);
}
@Override
public ELoggerMode getLogWorldGenPerformance() {
return Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenPerformance.get();
}
@Override
public void setLogWorldGenPerformance(ELoggerMode newLogWorldGenPerformance) {
Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenPerformance.set(newLogWorldGenPerformance);
}
@Override
public ELoggerMode getLogWorldGenLoadEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenLoadEvent.get();
}
@Override
public void setLogWorldGenLoadEvent(ELoggerMode newLogWorldGenLoadEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logWorldGenLoadEvent.set(newLogWorldGenLoadEvent);
}
@Override
public ELoggerMode getLogLodBuilderEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logLodBuilderEvent.get();
}
@Override
public void setLogLodBuilderEvent(ELoggerMode newLogLodBuilderEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logLodBuilderEvent.set(newLogLodBuilderEvent);
}
@Override
public ELoggerMode getLogRendererBufferEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logRendererBufferEvent.get();
}
@Override
public void setLogRendererBufferEvent(ELoggerMode newLogRendererBufferEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logRendererBufferEvent.set(newLogRendererBufferEvent);
}
@Override
public ELoggerMode getLogRendererGLEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logRendererGLEvent.get();
}
@Override
public void setLogRendererGLEvent(ELoggerMode newLogRendererGLEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logRendererGLEvent.set(newLogRendererGLEvent);
}
@Override
public ELoggerMode getLogFileReadWriteEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logFileReadWriteEvent.get();
}
@Override
public void setLogFileReadWriteEvent(ELoggerMode newLogFileReadWriteEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logFileReadWriteEvent.set(newLogFileReadWriteEvent);
}
@Override
public ELoggerMode getLogFileSubDimEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logFileSubDimEvent.get();
}
@Override
public void setLogFileSubDimEvent(ELoggerMode newLogFileSubDimEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logFileSubDimEvent.set(newLogFileSubDimEvent);
}
@Override
public ELoggerMode getLogNetworkEvent() {
return Config.Client.Advanced.Debugging.DebugSwitch.logNetworkEvent.get();
}
@Override
public void setLogNetworkEvent(ELoggerMode newLogNetworkEvent) {
Config.Client.Advanced.Debugging.DebugSwitch.logNetworkEvent.set(newLogNetworkEvent);
}
}
}
public static class Buffers implements IBuffers
{
@Override
public EGpuUploadMethod getGpuUploadMethod()
{
return Config.Client.Advanced.Buffers.gpuUploadMethod.get();
}
@Override
public void setGpuUploadMethod(EGpuUploadMethod newDisableVanillaFog)
{
Config.Client.Advanced.Buffers.gpuUploadMethod.set(newDisableVanillaFog);
}
@Override
public int getGpuUploadPerMegabyteInMilliseconds()
{
return Config.Client.Advanced.Buffers.gpuUploadPerMegabyteInMilliseconds.get();
}
@Override
public void setGpuUploadPerMegabyteInMilliseconds(int newMilliseconds) {
Config.Client.Advanced.Buffers.gpuUploadPerMegabyteInMilliseconds.set(newMilliseconds);
}
@Override
public EBufferRebuildTimes getRebuildTimes()
{
return Config.Client.Advanced.Buffers.rebuildTimes.get();
}
@Override
public void setRebuildTimes(EBufferRebuildTimes newBufferRebuildTimes)
{
Config.Client.Advanced.Buffers.rebuildTimes.set(newBufferRebuildTimes);
}
}
@Override
public boolean getLodOnlyMode() {
return Config.Client.Advanced.lodOnlyMode.get();
}
@Override
public void setLodOnlyMode(boolean newLodOnlyMode) {
Config.Client.Advanced.lodOnlyMode.set(newLodOnlyMode);
}
}
}
}