generated euphoria patches
This commit is contained in:
parent
6a4f3ff1c0
commit
e1fdef068e
4
.gitignore
vendored
4
.gitignore
vendored
@ -53,4 +53,6 @@ config/minemenu-common.toml
|
||||
config/oculus.properties
|
||||
config/sodiumextras-client.toml
|
||||
.qmenu_opened.marker
|
||||
mods/generated-pack/
|
||||
mods/generated-pack/
|
||||
|
||||
shaderpacks/*.txt
|
||||
|
||||
1
shaderpacks/ComplementaryUnbound_r5.4 + EuphoriaPatches_1.5.2/.gitignore
vendored
Normal file
1
shaderpacks/ComplementaryUnbound_r5.4 + EuphoriaPatches_1.5.2/.gitignore
vendored
Normal file
@ -0,0 +1 @@
|
||||
*.zip
|
||||
@ -0,0 +1,92 @@
|
||||
Complementary License Agreement 1.5
|
||||
===================================
|
||||
|
||||
0. Terminology
|
||||
--------------
|
||||
0.1. "The Pack" and/or "This Pack" means the software package that this
|
||||
specific license file you are reading from is found in.
|
||||
|
||||
0.2. "Normal Usage" means usage of The Pack as intended for the general
|
||||
public. This includes most usage, but the following usages are
|
||||
definitely NOT considered Normal Usage:
|
||||
a. Redistributing (parts of) The Pack
|
||||
b. Modifying code of The Pack
|
||||
|
||||
0.3. "User" and/or "Users" means people that are using The Pack under our
|
||||
definition of Normal Usage.
|
||||
|
||||
0.4. "Modpack" means a modification package made for the video
|
||||
game "Minecraft: Java Edition".
|
||||
|
||||
0.5. "Modified Pack" means a software package that consists of The Pack but
|
||||
with the code intentionally being changed to differ from The Pack.
|
||||
|
||||
0.6. "Original Pack" means one of two things:
|
||||
a. If "This Pack" is an original Complementary Development product,
|
||||
meaning that this specific license file you are reading from is
|
||||
found inside an original Complementary Development product, then
|
||||
"Original Pack" directly means the same thing as "This Pack".
|
||||
b. But if "This Pack" is not an original Complementary Development
|
||||
product, meaning that this specific license file you are reading
|
||||
from is found inside a pack that was created using the grant
|
||||
detailed at section "1.3", then "Original Pack" refers to the
|
||||
pack created by Complementary Development that must be mentioned
|
||||
in the description page(s) of This Pack.
|
||||
|
||||
1. Grants
|
||||
---------
|
||||
1.1. All Users are free to use This Pack for Normal Usage. This isn't
|
||||
limited to, but includes:
|
||||
a. Using The Pack for gameplay
|
||||
b. Using The Pack for content creation
|
||||
|
||||
1.2. This Pack is allowed to be redistributed inside a Modpack as long as
|
||||
the following conditions are met:
|
||||
a. This Pack must be visibly credited in the Modpack's description
|
||||
page(s).
|
||||
b. The author of the Modpack must acknowledge that any problems that
|
||||
may arise from using This Pack in their Modpack is entirely under
|
||||
the responsibility of the author of the Modpack.
|
||||
|
||||
1.3. This Pack is allowed to be redistributed as a Modified Pack as long as
|
||||
the following conditions are met:
|
||||
a. The Original Pack must be visibly credited in the description
|
||||
page(s) of the Modified Pack, with a link to the official
|
||||
Complementary Development website.
|
||||
b. This license file must still be left inside the Modified Pack
|
||||
without any changes being made to it, and it must be updated to
|
||||
the latest one found in the latest version of the Original Pack
|
||||
every time the Modified Pack gets updated to make more use of the
|
||||
code from the Original Pack.
|
||||
c. The Modified Pack must not have the word "Complementary" in its
|
||||
name, and there should be at least 3 character difference between
|
||||
the name of the Modified Pack and the Original Pack. Adding or
|
||||
removing non-alphabetic characters or the removal of
|
||||
"Complementary" does not count as a character difference.
|
||||
d. The Modified Pack must look noticeably different from the
|
||||
Original Pack in multiple common gameplay scenarios that must
|
||||
include daytime overworld visuals, regardless of the setting or
|
||||
variable changes in the Modified Pack and/or the Original Pack.
|
||||
|
||||
2. Denied Cases
|
||||
---------------
|
||||
2.1. Any usage or redistribution of any part of This Pack that isn't
|
||||
explicitly covered in the "Grants" section of this license should be
|
||||
treated as "All Rights Reserved". Only exceptions are the files that
|
||||
contain a notice that they are covered by a different license.
|
||||
|
||||
2.2. This agreement only applies to the version of This Pack that this exact
|
||||
file can be found in. This agreement is not valid for future or past
|
||||
versions of The Pack unless they contain the exact same agreement.
|
||||
|
||||
3. License Infringement
|
||||
-----------------------
|
||||
3.1. By using This Pack for any purpose, you agree that Complementary
|
||||
Development has the right to take action against you in the case of a
|
||||
license infringement, regardless of This Pack being the Original Pack
|
||||
or not.
|
||||
|
||||
3.2. Complementary Development reserves its rights to not take action
|
||||
against cases that it deems harmless. For this reason, cases that
|
||||
Complementary Development did not take action against in the past
|
||||
cannot be used as an excuse to ignore this agreement.
|
||||
@ -0,0 +1 @@
|
||||
https://www.euphoriapatches.com/credits
|
||||
@ -0,0 +1,70 @@
|
||||
Euphoria Patches License Agreement 1.0
|
||||
======================================
|
||||
|
||||
0. Terminology
|
||||
--------------
|
||||
0.1. The "Patcher Mod" or "EuphoriaPatcher Mod" refers to the mod named
|
||||
EuphoriaPatcher used to generate the shader pack Euphoria Patches.
|
||||
0.2. "Dev Versions" are development versions accessible through the
|
||||
Support Pages of the Euphoria Patches Developer.
|
||||
0.3. The Patcher Mod is publicly available on Modrinth and CurseForge.
|
||||
0.4. In the "Original Pack" terminology from the Complementary License Agreement (CLA):
|
||||
If This Pack is an original Euphoria Patches product, then "Original Pack"
|
||||
refers to This Pack.
|
||||
|
||||
1. Extension
|
||||
------------
|
||||
1.1. This agreement extends the CLA,
|
||||
inheriting all of its terminology and terms:
|
||||
a. All definitions and terminology in the CLA are applicable here.
|
||||
b. All terms and conditions from the CLA are also transferred to this license.
|
||||
|
||||
2. Grants
|
||||
---------
|
||||
2.1. The direct redistribution of This Pack is not allowed.
|
||||
|
||||
2.2. his Pack must be generated through the Patcher Mod unless:
|
||||
a. The version is classified as a Dev Version, which does not
|
||||
require the Patcher Mod.
|
||||
|
||||
2.3. This Pack is allowed to be redistributed inside a Modpack as long as
|
||||
the following conditions are met:
|
||||
a. The EuphoriaPatcher Mod used to generate this pack is included
|
||||
in the Modpack.
|
||||
b. The EuphoriaPatcher Mod must be included in the Modpack on the
|
||||
distribution sites this pack uses
|
||||
|
||||
2.4. This Pack is only allowed to be redistributed in a Modified Pack as long as
|
||||
the following conditions are met:
|
||||
a. It is also distributed through a patching mechanism similar to
|
||||
the EuphoriaPatcher Mod.
|
||||
b. The Modified Pack must retain this license file without alterations
|
||||
and update it to the latest version available in the Original Pack
|
||||
whenever using new content from the Original Pack.
|
||||
c. The Modified Pack must not include "Euphoria" in its name,
|
||||
and there must be at least a three-character difference between
|
||||
the Modified Pack's name and This Pack; adding/removing non-alphabetic
|
||||
characters does not count.
|
||||
|
||||
3. Denied Cases
|
||||
---------------
|
||||
3.1. Any usage or redistribution of any part of This Pack that isn't
|
||||
explicitly covered in the "Grants" section of this license should be
|
||||
treated as "All Rights Reserved". Only exceptions are the files that
|
||||
contain a notice that they are covered by a different license.
|
||||
|
||||
3.2. This agreement only applies to the version of This Pack that this exact
|
||||
file can be found in. This agreement is not valid for future or past
|
||||
versions of The Pack unless they contain the exact same agreement.
|
||||
|
||||
4. License Infringement
|
||||
-----------------------
|
||||
4.1. By using This Pack for any purpose, you agree that Euphoria Patches
|
||||
has the right to take action against you in the case of a
|
||||
license infringement, regardless of This Pack being the Original Pack
|
||||
or not.
|
||||
|
||||
4.2. Euphoria Patches reserves its rights to not take action
|
||||
against cases that it deems harmless. For this reason, cases that
|
||||
Euphoria Patches did not take action against in the past
|
||||
cannot be used as an excuse to ignore this agreement.
|
||||
@ -0,0 +1,64 @@
|
||||
````````````````````````````````````````````````````````````````````````````````````````````````````````
|
||||
██╗███╗ ██╗███████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██████╗ ███╗ ██╗
|
||||
██║████╗ ██║██╔════╝██╔═══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║██╔═══██╗████╗ ██║
|
||||
██║██╔██╗ ██║█████╗ ██║ ██║██████╔╝██╔████╔██║███████║ ██║ ██║██║ ██║██╔██╗ ██║
|
||||
██║██║╚██╗██║██╔══╝ ██║ ██║██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██║██║ ██║██║╚██╗██║
|
||||
██║██║ ╚████║██║ ╚██████╔╝██║ ██║██║ ╚═╝ ██║██║ ██║ ██║ ██║╚██████╔╝██║ ╚████║
|
||||
╚═╝╚═╝ ╚═══╝╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝
|
||||
````````````````````````````````````````````````````````````````````````````````````````````````````````
|
||||
# What is Euphoria Patches?
|
||||
Euphoria Patches is an add-on for Complementary Shaders, developed by SpacEagle17. It aims to extend Complementary with more optional handcrafted features and settings.
|
||||
|
||||
**Please don't report any issues encountered using this add-on to EminGT.**
|
||||
|
||||
# License notice:
|
||||
Most of the code in this project is subject to the Complementary License Agreement by EminGT (check License file) and is therefore NOT allowed to be redistributed.
|
||||
|
||||
# Why does Euphoria Patches need a mod?
|
||||
[Complementary's license](https://github.com/ComplementaryDevelopment/ComplementaryReimagined/blob/main/License.txt) does not allow me to publish Euphoria Patches directly as it does not have a "noticeably differen[ce] from the Original Pack in multiple common gameplay scenarios that must include daytime overworld visuals, regardless of the setting or variable changes in the Modified Pack and/or the Original Pack". I simply add onto Complementary, this would not qualify as an viable edit. A mutual agreement with Emin was made to distribute Euphoria Patches through a patcher where none of Emin's code gets distributed (and by that not breaking the license) and the user has to have Complementary Shaders installed in order to get the add-on. All parties profit from this method.
|
||||
|
||||
# When does Euphoria Patches update?
|
||||
Euphoria Patches Updates Immediately after a new Complementary Version is out. This includes dev versions. Euphoria Patches dev versions are available on **[Ko-Fi](https://ko-fi.com/spaceagle17)** or **[Patreon](https://www.patreon.com/SpacEagle17)**!
|
||||
|
||||
# Contribute
|
||||
Add **[Modded Blocks](https://github.com/EuphoriaPatches/propertiesFiles)** or **[Translation Files](https://github.com/EuphoriaPatches/langFiles)** to Euphoria Patches!
|
||||
|
||||
# Contact
|
||||
**Discord: [SpacEagle17](https://discord.gg/5N45SAsC3X)**'s Server for discussion, questions, suggestions... or the **[#euphoria-patches](https://discord.com/invite/985QQxVQZF)** channel on the Complementary Discord
|
||||
|
||||
# Euphoria Patches Settings
|
||||
All Euphoria options are disabled by default and the user can decide what to enable. Under the Popular Settings category, one can find the most popular Euphoria Patches features. Countless other settings exist and more get added with each update, have fun tinkering around!
|
||||
|
||||
# Euphoria Patches Credits
|
||||
This can be found in the Credits.txt file
|
||||
|
||||
# How to support Euphoria Patches
|
||||
You can support Euphoria Patches by being curious about new updates and sharing it with people, but you can also directly support SpacEagle17 on Patreon or Ko-Fi. https://www.patreon.com/SpacEagle17. https://ko-fi.com/spaceagle17.
|
||||
|
||||
# Euphoria Mod Support
|
||||
Check the supportedMods.md file or the [properties repo](https://github.com/EuphoriaPatches/propertiesFiles)
|
||||
|
||||
- Euphoria Patches aims to better support modded blocks than regular Complementary by having default modded block support (check block.properties). Light Source Detection with automatic applied emission. Foliage model detection with automatically applied SSS.
|
||||
- Euphoria Patches adds support to MANY blocks, entities and items though the properties files thanks to the community. Check the supportedMods.md file or the [properties repo](https://github.com/EuphoriaPatches/propertiesFiles)
|
||||
- Better modded end handling, the ender beams and fog will correctly change to the intended fog color in non vanilla biomes in the end
|
||||
|
||||
|
||||
# Best Shader Loader
|
||||
Euphoria Patches and also Complementary Shaders use iris-exclusive features which don't work on optifine. For the optimal experience, Iris is recommended on Fabric and Neoforge. On Forge Oculus is for now recommended as it seems to support most iris-exclusive features.
|
||||
|
||||
# Iris Exclusive Features
|
||||
**Things marked with (EP) are from Euphoria Patches**
|
||||
- Advanced Colored Lighting and all features related to it: Connected Glass, Colored Light Fog, Portal Edge Effect, Puddle Voxelation, Better waving nether vines and sugar cane(EP), Lava Edge Effect(EP)
|
||||
- Player Shadow Setting
|
||||
- Item and entity ipbr, such as glowing armor trims or light sources in the hand being emissive or iron golems being reflective
|
||||
- No rain above clouds(EP) working with vanilla clouds if the cloud height was changed with a mod
|
||||
- End Crystal Vortex and Dragon Healing Beam
|
||||
- Epic Thunderstorm(EP) works better - does generate from the lightning bolt and no false positives
|
||||
- Better modded SSBL(EP) support - light sources are automatically emissive depending on their light level and also work correctly if hand mode is switched to right handed
|
||||
- Better working Bedrock Noise(EP) setting
|
||||
- More accurate position data
|
||||
- More accurate handheld lighting, works correctly in third person
|
||||
- Distant Horizons Support
|
||||
- Emissive fire on Entities
|
||||
- End Portal Rays (EP)
|
||||
- Third Person interactive foliage (EP) and third person soul sand eyes (EP)
|
||||
@ -0,0 +1 @@
|
||||
This version of Euphoria Patches is an add-on for Complementary Shaders r5.4 by EminGT
|
||||
@ -0,0 +1,2 @@
|
||||
ComplementaryReimagined_r5.4.zip
|
||||
ComplementaryUnbound_r5.4.zip
|
||||
File diff suppressed because one or more lines are too long
@ -0,0 +1,34 @@
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
##### IMPORTANT! WHERE TO CONTRIBUTE: #####
|
||||
# If you want to contribute to the Euphoria Patches modded support library, please only edit the files from GitHub. https://euphoriapatches.com/properties
|
||||
#
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
#### Template for Dimensions: ####
|
||||
#
|
||||
# dimension.world-1 = vanillaId1 vanillaId2 \
|
||||
# \
|
||||
# modName1:modId1 modName1:modId2 modName1:modId3 ... \
|
||||
# \
|
||||
# modName2:modId1 modName2:modId2 modName2:modId3 ... \
|
||||
#
|
||||
# dimension.world1 = ...
|
||||
# ...
|
||||
#
|
||||
# IDs should be grouped by mods, for every new mod it should be added in a new line using "\"
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
dimension.world0=* \
|
||||
\
|
||||
ad_astra:mars ad_astra:glacio
|
||||
|
||||
dimension.world-1=minecraft:the_nether minecraft:nether minecraft:world-1_the_nether \
|
||||
\
|
||||
ad_astra:venus ad_astra:mercury \
|
||||
\
|
||||
prominent:vaaz_volcano prominent:cinderstone_depths
|
||||
|
||||
dimension.world1=minecraft:the_end minecraft:end minecraft:world1_the_end \
|
||||
\
|
||||
ad_astra:venus_orbit ad_astra:moon_orbit ad_astra:mercury_orbit ad_astra:mars_orbit ad_astra:glacio_orbit ad_astra:earth_orbit ad_astra:moon \
|
||||
\
|
||||
minecraft:thermalpoint
|
||||
@ -0,0 +1,179 @@
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
# Version 1.0 - Every time a vanilla block changes this number will go up, modded blocks don't affect the version number
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
#
|
||||
##### IMPORTANT! WHERE TO CONTRIBUTE: #####
|
||||
# If you want to contribute to the Euphoria Patches modded support library, please only edit the files from GitHub. https://euphoriapatches.com/properties
|
||||
#
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
#### Template for Modded Entities: ####
|
||||
#
|
||||
# # Description of the Entity ID
|
||||
# entity.XXXXX = vanillaId1 vanillaId2 vanillaId3 ... \
|
||||
# \
|
||||
# modName1:modId1 modName1:modId2 modName1:modId3 ... \
|
||||
# \
|
||||
# modName2:modId1 modName2:modId2 modName2:modId3 ... \
|
||||
# ...
|
||||
# lastModInThisIDName:modId1 lastModInThisIDName:modId2 lastModInThisIDName:modId3
|
||||
|
||||
# # Description of the Next Entity ID
|
||||
# entity.YYYYY = ...
|
||||
# ...
|
||||
|
||||
# - The last line of a entity.XXXX does not have a "\"
|
||||
|
||||
# --- IDs should be grouped by mods, for every new mod it should be added in a new line using "\" ---
|
||||
#---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#if MC_VERSION >= 11300
|
||||
#1.13 And Above Mapping:
|
||||
|
||||
entity.50000 = end_crystal
|
||||
|
||||
entity.50004 = lightning_bolt
|
||||
|
||||
entity.50008 = item_frame glow_item_frame \
|
||||
\
|
||||
tconstruct:fancy_item_frame
|
||||
|
||||
entity.50012 = iron_golem \
|
||||
\
|
||||
createbigcannons:ap_autocannon createbigcannons:ap_shot createbigcannons:ap_shell createbigcannons:cannon_carriage createbigcannons:flak_autocannon createbigcannons:fluid_shell createbigcannons:he_shell createbigcannons:shot createbigcannons:shrapnel_shell createbigcannons:smoke_shell \
|
||||
\
|
||||
ad_astra:tier_4_rocket ad_astra:tier_3_rocket ad_astra:tier_2_rocket ad_astra:tier_1_rocket ad_astra:lander \
|
||||
\
|
||||
securitycraft:bouncingbetty securitycraft:security_sea_boat securitycraft:sentry securitycraft:securitycamera securitycraft:bullet \
|
||||
\
|
||||
born_in_chaos_v1:door_knight born_in_chaos_v1:door_knight_not_despawn born_in_chaos_v1:fallen_chaos_knight \
|
||||
\
|
||||
man_of_many_planes:scarlet_biplane \
|
||||
\
|
||||
grapplemod:grapplehook
|
||||
|
||||
entity.50016 = player
|
||||
|
||||
entity.50020 = blaze \
|
||||
\
|
||||
burnt:fire_devil \
|
||||
\
|
||||
betternether:hydrogen_jellyfish \
|
||||
\
|
||||
adventurez:blaze_guardian adventurez:blaze_guardian_shield
|
||||
|
||||
entity.50024 = creeper \
|
||||
\
|
||||
ad_astra:sulfur_creeper
|
||||
|
||||
entity.50028 = drowned
|
||||
|
||||
entity.50032 = guardian
|
||||
|
||||
entity.50036 = elder_guardian
|
||||
|
||||
entity.50040 = endermite
|
||||
|
||||
entity.50044 = ghast
|
||||
|
||||
entity.50048 = glow_squid \
|
||||
\
|
||||
betternether:firefly \
|
||||
\
|
||||
betterend:cubozoa
|
||||
|
||||
entity.50052 = magma_cube \
|
||||
\
|
||||
wilderwild:scorched
|
||||
|
||||
entity.50056 = stray
|
||||
|
||||
entity.50060 = vex \
|
||||
\
|
||||
adventurez:amethyst_shard adventurez:void_shade adventurez:void_shard \
|
||||
\
|
||||
tconstruct:crystalshot tconstruct:glow_ball \
|
||||
\
|
||||
ad_astra:ice_spit \
|
||||
\
|
||||
born_in_chaos_v1:phantom_creeper born_in_chaos_v1:phantom_creeper_copy born_in_chaos_v1:restless_spirit born_in_chaos_v1:scarlet_persecutor
|
||||
|
||||
entity.50064 = witch
|
||||
|
||||
entity.50068 = wither wither_skull \
|
||||
\
|
||||
betternether:naga \
|
||||
\
|
||||
born_in_chaos_v1:lifestealer_true_form born_in_chaos_v1:lifestealer
|
||||
|
||||
entity.50072 = experience_orb \
|
||||
\
|
||||
levelz:level_experience_orb \
|
||||
\
|
||||
adventurez:void_bullet \
|
||||
\
|
||||
create_enchantment_industry:hyper_experience_orb \
|
||||
\
|
||||
dimdoors:monolith
|
||||
|
||||
entity.50076 = boat oak_boat spruce_boat birch_boat jungle_boat acacia_boat dark_oak_boat mangrove_boat cherry_boat pale_oak_boat chest_boat oak_chest_boat spruce_chest_boat birch_chest_boat jungle_chest_boat acacia_chest_boat dark_oak_chest_boat mangrove_chest_boat cherry_chest_boat pale_oak_chest_boat \
|
||||
\
|
||||
ecologics:boat ecologics:chest_boat \
|
||||
\
|
||||
terraform:boat terraform:chest_boat \
|
||||
\
|
||||
wilderwild:boat wilderwild:chest_boat wilderwild:baobab_boat wilderwild:baobab_chest_boat wilderwild:cypress_boat wilderwild:cypress_chest_boat wilderwild:palm_boat wilderwild:palm_chest_boat wilderwild:maple_boat wilderwild:maple_chest_boat
|
||||
|
||||
entity.50080 = allay \
|
||||
\
|
||||
ore_creeper:coal_creeper ore_creeper:copper_creeper ore_creeper:iron_creeper ore_creeper:gold_creeper ore_creeper:diamond_creeper ore_creeper:emerald_creeper ore_creeper:lapis_lazuli_creeper ore_creeper:redstone_creeper ore_creeper:nether_gold_creeper ore_creeper:nether_quartz_creeper \
|
||||
\
|
||||
adventurez:amethyst_golem adventurez:blackstone_golem adventurez:nightmare adventurez:soul_reaper adventurez:the_eye adventurez:tiny_eye \
|
||||
\
|
||||
betterend:dragonfly betterend:end_fish \
|
||||
\
|
||||
create_enchantment_industry:hyper_experience_bottle \
|
||||
\
|
||||
supplementaries:bomb \
|
||||
\
|
||||
born_in_chaos_v1:stimulating_bombprojectile born_in_chaos_v1:staffof_blindness_projectile born_in_chaos_v1:sir_pumpkinhead born_in_chaos_v1:sir_pumpkinhead_without_horse born_in_chaos_v1:sir_the_headless born_in_chaos_v1:senor_pumpkin born_in_chaos_v1:seared_spirit_not_despawn born_in_chaos_v1:seared_spirit born_in_chaos_v1:intoxicatind_bomb_projectile born_in_chaos_v1:missionary_charge born_in_chaos_v1:nightmare_stalker born_in_chaos_v1:riding_lords_felsteed born_in_chaos_v1:riding_felsteed born_in_chaos_v1:pumpkinhead born_in_chaos_v1:pumpkin_staff_projectile born_in_chaos_v1:pumpkin_staff_2_projectile born_in_chaos_v1:pumpkin_pistol_projectile born_in_chaos_v1:pumpkin_pistol_2_projectile born_in_chaos_v1:pumpkin_bomb born_in_chaos_v1:mr_pumpkin born_in_chaos_v1:mr_pumpkin_controlled born_in_chaos_v1:lord_pumpkinhead born_in_chaos_v1:lord_pumpkinhead_head born_in_chaos_v1:lord_pumpkinhead_withouta_horse born_in_chaos_v1:lord_the_headless born_in_chaos_v1:lords_felsteed born_in_chaos_v1:felsteed born_in_chaos_v1:phantom_bomb_projectile born_in_chaos_v1:phantom_bomb_entity \
|
||||
\
|
||||
immersive_aircraft:bullet
|
||||
|
||||
entity.50084 = slime chicken \
|
||||
\
|
||||
betterend:end_slime \
|
||||
\
|
||||
tconstruct:earth_slime tconstruct:ender_slime tconstruct:sky_slime tconstruct:terracube
|
||||
|
||||
entity.50088 = entity_flame
|
||||
|
||||
entity.50089 = fireball dragon_fireball small_fireball \
|
||||
\
|
||||
securitycraft:imsbomb
|
||||
|
||||
entity.50092 = trident
|
||||
|
||||
entity.50096 = minecart chest_minecart command_block_minecart furnace_minecart hopper_minecart spawner_minecart tnt_minecart \
|
||||
\
|
||||
lootr:lootr_minecart \
|
||||
\
|
||||
railways:benchcart railways:conductor railways:jukeboxcart \
|
||||
\
|
||||
supplementaries:dispenser_minecart
|
||||
|
||||
entity.50100 = bogged
|
||||
|
||||
entity.50104 = piglin piglin_brute zombified_piglin hoglin zoglin
|
||||
|
||||
entity.50108 = creaking
|
||||
|
||||
entity.50200 = end_crystal_beam
|
||||
|
||||
entity.50204 = ender_dragon \
|
||||
\
|
||||
adventurez:dragon adventurez:ender_whale adventurez:enderwarthog adventurez:void_shadow
|
||||
|
||||
#else
|
||||
#1.12 And Below Mapping:
|
||||
|
||||
#endif
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,151 @@
|
||||
//FXAA 3.11 from http://blog.simonrodriguez.fr/articles/30-07-2016_implementing_fxaa.html
|
||||
float quality[12] = float[12] (1.0, 1.0, 1.0, 1.0, 1.0, 1.5, 2.0, 2.0, 2.0, 2.0, 4.0, 8.0);
|
||||
|
||||
void FXAA311(inout vec3 color) {
|
||||
float edgeThresholdMin = 0.03125;
|
||||
float edgeThresholdMax = 0.0625;
|
||||
float subpixelQuality = 0.75;
|
||||
int iterations = 12;
|
||||
|
||||
vec2 view = 1.0 / vec2(viewWidth, viewHeight);
|
||||
|
||||
float lumaCenter = GetLuminance(color);
|
||||
float lumaDown = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 0, -1), 0).rgb);
|
||||
float lumaUp = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 0, 1), 0).rgb);
|
||||
float lumaLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, 0), 0).rgb);
|
||||
float lumaRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, 0), 0).rgb);
|
||||
|
||||
float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight)));
|
||||
float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight)));
|
||||
|
||||
float lumaRange = lumaMax - lumaMin;
|
||||
|
||||
if (lumaRange > max(edgeThresholdMin, lumaMax * edgeThresholdMax)) {
|
||||
float lumaDownLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, -1), 0).rgb);
|
||||
float lumaUpRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, 1), 0).rgb);
|
||||
float lumaUpLeft = GetLuminance(texelFetch(colortex3, texelCoord + ivec2(-1, 1), 0).rgb);
|
||||
float lumaDownRight = GetLuminance(texelFetch(colortex3, texelCoord + ivec2( 1, -1), 0).rgb);
|
||||
|
||||
float lumaDownUp = lumaDown + lumaUp;
|
||||
float lumaLeftRight = lumaLeft + lumaRight;
|
||||
|
||||
float lumaLeftCorners = lumaDownLeft + lumaUpLeft;
|
||||
float lumaDownCorners = lumaDownLeft + lumaDownRight;
|
||||
float lumaRightCorners = lumaDownRight + lumaUpRight;
|
||||
float lumaUpCorners = lumaUpRight + lumaUpLeft;
|
||||
|
||||
float edgeHorizontal = abs(-2.0 * lumaLeft + lumaLeftCorners ) +
|
||||
abs(-2.0 * lumaCenter + lumaDownUp ) * 2.0 +
|
||||
abs(-2.0 * lumaRight + lumaRightCorners);
|
||||
float edgeVertical = abs(-2.0 * lumaUp + lumaUpCorners ) +
|
||||
abs(-2.0 * lumaCenter + lumaLeftRight ) * 2.0 +
|
||||
abs(-2.0 * lumaDown + lumaDownCorners );
|
||||
|
||||
bool isHorizontal = (edgeHorizontal >= edgeVertical);
|
||||
|
||||
float luma1 = isHorizontal ? lumaDown : lumaLeft;
|
||||
float luma2 = isHorizontal ? lumaUp : lumaRight;
|
||||
float gradient1 = luma1 - lumaCenter;
|
||||
float gradient2 = luma2 - lumaCenter;
|
||||
|
||||
bool is1Steepest = abs(gradient1) >= abs(gradient2);
|
||||
float gradientScaled = 0.25 * max(abs(gradient1), abs(gradient2));
|
||||
|
||||
float stepLength = isHorizontal ? view.y : view.x;
|
||||
|
||||
float lumaLocalAverage = 0.0;
|
||||
|
||||
if (is1Steepest) {
|
||||
stepLength = - stepLength;
|
||||
lumaLocalAverage = 0.5 * (luma1 + lumaCenter);
|
||||
} else {
|
||||
lumaLocalAverage = 0.5 * (luma2 + lumaCenter);
|
||||
}
|
||||
|
||||
vec2 currentUv = texCoord;
|
||||
if (isHorizontal) {
|
||||
currentUv.y += stepLength * 0.5;
|
||||
} else {
|
||||
currentUv.x += stepLength * 0.5;
|
||||
}
|
||||
|
||||
vec2 offset = isHorizontal ? vec2(view.x, 0.0) : vec2(0.0, view.y);
|
||||
|
||||
vec2 uv1 = currentUv - offset;
|
||||
vec2 uv2 = currentUv + offset;
|
||||
float lumaEnd1 = GetLuminance(texture2D(colortex3, uv1).rgb);
|
||||
float lumaEnd2 = GetLuminance(texture2D(colortex3, uv2).rgb);
|
||||
lumaEnd1 -= lumaLocalAverage;
|
||||
lumaEnd2 -= lumaLocalAverage;
|
||||
|
||||
bool reached1 = abs(lumaEnd1) >= gradientScaled;
|
||||
bool reached2 = abs(lumaEnd2) >= gradientScaled;
|
||||
bool reachedBoth = reached1 && reached2;
|
||||
|
||||
if (!reached1) {
|
||||
uv1 -= offset;
|
||||
}
|
||||
if (!reached2) {
|
||||
uv2 += offset;
|
||||
}
|
||||
|
||||
if (!reachedBoth) {
|
||||
for (int i = 2; i < iterations; i++) {
|
||||
if (!reached1) {
|
||||
lumaEnd1 = GetLuminance(texture2D(colortex3, uv1).rgb);
|
||||
lumaEnd1 = lumaEnd1 - lumaLocalAverage;
|
||||
}
|
||||
if (!reached2) {
|
||||
lumaEnd2 = GetLuminance(texture2D(colortex3, uv2).rgb);
|
||||
lumaEnd2 = lumaEnd2 - lumaLocalAverage;
|
||||
}
|
||||
|
||||
reached1 = abs(lumaEnd1) >= gradientScaled;
|
||||
reached2 = abs(lumaEnd2) >= gradientScaled;
|
||||
reachedBoth = reached1 && reached2;
|
||||
|
||||
if (!reached1) {
|
||||
uv1 -= offset * quality[i];
|
||||
}
|
||||
if (!reached2) {
|
||||
uv2 += offset * quality[i];
|
||||
}
|
||||
|
||||
if (reachedBoth) break;
|
||||
}
|
||||
}
|
||||
|
||||
float distance1 = isHorizontal ? (texCoord.x - uv1.x) : (texCoord.y - uv1.y);
|
||||
float distance2 = isHorizontal ? (uv2.x - texCoord.x) : (uv2.y - texCoord.y);
|
||||
|
||||
bool isDirection1 = distance1 < distance2;
|
||||
float distanceFinal = min(distance1, distance2);
|
||||
|
||||
float edgeThickness = (distance1 + distance2);
|
||||
|
||||
float pixelOffset = - distanceFinal / edgeThickness + 0.5;
|
||||
|
||||
bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage;
|
||||
|
||||
bool correctVariation = ((isDirection1 ? lumaEnd1 : lumaEnd2) < 0.0) != isLumaCenterSmaller;
|
||||
|
||||
float finalOffset = correctVariation ? pixelOffset : 0.0;
|
||||
|
||||
float lumaAverage = (1.0 / 12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners);
|
||||
float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter) / lumaRange, 0.0, 1.0);
|
||||
float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1;
|
||||
float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * subpixelQuality;
|
||||
|
||||
finalOffset = max(finalOffset, subPixelOffsetFinal);
|
||||
|
||||
// Compute the final UV coordinates.
|
||||
vec2 finalUv = texCoord;
|
||||
if (isHorizontal) {
|
||||
finalUv.y += finalOffset * stepLength;
|
||||
} else {
|
||||
finalUv.x += finalOffset * stepLength;
|
||||
}
|
||||
|
||||
color = texture2D(colortex3, finalUv).rgb;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
// Jitter offset from Chocapic13
|
||||
vec2 jitterOffsets[8] = vec2[8](
|
||||
vec2( 0.125,-0.375),
|
||||
vec2(-0.125, 0.375),
|
||||
vec2( 0.625, 0.125),
|
||||
vec2( 0.375,-0.625),
|
||||
vec2(-0.625, 0.625),
|
||||
vec2(-0.875,-0.125),
|
||||
vec2( 0.375,-0.875),
|
||||
vec2( 0.875, 0.875)
|
||||
);
|
||||
|
||||
vec2 TAAJitter(vec2 coord, float w) {
|
||||
vec2 offset = jitterOffsets[int(framemod8)] * (w / vec2(viewWidth, viewHeight));
|
||||
#if TAA_MODE == 1 && !defined DH_TERRAIN && !defined DH_WATER
|
||||
offset *= 0.125;
|
||||
#endif
|
||||
return coord + offset;
|
||||
}
|
||||
@ -0,0 +1,164 @@
|
||||
#if TAA_MODE == 1
|
||||
float blendMinimum = 0.3;
|
||||
float blendVariable = 0.2;
|
||||
float blendConstant = 0.7;
|
||||
|
||||
float regularEdge = 20.0;
|
||||
float extraEdgeMult = 3.0;
|
||||
#elif TAA_MODE == 2
|
||||
float blendMinimum = 0.6;
|
||||
float blendVariable = 0.2;
|
||||
float blendConstant = 0.7;
|
||||
|
||||
float regularEdge = 5.0;
|
||||
float extraEdgeMult = 3.0;
|
||||
#endif
|
||||
|
||||
// Previous frame reprojection from Chocapic13
|
||||
vec2 Reprojection(vec4 viewPos1) {
|
||||
vec4 pos = gbufferModelViewInverse * viewPos1;
|
||||
vec4 previousPosition = pos + vec4(cameraPosition - previousCameraPosition, 0.0);
|
||||
previousPosition = gbufferPreviousModelView * previousPosition;
|
||||
previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
return previousPosition.xy / previousPosition.w * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec3 RGBToYCoCg(vec3 col) {
|
||||
return vec3(
|
||||
col.r * 0.25 + col.g * 0.5 + col.b * 0.25,
|
||||
col.r * 0.5 - col.b * 0.5,
|
||||
col.r * -0.25 + col.g * 0.5 + col.b * -0.25
|
||||
);
|
||||
}
|
||||
|
||||
vec3 YCoCgToRGB(vec3 col) {
|
||||
float n = col.r - col.b;
|
||||
return vec3(n + col.g, col.r + col.b, n - col.g);
|
||||
}
|
||||
|
||||
vec3 ClipAABB(vec3 q, vec3 aabb_min, vec3 aabb_max){
|
||||
vec3 p_clip = 0.5 * (aabb_max + aabb_min);
|
||||
vec3 e_clip = 0.5 * (aabb_max - aabb_min) + 0.00000001;
|
||||
|
||||
vec3 v_clip = q - vec3(p_clip);
|
||||
vec3 v_unit = v_clip.xyz / e_clip;
|
||||
vec3 a_unit = abs(v_unit);
|
||||
float ma_unit = max(a_unit.x, max(a_unit.y, a_unit.z));
|
||||
|
||||
if (ma_unit > 1.0)
|
||||
return vec3(p_clip) + v_clip / ma_unit;
|
||||
else
|
||||
return q;
|
||||
}
|
||||
|
||||
ivec2 neighbourhoodOffsets[8] = ivec2[8](
|
||||
ivec2( 1, 1),
|
||||
ivec2( 1,-1),
|
||||
ivec2(-1, 1),
|
||||
ivec2(-1,-1),
|
||||
ivec2( 1, 0),
|
||||
ivec2( 0, 1),
|
||||
ivec2(-1, 0),
|
||||
ivec2( 0,-1)
|
||||
);
|
||||
|
||||
void NeighbourhoodClamping(vec3 color, inout vec3 tempColor, float z0, float z1, inout float edge) {
|
||||
vec3 minclr = color;
|
||||
vec3 maxclr = minclr;
|
||||
|
||||
int cc = 2;
|
||||
ivec2 texelCoordM1 = clamp(texelCoord, ivec2(cc), ivec2(view) - cc); // Fixes screen edges
|
||||
for (int i = 0; i < 8; i++) {
|
||||
ivec2 texelCoordM2 = texelCoordM1 + neighbourhoodOffsets[i];
|
||||
|
||||
float z0Check = texelFetch(depthtex0, texelCoordM2, 0).r;
|
||||
float z1Check = texelFetch(depthtex1, texelCoordM2, 0).r;
|
||||
if (max(abs(GetLinearDepth(z0Check) - GetLinearDepth(z0)), abs(GetLinearDepth(z1Check) - GetLinearDepth(z1))) > 0.09) {
|
||||
edge = regularEdge;
|
||||
|
||||
if (int(texelFetch(colortex6, texelCoordM2, 0).g * 255.1) == 253) // Reduced Edge TAA
|
||||
edge *= extraEdgeMult;
|
||||
}
|
||||
|
||||
vec3 clr = texelFetch(colortex3, texelCoordM2, 0).rgb;
|
||||
minclr = min(minclr, clr); maxclr = max(maxclr, clr);
|
||||
}
|
||||
|
||||
tempColor = ClipAABB(tempColor, minclr, maxclr);
|
||||
}
|
||||
|
||||
void DoTAA(inout vec3 color, inout vec3 temp, float z1) {
|
||||
int materialMask = int(texelFetch(colortex6, texelCoord, 0).g * 255.1);
|
||||
|
||||
vec4 screenPos1 = vec4(texCoord, z1, 1.0);
|
||||
vec4 viewPos1 = gbufferProjectionInverse * (screenPos1 * 2.0 - 1.0);
|
||||
viewPos1 /= viewPos1.w;
|
||||
|
||||
#ifdef ENTITY_TAA_NOISY_CLOUD_FIX
|
||||
float cloudLinearDepth = texture2D(colortex4, texCoord).r;
|
||||
float lViewPos1 = length(viewPos1);
|
||||
|
||||
if (pow2(cloudLinearDepth) * renderDistance < min(lViewPos1, renderDistance)) {
|
||||
// Material in question is obstructed by the cloud volume
|
||||
materialMask = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (materialMask == 254) { // No SSAO, No TAA
|
||||
#ifndef CUSTOM_PBR
|
||||
if (z1 <= 0.56) return; // The edge pixel trick doesn't look nice on hand
|
||||
#endif
|
||||
int i = 0;
|
||||
while (i < 4) {
|
||||
int mms = int(texelFetch(colortex6, texelCoord + neighbourhoodOffsets[i], 0).g * 255.1);
|
||||
if (mms != materialMask) break;
|
||||
i++;
|
||||
} // Checking edge-pixels prevents flickering
|
||||
if (i == 4) return;
|
||||
}
|
||||
|
||||
float z0 = texelFetch(depthtex0, texelCoord, 0).r;
|
||||
|
||||
vec2 prvCoord = texCoord;
|
||||
if (z1 > 0.56) prvCoord = Reprojection(viewPos1);
|
||||
|
||||
vec3 tempColor = texture2D(colortex2, prvCoord).rgb;
|
||||
if (tempColor == vec3(0.0)) { // Fixes the first frame || Possibly fixes nans spreading around
|
||||
temp = color;
|
||||
return;
|
||||
}
|
||||
|
||||
float edge = 0.0;
|
||||
NeighbourhoodClamping(color, tempColor, z0, z1, edge);
|
||||
|
||||
if (materialMask == 253) // Reduced Edge TAA
|
||||
edge *= extraEdgeMult;
|
||||
|
||||
#ifdef DISTANT_HORIZONS
|
||||
if (z0 == 1.0) {
|
||||
blendMinimum = 0.75;
|
||||
blendVariable = 0.05;
|
||||
blendConstant = 0.9;
|
||||
edge = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
vec2 velocity = (texCoord - prvCoord.xy) * view;
|
||||
float blendFactor = float(prvCoord.x > 0.0 && prvCoord.x < 1.0 &&
|
||||
prvCoord.y > 0.0 && prvCoord.y < 1.0);
|
||||
float velocityFactor = dot(velocity, velocity) * 10.0;
|
||||
blendFactor *= max(exp(-velocityFactor) * blendVariable + blendConstant - length(cameraPosition - previousCameraPosition) * edge, blendMinimum);
|
||||
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
if (isLightningActive() > 0.0) blendFactor = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef MIRROR_DIMENSION
|
||||
blendFactor = 0.0;
|
||||
#endif
|
||||
|
||||
color = mix(color, tempColor, blendFactor);
|
||||
temp = color;
|
||||
|
||||
//if (edge > 0.05) color.rgb = vec3(1.0, 0.0, 1.0);
|
||||
}
|
||||
@ -0,0 +1,186 @@
|
||||
float GetAuroraVisibility(in float VdotU) {
|
||||
float visibility = sqrt1(clamp01(VdotU * (AURORA_DRAW_DISTANCE * 1.125 + 0.75) - 0.225)) - sunVisibility - maxBlindnessDarkness;
|
||||
|
||||
#ifdef CLEAR_SKY_WHEN_RAINING
|
||||
visibility -= mix(0.0, rainFactor * 0.8 + 0.2, heightRelativeToCloud);
|
||||
#elif defined NO_RAIN_ABOVE_CLOUDS
|
||||
visibility -= mix(0.0, rainFactor, heightRelativeToCloud);
|
||||
#else
|
||||
visibility -= rainFactor;
|
||||
#endif
|
||||
|
||||
visibility *= 1.0 - VdotU * 0.9;
|
||||
|
||||
#if AURORA_CONDITION == 1 || AURORA_CONDITION == 3
|
||||
visibility -= moonPhase;
|
||||
#endif
|
||||
#if AURORA_CONDITION == 2 || AURORA_CONDITION == 3
|
||||
visibility *= inSnowy;
|
||||
#endif
|
||||
#if AURORA_CONDITION == 4
|
||||
visibility = max(visibility * inSnowy, visibility - moonPhase);
|
||||
#endif
|
||||
|
||||
return visibility;
|
||||
}
|
||||
|
||||
vec3 auroraUpA[] = vec3[](
|
||||
vec3(112.0, 36.0, 192.0),
|
||||
vec3(255.0, 56.0, 64.0),
|
||||
vec3(255.0, 80.0, 112.0),
|
||||
vec3(72.0, 96.0, 192.0),
|
||||
vec3(112.0, 80.0, 255.0),
|
||||
vec3(232.0, 116.0, 232.0),
|
||||
vec3(212.0, 108.0, 216.0),
|
||||
vec3(120.0, 212.0, 56.0),
|
||||
vec3(64.0, 255.0, 255.0),
|
||||
vec3(168.0, 36.0, 88.0),
|
||||
vec3(255.0, 68.0, 124.0),
|
||||
vec3(216.0, 8.0, 255.0),
|
||||
vec3(0.0, 255.0, 255.0),
|
||||
vec3(0.0, 20.0, 60.0)
|
||||
);
|
||||
vec3 auroraDownA[] = vec3[](
|
||||
vec3(96.0, 255.0, 192.0),
|
||||
vec3(204.0, 172.0, 12.0),
|
||||
vec3(80.0, 255.0, 180.0),
|
||||
vec3(172.0, 44.0, 88.0),
|
||||
vec3(80.0, 255.0, 180.0),
|
||||
vec3(244.0, 188.0, 28.0),
|
||||
vec3(92.0, 188.0, 180.0),
|
||||
vec3(176.0, 88.0, 72.0),
|
||||
vec3(128.0, 64.0, 128.0),
|
||||
vec3(60.0, 184.0, 152.0),
|
||||
vec3(160.0, 96.0, 255.0),
|
||||
vec3(32.0, 176.0, 33.0),
|
||||
vec3(180.0, 0.0, 0.0),
|
||||
vec3(0.0, 24.0, 36.0)
|
||||
);
|
||||
|
||||
void GetAuroraColor(in vec2 wpos, out vec3 auroraUp, out vec3 auroraDown) {
|
||||
#ifdef SPOOKY
|
||||
auroraUp = vec3(0.0, 255.0, 255.0);
|
||||
auroraDown = vec3(180.0, 0.0, 0.0);
|
||||
#else
|
||||
#ifdef RGB_AURORA
|
||||
auroraUp = getRainbowColor(wpos, 0.06);
|
||||
auroraDown = getRainbowColor(wpos, 0.05);
|
||||
#elif AURORA_COLOR_PRESET == 0
|
||||
auroraUp = vec3(AURORA_UP_R, AURORA_UP_G, AURORA_UP_B);
|
||||
auroraDown = vec3(AURORA_DOWN_R, AURORA_DOWN_G, AURORA_DOWN_B);
|
||||
#else
|
||||
#if AURORA_COLOR_PRESET == 1
|
||||
int p = worldDay % auroraUpA.length();
|
||||
#elif AURORA_COLOR_PRESET == 2
|
||||
int p = worldDay % (auroraUpA.length() * 8) / 8;
|
||||
#else
|
||||
const int p = AURORA_COLOR_PRESET - 2;
|
||||
#endif
|
||||
|
||||
auroraUp = auroraUpA[p];
|
||||
auroraDown = auroraDownA[p];
|
||||
#endif
|
||||
#endif
|
||||
|
||||
auroraUp *= (AURORA_UP_I * 0.093 + 3.1) / GetLuminance(auroraUp);
|
||||
auroraDown *= (AURORA_DOWN_I * 0.245 + 8.15) / GetLuminance(auroraDown);
|
||||
}
|
||||
|
||||
vec3 AuroraAmbientColor(vec3 color, vec3 viewPos) {
|
||||
float visibility = GetAuroraVisibility(0.5);
|
||||
if (visibility > 0) {
|
||||
vec3 wpos = (gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz;
|
||||
wpos.xz /= (abs(wpos.y) + length(wpos.xz));
|
||||
|
||||
vec3 auroraUp, auroraDown;
|
||||
GetAuroraColor(wpos.xz, auroraUp, auroraDown);
|
||||
|
||||
vec3 auroraColor = mix(auroraUp, auroraDown, 0.8);
|
||||
#ifdef DEFERRED1
|
||||
auroraColor *= 0.2;
|
||||
visibility *= AURORA_CLOUD_INFLUENCE_INTENSITY;
|
||||
#elif defined GBUFFERS_CLOUDS
|
||||
auroraColor *= 0.6;
|
||||
visibility *= AURORA_CLOUD_INFLUENCE_INTENSITY;
|
||||
#elif defined COMPOSITE
|
||||
visibility *= AURORA_CLOUD_INFLUENCE_INTENSITY;
|
||||
return mix(color, auroraColor, visibility);
|
||||
#else
|
||||
auroraColor *= 0.05;
|
||||
visibility *= AURORA_TERRAIN_INFLUENCE_INTENSITY;
|
||||
#endif
|
||||
float luminanceColor = GetLuminance(color);
|
||||
vec3 newColor = mix(color, mix(color, vec3(luminanceColor), 0.88), visibility);
|
||||
newColor *= mix(vec3(1.0), auroraColor * luminanceColor * 10.0, visibility);
|
||||
return clamp01(newColor);
|
||||
// return mix(color, color * auroraColor, visibility); // old, keep it for now
|
||||
}
|
||||
return color;
|
||||
}
|
||||
|
||||
vec3 GetAuroraBorealis(vec3 viewPos, float VdotU, float dither) {
|
||||
float visibility = GetAuroraVisibility(VdotU);
|
||||
|
||||
if (visibility > 0.0) {
|
||||
vec3 aurora = vec3(0.0);
|
||||
|
||||
vec3 wpos = mat3(gbufferModelViewInverse) * viewPos;
|
||||
wpos.xz /= wpos.y;
|
||||
vec2 cameraPositionM = cameraPosition.xz * 0.0075;
|
||||
cameraPositionM.x += syncedTime * 0.04;
|
||||
|
||||
#ifdef DEFERRED1
|
||||
int sampleCount = 25;
|
||||
int sampleCountP = sampleCount + 5;
|
||||
#else
|
||||
int sampleCount = 10;
|
||||
int sampleCountP = sampleCount + 10;
|
||||
#endif
|
||||
|
||||
float ditherM = dither + 5.0;
|
||||
float auroraAnimate = frameTimeCounter * 0.001;
|
||||
|
||||
vec3 auroraUp, auroraDown;
|
||||
GetAuroraColor(wpos.xz, auroraUp, auroraDown);
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float current = pow2((i + ditherM) / sampleCountP);
|
||||
|
||||
vec2 planePos = wpos.xz * (AURORA_SIZE * 0.6 + 0.4 + current) * 11.0 + cameraPositionM;
|
||||
#if AURORA_STYLE == 1
|
||||
planePos = floor(planePos) * 0.0007;
|
||||
|
||||
float noise = texture2D(noisetex, planePos).b;
|
||||
noise = pow2(pow2(pow2(pow2(1.0 - 2.0 * abs(noise - 0.5)))));
|
||||
|
||||
noise *= pow1_5(texture2D(noisetex, planePos * 100.0 + auroraAnimate).b);
|
||||
#else
|
||||
planePos *= 0.0007;
|
||||
|
||||
float noise = texture2D(noisetex, planePos).r;
|
||||
noise = pow2(pow2(pow2(pow2(1.0 - 2.0 * abs(noise - 0.5)))));
|
||||
|
||||
noise *= texture2D(noisetex, planePos * 3.0 + auroraAnimate).b;
|
||||
noise *= texture2D(noisetex, planePos * 5.0 - auroraAnimate).b;
|
||||
#endif
|
||||
|
||||
float currentM = 1.0 - current;
|
||||
|
||||
aurora += noise * currentM * mix(auroraUp, auroraDown, pow2(pow2(currentM)));
|
||||
}
|
||||
|
||||
#if AURORA_STYLE == 1
|
||||
aurora *= 1.3;
|
||||
#else
|
||||
aurora *= 1.8;
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
aurora *= sqrtAtmColorMult; // C72380KD - Reduced atmColorMult impact on some things
|
||||
#endif
|
||||
|
||||
return aurora * visibility / sampleCount;
|
||||
}
|
||||
|
||||
return vec3(0.0);
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
vec3 GetBedrockNoise(vec3 viewPos, float VdotU, float dither) {
|
||||
float eyeAltitude1 = eyeAltitude * 0.005;
|
||||
float visibility = clamp01(-VdotU * 1.875 - 0.225) * (1.0 - maxBlindnessDarkness);
|
||||
visibility *= 1.0 + VdotU * 0.75;
|
||||
|
||||
// Calculate the distance from the player to the bedrockLevel
|
||||
float distanceToBedrock = max(0.0, bedrockLevel - eyeAltitude);
|
||||
|
||||
// Calculate the noiseHeightFactor based on the distance, starting large and decreasing as you approach bedrockLevel
|
||||
float maxNoiseHeight = 2.0; // Maximum noise height when far from bedrockLevel
|
||||
float noiseHeight = maxNoiseHeight / (1.0 + exp((distanceToBedrock - 90.0) / 120.0));
|
||||
|
||||
visibility *= -eyeAltitude1 * 3.0 + (bedrockLevel / 66.6) + 2.0;
|
||||
if (visibility > 0.0) {
|
||||
vec3 spots = vec3(0.0);
|
||||
|
||||
vec3 wpos = (gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz;
|
||||
wpos /= (abs(wpos.y) + length(wpos.xz) * 0.5);
|
||||
|
||||
vec2 cameraPositionM = cameraPosition.xz * 0.0075;
|
||||
cameraPositionM.x += frameTimeCounter * 0.004;
|
||||
|
||||
float VdotUM = 1.0 - VdotU * VdotU;
|
||||
|
||||
vec2 starCoord = noiseHeight * wpos.xz * 0.2 + cameraPositionM * 0.1;
|
||||
float starFactor = 1024.0;
|
||||
starCoord = floor(starCoord * starFactor) / starFactor;
|
||||
float star = 1.0;
|
||||
star *= GetStarNoise(starCoord.xy);
|
||||
star *= GetStarNoise(starCoord.xy+0.1);
|
||||
star *= GetStarNoise(starCoord.xy+0.23);
|
||||
star -= 0.4;
|
||||
star *= 6.0;
|
||||
star = max0(star);
|
||||
star *= star;
|
||||
|
||||
vec3 stars = star * vec3(0.1765, 0.1569, 0.1804);
|
||||
stars *= (VdotUM + 0.3); // remove stars below the player
|
||||
|
||||
float wind = fract((frameTimeCounter) * 0.0125);
|
||||
|
||||
int sampleCount = 1;
|
||||
int sampleCountP = sampleCount + 5;
|
||||
float ditherM = dither + 5.0;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float current = pow2((i + ditherM) / sampleCountP);
|
||||
|
||||
vec2 planePos = wpos.xz * (0.5 + current) * noiseHeight;
|
||||
planePos = (planePos * 0.5 + cameraPositionM * 0.5) * 20;
|
||||
float noiseSpots = texture2D(noisetex, floor(planePos) * 0.1).g;
|
||||
vec3 noise = texture2D(noisetex, vec2(noiseSpots) + wind * 0.3).b * vec3(0.3);
|
||||
|
||||
float currentM = 1.0 - current;
|
||||
spots += noise * currentM * 6.0;
|
||||
}
|
||||
#ifdef OVERWORLD
|
||||
spots = (spots - 0.5) * 1.5 + 0.5; // contrast
|
||||
#else
|
||||
spots = (spots - 0.5) * 3.5 + 0.5; // contrast
|
||||
#endif
|
||||
spots += stars;
|
||||
return spots * visibility / sampleCount * clamp01(noiseHeight) + clamp01(noiseHeight) -1.0;
|
||||
}
|
||||
return vec3(0.0);
|
||||
}
|
||||
@ -0,0 +1,37 @@
|
||||
#ifndef INCLUDE_CLOUD_COORD
|
||||
#define INCLUDE_CLOUD_COORD
|
||||
|
||||
// Thanks to SixthSurge
|
||||
vec2 GetRoundedCloudCoord(vec2 pos, float cloudRoundness) { // cloudRoundness is meant to be 0.125 for clouds and 0.35 for cloud shadows
|
||||
vec2 coord = pos.xy + 0.5;
|
||||
vec2 signCoord = sign(coord);
|
||||
coord = abs(coord) + 1.0;
|
||||
vec2 i, f = modf(coord, i);
|
||||
f = smoothstep(0.5 - cloudRoundness, 0.5 + cloudRoundness, f);
|
||||
coord = i + f;
|
||||
return (coord - 0.5) * signCoord / 256.0;
|
||||
}
|
||||
|
||||
vec3 ModifyTracePos(vec3 tracePos, int cloudAltitude) {
|
||||
#if CLOUD_SPEED_MULT == 100
|
||||
float wind = syncedTime;
|
||||
#else
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
float wind = frameTimeCounter * CLOUD_SPEED_MULT_M;
|
||||
#endif
|
||||
|
||||
#if INCREASED_RAIN_STRENGTH > 0
|
||||
if (rainFactor > 0.01) wind *= 2.5;
|
||||
#endif
|
||||
#if CLOUD_DIRECTION == 1
|
||||
tracePos.x += wind;
|
||||
#else
|
||||
tracePos.z += wind;
|
||||
#endif
|
||||
|
||||
tracePos.z += cloudAltitude * 64.0;
|
||||
tracePos.xz *= CLOUD_NARROWNESS;
|
||||
return tracePos.xyz;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,126 @@
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/lib/colors/cloudColors.glsl"
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
|
||||
float InterleavedGradientNoiseForClouds() {
|
||||
float n = 52.9829189 * fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y);
|
||||
#ifdef TAA
|
||||
return fract(n + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#else
|
||||
return fract(n);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if SHADOW_QUALITY > -1
|
||||
vec3 GetShadowOnCloudPosition(vec3 tracePos, vec3 cameraPos) {
|
||||
vec3 wpos = PlayerToShadow(tracePos - cameraPos);
|
||||
float distb = sqrt(wpos.x * wpos.x + wpos.y * wpos.y);
|
||||
float distortFactor = 1.0 - shadowMapBias + distb * shadowMapBias;
|
||||
vec3 shadowPosition = vec3(vec2(wpos.xy / distortFactor), wpos.z * 0.2);
|
||||
return shadowPosition * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
bool GetShadowOnCloud(vec3 tracePos, vec3 cameraPos, int cloudAltitude, float lowerPlaneAltitude, float higherPlaneAltitude) {
|
||||
const float cloudShadowOffset = 0.5;
|
||||
|
||||
vec3 shadowPosition0 = GetShadowOnCloudPosition(tracePos, cameraPos);
|
||||
if (length(shadowPosition0.xy * 2.0 - 1.0) < 1.0) {
|
||||
float shadowsample0 = shadow2D(shadowtex0, shadowPosition0).z;
|
||||
|
||||
if (shadowsample0 == 0.0) return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
#include "/lib/atmospherics/clouds/reimaginedClouds.glsl"
|
||||
#endif
|
||||
#ifdef CLOUDS_UNBOUND
|
||||
#include "/lib/atmospherics/clouds/unboundClouds.glsl"
|
||||
#endif
|
||||
|
||||
vec4 GetClouds(inout float cloudLinearDepth, float skyFade, vec3 cameraPos, vec3 playerPos, vec3 viewPos,
|
||||
float lViewPos, float VdotS, float VdotU, float dither, vec3 auroraBorealis, vec3 nightNebula) {
|
||||
vec4 clouds = vec4(0.0);
|
||||
|
||||
vec3 nPlayerPos = normalize(playerPos);
|
||||
float lViewPosM = lViewPos < renderDistance * 1.5 ? lViewPos - 1.0 : 1000000000.0;
|
||||
float skyMult0 = pow2(skyFade * 3.333333 - 2.333333);
|
||||
|
||||
float thresholdMix = pow2(clamp01(VdotU * 5.0));
|
||||
float thresholdF = mix(far, 1000.0, thresholdMix * 0.5 + 0.5);
|
||||
#ifdef DISTANT_HORIZONS
|
||||
thresholdF = max(thresholdF, renderDistance);
|
||||
#endif
|
||||
thresholdF *= CLOUD_RENDER_DISTANCE;
|
||||
|
||||
#if RAINBOW_CLOUD != 0
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz);
|
||||
wpos /= (abs(wpos.y) + length(wpos.xz));
|
||||
|
||||
vec3 rainbowColor = getRainbowColor(wpos.xz * rainbowCloudDistribution * 0.35, 0.05);
|
||||
cloudRainColor *= rainbowColor;
|
||||
cloudAmbientColor *= rainbowColor;
|
||||
cloudLightColor *= rainbowColor;
|
||||
#endif
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
cloudAmbientColor *= 1.0 + auroraSpookyMix * vec3(19.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
cloudAmbientColor = mix(AuroraAmbientColor(cloudAmbientColor, viewPos), cloudAmbientColor, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
cloudAmbientColor *= 1.0 - 0.25 * rainFactor;
|
||||
#endif
|
||||
|
||||
vec3 cloudColorMult = vec3(1.0);
|
||||
#if CLOUD_R != 100 || CLOUD_G != 100 || CLOUD_B != 100
|
||||
cloudColorMult *= vec3(CLOUD_R, CLOUD_G, CLOUD_B) * 0.01;
|
||||
#endif
|
||||
cloudAmbientColor *= cloudColorMult;
|
||||
cloudLightColor *= cloudColorMult;
|
||||
|
||||
#if !defined DOUBLE_REIM_CLOUDS || defined CLOUDS_UNBOUND
|
||||
clouds = GetVolumetricClouds(cloudAlt1i, thresholdF, cloudLinearDepth, skyFade, skyMult0,
|
||||
cameraPos, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
#else
|
||||
int maxCloudAlt = max(cloudAlt1i, cloudAlt2i);
|
||||
int minCloudAlt = min(cloudAlt1i, cloudAlt2i);
|
||||
|
||||
if (abs(cameraPos.y - minCloudAlt) < abs(cameraPos.y - maxCloudAlt)) {
|
||||
clouds = GetVolumetricClouds(minCloudAlt, thresholdF, cloudLinearDepth, skyFade, skyMult0,
|
||||
cameraPos, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
if (clouds.a == 0.0) {
|
||||
clouds = GetVolumetricClouds(maxCloudAlt, thresholdF, cloudLinearDepth, skyFade, skyMult0,
|
||||
cameraPos, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
}
|
||||
} else {
|
||||
clouds = GetVolumetricClouds(maxCloudAlt, thresholdF, cloudLinearDepth, skyFade, skyMult0,
|
||||
cameraPos, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
if (clouds.a == 0.0) {
|
||||
clouds = GetVolumetricClouds(minCloudAlt, thresholdF, cloudLinearDepth, skyFade, skyMult0,
|
||||
cameraPos, nPlayerPos, lViewPosM, VdotS, VdotU, dither);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
clouds.rgb *= sqrtAtmColorMult; // C72380KD - Reduced atmColorMult impact on some things
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
clouds.rgb *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
#if AURORA_STYLE > 0
|
||||
clouds.rgb += auroraBorealis * 0.1;
|
||||
#endif
|
||||
#ifdef NIGHT_NEBULA
|
||||
clouds.rgb += nightNebula * 0.2;
|
||||
#endif
|
||||
|
||||
return clouds;
|
||||
}
|
||||
@ -0,0 +1,149 @@
|
||||
#include "/lib/atmospherics/clouds/cloudCoord.glsl"
|
||||
|
||||
const float cloudStretch = CLOUD_STRETCH * 5.5;
|
||||
const float cloudHeightShader = cloudStretch * 2.0;
|
||||
|
||||
bool GetCloudNoise(vec3 tracePos, inout vec3 tracePosM, int cloudAltitude) {
|
||||
tracePosM = ModifyTracePos(tracePos, cloudAltitude);
|
||||
vec2 coord = GetRoundedCloudCoord(tracePosM.xz, CLOUD_ROUNDNESS);
|
||||
|
||||
#ifdef DEFERRED1
|
||||
float noise = texture2D(colortex3, coord).b;
|
||||
#else
|
||||
float noise = texture2D(gaux4, coord).b;
|
||||
#endif
|
||||
|
||||
float threshold = clamp(abs(cloudAltitude - tracePos.y) / cloudStretch, 0.001, 0.999);
|
||||
threshold = pow2(pow2(pow2(threshold)));
|
||||
return noise > threshold * 0.5 + 0.25;
|
||||
}
|
||||
|
||||
vec4 GetVolumetricClouds(int cloudAltitude, float distanceThreshold, inout float cloudLinearDepth, float skyFade, float skyMult0, vec3 cameraPos, vec3 nPlayerPos, float lViewPosM, float VdotS, float VdotU, float dither) {
|
||||
vec4 volumetricClouds = vec4(0.0);
|
||||
|
||||
float higherPlaneAltitude = cloudAltitude + cloudStretch;
|
||||
float lowerPlaneAltitude = cloudAltitude - cloudStretch;
|
||||
|
||||
float lowerPlaneDistance = (lowerPlaneAltitude - cameraPos.y) / nPlayerPos.y;
|
||||
float higherPlaneDistance = (higherPlaneAltitude - cameraPos.y) / nPlayerPos.y;
|
||||
float minPlaneDistance = min(lowerPlaneDistance, higherPlaneDistance);
|
||||
minPlaneDistance = max(minPlaneDistance, 0.0);
|
||||
float maxPlaneDistance = max(lowerPlaneDistance, higherPlaneDistance);
|
||||
if (maxPlaneDistance < 0.0) return vec4(0.0);
|
||||
float planeDistanceDif = maxPlaneDistance - minPlaneDistance;
|
||||
|
||||
#if CLOUD_QUALITY_INTERNAL == 1 || !defined DEFERRED1
|
||||
int sampleCount = max(int(planeDistanceDif) / 16, 6);
|
||||
#elif CLOUD_QUALITY_INTERNAL == 2
|
||||
int sampleCount = max(int(planeDistanceDif) / 8, 12);
|
||||
#elif CLOUD_QUALITY_INTERNAL == 3 || CLOUD_QUALITY_INTERNAL == 4
|
||||
int sampleCount = max(int(planeDistanceDif), 12);
|
||||
#endif
|
||||
|
||||
float stepMult = planeDistanceDif / sampleCount;
|
||||
vec3 traceAdd = nPlayerPos * stepMult;
|
||||
vec3 tracePos = cameraPos + minPlaneDistance * nPlayerPos;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos.y -= traceAdd.y;
|
||||
|
||||
#ifdef FIX_AMD_REFLECTION_CRASH
|
||||
sampleCount = min(sampleCount, 30); //BFARC
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
vec3 cloudPlayerPos = tracePos - cameraPos;
|
||||
float lTracePos = length(cloudPlayerPos);
|
||||
float lTracePosXZ = length(cloudPlayerPos.xz);
|
||||
float cloudMult = 1.0;
|
||||
if (lTracePosXZ > distanceThreshold) break;
|
||||
if (lTracePos > lViewPosM) {
|
||||
if (skyFade < 0.7) continue;
|
||||
else cloudMult = skyMult0;
|
||||
}
|
||||
|
||||
vec3 tracePosM;
|
||||
if (GetCloudNoise(tracePos, tracePosM, cloudAltitude)) {
|
||||
float lightMult = 1.0;
|
||||
|
||||
#if SHADOW_QUALITY > -1
|
||||
float shadowLength = min(shadowDistance, far) * 0.9166667; //consistent08JJ622
|
||||
if (shadowLength > lTracePos)
|
||||
if (GetShadowOnCloud(tracePos, cameraPos, cloudAltitude, lowerPlaneAltitude, higherPlaneAltitude)) {
|
||||
#ifdef CLOUD_CLOSED_AREA_CHECK
|
||||
if (eyeBrightness.y != 240) continue;
|
||||
else
|
||||
#endif
|
||||
lightMult = 0.25;
|
||||
}
|
||||
#endif
|
||||
|
||||
float cloudShading = 1.0 - (higherPlaneAltitude - tracePos.y) / cloudHeightShader;
|
||||
float VdotSM1 = max0(sunVisibility > 0.5 ? VdotS : - VdotS);
|
||||
|
||||
#if CLOUD_QUALITY_INTERNAL >= 2
|
||||
#ifdef DEFERRED1
|
||||
float cloudShadingM = 1.0 - pow2(cloudShading);
|
||||
#else
|
||||
float cloudShadingM = 1.0 - cloudShading;
|
||||
#endif
|
||||
|
||||
float gradientNoise = InterleavedGradientNoiseForClouds();
|
||||
|
||||
vec3 cLightPos = tracePosM;
|
||||
vec3 cLightPosAdd = normalize(ViewToPlayer(lightVec * 1000000000.0)) * vec3(0.08);
|
||||
cLightPosAdd *= shadowTime;
|
||||
|
||||
float light = 2.0;
|
||||
cLightPos += (1.0 + gradientNoise) * cLightPosAdd;
|
||||
#ifdef DEFERRED1
|
||||
light -= texture2D(colortex3, GetRoundedCloudCoord(cLightPos.xz, CLOUD_ROUNDNESS)).b * cloudShadingM;
|
||||
#else
|
||||
light -= texture2D(gaux4, GetRoundedCloudCoord(cLightPos.xz, CLOUD_ROUNDNESS)).b * cloudShadingM;
|
||||
#endif
|
||||
cLightPos += gradientNoise * cLightPosAdd;
|
||||
#ifdef DEFERRED1
|
||||
light -= texture2D(colortex3, GetRoundedCloudCoord(cLightPos.xz, CLOUD_ROUNDNESS)).b * cloudShadingM;
|
||||
#else
|
||||
light -= texture2D(gaux4, GetRoundedCloudCoord(cLightPos.xz, CLOUD_ROUNDNESS)).b * cloudShadingM;
|
||||
#endif
|
||||
|
||||
float VdotSM2 = VdotSM1 * shadowTime * 0.25;
|
||||
VdotSM2 += 0.5 * cloudShading + 0.08;
|
||||
cloudShading = VdotSM2 * light * lightMult;
|
||||
#endif
|
||||
|
||||
vec3 colorSample = cloudAmbientColor + cloudLightColor * (0.07 + cloudShading);
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
vec3 lightningPos = getLightningPos(tracePos - cameraPosition, lightningBoltPosition.xyz, false);
|
||||
vec2 lightningAdd = lightningFlashEffect(lightningPos, vec3(1.0), 450.0, 0.0, 0) * isLightningActive() * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#endif
|
||||
vec3 cloudSkyColor = GetSky(VdotU, VdotS, dither, true, false);
|
||||
#ifdef ATM_COLOR_MULTS
|
||||
cloudSkyColor *= sqrtAtmColorMult; // C72380KD - Reduced atmColorMult impact on some things
|
||||
#endif
|
||||
float distanceRatio = (distanceThreshold - lTracePosXZ) / distanceThreshold;
|
||||
float cloudDistanceFactor = clamp(distanceRatio, 0.0, 0.75);
|
||||
#ifndef DISTANT_HORIZONS
|
||||
float cloudFogFactor = cloudDistanceFactor;
|
||||
#else
|
||||
float cloudFogFactor = pow1_5(clamp(distanceRatio, 0.0, 1.0)) * 0.75;
|
||||
#endif
|
||||
float nightCloudRemove = NIGHT_CLOUD_UNBOUND_REMOVE * (1.0 - sunVisibility) * -1 + 1.0; // mapped to 1 to 0 range
|
||||
cloudMult *= CLOUD_TRANSPARENCY * nightCloudRemove;
|
||||
float skyMult1 = 1.0 - 0.2 * (1.0 - skyFade) * max(sunVisibility2, nightFactor);
|
||||
float skyMult2 = 1.0 - 0.33333 * skyFade;
|
||||
colorSample = mix(cloudSkyColor, colorSample * skyMult1, cloudFogFactor * skyMult2);
|
||||
colorSample *= pow2(1.0 - maxBlindnessDarkness);
|
||||
|
||||
cloudLinearDepth = sqrt(lTracePos / renderDistance);
|
||||
volumetricClouds.a = pow(cloudDistanceFactor * 1.33333, 0.5 + 10.0 * pow(abs(VdotSM1), 90.0)) * cloudMult;
|
||||
volumetricClouds.rgb = colorSample;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return volumetricClouds;
|
||||
}
|
||||
@ -0,0 +1,251 @@
|
||||
#if CLOUD_UNBOUND_SIZE_MULT != 100
|
||||
#define CLOUD_UNBOUND_SIZE_MULT_M CLOUD_UNBOUND_SIZE_MULT * 0.01
|
||||
#endif
|
||||
const float cloudStretchModified = max(0.25, float(CLOUD_STRETCH) * 1.9 - 0.9);
|
||||
#if CLOUD_QUALITY_INTERNAL == 1 || !defined DEFERRED1
|
||||
const float cloudStretchRaw = 11.0 * cloudStretchModified;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 2
|
||||
const float cloudStretchRaw = 16.0 * cloudStretchModified;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 3
|
||||
const float cloudStretchRaw = 18.0 * cloudStretchModified;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 4
|
||||
const float cloudStretchRaw = 20.0 * cloudStretchModified;
|
||||
#endif
|
||||
#if CLOUD_UNBOUND_SIZE_MULT <= 100
|
||||
const float cloudStretch = cloudStretchRaw;
|
||||
#else
|
||||
const float cloudStretch = cloudStretchRaw / float(CLOUD_UNBOUND_SIZE_MULT_M);
|
||||
#endif
|
||||
|
||||
const float cloudHeightShader = cloudStretch * 2.0;
|
||||
|
||||
float GetCloudNoise(vec3 tracePos, int cloudAltitude, float lTracePosXZ, float cloudPlayerPosY) {
|
||||
vec3 tracePosM = tracePos.xyz * 0.00016;
|
||||
float wind = 0.0006;
|
||||
#if INCREASED_RAIN_STRENGTH == 1
|
||||
wind *= mix(1.0, 2.5, rainFactor);
|
||||
#elif INCREASED_RAIN_STRENGTH == 2
|
||||
if (rainFactor > 0.01) wind *= 2.5;
|
||||
#endif
|
||||
float noise = 0.0;
|
||||
float currentPersist = 1.0;
|
||||
float total = 0.0;
|
||||
|
||||
#if CLOUD_SPEED_MULT == 100
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
wind *= syncedTime;
|
||||
#else
|
||||
#define CLOUD_SPEED_MULT_M CLOUD_SPEED_MULT * 0.01
|
||||
wind *= frameTimeCounter * CLOUD_SPEED_MULT_M;
|
||||
#endif
|
||||
#if CLOUD_UNBOUND_SIZE_MULT != 100
|
||||
tracePosM *= CLOUD_UNBOUND_SIZE_MULT_M;
|
||||
wind *= CLOUD_UNBOUND_SIZE_MULT_M;
|
||||
#endif
|
||||
|
||||
#if CLOUD_QUALITY_INTERNAL == 1
|
||||
int sampleCount = 2;
|
||||
float persistance = 0.6;
|
||||
float noiseMult = 0.95;
|
||||
tracePosM *= 0.5; wind *= 0.5;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 2 || !defined DEFERRED1
|
||||
int sampleCount = 4;
|
||||
float persistance = 0.5;
|
||||
float noiseMult = 1.07;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 3
|
||||
int sampleCount = 4;
|
||||
float persistance = 0.5;
|
||||
float noiseMult = 1.0;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 4
|
||||
int sampleCount = 5;
|
||||
float persistance = 0.5;
|
||||
float noiseMult = 1.05;
|
||||
#endif
|
||||
|
||||
#ifndef DEFERRED1
|
||||
noiseMult *= 1.2;
|
||||
#endif
|
||||
|
||||
#if CLOUD_DIRECTION == 2
|
||||
tracePosM.xz = tracePosM.zx;
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
#if CLOUD_QUALITY_INTERNAL >= 2
|
||||
noise += Noise3D(tracePosM + vec3(wind, 0.0, 0.0)) * currentPersist;
|
||||
#else
|
||||
noise += texture2D(noisetex, tracePosM.xz + vec2(wind, 0.0)).b * currentPersist;
|
||||
#endif
|
||||
total += currentPersist;
|
||||
|
||||
tracePosM *= 3.0;
|
||||
wind *= 0.5;
|
||||
currentPersist *= persistance;
|
||||
}
|
||||
noise = pow2(noise / total);
|
||||
|
||||
#ifndef DISTANT_HORIZONS
|
||||
#define CLOUD_BASE_ADD 0.65
|
||||
#define CLOUD_FAR_ADD 0.01
|
||||
#define CLOUD_ABOVE_ADD 0.1
|
||||
#else
|
||||
#define CLOUD_BASE_ADD 0.9
|
||||
#define CLOUD_FAR_ADD -0.005
|
||||
#define CLOUD_ABOVE_ADD 0.03
|
||||
#endif
|
||||
|
||||
float spookyCloudAdd = 0.0;
|
||||
#ifdef SPOOKY
|
||||
spookyCloudAdd = 0.5;
|
||||
#endif
|
||||
float nightCloudRemove = NIGHT_CLOUD_UNBOUND_REMOVE * (1.0 - sunVisibility) * -0.65 + 1.0; // mapped to 1 to 0.65 range
|
||||
|
||||
float seasonCloudAdd = 0.0;
|
||||
#if SEASONS > 0
|
||||
float autumnOnlyForests = 1.0;
|
||||
#ifdef AUTUMN_CONDITION
|
||||
autumnOnlyForests = inForest;
|
||||
#endif
|
||||
float autumnWinterTime = autumnTime + winterTime;
|
||||
#if SNOW_CONDITION != 2
|
||||
autumnWinterTime *= mix(inSnowy + autumnOnlyForests, inSnowy, winterTime); // make only appear in cold biomes during winter
|
||||
#endif
|
||||
#if SNOW_CONDITION == 0
|
||||
autumnWinterTime *= mix(rainFactor + autumnOnlyForests, rainFactor, winterTime); // make only appear in rain during winter
|
||||
#endif
|
||||
seasonCloudAdd += mix(0.0, 0.35, autumnWinterTime);
|
||||
seasonCloudAdd += mix(0.0, -0.2, summerTime);
|
||||
#endif
|
||||
|
||||
noiseMult *= CLOUD_BASE_ADD
|
||||
+ CLOUD_FAR_ADD * sqrt(lTracePosXZ + 10.0) // more/less clouds far away
|
||||
+ CLOUD_ABOVE_ADD * clamp01(-cloudPlayerPosY / cloudHeightShader) // more clouds when camera is above them
|
||||
+ CLOUD_UNBOUND_RAIN_ADD * rainFactor + spookyCloudAdd + seasonCloudAdd; // more clouds during rain, Spooky and seasons
|
||||
noise *= noiseMult * CLOUD_UNBOUND_AMOUNT * nightCloudRemove;
|
||||
|
||||
float threshold = clamp(abs(cloudAltitude - tracePos.y) / cloudStretch, 0.001, 0.999);
|
||||
threshold = pow2(pow2(pow2(threshold)));
|
||||
return noise - (threshold * 0.2 + 0.25);
|
||||
}
|
||||
|
||||
vec4 GetVolumetricClouds(int cloudAltitude, float distanceThreshold, inout float cloudLinearDepth, float skyFade, float skyMult0, vec3 cameraPos, vec3 nPlayerPos, float lViewPosM, float VdotS, float VdotU, float dither) {
|
||||
vec4 volumetricClouds = vec4(0.0);
|
||||
|
||||
float higherPlaneAltitude = cloudAltitude + cloudStretch;
|
||||
float lowerPlaneAltitude = cloudAltitude - cloudStretch;
|
||||
|
||||
float lowerPlaneDistance = (lowerPlaneAltitude - cameraPos.y) / nPlayerPos.y;
|
||||
float higherPlaneDistance = (higherPlaneAltitude - cameraPos.y) / nPlayerPos.y;
|
||||
float minPlaneDistance = min(lowerPlaneDistance, higherPlaneDistance);
|
||||
minPlaneDistance = max(minPlaneDistance, 0.0);
|
||||
float maxPlaneDistance = max(lowerPlaneDistance, higherPlaneDistance);
|
||||
if (maxPlaneDistance < 0.0) return vec4(0.0);
|
||||
float planeDistanceDif = maxPlaneDistance - minPlaneDistance;
|
||||
|
||||
#ifndef DEFERRED1
|
||||
float stepMult = 32.0;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 1
|
||||
float stepMult = 16.0;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 2
|
||||
float stepMult = 24.0;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 3
|
||||
float stepMult = 16.0;
|
||||
#elif CLOUD_QUALITY_INTERNAL == 4
|
||||
float stepMult = 24.0;
|
||||
#endif
|
||||
|
||||
#if CLOUD_UNBOUND_SIZE_MULT > 100
|
||||
stepMult = stepMult / sqrt(float(CLOUD_UNBOUND_SIZE_MULT_M));
|
||||
#endif
|
||||
|
||||
int sampleCount = int(planeDistanceDif / stepMult + dither + 1);
|
||||
vec3 traceAdd = nPlayerPos * stepMult;
|
||||
vec3 tracePos = cameraPos + minPlaneDistance * nPlayerPos;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos.y -= traceAdd.y;
|
||||
|
||||
float firstHitPos = 0.0;
|
||||
float VdotSM1 = max0(sunVisibility > 0.5 ? VdotS : - VdotS);
|
||||
float VdotSM1M = VdotSM1 * invRainFactor;
|
||||
float VdotSM2 = pow2(VdotSM1) * abs(sunVisibility - 0.5) * 2.0;
|
||||
float VdotSM3 = VdotSM2 * (2.5 + rainFactor) + 1.5 * rainFactor;
|
||||
|
||||
#ifdef FIX_AMD_REFLECTION_CRASH
|
||||
sampleCount = min(sampleCount, 30); //BFARC
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
if (abs(tracePos.y - cloudAltitude) > cloudStretch) break;
|
||||
|
||||
vec3 cloudPlayerPos = tracePos - cameraPos;
|
||||
float lTracePos = length(cloudPlayerPos);
|
||||
float lTracePosXZ = length(cloudPlayerPos.xz);
|
||||
float cloudMult = 1.0;
|
||||
if (lTracePosXZ > distanceThreshold) break;
|
||||
if (lTracePos > lViewPosM) {
|
||||
if (skyFade < 0.7) continue;
|
||||
else cloudMult = skyMult0;
|
||||
}
|
||||
|
||||
float cloudNoise = GetCloudNoise(tracePos, cloudAltitude, lTracePosXZ, cloudPlayerPos.y);
|
||||
|
||||
if (cloudNoise > 0.00001) {
|
||||
#if defined CLOUD_CLOSED_AREA_CHECK && SHADOW_QUALITY > -1
|
||||
float shadowLength = min(shadowDistance, far) * 0.9166667; //consistent08JJ622
|
||||
if (shadowLength < lTracePos)
|
||||
if (GetShadowOnCloud(tracePos, cameraPos, cloudAltitude, lowerPlaneAltitude, higherPlaneAltitude)) {
|
||||
if (eyeBrightness.y != 240) continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (firstHitPos < 1.0) {
|
||||
firstHitPos = lTracePos;
|
||||
#if CLOUD_QUALITY_INTERNAL == 1 && defined DEFERRED1
|
||||
tracePos.y += 4.0 * (texture2D(noisetex, tracePos.xz * 0.001).r - 0.5);
|
||||
#endif
|
||||
}
|
||||
|
||||
float opacityFactor = min1(cloudNoise * 8.0) * CLOUD_TRANSPARENCY;
|
||||
|
||||
float cloudShading = 1.0 - (higherPlaneAltitude - tracePos.y) / cloudHeightShader;
|
||||
cloudShading *= 1.0 + 0.75 * VdotSM3 * (1.0 - opacityFactor);
|
||||
|
||||
vec3 colorSample = cloudAmbientColor * (0.7 + 0.3 * cloudShading) + cloudLightColor * cloudShading;
|
||||
//vec3 colorSample = 2.5 * cloudLightColor * pow2(cloudShading); // <-- Used this to take the Unbound logo
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
vec3 lightningPos = getLightningPos(tracePos - cameraPosition, lightningBoltPosition.xyz, false);
|
||||
vec2 lightningAdd = lightningFlashEffect(lightningPos, vec3(1.0), 550.0, 0.0, 0) * isLightningActive() * 10.0;
|
||||
colorSample += lightningAdd.y;
|
||||
#endif
|
||||
vec3 cloudSkyColor = GetSky(VdotU, VdotS, dither, true, false);
|
||||
#ifdef ATM_COLOR_MULTS
|
||||
cloudSkyColor *= sqrtAtmColorMult; // C72380KD - Reduced atmColorMult impact on some things
|
||||
#endif
|
||||
float distanceRatio = (distanceThreshold - lTracePosXZ) / distanceThreshold;
|
||||
float cloudDistanceFactor = clamp(distanceRatio, 0.0, 0.8) * 1.25;
|
||||
#ifndef DISTANT_HORIZONS
|
||||
float cloudFogFactor = cloudDistanceFactor;
|
||||
#else
|
||||
float cloudFogFactor = clamp(distanceRatio, 0.0, 1.0);
|
||||
#endif
|
||||
float skyMult1 = 1.0 - 0.2 * (1.0 - skyFade) * max(sunVisibility2, nightFactor);
|
||||
float skyMult2 = 1.0 - 0.33333 * skyFade;
|
||||
colorSample = mix(cloudSkyColor, colorSample * skyMult1, cloudFogFactor * skyMult2 * 0.72);
|
||||
colorSample *= pow2(1.0 - maxBlindnessDarkness);
|
||||
|
||||
volumetricClouds.rgb = mix(volumetricClouds.rgb, colorSample, 1.0 - min1(volumetricClouds.a));
|
||||
volumetricClouds.a += opacityFactor * pow(cloudDistanceFactor, 0.5 + 10.0 * pow(abs(VdotSM1M), 90.0)) * cloudMult;
|
||||
|
||||
if (volumetricClouds.a > 0.9) {
|
||||
volumetricClouds.a = 1.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (volumetricClouds.a > 0.5) cloudLinearDepth = sqrt(firstHitPos / renderDistance);
|
||||
|
||||
return volumetricClouds;
|
||||
}
|
||||
@ -0,0 +1,292 @@
|
||||
#ifndef ENDCRYSTAL_SAMPLER_DEFINE
|
||||
uniform isampler2D endcrystal_sampler;
|
||||
#endif
|
||||
|
||||
const float healing_boundRadius = 6.0;
|
||||
const float healing_ballRadius = 3.5;
|
||||
const float healing_beamRadius = 0.6;
|
||||
const float vortex_cylinderRadius = 3.0;
|
||||
const float vortex_ballRadius = 5.0;
|
||||
const float death_radius = 70.0;
|
||||
|
||||
#ifndef INCLUDE_ENDER_BEAMS
|
||||
#ifdef GBUFFERS_WATER
|
||||
float vlFactor = 0.5;
|
||||
#endif
|
||||
vec3 endDragonCol = vec3(E_DRAGON_BEAM_R, E_DRAGON_BEAM_G, E_DRAGON_BEAM_B) / 255.0 * E_DRAGON_BEAM_I;
|
||||
vec3 beamCol = normalize(endColorBeam * endColorBeam * endColorBeam) * (2.5 - 1.0 * vlFactor) * E_BEAM_I;
|
||||
#endif
|
||||
|
||||
vec3 endDragonColM = sqrt(endDragonCol);
|
||||
vec3 beamColM = sqrt(beamCol);
|
||||
|
||||
float GetBallRadius(float state) {
|
||||
return vortex_ballRadius * (1.0 + 4.0 * sqrt(1.0 - state));
|
||||
}
|
||||
|
||||
float VortexWidth(float x, float ballRadius) {
|
||||
if (x > 0.5 * ballRadius) {
|
||||
float expScale = sqrt(0.75) * ballRadius - vortex_cylinderRadius;
|
||||
return vortex_cylinderRadius + expScale * exp( -sqrt(1.0/3.0) / expScale * (x - 0.5 * ballRadius));
|
||||
} else if (x > -ballRadius) {
|
||||
return sqrt(pow2(ballRadius) - pow2(x));
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
vec4 SampleEndCrystalVortex(vec3 relPos, vec2 state, vec2 noiseOffset) {
|
||||
float thisBallRadius = GetBallRadius(state.s);
|
||||
|
||||
float beamFactor = smoothstep(-thisBallRadius, thisBallRadius, relPos.y);
|
||||
float featureWidth = VortexWidth(relPos.y, thisBallRadius);
|
||||
vec2 horizontalScaledPos = featureWidth > 0.0 ? relPos.xz / featureWidth : vec2(2.0);
|
||||
float featureDist = length(horizontalScaledPos);
|
||||
if (length(relPos.xz) > featureWidth) {
|
||||
return vec4(0);
|
||||
}
|
||||
float beamStrength = 2.5 * beamFactor * (cos(featureDist * 3.1416) * 0.5 + 0.5) * pow2(max(0.0, 1 - pow2(0.005 / (0.9 * state.x + 0.1) / pow2(pow2(state.y)) * relPos.y))) * state.x;
|
||||
float spiralStrength = 200 * beamFactor * pow(featureDist, 7) * pow2(1.0 - featureDist) * pow2(max(0.0, 1 - pow2(0.02 / (0.6 * state.x * state.x + 0.4) / state.y * relPos.y)));
|
||||
float spiralAngle = (0.4 / vortex_cylinderRadius * relPos.y - 0.2 * pow2(min(0.0, -2.5 + relPos.y / thisBallRadius))) / (state.x + 0.2);
|
||||
vec2 spiralPos = mat2(cos(spiralAngle), -sin(spiralAngle), sin(spiralAngle), cos(spiralAngle)) * horizontalScaledPos;
|
||||
vec4 beamNoise = texture2D(noisetex, noiseOffset + 5.0 / noiseTextureResolution * horizontalScaledPos);
|
||||
vec4 beamNoise2 = texture2D(noisetex, noiseOffset + 5.0 / noiseTextureResolution * vec2(relPos.y * 0.02 + 2.7 * beamNoise.gb - 3.6 * frameTimeCounter * 0.5));
|
||||
vec4 spiralNoise = texture2D(noisetex, noiseOffset + 5.0 / noiseTextureResolution * spiralPos);
|
||||
vec4 spiralNoise2 = texture2D(noisetex, noiseOffset + 20.0 / noiseTextureResolution * spiralPos);
|
||||
return vec4(beamStrength * beamNoise.r * beamNoise2.r * endDragonColM + spiralStrength * pow2(spiralNoise.r) * (0.5 + spiralNoise2.r) * beamColM, beamStrength + spiralStrength) * 0.3;
|
||||
}
|
||||
|
||||
vec4 SingleEndCrystalVortex(vec3 start, vec3 direction, vec3 center, vec2 state, float dither) {
|
||||
const float stepSize = 0.5;
|
||||
float invHorizontalDirLen = 1.0 / length(direction.xz);
|
||||
float thisBallRadius = GetBallRadius(state.x);
|
||||
float closestProgress = clamp(
|
||||
dot(center.xz - start.xz, direction.xz) * pow2(invHorizontalDirLen),
|
||||
-thisBallRadius * invHorizontalDirLen,
|
||||
1.0 + thisBallRadius * invHorizontalDirLen);
|
||||
vec3 closestPos = start + closestProgress * direction;
|
||||
float closestDist = length(closestPos.xz - center.xz);
|
||||
if (closestDist > thisBallRadius) {
|
||||
return vec4(0);
|
||||
}
|
||||
float startProgress = closestProgress - sqrt((thisBallRadius * thisBallRadius - closestDist * closestDist)) * invHorizontalDirLen;
|
||||
float endProgress = min(1.0, 2 * closestProgress - startProgress);
|
||||
startProgress = max(0.0, startProgress);
|
||||
vec2 noiseOffset = (center.xz + cameraPosition.xz + vec2(3.0, 1.6) * frameTimeCounter) * 0.005;
|
||||
vec4 colour = vec4(0);
|
||||
float dist = startProgress + dither * invHorizontalDirLen * stepSize;
|
||||
for (int k = 0; k < 100; k++) {
|
||||
if (dist > endProgress) break;
|
||||
colour += SampleEndCrystalVortex(start + dist * direction - center, state, noiseOffset);
|
||||
dist += invHorizontalDirLen * stepSize;
|
||||
}
|
||||
return colour * stepSize * smoothstep(0.0, 1.0, state.x);
|
||||
}
|
||||
|
||||
float EndCrystalBeamWidth(float x, float len) {
|
||||
x = 0.5 * len - abs(x - 0.5 * len);
|
||||
if (x <= -healing_ballRadius) return 0.0;
|
||||
if (x < 0.5 * healing_ballRadius) return sqrt(pow2(healing_ballRadius) - pow2(x));
|
||||
float expScale = sqrt(0.75) * healing_ballRadius - healing_beamRadius;
|
||||
return healing_beamRadius + expScale * exp( -sqrt(1.0/3.0) / expScale * (x - 0.5 * healing_ballRadius));
|
||||
}
|
||||
|
||||
vec4 SampleEndCrystalBeam(vec3 relPos, float len) {
|
||||
float beamWidth = EndCrystalBeamWidth(relPos.x, len);
|
||||
|
||||
if (beamWidth > 0.0001) {
|
||||
float beamFactor = smoothstep(0.0, 2.0 * healing_ballRadius, 0.5 * len - abs(relPos.x - 0.5 * len));
|
||||
float noisyTime = frameTimeCounter + 0.4 * texture2D(noisetex, vec2(3.0 / noiseTextureResolution, frameTimeCounter / (0.45 * noiseTextureResolution))).r;
|
||||
|
||||
relPos.yz /= beamWidth;
|
||||
float strength = 0.0;
|
||||
vec3 healBeamColor = vec3(0);
|
||||
for (int k = 0; k < 3; k++) {
|
||||
vec2 noiseCoords = vec2(0.2 / noiseTextureResolution * relPos.x, 0 + vec2(k, 6 * k) / noiseTextureResolution);
|
||||
vec4 zapNoise0 = texture2D(noisetex, noiseCoords + floor(8.0 * noisyTime) / noiseTextureResolution);
|
||||
vec4 zapNoise1 = texture2D(noisetex, 3.3 * noiseCoords + floor(8.0 * noisyTime));
|
||||
vec4 zapNoise2 = texture2D(noisetex, 6.8 * noiseCoords + (15.0 * frameTimeCounter));
|
||||
vec2 thisRelPos = relPos.yz + beamFactor / beamWidth * (6.0 * zapNoise0.rb + 1.6 * zapNoise1.rb + 1.2 * zapNoise2.rb - (3.0 + 0.8 + 0.6));
|
||||
vec4 sideNoise = texture2D(noisetex, (7.0 * thisRelPos.xy) / noiseTextureResolution);
|
||||
vec3 colorNoise = texture2D(noisetex, 4.0 * noiseCoords + floor(12.0 * noisyTime) / noiseTextureResolution).rgb;
|
||||
float centerDist0 = length(thisRelPos.xy);
|
||||
|
||||
float centerDist = centerDist0 - 1.2;
|
||||
strength = max(strength, clamp( -centerDist, 0.0, 0.2) * pow2(max(0.0, 1.0 - pow2((centerDist0 - 1.0) * beamWidth * 0.5))) * mix(1.0, sideNoise.b, beamWidth / healing_ballRadius));
|
||||
healBeamColor = mix(clamp01(saturateColors(beamColM, 0.8) - sideNoise.rgb * 0.08), saturateColors(beamColM, 1.3) * 1.3, colorNoise);
|
||||
}
|
||||
return strength / beamWidth * vec4(healBeamColor * 0.5, 1.0) + 0.2 * beamFactor * exp(-6.0 * dot(relPos.yz, relPos.yz)) * vec4(endDragonColM * 2.2, 1.0);
|
||||
}
|
||||
return vec4(0.0);
|
||||
}
|
||||
|
||||
|
||||
vec4 EndCrystalBeam(vec3 start, vec3 direction, vec3 startPos, vec3 endPos, float dither) {
|
||||
vec3 startDiff = start - startPos;
|
||||
vec3 beamDirection = endPos - startPos;
|
||||
mat3 rotMat;
|
||||
rotMat[0] = normalize(beamDirection);
|
||||
rotMat[1] = normalize(cross(beamDirection, vec3(-2e-4, 1, 1e-5)));
|
||||
rotMat[2] = cross(rotMat[0], rotMat[1]);
|
||||
start *= rotMat;
|
||||
startPos *= rotMat;
|
||||
beamDirection *= rotMat;
|
||||
direction *= rotMat;
|
||||
const float stepSize = 0.5;
|
||||
float invHorizontalDirLen = 1.0 / length(direction.yz);
|
||||
float closestProgress = clamp(
|
||||
dot(startPos.yz - start.yz, direction.yz) * pow2(invHorizontalDirLen),
|
||||
-healing_boundRadius * invHorizontalDirLen,
|
||||
1.0 + healing_boundRadius * invHorizontalDirLen);
|
||||
vec3 closestPos = start + closestProgress * direction;
|
||||
float closestDist = length(closestPos.yz - startPos.yz);
|
||||
if (closestDist > healing_boundRadius) {
|
||||
return vec4(0);
|
||||
}
|
||||
float startProgress = closestProgress - sqrt((healing_boundRadius * healing_boundRadius - closestDist * closestDist)) * invHorizontalDirLen;
|
||||
float endProgress = min(1.0, 2 * closestProgress - startProgress);
|
||||
startProgress = max(0.0, startProgress);
|
||||
vec4 colour = vec4(0);
|
||||
float dist = startProgress + dither * invHorizontalDirLen * stepSize;
|
||||
for (int k = 0; k < 100; k++) {
|
||||
if (dist > endProgress) break;
|
||||
colour += SampleEndCrystalBeam(start + dist * direction - startPos, beamDirection.x);
|
||||
dist += invHorizontalDirLen * stepSize;
|
||||
}
|
||||
return 3.0 * log(length(colour) * stepSize + 1.0) * normalize(colour + 0.0000001);
|
||||
}
|
||||
|
||||
float GetDragonDeathFactor(float dragonDeathTime) {
|
||||
return 0.02 * dragonDeathTime * exp(0.1 * dragonDeathTime);
|
||||
}
|
||||
|
||||
vec4 SampleDeathBuildup(vec3 relPos, float dragonDeathTime) {
|
||||
float effectFactor = GetDragonDeathFactor(dragonDeathTime);
|
||||
float effectRadius = death_radius * effectFactor;
|
||||
float sizeNoiseFactor = 1.0 + 0.3 * texture2D(noisetex, vec2(0.2, dragonDeathTime * 5.0 / noiseTextureResolution)).r;
|
||||
float centerDist = length(relPos) / effectRadius;
|
||||
relPos *= sizeNoiseFactor;
|
||||
float angle = centerDist * 5.0 / log(dragonDeathTime * 0.6 + 1.0);
|
||||
mat2 rotMat = mat2(
|
||||
cos(angle), sin(angle),
|
||||
-sin(angle), cos(angle)
|
||||
);
|
||||
relPos.xz = rotMat * relPos.xz;
|
||||
vec2 val = pow(fract(hash23(floor(0.8 * relPos + 2.7 * sign(relPos) * exp(0.3 * dragonDeathTime)))), vec2(40.0 * pow2(centerDist))) * (1.0 - centerDist);
|
||||
return 0.1 * (vec4(beamColM, 1.0) * (val.x + 0.4 * exp(-8.0 * pow2(centerDist))) + vec4(endDragonColM, 1.0) * (val.y + 0.1 * exp(-3.0 * pow2(centerDist))));
|
||||
}
|
||||
|
||||
vec4 DragonDeathAnimation(vec3 start, vec3 direction, vec3 dragonPos, float dragonDeathTime, float dragonDeathFactor, float dither) {
|
||||
float dirLen = length(direction);
|
||||
float closestProgress = dot(dragonPos - start, direction) / pow2(dirLen);
|
||||
vec4 colour = vec4(0);
|
||||
if (dragonDeathFactor >= 0.99) {
|
||||
float effectRadius = death_radius * GetDragonDeathFactor(dragonDeathTime);
|
||||
vec3 closestPos = start + closestProgress * direction;
|
||||
float closestDist = length(closestPos - dragonPos);
|
||||
if (closestDist >= effectRadius) return vec4(0.0);
|
||||
float stepSize = 0.5 / dirLen;
|
||||
float startProgress = closestProgress - sqrt(pow2(effectRadius) - pow2(closestDist)) / dirLen;
|
||||
float endProgress = min(1.0, 2.0 * closestProgress - startProgress);
|
||||
startProgress = max(0.0, startProgress);
|
||||
float dist = startProgress + stepSize * dither;
|
||||
for (int k = 0; k < 150; k++) {
|
||||
if (dist > endProgress) break;
|
||||
colour += SampleDeathBuildup(start + dist * direction - dragonPos, dragonDeathTime);
|
||||
dist += stepSize;
|
||||
}
|
||||
colour *= stepSize * dirLen;
|
||||
} else {
|
||||
vec3 closestPos = start + clamp(closestProgress, 0.0, 1.0) * direction;
|
||||
float closestDist = length(dragonPos - closestPos);
|
||||
colour = vec4(endDragonColM + 0.5 * beamColM, 1.0) * (0.4 * death_radius * (1.0 - exp(-dirLen/(4.0 * death_radius))) * exp(-10.0 * (1.0 - dragonDeathFactor) - closestDist * closestDist / (death_radius * death_radius)) * dragonDeathFactor);
|
||||
}
|
||||
return colour;
|
||||
}
|
||||
|
||||
vec4 EndCrystalVortices(vec3 start, vec3 direction, float dither) {
|
||||
vec4 color = vec4(0);
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
ivec4 rawDragonPos = ivec4(
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 5), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 6), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 7), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 8), 0).r
|
||||
);
|
||||
vec3 dragonPos = rawDragonPos.xyz != ivec3(0) ? 0.0001 * rawDragonPos.xyz : vec3(0.5, 80.5, 0.5) - cameraPosition;
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
vec3[15] healBeamEndPositions;
|
||||
int isTarget = 0;
|
||||
int healBeamCount = 15;
|
||||
for (int k = 0; k < 15; k++) {
|
||||
ivec4 rawPos = ivec4(
|
||||
texelFetch(endcrystal_sampler, ivec2(20 + k, 5), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(20 + k, 6), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(20 + k, 7), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(20 + k, 8), 0).r
|
||||
);
|
||||
if (rawPos.w == 0) {
|
||||
healBeamCount = k;
|
||||
break;
|
||||
}
|
||||
healBeamEndPositions[k] = vec3(rawPos.xyz) / rawPos.w;
|
||||
isTarget |= (length(healBeamEndPositions[k].xz + cameraPosition.xz - 0.5) < 4.5 || length(dragonPos - healBeamEndPositions[k]) < 5.0) ? 1 << k : 0;
|
||||
}
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL % 2 == 1
|
||||
for (int k = 0; k < 20; k++) {
|
||||
if (texelFetch(endcrystal_sampler, ivec2(k, 8), 0).r <= 0) continue;
|
||||
ivec4 rawPos = ivec4(
|
||||
texelFetch(endcrystal_sampler, ivec2(k, 5), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(k, 6), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(k, 7), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(k, 8), 0).r
|
||||
);
|
||||
if (rawPos.w <= 0) {
|
||||
continue;
|
||||
}
|
||||
int age = texelFetch(endcrystal_sampler, ivec2(k, 9), 0).r;
|
||||
vec3 pos = rawPos.xyz * 0.0001;
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
for (int i = 0; i < healBeamCount; i++) {
|
||||
isTarget |= length(pos - healBeamEndPositions[i]) < 4.5 ? 1<<(i+15) : 0;
|
||||
}
|
||||
#endif
|
||||
vec2 state = vec2(clamp(rawPos.w / 15000.0, 0.0, 1.0), 1.00001 - exp(-0.0001 * age));
|
||||
color += pow2(SingleEndCrystalVortex(start, direction, pos, state, dither));
|
||||
}
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL / 2 == 1
|
||||
for (int k = 0; k < healBeamCount; k++) {
|
||||
for (int l = k+1; l < healBeamCount; l++) {
|
||||
if (
|
||||
((isTarget >> k & 1) == 0 ^^ (isTarget >> l & 1) == 0)
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL % 2 == 1
|
||||
&& ((isTarget >> k + 15 & 1) == 0 ^^ (isTarget >> l + 15 & 1) == 0)
|
||||
#endif
|
||||
) {
|
||||
vec3 pos0 = healBeamEndPositions[k];
|
||||
vec3 pos1 = healBeamEndPositions[l];
|
||||
if (pos0.y > pos1.y) {
|
||||
vec3 tmp = pos0;
|
||||
pos0 = pos1;
|
||||
pos1 = tmp;
|
||||
}
|
||||
color += pow2(EndCrystalBeam(start, direction, pos0, pos1, dither));
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
int isDying = texelFetch(endcrystal_sampler, ivec2(35, 0), 0).r;
|
||||
float dragonDeathTime = 0.0001 * rawDragonPos.w;
|
||||
float dragonDeathFactor = 0.0001 * isDying;
|
||||
// dragonDeathTime = mod(frameTimeCounter, 22.0);
|
||||
// dragonDeathFactor = 2.2 - 0.1 * dragonDeathTime;
|
||||
// dragonPos = vec3(0, 80, 0) - cameraPosition;
|
||||
if (dragonDeathFactor > 0.001) {
|
||||
color += pow2(DragonDeathAnimation(start, direction, dragonPos, dragonDeathTime, dragonDeathFactor, dither));
|
||||
}
|
||||
#endif
|
||||
return sqrt(color) * (1.0 - maxBlindnessDarkness);
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
#ifndef ENDCRYSTAL_SAMPLER_DEFINE
|
||||
uniform isampler2D endcrystal_sampler;
|
||||
#endif
|
||||
|
||||
vec2 RayAABoxIntersection(vec2 start, vec2 dir, vec2 lower, vec2 upper) {
|
||||
dir += 0.000001 * vec2(equal(dir, vec2(0)));
|
||||
vec2 front = mix(upper, lower, 0.5 * sign(dir) + 0.5);
|
||||
vec2 back = mix(lower, upper, 0.5 * sign(dir) + 0.5);
|
||||
vec2 front_iscts = (front - start) / dir;
|
||||
vec2 back_iscts = (back - start) / dir;
|
||||
float front_isct = max(front_iscts.x, front_iscts.y);
|
||||
float back_isct = min(back_iscts.x , back_iscts.y );
|
||||
return front_isct < back_isct ? vec2(front_isct, back_isct) : vec2(-1);
|
||||
}
|
||||
|
||||
vec4 GetEndPortalBeamNoise(vec3 relPos) {
|
||||
float colMixFactor = texture(noisetex, (relPos.xz + 0.1 * frameTimeCounter * vec2(-0.5, 1.5)) * 10.0 / noiseTextureResolution).r;
|
||||
float strengthMul = texture(noisetex, (relPos.xz + 0.1 * frameTimeCounter * vec2(1.5, -1.0)) * 5.0 / noiseTextureResolution + 0.2).r;
|
||||
colMixFactor = pow2(pow2(colMixFactor));
|
||||
strengthMul = pow2(strengthMul);
|
||||
vec3 col = mix(vec3(0.1137, 0.5569, 0.5255), vec3(0.3725, 0.8863, 0.749), colMixFactor);
|
||||
float strength
|
||||
= float(relPos.y > 0 && relPos.y < 2)
|
||||
* (2 - relPos.y)
|
||||
/ (3 * relPos.y*relPos.y*relPos.y + 1)
|
||||
* (strengthMul + 0.5);
|
||||
return pow2(vec4(col, 1) * strength);
|
||||
}
|
||||
|
||||
vec4 GetEndPortalBeam(vec3 start, vec3 dir) {
|
||||
if (texelFetch(endcrystal_sampler, ivec2(35, 4), 0).r == 1) {
|
||||
ivec4 rawPortalPos = ivec4(
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 5), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 6), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 7), 0).r,
|
||||
texelFetch(endcrystal_sampler, ivec2(35, 8), 0).r
|
||||
);
|
||||
if (rawPortalPos.w > 0) {
|
||||
vec3 portalPos = floor(vec3(rawPortalPos.xyz) / max(1, rawPortalPos.w) + 0.5) + 0.5 - cameraPositionFract;
|
||||
vec2 iscts = RayAABoxIntersection(start.xz, dir.xz, portalPos.xz - 1.49, portalPos.xz + 1.49);
|
||||
int validIsctCount = 0;
|
||||
vec3[2] isctPositions;
|
||||
for (int k = 0; k < 2; k++) {
|
||||
if (iscts[k] > 0.0 && iscts[k] < 1.0) {
|
||||
isctPositions[validIsctCount++] = start + iscts[k] * dir;
|
||||
}
|
||||
}
|
||||
vec4 col = vec4(0.0);
|
||||
for (int k = 0; k < validIsctCount; k++) {
|
||||
col += GetEndPortalBeamNoise(isctPositions[k] - portalPos);
|
||||
}
|
||||
|
||||
vec3 absDir = abs(dir);
|
||||
float maxDir = max(absDir.x, max(absDir.y, absDir.z));
|
||||
float transition = 1.0 - pow3(min1(maxDir / mix(40, 10, maxBlindnessDarkness) * 2.0)); // fade to 0 when close to the range limit (32 blocks)
|
||||
|
||||
col *= transition;
|
||||
|
||||
return col;
|
||||
}
|
||||
}
|
||||
return vec4(0.0);
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
#ifndef INCLUDE_ENDER_BEAMS
|
||||
#define INCLUDE_ENDER_BEAMS
|
||||
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
vec3 endDragonCol = vec3(E_DRAGON_BEAM_R, E_DRAGON_BEAM_G, E_DRAGON_BEAM_B) / 255.0 * E_DRAGON_BEAM_I;
|
||||
vec3 beamCol = normalize(endColorBeam * endColorBeam * endColorBeam) * (2.5 - 1.0 * vlFactor) * E_BEAM_I;
|
||||
vec3 beamDragon = endDragonCol * (300.0 + 700.0 * vlFactor);
|
||||
|
||||
vec2 wind = vec2(syncedTime * 0.00);
|
||||
|
||||
float BeamNoise(vec2 planeCoord, vec2 wind) {
|
||||
float noise = texture2D(noisetex, planeCoord * 0.175 - wind * 0.0625).b;
|
||||
noise+= texture2D(noisetex, planeCoord * 0.04375 + wind * 0.0375).b * 5.0;
|
||||
|
||||
return noise;
|
||||
}
|
||||
|
||||
vec3 DrawEnderBeams(float VdotU, vec3 playerPos) {
|
||||
int sampleCount = 8;
|
||||
|
||||
float VdotUM = 1.0 - VdotU * VdotU;
|
||||
float VdotUM2 = VdotUM + smoothstep1(pow2(pow2(1.0 - abs(VdotU)))) * 0.2;
|
||||
|
||||
vec4 beams = vec4(0.0);
|
||||
float gradientMix = 1.0;
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
vec2 planeCoord = playerPos.xz + cameraPosition.xz;
|
||||
planeCoord *= (1.0 + i * 6.0 / sampleCount) * 0.0014;
|
||||
|
||||
float noise = BeamNoise(planeCoord, wind);
|
||||
#ifndef BEAMS_NEAR_PLAYER
|
||||
noise = max(0.75 - 1.0 / abs(noise - (4.0 + VdotUM * 2.0)), 0.0) * 3.0;
|
||||
#else
|
||||
noise = max(0.75 - 1.0 / abs(noise - (4.0 + dot(upVec, upVec) * 2.0)), 0.0) * 3.0;
|
||||
#endif
|
||||
|
||||
|
||||
if (noise > 0.0) {
|
||||
noise *= 0.65;
|
||||
float fireNoise = texture2D(noisetex, abs(planeCoord * 0.2) - wind).b;
|
||||
noise *= 0.5 * fireNoise + 0.75;
|
||||
noise = noise * noise * 3.0 / sampleCount;
|
||||
#ifndef BEAMS_NEAR_PLAYER
|
||||
noise *= VdotUM2;
|
||||
#endif
|
||||
|
||||
vec3 beamColor = beamCol;
|
||||
beamColor += beamDragon * pow2(pow2(fireNoise - 0.5));
|
||||
beamColor *= gradientMix / sampleCount;
|
||||
|
||||
noise *= exp2(-6.0 * i / float(sampleCount));
|
||||
beams += vec4(noise * beamColor, noise);
|
||||
}
|
||||
gradientMix += 1.0;
|
||||
}
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
beams.rgb += 0.2 * isLightningActive();
|
||||
#endif
|
||||
beams.rgb *= beams.a * beams.a * beams.a * 3.5;
|
||||
beams.rgb = sqrt(beams.rgb);
|
||||
|
||||
return beams.rgb;
|
||||
}
|
||||
|
||||
#endif //INCLUDE_ENDER_BEAMS
|
||||
@ -0,0 +1,47 @@
|
||||
vec3 GetEnderStars(vec3 viewPos, float VdotU, float sizeMult, float starAmount) {
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * 1000.0, 1.0)).xyz);
|
||||
vec3 starCoord = 0.65 * wpos / (abs(wpos.y) + length(wpos.xz));
|
||||
vec2 starCoord2 = starCoord.xz * 0.5 / (END_STAR_SIZE * sizeMult);
|
||||
starCoord2 += VdotU < 0.0 ? 100.0 : 0.0;
|
||||
|
||||
const float starFactor = 1024.0;
|
||||
vec2 fractPart = fract(starCoord2 * starFactor);
|
||||
starCoord2 = floor(starCoord2 * starFactor) / starFactor;
|
||||
|
||||
float star = GetStarNoise(starCoord2.xy) * GetStarNoise(starCoord2.xy+0.1) * GetStarNoise(starCoord2.xy+0.23);
|
||||
|
||||
#if END_STAR_AMOUNT == 0
|
||||
star = max0(star - 0.77);
|
||||
#elif END_STAR_AMOUNT == 2
|
||||
star = max0((star + 0.15) * 0.9 - 0.7);
|
||||
#elif END_STAR_AMOUNT == 3
|
||||
star = max0((star + 0.4) * 0.8 - 0.7);
|
||||
#elif END_STAR_AMOUNT == 4
|
||||
star = max0((star + 0.5) * 0.8 - 0.7);
|
||||
#else
|
||||
star = max0(star - 0.7);
|
||||
#endif
|
||||
|
||||
star *= getStarEdgeFactor(fractPart, STAR_ROUNDNESS_OW / 10.0, STAR_SOFTNESS_END);
|
||||
star = max0(star - starAmount * 0.1);
|
||||
star *= star;
|
||||
|
||||
vec3 starColor = GetStarColor(starCoord2,
|
||||
endSkyColor,
|
||||
vec3(STAR_COLOR_1_END_R, STAR_COLOR_1_END_G, STAR_COLOR_1_END_B),
|
||||
vec3(STAR_COLOR_2_END_R, STAR_COLOR_2_END_G, STAR_COLOR_2_END_B),
|
||||
vec3(STAR_COLOR_3_END_R, STAR_COLOR_3_END_G, STAR_COLOR_3_END_B),
|
||||
STAR_COLOR_VARIATION_END);
|
||||
|
||||
vec3 enderStars = star * starColor * 3000.0 * END_STAR_BRIGHTNESS;
|
||||
|
||||
float VdotUM1 = abs(VdotU);
|
||||
float VdotUM2 = pow2(1.0 - VdotUM1);
|
||||
enderStars *= VdotUM1 * VdotUM1 * (VdotUM2 + 0.015) + 0.015;
|
||||
|
||||
#if END_TWINKLING_STARS > 0
|
||||
enderStars *= getTwinklingStars(starCoord2, float(END_TWINKLING_STARS));
|
||||
#endif
|
||||
|
||||
return enderStars;
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
#ifdef CAVE_FOG
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
const float rainBloomAdd = 8.0;
|
||||
const float nightBloomAdd = 3.0;
|
||||
const float caveBloomAdd = 14.0;
|
||||
const float waterBloomAdd = 14.0;
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
const float netherBloomAdd = 14.0;
|
||||
#else
|
||||
const float netherBloomAdd = 3.0;
|
||||
#endif
|
||||
|
||||
float GetBloomFog(float lViewPos) {
|
||||
#ifdef OVERWORLD
|
||||
float bloomFog = pow2(pow2(1.0 - exp(-lViewPos * (0.02 + 0.04 * float(isEyeInWater == 1)))));
|
||||
|
||||
float bloomFogMult;
|
||||
if (isEyeInWater != 1) {
|
||||
bloomFogMult = (rainFactor2 * rainBloomAdd + nightBloomAdd * (1.0 - sunFactor)) * eyeBrightnessM;
|
||||
#ifdef CAVE_FOG
|
||||
bloomFogMult += GetCaveFactor() * caveBloomAdd;
|
||||
#endif
|
||||
} else {
|
||||
bloomFogMult = waterBloomAdd;
|
||||
}
|
||||
#elif defined NETHER
|
||||
float farM = min(renderDistance, NETHER_VIEW_LIMIT); // consistency9023HFUE85JG
|
||||
float bloomFog = lViewPos / clamp(farM, 96.0, 256.0);
|
||||
bloomFog *= bloomFog * bloomFog;
|
||||
bloomFog = 1.0 - exp(-8.0 * bloomFog);
|
||||
bloomFog *= float(isEyeInWater == 0);
|
||||
|
||||
float bloomFogMult = netherBloomAdd;
|
||||
#endif
|
||||
|
||||
bloomFogMult *= BLOOM_STRENGTH * 8.33333;
|
||||
|
||||
return 1.0 + bloomFog * bloomFogMult;
|
||||
}
|
||||
@ -0,0 +1,16 @@
|
||||
#ifndef INCLUDE_CAVE_FACTOR
|
||||
#define INCLUDE_CAVE_FACTOR
|
||||
|
||||
float GetCaveFactor() {
|
||||
return clamp(1.0 - cameraPosition.y / oceanAltitude, 0.0, 1.0 - eyeBrightnessM);
|
||||
}
|
||||
|
||||
vec3 caveFogColorRaw = vec3(CAVE_FOG_R, CAVE_FOG_G, CAVE_FOG_B) / 255 * CAVE_FOG_I;
|
||||
#if MINIMUM_LIGHT_MODE <= 1
|
||||
vec3 caveFogColor = caveFogColorRaw * 0.7;
|
||||
#elif MINIMUM_LIGHT_MODE == 2
|
||||
vec3 caveFogColor = caveFogColorRaw * (0.7 + 0.3 * vsBrightness); // Default
|
||||
#elif MINIMUM_LIGHT_MODE >= 3
|
||||
vec3 caveFogColor = caveFogColorRaw;
|
||||
#endif
|
||||
#endif
|
||||
@ -0,0 +1,68 @@
|
||||
vec3 GetColoredLightFog(vec3 nPlayerPos, vec3 translucentMult, float lViewPos, float lViewPos1, float dither) {
|
||||
vec3 lightFog = vec3(0.0);
|
||||
|
||||
float stepMult = 8.0;
|
||||
|
||||
#ifdef CAVE_SMOKE
|
||||
float caveFactor = GetCaveFactor();
|
||||
#endif
|
||||
|
||||
float maxDist = min(effectiveACLdistance * 0.5, far);
|
||||
int sampleCount = int(maxDist / stepMult + 0.001);
|
||||
vec3 traceAdd = nPlayerPos * stepMult;
|
||||
vec3 tracePos = traceAdd * dither;
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
float lTracePos = length(tracePos);
|
||||
if (lTracePos > lViewPos1) break;
|
||||
if (any(greaterThan(abs(tracePos * 2.0), vec3(voxelVolumeSize)))) break;
|
||||
|
||||
vec3 voxelPos = SceneToVoxel(tracePos);
|
||||
voxelPos = clamp01(voxelPos / vec3(voxelVolumeSize));
|
||||
|
||||
vec4 lightVolume = GetLightVolume(voxelPos);
|
||||
vec3 lightSample = lightVolume.rgb;
|
||||
|
||||
float lTracePosM = length(
|
||||
vec3(
|
||||
tracePos.x,
|
||||
#if COLORED_LIGHTING_INTERNAL <= 512
|
||||
tracePos.y * 2.0,
|
||||
#elif COLORED_LIGHTING_INTERNAL == 768
|
||||
tracePos.y * 3.0,
|
||||
#elif COLORED_LIGHTING_INTERNAL == 1024
|
||||
tracePos.y * 4.0,
|
||||
#endif
|
||||
tracePos.z
|
||||
)
|
||||
);
|
||||
lightSample *= max0(1.0 - lTracePosM / maxDist);
|
||||
lightSample *= pow2(min1(lTracePos * 0.03125));
|
||||
|
||||
#ifdef CAVE_SMOKE
|
||||
if (caveFactor > 0.00001) {
|
||||
vec3 smokePos = 0.0025 * (tracePos + cameraPosition);
|
||||
vec3 smokeWind = frameTimeCounter * vec3(0.006, 0.003, 0.0);
|
||||
float smoke = Noise3D(smokePos + smokeWind)
|
||||
* Noise3D(smokePos * 3.0 - smokeWind)
|
||||
* Noise3D(smokePos * 9.0 + smokeWind);
|
||||
smoke = smoothstep1(smoke);
|
||||
lightSample *= mix(1.0, smoke * 16.0, caveFactor);
|
||||
lightSample += caveFogColor * pow2(smoke) * 0.05 * caveFactor;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (lTracePos > lViewPos) lightSample *= translucentMult;
|
||||
lightFog += lightSample;
|
||||
}
|
||||
|
||||
#ifdef NETHER
|
||||
lightFog *= netherColor * 5.0;
|
||||
#endif
|
||||
|
||||
lightFog *= 1.0 - maxBlindnessDarkness;
|
||||
|
||||
return pow(lightFog / sampleCount, vec3(0.25));
|
||||
}
|
||||
@ -0,0 +1,296 @@
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
#ifdef OVERWORLD
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
#elif defined NETHER || defined END
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
#endif
|
||||
|
||||
void DoBorderFog(inout vec3 color, inout float skyFade, float lPos, float VdotU, float VdotS, float dither, inout float fog) {
|
||||
#ifdef OVERWORLD
|
||||
fog = lPos / renderDistance;
|
||||
#ifdef SPOOKY
|
||||
fog = pow2(fog);
|
||||
#else
|
||||
fog = pow2(pow2(fog));
|
||||
#ifndef DISTANT_HORIZONS
|
||||
fog = pow2(pow2(fog));
|
||||
#endif
|
||||
#endif
|
||||
fog = 1.0 - exp(-BORDER_FOG_DISTANCE_OVERWORLD * fog);
|
||||
#endif
|
||||
#ifdef NETHER
|
||||
float farM = min(renderDistance, NETHER_VIEW_LIMIT); // consistency9023HFUE85JG
|
||||
fog = lPos / farM;
|
||||
fog = fog * 0.3 + 0.7 * pow(fog * BORDER_FOG_DISTANCE_NETHER / 3, 256.0 / max(farM, 256.0));
|
||||
#endif
|
||||
#ifdef END
|
||||
fog = lPos / renderDistance;
|
||||
fog = pow2(pow2(fog));
|
||||
fog = 1.0 - exp(-BORDER_FOG_DISTANCE_END * fog);
|
||||
#endif
|
||||
|
||||
#ifdef DREAM_TWEAKED_BORDERFOG
|
||||
fog *= fog * 0.5;
|
||||
#endif
|
||||
|
||||
if (fog > 0.0) {
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 fogColorM = GetSky(VdotU, VdotS, dither, true, false);
|
||||
#define BORDER_FOG_DENSITY BORDER_FOG_DENSITY_OVERWORLD
|
||||
#elif defined NETHER
|
||||
vec3 fogColorM = netherColor;
|
||||
#define BORDER_FOG_DENSITY BORDER_FOG_DENSITY_NETHER
|
||||
#else
|
||||
vec3 fogColorM = endSkyColor;
|
||||
#define BORDER_FOG_DENSITY BORDER_FOG_DENSITY_END
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
fogColorM *= atmColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
fogColorM *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
fog *= BORDER_FOG_DENSITY;
|
||||
color = mix(color, fogColorM, fog);
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
skyFade = fog;
|
||||
#else
|
||||
skyFade = fog * (1.0 - isEyeInWater);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
|
||||
void DoCaveFog(inout vec3 color, float lViewPos, inout float fog) {
|
||||
fog = GetCaveFactor() * (0.9 - 0.9 * exp(- lViewPos * 0.015 * CAVE_FOG_DENSITY));
|
||||
|
||||
color = mix(color, caveFogColor, fog);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef ATMOSPHERIC_FOG
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
|
||||
// SRATA: Atm. fog starts reducing above this altitude
|
||||
// CRFTM: Atm. fog continues reducing for this meters
|
||||
#ifdef OVERWORLD
|
||||
#define atmFogSRATA ATM_FOG_ALTITUDE + 0.1
|
||||
#ifndef DISTANT_HORIZONS
|
||||
float atmFogCRFTM = 60.0;
|
||||
#else
|
||||
float atmFogCRFTM = 90.0;
|
||||
#endif
|
||||
|
||||
vec3 GetAtmFogColor(float altitudeFactorRaw, float VdotS) {
|
||||
vec3 atmFogColor = vec3(ATMOSPHERIC_FOG_R, ATMOSPHERIC_FOG_G, ATMOSPHERIC_FOG_B) * ATMOSPHERIC_FOG_I / 255;
|
||||
#ifdef RADIOACTIVE_ATMOSPHERIC_FOG
|
||||
atmFogColor *= GetLuminance(atmFogColor) * 10;
|
||||
#endif
|
||||
#ifdef SPOOKY
|
||||
atmFogColor *= 0.5;
|
||||
#endif
|
||||
|
||||
float nightFogMult = 2.5 - 0.625 * max(pow2(pow2(altitudeFactorRaw)), rainFactor);
|
||||
float dayNightFogBlend = pow(invNightFactor, 4.0 - VdotS - 2.5 * sunVisibility2);
|
||||
return atmFogColor * mix(
|
||||
nightUpSkyColor * (nightFogMult - dayNightFogBlend * nightFogMult),
|
||||
dayDownSkyColor * (0.9 + 0.2 * noonFactor),
|
||||
dayNightFogBlend
|
||||
);
|
||||
}
|
||||
#else
|
||||
float atmFogSRATA = 55.1;
|
||||
float atmFogCRFTM = 30.0;
|
||||
#endif
|
||||
|
||||
float GetAtmFogAltitudeFactor(float altitude) {
|
||||
float altitudeFactor = pow2(1.0 - clamp(altitude - atmFogSRATA, 0.0, atmFogCRFTM) / atmFogCRFTM);
|
||||
#ifndef LIGHTSHAFTS_ACTIVE
|
||||
altitudeFactor = mix(altitudeFactor, 1.0, rainFactor * 0.2);
|
||||
#endif
|
||||
return altitudeFactor;
|
||||
}
|
||||
|
||||
void DoAtmosphericFog(inout vec3 color, vec3 playerPos, float lViewPos, float VdotS, inout float fog) {
|
||||
#ifndef DISTANT_HORIZONS
|
||||
float renDisFactor = min1(192.0 / renderDistance);
|
||||
|
||||
#if ATM_FOG_DISTANCE != 100
|
||||
#define ATM_FOG_DISTANCE_M 100.0 / ATM_FOG_DISTANCE;
|
||||
renDisFactor *= ATM_FOG_DISTANCE_M;
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
renDisFactor *= 100.0;
|
||||
#endif
|
||||
|
||||
fog = 1.0 - exp(-pow(lViewPos * (0.001 - 0.0007 * rainFactor), 2.0 - rainFactor2) * lViewPos * renDisFactor);
|
||||
#else
|
||||
fog = pow2(1.0 - exp(-max0(lViewPos - 40.0) * (0.7 + 0.7 * rainFactor) / ATM_FOG_DISTANCE));
|
||||
#endif
|
||||
|
||||
float atmFogA = 1.0;
|
||||
#ifndef SPOOKY
|
||||
atmFogA *= ATMOSPHERIC_FOG_DENSITY * ATM_FOG_MULT;
|
||||
#endif
|
||||
fog *= atmFogA - 0.1 - 0.15 * invRainFactor;
|
||||
|
||||
float altitudeFactorRaw = GetAtmFogAltitudeFactor(playerPos.y + cameraPosition.y);
|
||||
|
||||
#ifndef DISTANT_HORIZONS
|
||||
float altitudeFactor = altitudeFactorRaw * 0.9 + 0.1;
|
||||
#else
|
||||
float altitudeFactor = altitudeFactorRaw * 0.8 + 0.2;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
altitudeFactor *= 1.0 - 0.75 * GetAtmFogAltitudeFactor(cameraPosition.y) * invRainFactor;
|
||||
|
||||
#if defined SPECIAL_BIOME_WEATHER || RAIN_STYLE == 2
|
||||
#if RAIN_STYLE == 2
|
||||
float factor = 1.0;
|
||||
#else
|
||||
float factor = max(inSnowy, inDry);
|
||||
#endif
|
||||
|
||||
float fogFactor = 4.0;
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
fogFactor += 2.0 * inDry;
|
||||
#endif
|
||||
|
||||
float fogIntense = pow2(1.0 - exp(-lViewPos * fogFactor / ATM_FOG_DISTANCE));
|
||||
fog = mix(fog, fogIntense / altitudeFactor, 0.8 * rainFactor * factor);
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
fog *= 0.2 + 0.8 * sqrt2(eyeBrightnessM);
|
||||
fog *= 1.0 - GetCaveFactor();
|
||||
#ifdef SPOOKY
|
||||
fog *= 1.5;
|
||||
fog *= mix(1.0, 0.6, rainFactor);
|
||||
#endif
|
||||
#else
|
||||
fog *= eyeBrightnessM;
|
||||
#endif
|
||||
#else
|
||||
fog *= 0.5;
|
||||
#endif
|
||||
|
||||
fog *= altitudeFactor;
|
||||
|
||||
if (fog > 0.0) {
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 fogColorM = GetAtmFogColor(altitudeFactorRaw, VdotS);
|
||||
#else
|
||||
vec3 fogColorM = endSkyColor * 1.5;
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
fogColorM *= atmColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
fogColorM *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
color = mix(color, fogColorM, fog);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "/lib/atmospherics/fog/waterFog.glsl"
|
||||
|
||||
void DoWaterFog(inout vec3 color, float lViewPos) {
|
||||
float fog = GetWaterFog(lViewPos);
|
||||
|
||||
float spookyWaterFog = 1.0;
|
||||
#ifdef SPOOKY
|
||||
spookyWaterFog = 0.7;
|
||||
#endif
|
||||
|
||||
color = mix(color, waterFogColor, fog) * spookyWaterFog;
|
||||
}
|
||||
|
||||
void DoLavaFog(inout vec3 color, float lViewPos) {
|
||||
float fog = (lViewPos * 3.0 - gl_Fog.start) * gl_Fog.scale;
|
||||
|
||||
#ifdef LESS_LAVA_FOG
|
||||
fog = sqrt(fog) * 0.4;
|
||||
#endif
|
||||
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, fogColor * 5.0, fog);
|
||||
}
|
||||
|
||||
void DoPowderSnowFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos;
|
||||
|
||||
#ifdef LESS_LAVA_FOG
|
||||
fog = sqrt(fog) * 0.4;
|
||||
#endif
|
||||
|
||||
fog *= fog;
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, fogColor, fog);
|
||||
}
|
||||
|
||||
void DoBlindnessFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos * 0.3 * blindness;
|
||||
fog *= fog;
|
||||
fog = 1.0 - exp(-fog);
|
||||
|
||||
fog = clamp(fog, 0.0, 1.0);
|
||||
color = mix(color, vec3(0.0), fog);
|
||||
}
|
||||
|
||||
void DoDarknessFog(inout vec3 color, float lViewPos) {
|
||||
float fog = lViewPos * 0.075 * darknessFactor;
|
||||
fog *= fog;
|
||||
fog *= fog;
|
||||
color *= exp(-fog);
|
||||
}
|
||||
|
||||
void DoFog(inout vec3 color, inout float skyFade, float lViewPos, vec3 playerPos, float VdotU, float VdotS, float dither) {
|
||||
float caveFogAdd = 0.0;
|
||||
float atmosphericFogAdd = 0.0;
|
||||
float borderFogAdd = 0.0;
|
||||
#ifdef CAVE_FOG
|
||||
DoCaveFog(color, lViewPos, caveFogAdd);
|
||||
#endif
|
||||
#ifdef ATMOSPHERIC_FOG
|
||||
DoAtmosphericFog(color, playerPos, lViewPos, VdotS, atmosphericFogAdd);
|
||||
#endif
|
||||
#ifdef BORDER_FOG
|
||||
DoBorderFog(color, skyFade, max(length(playerPos.xz), abs(playerPos.y)), VdotU, VdotS, dither, borderFogAdd);
|
||||
#endif
|
||||
|
||||
float fogAddition = max(max(caveFogAdd, atmosphericFogAdd), borderFogAdd);
|
||||
|
||||
if (isEyeInWater == 1) DoWaterFog(color, lViewPos);
|
||||
else if (isEyeInWater == 2) DoLavaFog(color, lViewPos);
|
||||
else if (isEyeInWater == 3) DoPowderSnowFog(color, lViewPos);
|
||||
|
||||
if (blindness > 0.00001) DoBlindnessFog(color, lViewPos);
|
||||
if (darknessFactor > 0.00001) DoDarknessFog(color, lViewPos);
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
#ifndef INCLUDE_WATER_FOG
|
||||
#define INCLUDE_WATER_FOG
|
||||
|
||||
float GetWaterFog(float lViewPos) {
|
||||
#if WATER_FOG_MULT != 100
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
lViewPos *= WATER_FOG_MULT_M;
|
||||
#endif
|
||||
|
||||
#if LIGHTSHAFT_QUALI > 0 && SHADOW_QUALITY > -1
|
||||
float fog = lViewPos / 48.0;
|
||||
fog *= fog;
|
||||
#else
|
||||
float fog = lViewPos / 32.0;
|
||||
#endif
|
||||
|
||||
return 1.0 - exp(-fog);
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,43 @@
|
||||
vec3 GetNetherNoise(vec3 viewPos, float VdotU, float dither) {
|
||||
float visibility = clamp01(VdotU * 1.875 - 0.225);
|
||||
visibility *= 1.0 - VdotU * 0.75 - maxBlindnessDarkness;
|
||||
|
||||
if (visibility > 0.0) {
|
||||
vec3 spots = vec3(0.0);
|
||||
|
||||
float eyeAltitude1 = eyeAltitude * 0.005;
|
||||
float noiseHeightFactor = max(0.0, 1.5 - eyeAltitude1 / (eyeAltitude1 + 1.0));
|
||||
noiseHeightFactor *= noiseHeightFactor;
|
||||
float noiseHeight = noiseHeightFactor * 0.5;
|
||||
|
||||
vec3 wpos = (gbufferModelViewInverse * vec4(viewPos, 1.0)).xyz;
|
||||
wpos.xz /= wpos.y;
|
||||
|
||||
vec2 cameraPositionM = cameraPosition.xz * 0.0075;
|
||||
cameraPositionM.x += frameTimeCounter * 0.004;
|
||||
|
||||
int sampleCount = 10;
|
||||
int sampleCountP = sampleCount + 5;
|
||||
float ditherM = dither + 5.0;
|
||||
float wind = fract(frameTimeCounter * 0.0125);
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float current = pow2((i + ditherM) / sampleCountP);
|
||||
|
||||
vec2 planePos = wpos.xz * (0.8 + current) * noiseHeight;
|
||||
planePos = (planePos * 0.5 + cameraPositionM * 0.5) * 1.5;
|
||||
float noiseSpots = texture2D(noisetex, planePos * 0.5).g;
|
||||
vec3 noise = texture2D(noisetex, vec2(noiseSpots) + wind).g * netherColor * 2.5 - netherColor * 1.3;
|
||||
|
||||
float currentM = 1.0 - current;
|
||||
spots += noise * currentM * 6.0;
|
||||
}
|
||||
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
spots += 2.0 * isLightningActive();
|
||||
#endif
|
||||
|
||||
return spots * visibility / sampleCount;
|
||||
}
|
||||
|
||||
return vec3(0.0);
|
||||
}
|
||||
@ -0,0 +1,78 @@
|
||||
vec4 GetNetherStorm(vec3 color, vec3 translucentMult, vec3 nPlayerPos, vec3 playerPos, float lViewPos, float lViewPos1, float dither) {
|
||||
if (isEyeInWater != 0) return vec4(0.0);
|
||||
vec4 netherStorm = vec4(1.0, 1.0, 1.0, 0.0);
|
||||
|
||||
#ifdef BORDER_FOG
|
||||
float maxDist = min(renderDistance, NETHER_VIEW_LIMIT); // consistency9023HFUE85JG
|
||||
#else
|
||||
float maxDist = renderDistance;
|
||||
#endif
|
||||
|
||||
#ifndef LOW_QUALITY_NETHER_STORM
|
||||
int sampleCount = int(maxDist / 8.0 + 0.001);
|
||||
|
||||
vec3 traceAdd = nPlayerPos * maxDist / sampleCount;
|
||||
vec3 tracePos = cameraPosition;
|
||||
tracePos += traceAdd * dither;
|
||||
#else
|
||||
int sampleCount = int(maxDist / 16.0 + 0.001);
|
||||
|
||||
vec3 traceAdd = 0.75 * nPlayerPos * maxDist / sampleCount;
|
||||
vec3 tracePos = cameraPosition;
|
||||
tracePos += traceAdd * dither;
|
||||
tracePos += traceAdd * sampleCount * 0.25;
|
||||
#endif
|
||||
|
||||
vec3 translucentMultM = pow(translucentMult, vec3(1.0 / sampleCount));
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
tracePos += traceAdd;
|
||||
|
||||
vec3 tracedPlayerPos = tracePos - cameraPosition;
|
||||
float lTracePos = length(tracedPlayerPos);
|
||||
if (lTracePos > lViewPos1) break;
|
||||
|
||||
vec3 wind = vec3(frameTimeCounter * 0.002);
|
||||
|
||||
vec3 tracePosM = tracePos * 0.001;
|
||||
tracePosM.y += tracePosM.x;
|
||||
tracePosM += Noise3D(tracePosM - wind) * 0.01;
|
||||
tracePosM = tracePosM * vec3(2.0, 0.5, 2.0);
|
||||
|
||||
float traceAltitudeM = abs(tracePos.y - NETHER_STORM_LOWER_ALT);
|
||||
if (tracePos.y < NETHER_STORM_LOWER_ALT) traceAltitudeM *= 10.0;
|
||||
traceAltitudeM = 1.0 - min1(abs(traceAltitudeM) / NETHER_STORM_HEIGHT);
|
||||
|
||||
for (int h = 0; h < 4; h++) {
|
||||
float stormSample = pow2(Noise3D(tracePosM + wind));
|
||||
stormSample *= traceAltitudeM;
|
||||
stormSample = pow2(pow2(stormSample));
|
||||
stormSample *= sqrt1(max0(1.0 - lTracePos / maxDist));
|
||||
|
||||
netherStorm.a += stormSample;
|
||||
tracePosM *= 2.0;
|
||||
wind *= -2.0;
|
||||
}
|
||||
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
vec3 lightningPos = getLightningPos(tracePos - cameraPosition, lightningBoltPosition.xyz, false);
|
||||
vec2 lightningAdd = lightningFlashEffect(lightningPos, vec3(1.0), 150.0, 0.0, 0) * isLightningActive() * 8.0;
|
||||
netherStorm.rgb += lightningAdd.y;
|
||||
#endif
|
||||
|
||||
if (lTracePos > lViewPos) netherStorm.rgb *= translucentMultM;
|
||||
}
|
||||
|
||||
#ifdef LOW_QUALITY_NETHER_STORM
|
||||
netherStorm.a *= 1.8;
|
||||
#endif
|
||||
|
||||
netherStorm.a = min1(netherStorm.a * NETHER_STORM_I);
|
||||
|
||||
netherStorm.rgb *= netherColor * 3.0 * (1.0 - maxBlindnessDarkness);
|
||||
|
||||
//if (netherStorm.a > 0.98) netherStorm.rgb = vec3(1,0,1);
|
||||
//netherStorm.a *= 1.0 - max0(netherStorm.a - 0.98) * 50.0;
|
||||
|
||||
return netherStorm;
|
||||
}
|
||||
@ -0,0 +1,125 @@
|
||||
// Nebula implementation by flytrap https://godotshaders.com/shader/2d-nebula-shader/
|
||||
|
||||
#ifndef HQ_NIGHT_NEBULA
|
||||
const int OCTAVE = 5;
|
||||
#else
|
||||
const int OCTAVE = 8;
|
||||
#endif
|
||||
const float timescale = 5.0;
|
||||
const float zoomScale = 3.5;
|
||||
const vec4 CLOUD1_COL = vec4(0.41, 0.64, 0.97, 0.4);
|
||||
const vec4 CLOUD2_COL = vec4(0.81, 0.55, 0.21, 0.2);
|
||||
const vec4 CLOUD3_COL = vec4(0.51, 0.81, 0.98, 1.0);
|
||||
|
||||
float sinM(float x) {
|
||||
return sin(mod(x, 2.0 * pi));
|
||||
}
|
||||
|
||||
float cosM(float x) {
|
||||
return cos(mod(x, 2.0 * pi));
|
||||
}
|
||||
|
||||
float rand(vec2 inCoord){
|
||||
return fract(sinM(dot(inCoord, vec2(23.53, 44.0))) * 42350.45);
|
||||
}
|
||||
|
||||
float perlin(vec2 inCoord){
|
||||
vec2 i = floor(inCoord);
|
||||
vec2 j = fract(inCoord);
|
||||
vec2 coord = smoothstep(0.0, 1.0, j);
|
||||
|
||||
float a = rand(i);
|
||||
float b = rand(i + vec2(1.0, 0.0));
|
||||
float c = rand(i + vec2(0.0, 1.0));
|
||||
float d = rand(i + vec2(1.0, 1.0));
|
||||
|
||||
return mix(mix(a, b, coord.x), mix(c, d, coord.x), coord.y);
|
||||
}
|
||||
|
||||
float fbmCloud(vec2 inCoord, float minimum){
|
||||
float value = 0.0;
|
||||
float scale = 0.5;
|
||||
|
||||
for (int i = 0; i < OCTAVE; i++){
|
||||
value += perlin(inCoord) * scale;
|
||||
inCoord *= 2.0;
|
||||
scale *= 0.5;
|
||||
}
|
||||
|
||||
return smoothstep(0.0, 1.0, (smoothstep(minimum, 1.0, value) - minimum) / (1.0 - minimum));
|
||||
}
|
||||
|
||||
float fbmCloud2(vec2 inCoord, float minimum){
|
||||
float value = 0.0;
|
||||
float scale = 0.5;
|
||||
|
||||
for (int i = 0; i < OCTAVE; i++){
|
||||
value += perlin(inCoord) * scale;
|
||||
inCoord *= 2.0;
|
||||
scale *= 0.5;
|
||||
}
|
||||
|
||||
return (smoothstep(minimum, 1.0, value) - minimum) / (1.0 - minimum);
|
||||
}
|
||||
|
||||
vec3 GetNightNebula(vec3 viewPos, float VdotU, float VdotS) {
|
||||
float nebulaFactor = pow2(max0(VdotU) * min1(nightFactor * 2.0));
|
||||
|
||||
#if defined CLEAR_SKY_WHEN_RAINING || defined NO_RAIN_ABOVE_CLOUDS
|
||||
#ifndef CLEAR_SKY_WHEN_RAINING
|
||||
nebulaFactor *= mix(1.0, invRainFactor, heightRelativeToCloud);
|
||||
#else
|
||||
nebulaFactor *= mix(1.0, invRainFactor * 0.8 + 0.2, heightRelativeToCloud);
|
||||
#endif
|
||||
#else
|
||||
nebulaFactor *= invRainFactor;
|
||||
#endif
|
||||
|
||||
nebulaFactor -= maxBlindnessDarkness;
|
||||
|
||||
if (nebulaFactor < 0.001) return vec3(0.0);
|
||||
|
||||
vec2 UV = GetStarCoord(viewPos, 0.75);
|
||||
float TIME = syncedTime * 0.003 + 15.0;
|
||||
|
||||
float timescaled = TIME * timescale;
|
||||
vec2 zoomUV2
|
||||
= vec2(zoomScale * UV.x + 0.03 * timescaled * sinM(0.07 * timescaled), zoomScale * UV.y + 0.03 * timescaled * cosM(0.06 * timescaled));
|
||||
vec2 zoomUV3
|
||||
= vec2(zoomScale * UV.x + 0.027 * timescaled * sinM(0.07 * timescaled), zoomScale * UV.y + 0.025 * timescaled * cosM(0.06 * timescaled));
|
||||
vec2 zoomUV4
|
||||
= vec2(zoomScale * UV.x + 0.021 * timescaled * sinM(0.07 * timescaled), zoomScale * UV.y + 0.021 * timescaled * cosM(0.07 * timescaled));
|
||||
float tide = 0.05 * sinM(TIME);
|
||||
float tide2 = 0.06 * cosM(0.3 * TIME);
|
||||
|
||||
vec4 nebulaTexture = vec4(vec3(0.0), 0.5 + 0.2 * sinM(0.23 * TIME + UV.x - UV.y));
|
||||
nebulaTexture += fbmCloud2(zoomUV3, 0.24 + tide) * CLOUD1_COL;
|
||||
nebulaTexture += fbmCloud(zoomUV2 * 0.9, 0.33 - tide) * CLOUD2_COL;
|
||||
nebulaTexture = mix(nebulaTexture, CLOUD3_COL, fbmCloud(vec2(0.9 * zoomUV4.x, 0.9 * zoomUV4.y), 0.25 + tide2));
|
||||
|
||||
nebulaFactor *= 1.0 - pow2(pow2(pow2(abs(VdotS))));
|
||||
nebulaTexture.a *= min1(pow2(pow2(nebulaTexture.a))) * nebulaFactor;
|
||||
|
||||
float starFactor = 1024.0;
|
||||
UV /= STAR_SIZE;
|
||||
vec2 starCoord = floor(UV * 0.25 * starFactor) / starFactor;
|
||||
|
||||
vec2 fractPart = fract(UV * 0.25 * starFactor);
|
||||
|
||||
float starIntensity = GetStarNoise(starCoord) * GetStarNoise(starCoord + 0.1) - 0.6;
|
||||
|
||||
starIntensity *= getStarEdgeFactor(fractPart, STAR_ROUNDNESS_OW / 10.0, STAR_SOFTNESS_OW);
|
||||
|
||||
nebulaTexture.rgb *= 1.5 + 10.0 * pow2(max0(starIntensity));
|
||||
|
||||
#if NIGHT_NEBULA_I != 100
|
||||
#define NIGHT_NEBULA_IM NIGHT_NEBULA_I * 0.01
|
||||
nebulaTexture.a *= NIGHT_NEBULA_IM;
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
nebulaTexture.rgb *= sqrtAtmColorMult; // C72380KD - Reduced atmColorMult impact on some things
|
||||
#endif
|
||||
|
||||
return max(nebulaTexture.rgb * nebulaTexture.a, vec3(0.0));
|
||||
}
|
||||
@ -0,0 +1,65 @@
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
vec3 beamCol = normalize(ColorBeam) * 3.0 * (2.5 - 1.0 * vlFactor) * OVERWORLD_BEAMS_INTENSITY;
|
||||
|
||||
vec2 wind = vec2(syncedTime * 0.0056);
|
||||
|
||||
float BeamNoise(vec2 planeCoord, vec2 wind) {
|
||||
float noise = texture2D(noisetex, planeCoord * 0.275 - wind * 0.0625).b;
|
||||
noise+= texture2D(noisetex, planeCoord * 0.34375 + wind * 0.0575).b * 10.0;
|
||||
|
||||
return noise;
|
||||
}
|
||||
|
||||
vec4 DrawOverworldBeams(float VdotU, vec3 playerPos, vec3 viewPos) {
|
||||
float visibility = 1.0 - sunVisibility - maxBlindnessDarkness;
|
||||
#if OVERWORLD_BEAMS_CONDITION == 0
|
||||
visibility -= moonPhase;
|
||||
#endif
|
||||
if (visibility > 0.0) {
|
||||
vec3 result = vec3(0.0);
|
||||
|
||||
int sampleCount = 8;
|
||||
|
||||
float VdotUM = 1.0 - VdotU * VdotU;
|
||||
float VdotUM2 = VdotUM + smoothstep1(pow2(pow2(1.0 - abs(VdotU)))) * 0.2;
|
||||
|
||||
vec4 beams = vec4(0.0);
|
||||
float gradientMix = 1.0;
|
||||
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
auroraSpookyMix = getBloodMoon(moonPhase, sunVisibility);
|
||||
beamCol *= 1.0 + auroraSpookyMix * vec3(2.0, -1.0, -1.0);
|
||||
#endif
|
||||
#ifdef AURORA_INFLUENCE
|
||||
beamCol = mix(AuroraAmbientColor(beamCol, viewPos), beamCol, auroraSpookyMix);
|
||||
#endif
|
||||
|
||||
for(int i = 0; i < sampleCount; i++) {
|
||||
vec2 planeCoord = (playerPos.xz + cameraPosition.xz) * (1.0 + i * 6.0 / sampleCount) * 0.0014;
|
||||
|
||||
float noise = BeamNoise(planeCoord, wind);
|
||||
noise = max(0.92 - 1.0 / abs(noise - (2.5 + VdotUM * 2.0)), 0.0) * 2.5;
|
||||
|
||||
if (noise > 0.0) {
|
||||
noise *= 0.55;
|
||||
float fireNoise = texture2D(noisetex, abs(planeCoord * 0.2) - wind).b;
|
||||
noise *= 0.5 * fireNoise + 0.75;
|
||||
noise = noise * noise * 3.0 / sampleCount;
|
||||
noise *= mix(1.0, sqrt3(VdotUM2), 0.25);
|
||||
|
||||
vec3 beamColor = beamCol;
|
||||
beamColor *= gradientMix / sampleCount;
|
||||
|
||||
noise *= exp2(-6.0 * i / float(sampleCount));
|
||||
beams += vec4(noise * beamColor, noise);
|
||||
}
|
||||
gradientMix += 1.0;
|
||||
}
|
||||
beams.rgb *= beams.a * beams.a * beams.a * 5000.0;
|
||||
beams.rgb *= sqrt(beams.rgb);
|
||||
result = sqrt(beams.rgb);
|
||||
return vec4(result * visibility / sampleCount, beams.a);
|
||||
}
|
||||
return vec4(1.0);
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
#define RAINBOW_DIAMETER 1.00 //[0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 1.05 1.10 1.15 1.20 1.25 1.30 1.35 1.40 1.45 1.50 1.55 1.60 1.65 1.70 1.75 1.80 1.85 1.90 1.95 2.00 2.05 2.10 2.15 2.20 2.25 2.30 2.35 2.40 2.45 2.50 2.55 2.60 2.65 2.70 2.75 2.80 2.85 2.90 2.95 3.00 3.05 3.10 3.15 3.20 3.25 3.30 3.35 3.40 3.45 3.50 3.55 3.60 3.65 3.70 3.75 3.80 3.85 3.90 3.95 4.00 4.25 4.50 4.75 5.00 5.25 5.50 5.75 6.00 6.25 6.50 6.75 7.00 7.50 8.00]
|
||||
#define RAINBOW_STYLE 1 //[1 2]
|
||||
|
||||
vec3 GetRainbow(vec3 translucentMult, float z0, float z1, float lViewPos, float lViewPos1, float VdotL, float dither) {
|
||||
vec3 rainbow = vec3(0.0);
|
||||
|
||||
float rainbowTime = min1(max0(SdotU - 0.1) / 0.15);
|
||||
rainbowTime = clamp(rainbowTime - pow2(pow2(pow2(noonFactor))) * 8.0, 0.0, 0.85);
|
||||
#if RAINBOWS == 1 // After Rain
|
||||
#if defined CLEAR_SKY_WHEN_RAINING || defined NO_RAIN_ABOVE_CLOUDS
|
||||
rainbowTime *= sqrt2(max0(wetness - 0.333) * 1.5) * mix(1.0, invRainFactor, heightRelativeToCloud) * inRainy;
|
||||
#else
|
||||
rainbowTime *= sqrt2(max0(wetness - 0.333) * 1.5) * invRainFactor * inRainy;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (rainbowTime > 0.001) {
|
||||
float cloudLinearDepth = texelFetch(colortex4, texelCoord, 0).r;
|
||||
float cloudDistance = pow2(cloudLinearDepth + OSIEBCA * dither) * far;
|
||||
if (cloudDistance < lViewPos1) lViewPos = cloudDistance;
|
||||
|
||||
float rainbowLength = max(far, 128.0) * 0.9;
|
||||
|
||||
float rainbowCoord = clamp01(1.0 - (VdotL + 0.75) / (0.0625 * RAINBOW_DIAMETER));
|
||||
float rainbowFactor = rainbowCoord * (1.0 - rainbowCoord);
|
||||
rainbowFactor = pow2(pow2(rainbowFactor * 3.7));
|
||||
rainbowFactor *= pow2(min1(lViewPos / rainbowLength));
|
||||
rainbowFactor *= rainbowTime;
|
||||
rainbowFactor *= 1.0 - GetCaveFactor();
|
||||
|
||||
if (rainbowFactor > 0.0) {
|
||||
#if RAINBOW_STYLE == 1
|
||||
float rainbowCoordM = pow(rainbowCoord, 1.4 + max(rainbowCoord - 0.5, 0.0) * 1.6);
|
||||
rainbowCoordM = smoothstep(0.0, 1.0, rainbowCoordM) * 0.85;
|
||||
rainbowCoordM += (dither - 0.5) * 0.1;
|
||||
rainbow += clamp(abs(mod(rainbowCoordM * 6.0 + vec3(-0.55,4.3,2.2) ,6.0)-3.0)-1.0, 0.0, 1.0);
|
||||
rainbowCoordM += 0.1;
|
||||
rainbow += clamp(abs(mod(rainbowCoordM * 6.0 + vec3(-0.55,4.3,2.2) ,6.0)-3.0)-1.0, 0.0, 1.0);
|
||||
rainbowCoordM -= 0.2;
|
||||
rainbow += clamp(abs(mod(rainbowCoordM * 6.0 + vec3(-0.55,4.3,2.2) ,6.0)-3.0)-1.0, 0.0, 1.0);
|
||||
rainbow /= 3.0;
|
||||
rainbow.r += pow2(max(rainbowCoord - 0.5, 0.0)) * (max(1.0 - rainbowCoord, 0.0)) * 26.0;
|
||||
rainbow = pow(rainbow, vec3(2.2)) * vec3(0.25, 0.075, 0.25) * 3.0;
|
||||
#else
|
||||
float rainbowCoordM = pow(rainbowCoord, 1.35);
|
||||
rainbowCoordM = smoothstep(0.0, 1.0, rainbowCoordM);
|
||||
rainbow += clamp(abs(mod(rainbowCoordM * 6.0 + vec3(0.0,4.0,2.0) ,6.0)-3.0)-1.0, 0.0, 1.0);
|
||||
rainbow *= rainbow * (3.0 - 2.0 * rainbow);
|
||||
rainbow = pow(rainbow, vec3(2.2)) * vec3(0.25, 0.075, 0.25) * 3.0;
|
||||
#endif
|
||||
|
||||
if (z1 > z0 && lViewPos < rainbowLength)
|
||||
rainbow *= mix(translucentMult, vec3(1.0), lViewPos / rainbowLength);
|
||||
|
||||
rainbow *= rainbowFactor;
|
||||
}
|
||||
}
|
||||
|
||||
return rainbow;
|
||||
}
|
||||
@ -0,0 +1,155 @@
|
||||
#ifndef INCLUDE_SKY
|
||||
#define INCLUDE_SKY
|
||||
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
#include "/lib/atmospherics/fog/caveFactor.glsl"
|
||||
#endif
|
||||
|
||||
vec3 GetSky(float VdotU, float VdotS, float dither, bool doGlare, bool doGround) {
|
||||
// Prepare variables
|
||||
float nightFactorSqrt2 = sqrt2(nightFactor);
|
||||
float nightFactorM = sqrt2(nightFactorSqrt2) * 0.4;
|
||||
float VdotSM1 = pow2(max(VdotS, 0.0));
|
||||
float VdotSM2 = pow2(VdotSM1);
|
||||
float VdotSM3 = pow2(pow2(max(-VdotS, 0.0)));
|
||||
float VdotSML = sunVisibility > 0.5 ? VdotS : -VdotS;
|
||||
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUmax0M = 1.0 - pow2(VdotUmax0);
|
||||
|
||||
// Prepare colors
|
||||
vec3 upColor = mix(nightUpSkyColor * (1.5 - 0.5 * nightFactorSqrt2 + nightFactorM * VdotSM3 * 1.5), dayUpSkyColor, sunFactor);
|
||||
vec3 middleColor = mix(nightMiddleSkyColor * (3.0 - 2.0 * nightFactorSqrt2), dayMiddleSkyColor * (1.0 + VdotSM2 * 0.3), sunFactor);
|
||||
vec3 downColor = mix(nightDownSkyColor, dayDownSkyColor, (sunFactor + sunVisibility) * 0.5);
|
||||
|
||||
// Mix the colors
|
||||
// Set sky gradient
|
||||
float scatteredGroundMixerMult = 1.0;
|
||||
float spookyMiddleMult = 1.0;
|
||||
#ifdef SPOOKY
|
||||
scatteredGroundMixerMult = 0.2;
|
||||
spookyMiddleMult = 0.8;
|
||||
#endif
|
||||
float VdotUM1 = pow2(1.0 - VdotUmax0);
|
||||
VdotUM1 = pow(VdotUM1, 1.0 - VdotSM2 * 0.4);
|
||||
VdotUM1 = mix(VdotUM1, 1.0, rainFactor2 * 0.15);
|
||||
vec3 finalSky = mix(upColor, middleColor * spookyMiddleMult, VdotUM1);
|
||||
|
||||
// Add sunset color
|
||||
float VdotUM2 = pow2(1.0 - abs(VdotU));
|
||||
VdotUM2 = VdotUM2 * VdotUM2 * (3.0 - 2.0 * VdotUM2);
|
||||
VdotUM2 *= (0.7 - nightFactorM + VdotSM1 * (0.3 + nightFactorM)) * invNoonFactor * sunFactor;
|
||||
finalSky = mix(finalSky, sunsetDownSkyColorP * (1.0 + VdotSM1 * 0.3), VdotUM2 * invRainFactor);
|
||||
|
||||
// Add sky ground with fake light scattering
|
||||
float VdotUM3 = min(max0(-VdotU + 0.08) / 0.35, 1.0);
|
||||
VdotUM3 = smoothstep1(VdotUM3);
|
||||
vec3 scatteredGroundMixer = vec3(VdotUM3 * VdotUM3, sqrt1(VdotUM3), sqrt3(VdotUM3));
|
||||
scatteredGroundMixer = mix(vec3(VdotUM3), scatteredGroundMixer, 0.75 - 0.5 * rainFactor);
|
||||
finalSky = mix(finalSky, downColor, scatteredGroundMixer * scatteredGroundMixerMult);
|
||||
//
|
||||
|
||||
// Sky Ground
|
||||
if (doGround)
|
||||
finalSky *= smoothstep1(pow2(1.0 + min(VdotU, 0.0)));
|
||||
|
||||
// Apply Underwater Fog
|
||||
if (isEyeInWater == 1)
|
||||
finalSky = mix(finalSky * 3.0, waterFogColor, VdotUmax0M);
|
||||
|
||||
// Sun/Moon Glare
|
||||
#if SUN_GLARE_AMOUNT > 0
|
||||
if (doGlare) {
|
||||
if (0.0 < VdotSML) {
|
||||
float glareScatter = 4.0 * (2.0 - clamp01(VdotS * 1000.0));
|
||||
float VdotSM4 = pow(abs(VdotS), glareScatter);
|
||||
|
||||
float visfactor = 0.075;
|
||||
float glare = visfactor / (1.0 - (1.0 - visfactor) * VdotSM4) - visfactor;
|
||||
|
||||
glare *= 0.5 + pow2(noonFactor) * 1.2;
|
||||
glare *= 1.0 - rainFactor * 0.5;
|
||||
|
||||
float glareWaterFactor = isEyeInWater * sunVisibility;
|
||||
vec3 moonGlareColor = vec3(0.502, 0.3804, 0.3804);
|
||||
#if defined SPOOKY && BLOOD_MOON > 0
|
||||
moonGlareColor = mix(moonGlareColor, vec3(1.0, 0.0, 0.0) * 1.5, getBloodMoon(moonPhase, sunVisibility));
|
||||
#endif
|
||||
vec3 glareColor = mix(moonGlareColor * 0.7, vec3(0.5), sunVisibility);
|
||||
glareColor = glareColor + glareWaterFactor * vec3(7.0);
|
||||
|
||||
glare *= SUN_GLARE_AMOUNT * 0.1;
|
||||
|
||||
#ifdef SPOOKY
|
||||
glare *= 0.5;
|
||||
#endif
|
||||
|
||||
finalSky += glare * shadowTime * glareColor;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
// Apply Cave Fog
|
||||
finalSky = mix(finalSky, caveFogColor, GetCaveFactor() * VdotUmax0M);
|
||||
#endif
|
||||
|
||||
// Dither to fix banding
|
||||
finalSky += (dither - 0.5) / 128.0;
|
||||
|
||||
#if RETRO_LOOK == 1
|
||||
finalSky = vec3(0.0);
|
||||
#elif RETRO_LOOK ==2
|
||||
finalSky = mix(finalSky, vec3(0.0), nightVision);
|
||||
#endif
|
||||
|
||||
return finalSky;
|
||||
}
|
||||
|
||||
vec3 GetLowQualitySky(float VdotU, float VdotS, float dither, bool doGlare, bool doGround) {
|
||||
// Prepare variables
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUmax0M = 1.0 - pow2(VdotUmax0);
|
||||
|
||||
// Prepare colors
|
||||
vec3 upColor = mix(nightUpSkyColor, dayUpSkyColor, sunFactor);
|
||||
vec3 middleColor = mix(nightMiddleSkyColor, dayMiddleSkyColor, sunFactor);
|
||||
|
||||
// Mix the colors
|
||||
// Set sky gradient
|
||||
float VdotUM1 = pow2(1.0 - VdotUmax0);
|
||||
VdotUM1 = mix(VdotUM1, 1.0, rainFactor2 * 0.2);
|
||||
vec3 finalSky = mix(upColor, middleColor, VdotUM1);
|
||||
|
||||
// Add sunset color
|
||||
float VdotUM2 = pow2(1.0 - abs(VdotU));
|
||||
VdotUM2 *= invNoonFactor * sunFactor * (0.8 + 0.2 * VdotS);
|
||||
finalSky = mix(finalSky, sunsetDownSkyColorP * (shadowTime * 0.6 + 0.2), VdotUM2 * invRainFactor);
|
||||
//
|
||||
|
||||
// Sky Ground
|
||||
finalSky *= pow2(pow2(1.0 + min(VdotU, 0.0)));
|
||||
|
||||
// Apply Underwater Fog
|
||||
if (isEyeInWater == 1)
|
||||
finalSky = mix(finalSky, waterFogColor, VdotUmax0M);
|
||||
|
||||
// Sun/Moon Glare
|
||||
finalSky *= 1.0 + mix(nightFactor, 0.5 + 0.7 * noonFactor, VdotS * 0.5 + 0.5) * pow2(pow2(pow2(VdotS)));
|
||||
|
||||
#ifdef CAVE_FOG
|
||||
// Apply Cave Fog
|
||||
finalSky = mix(finalSky, caveFogColor, GetCaveFactor() * VdotUmax0M);
|
||||
#endif
|
||||
|
||||
#if RETRO_LOOK == 1 || RETRO_LOOK == 2
|
||||
finalSky = vec3(0.0);
|
||||
#endif
|
||||
|
||||
return finalSky;
|
||||
}
|
||||
|
||||
#endif //INCLUDE_SKY
|
||||
@ -0,0 +1,77 @@
|
||||
#include "/lib/colors/skyColors.glsl"
|
||||
|
||||
vec2 GetStarCoord(vec3 viewPos, float sphereness) {
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * 1000.0, 1.0)).xyz);
|
||||
vec3 starCoord = wpos / (wpos.y + length(wpos.xz) * sphereness);
|
||||
starCoord.x += 0.006 * syncedTime;
|
||||
return starCoord.xz;
|
||||
}
|
||||
|
||||
vec3 GetStars(vec2 starCoord, float VdotU, float VdotS, float sizeMult, float starAmount) {
|
||||
if (VdotU < 0.0) return vec3(0.0);
|
||||
|
||||
float spookyStarSize = 10000.0;
|
||||
#ifdef SPOOKY
|
||||
spookyStarSize = 0.5;
|
||||
#endif
|
||||
|
||||
starCoord *= 0.2 / (min(STAR_SIZE, spookyStarSize) * sizeMult);
|
||||
const float starFactor = 1024.0;
|
||||
|
||||
vec2 fractPart = fract(starCoord * starFactor);
|
||||
|
||||
starCoord = floor(starCoord * starFactor) / starFactor;
|
||||
|
||||
float star = GetStarNoise(starCoord.xy) * GetStarNoise(starCoord.xy+0.1) * GetStarNoise(starCoord.xy+0.23);
|
||||
|
||||
#if MORE_STARS_OVERWORLD == 1 || defined SPOOKY
|
||||
star = max0((star - 0.5) * 0.55);
|
||||
#elif MORE_STARS_OVERWORLD == 2
|
||||
star = max0((star - 0.4) * 0.45);
|
||||
#elif NIGHT_STAR_AMOUNT == 2
|
||||
star = max0(star - 0.7);
|
||||
#else
|
||||
star = max0((star - 0.6) * 0.65);
|
||||
#endif
|
||||
|
||||
star = max0(star - starAmount * 0.1);
|
||||
star *= getStarEdgeFactor(fractPart, STAR_ROUNDNESS_OW / 10.0, STAR_SOFTNESS_OW);
|
||||
star *= star;
|
||||
|
||||
star *= min1(VdotU * 3.0) * max0(1.0 - pow(abs(VdotS) * 1.002, 100.0));
|
||||
#ifndef DAYLIGHT_STARS
|
||||
star *= pow2(pow2(invNoonFactor2)) * (1.0 - 0.5 * sunVisibility);
|
||||
#endif
|
||||
|
||||
#if defined CLEAR_SKY_WHEN_RAINING || defined NO_RAIN_ABOVE_CLOUDS
|
||||
#ifndef CLEAR_SKY_WHEN_RAINING
|
||||
star *= mix(1.0, invRainFactor, heightRelativeToCloud);
|
||||
#else
|
||||
star *= mix(1.0, invRainFactor * 0.8 + 0.2, heightRelativeToCloud);
|
||||
#endif
|
||||
#else
|
||||
star *= invRainFactor;
|
||||
#endif
|
||||
|
||||
float spookyStarMult = 0.0;
|
||||
#ifdef SPOOKY
|
||||
spookyStarMult = 2.0;
|
||||
#endif
|
||||
|
||||
const float starBrightness = STAR_BRIGHTNESS > 3.0 ? ((STAR_BRIGHTNESS - 3.0) * 0.1) : STAR_BRIGHTNESS;
|
||||
|
||||
vec3 starColor = GetStarColor(starCoord,
|
||||
vec3(0.38, 0.4, 0.5),
|
||||
vec3(STAR_COLOR_1_OW_R, STAR_COLOR_1_OW_G, STAR_COLOR_1_OW_B),
|
||||
vec3(STAR_COLOR_2_OW_R, STAR_COLOR_2_OW_G, STAR_COLOR_2_OW_B),
|
||||
vec3(STAR_COLOR_3_OW_R, STAR_COLOR_3_OW_G, STAR_COLOR_3_OW_B),
|
||||
STAR_COLOR_VARIATION_OW);
|
||||
|
||||
vec3 stars = 40.0 * star * starColor * max(starBrightness, spookyStarMult);
|
||||
|
||||
#if TWINKLING_STARS > 0 || defined SPOOKY
|
||||
stars *= getTwinklingStars(starCoord, float(TWINKLING_STARS));
|
||||
#endif
|
||||
|
||||
return stars;
|
||||
}
|
||||
@ -0,0 +1,350 @@
|
||||
// Volumetric tracing from Robobo1221, highly modified
|
||||
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
|
||||
float GetDepth(float depth) {
|
||||
return 2.0 * near * far / (far + near - (2.0 * depth - 1.0) * (far - near));
|
||||
}
|
||||
|
||||
float GetDistX(float dist) {
|
||||
return (far * (dist - near)) / (dist * (far - near));
|
||||
}
|
||||
|
||||
vec4 DistortShadow(vec4 shadowpos, float distortFactor) {
|
||||
shadowpos.xy *= 1.0 / distortFactor;
|
||||
shadowpos.z = shadowpos.z * 0.2;
|
||||
shadowpos = shadowpos * 0.5 + 0.5;
|
||||
|
||||
return shadowpos;
|
||||
}
|
||||
|
||||
vec4 GetVolumetricLight(inout vec3 color, inout float vlFactor, vec3 translucentMult, float lViewPos0, float lViewPos1, vec3 nViewPos, float VdotL, float VdotU, vec2 texCoord, float z0, float z1, float dither) {
|
||||
vec4 volumetricLight = vec4(0.0);
|
||||
#if defined BEDROCK_NOISE && defined OVERWORLD
|
||||
if ((cameraPosition.y < bedrockLevel) && (eyeBrightnessM < 0.4)) return vec4(0.0);
|
||||
#endif
|
||||
float vlMult = 1.0 - maxBlindnessDarkness;
|
||||
|
||||
#if SHADOW_QUALITY > -1
|
||||
// Optifine for some reason doesn't provide correct shadowMapResolution if Shadow Quality isn't 1x
|
||||
vec2 shadowMapResolutionM = textureSize(shadowtex0, 0);
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 vlColor = lightColor;
|
||||
vec3 vlColorReducer = vec3(1.0);
|
||||
float vlSceneIntensity = isEyeInWater != 1 ? vlFactor : 1.0;
|
||||
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
vlSceneIntensity = mix(vlSceneIntensity, 1.0, inDry * rainFactor);
|
||||
#endif
|
||||
|
||||
if (sunVisibility < 0.5) {
|
||||
vlSceneIntensity = 0.0;
|
||||
|
||||
float vlMultNightModifier = 0.6 + 0.4 * max0(far - lViewPos1) / far;
|
||||
#ifdef SPECIAL_PALE_GARDEN_LIGHTSHAFTS
|
||||
vlMultNightModifier = mix(vlMultNightModifier, 1.0, inPaleGarden);
|
||||
#endif
|
||||
vlMult *= vlMultNightModifier;
|
||||
|
||||
vlColor = normalize(pow(vlColor, vec3(1.0 - max0(1.0 - 1.5 * nightFactor))));
|
||||
vlColor *= 0.0766 + 0.0766 * vsBrightness;
|
||||
} else {
|
||||
vlColorReducer = 1.0 / sqrt(vlColor);
|
||||
}
|
||||
|
||||
#ifdef SPECIAL_PALE_GARDEN_LIGHTSHAFTS
|
||||
vlSceneIntensity = mix(vlSceneIntensity, 1.0, inPaleGarden);
|
||||
vlMult *= 1.0 + (3.0 * inPaleGarden) * (1.0 - sunVisibility);
|
||||
#endif
|
||||
|
||||
float rainyNight = (1.0 - sunVisibility) * rainFactor;
|
||||
float VdotLM = max((VdotL + 1.0) / 2.0, 0.0);
|
||||
float VdotUmax0 = max(VdotU, 0.0);
|
||||
float VdotUM = mix(pow2(1.0 - VdotUmax0), 1.0, 0.5 * vlSceneIntensity);
|
||||
VdotUM = smoothstep1(VdotUM);
|
||||
VdotUM = pow(VdotUM, min(lViewPos1 / far, 1.0) * (3.0 - 2.0 * vlSceneIntensity));
|
||||
vlMult *= mix(VdotUM * VdotLM, 1.0, 0.4 * rainyNight) * vlTime;
|
||||
vlMult *= mix(invNoonFactor2 * 0.875 + 0.125, 1.0, max(vlSceneIntensity, rainFactor2));
|
||||
|
||||
#if LIGHTSHAFT_QUALI == 4
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 30 : 50;
|
||||
#elif LIGHTSHAFT_QUALI == 3
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 15 : 30;
|
||||
#elif LIGHTSHAFT_QUALI == 2
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 10 : 20;
|
||||
#elif LIGHTSHAFT_QUALI == 1
|
||||
int sampleCount = vlSceneIntensity < 0.5 ? 6 : 12;
|
||||
#endif
|
||||
|
||||
#ifdef LIGHTSHAFT_SMOKE
|
||||
float totalSmoke = 0.0;
|
||||
#endif
|
||||
#else
|
||||
translucentMult = sqrt(translucentMult); // Because we pow2() the vl result in composite for the End dimension
|
||||
|
||||
float vlSceneIntensity = 0.0;
|
||||
|
||||
#ifndef LOW_QUALITY_ENDER_NEBULA
|
||||
int sampleCount = 16;
|
||||
#else
|
||||
int sampleCount = 10;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float addition = 1.0;
|
||||
float maxDist = mix(max(far, 96.0) * 0.55, 80.0, vlSceneIntensity);
|
||||
|
||||
#if WATER_FOG_MULT != 100
|
||||
if (isEyeInWater == 1) {
|
||||
#define WATER_FOG_MULT_M WATER_FOG_MULT * 0.01;
|
||||
maxDist /= WATER_FOG_MULT_M;
|
||||
}
|
||||
#endif
|
||||
|
||||
float distMult = maxDist / (sampleCount + addition);
|
||||
float sampleMultIntense = isEyeInWater != 1 ? 1.0 : 0.85;
|
||||
|
||||
float viewFactor = 1.0 - 0.7 * pow2(dot(nViewPos.xy, nViewPos.xy));
|
||||
|
||||
float depth0 = GetDepth(z0);
|
||||
float depth1 = GetDepth(z1);
|
||||
#ifdef END
|
||||
if (z0 == 1.0) depth0 = 1000.0;
|
||||
if (z1 == 1.0) depth1 = 1000.0;
|
||||
#endif
|
||||
|
||||
// Fast but inaccurate perspective distortion approximation
|
||||
maxDist *= viewFactor;
|
||||
distMult *= viewFactor;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float maxCurrentDist = min(depth1, maxDist);
|
||||
#else
|
||||
float maxCurrentDist = min(depth1, far);
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < sampleCount; i++) {
|
||||
float currentDist = (i + dither) * distMult + addition;
|
||||
|
||||
if (currentDist > maxCurrentDist) break;
|
||||
|
||||
vec4 viewPos = gbufferProjectionInverse * (vec4(texCoord, GetDistX(currentDist), 1.0) * 2.0 - 1.0);
|
||||
viewPos /= viewPos.w;
|
||||
vec4 wpos = gbufferModelViewInverse * viewPos;
|
||||
vec3 playerPos = wpos.xyz / wpos.w;
|
||||
#if defined END && defined END_BEAMS
|
||||
#ifdef DISTANT_HORIZONS
|
||||
playerPos *= sqrt(renderDistance / far);
|
||||
#endif
|
||||
vec4 enderBeamSample = vec4(DrawEnderBeams(VdotU, playerPos), 1.0);
|
||||
enderBeamSample /= sampleCount;
|
||||
#endif
|
||||
#if defined OVERWORLD && defined OVERWORLD_BEAMS
|
||||
vec4 overworldBeamSample = DrawOverworldBeams(VdotU, playerPos, viewPos.xyz);
|
||||
#endif
|
||||
|
||||
float shadowSample = 1.0;
|
||||
vec3 vlSample = vec3(1.0);
|
||||
#if SHADOW_QUALITY > -1
|
||||
wpos = shadowModelView * wpos;
|
||||
wpos = shadowProjection * wpos;
|
||||
wpos /= wpos.w;
|
||||
float distb = sqrt(wpos.x * wpos.x + wpos.y * wpos.y);
|
||||
float distortFactor = 1.0 - shadowMapBias + distb * shadowMapBias;
|
||||
vec4 shadowPosition = DistortShadow(wpos,distortFactor);
|
||||
//shadowPosition.z += 0.0001;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float percentComplete = currentDist / maxDist;
|
||||
float sampleMult = mix(percentComplete * 3.0, sampleMultIntense, max(rainFactor, vlSceneIntensity));
|
||||
if (currentDist < 5.0) sampleMult *= smoothstep1(clamp(currentDist / 5.0, 0.0, 1.0));
|
||||
sampleMult /= sampleCount;
|
||||
#endif
|
||||
|
||||
if (length(shadowPosition.xy * 2.0 - 1.0) < 1.0) {
|
||||
// 28A3DK6 We need to use texelFetch here or a lot of Nvidia GPUs can't get a valid value
|
||||
shadowSample = texelFetch(shadowtex0, ivec2(shadowPosition.xy * shadowMapResolutionM), 0).x;
|
||||
shadowSample = clamp((shadowSample-shadowPosition.z)*65536.0,0.0,1.0);
|
||||
|
||||
vlSample = vec3(shadowSample);
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
if (shadowSample == 0.0) {
|
||||
float testsample = shadow2D(shadowtex1, shadowPosition.xyz).z;
|
||||
if (testsample == 1.0) {
|
||||
vec3 colsample = texture2D(shadowcolor1, shadowPosition.xy).rgb * 4.0;
|
||||
colsample *= colsample;
|
||||
vlSample = colsample;
|
||||
shadowSample = 1.0;
|
||||
#ifdef OVERWORLD
|
||||
vlSample *= vlColorReducer;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
#ifdef OVERWORLD
|
||||
// For water-tinting the water surface when observed from below the surface
|
||||
if (translucentMult != vec3(1.0) && currentDist > depth0) {
|
||||
vec3 tinter = vec3(1.0);
|
||||
if (isEyeInWater == 1) {
|
||||
vec3 translucentMultM = translucentMult * 2.8;
|
||||
tinter = pow(translucentMultM, vec3(sunVisibility * 3.0 * clamp01(playerPos.y * 0.03)));
|
||||
} else {
|
||||
tinter = 0.1 + 0.9 * pow2(pow2(translucentMult * 1.7));
|
||||
}
|
||||
vlSample *= mix(vec3(1.0), tinter, clamp01(oceanAltitude - cameraPosition.y));
|
||||
}
|
||||
#endif
|
||||
|
||||
if (isEyeInWater == 1 && translucentMult == vec3(1.0)) vlSample = vec3(0.0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
if (currentDist > depth0) vlSample *= translucentMult;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#ifdef LIGHTSHAFT_SMOKE
|
||||
vec3 smokePos = 0.0015 * (playerPos + cameraPosition);
|
||||
vec3 smokeWind = frameTimeCounter * vec3(0.002, 0.001, 0.0);
|
||||
float smoke = 0.65 * Noise3D(smokePos + smokeWind)
|
||||
+ 0.25 * Noise3D((smokePos - smokeWind) * 3.0)
|
||||
+ 0.10 * Noise3D((smokePos + smokeWind) * 9.0);
|
||||
smoke = smoothstep1(smoothstep1(smoothstep1(smoke)));
|
||||
totalSmoke += smoke * shadowSample * sampleMult;
|
||||
#endif
|
||||
vec4 volumetricLightAdd = vec4(vlSample, shadowSample) * sampleMult;
|
||||
#ifdef OVERWORLD_BEAMS
|
||||
volumetricLight += volumetricLightAdd * mix(vec4(1.0), overworldBeamSample, overworldBeamSample.a);
|
||||
#else
|
||||
volumetricLight += volumetricLightAdd;
|
||||
#endif
|
||||
#else
|
||||
#ifdef END_BEAMS
|
||||
volumetricLight += vec4(vlSample, shadowSample) * enderBeamSample;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef LIGHTSHAFT_SMOKE
|
||||
volumetricLight *= pow(totalSmoke / volumetricLight.a, min(1.0 - volumetricLight.a, 0.5));
|
||||
volumetricLight.rgb /= pow(0.5, 1.0 - volumetricLight.a);
|
||||
#endif
|
||||
|
||||
// Decision of Intensity for Scene Aware Light Shafts //
|
||||
#if defined OVERWORLD && LIGHTSHAFT_BEHAVIOUR == 1 && SHADOW_QUALITY >= 1
|
||||
if (viewWidth + viewHeight - gl_FragCoord.x - gl_FragCoord.y < 1.5) {
|
||||
if (frameCounter % int(0.06666 / frameTimeSmooth + 0.5) == 0) { // Change speed is not too different above 10 fps
|
||||
int salsX = 5;
|
||||
int salsY = 5;
|
||||
float heightThreshold = 6.0;
|
||||
|
||||
vec2 viewM = 1.0 / vec2(salsX, salsY);
|
||||
float salsSampleSum = 0.0;
|
||||
int salsSampleCount = 0;
|
||||
for (float i = 0.25; i < salsX; i++) {
|
||||
for (float h = 0.45; h < salsY; h++) {
|
||||
vec2 coord = 0.3 + 0.4 * viewM * vec2(i, h);
|
||||
ivec2 icoord = ivec2(coord * shadowMapResolutionM);
|
||||
float salsSample = texelFetch(shadowtex0, icoord, 0).x; // read 28A3DK6
|
||||
if (salsSample < 0.55) {
|
||||
float sampledHeight = texture2D(shadowcolor1, coord).a;
|
||||
if (sampledHeight > 0.0) {
|
||||
sampledHeight = max0(sampledHeight - 0.25) / 0.05; // consistencyMEJHRI7DG
|
||||
salsSampleSum += sampledHeight;
|
||||
salsSampleCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
float salsCheck = salsSampleSum / salsSampleCount;
|
||||
int reduceAmount = 2;
|
||||
|
||||
int skyCheck = 0;
|
||||
for (float i = 0.1; i < 1.0; i += 0.2) {
|
||||
skyCheck += int(texelFetch(depthtex0, ivec2(view.x * i, view.y * 0.9), 0).x == 1.0);
|
||||
}
|
||||
if (skyCheck >= 4) {
|
||||
salsCheck = 0.0;
|
||||
reduceAmount = 3;
|
||||
}
|
||||
|
||||
if (salsCheck > heightThreshold) {
|
||||
vlFactor = min(vlFactor + OSIEBCA, 1.0);
|
||||
} else {
|
||||
vlFactor = max(vlFactor - OSIEBCA * reduceAmount, 0.0);
|
||||
}
|
||||
}
|
||||
} else vlFactor = 0.0;
|
||||
//if (gl_FragCoord.y < 50) color.rgb = vec3(1,0,1) * float(salsCheck / heightThreshold > gl_FragCoord.x / 1920.0);
|
||||
|
||||
/*for (float i = 0.25; i < salsX; i++) {
|
||||
for (float h = 0.45; h < salsY; h++) {
|
||||
if (length(texCoord - (0.3 + 0.4 * viewM * vec2(i, h))) < 0.01) return vec4(1,0,1,1);
|
||||
}
|
||||
}*/
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vlColor = pow(vlColor, vec3(0.5 + 0.5 * invNoonFactor * invRainFactor + 0.3 * rainFactor));
|
||||
vlColor *= 1.0 - (0.3 + 0.3 * noonFactor) * rainFactor - 0.5 * rainyNight;
|
||||
|
||||
#if LIGHTSHAFT_DAY_I != 100 || LIGHTSHAFT_NIGHT_I != 100 || LIGHTSHAFT_RAIN_I != 100
|
||||
#define LIGHTSHAFT_DAY_IM LIGHTSHAFT_DAY_I * 0.01
|
||||
#define LIGHTSHAFT_NIGHT_IM LIGHTSHAFT_NIGHT_I * 0.01
|
||||
#define LIGHTSHAFT_RAIN_IM LIGHTSHAFT_RAIN_I * 0.01
|
||||
|
||||
if (isEyeInWater == 0) {
|
||||
#if LIGHTSHAFT_DAY_I != 100 || LIGHTSHAFT_NIGHT_I != 100
|
||||
vlColor.rgb *= mix(LIGHTSHAFT_NIGHT_IM, LIGHTSHAFT_DAY_IM, sunVisibility);
|
||||
#endif
|
||||
#if LIGHTSHAFT_RAIN_I != 100
|
||||
vlColor.rgb *= mix(1.0, LIGHTSHAFT_RAIN_IM, rainFactor);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
volumetricLight.rgb *= vlColor;
|
||||
#endif
|
||||
|
||||
volumetricLight.rgb *= vlMult;
|
||||
volumetricLight = max(volumetricLight, vec4(0.0));
|
||||
|
||||
#ifdef DISTANT_HORIZONS
|
||||
if (isEyeInWater == 0) {
|
||||
#ifdef OVERWORLD
|
||||
float lViewPosM = lViewPos0;
|
||||
if (z0 >= 1.0) {
|
||||
float z0DH = texelFetch(dhDepthTex, texelCoord, 0).r;
|
||||
vec4 screenPosDH = vec4(texCoord, z0DH, 1.0);
|
||||
vec4 viewPosDH = dhProjectionInverse * (screenPosDH * 2.0 - 1.0);
|
||||
viewPosDH /= viewPosDH.w;
|
||||
lViewPosM = length(viewPosDH.xyz);
|
||||
}
|
||||
lViewPosM = min(lViewPosM, renderDistance * 0.6);
|
||||
|
||||
float dhVlStillIntense = max(max(vlSceneIntensity, rainFactor), nightFactor * 0.5);
|
||||
|
||||
volumetricLight *= mix(0.0003 * lViewPosM, 1.0, dhVlStillIntense);
|
||||
#else
|
||||
volumetricLight *= min1(lViewPos1 * 3.0 / renderDistance);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if RETRO_LOOK == 1
|
||||
volumetricLight *= vec4(0.0);
|
||||
#elif RETRO_LOOK == 2
|
||||
volumetricLight *= mix(vec4(1.0), vec4(0.0), nightVision);
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
if (isEyeInWater == 1) volumetricLight *= 0.2;
|
||||
volumetricLight *= 0.35;
|
||||
#endif
|
||||
|
||||
return volumetricLight;
|
||||
}
|
||||
@ -0,0 +1,272 @@
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
#ifdef SPOOKY
|
||||
vec3 blocklightCol = mix(vec3(0.2, 0.1098, 0.0431) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B), vec3(0.05, 0.22, 0.25), inSoulValley);
|
||||
#else
|
||||
vec3 blocklightCol = mix(vec3(0.1775, 0.108, 0.0775) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B), vec3(0.05, 0.22, 0.25), inSoulValley);
|
||||
#endif
|
||||
vec3 fireSpecialLightColorGradient = mix(vec3(2.0, 0.87, 0.27) * 3.8, mix(vec3(2.5, 0.87, 0.27), vec3(0.5, 1.9, 2.1) * 3.8, 0.3), inSoulValley);
|
||||
vec3 torchBlockSpecialLightColor = mix(vec3(2.0, 0.87, 0.27) * 3.8, mix(vec3(2.5, 0.87, 0.27), vec3(0.5, 1.9, 2.1) * 3.8, 0.5), inSoulValley);
|
||||
vec3 lanternBlockSpecialLightColor = mix(vec3(2.0, 0.87, 0.27) * 3.8, mix(vec3(2.5, 0.87, 0.27), vec3(0.5, 1.9, 2.1) * 3.8, 0.4), inSoulValley);
|
||||
vec3 fireSpecialLightColor = mix(vec3(2.0, 0.87, 0.27) * 3.8, vec3(0.5, 1.9, 2.1) * 3.8, inSoulValley);
|
||||
vec4 lavaSpecialLightColor = vec4(mix(vec3(3.0, 0.9, 0.2) * 4.0, vec3(0.5, 1.9, 2.1) * 4.0, inSoulValley), 0.0);
|
||||
vec4 brewingStandSpecialLightColor = vec4(mix(vec3(2.5, 1.2, 0.4) * 0.1, vec3(0.5, 1.9, 2.1) * 0.1, inSoulValley), 0.1);
|
||||
#elif defined PURPLE_END_FIRE_INTERNAL
|
||||
#ifdef SPOOKY
|
||||
vec3 blocklightCol = vec3(0.2, 0.1098, 0.0431) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B);
|
||||
#else
|
||||
vec3 blocklightCol = vec3(0.1775, 0.108, 0.0775) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B);
|
||||
#endif
|
||||
vec3 fireSpecialLightColor = vec3(0.6, 0.3, 2.4) * 3.8;
|
||||
vec3 fireSpecialLightColorGradient = mix(vec3(2.0, 0.77, 0.17) * 3.8, fireSpecialLightColor, clamp01(0.7 + max(0.0, clamp01(sin(pow2(texture2D(noisetex, vec2(frameTimeCounter * 0.01)).r))))));
|
||||
vec3 torchBlockSpecialLightColor = mix(vec3(2.0, 0.87, 0.27), fireSpecialLightColor, 0.75);
|
||||
vec3 lanternBlockSpecialLightColor = fireSpecialLightColor;
|
||||
vec4 lavaSpecialLightColor = vec4(vec3(1.0, 0.5, 4.0) * 4.0, 0.5);
|
||||
vec4 brewingStandSpecialLightColor = vec4(vec3(0.10, 0.05, 0.4) * 0.4, 0.1);
|
||||
#else
|
||||
#ifdef SPOOKY
|
||||
vec3 blocklightCol = vec3(0.2, 0.1098, 0.0431) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B);
|
||||
#else
|
||||
vec3 blocklightCol = vec3(0.1775, 0.108, 0.0775) * vec3(XLIGHT_R, XLIGHT_G, XLIGHT_B);
|
||||
#endif
|
||||
vec3 fireSpecialLightColor = vec3(2.0, 0.87, 0.27) * 3.8;
|
||||
vec3 fireSpecialLightColorGradient = fireSpecialLightColor;
|
||||
vec3 torchBlockSpecialLightColor = fireSpecialLightColor;
|
||||
vec3 lanternBlockSpecialLightColor = fireSpecialLightColor;
|
||||
vec4 lavaSpecialLightColor = vec4(vec3(3.0, 0.9, 0.2) * 4.0, 0.0);
|
||||
vec4 brewingStandSpecialLightColor = vec4(vec3(2.5, 1.2, 0.4) * 0.1, 0.1);
|
||||
#endif
|
||||
#if defined NETHER && defined BIOME_COLORED_NETHER_PORTALS
|
||||
vec3 netherPortalSpecialLightColor = normalize(netherColor) * 2.0;
|
||||
vec3 respawnAnchorSpecialLightColor = normalize(netherColor) * 2.0;
|
||||
#else
|
||||
vec3 netherPortalSpecialLightColor = vec3(1.8, 0.4, 2.2) * 0.8;
|
||||
vec3 respawnAnchorSpecialLightColor = vec3(1.7, 0.9, 0.4) * 2.0;
|
||||
#endif
|
||||
vec3 redstoneSpecialLightColor = vec3(4.0, 0.1, 0.1);
|
||||
vec4 soulFireSpecialColor = vec4(vec3(0.3, 2.0, 2.2) * 1.0, 0.3);
|
||||
float candleColorMult = 2.0;
|
||||
float candleExtraLight = 0.004;
|
||||
#if END_ROD_COLOR_PROFILE == 1
|
||||
vec3 endRodSpacialColor = vec3(END_ROD_R, END_ROD_G, END_ROD_B) / 255 * END_ROD_I;
|
||||
#elif (END_ROD_COLOR_PROFILE == 2 || (END_ROD_COLOR_PROFILE == 3 && defined OVERWORLD)) && COLORED_LIGHTING_INTERNAL > 0
|
||||
vec3 endRodSpacialColor = vec3(pow2(getRainbowColor(vec2(0.0), float(END_ROD_RAINBOW_ANIMATE))));
|
||||
#else
|
||||
#ifdef END
|
||||
vec3 endRodSpacialColor = vec3(1.25, 0.5, 1.25); // End Rod in the End dimension
|
||||
#else
|
||||
vec3 endRodSpacialColor = vec3(1.0, 1.0, 1.0);
|
||||
#endif
|
||||
#endif
|
||||
#ifdef EMISSIVE_ENCHANTING_TABLE
|
||||
vec3 enchantingTableSpecialLightColor = vec3(0.5, 2.0, 2.0) * 0.4;
|
||||
#else
|
||||
vec3 enchantingTableSpecialLightColor = vec3(1.4, 1.1, 0.5);
|
||||
#endif
|
||||
void AddSpecialLightDetail(inout vec3 light, vec3 albedo, float emission) {
|
||||
vec3 lightM = max(light, vec3(0.0));
|
||||
lightM /= (0.2 + 0.8 * GetLuminance(lightM));
|
||||
lightM *= (1.0 / (1.0 + emission)) * 0.22;
|
||||
light *= 0.9;
|
||||
light += pow2(lightM / (albedo + 0.1));
|
||||
}
|
||||
vec4 GetSpecialBlocklightColor(int mat) {
|
||||
/* Please note that these colors do not determine the intensity of the
|
||||
final light. Instead; higher values of color change how long the color
|
||||
will travel, and also how dominant it will be next to other colors.*/
|
||||
/* Additional feature: An alpha value bigger than 0 will make that
|
||||
block cast extra light regardless of the vanilla lightmap. Use this
|
||||
with caution though because our floodfill isn't as accurate as vanilla.*/
|
||||
|
||||
if (mat < 50) {
|
||||
if (mat < 26) {
|
||||
if (mat < 14) {
|
||||
if (mat < 8) {
|
||||
if (mat == 2) return vec4(torchBlockSpecialLightColor, 0.0); // Torch
|
||||
if (mat == 3) return vec4(endRodSpacialColor * 4.0, 0.0); // End Rod - This is the base for all lights. Total value 12. vec3(1.0, 1.0, 1.0) * 4.0
|
||||
if (mat == 4) return vec4(vec3(1.0, 1.5, 2.0) * 3.0, 0.0); // Beacon
|
||||
if (mat == 5) return vec4(fireSpecialLightColorGradient, 0.0); // Fire
|
||||
if (mat == 6) return vec4(vec3(0.7, 1.5, 1.5) * 1.7, 0.0); // Sea Pickle:Waterlogged
|
||||
if (mat == 7) return vec4(pow(vec3(1.1, 0.85, 0.35), vec3(FROGLIGHT_SATURATION * 0.5 + 0.5)) * 5.0, 0.0); // Ochre Froglight
|
||||
} else {
|
||||
if (mat == 8) return vec4(pow(vec3(0.6, 1.3, 0.6), vec3(FROGLIGHT_SATURATION * 0.5 + 0.5)) * 4.5, 0.0); // Verdant Froglight
|
||||
if (mat == 9) return vec4(pow(vec3(1.1, 0.5, 0.9), vec3(FROGLIGHT_SATURATION * 0.5 + 0.5)) * 4.5, 0.0); // Pearlescent Froglight
|
||||
if (mat == 10) return vec4(vec3(1.7, 0.9, 0.4) * 4.0, 0.0); // Glowstone
|
||||
if (mat == 11) return vec4(fireSpecialLightColor, 0.0); // Jack o'Lantern
|
||||
if (mat == 12) return vec4(lanternBlockSpecialLightColor, 0.0); // Lantern
|
||||
if (mat == 13) return lavaSpecialLightColor; // Lava
|
||||
}
|
||||
} else {
|
||||
if (mat < 20) {
|
||||
if (mat == 14) return vec4(lavaSpecialLightColor.rgb, 0.0); // Lava Cauldron
|
||||
if (mat == 15) return vec4(fireSpecialLightColorGradient, 0.0); // Campfire:Lit
|
||||
if (mat == 16) return vec4(vec3(1.7, 0.9, 0.4) * 4.0, 0.0); // Redstone Lamp:Lit
|
||||
if (mat == 17) return vec4(respawnAnchorSpecialLightColor, 0.0); // Respawn Anchor:Lit
|
||||
if (mat == 18) return vec4(vec3(1.0, 1.25, 1.5) * 3.4, 0.0); // Sea Lantern
|
||||
if (mat == 19) return vec4(vec3(3.0, 0.9, 0.2) * 3.0, 0.0); // Shroomlight
|
||||
} else {
|
||||
if (mat == 20) return vec4(vec3(2.3, 0.9, 0.2) * 3.4, 0.0); // Cave Vines:With Glow Berries
|
||||
if (mat == 21) return vec4(fireSpecialLightColor * 0.7, 0.0); // Furnace:Lit
|
||||
if (mat == 22) return vec4(fireSpecialLightColor * 0.7, 0.0); // Smoker:Lit
|
||||
if (mat == 23) return vec4(fireSpecialLightColor * 0.7, 0.0); // Blast Furnace:Lit
|
||||
if (mat == 24) return vec4(fireSpecialLightColor * 0.25 * candleColorMult, candleExtraLight); // Standard Candles:Lit
|
||||
if (mat == 25) return vec4(netherPortalSpecialLightColor * 2.0, 0.4); // Nether Portal
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 38) {
|
||||
if (mat < 32) {
|
||||
if (mat == 26) return vec4(netherPortalSpecialLightColor, 0.0); // Crying Obsidian
|
||||
if (mat == 27) return soulFireSpecialColor; // Soul Fire
|
||||
if (mat == 28) return soulFireSpecialColor; // Soul Torch
|
||||
if (mat == 29) return soulFireSpecialColor; // Soul Lantern
|
||||
if (mat == 30) return soulFireSpecialColor; // Soul Campfire:Lit
|
||||
if (mat == 31) return vec4(redstoneSpecialLightColor * 0.5, 0.1); // Redstone Ores:Lit
|
||||
} else {
|
||||
if (mat == 32) return vec4(redstoneSpecialLightColor * 0.3, 0.1); // Redstone Ores:Unlit
|
||||
if (mat == 33) return vec4(enchantingTableSpecialLightColor, 0.0); // Enchanting Table
|
||||
#if GLOWING_LICHEN > 0
|
||||
if (mat == 34) return vec4(vec3(0.8, 1.1, 1.1), 0.05); // Glow Lichen with IntegratedPBR
|
||||
#else
|
||||
if (mat == 34) return vec4(vec3(0.4, 0.55, 0.55), 0.0); // Glow Lichen vanilla
|
||||
#endif
|
||||
if (mat == 35) return vec4(redstoneSpecialLightColor * 0.25, 0.0); // Redstone Torch
|
||||
if (mat == 36) return vec4(vec3(0.325, 0.15, 0.425) * 2.0, 0.05); // Amethyst Cluster, Amethyst Buds, Calibrated Sculk Sensor
|
||||
if (mat == 37) return vec4(lavaSpecialLightColor.rgb * 0.1, 0.1); // Magma Block
|
||||
}
|
||||
} else {
|
||||
if (mat < 44) {
|
||||
#ifdef EMISSIVE_DRAGON_EGG
|
||||
if (mat == 38) return vec4(vec3(2.0, 0.5, 1.5) * 0.3, 0.1); // Dragon Egg
|
||||
#endif
|
||||
if (mat == 39) return vec4(vec3(2.0, 1.0, 1.5) * 0.25, 0.1); // Chorus Flower
|
||||
if (mat == 40) return brewingStandSpecialLightColor; // Brewing Stand
|
||||
if (mat == 41) return vec4(redstoneSpecialLightColor * 0.4, 0.15); // Redstone Block
|
||||
if (mat == 42) return vec4(vec3(0.75, 0.75, 3.0) * 0.277, 0.15); // Lapis Block
|
||||
if (mat == 43) return vec4(vec3(1.7, 0.9, 0.4) * 0.45, 0.05); // Iron Ores
|
||||
} else {
|
||||
if (mat == 44) return vec4(vec3(1.7, 1.1, 0.2) * 0.45, 0.1); // Gold Ores
|
||||
if (mat == 45) return vec4(vec3(1.7, 0.8, 0.4) * 0.45, 0.05); // Copper Ores
|
||||
if (mat == 46) return vec4(vec3(0.75, 0.75, 3.0) * 0.2, 0.1); // Lapis Ores
|
||||
if (mat == 47) return vec4(vec3(0.5, 3.5, 0.5) * 0.3, 0.1); // Emerald Ores
|
||||
if (mat == 48) return vec4(vec3(0.5, 2.0, 2.0) * 0.4, 0.15); // Diamond Ores
|
||||
if (mat == 49) return vec4(vec3(1.5, 1.5, 1.5) * 0.3, 0.05); // Nether Quartz Ore
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 74) {
|
||||
if (mat < 62) {
|
||||
if (mat < 56) {
|
||||
if (mat == 50) return vec4(vec3(1.7, 1.1, 0.2) * 0.45, 0.05); // Nether Gold Ore
|
||||
if (mat == 51) return vec4(vec3(1.7, 1.1, 0.2) * 0.45, 0.05); // Gilded Blackstone
|
||||
if (mat == 52) return vec4(vec3(1.8, 0.8, 0.4) * 0.6, 0.15); // Ancient Debris
|
||||
if (mat == 53) return vec4(vec3(1.4, 0.2, 1.4) * 0.3, 0.05); // Spawner
|
||||
if (mat == 54) return vec4(vec3(3.1, 1.1, 0.3) * 1.0, 0.1); // Trial Spawner:NotOminous:Active, Vault:NotOminous:Active
|
||||
if (mat == 55) return vec4(vec3(1.7, 0.9, 0.4) * 4.0, 0.0); // Copper Bulb:BrighterOnes:Lit
|
||||
} else {
|
||||
if (mat == 56) return vec4(vec3(1.7, 0.9, 0.4) * 2.0, 0.0); // Copper Bulb:DimmerOnes:Lit
|
||||
if (mat == 57) return vec4(vec3(0.1, 0.3, 0.4) * 0.5, 0.0005); // Sculk++
|
||||
if (mat == 58) return vec4(vec3(0.0, 1.4, 1.4) * 4.0, 0.15); // End Portal Frame:Active
|
||||
if (mat == 59) return vec4(0.0); // Bedrock
|
||||
if (mat == 60) return vec4(vec3(3.1, 1.1, 0.3) * 0.125, 0.0125); // Command Block
|
||||
if (mat == 61) return vec4(vec3(3.0, 0.9, 0.2) * 0.125, 0.0125); // Warped Fungus, Crimson Fungus
|
||||
}
|
||||
} else {
|
||||
if (mat < 68) {
|
||||
if (mat == 62) return vec4(vec3(3.5, 0.6, 0.4) * 0.3, 0.05); // Crimson Stem, Crimson Hyphae
|
||||
if (mat == 63) return vec4(vec3(0.3, 1.9, 1.5) * 0.3, 0.05); // Warped Stem, Warped Hyphae
|
||||
if (mat == 64) return vec4(vec3(1.1, 0.7, 1.1) * 0.45, 0.1); // Structure Block, Jigsaw Block
|
||||
if (mat == 65) return vec4(vec3(3.0, 0.9, 0.2) * 0.125, 0.0125); // Weeping Vines Plant
|
||||
if (mat == 66) return vec4(redstoneSpecialLightColor * 0.05, 0.002); // Redstone Wire:Lit, Comparator:Unlit:Subtract
|
||||
if (mat == 67) return vec4(redstoneSpecialLightColor * 0.125, 0.0125); // Repeater:Lit, Comparator:Lit
|
||||
} else {
|
||||
if (mat == 68) return vec4(vec3(0.75), 0.0); // Vault:Inactive
|
||||
if (mat == 69) return vec4(vec3(1.3, 1.6, 1.6) * 1.0, 0.1); // Trial Spawner:Ominous:Active, Vault:Ominous:Active
|
||||
if (mat == 70) return vec4(vec3(1.0, 0.1, 0.1) * candleColorMult, candleExtraLight); // Red Candles:Lit
|
||||
if (mat == 71) return vec4(vec3(1.0, 0.4, 0.1) * candleColorMult, candleExtraLight); // Orange Candles:Lit
|
||||
if (mat == 72) return vec4(vec3(1.0, 1.0, 0.1) * candleColorMult, candleExtraLight); // Yellow Candles:Lit
|
||||
if (mat == 73) return vec4(vec3(0.1, 1.0, 0.1) * candleColorMult, candleExtraLight); // Lime Candles:Lit
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 86) {
|
||||
if (mat < 80) {
|
||||
if (mat == 74) return vec4(vec3(0.3, 1.0, 0.3) * candleColorMult, candleExtraLight); // Green Candles:Lit
|
||||
if (mat == 75) return vec4(vec3(0.3, 0.8, 1.0) * candleColorMult, candleExtraLight); // Cyan Candles:Lit
|
||||
if (mat == 76) return vec4(vec3(0.5, 0.65, 1.0) * candleColorMult, candleExtraLight); // Light Blue Candles:Lit
|
||||
if (mat == 77) return vec4(vec3(0.1, 0.15, 1.0) * candleColorMult, candleExtraLight); // Blue Candles:Lit
|
||||
if (mat == 78) return vec4(vec3(0.7, 0.3, 1.0) * candleColorMult, candleExtraLight); // Purple Candles:Lit
|
||||
if (mat == 79) return vec4(vec3(1.0, 0.1, 1.0) * candleColorMult, candleExtraLight); // Magenta Candles:Lit
|
||||
} else {
|
||||
if (mat == 80) return vec4(vec3(1.0, 0.4, 1.0) * candleColorMult, candleExtraLight); // Pink Candles:Lit
|
||||
if (mat == 81) return vec4(vec3(2.8, 1.1, 0.2) * 0.125, 0.0125); // Open Eyeblossom
|
||||
if (mat == 82) return vec4(vec3(2.8, 1.1, 0.2) * 0.3, 0.05); // Creaking Heart: Active
|
||||
if (mat == 83) return vec4(0.0);
|
||||
if (mat == 84) return vec4(0.0);
|
||||
if (mat == 85) return vec4(0.0);
|
||||
}
|
||||
} else {
|
||||
if (mat < 92) {
|
||||
if (mat == 86) return vec4(0.0);
|
||||
if (mat == 87) return vec4(0.0);
|
||||
if (mat == 88) return vec4(0.0);
|
||||
if (mat == 89) return vec4(0.0);
|
||||
if (mat == 90) return vec4(0.0);
|
||||
if (mat == 91) return vec4(0.0);
|
||||
} else {
|
||||
if (mat == 92) return vec4(0.0);
|
||||
if (mat == 93) return vec4(0.0);
|
||||
if (mat == 94) return vec4(0.0);
|
||||
if (mat == 95) return vec4(0.0);
|
||||
if (mat == 96) return vec4(0.0);
|
||||
if (mat == 97) return vec4(vec3(1.0, 1.0, 1.0) * 4.0, candleExtraLight); // Modded White Light Source
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return vec4(blocklightCol * 20.0, 0.0);
|
||||
}
|
||||
|
||||
vec3[] specialTintColor = vec3[](
|
||||
// 200: White
|
||||
vec3(1.0),
|
||||
// 201: Orange
|
||||
vec3(1.0, 0.3, 0.1),
|
||||
// 202: Magenta
|
||||
vec3(1.0, 0.1, 1.0),
|
||||
// 203: Light Blue
|
||||
vec3(0.5, 0.65, 1.0),
|
||||
// 204: Yellow
|
||||
vec3(1.0, 1.0, 0.1),
|
||||
// 205: Lime
|
||||
vec3(0.1, 1.0, 0.1),
|
||||
// 206: Pink
|
||||
vec3(1.0, 0.4, 1.0),
|
||||
// 207: Gray
|
||||
vec3(1.0),
|
||||
// 208: Light Gray
|
||||
vec3(1.0),
|
||||
// 209: Cyan
|
||||
vec3(0.3, 0.8, 1.0),
|
||||
// 210: Purple
|
||||
vec3(0.7, 0.3, 1.0),
|
||||
// 211: Blue
|
||||
vec3(0.1, 0.15, 1.0),
|
||||
// 212: Brown
|
||||
vec3(1.0, 0.75, 0.5),
|
||||
// 213: Green
|
||||
vec3(0.3, 1.0, 0.3),
|
||||
// 214: Red
|
||||
vec3(1.0, 0.1, 0.1),
|
||||
// 215: Black
|
||||
vec3(1.0),
|
||||
// 216: Ice
|
||||
vec3(0.5, 0.65, 1.0),
|
||||
// 217: Glass
|
||||
vec3(1.0),
|
||||
// 218: Glass Pane
|
||||
vec3(1.0),
|
||||
// 219++
|
||||
vec3(0.0)
|
||||
);
|
||||
@ -0,0 +1,3 @@
|
||||
vec3 cloudRainColor = mix(nightMiddleSkyColor, dayMiddleSkyColor, sunFactor);
|
||||
vec3 cloudAmbientColor = mix(ambientColor * (sunVisibility2 * (0.55 + 0.1 * noonFactor) + 0.35), cloudRainColor * 0.5, rainFactor);
|
||||
vec3 cloudLightColor = mix(lightColor * (0.9 + 0.2 * noonFactor), cloudRainColor * 0.25, noonFactor * rainFactor);
|
||||
@ -0,0 +1,80 @@
|
||||
#ifndef INCLUDE_LIGHT_AND_AMBIENT_MULTIPLIERS
|
||||
#define INCLUDE_LIGHT_AND_AMBIENT_MULTIPLIERS
|
||||
|
||||
vec3 GetLightColorMult() {
|
||||
vec3 lightColorMult;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 morningLightMult = vec3(LIGHT_MORNING_R, LIGHT_MORNING_G, LIGHT_MORNING_B) * LIGHT_MORNING_I;
|
||||
vec3 noonLightMult = vec3(LIGHT_NOON_R, LIGHT_NOON_G, LIGHT_NOON_B) * LIGHT_NOON_I;
|
||||
vec3 nightLightMult = vec3(LIGHT_NIGHT_R, LIGHT_NIGHT_G, LIGHT_NIGHT_B) * LIGHT_NIGHT_I;
|
||||
vec3 rainLightMult = vec3(LIGHT_RAIN_R, LIGHT_RAIN_G, LIGHT_RAIN_B) * LIGHT_RAIN_I;
|
||||
|
||||
lightColorMult = mix(noonLightMult, morningLightMult, invNoonFactor2);
|
||||
lightColorMult = mix(nightLightMult, lightColorMult, sunVisibility2);
|
||||
lightColorMult = mix(lightColorMult, dot(lightColorMult, vec3(0.33333)) * rainLightMult, rainFactor);
|
||||
#elif defined NETHER
|
||||
vec3 netherLightMult = vec3(LIGHT_NETHER_R, LIGHT_NETHER_G, LIGHT_NETHER_B) * LIGHT_NETHER_I;
|
||||
|
||||
lightColorMult = netherLightMult;
|
||||
#elif defined END
|
||||
vec3 endLightMult = vec3(LIGHT_END_R, LIGHT_END_G, LIGHT_END_B) * LIGHT_END_I;
|
||||
|
||||
lightColorMult = endLightMult;
|
||||
#endif
|
||||
|
||||
#ifdef COLOR_MULTIPLIER_COMPARISON
|
||||
return gl_FragCoord.x < mix(0.5, 0.0, isSneaking) * viewWidth ? vec3(1.0) : lightColorMult;
|
||||
#else
|
||||
return lightColorMult;
|
||||
#endif
|
||||
}
|
||||
|
||||
vec3 GetAtmColorMult() {
|
||||
vec3 atmColorMult;
|
||||
|
||||
float spookyIntensityNight = 1.0;
|
||||
float spookyIntensityRain = 1.0;
|
||||
float spookyIntensityNether = 1.0;
|
||||
float spookyIntensityEnd = 1.0;
|
||||
#ifdef SPOOKY
|
||||
spookyIntensityNight = 0.5;
|
||||
spookyIntensityRain = 0.75;
|
||||
spookyIntensityNether = 0.3;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
vec3 morningAtmMult = vec3(ATM_MORNING_R, ATM_MORNING_G, ATM_MORNING_B) * ATM_MORNING_I;
|
||||
vec3 noonAtmMult = vec3(ATM_NOON_R, ATM_NOON_G, ATM_NOON_B) * ATM_NOON_I;
|
||||
vec3 nightAtmMult = vec3(ATM_NIGHT_R, ATM_NIGHT_G, ATM_NIGHT_B) * ATM_NIGHT_I * spookyIntensityNight;
|
||||
vec3 rainAtmMult = vec3(ATM_RAIN_R, ATM_RAIN_G, ATM_RAIN_B) * ATM_RAIN_I * spookyIntensityRain;
|
||||
|
||||
atmColorMult = mix(noonAtmMult, morningAtmMult, invNoonFactor2);
|
||||
atmColorMult = mix(nightAtmMult, atmColorMult, sunVisibility2);
|
||||
atmColorMult = mix(atmColorMult, dot(atmColorMult, vec3(0.33333)) * rainAtmMult, rainFactor);
|
||||
#elif defined NETHER
|
||||
vec3 netherAtmMult = vec3(ATM_NETHER_R, ATM_NETHER_G, ATM_NETHER_B) * ATM_NETHER_I;
|
||||
|
||||
atmColorMult = netherAtmMult;
|
||||
#elif defined END
|
||||
vec3 endAtmMult = vec3(ATM_END_R, ATM_END_G, ATM_END_B) * ATM_END_I;
|
||||
|
||||
atmColorMult = endAtmMult;
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
return atmColorMult;
|
||||
#else
|
||||
#ifdef COLOR_MULTIPLIER_COMPARISON
|
||||
return gl_FragCoord.x < mix(0.5, 0.0, isSneaking) * viewWidth ? vec3(1.0) : atmColorMult;
|
||||
#else
|
||||
return atmColorMult;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
vec3 lightColorMult;
|
||||
vec3 atmColorMult;
|
||||
vec3 sqrtAtmColorMult;
|
||||
|
||||
#endif //INCLUDE_LIGHT_AND_AMBIENT_MULTIPLIERS
|
||||
@ -0,0 +1,106 @@
|
||||
#ifndef INCLUDE_LIGHT_AND_AMBIENT_COLORS
|
||||
#define INCLUDE_LIGHT_AND_AMBIENT_COLORS
|
||||
|
||||
#if defined OVERWORLD
|
||||
#ifndef COMPOSITE
|
||||
vec3 noonClearLightColor = vec3(0.7, 0.55, 0.4) * 1.9; //ground and cloud color
|
||||
#else
|
||||
vec3 noonClearLightColor = vec3(0.4, 0.7, 1.4); //light shaft color
|
||||
#endif
|
||||
vec3 noonClearAmbientColor = pow(skyColor, vec3(0.65)) * 0.85;
|
||||
|
||||
#ifndef COMPOSITE
|
||||
vec3 sunsetClearLightColor = pow(vec3(0.64, 0.45, 0.3), vec3(1.5 + invNoonFactor)) * 5.0; //ground and cloud color
|
||||
#else
|
||||
vec3 sunsetClearLightColor = pow(vec3(0.62, 0.39, 0.24), vec3(1.5 + invNoonFactor)) * 6.8; //light shaft color
|
||||
#endif
|
||||
vec3 sunsetClearAmbientColor = noonClearAmbientColor * vec3(1.21, 0.92, 0.76) * 0.95;
|
||||
|
||||
#if !defined COMPOSITE && !defined DEFERRED1
|
||||
vec3 nightClearLightColor = vec3(0.15, 0.14, 0.20) * (0.4 + vsBrightness * 0.4); //ground color
|
||||
#elif defined DEFERRED1
|
||||
vec3 nightClearLightColor = vec3(0.11, 0.14, 0.20); //cloud color
|
||||
#else
|
||||
vec3 nightClearLightColor = vec3(0.07, 0.12, 0.27); //light shaft color
|
||||
#endif
|
||||
vec3 nightClearAmbientColor = vec3(0.09, 0.12, 0.17) * (1.55 + vsBrightness * 0.77);
|
||||
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
vec3 drlcSnowM = inSnowy * vec3(-0.06, 0.0, 0.04);
|
||||
vec3 drlcDryM = inDry * vec3(0.0, -0.03, -0.05);
|
||||
#else
|
||||
vec3 drlcSnowM = vec3(0.0), drlcDryM = vec3(0.0);
|
||||
#endif
|
||||
#if RAIN_STYLE == 2
|
||||
vec3 drlcRainMP = vec3(-0.03, 0.0, 0.02);
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
vec3 drlcRainM = inRainy * drlcRainMP;
|
||||
#else
|
||||
vec3 drlcRainM = drlcRainMP;
|
||||
#endif
|
||||
#else
|
||||
vec3 drlcRainM = vec3(0.0);
|
||||
#endif
|
||||
vec3 dayRainLightColor = vec3(0.21, 0.16, 0.13) * 0.85 + noonFactor * vec3(0.0, 0.02, 0.06)
|
||||
+ rainFactor * (drlcRainM + drlcSnowM + drlcDryM);
|
||||
vec3 dayRainAmbientColor = vec3(0.2, 0.2, 0.25) * (1.8 + 0.5 * vsBrightness);
|
||||
|
||||
vec3 nightRainLightColor = vec3(0.03, 0.035, 0.05) * (0.5 + 0.5 * vsBrightness);
|
||||
vec3 nightRainAmbientColor = vec3(0.16, 0.20, 0.3) * (0.75 + 0.6 * vsBrightness);
|
||||
#ifndef COMPOSITE
|
||||
float noonFactorDM = noonFactor; //ground and cloud factor
|
||||
#else
|
||||
float noonFactorDM = noonFactor * noonFactor; //light shaft factor
|
||||
#endif
|
||||
vec3 dayLightColor = mix(sunsetClearLightColor, noonClearLightColor, noonFactorDM);
|
||||
vec3 dayAmbientColor = mix(sunsetClearAmbientColor, noonClearAmbientColor, noonFactorDM);
|
||||
|
||||
vec3 clearLightColor = mix(nightClearLightColor, dayLightColor, sunVisibility2);
|
||||
vec3 clearAmbientColor = mix(nightClearAmbientColor, dayAmbientColor, sunVisibility2);
|
||||
|
||||
vec3 rainLightColor = mix(nightRainLightColor, dayRainLightColor, sunVisibility2) * 2.5;
|
||||
vec3 rainAmbientColor = mix(nightRainAmbientColor, dayRainAmbientColor, sunVisibility2);
|
||||
#ifdef SPOOKY
|
||||
vec3 lightColor = mix(clearLightColor, rainLightColor, rainFactor) * 0.4;
|
||||
#else
|
||||
vec3 lightColor = mix(clearLightColor, rainLightColor, rainFactor);
|
||||
#endif
|
||||
#ifdef SPOOKY
|
||||
vec3 ambientColor = mix(clearAmbientColor, rainAmbientColor, rainFactor) * 0.4;
|
||||
#elif SILHOUETTE == 0
|
||||
vec3 ambientColor = mix(clearAmbientColor, rainAmbientColor, rainFactor);
|
||||
#elif SILHOUETTE == 1
|
||||
vec3 ambientColor = mix(clearAmbientColor, rainAmbientColor, rainFactor) * mix(SILHOUETTE_BRIGHTNESS, 1.0, sunVisibility);
|
||||
#else
|
||||
vec3 ambientColor = mix(clearAmbientColor, rainAmbientColor, rainFactor) * SILHOUETTE_BRIGHTNESS;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD_BEAMS
|
||||
vec3 ambientColorBeam = mix(clearAmbientColor, rainAmbientColor, rainFactor);
|
||||
vec3 ColorBeam = mix(ambientColorBeam, vec3(OW_BEAM_R, OW_BEAM_G, OW_BEAM_B) / 255, BEAMS_AMBIENT_INFLUENCE);
|
||||
#else
|
||||
vec3 ColorBeam = vec3(0.0);
|
||||
#endif
|
||||
#elif defined NETHER
|
||||
vec3 lightColor = vec3(0.0);
|
||||
#ifdef SPOOKY
|
||||
vec3 ambientColor = (netherColor + 0.5 * lavaLightColor) * (0.9 + 0.45 * vsBrightness) * 0.4;
|
||||
#else
|
||||
vec3 ambientColor = (netherColor + 0.5 * lavaLightColor) * (0.9 + 0.45 * vsBrightness);
|
||||
#endif
|
||||
#elif defined END
|
||||
float fogLuminance = dot(fogColor, vec3(0.299, 0.587, 0.114));
|
||||
vec3 endLightColor = clamp01(mix(fogColor * 0.6 + 0.3 * normalize(fogColor + 0.0001) + 0.25 * (1.0 - fogLuminance), vec3(0.68, 0.51, 1.07), inVanillaEnd));
|
||||
float endLightBalancer = 0.2 * vsBrightness;
|
||||
#ifdef SPOOKY
|
||||
vec3 lightColor = endLightColor * (0.35 - endLightBalancer) * 0.4;
|
||||
vec3 ambientCol = endLightColor * (0.2 + endLightBalancer) * 0.4;
|
||||
#else
|
||||
vec3 lightColor = endLightColor * (0.35 - endLightBalancer);
|
||||
vec3 ambientCol = endLightColor * (0.2 + endLightBalancer);
|
||||
#endif
|
||||
vec3 ambientColor = mix(ambientCol, vec3(END_AMBIENT_R, END_AMBIENT_G, END_AMBIENT_B) / 255 * END_AMBIENT_I, END_AMBIENT_INFLUENCE);
|
||||
vec3 endColorBeam = mix(ambientCol, vec3(E_BEAM_R, E_BEAM_G, E_BEAM_B) / 255, E_BEAMS_AMBIENT_INFLUENCE);
|
||||
#endif
|
||||
|
||||
#endif //INCLUDE_LIGHT_AND_AMBIENT_COLORS
|
||||
@ -0,0 +1,13 @@
|
||||
#ifndef INCLUDE_MOON_PHASE_INF
|
||||
#define INCLUDE_MOON_PHASE_INF
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float moonPhaseInfluence = mix(
|
||||
1.0,
|
||||
moonPhase == 0 ? MOON_PHASE_FULL : moonPhase != 4 ? MOON_PHASE_PARTIAL : MOON_PHASE_DARK,
|
||||
1.0 - sunVisibility2
|
||||
);
|
||||
#else
|
||||
float moonPhaseInfluence = 1.0;
|
||||
#endif
|
||||
#endif
|
||||
@ -0,0 +1,59 @@
|
||||
#ifndef INCLUDE_SKY_COLORS
|
||||
#define INCLUDE_SKY_COLORS
|
||||
|
||||
#ifdef OVERWORLD
|
||||
#if defined CLEAR_SKY_WHEN_RAINING || defined NO_RAIN_ABOVE_CLOUDS
|
||||
float rainFactorM = rainFactor * heightRelativeToCloud;
|
||||
#else
|
||||
float rainFactorM = rainFactor;
|
||||
#endif
|
||||
float rainFactorM2 = rainFactorM * rainFactor;
|
||||
|
||||
vec3 skyColorSqrt = sqrt(skyColor);
|
||||
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
vec3 nmscSnowM = inSnowy * vec3(-0.3, 0.05, 0.2);
|
||||
vec3 nmscDryM = inDry * vec3(-0.3);
|
||||
vec3 ndscSnowM = inSnowy * vec3(-0.25, -0.01, 0.25);
|
||||
vec3 ndscDryM = inDry * vec3(-0.05, -0.09, -0.1);
|
||||
#else
|
||||
vec3 nmscSnowM = vec3(0.0), nmscDryM = vec3(0.0), ndscSnowM = vec3(0.0), ndscDryM = vec3(0.0);
|
||||
#endif
|
||||
#if RAIN_STYLE == 2
|
||||
vec3 nmscRainMP = vec3(-0.15, 0.025, 0.1);
|
||||
vec3 ndscRainMP = vec3(-0.125, -0.005, 0.125);
|
||||
#ifdef SPECIAL_BIOME_WEATHER
|
||||
vec3 nmscRainM = inRainy * ndscRainMP;
|
||||
vec3 ndscRainM = inRainy * ndscRainMP;
|
||||
#else
|
||||
vec3 nmscRainM = ndscRainMP;
|
||||
vec3 ndscRainM = ndscRainMP;
|
||||
#endif
|
||||
#else
|
||||
vec3 nmscRainM = vec3(0.0), ndscRainM = vec3(0.0);
|
||||
#endif
|
||||
vec3 nmscWeatherM = vec3(-0.1, -0.4, -0.6) + vec3(0.0, 0.06, 0.12) * noonFactor;
|
||||
vec3 ndscWeatherM = vec3(-0.15, -0.3, -0.42) + vec3(0.0, 0.02, 0.08) * noonFactor;
|
||||
|
||||
vec3 noonUpSkyColor = pow(skyColorSqrt, vec3(2.9));
|
||||
vec3 noonMiddleSkyColor = skyColorSqrt * (vec3(1.15) + rainFactorM * (nmscWeatherM + nmscRainM + nmscSnowM + nmscDryM))
|
||||
+ noonUpSkyColor * 0.6;
|
||||
vec3 noonDownSkyColor = skyColorSqrt * (vec3(0.9) + rainFactorM * (ndscWeatherM + ndscRainM + ndscSnowM + ndscDryM))
|
||||
+ noonUpSkyColor * 0.25;
|
||||
|
||||
vec3 sunsetUpSkyColor = skyColor * (vec3(0.8, 0.58, 0.58) + vec3(0.1, 0.2, 0.35) * rainFactorM2);
|
||||
vec3 sunsetMiddleSkyColor = skyColor * (vec3(1.8, 1.3, 1.2) + vec3(0.15, 0.25, -0.05) * rainFactorM2);
|
||||
vec3 sunsetDownSkyColorP = vec3(1.45, 0.86, 0.5) - vec3(0.8, 0.3, 0.0) * rainFactorM;
|
||||
vec3 sunsetDownSkyColor = sunsetDownSkyColorP * 0.5 + 0.25 * sunsetMiddleSkyColor;
|
||||
|
||||
vec3 dayUpSkyColor = mix(noonUpSkyColor, sunsetUpSkyColor, invNoonFactor2);
|
||||
vec3 dayMiddleSkyColor = mix(noonMiddleSkyColor, sunsetMiddleSkyColor, invNoonFactor2);
|
||||
vec3 dayDownSkyColor = mix(noonDownSkyColor, sunsetDownSkyColor, invNoonFactor2);
|
||||
|
||||
vec3 nightColFactor = vec3(0.07, 0.14, 0.24) * (1.0 - 0.5 * rainFactorM) + skyColor;
|
||||
vec3 nightUpSkyColor = pow(nightColFactor, vec3(0.90)) * 0.4;
|
||||
vec3 nightMiddleSkyColor = sqrt(nightUpSkyColor) * 0.68;
|
||||
vec3 nightDownSkyColor = nightMiddleSkyColor * vec3(0.82, 0.82, 0.88);
|
||||
#endif
|
||||
|
||||
#endif //INCLUDE_SKY_COLORS
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,32 @@
|
||||
// vec2 Reprojection(vec3 pos) {
|
||||
// pos = pos * 2.0 - 1.0;
|
||||
|
||||
// vec4 viewPosPrev = gbufferProjectionInverse * vec4(pos, 1.0);
|
||||
// viewPosPrev /= viewPosPrev.w;
|
||||
// viewPosPrev = gbufferModelViewInverse * viewPosPrev;
|
||||
|
||||
// vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
// cameraOffset *= float(pos.z > 0.56);
|
||||
|
||||
// vec4 previousPosition = viewPosPrev + vec4(cameraOffset, 0.0);
|
||||
// previousPosition = gbufferPreviousModelView * previousPosition;
|
||||
// previousPosition = gbufferPreviousProjection * previousPosition;
|
||||
// return previousPosition.xy / previousPosition.w * 0.5 + 0.5;
|
||||
// }
|
||||
|
||||
vec3 ApplyMultiColoredBlocklight(vec3 blocklightCol, vec3 screenPos) {
|
||||
vec3 cameraOffset = cameraPosition - previousCameraPosition;
|
||||
cameraOffset *= float(screenPos.z * 2.0 - 1.0 > 0.56);
|
||||
|
||||
if (screenPos.z > 0.56) {
|
||||
screenPos.xy = Reprojection(screenPos, cameraOffset);
|
||||
}
|
||||
vec3 coloredLight = texture2D(colortex9, screenPos.xy).rgb;
|
||||
vec3 coloredLightNormalized = normalize(coloredLight + 0.00001);
|
||||
|
||||
// do luminance correction for a seamless transition from the default blocklight color
|
||||
coloredLightNormalized *= GetLuminance(blocklightCol) / GetLuminance(coloredLightNormalized);
|
||||
|
||||
float coloredLightMix = min1((coloredLight.r + coloredLight.g + coloredLight.b) * 2048);
|
||||
return mix(blocklightCol, coloredLightNormalized, coloredLightMix * MCBL_INFLUENCE);
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
// GGX area light approximation from Horizon Zero Dawn
|
||||
float GetNoHSquared(float radiusTan, float NoL, float NoV, float VoL) {
|
||||
float radiusCos = 1.0 / sqrt(1.0 + radiusTan * radiusTan);
|
||||
|
||||
float RoL = 2.0 * NoL * NoV - VoL;
|
||||
if (RoL >= radiusCos)
|
||||
return 1.0;
|
||||
|
||||
float rOverLengthT = radiusCos * radiusTan / sqrt(1.0 - RoL * RoL);
|
||||
float NoTr = rOverLengthT * (NoV - RoL * NoL);
|
||||
float VoTr = rOverLengthT * (2.0 * NoV * NoV - 1.0 - RoL * VoL);
|
||||
|
||||
float triple = sqrt(clamp(1.0 - NoL * NoL - NoV * NoV - VoL * VoL + 2.0 * NoL * NoV * VoL, 0.0, 1.0));
|
||||
|
||||
float NoBr = rOverLengthT * triple, VoBr = rOverLengthT * (2.0 * triple * NoV);
|
||||
float NoLVTr = NoL * radiusCos + NoV + NoTr, VoLVTr = VoL * radiusCos + 1.0 + VoTr;
|
||||
float p = NoBr * VoLVTr, q = NoLVTr * VoLVTr, s = VoBr * NoLVTr;
|
||||
float xNum = q * (-0.5 * p + 0.25 * VoBr * NoLVTr);
|
||||
float xDenom = p * p + s * ((s - 2.0 * p)) + NoLVTr * ((NoL * radiusCos + NoV) * VoLVTr * VoLVTr +
|
||||
q * (-0.5 * (VoLVTr + VoL * radiusCos) - 0.5));
|
||||
float twoX1 = 2.0 * xNum / (xDenom * xDenom + xNum * xNum);
|
||||
float sinTheta = twoX1 * xDenom;
|
||||
float cosTheta = 1.0 - twoX1 * xNum;
|
||||
NoTr = cosTheta * NoTr + sinTheta * NoBr;
|
||||
VoTr = cosTheta * VoTr + sinTheta * VoBr;
|
||||
|
||||
float newNoL = NoL * radiusCos + NoTr;
|
||||
float newVoL = VoL * radiusCos + VoTr;
|
||||
float NoH = NoV + newNoL;
|
||||
float HoH = 2.0 * newVoL + 2.0;
|
||||
return clamp(NoH * NoH / HoH, 0.0, 1.0);
|
||||
}
|
||||
|
||||
float GGX(vec3 normalM, vec3 viewPos, vec3 lightVec, float NdotLmax0, float smoothnessG) {
|
||||
smoothnessG = sqrt1(smoothnessG * 0.9 + 0.1);
|
||||
float roughnessP = (1.35 - smoothnessG);
|
||||
float roughness = pow2(pow2(roughnessP));
|
||||
|
||||
vec3 halfVec = normalize(lightVec - viewPos);
|
||||
|
||||
float dotLH = clamp(dot(halfVec, lightVec), 0.0, 1.0);
|
||||
float dotNV = dot(normalM, -viewPos);
|
||||
|
||||
#if WATER_REFLECT_QUALITY >= 2
|
||||
float dotNH = GetNoHSquared(0.01, NdotLmax0, dotNV, dot(-viewPos, lightVec));
|
||||
#else
|
||||
float dotNH = pow2(min1(2.0 * NdotLmax0 * dotNV * length(halfVec) - dot(-viewPos, lightVec)));
|
||||
#endif
|
||||
|
||||
float denom = dotNH * roughness - dotNH + 1.0;
|
||||
float D = roughness / (3.141592653589793 * pow2(denom));
|
||||
float f0 = 0.05;
|
||||
float F = exp2((-5.55473 * dotLH - 6.98316) * dotLH) * (1.0 - f0) + f0;
|
||||
|
||||
float NdotLmax0M = sqrt3(NdotLmax0 * max0(dot(normal, lightVec)));
|
||||
float specular = max0(NdotLmax0M * D * F / pow2(dotLH));
|
||||
specular = specular / (0.125 * specular + 1.0);
|
||||
|
||||
return specular;
|
||||
}
|
||||
@ -0,0 +1,754 @@
|
||||
//Lighting Includes//
|
||||
#include "/lib/colors/lightAndAmbientColors.glsl"
|
||||
#include "/lib/lighting/ggx.glsl"
|
||||
|
||||
#if SHADOW_QUALITY > -1 && (defined OVERWORLD || defined END)
|
||||
#include "/lib/lighting/shadowSampling.glsl"
|
||||
#endif
|
||||
|
||||
#if defined CLOUDS_REIMAGINED && defined CLOUD_SHADOWS
|
||||
#include "/lib/atmospherics/clouds/cloudCoord.glsl"
|
||||
#endif
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
|
||||
#if defined MOON_PHASE_INF_LIGHT || defined MOON_PHASE_INF_REFLECTION
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#endif
|
||||
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#define ENDCRYSTAL_SAMPLER_DEFINE
|
||||
uniform isampler2D endcrystal_sampler;
|
||||
#endif
|
||||
|
||||
vec3 highlightColor = normalize(pow(lightColor, vec3(0.37))) * (0.3 + 1.5 * sunVisibility2) * (1.0 - 0.85 * rainFactor);
|
||||
|
||||
//Lighting//
|
||||
void DoLighting(inout vec4 color, inout vec3 shadowMult, vec3 playerPos, vec3 viewPos, float lViewPos, vec3 geoNormal, vec3 normalM,
|
||||
vec3 worldGeoNormal, vec2 lightmap, bool noSmoothLighting, bool noDirectionalShading, bool noVanillaAO,
|
||||
bool centerShadowBias, int subsurfaceMode, float smoothnessG, float highlightMult, float emission, inout float purkinjeOverwrite) {
|
||||
#ifdef SPOOKY
|
||||
lightmap.x *= 0.85;
|
||||
#endif
|
||||
|
||||
vec2 oldLightmap = lightmap.xy;
|
||||
|
||||
#ifdef DO_PIXELATION_EFFECTS
|
||||
vec2 pixelationOffset = ComputeTexelOffset(tex, texCoord);
|
||||
|
||||
#ifdef PIXELATED_SHADOWS
|
||||
vec3 playerPosPixelated = TexelSnap(playerPos, pixelationOffset);
|
||||
#endif
|
||||
#ifdef PIXELATED_BLOCKLIGHT
|
||||
lightmap = clamp(TexelSnap(lightmap, pixelationOffset), 0.0, 1.0);
|
||||
lViewPos = TexelSnap(lViewPos, pixelationOffset);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float lightmapY2 = pow2(lightmap.y);
|
||||
float lightmapYM = smoothstep1(lightmap.y);
|
||||
float subsurfaceHighlight = 0.0;
|
||||
float ambientMult = 1.0;
|
||||
vec3 lightColorM = lightColor;
|
||||
vec3 ambientColorM = ambientColor;
|
||||
vec3 nViewPos = normalize(viewPos);
|
||||
|
||||
#if defined LIGHT_COLOR_MULTS && !defined GBUFFERS_WATER // lightColorMult is defined early in gbuffers_water
|
||||
lightColorMult = GetLightColorMult();
|
||||
#endif
|
||||
vec2 lightningAdd = vec2(0);
|
||||
vec2 deathFlashAdd = vec2(0);
|
||||
vec3 lightningPos = vec3(0);
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
float lightningDistance = 550.0;
|
||||
lightningPos = getLightningPos(playerPos, lightningBoltPosition.xyz, false);
|
||||
float lightningFadeOut = max(1.0 - length(lightningPos) / lightningDistance, 0.0);
|
||||
float lightningFadeOutExp = exp((1.0 - lightningFadeOut) * -15.0);
|
||||
vec3 normalLightning = mat3(gbufferModelViewInverse) * mix(geoNormal, normalM, 0.25);
|
||||
float lightningNormalGradient = 0.12;
|
||||
if (subsurfaceMode == 1) lightningNormalGradient = mix(lightningNormalGradient, 0.45, lightningFadeOutExp);
|
||||
lightningAdd = (lightningFlashEffect(lightningPos, normalLightning, lightningDistance, lightningNormalGradient, subsurfaceMode) * 10.0 + mix(0.1, 0.0 , lightningFadeOut)) * isLightningActive();
|
||||
ambientColorM += lightningAdd.x;
|
||||
#endif
|
||||
#if DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
vec3 dragonPosition = vec3(0, 80, 0) - cameraPosition;
|
||||
int isDying = texelFetch(endcrystal_sampler, ivec2(35, 0), 0).r;
|
||||
float dragonDeathFactor = 0.0001 * isDying;
|
||||
float deathFadeFactor = exp(-3.0 * (1.0 - dragonDeathFactor)) * dragonDeathFactor;
|
||||
|
||||
if (dragonDeathFactor < 0.99) {
|
||||
vec3 normalMDeath = mat3(gbufferModelViewInverse) * mix(geoNormal, normalM, 0.5);
|
||||
vec3 endDragonCol = vec3(E_DRAGON_BEAM_R, E_DRAGON_BEAM_G, E_DRAGON_BEAM_B) / 255.0 * E_DRAGON_BEAM_I;
|
||||
vec3 deathFlashPos = getLightningPos(playerPos, dragonPosition, true);
|
||||
float effectDistance = 800.0;
|
||||
deathFlashAdd = lightningFlashEffect(deathFlashPos, normalMDeath, effectDistance, 0.0, subsurfaceMode) * 35.0 * deathFadeFactor;
|
||||
ambientColorM *= mix(1.0, 0.0, deathFadeFactor) + deathFlashAdd.x * saturateColors(sqrt(endDragonCol), 0.5);
|
||||
purkinjeOverwrite = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SSS_STRENGTH == 0
|
||||
subsurfaceMode = 0;
|
||||
#endif
|
||||
|
||||
#ifdef OVERWORLD
|
||||
float skyLightShadowMult = pow2(pow2(lightmapY2));
|
||||
#else
|
||||
float skyLightShadowMult = 1.0;
|
||||
#endif
|
||||
|
||||
#if defined SIDE_SHADOWING || defined DIRECTIONAL_SHADING
|
||||
float NdotN = dot(normalM, northVec);
|
||||
float absNdotN = abs(NdotN);
|
||||
#endif
|
||||
|
||||
#if defined CUSTOM_PBR || defined GENERATED_NORMALS
|
||||
float NPdotU = abs(dot(geoNormal, upVec));
|
||||
#endif
|
||||
|
||||
// Shadows
|
||||
#if defined OVERWORLD || defined END
|
||||
float NdotL = dot(normalM, lightVec);
|
||||
#ifdef GBUFFERS_WATER
|
||||
//NdotL = mix(NdotL, 1.0, 1.0 - color.a);
|
||||
#endif
|
||||
#ifdef CUSTOM_PBR
|
||||
float geoNdotL = dot(geoNormal, lightVec);
|
||||
float geoNdotLM = geoNdotL > 0.0 ? geoNdotL * 10.0 : geoNdotL;
|
||||
NdotL = min(geoNdotLM, NdotL);
|
||||
|
||||
NdotL *= 1.0 - 0.7 * (1.0 - pow2(pow2(NdotUmax0))) * NPdotU;
|
||||
#endif
|
||||
#if SHADOW_QUALITY == -1 && defined GBUFFERS_TERRAIN || defined DREAM_TWEAKED_LIGHTING
|
||||
if (subsurfaceMode == 1) {
|
||||
NdotU = 1.0;
|
||||
NdotUmax0 = 1.0;
|
||||
NdotL = dot(upVec, lightVec);
|
||||
} else if (subsurfaceMode == 2) {
|
||||
highlightMult *= NdotL;
|
||||
NdotL = mix(NdotL, 1.0, 0.35);
|
||||
}
|
||||
|
||||
subsurfaceMode = 0;
|
||||
#endif
|
||||
float NdotLmax0 = max0(NdotL);
|
||||
float NdotLM = NdotLmax0 * 0.9999;
|
||||
|
||||
#ifdef GBUFFERS_TEXTURED
|
||||
NdotLM = 1.0;
|
||||
#else
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode != 0) {
|
||||
#if defined CUSTOM_PBR && defined POM && POM_QUALITY >= 128 && POM_LIGHTING_MODE == 2
|
||||
shadowMult *= max(pow2(pow2(dot(normalM, geoNormal))), sqrt2(NdotLmax0));
|
||||
#endif
|
||||
NdotLM = 1.0;
|
||||
}
|
||||
#ifdef SIDE_SHADOWING
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
#ifdef SIDE_SHADOWING
|
||||
NdotLM = max0(NdotL + 0.4) * 0.714;
|
||||
|
||||
#ifdef END
|
||||
NdotLM = sqrt3(NdotLM);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if ENTITY_SHADOWS_DEFINE == -1 && (defined GBUFFERS_ENTITIES || defined GBUFFERS_BLOCK)
|
||||
lightColorM = mix(lightColorM * 0.75, ambientColorM, 0.5 * pow2(pow2(1.0 - NdotLM)));
|
||||
NdotLM = NdotLM * 0.75 + 0.25;
|
||||
#endif
|
||||
|
||||
if (shadowMult.r > 0.00001) {
|
||||
#if SHADOW_QUALITY > -1
|
||||
if (NdotLM > 0.0001) {
|
||||
vec3 shadowMultBeforeLighting = shadowMult;
|
||||
float shadowLength = min(shadowDistance, far) * 0.9166667 - lViewPos; //consistent08JJ622
|
||||
|
||||
if (shadowLength > 0.000001) {
|
||||
#if SHADOW_SMOOTHING == 4 || SHADOW_QUALITY == 0
|
||||
float offset = 0.00098;
|
||||
#elif SHADOW_SMOOTHING == 3
|
||||
float offset = 0.00075;
|
||||
#elif SHADOW_SMOOTHING == 2
|
||||
float offset = 0.0005;
|
||||
#elif SHADOW_SMOOTHING == 1
|
||||
float offset = 0.0003;
|
||||
#endif
|
||||
|
||||
vec3 playerPosM = playerPos;
|
||||
|
||||
#if defined DO_PIXELATION_EFFECTS && defined PIXELATED_SHADOWS
|
||||
playerPosM = playerPosPixelated;
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_TEXTURED
|
||||
vec3 centerPlayerPos = floor(playerPos + cameraPosition) - cameraPosition + 0.5;
|
||||
playerPosM = mix(centerPlayerPos, playerPosM + vec3(0.0, 0.02, 0.0), lightmapYM);
|
||||
#else
|
||||
// Shadow bias without peter-panning
|
||||
float distanceBias = pow(dot(playerPos, playerPos), 0.75);
|
||||
distanceBias = 0.12 + 0.0008 * distanceBias;
|
||||
vec3 bias = worldGeoNormal * distanceBias * (2.0 - 0.95 * NdotLmax0); // 0.95 fixes pink petals noon shadows
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode == 2) {
|
||||
bias *= vec3(0.0, 0.0, -0.75);
|
||||
} else if (subsurfaceMode == 1) {
|
||||
bias = vec3(0.0);
|
||||
centerShadowBias = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Fix light leaking in caves
|
||||
if (lightmapYM < 0.999) {
|
||||
#ifdef GBUFFERS_HAND
|
||||
playerPosM = mix(vec3(0.0), playerPosM, 0.2 + 0.8 * lightmapYM);
|
||||
#else
|
||||
if (centerShadowBias) {
|
||||
#ifdef OVERWORLD
|
||||
vec3 centerPos = floor(playerPosM + cameraPosition) - cameraPosition + 0.5;
|
||||
playerPosM = mix(centerPos, playerPosM, 0.5 + 0.5 * lightmapYM);
|
||||
#endif
|
||||
} else {
|
||||
vec3 edgeFactor = 0.2 * (0.5 - fract(playerPosM + cameraPosition + worldGeoNormal * 0.01));
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
bias *= 0.7;
|
||||
playerPosM += (1.0 - lightmapYM) * edgeFactor;
|
||||
#endif
|
||||
|
||||
playerPosM += (1.0 - pow2(pow2(max(glColor.a, lightmapYM)))) * edgeFactor;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
playerPosM += bias;
|
||||
#endif
|
||||
|
||||
vec3 shadowPos = GetShadowPos(playerPosM);
|
||||
|
||||
bool leaves = false;
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode == 0) {
|
||||
#if defined PERPENDICULAR_TWEAKS && defined SIDE_SHADOWING
|
||||
offset *= 1.0 + pow2(absNdotN);
|
||||
#endif
|
||||
} else {
|
||||
float VdotL = dot(nViewPos, lightVec);
|
||||
|
||||
float lightFactor = pow(max(VdotL, 0.0), 10.0) * float(isEyeInWater == 0);
|
||||
if (subsurfaceMode == 1) {
|
||||
offset = 0.0010235 * lightmapYM + 0.0009765;
|
||||
shadowPos.z -= max(NdotL * 0.0001, 0.0) * lightmapYM;
|
||||
subsurfaceHighlight = lightFactor * 0.8;
|
||||
#ifndef SHADOW_FILTERING
|
||||
shadowPos.z -= 0.0002;
|
||||
#endif
|
||||
} else if (subsurfaceMode == 2) {
|
||||
leaves = true;
|
||||
offset = 0.0005235 * lightmapYM + 0.0009765;
|
||||
shadowPos.z -= 0.000175 * lightmapYM;
|
||||
subsurfaceHighlight = lightFactor * 0.6;
|
||||
#ifndef SHADOW_FILTERING
|
||||
NdotLM = mix(NdotL, NdotLM, 0.5);
|
||||
#endif
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
shadowMult *= GetShadow(shadowPos, lViewPos, lightmap.y, offset, leaves);
|
||||
}
|
||||
|
||||
float shadowSmooth = 16.0;
|
||||
if (shadowLength < shadowSmooth) {
|
||||
float shadowMixer = max0(shadowLength / shadowSmooth);
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (subsurfaceMode != 0) {
|
||||
float shadowMixerM = pow2(shadowMixer);
|
||||
|
||||
if (subsurfaceMode == 1) skyLightShadowMult *= mix(0.6 + 0.3 * pow2(noonFactor), 1.0, shadowMixerM);
|
||||
else skyLightShadowMult *= mix(NdotL * 0.4999 + 0.5, 1.0, shadowMixerM);
|
||||
|
||||
subsurfaceHighlight *= shadowMixer;
|
||||
}
|
||||
#endif
|
||||
|
||||
shadowMult = mix(vec3(skyLightShadowMult * shadowMultBeforeLighting), shadowMult, shadowMixer);
|
||||
}
|
||||
}
|
||||
#else
|
||||
shadowMult *= skyLightShadowMult;
|
||||
#endif
|
||||
|
||||
#ifdef CLOUD_SHADOWS
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
#if defined DO_PIXELATION_EFFECTS && defined PIXELATED_SHADOWS
|
||||
worldPos = playerPosPixelated + cameraPosition;
|
||||
#endif
|
||||
float cloudShadowMult = 1.0;
|
||||
#ifdef CLOUDS_REIMAGINED
|
||||
float EdotL = dot(eastVec, lightVec);
|
||||
float EdotLM = tan(acos(EdotL));
|
||||
|
||||
#if SUN_ANGLE != 0
|
||||
float NVdotLM = tan(acos(dot(northVec, lightVec)));
|
||||
#endif
|
||||
|
||||
float distToCloudLayer1 = cloudAlt1i - worldPos.y;
|
||||
vec3 cloudOffset1 = vec3(distToCloudLayer1 / EdotLM, 0.0, 0.0);
|
||||
#if SUN_ANGLE != 0
|
||||
cloudOffset1.z += distToCloudLayer1 / NVdotLM;
|
||||
#endif
|
||||
vec2 cloudPos1 = GetRoundedCloudCoord(ModifyTracePos(worldPos + cloudOffset1, cloudAlt1i).xz, CLOUD_SHADOW_ROUNDNESS);
|
||||
float cloudSample = texture2D(gaux4, cloudPos1).b;
|
||||
cloudSample *= clamp(distToCloudLayer1 * 0.1, 0.0, 1.0);
|
||||
|
||||
#ifdef DOUBLE_REIM_CLOUDS
|
||||
float distToCloudLayer2 = cloudAlt2i - worldPos.y;
|
||||
vec3 cloudOffset2 = vec3(distToCloudLayer2 / EdotLM, 0.0, 0.0);
|
||||
#if SUN_ANGLE != 0
|
||||
cloudOffset2.z += distToCloudLayer2 / NVdotLM;
|
||||
#endif
|
||||
vec2 cloudPos2 = GetRoundedCloudCoord(ModifyTracePos(worldPos + cloudOffset2, cloudAlt2i).xz, CLOUD_SHADOW_ROUNDNESS);
|
||||
float cloudSample2 = texture2D(gaux4, cloudPos2).b;
|
||||
cloudSample2 *= clamp(distToCloudLayer2 * 0.1, 0.0, 1.0);
|
||||
|
||||
cloudSample = 1.0 - (1.0 - cloudSample) * (1.0 - cloudSample2);
|
||||
#endif
|
||||
|
||||
cloudSample *= sqrt3(1.0 - abs(EdotL));
|
||||
cloudShadowMult = 1.0 - 0.85 * cloudSample;
|
||||
#else
|
||||
vec2 csPos = worldPos.xz + worldPos.y * 0.25;
|
||||
csPos.x += syncedTime;
|
||||
csPos *= 0.000002 * CLOUD_UNBOUND_SIZE_MULT;
|
||||
|
||||
vec2 shadowoffsets[8] = vec2[8](
|
||||
vec2( 0.0 , 1.0 ),
|
||||
vec2( 0.7071, 0.7071),
|
||||
vec2( 1.0 , 0.0 ),
|
||||
vec2( 0.7071,-0.7071),
|
||||
vec2( 0.0 ,-1.0 ),
|
||||
vec2(-0.7071,-0.7071),
|
||||
vec2(-1.0 , 0.0 ),
|
||||
vec2(-0.7071, 0.7071));
|
||||
float cloudSample = 0.0;
|
||||
for (int i = 0; i < 8; i++) {
|
||||
cloudSample += texture2D(noisetex, csPos + 0.005 * shadowoffsets[i]).b;
|
||||
}
|
||||
|
||||
shadowMult *= smoothstep1(pow2(min1(cloudSample * 0.2)));
|
||||
cloudShadowMult = smoothstep1(pow2(min1(cloudSample * 0.2)));
|
||||
#endif
|
||||
shadowMult *= mix(1.0, mix(cloudShadowMult, 1.0, NIGHT_CLOUD_UNBOUND_REMOVE * (1.0 - sunVisibility)), CLOUD_TRANSPARENCY);
|
||||
#endif
|
||||
|
||||
shadowMult *= max(NdotLM * shadowTime, 0.0);
|
||||
}
|
||||
#ifdef GBUFFERS_WATER
|
||||
else { // Low Quality Water
|
||||
shadowMult = vec3(pow2(lightmapY2) * max(NdotLM * shadowTime, 0.0));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Blocklight
|
||||
#if defined DIRECTIONAL_LIGHTMAP_NORMALS && !defined GBUFFERS_HAND
|
||||
float lightmapDir = oldLightmap.x;
|
||||
float lightmapDir1 = lightmapDir;
|
||||
vec3 dFdViewPosX = dFdx(viewPos);
|
||||
vec3 dFdViewPosY = dFdy(viewPos);
|
||||
vec2 dFdBlock = vec2(dFdx(oldLightmap.x), dFdy(oldLightmap.x));
|
||||
vec3 blockLightDir = dFdViewPosX * dFdBlock.x + dFdViewPosY * dFdBlock.y;
|
||||
if (length(dFdBlock) > 1e-6) {
|
||||
lightmapDir *= clamp01(dot(normalize(blockLightDir), normalM)) + 1.0;
|
||||
lightmapDir1 *= clamp01(dot(normalize(blockLightDir), normalM) + 1.0);
|
||||
lightmapDir = mix(lightmapDir, lightmapDir1, 0.55);
|
||||
}
|
||||
lightmap.x = mix(lightmap.x, lightmapDir, DIRECTIONAL_LIGHTMAP_NORMALS_BLOCK_STRENGTH * 0.01 * max0(100.0 - lViewPos)); // mix with 0.5 to match regular normal intensity, mix to the normal lightmap with lViewPos to mitigate floating point precision error, dir lightmap only when player near light sources, otherwise normal lightmap
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_TEXTURED
|
||||
float lightmapXM;
|
||||
if (!noSmoothLighting) {
|
||||
float lightmapXMTransition = pow2(pow2(pow2(pow2(lightmap.x)))) * (10 - vsBrightness) * 2;
|
||||
float lightmapXMTransition2 = pow2(pow2(pow2(lightmap.x))) * (3.8 - vsBrightness) * 0.8;
|
||||
float lightmapXMTransition3 = pow2(pow2(lightmap.x)) * (3.8 - vsBrightness * 0.7);
|
||||
|
||||
float lightmapXMSteep = max(0.0, pow2(pow2(lightmap.x * lightmap.x)) * (3.8 - 0.6 * vsBrightness) + (lightmapXMTransition + lightmapXMTransition2 + lightmapXMTransition3) * ((UPPER_LIGHTMAP_CURVE * 0.1 + 0.9) - 1.0) * mix(1.0, 10.0, float(int(max(0.0, UPPER_LIGHTMAP_CURVE - 0.01))))); // Fancy Math
|
||||
float lightmapXMCalm = (lightmap.x) * (1.8 + 0.6 * vsBrightness) * LOWER_LIGHTMAP_CURVE;
|
||||
lightmapXM = pow(lightmapXMSteep + lightmapXMCalm, 2.25);
|
||||
} else lightmapXM = pow2(lightmap.x) * 10.0 * pow(lightmap.x, pow2(UPPER_LIGHTMAP_CURVE)) * UPPER_LIGHTMAP_CURVE * (UPPER_LIGHTMAP_CURVE * 0.7 + 0.3);
|
||||
#else
|
||||
float lightmapXM;
|
||||
if (!noSmoothLighting) {
|
||||
float lightmapXMSteep = pow2(pow2(lightmap.x * lightmap.x)) * (3.8 - 0.6 * vsBrightness);
|
||||
float lightmapXMCalm = (lightmap.x) * (1.8 + 0.6 * vsBrightness);
|
||||
lightmapXM = pow(lightmapXMSteep + lightmapXMCalm, 2.25);
|
||||
} else lightmapXM = pow2(lightmap.x) * lightmap.x * 10.0;
|
||||
#endif
|
||||
|
||||
#if BLOCKLIGHT_FLICKERING > 0 || defined SPOOKY
|
||||
float blocklightFlickerSpookyStrength = 0.0;
|
||||
#ifdef SPOOKY
|
||||
blocklightFlickerSpookyStrength = 0.7;
|
||||
#endif
|
||||
vec2 flickerNoiseBlock = texture2D(noisetex, vec2(frameTimeCounter * 0.06)).rb;
|
||||
lightmapXM *= mix(1.0, min1(max(flickerNoiseBlock.r, flickerNoiseBlock.g) * 1.7), max(pow2(BLOCKLIGHT_FLICKERING * 0.1), blocklightFlickerSpookyStrength));
|
||||
#endif
|
||||
|
||||
#ifdef RANDOM_BLOCKLIGHT
|
||||
float RandR = texture2D(noisetex, 0.00016 * RANDOM_BLOCKLIGHT_SIZE * (playerPos.xz + cameraPosition.xz)).r * XLIGHT_R;
|
||||
float RandG = texture2D(noisetex, 0.00029 * RANDOM_BLOCKLIGHT_SIZE * (playerPos.xz + cameraPosition.xz)).r * XLIGHT_G;
|
||||
float RandB = texture2D(noisetex, 0.00034 * RANDOM_BLOCKLIGHT_SIZE * (playerPos.xz + cameraPosition.xz)).r * XLIGHT_B;
|
||||
blocklightCol = vec3(RandR, RandG, RandB) * 0.875;
|
||||
#endif
|
||||
|
||||
vec3 blockLighting = lightmapXM * blocklightCol;
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
// Prepare
|
||||
#if defined GBUFFERS_HAND
|
||||
vec3 voxelPos = SceneToVoxel(vec3(0.0));
|
||||
#elif defined GBUFFERS_TEXTURED
|
||||
vec3 voxelPos = SceneToVoxel(playerPos);
|
||||
#else
|
||||
vec3 voxelPos = SceneToVoxel(playerPos);
|
||||
voxelPos = voxelPos + worldGeoNormal * 0.55; // should be close to 0.5 for ACL_CORNER_LEAK_FIX but 0.5 makes slabs flicker
|
||||
#endif
|
||||
|
||||
vec3 specialLighting = vec3(0.0);
|
||||
vec4 lightVolume = vec4(0.0);
|
||||
if (CheckInsideVoxelVolume(voxelPos)) {
|
||||
vec3 voxelPosM = clamp01(voxelPos / vec3(voxelVolumeSize));
|
||||
lightVolume = GetLightVolume(voxelPosM);
|
||||
lightVolume = sqrt(lightVolume);
|
||||
specialLighting = lightVolume.rgb;
|
||||
}
|
||||
|
||||
// Add extra articial light for blocks that request it
|
||||
lightmapXM = mix(lightmapXM, 10.0, lightVolume.a);
|
||||
specialLighting *= 1.0 + 50.0 * lightVolume.a;
|
||||
|
||||
// Color Balance
|
||||
specialLighting = lightmapXM * 0.13 * DoLuminanceCorrection(specialLighting + blocklightCol * 0.05);
|
||||
|
||||
// Add some extra non-contrasty detail
|
||||
AddSpecialLightDetail(specialLighting, color.rgb, emission);
|
||||
|
||||
#if COLORED_LIGHT_SATURATION != 100
|
||||
specialLighting = mix(blockLighting, specialLighting, COLORED_LIGHT_SATURATION * 0.01);
|
||||
#endif
|
||||
|
||||
// Serve with distance fade
|
||||
vec3 absPlayerPosM = abs(playerPos);
|
||||
#if COLORED_LIGHTING_INTERNAL <= 512
|
||||
absPlayerPosM.y *= 2.0;
|
||||
#elif COLORED_LIGHTING_INTERNAL == 768
|
||||
absPlayerPosM.y *= 3.0;
|
||||
#elif COLORED_LIGHTING_INTERNAL == 1024
|
||||
absPlayerPosM.y *= 4.0;
|
||||
#endif
|
||||
float maxPlayerPos = max(absPlayerPosM.x, max(absPlayerPosM.y, absPlayerPosM.z));
|
||||
float blocklightDecider = pow2(min1(maxPlayerPos / effectiveACLdistance * 2.0));
|
||||
//if (heldItemId != 40000 || heldItemId2 == 40000) // Hold spider eye to see vanilla lighting
|
||||
blockLighting = mix(specialLighting, blockLighting, blocklightDecider);
|
||||
//if (heldItemId2 == 40000 && heldItemId != 40000) blockLighting = lightVolume.rgb; // Hold spider eye to see light volume
|
||||
#endif
|
||||
|
||||
#if HELD_LIGHTING_MODE >= 1
|
||||
float heldLight = heldBlockLightValue; float heldLight2 = heldBlockLightValue2;
|
||||
|
||||
#ifndef IS_IRIS
|
||||
if (heldLight > 15.1) heldLight = 0.0;
|
||||
if (heldLight2 > 15.1) heldLight2 = 0.0;
|
||||
#endif
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL == 0
|
||||
vec3 heldLightCol = blocklightCol; vec3 heldLightCol2 = blocklightCol;
|
||||
|
||||
if (heldItemId == 45032) heldLight = 15; if (heldItemId2 == 45032) heldLight2 = 15; // Lava Bucket
|
||||
#else
|
||||
vec3 heldLightCol = GetSpecialBlocklightColor(heldItemId - 44000).rgb;
|
||||
vec3 heldLightCol2 = GetSpecialBlocklightColor(heldItemId2 - 44000).rgb;
|
||||
|
||||
if (heldItemId == 45032) { heldLightCol = lavaSpecialLightColor.rgb; heldLight = 15; } // Lava Bucket
|
||||
if (heldItemId2 == 45032) { heldLightCol2 = lavaSpecialLightColor.rgb; heldLight2 = 15; }
|
||||
|
||||
#if COLORED_LIGHT_SATURATION != 100
|
||||
heldLightCol = mix(blocklightCol, heldLightCol, COLORED_LIGHT_SATURATION * 0.01);
|
||||
heldLightCol2 = mix(blocklightCol, heldLightCol2, COLORED_LIGHT_SATURATION * 0.01);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
heldLight = clamp(heldLight, 0.0, 15.0);
|
||||
heldLight2 = clamp(heldLight2, 0.0, 15.0);
|
||||
|
||||
vec3 playerPosLightM = playerPos + relativeEyePosition;
|
||||
playerPosLightM.y += 0.7;
|
||||
float lViewPosL = length(playerPosLightM) + 6.0;
|
||||
#if HELD_LIGHTING_MODE == 1
|
||||
lViewPosL *= 1.5;
|
||||
#endif
|
||||
|
||||
#ifdef SPOOKY
|
||||
heldLight *= 1.3;
|
||||
heldLight2 *= 1.3;
|
||||
lViewPosL *= 1.6;
|
||||
#endif
|
||||
|
||||
#ifdef DIRECTIONAL_LIGHTMAP_NORMALS
|
||||
vec3 cameraHeldLightPos = (gbufferModelView * vec4(-relativeEyePosition, 1.0)).xyz;
|
||||
vec3 worldGeoNormalView = (gbufferModelView * vec4(worldGeoNormal, 1.0)).xyz;
|
||||
|
||||
cameraHeldLightPos.x += 0.66 * (float(heldLight > 0) - float(heldLight2 > 0)); // Held light position offset
|
||||
|
||||
float dirHandLightmap = clamp01(dot(normalize(cameraHeldLightPos - viewPos), normalM)) + 1.0;
|
||||
float differenceDir = dirHandLightmap - (clamp01(dot(normalize(cameraHeldLightPos - viewPos), worldGeoNormalView)) + 1.0); // Difference between normal and geo normal
|
||||
|
||||
dirHandLightmap = mix(1.0, dirHandLightmap, differenceDir * DIRECTIONAL_LIGHTMAP_NORMALS_HANDHELD_STRENGTH);
|
||||
heldLight *= dirHandLightmap;
|
||||
heldLight2 *= dirHandLightmap;
|
||||
#endif
|
||||
|
||||
heldLight = pow2(pow2(heldLight * 0.47 / lViewPosL));
|
||||
heldLight2 = pow2(pow2(heldLight2 * 0.47 / lViewPosL));
|
||||
|
||||
vec3 heldLighting = pow2(heldLight * DoLuminanceCorrection(heldLightCol + 0.001))
|
||||
+ pow2(heldLight2 * DoLuminanceCorrection(heldLightCol2 + 0.001));
|
||||
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
AddSpecialLightDetail(heldLighting, color.rgb, emission);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_HAND
|
||||
blockLighting *= 0.5;
|
||||
heldLighting *= 2.0;
|
||||
#endif
|
||||
#if HAND_BLOCKLIGHT_FLICKERING > 0
|
||||
vec2 flickerNoiseHand = texture2D(noisetex, vec2(frameTimeCounter * 0.06)).rb;
|
||||
float flickerMix = mix(1.0, min1(max(flickerNoiseHand.r, flickerNoiseHand.g) * 1.7), pow2(HAND_BLOCKLIGHT_FLICKERING * 0.1));
|
||||
|
||||
heldLighting *= flickerMix;
|
||||
#ifdef GBUFFERS_HAND
|
||||
emission *= mix(1.0, flickerMix, heldLight + heldLight2);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Minimum Light
|
||||
float fadeMinLightDistance = 1.0;
|
||||
#if defined DISTANCE_MIN_LIGHT || defined SPOOKY
|
||||
float blockMinLightFadeDistance = 250;
|
||||
#ifdef SPOOKY
|
||||
blockMinLightFadeDistance = 80;
|
||||
#endif
|
||||
fadeMinLightDistance = max(1.0 - length(playerPos) / blockMinLightFadeDistance, 0.0);
|
||||
fadeMinLightDistance = exp((1.0 - fadeMinLightDistance) * -15.0) * (1.0 - nightVision) + nightVision;
|
||||
#endif
|
||||
#if !defined END && defined SPOOKY
|
||||
vec3 minLighting = vec3(0.045) * fadeMinLightDistance;
|
||||
#else
|
||||
#if !defined END && MINIMUM_LIGHT_MODE > 0
|
||||
#if MINIMUM_LIGHT_MODE == 1
|
||||
vec3 minLighting = vec3(0.0038) * fadeMinLightDistance;
|
||||
#elif MINIMUM_LIGHT_MODE == 2
|
||||
vec3 minLighting = vec3(0.005625 + vsBrightness * 0.043) * fadeMinLightDistance;
|
||||
#elif MINIMUM_LIGHT_MODE == 3
|
||||
vec3 minLighting = vec3(0.0625) * fadeMinLightDistance;
|
||||
#elif MINIMUM_LIGHT_MODE >= 4
|
||||
vec3 minLighting = vec3(0.07 * pow2(MINIMUM_LIGHT_MODE - 2.5)) * fadeMinLightDistance;
|
||||
#endif
|
||||
minLighting *= vec3(0.45, 0.475, 0.6);
|
||||
minLighting *= 1.0 - lightmapYM;
|
||||
#else
|
||||
vec3 minLighting = vec3(0.0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
minLighting += nightVision * vec3(0.5, 0.5, 0.75);
|
||||
|
||||
// Lighting Tweaks
|
||||
#ifdef OVERWORLD
|
||||
ambientMult = mix(lightmapYM, pow2(lightmapYM) * lightmapYM, rainFactor);
|
||||
|
||||
#if SHADOW_QUALITY == -1
|
||||
float tweakFactor = 1.0 + 0.6 * (1.0 - pow2(pow2(pow2(noonFactor))));
|
||||
lightColorM /= tweakFactor;
|
||||
ambientMult *= mix(tweakFactor, 1.0, 0.5 * NdotUmax0);
|
||||
#endif
|
||||
|
||||
#if AMBIENT_MULT != 100
|
||||
#define AMBIENT_MULT_M (AMBIENT_MULT - 100) * 0.006
|
||||
vec3 shadowMultP = shadowMult / (0.1 + 0.9 * sqrt2(max0(NdotLM)));
|
||||
ambientMult *= 1.0 + pow2(pow2(max0(1.0 - dot(shadowMultP, shadowMultP)))) * AMBIENT_MULT_M *
|
||||
(0.5 + 0.2 * sunFactor + 0.8 * noonFactor) * (1.0 - rainFactor * 0.5);
|
||||
#endif
|
||||
|
||||
if (isEyeInWater != 1) {
|
||||
float lxFactor = (sunVisibility2 * 0.4 + (0.6 - 0.6 * pow2(invNoonFactor))) * (6.0 - 5.0 * rainFactor);
|
||||
lxFactor *= lightmapY2 + lightmapY2 * 2.0 * pow2(shadowMult.r);
|
||||
lxFactor = max0(lxFactor - emission * 1000000.0);
|
||||
blockLighting *= pow(lightmapXM / 60.0 + 0.001, 0.09 * lxFactor);
|
||||
|
||||
// Less light in the distance / more light closer to the camera during rain or night to simulate thicker fog
|
||||
float rainLF = 0.1 * rainFactor;
|
||||
float lightFogTweaks = 1.0 + max0(96.0 - lViewPos) * (0.002 * (1.0 - sunVisibility2) + 0.0104 * rainLF) - rainLF;
|
||||
ambientMult *= lightFogTweaks;
|
||||
lightColorM *= lightFogTweaks;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_HAND
|
||||
ambientMult *= 1.3; // To improve held map visibility
|
||||
#endif
|
||||
|
||||
// Directional Shading
|
||||
float directionShade = 1.0;
|
||||
#ifdef DIRECTIONAL_SHADING
|
||||
if (!noDirectionalShading) {
|
||||
float NdotE = dot(normalM, eastVec);
|
||||
float absNdotE = abs(NdotE);
|
||||
float absNdotE2 = pow2(absNdotE);
|
||||
|
||||
#if !defined NETHER
|
||||
float NdotUM = 0.75 + NdotU * 0.25;
|
||||
#else
|
||||
float NdotUM = 0.75 + abs(NdotU + 0.5) * 0.16666;
|
||||
#endif
|
||||
float NdotNM = 1.0 + 0.075 * absNdotN;
|
||||
float NdotEM = 1.0 - 0.1 * absNdotE2;
|
||||
directionShade = NdotUM * NdotEM * NdotNM;
|
||||
|
||||
#ifdef OVERWORLD
|
||||
lightColorM *= 1.0 + absNdotE2 * 0.75;
|
||||
#elif defined NETHER
|
||||
directionShade *= directionShade;
|
||||
ambientColorM += lavaLightColor * pow2(absNdotN * 0.5 + max0(-NdotU)) * (0.7 + 0.35 * vsBrightness);
|
||||
#endif
|
||||
|
||||
#if defined CUSTOM_PBR || defined GENERATED_NORMALS
|
||||
float cpbrAmbFactor = NdotN * NPdotU;
|
||||
cpbrAmbFactor = 1.0 - 0.3 * cpbrAmbFactor;
|
||||
ambientColorM *= cpbrAmbFactor;
|
||||
minLighting *= cpbrAmbFactor;
|
||||
#endif
|
||||
|
||||
#if defined OVERWORLD && defined PERPENDICULAR_TWEAKS && defined SIDE_SHADOWING
|
||||
// Fake bounced light
|
||||
ambientColorM = mix(ambientColorM, lightColorM, (0.05 + 0.03 * subsurfaceMode) * absNdotN * lightmapY2);
|
||||
|
||||
// Get a bit more natural looking lighting during noon
|
||||
lightColorM *= 1.0 + max0(1.0 - subsurfaceMode) * pow(noonFactor, 20.0) * (pow2(absNdotN) - absNdotE2 * 0.1);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef DREAM_TWEAKED_LIGHTING
|
||||
ambientColorM = mix(ambientColorM, lightColorM, 0.25) * 1.5;
|
||||
lightColorM = lightColorM * 0.3;
|
||||
#endif
|
||||
|
||||
// Scene Lighting Stuff
|
||||
vec3 sceneLighting = lightColorM * shadowMult + ambientColorM * ambientMult;
|
||||
float dotSceneLighting = dot(sceneLighting, sceneLighting);
|
||||
|
||||
#if HELD_LIGHTING_MODE >= 1
|
||||
blockLighting = sqrt(pow2(blockLighting) + heldLighting);
|
||||
#endif
|
||||
|
||||
blockLighting *= XLIGHT_I;
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
sceneLighting *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_LIGHT
|
||||
sceneLighting *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
// Vanilla Ambient Occlusion
|
||||
float vanillaAO = 1.0;
|
||||
#if VANILLAAO_I > 0
|
||||
vanillaAO = glColor.a;
|
||||
|
||||
#if defined DO_PIXELATION_EFFECTS && defined PIXELATED_AO
|
||||
vanillaAO = TexelSnap(vanillaAO, pixelationOffset);
|
||||
#endif
|
||||
|
||||
if (subsurfaceMode != 0) vanillaAO = mix(min1(vanillaAO * 1.15), 1.0, shadowMult.g);
|
||||
else if (!noVanillaAO) {
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
vanillaAO = min1(vanillaAO + 0.08);
|
||||
#ifdef OVERWORLD
|
||||
vanillaAO = pow(
|
||||
pow1_5(vanillaAO),
|
||||
1.0 + dotSceneLighting * 0.02 + NdotUmax0 * (0.15 + 0.25 * pow2(noonFactor * pow2(lightmapY2)))
|
||||
);
|
||||
#elif defined NETHER
|
||||
vanillaAO = pow(
|
||||
pow1_5(vanillaAO),
|
||||
1.0 + NdotUmax0 * 0.5
|
||||
);
|
||||
#else
|
||||
vanillaAO = pow(
|
||||
vanillaAO,
|
||||
0.75 + NdotUmax0 * 0.25
|
||||
);
|
||||
#endif
|
||||
#endif
|
||||
vanillaAO = vanillaAO * 0.9 + 0.1;
|
||||
|
||||
#if VANILLAAO_I != 100
|
||||
#define VANILLAAO_IM VANILLAAO_I * 0.01
|
||||
vanillaAO = pow(vanillaAO, VANILLAAO_IM);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef EPIC_THUNDERSTORM
|
||||
vanillaAO += lightningAdd.y * 0.1 * (-vanillaAO + 1);
|
||||
#endif
|
||||
|
||||
// Light Highlight
|
||||
vec3 lightHighlight = vec3(0.0);
|
||||
#ifdef LIGHT_HIGHLIGHT
|
||||
float specularHighlight = GGX(normalM, nViewPos, lightVec, NdotLmax0, smoothnessG);
|
||||
|
||||
specularHighlight *= highlightMult;
|
||||
|
||||
lightHighlight = isEyeInWater != 1 ? shadowMult : pow(shadowMult, vec3(0.25)) * 0.35;
|
||||
lightHighlight *= (subsurfaceHighlight + specularHighlight) * highlightColor;
|
||||
|
||||
#ifdef LIGHT_COLOR_MULTS
|
||||
lightHighlight *= lightColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_REFLECTION
|
||||
lightHighlight *= pow2(moonPhaseInfluence);
|
||||
#endif
|
||||
#ifdef SPOOKY
|
||||
lightHighlight *= 0.3;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Mix Colors
|
||||
vec3 finalDiffuse = pow2(directionShade * vanillaAO) * (blockLighting + pow2(sceneLighting) + minLighting) + pow2(emission);
|
||||
finalDiffuse = sqrt(max(finalDiffuse, vec3(0.0))); // sqrt() for a bit more realistic light mix, max() to prevent NaNs
|
||||
|
||||
// Apply Lighting
|
||||
color.rgb *= finalDiffuse;
|
||||
color.rgb += lightHighlight;
|
||||
color.rgb *= pow2(1.0 - darknessLightFactor);
|
||||
}
|
||||
@ -0,0 +1,118 @@
|
||||
vec3 GetShadowPos(vec3 playerPos) {
|
||||
vec3 shadowPos = PlayerToShadow(playerPos);
|
||||
float distb = sqrt(shadowPos.x * shadowPos.x + shadowPos.y * shadowPos.y);
|
||||
float distortFactor = distb * shadowMapBias + (1.0 - shadowMapBias);
|
||||
shadowPos.xy /= distortFactor;
|
||||
shadowPos.z *= 0.2;
|
||||
return shadowPos * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
vec3 SampleShadow(vec3 shadowPos, float colorMult, float colorPow) {
|
||||
float shadow0 = shadow2D(shadowtex0, vec3(shadowPos.st, shadowPos.z)).x;
|
||||
|
||||
vec3 shadowcol = vec3(0.0);
|
||||
if (shadow0 < 1.0) {
|
||||
float shadow1 = shadow2D(shadowtex1, vec3(shadowPos.st, shadowPos.z)).x;
|
||||
if (shadow1 > 0.9999) {
|
||||
shadowcol = texture2D(shadowcolor0, shadowPos.st).rgb * shadow1;
|
||||
|
||||
shadowcol *= colorMult;
|
||||
shadowcol = pow(shadowcol, vec3(colorPow));
|
||||
}
|
||||
}
|
||||
|
||||
return shadowcol * (1.0 - shadow0) + shadow0;
|
||||
}
|
||||
|
||||
float InterleavedGradientNoiseForShadows() {
|
||||
float n = 52.9829189 * fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y);
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_HAND && !defined GBUFFERS_TEXTURED && defined TAA
|
||||
return fract(n + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#else
|
||||
return fract(n);
|
||||
#endif
|
||||
}
|
||||
|
||||
vec2 offsetDist(float x, int s) {
|
||||
float n = fract(x * 2.427) * 3.1415;
|
||||
return vec2(cos(n), sin(n)) * 1.4 * x / s;
|
||||
}
|
||||
|
||||
vec3 SampleTAAFilteredShadow(vec3 shadowPos, float lViewPos, float offset, bool leaves, float colorMult, float colorPow) {
|
||||
vec3 shadow = vec3(0.0);
|
||||
float gradientNoise = InterleavedGradientNoiseForShadows();
|
||||
|
||||
#if SHADOW_QUALITY == 0
|
||||
int shadowSamples = 0; // We don't use SampleTAAFilteredShadow on Shadow Quality 0
|
||||
#elif SHADOW_QUALITY == 1
|
||||
int shadowSamples = 1;
|
||||
#elif SHADOW_QUALITY == 2 || SHADOW_QUALITY == 3
|
||||
int shadowSamples = 2;
|
||||
#elif SHADOW_QUALITY == 4
|
||||
int shadowSamples = 2;
|
||||
if (lViewPos < 10.0) shadowSamples = 6;
|
||||
#elif SHADOW_QUALITY == 5
|
||||
int shadowSamples = 6;
|
||||
if (lViewPos < 10.0) shadowSamples = 12;
|
||||
#endif
|
||||
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_HAND && !defined GBUFFERS_TEXTURED
|
||||
offset *= 1.3875;
|
||||
#else
|
||||
shadowSamples *= 2;
|
||||
offset *= 0.69375;
|
||||
#endif
|
||||
|
||||
float shadowPosZM = shadowPos.z;
|
||||
for (int i = 0; i < shadowSamples; i++) {
|
||||
vec2 offset2 = offsetDist(gradientNoise + i, shadowSamples) * offset;
|
||||
if (leaves) shadowPosZM = shadowPos.z - 0.12 * offset * (gradientNoise + i) / shadowSamples;
|
||||
shadow += SampleShadow(vec3(shadowPos.st + offset2, shadowPosZM), colorMult, colorPow);
|
||||
shadow += SampleShadow(vec3(shadowPos.st - offset2, shadowPosZM), colorMult, colorPow);
|
||||
}
|
||||
|
||||
shadow /= shadowSamples * 2.0;
|
||||
|
||||
return shadow;
|
||||
}
|
||||
|
||||
vec2 shadowOffsets[4] = vec2[4](
|
||||
vec2( 1.0, 0.0),
|
||||
vec2( 0.0, 1.0),
|
||||
vec2(-1.0, 0.0),
|
||||
vec2( 0.0,-1.0));
|
||||
|
||||
vec3 SampleBasicFilteredShadow(vec3 shadowPos, float offset) {
|
||||
float shadow = 0.0;
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
shadow += shadow2D(shadowtex0, vec3(offset * shadowOffsets[i] + shadowPos.st, shadowPos.z)).x;
|
||||
}
|
||||
|
||||
return vec3(shadow * 0.25);
|
||||
}
|
||||
|
||||
vec3 GetShadow(vec3 shadowPos, float lViewPos, float lightmapY, float offset, bool leaves) {
|
||||
#if SHADOW_QUALITY > 0
|
||||
#if ENTITY_SHADOWS_DEFINE == -1 && defined GBUFFERS_BLOCK
|
||||
offset *= 4.0;
|
||||
#else
|
||||
#ifdef OVERWORLD
|
||||
offset *= 1.0 + rainFactor2 * 2.0;
|
||||
#else
|
||||
offset *= 3.0;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
float colorMult = 1.2 + 3.8 * lightmapY; // Natural strength is 5.0
|
||||
float colorPow = 1.1 - 0.6 * pow2(pow2(pow2(lightmapY)));
|
||||
|
||||
#if SHADOW_QUALITY >= 1
|
||||
vec3 shadow = SampleTAAFilteredShadow(shadowPos, lViewPos, offset, leaves, colorMult, colorPow);
|
||||
#else
|
||||
vec3 shadow = SampleBasicFilteredShadow(shadowPos, offset);
|
||||
#endif
|
||||
|
||||
return shadow;
|
||||
}
|
||||
@ -0,0 +1,123 @@
|
||||
if (blockEntityId < 60028) {
|
||||
if (blockEntityId < 60012) {
|
||||
if (blockEntityId < 60004) {
|
||||
if (blockEntityId == 10548) { // Enchanting Table:Book
|
||||
smoothnessG = pow2(color.g) * 0.35;
|
||||
|
||||
if (color.b < 0.0001 && color.r > color.g) {
|
||||
emission = color.g * 4.0;
|
||||
}
|
||||
overlayNoiseIntensity = 0.3;
|
||||
} else if (blockEntityId == 60000) { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60004) { // Signs
|
||||
noSmoothLighting = true;
|
||||
|
||||
if (glColor.r + glColor.g + glColor.b <= 2.99 || lmCoord.x > 0.999) { // Sign Text
|
||||
#include "/lib/materials/specificMaterials/others/signText.glsl"
|
||||
}
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
} else if (blockEntityId == 60008) { // Chest
|
||||
noSmoothLighting = true;
|
||||
|
||||
smoothnessG = pow2(color.g);
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
redstoneIPBR(color.rgb, emission);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60020) {
|
||||
if (blockEntityId == 60012) { // Ender Chest
|
||||
noSmoothLighting = true;
|
||||
|
||||
float factor = min(pow2(color.g), 0.25);
|
||||
smoothnessG = factor * 2.0;
|
||||
|
||||
if (color.g > color.r || color.b > color.g)
|
||||
emission = pow2(factor) * 20.0;
|
||||
emission += 0.35;
|
||||
#if SEASONS == 1 || SEASONS == 4 || defined MOSS_NOISE_INTERNAL || defined SAND_NOISE_INTERNAL
|
||||
overlayNoiseIntensity = 0.7;
|
||||
if (dot(normal, upVec) > 0.99) {
|
||||
#if SNOW_CONDITION < 2 && SNOW_CONDITION != 0
|
||||
emission = mix(emission, emission * 0.8, inSnowy);
|
||||
#elif SNOW_CONDITION == 0
|
||||
emission = mix(emission, emission * 0.8, rainFactor * inSnowy);
|
||||
#else
|
||||
emission *= 0.8;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
} else /*if (blockEntityId == 60016)*/ { // Shulker Box+, Banner+, Head+, Bed+
|
||||
noSmoothLighting = true;
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.2;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60020) { // Conduit
|
||||
noSmoothLighting = true;
|
||||
lmCoordM.x = 0.9;
|
||||
|
||||
if (color.b > color.r) { // Conduit:Wind, Conduit:Blue Pixels of The Eye
|
||||
emission = color.r * 16.0;
|
||||
} else if (color.r > color.b * 2.5) { // Conduit:Red Pixels of The Eye
|
||||
emission = 20.0;
|
||||
color.rgb *= vec3(1.0, 0.25, 0.1);
|
||||
}
|
||||
overlayNoiseIntensity = 0.3;
|
||||
} else /*if (blockEntityId == 60025)*/ { // End Portal, End Gateway
|
||||
#ifdef SPECIAL_PORTAL_EFFECTS
|
||||
#include "/lib/materials/specificMaterials/others/endPortalEffect.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60044) {
|
||||
if (blockEntityId < 60036) {
|
||||
if (blockEntityId == 60028) { // Bell
|
||||
if (color.r + color.g > color.b + 0.5) { // Bell:Golden Part
|
||||
#include "/lib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/stone.glsl"
|
||||
}
|
||||
} else /*if (blockEntityId == 60032)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60036) { //
|
||||
|
||||
} else /*if (blockEntityId == 60040)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId < 60052) {
|
||||
if (blockEntityId == 60044) { //
|
||||
|
||||
} else /*if (blockEntityId == 60048)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (blockEntityId == 60052) { //
|
||||
|
||||
} else if (blockEntityId == 60056) { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,157 @@
|
||||
#ifdef POM
|
||||
#include "/lib/materials/materialMethods/pomEffects.glsl"
|
||||
#endif
|
||||
|
||||
#include "/lib/materials/materialMethods/customEmission.glsl"
|
||||
|
||||
void GetCustomMaterials(inout vec4 color, inout vec3 normalM, inout vec2 lmCoordM, inout float NdotU, inout vec3 shadowMult, inout float smoothnessG, inout float smoothnessD, inout float highlightMult, inout float emission, inout float materialMask, vec3 viewPos, float lViewPos) {
|
||||
vec2 texCoordM = texCoord;
|
||||
|
||||
#ifdef POM
|
||||
float parallaxFade, parallaxTexDepth;
|
||||
vec2 parallaxLocalCoord;
|
||||
vec3 parallaxTraceCoordDepth;
|
||||
vec4 normalMap;
|
||||
|
||||
#if defined GBUFFERS_TERRAIN
|
||||
bool skipPom = (mat == 20000);
|
||||
#elif defined GBUFFERS_BLOCK
|
||||
bool skipPom = (blockEntityId == 20000);
|
||||
#else
|
||||
bool skipPom = false;
|
||||
#endif
|
||||
|
||||
if (!skipPom) {
|
||||
texCoordM = vTexCoord.xy * vTexCoordAM.zw + vTexCoordAM.xy;
|
||||
|
||||
parallaxFade = pow2(lViewPos / POM_DISTANCE); // Still enabled to test: Lava, Painting
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
if (entityId == 50008) parallaxFade = 1.1; // Item Frame, Glow Item Frame
|
||||
#endif
|
||||
#ifdef GBUFFERS_BLOCK
|
||||
if (blockEntityId == 60004) parallaxFade = 1.1; // Signs
|
||||
#endif
|
||||
#ifdef GBUFFERS_HAND
|
||||
if (heldItemId == 40004 || heldItemId2 == 40004) parallaxFade = 1.1; // Filled Map
|
||||
#endif
|
||||
|
||||
parallaxTraceCoordDepth = vec3(texCoordM, 1.0);
|
||||
parallaxLocalCoord = vTexCoord.st;
|
||||
|
||||
normalMap = ReadNormal(vTexCoord.st);
|
||||
parallaxFade += pow(normalMap.a, 64.0);
|
||||
|
||||
if (parallaxFade < 1.0) {
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
#endif
|
||||
|
||||
parallaxLocalCoord = GetParallaxCoord(parallaxFade, dither, texCoordM, parallaxTexDepth, parallaxTraceCoordDepth);
|
||||
|
||||
normalMap = textureGrad(normals, texCoordM, dcdx, dcdy);
|
||||
color = textureGrad(tex, texCoordM, dcdx, dcdy);
|
||||
#if !defined GBUFFERS_ENTITIES && !defined GBUFFERS_BLOCK
|
||||
color.rgb *= glColor.rgb;
|
||||
#else
|
||||
color *= glColor;
|
||||
#endif
|
||||
|
||||
shadowMult *= GetParallaxShadow(parallaxFade, dither, normalMap.a, parallaxLocalCoord, lightVec, tbnMatrix);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// Normal Map
|
||||
#if NORMAL_MAP_STRENGTH != 0
|
||||
#ifdef POM
|
||||
else normalMap = texture2D(normals, texCoordM);
|
||||
#else
|
||||
vec4 normalMap = texture2D(normals, texCoordM);
|
||||
#endif
|
||||
|
||||
normalM = normalMap.xyz;
|
||||
normalM += vec3(0.5, 0.5, 0.0);
|
||||
normalM = pow(normalM, vec3(NORMAL_MAP_STRENGTH * 0.007)); // 70% strength by default
|
||||
normalM -= vec3(0.5, 0.5, 0.0);
|
||||
normalM = normalM * 2.0 - 1.0;
|
||||
|
||||
#if RP_MODE == 3 // labPBR
|
||||
if (normalM.x + normalM.y > -1.999) {
|
||||
if (length(normalM.xy) > 1.0) normalM.xy = normalize(normalM.xy);
|
||||
normalM.z = sqrt(1.0 - dot(normalM.xy, normalM.xy));
|
||||
normalM.xyz = normalize(clamp(normalM.xyz, vec3(-1.0), vec3(1.0)));
|
||||
} else normalM = vec3(0.0, 0.0, 1.0);
|
||||
#endif
|
||||
|
||||
#if defined POM && POM_QUALITY >= 128 && POM_LIGHTING_MODE == 2
|
||||
if (!skipPom) {
|
||||
float slopeThreshold = max(1.0 / POM_QUALITY, 1.0/255.0);
|
||||
if (parallaxTexDepth - parallaxTraceCoordDepth.z > slopeThreshold) {
|
||||
vec3 slopeNormal = GetParallaxSlopeNormal(parallaxLocalCoord, parallaxTraceCoordDepth.z, viewVector);
|
||||
normalM = mix(normalM, slopeNormal, 0.5 * pow2(max0(1.0 - parallaxFade * 2.0)));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
normalM = clamp(normalize(normalM * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
|
||||
NdotU = dot(normalM, upVec);
|
||||
NdotUmax0 = max0(NdotU);
|
||||
#endif
|
||||
|
||||
#if DIRECTIONAL_BLOCKLIGHT > 0
|
||||
mat3 lightmapTBN = mat3(normalize(dFdx(viewPos)), normalize(dFdy(viewPos)), vec3(0.0));
|
||||
lightmapTBN[2] = cross(lightmapTBN[0], lightmapTBN[1]);
|
||||
|
||||
float lmCoordXDir = lmCoordM.x;
|
||||
vec2 deriv = vec2(dFdx(lmCoordXDir), dFdy(lmCoordXDir)) * 256.0;
|
||||
vec3 dir = normalize(vec3(deriv.x * lightmapTBN[0] +
|
||||
0.0005 * lightmapTBN[2] +
|
||||
deriv.y * lightmapTBN[1]));
|
||||
|
||||
float pwr = clamp(dot(normalM, dir), -1.0, 1.0);
|
||||
float absPwr = abs(pwr);
|
||||
if (absPwr > 0.0) pwr = pow(absPwr, 9.0 / DIRECTIONAL_BLOCKLIGHT) * sign(pwr) * lmCoordXDir;
|
||||
if (length(deriv) > 0.001) lmCoordXDir = pow(max(lmCoordXDir, 0.00001), 1.0 - pwr);
|
||||
|
||||
lmCoordM.x = mix(lmCoordM.x, lmCoordXDir, 0.01 * max0(100.0 - pow2(lViewPos)));
|
||||
#endif
|
||||
|
||||
// Specular Map
|
||||
vec4 specularMap = texture2D(specular, texCoordM);
|
||||
|
||||
float smoothnessM = pow2(specularMap.r);
|
||||
smoothnessG = smoothnessM;
|
||||
smoothnessD = smoothnessM;
|
||||
highlightMult = 1.0 + 2.5 * specularMap.r;
|
||||
|
||||
#if RP_MODE == 3 // labPBR
|
||||
highlightMult *= 0.5 + 0.5 * specularMap.g;
|
||||
#endif
|
||||
|
||||
emission = GetCustomEmission(specularMap, texCoordM);
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
#if defined GBUFFERS_ENTITIES || defined GBUFFERS_HAND
|
||||
if (
|
||||
materialMask > OSIEBCA * 240.1
|
||||
&& specularMap.g < 0.01
|
||||
) return;
|
||||
#endif
|
||||
|
||||
#if RP_MODE == 2 // seuspbr
|
||||
materialMask = specularMap.g * OSIEBCA * 240.0;
|
||||
|
||||
color.rgb *= 1.0 - 0.25 * specularMap.g;
|
||||
#elif RP_MODE == 3 // labPBR
|
||||
if (specularMap.g < OSIEBCA * 229.1) {
|
||||
materialMask = specularMap.g * OSIEBCA * 214.0;
|
||||
} else {
|
||||
materialMask = specularMap.g - OSIEBCA * 15.0;
|
||||
|
||||
color.rgb *= 0.75;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1,72 @@
|
||||
if (abs(materialMaskInt - 149.5) < 50.0) { // Entity Reflection Handling (see common.glsl for details)
|
||||
materialMaskInt -= 100;
|
||||
entityOrHand = true;
|
||||
}
|
||||
|
||||
if (materialMaskInt != 0) {
|
||||
if (materialMaskInt < 9) {
|
||||
if (materialMaskInt < 5) {
|
||||
if (materialMaskInt < 3) {
|
||||
if (materialMaskInt == 1) { // Intense Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
} else /*if (materialMaskInt == 2)*/ { // Copper Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = mix(vec3(0.5, 0.75, 0.5), vec3(1.0, 0.45, 0.3), sqrt1(smoothnessD));
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 3) { // Gold Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = vec3(1.0, 0.8, 0.5);
|
||||
} else /*if (materialMaskInt == 4)*/ { // End Portal
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 7) {
|
||||
if (materialMaskInt == 5) { // Redstone Fresnel
|
||||
intenseFresnel = 1.0;
|
||||
reflectColor = vec3(1.0, 0.3, 0.2);
|
||||
} else /*if (materialMaskInt == 6)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 7) { //
|
||||
|
||||
} else /*if (materialMaskInt == 8)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 13) {
|
||||
if (materialMaskInt < 11) {
|
||||
if (materialMaskInt == 9) { //
|
||||
|
||||
} else /*if (materialMaskInt == 10)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 11) { //
|
||||
|
||||
} else /*if (materialMaskInt == 12)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt < 15) {
|
||||
if (materialMaskInt == 13) { //
|
||||
|
||||
} else /*if (materialMaskInt == 14)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (materialMaskInt == 254) { // No SSAO, No TAA
|
||||
ssao = 1.0;
|
||||
entityOrHand = true;
|
||||
} else /*if (materialMaskInt == "15 to 255 except 254")*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,246 @@
|
||||
if (entityId < 50064) {
|
||||
if (entityId < 50032) {
|
||||
if (entityId < 50016) {
|
||||
if (entityId < 50008) {
|
||||
if (entityId == 50000) { // End Crystal
|
||||
lmCoordM.x *= 0.7;
|
||||
|
||||
if (color.g * 1.2 < color.r) {
|
||||
emission = 12.0 * color.g;
|
||||
color.r *= 1.1;
|
||||
}
|
||||
} else if (entityId == 50004) { // Lightning Bolt
|
||||
#include "/lib/materials/specificMaterials/entities/lightningBolt.glsl"
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50008) { // Item Frame, Glow Item Frame
|
||||
noSmoothLighting = true;
|
||||
} else /*if (entityId == 50012)*/ { // Iron Golem
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
|
||||
smoothnessD *= 0.4;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50024) {
|
||||
if (entityId == 50016) { // Player
|
||||
if (entityColor.a < 0.001) {
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
|
||||
if (CheckForColor(texelFetch(tex, ivec2(0, 0), 0).rgb, vec3(23, 46, 92))) {
|
||||
for (int i = 63; i >= 56; i--) {
|
||||
vec3 dif = color.rgb - texelFetch(tex, ivec2(i, 0), 0).rgb;
|
||||
if (dif == clamp(dif, vec3(-0.001), vec3(0.001))) {
|
||||
emission = 2.0 * texelFetch(tex, ivec2(i, 1), 0).r;
|
||||
}
|
||||
}
|
||||
}
|
||||
// #ifdef SKIN_SPACEAGLE17
|
||||
// if (CheckForColor(color.rgb, vec3(255, 255, 255))) emission = 3.0;
|
||||
// #endif
|
||||
|
||||
}
|
||||
} else /*if (entityId == 50020)*/ { // Blaze
|
||||
lmCoordM = vec2(0.9, 0.0);
|
||||
emission = min(color.r, 0.7) * 1.4;
|
||||
|
||||
float dotColor = dot(color.rgb, color.rgb);
|
||||
if (abs(dotColor - 1.5) > 1.4) {
|
||||
emission = 5.0;
|
||||
} else {
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50024) { // Creeper
|
||||
emission = max0(color.b - color.g - color.r) * 10.0;
|
||||
} else /*if (entityId == 50028)*/ { // Drowned
|
||||
if (atlasSize.x < 900) {
|
||||
if (CheckForColor(color.rgb, vec3(143, 241, 215)) ||
|
||||
CheckForColor(color.rgb, vec3( 49, 173, 183)) ||
|
||||
CheckForColor(color.rgb, vec3(101, 224, 221))) emission = 2.5;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50048) {
|
||||
if (entityId < 50040) {
|
||||
if (entityId == 50032) { // Guardian
|
||||
vec3 absDif = abs(vec3(color.r - color.g, color.g - color.b, color.r - color.b));
|
||||
float maxDif = max(absDif.r, max(absDif.g, absDif.b));
|
||||
if (maxDif < 0.1 && color.b > 0.5 && color.b < 0.88) {
|
||||
emission = pow2(pow1_5(color.b)) * 5.0;
|
||||
color.rgb *= color.rgb;
|
||||
}
|
||||
} else /*if (entityId == 50036)*/ { // Elder Guardian
|
||||
if (CheckForColor(color.rgb, vec3(203, 177, 165)) ||
|
||||
CheckForColor(color.rgb, vec3(214, 155, 126))) {
|
||||
emission = pow2(pow1_5(color.b)) * 10.0;
|
||||
color.r *= 1.2;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50040) { // Endermite
|
||||
if (CheckForColor(color.rgb, vec3(87, 23, 50))) {
|
||||
emission = 8.0;
|
||||
color.rgb *= color.rgb;
|
||||
}
|
||||
} else /*if (entityId == 50044)*/ { // Ghast
|
||||
if (entityColor.a < 0.001)
|
||||
emission = max0(color.r - color.g - color.b) * 6.0;
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
if (color.r > color.b * 2.0) color.rgb = changeColorFunction(color.rgb, 7.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
if (color.r > color.b * 2.0) color.rgb = changeColorFunction(color.rgb, 7.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50056) {
|
||||
if (entityId == 50048) { // Glow Squid
|
||||
lmCoordM.x = 0.0;
|
||||
float dotColor = dot(color.rgb, color.rgb);
|
||||
emission = pow2(pow2(min(dotColor * 0.65, 1.5))) + 0.45;
|
||||
} else /*if (entityId == 50052)*/ { // Magma Cube
|
||||
emission = color.g * 6.0;
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50056) { // Stray
|
||||
if (CheckForColor(color.rgb, vec3(230, 242, 246)) && texCoord.y > 0.35)
|
||||
emission = 2.5;
|
||||
} else /*if (entityId == 50060)*/ { // Vex
|
||||
lmCoordM = vec2(0.0);
|
||||
emission = pow2(pow2(color.r)) * 3.5 + 0.5;
|
||||
color.a *= color.a;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50096) {
|
||||
if (entityId < 50080) {
|
||||
if (entityId < 50072) {
|
||||
if (entityId == 50064) { // Witch
|
||||
emission = 2.0 * color.g * float(color.g * 1.5 > color.b + color.r);
|
||||
} else /*if (entityId == 50068)*/ { // Wither, Wither Skull
|
||||
lmCoordM.x = 0.9;
|
||||
emission = 3.0 * float(dot(color.rgb, color.rgb) > 1.0);
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50072) { // Experience Orb
|
||||
emission = 7.5;
|
||||
|
||||
color.rgb *= color.rgb;
|
||||
} else /*if (entityId == 50076)*/ { // Boats
|
||||
playerPos.y += 0.38; // to avoid water shadow and the black inner shadow bug
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50088) {
|
||||
if (entityId == 50080) { // Allay
|
||||
if (atlasSize.x < 900) {
|
||||
lmCoordM = vec2(0.0);
|
||||
emission = float(color.r > 0.9 && color.b > 0.9) * 5.0 + color.g;
|
||||
} else {
|
||||
lmCoordM.x = 0.8;
|
||||
}
|
||||
} else /*if (entityId == 50084)*/ { // Slime, Chicken
|
||||
//only code is in Vertex Shader for now
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50088) { // Entity Flame (Iris Feature)
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 3.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
emission = 1.3;
|
||||
} else if (entityId == 50089) { // fireball, small fireball, dragon fireball
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 4.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 4.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
} else /*if (entityId == 50092)*/ { // Trident Entity
|
||||
#ifdef IS_IRIS
|
||||
// Only on Iris, because otherwise it would be inconsistent with the Trident item
|
||||
#include "/lib/materials/specificMaterials/others/trident.glsl"
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50112) {
|
||||
if (entityId < 50104) {
|
||||
if (entityId == 50096) { // Minecart++
|
||||
if (atlasSize.x < 900 && color.r * color.g * color.b + color.b > 0.3) {
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
|
||||
smoothnessD *= 0.6;
|
||||
}
|
||||
} else /*if (entityId == 50100)*/ { // Bogged
|
||||
if (CheckForColor(color.rgb, vec3(239, 254, 194)))
|
||||
emission = 2.5;
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50104) { // Piglin++, Hoglin+
|
||||
if (atlasSize.x < 900) {
|
||||
if (CheckForColor(color.rgb, vec3(255)) || CheckForColor(color.rgb, vec3(255, 242, 246))) {
|
||||
vec2 tSize = textureSize(tex, 0);
|
||||
vec4 checkRightmostColor = texelFetch(tex, ivec2(texCoord * tSize) + ivec2(1, 0), 0);
|
||||
if (
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(201, 130, 101)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(241, 158, 152)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(223, 127, 119)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(241, 158, 152)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(165, 99, 80)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(213, 149, 122)) ||
|
||||
CheckForColor(checkRightmostColor.rgb, vec3(255))
|
||||
) {
|
||||
emission = 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else /*if (entityId == 50108)*/ { // Creaking
|
||||
if (color.r > 0.7 && color.r > color.g * 1.2 && color.g > color.b * 2.0) { // Eyes
|
||||
lmCoordM.x = 0.5;
|
||||
emission = 5.0 * color.g;
|
||||
color.rgb *= color.rgb;
|
||||
purkinjeOverwrite = 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (entityId < 50120) {
|
||||
if (entityId == 50112) { //
|
||||
|
||||
} else /*if (entityId == 50116)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (entityId == 50120) { //
|
||||
|
||||
} else /*if (entityId == 50124)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,249 @@
|
||||
int mat = currentRenderedItemId;
|
||||
|
||||
#ifdef GBUFFERS_HAND
|
||||
float lViewPos = 0.0;
|
||||
#endif
|
||||
|
||||
int subsurfaceMode;
|
||||
bool noDirectionalShading, noVanillaAO, centerShadowBias;
|
||||
float noPuddles;
|
||||
|
||||
if (currentRenderedItemId < 45000) {
|
||||
#include "/lib/materials/materialHandling/terrainMaterials.glsl"
|
||||
} else
|
||||
|
||||
if (currentRenderedItemId < 45064) {
|
||||
if (currentRenderedItemId < 45032) {
|
||||
if (currentRenderedItemId < 45016) {
|
||||
if (currentRenderedItemId < 45008) {
|
||||
if (currentRenderedItemId == 45000) { // Armor Trims
|
||||
smoothnessG = 0.5;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 0.5;
|
||||
|
||||
#ifdef GLOWING_ARMOR_TRIM
|
||||
emission = 1.0;
|
||||
#endif
|
||||
#ifdef SITUATIONAL_GLOWING_TRIMS
|
||||
emission *= skyLightCheck;
|
||||
#endif
|
||||
} else if (currentRenderedItemId == 45004) { // Wooden Tools, Bow, Fishing Rod
|
||||
#include "/lib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
smoothnessG = min(smoothnessG, 0.4);
|
||||
smoothnessD = smoothnessG;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45008) { // Stone Tools
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/lib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/stone.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45012)*/ { // Iron Tools, Iron Armor, Iron Ingot, Iron Nugget, Iron Horse Armor, Flint and Steel, Flint, Spyglass, Shears, Chainmail Armor
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/lib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45024) {
|
||||
if (currentRenderedItemId == 45016) { // Golden Tools, Golden Armor, Gold Ingot, Gold Nugget, Golden Apple, Enchanted Golden Apple, Golden Carrot, Golden Horse Armor, Copper Ingot
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/lib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45020)*/ { // Diamond Tools, Diamond Armor, Diamond, Diamond Horse Armor, Emerald
|
||||
if (CheckForStick(color.rgb)) {
|
||||
#include "/lib/materials/specificMaterials/planks/sprucePlanks.glsl"
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/diamondBlock.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45024) { // Netherite Tools, Netherite Armor, Netherite Ingot
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
smoothnessG = color.r * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
highlightMult = smoothnessG * 2.0;
|
||||
smoothnessD = smoothnessG * smoothnessG * 0.5;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
} else /*if (currentRenderedItemId == 45028)*/ { // Trident Item
|
||||
#include "/lib/materials/specificMaterials/others/trident.glsl"
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45048) {
|
||||
if (currentRenderedItemId < 45040) {
|
||||
if (currentRenderedItemId == 45032) { // Lava Bucket
|
||||
if (color.r + color.g > color.b * 2.0) {
|
||||
emission = color.r + color.g - color.b * 1.5;
|
||||
emission *= 1.8;
|
||||
color.rg += color.b * vec2(0.4, 0.15);
|
||||
color.b *= 0.8;
|
||||
if (LAVA_TEMPERATURE != 0.0) maRecolor += LAVA_TEMPERATURE * 0.1;
|
||||
emission *= LAVA_EMISSION;
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
} else {
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
} else /*if (currentRenderedItemId == 45036)*/ { // Bucket++
|
||||
if (GetMaxColorDif(color.rgb) < 0.01) {
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
} else {
|
||||
float factor = color.b;
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 2.0;
|
||||
smoothnessD = factor;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45040) { // Blaze Rod, Blaze Powder
|
||||
noSmoothLighting = false;
|
||||
lmCoordM.x = 0.85;
|
||||
emission = color.g;
|
||||
color.rgb = sqrt1(color.rgb);
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 2.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
} else /*if (currentRenderedItemId == 45044)*/ { // Bottle o' Enchanting, Glow Inc Sac
|
||||
emission = color.b * 2.0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45056) {
|
||||
if (currentRenderedItemId == 45048) { // Fire Charge
|
||||
emission = max0(color.r + color.g - color.b * 0.5);
|
||||
#ifdef SOUL_SAND_VALLEY_OVERHAUL_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 5.0, colorSoul, inSoulValley);
|
||||
#endif
|
||||
#ifdef PURPLE_END_FIRE_INTERNAL
|
||||
color.rgb = changeColorFunction(color.rgb, 5.0, colorEndBreath, 1.0);
|
||||
#endif
|
||||
} else /*if (currentRenderedItemId == 45052)*/ { // Chorus Fruit
|
||||
emission = max0(color.b * 2.0 - color.r) * 1.5;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45056) { // Amethyst Shard
|
||||
materialMask = OSIEBCA; // Intense Fresnel
|
||||
float factor = pow2(color.r);
|
||||
smoothnessG = 0.8 - factor * 0.3;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
} else /*if (currentRenderedItemId == 45060)*/ { // Shield
|
||||
float factor = min(color.r * color.g * color.b * 4.0, 0.7) * 0.7;
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45096) {
|
||||
if (currentRenderedItemId < 45080) {
|
||||
if (currentRenderedItemId < 45072) {
|
||||
if (currentRenderedItemId == 45064) { // Turtle Shell
|
||||
float factor = color.g * 0.7;
|
||||
smoothnessG = factor;
|
||||
highlightMult = factor * 3.0;
|
||||
smoothnessD = factor;
|
||||
} else /*if (currentRenderedItemId == 45068)*/ { // Ender Pearl
|
||||
smoothnessG = 1.0;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 1.0;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45072) { // Eye of Ender
|
||||
smoothnessG = 1.0;
|
||||
highlightMult = 2.0;
|
||||
smoothnessD = 1.0;
|
||||
emission = max0(color.g - color.b * 0.25);
|
||||
color.rgb = pow(color.rgb, vec3(1.0 - 0.75 * emission));
|
||||
} else /*if (currentRenderedItemId == 45076)*/ { // Clock
|
||||
if (
|
||||
CheckForColor(color.rgb, vec3(255, 255, 0)) ||
|
||||
CheckForColor(color.rgb, vec3(204, 204, 0)) ||
|
||||
CheckForColor(color.rgb, vec3(73, 104, 216)) ||
|
||||
CheckForColor(color.rgb, vec3(58, 83, 172)) ||
|
||||
CheckForColor(color.rgb, vec3(108, 108, 137)) ||
|
||||
CheckForColor(color.rgb, vec3(86, 86, 109))
|
||||
) {
|
||||
emission = 1.0;
|
||||
color.rgb += vec3(0.1);
|
||||
}
|
||||
|
||||
#include "/lib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45088) {
|
||||
if (currentRenderedItemId == 45080) { // Compass
|
||||
if (color.r - 0.1 > color.b + color.g) {
|
||||
emission = color.r * 1.5;
|
||||
}
|
||||
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
} else /*if (currentRenderedItemId == 45084)*/ { // Echo Shard, Recovery Compass, Music Disc 5
|
||||
emission = max0(color.b + color.g - color.r * 2.0);
|
||||
|
||||
#include "/lib/materials/specificMaterials/terrain/ironBlock.glsl"
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45088) { // Nether Star
|
||||
emission = pow2(color.r + color.g) * 0.5;
|
||||
} else /*if (currentRenderedItemId == 45092)*/ { // End Crystal
|
||||
if (color.g < color.r) {
|
||||
emission = 3.0;
|
||||
color.r *= 1.1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45112) {
|
||||
if (currentRenderedItemId < 45104) {
|
||||
if (currentRenderedItemId == 45096) { // Glow Berries
|
||||
// iris needs to add support
|
||||
} else /*if (currentRenderedItemId == 45100)*/ { // Glowstone Dust
|
||||
emission = dot(color.rgb, color.rgb) * 0.5 + 1.0;
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45104) { // Prismarine Crystals
|
||||
emission = pow1_5(color.r) * 2.5 + 0.2;
|
||||
} else /*if (currentRenderedItemId == 45108)*/ { // Totem of Undying
|
||||
#include "/lib/materials/specificMaterials/terrain/goldBlock.glsl"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId < 45120) {
|
||||
if (currentRenderedItemId == 45112) { // Trial Key
|
||||
emission = max0(color.r - color.b) * 3.0;
|
||||
color.rgb = pow(color.rgb, vec3(1.0 + 0.5 * sqrt(emission)));
|
||||
} else /*if (currentRenderedItemId == 45116)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (currentRenderedItemId == 45120) { //
|
||||
|
||||
} else /*if (currentRenderedItemId == 45124)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,172 @@
|
||||
if (mat < 32008) {
|
||||
if (mat < 30016) {
|
||||
if (mat < 30008) {
|
||||
if (mat == 30000) { //
|
||||
|
||||
} else if (mat == 30004) { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (mat == 30008) { // Tinted Glass
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
uint voxelID = uint(254);
|
||||
bool isPane = false;
|
||||
DoConnectedGlass(colorP, color, noGeneratedNormals, playerPos, worldGeoNormal, voxelID, isPane);
|
||||
#endif
|
||||
color.a = pow(color.a, 1.0 - fresnel * 0.65);
|
||||
reflectMult = 0.75;
|
||||
overlayNoiseAlpha = 0.95;
|
||||
sandNoiseIntensity = 0.5;
|
||||
mossNoiseIntensity = 0.5;
|
||||
} else /*if (mat == 30012)*/ { // Slime Block
|
||||
translucentMultCalculated = true;
|
||||
reflectMult = 0.7;
|
||||
translucentMult.rgb = pow2(color.rgb) * 0.2;
|
||||
|
||||
smoothnessG = color.g * 0.7;
|
||||
highlightMult = 2.5;
|
||||
overlayNoiseAlpha = 0.6;
|
||||
sandNoiseIntensity = 0.5;
|
||||
mossNoiseIntensity = 0.5;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 32000) {
|
||||
if (mat < 31000) {
|
||||
if (mat == 30016) { // Honey Block
|
||||
translucentMultCalculated = true;
|
||||
reflectMult = 1.0;
|
||||
translucentMult.rgb = pow2(color.rgb) * 0.2;
|
||||
|
||||
smoothnessG = color.r * 0.7;
|
||||
highlightMult = 2.5;
|
||||
overlayNoiseAlpha = 0.4;
|
||||
sandNoiseIntensity = 0.5;
|
||||
mossNoiseIntensity = 0.5;
|
||||
} else /*if (mat == 30020)*/ { // Nether Portal
|
||||
#ifdef SPECIAL_PORTAL_EFFECTS
|
||||
#include "/lib/materials/specificMaterials/translucents/netherPortal.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
}
|
||||
} else { // (31XXX)
|
||||
if (mat % 2 == 0) { // Stained Glass
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
uint voxelID = uint(200 + (mat - 31000) / 2);
|
||||
bool isPane = false;
|
||||
DoConnectedGlass(colorP, color, noGeneratedNormals, playerPos, worldGeoNormal, voxelID, isPane);
|
||||
#endif
|
||||
#include "/lib/materials/specificMaterials/translucents/stainedGlass.glsl"
|
||||
overlayNoiseAlpha = 1.05;
|
||||
mossNoiseIntensity = 0.8;
|
||||
} else /*if (mat % 2 == 1)*/ { // Stained Glass Pane
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
uint voxelID = uint(200 + (mat - 31000) / 2);
|
||||
bool isPane = true;
|
||||
DoConnectedGlass(colorP, color, noGeneratedNormals, playerPos, worldGeoNormal, voxelID, isPane);
|
||||
#endif
|
||||
#include "/lib/materials/specificMaterials/translucents/stainedGlass.glsl"
|
||||
noSmoothLighting = true;
|
||||
overlayNoiseAlpha = 1.05;
|
||||
sandNoiseIntensity = 0.8;
|
||||
mossNoiseIntensity = 0.8;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat == 32000) { // Water
|
||||
#ifdef SHADER_WATER
|
||||
#include "/lib/materials/specificMaterials/translucents/water.glsl"
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.0;
|
||||
overlayNoiseFresnelMult = 0.0;
|
||||
IPBRMult = 0.0;
|
||||
overlayNoiseAlpha = 0.0;
|
||||
} else /*if (mat == 32004)*/ { // Ice
|
||||
smoothnessG = pow2(color.g) * color.g;
|
||||
highlightMult = pow2(min1(pow2(color.g) * 1.5)) * 3.5;
|
||||
|
||||
reflectMult = 0.7;
|
||||
overlayNoiseAlpha = 0.6;
|
||||
sandNoiseIntensity = 0.7;
|
||||
mossNoiseIntensity = 0.7;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 32024) {
|
||||
if (mat < 32016) {
|
||||
if (mat == 32008) { // Glass
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
uint voxelID = uint(217);
|
||||
bool isPane = false;
|
||||
DoConnectedGlass(colorP, color, noGeneratedNormals, playerPos, worldGeoNormal, voxelID, isPane);
|
||||
#endif
|
||||
#include "/lib/materials/specificMaterials/translucents/glass.glsl"
|
||||
overlayNoiseAlpha = 0.8;
|
||||
sandNoiseIntensity = 0.8;
|
||||
mossNoiseIntensity = 0.8;
|
||||
} else /*if (mat == 32012)*/ { // Glass Pane
|
||||
#ifdef CONNECTED_GLASS_EFFECT
|
||||
uint voxelID = uint(218);
|
||||
bool isPane = true;
|
||||
DoConnectedGlass(colorP, color, noGeneratedNormals, playerPos, worldGeoNormal, voxelID, isPane);
|
||||
#endif
|
||||
if (color.a < 0.001 && abs(NdotU) > 0.95) discard; // Fixing artifacts on CTM/Opti connected glass panes
|
||||
#include "/lib/materials/specificMaterials/translucents/glass.glsl"
|
||||
noSmoothLighting = true;
|
||||
overlayNoiseAlpha = 0.8;
|
||||
sandNoiseIntensity = 0.8;
|
||||
mossNoiseIntensity = 0.8;
|
||||
}
|
||||
} else {
|
||||
if (mat == 32016) { // Beacon
|
||||
lmCoordM.x = 0.88;
|
||||
|
||||
translucentMultCalculated = true;
|
||||
translucentMult = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
|
||||
if (color.b > 0.5) {
|
||||
if (color.g - color.b < 0.01 && color.g < 0.99) {
|
||||
#include "/lib/materials/specificMaterials/translucents/glass.glsl"
|
||||
} else { // Beacon:Center
|
||||
lmCoordM = vec2(0.0);
|
||||
noDirectionalShading = true;
|
||||
|
||||
float lColor = length(color.rgb);
|
||||
vec3 baseColor = vec3(0.1, 1.0, 0.92);
|
||||
if (lColor > 1.5) color.rgb = baseColor + 0.22;
|
||||
else if (lColor > 1.3) color.rgb = baseColor + 0.15;
|
||||
else if (lColor > 1.15) color.rgb = baseColor + 0.09;
|
||||
else color.rgb = baseColor + 0.05;
|
||||
emission = 4.0;
|
||||
}
|
||||
} else { // Beacon:Obsidian
|
||||
float factor = color.r * 1.5;
|
||||
|
||||
smoothnessG = factor;
|
||||
highlightMult = 2.0 + min1(smoothnessG * 2.0) * 1.5;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
}
|
||||
overlayNoiseAlpha = 0.8;
|
||||
sandNoiseIntensity = 0.5;
|
||||
mossNoiseIntensity = 0.5;
|
||||
} else /*if (mat == 32020)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (mat < 32032) {
|
||||
if (mat == 32024) { //
|
||||
|
||||
} else /*if (mat == 32028)*/ { //
|
||||
|
||||
}
|
||||
} else {
|
||||
if (mat == 32032) { //
|
||||
|
||||
} else /*if (mat == 32036)*/ { //
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
/*
|
||||
This file is specifically licensed with Mozilla Public License Version 2.0.
|
||||
You can get a copy from https://www.mozilla.org/MPL/2.0/
|
||||
*/
|
||||
|
||||
float manualDeterminant(mat2 matrix) {
|
||||
return matrix[0].x * matrix[1].y - matrix[0].y * matrix[1].x;
|
||||
}
|
||||
|
||||
mat2 inverseM(mat2 m) {
|
||||
#if MC_VERSION >= 11700
|
||||
return inverse(m);
|
||||
#else
|
||||
mat2 adj;
|
||||
adj[0][0] = m[1][1];
|
||||
adj[0][1] = -m[0][1];
|
||||
adj[1][0] = -m[1][0];
|
||||
adj[1][1] = m[0][0];
|
||||
return adj / manualDeterminant(m);
|
||||
#endif
|
||||
}
|
||||
|
||||
vec4 textureAF(sampler2D texSampler, vec2 uv) {
|
||||
vec2 spriteDimensions = vec2(spriteBounds.z - spriteBounds.x, spriteBounds.w - spriteBounds.y);
|
||||
|
||||
mat2 J = inverseM(mat2(dFdx(uv), dFdy(uv)));
|
||||
J = transpose(J)*J;
|
||||
float d = manualDeterminant(J), t = J[0][0]+J[1][1],
|
||||
D = sqrt(abs(t*t-4.001*d)), // using 4.001 instead of 4.0 fixes a rare texture glitch with square texture atlas
|
||||
V = (t-D)/2.0, v = (t+D)/2.0,
|
||||
M = 1.0/sqrt(V), m = 1./sqrt(v);
|
||||
vec2 A = M * normalize(vec2(-J[0][1], J[0][0]-V));
|
||||
|
||||
float lod = 0.0;
|
||||
#if ANISOTROPIC_FILTER >= 8 && defined GBUFFERS_TERRAIN
|
||||
// Fix257062 - Checking if absMidCoordPos is fine or else miplevel will be broken. This can be an issue for flowing lava.
|
||||
if (absMidCoordPos.x > 0.0001)
|
||||
// Excluding cutout blocks for better looks
|
||||
if (texture2DLod(texSampler, uv, 10000.0).a == 1.0)
|
||||
lod = miplevel * 0.4;
|
||||
#endif
|
||||
|
||||
float samplesDiv2 = ANISOTROPIC_FILTER / 2.0;
|
||||
vec2 ADivSamples = A / ANISOTROPIC_FILTER;
|
||||
|
||||
vec4 filteredColor = vec4(0.0);
|
||||
vec4 spriteBoundsM = mix(spriteBounds, vec4(midCoord, midCoord), 0.0001); // Fixes some mods causing issues with cutout blocks
|
||||
for (float i = -samplesDiv2 + 0.5; i < samplesDiv2; i++) {
|
||||
vec2 sampleUV = uv + ADivSamples * i;
|
||||
sampleUV = clamp(sampleUV, spriteBoundsM.xy, spriteBoundsM.zw);
|
||||
vec4 colorSample = texture2DLod(texSampler, sampleUV, lod);
|
||||
|
||||
filteredColor.rgb += colorSample.rgb * colorSample.a;
|
||||
filteredColor.a += colorSample.a;
|
||||
}
|
||||
filteredColor.rgb /= filteredColor.a;
|
||||
filteredColor.a /= ANISOTROPIC_FILTER;
|
||||
|
||||
return filteredColor;
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
const float packSizeNT = COATED_TEXTURE_RES;
|
||||
|
||||
void CoatTextures(inout vec3 color, float noiseFactor, vec3 playerPos, bool doTileRandomisation) {
|
||||
#ifndef ENTITY_GN_AND_CT
|
||||
#if defined GBUFFERS_ENTITIES || defined GBUFFERS_HAND
|
||||
return;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef SAFER_GENERATED_NORMALS
|
||||
vec2 noiseCoord = floor(midCoordPos / 16.0 * packSizeNT * atlasSizeM) / packSizeNT / 3.0;
|
||||
#else
|
||||
vec2 offsetR = max(absMidCoordPos.x, absMidCoordPos.y) * vec2(float(atlasSizeM.y) / float(atlasSizeM.x), 1.0);
|
||||
vec2 noiseCoord = floor(midCoordPos / 2.0 * packSizeNT / offsetR) / packSizeNT / 3.0;
|
||||
#endif
|
||||
|
||||
if (doTileRandomisation) {
|
||||
vec3 floorWorldPos = floor(playerPos + cameraPosition + 0.001);
|
||||
noiseCoord += 0.84 * (floorWorldPos.xz + floorWorldPos.y);
|
||||
}
|
||||
|
||||
float noiseTexture = texture2D(noisetex, noiseCoord).r;
|
||||
noiseTexture = noiseTexture + 0.6;
|
||||
float colorBrightness = dot(color, color) * 0.3;
|
||||
#define COATED_TEXTURE_MULT_M COATED_TEXTURE_MULT * 0.0027
|
||||
noiseFactor *= COATED_TEXTURE_MULT_M * max0(1.0 - colorBrightness);
|
||||
noiseFactor *= max(1.0 - miplevel * 0.25, 0.0);
|
||||
noiseTexture = pow(noiseTexture, noiseFactor);
|
||||
color *= noiseTexture;
|
||||
}
|
||||
@ -0,0 +1,117 @@
|
||||
ivec3[6] glassOffsets = ivec3[](
|
||||
ivec3( 1, 0, 0),
|
||||
ivec3(-1, 0, 0),
|
||||
ivec3( 0, 1, 0),
|
||||
ivec3( 0,-1, 0),
|
||||
ivec3( 0, 0, 1),
|
||||
ivec3( 0, 0,-1)
|
||||
);
|
||||
|
||||
ivec3[12] glassCornerOffsets = ivec3[](
|
||||
ivec3( 1, 1, 0),
|
||||
ivec3( 1,-1, 0),
|
||||
ivec3(-1, 1, 0),
|
||||
ivec3(-1,-1, 0),
|
||||
ivec3( 0, 1, 1),
|
||||
ivec3( 0, 1,-1),
|
||||
ivec3( 0,-1, 1),
|
||||
ivec3( 0,-1,-1),
|
||||
ivec3( 1, 0, 1),
|
||||
ivec3( 1, 0,-1),
|
||||
ivec3(-1, 0, 1),
|
||||
ivec3(-1, 0,-1)
|
||||
);
|
||||
|
||||
vec2 GetModifiedMidCoord() {
|
||||
float epsilon1 = 0.00001;
|
||||
vec2 midCoord = texCoord - signMidCoordPos * absMidCoordPos;
|
||||
return midCoord - epsilon1;
|
||||
}
|
||||
|
||||
void DoSimpleConnectedGlass(inout vec4 color) {
|
||||
color = texture2DLod(tex, GetModifiedMidCoord(), 0);
|
||||
}
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
void DoConnectedGlass(inout vec4 colorP, inout vec4 color, inout bool noGeneratedNormals, vec3 playerPos, vec3 worldGeoNormal, uint voxelID, bool isPane) {
|
||||
vec3 worldGeoNormalM = vec3( // Fixes Iris 1.8 normal precision issues causing the coordinates to be imperfect
|
||||
round(worldGeoNormal.x),
|
||||
round(worldGeoNormal.y),
|
||||
round(worldGeoNormal.z)
|
||||
);
|
||||
vec3 playerPosM = playerPos - worldGeoNormalM * 0.25;
|
||||
vec3 voxelPos = SceneToVoxel(playerPosM);
|
||||
|
||||
if (CheckInsideVoxelVolume(voxelPos)) {
|
||||
#if IRIS_VERSION >= 10800
|
||||
float epsilon2 = 0.0;
|
||||
#else
|
||||
float epsilon2 = 0.001;
|
||||
#endif
|
||||
float pixelOffset = 0.5 / (absMidCoordPos.y * atlasSize.y);
|
||||
float pixelOffsetPlus = pixelOffset + epsilon2;
|
||||
float pixelOffsetMinus = pixelOffset - epsilon2;
|
||||
|
||||
colorP = texture2DLod(tex, texCoord, 0);
|
||||
vec4 colorPvanilla = colorP;
|
||||
|
||||
vec2 midCoordM = GetModifiedMidCoord();
|
||||
vec3 worldPos = playerPosM + cameraPositionBestFract;
|
||||
vec3 floorWorldPos = floor(worldPos);
|
||||
|
||||
// Remove edges
|
||||
for (int i = 0; i < 6; i++) {
|
||||
uint voxel = texelFetch(voxel_sampler, ivec3(voxelPos) + glassOffsets[i], 0).r;
|
||||
if (voxel == voxelID) {
|
||||
if (floor(worldPos + glassOffsets[i] * pixelOffsetPlus) != floorWorldPos) {
|
||||
colorP = texture2DLod(tex, midCoordM, 0);
|
||||
}
|
||||
#ifdef GENERATED_NORMALS
|
||||
if (floor(worldPos + glassOffsets[i] * pixelOffsetPlus * 1.25) != floorWorldPos) {
|
||||
noGeneratedNormals = true;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
// Fixes the connections by restoring the edges that aren't connected
|
||||
for (int i = 0; i < 6; i++) {
|
||||
uint voxel = texelFetch(voxel_sampler, ivec3(voxelPos) + glassOffsets[i], 0).r;
|
||||
if (voxel != voxelID) {
|
||||
//if (floor(worldPos + glassOffsets[i] * 0.0625) != floorWorldPos) {
|
||||
if (floor(worldPos + glassOffsets[i] * pixelOffsetMinus) != floorWorldPos) {
|
||||
colorP = colorPvanilla;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isPane) {
|
||||
// Fixes lines between layers of glass panes
|
||||
if (NdotU > 0.9) {
|
||||
uint voxel = texelFetch(voxel_sampler, ivec3(voxelPos) + ivec3(0, 1, 0), 0).r;
|
||||
if (voxel == voxelID) discard;
|
||||
}
|
||||
if (NdotU < -0.9) {
|
||||
uint voxel = texelFetch(voxel_sampler, ivec3(voxelPos) - ivec3(0, 1, 0), 0).r;
|
||||
if (voxel == voxelID) discard;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONNECTED_GLASS_CORNER_FIX
|
||||
else {
|
||||
// Restores corners
|
||||
for (int i = 0; i < 12; i++) {
|
||||
uint voxel = texelFetch(voxel_sampler, ivec3(voxelPos) + glassCornerOffsets[i], 0).r;
|
||||
if (voxel != voxelID) {
|
||||
if (floor((worldPos - glassCornerOffsets[i] * (1.0 - pixelOffsetMinus))) == floorWorldPos) {
|
||||
colorP = colorPvanilla;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
color = colorP * vec4(glColor.rgb, 1.0);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,35 @@
|
||||
#ifndef INCLUDE_CUSTOM_EMISSION
|
||||
#define INCLUDE_CUSTOM_EMISSION
|
||||
|
||||
float GetCustomEmission(vec4 specularMap, vec2 texCoordM) {
|
||||
#if CUSTOM_EMISSION_INTENSITY > 0
|
||||
#if RP_MODE == 2 || RP_MODE == 1 && IPBR_EMISSIVE_MODE == 2 // seuspbr
|
||||
float emission = specularMap.b;
|
||||
#elif RP_MODE == 3 || RP_MODE == 1 && IPBR_EMISSIVE_MODE == 3 // labPBR
|
||||
float emission = specularMap.a < 1.0 ? specularMap.a : 0.0;
|
||||
|
||||
vec4 specularMapL0 = texture2DLod(specular, texCoordM, 0);
|
||||
float emissionL0 = specularMapL0.a < 1.0 ? specularMapL0.a : 0.0;
|
||||
emission = min(emission, emissionL0); // Fixes issues caused by mipmaps
|
||||
#endif
|
||||
|
||||
return emission * 0.03 * CUSTOM_EMISSION_INTENSITY;
|
||||
#else
|
||||
return 0.0;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef IPBR
|
||||
float GetCustomEmissionForIPBR(inout vec4 color, float emission) {
|
||||
vec4 specularMapCheck = texture2DLod(specular, texCoord, 1000.0);
|
||||
if (specularMapCheck.a == 0.0) return emission;
|
||||
|
||||
color = texture2D(tex, texCoord);
|
||||
|
||||
vec4 specularMap = texture2D(specular, texCoord);
|
||||
float customEmission = GetCustomEmission(specularMap, texCoord);
|
||||
return customEmission;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //INCLUDE_CUSTOM_EMISSION
|
||||
@ -0,0 +1,85 @@
|
||||
const float normalThreshold = 0.05;
|
||||
const float normalClamp = 0.2;
|
||||
const float packSizeGN = 128.0;
|
||||
|
||||
#ifndef GBUFFERS_HAND
|
||||
const float normalMult = GENERATED_NORMAL_MULT * 0.025;
|
||||
#else
|
||||
const float normalMult = GENERATED_NORMAL_MULT * 0.015;
|
||||
#endif
|
||||
|
||||
float GetDif(float lOriginalAlbedo, vec2 offsetCoord) {
|
||||
#ifndef GBUFFERS_WATER
|
||||
float lNearbyAlbedo = length(texture2D(tex, offsetCoord).rgb);
|
||||
#else
|
||||
vec4 textureSample = texture2D(tex, offsetCoord);
|
||||
float lNearbyAlbedo = length(textureSample.rgb * textureSample.a * 1.5);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
lOriginalAlbedo = abs(lOriginalAlbedo - 1.0);
|
||||
lNearbyAlbedo = abs(lNearbyAlbedo - 1.0);
|
||||
#endif
|
||||
|
||||
float dif = lOriginalAlbedo - lNearbyAlbedo;
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
dif = -dif;
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_WATER
|
||||
if (dif > 0.0) dif = max(dif - normalThreshold, 0.0);
|
||||
else dif = min(dif + normalThreshold, 0.0);
|
||||
#endif
|
||||
|
||||
return clamp(dif, -normalClamp, normalClamp);
|
||||
}
|
||||
|
||||
void GenerateNormals(inout vec3 normalM, vec3 color) {
|
||||
#ifndef ENTITY_GN_AND_CT
|
||||
#if defined GBUFFERS_ENTITIES || defined GBUFFERS_HAND
|
||||
return;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
vec2 absMidCoordPos2 = absMidCoordPos * 2.0;
|
||||
float lOriginalAlbedo = length(color.rgb);
|
||||
|
||||
float normalMult = max0(1.0 - mipDelta) * normalMult;
|
||||
|
||||
#ifndef SAFER_GENERATED_NORMALS
|
||||
vec2 offsetR = 16.0 / atlasSizeM;
|
||||
#else
|
||||
vec2 offsetR = max(absMidCoordPos2.x, absMidCoordPos2.y) * vec2(float(atlasSizeM.y) / float(atlasSizeM.x), 1.0);
|
||||
#endif
|
||||
offsetR /= NORMAL_RES;
|
||||
|
||||
vec2 midCoord = texCoord - midCoordPos;
|
||||
vec2 maxOffsetCoord = midCoord + absMidCoordPos;
|
||||
vec2 minOffsetCoord = midCoord - absMidCoordPos;
|
||||
if (normalMult > 0.0) {
|
||||
vec3 normalMap = vec3(0.0, 0.0, 1.0);
|
||||
|
||||
vec2 offsetCoord = texCoord + vec2( 0.0, offsetR.y);
|
||||
if (offsetCoord.y < maxOffsetCoord.y)
|
||||
normalMap.y += GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2( offsetR.x, 0.0);
|
||||
if (offsetCoord.x < maxOffsetCoord.x)
|
||||
normalMap.x += GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2( 0.0,-offsetR.y);
|
||||
if (offsetCoord.y > minOffsetCoord.y)
|
||||
normalMap.y -= GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
offsetCoord = texCoord + vec2(-offsetR.x, 0.0);
|
||||
if (offsetCoord.x > minOffsetCoord.x)
|
||||
normalMap.x -= GetDif(lOriginalAlbedo, offsetCoord);
|
||||
|
||||
normalMap.xy *= normalMult;
|
||||
normalMap.xy = clamp(normalMap.xy, vec2(-1.0), vec2(1.0));
|
||||
|
||||
if (normalMap.xy != vec2(0.0, 0.0))
|
||||
normalM = clamp(normalize(normalMap * tbnMatrix), vec3(-1.0), vec3(1.0));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,121 @@
|
||||
#include "/lib/util/dither.glsl"
|
||||
|
||||
vec2 vTexCoord = signMidCoordPos * 0.5 + 0.5;
|
||||
|
||||
#include "/lib/util/dFdxdFdy.glsl"
|
||||
|
||||
vec4 ReadNormal(vec2 coord) {
|
||||
coord = fract(coord) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
return textureGrad(normals, coord, dcdx, dcdy);
|
||||
}
|
||||
|
||||
vec2 GetParallaxCoord(float parallaxFade, float dither, inout vec2 newCoord, inout float texDepth, inout vec3 traceCoordDepth) {
|
||||
float invParallaxQuality = 1.0 / POM_QUALITY;
|
||||
vec4 normalMap = ReadNormal(vTexCoord.st);
|
||||
vec2 normalMapM = normalMap.xy * 2.0 - 1.0;
|
||||
float normalCheck = normalMapM.x + normalMapM.y;
|
||||
float minHeight = 1.0 - invParallaxQuality;
|
||||
|
||||
if (viewVector.z >= 0.0 || normalMap.a >= minHeight || normalCheck <= -1.999) return vTexCoord.st;
|
||||
|
||||
vec2 interval = viewVector.xy * 0.25 * (1.0 - parallaxFade) * POM_DEPTH / (-viewVector.z * POM_QUALITY);
|
||||
|
||||
float i = 0.0;
|
||||
vec2 localCoord;
|
||||
#if defined GBUFFERS_TERRAIN || defined GBUFFERS_BLOCK
|
||||
if (texDepth <= 1.0 - i * invParallaxQuality) {
|
||||
localCoord = vTexCoord.st + i * interval;
|
||||
texDepth = ReadNormal(localCoord).a;
|
||||
i = dither;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (; i < POM_QUALITY && texDepth <= 1.0 - i * invParallaxQuality; i++) {
|
||||
localCoord = vTexCoord.st + i * interval;
|
||||
texDepth = ReadNormal(localCoord).a;
|
||||
}
|
||||
|
||||
float pI = float(max(i - 1, 0));
|
||||
traceCoordDepth.xy -= pI * interval;
|
||||
traceCoordDepth.z -= pI * invParallaxQuality;
|
||||
|
||||
localCoord = fract(vTexCoord.st + pI * interval);
|
||||
newCoord = localCoord * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
return localCoord;
|
||||
}
|
||||
|
||||
float GetParallaxShadow(float parallaxFade, float dither, float height, vec2 coord, vec3 lightVec, mat3 tbn) {
|
||||
float parallaxshadow = 1.0;
|
||||
|
||||
vec3 parallaxdir = tbn * lightVec;
|
||||
parallaxdir.xy *= 1.0 * POM_DEPTH; // Angle
|
||||
|
||||
for (int i = 0; i < 4 && parallaxshadow >= 0.01; i++) {
|
||||
float stepLC = 0.025 * (i + dither);
|
||||
|
||||
float currentHeight = height + parallaxdir.z * stepLC;
|
||||
|
||||
vec2 parallaxCoord = fract(coord + parallaxdir.xy * stepLC) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
float offsetHeight = textureGrad(normals, parallaxCoord, dcdx, dcdy).a;
|
||||
|
||||
parallaxshadow *= clamp(1.0 - (offsetHeight - currentHeight) * 4.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
return mix(parallaxshadow, 1.0, parallaxFade);
|
||||
}
|
||||
|
||||
// Big thanks to null511 for slope normals
|
||||
vec3 GetParallaxSlopeNormal(vec2 texCoord, float traceDepth, vec3 viewDir) {
|
||||
vec2 atlasPixelSize = 1.0 / atlasSize;
|
||||
float atlasAspect = atlasSize.x / atlasSize.y;
|
||||
vec2 atlasCoord = fract(texCoord) * vTexCoordAM.pq + vTexCoordAM.st;
|
||||
|
||||
vec2 tileSize = atlasSize * vTexCoordAM.pq;
|
||||
vec2 tilePixelSize = 1.0 / tileSize;
|
||||
|
||||
vec2 tex_snapped = floor(atlasCoord * atlasSize) * atlasPixelSize;
|
||||
vec2 tex_offset = atlasCoord - (tex_snapped + 0.5 * atlasPixelSize);
|
||||
|
||||
vec2 stepSign = sign(tex_offset);
|
||||
vec2 viewSign = sign(viewDir.xy);
|
||||
|
||||
bool dir = abs(tex_offset.x * atlasAspect) < abs(tex_offset.y);
|
||||
vec2 tex_x, tex_y;
|
||||
|
||||
if (dir) {
|
||||
tex_x = texCoord - vec2(tilePixelSize.x * viewSign.x, 0.0);
|
||||
tex_y = texCoord + vec2(0.0, stepSign.y * tilePixelSize.y);
|
||||
}
|
||||
else {
|
||||
tex_x = texCoord + vec2(tilePixelSize.x * stepSign.x, 0.0);
|
||||
tex_y = texCoord - vec2(0.0, viewSign.y * tilePixelSize.y);
|
||||
}
|
||||
|
||||
float height_x = ReadNormal(tex_x).a;
|
||||
float height_y = ReadNormal(tex_y).a;
|
||||
|
||||
if (dir) {
|
||||
if (!(traceDepth > height_y && viewSign.y != stepSign.y)) {
|
||||
if (traceDepth > height_x) return vec3(-viewSign.x, 0.0, 0.0);
|
||||
|
||||
if (abs(viewDir.y) > abs(viewDir.x))
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
else
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
}
|
||||
else {
|
||||
if (!(traceDepth > height_x && viewSign.x != stepSign.x)) {
|
||||
if (traceDepth > height_y) return vec3(0.0, -viewSign.y, 0.0);
|
||||
|
||||
if (abs(viewDir.y) > abs(viewDir.x))
|
||||
return vec3(0.0, -viewSign.y, 0.0);
|
||||
else
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
|
||||
return vec3(-viewSign.x, 0.0, 0.0);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,339 @@
|
||||
#ifdef OVERWORLD
|
||||
#include "/lib/atmospherics/sky.glsl"
|
||||
#ifdef OVERWORLD_BEAMS
|
||||
#include "/lib/atmospherics/overworldBeams.glsl"
|
||||
#endif
|
||||
#ifdef END_PORTAL_BEAM_INTERNAL
|
||||
#include "/lib/atmospherics/endPortalBeam.glsl"
|
||||
#endif
|
||||
#endif
|
||||
#ifdef END
|
||||
#ifdef DEFERRED1
|
||||
#include "/lib/atmospherics/enderBeams.glsl"
|
||||
#endif
|
||||
#if END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0
|
||||
#include "/lib/atmospherics/endCrystalVortex.glsl"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
#include "/lib/colors/colorMultipliers.glsl"
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
#include "/lib/colors/moonPhaseInfluence.glsl"
|
||||
#endif
|
||||
|
||||
vec3 nvec3(vec4 pos) {
|
||||
return pos.xyz/pos.w;
|
||||
}
|
||||
|
||||
vec3 refPos = vec3(0.0);
|
||||
|
||||
vec4 GetReflection(vec3 normalM, vec3 viewPos, vec3 nViewPos, vec3 playerPos, float lViewPos, float z0,
|
||||
sampler2D depthtex, float dither, float skyLightFactor, float fresnel,
|
||||
float smoothness, vec3 geoNormal, vec3 color, vec3 shadowMult, float highlightMult) {
|
||||
// Step 1: Prepare
|
||||
vec2 rEdge = vec2(0.6, 0.55);
|
||||
vec3 normalMR = normalM;
|
||||
|
||||
#if defined GBUFFERS_WATER && WATER_STYLE == 1 && defined GENERATED_NORMALS
|
||||
normalMR = mix(geoNormal, normalM, 0.05);
|
||||
#endif
|
||||
|
||||
vec3 nViewPosR = reflect(nViewPos, normalMR);
|
||||
float RVdotU = dot(normalize(nViewPosR), upVec);
|
||||
float RVdotS = dot(normalize(nViewPosR), sunVec);
|
||||
vec3 worldRefDir = 0.5 * far * (mat3(gbufferModelViewInverse) * nViewPosR);
|
||||
|
||||
#if defined GBUFFERS_WATER && WATER_STYLE >= 2
|
||||
normalMR = mix(geoNormal, normalM, 0.8);
|
||||
#endif
|
||||
// End Step 1
|
||||
|
||||
// Step 2: Calculate Terrain Reflection and Alpha
|
||||
vec4 reflection = vec4(0.0);
|
||||
#if defined DEFERRED1 || WATER_REFLECT_QUALITY >= 1
|
||||
#if (defined DEFERRED1 || WATER_REFLECT_QUALITY >= 2) && (!defined DH_WATER || DETAIL_QUALITY >= 3)
|
||||
// Method 1: Ray Marched Reflection //
|
||||
|
||||
// Ray Marching
|
||||
vec3 start = viewPos + normalMR * (lViewPos * 0.025 * (1.0 - fresnel) + 0.05);
|
||||
#if defined GBUFFERS_WATER && WATER_STYLE >= 2
|
||||
vec3 vectorBase = reflect(nViewPos, normalize(normalMR)); // Not using nViewPosR because normalMR changed
|
||||
#else
|
||||
vec3 vectorBase = nViewPosR;
|
||||
#endif
|
||||
//vector = normalize(vector - 0.5 * (1.0 - smoothness) * (1.0 - fresnel) * normalMR); // reflection anisotropy test
|
||||
//vector = normalize(vector - 0.075 * dither * (1.0 - pow2(pow2(fresnel))) * normalMR);
|
||||
vectorBase *= 0.5;
|
||||
vec3 viewPosRTBase = viewPos + vectorBase;
|
||||
|
||||
vec3 vector = vec3(0.0);
|
||||
vec3 viewPosRT = vec3(0.0);
|
||||
|
||||
float dist = 0.0;
|
||||
vec3 rfragpos = vec3(0.0);
|
||||
|
||||
// Normal pass
|
||||
{
|
||||
vector = vectorBase;
|
||||
viewPosRT = viewPosRTBase;
|
||||
|
||||
vec3 tvector = vector;
|
||||
int sr = 0;
|
||||
for (int i = 0; i < 30; i++) {
|
||||
refPos = nvec3(gbufferProjection * vec4(viewPosRT, 1.0)) * 0.5 + 0.5;
|
||||
if (abs(refPos.x - 0.5) > rEdge.x || abs(refPos.y - 0.5) > rEdge.y) break;
|
||||
|
||||
rfragpos = vec3(refPos.xy, texture2D(depthtex, refPos.xy).r);
|
||||
rfragpos = nvec3(gbufferProjectionInverse * vec4(rfragpos * 2.0 - 1.0, 1.0));
|
||||
dist = length(start - rfragpos);
|
||||
|
||||
float err = length(viewPosRT - rfragpos);
|
||||
|
||||
if (err < length(vector) * 3.0) {
|
||||
sr++;
|
||||
if (sr >= 6) break;
|
||||
tvector -= vector;
|
||||
vector *= 0.1;
|
||||
}
|
||||
vector *= 2.0;
|
||||
tvector += vector * (0.95 + 0.1 * dither);
|
||||
viewPosRT = start + tvector;
|
||||
}
|
||||
}
|
||||
|
||||
// DH pass on non-DH (if there is nothing blocking)
|
||||
#if defined DISTANT_HORIZONS && !defined DH_WATER && DETAIL_QUALITY >= 3
|
||||
if (refPos.z > 0.99997) {
|
||||
vector = vectorBase;
|
||||
viewPosRT = viewPosRTBase;
|
||||
|
||||
vec3 tvector = vector;
|
||||
int sr = 0;
|
||||
for (int i = 0; i < 30; i++) {
|
||||
refPos = nvec3(dhProjection * vec4(viewPosRT, 1.0)) * 0.5 + 0.5;
|
||||
if (abs(refPos.x - 0.5) > rEdge.x || abs(refPos.y - 0.5) > rEdge.y) break;
|
||||
|
||||
rfragpos = vec3(refPos.xy, texture2D(dhDepthTex1, refPos.xy).r);
|
||||
rfragpos = nvec3(dhProjectionInverse * vec4(rfragpos * 2.0 - 1.0, 1.0));
|
||||
dist = length(start - rfragpos);
|
||||
|
||||
float err = length(viewPosRT - rfragpos);
|
||||
|
||||
if (err < length(vector) * 3.0) {
|
||||
sr++;
|
||||
if (sr >= 6) break;
|
||||
tvector -= vector;
|
||||
vector *= 0.1;
|
||||
}
|
||||
vector *= 2.0;
|
||||
tvector += vector * (0.95 + 0.1 * dither);
|
||||
viewPosRT = start + tvector;
|
||||
}
|
||||
|
||||
if (texture2D(depthtex, refPos.xy).r < 0.99997) refPos.z = 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Finalizing Terrain Reflection and Alpha
|
||||
if (refPos.z < 0.99997) {
|
||||
vec2 absPos = abs(refPos.xy - 0.5);
|
||||
vec2 cdist = absPos / rEdge;
|
||||
float border = clamp(1.0 - pow(max(cdist.x, cdist.y), 50.0), 0.0, 1.0);
|
||||
reflection.a = border;
|
||||
|
||||
float lViewPosRT = length(rfragpos);
|
||||
|
||||
if (reflection.a > 0.001) {
|
||||
vec2 edgeFactor = pow2(pow2(pow2(cdist)));
|
||||
refPos.y += (dither - 0.5) * (0.05 * (edgeFactor.x + edgeFactor.y));
|
||||
|
||||
#ifdef DEFERRED1
|
||||
float smoothnessDM = pow2(smoothness);
|
||||
float lodFactor = 1.0 - exp(-0.125 * (1.0 - smoothnessDM) * dist);
|
||||
float lod = log2(viewHeight / 8.0 * (1.0 - smoothnessDM) * lodFactor) * 0.45;
|
||||
if (z0 <= 0.56) lod *= 2.22; // Using more lod to compensate for less roughness noise on held items
|
||||
lod = max(lod - 1.0, 0.0);
|
||||
|
||||
reflection.rgb = texture2DLod(colortex0, refPos.xy, lod).rgb;
|
||||
#else
|
||||
reflection = texture2D(gaux2, refPos.xy);
|
||||
reflection.rgb = pow2(reflection.rgb + 1.0);
|
||||
#endif
|
||||
|
||||
float skyFade = 0.0;
|
||||
DoFog(reflection.rgb, skyFade, lViewPosRT, ViewToPlayer(rfragpos.xyz), RVdotU, RVdotS, dither);
|
||||
|
||||
edgeFactor.x = pow2(edgeFactor.x);
|
||||
edgeFactor = 1.0 - edgeFactor;
|
||||
reflection.a *= pow(edgeFactor.x * edgeFactor.y, 2.0 + 3.0 * GetLuminance(reflection.rgb));
|
||||
}
|
||||
|
||||
float posDif = lViewPosRT - lViewPos;
|
||||
reflection.a *= clamp(posDif + 3.0, 0.0, 1.0);
|
||||
}
|
||||
#if defined DEFERRED1 && defined TEMPORAL_FILTER
|
||||
else refPos.z = 1.0;
|
||||
#endif
|
||||
#if !defined DEFERRED1 && defined DISTANT_HORIZONS && DETAIL_QUALITY < 3
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
#if !defined DEFERRED1 && (WATER_REFLECT_QUALITY < 2 || (defined DISTANT_HORIZONS && DETAIL_QUALITY < 3))
|
||||
{ // Method 2: Mirorred Image Reflection //
|
||||
|
||||
#if WATER_REFLECT_QUALITY < 2
|
||||
float verticalStretch = 0.013; // for potato quality reflections
|
||||
#else
|
||||
float verticalStretch = 0.0025; // for distant horizons reflections
|
||||
#endif
|
||||
|
||||
vec4 clipPosR = gbufferProjection * vec4(nViewPosR + verticalStretch * viewPos, 1.0);
|
||||
vec3 screenPosR = clipPosR.xyz / clipPosR.w * 0.5 + 0.5;
|
||||
vec2 screenPosRM = abs(screenPosR.xy - 0.5);
|
||||
|
||||
if (screenPosRM.x < rEdge.x && screenPosRM.y < rEdge.y) {
|
||||
vec2 edgeFactor = pow2(pow2(pow2(screenPosRM / rEdge)));
|
||||
screenPosR.y += (dither - 0.5) * (0.03 * (edgeFactor.x + edgeFactor.y) + 0.004);
|
||||
|
||||
screenPosR.z = texture2D(depthtex1, screenPosR.xy).x;
|
||||
vec3 viewPosR = ScreenToView(screenPosR);
|
||||
if (lViewPos <= 2.0 + length(viewPosR)) {
|
||||
reflection = texture2D(gaux2, screenPosR.xy);
|
||||
reflection.rgb = pow2(reflection.rgb + 1.0);
|
||||
}
|
||||
|
||||
edgeFactor.x = pow2(edgeFactor.x);
|
||||
edgeFactor = 1.0 - edgeFactor;
|
||||
reflection.a *= edgeFactor.x * edgeFactor.y;
|
||||
}
|
||||
|
||||
reflection.a *= reflection.a;
|
||||
reflection.a *= clamp01((dot(nViewPos, nViewPosR) - 0.45) * 10.0); // Fixes perpendicular ref
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
// End Step 2
|
||||
|
||||
// Step 3: Add Sky Reflection
|
||||
#if defined DEFERRED1 || WATER_REFLECT_QUALITY >= 1
|
||||
if (reflection.a < 1.0)
|
||||
#endif
|
||||
{
|
||||
#ifdef OVERWORLD
|
||||
#if defined DEFERRED1 || WATER_REFLECT_QUALITY >= 2
|
||||
vec3 skyReflection = GetSky(RVdotU, RVdotS, dither, true, true);
|
||||
#else
|
||||
vec3 skyReflection = GetLowQualitySky(RVdotU, RVdotS, dither, true, true);
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
skyReflection *= atmColorMult;
|
||||
#endif
|
||||
#ifdef MOON_PHASE_INF_ATMOSPHERE
|
||||
skyReflection *= moonPhaseInfluence;
|
||||
#endif
|
||||
|
||||
#ifdef DEFERRED1
|
||||
skyReflection *= skyLightFactor;
|
||||
#ifdef OVERWORLD_BEAMS
|
||||
skyReflection += DrawOverworldBeams(RVdotU, playerPos, viewPos).rgb * 0.01;
|
||||
#endif
|
||||
#else
|
||||
float specularHighlight = GGX(normalM, nViewPos, lightVec, max(dot(normalM, lightVec), 0.0), smoothness);
|
||||
skyReflection += specularHighlight * highlightColor * shadowMult * highlightMult * invRainFactor;
|
||||
|
||||
#if WATER_REFLECT_QUALITY >= 1
|
||||
#ifdef SKY_EFFECT_REFLECTION
|
||||
float cloudLinearDepth = 1.0;
|
||||
float skyFade = 1.0;
|
||||
vec3 auroraBorealis = vec3(0.0);
|
||||
vec3 nightNebula = vec3(0.0);
|
||||
|
||||
#if AURORA_STYLE > 0
|
||||
auroraBorealis = GetAuroraBorealis(nViewPosR, RVdotU, dither);
|
||||
skyReflection += auroraBorealis;
|
||||
#endif
|
||||
#ifdef NIGHT_NEBULA
|
||||
nightNebula += GetNightNebula(nViewPosR, RVdotU, RVdotS);
|
||||
skyReflection += nightNebula;
|
||||
#endif
|
||||
#ifdef OVERWORLD_BEAMS
|
||||
skyReflection += (DrawOverworldBeams(RVdotU, playerPos, viewPos) * 0.4 + 0.6).rgb * 0.08;
|
||||
#endif
|
||||
|
||||
vec2 starCoord = GetStarCoord(nViewPosR, 0.5);
|
||||
#if STAR_BRIGHTNESS != 3
|
||||
vec3 starColor = GetStars(starCoord, RVdotU, RVdotS, 1.0, 0.0);
|
||||
|
||||
#define ADD_STAR_LAYER_OW1 (STAR_LAYER_OW == 1 || STAR_LAYER_OW == 3)
|
||||
#define ADD_STAR_LAYER_OW2 (STAR_LAYER_OW == 2 || STAR_LAYER_OW == 3)
|
||||
|
||||
#if ADD_STAR_LAYER_OW1
|
||||
starColor = max(starColor, GetStars(starCoord, RVdotU, RVdotS, 0.66, 0.0));
|
||||
#endif
|
||||
|
||||
#if ADD_STAR_LAYER_OW2
|
||||
starColor = max(starColor, GetStars(starCoord, RVdotU, RVdotS, 2.2, 0.45));
|
||||
#endif
|
||||
|
||||
skyReflection += starColor;
|
||||
#endif
|
||||
|
||||
#ifdef VL_CLOUDS_ACTIVE
|
||||
vec3 worldNormalMR = normalize(mat3(gbufferModelViewInverse) * normalMR);
|
||||
vec3 RCameraPos = cameraPosition + 2.0 * worldNormalMR * dot(playerPos, worldNormalMR);
|
||||
vec3 RPlayerPos = normalize(mat3(gbufferModelViewInverse) * nViewPosR);
|
||||
float RlViewPos = 100000.0;
|
||||
|
||||
vec4 clouds = GetClouds(cloudLinearDepth, skyFade, RCameraPos, RPlayerPos,
|
||||
viewPos, RlViewPos, RVdotS, RVdotU, dither, auroraBorealis, nightNebula);
|
||||
|
||||
skyReflection = mix(skyReflection, clouds.rgb, clouds.a);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
skyReflection = mix(color * 0.5, skyReflection, skyLightFactor);
|
||||
#else
|
||||
skyReflection = mix(color, skyReflection, skyLightFactor * 0.5);
|
||||
#endif
|
||||
#endif
|
||||
#elif defined END
|
||||
#if defined DEFERRED1 && defined END_BEAMS
|
||||
vec3 skyReflection = (endSkyColor + 0.4 * DrawEnderBeams(RVdotU, playerPos)) * skyLightFactor;
|
||||
#else
|
||||
vec3 skyReflection = endSkyColor * shadowMult;
|
||||
#endif
|
||||
|
||||
#if defined ATM_COLOR_MULTS || defined SPOOKY
|
||||
skyReflection *= atmColorMult;
|
||||
#endif
|
||||
#else
|
||||
vec3 skyReflection = vec3(0.0);
|
||||
#endif
|
||||
|
||||
#if RETRO_LOOK == 1
|
||||
color.rgb *= vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.5 * RETRO_LOOK_I;
|
||||
#elif RETRO_LOOK == 2
|
||||
color.rgb *= mix(vec3(1.0), vec3(RETRO_LOOK_R, RETRO_LOOK_G, RETRO_LOOK_B) * 0.5 * RETRO_LOOK_I, nightVision);
|
||||
#endif
|
||||
|
||||
reflection.rgb = mix(skyReflection, reflection.rgb, reflection.a);
|
||||
}
|
||||
// End Step 3
|
||||
|
||||
// Step 4: Add volumetrics to reflection
|
||||
{
|
||||
#if (defined DEFERRED1 || (WATER_REFLECT_QUALITY >= 2 && defined SKY_EFFECT_REFLECTION)) && (END_CRYSTAL_VORTEX_INTERNAL > 0 || DRAGON_DEATH_EFFECT_INTERNAL > 0)
|
||||
reflection.rgb += EndCrystalVortices(playerPos, worldRefDir, dither).rgb;
|
||||
#endif
|
||||
#if (defined DEFERRED1 || (WATER_REFLECT_QUALITY >= 2 && defined SKY_EFFECT_REFLECTION)) && defined END_PORTAL_BEAM_INTERNAL
|
||||
vec4 refPosPlayer = gbufferModelViewInverse * (gbufferProjectionInverse * vec4(refPos * 2.0 - 1.0, 1.0));
|
||||
refPosPlayer /= refPosPlayer.w;
|
||||
reflection.rgb += sqrt(GetEndPortalBeam(playerPos, refPosPlayer.xyz * reflection.a - playerPos).rgb);
|
||||
#endif
|
||||
}
|
||||
|
||||
return reflection;
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
float GetApproxDistance(float depth) {
|
||||
return near * far / (far - depth * far);
|
||||
}
|
||||
|
||||
void DoRefraction(inout vec3 color, inout float z0, inout float z1, vec3 viewPos, float lViewPos) {
|
||||
// Prep
|
||||
if (int(texelFetch(colortex6, texelCoord, 0).g * 255.1) != 241) return;
|
||||
|
||||
float fovScale = gbufferProjection[1][1];
|
||||
|
||||
vec3 playerPos = ViewToPlayer(viewPos.xyz);
|
||||
vec3 worldPos = playerPos.xyz + cameraPosition.xyz;
|
||||
vec2 worldPosRM = worldPos.xz * 0.02 + worldPos.y * 0.01 + 0.01 * frameTimeCounter;
|
||||
|
||||
vec2 refractNoise = texture2D(noisetex, worldPosRM).rb - vec2(0.5);
|
||||
refractNoise *= WATER_REFRACTION_INTENSITY * fovScale / (3.0 + lViewPos);
|
||||
|
||||
#if WATER_STYLE < 3
|
||||
refractNoise *= 0.015;
|
||||
#else
|
||||
refractNoise *= 0.02;
|
||||
#endif
|
||||
|
||||
// Check
|
||||
float approxDif = GetApproxDistance(z1) - GetApproxDistance(z0);
|
||||
refractNoise *= clamp(approxDif, 0.0, 1.0);
|
||||
|
||||
vec2 refractCoord = texCoord.xy + refractNoise;
|
||||
|
||||
if (int(texture2D(colortex6, refractCoord).g * 255.1) != 241) return;
|
||||
|
||||
float z0check = texture2D(depthtex0, refractCoord).r;
|
||||
float z1check = texture2D(depthtex1, refractCoord).r;
|
||||
float approxDifCheck = GetApproxDistance(z1check) - GetApproxDistance(z0check);
|
||||
refractNoise *= clamp(approxDifCheck, 0.0, 1.0);
|
||||
|
||||
// Sample
|
||||
refractCoord = texCoord.xy + refractNoise;
|
||||
color = texture2D(colortex0, refractCoord).rgb;
|
||||
z0 = texture2D(depthtex0, refractCoord).r;
|
||||
z1 = texture2D(depthtex1, refractCoord).r;
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
const float packSizeSW = 16.0;
|
||||
|
||||
void DoSnowyWorld(inout vec4 color, inout float smoothnessG, inout float highlightMult, inout float smoothnessD, inout float emission,
|
||||
vec3 playerPos, vec2 lmCoord, float snowFactor, float snowMinNdotU, float NdotU, int subsurfaceMode) {
|
||||
float snowFactorM = snowFactor * 1000.0 * max(NdotU - 0.9, snowMinNdotU) * max0(lmCoord.y - 0.9) * (0.9 - clamp(lmCoord.x, 0.8, 0.9));
|
||||
if (snowFactorM <= 0.0001) return;
|
||||
|
||||
vec3 worldPos = playerPos + cameraPosition;
|
||||
vec2 noiseCoord = floor(packSizeSW * worldPos.xz + 0.001) / packSizeSW;
|
||||
noiseCoord += floor(packSizeSW * worldPos.y + 0.001) / packSizeSW;
|
||||
float noiseTexture = dot(vec2(0.25, 0.75), texture2D(noisetex, noiseCoord * 0.45).rg);
|
||||
vec3 snowColor = mix(vec3(0.65, 0.8, 0.85), vec3(1.0, 1.0, 1.0), noiseTexture * 0.75 + 0.125);
|
||||
|
||||
color.rgb = mix(color.rgb, snowColor + color.rgb * emission * 0.2, snowFactorM);
|
||||
smoothnessG = mix(smoothnessG, 0.25 + 0.25 * noiseTexture, snowFactorM);
|
||||
highlightMult = mix(highlightMult, 2.0 - subsurfaceMode * 0.666, snowFactorM);
|
||||
smoothnessD = mix(smoothnessD, 0.0, snowFactorM);
|
||||
emission *= 1.0 - snowFactorM * 0.85;
|
||||
}
|
||||
@ -0,0 +1,149 @@
|
||||
float random (in float x) { return fract(sin(x)*1e4);}
|
||||
float random (in vec2 st) {return fract(sin(dot(st.xy, vec2(12.9898,78.233)))* 43758.5453123);}
|
||||
vec2 random2( vec2 p ) {
|
||||
return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453);
|
||||
}
|
||||
|
||||
vec4 hash4( vec2 p ) { return fract(sin(vec4( 1.0+dot(p,vec2(37.0,17.0)),
|
||||
2.0+dot(p,vec2(11.0,47.0)),
|
||||
3.0+dot(p,vec2(41.0,29.0)),
|
||||
4.0+dot(p,vec2(23.0,31.0))))*103.0); }
|
||||
|
||||
vec4 textureNoTile( sampler2D samp, in vec2 uv )
|
||||
{
|
||||
vec2 iuv = floor( uv );
|
||||
vec2 fuv = fract( uv );
|
||||
|
||||
// #ifdef USEHASH
|
||||
// // generate per-tile transform (needs GL_NEAREST_MIPMAP_LINEARto work right)
|
||||
// vec4 ofa = texture( samp, (iuv + vec2(0.5,0.5))/256.0 );
|
||||
// vec4 ofb = texture( samp, (iuv + vec2(1.5,0.5))/256.0 );
|
||||
// vec4 ofc = texture( samp, (iuv + vec2(0.5,1.5))/256.0 );
|
||||
// vec4 ofd = texture( samp, (iuv + vec2(1.5,1.5))/256.0 );
|
||||
// #else
|
||||
// generate per-tile transform
|
||||
vec4 ofa = hash4( iuv + vec2(0.0,0.0) );
|
||||
vec4 ofb = hash4( iuv + vec2(1.0,0.0) );
|
||||
vec4 ofc = hash4( iuv + vec2(0.0,1.0) );
|
||||
vec4 ofd = hash4( iuv + vec2(1.0,1.0) );
|
||||
//#endif
|
||||
|
||||
vec2 ddx = dFdx( uv );
|
||||
vec2 ddy = dFdy( uv );
|
||||
|
||||
// transform per-tile uvs
|
||||
ofa.zw = sign(ofa.zw-0.5);
|
||||
ofb.zw = sign(ofb.zw-0.5);
|
||||
ofc.zw = sign(ofc.zw-0.5);
|
||||
ofd.zw = sign(ofd.zw-0.5);
|
||||
|
||||
// uv's, and derivarives (for correct mipmapping)
|
||||
vec2 uva = uv*ofa.zw + ofa.xy; vec2 ddxa = ddx*ofa.zw; vec2 ddya = ddy*ofa.zw;
|
||||
vec2 uvb = uv*ofb.zw + ofb.xy; vec2 ddxb = ddx*ofb.zw; vec2 ddyb = ddy*ofb.zw;
|
||||
vec2 uvc = uv*ofc.zw + ofc.xy; vec2 ddxc = ddx*ofc.zw; vec2 ddyc = ddy*ofc.zw;
|
||||
vec2 uvd = uv*ofd.zw + ofd.xy; vec2 ddxd = ddx*ofd.zw; vec2 ddyd = ddy*ofd.zw;
|
||||
|
||||
// fetch and blend
|
||||
vec2 b = smoothstep(0.25,0.75,fuv);
|
||||
|
||||
return mix( mix( textureGrad( samp, uva, ddxa, ddya ),
|
||||
textureGrad( samp, uvb, ddxb, ddyb ), b.x ),
|
||||
mix( textureGrad( samp, uvc, ddxc, ddyc ),
|
||||
textureGrad( samp, uvd, ddxd, ddyd ), b.x), b.y );
|
||||
}
|
||||
|
||||
vec3 voronoi( in vec2 x, float rnd ) {
|
||||
vec2 n = floor(x);
|
||||
vec2 f = fract(x);
|
||||
|
||||
// first pass: regular voronoi
|
||||
vec2 mg, mr;
|
||||
float md = 8.0;
|
||||
for (int j=-1; j<=1; j++ ) {
|
||||
for (int i=-1; i<=1; i++ ) {
|
||||
vec2 g = vec2(float(i),float(j));
|
||||
vec2 o = random2( n + g )*rnd;
|
||||
o = 0.5 + 0.5*sin( frameTimeCounter + 6.2831*o );
|
||||
vec2 r = g + o - f;
|
||||
float d = dot(r,r);
|
||||
|
||||
if( d<md ) {
|
||||
md = d;
|
||||
mr = r;
|
||||
mg = g;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// second pass: distance to borders
|
||||
md = 8.0;
|
||||
for (int j=-2; j<=2; j++ ) {
|
||||
for (int i=-2; i<=2; i++ ) {
|
||||
vec2 g = mg + vec2(float(i),float(j));
|
||||
vec2 o = random2(n + g)*rnd;
|
||||
o = 0.5 + 0.5*sin( frameTimeCounter + 6.2831*o );
|
||||
vec2 r = g + o - f;
|
||||
|
||||
if( dot(mr-r,mr-r)>0.00001 )
|
||||
md = min( md, dot( 0.5*(mr+r), normalize(r-mr) ) );
|
||||
}
|
||||
}
|
||||
return vec3( md, mr );
|
||||
}
|
||||
|
||||
vec3 waterMaskFunc(vec3 worldPos, const float water_scroll_speed, vec3 waterColor, int mat, vec3 normal) {
|
||||
const float foam_speed = 0.05;
|
||||
const float water_warp = 0.005;
|
||||
vec3 water_color = vec3(0);
|
||||
if (mat == 10049) { // Water Cauldron
|
||||
water_color = saturateColors(waterColor, 0.3) * 0.7;
|
||||
} else {
|
||||
water_color = mix(waterColor * 0.4, vec3(0.22, 0.22, 0.22), 0.5);
|
||||
}
|
||||
|
||||
//pixelated coord to created pixelated visual
|
||||
vec3 uv = worldPos;
|
||||
uv = (uv-.5)*.25+.5;
|
||||
float pixelWaterSize = 16;
|
||||
uv = floor(uv * (pixelWaterSize * 4)) / (pixelWaterSize * 4);
|
||||
|
||||
float d = dot(uv.xz-0.5,uv.xz-0.5);
|
||||
vec3 c = voronoi(5.0*uv.xz, pow(d,.6) );
|
||||
|
||||
vec2 water_pos = vec2(frameTimeCounter) * water_scroll_speed;
|
||||
vec3 foamNoise = textureNoTile(noisetex, uv.xz + vec2(frameTimeCounter) * foam_speed).xyz;
|
||||
|
||||
vec3 result = vec3(0.0);
|
||||
// borders
|
||||
vec3 waterMask = mix(vec3(1.00), vec3(0.0), smoothstep( 0.04, 0.06, c.x ));
|
||||
vec3 foam = waterMask * vec3(foamNoise.y - 0.55);
|
||||
foam = clamp(foam, vec3(0.02), vec3(1.0));
|
||||
foam *= 1.3;
|
||||
|
||||
//not regular structure water
|
||||
float water_sample = floor(texture2D(noisetex, uv.xz * 0.25 + foamNoise.xz * water_warp + water_pos).r * 16) / 16;
|
||||
vec3 water = mix(water_color, vec3(0.001), water_sample * float(foam));
|
||||
|
||||
// small particles in water
|
||||
// Grid
|
||||
vec2 st = uv.xz;
|
||||
st *= vec2(100.0,100.);
|
||||
vec2 ipos = floor(st); // integer
|
||||
vec2 vel = vec2(frameTimeCounter); // time
|
||||
vel *= vec2(-1.,0.); // direction
|
||||
vel *= (step(1.0, mod(ipos.y,5.024))-0.5)*2.; // Oposite directions
|
||||
vel *= vec2(-1.,0.); // direction
|
||||
vel *= random(ipos.y); // random speed
|
||||
|
||||
//Creating particles
|
||||
vec3 pixelParticle = vec3(1.0);
|
||||
pixelParticle *= random(floor(vec2(st.x*0.32, st.y)+vel));
|
||||
float mixFactor = clamp((sin(frameTimeCounter*0.1) + 1.0)*0.5, 0.005, 0.15);
|
||||
pixelParticle = smoothstep(0.0,mixFactor,pixelParticle);
|
||||
pixelParticle = (1.0 - pixelParticle) * (foamNoise.y - 0.55);
|
||||
pixelParticle = clamp(pixelParticle, vec3(0.02), vec3(1.0));
|
||||
|
||||
result = foam * 2.0 + pixelParticle * 2.0 + water;
|
||||
//result = vec3(foamNoise.y - 0.55);
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,214 @@
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
#include "/lib/misc/voxelization.glsl"
|
||||
#endif
|
||||
|
||||
vec3 GetRawWave(in vec3 pos, float wind) {
|
||||
float magnitude = sin(wind * 0.0027 + pos.z + pos.y) * 0.04 + 0.04;
|
||||
#if (INCREASED_RAIN_STRENGTH > 0 && WAVING_I_RAIN_MULT != 100) || defined SPOOKY
|
||||
magnitude *= mix(1.0, 2.5, rainFactor);
|
||||
#endif
|
||||
float d0 = sin(wind * 0.0127);
|
||||
float d1 = sin(wind * 0.0089);
|
||||
float d2 = sin(wind * 0.0114);
|
||||
vec3 wave;
|
||||
wave.x = sin(wind*0.0063 + d0 + d1 - pos.x + pos.z + pos.y) * magnitude;
|
||||
wave.z = sin(wind*0.0224 + d1 + d2 + pos.x - pos.z + pos.y) * magnitude;
|
||||
wave.y = sin(wind*0.0015 + d2 + d0 + pos.z + pos.y - pos.y) * magnitude;
|
||||
|
||||
return wave;
|
||||
}
|
||||
|
||||
vec3 GetWave(in vec3 pos, float waveSpeed) {
|
||||
float wind = frameTimeCounter * waveSpeed * WAVING_SPEED;
|
||||
vec3 wave = GetRawWave(pos, wind);
|
||||
|
||||
#define WAVING_I_RAIN_MULT_M WAVING_I_RAIN_MULT * 0.01
|
||||
|
||||
#if WAVING_I_RAIN_MULT > 100
|
||||
float windRain = frameTimeCounter * waveSpeed * WAVING_I_RAIN_MULT_M * WAVING_SPEED;
|
||||
vec3 waveRain = GetRawWave(pos, windRain);
|
||||
wave = mix(wave, waveRain, rainFactor);
|
||||
#endif
|
||||
|
||||
#if defined NO_WAVING_INDOORS && !defined WAVE_EVERYTHING
|
||||
wave *= clamp(lmCoord.y - 0.87, 0.0, 0.1);
|
||||
#else
|
||||
wave *= 0.1;
|
||||
#endif
|
||||
|
||||
float wavingIntensity = WAVING_I * mix(1.0, WAVING_I_RAIN_MULT_M, rainFactor);
|
||||
|
||||
return wave * wavingIntensity;
|
||||
}
|
||||
|
||||
void DoWave_Foliage(inout vec3 playerPos, vec3 worldPos, float waveMult) {
|
||||
worldPos.y *= 0.5;
|
||||
|
||||
vec3 wave = GetWave(worldPos, 170.0);
|
||||
wave.x = wave.x * 8.0 + wave.y * 4.0;
|
||||
wave.y = 0.0;
|
||||
wave.z = wave.z * 3.0;
|
||||
|
||||
playerPos.xyz += wave * waveMult;
|
||||
}
|
||||
|
||||
void DoWave_Leaves(inout vec3 playerPos, vec3 worldPos, float waveMult) {
|
||||
worldPos *= vec3(0.75, 0.375, 0.75);
|
||||
|
||||
vec3 wave = GetWave(worldPos, 170.0);
|
||||
wave *= vec3(8.0, 3.0, 4.0);
|
||||
|
||||
wave *= 1.0 - inSnowy; // Leaves with snow on top look wrong
|
||||
|
||||
playerPos.xyz += wave * waveMult;
|
||||
}
|
||||
|
||||
void DoWave_Water(inout vec3 playerPos, vec3 worldPos) {
|
||||
float waterWaveTime = frameTimeCounter * 6.0 * WAVING_SPEED;
|
||||
worldPos.xz *= 14.0;
|
||||
|
||||
float wave = sin(waterWaveTime * 0.7 + worldPos.x * 0.14 + worldPos.z * 0.07);
|
||||
wave += sin(waterWaveTime * 0.5 + worldPos.x * 0.10 + worldPos.z * 0.05);
|
||||
|
||||
#ifdef NO_WAVING_INDOORS
|
||||
wave *= clamp(lmCoord.y - 0.87, 0.0, 0.1);
|
||||
#else
|
||||
wave *= 0.1;
|
||||
#endif
|
||||
|
||||
playerPos.y += wave * 0.125 - 0.05;
|
||||
|
||||
#if defined GBUFFERS_WATER && WATER_STYLE == 1
|
||||
normal = mix(normal, tangent, wave * 0.01);
|
||||
#endif
|
||||
}
|
||||
|
||||
void DoWave_Lava(inout vec3 playerPos, vec3 worldPos) {
|
||||
if (fract(worldPos.y + 0.005) > 0.06) {
|
||||
float lavaWaveTime = frameTimeCounter * 3.0 * WAVING_SPEED;
|
||||
worldPos.xz *= 14.0;
|
||||
|
||||
float wave = sin(lavaWaveTime * 0.7 + worldPos.x * 0.14 + worldPos.z * 0.07);
|
||||
wave += sin(lavaWaveTime * 0.5 + worldPos.x * 0.05 + worldPos.z * 0.10);
|
||||
|
||||
#if defined NETHER && defined WAVIER_LAVA
|
||||
if (worldPos.y > 30 && worldPos.y < 32) wave *= 4.5;
|
||||
else wave *= 2.0;
|
||||
#endif
|
||||
|
||||
playerPos.y += wave * 0.0125;
|
||||
}
|
||||
}
|
||||
|
||||
void DoWave(inout vec3 playerPos, int mat) {
|
||||
vec3 worldPos = playerPos.xyz + cameraPosition.xyz;
|
||||
|
||||
#if defined GBUFFERS_TERRAIN || defined SHADOW
|
||||
#ifdef WAVING_FOLIAGE
|
||||
if (mat == 10003 || mat == 10005 || mat == 10029 || mat == 10025) { // Grounded Waving Foliage
|
||||
if (gl_MultiTexCoord0.t < mc_midTexCoord.t || fract(worldPos.y + 0.21) > 0.26)
|
||||
DoWave_Foliage(playerPos.xyz, worldPos, 1.0);
|
||||
} else if (mat == 10021 || mat == 10023 || mat == 10027) { // Upper Layer Waving Foliage
|
||||
DoWave_Foliage(playerPos.xyz, worldPos, 1.0);
|
||||
}
|
||||
|
||||
#if defined WAVING_LEAVES_ENABLED || defined WAVING_LAVA || defined WAVING_LILY_PAD
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WAVING_LEAVES_ENABLED
|
||||
if (mat == 10007 || mat == 10009 || mat == 10011) { // Leaves
|
||||
DoWave_Leaves(playerPos.xyz, worldPos, 1.0);
|
||||
} else if (mat == 10013 || mat == 10923) { // Vine
|
||||
// Reduced waving on vines to prevent clipping through blocks
|
||||
DoWave_Leaves(playerPos.xyz, worldPos, 0.75);
|
||||
}
|
||||
#if defined NETHER || defined DO_NETHER_VINE_WAVING_OUTSIDE_NETHER
|
||||
else if (mat == 10884 || mat == 10885) { // Weeping Vines, Twisting Vines
|
||||
float waveMult = 1.0;
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
vec3 playerPosP = playerPos + vec3(0.0, 0.1, 0.0);
|
||||
vec3 voxelPosP = SceneToVoxel(playerPosP);
|
||||
vec3 playerPosN = playerPos - vec3(0.0, 0.1, 0.0);
|
||||
vec3 voxelPosN = SceneToVoxel(playerPosN);
|
||||
|
||||
if (CheckInsideVoxelVolume(voxelPosP)) {
|
||||
int voxelP = int(texelFetch(voxel_sampler, ivec3(voxelPosP), 0).r);
|
||||
int voxelN = int(texelFetch(voxel_sampler, ivec3(voxelPosN), 0).r);
|
||||
if (voxelP != 0 && voxelP != 65 || voxelN != 0 && voxelN != 65) // not air, not weeping vines
|
||||
waveMult = 0.0;
|
||||
}
|
||||
#endif
|
||||
DoWave_Foliage(playerPos.xyz, worldPos, waveMult);
|
||||
}
|
||||
#endif
|
||||
#ifdef WAVING_SUGAR_CANE
|
||||
if (mat == 10035) { // Sugar Cane
|
||||
float waveMult = 0.75;
|
||||
#if COLORED_LIGHTING_INTERNAL > 0
|
||||
vec3 voxelPosP = SceneToVoxel(playerPos - vec3(0.0, 0.1, 0.0));
|
||||
|
||||
if (CheckInsideVoxelVolume(voxelPosP)) {
|
||||
int voxelP = int(texelFetch(voxel_sampler, ivec3(voxelPosP), 0).r);
|
||||
if (voxelP != 0) // not air
|
||||
waveMult = 0.0;
|
||||
}
|
||||
#endif
|
||||
DoWave_Foliage(playerPos.xyz, worldPos, waveMult);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined WAVING_LAVA || defined WAVING_LILY_PAD
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WAVING_LAVA
|
||||
if (mat == 10068 || mat == 10070) { // Lava
|
||||
DoWave_Lava(playerPos.xyz, worldPos);
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
// G8FL735 Fixes Optifine-Iris parity. Optifine has 0.9 gl_Color.rgb on a lot of versions
|
||||
glColorRaw.rgb = min(glColorRaw.rgb, vec3(0.9));
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef WAVING_LILY_PAD
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WAVING_LILY_PAD
|
||||
if (mat == 10489) { // Lily Pad
|
||||
DoWave_Water(playerPos.xyz, worldPos);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined GBUFFERS_WATER || defined SHADOW
|
||||
#ifdef WAVING_WATER_VERTEX
|
||||
#if defined WAVING_ANYTHING_TERRAIN && defined SHADOW
|
||||
else
|
||||
#endif
|
||||
|
||||
if (mat == 32000) { // Water
|
||||
if (fract(worldPos.y + 0.005) > 0.06)
|
||||
DoWave_Water(playerPos.xyz, worldPos);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
void DoInteractiveWave(inout vec3 playerPos, int mat) {
|
||||
float strength = 2.0;
|
||||
if (mat == 10003 || mat == 10023 || mat == 10015) { // Flowers
|
||||
strength = 1.0;
|
||||
}
|
||||
if (length(playerPos) < 2.0) playerPos.xz += playerPos.xz * max(5.0 / max(length(playerPos * vec3(8.0, 2.0, 8.0) - vec3(0.0, 2.0, 0.0)), 2.0) -0.625, 0.0) * clamp(2.0 / length(playerPos) - 1.0, 0.0, 1.0) * strength; // Emin's code from v4 + smooth transition by me
|
||||
}
|
||||
|
||||
void DoWaveEverything(inout vec3 playerPos) {
|
||||
vec3 worldPos = playerPos.xyz + cameraPosition.xyz;
|
||||
DoWave_Leaves(playerPos.xyz, worldPos, 1.0);
|
||||
DoWave_Foliage(playerPos.xyz, worldPos, 1.0);
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
vec2 getOverlayNoise(float sideIntensity, bool noLightCheck, bool decreaseWithDepth, float meltingRadius, int pixelSize, vec3 worldPos, float noiseTransparency, float removeIntensity) {
|
||||
float overlayNoiseVariable;
|
||||
float topCheck = abs(clamp01(dot(normal, upVec))); // normal check for top surfaces
|
||||
if (topCheck > 0.99) {
|
||||
overlayNoiseVariable = 0.0;
|
||||
overlayNoiseVariable += topCheck;
|
||||
} else {
|
||||
overlayNoiseVariable = sideIntensity;
|
||||
}
|
||||
|
||||
//noise
|
||||
int noiseSize = 0;
|
||||
// #if SNOW_SIZE > 0 || MOSS_SIZE > 0 || SAND_SIZE > 0
|
||||
noiseSize = pixelSize;
|
||||
// #else
|
||||
// noiseSize = pixelTexSize.x + 1; // only commented out for nostalgia :p
|
||||
// #endif
|
||||
float noise = float(hash33(floor(mod(worldPos, vec3(100.0)) * noiseSize + 0.03) * noiseSize)) * 0.25; // pixel-locked procedural noise
|
||||
|
||||
//make patches of terrain that don't have noise
|
||||
float removeNoise1 = 1.0 - Noise3D(worldPos * 0.0005) * removeIntensity * 1.2;
|
||||
float removeNoise2 = 1.0 - Noise3D(worldPos * 0.005) * removeIntensity;
|
||||
float removeNoise3 = Noise3D(worldPos * 0.02) * removeIntensity;
|
||||
float removeNoise = clamp01(2.0 * removeNoise1 + 0.70 * removeNoise2 + 0.2 * removeNoise3);
|
||||
overlayNoiseVariable *= removeNoise;
|
||||
|
||||
// light check so noise is not in caves (near light sources)
|
||||
overlayNoiseVariable = clamp01(overlayNoiseVariable); // to prevent stuff breaking, like the fucking bamboo sapling!!!!
|
||||
if (!noLightCheck) {
|
||||
overlayNoiseVariable *= (1.0 - pow(lmCoord.x, 1.0 / meltingRadius * 2.5) * 4.3) * pow(lmCoord.y, 14.0); // first part to turn off at light sources, second part to turn off if under blocks
|
||||
}
|
||||
float depthTransparency = 1.0;
|
||||
if (decreaseWithDepth) {
|
||||
depthTransparency = 10.0 / abs(min(worldPos.y, 0.001)) - 0.3 + clamp(removeNoise * 1.3, 0.0, 0.1); // increase transparency beginning at y=0 at increasing with decreasing y level
|
||||
}
|
||||
overlayNoiseVariable = clamp(overlayNoiseVariable, 0.0, min1(log(noiseTransparency + 3.0) - 0.6) * depthTransparency); // to prevent artifacts near light sources
|
||||
|
||||
vec2 result = vec2(overlayNoiseVariable, noise);
|
||||
return result;
|
||||
}
|
||||
@ -0,0 +1,147 @@
|
||||
vec3 absPlayerPos = abs(playerPos);
|
||||
float maxPlayerPosXZ = max(absPlayerPos.x, absPlayerPos.z);
|
||||
#ifdef MOSS_NOISE_INTERNAL
|
||||
float mossDecider = -clamp01(pow2(min1(maxPlayerPosXZ / (200 * MOSS_NOISE_DISTANCE)) * 2.0)) + 1.0; // The effect will only be around the player
|
||||
if (mossDecider > 0.001){
|
||||
vec3 mossColor = mix(vec3(0.2745, 0.3412, 0.1412), vec3(0.451, 0.5804, 0.1255), float(hash33(floor(mod(worldPos, vec3(100.0)) * MOSS_SIZE + 0.03) * MOSS_SIZE)) * 0.15);
|
||||
#if MOSS_IN_CAVES < 2
|
||||
bool disableLight = true;
|
||||
#else
|
||||
bool disableLight = false;
|
||||
#endif
|
||||
|
||||
#if MOSS_SIDE_INTENSITY == 0
|
||||
float mossSide = 0.0;
|
||||
#else
|
||||
float mossSide = MOSS_SIDE_INTENSITY * 0.1;
|
||||
#endif
|
||||
|
||||
vec2 mossVec = getOverlayNoise(mossSide, disableLight, false, 0.1, MOSS_SIZE, worldPos, MOSS_TRANSPARENCY, MOSS_NOISE_REMOVE_INTENSITY * 1.5);
|
||||
|
||||
float mossNoise = mossVec.y;
|
||||
float mossVariable = mossVec.x;
|
||||
|
||||
#if MOSS_IN_CAVES == 0
|
||||
mossVariable *= inLushCave;
|
||||
#endif
|
||||
|
||||
mossColor *= 1.1;
|
||||
mossColor += 0.13 * mossNoise * MOSS_NOISE_INTENSITY; // make the noise less noticeable & configurable with option
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
#if MOSS_IN_CAVES == 0
|
||||
emission *= mix(1.0, overlayNoiseEmission, inLushCave * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, 0.0, mossVariable * inLushCave * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, smoothnessG, mossVariable * inLushCave * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#endif
|
||||
#else
|
||||
emission *= mix(1.0, overlayNoiseEmission, overlayNoiseIntensity * mossNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, 0.0, mossVariable * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, smoothnessG, mossVariable * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if MOSS_IN_CAVES == 0
|
||||
smoothnessG = mix(smoothnessG, max(smoothnessG, 0.3 * color.g * float(color.g > color.b * 1.5)), mossVariable * inLushCave * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#else
|
||||
smoothnessG = mix(smoothnessG, max(smoothnessG, 0.3 * color.g * float(color.g > color.b * 1.5)), mossVariable * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
#if MOSS_IN_CAVES == 0
|
||||
overlayNoiseTransparentOverwrite = mix(overlayNoiseTransparentOverwrite, overlayNoiseAlpha, inLushCave);
|
||||
fresnel = mix(fresnel, 0.01, mossVariable * overlayNoiseFresnelMult * inLushCave);
|
||||
#else
|
||||
overlayNoiseTransparentOverwrite = overlayNoiseAlpha;
|
||||
fresnel = mix(fresnel, 0.01, mossVariable * overlayNoiseFresnelMult);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
mossVariable *= mossDecider;
|
||||
|
||||
color.rgb = mix(color.rgb, mossColor, mossVariable * overlayNoiseIntensity * mossNoiseIntensity);
|
||||
color.a = mix(color.a, 1.0, clamp(overlayNoiseTransparentOverwrite * mossVariable * mossNoiseIntensity, 0.0, 1.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SAND_NOISE_INTERNAL
|
||||
float sandDecider = -clamp01(pow2(min1(maxPlayerPosXZ / (200 * SAND_NOISE_DISTANCE)) * 2.0)) + 1.0; // The effect will only be around the player
|
||||
if (sandDecider > 0.001){
|
||||
#if SAND_CONDITION == 0
|
||||
float desertSandColorMixer = inSand + inRedSand;
|
||||
vec3 sandColor = mix(
|
||||
vec3(0.9216, 0.8353, 0.6196), (inSand * vec3(0.9216, 0.8353, 0.6196) + inRedSand * vec3(0.5843, 0.3412, 0.1569)), desertSandColorMixer);
|
||||
#else
|
||||
vec3 sandColor = vec3(0.9216, 0.8353, 0.6196);
|
||||
#endif
|
||||
|
||||
#if SAND_SIDE_INTENSITY == 0
|
||||
float sandSide = 0.0;
|
||||
#else
|
||||
float sandSide = SAND_SIDE_INTENSITY * 0.1;
|
||||
#endif
|
||||
|
||||
vec2 sandVec = getOverlayNoise(sandSide, SAND_IN_CAVES, true, 0.1, SAND_SIZE, worldPos, SAND_TRANSPARENCY, SAND_NOISE_REMOVE_INTENSITY * 2.0);
|
||||
|
||||
float sandNoise = sandVec.y;
|
||||
float sandVariable = sandVec.x;
|
||||
|
||||
#if SAND_CONDITION == 0
|
||||
sandVariable *= desertSandColorMixer;
|
||||
#elif SAND_CONDITION == 1
|
||||
sandVariable *= inDry;
|
||||
#endif
|
||||
|
||||
sandColor *= 1.1;
|
||||
sandColor += 0.13 * sandNoise * SAND_NOISE_INTENSITY; // make the noise less noticeable & configurable with option
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
#if SAND_CONDITION == 0
|
||||
emission *= mix(1.0, overlayNoiseEmission, desertSandColorMixer * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, pow(color.g, 16.0) * 2.0, sandVariable * desertSandColorMixer * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, min1(smoothnessG), sandVariable * desertSandColorMixer * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, smoothnessG * 0.7, sandVariable * desertSandColorMixer * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#endif
|
||||
highlightMult = mix(highlightMult, 2.0, sandVariable * desertSandColorMixer * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#elif SAND_CONDITION == 1
|
||||
emission *= mix(1.0, overlayNoiseEmission, inDry * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, pow(color.g, 16.0) * 2.0, sandVariable * inDry * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, min1(smoothnessG), sandVariable * inDry * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, smoothnessG * 0.7, sandVariable * inDry * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#endif
|
||||
highlightMult = mix(highlightMult, 2.0, sandVariable * inDry * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#else
|
||||
emission *= overlayNoiseEmission;
|
||||
smoothnessG = mix(smoothnessG, pow(color.g, 16.0) * 2.0, sandVariable * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, min1(smoothnessG), sandVariable * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, smoothnessG * 0.7, sandVariable * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#endif
|
||||
highlightMult = mix(highlightMult, 2.0, sandVariable * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
#if SAND_CONDITION == 0
|
||||
overlayNoiseTransparentOverwrite = mix(0.0, overlayNoiseAlpha, desertSandColorMixer);
|
||||
fresnel = mix(fresnel, 0.01, sandVariable * overlayNoiseFresnelMult * desertSandColorMixer);
|
||||
#elif SAND_CONDITION == 1
|
||||
overlayNoiseTransparentOverwrite = mix(0.0, overlayNoiseAlpha, inDry);
|
||||
fresnel = mix(fresnel, 0.01, sandVariable * overlayNoiseFresnelMult * inDry);
|
||||
#else
|
||||
overlayNoiseTransparentOverwrite = overlayNoiseAlpha;
|
||||
fresnel = mix(fresnel, 0.01, sandVariable * overlayNoiseFresnelMult);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
sandVariable *= sandDecider;
|
||||
|
||||
color.rgb = mix(color.rgb, sandColor, sandVariable * overlayNoiseIntensity * sandNoiseIntensity);
|
||||
color.a = mix(color.a, 1.0, clamp(overlayNoiseTransparentOverwrite * sandVariable * overlayNoiseIntensity * sandNoiseIntensity, 0.0, 1.0));
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,425 @@
|
||||
// Yes I hate myself for having done all of this in a big file and with functions. Thanks you me from a year ago
|
||||
|
||||
#ifndef GBUFFERS_HAND
|
||||
vec3 oldColor = color.rgb; // Needed for entities
|
||||
|
||||
#if SEASONS != 2 && SEASONS != 5
|
||||
// Color Desaturation
|
||||
vec3 desaturatedColor = color.rgb;
|
||||
if (SEASON_COLOR_DESATURATION > 0.0) {
|
||||
float desaturation = SEASON_COLOR_DESATURATION;
|
||||
|
||||
#if SEASONS == 1 || SEASONS == 4
|
||||
if (winterTime > 0) {
|
||||
// snow conditions
|
||||
#if SNOW_CONDITION != 2
|
||||
desaturation *= inSnowy; // make only appear in cold biomes
|
||||
#elif SNOW_CONDITION == 0
|
||||
desaturation *= rainFactor; // make only appear in rain
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
desaturatedColor = mix(color.rgb, vec3(GetLuminance(color.rgb)), clamp01(desaturation - lmCoord.x));
|
||||
}
|
||||
#endif
|
||||
|
||||
bool dhLeaves = true;
|
||||
#ifdef DH_TERRAIN
|
||||
if (mat == DH_BLOCK_LEAVES && dhColor.r < 0.17 || dhColor.r > 0.7) dhLeaves = false;
|
||||
#endif
|
||||
|
||||
#if SEASONS == 1 || SEASONS == 2
|
||||
vec3 summerColor = color.rgb;
|
||||
if (summerTime > 0) {
|
||||
#if defined GBUFFERS_TERRAIN || defined DH_TERRAIN
|
||||
if (isFoliage && dhLeaves || mat == 10132 && glColor.b < 0.999) { // Normal Grass Block
|
||||
summerColor = mix(summerColor, GetLuminance(summerColor) * vec3(1.0, 0.8941, 0.3725), 0.3 * SUMMER_STRENGTH);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
float autumnOnlyForests = 1.0;
|
||||
#ifdef AUTUMN_CONDITION
|
||||
autumnOnlyForests = inForest;
|
||||
#endif
|
||||
|
||||
#if SEASONS == 1 || SEASONS == 3
|
||||
vec3 autumnColor = vec3(0);
|
||||
|
||||
if (autumnTime > 0 && inPaleGarden < 0.5) {
|
||||
autumnColor = mix(color.rgb, desaturatedColor, 0.65 * autumnOnlyForests);
|
||||
|
||||
#if defined GBUFFERS_TERRAIN || defined GBUFFERS_BLOCK || defined DH_TERRAIN
|
||||
const vec3 autumnLeafColor0 = vec3(0.9922, 0.5707, 0.098);
|
||||
const vec3 autumnLeafColor1 = vec3(0.9922, 0.4786, 0.098);
|
||||
const vec3 autumnLeafColor2 = vec3(0.9804, 0.4033, 0.1569);
|
||||
const vec3 autumnLeafColor3 = vec3(0.9765, 0.3333, 0.149);
|
||||
const vec3 autumnLeafColor4 = vec3(0.9765, 0.1333, 0.149);
|
||||
|
||||
float noiseLeavesColor1 = smoothstep(0.4, 0.7, Noise3D(worldPos * 0.0001 * AUTUMN_NOISE_SIZE));
|
||||
float noiseLeavesColor2 = smoothstep(0.3, 0.7, Noise3D(worldPos * 0.0003 * AUTUMN_NOISE_SIZE + 300.0));
|
||||
float noiseLeavesColor3 = smoothstep(0.65, 0.7, Noise3D(worldPos * 0.0005 * AUTUMN_NOISE_SIZE + 700.0));
|
||||
float noiseLeavesColor4 = smoothstep(0.7, 0.8, Noise3D(worldPos * 0.0003 * AUTUMN_NOISE_SIZE + 1000.0));
|
||||
|
||||
vec3 leafMainColor = mix(mix(mix(mix(autumnLeafColor0, autumnLeafColor1, noiseLeavesColor1), autumnLeafColor2, noiseLeavesColor2), autumnLeafColor3, noiseLeavesColor3), autumnLeafColor4, noiseLeavesColor4) * 1.5; // giant mix :p
|
||||
|
||||
if (isFoliage) {
|
||||
if (mat == 10009 || mat == 10011
|
||||
#ifdef DH_TERRAIN
|
||||
|| mat == DH_BLOCK_LEAVES && isFoliage && dhLeaves
|
||||
#endif
|
||||
) { // Except some leaves
|
||||
autumnColor *= mix(vec3(1.0), leafMainColor, autumnOnlyForests);
|
||||
} else {
|
||||
autumnColor *= mix(vec3(1.0), vec3(0.9882, 0.7725, 0.5725), autumnOnlyForests * 0.5);
|
||||
}
|
||||
} else { // leaves on the ground
|
||||
if ((mat == 10132
|
||||
#ifdef DH_TERRAIN
|
||||
|| mat == DH_BLOCK_GRASS
|
||||
#endif
|
||||
) && glColor.b < 0.999) { // Normal Grass Block, grass part
|
||||
autumnColor *= mix(vec3(1.0), vec3(0.9882, 0.7725, 0.5725), autumnOnlyForests * 0.4);
|
||||
}
|
||||
#ifdef LEAVES_ON_GROUND
|
||||
vec3 absPlayerPos = abs(playerPos);
|
||||
float maxPlayerPosXZ = max(absPlayerPos.x, absPlayerPos.z);
|
||||
float leafDecider = -clamp01(pow2(min1(maxPlayerPosXZ / 100) * 2.0)) + 1.0; // The effect will only be around the player
|
||||
if (leafDecider > 0.001){
|
||||
float noiseLeavesFloorColor = float(hash33(floor(mod(worldPos, vec3(100.0)) * 16 + 0.03) * 16)) * 0.25;
|
||||
|
||||
vec3 leafFloorColorRandomMess = mix(mix(mix(mix(autumnLeafColor0, autumnLeafColor1, noiseLeavesFloorColor), autumnLeafColor2, noiseLeavesFloorColor), autumnLeafColor3, noiseLeavesFloorColor), autumnLeafColor4, noiseLeavesFloorColor) * 2.0;
|
||||
|
||||
vec3 leafFloorColor = mix(leafFloorColorRandomMess, leafMainColor, 0.6); // this mixes between the random colors and the colors of the leaves at the world pos
|
||||
|
||||
vec2 leafVec = getOverlayNoise(0.0, true, false, 0.1, 16, worldPos, 1.0, 0.0);
|
||||
|
||||
float leafFloorNoise = leafVec.y;
|
||||
float leafVariable = leafVec.x;
|
||||
|
||||
leafVariable *= (1.0 - pow(lmCoord.y + 0.01, 30.0)) * pow(lmCoord.y + 0.01, 2.0);
|
||||
|
||||
leafFloorColor += 0.13 * leafFloorNoise; // make the noise less noticeable
|
||||
|
||||
float leafAddNoise1 = 1.0 - texture2D(noisetex, 0.0005 * (worldPos.xz + worldPos.y)).r * 1.3;
|
||||
float leafAddNoise2 = 1.0 - texture2D(noisetex, 0.005 * (worldPos.xz + worldPos.y)).r * 1.3;
|
||||
float leafAddNoise3 = texture2D(noisetex, 0.02 * (worldPos.xz + worldPos.y)).r * 1.3;
|
||||
leafVariable += mix(0.0, lmCoord.y * 1.0 - clamp(2.0 * leafAddNoise1 + 0.70 * leafAddNoise2 + 0.2 * leafAddNoise1, 0.0, 1.0), inForest);
|
||||
leafVariable = clamp01(leafVariable);
|
||||
|
||||
leafVariable *= abs(clamp01(dot(normal, upVec))); // make only appear on top of blocks
|
||||
|
||||
leafVariable *= leafDecider;
|
||||
|
||||
autumnColor *= mix(vec3(1.0), leafFloorColor, leafVariable * overlayNoiseIntensity * autumnOnlyForests);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef GBUFFERS_ENTITIES
|
||||
autumnColor *= mix(vec3(1.0), vec3(1.0, 0.7, 0.5), autumnTime * 0.7 * autumnOnlyForests * AUTUMN_STRENGTH);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (SEASONS == 1 || SEASONS == 3 || SEASONS == 4) && (defined GBUFFERS_TERRAIN || defined DH_TERRAIN) && LESS_LEAVES > 0
|
||||
if (mat == 10009 || mat == 10011) { // Except some leaves
|
||||
#if defined MIRROR_DIMENSION || defined WORLD_CURVATURE || defined WAVING_ANYTHING_TERRAIN || defined WAVE_EVERYTHING || defined INTERACTIVE_FOLIAGE
|
||||
vec3 worldLeavesNoise = beforeTransformPos.xyz;
|
||||
#else
|
||||
vec3 worldLeavesNoise = playerPos.xyz;
|
||||
#endif
|
||||
float autumnWinterTime = autumnTime + winterTime;
|
||||
#if SNOW_CONDITION != 2
|
||||
autumnWinterTime *= mix(inSnowy + autumnOnlyForests, inSnowy, winterTime); // make only appear in cold biomes during winter
|
||||
#endif
|
||||
#if SNOW_CONDITION == 0
|
||||
autumnWinterTime *= mix(rainFactor + autumnOnlyForests, rainFactor, winterTime); // make only appear in rain during winter
|
||||
#endif
|
||||
float noiseLeaveAlpha = step(autumnWinterTime * LESS_LEAVES * 0.15, hash13(floor(mod(worldLeavesNoise - 0.001 * (mat3(gbufferModelViewInverse) * normal) + cameraPosition.xyz, vec3(100.0)) * 4) * 4)); // remove some leaves with noise
|
||||
noiseLeaveAlpha += step(autumnWinterTime * LESS_LEAVES * 0.13, hash13(floor(mod(worldLeavesNoise - 0.001 * (mat3(gbufferModelViewInverse) * normal) + cameraPosition.xyz, vec3(100.0)) * 16) * 16));
|
||||
color.a *= noiseLeaveAlpha;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SEASONS == 1 || SEASONS == 4
|
||||
vec3 winterColor = vec3(0);
|
||||
|
||||
if (winterTime > 0) {
|
||||
float snowSide = 0.0;
|
||||
#if !defined GBUFFERS_ENTITIES && defined GBUFFERS_TERRAIN
|
||||
if (isFoliage) snowSide = mix(1.0, 0.0, 1.0 / (color.g * color.g) * 0.05); // make all foliage white
|
||||
#ifndef DH_TERRAIN
|
||||
if ((mat == 10132 && glColor.b < 0.999) || (mat == 10126 && color.b + color.g < color.r * 2.0 && color.b > 0.3 && color.g < 0.45) || (mat == 10493 && color.r > 0.52 && color.b < 0.30 && color.g > 0.41 && color.g + color.b * 0.95 > color.r * 1.2)) { // Normal Grass Block and Dirt Path
|
||||
snowSide = mix(0.0, 1.0, pow(blockUV.y, 3.0));
|
||||
#if defined SSS_SEASON_SNOW && (SEASONS == 1 || SEASONS == 4)
|
||||
#if SNOW_CONDITION == 0
|
||||
if (rainFactor > 0 && inSnowy > 0) subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true; // SSS
|
||||
#elif SNOW_CONDITION == 1
|
||||
if (inSnowy > 0) subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#else
|
||||
subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#endif
|
||||
#endif
|
||||
} // add to the side of grass, mycelium, path blocks; in that order. Use blockUV to increase transparency the the further down the block it goes
|
||||
#endif
|
||||
if (mat == 10132 && glColor.b < 0.999) snowSide += abs(color.g - color.g * 0.5); // Normal Grass Block, mute the grass colors a bit
|
||||
|
||||
if ((mat == 10132
|
||||
#ifdef DH_TERRAIN
|
||||
|| mat == DH_BLOCK_GRASS
|
||||
#endif
|
||||
) && glColor.b < 0.999 || isFoliage && dhLeaves && mat != 10007) { // Foliage except some leaves
|
||||
desaturatedColor = mix(desaturatedColor, mix(saturateColors(desaturatedColor, 0.4), desaturatedColor * vec3(0.9098, 0.6118, 0.4118), 0.5), winterTime * (1.0 - WINTER_GREEN_AMOUNT));
|
||||
}
|
||||
#endif
|
||||
|
||||
winterColor = desaturatedColor;
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
oldColor = mix(color.rgb, winterColor, winterTime);
|
||||
#else
|
||||
float winterAlpha = color.a;
|
||||
|
||||
vec3 snowColor = vec3(0.9713, 0.9691, 0.9891);
|
||||
|
||||
vec2 snowVec = getOverlayNoise(snowSide, false, false, MELTING_RADIUS, SNOW_SIZE, worldPos, SNOW_TRANSPARENCY, SNOW_NOISE_REMOVE_INTENSITY * 1.2);
|
||||
|
||||
float snowNoise = snowVec.y;
|
||||
float snowVariable = snowVec.x;
|
||||
|
||||
snowColor *= 1.1;
|
||||
snowColor += 0.13 * snowNoise * SNOW_NOISE_INTENSITY; // make the noise less noticeable & configurable with option
|
||||
|
||||
// snow conditions
|
||||
#if SNOW_CONDITION != 2
|
||||
snowVariable *= inSnowy; // make only appear in cold biomes
|
||||
#endif
|
||||
#if SNOW_CONDITION == 0
|
||||
snowVariable *= rainFactor; // make only appear in rain
|
||||
#endif
|
||||
|
||||
#if SNOW_CONDITION == 0
|
||||
highlightMult = mix(highlightMult, 2.3 - subsurfaceMode * 0.1, snowVariable * IPBRMult * winterTime * rainFactor * inSnowy * overlayNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, 0.45 + 0.1 * snowNoise, snowVariable * IPBRMult * winterTime * rainFactor * inSnowy * overlayNoiseIntensity);
|
||||
#elif SNOW_CONDITION == 1
|
||||
highlightMult = mix(highlightMult, 2.3 - subsurfaceMode * 0.1, snowVariable * IPBRMult * winterTime * inSnowy * overlayNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, 0.45 + 0.1 * snowNoise, snowVariable * IPBRMult * winterTime * inSnowy * overlayNoiseIntensity);
|
||||
#else
|
||||
highlightMult = mix(highlightMult, 2.3 - subsurfaceMode * 0.1, snowVariable * IPBRMult * winterTime * overlayNoiseIntensity);
|
||||
smoothnessG = mix(smoothnessG, 0.45 + 0.1 * snowNoise, snowVariable * IPBRMult * winterTime * overlayNoiseIntensity);
|
||||
#endif
|
||||
|
||||
#ifdef SSS_SEASON_SNOW
|
||||
if (dot(normal, upVec) > 0.99) {
|
||||
#if SNOW_CONDITION == 0
|
||||
if (rainFactor > 0 && inSnowy > 0) subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#elif SNOW_CONDITION == 1
|
||||
if (inSnowy > 0) subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#else
|
||||
subsurfaceMode = 3, noSmoothLighting = true, noDirectionalShading = true;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (dot(normal, upVec) > 0.99) {
|
||||
#if SNOW_CONDITION == 0
|
||||
emission = mix(emission, emission * overlayNoiseEmission, rainFactor * inSnowy * winterTime * overlayNoiseIntensity); // make only appear in rain
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, 0.0, snowVariable * rainFactor * inSnowy * winterTime * overlayNoiseIntensity);
|
||||
#endif
|
||||
#elif SNOW_CONDITION == 1
|
||||
emission = mix(emission, emission * overlayNoiseEmission, inSnowy * winterTime * overlayNoiseIntensity); // make only appear in cold biomes
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, 0.0, snowVariable * inSnowy * winterTime * overlayNoiseIntensity);
|
||||
#endif
|
||||
#else
|
||||
emission = mix(emission, emission * overlayNoiseEmission, winterTime * overlayNoiseIntensity);
|
||||
#ifndef DH_TERRAIN
|
||||
smoothnessD = mix(smoothnessD, 0.0, snowVariable * winterTime * overlayNoiseIntensity);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_WATER
|
||||
if (dot(normal, upVec) > 0.99) {
|
||||
#if SNOW_CONDITION == 0
|
||||
overlayNoiseTransparentOverwrite = mix(overlayNoiseTransparentOverwrite, overlayNoiseAlpha, rainFactor * inSnowy * winterTime);
|
||||
fresnel = mix(fresnel, 0.01, snowVariable * overlayNoiseFresnelMult * winterTime * rainFactor * inSnowy);
|
||||
#elif SNOW_CONDITION == 1
|
||||
overlayNoiseTransparentOverwrite = mix(overlayNoiseTransparentOverwrite, overlayNoiseAlpha, inSnowy * winterTime);
|
||||
fresnel = mix(fresnel, 0.01, snowVariable * overlayNoiseFresnelMult * winterTime * inSnowy);
|
||||
#else
|
||||
overlayNoiseTransparentOverwrite = mix(1.0, overlayNoiseAlpha, winterTime);
|
||||
fresnel = mix(fresnel, 0.01, snowVariable * overlayNoiseFresnelMult * winterTime);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// final mix
|
||||
winterColor = mix(winterColor, snowColor, snowVariable * overlayNoiseIntensity);
|
||||
winterAlpha = mix(color.a, 1.0, clamp(overlayNoiseTransparentOverwrite * snowVariable, 0.0, 1.0));
|
||||
color.a = mix(color.a, winterAlpha, winterTime * overlayNoiseIntensity);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SEASONS == 1 || SEASONS == 5
|
||||
vec3 springColor = color.rgb;
|
||||
if (springTime > 0 && inPaleGarden < 0.5) {
|
||||
#ifdef GBUFFERS_TERRAIN
|
||||
if (isFoliage && dhLeaves || mat == 10132 && glColor.b < 0.999
|
||||
#ifdef DH_TERRAIN
|
||||
|| mat == DH_BLOCK_GRASS
|
||||
#endif
|
||||
) { // Foliage except some leaves, Normal Grass Block
|
||||
if (glColor.b < 0.99) springColor = mix(springColor, GetLuminance(springColor) * vec3(0.3725, 1.0, 0.4235), 0.5 * SPRING_GREEN_INTENSITY);
|
||||
}
|
||||
#if FLOWER_AMOUNT > 0 && !defined DH_TERRAIN
|
||||
if (mat == 10132) { // Normal Grass Block
|
||||
float flowerNoiseAdd = step(texture2D(noisetex, 0.0005 * (worldPos.xz + atMidBlock.xz / 64)).r, 0.25) * 3.5 + 1.0; // Noise to add more flowers
|
||||
float flowerNoiseRemove = clamp01(step(texture2D(noisetex, 0.003 * (worldPos.xz + atMidBlock.xz / 64)).g, 0.69) + 0.15); // Noise to reduce the amount of flowers
|
||||
|
||||
ivec2 flowerUV = ivec2(blockUV.xz * FLOWER_SIZE);
|
||||
|
||||
float flower1Variable = 0.0;
|
||||
float flower2Variable = 0.0;
|
||||
float flower3Variable = 0.0;
|
||||
float flower4Variable = 0.0;
|
||||
float flower5Variable = 0.0;
|
||||
|
||||
float flower4Emission = 0.0; // this exists to only make the purple part of the flower bud be emissive
|
||||
float flowerEmissionMask = 0.0;
|
||||
|
||||
const ivec2 flower1Size = ivec2(3, 3);
|
||||
const ivec2 flower2Size = ivec2(3, 3);
|
||||
const ivec2 flower3Size = ivec2(1, 1);
|
||||
const ivec2 flower4Size = ivec2(2, 2);
|
||||
const ivec2 flower5Size = ivec2(5, 5);
|
||||
|
||||
vec4 flower1Pixels[flower1Size.x * flower1Size.y] = vec4[flower1Size.x * flower1Size.y](
|
||||
vec4(0), vec4(1) , vec4(0),
|
||||
vec4(1), vec4(1.0, 0.8784, 0.2706, 1.0), vec4(1),
|
||||
vec4(0), vec4(1) , vec4(0)
|
||||
);
|
||||
vec4 flower2Pixels[flower2Size.x * flower2Size.y] = vec4[flower2Size.x * flower2Size.y](
|
||||
vec4(0), vec4(0.9922, 0.7686, 0.4078, 1.0) , vec4(0),
|
||||
vec4(0.9922, 0.7686, 0.4078, 1.0), vec4(0.8471, 0.5216, 0.0627, 1.0), vec4(0.9922, 0.7686, 0.4078, 1.0),
|
||||
vec4(0), vec4(0.9922, 0.7686, 0.4078, 1.0) , vec4(0)
|
||||
);
|
||||
vec4 flower3Pixels[flower3Size.x] = vec4[flower3Size.x](vec4(1.0, 0.8784, 0.2706, 1.0));
|
||||
vec4 flower4Pixels[flower4Size.x * flower4Size.y] = vec4[flower4Size.x * flower4Size.y](
|
||||
vec4(0.1137, 0.3882, 0.1137, 1.0), vec4(0.5294, 0.2902, 0.5647, 1.0),
|
||||
vec4(0.1059, 0.3333, 0.0863, 1.0), vec4(0.1137, 0.3882, 0.1137, 1.0)
|
||||
);
|
||||
vec4 flower5Pixels[flower5Size.x * flower5Size.y] = vec4[flower5Size.x * flower5Size.y](
|
||||
vec4(0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0), vec4(0),
|
||||
vec4(0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.9137, 0.5882, 0.9647, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0),
|
||||
vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.9137, 0.5882, 0.9647, 1.0), vec4(0.8667, 0.2627, 0.9569, 1.0), vec4(0.9137, 0.5882, 0.9647, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0),
|
||||
vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.9137, 0.5882, 0.9647, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0),
|
||||
vec4(0), vec4(0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0.6627, 0.4118, 0.7373, 1.0), vec4(0)
|
||||
);
|
||||
|
||||
for (int i = 1; i <= FLOWER_AMOUNT; i++) {
|
||||
if (NdotU > 0.5) {
|
||||
ivec2 randomFlower1UV = ivec2((hash33(mod(floor(worldPos + atMidBlock / 64), vec3(200)) + i) * 0.5 + 0.5) * (FLOWER_SIZE + 1 - flower1Size.x)); // here the bigger component of flower1Size should be used, currently all flowers are symmetric
|
||||
ivec2 randomFlower2UV = ivec2((hash33(mod(floor(worldPos + atMidBlock / 64), vec3(300)) + i) * 0.5 + 0.5) * (FLOWER_SIZE + 1 - flower2Size.x));
|
||||
ivec2 randomFlower3UV = ivec2((hash33(mod(floor(worldPos + atMidBlock / 64), vec3(400)) + i) * 0.5 + 0.5) * (FLOWER_SIZE + 1 - flower3Size.x));
|
||||
ivec2 randomFlower4UV = ivec2((hash33(mod(floor(worldPos + atMidBlock / 64), vec3(501))) * 0.5 + 0.5) * (FLOWER_SIZE + 1 - flower4Size.x)); // Only 1 flower should max generate on a block for flower4/5
|
||||
ivec2 randomFlower5UV = ivec2((hash33(mod(floor(worldPos + atMidBlock / 64), vec3(500))) * 0.5 + 0.5) * (FLOWER_SIZE + 1 - flower5Size.x));
|
||||
|
||||
float randomFlower1Block = step(hash13(mod(floor(worldPos + atMidBlock / 64), vec3(300)) + i), 0.15 * flowerNoiseRemove * flowerNoiseAdd * FLOWER_DENSITY);
|
||||
float randomFlower2Block = step(hash13(mod(floor(worldPos + atMidBlock / 64), vec3(200)) + i), 0.15 * flowerNoiseRemove * flowerNoiseAdd * FLOWER_DENSITY);
|
||||
float randomFlower3Block = step(hash13(mod(floor(worldPos + atMidBlock / 64), vec3(500)) + i), 0.40 * flowerNoiseRemove * flowerNoiseAdd * FLOWER_DENSITY);
|
||||
float randomFlower45Block = step(hash13(mod(floor(worldPos + atMidBlock / 64), vec3(400))) , 0.001 * flowerNoiseRemove * flowerNoiseAdd * FLOWER_DENSITY); // both purple flowers should appear only on the same block
|
||||
float inverseRandomFlower45Block = randomFlower45Block * -1.0 + 1.0; // to remove other flower types on the block where the purple flower is on
|
||||
|
||||
ivec2 flower1RelCoord = flowerUV - randomFlower1UV;
|
||||
ivec2 flower2RelCoord = flowerUV - randomFlower2UV;
|
||||
ivec2 flower3RelCoord = flowerUV - randomFlower3UV;
|
||||
ivec2 flower4RelCoord = flowerUV - randomFlower4UV;
|
||||
ivec2 flower5RelCoord = flowerUV - randomFlower5UV;
|
||||
|
||||
if (all(greaterThanEqual(flower1RelCoord, ivec2(0))) && all(lessThan(flower1RelCoord, flower1Size))) { // if the position is inside the flower, do the flower
|
||||
vec4 flower1Col = flower1Pixels[flower1RelCoord.x + flower1Size.x * flower1RelCoord.y]; // this flower pixel's colour
|
||||
flower1Variable = flower1Col.a * randomFlower1Block * inverseRandomFlower45Block;
|
||||
springColor = mix(springColor, flower1Col.rgb, flower1Variable); // apply the flower colour
|
||||
}
|
||||
if (all(greaterThanEqual(flower2RelCoord, ivec2(0))) && all(lessThan(flower2RelCoord, flower2Size))) {
|
||||
vec4 flower2Col = flower2Pixels[flower2RelCoord.x + flower2Size.x * flower2RelCoord.y];
|
||||
flower2Variable = flower2Col.a * randomFlower2Block * inverseRandomFlower45Block;
|
||||
springColor = mix(springColor, flower2Col.rgb, flower2Variable);
|
||||
}
|
||||
if (all(greaterThanEqual(flower3RelCoord, ivec2(0))) && all(lessThan(flower3RelCoord, flower3Size))) {
|
||||
vec4 flower3Col = flower3Pixels[flower3RelCoord.x + flower3RelCoord.y];
|
||||
flower3Variable = flower3Col.a * randomFlower3Block * inverseRandomFlower45Block;
|
||||
springColor = mix(springColor, flower3Col.rgb, flower3Variable);
|
||||
}
|
||||
if (all(greaterThanEqual(flower4RelCoord, ivec2(0))) && all(lessThan(flower4RelCoord, flower4Size))) {
|
||||
vec4 flower4Col = flower4Pixels[flower4RelCoord.x + flower4Size.x * flower4RelCoord.y];
|
||||
flower4Variable = flower4Col.a * randomFlower45Block;
|
||||
flower4Emission = flower4Variable * (1.0 - step(flower4Col.r , 0.5));
|
||||
springColor = mix(springColor, flower4Col.rgb, flower4Variable);
|
||||
}
|
||||
if (all(greaterThanEqual(flower5RelCoord, ivec2(0))) && all(lessThan(flower5RelCoord, flower5Size))) {
|
||||
vec4 flower5Col = flower5Pixels[flower5RelCoord.x + flower5Size.x * flower5RelCoord.y];
|
||||
flower5Variable = flower5Col.a * randomFlower45Block;
|
||||
springColor = mix(springColor, flower5Col.rgb, flower5Variable);
|
||||
}
|
||||
|
||||
#if EMISSIVE_FLOWERS > 0
|
||||
flowerEmissionMask = max(emission, (flower1Variable + flower2Variable + flower3Variable + flower4Emission + flower5Variable)); // Emission Mask
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#if EMISSIVE_FLOWERS > 0 && defined EMISSIVE_SPRING_FLOWERS
|
||||
#if EMISSIVE_FLOWERS_TYPE == 1
|
||||
if (color.b < max(color.r, color.g * 1.1) * 0.95) emission = 0.0;
|
||||
#elif EMISSIVE_FLOWERS_TYPE == 2
|
||||
if (color.r < max(color.b * 1.15, color.g * 1.1) * 0.95) emission = 0.0;
|
||||
#endif
|
||||
emission = 2.0 * skyLightCheck * flowerEmissionMask;
|
||||
#if EMISSIVE_FLOWERS == 2
|
||||
emission = max(emission, mix(0.0, rainFactor + 1.0 * rainFactor, flowerEmissionMask));
|
||||
#endif
|
||||
emission *= EMISSIVE_FLOWERS_STRENGTH;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SEASONS == 1
|
||||
vec3 summerToAutumn = mix(summerColor, autumnColor, summer);
|
||||
vec3 autumnToWinter = mix(summerToAutumn, winterColor, autumn);
|
||||
vec3 winterToSpring = mix(autumnToWinter, springColor, winter);
|
||||
vec3 springToSummer = mix(winterToSpring, summerColor, spring);
|
||||
|
||||
#ifndef GBUFFERS_ENTITIES
|
||||
color.rgb = springToSummer;
|
||||
#endif
|
||||
|
||||
#elif SEASONS == 2
|
||||
color.rgb = summerColor;
|
||||
|
||||
#elif SEASONS == 3
|
||||
color.rgb = autumnColor;
|
||||
|
||||
#elif SEASONS == 4
|
||||
color.rgb = winterColor;
|
||||
|
||||
#elif SEASONS == 5
|
||||
color.rgb = springColor;
|
||||
#endif
|
||||
|
||||
#ifdef GBUFFERS_ENTITIES
|
||||
color.rgb = oldColor;
|
||||
#endif
|
||||
#endif
|
||||
@ -0,0 +1,40 @@
|
||||
#if SEASONS == 1
|
||||
#if SEASON_LENGTH >= 24000
|
||||
int seasonLength = SEASON_LENGTH;
|
||||
#else
|
||||
int seasonLength = SEASON_LENGTH * 24000;
|
||||
#endif
|
||||
|
||||
float YearLoop = (worldDay * 24000 + worldTime + SEASON_START * seasonLength) % (seasonLength * 4);
|
||||
|
||||
float summer = max(0.0, (1.0 + SEASON_TRANSITION_START) * (clamp(YearLoop - seasonLength * 0, 0, seasonLength) / seasonLength) - SEASON_TRANSITION_START);
|
||||
float autumn = max(0.0, (1.0 + SEASON_TRANSITION_START * 2.5) * (clamp(YearLoop - seasonLength * 1, 0, seasonLength) / seasonLength) - SEASON_TRANSITION_START * 2.5); // 2.5 to make snow appear sooner
|
||||
float winter = max(0.0, (1.0 + SEASON_TRANSITION_START) * (clamp(YearLoop - seasonLength * 2, 0, seasonLength) / seasonLength) - SEASON_TRANSITION_START);
|
||||
float spring = max(0.0, (1.0 + SEASON_TRANSITION_START) * (clamp(YearLoop - seasonLength * 3, 0, seasonLength) / seasonLength) - SEASON_TRANSITION_START);
|
||||
|
||||
float summerTime = spring - summer + 1.0;
|
||||
float autumnTime = summer - autumn;
|
||||
float winterTime = autumn - winter;
|
||||
float springTime = winter - spring;
|
||||
|
||||
#elif SEASONS == 2
|
||||
float summerTime = 1.0;
|
||||
float autumnTime = 0.0;
|
||||
float winterTime = 0.0;
|
||||
float springTime = 0.0;
|
||||
#elif SEASONS == 3
|
||||
float summerTime = 0.0;
|
||||
float autumnTime = 1.0;
|
||||
float winterTime = 0.0;
|
||||
float springTime = 0.0;
|
||||
#elif SEASONS == 4
|
||||
float summerTime = 0.0;
|
||||
float autumnTime = 0.0;
|
||||
float winterTime = 1.0;
|
||||
float springTime = 0.0;
|
||||
#elif SEASONS == 5
|
||||
float summerTime = 0.0;
|
||||
float autumnTime = 0.0;
|
||||
float winterTime = 0.0;
|
||||
float springTime = 1.0;
|
||||
#endif
|
||||
@ -0,0 +1 @@
|
||||
#include "/lib/materials/specificMaterials/entities/itemFrame.glsl"
|
||||
@ -0,0 +1 @@
|
||||
noSmoothLighting = true;
|
||||
@ -0,0 +1,6 @@
|
||||
color = vec4(1.0, 1.1, 1.4, 1.0);
|
||||
|
||||
lmCoordM = vec2(0.0);
|
||||
shadowMult = vec3(0.0);
|
||||
|
||||
emission = 0.5;
|
||||
@ -0,0 +1,139 @@
|
||||
// End Portal fix by fayer3#2332 (Modified)
|
||||
float dither = Bayer64(gl_FragCoord.xy);
|
||||
#ifdef TAA
|
||||
dither = fract(dither + goldenRatio * mod(float(frameCounter), 3600.0));
|
||||
int repeat = 4;
|
||||
#else
|
||||
int repeat = 8;
|
||||
#endif
|
||||
|
||||
#if END_PORTAL_VARIATION == 0 || END_PORTAL_VARIATION == 1
|
||||
#if END_PORTAL_VARIATION == 0
|
||||
vec3[8] colors = vec3[](
|
||||
vec3(0.3472479, 0.6559956, 0.7387838) * 1.5,
|
||||
vec3(0.6010780, 0.7153565, 1.060625 ),
|
||||
vec3(0.4221090, 0.8135094, 0.9026056),
|
||||
vec3(0.3492291, 1.0241201, 1.8612821),
|
||||
vec3(0.7543085, 0.8238697, 0.6803233),
|
||||
vec3(0.4144472, 0.5648165, 0.8037 ),
|
||||
vec3(0.508905 , 0.6719649, 0.9982805),
|
||||
vec3(0.5361914, 0.4476583, 0.8008522));
|
||||
color.rgb = vec3(0.421, 0.7, 1.6) * 0.14;
|
||||
#else
|
||||
vec3[3] colors = vec3[](
|
||||
vec3(1.0, 0.0, 0.0),
|
||||
vec3(0.0, 1.0, 0.0),
|
||||
vec3(0.0, 0.0, 1.0));
|
||||
color.rgb = vec3(0.4214321, 0.4722309, 1.9922364) * 0.08;
|
||||
#endif
|
||||
|
||||
float dismult = 0.5;
|
||||
for (int j = 0; j < repeat; j++) {
|
||||
float add = float(j + dither) * 0.0625 / float(repeat);
|
||||
for (int i = 1; i <= 8; i++) {
|
||||
vec2 offset = vec2(0.0, 1.0/(3600.0/24.0)) * pow(16.0 - i, 2.0) * 0.004;
|
||||
vec2 wind = fract((frameTimeCounter + 984.0) * (i + 8) * 0.125 * offset);
|
||||
|
||||
vec3 wpos = normalize((gbufferModelViewInverse * vec4(viewPos * (i * dismult + 1), 1.0)).xyz);
|
||||
if (abs(NdotU) > 0.9) {
|
||||
wpos.xz /= wpos.y;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.y);
|
||||
wpos.xz *= abs(playerPos.y) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.xz * 0.05;
|
||||
} else {
|
||||
vec3 absPos = abs(playerPos);
|
||||
if (abs(dot(normal, eastVec)) > 0.9) {
|
||||
wpos.xz = wpos.yz / wpos.x;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.x);
|
||||
wpos.xz *= abs(playerPos.x) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.yz * 0.05;
|
||||
} else {
|
||||
wpos.xz = wpos.yx / wpos.z;
|
||||
wpos.xz *= 0.06 * sign(- playerPos.z);
|
||||
wpos.xz *= abs(playerPos.z) + i * dismult + add;
|
||||
wpos.xz -= cameraPosition.yx * 0.05;
|
||||
}
|
||||
}
|
||||
vec2 pos = wpos.xz;
|
||||
|
||||
#if END_PORTAL_VARIATION == 0
|
||||
float colormult = 0.9/(30.0+i);
|
||||
float rotation = (i - 0.1 * i + 0.71 * i - 11 * i + 21) * 0.01 + i * 0.01;
|
||||
float Cos = cos(radians(rotation));
|
||||
float Sin = sin(radians(rotation));
|
||||
|
||||
vec2 coord = mat2(Cos, Sin, -Sin, Cos) * pos + wind;
|
||||
if (mod(float(i), 4) < 1.5) coord = coord.yx + vec2(-1.0, 1.0) * wind.y;
|
||||
|
||||
vec3 psample = pow(texture2D(tex, coord).rgb, vec3(0.85)) * colors[i-1] * colormult;
|
||||
color.rgb += psample * length(psample.rgb) * (3000.0 / repeat);
|
||||
#else
|
||||
float noisePortal = texture2D(noisetex, pos * 0.5).g;
|
||||
color.rgb += texture2D(noisetex, vec2(noisePortal, noisePortal) + wind * 2.0).g * colors[i % 3] * 0.1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
color.rgb *= vec3(0.09, 0.086, 0.06) * 0.9;
|
||||
emission = 10.0;
|
||||
#elif END_PORTAL_VARIATION == 3 // Thanks to WoMspace
|
||||
float portalEffectSpeed = 3.0;
|
||||
vec3 roundedCoords = floor((playerPos - vec3(0.001) + cameraPosition) * 16.0); // not perfect yet, portal shifts when moving up or down
|
||||
float pixelPortalEffect = 0.0;
|
||||
for (int i = 0; i < 5; i++){
|
||||
float currentTime = floor(frameTimeCounter * portalEffectSpeed + float(i));
|
||||
float nextTime = floor(frameTimeCounter * portalEffectSpeed + 1.0 + float(i));
|
||||
// float currentFrame = hash14(vec4(roundedCoords, floor(worldPos.y * 16.0), currentTime));
|
||||
float currentFrame = hash13(vec3(roundedCoords + currentTime));
|
||||
// float nextFrame = hash14(vec4(roundedCoords, floor(worldPos.y * 16.0), nextTime));
|
||||
float nextFrame = hash13(vec3(roundedCoords + nextTime));
|
||||
pixelPortalEffect += mix(currentFrame, nextFrame, fract(frameTimeCounter * portalEffectSpeed));
|
||||
}
|
||||
pixelPortalEffect /= 5.0;
|
||||
|
||||
color.rgb = vec3(0.37, 0.5, 0.8) * pow(pixelPortalEffect, 5.0) * 10.0;
|
||||
emission = pow(pixelPortalEffect, 5.0) * 2.0;
|
||||
lmCoordM.x = 0.0;
|
||||
#endif
|
||||
noDirectionalShading = true;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef PORTAL_EDGE_EFFECT
|
||||
//vec3 voxelPos = SceneToVoxel(mix(playerPos, vec3(0.0), -0.02)); // Fixes weird parallax offset
|
||||
vec3 voxelPos = SceneToVoxel(playerPos);
|
||||
|
||||
if (CheckInsideVoxelVolume(voxelPos)) {
|
||||
float portalOffset = 0.08333 * dither;
|
||||
vec3[4] portalOffsets = vec3[](
|
||||
vec3( portalOffset, 0, portalOffset),
|
||||
vec3( portalOffset, 0,-portalOffset),
|
||||
vec3(-portalOffset, 0, portalOffset),
|
||||
vec3(-portalOffset, 0,-portalOffset)
|
||||
);
|
||||
|
||||
float edge = 0.0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int voxel = int(texelFetch(voxel_sampler, ivec3(voxelPos + portalOffsets[i]), 0).r);
|
||||
if (voxel == 58 || voxel == 255) { // End Portal Frame or Bedrock
|
||||
edge = 1.0; break;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef END
|
||||
// No edge effect in the middle of the return fountain
|
||||
vec2 var1 = abs(playerPos.xz + cameraPosition.xz - 0.5);
|
||||
float var2 = max(var1.x, var1.y);
|
||||
if (var2 > 1.0)
|
||||
#endif
|
||||
{
|
||||
vec4 edgeColor = vec4(vec3(0.18, 0.5, 0.45), 1.0);
|
||||
#if END_PORTAL_VARIATION == 3
|
||||
edgeColor = vec4(vec3(0.2431, 0.2588, 0.7294), 1.0);
|
||||
#endif
|
||||
color = mix(color, edgeColor, edge);
|
||||
emission = mix(emission, 5.0, edge);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,15 @@
|
||||
normalM = upVec;
|
||||
|
||||
highlightMult = 0.0;
|
||||
shadowMult = vec3(0.0);
|
||||
|
||||
#if MC_VERSION >= 11700
|
||||
if (lmCoord.x > 0.99) { // Glowing Sign Text
|
||||
lmCoordM = vec2(0.0);
|
||||
|
||||
emission = 1.0;
|
||||
|
||||
color.rgb *= length(color.rgb) + 0.5;
|
||||
} else // Normal Sign Text
|
||||
#endif
|
||||
color.rgb *= 5.0;
|
||||
@ -0,0 +1,4 @@
|
||||
smoothnessG = color.g;
|
||||
smoothnessD = color.g;
|
||||
|
||||
emission = min(max0(dot(color.rgb, color.rgb) - 1.0) * 6.0, 1.0);
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.r)) * 0.65;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.5;
|
||||
#endif
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = color.r * 0.4;
|
||||
|
||||
smoothnessD = color.r * 0.3;
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 0.75;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.r) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = color.r * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(pow2(color.g))) * 12.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(color.r) * 0.7;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(pow2(color.g))) * 12.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.g) * 0.25;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,7 @@
|
||||
smoothnessG = pow2(pow2(color.g)) * 8.0;
|
||||
smoothnessG = min1(smoothnessG);
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.66;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = pow2(color.g) * 0.7;
|
||||
smoothnessD = smoothnessG;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.77;
|
||||
#endif
|
||||
@ -0,0 +1,6 @@
|
||||
smoothnessG = color.r;
|
||||
smoothnessD = color.r;
|
||||
|
||||
#ifdef COATED_TEXTURES
|
||||
noiseFactor = 0.33;
|
||||
#endif
|
||||
@ -0,0 +1,17 @@
|
||||
float epsilon = 0.00001;
|
||||
vec2 absMidCoordPosM = absMidCoordPos - epsilon;
|
||||
vec3 avgBorderColor = vec3(0.0);
|
||||
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2( absMidCoordPosM.x, absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2(-absMidCoordPosM.x, absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2( absMidCoordPosM.x,-absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2(-absMidCoordPosM.x,-absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2(epsilon, absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2(epsilon,-absMidCoordPosM.y)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2( absMidCoordPosM.x, epsilon)).rgb;
|
||||
avgBorderColor += texture2D(tex, midCoord + vec2(-absMidCoordPosM.x, epsilon)).rgb;
|
||||
avgBorderColor *= 0.125;
|
||||
|
||||
vec3 colorDif = abs(avgBorderColor - color.rgb);
|
||||
emission = max(colorDif.r, max(colorDif.g, colorDif.b));
|
||||
emission = pow2(emission * 2.5 - 0.15);
|
||||
@ -0,0 +1,2 @@
|
||||
smoothnessG = color.r;
|
||||
smoothnessD = color.r * 0.65;
|
||||
@ -0,0 +1,8 @@
|
||||
noSmoothLighting = true;
|
||||
|
||||
color.rgb *= 1.0 + 0.7 * pow2(max(-signMidCoordPos.y + 0.6, float(NdotU > 0.9) * 1.6));
|
||||
|
||||
#ifdef SNOWY_WORLD
|
||||
snowFactor = 0.0;
|
||||
#endif
|
||||
overlayNoiseIntensity = 0.3;
|
||||
@ -0,0 +1,3 @@
|
||||
smoothnessG = pow2(pow2(color.g));
|
||||
smoothnessD = smoothnessG;
|
||||
smoothnessG = max(smoothnessG, 0.3 * color.g * float(color.g > color.b * 1.5));
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user