clouds = off
oldLighting = false
oldHandLight = false
underwaterOverlay = false
vignette = false
sun = false

# 3D texture
#texture.composite.gaux1=textures/inversion_lut.dat TEXTURE_3D RGBA32F 64 64 64 RGBA FLOAT

# Raw textures (binary dump) can also be loaded:
#   texture.<stage>.<name>=<path> <type> <internalFormat> <dimensions> <pixelFormat> <pixelType>
# Where:
#   <type> is one of: TEXTURE_1D, TEXTURE_2D, TEXTURE_3D, TEXTURE_RECTANGLE
#   <internalFormat> is the texture format, see "shaders.txt" Texture Formats for the available names
#   <dimensions> is a list of texture dimensions, depends on the texture type
#    <pixelFormat> is the pixel format, see "shaders.txt" Pixel Formats for the available names
#   <pixelType> is the pixel type, see "shaders.txt" Pixel Types for the available names.
# For example:
#   texture.composite.gaux1=textures/lut_1d.dat TEXTURE_1D RGBA32F 64 RGBA FLOAT
#   texture.composite.gaux1=textures/lut_3d.dat TEXTURE_3D RGBA32F 64 64 64 RGBA FLOAT

flip.deferred_pre.colortex0=true
flip.deferred11.colortex0=true
flip.composite.colortex0=true
flip.composite3.colortex0=true

texture.noise=textures/blueNoiseRGB.png
texture.gbuffers.gaux1=minecraft:textures/atlas/blocks.png
texture.gbuffers.gaux2=textures/RippleAnimation2.png
texture.deferred.colortex0=textures/Caustics.png
texture.deferred.colortex3=minecraft:textures/atlas/blocks.png
texture.deferred.depthtex0=minecraft:textures/atlas/blocks_s.png
texture.composite.colortex4=textures/Caustics.png
texture.composite.colortex0=minecraft:textures/atlas/blocks.png
texture.composite.depthtex2=minecraft:textures/atlas/blocks_s.png


program.deferred.enabled=true
program.deferred1.enabled=false
program.deferred2.enabled=true
program.deferred3.enabled=true
program.deferred4.enabled=true
program.deferred5.enabled=true
program.deferred6.enabled=true
program.deferred7.enabled=true
program.deferred8.enabled=true
program.deferred9.enabled=true
program.deferred10.enabled=true
program.deferred11.enabled=true
program.deferred12.enabled=true


program.composite.enabled=true
program.composite1.enabled=true
program.composite2.enabled=true
program.composite3.enabled=true
program.composite4.enabled=true
program.composite5.enabled=true
program.composite6.enabled=true
program.composite7.enabled=true
program.composite8.enabled=true
program.composite9.enabled=true
program.composite10.enabled=true
program.composite11.enabled=true
program.composite12.enabled=true
program.composite13.enabled=true
program.composite14.enabled=true
program.composite15.enabled=true


blend.gbuffers_water=ONE ZERO ONE ZERO
blend.gbuffers_hand=ONE ZERO ONE ZERO
blend.gbuffers_hand_water=ONE ZERO ONE ZERO
blend.gbuffers_block=ONE ZERO ONE ZERO
blend.gbuffers_entities = ONE ZERO ONE ZERO
blend.gbuffers_spidereyes = ONE ZERO ONE ZERO
blend.gbuffers_beaconbeam = ONE ZERO ONE ZERO
blend.gbuffers_terrain = ONE ZERO ONE ZERO
blend.gbuffers_textured = ONE ZERO ONE ZERO
blend.shadow = ONE ZERO ONE ZERO

blend.gbuffers_weather = ONE ONE ONE ONE
# blend.gbuffers_armor_glint = ONE_MINUS_DST_COLOR ONE ONE ONE
blend.gbuffers_damagedblock = DST_COLOR ZERO ONE ZERO


screen = <empty> <empty> TEXTURE_RESOLUTION shadowMapResolution <empty> <empty> [Atmosphere] [Shadow] [Lighting] [Texture] [RayTracing] [Reflection] \
         [Water] [Postprocessing] <empty> <empty> Version [Others]
    screen.Atmosphere = <empty> <empty> CLOUDS_IN_GI CLOUDS_IN_AMBIENT CIRRUS_CLOUDS CUMULUS_CLOUDS CLOUDS_BLOCKY <empty> <empty> <empty> GODRAYS \
                        GODRAYS_STAINED_GLASS_TINT VOLUMETRIC_LIGHT_STRENGTH
    screen.Shadow = shadowMapResolution shadowDistance SHADOW_MAP_BIAS sunPathRotation <empty> RAY_TRACE_SHADOW SCREEN_SPACE_SHADOW CLOUD_SHADOW SUNLIGHT_LEAK_FIX
    screen.Shadow.columns = 1
    screen.Lighting = <empty> <empty> SUNLIGHT_BRIGHTNESS TORCHLIGHT_COLOR_TEMPERATURE GI_LIGHT_BLOCK_INTENSITY GI_LIGHT_TORCH_INTENSITY <empty> <empty> HELD_LIGHT \
                      GI_SUNLIGHT_STAINED_GLASS_TINT <empty> <empty> GLOWING_REDSTONE_BLOCK GLOWING_EMERALD_BLOCK GLOWING_LAPIS_LAZULI_BLOCK
    screen.Texture = <empty> <empty> TEXTURE_RESOLUTION NORMAL_MAP_STRENGTH <empty> <empty> TEXTURE_LOD_BIAS ANISOTROPIC_LOD_BIAS \
                     FORCE_WET_EFFECT RAIN_SPLASH_EFFECT RAIN_SPLASH_BILATERAL WET_CAVE_EFFECT <empty> <empty> [Parallax] [Specular]
    screen.Texture.columns = 1
        screen.Parallax = <empty> <empty> PARALLAX SMOOTH_PARALLAX <empty> PARALLAX_DEPTH PARALLAX_DISTANCE
        screen.Parallax.columns = 1
        screen.Specular = SPEC_EMISSIVE SPEC_SMOOTHNESS_AS_ROUGHNESS PHYSICALLY_BASED_MAX_ROUGHNESS FULL_RT_REFLECTIONS <empty> SPEC_CHANNEL_SMOOTHNESS \
                          SPEC_CHANNEL_METALNESS SPEC_CHANNEL_EMISSIVE
        screen.Specular.columns = 1
    screen.RayTracing = shadowMapResolution shadowDistance <empty> <empty> GI_RAY_COUNT GI_SECONDARY_SAMPLES DIFFUSE_TRACE_LENGTH RAYTRACE_GEOMETRY_QUALITY \
                        <empty> <empty> MAX_BLEND_WEIGHT GI_SCREEN_SPACE_TRACING MOD_BLOCK_SUPPORT CAVE_GI_LEAK_FIX <empty> <empty> CLOUDS_IN_GI SHAPE_CALC_FUNC
    screen.Reflection = <empty> <empty> REFLECTION_TRACE_LENGTH <empty> FULL_RT_REFLECTIONS SCREEN_SPACE_CONNECTION_REFLECTION REFLECTION_SCREEN_SPACE_TRACING
    screen.Reflection.columns = 1
    screen.Water = <empty> WATER_PARALLAX WATER_WAVE_HEIGHT <empty> WATER_FOG_DENSITY
    screen.Water.columns = 1
    screen.Postprocessing = TONEMAP_OPERATOR TONEMAP_CURVE EXPOSURE SATURATION GAMMA BLOOM_AMOUNT BLACK_DEPTH WHITE_CLIP <empty> <empty> MOTION_BLUR \
                            MOTION_BLUR_INTENSITY DEPTH_OF_FIELD DOF_STRENGTH POST_SHARPENING [AntiAliasing]
        screen.AntiAliasing = <empty> FINAL_FXAA PIXEL_LOOK AA_STYLE <empty> SKIP_AA
        screen.AntiAliasing.columns = 1
    screen.Others = <empty> <empty> VISUALIZE_DANGEROUS_LIGHT_LEVEL <empty> SKYLIGHT_FIX <empty> WEATHER
    screen.Others.columns = 1


sliders=FINAL_FXAA SHADOW_MAP_BIAS RAYTRACE_GEOMETRY_QUALITY WHITE_CLIP TONEMAP_OPERATOR WATER_WAVE_HEIGHT SPEC_CHANNEL_SMOOTHNESS \
        SPEC_CHANNEL_METALNESS SPEC_CHANNEL_EMISSIVE REFLECTION_TRACE_LENGTH shadowDistance SUNLIGHT_BRIGHTNESS TORCHLIGHT_COLOR_TEMPERATURE GI_LIGHT_BLOCK_INTENSITY \
        GI_LIGHT_TORCH_INTENSITY TONEMAP_CURVE MOTION_BLUR_INTENSITY EXPOSURE GAMMA SATURATION BLACK_DEPTH BLOOM_AMOUNT POST_SHARPENING WATER_FOG_DENSITY shadowMapResolution \
        VOLUMETRIC_LIGHT_STRENGTH PARALLAX_DEPTH PARALLAX_DISTANCE NORMAL_MAP_STRENGTH GI_SECONDARY_SAMPLES GI_RAY_COUNT DIFFUSE_TRACE_LENGTH REFLECTION_TRACE_LENGTH TEXTURE_RESOLUTION \
        MAX_BLEND_WEIGHT sunPathRotation TEXTURE_LOD_BIAS DOF_STRENGTH


uniform.vec2.ScreenSize = vec2(viewWidth, viewHeight)
uniform.vec2.ScreenTexel = vec2(1.0/viewWidth, 1.0/viewHeight)
uniform.vec2.HalfScreen = vec2((floor(viewWidth * 0.5) + 1.0)/viewWidth, (floor(viewHeight * 0.5) + 1.0)/viewHeight)

variable.int.frames = frameCounter % 16
variable.float.jitterX = frac(frames * 12664745.0 / 16777216.0)
variable.float.jitterY = frac(frames * 9560333.0 / 16777216.0)
uniform.vec2.JitterSampleOffset = vec2((jitterX * 2.0 - 1.0) / viewWidth, (jitterY * 2.0 - 1.0) / viewHeight)

variable.float.lightAngle = -signum(sunAngle * 2.0 - 1.0)
variable.float.worldLightVectorLength = sqrt(shadowModelViewInverse.2.0 * shadowModelViewInverse.2.0 + shadowModelViewInverse.2.1 * shadowModelViewInverse.2.1 + shadowModelViewInverse.2.2 * shadowModelViewInverse.2.2)
variable.float.worldLightVectorX = shadowModelViewInverse.2.0 / worldLightVectorLength
variable.float.worldLightVectorY = shadowModelViewInverse.2.1 / worldLightVectorLength
variable.float.worldLightVectorZ = shadowModelViewInverse.2.2 / worldLightVectorLength
uniform.vec3.worldLightVector = vec3(worldLightVectorX, worldLightVectorY, worldLightVectorZ)
variable.float.worldSunVectorX = worldLightVectorX * lightAngle
variable.float.worldSunVectorY = worldLightVectorY * lightAngle
variable.float.worldSunVectorZ = worldLightVectorZ * lightAngle
uniform.vec3.worldSunVector = vec3(worldSunVectorX, worldSunVectorY, worldSunVectorZ)

variable.int.altRTDiameterTemp = floor(pow(viewWidth * viewHeight, 0.333333))
uniform.int.altRTDiameter = altRTDiameterTemp - altRTDiameterTemp % 2

variable.float.FractCameraPositionX = frac(cameraPosition.x + 0.5)
variable.float.FractCameraPositionY = frac(cameraPosition.y + 0.5)
variable.float.FractCameraPositionZ = frac(cameraPosition.z + 0.5)
variable.float.FractCameraPositionXFixed = if(FractCameraPositionX == 0.0, 1.0, FractCameraPositionX)
variable.float.FractCameraPositionYFixed = if(FractCameraPositionY == 0.0, 1.0, FractCameraPositionY)
variable.float.FractCameraPositionZFixed = if(FractCameraPositionZ == 0.0, 1.0, FractCameraPositionZ)
uniform.vec3.FractedCameraPosition = vec3(FractCameraPositionXFixed, FractCameraPositionYFixed, FractCameraPositionZFixed)

uniform.vec3.cameraPositionDiff = vec3(cameraPosition.x - previousCameraPosition.x, cameraPosition.y - previousCameraPosition.y, cameraPosition.z - previousCameraPosition.z)

uniform.float.nightBrightness = 0.0001 + 0.0019 * nightVision

uniform.float.timeMidnight = clamp(-worldSunVectorY * 10.0, 0.0, 1.0)

variable.float.sunVectorVariable1 = 0.233333 * (1.0 - exp(-worldLightVectorY * 24.0)) / worldLightVectorY
variable.float.sunVectorVariable2 = min(worldLightVectorY * 40.0, 1.0) * if(worldSunVectorY < 0.0, nightBrightness, 1.0)
variable.float.colorSunlightX = exp((-0.175 - wetness) * sunVectorVariable1) * sunVectorVariable2 * 0.976709
variable.float.colorSunlightY = exp((-0.405 - wetness) * sunVectorVariable1) * sunVectorVariable2 * 0.946058
variable.float.colorSunlightZ = exp((-0.995 - wetness) * sunVectorVariable1) * sunVectorVariable2 * 0.871758
uniform.vec3.colorSunlight = vec3(colorSunlightX, colorSunlightY, colorSunlightZ)

variable.float.FloorCameraPositionX = cameraPosition.x - FractCameraPositionXFixed
variable.float.FloorCameraPositionY = cameraPosition.y - FractCameraPositionYFixed
variable.float.FloorCameraPositionZ = cameraPosition.z - FractCameraPositionZFixed
variable.float.FractPrevCameraPositionX = frac(previousCameraPosition.x + 0.5)
variable.float.FractPrevCameraPositionY = frac(previousCameraPosition.y + 0.5)
variable.float.FractPrevCameraPositionZ = frac(previousCameraPosition.z + 0.5)
variable.float.FloorPrevCameraPositionX = previousCameraPosition.x - if(FractPrevCameraPositionX == 0.0, 1.0, FractPrevCameraPositionX)
variable.float.FloorPrevCameraPositionY = previousCameraPosition.y - if(FractPrevCameraPositionY == 0.0, 1.0, FractPrevCameraPositionY)
variable.float.FloorPrevCameraPositionZ = previousCameraPosition.z - if(FractPrevCameraPositionZ == 0.0, 1.0, FractPrevCameraPositionZ)
uniform.vec3.cameraPosCenterDiff = vec3(FloorCameraPositionX - FloorPrevCameraPositionX, \
                                        FloorCameraPositionY - FloorPrevCameraPositionY, \
                                        FloorCameraPositionZ - FloorPrevCameraPositionZ)
