Compare commits

...

958 Commits

Author SHA1 Message Date
James Seibel d09ddf57d3 remove dev from version number 2025-07-19 14:57:19 -05:00
James Seibel 486edac1d8 replace 1.21.7 with 1.21.8 in gitlab CI 2025-07-19 14:56:32 -05:00
James Seibel 3b3731a137 Replace 1.21.7 support with 1.21.8 2025-07-19 13:29:29 -05:00
s809 563ec70154 Load level on player add if missing 2025-07-19 19:05:59 +05:00
James Seibel 175f5ed6d6 Improve logging for initial DH startup 2025-07-16 07:28:15 -05:00
James Seibel 1e63607233 Fix AfterDhInitEvent not firing on Neo
Fixes some Iris shader compile issues
2025-07-16 07:18:23 -05:00
James Seibel 4dd8be23fa Merge !81 (forge AfterInit API Event not firing on clients) 2025-07-16 06:56:38 -05:00
James Seibel 7fac5b4c6e Remove chunky incompatibility
I'm still a bit annoyed that problems can arise, but if people are able to configure DH/Chunky to work well together, I won't stop them from running together.

Note that a warning will be printed to the chat/log, if chunky is detected.
2025-07-15 07:49:44 -05:00
James Seibel f2ec1ecf3f Update all neoforge references to latest
Hopefully will fix some shader issues #1087
2025-07-15 07:41:19 -05:00
James Seibel 2674e6b2e9 up the version number 2.3.3 -> 2.3.4 2025-07-12 09:35:52 -05:00
James Seibel bcbe3f0fb7 remove dev from the version number 2025-07-12 09:35:24 -05:00
James Seibel f85108ed11 Fix API config renderingEnabled() changing the user value
Fixes #1083
2025-07-12 08:16:40 -05:00
James Seibel 2bc5169ce5 Closes #1084 (AfterDhInitEvent firing before DH config setup) 2025-07-12 08:02:08 -05:00
James Seibel 1edd809708 Fix config UI not showing DH version for MC 1.21.6+ 2025-07-11 07:29:46 -05:00
James Seibel 475111b38b full data DTO close data source if corrupted 2025-07-10 22:25:41 -05:00
James Seibel b44a967e56 Fix monoliths when connected to a server 2025-07-10 07:29:52 -05:00
James Seibel acea685e75 fix some neo running issues with dependency ranges 2025-07-09 07:28:54 -05:00
James Seibel 20f15a6b39 Fixes !1078 (lag due to beacon updating on server) 2025-07-09 07:28:37 -05:00
James Seibel debf52418c Potentially fix an issue with AMD GPU shader compiling
Fix from Cortex and the Canvas mod
2025-07-08 07:22:41 -05:00
James Seibel cf71491381 Disable vanilla fading when shaders are active 2025-07-07 07:49:46 -05:00
James Seibel 0a4a8466cf Add comments to MixinFogRenderer 2025-07-04 09:21:02 -05:00
James Seibel 31fac60d34 Increment default dev MC version 1.21.6 -> 1.21.7 2025-07-04 09:12:36 -05:00
James Seibel c335020c2f Fix sodium fog for MC 1.21.7 2025-07-04 09:05:42 -05:00
James Seibel 4db4f2fbc6 Fix Neoforge 1.21.7 packet registration changes 2025-07-04 09:05:23 -05:00
James Seibel f9f4a208e7 Fix 1.21.7 compiling 2025-07-03 07:52:17 -05:00
James Seibel b5fa5936b3 Add 1.21.7 version (may not compile) 2025-07-02 07:52:07 -05:00
James Seibel 6ceabe7895 Force vanilla fading and overdraw prevention with Sodium 2025-07-02 07:42:55 -05:00
s809 ec3d8afbfc Disable enableAdaptiveTransferSpeed bby default 2025-07-01 22:03:16 +05:00
James Seibel e9a0c6d097 Fix config UI changes not always saving 2025-07-01 07:45:31 -05:00
James Seibel 0238568370 Fix neo config crashing and fix some warnings 2025-07-01 07:22:43 -05:00
James Seibel 74be00e025 Fix neoforge vanilla fade for MC 1.21.6 2025-07-01 07:11:08 -05:00
James Seibel c10af6dd04 fix build-all scripts 2025-06-30 07:46:18 -05:00
James Seibel 85ee5ac833 fix forge compiling 2025-06-30 07:46:12 -05:00
James Seibel 21877d67a5 Add neo version dependency and roll back 6.20 -> 6.19
6.20 had some issue preventing running in dev
2025-06-30 07:38:37 -05:00
James Seibel ae33a79d6e update to Neo 21.6.20 2025-06-30 06:56:08 -05:00
James Seibel 9204b357d8 comment out Z_STD compression
comment out Z_STD compression
2025-06-30 06:55:47 -05:00
James Seibel 78b1b74036 Mark Chunky as incompatible
Done as a test
2025-06-28 13:58:12 -05:00
James Seibel 864c5b5f86 Re-Add Z_STD compression for testing 2025-06-28 11:37:17 -05:00
James Seibel b271c8e119 Fix MinecraftGLWrapper.getActiveTexture() 2025-06-28 10:10:03 -05:00
James Seibel 79bdae5b8b Fix auto-updater for MC 1.21.6 2025-06-28 09:56:51 -05:00
James Seibel d5dc9f6b79 Fix multiplayer null pointer 2025-06-28 09:22:32 -05:00
James Seibel a50f13caa0 Mostly fix Iris transparent rendering for 1.21.6 2025-06-28 08:37:18 -05:00
James Seibel 75b3649a97 Fix world-gen progress not showing in release builds 2025-06-27 07:29:43 -05:00
James Seibel 69adb54b91 disable blending data parsing in chunk loading for MC 1.21.6
There appears to be a parsing issue and since it doesn't appear to change how the chunks load I'm going to ignore it for now
2025-06-27 07:18:01 -05:00
James Seibel 458c1ae7e0 re-add LevelTicks mixin for MC 1.21.4+ 2025-06-27 07:10:12 -05:00
James Seibel a647551d26 Move RenderState to core 2025-06-26 07:50:59 -05:00
James Seibel 3a45bdd2a2 remove broken var in NeoClientProxy 2025-06-26 07:29:51 -05:00
James Seibel 4806cd2445 Move RenderState object into ClientApi 2025-06-26 07:21:33 -05:00
James Seibel af7f90f128 add 1.21.6 to the CI script 2025-06-26 07:10:39 -05:00
James Seibel f72ad60f58 Fix old MC version compiling 2025-06-26 07:10:32 -05:00
James Seibel 6015afbf4c Fix neo rendering and fabric shader rendering 2025-06-25 07:48:04 -05:00
James Seibel 0369ae63f3 fix neo fox mixin 2025-06-21 09:22:39 -05:00
James Seibel 278d5063fb up neoforge version 2025-06-21 09:21:47 -05:00
James Seibel a64e72034e Fix UI text rendering 2025-06-21 09:21:40 -05:00
James Seibel fcdb56660c fix fog renderer again 2025-06-20 07:39:50 -05:00
James Seibel 0c26261cd5 Update gradle.properties 2025-06-19 07:32:43 -05:00
James Seibel b50525fff9 Update ServerPlayerWrapper.java 2025-06-19 07:32:35 -05:00
James Seibel 92e403823b fix gui button rendering 2025-06-19 07:32:21 -05:00
James Seibel e02f56f4ef Update VersionConstants.java 2025-06-19 06:52:32 -05:00
James Seibel aa4681e044 update MC GL Wrapper 2025-06-18 17:36:46 -05:00
James Seibel 1c9130c3f1 update McObjectConverter for matricies 2025-06-18 17:36:22 -05:00
James Seibel c3597cd843 update fog mixin 2025-06-18 17:36:02 -05:00
James Seibel d4a52ac5a3 update version properties 2025-06-18 17:34:14 -05:00
James Seibel 1b9d14e7b4 Disable cave culling for medium quality and higher 2025-06-17 07:15:36 -05:00
James Seibel 0ea27b676e Optimize ClientLevelWrapper.GetWrapper()
Should speed up initial LOD loading a bit
2025-06-17 07:15:15 -05:00
James Seibel cd73608b07 Reduce stuttering with fast world gen 2025-06-14 16:17:33 -05:00
James Seibel 03fc22f611 Reduce allocations in getBlockColor by using a cached method reference
Currently there is a large number of allocations of `java.lang.invoke.invokers$Holder:linkToTargetMethod` -- this prevents that
2025-06-11 07:09:40 -05:00
James Seibel cc251e46b0 Add Api Before/After Text Create events 2025-06-09 07:50:25 -05:00
James Seibel 7aa0bfefec Fix hash collisions in FullDataPointIdMap 2025-06-06 07:43:44 -05:00
James Seibel 9bdad5e4f1 Fix 1.21.5 compiling 2025-06-06 07:36:00 -05:00
James Seibel baebb7323d Close #776 (fix Polytone client biome colors) 2025-06-05 07:53:23 -05:00
James Seibel 8a3175f345 Mark Polytone as incompatible 2025-06-04 07:49:15 -05:00
James Seibel dc58efb301 Handle nulls in ChunkLoader
Should fix WorldPainter worlds
2025-06-04 07:28:51 -05:00
James Seibel c9ac4b2ada Fix GLMC.glDeleteTextures() calls 2025-06-04 07:07:51 -05:00
s809 6e1ec476ed Check LOD timestamps in file handler threads 2025-06-03 23:41:51 +05:00
James Seibel d1aa5a524b Remove line ending from editorconfig
Done to fix some issues with some devs on linux
2025-05-17 11:47:06 -05:00
James Seibel 5c661a3a76 yaml indent 2 -> 4
for consistency
2025-05-17 11:25:37 -05:00
s809 d29e9085a1 Fix getWorldFolderName crash 2025-05-03 13:44:54 +05:00
Ran d392de3c0d Update Forgix
fixes a critical bug
2025-05-03 17:40:58 +10:00
Ran 7209193f8f Fix gradle versioning 2025-05-03 11:21:17 +10:00
s809 ed4f644a3f Bump protocol version 2025-05-03 00:08:12 +05:00
Ran 34038684a7 Fix gradle versioning for core application 2025-05-02 12:45:18 +10:00
s809 6fe6694c82 Merge branch 'feature/adaptive-data-rate' 2025-04-27 21:57:47 +05:00
s809 8e52f1aca5 Merge branch 'refactor/remove-python-dependency' 2025-04-27 21:48:53 +05:00
s809 5ce3dda2d5 Clear up the comment a bit 2025-04-27 21:48:28 +05:00
s809 f4f81f4d7f Account for forge byte when encoding protocol version instead of shifting the entire packet on pre-1.20.6 2025-04-27 21:40:50 +05:00
s809 7c37a5c370 Run prepare only when needed 2025-04-27 00:40:12 +05:00
s809 b495ac4799 remove python dependency for building with correct sqlite natives 2025-04-27 00:13:24 +05:00
s809 2ddeaf50eb test builds 2025-04-21 00:00:01 +05:00
Ran 3721ebea6e Improve LodDataBuilder.java
- Use bitwise modulo
- Don't compute certain things 256 times when they can be computed once.
- Removed expressions that are always false
- Improved comments
2025-04-11 11:24:17 +10:00
Ran 98f8a87362 Improve LodDataBuilder.java
- Use bitwise modulo
- Don't compute certain things 256 times when they can be computed once.
- Removed expressions that are always false
- Improved comments
2025-04-11 11:20:05 +10:00
Ran 10a743ddef Don't check for Indium for Sodium version >= 0.6 2025-04-07 23:53:02 +10:00
James Seibel 95c896f964 maybe break n-sized rendering but fix LOD loading getting stuck 2025-04-07 06:56:58 -05:00
James Seibel 040bc16874 re-add comment to getWorldFolderName() 2025-04-07 06:55:45 -05:00
James Seibel 35d3fdb473 Revert "bandaid fix for Forge 1.20.1 UI crashing"
This reverts commit 2b519a826f.
2025-04-07 06:55:01 -05:00
Ran 549f7510f7 Merge remote-tracking branch 'origin/main'
# Conflicts:
#	common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/TintWithoutLevelOverrider.java
2025-04-07 13:52:25 +10:00
Ran fab64d8477 Fix white foliage issue 2025-04-07 13:52:02 +10:00
Ran 4a6a35f617 Fix white foliage issue 2025-04-07 13:47:42 +10:00
James Seibel 2b519a826f bandaid fix for Forge 1.20.1 UI crashing 2025-04-05 09:19:36 -05:00
James Seibel 445c01b5ae up version number 2.3.2 -> 2.3.3 2025-04-05 09:11:45 -05:00
James Seibel 0f08bd540e remove dev from the version number 2025-04-05 09:10:23 -05:00
James Seibel 77088465f9 Improve DH world gen progress message 2025-04-02 07:25:19 -05:00
James Seibel affe014433 Fix auto updater for MC 1.21.4 and 1.21.5 2025-03-31 06:56:00 -05:00
James Seibel 4c06bf6dbd change iris incompat MC 1.21.5 1.8.12 -> 1.8.10 2025-03-30 17:31:51 -05:00
James Seibel dcab616385 Fix memory leaks due to un-closed thread pools and worlds 2025-03-30 17:31:04 -05:00
James Seibel 89b7d08e9b Fix the sun/moon and stars not rendering
Closes #986
2025-03-30 16:50:43 -05:00
James Seibel 724e318221 Fix beacon beams now going through some blocks 2025-03-30 15:23:27 -05:00
James Seibel a40d62d46a Fix flashing on MC 1.21.5 in non-overworld dimensions 2025-03-30 14:36:56 -05:00
James Seibel 2f6b4c079b don't log InterruptedException during threadPool shutdown 2025-03-29 20:11:36 -05:00
James Seibel 951e3c0271 Fix accidentally removing required imports 2025-03-29 20:09:41 -05:00
James Seibel 84825c2d09 Add MC 1.21.5 to the auto build script 2025-03-29 19:23:53 -05:00
James Seibel ec627e2eba Fix fog for MC 1.16.5 2025-03-29 19:22:59 -05:00
James Seibel 06bc9a349f Fix MC 1.16.5 compiling 2025-03-29 18:48:00 -05:00
James Seibel ff6c4e227b level wrapper weak refs to fix leak on bad shutdown 2025-03-29 18:18:23 -05:00
James Seibel a4d46ffe94 Mark Iris 1.8.12 and lower broken for MC 1.21.5
Older MC versions are unaffected and function correctly
2025-03-29 16:51:46 -05:00
James Seibel bd5c140782 Fix import for fabric mixin texture 2025-03-29 16:45:32 -05:00
James Seibel 229c3f7c91 Add neoforge 1.21.5 2025-03-29 16:11:04 -05:00
James Seibel 693369bc08 MC 1.21.5 changes, lighting fix, and world gen dup fix 2025-03-29 15:45:26 -05:00
James Seibel d109fe6c43 comment out LOD bias option for MC 1.21.5+ 2025-03-29 15:44:54 -05:00
James Seibel 3c9d3707cf update world gen chunk loading for MC 1.21.5 2025-03-29 15:38:42 -05:00
James Seibel 6e53564835 Fix getting block colors for MC 1.21.5 2025-03-29 12:34:35 -05:00
James Seibel 2480fe0d86 Add basic MC 1.21.5 rendering (block colors and world gen broken) 2025-03-29 10:40:36 -05:00
James Seibel 691c9d3f45 up version number 2.3.1 -> 2.3.2 2025-03-25 07:17:34 -05:00
James Seibel 3faf25636d remove dev from version number 2025-03-25 07:16:56 -05:00
James Seibel ab3bfbefb4 remove version from clean in buildall.bat 2025-03-25 07:16:07 -05:00
James Seibel 890e802de4 add execution policy for python script 2025-03-25 07:15:52 -05:00
James Seibel c13bc0cd6e Fix forge 1.18.2 dedicated server crash on startup 2025-03-20 07:08:21 -05:00
James Seibel 7143b7de08 Add config to only log GL errors once 2025-03-19 22:02:57 -05:00
James Seibel d136d782f5 Attempt to fix Linux complaining about glIsFramebuffer() 2025-03-19 18:34:06 -05:00
James Seibel 29a160316c Potentially fix LAN connections on neo/forge 2025-03-19 17:34:03 -05:00
James Seibel 1f6f64d322 Potentially fix GL errors when accessing the default FBO on Linux 2025-03-19 17:00:36 -05:00
James Seibel 37c0af529d Fix restoring textures to the default FBO 2025-03-18 20:18:30 -05:00
James Seibel 1341ea3f3d Attempt to fix GL errors on Linux during buffer cleanup
Attempt to fix #950
2025-03-18 19:51:22 -05:00
James Seibel c0bb120669 Add stack tracing to GL error logging 2025-03-18 18:10:25 -05:00
James Seibel f8887e403f fix passing in the wrong flags to glBufferStorage()
Might Resolve #964 and #950
2025-03-18 07:43:23 -05:00
James Seibel 949ee423c8 Fix changing graphics settings on world load via API 2025-03-16 14:30:04 -05:00
James Seibel b19ed3f30c Fix GL error logging 2025-03-14 10:18:03 -05:00
James Seibel 2d085e1074 Add additional error checking/handling to Shader compiling 2025-03-13 21:12:34 -05:00
James Seibel 6ba0490cf7 Closes !950 (Texture name does not refer to a texture object) 2025-03-13 18:09:43 -05:00
James Seibel b6a0878241 up version number 2.3.0-b -> 2.3.1-b-dev
Also fix compiling for release builds
2025-03-08 08:11:14 -06:00
James Seibel 50f5371084 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-03-06 07:43:29 -06:00
James Seibel df74b8d243 Update coreSubProjects 2025-03-06 07:43:22 -06:00
James Seibel fce2868c62 remove dev from version number for release 2025-03-06 07:41:52 -06:00
s809 a36cd0763b Add some debugging info for DTOs 2025-03-02 20:09:11 +05:00
James Seibel 0fba015f54 Fix crashing on MC 1.20.1 and older when updates aren't found 2 2025-03-01 09:19:52 -06:00
James Seibel f251c90472 Fix crashing on MC 1.20.1 and older when updates aren't found 2025-03-01 09:13:47 -06:00
s809 492a051a3b Replace chunk counts with speed in pregen 2025-02-27 21:08:31 +05:00
s809 0aa4743c1b Should be division instead of multiplication 2025-02-26 23:17:05 +05:00
s809 85f16944b2 Offset generation bounds by teleportation scale 2025-02-26 22:13:43 +05:00
James Seibel dddb0be2ac duct tape fix to reduce chance of LOD uploading requiring MC reboot 2025-02-25 07:26:12 -06:00
s809 4a3effa2f5 Remember split section responses temporarily 2025-02-22 20:55:18 +05:00
s809 a0a9151bfd Fix foreground thread sometimes blocking server shutdown 2025-02-19 21:17:42 +05:00
s809 aa3d15f38f Show section numbers in pregen 2025-02-19 20:37:29 +05:00
James Seibel adcb2a3a05 Fix IDhApiConfigValue.clearValue() failing for some deprecated functions 2025-02-17 21:16:27 -06:00
James Seibel 78f2cb24cc Fix DB leaks in FullDataV2Repo 2025-02-16 20:07:13 -06:00
James Seibel 67945509ed Fix errors related to player pos being unloaded 2025-02-16 19:54:11 -06:00
James Seibel c653e526a5 Revert 10 minute memoization for world gen 2025-02-15 11:56:25 -06:00
James Seibel 49b50c4c88 Fix beacon culling with auto overdraw prevention 2025-02-15 11:12:57 -06:00
James Seibel 7449f46c5e Add missing cave blocks for cave culling 2025-02-15 11:06:57 -06:00
James Seibel 069fc39aad up fabric api version for 1.21.1 to allow Immersive Portals testing 2025-02-14 07:48:32 -06:00
s809 4979ccf3e2 Invert generateOnlyInHighestDetail and rename to enableNSizedGeneration 2025-02-11 22:08:29 +05:00
James Seibel dd7f9c20b6 Put N-sized generation and upsampling behind experimental configs 2025-02-11 07:47:36 -06:00
James Seibel e96f9de1f0 Fix dimension wrapper creating duplicates for the same name 2025-02-11 07:05:34 -06:00
James Seibel c902e1957f Fix auto updater failing for nightly builds 2025-02-10 07:47:03 -06:00
James Seibel d40afb7a2a Fix C2ME slowdown again 2025-02-08 21:43:49 -06:00
James Seibel 01474d72e3 remove unneeded IVersionConstant methods 2025-02-08 11:39:26 -06:00
James Seibel 7c5af1836b add FIXME comment related to getChunkNbtDataAsync()
this method appears to be called much more often than it should be, very often 25 times per chunk position.
Very strange.
2025-02-08 11:12:06 -06:00
James Seibel a9bf6ae7e4 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-02-08 10:46:16 -06:00
James Seibel aef3162246 reduce test N-sized generator height 2025-02-08 10:45:55 -06:00
James Seibel 97ce869076 Fix C2ME causing memory use to explode with DH world gen 2025-02-08 10:45:38 -06:00
s809 91b3c83ffd Update core 2025-02-07 23:23:25 +05:00
James Seibel 1522df19cb Attempt to fix threadpool shutdown rejection exception 2025-02-07 07:26:07 -06:00
James Seibel 3845564128 Reduce world gen down time when using extremely fast generators 2025-02-07 07:15:31 -06:00
s809 23ef7cf27a Fix incorrect distance being used in update propagation SQL and reduce queue size 2025-02-07 01:05:18 +05:00
James Seibel bec28a5694 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-02-05 17:32:37 -06:00
James Seibel 8f20f103ad Fix empty data sources when moving in multiplayer or with N-sized world gen
Increases networking protocol from 9 -> 10
2025-02-05 17:32:30 -06:00
James Seibel 246e77cc56 Fix render enabled config getting set by world gen progress config 2025-02-02 19:55:06 -06:00
James Seibel 87fa29c77a Fix compiling with missing "E" 2025-02-02 15:52:20 -06:00
s809 5010256ce6 Update core 2025-02-02 20:30:57 +05:00
s809 a66ad19343 Balance tasks in thread pool using elapsed time instead of priorities 2025-02-02 20:30:04 +05:00
s809 913a458a1a Auto-move old save data to new location 2025-02-02 15:38:06 +05:00
s809 093d3a801e Remove generationProgressDisableMessageDisplayTimeInSeconds from server config command 2025-02-01 19:38:46 +05:00
s809 61ccf7bf60 Decrease delay between missing generation rechecks 2025-01-31 14:54:32 +05:00
s809 f948072253 Decrease delay between missing generation rechecks 2025-01-31 14:53:57 +05:00
s809 b748f27a1c Fix beacon beams flickering 2025-01-30 22:30:08 +05:00
s809 4dd4bb9ef0 Fix nightly self-updater after moving jars into zip root 2025-01-30 18:11:39 +05:00
s809 5051bde3b0 Add pycache into gitignore 2025-01-30 00:22:03 +05:00
s809 42cf639acc Merge branch 'test/artifacts-in-zip-root' 2025-01-30 00:21:02 +05:00
s809 9e6953a596 Fix relocation breaking runClient & runServer 2025-01-29 23:59:23 +05:00
s809 7f4f8a40eb Merge branch 'experimental/relocate_sqlite' 2025-01-29 23:23:36 +05:00
s809 89ca535a6f Add all the extra comments 2025-01-29 23:23:21 +05:00
s809 145182502e Do not relocate when python is not installed 2025-01-29 23:01:28 +05:00
s809 d61dfc9e03 Revert "Improve chunk processing throughput" 2025-01-28 22:56:52 +05:00
James Seibel 611d7d87ae Fix compiling for MC 1.19.2 and below 2025-01-26 18:12:01 -06:00
James Seibel 2f6a2d99ab Remove unneeded MixinLevelTicks (!73)
https://gitlab.com/distant-horizons-team/distant-horizons/-/merge_requests/73#note_2281882248
2025-01-26 17:47:32 -06:00
James Seibel d88ca0c98d Improve CPU usage and chunk update throughput 2025-01-26 17:13:28 -06:00
s809 0f64df7be0 Add missing enabled check 2025-01-26 22:08:17 +05:00
s809 23a1f0b025 Clean up code 2025-01-26 17:52:30 +05:00
s809 4a72e02550 Sign natives for mac 2025-01-25 18:25:58 +05:00
James Seibel 521bcdcc0f fix recalculate heightmap breaking stairs, slabs, and glass 2025-01-24 07:24:43 -06:00
s809 4eb20d5ce8 Fix using wrong path on linux 2025-01-24 11:28:51 +05:00
s809 3ad68aaf42 Merge branch 'main' into experimental/relocate_sqlite 2025-01-24 11:27:41 +05:00
s809 2a9a03771e Check if session is ready before ignoring local chunks 2025-01-24 11:20:49 +05:00
James Seibel 8f7823a4d2 Fix holes when moving with N-sized world gen/server side support 2025-01-23 19:45:25 -06:00
James Seibel cc4b965966 Speed up PhantomArrayListPool for large checkouts 2025-01-23 19:21:13 -06:00
s809 a6418de927 Merge branch 'main' into experimental/relocate_sqlite 2025-01-23 23:23:12 +05:00
s809 5303415d05 Ignore local chunks if realtime updates are enabled 2025-01-23 23:21:40 +05:00
s809 836515934f Fix column order check breaking on tiny columns 2 2025-01-23 00:18:38 +05:00
s809 228dc46d6b Fix column order check breaking on tiny columns 2025-01-23 00:15:18 +05:00
James Seibel a91f9670dc Show instructions to disable world gen progress message for short time 2025-01-21 07:49:36 -06:00
James Seibel 81313252f2 fix links in issue templates 2025-01-21 07:07:53 -06:00
s809 f65d411978 Fix task splitting causing generation of already generated sections 2025-01-21 17:26:58 +05:00
James Seibel 8c8a5ffeaf Fix cached RenderSource closing while in use 2025-01-20 21:51:24 -06:00
s809 68793fbe8d Process elf correctly 2025-01-21 00:33:43 +05:00
s809 d8401a8f49 Merge branch 'main' of https://gitlab.com/jeseibel/distant-horizons into experimental/relocate_sqlite 2025-01-20 23:39:16 +05:00
s809 07ff00f7c9 Merge remote-tracking branch 'origin/main'
# Conflicts:
#	coreSubProjects
2025-01-20 11:00:29 +05:00
s809 fadaff1113 Add generation bounds 2025-01-20 10:59:33 +05:00
James Seibel ff6bf7b4c9 Fix beacons disappearing and not updating correctly
Note: there appears to still be some off-by-one errors, although they happen relatively infrequently in my testing.
2025-01-19 17:48:36 -06:00
s809 082b1224a8 Relocate sqlite library 2025-01-19 03:26:53 +05:00
s809 bc475373fc Add a check for duplicate config command names and fix duplicate name 2025-01-18 16:27:16 +05:00
s809 498e958eca Add a check for duplicate config command names and fix duplicate name 2025-01-18 16:26:42 +05:00
s809 82e0cfe0b4 Fix server not shutting down, again 2025-01-15 23:34:48 +05:00
James Seibel 31d89e3349 Reduce duplicate warning logs when handling old worlds 2025-01-14 21:17:57 -06:00
James Seibel a3775c1f88 remove unneeded debug log 2025-01-14 19:48:30 -06:00
s809 e070bf4244 More consistent names but reverse 2025-01-14 21:25:58 +05:00
s809 8287192cd0 More consistent names 2025-01-14 21:15:01 +05:00
s809 d40f4dfe19 Artifacts in zip root 4 2025-01-14 21:01:30 +05:00
s809 595cdf011a Artifacts in zip root 3 2025-01-14 20:56:44 +05:00
s809 96f2f8c3b2 Artifacts in zip root 2 2025-01-14 20:48:17 +05:00
s809 c883ded7c4 Artifacts in zip root 2025-01-14 20:39:21 +05:00
James Seibel 834269da67 Reduce holes when flying around a partially loaded world 2025-01-14 07:35:39 -06:00
James Seibel a9bebf03d5 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-14 07:04:24 -06:00
James Seibel 939f6304bf Put several queries in try-finally blocks 2025-01-14 07:04:11 -06:00
s809 6e9f466570 Release full data sources after sending to clients 2025-01-13 23:37:26 +05:00
James Seibel a0b5cc7a5c Fix potential world gen error if center chunk is missing 2025-01-13 07:31:50 -06:00
s809 82708d998d Use dynamic precision for displaying pregen status 2025-01-12 21:56:54 +05:00
James Seibel 613e444490 Remove year range from licensing headers
The license is still valid, now I just don't have to update them every year
2025-01-11 21:27:25 -06:00
James Seibel f493e201d4 Add commented out logic for LevelChunkSection cloning
It was far to difficult a task for a issue I've only ever heard about once
2025-01-11 21:16:15 -06:00
James Seibel 2a8013b1d6 reminder comment about potential LodQuadTree concurrent issue 2025-01-11 21:06:58 -06:00
James Seibel 54fed62507 Add automatic overdraw prevention to improve fading 2025-01-11 17:59:27 -06:00
James Seibel e51bec9ce4 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-11 14:56:39 -06:00
s809 e47a83b706 Pregen improvements 2025-01-11 23:55:23 +05:00
James Seibel 8029c7b00c Fix some generic object rendering concurrent modification issues 2025-01-11 09:35:36 -06:00
James Seibel 2b38dc2575 Fix GL state corruption for mods not using MC's GlStateManager
This specifically fixes a bug with Iris where `GL46C.glDisable(GL46C.GL_CULL_FACE);` is called (instead of `GlStateManager._disableCull()`) during the transparent rendering pass, causing vanilla MC water chunks to have their normals inverted.
2025-01-11 08:24:28 -06:00
James Seibel 46cafb4cbe Fix compiling, forgot to move some QuadTree objects 2025-01-10 22:16:23 -06:00
James Seibel ff96533c93 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-10 22:00:24 -06:00
James Seibel 89e73f6383 Fix rendering LODs from different levels after changing dimensions 2025-01-10 21:57:57 -06:00
s809 069ebfe24e Add pregen command 2025-01-11 02:55:09 +05:00
s809 8b374c4734 Fix compilation 2025-01-11 02:54:30 +05:00
James Seibel 1febade083 Improve initial LOD loading speed and add KeyedLockContainer 2025-01-10 07:26:44 -06:00
James Seibel deedd85914 Fix delayedSaveCache and fix slow LOD updating regression 2025-01-09 21:27:00 -06:00
James Seibel 218c27adae Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-09 18:44:09 -06:00
James Seibel fde48b6f1a replace stacktrace prints with loggers 2025-01-09 18:43:59 -06:00
James Seibel f2a36e73d0 Fix typo in BatchGenEnvironment 2025-01-09 17:13:03 -06:00
s809 c5429ad139 Ignore task rejections if shutting down 2025-01-08 18:46:22 +05:00
James Seibel 7bc2ee296c Improve auto updater logging and fix potential issues with updating 2025-01-07 21:34:07 -06:00
James Seibel 4e26e4ab31 Add quick config to show/hide world gen progress 2025-01-07 20:30:34 -06:00
James Seibel a91685b590 Fix missing LODs (especially when world gen is active) 2025-01-07 20:14:46 -06:00
James Seibel 06f73c9b0a Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-07 20:00:55 -06:00
James Seibel 062dc29fd4 Add world gen progress updates to the overlay 2025-01-07 19:18:30 -06:00
s809 4096a24306 Fix some small issues and add comments 2025-01-07 17:08:28 +05:00
s809 2563de3ba3 Merge branch 'refactor/thread-pool-executors' 2025-01-07 16:36:57 +05:00
s809 4a99b42fa8 Add a config option to force server to always send only the highest detail 2025-01-07 01:25:36 +05:00
s809 f12f119ce2 Refactor thread pool handling 2025-01-06 23:32:29 +05:00
James Seibel 775adfaad5 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2025-01-05 19:15:28 -06:00
James Seibel 2a9c319935 Log a warning if the vanilla render distance is too high 2025-01-05 19:15:18 -06:00
s809 fda44c41a8 Add comments to UPDATE_POS_MANAGER.maxSize and refactor 2025-01-04 22:11:26 +05:00
James Seibel 8247f5f215 add comments to DhLitWorldGenRegion.getBlockTicks() 2025-01-04 10:50:56 -06:00
James Seibel 7eba6848bb Merge branch 'distant-horizons-fix/disable-scheduled-ticks' 2025-01-04 10:17:09 -06:00
James Seibel 6e84cac0d2 Fix infinitely growing memory and add warnings if memory isn't enough 2025-01-04 10:12:03 -06:00
s809 2bf96ea781 Update core 2025-01-04 19:25:48 +05:00
James Seibel d5de4a8171 Fix sqlite memory leaks 2025-01-03 14:47:42 -06:00
James Seibel 3cd7c7f1a3 remove pmcVer from forge runClient 2025-01-03 14:47:18 -06:00
ishland 1741ebf8b2 change: remove block and fluid scheduled tick access as it is unneeded 2025-01-03 16:57:34 +08:00
s809 55776f8beb Update core 2025-01-03 01:04:13 +05:00
s809 a469770e5d Check for updates on launch on dedicated servers 2025-01-03 00:30:15 +05:00
s809 851dabc18b Fix 1.16.5 compilation 2025-01-02 20:20:32 +05:00
s809 dccdbaeb73 Rename serversideShortName to chatCommandName 2025-01-02 19:43:01 +05:00
s809 f4126f5378 Add descriptions to config entries in commands 2025-01-01 20:33:01 +05:00
s809 97af075c7d Use correct world folder name in LAN level key prefix 2025-01-01 18:13:25 +05:00
James Seibel 1dfdd422db Potentially fix EXCEPTION_ACCESS_VIOLATION rendering crash 2024-12-31 09:08:25 -06:00
James Seibel 072082c56a handle corrupted data better 2024-12-28 13:45:43 -06:00
James Seibel 43caa2a55c Fix neoforge running in release 2024-12-28 13:45:17 -06:00
James Seibel b8bad9b6bf fix compiling for MC 1.20.4 2024-12-27 18:12:14 -06:00
James Seibel 8afdd6ed2b Fix typo preventing threadpools from running 2024-12-27 18:11:58 -06:00
James Seibel 34968a6945 Add schedule fix mixin to neoforge
also fix old fabric compiling
2024-12-27 09:25:54 -06:00
James Seibel 851a79a77e Fix compiling on older MC versions 2024-12-27 09:18:00 -06:00
James Seibel 1ca1db705f Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-12-27 08:48:16 -06:00
James Seibel 8f57c2cce2 Only have a single thread config 2024-12-27 08:47:20 -06:00
s809 942e3093cb Respond to incompatible packets so the client is able to display an error in F3 2024-12-27 17:05:07 +05:00
s809 f3e65010f1 Fix failed counter working incorrectly 2024-12-27 15:51:47 +05:00
s809 b3cfb35fac Update core 2024-12-26 16:09:29 +05:00
s809 b60d778303 Use library provided method for filling *ArrayLists 2024-12-25 23:12:58 +05:00
James Seibel 9ec28aa661 Fix beacons not appearing chunks pulled from distant generation 2024-12-25 09:31:01 -06:00
James Seibel 98400a9d3c Fix mod compat warning chat not hiding with config 2024-12-25 09:17:44 -06:00
James Seibel ae8658ae77 Fix DH preventing server shutdown on close 2024-12-25 09:04:55 -06:00
James Seibel e928fe3ecd Fix not loaded tick schedule warning in world gen
"Trying to schedule tick in not loaded position" can log in MC 1.21.4 when sand or other FallingBlock.class blocks attempt to generate in a DH context (IE the chunk isn't loaded in the server).
2024-12-25 08:23:33 -06:00
James Seibel 963dc4a404 minor DhLitWorldGenregion refactor 2024-12-25 08:21:42 -06:00
James Seibel 04f42999df potentially fix rare null pointer 2024-12-24 08:54:28 -06:00
James Seibel 730d014f13 Fix compiling on for MC before 1.21.1 2024-12-24 08:09:02 -06:00
James Seibel 1f81c50ce1 Fix lag/errors when pulling pre-existing chunks 2024-12-24 08:02:01 -06:00
James Seibel f60c550879 Massively reduce memory use and fix object leaks 2024-12-22 09:17:49 -06:00
James Seibel 0d556b5d95 Attempt to fix stuttering in MC 1.21.4 for pre-existing chunk pulling 2024-12-20 15:36:36 -06:00
James Seibel 70d897f09c add config assumePreExistingChunksAreFinished 2024-12-20 15:27:03 -06:00
James Seibel 9accb6d584 refactor testGenericWorldGen to support hotswapping 2024-12-20 14:02:30 -06:00
James Seibel 843dc580c8 Repo and Obj Pool rewrite
This should provide a significant reduction in garbage generated, reducing GC pressure.
2024-12-20 13:38:47 -06:00
James Seibel 77aa4773ef Fix some bugs and reduce GC load slightly 2024-12-14 23:35:36 -06:00
James Seibel fc3c944e3d remove timeout from chunk IoWorker in world gen 2024-12-14 23:35:29 -06:00
James Seibel 7d6aecc4c7 Merge branch 'distant-horizons-feature/server-backed-distant-gen'
Also remove ChunkWrapper LevelReader parameter
2024-12-14 14:07:16 -06:00
James Seibel 528beb8384 Revert chunky core changes 2024-12-14 12:21:56 -06:00
James Seibel 5f1180a5dd Revert "Fix holes when using Chunky" 2024-12-14 12:21:39 -06:00
James Seibel a9f1e8587c Revert "change the chunky warning message"
This reverts commit 77a366065d.
2024-12-14 12:20:27 -06:00
James Seibel 7a076f5509 re-add full (server) distant generator mode 2024-12-13 07:26:55 -06:00
James Seibel 3349e51655 minor batchGenEnv renaming 2024-12-13 07:25:47 -06:00
James Seibel 77a366065d change the chunky warning message 2024-12-12 21:05:19 -06:00
James Seibel c2d6ecaae6 Fix holes when using Chunky
(at the cost of some server lag)
2024-12-12 20:56:48 -06:00
James Seibel c9bc830058 Fix null pointer in LodRenderSection 2024-12-12 07:46:41 -06:00
James Seibel 6125031d9d Remove world gen timeout config
It didn't work as originally intended. It was originally added to prevent world gen lock-ups if a thread hits and infinite loop, but it didn't do anything for that use case and just ended up being annoying for low-end users.
2024-12-12 06:59:10 -06:00
s809 c041cde574 Show thread preset in config entries in server command 2024-12-10 20:19:03 +05:00
s809 bd946af229 Add player into request group before trying to fulfill 2024-12-09 16:48:24 +05:00
s809 559626456a Prune world gen tasks above limit in multiplayer 2024-12-09 12:03:53 +05:00
s809 c6843c1d95 Revert "Fix gen tasks sometimes not submitting after LOD level changes"
This reverts commit 585a288f
2024-12-08 19:33:20 +05:00
James Seibel 0d32fab434 Fix off-by-one error in DhAPI Terrain Repo
Specifically getting by blockpos
2024-12-07 15:08:40 -06:00
James Seibel 94571de00f Improve Chunk LOD building (thanks builderb0y!) 2024-12-07 11:45:02 -06:00
James Seibel d062eff8b4 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-12-07 11:20:28 -06:00
James Seibel b1e46faf6f Fix GLWrapper compiling for MC 1.16 2024-12-07 11:20:09 -06:00
James Seibel 04ed5b2e03 Replace many GL32 calls with GLMC (IMinecraftGLWrapper) 2024-12-07 09:56:50 -06:00
s809 15d9ff503f Re-add pruning of visitedPositions 2024-12-06 23:32:59 +05:00
s809 64942d77e4 Use N-sized generation on server when available 2024-12-06 23:10:53 +05:00
s809 f287dbd4d3 Merge branch 'NSizedMultiplayerTest' 2024-12-04 23:40:00 +05:00
James Seibel c387f57d9c Add MC 1.21.4 to the CI build script 2024-12-03 20:21:10 -06:00
James Seibel 2dacb91b79 Add MC 1.21.4 support 2024-12-03 20:17:50 -06:00
James Seibel d809568cc3 update Iris/Sodium dependency versions for 1.21.1
Just used for compiling and consistency, shouldn't change anything
2024-12-03 19:44:04 -06:00
James Seibel beee44df14 Add fabric-api >= 0.110.1 requirement for MC 1.21.3 2024-12-03 19:40:29 -06:00
s809 f651fc4b50 Up protocol version 2024-12-03 21:23:41 +05:00
s809 596e4eae0e Fix gen tasks sometimes not submitting after LOD level changes 2024-12-03 21:13:01 +05:00
James Seibel 6e70073ae4 Add visited position removal timer in RemoteFullDataSourceProvider 2024-12-02 07:51:12 -06:00
James Seibel 1beef2b4ad Fix a potential null pointer in world gen chunk loading 2024-12-02 07:18:42 -06:00
James Seibel a0e4ed8371 Fix 1.20.4 compiling 2024-12-01 21:06:30 -06:00
James Seibel f40adfd9c6 Merge !70 (Fix invisible gui button in MC 1.21.3) 2024-12-01 17:52:32 -06:00
James Seibel 7fb5e95809 Add Fabric 1.21.3 support
Also fixes:
`Mod was built with a newer version of Loom (1.8.9), you are using Loom (1.7.415)`
2024-12-01 17:43:09 -06:00
James Seibel 03d5cb9289 Fix compiling for Java 8 2024-12-01 17:06:53 -06:00
James Seibel 3b4b4d6b7e Remove unused world gen MixinData thread local 2024-12-01 17:00:22 -06:00
James Seibel b9a97a0fda Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-12-01 15:51:42 -06:00
James Seibel 0dae6942cb Update coreSubProjects 2024-12-01 15:51:27 -06:00
James Seibel 8bb6aeb526 up the manifold version 2024.1.35 -> 37 2024-12-01 15:50:54 -06:00
James Seibel 32ec420248 Merge !68 (Fix slowdown when C2ME is installed)
Thanks ishland for the fix!
2024-12-01 15:50:41 -06:00
s809 1925537da0 Lower log level of out of range warning 2024-11-22 14:54:48 +05:00
James Seibel 3bb4c21fa2 Fix forge compiling for some versions 2024-11-21 19:22:25 -06:00
James Seibel 5b61a98196 Fix race condition when generating terrain extremely quickly 2024-11-21 19:00:57 -06:00
James Seibel 7c6eba983a Fix auto updater attempting to update to "null" 2024-11-19 07:32:54 -06:00
James Seibel 0023ab09ed Fix auto updater not appearing on neoforge 2024-11-19 07:32:27 -06:00
James Seibel c289f5d717 minor format cleanup 2024-11-19 06:58:12 -06:00
watertrainer 6df3ad722c delete done TODO 2024-11-19 11:30:43 +00:00
watertrainer 56f6abd858 ensure clientLevel is loaded, even if player gets redirected (fixes #869) 2024-11-19 11:30:00 +00:00
James Seibel c326e0ba81 Fix a rare error where chunk lighting is set to -1 2024-11-18 07:46:27 -06:00
James Seibel 60b28fcf2e Fix sometimes not loading high-detail LODs when on a server 2024-11-18 07:40:24 -06:00
James Seibel a9ffd3bd3b Forgot to remove all of manifold string gradle 2024-11-18 07:15:33 -06:00
James Seibel bc72e925df Remove manifold string plugin 2024-11-17 08:03:15 -06:00
James Seibel 108df99633 up version number 2.3.0-a -> 2.3.0-b 2024-11-16 22:07:41 -06:00
James Seibel ba245ea266 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-11-16 22:03:48 -06:00
James Seibel ec721ce172 minor build.gradle formatting change 2024-11-16 21:59:28 -06:00
James Seibel 3ad2a95c10 up fabric loader version in 1.21.1 2024-11-16 21:59:15 -06:00
James Seibel e22e241d06 revert accidental change to gradle.properties default version 2024-11-16 21:58:18 -06:00
James Seibel cd70d55b4d comment to remove unused fabricLike gradle references 2024-11-16 21:30:58 -06:00
James Seibel b6c98d3bde Append mod loader to merged jars 2024-11-16 21:25:50 -06:00
s809 5fe605540d Replace Apache's base32 with guava 2024-11-15 09:33:10 +05:00
s809 c232b64f24 Add a comment to #pluginMessageReceived methods 2024-11-14 15:52:46 +05:00
s809 f94b6dbaa5 Replace truncating the hashed seed with encoding it into base32 2024-11-14 15:23:57 +05:00
James Seibel 928bc5df6c Fix setting saturation to 0 crashing the game 2024-11-13 18:26:32 -06:00
James Seibel a5865b3545 Decrease Min mcmeta version from 16 -> 7
should still fix #832
mcmeta files were re-added since forge needs them for certain resource files to load
2024-11-11 07:13:04 -06:00
James Seibel 8f15ab7ccd Revert "Close #832 (remove pack.mcmeta)"
This reverts commit 70550a21a0.
2024-11-11 06:58:15 -06:00
James Seibel 131e4124f3 fix getHashedSeed again from merge 2024-11-09 21:21:21 -06:00
James Seibel ae6333c7b5 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-11-09 21:19:36 -06:00
James Seibel d38c622d9b Fix compiling due to incomplete IDhLevel changes 2024-11-09 21:19:01 -06:00
James Seibel fe625e5b55 Fix ColorUtil impot in ClientLevelWrapper 2024-11-09 21:07:23 -06:00
James Seibel 38a6ad552b Fix height fog 2024-11-09 20:58:59 -06:00
s809 222a008514 Remove seed hash from local & server worlds, and expose DH's level identifier to API 2024-11-09 22:37:05 +05:00
James Seibel 56684bdf4c Fix some render thread tasks not running (causing holes) 2024-11-09 09:53:45 -06:00
James Seibel eb4525c68d Update coreSubProjects 2024-11-09 08:49:23 -06:00
James Seibel 66eb2ed0f9 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-11-09 08:49:05 -06:00
James Seibel 9866842e01 Improve Buffer uploading speed and remove buffer upload thread 2024-11-09 08:48:29 -06:00
coolGi e9487b0481 Updated readme to use the new DH links 2024-11-09 14:40:00 +00:00
James Seibel 82c5aa907b Buffer upload speed test 2024-11-08 07:46:17 -06:00
James Seibel 47b145cb90 up neoforge version 21.3.4 -> 21.3.11 2024-11-07 07:30:46 -06:00
James Seibel ff46b925b2 minor config screen refactoring 2024-11-07 07:30:30 -06:00
James Seibel 8ca7ff5ae0 Fix crashing after server shutdown in serverPlayerDisconnectEvent 2024-11-06 07:08:36 -06:00
James Seibel 70550a21a0 Close #832 (remove pack.mcmeta)
DH doesn't use resource pack files so these files are unnecessary and just cause warnings.
2024-11-06 07:01:55 -06:00
James Seibel 50f911f63c Fix unnecessary logging for JarUtil jarFile getting
Closes #733
2024-11-05 07:32:49 -06:00
James Seibel 4b0dca5823 re-add missing ColorUtil import 2024-11-04 19:34:50 -06:00
James Seibel 0e777f04bc Add hashed seed to server level folders to replace multiverse similarity
Closes !514 and Closes !476
2024-11-04 18:31:04 -06:00
s809 b12f27cc18 Fix Flashback crash on dimension loading 2024-11-03 19:20:20 +05:00
James Seibel 1a66f457af add recalculate heightmap config (disabled by default) 2024-11-02 13:09:03 -05:00
James Seibel b4dca6a1b4 Fix MC_CLIENT.getPlayerCount() null pointer 2024-11-02 13:06:10 -05:00
James Seibel 7759a2f9ea Fix air.isSolid() crash 2024-11-02 13:05:56 -05:00
James Seibel fe9bccb91f add 1.21.3 to nightly builds (still no fabric) 2024-11-02 11:29:55 -05:00
James Seibel fc6fd310f6 use gradle for shared fabric launch config 2024-11-02 11:21:20 -05:00
James Seibel 8be161b381 Add MC 1.21.3 support for Neoforge (no fabric) 2024-11-02 11:21:03 -05:00
James Seibel 8eba8cb40b gradle wrapper 2024-10-30 20:49:22 -05:00
James Seibel 44326344e6 update fabric api dependency for 1.21.1 2024-10-29 20:01:59 -05:00
James Seibel 17b7ee9045 Increase the default render distance 128 -> 256 2024-10-27 16:13:54 -05:00
s809 6a47a2150f Fix too many chunks spam 2024-10-26 00:33:48 +05:00
James Seibel 13728a7540 Closes !825 (Cache arrays used in generic object upload) 2024-10-25 07:40:48 -05:00
James Seibel c51e941413 Fix the update screen logo scaling 2024-10-24 07:07:51 -05:00
James Seibel 2a05c32a2f Fix DH fade corrupting the GL state 2024-10-22 16:28:07 -05:00
James Seibel 353a507914 Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-10-22 15:33:16 -05:00
James Seibel f3b73d54f8 Update coreSubProjects 2024-10-22 15:33:13 -05:00
s809 92ed9b8070 Update core 2024-10-22 23:55:50 +05:00
s809 9c3c37bc3e Use earlier event for storing server instance 2024-10-22 23:55:37 +05:00
James Seibel 79fb7c654a Add warning if chunky is installed 2024-10-21 13:27:28 -04:00
James Seibel 520b4e0930 add ClientUtil.argbToInt() 2024-10-21 08:53:26 -04:00
s809 45a07206c9 Update core 2024-10-21 16:43:46 +05:00
s809 ad0b78936a Enable multiplayer in 1.16.5 2024-10-21 16:43:39 +05:00
s809 2babae40de Multiply update queue size by player count 2024-10-20 20:04:35 +05:00
s809 17713a9f93 Make sure data source received from file handler is fully generated before sending to client 2024-10-20 15:15:15 +05:00
s809 48120a4a38 Move commands under /dh, add /dh debug command 2024-10-20 15:14:03 +05:00
s809 69ffd795c9 Split commands into classes 2024-10-20 01:39:16 +05:00
s809 1df5dd5458 Up protocol version 2024-10-18 11:18:34 +05:00
James Seibel b77acaa3b2 Fix javadoc compiling and some Mac lockup issues 2024-10-15 07:47:59 -05:00
s809 d8024ab488 Use version specific caches 2024-10-15 00:33:15 +05:00
James Seibel 064d8b3506 Fix default beacon culling setting 2024-10-14 07:41:13 -05:00
James Seibel 9ca6a2116b Fix Forge compiling 2024-10-14 07:40:24 -05:00
James Seibel 449c87982c Add additional run configurations 2024-10-14 07:12:44 -05:00
James Seibel 7edfc40b9d Split the config file, update the config UI, and remove a few unused configs 2024-10-12 20:39:42 -05:00
James Seibel 9acda97f54 Fix N-sized world gen causing holes when moving 2024-10-12 09:53:46 -05:00
James Seibel 14edd63029 Fix adjacent chunk lighting (thanks CreepermeYT) 2024-10-11 22:14:01 -05:00
James Seibel f3a1235dd3 Fix core standalone jar running (hopefully this doesn't bork Quilt) 2024-10-10 07:44:15 -05:00
James Seibel de93bfee2f Fix 1.16.5 and 1.17 compiling 2024-10-10 06:56:03 -05:00
James Seibel 6eb80ace00 Fix world gen incorrectly returning some data sources to the pool 2024-10-08 20:17:33 -05:00
s809 3ac8d6a8b1 Fix incorrect name of a method 2024-10-08 22:59:00 +05:00
s809 269c8dc4e3 Fix incorrect folder being used without level keys 2024-10-08 22:37:55 +05:00
James Seibel c8173005a7 Decrease vertical quality drop off 2024-10-08 07:51:39 -05:00
James Seibel ed846ea564 merge !67 (Add Mojang Maven repository to fix arm64 MacOS builds) 2024-10-08 07:23:39 -05:00
James Seibel f6a8f5c6b5 Prevent returning out of bounds ColumnArrayView's 2024-10-08 07:07:53 -05:00
s809 3c60a7d842 Fix keyed levels not changing 2024-10-08 09:05:27 +05:00
James Seibel 3c97feeaf8 add comment about spongepowered vanilla gradle versions 2024-10-07 20:16:27 -05:00
James Seibel b2ac91f7db Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-10-07 19:45:37 -05:00
James Seibel 1ebad39fc1 Update the API to allow for N-sized world generation requests
This breaks old world generators
2024-10-07 19:45:33 -05:00
James Seibel 38a2edff06 fix batch gen environment exception name 2024-10-07 18:19:39 -05:00
s809 b2cf38798e Fix unhandled message spam in replay mod 2024-10-06 01:47:51 +05:00
s809 ed83e41f19 Use level key prefixes to in LAN multiplayer 2024-10-06 00:20:07 +05:00
s809 6d52cdba0a Prevent server crash on shutdown 2024-10-05 21:30:01 +05:00
s809 05449c9e86 Decouple beacon beam data handling from render handling, send beacon beams to clients 2024-10-05 14:03:08 +05:00
James Seibel 33ef1297ba Close !66 (add IDhApiLevelWrapper.getDhSaveFolder()) 2024-10-04 07:46:09 -05:00
James Seibel 3b13786990 Improve beacon fade rendering 2024-10-03 20:25:26 -05:00
James Seibel 222d06898e Fix zoom mods breaking DH's fade/near clip plane 2024-10-03 17:25:54 -05:00
James Seibel 4438adad24 Improve fade config, add localization, and add fading to the quality presets 2024-10-03 17:10:56 -05:00
James Seibel 986e474657 Add fading to Forge and Neo, fix fading rain, fix old MC compiling 2024-10-03 07:36:11 -05:00
James Seibel e8288a0df9 Fix fade rendering when DH rendering is disabled 2024-10-02 18:16:46 -05:00
James Seibel 74cab8f4ad replace random noise with Bayer for dithering 2024-10-02 18:08:57 -05:00
James Seibel 5e35572de8 Improve overdraw prevention quality 2024-10-02 07:49:46 -05:00
James Seibel 7e0e02bafc Add dithered DH fading, double pass fading, and fix LOD clouds 2024-10-01 22:02:45 -05:00
James Seibel a301532443 merge core changes 2024-09-30 22:00:06 -05:00
James Seibel 940448f219 Add experimental DH/vanilla fading 2024-09-30 21:59:25 -05:00
James Seibel 8510deb6aa Merge branch 'main' of gitlab.com:distant-horizons-team/distant-horizons 2024-09-28 15:28:08 -05:00
s809 0d0ba5d3bf Do not sync sections after generation, fix incorrect timestamp fetch pos range calculation 2024-09-29 01:18:04 +05:00
James Seibel 036371dd76 Remove multiverse similarity percent and add IDhApiSaveStructure
Similarity percent should no longer be needed since the server support was added
2024-09-28 14:30:38 -05:00
James Seibel 5aae584ffe Fix F3 menu showing the same level multiple times 2024-09-28 10:22:47 -05:00
James Seibel 201c619915 Add Api world load/unload events and DhApiWorldProxy.get/setReadOnly() 2024-09-28 08:33:30 -05:00
James Seibel 7cd6a3bb79 Add temporary vertical Quality CUSTOM option
This is temporary since it's just for determining what values we want long term and adding full control will over-complicate the config
2024-09-26 22:34:38 -05:00
James Seibel ca36d4797d Add hashCode() to FullDataPointIdMap 2024-09-26 07:42:31 -05:00
James Seibel b5fe3bcbf9 Up manifold version 2024.1.30 -> 2024.1.32 2024-09-25 21:58:08 -05:00
James Seibel e43f9e76f6 Change FullDataSourceDTO checksum/hash logic to hopefully be more consistent 2024-09-25 21:57:54 -05:00
James Seibel b8901c3edd Fix default generic rendering instanced mode 2024-09-25 18:44:47 -05:00
James Seibel d28938f8af fix readme logo filepaths 2024-09-22 17:25:19 -05:00
James Seibel 9f108220f5 Update readme logos 2024-09-22 17:23:41 -05:00
James Seibel ffe53a7196 Add new logos 2024-09-22 17:19:00 -05:00
James Seibel 9e12849107 Allow toggling generic obj instanced rendering via config 2024-09-22 16:32:51 -05:00
s809 0a8c093682 Fix missing testAnnotationProcessor 2024-09-23 01:18:39 +05:00
s809 60056e1654 Merge branch 'feature/lan-support' 2024-09-23 00:46:56 +05:00
s809 11a752a99d Fix dedicated server failing to send packets 2024-09-23 00:43:00 +05:00
s809 68097f61eb LAN multiplayer kinda works 2024-09-23 00:02:57 +05:00
James Seibel 8b514b07dc Move mod compat warnings into AbstractModInit and add WWOO to the list 2024-09-22 08:09:31 -05:00
s809 8e6010bbe5 Abstract away serverside parts of world & level 2024-09-22 03:29:07 +05:00
James Seibel 95eb07ca79 add commented out attempt at relocating Sqlite 2024-09-21 11:47:40 -05:00
James Seibel e6e03e78ea try upping manifold_version 2024.1.30 -> 2023.1.17 again
Please revert if compiler messages don't appear correctly
2024-09-21 11:47:16 -05:00
James Seibel d2c572414c up Sqlite version 3.43.0.0 -> 3.46.1.0 2024-09-21 11:46:42 -05:00
James Seibel d2e0d5b32b relocate org.slf4j to partially fix old XaeroPlus 2024-09-21 11:46:17 -05:00
James Seibel d4ba227a44 Fix config file handler corruption due to reading/writing concurrently 2024-09-20 07:29:41 -05:00
James Seibel caba007899 Add pshsh, to the author list 2024-09-20 07:08:37 -05:00
James Seibel d5cfe9b8e9 Revert Iris 1.8 requirement since it didn't work correctly 2024-09-19 19:59:52 -05:00
James Seibel f1707236fa Replace incompatible Iris<=1.7.4 with <1.8.0 to hopefully reduce confusion 2024-09-19 07:31:14 -05:00
James Seibel c55cbdb69a Mark Oculus 1.7 and lower as incompatible on forge 2024-09-19 07:30:10 -05:00
s809 00b69dcc68 Fix mixin crashes on 1.16.5 2024-09-18 01:06:06 +05:00
s809 cd74e33c54 Bump protocol version because of removed InvalidSectionPosException 2024-09-17 12:41:52 +05:00
s809 3f14e5dfa5 Fix naming of some things and comments 2024-09-17 09:48:15 +05:00
James Seibel 8c9e6ea79a Fix very high file handler jobs and pool some render data sources 2024-09-16 20:36:10 -05:00
James Seibel c71de31f57 Fix a few pre-processors blocked renamings 2024-09-16 19:37:34 -05:00
James Seibel ac869bf06e Up API version 3.0.1 -> 4.0.0 2024-09-15 21:16:24 -05:00
James Seibel 3175bc0439 Up version 2.2.2 -> 2.3.0 2024-09-15 21:16:13 -05:00
James Seibel 23ac6ec957 merge server side and minor refactoring 2024-09-15 21:15:40 -05:00
James Seibel f080a59b41 Add netty leak detection and server/client folder separation 2024-09-11 17:38:02 -05:00
James Seibel 603200ed8b only log git info on startup in dev builds 2024-09-11 17:19:33 -05:00
James Seibel b0774052a0 add default intellij gradle run scripts 2024-09-11 17:12:34 -05:00
James Seibel 7e163ce626 Add ILevelWrapper.getDimensionName() 2024-09-11 07:18:57 -05:00
James Seibel d19654cf15 Remove unneeded ChunkWrapper lighting checks 2024-09-10 07:35:02 -05:00
James Seibel 838d8be08b minor refactoring and style cleanup 2024-09-10 07:29:42 -05:00
James Seibel 2de82b1223 Add Netty to the build script 2024-09-10 06:55:40 -05:00
James Seibel 650012fb08 allow CI/CD to auto retry if there was a system failure 2024-09-10 06:53:06 -05:00
James Seibel a1ef3466ad Add test scripts folder 2024-09-10 06:52:21 -05:00
James Seibel 97421feb33 Add Oculus 1.7 to the list of incompatible fabric mods 2024-09-09 07:43:24 -05:00
James Seibel 0c90af6515 Fix low quality LODs not loading when flying in a new straight line 2024-09-09 07:41:20 -05:00
James Seibel 9cebd0298c add brown mushrooms to the list of ignored blocks to fix swamp issues 2024-09-07 14:22:45 -05:00
James Seibel 9afcddca4f Add faster sky light engine from Builderb0y
Closes !67
2024-09-07 12:07:59 -05:00
James Seibel 02fb7eedba Add missing LightingTestChunkWrapper methods 2024-09-06 21:55:55 -05:00
James Seibel 4aa9bec15c Fix unit test compiling 2024-09-06 19:36:41 -05:00
James Seibel a6eeaa5b3e Closes #805 (Hide "Distant Horizons overloaded")
Also update chunks closest to the player first
2024-09-06 18:23:04 -05:00
James Seibel c462325ce6 Add BuilderB0y's getBlockState optimization 2024-09-05 07:50:25 -05:00
James Seibel d208b0ab19 Up version number 2.2.1 -> 2.2.2-dev 2024-09-04 06:59:07 -05:00
James Seibel ab4ef429db Up version 2.2.1-dev -> 2.2.1 and API 3.0.0 -> 3.0.1 2024-09-04 06:58:28 -05:00
James Seibel 86473e022e Fix referencing unavailable GLFW methods for MC 1.18.2 and lower 2024-09-03 07:03:30 -05:00
James Seibel fd89f569d0 Fix MC 1.17.1 not compiling 2024-09-01 21:16:14 -05:00
James Seibel eefc765823 Fix LODs flashing while moving 2024-09-01 21:10:32 -05:00
James Seibel ebccb2516b Cull beacons based on X/Z distance instead of 3D distance 2024-09-01 17:28:13 -05:00
James Seibel 8c62a40da9 Disable instanced rendering on Mac when Sodium is present
Closes !793 (Generic Rendering crashes with Sodium on M1 Mac)
2024-09-01 17:02:49 -05:00
James Seibel d56af5c38f Fix some beacon rendering/updating issues 2024-09-01 16:36:41 -05:00
James Seibel 39b1ec61ba Fix glass panes not affecting beacon colors 2024-09-01 15:04:27 -05:00
James Seibel cb613cf7df add disableUnchangedChunkCheck config 2024-08-31 22:11:29 -05:00
James Seibel 28e33b4c36 Fix MC 1.16+ compiling 2024-08-31 22:11:14 -05:00
James Seibel 855e6b8180 Update pos getters and remove (hopefully) unneeded imports 2024-08-31 21:57:53 -05:00
James Seibel d62161f529 Fix cloud color not matching MC 2024-08-31 21:56:32 -05:00
James Seibel 71d48411f1 Add DhBlockPosMutable and make the original immutable 2024-08-30 07:36:04 -05:00
James Seibel 731842e09c Fix DH beacon detection logic breaking the lighting engine 2024-08-29 19:54:44 -05:00
James Seibel 61169f87c0 Fix LODs not updating underground 2024-08-29 07:33:21 -05:00
James Seibel 9fb3b196d2 Add a quick DH cloud UI config 2024-08-28 07:16:33 -05:00
James Seibel 867b875cf9 Fix Lithium breaking world gen for MC 1.20.1 and older 2024-08-27 19:19:09 -05:00
James Seibel 3875c8c4ce Up version number 2.2.0 -> 2.2.1-dev 2024-08-20 19:16:28 -05:00
James Seibel 89b959d3f5 Up version number 2.1.3-dev -> 2.2.0 2024-08-20 17:45:42 -05:00
James Seibel d62e50d6f4 Fix Legacy GL causing fog to smear 2024-08-20 17:45:31 -05:00
James Seibel 16836a2b49 Move MixinChunkMap shared code to common 2024-08-18 14:46:49 -05:00
James Seibel f5651f26a5 Merge !65 (fix neo/forge chunk update events) 2024-08-18 14:31:24 -05:00
James Seibel 82ff59c857 Fix fog and SSAO being broken by some mods 2024-08-17 22:29:42 -05:00
James Seibel 8af61041f0 Remove 1.21 from CI build script
1.21.1 also covers 1.21
2024-08-16 17:28:36 -05:00
James Seibel 2a9136b56f Merge 1.21.1 and 1.21 2024-08-15 07:21:19 -05:00
James Seibel 64da6c811d revert temporary 1.17.1 breakage 2024-08-13 17:24:18 -05:00
James Seibel e6b93e0d92 forgot to close test preprocessor 2024-08-13 07:46:49 -05:00
James Seibel f874219a64 Wrong 1.17.1 perpreocessor used 2024-08-13 07:33:39 -05:00
James Seibel b4822740f4 temporarily break 1.17 compiling to test gitlab bages 2024-08-13 07:33:04 -05:00
James Seibel af205a50b4 Deprecate IDhApiWorldGenerator.isBusy(), task queuing is now handled internally 2024-08-12 22:20:14 -05:00
James Seibel 2f6eaf79bd Add optional DhApiChunk validation for world gen 2024-08-12 21:47:58 -05:00
James Seibel 625f1e700f Fix MC 1.21 / 1.21.1 2024-08-12 21:05:15 -05:00
James Seibel 897d5b0b11 Change MC 1.21 -> 1.21.1 in CI version 2024-08-12 19:53:48 -05:00
James Seibel 95641e2f4e Allow adding empty lists to DhApiChunk 2024-08-11 22:01:29 -05:00
James Seibel cd856b86c7 Fix DhApiChunk setDataPoints failing for empty lists 2024-08-11 21:55:19 -05:00
James Seibel c00aa6d627 Add MC 1.21.1 2024-08-11 20:05:24 -05:00
James Seibel 398a3fb0bc Add alex's cave warning message 2024-08-11 09:55:12 -05:00
James Seibel e0fa638ad9 Fix beacons not enabling/disabling correctly 2024-08-09 07:26:20 -05:00
James Seibel 4e42cbd4ce Fix frustum culling when the screen is warped 2024-08-07 18:55:09 -05:00
James Seibel b6c6be77cd Fix beacons not being updated 2024-08-07 07:47:30 -05:00
James Seibel 0964293a72 Fix direct memory leak and remove config for GpuUpload 2024-08-07 07:30:01 -05:00
James Seibel c8b6141ce0 Improve LOD detail level detection and hole filling 2024-08-04 08:31:03 -05:00
James Seibel 948540369f Attempt to improve LOD building speed and reduce broken lighting on servers 2024-08-03 17:11:22 -05:00
James Seibel 363df0ad6f Fix MC 1.16/1.17 compiling 2024-08-03 11:38:02 -05:00
James Seibel a37e105434 Add (disabled) test API world generator 2024-08-03 09:52:06 -05:00
James Seibel aeea0c00c3 Allow DhApiChunk to accept top down or bottom up data point orders 2024-08-03 09:33:05 -05:00
James Seibel 137352674e Fix off by 1 error in Render data transformer 2024-08-02 18:30:59 -05:00
James Seibel 4734552954 Fix MC 1.16 compiling 2024-08-02 18:21:47 -05:00
James Seibel 879c2f1ec4 Fix out of bounds exception in Full Data Transformer 2024-08-02 17:56:33 -05:00
James Seibel 7dc9d2a352 Clean up faster world gen and fix even offset gen events 2024-08-02 08:25:32 -05:00
James Seibel cabc470ebd Temporary Test removing world gen boarder chunks 2024-08-01 07:44:46 -05:00
James Seibel 0bf1f493aa Change some world gen info logs to debug 2024-08-01 07:06:47 -05:00
James Seibel 705bd14ee4 Fix cave culling affecting floating islands and add LOD reload to some configs 2024-07-31 19:06:47 -05:00
James Seibel 155955e49b Mark Iris 1.7.4 and lower as incompatible (as recommended by IMS) 2024-07-30 17:13:54 -05:00
James Seibel c76a793b18 Remove deprecated methods and move method to StringUtil 2024-07-30 17:07:16 -05:00
James Seibel 50cc8501a0 Remove unused sodium and McRenderWrapper methods
Removed methods were originally used to cull LODs if MC had loaded chunks, however this turned out to be more trouble than it was worth and caused more problems than it solved.
2024-07-30 17:01:09 -05:00
James Seibel 209279e3e4 Merge branch 'distant-horizons-m2' 2024-07-30 16:06:39 -05:00
James Seibel 41239572a5 Fix presets only using "custom" after any value was changed 2024-07-30 15:47:52 -05:00
James Seibel 106ab47c3d Fix default logging debug to file 2024-07-29 20:40:54 -05:00
James Seibel a84f9b60e5 Fix rapidly changing dimensions causing the game to crash 2024-07-29 07:29:56 -05:00
James Seibel 4481e8634a Fix incorrect DhApiChunk create constructor parameter order (again) 2024-07-28 20:18:31 -05:00
James Seibel 3e432682fb fix incorrect positions being fed into biome color code 2024-07-28 09:34:15 -05:00
James Seibel 05569c03a4 Revert and Deprecate DhApiChunk and DhApiTerrainDataPoint constructors 2024-07-28 08:56:26 -05:00
James Seibel 2d567b84be Fix holes in LODs boarding different detail levels 2024-07-27 21:06:55 -05:00
James Seibel e2a378250f Fix LOD upload warning 2024-07-27 20:25:58 -05:00
James Seibel e2083a1836 Fix LODs flashing twice when changing configs 2024-07-27 20:11:49 -05:00
James Seibel 334946ab59 Potentially fix thread warnings in ClientBlockStateColorCache 2024-07-27 19:15:00 -05:00
James Seibel 8c9bb98125 Update IDhApiRenderProxy.clearRenderDataCache() to also clear cached block colors 2024-07-27 17:36:57 -05:00
James Seibel 726f0f3d3c Remove unused ServerBlockStateCache 2024-07-27 16:51:14 -05:00
James Seibel 50e5898692 Rename ClientBlockStateCache -> ClientBlockStateColorCache
And do some additional cleanup
2024-07-27 16:44:47 -05:00
James Seibel de05a5f674 Refactor and cleanup ClientBlockStateCache 2024-07-27 16:25:27 -05:00
James Seibel 31b57fae50 fix 1.16.5 compiling 2024-07-27 16:24:31 -05:00
James Seibel 2f686057f3 Fix ice/water vertical LOD lighting 2024-07-27 09:30:51 -05:00
James Seibel 132251341f Fix replay mod not showing LODs 2024-07-21 20:06:40 -05:00
James Seibel 2bac5f933a remove unused clientLevelWrapper.getGameDirectory() 2024-07-21 19:29:01 -05:00
James Seibel 2e565aa83a Improve cave culling and add config for ignored/cave blocks 2024-07-21 17:27:26 -05:00
James Seibel 4e9d0f4861 Fix ConfigEntry String value saving 2024-07-21 16:13:55 -05:00
James Seibel 7216b193e8 Fix API chunk world gen 2024-07-20 17:58:39 -05:00
James Seibel c33a5bf814 Add IDhApiWrapperFactory resourceLocation string methods for block/biomes 2024-07-20 11:21:01 -05:00
James Seibel 97756a5196 Add AbstractDhApiChunkWorldGenerator.generateApiChunk() 2024-07-20 10:45:55 -05:00
James Seibel 377f7d23e3 Remove render param from DhApiAfterRenderEvent 2024-07-14 09:31:03 -05:00
James Seibel 7005202384 Add a optional memory cache to the IDhApiTerrainDataRepo 2024-07-14 08:41:22 -05:00
James Seibel 99e8f57bac add missing genericRendering to IDhApiGraphicsConfig 2024-07-14 07:25:49 -05:00
James Seibel afddf4168e Change some chunk deserialization errors to warnings 2024-07-13 12:59:43 -05:00
James Seibel fbffdc0c9f Fix fog for Mac and remove near fog limitation 2024-07-13 12:17:30 -05:00
James Seibel e6d3647490 Increase default fog start distance 2024-07-13 08:14:33 -05:00
James Seibel 13363ff363 make clouds smaller and thinner 2024-07-12 21:47:16 -05:00
James Seibel 7f98e4b1eb Fix potential chunkWrapper null pointer 2024-07-12 21:31:12 -05:00
James Seibel 408460b0ae Fix missing imports for MC 1.19 and below 2024-07-12 20:31:36 -05:00
James Seibel b69ef5835d Fix repo connections not getting closed 2024-07-12 20:22:02 -05:00
James Seibel 0428fa0912 Clone API event parameters to reduce listener contamination 2024-07-12 19:22:25 -05:00
James Seibel 9f3124fa56 Add renderEventParam to generic rendering shader binding by IMS request 2024-07-12 17:27:32 -05:00
James Seibel fbbdab73c6 Attempt to fix lag spikes when right clicking blocks 2024-07-12 17:24:45 -05:00
James Seibel ee9441c521 Fix world gen not skipping already complete stages 2024-07-12 07:41:18 -05:00
James Seibel a9e0fd5d9b Add generic object setup/cleanup events 2024-07-12 07:16:06 -05:00
James Seibel 98464889ca Fix material typo 2 2024-07-11 22:51:47 -05:00
James Seibel eed5fd60c6 Fix material typo 2024-07-11 22:07:15 -05:00
James Seibel ac43cd5496 Add generic object materials 2024-07-11 18:13:07 -05:00
James Seibel 1f16a7c808 Fix generic rendering and add EDhApiBlockMaterial 2024-07-11 17:58:05 -05:00
James Seibel 39e4c70754 Add api for generic rendering config 2024-07-11 17:39:01 -05:00
James Seibel 82eb27af4c Add DhApiBeforeGenericObjectRenderEvent 2024-07-11 17:32:26 -05:00
IMS212 3aaab94b39 Support both Sodium 0.5 and 0.6 with reflection 2024-07-10 21:02:53 -07:00
James Seibel 07a0779ca4 Fix potential light map crashing and memory leak 2024-07-10 18:57:09 -05:00
James Seibel 2adba02a38 Add "IP Only" to multiplayer tooltip 2024-07-10 07:45:12 -05:00
James Seibel 9dd76db3fc Fix generic rendering at extreme distances 2024-07-10 07:37:18 -05:00
James Seibel 97dacf2429 Add toggleable logging for GL Buffer garbage collection
Will need to be tested by someone who is experiencing issue #718, so far I've been unable to reproduce anything meaningful.
2024-07-09 17:40:27 -05:00
James Seibel 1c189e162a fix sub MC 1.20.1 compiling 2024-07-09 16:39:29 -05:00
James Seibel f7a0fff869 Move IBlockStateWrapper constants into LodUtil 2024-07-09 16:39:04 -05:00
James Seibel 2f985d0926 Add beacon colors 2024-07-09 07:33:30 -05:00
James Seibel 2a3c544fba Increase cloud rendering performance 2024-07-08 19:56:29 -05:00
James Seibel 09d133b994 Add generic rendering localization 2024-07-08 07:45:03 -05:00
James Seibel 26a4223ecf Fix double unloading beacons 2024-07-07 19:54:25 -05:00
James Seibel e2943fdcaf Fix beacons un-rendering when unloading LODs 2024-07-07 19:45:47 -05:00
James Seibel f1053251b4 Add missing generic rendering config options 2024-07-07 18:13:58 -05:00
James Seibel be1dcaf43c Add cloud rendering 2024-07-07 18:03:11 -05:00
James Seibel a899d988fc Fix concurrent modification for GenericObjectRenderer 2024-07-04 21:43:15 -05:00
James Seibel 06b5b2c514 Fix potential null pointer in auto updater 2024-07-04 17:37:30 -05:00
James Seibel 864a19b79f Remove useless IServerLevelWrapper.tryGetClientLevelWrapper() 2024-07-04 16:31:04 -05:00
James Seibel 8974323406 Fix Api client level not containing the generic renderer 2024-07-04 16:15:51 -05:00
James Seibel 46c9e0103a Improve world gen timeout warning message 2024-07-04 16:01:33 -05:00
James Seibel 02203466ed Move generic rendering to the level API 2024-07-03 22:38:14 -05:00
James Seibel 87b22ea1cc Add a config to use pre-existing lighting 2024-07-03 20:30:56 -05:00
James Seibel d26327a930 fix max chunk Y position for empty chunks 2024-07-03 19:14:47 -05:00
James Seibel 469d2bdcb7 Add improved beacon logic 2024-07-02 17:51:26 -05:00
James Seibel 5516603a0c Add temporary proof-of-concept beacon rendering 2024-06-30 18:08:55 -05:00
James Seibel b737adc3da Up API version 2.1.0 -> 3.0.0 2024-06-30 16:36:49 -05:00
James Seibel f3a8afeee3 Up version 2.1.2 -> 2.1.3-dev 2024-06-25 19:25:35 -05:00
James Seibel a4501f86e9 Update coreSubProjects 2024-06-25 19:24:13 -05:00
James Seibel 095fff96ff Up version 2.1.1-dev -> 2.1.2 2024-06-24 20:53:45 -05:00
James Seibel a23211d061 Fix NeoForge not running 2024-06-24 20:52:14 -05:00
James Seibel b57ea41686 neoforge build script cleanup 2024-06-23 08:52:55 -05:00
James Seibel 62fb5ffb73 Add DB file lock checking 2024-06-23 08:36:48 -05:00
James Seibel 99c713967b Temporary spongepowered.vanillagradle fix/workaround 2024-06-22 16:21:19 -05:00
James Seibel 9f3de07bd8 Increase default world gen timeout to 3 minutes (from 60 sec) 2024-06-18 07:12:01 -05:00
James Seibel cd74117de3 Fix file handler tooltip 2024-06-17 07:42:35 -05:00
James Seibel e7d7033548 Improve F3 menu logic and visuals 2024-06-15 19:20:25 -05:00
James Seibel 34db7c9dac Lower the default CPU presets 2024-06-15 11:26:05 -05:00
James Seibel 272841aae9 Add a startup low memory warning 2024-06-15 11:05:10 -05:00
James Seibel 389b09a5cd Prevent creating LODs for already processed chunks 2024-06-15 09:42:49 -05:00
James Seibel 84bd876c71 Refactor ChunkWrapper 2024-06-15 08:11:26 -05:00
James Seibel 7e45051ffd Fix more MC version compiles 2024-06-14 22:21:52 -05:00
James Seibel 5570f3a313 Fix some compiling issues 2024-06-14 19:31:21 -05:00
James Seibel f4e71f7012 Add NeoForge 1.21 2024-06-14 19:05:45 -05:00
James Seibel 601d4e6e3a Fix CI not picking up 1.21 2024-06-14 07:40:29 -05:00
James Seibel a12092c1a1 Add fabric 1.21 support 2024-06-14 07:36:25 -05:00
James Seibel 94ad118c5d Minor memory optimization thanks to littlewolf 2024-06-13 07:30:42 -05:00
James Seibel 48e2978438 Fixes #713 (Forge/Neo level unload events not being called) 2024-06-13 07:15:11 -05:00
James Seibel 96b4c1a9e8 Use existing lighting for pre-generated chunks 2024-06-11 20:22:13 -05:00
James Seibel cc4a69c10c Move shared ChunkWrapper code form Main to Core 2024-06-11 18:35:02 -05:00
James Seibel 7293677ddb Batch Generation Environment refactoring 2024-06-10 21:32:14 -05:00
James Seibel 0f2ff20375 Re-arange ChunkLoader 2024-06-10 21:17:57 -05:00
James Seibel 7706240acb Remove OpenGL multithreading 2024-06-08 12:49:17 -05:00
James Seibel 4cf48fd997 Try changing LZMA preset from 4 -> 3 (faster, less compressed)
won't require any lod regeneration since the decompressor is the same
2024-06-08 11:06:42 -05:00
James Seibel 2708c1ee11 Improve config comment spacing 2024-06-08 08:33:41 -05:00
James Seibel ebb0f6ebad Up the manifold version 2023.1.17 -> 2024.1.15 2024-06-08 08:12:03 -05:00
James Seibel 2c263a2549 Up the API version 2.0.0 -> 2.1.0 2024-06-08 08:11:48 -05:00
James Seibel 955524c632 Remove blendium from the list of suggested fabric mods 2024-06-08 08:11:34 -05:00
James Seibel 564e0d3263 Add update branch config "auto" 2024-06-08 08:11:26 -05:00
James Seibel c533b2e8ea Fix config screen blur on 1.20.6 2024-06-08 07:19:50 -05:00
James Seibel 6073d8122a Up the version number 2.1.0-a -> 2.1.1-a-dev 2024-06-07 17:42:46 -05:00
James Seibel 71ca26bba9 Up the version number 2.0.4-a-dev -> 2.1.0-a 2024-05-30 20:14:04 -05:00
James Seibel 75a51be28c remove unused lightmapBindingIndex in DhApiRenderParam 2024-05-27 17:57:58 -05:00
James Seibel a66e4ba157 Potentially fix memory leaks when rendering is disabled 2024-05-27 17:38:00 -05:00
James Seibel f2b9e428d3 Re-add a missing import to fix compiling 2024-05-21 18:24:30 -05:00
James Seibel 5b2497b9d4 Minor MixinMinecraft reformatting 2024-05-21 17:16:36 -05:00
Yeshi0 e78424def4 typo 2024-05-21 20:58:44 +02:00
Yeshi0 e2c94de6e6 fix blurry text on auto update screen 2024-05-21 20:57:12 +02:00
Yeshi0 daa3caf684 Merge branch 'main' of https://gitlab.com/jeseibel/distant-horizons 2024-05-21 15:12:52 +02:00
James Seibel 5991aa42d9 Revert "Add JVM Downgrader (DH now uses Java version Ω)"
This reverts commit af6dca6e5e.
2024-05-21 07:45:33 -05:00
James Seibel ff6a5aae69 Revert "Set the core to use Java version Ω"
This reverts commit c4a9e7a2a7.
2024-05-21 07:45:25 -05:00
James Seibel 80d9b4540b Fix LZ4 in retail MC 2024-05-21 07:43:45 -05:00
James Seibel 4998991ebe Fix option button in 1.20.6 being on the wrong side 2024-05-21 07:12:04 -05:00
James Seibel 14343569fe Fix neoforge config button position 2024-05-21 06:56:27 -05:00
James Seibel be6cc5ff4e Fix some old MC version compiling 2024-05-20 22:19:04 -05:00
James Seibel 0ad3391bea Put config button hide option only in file 2024-05-20 22:15:45 -05:00
James Seibel 582d998e2e Fix GuiHelper rename for MC 1.19.4 and below 2024-05-20 22:12:09 -05:00
James Seibel c00ee26075 Properly shade libraries when using Java version Ω 2024-05-20 22:10:48 -05:00
James Seibel 4c9f70a52f Merge branch 'main' of gitlab.com:jeseibel/distant-horizons 2024-05-20 22:06:59 -05:00
James Seibel 29481bc123 Fix 1.20.6 config page and config button 2024-05-20 22:06:25 -05:00
Cutiepie e274c9e004 Properly shade libraries when using Java version Ω 2024-05-21 11:53:00 +10:00
Yeshi 73988f0308 Merge branch distant-horizons:main into main 2024-05-20 20:06:23 +00:00
Cutiepie c4a9e7a2a7 Set the core to use Java version Ω 2024-05-21 01:56:33 +10:00
Cutiepie af6dca6e5e Add JVM Downgrader (DH now uses Java version Ω) 2024-05-21 01:26:03 +10:00
Yeshi0 a49720a221 fix gradle.properties typos (it was bothering me) 2024-05-20 17:04:10 +02:00
Yeshi0 12a66e70c9 remove unnecessary references to zstd 2024-05-20 17:01:45 +02:00
James Seibel 00d8aa356b minor ClassicConfigGUI reformat 2024-05-20 07:52:46 -05:00
James Seibel d40d94a565 Add probably broken AT OptionsScreen code
Will probably break 1.20.2 and 1.20.4
2024-05-20 07:52:38 -05:00
James Seibel c1f798793e roll back manifold version to fix mystery compiler issues 2024.1.15 -> 2023.1.17 2024-05-19 21:25:26 -05:00
James Seibel 8fe4ad454c update CI JDK 17 -> 21 2024-05-19 20:31:51 -05:00
James Seibel 17022f2df2 Document GuiHelper args 2024-05-19 14:26:27 -05:00
James Seibel 7fa4bc35f6 remove forge from 1.20.6 to fix CI/CD 2024-05-19 14:16:40 -05:00
James Seibel 85df9c5ef4 Add 1.20.6 to the CI build script 2024-05-18 20:32:33 -05:00
James Seibel 45d4f390a9 Fix a bunch of compiler errors 2024-05-18 20:31:15 -05:00
James Seibel e7b60b7562 Fix neoforge 1.20.6 compiling 2024-05-18 11:14:13 -05:00
James Seibel 2615177907 Fix fabric 1.20.6 compiling 2024-05-18 08:07:48 -05:00
James Seibel a83d7e2a26 Replace DhSectionPos with long's for GC performance
What could possibly go wrong?
2024-05-16 22:15:43 -05:00
James Seibel 8a2182e238 Merge branch 'main' of gitlab.com:jeseibel/distant-horizons 2024-05-15 20:40:11 -05:00
James Seibel d45455092c Replace QuadTree iterator linked list with ArrayDeque
Thanks JustALittleWolf!
2024-05-15 07:36:42 -04:00
James Seibel da18469fd4 Fix resource locations in biome/block wrappers 2024-05-15 07:24:08 -04:00
James Seibel 6b5bae9bee Cache block and biome wrapper deserialization values 2024-05-13 20:26:47 -04:00
James Seibel e29a7786e4 Potentially fix LODs not loading in 2024-05-11 16:23:50 -05:00
James Seibel 55a837ca5e Attempt to prevent thread starvation due to world gen 2024-05-10 22:27:29 -05:00
James Seibel 94cba6cf67 Fix compiling 2024-05-10 17:25:52 -05:00
James Seibel 294685df00 Remove indium recommended dependency
A lot of people were reading fabric's warning as a required dependency
2024-05-10 07:05:40 -05:00
James Seibel 2642b7a9a4 disable sql timeout 2024-05-09 23:22:50 -05:00
James Seibel 45594e4e47 Handle missing/corrupted block/biome ID's in the full data 2024-05-09 19:46:33 -05:00
James Seibel 54cd1a2e48 Fix monoliths due to duplicate IDs 2024-05-09 19:45:50 -05:00
James Seibel a20fb982ec Potential fix for NaN multiverse similarity 2024-05-09 07:35:00 -05:00
James Seibel 184d61e637 Up the API version 1.1.0 -> 2.0.0
There were several breaking changes and I forgot to up the major version number appropriately.
2024-05-04 18:17:10 -05:00
James Seibel 06ea56767f Up manifold version 2024.1.12 -> 2024.1.13 2024-05-04 15:37:20 -05:00
James Seibel 1f6e137759 Fix F3 levels not closing with multiverse 2024-05-04 15:36:51 -05:00
James Seibel c7cf7885ae Fix #670 Remove outdated world gen options from tooltip 2024-05-04 09:48:40 -05:00
James Seibel 8e98444887 Update coreSubProjects 2024-05-04 09:23:02 -05:00
James Seibel 9bfe2e8233 Up 1.20 fabric loader versions 0.14.24/0.15.1 -> 0.15.6 2024-05-04 09:22:44 -05:00
James Seibel 21f4adc769 Minor 1.20.6 preprocessor updates 2024-05-02 17:28:30 -05:00
James Seibel 3b10ca5809 Update arch loom 1.5-snapshot -> 1.6-snapshot 2024-05-02 17:27:04 -05:00
James Seibel 6cc8284747 Start adding 1.20.6 2024-05-01 07:45:23 -05:00
James Seibel 6254f7156f Improve nightly build and migration messages 2024-04-30 21:59:17 -05:00
James Seibel 0fa03701a4 Fix debug wireframes rendering on top of LODs 2024-04-30 21:24:08 -05:00
James Seibel 49125cae47 Remove ZStd compression option
Any ZStd data will be automatically deleted and re-generated
2024-04-30 21:17:54 -05:00
James Seibel 3298857d0c Remove references to FastUtil 8.5.13 2024-04-30 20:30:51 -05:00
James Seibel d939cbeb96 remove unused MixinWorldupgrader files 2024-04-30 19:44:44 -05:00
James Seibel 54d254be73 Fix optifine 1.16 support 2024-04-30 19:44:23 -05:00
James Seibel d433fdea62 Fix white grass/water if the biome is null 2024-04-28 17:35:10 -05:00
James Seibel ffa1c54ff3 Fix warning about BiomeWrapper null level on startup 2024-04-28 16:08:08 -05:00
James Seibel 019ac6dec3 Add corrupt data read handling 2024-04-28 15:52:11 -05:00
James Seibel 08d3da47f4 Fix fastutil relocation issues with world gen 2024-04-27 16:46:22 -05:00
James Seibel 348ac2b734 Closes #638 (optifine not rendering on 1.16 + 1.17) 2024-04-27 13:20:18 -05:00
James Seibel fe014b4985 revert b1c6a5c1 2024-04-27 12:56:20 -05:00
James Seibel b7f6f3b900 Remove (hopefully) unused MixinThreadingDetector 2024-04-27 11:55:27 -05:00
James Seibel 3c76ed71d8 Fix some lib shading issues 2024-04-27 11:35:16 -05:00
James Seibel 5de1998913 up the version number 2.0.3 -> 2.0.4 2024-04-26 07:33:48 -05:00
James Seibel 05c0f030cb Fix issues with compressors not appearing at runtime 2024-04-26 07:33:26 -05:00
James Seibel bd85329589 Merge Data_source_rewrite into main 2024-04-26 07:22:03 -05:00
James Seibel da0f4ae326 shade in apache.logging for the standalone jar 2024-04-25 22:09:56 -05:00
James Seibel b37e568372 Change Initializer compressor test class 2024-04-25 21:52:56 -05:00
James Seibel b1c6a5c1d4 Move most libraries from the main script to core 2024-04-25 21:52:04 -05:00
James Seibel 8222126e8f minor MixinMinecraft reformat 2024-04-25 21:34:39 -05:00
James Seibel b5b888c69f Remove duplicate remapJar in fabric gradle 2024-04-25 21:10:05 -05:00
James Seibel 85f6b8320b Fix Fabric compiling 2024-04-25 21:09:42 -05:00
James Seibel 6c4740e8aa Remove Unimined and restore Architectury build system 2024-04-24 22:05:59 -05:00
Cutiepie ffda83c25d Add core to gradle 2024-04-22 18:53:32 +10:00
James Seibel 18859d22a8 Fix getChunk null assertion 2024-04-20 15:36:42 -05:00
James Seibel befa3b375e Fix compiling 2024-04-20 12:36:33 -05:00
James Seibel a96c08cad4 Clean up DhLitWorldGenRegion 2024-04-20 12:16:33 -05:00
James Seibel d7f789c402 Fix fastutil shading
fastutil is already in MC and used by some world gen so shading it causes issues.
2024-04-20 11:23:47 -05:00
James Seibel ed28bcd0ba fix forge issues with already deleted lib folders 2024-04-18 21:07:09 -05:00
James Seibel 982ae0c0a0 speed up initial LOD loading 2024-04-18 21:06:32 -05:00
James Seibel d17897f276 Fix transparent blocks glowing (thanks IMS) 2024-04-18 07:47:47 -05:00
James Seibel c0ccef7e82 Fix common complaining about missing "prepareWorkspace" task 2024-04-16 07:32:21 -05:00
James Seibel 55e5c64c68 update manifold 2024.1.0 -> 2024.1.9 2024-04-14 21:17:15 -05:00
James Seibel da72f783ed minor forge modinfo fix 2024-04-14 21:17:02 -05:00
James Seibel 8a9bfa3d33 fix unnecessary issues with javax and jetbrain compile time annotations 2024-04-14 21:16:50 -05:00
James Seibel 82937d840a Merge branch 'removeArch' into Data_Source_Rewrite 2024-04-14 16:41:28 -05:00
James Seibel c1bd358502 fix fastutil not being relocated 2024-04-13 21:24:58 -05:00
James Seibel a8a22fd9fe Fix Iris incompatibility check for 1.20.4 and add for 1.20.2 and lower 2024-04-13 21:15:37 -05:00
James Seibel adb70857fe Fix migration messages 2024-04-13 17:53:32 -05:00
James Seibel a680596b3e log migration status in F3 menu and chat 2024-04-13 14:25:34 -05:00
James Seibel b2986ec782 Fix fabric unnecessarily unloading levels when respawning 2024-04-13 13:35:22 -05:00
James Seibel f40f7afab3 speed up initial loading when DB migration is necessary 2024-04-13 12:14:59 -05:00
James Seibel 59555d1ca8 Update coreSubProjects 2024-04-13 11:19:11 -05:00
cola98765 6e2eb7d1ac I may be dumb 2024-04-10 13:42:15 +00:00
cola98765 69483067b4 Made leaves color like if they are in fancy setting. Still no config, but with all other changes to colors this might fit better. 2024-04-10 13:40:32 +00:00
James Seibel c815591565 Fix Z-fighting at very high heights 2024-04-10 07:11:30 -05:00
James Seibel f82b7ec608 Improve file handler speed 2024-04-09 07:48:39 -05:00
James Seibel 23a107682c Mark Iris 1.7.0 and older as incompatible 2024-04-08 07:23:49 -05:00
James Seibel 26da69c875 Remove deprecated DhApiScreenResizeEvent 2024-04-08 07:17:30 -05:00
James Seibel 8f2df2396d Improve grass side rendering and add a config 2024-04-07 21:42:39 -05:00
James Seibel dbc9cbb418 Have grass fade to dirt for walls 2024-04-06 12:37:44 -05:00
James Seibel 09c788e495 Fix removed Screen imports 2024-04-06 10:28:50 -05:00
James Seibel 9af71ac0ea Fix API enums missing "DhApi" prefix and remove unused Enums/code 2024-04-06 10:06:09 -05:00
James Seibel 2db20f8f24 Add Sqlite Write Ahead Log to Sqlite 2024-04-06 09:53:34 -05:00
James Seibel 2c9827c227 Merge branch 'distant-horizons-main' into Data_Source_Rewrite 2024-04-06 08:54:19 -05:00
James Seibel 825b1ab4db Re-add a couple readme breakpoints and remove a unneeded note 2024-04-06 08:51:06 -05:00
James Seibel c61faac06c Merge branch 'distant-horizons-main' into Data_Source_Rewrite 2024-04-06 08:46:59 -05:00
James Seibel 6b442f03c1 Update ELodShading names and descriptions 2024-04-06 08:46:47 -05:00
James Seibel 10ab638643 Change Sqlite Journaling to WAL to potentially improve concurrent performance 2024-04-04 07:50:21 -05:00
James Seibel d349d0c453 Make rendering speed worse but improve LOD loading speed 2024-04-04 07:09:56 -05:00
James Seibel e5c948ce9c Improve initial LOD loading speed 2024-04-03 22:07:29 -05:00
James Seibel c51255f379 Add fastutil to gradle (specifically to fix MC 1.16) 2024-04-03 07:43:12 -05:00
James Seibel 5bbeceee56 Add data source pooling 2024-04-01 20:28:38 -05:00
cola98765 ee78920a88 Merge branch 'fix_glass_transparency' into 'Data_Source_Rewrite'
Rework to "calculateColorFromTexture"

See merge request jeseibel/distant-horizons!55
2024-03-29 14:54:06 +00:00
cola98765 138972cf18 Rework to "calculateColorFromTexture" 2024-03-29 14:54:06 +00:00
James Seibel 1bda767cd7 Add Cola's RenderDataTransformer fixes 2024-03-28 17:14:56 -05:00
James Seibel cf1402edb9 Remove the DhRenderData DB table 2024-03-28 07:47:17 -05:00
James Seibel 778144a553 Add WorldCompressionMode config, default to VISUALLY_EQUAL 2024-03-28 07:43:32 -05:00
James Seibel fcca51a8d9 Fix missing indium messy crash error when java.awt is headless 2024-03-24 11:53:46 -05:00
James Seibel 3cc663ee95 remove render data file handling 2024-03-23 18:09:10 -05:00
James Seibel 52f15a86fd add todo about error in ClientBlockStateCache 2024-03-23 17:56:29 -05:00
James Seibel 734bb4afb8 minor biome/block wrapper changes 2024-03-23 16:23:40 -05:00
James Seibel 9cd48fb5d7 Comment out trace logs
These logs aren't printed and will just increase GC pressure for strings
2024-03-23 16:18:40 -05:00
James Seibel cd5c3d9f13 Compress the column gen step in the database 2024-03-20 07:25:42 -05:00
James Seibel 73ba1c8b56 Fix transactionScript auto update variable flipped 2024-03-19 21:10:31 -05:00
James Seibel 8199b4408a Reduce string concatenations in assertions 2024-03-19 20:53:15 -05:00
James Seibel c00e3d7393 Change the SQLite journal mode DELETE -> TRUNCATE 2024-03-19 20:07:35 -05:00
James Seibel 5d60251da0 Cache the blockState and biome wrapper hashCodes 2024-03-19 17:36:22 -05:00
Yeshi 855d707b3e readme improvements 2024-03-19 18:55:05 +01:00
James Seibel 592a1c3601 up the version number 2.0.2 -> 2.0.3 2024-03-19 06:48:31 -05:00
James Seibel da280db0f8 Fix lighting in superflat worlds 2024-03-18 21:28:27 -05:00
James Seibel 0ee6673e68 update todo comments 2024-03-17 16:15:27 -05:00
James Seibel 8bedb3dbaa Remove Seamless Overdraw Test
The result wasn't very good due to rendering issues with entities
2024-03-16 21:03:27 -05:00
James Seibel ea0e24b430 Add multiple compression options and unit tests 2024-03-16 17:25:29 -05:00
Tatounee cd35461df6 Fix cd command in compiling instructions 2024-03-10 02:38:31 +01:00
James Seibel 40580e81c2 Fix ChunkWrapper returning block light 15 for out of bound positions
Now it will return 0, which is more accurate
2024-03-03 14:54:11 -06:00
James Seibel 1a279b90be rename ThreadPools -> ThreadPoolUtil 2024-03-03 14:53:40 -06:00
James Seibel e34203fe3d Fix potential null pointer in BiomeWrapper 2024-03-02 11:45:14 -06:00
James Seibel 870c0f68d3 temporary multiverse null pointer fix 2024-02-22 07:05:21 -06:00
coolGi 004059dd9f Removed mixins from neoforge's mods.toml 2024-02-22 22:10:34 +10:30
coolGi 4290cdf8c6 Changed run dir to the root of the project 2024-02-20 00:51:41 +10:30
coolGi 4d038fc5e6 Fixed up AT 2024-02-20 00:51:25 +10:30
coolGi 0146d62c2a Moved AT to only appear in final build, not in the source code 2024-02-19 23:44:53 +10:30
coolGi 4e6255dc2b Re-added jank file deleting again for now 2024-02-18 21:38:20 +10:30
coolGi 4d73c3ecb8 Moved common to Unimined 2024-02-18 21:09:00 +10:30
coolGi d0dc3ec9bc Added the new unimined flag to fix fabric's access wideners 2024-02-18 20:11:15 +10:30
coolGi ee922236a0 Fixed forge version in readme for this branch 2024-02-18 19:13:20 +10:30
coolGi bf088ab29c Merge branch 'main' into removeArch 2024-02-18 19:11:47 +10:30
coolGi 40102521a1 Updated readme with new mc version 2024-02-18 19:09:54 +10:30
coolGi eb491144f3 Refactored logos into assets/distanthorizons 2024-02-18 19:04:29 +10:30
coolGi a14748ac75 Fixed most of the remaining issues 2024-02-18 18:42:44 +10:30
coolGi 0c5f38a00b Removed un-needed stuff 2024-02-18 16:07:51 +10:30
James Seibel feb6dd41b7 Merge branch 'removeArch' of gitlab.com:jeseibel/distant-horizons into removeArch 2024-02-17 22:37:10 -06:00
James Seibel a093524939 Fix Forge 1.20.4 gradle run 2024-02-17 22:34:18 -06:00
James Seibel 5cc7bebbe5 Update forge 1.20.4 49.0.16 -> 49.0.30 2024-02-17 22:34:06 -06:00
coolGi 32a256619f Fixed using wrong implementation for joml 2024-02-18 14:00:34 +10:30
coolGi f93e648f69 Added a small error if the user forgot to clone the sub-project, and some extra comments 2024-02-18 13:43:11 +10:30
coolGi 41f022df99 Merge branch 'main' into removeArch
# Conflicts:
#	build.gradle
2024-02-18 12:01:02 +10:30
coolGi c84aac7e45 Fixed resources in forge 2024-02-18 11:59:02 +10:30
James Seibel 4e4fbbe48c Merge branch 'main' into removeArch 2024-02-17 09:25:34 -06:00
James Seibel 7265e2b631 add chunk read timeout config and remove duplicate RegionFileStorageExternalCache 2024-02-16 20:04:46 -06:00
James Seibel 0a11f310cf Revert Fog near end/far start distance to pre-RenderUtil fix 2024-02-15 21:54:33 -06:00
James Seibel a6143780fa Fix C2ME file loading 2024-02-15 21:45:11 -06:00
James Seibel 761f802ced Fix fog rendering 2024-02-15 20:36:41 -06:00
James Seibel 2e7cc9f4b6 Temp fix for near clip plane going too far in some cases 2024-02-13 07:53:08 -06:00
James Seibel 4e6e727799 Fix ocean floors showing at very low detail levels
Partially fixes #632
2024-02-11 21:32:08 -06:00
James Seibel 2da444d03c Fix BiomeWrapper warning about null level on startup 2024-02-11 20:24:36 -06:00
James Seibel f4f234a159 Fix NeverCullFrustum casting error 2024-02-11 18:29:51 -06:00
James Seibel e87823aa29 Close #615 (lag when rapidly breaking/placing blocks) 2024-02-11 16:39:29 -06:00
James Seibel 56167a137e Default to no culling for the shadow pass 2024-02-11 14:56:16 -06:00
James Seibel 91ac4309df Fix the API seeing the wrong far clip plane 2024-02-10 22:02:19 -06:00
James Seibel 8a5bca3136 Fix using the wrong near clip plane 2024-02-10 21:58:24 -06:00
James Seibel ec8d1b5538 Fix Lava Iris block material ID 2024-02-10 21:38:55 -06:00
James Seibel 0ebe8db268 Add IDhApiShadowCullingFrustum and a config for shadow culling 2024-02-10 21:38:44 -06:00
coolGi 3bba08723f joml is included in vanilla 1.19.4 2024-02-08 10:28:33 +00:00
coolGi 6a6a87a3f7 Fixed joml being embedded on versions where mc already embeds it 2024-02-08 17:47:13 +10:30
James Seibel 0ccdcfbb6d Fix 1.20.4 compling 2024-02-07 18:19:41 -06:00
James Seibel aa084c885d Attempt to reduce queuing duplicate world gen tasks 2024-02-07 07:34:49 -06:00
coolGi e3a8a7782e Merge branch 'main' into removeArch
# Conflicts:
#	build.gradle
#	common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/BlockStateWrapper.java
#	forge/src/main/java/com/seibel/distanthorizons/forge/ForgeMain.java
2024-02-07 23:44:24 +10:30
James Seibel c578ae0fa4 Add Lod Shading to the api config 2024-02-07 07:06:39 -06:00
coolGi f17bc1eccd Fixed JOML not being shadowed (not being included in the jar) 2024-02-07 23:32:33 +10:30
coolGi 08c31e5999 Fixed mod auto-updating on quilt 2024-02-07 23:23:15 +10:30
James Seibel dd341c9a22 Add frustum culling config control to the API 2024-02-06 21:45:12 -06:00
James Seibel 733fb8e871 Merge branch 'minecraft-lod-mod-shadow.frustum.culling' 2024-02-06 19:23:56 -06:00
James Seibel 4764f0969a Fix assertion errors in the end 2024-02-06 17:49:08 -06:00
James Seibel 41f8c8cfa4 Fix compiling on MC 1.19.2 and below 2024-02-06 07:17:43 -06:00
James Seibel 42bcc28d3e Merge branch 'minecraft-lod-mod-frustum.culling' 2024-02-05 21:38:46 -06:00
James Seibel b878faac96 Improve StepFeatures logging 2024-02-05 20:31:05 -06:00
James Seibel 32c1cc29f8 Fix Render Buffer count F3 menu not closing 2024-02-05 19:21:52 -06:00
James Seibel 838d82589b Fix Forge 1.20.4 compiling, but not gradle running 2024-02-04 21:27:22 -06:00
James Seibel b62af66f4b rename shadowMe ->shadowCore and shade ->shadowMc 2024-02-04 16:30:25 -06:00
James Seibel 794f524ae3 gradle commenting and minor refactoring 2024-02-04 15:52:27 -06:00
Cutiepie a38551b3d0 Disable tests for modloader projects 2024-02-04 13:28:52 +11:00
James Seibel 03c4926b09 update to latest core 2024-02-03 19:45:29 -06:00
James Seibel 982bf951e1 Fix 1.19.2 compiling 2024-02-01 07:39:16 -06:00
James Seibel a887e35285 Add Iris API events 2024-01-31 21:49:59 -06:00
Cutiepie 172f2b088d Attempt to move over to Unimined 2024-01-30 17:45:47 +11:00
Cutiepie 6d7b557c36 Attempt to move over to Unimined 2024-01-30 17:44:50 +11:00
James Seibel 9959ebc196 Merge branch 'distant-horizons-fixes' 2024-01-27 13:37:50 -06:00
James Seibel d868b8fc72 Fix missing imports 2024-01-27 13:32:35 -06:00
IMS212 297c8a1a1e Actually fix 1.16 2024-01-23 07:47:43 -08:00
IMS212 e809429a8c Fix 1.16 support 2024-01-22 17:59:59 -08:00
IMS212 200ad05f4c Fix suspicious frame time code 2024-01-22 17:52:51 -08:00
IMS212 9b4276c29b Add mushroom 2024-01-22 08:49:00 -08:00
IMS212 038073d34d Minor fixes for translucency and block ID's 2024-01-22 08:37:27 -08:00
James Seibel 8d32ab9bdb Fix method names in neoForge mixinLevelRenderer 2024-01-21 21:48:06 -06:00
James Seibel 9390b8bc4d Fix several Block materials 2024-01-21 21:36:12 -06:00
James Seibel 0d165860fb Merge branch 'distant-horizons-main' 2024-01-21 19:24:42 -06:00
James Seibel 4135fa6211 Update coreSubProjects 2024-01-20 12:24:10 -06:00
James Seibel 1d89467022 Fix Forge 1.20.1 launching (although crashes due to shadowJar fail) 2024-01-20 11:12:08 -06:00
coolGi e21ac626b3 Merge remote-tracking branch 'origin/main' 2024-01-18 19:47:23 +10:30
James Seibel aa73a30ac4 Fix C2ME throwing errors when attempting to get region file 2024-01-17 20:57:10 -06:00
Cutiepie 9a8f14c7d3 Attempt to remove arch and add AWToAt.java 2024-01-17 23:47:58 +06:00
James Seibel d7618d73c3 Fixes #613 (multiplayer failing due to folder not existing) 2024-01-17 07:45:08 -06:00
James Seibel 5aca47b357 Fix render data holes on world gen 2024-01-17 07:15:47 -06:00
coolGi 666ab1319b Fixed 1.17.1 2024-01-17 17:24:52 +10:30
coolGi 50663edc76 Fixed compilation for pre 1.19.4 2024-01-16 17:28:42 +10:30
James Seibel 1fbc37f8e7 Initializer code reduction and reformatting 2024-01-14 16:55:55 -06:00
James Seibel 5f437f8a4e Merge branch 'minecraft-lod-mod-refactor/initialization' 2024-01-14 16:10:40 -06:00
James Seibel 6130c65c48 Add messages to chunk loading about world optimization 2024-01-14 15:53:21 -06:00
James Seibel 1e19dfd6e8 minor lightMapWrapper reformat 2024-01-14 15:08:29 -06:00
James Seibel f866243d5c Attempt to fix File handler repo closed issues 2024-01-14 15:07:35 -06:00
James Seibel af04c6d995 Fix light engine out of bounds for MC 1.16 and 1.17 2024-01-14 13:27:14 -06:00
James Seibel 46bf8d0188 Update coreSubProjects 2024-01-13 23:12:19 -06:00
coolGi fc62c78136 Updated core sub-module 2024-01-13 16:19:54 +10:30
coolGi 93c2bf530f Fixed neoforge crash with merged jar 2024-01-13 16:19:10 +10:30
James Seibel 51b543a23e Fix Optifine not running in dev environment
For some reason loading the net.minecraft.client.ClientBrandRetriever class causes mixin issues
2024-01-12 07:50:49 -06:00
James Seibel dab5373231 Fix Bclib sometimes refusing to download in 1.20.1 2024-01-11 22:13:11 -06:00
coolGi 17f274a7b4 Renamed many neoforged stuff to neoforge (removed "d" at the end) 2024-01-09 19:26:00 +10:30
coolGi 841e5ba492 Fixed neoforge and updated some dependencies 2024-01-09 19:12:26 +10:30
s809 50339c94e7 Merge branch 'main' of https://gitlab.com/jeseibel/distant-horizons into refactor/initialization 2024-01-08 14:52:26 +05:00
James Seibel d2ad35ad05 Overhaul file handlers 2024-01-07 16:06:09 -06:00
James Seibel 0d65578e6a Fix chunk break/place events not triggering fabric updates post MC 1.17 2024-01-07 15:00:53 -06:00
s809 526df4f184 Refactor initializer code 2024-01-07 21:50:50 +05:00
coolGi aa6cbd1b7d Renamed forge classes to neoforge 2023-12-25 18:50:24 +10:30
coolGi 92f0703723 Removed depricated neoforged code 2023-12-25 18:48:18 +10:30
James Seibel 064241333b Merge branch 'fix-url' into 'main'
Fix clone URL

See merge request jeseibel/distant-horizons!47
2023-12-24 15:17:55 +00:00
Rózsa Péter 39b77c783b Fix clone URL 2023-12-24 13:47:11 +00:00
coolGi 0c8717a0da Fixed implNote in JavaDocs (as it "technically" part of the official Java standard) 2023-12-24 21:42:17 +10:30
coolGi 7f89a1a2cc Fixed 1.16.5 & 1.17.1 compilation 2023-12-24 21:32:21 +10:30
coolGi 5f16f81d58 Merged jar, now for fabric (works on quilt as well), forge and neoforged 2023-12-24 21:16:10 +10:30
coolGi 10bbcc79d3 Re-added forge to 1.20.4 build properties 2023-12-24 19:39:22 +10:30
coolGi ffc9771b17 Renamed forge stuff in neoforged to neoforged 2023-12-24 19:25:57 +10:30
coolGi 091b115aad Added neoforged to the ci 2023-12-23 15:31:41 +10:30
coolGi c3bdc22e28 NeoForged for 1.20.4! 2023-12-23 05:31:02 +10:30
coolGi 28d4cc86a9 Fixed 1.20.4 forge remap 2023-12-23 04:07:44 +10:30
James Seibel bb6e29f254 Merge Builderb0y API world gen extension 2023-12-22 07:19:26 -06:00
James Seibel ea0d4ba7d8 Potential fix for world gen lockup if files system fails 2023-12-20 22:06:08 -06:00
James Seibel 0504882afd Fix ocean lighting grid issue 2023-12-20 07:45:21 -06:00
James Seibel 0156f03e91 Update coreSubProjects 2023-12-19 07:38:55 -06:00
James Seibel d2acaba5c7 Add IDhApiWrapperFactory 2023-12-16 15:49:53 -06:00
James Seibel 60e4128316 Add DhApi.isDhThread() 2023-12-16 09:50:41 -06:00
James Seibel dc8aa7624b Update coreSubProjects 2023-12-16 09:09:46 -06:00
James Seibel 941aeedee0 Merge branch 'chisels' 2023-12-15 07:12:07 -06:00
James Seibel 4d8ce3b5ea Optimize DH lighting for chunks with populated sections
Specifically improves lighting speed for BigGlobe worlds
2023-12-14 07:50:57 -06:00
James Seibel 6044d24a48 Fix ThreadPool null pointer before world startup 2023-12-13 22:08:45 -06:00
James Seibel d597634ac6 Fix forge 1.20.4 crashing due to incorrect version number order 2023-12-12 07:47:22 -06:00
coolGi cf8b0329bb Hopefully fixed compolation with the new preprocessor 2023-12-12 22:17:21 +10:30
coolGi 24520824e9 Updated to new git url 2023-12-12 19:28:45 +10:30
coolGi 0d7b0f9fe4 Updated to new git url 2023-12-12 19:28:41 +10:30
coolGi 61460f9ac0 Updated java files to use version numbers 2023-12-12 19:23:28 +10:30
coolGi 14d64d535a Changed preprocessor to use version numbers 2023-12-12 18:11:26 +10:30
coolGi b00c252f17 Updated gradle (and its wrapper), and fabric and architectury loom 2023-12-12 17:56:44 +10:30
Pierre Remacle 0fe017df74 Chisels & Bits blocks transparent 2023-12-11 16:05:03 +01:00
James Seibel 4ae7083dcf Update coreSubProjects 2023-12-11 07:46:53 -06:00
James Seibel 7d5357dec8 downgrade 1.17.1 bclib 0.5.6 -> 0.5.5
For some reason my machine refused to download 0.5.6, anyone can re-update to the latest if the issue becomes resolved
2023-12-11 07:46:50 -06:00
James Seibel 2bb2f5a233 Remove PRE and POST preprocessor MC versions 2023-12-11 07:45:54 -06:00
James Seibel fee1c98a34 Fix 595 (crash on save and exit) 2023-12-09 16:19:05 -06:00
James Seibel e787d7d317 Attempt to fix a rare concurrent lighting engine issue with ChunkWrapper.getBlockLightPosList() 2023-12-09 16:18:17 -06:00
James Seibel ed52efa72b Fix SSAO and Fog not applying when Optifine shaders are enabled 2023-12-09 10:05:17 -06:00
James Seibel 963d22b2f5 Add a potential fix to unconfigured C2ME crashing/log spam 2023-12-09 09:42:18 -06:00
coolGi 8714be1dc7 Updated ci to include 1.20.4 2023-12-09 14:47:19 +10:30
coolGi 04ddd83519 Fixed up screens looking incorrect on 1.20.4 mc versions 2023-12-09 14:41:15 +10:30
coolGi 5b81ca2716 Updated to 1.20.3/4 2023-12-09 14:09:24 +10:30
James Seibel 6f8c7e8249 Add Config API methods getApiValue() and clearValue() 2023-12-07 07:13:43 -06:00
James Seibel fabad7158e Up the api version number 1.0.0 -> 1.1.0 2023-12-06 07:50:23 -06:00
James Seibel bae7e44dd8 Add overdraw number input 2023-12-06 07:50:10 -06:00
James Seibel 926c7924df Merge in Builderb0y's render merging improvements 2023-12-05 07:15:39 -06:00
James Seibel 704a2ff217 Only display empty biomeWrapper string logs once 2023-12-04 07:17:51 -06:00
coolGi 871c6031b8 Added version number to updated jar 2023-12-04 23:34:40 +10:30
James Seibel afb0a57920 up the version number 2.0.1-a -> 2.0.2-a 2023-12-03 19:13:19 -06:00
266 changed files with 14737 additions and 5723 deletions
-1
View File
@@ -5,7 +5,6 @@ root = true
[*] [*]
charset = utf-8 charset = utf-8
end_of_line = crlf
indent_size = 4 indent_size = 4
indent_style = space indent_style = space
insert_final_newline = false insert_final_newline = false
+10
View File
@@ -26,6 +26,10 @@ Merged/
# Folder created by the buildAll scripts # Folder created by the buildAll scripts
buildAllJars/ buildAllJars/
relocate_natives/.venv/
relocate_natives/__pycache__/
relocate_natives/apple-codesign/
# file from notepad++ # file from notepad++
*.bak *.bak
@@ -34,3 +38,9 @@ build.properties
# Sqlite databases # Sqlite databases
*.sqlite *.sqlite
*.sqlite-journal
*.sqlite-shm
*.sqlite-wal
# Don't add access transformers to git as they're dynamically generated
accesstransformer.cfg
+19 -20
View File
@@ -1,6 +1,6 @@
# use Eclipse's JDK # use Eclipse's JDK
# The ci should always use a unix(-like) OS to work # The ci should always use a unix(-like) OS to work
image: eclipse-temurin:17 image: eclipse-temurin:21
# all stages need to be defined here # all stages need to be defined here
# TODO: Make stages depend on what is in versionProperties # TODO: Make stages depend on what is in versionProperties
@@ -18,39 +18,38 @@ variables:
.build_java: .build_java:
#image: eclipse-temurin:17 #image: eclipse-temurin:17
cache: cache:
key: "gradleCache" key: "gradleCache_$CI_JOB_NAME_SLUG"
policy: pull-push policy: pull-push
paths: paths:
- .gradle - .gradle
- cache/ - cache/
allow_failure: true allow_failure: true
retry:
max: 2
when:
- runner_system_failure
- stuck_or_timeout_failure
build: build:
stage: build stage: build
parallel: parallel:
matrix: matrix:
- MC_VER: ["1.16.5", "1.17.1", "1.18.2", "1.19.2", "1.19.4", "1.20.1", "1.20.2"] - MC_VER: ["1.16.5", "1.17.1", "1.18.2", "1.19.2", "1.19.4", "1.20.1", "1.20.2", "1.20.4", "1.20.6", "1.21.1", "1.21.3", "1.21.4", "1.21.5", "1.21.6", "1.21.8"]
script: script:
# this both runs the unit tests and assembles the code # this both runs the unit tests and assembles the code
- ./gradlew clean -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/; - ./gradlew clean -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/;
- ./gradlew build -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/; - ./gradlew build -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/;
- ./gradlew mergeJars -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/; - ./gradlew mergeJars -PmcVer="${MC_VER}" -PinfoGitCommit="${CI_COMMIT_SHA}" -PinfoGitBranch="${CI_COMMIT_BRANCH}" -PinfoBuildSource="GitLab CI (${CI_PIPELINE_ID})" --gradle-user-home cache/;
- cp ./fabric/build/libs/* ./forge/build/libs/* ./neoforge/build/libs/* ./build/merged/* . || true
artifacts: artifacts:
name: "NightlyBuild_${MC_VER}-${CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}" name: "NightlyBuild_${MC_VER}-${CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}"
paths: paths:
- Merged/*.jar - ./*.jar
- fabric/build/libs/*.jar
- forge/build/libs/*.jar
- quilt/build/libs/*.jar
exclude: exclude:
# TODO: There is a lot of duplicate stuff here, try to maybe make it smaller - ./*-all.jar
- fabric/build/libs/*-all.jar - ./*-dev.jar
- fabric/build/libs/*-sources.jar - ./*-sources.jar
- forge/build/libs/*-all.jar
- forge/build/libs/*-sources.jar
- quilt/build/libs/*-all.jar
- quilt/build/libs/*-sources.jar
expire_in: 14 days expire_in: 14 days
when: always when: always
extends: .build_java extends: .build_java
@@ -65,15 +64,15 @@ api:
# this also runs unit tests # this also runs unit tests
- ./gradlew api:build --gradle-user-home cache/; - ./gradlew api:build --gradle-user-home cache/;
- ./gradlew api:addSourcesToCompiledJar --gradle-user-home cache/; - ./gradlew api:addSourcesToCompiledJar --gradle-user-home cache/;
- cp ./coreSubProjects/api/build/libs/merged/* .
artifacts: artifacts:
name: "Api_NightlyBuild-${CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}" name: "NightlyBuild_Api-${CI_COMMIT_SHORT_SHA}-${CI_COMMIT_TIMESTAMP}"
paths: paths:
- coreSubProjects/api/build/libs/merged/*.jar - ./*.jar
# can be uncommented if we don't want a jar with the source code
# - coreSubProjects/api/build/libs/*.jar
exclude: exclude:
- coreSubProjects/api/build/libs/merged/*-all.jar - ./*-all.jar
- coreSubProjects/api/build/libs/merged/*-sources.jar - ./*-dev.jar
- ./*-sources.jar
expire_in: 1 day expire_in: 1 day
when: always when: always
extends: .build_java extends: .build_java
+3 -3
View File
@@ -6,13 +6,13 @@ Or click the checkbox once the issue has been created.
--> -->
1. [ ] Check the FAQ to see if your issue has already been reported and has a solution: 1. [ ] Check the FAQ to see if your issue has already been reported and has a solution:
[Problems-and-solutions](https://gitlab.com/jeseibel/minecraft-lod-mod/-/wikis/2-frequently-asked-questions/2-problems-and-solutions/Problems-and-Solutions) [Problems-and-solutions](https://gitlab.com/distant-horizons-team/distant-horizons/-/wikis/1-user-guide/1-frequently-asked-questions/2-problems-and-solutions/Problems-and-Solutions)
2. [ ] Make sure you are not using any mods on the incompatible list: 2. [ ] Make sure you are not using any mods on the incompatible list:
[Mod support FAQ](https://gitlab.com/jeseibel/minecraft-lod-mod/-/wikis/2-frequently-asked-questions/4-mod-support/Mod-Support) [Mod support FAQ](https://gitlab.com/distant-horizons-team/distant-horizons/-/wikis/1-user-guide/1-frequently-asked-questions/4-mod-support/Mod-Support)
3. [ ] Check the existing issues to verify that your bug hasn't already been submitted: 3. [ ] Check the existing issues to verify that your bug hasn't already been submitted:
[Issues](https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues/) [Issues](https://gitlab.com/distant-horizons-team/distant-horizons/-/issues)
4. [ ] Upload Minecraft's crash report and/or log. \ 4. [ ] Upload Minecraft's crash report and/or log. \
Minecraft crash reports are located in: `.minecraft/crash-reports` \ Minecraft crash reports are located in: `.minecraft/crash-reports` \
+1 -1
View File
@@ -1,4 +1,4 @@
- [ ] Check the existing [feature requests](https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues/?sort=updated_desc&state=opened&label_name%5B%5D=Feature) to verify that your feature hasn't already been suggested. - [ ] Check the existing [feature requests](https://gitlab.com/distant-horizons-team/distant-horizons/-/issues?sort=updated_desc&state=opened&label_name%5B%5D=Feature) to verify that your feature hasn't already been suggested.
1. **Describe the feature**: 1. **Describe the feature**:
@@ -1,3 +1,3 @@
1. Check the existing [improvement requests](https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues/?sort=updated_desc&state=all&label_name%5B%5D=Improvement) to verify that your improvement hasn't already been suggested. 1. Check the existing [improvement requests](https://gitlab.com/distant-horizons-team/distant-horizons/-/issues?sort=updated_desc&state=all&label_name%5B%5D=Improvement) to verify that your improvement hasn't already been suggested.
2. **Describe the improvement**: 2. **Describe the improvement**:
+7
View File
@@ -0,0 +1,7 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Fabric Client &amp; Server" type="CompoundRunConfigurationType">
<toRun name="Fabric Client (:fabric)" type="Application" />
<toRun name="Fabric Server (:fabric)" type="Application" />
<method v="2" />
</configuration>
</component>
+7
View File
@@ -0,0 +1,7 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Forge Client &amp; Server" type="CompoundRunConfigurationType">
<toRun name="Forge Client (gradle)" type="GradleRunConfiguration" />
<toRun name="Forge Server (gradle)" type="GradleRunConfiguration" />
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Forge Client (gradle)" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="forge:runClient" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Forge Server (gradle)" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="forge:runServer" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+7
View File
@@ -0,0 +1,7 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Neoforge Client &amp; Server" type="CompoundRunConfigurationType">
<toRun name="Neoforge Client (gradle)" type="GradleRunConfiguration" />
<toRun name="Neoforge Server (gradle)" type="GradleRunConfiguration" />
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Neoforge Client (gradle)" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="neoforge:runClient" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Neoforge Server (gradle)" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="neoforge:runServer" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [build]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="build" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [clean]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="clean" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [core:build]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="core:build" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [fabric:runClient]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="fabric:runClient" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [forge:runClient]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="forge:runClient" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [mergeJars]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="mergeJars" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [neoforge:runClient]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="neoforge:runClient" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+24
View File
@@ -0,0 +1,24 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="distant-horizons [test]" type="GradleRunConfiguration" factoryName="Gradle" nameIsGenerated="true">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="test" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
+1
View File
@@ -0,0 +1 @@
Distant Horizons logos © 2024 by Pankakes are licensed under CC BY-SA 4.0
+40 -37
View File
@@ -1,18 +1,16 @@
# <img src="https://gitlab.com/jeseibel/distant-horizons-core/-/raw/main/_Misc%20Files/logo%20files/LOD%20logo%20flat%20-%20with%20boarder.png" width="32"> Distant Horizons # <img src="https://gitlab.com/distant-horizons-team/distant-horizons-core/-/raw/main/_Misc%20Files/logo%20files/new/SVG/Distant-Horizons.svg" height="128px">
_See farther without turning your game into a slide show._
> A mod that adds a Level of Detail System to Minecraft
<br>
# What is Distant Horizons? # What is Distant Horizons?
Distant Horizons is a Minecraft mod that adds a Level Of Detail (LOD) system to\ Distant Horizons is a mod which implements a [Level of Detail](https://en.wikipedia.org/wiki/Level_of_detail_(computer_graphics)) system to Minecraft.\
render simplified chunks outside the normal render distance\ This allows for far greater render distances without harming performance by gradually lowering the quality of distant terrain.
allowing for an increased view distance without harming performance.
In other words: this mod lets you see farther without turning your game into a slide show.\ Below is a video demonstrating the system:
If you want to see a quick demo, check out a video covering the mod here:
<a href="https://youtu.be/_04BZ8W2bDM" target="_blank">![Minecraft Level Of Detail (LOD) mod - Alpha 1.6.3](https://cdn.ko-fi.com/cdn/useruploads/png_ef4d209d-50d9-462f-b31f-92e42ec3e260cover.jpg?v=c1097a5b-029c-4484-bec3-80ff58c5d239)</a> <a href="https://youtu.be/SxQdbtjGEsc" target="_blank">![Distant Horizons - Alpha 2.0](https://i.ytimg.com/vi/SxQdbtjGEsc/hqdefault.jpg)</a>
<br> <br>
@@ -20,6 +18,14 @@ If you want to see a quick demo, check out a video covering the mod here:
### This branch supports the following versions of Minecraft: ### This branch supports the following versions of Minecraft:
#### 1.20.4, 1.20.3 (Default)
Fabric: 0.15.1\
Fabric API: 0.91.2+1.20.4\
Forge: 49.0.30\
NeoForge: 118-beta\
Parchment: 1.20.2:2023.12.10\
Modmenu: 9.0.0-pre.1
#### 1.20.2 #### 1.20.2
Fabric: 0.14.24\ Fabric: 0.14.24\
Fabric API: 0.90.4+1.20.2\ Fabric API: 0.90.4+1.20.2\
@@ -27,7 +33,7 @@ Forge: 48.0.13\
Parchment: 1.20.1:2023.09.03\ Parchment: 1.20.1:2023.09.03\
Modmenu: 8.0.0 Modmenu: 8.0.0
#### 1.20.1, 1.20 (Default) #### 1.20.1, 1.20
Fabric: 0.14.24\ Fabric: 0.14.24\
Fabric API: 0.90.4+1.20.1\ Fabric API: 0.90.4+1.20.1\
Forge: 47.2.1\ Forge: 47.2.1\
@@ -73,14 +79,15 @@ Modmenu: 1.16.22
- 1.18.1, 1.18 - 1.18.1, 1.18
- 1.19.1, 1.19 - 1.19.1, 1.19
- 1.19.3 - 1.19.3
<br><br>
<br>
### Plugin and Library versions ### Plugin and Library versions
Fabric loom: 1.1.+\ Gradle: 8.5\
Forge gradle (Using Architectury): 3.4-SNAPSHOT\ Fabric loom: 1.4-SNAPSHOT\
Architectury loom (Forge gradle replacement): 1.4-SNAPSHOT\
Sponge vanilla gradle: 0.2.1-SNAPSHOT\ Sponge vanilla gradle: 0.2.1-SNAPSHOT\
Sponge mixin: 0.8.5\
Java Preprocessor plugin: Manifold Preprocessor Java Preprocessor plugin: Manifold Preprocessor
<br> <br>
@@ -93,7 +100,7 @@ Java Preprocessor plugin: Manifold Preprocessor
Visit https://www.oracle.com/java/technologies/downloads/ for installers. Visit https://www.oracle.com/java/technologies/downloads/ for installers.
* Git or someway to clone git projects. <br> * Git or someway to clone git projects. <br>
Visit https://git-scm.com/ for installers. Visit https://git-scm.com/ for installers.
* (Not required) Any Java IDE with plugins that support Manifold, for example Intellij IDEA. * (Not required) Any Java IDE with plugins that support Manifold, for example IntelliJ IDEA.
**If using IntelliJ:** **If using IntelliJ:**
1. Install the Manifold plugin 1. Install the Manifold plugin
@@ -106,17 +113,14 @@ Java Preprocessor plugin: Manifold Preprocessor
3. Make sure eclipse has the JDK 17 installed. (This is needed so that eclipse can run minecraft) 3. Make sure eclipse has the JDK 17 installed. (This is needed so that eclipse can run minecraft)
4. Import the project into eclipse 4. Import the project into eclipse
<br>
## Switching Versions ## Switching Versions
To switch between different Minecraft versions, change `mcVer=1.?` in the `gradle.properties` file. To switch between different Minecraft versions, change `mcVer=1.?` in the `gradle.properties` file.
If running in an IDE, to ensure the IDE noticed the version change, run any gradle command to refresh gradle. (In IntellJ you will also need to do a gradle sync if it didn't happen automatically.) If running in an IDE, to ensure the IDE noticed the version change, run any gradle command to refresh gradle.\
>Note: There may be a `java.nio.file.FileSystemException` thrown when running the command after switching versions. To fix it, either restart your IDE (as your IDE is probably locking a file) or use a tool like LockHunter to unlock the linked file(s). (Generally it is a lib file under `common\build\lib`, `forge\build\lib`, or `fabric\build\lib`). \ In IntelliJ, you will also need to do a gradle sync if it didn't happen automatically.
> If anyone knows how to solve this issue please let us know here: \
> https://gitlab.com/jeseibel/minecraft-lod-mod/-/issues/233
<br> <br>
@@ -127,24 +131,23 @@ Prerequisites:
From the File Explorer: From the File Explorer:
1. Download and extract the project zip 1. Download and extract the project zip
2. Download the core from https://gitlab.com/jeseibel/distant-horizons-core and extract into a folder called `coreSubProjects` 2. Download the core from https://gitlab.com/distant-horizons-team/distant-horizons-core and extract into a folder called `coreSubProjects`
3. Open a terminal emulator in the project folder (On Windows you can type `cmd` in the title bar) 3. Open a terminal emulator in the project folder (On Windows you can type `cmd` in the title bar)
4. Run the commands: `./gradlew assemble` (You may need to use a `.\` on Windows) 4. Run the commands: `./gradlew assemble` (You may need to use a `.\` on Windows)
5. Merge the jars wih `./gradlew mergeJars` 5. Merge the jars with `./gradlew mergeJars`
6. The compiled jar file will be in the folder `Merged` 6. The compiled jar file will be in the folder `Merged`
From the command line: From the command line:
1. `git clone --recurse-submodules https://gitlab.com/jeseibel/minecraft-lod-mod.git` 1. `git clone --recurse-submodules https://gitlab.com/distant-horizons-team/distant-horizons.git`
2. `cd minecraft-lod-mod` 2. `cd distant-horizons`
3. `./gradlew assemble` 3. `./gradlew assemble`
4. `./gradlew mergeJars` 4. `./gradlew mergeJars`
5. The compiled jar file will be in the folder `Merged` 5. The compiled jar file will be in the folder `Merged`
Run tests with: `./gradlew test` Run tests with: `./gradlew test`
>Note: You can add the arg: `-PmcVer=?` to tell gradle to build a selected MC version instead of having to modify the `gradle.properties` file. \ >Note: You can add the argument `-PmcVer=?` to tell gradle to build a selected MC version instead of having to modify the `gradle.properties` file.\
> Example: `./gradlew assemble -PmcVer=1.18.2` > For example: `./gradlew assemble -PmcVer=1.18.2`
<br> <br>
@@ -154,7 +157,6 @@ Run tests with: `./gradlew test`
You can also locally compile the DH jars without a Java environment by using Docker. Where `<version>` is the version of Minecraft to compile for (ie `1.20.1`), or the keyword `all`. See [Versions](#minecraft-and-library-versions) for a list of all supported values. You can also locally compile the DH jars without a Java environment by using Docker. Where `<version>` is the version of Minecraft to compile for (ie `1.20.1`), or the keyword `all`. See [Versions](#minecraft-and-library-versions) for a list of all supported values.
<br> <br>
## Other commands ## Other commands
@@ -163,6 +165,7 @@ You can also locally compile the DH jars without a Java environment by using Doc
`./gradlew clean` to delete any compiled code. `./gradlew clean` to delete any compiled code.
<br>
## Note to self ## Note to self
@@ -170,7 +173,7 @@ The Minecraft source code is NOT added to your workspace in an editable way. Min
Source code uses Mojang mappings & [Parchment](https://parchmentmc.org/) mappings. Source code uses Mojang mappings & [Parchment](https://parchmentmc.org/) mappings.
To generate the source code run `./gradlew genSources`\ To generate the source code run `./gradlew genSources` <br>
If your IDE fails to auto-detect the source jars when browsing Minecraft classes; manually select the JAR file ending with -sources.jar when prompted by your IDE. <br> If your IDE fails to auto-detect the source jars when browsing Minecraft classes; manually select the JAR file ending with -sources.jar when prompted by your IDE. <br>
(In IntelliJ it's at the top where it says "choose sources" when browsing a Minecraft class) (In IntelliJ it's at the top where it says "choose sources" when browsing a Minecraft class)
@@ -178,12 +181,12 @@ If your IDE fails to auto-detect the source jars when browsing Minecraft classes
## Other Useful commands ## Other Useful commands
Run the standalone jar: `./gradlew run`\ Run the standalone jar: `./gradlew run` <br>
Build the standalone jar: `./gradlew core:build`\ Build the standalone jar: `./gradlew core:build` <br>
Only build Fabric: `./gradlew fabric:assemble` or `./gradlew fabric:build`\ Only build Fabric: `./gradlew fabric:assemble` or `./gradlew fabric:build` <br>
Only build Forge: `./gradlew fabric:assemble` or `./gradlew forge:build`\ Only build Forge: `./gradlew forge:assemble` or `./gradlew forge:build` <br>
Run the Fabric client (for debugging): `./gradlew fabric:runClient`\ Run the Fabric client (for debugging): `./gradlew fabric:runClient` <br>
Run the Forge client (for debugging): `./gradlew forge:runClient` Run the Forge client (for debugging): `./gradlew forge:runClient` <br>
To build all versions: `./buildAll` (all builds will end up in the `Merged` folder) To build all versions: `./buildAll` (all builds will end up in the `Merged` folder)
@@ -197,7 +200,7 @@ https://github.com/PacifistMC/Forgix
LZ4 for Java (data compression)\ LZ4 for Java (data compression)\
https://github.com/lz4/lz4-java https://github.com/lz4/lz4-java
NightConfig for Json & Toml (config handling)\ NightConfig for JSON & TOML (config handling)\
https://github.com/TheElectronWill/night-config https://github.com/TheElectronWill/night-config
SVG Salamander for SVG support (not being used atm)\ SVG Salamander for SVG support (not being used atm)\
+214 -154
View File
@@ -1,77 +1,60 @@
import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
import org.apache.tools.zip.ZipEntry
import javax.annotation.Nonnull
import org.apache.tools.zip.ZipOutputStream
plugins { plugins {
id "java" id "java"
// Plugin to handle dependencies // Plugin to put dependencies inside our final jar
id "com.github.johnrengelman.shadow" version '7.1.2' apply false id "com.github.johnrengelman.shadow" version '8.1.1' apply false
// Plugin to create merged jars // Plugin to create merged jars
id "io.github.pacifistmc.forgix" version "1.2.6" id "io.github.pacifistmc.forgix" version "1.3.4"
// Manifold preprocessor // Manifold preprocessor
id "systems.manifold.manifold-gradle-plugin" version "0.0.2-alpha" id "systems.manifold.manifold-gradle-plugin" version "0.0.2-alpha"
// Provides mc libraries to core
// id "org.spongepowered.gradle.vanilla" version '0.2.1-SNAPSHOT' apply false
// Architectury is used here only as a replacement for forge's own loom // Architectury is used here only as a replacement for forge's own loom
id "dev.architectury.loom" version "1.1.+" apply false id "dev.architectury.loom" version "1.10-SNAPSHOT" apply false
} }
/** /**
* Creates the list of preprocessors to use. * Creates the list of preprocessors to use.
* *
* @param mcVers array of all MC versions * @param mcVers array of all MC versions
* @param mcIndex array index of the currently active MC version * @param mcIndex array index of the currently active MC version
*/ */
def writeBuildGradlePredefine(List<String> mcVers, int mcIndex) { def writeBuildGradlePredefine(List<String> mcVers, int mcIndex)
ArrayList<String> redefineList = new ArrayList<String>() {
for (int i = 0; i < mcVers.size(); i++) {
String mcStr = mcVers[i].replace(".", "_")
if (mcIndex < i) {
// exclusive before
// FIXME doesn't function correctly for 1.16.5 (IE the first item in the list)
redefineList.add("PRE_MC_" + mcStr)
}
if (mcIndex <= i) {
// inclusive before
redefineList.add("PRE_AND_MC_" + mcStr)
}
if (mcIndex == i) {
// exact
redefineList.add("MC_" + mcStr)
}
if (mcIndex > i) {
// inclusive after
redefineList.add("POST_AND_MC_" + mcStr)
}
if (mcIndex >= i) {
// exclusive after
redefineList.add("POST_MC_" + mcStr)
}
}
// Build the list of preprocessors to use // Build the list of preprocessors to use
StringBuilder sb = new StringBuilder() StringBuilder sb = new StringBuilder();
sb.append("# DON'T TOUCH THIS FILE, This is handled by the build script\n") sb.append("# DON'T TOUCH THIS FILE, This is handled by the build script\n");
for (int i = 0; i < mcVers.size(); i++)
{
String verStr = mcVers[i].replace(".", "_");
sb.append("MC_" + verStr + "=" + i.toString() + "\n");
if (mcIndex == i)
sb.append("MC_VER=" + i.toString() + "\n");
}
// Check if this is a development build // Check if this is a development build
if (mod_version.toLowerCase().contains("dev")) { if (mod_version.toLowerCase().contains("dev"))
{
// WARNING: only use this for logging, we don't want to have confusion // WARNING: only use this for logging, we don't want to have confusion
// when a method doesn't work correctly in the release build. // when a method doesn't work correctly in the release build.
sb.append("DEV_BUILD") sb.append("DEV_BUILD=\n");
sb.append("=\n")
} }
// Build the MC version preprocessors
for (String redefinedVersion : redefineList) {
sb.append(redefinedVersion)
sb.append("=\n")
}
new File(projectDir, "build.properties").text = sb.toString() new File(projectDir, "build.properties").text = sb.toString()
} }
@@ -79,37 +62,69 @@ def writeBuildGradlePredefine(List<String> mcVers, int mcIndex) {
// Transfers the values set in settings.gradle to the rest of the project // Transfers the values set in settings.gradle to the rest of the project
project.gradle.ext.getProperties().each { prop -> project.gradle.ext.getProperties().each { prop ->
rootProject.ext.set(prop.key, prop.value) rootProject.ext.set(prop.key, prop.value)
// println "Added prop [key:" + prop.key + ", value:" + prop.value + "]" //println "Added prop [key:" + prop.key + ", value:" + prop.value + "]"
} }
// Sets up manifold stuff // Sets up manifold stuff
writeBuildGradlePredefine(rootProject.mcVers, rootProject.mcIndex) writeBuildGradlePredefine(rootProject.mcVers, rootProject.mcIndex)
// Sets up the version string (the name we use for our jar) // Sets up the version string (the name we use for our jar)
rootProject.versionStr = rootProject.mod_version + "-" + rootProject.minecraft_version // + "-" + new Date().format("yyyy_MM_dd_HH_mm") rootProject.versionStr = rootProject.mod_version + "-" + rootProject.minecraft_version // + "-" + new Date().format("yyyy_MM_dd_HH_mm")
// Forgix settings (used for merging jars)
forgix {
group = "com.seibel.distanthorizons"
mergedJarName = "DistantHorizons-${rootProject.versionStr}.jar"
if (findProject(":forge")) class NativeTransformer implements Transformer {
forge { private final HashMap<String, String> replacements = new HashMap()
jarLocation = "build/libs/DistantHorizons-forge-${rootProject.versionStr}.jar" private final HashMap<String, byte[]> rewrittenFiles = new HashMap()
private var nativeRelocator
public File rootDir
void relocateNative(String target, String replacement) {
if (replacement.length() > target.length()) {
throw new GradleException("Length of value \"${replacement}\" exceeds the length of \"${target}\": ${replacement.length()} > ${target.length()}")
} }
if (findProject(":fabric")) replacements.put(target, replacement)
fabric { }
jarLocation = "build/libs/DistantHorizons-fabric-${rootProject.versionStr}.jar"
@Override
boolean canTransformResource(@Nonnull FileTreeElement element) {
return replacements.keySet().stream().anyMatch {
element.name.startsWith(it as String)
}
}
@Override
void transform(@Nonnull TransformerContext context) {
byte[] content = context.is.readAllBytes()
if (nativeRelocator == null) {
nativeRelocator = new NativeRelocator(rootDir.toPath().resolve("relocate_natives"))
} }
if (findProject(":quilt")) try {
quilt { Map.Entry<String, String> pathReplacement = replacements.entrySet().stream().filter {
jarLocation = "build/libs/DistantHorizons-quilt-${rootProject.versionStr}.jar" context.path.startsWith(it.key as String)
} }.findFirst().orElseThrow()
removeDuplicate "com.seibel.distanthorizons" String path = context.path.replace(pathReplacement.key as String, pathReplacement.value as String)
content = nativeRelocator.processBinary(path, content, replacements)
rewrittenFiles.put(path, content)
}
catch (Throwable e) {
throw new GradleException("Failed to relocate", e)
}
}
@Override
boolean hasTransformedResource() { return !rewrittenFiles.isEmpty() }
@Override
void modifyOutputStream(@Nonnull ZipOutputStream os, boolean preserveFileTimestamps) {
for (Map.Entry<String, byte[]> rewrittenFile : rewrittenFiles.entrySet()) {
os.putNextEntry(new ZipEntry(rewrittenFile.key))
os.write(rewrittenFile.value)
}
}
} }
subprojects { p -> subprojects { p ->
@@ -123,20 +138,21 @@ subprojects { p ->
apply plugin: "com.github.johnrengelman.shadow" apply plugin: "com.github.johnrengelman.shadow"
if (isMinecraftSubProject) if (isMinecraftSubProject)
apply plugin: "systems.manifold.manifold-gradle-plugin" apply plugin: "systems.manifold.manifold-gradle-plugin"
if (p == project(":core"))
apply plugin: "application"
// apply plugin: "org.spongepowered.gradle.vanilla" // Provides minecraft libraries
// Apply forge's loom // Apply forge's loom
if (findProject(":forge") && p == project(":forge")) if ((findProject(":forge") && p == project(":forge")) ||
(findProject(":neoforge") && p == project(":neoforge"))
)
{
apply plugin: "dev.architectury.loom" apply plugin: "dev.architectury.loom"
}
// Set the manifold version (may not be required tough) // Set the manifold version (may not be required tough)
manifold { manifold {
manifoldVersion = rootProject.manifold_version manifoldVersion = rootProject.manifold_version
} }
// set up custom configurations (configurations are a way to handle dependencies) // set up custom configurations (configurations are a way to handle dependencies)
configurations { configurations {
@@ -148,8 +164,8 @@ subprojects { p ->
// Configuration fpr core & api // Configuration fpr core & api
coreProjects coreProjects
shadowMe.extendsFrom(coreProjects) shadowMe.extendsFrom(coreProjects)
// FIXME this additional configuration is necessary because forge // FIXME this additional configuration is necessary because forge
// needs forgeRuntimeLibrary, although adding it to shadowMe // needs forgeRuntimeLibrary, although adding it to shadowMe
// causes runtime issues where the libraries aren't properly added // causes runtime issues where the libraries aren't properly added
@@ -158,67 +174,85 @@ subprojects { p ->
implementation.extendsFrom(forgeShadowMe) implementation.extendsFrom(forgeShadowMe)
shadowMe.extendsFrom(forgeShadowMe) shadowMe.extendsFrom(forgeShadowMe)
forgeRuntimeLibrary.extendsFrom(forgeShadowMe) forgeRuntimeLibrary.extendsFrom(forgeShadowMe)
if (isMinecraftSubProject && p != project(":common")) { if (isMinecraftSubProject && p != project(":common")) {
// Shadow common // Shadow common
common common
shadowCommon // Don't use shadow from the shadow plugin because we don't want IDEA to index this. shadowCommon // Don't use shadow from the shadow plugin because we don't want IDEA to index this.
compileClasspath.extendsFrom common compileClasspath.extendsFrom common
runtimeClasspath.extendsFrom common runtimeClasspath.extendsFrom common
developmentForge.extendsFrom common if (findProject(":forge"))
developmentForge.extendsFrom common
if (findProject(":neoforge"))
developmentNeoForge.extendsFrom common
compileClasspath.extendsFrom coreProjects compileClasspath.extendsFrom coreProjects
runtimeClasspath.extendsFrom coreProjects runtimeClasspath.extendsFrom coreProjects
developmentForge.extendsFrom coreProjects if (findProject(":forge"))
developmentForge.extendsFrom coreProjects
if (findProject(":neoforge"))
developmentNeoForge.extendsFrom coreProjects
// TODO remove unused fabricLike
if (findProject(":fabricLike") && p != project(":fabricLike")) { if (findProject(":fabricLike") && p != project(":fabricLike")) {
// Shadow fabricLike // Shadow fabricLike
fabricLike fabricLike
shadowFabricLike shadowFabricLike
compileClasspath.extendsFrom fabricLike compileClasspath.extendsFrom fabricLike
runtimeClasspath.extendsFrom fabricLike runtimeClasspath.extendsFrom fabricLike
developmentForge.extendsFrom fabricLike
} }
} }
} }
// Let the application plugin know where the main class is
// (This will point to a non-existent class in all sub-projects except "Core")
if (p == project(":core")) {
application {
mainClass.set("com.seibel.distanthorizons.core.jar.JarMain")
}
}
dependencies { dependencies {
//=====================// //=====================//
// shared dependencies // // shared dependencies //
//=====================// //=====================//
// Manifold // Manifold
if (isMinecraftSubProject) { if (isMinecraftSubProject) {
annotationProcessor("systems.manifold:manifold-preprocessor:${rootProject.manifold_version}") annotationProcessor("systems.manifold:manifold-preprocessor:${rootProject.manifold_version}")
} }
// Log4j // Log4j
// TODO: Change to shadowMe later to work in the standalone jar if (p == project(":core"))
// We cannot do this now as it would break Quilt {
implementation("org.apache.logging.log4j:log4j-api:${rootProject.log4j_version}") // the standalone core jar needs logging shaded otherwise it won't run
implementation("org.apache.logging.log4j:log4j-core:${rootProject.log4j_version}") forgeShadowMe("org.apache.logging.log4j:log4j-api:${rootProject.log4j_version}")
forgeShadowMe("org.apache.logging.log4j:log4j-core:${rootProject.log4j_version}")
}
else
{
// When running in MC, MC already includes logging
implementation("org.apache.logging.log4j:log4j-api:${rootProject.log4j_version}")
implementation("org.apache.logging.log4j:log4j-core:${rootProject.log4j_version}")
}
// JOML // JOML
implementation("org.joml:joml:${rootProject.joml_version}") if (project.hasProperty("embed_joml") && embed_joml == "true")
forgeShadowMe("org.joml:joml:${rootProject.joml_version}")
else
implementation("org.joml:joml:${rootProject.joml_version}")
// JUnit tests // JUnit tests
implementation("org.junit.jupiter:junit-jupiter:5.8.2") implementation("org.junit.jupiter:junit-jupiter:5.8.2")
implementation("org.junit.jupiter:junit-jupiter-engine:5.8.2") implementation("org.junit.jupiter:junit-jupiter-engine:5.8.2")
implementation("junit:junit:4.13") implementation("junit:junit:4.13")
// FastUtil
// Note: MC 1.16 uses 8.2.1, and versions after use 8.5.12
// We cannot relocate this library since we call some MC classes that reference it
implementation("it.unimi.dsi:fastutil:${rootProject.fastutil_version}")
//forgeShadowMe("com.github.luben:zstd-jni:1.5.7-3")
//forgeShadowMe("org.apache.commons:commons-compress:1.27.1")
// Compression // Compression
forgeShadowMe("org.lz4:lz4-java:${rootProject.lz4_version}") forgeShadowMe("org.lz4:lz4-java:${rootProject.lz4_version}") // LZ4
forgeShadowMe("org.tukaani:xz:${rootProject.xz_version}") // LZMA
// Sqlite Database // Sqlite Database
forgeShadowMe("org.xerial:sqlite-jdbc:${rootProject.sqlite_jdbc_version}") forgeShadowMe("org.xerial:sqlite-jdbc:${rootProject.sqlite_jdbc_version}")
@@ -230,8 +264,7 @@ subprojects { p ->
// forgeShadowMe("com.formdev:svgSalamander:${rootProject.svgSalamander_version}") // forgeShadowMe("com.formdev:svgSalamander:${rootProject.svgSalamander_version}")
// Netty // Netty
// Breaks 1.16.5 implementation("io.netty:netty-buffer:${rootProject.netty_version}")
//forgeShadowMe("io.netty:netty-all:${rootProject.netty_version}")
// Remember, for lwjgl dependencies that arent included in Minecraft, you need to also need to add it to the ShadowJar thing // Remember, for lwjgl dependencies that arent included in Minecraft, you need to also need to add it to the ShadowJar thing
forgeShadowMe("org.lwjgl:lwjgl-jawt:${rootProject.lwjgl_version}") { forgeShadowMe("org.lwjgl:lwjgl-jawt:${rootProject.lwjgl_version}") {
@@ -289,13 +322,13 @@ subprojects { p ->
if (isMinecraftSubProject && p != project(":common")) { if (isMinecraftSubProject && p != project(":common")) {
configurations.push(project.configurations.shadowCommon) // Shadow the common subproject configurations.push(project.configurations.shadowCommon) // Shadow the common subproject
relocate "com.seibel.distanthorizons.common", "loaderCommon.${p.name}.com.seibel.distanthorizons.common" // Move the loader files to a different location relocate "com.seibel.distanthorizons.common", "loaderCommon.${p.name}.com.seibel.distanthorizons.common" // Move the loader files to a different location
if (findProject(":fabricLike") && p != project(":fabricLike")) { if (findProject(":fabricLike") && p != project(":fabricLike")) {
configurations.push(project.configurations.shadowFabricLike) // Shadow the fabricLike subproject configurations.push(project.configurations.shadowFabricLike) // Shadow the fabricLike subproject
relocate "com.seibel.distanthorizons.fabriclike", "loaderCommon.${p.name}.com.seibel.distanthorizons.fabriclike" // Move the loader files to a different location relocate "com.seibel.distanthorizons.fabriclike", "loaderCommon.${p.name}.com.seibel.distanthorizons.fabriclike" // Move the loader files to a different location
} }
} }
def librariesLocation = "distanthorizons.libraries" def librariesLocation = "DistantHorizons.libraries"
// LWJGL // LWJGL
// Only ever shadow the dependencies we use otherwise some stuff would break when running on an external client // Only ever shadow the dependencies we use otherwise some stuff would break when running on an external client
@@ -304,9 +337,27 @@ subprojects { p ->
// Compression (LZ4) // Compression (LZ4)
relocate "net.jpountz", "${librariesLocation}.jpountz" relocate "net.jpountz", "${librariesLocation}.jpountz"
// Logging
relocate "org.slf4j", "${librariesLocation}.slf4j"
// Sqlite Database // Sqlite Database
//At the moment, there is a bug in this library which doesnt allow it to be relocated // librariesLocation isn't used because it's too long for replacing paths in native libraries
// relocate "org.sqlite", "${librariesLocation}.sqlite" // Allowing strings larger than the original string would require shifting the entire binary's contents
relocate "org.sqlite", "dh_sqlite", {
exclude "org/sqlite/native/**"
}
relocate "jdbc:sqlite", "jdbc:dh_sqlite"
transform(NativeTransformer) {
rootDir = project.rootDir
relocateNative "org/sqlite", "dh_sqlite"
relocateNative "org_sqlite", "dh_1sqlite"
}
// JOML
if (project.hasProperty("embed_joml") && embed_joml == "true")
relocate "org.joml", "${librariesLocation}.joml"
// NightConfig (includes Toml & Json) // NightConfig (includes Toml & Json)
relocate "com.electronwill.nightconfig", "${librariesLocation}.electronwill.nightconfig" relocate "com.electronwill.nightconfig", "${librariesLocation}.electronwill.nightconfig"
@@ -315,7 +366,8 @@ subprojects { p ->
// relocate "com.kitfox.svg", "${librariesLocation}.kitfox.svg" // relocate "com.kitfox.svg", "${librariesLocation}.kitfox.svg"
// Netty // Netty
relocate "io.netty", "${librariesLocation}.netty" // Don't relocate, it causes problems with using MC's FriendlyByteBufs
// relocate "io.netty", "${librariesLocation}.netty"
mergeServiceFiles() mergeServiceFiles()
} }
@@ -326,22 +378,23 @@ subprojects { p ->
// Put stuff from gradle.properties into the mod info // Put stuff from gradle.properties into the mod info
processResources { processResources {
def resourceTargets = [ // Location of where to inject the properties def resourceTargets = [ // Location of where to inject the properties
// Holds info like git commit // Holds info like git commit
// TODO: For some reason this script doesnt work with the core project // TODO: For some reason this script doesnt work with the core project
"build_info.json", "build_info.json",
// Properties for each of the loaders // Properties for each of the loaders
"fabric.mod.json", "fabric.mod.json",
"quilt.mod.json", "quilt.mod.json",
"META-INF/mods.toml", "META-INF/mods.toml",
"META-INF/neoforge.mods.toml",
// The mixins for each of the loaders // The mixins for each of the loaders
"DistantHorizons."+ p.name +".fabricLike.mixins.json" "DistantHorizons."+ p.name +".fabricLike.mixins.json"
] ]
def intoTargets = ["$buildDir/resources/main/"] // Location of the built resources folder def intoTargets = ["$buildDir/resources/main/"] // Location of the built resources folder
// Fix forge version numbering system as it is weird // Fix forge version numbering system as it is weird
// For whatever reason forge uses [1.18, 1.18.1, 1.18.2) instead of the standard ["1.18", "1.18.1", "1.18.2"] which make more sense // For whatever reason forge uses [1.18, 1.18.1, 1.18.2) instead of the standard ["1.18", "1.18.1", "1.18.2"]
def compatible_forgemc_versions = "${compatible_minecraft_versions}".replaceAll("\"", "").replaceAll("]", ",)") def compatible_forgemc_versions = "${compatible_minecraft_versions}".replaceAll("\"", "").replaceAll("]", ",)")
// println compatible_forgemc_versions // println compatible_forgemc_versions
@@ -354,9 +407,9 @@ subprojects { p ->
quilt_contributors.push("\"${dev.strip()}\": \"Developer\"") quilt_contributors.push("\"${dev.strip()}\": \"Developer\"")
} }
quilt_contributors.reverse() quilt_contributors.reverse()
// println quilt_contributors.join(", ") //println quilt_contributors.join(", ")
// TODOI: Find something we can use so we can basically re-map only when the jar is shadowed and relocated // TODO: Find something we can use so we can basically re-map only when the jar is shadowed and relocated
// println p.tasks.findByName('shadowJar') // println p.tasks.findByName('shadowJar')
@@ -371,6 +424,7 @@ subprojects { p ->
println "Git or Git project not found" println "Git or Git project not found"
} }
// The left side is what gets replaced in the mod info and the right side is where to get it from in the gradle.properties
def replaceProperties = [ def replaceProperties = [
version : mod_version, version : mod_version,
mod_name : mod_readable_name, mod_name : mod_readable_name,
@@ -392,16 +446,18 @@ subprojects { p ->
info_build_source : infoBuildSource, info_build_source : infoBuildSource,
fabric_incompatibility_list : fabric_incompatibility_list, fabric_incompatibility_list : fabric_incompatibility_list,
fabric_recommend_list : fabric_recommend_list, fabric_recommend_list : fabric_recommend_list,
]
// The left side is what gets replaced in the mod info and the right side is where to get it from in the gradle.properties
neoforge_version_range : neoforge_version_range,
]
// replace any properties in the sub-projects with the values defined here
inputs.properties replaceProperties inputs.properties replaceProperties
replaceProperties.put "project", project replaceProperties.put "project", project
filesMatching(resourceTargets) { filesMatching(resourceTargets) {
expand replaceProperties expand replaceProperties
} }
intoTargets.each { target -> intoTargets.each { target ->
if (file(target).exists()) { if (file(target).exists()) {
copy { copy {
@@ -423,7 +479,7 @@ subprojects { p ->
//// include "${accessWidenerVersion}.distanthorizons.accesswidener" //// include "${accessWidenerVersion}.distanthorizons.accesswidener"
// Jank solution to remove all unused accesswideners // Jank solution to remove all unused accesswideners
// The line above would work..., except forge requires the original accesswidener file, meaning we require this jank solution to keep it // The line above would work..., except that (neo)forge (well, mainly architectury) requires the original accesswidener file, meaning we require this jank solution to keep it
exclude { file -> exclude { file ->
if (file.name.contains(".distanthorizons.accesswidener") && file.name != "${accessWidenerVersion}.distanthorizons.accesswidener") { if (file.name.contains(".distanthorizons.accesswidener") && file.name != "${accessWidenerVersion}.distanthorizons.accesswidener") {
return true return true
@@ -437,9 +493,12 @@ subprojects { p ->
jar { jar {
from "LICENSE.txt" from "LICENSE.txt"
manifest { manifest {
attributes 'Implementation-Title': rootProject.mod_name, attributes(
'Implementation-Version': rootProject.mod_version, 'Implementation-Title': rootProject.mod_name,
'Main-Class': 'com.seibel.distanthorizons.core.jar.JarMain' // When changing the main of the jar change this line 'Implementation-Version': rootProject.mod_version,
'Multi-Release': true, // needed for logging in the standalone core jar
'Main-Class': 'com.seibel.distanthorizons.core.jar.JarMain', // When changing the main of the jar change this line
)
} }
} }
@@ -459,17 +518,10 @@ subprojects { p ->
} }
} }
*/ */
// Run mergeJars when running build
// TODO: Fix later
// if (isMinecraftSubProject) {
// build.finalizedBy(mergeJars)
// assemble.finalizedBy(mergeJars)
// }
} }
allprojects { p -> allprojects { p ->
// Does the same as "p == project(":common") || p == project(":fabric") || p == project(":quilt") || p == project(":forge")" // Does the same as "p == project(":common") || p == project(":fabric") || p == project(":quilt") || p == project(":forge") || p == project("WhateverWeAddLaterOn")"
// Useful later on so we dont have duplicated code // Useful later on so we dont have duplicated code
def isMinecraftSubProject = p != project(":core") && p != project(":api") def isMinecraftSubProject = p != project(":core") && p != project(":api")
@@ -477,16 +529,33 @@ allprojects { p ->
apply plugin: "java" apply plugin: "java"
apply plugin: "maven-publish" apply plugin: "maven-publish"
// Sets the name of the jar, the version will contain the name of the project if it isn't the root project
archivesBaseName = rootProject.mod_name archivesBaseName = rootProject.mod_name
version = project.name + "-" + rootProject.versionStr version = (project == rootProject ? "" : project.name + "-") + rootProject.versionStr
group = rootProject.maven_group group = rootProject.maven_group
// this is the text that appears at the top of the overview (home) page // this is the text that appears at the top of the overview (home) page
// and is used when bookmarking a page // and is used when bookmarking a page
javadoc.title = rootProject.mod_name + "-" + project.name javadoc.title = rootProject.mod_name + "-" + project.name
// Some annotations arent "technically" part of the official java standard,
// so we define it ourself here
javadoc {
configure( options ) {
tags(
'todo:X"',
'apiNote:a:API Note:',
'implSpec:a:Implementation Requirements:',
'implNote:a:Implementation Note:'
)
}
}
repositories { repositories {
// Mojang overrides (added to fix downloading the wrong LWJGL libs on M1 Mac's and potentially other arm64 based machines)
maven { url "https://libraries.minecraft.net/" }
// The central repo // The central repo
mavenCentral() mavenCentral()
@@ -494,6 +563,7 @@ allprojects { p ->
maven { url "https://repo.enonic.com/public/" } maven { url "https://repo.enonic.com/public/" }
// For parchment mappings // For parchment mappings
// versions can be found here: https://ldtteam.jfrog.io/ui/native/parchmentmc-public/org/parchmentmc/data/
maven { url "https://maven.parchmentmc.org" } maven { url "https://maven.parchmentmc.org" }
// For Architectury API // For Architectury API
@@ -522,15 +592,17 @@ allprojects { p ->
} }
} }
// Required for ModMenu // VanillaGradle and Mixins in common
maven { url "https://maven.terraformersmc.com/" }
// Required for Mixins & VanillaGradle
maven { url "https://repo.spongepowered.org/maven/" } maven { url "https://repo.spongepowered.org/maven/" }
// Required for Canvas (mod) // Canvas mod
maven { url "https://maven.vram.io/" } maven { url "https://maven.vram.io/" }
// ModMenu mod
maven { url "https://maven.terraformersmc.com/" }
// neoforge
maven { url "https://maven.neoforged.net/releases/" }
// These 3 are for importing mods that arnt on CursedForge, Modrinth, GitHub, GitLab or anywhere opensource // These 3 are for importing mods that arnt on CursedForge, Modrinth, GitHub, GitLab or anywhere opensource
flatDir { flatDir {
dirs "${rootDir}/mods/fabric" dirs "${rootDir}/mods/fabric"
@@ -550,6 +622,7 @@ allprojects { p ->
includeGroup "forge-mod" includeGroup "forge-mod"
} }
} }
// TODO: If neoforged is ever needed, should we use that, or call it a forge mod?
} }
// Adds some dependencies that are in vanilla but not in core // Adds some dependencies that are in vanilla but not in core
@@ -586,7 +659,6 @@ allprojects { p ->
implementation("com.google.code.findbugs:jsr305:3.0.2") implementation("com.google.code.findbugs:jsr305:3.0.2")
implementation("com.google.common:google-collect:0.5") implementation("com.google.common:google-collect:0.5")
implementation("com.google.guava:guava:31.1-jre") implementation("com.google.guava:guava:31.1-jre")
implementation("it.unimi.dsi:fastutil:8.5.11")
} }
} }
@@ -613,7 +685,6 @@ allprojects { p ->
tasks.withType(JavaCompile) { tasks.withType(JavaCompile) {
if (isMinecraftSubProject) { if (isMinecraftSubProject) {
options.release = rootProject.java_version as Integer options.release = rootProject.java_version as Integer
options.compilerArgs += ["-Xplugin:Manifold"]
} else { } else {
options.release = 8; // Core & Api should use Java 8 no matter what options.release = 8; // Core & Api should use Java 8 no matter what
//options.release = rootProject.java_version as Integer // But if you want to test some stuff, then this can be enabled //options.release = rootProject.java_version as Integer // But if you want to test some stuff, then this can be enabled
@@ -625,14 +696,3 @@ allprojects { p ->
withSourcesJar() withSourcesJar()
} }
} }
// Delete the merged folder when running clean
task cleanMergedJars() {
def mergedFolder = file("Merged")
if (mergedFolder.exists()) {
delete(mergedFolder)
}
}
// add cleanMergedJars to the end of the "clean" task
tasks["clean"].finalizedBy(cleanMergedJars)
+12 -6
View File
@@ -1,7 +1,8 @@
#!/bin/sh #!/bin/sh
echo "==================== Note: All build jars will be in the folder called 'buildAllJars' ====================" echo "==================== Note: All build jars will be in the folder called 'buildAllJars' ===================="
mkdir -p buildAllJars | true mkdir -p buildAllJars
rm -rf buildAllJars/*
# Loop trough everything in the version properties folder # Loop trough everything in the version properties folder
for d in versionProperties/*; do for d in versionProperties/*; do
@@ -11,12 +12,17 @@ for d in versionProperties/*; do
# Clean out the folders, build it, and merge it # Clean out the folders, build it, and merge it
# (We could use "./" to run gradlew, but as it is a shell script im going to be running it with the "sh" command) # (We could use "./" to run gradlew, but as it is a shell script im going to be running it with the "sh" command)
echo "==================== Cleaning workspace to build $version ====================" echo "==================== Cleaning workspace to build $version ===================="
sh gradlew clean -PmcVer=$version --no-daemon || true sh gradlew clean -PmcVer=$version
if [ $? != 0 ]; then continue; fi
echo "====================Building $version ====================" echo "====================Building $version ===================="
sh gradlew build -PmcVer=$version --no-daemon || true sh gradlew build -PmcVer=$version
if [ $? != 0 ]; then continue; fi
echo "==================== Merging $version ====================" echo "==================== Merging $version ===================="
sh gradlew mergeJars -PmcVer=$version --no-daemon || true sh gradlew mergeJars -PmcVer=$version
if [ $? != 0 ]; then continue; fi
echo "==================== Moving jar ====================" echo "==================== Moving jar ===================="
mv Merged/*.jar buildAllJars/ || true mv build/merged/*.jar buildAllJars/
# The "| true" at the end of those are just to make sure the script continues even if a build fails
done done
+10 -6
View File
@@ -5,6 +5,7 @@
echo ==================== Note: All build jars will be in the folder called 'buildAllJars' ==================== echo ==================== Note: All build jars will be in the folder called 'buildAllJars' ====================
mkdir buildAllJars mkdir buildAllJars
del buildAllJars/*
@rem Loop trough everything in the version properties folder @rem Loop trough everything in the version properties folder
for %%f in (versionProperties\*) do ( for %%f in (versionProperties\*) do (
@@ -13,13 +14,16 @@ for %%f in (versionProperties\*) do (
@rem Clean out the folders, build it, and merge it @rem Clean out the folders, build it, and merge it
echo ==================== Cleaning workspace to build !version! ==================== echo ==================== Cleaning workspace to build !version! ====================
call .\gradlew.bat clean -PmcVer="!version!" --no-daemon call .\gradlew.bat clean
echo ==================== Building !version! ====================
call .\gradlew.bat build -PmcVer="!version!" --no-daemon echo ==================== Building !version! ====================
echo ==================== Merging !version! ==================== call .\gradlew.bat build -PmcVer="!version!"
call .\gradlew.bat mergeJars -PmcVer="!version!" --no-daemon
echo ==================== Merging !version! ====================
call .\gradlew.bat mergeJars -PmcVer="!version!"
echo ==================== Moving jar ==================== echo ==================== Moving jar ====================
move Merged\*.jar buildAllJars\ move build\merged\*.jar buildAllJars\
) )
endlocal endlocal
+239
View File
@@ -0,0 +1,239 @@
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AWToAT {
private static final Map<String, String> ACCESS_POINT_MAP = new HashMap<>();
static {
ACCESS_POINT_MAP.put("accessible", "public");
ACCESS_POINT_MAP.put("extendable", "public-f");
ACCESS_POINT_MAP.put("mutable", "public-f");
}
public String minecraftVersion;
public File remap(File file, String minecraftVersion) {
this.minecraftVersion = minecraftVersion.replace("_", ".");
File atFile = createATFile(file);
processFile(file, atFile);
return atFile;
}
private File createATFile(File file) {
File metaInf = new File(file.getParentFile(), "META-INF");
if (!metaInf.exists() && !metaInf.mkdir()) throw new RuntimeException("Error creating META-INF folder");
File atFile = new File(metaInf, "accesstransformer.cfg");
try {
atFile.createNewFile();
} catch (IOException e) {
throw new RuntimeException("Error creating new file", e);
}
return atFile;
}
private void processFile(File file, File atFile) {
/* Validates if we need to recreate the Access Transformer file if it's out of date */
// Get the hash of the file
String fileHash = getFileHash(file);
try (Scanner atScanner = new Scanner(atFile)) {
// Check if the AT file is up-to-date by comparing the hash of the file with the hash stored in the AT file
boolean hashFound = false;
while (atScanner.hasNextLine()) {
String line = atScanner.nextLine();
if (hashCheck(line, fileHash)) {
hashFound = true;
}
}
// If the AT file is up-to-date, print a message and return
if (hashFound) {
System.out.println("Access Transformer file is already up to date.");
return;
}
} catch (FileNotFoundException ignored) {
// If the AT file does not exist, continue
}
/* Creates the Access Transformer file */
// Opens a scanner for reading the Access Widener file and a writer for writing to the Access Transformer file
try (Scanner scanner = new Scanner(file); FileWriter writer = new FileWriter(atFile)) {
// Create an ExecutorService with a fixed thread pool size equal to the number of available processors
ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// List to hold Future objects representing results of computation
List<Future<String>> futures = new ArrayList<>();
// Write the hash of the file to the AT file
writer.write("#DH_MAPPING_HASH:" + fileHash + "\n");
// Read each line from the file
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// Skip lines starting with "accessWidener", "#" or blank lines
if (line.startsWith("accessWidener") || line.startsWith("#") || line.isBlank()) continue;
// Submit the line to the executor service for processing
// The processing is done by the processLine method
futures.add(executor.submit(() -> processLine(line.split(" "))));
}
// Write the results to the output file
// The results are obtained by calling the get method on each Future
for (Future<String> future : futures) {
writer.write(future.get());
}
// Shutdown the executor service to free up resources
executor.shutdown();
} catch (Exception e) {
throw new RuntimeException("Error reading or writing to file", e);
}
}
private String processLine(String[] fields) {
// fields[0] = access point like "accessible", "extendable", "mutable"
// fields[1] = type like "field", "method", "class"
// fields[2] = class name
// fields[3] = field/method name
// fields[4] = field/method descriptor
try {
// Store the original field/method name
String originalName = "";
// If there is a class name, replace the slashes with dots in the package name
if (fields.length > 2) fields[2] = fields[2].replace("/", ".");
// If there is a field/method name, store the original name and remap it to SRG
if (fields.length > 3) {
originalName = fields[3];
fields[3] = remapToSRG(fields[2], fields[3]);
}
StringBuilder line = new StringBuilder(ACCESS_POINT_MAP.getOrDefault(fields[0], "public")).append(" ");
switch (fields[1]) {
case "field":
line.append(fields[2]).append(" ").append(fields[3]).append(" #").append(originalName);
// It'll be like: access-point class-name field-name-SRG # field-name-Mojmap
// Eg: public net.minecraft.client.Minecraft f_90981_ # instance
break;
case "method":
line.append(fields[2]).append(" ").append(fields[3]).append(fields[4]).append(" #").append(originalName);
// It'll be like: access-point class-name method-name-SRG method-descriptor # method-name-Mojmap
// Eg: public net.minecraft.client.Minecraft m_172797_()Lnet/minecraft/client/Minecraft; # getInstance
break;
default:
line.append(fields[2]);
// It'll be like: access-point class-name
// Eg: public net.minecraft.client.Minecraft
break;
}
line.append("\n");
return line.toString();
} catch (Exception e) {
throw new RuntimeException("Error processing line", e);
}
}
private boolean hashCheck(String line, String fileHash) {
if (line.startsWith("#DH_MAPPING_HASH:")) {
String hash = line.substring(17);
return hash.equals(fileHash);
}
return false;
}
public String getFileHash(File file) {
try {
MessageDigest shaDigest = MessageDigest.getInstance("SHA-256");
try (InputStream fis = new FileInputStream(file)) {
byte[] byteArray = new byte[1024];
int bytesCount;
// Read file data and update in message digest
while ((bytesCount = fis.read(byteArray)) != -1) {
shaDigest.update(byteArray, 0, bytesCount);
}
}
byte[] bytes = shaDigest.digest();
// Convert byte array into signum representation
StringBuilder sb = new StringBuilder();
for (byte aByte : bytes) {
sb.append(Integer.toString((aByte & 0xff) + 0x100, 16).substring(1));
}
// Return complete hash
return sb.toString();
} catch (NoSuchAlgorithmException | IOException e) {
throw new RuntimeException(e);
}
}
// WARNING: BELOW LIES HIGHLY CURSED CODE AND MIGHT EVEN BE ILLEGAL
// Flag to track if there was an error in the GET request
boolean error = false;
/**
* This method returns a field or method name from Mojang mappings as SRG mappings.
* It makes a GET request to the Linkie API to fetch the SRG name.
*
* @param clazz The class name
* @param name The field or method name
* @return The SRG name
* @throws Exception If there is an error in the GET request or the SRG name is not found in the response
*/
private String remapToSRG(String clazz, String name) throws Exception {
// Encode the class and field/method name to be used in the URL
String query = URLEncoder.encode(clazz + "." + name, StandardCharsets.UTF_8);
// Construct the URL for the GET request
String urlString = "https://linkieapi.shedaniel.me/api/search?namespace=mojang&query=" + query + "&version=" + this.minecraftVersion + "&limit=1&allowClasses=false&allowFields=true&allowMethods=true&translate=mojang_srg";
URL url = new URI(urlString).toURL();
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
int responseCode = conn.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String inputLine;
StringBuilder content = new StringBuilder();
// Read the response line by line
while ((inputLine = in.readLine()) != null) {
content.append(inputLine);
}
in.close();
conn.disconnect();
// Regex to find the SRG name in the response
Pattern pattern = Pattern.compile("\"l\"\\s*:\\s*\\{[^}]*\"i\"\\s*:\\s*\"([^\"]*)\"");
Matcher matcher = pattern.matcher(content.toString());
if (matcher.find()) return matcher.group(1);
else throw new Exception("Couldn't find the SRG mapping for name: " + name + "\nCould not find 'i' in 'l' object in the response"); // `i` is the SRG name which is stored in the `l` JSON object
} else {
if (error) {
// If there was an error in the GET request, and we already tried again, throw an exception
throw new Exception("The GET request failed");
}
// If there was an error in the GET request, wait 2.5 seconds and try again as we probably got rate limited
error = true;
Thread.sleep(2500);
return remapToSRG(clazz, name);
}
}
}
+211
View File
@@ -0,0 +1,211 @@
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
class NativeRelocator
{
private final Path rootDirectory;
private final Path cacheRoot;
/**
* Initializes the NativeRelocator by preparing the environment if necessary.
* Executes the appropriate preparation script based on the OS.
*/
NativeRelocator(Path rootDirectory)
{
this.rootDirectory = rootDirectory;
this.cacheRoot = this.rootDirectory.resolve("cache");
}
private void prepare() throws Exception
{
if (this.rootDirectory.resolve(".venv").toFile().exists())
{
return;
}
ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.directory(this.rootDirectory.toFile());
String os = System.getProperty("os.name").toLowerCase();
if (os.contains("win"))
{
processBuilder.command("powershell", "-ExecutionPolicy", "Bypass", "./prepare.ps1");
}
else if (os.contains("nix") || os.contains("nux") || os.contains("mac"))
{
processBuilder.command("./prepare.sh");
}
else
{
throw new IllegalStateException("Unsupported operating system: " + os);
}
Process process = processBuilder.start();
CompletableFuture<Void> outputFuture = readOutputStreams(process);
int exitCode = process.waitFor();
outputFuture.get();
if (exitCode != 0)
{
throw new Exception("Prepare failed: " + exitCode);
}
}
/**
* Reads and prints the output and error streams of a process asynchronously.
*
* @param process The process whose streams should be read.
* @return A CompletableFuture that completes once all output has been processed.
*/
private static CompletableFuture<Void> readOutputStreams(Process process)
{
return CompletableFuture.runAsync(() -> {
try
{
while (process.isAlive() || process.getInputStream().available() > 0 || process.getErrorStream().available() > 0)
{
if (process.getInputStream().available() > 0)
{
byte[] data = new byte[process.getInputStream().available()];
//noinspection ResultOfMethodCallIgnored
process.getInputStream().read(data);
System.out.write(data);
}
if (process.getErrorStream().available() > 0)
{
byte[] data = new byte[process.getErrorStream().available()];
//noinspection ResultOfMethodCallIgnored
process.getErrorStream().read(data);
System.err.write(data);
}
//noinspection BusyWait
Thread.sleep(100);
}
}
catch (Throwable ignored)
{
}
});
}
/**
* Replaces occurrences of a target string in a byte array, ensuring null termination.
*
* @param byteArray The byte array where replacements should occur.
* @param target The string to replace.
* @param replacement The replacement string (must not be longer than the target).
* @throws IllegalArgumentException if the replacement is longer than the target.
*/
private void replaceInNullTerminatedStrings(byte[] byteArray, String target, String replacement)
{
if (target.length() < replacement.length())
{
throw new IllegalArgumentException("Replacement must be the same length or shorter than the target.");
}
byte[] targetBytes = target.getBytes(StandardCharsets.US_ASCII);
byte[] replacementBytes = replacement.getBytes(StandardCharsets.US_ASCII);
byte nullByte = 0;
for (int endPos = 0; endPos < byteArray.length - targetBytes.length - 1; endPos++)
{
int startPos = endPos;
int targetPos = 0;
while (targetPos < targetBytes.length && byteArray[endPos] == targetBytes[targetPos])
{
targetPos++;
endPos++;
}
if (targetPos == targetBytes.length)
{
System.arraycopy(replacementBytes, 0, byteArray, startPos, replacementBytes.length);
startPos = startPos + replacementBytes.length;
while (byteArray[endPos] != nullByte)
{
byteArray[startPos] = byteArray[endPos];
endPos++;
startPos++;
}
byteArray[startPos] = nullByte;
}
}
}
/**
* Runs an external script to fix a modified binary and returns the processed content.
*
* @param outputFilePath Path to store the processed binary.
* @param content The original binary content.
* @return The modified binary content.
* @throws Exception if the process execution fails.
*/
public byte[] fixModifiedBinary(Path outputFilePath, byte[] content) throws Exception
{
ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.directory(this.rootDirectory.toFile());
processBuilder.command(
this.rootDirectory.resolve(".venv/Scripts").toFile().exists()
? this.rootDirectory.resolve(".venv/Scripts/python.exe").toString()
: this.rootDirectory.resolve(".venv/bin/python").toString(),
"./fix_modified_binary.py",
outputFilePath.toString()
);
Process process = processBuilder.start();
CompletableFuture<Void> outputFuture = readOutputStreams(process);
process.getOutputStream().write(content);
process.getOutputStream().close();
int exitCode = process.waitFor();
outputFuture.get();
if (exitCode != 0)
{
throw new Exception("Process failed: " + exitCode);
}
return Files.readAllBytes(outputFilePath);
}
/**
* Processes a binary file, applying string replacements and fixing modifications.
*
* @param outputPath The output file path relative to the cache directory.
* @param content The binary content to process.
* @param replacements A map of string replacements to apply.
* @return The modified binary content.
* @throws Exception if processing fails.
*/
public byte[] processBinary(String outputPath, byte[] content, Map<String, String> replacements) throws Exception
{
Path outputFilePath = this.cacheRoot.resolve(outputPath);
//noinspection ResultOfMethodCallIgnored
outputFilePath.getParent().toFile().mkdirs();
if (outputFilePath.toFile().exists())
{
return Files.readAllBytes(outputFilePath);
}
System.out.println("Relocating to " + outputPath + "...");
this.prepare();
for (Map.Entry<String, String> replacement : replacements.entrySet())
{
this.replaceInNullTerminatedStrings(content, replacement.getKey(), replacement.getValue());
}
return this.fixModifiedBinary(outputFilePath, content);
}
}
+13 -4
View File
@@ -1,3 +1,15 @@
// temporary fix for broken spongepowered version
buildscript {
configurations.configureEach {
resolutionStrategy {
force 'org.spongepowered:vanillagradle:0.2.1-20240507.024226-82'
// newer versions can be found by going to the link:
// https://repo.spongepowered.org/#browse/browse:maven-public:org%2Fspongepowered%2Fvanillagradle%2F0.2.1-SNAPSHOT
}
}
}
plugins { plugins {
id "org.spongepowered.gradle.vanilla" version "0.2.1-SNAPSHOT" id "org.spongepowered.gradle.vanilla" version "0.2.1-SNAPSHOT"
} }
@@ -8,10 +20,6 @@ minecraft {
} }
dependencies { dependencies {
// We depend on fabric loader here to use the fabric @Environment annotations and get the mixin dependencies
// Do NOT use other classes from fabric loader
// modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
// So mixins can be written in common // So mixins can be written in common
compileOnly group:'org.spongepowered', name:'mixin', version:'0.8.5' compileOnly group:'org.spongepowered', name:'mixin', version:'0.8.5'
} }
@@ -30,3 +38,4 @@ publishing {
// Add repositories to publish to here. // Add repositories to publish to here.
} }
} }
@@ -0,0 +1,299 @@
package com.seibel.distanthorizons.common;
import com.mojang.brigadier.CommandDispatcher;
import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiAfterDhInitEvent;
import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeDhInitEvent;
import com.seibel.distanthorizons.common.commands.CommandInitializer;
import com.seibel.distanthorizons.common.wrappers.DependencySetup;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftServerWrapper;
import com.seibel.distanthorizons.core.api.internal.ClientApi;
import com.seibel.distanthorizons.core.api.internal.SharedApi;
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.config.ConfigBase;
import com.seibel.distanthorizons.core.config.eventHandlers.presets.ThreadPresetConfigEventHandler;
import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector;
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.jar.ModJarInfo;
import com.seibel.distanthorizons.core.jar.updater.SelfUpdater;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor;
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModChecker;
import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector;
import com.seibel.distanthorizons.coreapi.ModInfo;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.dedicated.DedicatedServer;
import org.apache.logging.log4j.Logger;
import java.lang.invoke.MethodHandles;
import java.util.function.Consumer;
import java.util.function.Supplier;
/**
* Base for all mod loader initializers
* and handles most setup.
*/
public abstract class AbstractModInitializer
{
protected static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());
private CommandInitializer commandInitializer;
//==================//
// abstract methods //
//==================//
protected abstract void createInitialBindings();
protected abstract IEventProxy createClientProxy();
protected abstract IEventProxy createServerProxy(boolean isDedicated);
protected abstract void initializeModCompat();
protected abstract void subscribeRegisterCommandsEvent(Consumer<CommandDispatcher<CommandSourceStack>> eventHandler);
protected abstract void subscribeClientStartedEvent(Runnable eventHandler);
protected abstract void subscribeServerStartingEvent(Consumer<MinecraftServer> eventHandler);
protected abstract void runDelayedSetup();
//===================//
// initialize events //
//===================//
public void onInitializeClient()
{
DependencySetup.createClientBindings();
LOGGER.info("Initializing " + ModInfo.READABLE_NAME + " client, firing DhApiBeforeDhInitEvent...");
ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeDhInitEvent.class, null);
this.startup();
this.logBuildInfo();
this.createClientProxy().registerEvents();
this.createServerProxy(false).registerEvents();
this.initializeModCompat();
// Client uses config for auto-updater, so it's initialized here instead of post-init stage
this.initConfig();
logModIncompatibilityWarnings(); // needs to be called after config loading
LOGGER.info(ModInfo.READABLE_NAME + " client Initialized.");
this.subscribeClientStartedEvent(this::postInit);
}
public void onInitializeServer()
{
DependencySetup.createServerBindings();
LOGGER.info("Initializing " + ModInfo.READABLE_NAME + " server, firing DhApiBeforeDhInitEvent event...");
ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeDhInitEvent.class, null);
this.startup();
this.logBuildInfo();
// This prevents returning uninitialized Config values,
// resulting from a circular reference mid-initialization in a static class
// noinspection ResultOfMethodCallIgnored
ThreadPresetConfigEventHandler.INSTANCE.toString();
this.createServerProxy(true).registerEvents();
this.initializeModCompat();
LOGGER.info(ModInfo.READABLE_NAME + " server Initialized, adding event subscribers...");
this.subscribeRegisterCommandsEvent(dispatcher -> { this.commandInitializer = new CommandInitializer(dispatcher); });
this.subscribeServerStartingEvent(server ->
{
MinecraftServerWrapper.INSTANCE.dedicatedServer = (DedicatedServer)server;
this.initConfig();
this.postInit();
this.commandInitializer.initCommands();
this.checkForUpdates();
LOGGER.info(ModInfo.READABLE_NAME + " server Initialized at " + server.getServerDirectory());
});
}
//===========================//
// inner initializer methods //
//===========================//
private void startup()
{
DependencySetup.createSharedBindings();
SharedApi.init();
this.createInitialBindings();
}
private void logBuildInfo()
{
LOGGER.info(ModInfo.READABLE_NAME + ", Version: " + ModInfo.VERSION);
// if the build is stable the branch/commit/etc shouldn't be needed
if (ModInfo.IS_DEV_BUILD)
{
LOGGER.info("DH Branch: " + ModJarInfo.Git_Branch);
LOGGER.info("DH Commit: " + ModJarInfo.Git_Commit);
LOGGER.info("DH Jar Build Source: " + ModJarInfo.Build_Source);
}
}
protected <T extends IModAccessor> void tryCreateModCompatAccessor(String modId, Class<? super T> accessorClass, Supplier<T> accessorConstructor)
{
IModChecker modChecker = SingletonInjector.INSTANCE.get(IModChecker.class);
if (modChecker.isModLoaded(modId))
{
//noinspection unchecked
ModAccessorInjector.INSTANCE.bind((Class<? extends IModAccessor>) accessorClass, accessorConstructor.get());
}
}
private void initConfig()
{
ConfigBase.INSTANCE = new ConfigBase(ModInfo.ID, ModInfo.NAME, Config.class, ModInfo.CONFIG_FILE_VERSION);
Config.completeDelayedSetup();
}
private void checkForUpdates()
{
if (Config.Client.Advanced.AutoUpdater.enableAutoUpdater.get())
{
if (Config.Client.Advanced.AutoUpdater.enableSilentUpdates.get())
{
LOGGER.info("Silent updates are not allowed for dedicated servers; force disabling.");
Config.Client.Advanced.AutoUpdater.enableSilentUpdates.set(false);
}
SelfUpdater.onStart();
}
}
private void postInit()
{
LOGGER.info("Running Delayed setup...");
this.runDelayedSetup();
LOGGER.info("Delayed setup complete, firing DhApiAfterDhInitEvent event...");
// should be fired after all delayed setup so singletons and config can be accessed
ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterDhInitEvent.class, null);
}
//==================================//
// mod partial compatibility checks //
//==================================//
/**
* Some mods will work with a few tweaks
* or will partially work but have some known issues we can't solve.
* This method will log (and display to chat if enabled)
* these warnings and potential fixes.
*/
private static void logModIncompatibilityWarnings()
{
boolean showChatWarnings = Config.Common.Logging.Warning.showModCompatibilityWarningsOnStartup.get();
IModChecker modChecker = SingletonInjector.INSTANCE.get(IModChecker.class);
String startingString = "Partially Incompatible Distant Horizons mod detected: ";
// Alex's caves
if (modChecker.isModLoaded("alexscaves"))
{
// There've been a few reports about this mod breaking DH at a few different points in time
// the fixes for said breakage changes depending on the version so unfortunately
// all we can do is log a warning so the user can handle it.
if (showChatWarnings)
{
String message =
// orange text
"\u00A76" + "Distant Horizons: Alex's Cave detected." + "\u00A7r\n" +
"You may have to change Alex's config for DH to render. ";
ClientApi.INSTANCE.showChatMessageNextFrame(message);
}
LOGGER.warn(startingString + "[Alex's Caves] may require some config changes in order to render Distant Horizons correctly.");
}
// William Wythers' Overhauled Overworld (WWOO)
if (modChecker.isModLoaded("wwoo"))
{
// WWOO has a bug with it's world gen that can't be fixed by DH or WWOO
// (at least that is what James learned after talking with WWOO)
// WWOO will cause grid lines to appear in the world when DH generates the chunks
// this might be due to how WWOO uses features for everything when generating
// and said features don't always get to the edge of said chunks.
String wwooWarning = "LODs generated by DH may have grid lines between sections. Disabling either WWOO or DH's distant generator will fix the problem.";
if (showChatWarnings)
{
String message =
// orange text
"\u00A76" + "Distant Horizons: WWOO detected." + "\u00A7r\n" +
wwooWarning;
ClientApi.INSTANCE.showChatMessageNextFrame(message);
}
LOGGER.warn(startingString + "[WWOO] "+ wwooWarning);
}
// Chunky
boolean chunkyPresent = false;
try
{
Class.forName("org.popcraft.chunky.api.ChunkyAPI");
chunkyPresent = true;
}
catch (ClassNotFoundException ignore) { }
if (chunkyPresent)
{
// Chunky can generate chunks faster than DH can process them,
// causing holes in the LODs.
// Generally it's better and faster to use DH's world generator.
String chunkyWarning = "Chunky can cause DH LODs to have holes " +
"since Chunky can generate chunks faster than DH can process them. \n" +
"Using DH's distant generator instead of chunky or increasing DH's CPU thread count can resolve the issue.";
if (showChatWarnings)
{
String message =
// orange text
"\u00A76" + "Distant Horizons: Chunky detected." + "\u00A7r\n" +
chunkyWarning;
ClientApi.INSTANCE.showChatMessageNextFrame(message);
}
LOGGER.warn(startingString + "[Chunky] "+ chunkyWarning);
}
}
//================//
// helper classes //
//================//
public interface IEventProxy
{
void registerEvents();
}
}
@@ -0,0 +1,131 @@
package com.seibel.distanthorizons.common;
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.logging.ConfigBasedLogger;
import com.seibel.distanthorizons.core.network.event.internal.IncompatibleMessageInternalEvent;
import com.seibel.distanthorizons.core.network.event.internal.ProtocolErrorInternalEvent;
import com.seibel.distanthorizons.core.network.messages.MessageRegistry;
import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
import com.seibel.distanthorizons.core.network.messages.base.CloseReasonMessage;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IPluginPacketSender;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
import com.seibel.distanthorizons.coreapi.ModInfo;
import io.netty.buffer.ByteBufUtil;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.level.ServerPlayer;
import org.apache.logging.log4j.LogManager;
import java.io.IOException;
import java.util.Objects;
public abstract class AbstractPluginPacketSender implements IPluginPacketSender
{
private static final ConfigBasedLogger LOGGER = new ConfigBasedLogger(LogManager.getLogger(),
() -> Config.Common.Logging.logNetworkEvent.get());
#if MC_VER >= MC_1_21_1
public static final ResourceLocation WRAPPER_PACKET_RESOURCE = ResourceLocation.fromNamespaceAndPath(ModInfo.RESOURCE_NAMESPACE, ModInfo.WRAPPER_PACKET_PATH);
#else
public static final ResourceLocation WRAPPER_PACKET_RESOURCE = new ResourceLocation(ModInfo.RESOURCE_NAMESPACE, ModInfo.WRAPPER_PACKET_PATH);
#endif
// "Forge byte" is an unused packet ID. We have our own system which works with all mod loaders,
// so we're just accounting for it by reading the protocol version as a byte instead of a short in Forge, to keep cross-loader compatibility
private final boolean forgeByteInProtocolVersion;
public AbstractPluginPacketSender() { this(false); }
public AbstractPluginPacketSender(boolean forgeByteInProtocolVersion)
{
this.forgeByteInProtocolVersion = forgeByteInProtocolVersion;
}
@Override
public final void sendToClient(IServerPlayerWrapper serverPlayer, AbstractNetworkMessage message)
{
this.sendToClient((ServerPlayer) serverPlayer.getWrappedMcObject(), message);
}
public abstract void sendToClient(ServerPlayer serverPlayer, AbstractNetworkMessage message);
@Override
public abstract void sendToServer(AbstractNetworkMessage message);
public AbstractNetworkMessage decodeMessage(FriendlyByteBuf in)
{
AbstractNetworkMessage message = null;
try
{
in.markReaderIndex();
int protocolVersion = this.forgeByteInProtocolVersion ? in.readByte() : in.readShort();
if (protocolVersion != ModInfo.PROTOCOL_VERSION)
{
return new IncompatibleMessageInternalEvent(protocolVersion);
}
message = MessageRegistry.INSTANCE.createMessage(in.readUnsignedShort());
message.decode(in);
if (in.isReadable())
{
throw new IOException("Buffer has not been fully read");
}
return message;
}
catch (Exception e)
{
in.resetReaderIndex();
LOGGER.error("Failed to decode message", e);
LOGGER.error("Buffer: ["+in+"]");
LOGGER.error("Buffer contents: ["+ByteBufUtil.hexDump(in)+"]");
return new ProtocolErrorInternalEvent(e, message, true);
}
finally
{
// Prevent connection crashing if not entire buffer has been read
in.readerIndex(in.writerIndex());
}
}
public void encodeMessage(FriendlyByteBuf out, AbstractNetworkMessage message)
{
// This is intentionally unhandled, because errors related to this are unlikely to appear in wild
Objects.requireNonNull(message);
if (this.forgeByteInProtocolVersion)
{
out.writeByte(ModInfo.PROTOCOL_VERSION);
}
else
{
out.writeShort(ModInfo.PROTOCOL_VERSION);
}
try
{
out.markWriterIndex();
out.writeShort(MessageRegistry.INSTANCE.getMessageId(message));
message.encode(out);
}
catch (Exception e)
{
LOGGER.error("Failed to encode message", e);
LOGGER.error("Message: ["+message+"]");
message.getSession().tryHandleMessage(new ProtocolErrorInternalEvent(e, message, false));
// Encode close reason message instead
out.resetWriterIndex();
message = new CloseReasonMessage("Internal error on other side");
out.writeShort(MessageRegistry.INSTANCE.getMessageId(message));
message.encode(out);
}
}
}
@@ -0,0 +1,39 @@
package com.seibel.distanthorizons.common;
#if MC_VER >= MC_1_20_6
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.network.messages.AbstractNetworkMessage;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IPluginPacketSender;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public record CommonPacketPayload(@Nullable AbstractNetworkMessage message) implements CustomPacketPayload
{
public static final Type<CommonPacketPayload> TYPE = new Type<>(AbstractPluginPacketSender.WRAPPER_PACKET_RESOURCE);
private static final AbstractPluginPacketSender PACKET_SENDER = (AbstractPluginPacketSender) SingletonInjector.INSTANCE.get(IPluginPacketSender.class);
@NotNull
@Override
public Type<? extends CustomPacketPayload> type() { return TYPE; }
public static class Codec implements StreamCodec<FriendlyByteBuf, CommonPacketPayload>
{
@NotNull
@Override
public CommonPacketPayload decode(@NotNull FriendlyByteBuf in)
{ return new CommonPacketPayload(PACKET_SENDER.decodeMessage(in)); }
@Override
public void encode(@NotNull FriendlyByteBuf out, CommonPacketPayload payload)
{ PACKET_SENDER.encodeMessage(out, payload.message()); }
}
}
#endif
@@ -1,64 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common;
import com.seibel.distanthorizons.common.forge.LodForgeMethodCaller;
import com.seibel.distanthorizons.common.wrappers.DependencySetup;
import com.seibel.distanthorizons.coreapi.ModInfo;
import com.seibel.distanthorizons.core.api.internal.SharedApi;
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.config.ConfigBase;
/**
* This is the common main class
*
* @author Ran
*/
public class LodCommonMain
{
public static boolean forge = false;
public static LodForgeMethodCaller forgeMethodCaller;
public static void startup(LodForgeMethodCaller forgeMethodCaller)
{
if (forgeMethodCaller != null)
{
LodCommonMain.forge = true;
LodCommonMain.forgeMethodCaller = forgeMethodCaller;
}
DependencySetup.createSharedBindings();
SharedApi.init();
// if (!serverSided) {
// new NetworkReceiver().register_Client();
// } else {
// new NetworkReceiver().register_Server();
// }
}
public static void initConfig()
{
ConfigBase.INSTANCE = new ConfigBase(ModInfo.ID, ModInfo.NAME, Config.class, 2);
Config.completeDelayedSetup();
}
}
@@ -0,0 +1,102 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.seibel.distanthorizons.common.wrappers.misc.ServerPlayerWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
import net.minecraft.commands.CommandSourceStack;
#if MC_VER >= MC_1_19_2
import net.minecraft.network.chat.Component;
import java.util.Objects;
#else // < 1.19.2
import net.minecraft.network.chat.TranslatableComponent;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
#endif
/**
* Abstract class providing common functionality for DH's commands.
*/
public abstract class AbstractCommand
{
public abstract LiteralArgumentBuilder<CommandSourceStack> buildCommand();
/**
* Sends a success response to the player with the given text.
*
* @param commandContext The command context to send the response to.
* @param text The text to display in the success message.
* @return 1, indicating that the command was successful.
*/
protected int sendSuccessResponse(CommandContext<CommandSourceStack> commandContext, String text, boolean notifyAdmins)
{
#if MC_VER >= MC_1_20_1
commandContext.getSource().sendSuccess(() -> Component.literal(text), notifyAdmins);
#elif MC_VER >= MC_1_19_2
commandContext.getSource().sendSuccess(Component.literal(text), notifyAdmins);
#else
commandContext.getSource().sendSuccess(new TranslatableComponent(text), notifyAdmins);
#endif
return 1;
}
/**
* Sends a failure response to the player with the given text.
*
* @param commandContext The command context to send the response to.
* @param text The text to display in the failure message.
* @return 1, indicating that the command was successful.
*/
protected int sendFailureResponse(CommandContext<CommandSourceStack> commandContext, String text)
{
#if MC_VER >= MC_1_20_1
commandContext.getSource().sendFailure(Component.literal(text));
#elif MC_VER >= MC_1_19_2
commandContext.getSource().sendFailure(Component.literal(text));
#else
commandContext.getSource().sendFailure(new TranslatableComponent(text));
#endif
return 1;
}
/**
* Gets the server player from a command context.
*
* @param commandContext The command context to get the server player from.
* @return The server player wrapper for the player who sent the command.
*/
protected IServerPlayerWrapper getSourcePlayer(CommandContext<CommandSourceStack> commandContext) #if MC_VER < MC_1_19_2 throws CommandSyntaxException #endif
{
#if MC_VER >= MC_1_19_2
return ServerPlayerWrapper.getWrapper(Objects.requireNonNull(commandContext.getSource().getPlayer()));
#else
return ServerPlayerWrapper.getWrapper(commandContext.getSource().getPlayerOrException());
#endif
}
/**
* Checks if the source of a command is a player.
*
* @param source The source of the command to check.
* @return True if the source is a player, false otherwise.
*/
protected boolean isPlayerSource(CommandSourceStack source)
{
#if MC_VER >= MC_1_19_2
return source.isPlayer();
#else
try
{
source.getPlayerOrException();
return true;
}
catch (CommandSyntaxException e)
{
return false;
}
#endif
}
}
@@ -0,0 +1,49 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import net.minecraft.commands.CommandSourceStack;
import static com.seibel.distanthorizons.core.network.messages.MessageRegistry.DEBUG_CODEC_CRASH_MESSAGE;
import static net.minecraft.commands.Commands.literal;
/**
* Initializes commands of the mod.
*/
public class CommandInitializer
{
private final CommandDispatcher<CommandSourceStack> commandDispatcher;
/**
* Constructs a new instance of this class.
*
* @param commandDispatcher The dispatcher to use for registering commands.
*/
public CommandInitializer(CommandDispatcher<CommandSourceStack> commandDispatcher)
{
this.commandDispatcher = commandDispatcher;
}
/**
* Initializes all available commands.
*/
public void initCommands()
{
LiteralArgumentBuilder<CommandSourceStack> builder = literal("dh")
.requires(source -> source.hasPermission(4));
builder.then(new ConfigCommand().buildCommand());
builder.then(new DebugCommand().buildCommand());
builder.then(new PregenCommand().buildCommand());
if (DEBUG_CODEC_CRASH_MESSAGE)
{
builder.then(new CrashCommand().buildCommand());
}
this.commandDispatcher.register(builder);
}
}
@@ -0,0 +1,154 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.arguments.*;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.seibel.distanthorizons.core.config.ConfigBase;
import com.seibel.distanthorizons.core.config.types.AbstractConfigType;
import com.seibel.distanthorizons.core.config.types.ConfigEntry;
import net.minecraft.commands.CommandSourceStack;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntBiFunction;
import static com.mojang.brigadier.arguments.DoubleArgumentType.doubleArg;
import static com.mojang.brigadier.arguments.IntegerArgumentType.integer;
import static net.minecraft.commands.Commands.argument;
import static net.minecraft.commands.Commands.literal;
/**
* Command for managing config.
*/
public class ConfigCommand extends AbstractCommand
{
private static final List<CommandArgumentData<?>> commandArguments = Arrays.asList(
new CommandArgumentData<>(Integer.class, configEntry -> integer(configEntry.getMin(), configEntry.getMax()), IntegerArgumentType::getInteger),
new CommandArgumentData<>(Double.class, configEntry -> doubleArg(configEntry.getMin(), configEntry.getMax()), DoubleArgumentType::getDouble),
new CommandArgumentData<>(Boolean.class, BoolArgumentType::bool, BoolArgumentType::getBool),
new CommandArgumentData<>(String.class, StringArgumentType::string, StringArgumentType::getString)
);
/**
* Builds a command tree.
*/
@Override
@SuppressWarnings({"rawtypes", "unchecked"})
public LiteralArgumentBuilder<CommandSourceStack> buildCommand()
{
LiteralArgumentBuilder<CommandSourceStack> builder = literal("config");
HashSet<String> addedCommands = new HashSet<>();
for (AbstractConfigType<?, ?> type : ConfigBase.INSTANCE.entries)
{
// Skip non-config entries
if (!(type instanceof ConfigEntry))
{
continue;
}
//noinspection PatternVariableCanBeUsed
ConfigEntry configEntry = (ConfigEntry) type;
if (configEntry.getChatCommandName() == null)
{
continue;
}
if (!addedCommands.add(configEntry.getChatCommandName()))
{
throw new IllegalStateException("Duplicate command name: " + configEntry.getChatCommandName());
}
LiteralArgumentBuilder<CommandSourceStack> subcommand = literal(configEntry.getChatCommandName())
.executes(commandContext -> this.sendSuccessResponse(commandContext,
"\n" +
"Description of §l" + configEntry.getChatCommandName() + "§r:\n" +
"§o" + configEntry.getComment().trim() + "§r\n" +
"§7Config file name: §f" + configEntry.name + "§7, category: §f" + configEntry.category + "\n" +
"\n" +
"Current value of " + configEntry.getChatCommandName() + " is §n" + configEntry.get() + "§r",
false
));
ToIntBiFunction<CommandContext<CommandSourceStack>, Object> updateConfigValue = (commandContext, value) -> {
configEntry.set(value);
return this.sendSuccessResponse(commandContext, "Changed the value of [" + configEntry.getChatCommandName() + "] to [" + value + "]", true);
};
// Enum type needs a special case since enums aren't represented by existing argument type
// and need literals for each individual value
if (Enum.class.isAssignableFrom(configEntry.getType()))
{
for (Object choice : configEntry.getType().getEnumConstants())
{
subcommand.then(
literal(choice.toString())
.executes(c -> updateConfigValue.applyAsInt(c, choice))
);
}
}
else
{
boolean setterAdded = false;
for (CommandArgumentData<?> commandArgumentData : commandArguments)
{
if (!commandArgumentData.argumentClass.isAssignableFrom(configEntry.getType()))
{
continue;
}
subcommand.then(argument("value", commandArgumentData.getArgumentType(configEntry))
.executes(c -> updateConfigValue.applyAsInt(c, commandArgumentData.getValue(c, "value"))));
setterAdded = true;
break;
}
if (!setterAdded)
{
throw new RuntimeException("Config type of " + type.getName() + " is not supported: " + configEntry.getType().getSimpleName());
}
}
builder.then(subcommand);
}
return builder;
}
private static class CommandArgumentData<T>
{
public final Class<T> argumentClass;
public final Function<ConfigEntry<T>, ArgumentType<T>> argumentTypeFunction;
private final BiFunction<CommandContext<CommandSourceStack>, String, T> valueGetter;
public CommandArgumentData(Class<T> argumentClass, Supplier<ArgumentType<T>> argumentTypeSupplier, BiFunction<CommandContext<CommandSourceStack>, String, T> valueGetter)
{
this(argumentClass, configEntry -> argumentTypeSupplier.get(), valueGetter);
}
public CommandArgumentData(Class<T> argumentClass, Function<ConfigEntry<T>, ArgumentType<T>> argumentTypeFunction, BiFunction<CommandContext<CommandSourceStack>, String, T> valueGetter)
{
this.argumentClass = argumentClass;
this.argumentTypeFunction = argumentTypeFunction;
this.valueGetter = valueGetter;
}
public ArgumentType<T> getArgumentType(ConfigEntry<T> configEntry)
{
return this.argumentTypeFunction.apply(configEntry);
}
public T getValue(CommandContext<CommandSourceStack> commandContext, String argumentName)
{
return this.valueGetter.apply(commandContext, argumentName);
}
}
}
@@ -0,0 +1,44 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.seibel.distanthorizons.core.api.internal.SharedApi;
import com.seibel.distanthorizons.core.multiplayer.server.ServerPlayerState;
import com.seibel.distanthorizons.core.network.messages.base.CodecCrashMessage;
import net.minecraft.commands.CommandSourceStack;
import static net.minecraft.commands.Commands.literal;
public class CrashCommand extends AbstractCommand
{
@Override
public LiteralArgumentBuilder<CommandSourceStack> buildCommand()
{
return literal("crash")
.requires(this::isPlayerSource)
.then(literal("encode")
.executes(c -> {
assert SharedApi.getIDhServerWorld() != null;
ServerPlayerState serverPlayerState = SharedApi.getIDhServerWorld().getServerPlayerStateManager()
.getConnectedPlayer(this.getSourcePlayer(c));
if (serverPlayerState != null)
{
serverPlayerState.networkSession.sendMessage(new CodecCrashMessage(CodecCrashMessage.ECrashPhase.ENCODE));
}
return 1;
}))
.then(literal("decode")
.executes(c -> {
assert SharedApi.getIDhServerWorld() != null;
ServerPlayerState serverPlayerState = SharedApi.getIDhServerWorld().getServerPlayerStateManager()
.getConnectedPlayer(this.getSourcePlayer(c));
if (serverPlayerState != null)
{
serverPlayerState.networkSession.sendMessage(new CodecCrashMessage(CodecCrashMessage.ECrashPhase.DECODE));
}
return 1;
}));
}
}
@@ -0,0 +1,25 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.seibel.distanthorizons.core.logging.f3.F3Screen;
import net.minecraft.commands.CommandSourceStack;
import java.util.ArrayList;
import java.util.List;
import static net.minecraft.commands.Commands.literal;
public class DebugCommand extends AbstractCommand
{
@Override
public LiteralArgumentBuilder<CommandSourceStack> buildCommand()
{
return literal("debug")
.executes(c -> {
List<String> lines = new ArrayList<>();
F3Screen.addStringToDisplay(lines);
return this.sendSuccessResponse(c, String.join("\n", lines), false);
});
}
}
@@ -0,0 +1,107 @@
package com.seibel.distanthorizons.common.commands;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.core.generation.PregenManager;
import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos2D;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.arguments.DimensionArgument;
import net.minecraft.commands.arguments.coordinates.ColumnPosArgument;
import net.minecraft.server.level.ColumnPos;
import net.minecraft.server.level.ServerLevel;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
import static com.mojang.brigadier.arguments.IntegerArgumentType.getInteger;
import static com.mojang.brigadier.arguments.IntegerArgumentType.integer;
import static net.minecraft.commands.Commands.argument;
import static net.minecraft.commands.Commands.literal;
public class PregenCommand extends AbstractCommand
{
private final PregenManager pregenManager = new PregenManager();
@Override
public LiteralArgumentBuilder<CommandSourceStack> buildCommand()
{
LiteralArgumentBuilder<CommandSourceStack> statusCommand = literal("status")
.executes(this::pregenStatus);
LiteralArgumentBuilder<CommandSourceStack> startCommand = literal("start")
.then(argument("dimension", DimensionArgument.dimension())
.then(argument("origin", ColumnPosArgument.columnPos())
.then(argument("chunkRadius", integer(32))
.executes(this::pregenStart))));
LiteralArgumentBuilder<CommandSourceStack> stopCommand = literal("stop")
.executes(this::pregenStop);
return literal("pregen")
.then(statusCommand)
.then(startCommand)
.then(stopCommand);
}
private int pregenStatus(CommandContext<CommandSourceStack> c)
{
String statusString = this.pregenManager.getStatusString();
//noinspection ReplaceNullCheck
if (statusString != null)
{
return this.sendSuccessResponse(c, statusString, false);
}
else
{
return this.sendSuccessResponse(c, "Pregen is not running", false);
}
}
private int pregenStart(CommandContext<CommandSourceStack> c) throws CommandSyntaxException
{
this.sendSuccessResponse(c, "Starting pregen. Progress will be in the server console.", true);
ServerLevel level = DimensionArgument.getDimension(c, "dimension");
ColumnPos origin = ColumnPosArgument.getColumnPos(c, "origin");
int chunkRadius = getInteger(c, "chunkRadius");
CompletableFuture<Void> future = this.pregenManager.startPregen(
ServerLevelWrapper.getWrapper(level),
new DhBlockPos2D(#if MC_VER >= MC_1_19_2 origin.x(), origin.z() #else origin.x, origin.z #endif),
chunkRadius
);
future.whenComplete((result, throwable) -> {
if (throwable instanceof CancellationException)
{
this.sendSuccessResponse(c, "Pregen is cancelled", true);
return;
}
else if (throwable != null)
{
this.sendFailureResponse(c, "Pregen failed: " + throwable.getMessage() + "\n Check the logs for more details.");
return;
}
this.sendSuccessResponse(c, "Pregen is complete", true);
});
return 1;
}
private int pregenStop(CommandContext<CommandSourceStack> c)
{
CompletableFuture<Void> runningPregen = this.pregenManager.getRunningPregen();
if (runningPregen == null)
{
return this.sendFailureResponse(c, "Pregen is not running");
}
runningPregen.cancel(true);
return 1;
}
}
@@ -0,0 +1,85 @@
package com.seibel.distanthorizons.common.commonMixins;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.core.api.internal.ServerApi;
import com.seibel.distanthorizons.core.api.internal.SharedApi;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.chunk.ChunkAccess;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
public class MixinChunkMapCommon
{
public static void onChunkSave(ServerLevel level, ChunkAccess chunk, CallbackInfoReturnable<Boolean> ci)
{
// is this position already being updated?
if (SharedApi.isChunkAtChunkPosAlreadyUpdating(chunk.getPos().x, chunk.getPos().z))
{
return;
}
// is this chunk being saved to disk?
boolean savingChunkToDisk = ci.getReturnValue();
// true means a chunk was saved to disk
if (!savingChunkToDisk)
{
return;
}
// TODO are the following validations necessary since we are checking above if
// the callback return value should state if the chunk was actually saved or not?
// Do we trust it to always be correct?
// corrupt/incomplete chunk validation //
// MC has a tendency to try saving incomplete or corrupted chunks (which show up as empty or black chunks)
// this logic should prevent that from happening
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
if (chunk.isUnsaved() || chunk.getUpgradeData() != null || !chunk.isLightCorrect())
{
return;
}
#else
if (chunk.isUnsaved() || chunk.isUpgrading() || !chunk.isLightCorrect())
{
return;
}
#endif
// biome validation //
// some chunks may be missing their biomes, which cause issues when attempting to save them
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
if (chunk.getBiomes() == null)
{
return;
}
#else
try
{
// this will throw an exception if the biomes aren't set up
chunk.getNoiseBiome(0,0,0);
}
catch (Exception e)
{
return;
}
#endif
// submit the update event
ServerApi.INSTANCE.serverChunkSaveEvent(
new ChunkWrapper(chunk, ServerLevelWrapper.getWrapper(level)),
ServerLevelWrapper.getWrapper(level)
);
}
}
@@ -1,52 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.forge;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftClientWrapper;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.core.Direction;
#if POST_MC_1_19_2
import net.minecraft.util.RandomSource;
#endif
import net.minecraft.world.level.ColorResolver;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.state.BlockState;
import java.util.List;
import java.util.Random;
/**
* used for calling methods that forge modified
* (forge modifies vanilla methods for some reason)
*
* @author Ran
*/
public interface LodForgeMethodCaller
{
#if PRE_MC_1_19_2
List<BakedQuad> getQuads(MinecraftClientWrapper mc, Block block, BlockState blockState, Direction direction, Random random); // FIXME: For 1.19
#else
List<BakedQuad> getQuads(MinecraftClientWrapper mc, Block block, BlockState blockState, Direction direction, RandomSource random); // FIXME: For 1.19
#endif
int colorResolverGetColor(ColorResolver resolver, Biome biome, double x, double z);
}
@@ -1,96 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.rendering;
#if PRE_MC_1_19_4
import com.mojang.math.Matrix4f;
#else
import org.joml.Matrix4f;
#endif
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.util.RenderUtil;
import com.seibel.distanthorizons.coreapi.util.math.Mat4f;
import org.lwjgl.opengl.GL15;
import java.nio.FloatBuffer;
public class SeamlessOverdraw
{
/**
* Proof-of-concept experimental option, not intended for normal use. <br>
* (Poorly) replaces Minecraft's far clip plane so it lines up with DH's near clip plane.
*/
public static float[] overwriteMinecraftNearFarClipPlanes(Matrix4f minecraftProjectionMatrix, float previousPartialTicks)
{
float[] matrixFloatArray;
#if PRE_MC_1_19_4
FloatBuffer matrixFloatBuffer = FloatBuffer.allocate(16);
minecraftProjectionMatrix.store(matrixFloatBuffer);
matrixFloatArray = matrixFloatBuffer.array();
#else
// Passing float buffers in caused native code crashes, so we are passing in a float array instead
matrixFloatArray = new float[16];
minecraftProjectionMatrix.get(matrixFloatArray);
#endif
return overwriteMinecraftNearFarClipPlanes(matrixFloatArray, previousPartialTicks);
}
public static float[] overwriteMinecraftNearFarClipPlanes(Mat4f minecraftProjectionMatrix, float previousPartialTicks)
{
return overwriteMinecraftNearFarClipPlanes(minecraftProjectionMatrix.getValuesAsArray(), previousPartialTicks);
}
private static float[] overwriteMinecraftNearFarClipPlanes(float[] projectionMatrixFloatArray, float previousPartialTicks)
{
float dhFarClipPlane = RenderUtil.getNearClipPlaneDistanceInBlocks(previousPartialTicks);
// works for fabric, bad not for forge for some reason :/
float farClip = dhFarClipPlane * 5.1f; // magic number found via trial and error, James has no idea what it represents, except that it makes the seam between DH and vanilla rendering pretty close
float nearClip = 0.5f; // this causes issues with some vanilla rendering, specifically the wireframe around selected blocks is slightly off. Unfortunately the ratio between the near and far clip plane can't be easily modified without completely screwing up the rendering.
// these may be the wrong index locations in any version of MC other than 1.18.2
projectionMatrixFloatArray[10] = -((farClip + nearClip) / (farClip - nearClip)); // near clip plane
projectionMatrixFloatArray[11] = -((2 * farClip * nearClip) / (farClip - nearClip)); // far clip plane
return projectionMatrixFloatArray;
}
//================//
// helper methods //
//================//
public static void applyLegacyProjectionMatrix(float[] projectionMatrixFloatArray)
{
int glMatrixMode = GL15.glGetInteger(GL15.GL_MATRIX_MODE);
GL15.glMatrixMode(GL15.GL_PROJECTION);
GL15.glLoadMatrixf(projectionMatrixFloatArray);
GL15.glMatrixMode(glMatrixMode);
}
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -22,7 +22,8 @@ package com.seibel.distanthorizons.common.wrappers;
import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI;
import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper;
import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftDedicatedServerWrapper; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftServerWrapper;
import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
import com.seibel.distanthorizons.core.wrapperInterfaces.config.IConfigGui; import com.seibel.distanthorizons.core.wrapperInterfaces.config.IConfigGui;
import com.seibel.distanthorizons.core.wrapperInterfaces.config.ILangWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.config.ILangWrapper;
@@ -32,6 +33,7 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants;
import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
@@ -60,7 +62,7 @@ public class DependencySetup
//@Environment(EnvType.SERVER) //@Environment(EnvType.SERVER)
public static void createServerBindings() public static void createServerBindings()
{ {
SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftDedicatedServerWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftServerWrapper.INSTANCE);
} }
//@Environment(EnvType.CLIENT) //@Environment(EnvType.CLIENT)
@@ -69,6 +71,7 @@ public class DependencySetup
SingletonInjector.INSTANCE.bind(IMinecraftClientWrapper.class, MinecraftClientWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftClientWrapper.class, MinecraftClientWrapper.INSTANCE);
SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftClientWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftClientWrapper.INSTANCE);
SingletonInjector.INSTANCE.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE);
SingletonInjector.INSTANCE.bind(IMinecraftGLWrapper.class, MinecraftGLWrapper.INSTANCE);
SingletonInjector.INSTANCE.bind(IConfigGui.class, ClassicConfigGUI.CONFIG_CORE_INTERFACE); SingletonInjector.INSTANCE.bind(IConfigGui.class, ClassicConfigGUI.CONFIG_CORE_INTERFACE);
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -25,7 +25,12 @@ public class DependencySetupDoneCheck
{ {
// TODO move to DependencySetup // TODO move to DependencySetup
public static boolean isDone = false; public static boolean isDone = false;
// TODO why is this here and what is its purpose? /**
* This is used so we can override some MC logic when running
* in DH's world generator.
* Specifically so we can redirect threads to run on DH threads instead
* of MC threads.
*/
public static Supplier<Boolean> getIsCurrentThreadDistantGeneratorThread = (() -> { return false; }); public static Supplier<Boolean> getIsCurrentThreadDistantGeneratorThread = (() -> { return false; });
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -20,19 +20,11 @@
package com.seibel.distanthorizons.common.wrappers; package com.seibel.distanthorizons.common.wrappers;
import java.nio.FloatBuffer; import java.nio.FloatBuffer;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
#if PRE_MC_1_19_4
import com.mojang.math.Matrix4f;
#else
import org.joml.Matrix4f;
#endif
import com.seibel.distanthorizons.core.enums.EDhDirection; import com.seibel.distanthorizons.core.enums.EDhDirection;
import com.seibel.distanthorizons.core.pos.DhBlockPos; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.coreapi.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Mat4f;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction; import net.minecraft.core.Direction;
@@ -51,10 +43,35 @@ public class McObjectConverter
{ {
return y * 4 + x; return y * 4 + x;
} }
/** Taken from Minecraft's com.mojang.math.Matrix4f class from 1.18.2 */
private static void storeMatrix(Matrix4f matrix, FloatBuffer buffer)
/** 4x4 float matrix converter */
@Deprecated
public static Mat4f Convert(
#if MC_VER < MC_1_19_4 com.mojang.math.Matrix4f
#elif MC_VER < MC_1_21_6 org.joml.Matrix4f
#else org.joml.Matrix4fc
#endif
mcMatrix)
{ {
#if PRE_MC_1_19_4 FloatBuffer buffer = FloatBuffer.allocate(16);
storeMatrix(mcMatrix, buffer);
Mat4f matrix = new Mat4f(buffer);
#if MC_VER < MC_1_19_4
matrix.transpose(); // In 1.19.3 and later, we no longer need to transpose it
#endif
return matrix;
}
/** Taken from Minecraft's com.mojang.math.Matrix4f class from 1.18.2 */
private static void storeMatrix(
#if MC_VER < MC_1_19_4 com.mojang.math.Matrix4f
#elif MC_VER < MC_1_21_6 org.joml.Matrix4f
#else org.joml.Matrix4fc
#endif
matrix,
FloatBuffer buffer)
{
#if MC_VER < MC_1_19_4
matrix.store(buffer); matrix.store(buffer);
#else #else
// Mojang starts to use joml's Matrix4f libary in 1.19.3 so we copy their store method and use it here if its newer than 1.19.3 // Mojang starts to use joml's Matrix4f libary in 1.19.3 so we copy their store method and use it here if its newer than 1.19.3
@@ -77,18 +94,6 @@ public class McObjectConverter
#endif #endif
} }
/** 4x4 float matrix converter */
public static Mat4f Convert(Matrix4f mcMatrix)
{
FloatBuffer buffer = FloatBuffer.allocate(16);
storeMatrix(mcMatrix, buffer);
Mat4f matrix = new Mat4f(buffer);
#if PRE_MC_1_19_4
matrix.transpose(); // In 1.19.3 and later, we no longer need to transpose it
#endif
return matrix;
}
static final Direction[] directions; static final Direction[] directions;
static final EDhDirection[] lodDirections; static final EDhDirection[] lodDirections;
@@ -134,41 +139,10 @@ public class McObjectConverter
} }
} }
public static BlockPos Convert(DhBlockPos wrappedPos) public static BlockPos Convert(DhBlockPos wrappedPos) { return new BlockPos(wrappedPos.getX(), wrappedPos.getY(), wrappedPos.getZ()); }
{ public static ChunkPos Convert(DhChunkPos wrappedPos) { return new ChunkPos(wrappedPos.getX(), wrappedPos.getZ()); }
return new BlockPos(wrappedPos.x, wrappedPos.y, wrappedPos.z);
}
public static ChunkPos Convert(DhChunkPos wrappedPos)
{
return new ChunkPos(wrappedPos.x, wrappedPos.z);
}
public static Direction Convert(EDhDirection lodDirection) public static Direction Convert(EDhDirection lodDirection) { return directions[lodDirection.ordinal()]; }
{ public static EDhDirection Convert(Direction direction) { return lodDirections[direction.ordinal()]; }
return directions[lodDirection.ordinal()];
}
public static EDhDirection Convert(Direction direction)
{
return lodDirections[direction.ordinal()];
}
public static void DebugCheckAllPackers()
{
BiConsumer<Integer, Integer> func = (x, z) -> DhChunkPos._DebugCheckPacker(x, z, ChunkPos.asLong(x, z));
func.accept(0, 0);
func.accept(12345, 134);
func.accept(-12345, -134);
func.accept(-30000000 / 16, 30000000 / 16);
func.accept(30000000 / 16, -30000000 / 16);
func.accept(30000000 / 16, 30000000 / 16);
func.accept(-30000000 / 16, -30000000 / 16);
Consumer<BlockPos> func2 = (p) -> DhBlockPos._DebugCheckPacker(p.getX(), p.getY(), p.getZ(), p.asLong());
func2.accept(new BlockPos(0, 0, 0));
func2.accept(new BlockPos(12345, 134, 123));
func2.accept(new BlockPos(-12345, -134, -80));
func2.accept(new BlockPos(-30000000, 2047, 30000000));
func2.accept(new BlockPos(30000000, -2048, -30000000));
func2.accept(new BlockPos(30000000, 2047, 30000000));
func2.accept(new BlockPos(-30000000, -2048, -30000000));
}
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -20,8 +20,6 @@
package com.seibel.distanthorizons.common.wrappers; package com.seibel.distanthorizons.common.wrappers;
import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants;
import net.minecraft.SharedConstants;
import net.minecraft.client.Minecraft;
/** /**
* @author James Seibel * @author James Seibel
@@ -38,32 +36,52 @@ public class VersionConstants implements IVersionConstants
} }
@Override
public int getMinimumWorldHeight()
{
return 0;
}
@Override
public int getWorldGenerationCountPerThread()
{
return 1;
}
@Override
public boolean isVanillaRenderedChunkSquare()
{
return false;
}
@Override @Override
public String getMinecraftVersion() public String getMinecraftVersion()
{ {
#if PRE_MC_1_19_2 // these values are hard-coded to prevent an issue with Forge (specifically 1.18.2) where
return Minecraft.getInstance().getGame().getVersion().getId(); // it can't load client classes when running as a dedicated server,
// which was how we were dynamically accessing the MC version string
#if MC_VER == MC_1_16_5
return "1.16.5";
#elif MC_VER == MC_1_17_1
return "1.17.1";
#elif MC_VER == MC_1_18_2
return "1.18.2";
#elif MC_VER == MC_1_19_2
return "1.19.2";
#elif MC_VER == MC_1_19_4
return "1.19.4";
#elif MC_VER == MC_1_20_1
return "1.20.1";
#elif MC_VER == MC_1_20_2
return "1.20.2";
#elif MC_VER == MC_1_20_4
return "1.20.4";
#elif MC_VER == MC_1_20_6
return "1.20.6";
#elif MC_VER == MC_1_21_1
return "1.21.1";
#elif MC_VER == MC_1_21_3
return "1.21.3";
#elif MC_VER == MC_1_21_4
return "1.21.4";
#elif MC_VER == MC_1_21_5
return "1.21.5";
#elif MC_VER == MC_1_21_6
return "1.21.6";
#elif MC_VER == MC_1_21_8
return "1.21.8";
#else #else
return SharedConstants.getCurrentVersion().getId(); ERROR MC version constant missing
#endif #endif
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,7 +19,11 @@
package com.seibel.distanthorizons.common.wrappers; package com.seibel.distanthorizons.common.wrappers;
import com.seibel.distanthorizons.api.interfaces.block.IDhApiBiomeWrapper;
import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper;
import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator;
import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper;
import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
@@ -28,6 +32,7 @@ import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment;
import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhLevel;
import com.seibel.distanthorizons.core.level.IDhServerLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel;
import com.seibel.distanthorizons.core.util.LodUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
@@ -35,9 +40,14 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvironmentWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.AbstractBatchGenerationEnvironmentWrapper;
import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.multiplayer.ClientLevel;
#if MC_VER > MC_1_17_1
import net.minecraft.core.Holder;
#endif
import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.Level; import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelReader; import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import java.io.IOException; import java.io.IOException;
@@ -45,9 +55,6 @@ import java.util.HashSet;
/** /**
* This handles creating abstract wrapper objects. * This handles creating abstract wrapper objects.
*
* @author James Seibel
* @version 2022-12-5
*/ */
public class WrapperFactory implements IWrapperFactory public class WrapperFactory implements IWrapperFactory
{ {
@@ -55,6 +62,9 @@ public class WrapperFactory implements IWrapperFactory
//==============//
// core methods //
//==============//
@Override @Override
public AbstractBatchGenerationEnvironmentWrapper createBatchGenerator(IDhLevel targetLevel) public AbstractBatchGenerationEnvironmentWrapper createBatchGenerator(IDhLevel targetLevel)
@@ -69,17 +79,56 @@ public class WrapperFactory implements IWrapperFactory
} }
} }
@Override
public IDhApiBiomeWrapper getBiomeWrapper(String resourceLocationString, IDhApiLevelWrapper levelWrapper) throws IOException, ClassCastException
{
if (!(levelWrapper instanceof ILevelWrapper))
{
throw new ClassCastException("levelWrapper must be returned by DH and of type ["+ILevelWrapper.class.getName()+"].");
}
return BiomeWrapper.deserialize(resourceLocationString, (ILevelWrapper)levelWrapper);
}
@Override
public IDhApiBlockStateWrapper getDefaultBlockStateWrapper(String resourceLocationString, IDhApiLevelWrapper levelWrapper) throws IOException, ClassCastException
{
if (!(levelWrapper instanceof ILevelWrapper))
{
throw new ClassCastException("Invalid ["+IDhApiLevelWrapper.class.getSimpleName()+"] value given. Level wrapper object must be one given by the DH API (it can't be a custom implementation), specifically of type ["+ILevelWrapper.class.getName()+"].");
}
return BlockStateWrapper.deserialize(resourceLocationString, (ILevelWrapper)levelWrapper);
}
@Override @Override
public IBiomeWrapper deserializeBiomeWrapper(String str, ILevelWrapper levelWrapper) throws IOException { return BiomeWrapper.deserialize(str, levelWrapper); } public IBiomeWrapper deserializeBiomeWrapper(String str, ILevelWrapper levelWrapper) throws IOException { return BiomeWrapper.deserialize(str, levelWrapper); }
@Override
public IBiomeWrapper getPlainsBiomeWrapper(ILevelWrapper levelWrapper) // TODO is there a way we could get this without the levelWrapper? it isn't necessary but would clean up the code a bit
{
try
{
return BiomeWrapper.deserialize(BiomeWrapper.PLAINS_RESOURCE_LOCATION_STRING, levelWrapper);
}
catch (IOException e)
{
throw new LodUtil.AssertFailureException("Unable to parse plains resource string ["+BiomeWrapper.PLAINS_RESOURCE_LOCATION_STRING+"], error:\n " + e.getMessage());
}
}
@Override @Override
public IBlockStateWrapper deserializeBlockStateWrapper(String str, ILevelWrapper levelWrapper) throws IOException { return BlockStateWrapper.deserialize(str, levelWrapper); } public IBlockStateWrapper deserializeBlockStateWrapper(String str, ILevelWrapper levelWrapper) throws IOException { return BlockStateWrapper.deserialize(str, levelWrapper); }
@Override @Override
public IBlockStateWrapper getAirBlockStateWrapper() { return BlockStateWrapper.AIR; } public IBlockStateWrapper getAirBlockStateWrapper() { return BlockStateWrapper.AIR; }
@Override @Override
public HashSet<IBlockStateWrapper> getRendererIgnoredBlocks(ILevelWrapper levelWrapper) { return BlockStateWrapper.getRendererIgnoredBlocks(levelWrapper); } public HashSet<IBlockStateWrapper> getRendererIgnoredBlocks(ILevelWrapper levelWrapper) { return BlockStateWrapper.getRendererIgnoredBlocks(levelWrapper); }
@Override
public HashSet<IBlockStateWrapper> getRendererIgnoredCaveBlocks(ILevelWrapper levelWrapper) { return BlockStateWrapper.getRendererIgnoredCaveBlocks(levelWrapper); }
@Override
public void resetRendererIgnoredCaveBlocks() { BlockStateWrapper.clearRendererIgnoredCaveBlocks(); }
@Override
public void resetRendererIgnoredBlocksSet() { BlockStateWrapper.clearRendererIgnoredBlocks(); }
/** /**
@@ -106,8 +155,7 @@ public class WrapperFactory implements IWrapperFactory
} }
} }
// MC 1.16, 1.18, 1.19, 1.20 //#if MC_VER <= MC_1_XX_X
#if POST_MC_1_17_1 || MC_1_16_5
else if (objectArray.length == 2) else if (objectArray.length == 2)
{ {
// correct number of parameters from the API // correct number of parameters from the API
@@ -126,43 +174,22 @@ public class WrapperFactory implements IWrapperFactory
} }
// the level is needed for the DH level wrapper... // the level is needed for the DH level wrapper...
Level level = (Level) objectArray[1]; Level level = (Level) objectArray[1];
// ...the LevelReader is needed for chunk lighting
LevelReader lightSource = level;
// level wrapper // level wrapper
ILevelWrapper levelWrapper; ILevelWrapper levelWrapper = level.isClientSide()
if (level instanceof ServerLevel) ? ClientLevelWrapper.getWrapper((ClientLevel)level)
{ : ServerLevelWrapper.getWrapper((ServerLevel)level);
levelWrapper = ServerLevelWrapper.getWrapper((ServerLevel)level);
}
else if (level instanceof ClientLevel)
{
levelWrapper = ClientLevelWrapper.getWrapper((ClientLevel)level);
}
else
{
throw new ClassCastException(createChunkWrapperErrorMessage(objectArray));
}
return new ChunkWrapper(chunk, lightSource, levelWrapper); return new ChunkWrapper(chunk, levelWrapper);
} }
// incorrect number of parameters from the API // incorrect number of parameters from the API
else else
{ {
throw new ClassCastException(createChunkWrapperErrorMessage(objectArray)); throw new ClassCastException(createChunkWrapperErrorMessage(objectArray));
} }
#else //#endif
// Intentional compiler error to bring attention to the missing wrapper function.
// If you need to work on an unimplemented version but don't have the ability to implement this yet
// you can comment it out, but please don't commit it. Someone will have to implement it .
// After implementing the new version please read this method's javadocs for instructions
// on what other locations also need to be updated, the DhAPI specifically needs to
// be updated to state which objects this method accepts.
not implemented for this version of Minecraft!
#endif
} }
/** /**
* Note: when this is updated for different MC versions, * Note: when this is updated for different MC versions,
@@ -170,25 +197,152 @@ public class WrapperFactory implements IWrapperFactory
*/ */
private static String createChunkWrapperErrorMessage(Object[] objectArray) private static String createChunkWrapperErrorMessage(Object[] objectArray)
{ {
StringBuilder message = new StringBuilder( String[] expectedClassNames;
"Chunk wrapper creation failed. \n" +
"Expected parameters: \n");
// MC 1.16, 1.18, 1.19, 1.20 //#if MC_VER <= MC_1_XX_X
#if POST_MC_1_17_1 || MC_1_16_5 expectedClassNames = new String[]
message.append("[" + ChunkAccess.class.getName() + "], \n"); {
message.append("[" + ServerLevel.class.getName() + "] or [" + ClientLevel.class.getName() + "]. \n"); ChunkAccess.class.getName(),
#else "[ServerLevel] or [ClientLevel]" // Classes are not referenced by names to avoid exception when one of them is missing
// See preprocessor comment in createChunkWrapper() for full documentation };
not implemented for this version of Minecraft! //#endif
return createWrapperErrorMessage("Chunk wrapper", expectedClassNames, objectArray);
}
//=============//
// api methods //
//=============//
// documentation should be in the API interface
public IDhApiBiomeWrapper getBiomeWrapper(Object[] objectArray, IDhApiLevelWrapper levelWrapper)
{
// confirm the API level wrapper is also a Core wrapper
if (!(levelWrapper instanceof ILevelWrapper))
{
throw new ClassCastException("Invalid ["+IDhApiLevelWrapper.class.getSimpleName()+"] value given. Level wrapper object must be one given by the DH API (it can't be a custom implementation), specifically of type ["+ILevelWrapper.class.getName()+"].");
}
ILevelWrapper coreLevelWrapper = (ILevelWrapper) levelWrapper;
#if MC_VER < MC_1_20_4
if (objectArray.length != 1)
{
throw new ClassCastException(createBiomeWrapperErrorMessage(objectArray));
}
#endif #endif
#if MC_VER < MC_1_18_2
if (!(objectArray[0] instanceof Biome))
{
throw new ClassCastException(createBiomeWrapperErrorMessage(objectArray));
}
Biome biome = (Biome) objectArray[0];
return BiomeWrapper.getBiomeWrapper(biome, coreLevelWrapper);
#else
if (!(objectArray[0] instanceof Holder) || !(((Holder<?>) objectArray[0]).value() instanceof Biome))
{
throw new ClassCastException(createBiomeWrapperErrorMessage(objectArray));
}
Holder<Biome> biomeHolder = (Holder<Biome>) objectArray[0];
return BiomeWrapper.getBiomeWrapper(biomeHolder, coreLevelWrapper);
#endif
}
/**
* Note: when this is updated for different MC versions,
* make sure you also update the documentation in {@link IDhApiWrapperFactory#getBiomeWrapper}.
*/
private static String createBiomeWrapperErrorMessage(Object[] objectArray)
{
String[] expectedClassNames;
#if MC_VER < MC_1_18_2
expectedClassNames = new String[] { Biome.class.getName() };
#else
expectedClassNames = new String[] { Holder.class.getName()+"<"+Biome.class.getName()+">" };
#endif
return createWrapperErrorMessage("Biome wrapper", expectedClassNames, objectArray);
}
public IDhApiBlockStateWrapper getBlockStateWrapper(Object[] objectArray, IDhApiLevelWrapper levelWrapper)
{
// confirm the API level wrapper is also a Core wrapper
if (!(levelWrapper instanceof ILevelWrapper))
{
throw new ClassCastException("Invalid ["+IDhApiLevelWrapper.class.getSimpleName()+"] value given. Level wrapper object must be one given by the DH API (it can't be a custom implementation), specifically of type ["+ILevelWrapper.class.getName()+"].");
}
ILevelWrapper coreLevelWrapper = (ILevelWrapper) levelWrapper;
//#if MC_VER <= MC_1_XX_X
if (objectArray.length != 1)
{
throw new ClassCastException(createBlockStateWrapperErrorMessage(objectArray));
}
if (!(objectArray[0] instanceof BlockState))
{
throw new ClassCastException(createBlockStateWrapperErrorMessage(objectArray));
}
BlockState blockState = (BlockState) objectArray[0];
return BlockStateWrapper.fromBlockState(blockState, coreLevelWrapper);
//#endif
}
/**
* Note: when this is updated for different MC versions,
* make sure you also update the documentation in {@link IDhApiWrapperFactory#getBlockStateWrapper}.
*/
private static String createBlockStateWrapperErrorMessage(Object[] objectArray)
{
String[] expectedClassNames;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
expectedClassNames = new String[] { Biome.class.getName() };
#else
expectedClassNames = new String[] { Holder.class.getName()+"<"+Biome.class.getName()+">" };
#endif
return createWrapperErrorMessage("BlockState wrapper", expectedClassNames, objectArray);
}
//================//
// helper methods //
//================//
private static String createWrapperErrorMessage(String wrapperName, String[] expectedClassNames, Object[] objectArray)
{
// error header
StringBuilder message = new StringBuilder(
wrapperName + " creation failed. \n" +
"Expected object array parameters: \n");
// expected parameters
for (String expectedClassName : expectedClassNames)
{
message.append("[").append(expectedClassName).append("], \n");
}
// given parameters
if (objectArray.length != 0) if (objectArray.length != 0)
{ {
message.append("Given parameters: "); message.append("Given parameters: ");
for (Object obj : objectArray) for (Object obj : objectArray)
{ {
message.append("[").append(obj.getClass().getName()).append("], "); String objClassName = (obj != null) ? obj.getClass().getName() : "NULL";
message.append("[").append(objClassName).append("], ");
} }
} }
else else
@@ -196,8 +350,8 @@ public class WrapperFactory implements IWrapperFactory
message.append(" No parameters given."); message.append(" No parameters given.");
} }
return message.toString(); return message.toString();
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -22,6 +22,7 @@ package com.seibel.distanthorizons.common.wrappers.block;
import java.io.IOException; import java.io.IOException;
import java.util.HashSet; import java.util.HashSet;
import java.util.Objects; import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ConcurrentMap;
@@ -32,19 +33,9 @@ import org.apache.logging.log4j.Logger;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
import net.minecraft.client.Minecraft; #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
#if POST_MC_1_17
import net.minecraft.core.Holder;
import net.minecraft.resources.RegistryOps;
#endif
#if POST_MC_1_19_2
#endif
#if MC_1_16_5 || MC_1_17_1
import net.minecraft.core.Registry; import net.minecraft.core.Registry;
#elif MC_1_18_2 || MC_1_19_2 #elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
import net.minecraft.core.Holder; import net.minecraft.core.Holder;
import net.minecraft.core.Registry; import net.minecraft.core.Registry;
import net.minecraft.core.RegistryAccess; import net.minecraft.core.RegistryAccess;
@@ -56,7 +47,8 @@ import net.minecraft.core.registries.Registries;
import net.minecraft.resources.ResourceLocation; import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.Biome;
#if !PRE_MC_1_18_2
#if MC_VER >= MC_1_18_2
import net.minecraft.world.level.biome.Biomes; import net.minecraft.world.level.biome.Biomes;
#endif #endif
@@ -64,32 +56,46 @@ import net.minecraft.world.level.biome.Biomes;
/** This class wraps the minecraft BlockPos.Mutable (and BlockPos) class */ /** This class wraps the minecraft BlockPos.Mutable (and BlockPos) class */
public class BiomeWrapper implements IBiomeWrapper public class BiomeWrapper implements IBiomeWrapper
{ {
// must be defined before AIR, otherwise a null pointer will be thrown
private static final Logger LOGGER = LogManager.getLogger(); private static final Logger LOGGER = LogManager.getLogger();
#if PRE_MC_1_18_2
#if MC_VER < MC_1_18_2
public static final ConcurrentMap<Biome, BiomeWrapper> WRAPPER_BY_BIOME = new ConcurrentHashMap<>(); public static final ConcurrentMap<Biome, BiomeWrapper> WRAPPER_BY_BIOME = new ConcurrentHashMap<>();
#else #else
public static final ConcurrentMap<Holder<Biome>, BiomeWrapper> WRAPPER_BY_BIOME = new ConcurrentHashMap<>(); public static final ConcurrentMap<Holder<Biome>, BiomeWrapper> WRAPPER_BY_BIOME = new ConcurrentHashMap<>();
#endif #endif
public static final String EMPTY_STRING = "EMPTY"; public static final ConcurrentHashMap<String, BiomeWrapper> WRAPPER_BY_RESOURCE_LOCATION = new ConcurrentHashMap<>();
public static final String EMPTY_BIOME_STRING = "EMPTY";
public static final BiomeWrapper EMPTY_WRAPPER = new BiomeWrapper(null, null); public static final BiomeWrapper EMPTY_WRAPPER = new BiomeWrapper(null, null);
public static final String PLAINS_RESOURCE_LOCATION_STRING = "minecraft:plains";
/** keep track of broken biomes so we don't log every time */ /** keep track of broken biomes so we don't log every time */
private static final HashSet<String> BrokenResourceLocationStrings = new HashSet<>(); private static final HashSet<String> brokenResourceLocationStrings = new HashSet<>();
/**
* Only display this warning once, otherwise the log may be spammed <br>
* This is a known issue when joining Hypixel.
*/
private static boolean emptyStringWarningLogged = false;
private static boolean emptyLevelSerializeFailLogged = false;
// properties // // properties //
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
public final Biome biome; public final Biome biome;
#else #else
public final Holder<Biome> biome; public final Holder<Biome> biome;
#endif #endif
/** technically final, but since it requires a method call to generate it can't be marked as such */ /** technically final, but since it requires a method call to generate it can't be marked as such */
private String serialString = null; private String serialString;
private final int hashCode;
@@ -97,7 +103,7 @@ public class BiomeWrapper implements IBiomeWrapper
// constructors // // constructors //
//==============// //==============//
static public IBiomeWrapper getBiomeWrapper(#if PRE_MC_1_18_2 Biome #else Holder<Biome> #endif biome, ILevelWrapper levelWrapper) static public IBiomeWrapper getBiomeWrapper(#if MC_VER < MC_1_18_2 Biome #else Holder<Biome> #endif biome, ILevelWrapper levelWrapper)
{ {
if (biome == null) if (biome == null)
{ {
@@ -116,12 +122,13 @@ public class BiomeWrapper implements IBiomeWrapper
return newWrapper; return newWrapper;
} }
} }
private BiomeWrapper(#if MC_VER < MC_1_18_2 Biome #else Holder<Biome> #endif biome, ILevelWrapper levelWrapper)
private BiomeWrapper(#if PRE_MC_1_18_2 Biome #else Holder<Biome> #endif biome, ILevelWrapper levelWrapper)
{ {
this.biome = biome; this.biome = biome;
this.serialString = this.serialize(levelWrapper); this.serialString = this.serialize(levelWrapper);
LOGGER.trace("Created BiomeWrapper ["+this.serialString+"] for ["+biome+"]"); this.hashCode = Objects.hash(this.serialString);
//LOGGER.trace("Created BiomeWrapper ["+this.serialString+"] for ["+biome+"]");
} }
@@ -135,10 +142,10 @@ public class BiomeWrapper implements IBiomeWrapper
{ {
if (this == EMPTY_WRAPPER) if (this == EMPTY_WRAPPER)
{ {
return EMPTY_STRING; return EMPTY_BIOME_STRING;
} }
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
return biome.toString(); return biome.toString();
#else #else
return this.biome.unwrapKey().orElse(Biomes.THE_VOID).registry().toString(); return this.biome.unwrapKey().orElse(Biomes.THE_VOID).registry().toString();
@@ -163,7 +170,7 @@ public class BiomeWrapper implements IBiomeWrapper
} }
@Override @Override
public int hashCode() { return Objects.hash(this.getSerialString()); } public int hashCode() { return this.hashCode; }
@Override @Override
public String getSerialString() { return this.serialString; } public String getSerialString() { return this.serialString; }
@@ -182,52 +189,77 @@ public class BiomeWrapper implements IBiomeWrapper
public String serialize(ILevelWrapper levelWrapper) public String serialize(ILevelWrapper levelWrapper)
{ {
if (levelWrapper == null) if (this.biome == null)
{ {
return EMPTY_STRING; return EMPTY_BIOME_STRING;
} }
if (this.serialString == null)
// we can't generate a serial string if the level is null
if (levelWrapper == null)
{ {
net.minecraft.core.RegistryAccess registryAccess = Minecraft.getInstance().level.registryAccess(); if (!emptyLevelSerializeFailLogged)
{
emptyLevelSerializeFailLogged = true;
LOGGER.warn("Unable to serialize biome: [" + this.biome + "] because the passed in level wrapper is null. Future errors of this type won't be logged.");
}
ResourceLocation resourceLocation; return EMPTY_BIOME_STRING;
#if MC_1_16_5 || MC_1_17_1 }
resourceLocation = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).getKey(this.biome);
#elif MC_1_18_2 || MC_1_19_2
resourceLocation = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).getKey(this.biome.value());
// generate the serial string //
Level level = (Level)levelWrapper.getWrappedMcObject();
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
ResourceLocation resourceLocation;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
resourceLocation = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).getKey(this.biome);
#elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
resourceLocation = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).getKey(this.biome.value());
#elif MC_VER < MC_1_21_3
resourceLocation = registryAccess.registryOrThrow(Registries.BIOME).getKey(this.biome.value());
#else
resourceLocation = registryAccess.lookupOrThrow(Registries.BIOME).getKey(this.biome.value());
#endif
if (resourceLocation == null)
{
String biomeName;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
biomeName = this.biome.toString();
#else #else
resourceLocation = registryAccess.registryOrThrow(Registries.BIOME).getKey(this.biome.value()); biomeName = this.biome.value().toString();
#endif #endif
if (resourceLocation == null) LOGGER.warn("unable to serialize: " + biomeName);
{ // shouldn't normally happen, but just in case
String biomeName; this.serialString = "";
#if MC_1_16_5 || MC_1_17_1 }
biomeName = this.biome.toString(); else
#else {
biomeName = this.biome.value().toString(); this.serialString = resourceLocation.getNamespace() + ":" + resourceLocation.getPath();
#endif
LOGGER.warn("unable to serialize: " + biomeName);
// shouldn't normally happen, but just in case
this.serialString = "";
}
else
{
this.serialString = resourceLocation.getNamespace() + ":" + resourceLocation.getPath();
}
} }
return this.serialString; return this.serialString;
} }
// TODO would it be worth while to cache these objects in a ConcurrentHashMap<string, IBiomeWrapper>?
public static IBiomeWrapper deserialize(String resourceLocationString, ILevelWrapper levelWrapper) throws IOException public static IBiomeWrapper deserialize(String resourceLocationString, ILevelWrapper levelWrapper) throws IOException
{ {
if (resourceLocationString.equals(EMPTY_STRING)) // we need the final string for the concurrent hash map later
final String finalResourceStateString = resourceLocationString;
if (resourceLocationString.equals(EMPTY_BIOME_STRING))
{ {
LOGGER.warn("["+EMPTY_STRING+"] biome string deserialized. This may mean there was a file saving error or a biome saving error."); if (!emptyStringWarningLogged)
{
emptyStringWarningLogged = true;
LOGGER.warn("[" + EMPTY_BIOME_STRING + "] biome string deserialized. This may mean the level was null when a save was attempted, a file saving error, or a biome saving error. Future errors will not be logged.");
}
return EMPTY_WRAPPER; return EMPTY_WRAPPER;
} }
else if (resourceLocationString.trim().isEmpty() || resourceLocationString.equals("")) else if (resourceLocationString.trim().isEmpty() || resourceLocationString.equals(""))
@@ -236,54 +268,127 @@ public class BiomeWrapper implements IBiomeWrapper
return EMPTY_WRAPPER; return EMPTY_WRAPPER;
} }
if (WRAPPER_BY_RESOURCE_LOCATION.containsKey(finalResourceStateString))
{
return WRAPPER_BY_RESOURCE_LOCATION.get(finalResourceStateString);
}
// if no wrapper is found, default to the empty wrapper
BiomeWrapper foundWrapper = EMPTY_WRAPPER;
try
{
try
{
Level level = (Level) levelWrapper.getWrappedMcObject();
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
BiomeDeserializeResult deserializeResult = deserializeBiome(resourceLocationString, registryAccess);
if (!deserializeResult.success)
{
if (!brokenResourceLocationStrings.contains(resourceLocationString))
{
brokenResourceLocationStrings.add(resourceLocationString);
LOGGER.warn("Unable to deserialize biome from string: [" + resourceLocationString + "]");
}
return EMPTY_WRAPPER;
}
foundWrapper = (BiomeWrapper) getBiomeWrapper(deserializeResult.biome, levelWrapper);
return foundWrapper;
}
catch (Exception e)
{
throw new IOException("Failed to deserialize the string [" + finalResourceStateString + "] into a BiomeWrapper: " + e.getMessage(), e);
}
}
finally
{
WRAPPER_BY_RESOURCE_LOCATION.putIfAbsent(finalResourceStateString, foundWrapper);
}
}
public static BiomeDeserializeResult deserializeBiome(String resourceLocationString, net.minecraft.core.RegistryAccess registryAccess) throws IOException
{
// parse the resource location // parse the resource location
int separatorIndex = resourceLocationString.indexOf(":"); int separatorIndex = resourceLocationString.indexOf(":");
if (separatorIndex == -1) if (separatorIndex == -1)
{ {
throw new IOException("Unable to parse resource location string: [" + resourceLocationString + "]."); throw new IOException("Unable to parse resource location string: [" + resourceLocationString + "].");
} }
ResourceLocation resourceLocation = new ResourceLocation(resourceLocationString.substring(0, separatorIndex), resourceLocationString.substring(separatorIndex + 1));
ResourceLocation resourceLocation;
try try
{ {
Level level = (Level)levelWrapper.getWrappedMcObject(); #if MC_VER < MC_1_21_1
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess(); resourceLocation = new ResourceLocation(resourceLocationString.substring(0, separatorIndex), resourceLocationString.substring(separatorIndex + 1));
boolean success;
#if MC_1_16_5 || MC_1_17_1
Biome biome = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).get(resourceLocation);
success = (biome != null);
#elif MC_1_18_2 || MC_1_19_2
Biome unwrappedBiome = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).get(resourceLocation);
success = (unwrappedBiome != null);
Holder<Biome> biome = new Holder.Direct<>(unwrappedBiome);
#else #else
Biome unwrappedBiome = registryAccess.registryOrThrow(Registries.BIOME).get(resourceLocation); resourceLocation = ResourceLocation.fromNamespaceAndPath(resourceLocationString.substring(0, separatorIndex), resourceLocationString.substring(separatorIndex + 1));
success = (unwrappedBiome != null);
Holder<Biome> biome = new Holder.Direct<>(unwrappedBiome);
#endif #endif
if (!success)
{
if (!BrokenResourceLocationStrings.contains(resourceLocationString))
{
BrokenResourceLocationStrings.add(resourceLocationString);
LOGGER.warn("Unable to deserialize biome from string: [" + resourceLocationString + "]");
}
return EMPTY_WRAPPER;
}
return getBiomeWrapper(biome, levelWrapper);
} }
catch (Exception e) catch (Exception e)
{ {
throw new IOException("Failed to deserialize the string [" + resourceLocationString + "] into a BiomeWrapper: " + e.getMessage(), e); throw new IOException("No Resource Location found for the string: [" + resourceLocationString + "] Error: [" + e.getMessage() + "].");
}
boolean success;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
Biome biome = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).get(resourceLocation);
success = (biome != null);
#elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
Biome unwrappedBiome = registryAccess.registryOrThrow(Registry.BIOME_REGISTRY).get(resourceLocation);
success = (unwrappedBiome != null);
Holder<Biome> biome = new Holder.Direct<>(unwrappedBiome);
#elif MC_VER < MC_1_21_3
Biome unwrappedBiome = registryAccess.registryOrThrow(Registries.BIOME).get(resourceLocation);
success = (unwrappedBiome != null);
Holder<Biome> biome = new Holder.Direct<>(unwrappedBiome);
#else
Holder<Biome> biome;
Optional<Holder.Reference<Biome>> optionalBiomeHolder = registryAccess.lookupOrThrow(Registries.BIOME).get(resourceLocation);
if (optionalBiomeHolder.isPresent())
{
Biome unwrappedBiome = optionalBiomeHolder.get().value();
success = (unwrappedBiome != null);
biome = new Holder.Direct<>(unwrappedBiome);
}
else
{
success = false;
biome = null;
}
#endif
return new BiomeDeserializeResult(success, biome);
}
//================//
// helper classes //
//================//
public static class BiomeDeserializeResult
{
public final boolean success;
#if MC_VER < MC_1_18_2
public final Biome biome;
#else
public final Holder<Biome> biome;
#endif
public BiomeDeserializeResult(boolean success, #if MC_VER < MC_1_18_2 Biome #else Holder<Biome> #endif biome)
{
this.success = success;
this.biome = biome;
} }
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,35 +19,48 @@
package com.seibel.distanthorizons.common.wrappers.block; package com.seibel.distanthorizons.common.wrappers.block;
import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial;
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.config.types.ConfigEntry;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.util.ColorUtil;
import com.seibel.distanthorizons.core.util.LodUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import net.minecraft.resources.ResourceLocation; import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.BlockTags;
import net.minecraft.world.level.block.BeaconBeamBlock;
import net.minecraft.world.level.block.Block; import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.SoundType;
import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.BlockState;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.awt.*;
import java.io.IOException; import java.io.IOException;
import java.util.*; import java.util.*;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
#if MC_1_16_5 || MC_1_17_1 import org.jetbrains.annotations.Nullable;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
import net.minecraft.core.Registry; import net.minecraft.core.Registry;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.world.level.EmptyBlockGetter; import net.minecraft.world.level.EmptyBlockGetter;
#elif MC_1_18_2 || MC_1_19_2 #elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.world.level.Level; import net.minecraft.world.level.Level;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Registry; import net.minecraft.core.Registry;
import net.minecraft.world.level.EmptyBlockGetter; import net.minecraft.world.level.EmptyBlockGetter;
#else #else
import net.minecraft.client.Minecraft;
import net.minecraft.world.level.Level; import net.minecraft.world.level.Level;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.registries.Registries; import net.minecraft.core.registries.Registries;
import net.minecraft.world.level.EmptyBlockGetter; import net.minecraft.world.level.EmptyBlockGetter;
import net.minecraft.core.Holder;
#endif #endif
public class BlockStateWrapper implements IBlockStateWrapper public class BlockStateWrapper implements IBlockStateWrapper
@@ -62,29 +75,39 @@ public class BlockStateWrapper implements IBlockStateWrapper
private static final Logger LOGGER = DhLoggerBuilder.getLogger(); private static final Logger LOGGER = DhLoggerBuilder.getLogger();
public static final ConcurrentHashMap<BlockState, BlockStateWrapper> WRAPPER_BY_BLOCK_STATE = new ConcurrentHashMap<>(); public static final ConcurrentHashMap<BlockState, BlockStateWrapper> WRAPPER_BY_BLOCK_STATE = new ConcurrentHashMap<>();
public static final ConcurrentHashMap<String, BlockStateWrapper> WRAPPER_BY_RESOURCE_LOCATION = new ConcurrentHashMap<>();
public static final String AIR_STRING = "AIR"; public static final String AIR_STRING = "AIR";
public static final BlockStateWrapper AIR = new BlockStateWrapper(null, null); public static final BlockStateWrapper AIR = new BlockStateWrapper(null, null);
// TODO: Make this changeable through the config public static final String DIRT_RESOURCE_LOCATION_STRING = "minecraft:dirt";
public static final String[] RENDERER_IGNORED_BLOCKS_RESOURCE_LOCATIONS = { AIR_STRING, "minecraft:barrier", "minecraft:structure_void", "minecraft:light", "minecraft:tripwire" };
public static HashSet<IBlockStateWrapper> rendererIgnoredBlocks = null; public static HashSet<IBlockStateWrapper> rendererIgnoredBlocks = null;
public static HashSet<IBlockStateWrapper> rendererIgnoredCaveBlocks = null;
/** keep track of broken blocks so we don't log every time */ /** keep track of broken blocks so we don't log every time */
private static final HashSet<ResourceLocation> BrokenResourceLocations = new HashSet<>(); private static final HashSet<ResourceLocation> BROKEN_RESOURCE_LOCATIONS = new HashSet<>();
// properties // // properties //
@Nullable
public final BlockState blockState; public final BlockState blockState;
/** technically final, but since it requires a method call to generate it can't be marked as such */ /** technically final, but since it requires a method call to generate it can't be marked as such */
private String serialString; private String serialString;
/** private final int hashCode;
* Cached opacity value, -1 if not populated. <br> /** Should be between {@link LodUtil#BLOCK_FULLY_OPAQUE} and {@link LodUtil#BLOCK_FULLY_OPAQUE} */
* Should be between {@link IBlockStateWrapper#FULLY_OPAQUE} and {@link IBlockStateWrapper#FULLY_OPAQUE} private final int opacity;
*/ /** used by the Iris shader mod to determine how each LOD should be rendered */
private int opacity = -1; private byte blockMaterialId = 0;
private final boolean isBeaconBlock;
private final boolean isBeaconBaseBlock;
private final boolean allowsBeaconBeamPassage;
/** null if this block can't tint beacons */
private final Color beaconTintColor;
private final Color mapColor;
@@ -112,18 +135,129 @@ public class BlockStateWrapper implements IBlockStateWrapper
} }
} }
/**
* Can be faster than {@link BlockStateWrapper#fromBlockState(BlockState, ILevelWrapper)}
* in cases where the same block state is expected to be referenced multiple times.
*/
public static BlockStateWrapper fromBlockState(BlockState blockState, ILevelWrapper levelWrapper, IBlockStateWrapper guess)
{
BlockState guessBlockState = (guess == null || guess.isAir()) ? null : (BlockState) guess.getWrappedMcObject();
BlockState inputBlockState = (blockState == null || blockState.isAir()) ? null : blockState;
if (guess instanceof BlockStateWrapper
&& guessBlockState == inputBlockState)
{
return (BlockStateWrapper) guess;
}
else
{
return fromBlockState(blockState, levelWrapper);
}
}
private BlockStateWrapper(BlockState blockState, ILevelWrapper levelWrapper) private BlockStateWrapper(BlockState blockState, ILevelWrapper levelWrapper)
{ {
this.blockState = blockState; this.blockState = blockState;
this.serialString = this.serialize(levelWrapper); this.serialString = this.serialize(levelWrapper);
LOGGER.trace("Created BlockStateWrapper ["+this.serialString+"] for ["+blockState+"]"); this.hashCode = Objects.hash(this.serialString);
this.blockMaterialId = this.calculateEDhApiBlockMaterialId().index;
this.opacity = this.calculateOpacity();
String lowercaseSerial = this.serialString.toLowerCase();
// beacon blocks
boolean isBeaconBaseBlock = false;
for (int i = 0; i < LodUtil.BEACON_BASE_BLOCK_NAME_LIST.size(); i++)
{
String baseBlockName = LodUtil.BEACON_BASE_BLOCK_NAME_LIST.get(i);
if (lowercaseSerial.contains(baseBlockName))
{
isBeaconBaseBlock = true;
break;
}
}
this.isBeaconBaseBlock = isBeaconBaseBlock;
this.isBeaconBlock = lowercaseSerial.contains("minecraft:beacon");
// beacon tint color
Color beaconTintColor = null;
if (this.blockState != null
// beacon blocks also show up here, but since they block the beacon beam we don't want their color
&& !this.isBeaconBlock)
{
Block block = this.blockState.getBlock();
if (block instanceof BeaconBeamBlock)
{
int colorInt;
#if MC_VER <= MC_1_19_4
colorInt = ((BeaconBeamBlock) block).getColor().getMaterialColor().col;
#else
colorInt = ((BeaconBeamBlock) block).getColor().getMapColor().col;
#endif
beaconTintColor = ColorUtil.toColorObjRGB(colorInt);
}
}
this.beaconTintColor = beaconTintColor;
// allow/deny beacon beam passage
boolean allowsBeaconBeamPassage;
if (this.blockState != null)
{
// get block properties (defaults to the values used by air)
boolean canOcclude = this.getCanOcclude();
boolean propagatesSkyLightDown = this.getPropagatesSkyLightDown();
if (lowercaseSerial.contains("minecraft:bedrock"))
{
// bedrock is a special case fully opaque block that does allow beacons through
allowsBeaconBeamPassage = true;
}
else if (propagatesSkyLightDown || !canOcclude)
{
// stairs, cake, fences, etc.
allowsBeaconBeamPassage = true;
}
else
{
// non-opaque blocks (glass, mob spawners, etc.)
// all allow beacons through
allowsBeaconBeamPassage = (this.opacity != LodUtil.BLOCK_FULLY_OPAQUE);
}
}
else
{
// air allows beacons through
allowsBeaconBeamPassage = true;
}
this.allowsBeaconBeamPassage = allowsBeaconBeamPassage;
int mcColor = 0;
if (this.blockState != null)
{
#if MC_VER < MC_1_20_1
mcColor = this.blockState.getMaterial().getColor().col;
#else
mcColor = this.blockState.getMapColor(EmptyBlockGetter.INSTANCE, BlockPos.ZERO).col;
#endif
this.mapColor = ColorUtil.toColorObjRGB(mcColor);
}
else
{
this.mapColor = new Color(0,0,0,0);
}
//LOGGER.trace("Created BlockStateWrapper ["+this.serialString+"] for ["+blockState+"] with material ID ["+this.EDhApiBlockMaterialId+"]");
} }
//================// //====================//
// helper methods // // LodBuilder methods //
//================// //====================//
/** /**
* Requires a {@link ILevelWrapper} since {@link BlockStateWrapper#deserialize(String,ILevelWrapper)} also requires one. * Requires a {@link ILevelWrapper} since {@link BlockStateWrapper#deserialize(String,ILevelWrapper)} also requires one.
@@ -137,37 +271,104 @@ public class BlockStateWrapper implements IBlockStateWrapper
return rendererIgnoredBlocks; return rendererIgnoredBlocks;
} }
HashSet<String> baseIgnoredBlock = new HashSet<>();
baseIgnoredBlock.add(AIR_STRING);
rendererIgnoredBlocks = getBlockWrappers(Config.Client.Advanced.Graphics.Culling.ignoredRenderBlockCsv, baseIgnoredBlock, levelWrapper);
return rendererIgnoredBlocks;
}
/**
* Requires a {@link ILevelWrapper} since {@link BlockStateWrapper#deserialize(String,ILevelWrapper)} also requires one.
* This way the method won't accidentally be called before the deserialization can be completed.
*/
public static HashSet<IBlockStateWrapper> getRendererIgnoredCaveBlocks(ILevelWrapper levelWrapper)
{
// use the cached version if possible
if (rendererIgnoredCaveBlocks != null)
{
return rendererIgnoredCaveBlocks;
}
HashSet<String> baseIgnoredBlock = new HashSet<>();
baseIgnoredBlock.add(AIR_STRING);
rendererIgnoredCaveBlocks = getBlockWrappers(Config.Client.Advanced.Graphics.Culling.ignoredRenderCaveBlockCsv, baseIgnoredBlock, levelWrapper);
return rendererIgnoredCaveBlocks;
}
public static void clearRendererIgnoredBlocks() { rendererIgnoredBlocks = null; }
public static void clearRendererIgnoredCaveBlocks() { rendererIgnoredCaveBlocks = null; }
// lod builder helpers //
private static HashSet<IBlockStateWrapper> getBlockWrappers(ConfigEntry<String> config, HashSet<String> baseResourceLocations, ILevelWrapper levelWrapper)
{
// get the base blocks
HashSet<String> blockStringList = new HashSet<>();
if (baseResourceLocations != null)
{
blockStringList.addAll(baseResourceLocations);
}
// get the config blocks
String ignoreBlockCsv = config.get();
if (ignoreBlockCsv != null)
{
blockStringList.addAll(Arrays.asList(ignoreBlockCsv.split(",")));
}
return getBlockWrappers(blockStringList, levelWrapper);
}
private static HashSet<IBlockStateWrapper> getBlockWrappers(HashSet<String> blockResourceLocationSet, ILevelWrapper levelWrapper)
{
// deserialize each of the given resource locations // deserialize each of the given resource locations
HashSet<IBlockStateWrapper> blockStateWrappers = new HashSet<>(); HashSet<IBlockStateWrapper> blockStateWrappers = new HashSet<>();
for (String blockResourceLocation : RENDERER_IGNORED_BLOCKS_RESOURCE_LOCATIONS) for (String blockResourceLocation : blockResourceLocationSet)
{ {
try try
{ {
BlockStateWrapper DefaultBlockStateToIgnore = (BlockStateWrapper) deserialize(blockResourceLocation, levelWrapper); if (blockResourceLocation == null)
blockStateWrappers.add(DefaultBlockStateToIgnore); {
// shouldn't happen, but just in case
if (DefaultBlockStateToIgnore == AIR) continue;
}
String cleanedResourceLocation = blockResourceLocation.trim();
if (cleanedResourceLocation.length() == 0)
{ {
continue; continue;
} }
// add all possible blockstates (to account for light blocks with different light values and such)
List<BlockState> blockStatesToIgnore = DefaultBlockStateToIgnore.blockState.getBlock().getStateDefinition().getPossibleStates(); BlockStateWrapper defaultBlockStateToIgnore = (BlockStateWrapper) deserialize(cleanedResourceLocation, levelWrapper);
for (BlockState blockState : blockStatesToIgnore) blockStateWrappers.add(defaultBlockStateToIgnore);
if (defaultBlockStateToIgnore != AIR)
{ {
BlockStateWrapper newBlockToIgnore = BlockStateWrapper.fromBlockState(blockState, levelWrapper); // add all possible blockstates (to account for light blocks with different light values and such)
blockStateWrappers.add(newBlockToIgnore); List<BlockState> blockStatesToIgnore = defaultBlockStateToIgnore.blockState.getBlock().getStateDefinition().getPossibleStates();
for (BlockState blockState : blockStatesToIgnore)
{
BlockStateWrapper newBlockToIgnore = BlockStateWrapper.fromBlockState(blockState, levelWrapper);
blockStateWrappers.add(newBlockToIgnore);
}
}
else
{
// air is a special case so it must be handled separately
blockStateWrappers.add(AIR);
} }
} }
catch (IOException e) catch (IOException e)
{ {
LOGGER.warn("Unable to deserialize rendererIgnoredBlock with the resource location: ["+blockResourceLocation+"]. Error: "+e.getMessage(), e); LOGGER.warn("Unable to deserialize block with the resource location: ["+blockResourceLocation+"]. Error: "+e.getMessage(), e);
}
catch (Exception e)
{
LOGGER.warn("Unexpected error deserializing block with the resource location: ["+blockResourceLocation+"]. Error: "+e.getMessage(), e);
} }
} }
rendererIgnoredBlocks = blockStateWrappers; return blockStateWrappers;
return rendererIgnoredBlocks;
} }
@@ -177,42 +378,75 @@ public class BlockStateWrapper implements IBlockStateWrapper
//=================// //=================//
@Override @Override
public int getOpacity() public int getOpacity() { return this.opacity; }
private int calculateOpacity()
{ {
// use the cached opacity value if possible // get block properties (defaults to the values used by air)
if (this.opacity != -1) boolean canOcclude = this.getCanOcclude();
{ boolean propagatesSkyLightDown = this.getPropagatesSkyLightDown();
return this.opacity;
}
// this method isn't perfect, but works well enough for our use case // this method isn't perfect, but works well enough for our use case
int opacity; int opacity;
if (this.isAir()) if (this.isAir())
{ {
opacity = FULLY_TRANSPARENT; opacity = LodUtil.BLOCK_FULLY_TRANSPARENT;
} }
else if (this.isLiquid() && !this.blockState.canOcclude()) else if (this.isLiquid() && !canOcclude)
{ {
// probably not a waterlogged block (which should block light entirely) // probably not a waterlogged block (which should block light entirely)
// +1 to indicate that the block is translucent (in between transparent and opaque) // +1 to indicate that the block is translucent (in between transparent and opaque)
opacity = FULLY_TRANSPARENT + 1; opacity = LodUtil.BLOCK_FULLY_TRANSPARENT + 1;
} }
else if (this.blockState.propagatesSkylightDown(EmptyBlockGetter.INSTANCE, BlockPos.ZERO)) else if (propagatesSkyLightDown && !canOcclude)
{ {
opacity = FULLY_TRANSPARENT; // probably glass or some other fully transparent block
// !canOcclude is required to ignore stairs and slabs since
// propagateSkyLightDown is true for them, but they're solid and don't actually let light through
opacity = LodUtil.BLOCK_FULLY_TRANSPARENT;
} }
else else
{ {
// default for all other blocks // default for all other blocks
opacity = FULLY_OPAQUE; opacity = LodUtil.BLOCK_FULLY_OPAQUE;
} }
this.opacity = opacity; return opacity;
return this.opacity;
} }
private boolean getCanOcclude()
{
// defaults to the value used by air
boolean canOcclude = false;
if (this.blockState != null)
{
canOcclude = this.blockState.canOcclude();
}
return canOcclude;
}
private boolean getPropagatesSkyLightDown()
{
// defaults to the value used by air
boolean propagatesSkyLightDown = true;
if (this.blockState != null)
{
#if MC_VER < MC_1_21_3
propagatesSkyLightDown = this.blockState.propagatesSkylightDown(EmptyBlockGetter.INSTANCE, BlockPos.ZERO);
#else
propagatesSkyLightDown = this.blockState.propagatesSkylightDown();
#endif
}
return propagatesSkyLightDown;
}
@Override @Override
public int getLightEmission() { return (this.blockState != null) ? this.blockState.getLightEmission() : 0; } public int getLightEmission() { return (this.blockState != null) ? this.blockState.getLightEmission() : 0; }
@@ -239,7 +473,7 @@ public class BlockStateWrapper implements IBlockStateWrapper
} }
@Override @Override
public int hashCode() { return Objects.hash(this.getSerialString()); } public int hashCode() { return this.hashCode; }
@Override @Override
@@ -252,7 +486,12 @@ public class BlockStateWrapper implements IBlockStateWrapper
@Override @Override
public boolean isSolid() public boolean isSolid()
{ {
#if PRE_MC_1_20_1 if (this.isAir())
{
return false;
}
#if MC_VER < MC_1_20_1
return this.blockState.getMaterial().isSolid(); return this.blockState.getMaterial().isSolid();
#else #else
return !this.blockState.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO).isEmpty(); return !this.blockState.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO).isEmpty();
@@ -267,13 +506,30 @@ public class BlockStateWrapper implements IBlockStateWrapper
return false; return false;
} }
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
return this.blockState.getMaterial().isLiquid() || !this.blockState.getFluidState().isEmpty(); return this.blockState.getMaterial().isLiquid() || !this.blockState.getFluidState().isEmpty();
#else #else
return !this.blockState.getFluidState().isEmpty(); return !this.blockState.getFluidState().isEmpty();
#endif #endif
} }
@Override
public boolean isBeaconBlock() { return this.isBeaconBlock; }
@Override
public boolean isBeaconBaseBlock() { return this.isBeaconBaseBlock; }
@Override
public boolean isBeaconTintBlock() { return this.beaconTintColor != null; }
@Override
public boolean allowsBeaconBeamPassage() { return this.allowsBeaconBeamPassage; }
@Override
public Color getMapColor() { return this.mapColor; }
@Override
public Color getBeaconTintColor() { return this.beaconTintColor; }
@Override
public byte getMaterialId() { return this.blockMaterialId; }
@Override @Override
public String toString() { return this.getSerialString(); } public String toString() { return this.getSerialString(); }
@@ -293,18 +549,20 @@ public class BlockStateWrapper implements IBlockStateWrapper
// older versions of MC have a static registry // older versions of MC have a static registry
#if !(MC_1_16_5 || MC_1_17_1) #if MC_VER > MC_1_17_1
Level level = (Level)levelWrapper.getWrappedMcObject(); Level level = (Level)levelWrapper.getWrappedMcObject();
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess(); net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
#endif #endif
ResourceLocation resourceLocation; ResourceLocation resourceLocation;
#if MC_1_16_5 || MC_1_17_1 #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
resourceLocation = Registry.BLOCK.getKey(this.blockState.getBlock()); resourceLocation = Registry.BLOCK.getKey(this.blockState.getBlock());
#elif MC_1_18_2 || MC_1_19_2 #elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
resourceLocation = registryAccess.registryOrThrow(Registry.BLOCK_REGISTRY).getKey(this.blockState.getBlock()); resourceLocation = registryAccess.registryOrThrow(Registry.BLOCK_REGISTRY).getKey(this.blockState.getBlock());
#else #elif MC_VER < MC_1_21_3
resourceLocation = registryAccess.registryOrThrow(Registries.BLOCK).getKey(this.blockState.getBlock()); resourceLocation = registryAccess.registryOrThrow(Registries.BLOCK).getKey(this.blockState.getBlock());
#else
resourceLocation = registryAccess.lookupOrThrow(Registries.BLOCK).getKey(this.blockState.getBlock());
#endif #endif
@@ -325,103 +583,142 @@ public class BlockStateWrapper implements IBlockStateWrapper
/** will only work if a level is currently loaded */ /** will only work if a level is currently loaded */
public static IBlockStateWrapper deserialize(String resourceStateString, ILevelWrapper levelWrapper) throws IOException public static IBlockStateWrapper deserialize(String resourceStateString, ILevelWrapper levelWrapper) throws IOException
{ {
if (resourceStateString.equals(AIR_STRING) || resourceStateString.equals("")) // the empty string shouldn't normally happen, but just in case // we need the final string for the concurrent hash map later
final String finalResourceStateString = resourceStateString;
if (finalResourceStateString.equals(AIR_STRING) || finalResourceStateString.equals("")) // the empty string shouldn't normally happen, but just in case
{ {
return AIR; return AIR;
} }
// attempt to use the existing wrapper
if (WRAPPER_BY_RESOURCE_LOCATION.containsKey(finalResourceStateString))
// try to parse out the BlockState
String blockStatePropertiesString = null; // will be null if no properties were included
int stateSeparatorIndex = resourceStateString.indexOf(STATE_STRING_SEPARATOR);
if (stateSeparatorIndex != -1)
{ {
// blockstate properties found return WRAPPER_BY_RESOURCE_LOCATION.get(finalResourceStateString);
blockStatePropertiesString = resourceStateString.substring(stateSeparatorIndex + STATE_STRING_SEPARATOR.length());
resourceStateString = resourceStateString.substring(0, stateSeparatorIndex);
} }
// parse the resource location
int resourceSeparatorIndex = resourceStateString.indexOf(RESOURCE_LOCATION_SEPARATOR);
if (resourceSeparatorIndex == -1)
{
throw new IOException("Unable to parse Resource Location out of string: [" + resourceStateString + "].");
}
ResourceLocation resourceLocation = new ResourceLocation(resourceStateString.substring(0, resourceSeparatorIndex), resourceStateString.substring(resourceSeparatorIndex + 1));
// if no wrapper is found, default to air
// attempt to get the BlockState from all possible BlockStates BlockStateWrapper foundWrapper = AIR;
try try
{ {
// try to parse out the BlockState
#if !(MC_1_16_5 || MC_1_17_1) String blockStatePropertiesString = null; // will be null if no properties were included
// use the given level if possible, otherwise try using the currently loaded one int stateSeparatorIndex = resourceStateString.indexOf(STATE_STRING_SEPARATOR);
Level level = (levelWrapper != null ? (Level)levelWrapper.getWrappedMcObject() : null); if (stateSeparatorIndex != -1)
level = (level == null ? Minecraft.getInstance().level : level);
#endif
Block block;
#if MC_1_16_5 || MC_1_17_1
block = Registry.BLOCK.get(resourceLocation);
#elif MC_1_18_2 || MC_1_19_2
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
block = registryAccess.registryOrThrow(Registry.BLOCK_REGISTRY).get(resourceLocation);
#else
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
block = registryAccess.registryOrThrow(Registries.BLOCK).get(resourceLocation);
#endif
if (block == null)
{ {
// shouldn't normally happen, but here to make the compiler happy // blockstate properties found
if (!BrokenResourceLocations.contains(resourceLocation)) blockStatePropertiesString = resourceStateString.substring(stateSeparatorIndex + STATE_STRING_SEPARATOR.length());
{ resourceStateString = resourceStateString.substring(0, stateSeparatorIndex);
BrokenResourceLocations.add(resourceLocation); }
LOGGER.warn("Unable to find BlockState with the resourceLocation [" + resourceLocation + "] and properties: [" + blockStatePropertiesString + "]. Air will be used instead, some data may be lost.");
} // parse the resource location
return AIR; int separatorIndex = resourceStateString.indexOf(RESOURCE_LOCATION_SEPARATOR);
if (separatorIndex == -1)
{
throw new IOException("Unable to parse Resource Location out of string: [" + resourceStateString + "].");
}
ResourceLocation resourceLocation;
try
{
#if MC_VER < MC_1_21_1
resourceLocation = new ResourceLocation(resourceStateString.substring(0, separatorIndex), resourceStateString.substring(separatorIndex + 1));
#else
resourceLocation = ResourceLocation.fromNamespaceAndPath(resourceStateString.substring(0, separatorIndex), resourceStateString.substring(separatorIndex + 1));
#endif
}
catch (Exception e)
{
throw new IOException("No Resource Location found for the string: [" + resourceStateString + "] Error: [" + e.getMessage() + "].");
} }
// attempt to find the blockstate from all possibilities
BlockState foundState = null; // attempt to get the BlockState from all possible BlockStates
if (blockStatePropertiesString != null) try
{ {
List<BlockState> possibleStateList = block.getStateDefinition().getPossibleStates();
for (BlockState possibleState : possibleStateList) #if MC_VER > MC_1_17_1
LodUtil.assertTrue(levelWrapper != null && levelWrapper.getWrappedMcObject() != null);
Level level = (Level)levelWrapper.getWrappedMcObject();
#endif
Block block;
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
block = Registry.BLOCK.get(resourceLocation);
#elif MC_VER == MC_1_18_2 || MC_VER == MC_1_19_2
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
block = registryAccess.registryOrThrow(Registry.BLOCK_REGISTRY).get(resourceLocation);
#elif MC_VER < MC_1_21_3
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
block = registryAccess.registryOrThrow(Registries.BLOCK).get(resourceLocation);
#else
net.minecraft.core.RegistryAccess registryAccess = level.registryAccess();
Optional<Holder.Reference<Block>> optionalBlockHolder = registryAccess.lookupOrThrow(Registries.BLOCK).get(resourceLocation);
block = optionalBlockHolder.isPresent() ? optionalBlockHolder.get().value() : null;
#endif
if (block == null)
{ {
String possibleStatePropertiesString = serializeBlockStateProperties(possibleState); // shouldn't normally happen, but here to make the compiler happy
if (possibleStatePropertiesString.equals(blockStatePropertiesString)) if (!BROKEN_RESOURCE_LOCATIONS.contains(resourceLocation))
{ {
foundState = possibleState; BROKEN_RESOURCE_LOCATIONS.add(resourceLocation);
break; LOGGER.warn("Unable to find BlockState with the resourceLocation [" + resourceLocation + "] and properties: [" + blockStatePropertiesString + "]. Air will be used instead, some data may be lost.");
} }
return AIR;
} }
}
// use the default if no state was found or given // attempt to find the blockstate from all possibilities
if (foundState == null) BlockState foundState = null;
{
if (blockStatePropertiesString != null) if (blockStatePropertiesString != null)
{ {
// we should have found a blockstate, but didn't List<BlockState> possibleStateList = block.getStateDefinition().getPossibleStates();
if (!BrokenResourceLocations.contains(resourceLocation)) for (BlockState possibleState : possibleStateList)
{ {
BrokenResourceLocations.add(resourceLocation); String possibleStatePropertiesString = serializeBlockStateProperties(possibleState);
LOGGER.warn("Unable to find BlockState for Block [" + resourceLocation + "] with properties: [" + blockStatePropertiesString + "]. Using the default block state."); if (possibleStatePropertiesString.equals(blockStatePropertiesString))
{
foundState = possibleState;
break;
}
} }
} }
foundState = block.defaultBlockState(); // use the default if no state was found or given
if (foundState == null)
{
if (blockStatePropertiesString != null)
{
// we should have found a blockstate, but didn't
if (!BROKEN_RESOURCE_LOCATIONS.contains(resourceLocation))
{
BROKEN_RESOURCE_LOCATIONS.add(resourceLocation);
LOGGER.warn("Unable to find BlockState for Block [" + resourceLocation + "] with properties: [" + blockStatePropertiesString + "]. Using the default block state.");
}
}
foundState = block.defaultBlockState();
}
foundWrapper = new BlockStateWrapper(foundState, levelWrapper);
return foundWrapper;
}
catch (Exception e)
{
throw new IOException("Failed to deserialize the string [" + finalResourceStateString + "] into a BlockStateWrapper: " + e.getMessage(), e);
} }
return new BlockStateWrapper(foundState, levelWrapper);
} }
catch (Exception e) finally
{ {
throw new IOException("Failed to deserialize the string [" + resourceStateString + "] into a BlockStateWrapper: " + e.getMessage(), e); // put if absent in case two threads deserialize at the same time
// unfortunately we can't put everything in a computeIfAbsent() since we also throw exceptions
WRAPPER_BY_RESOURCE_LOCATION.putIfAbsent(finalResourceStateString, foundWrapper);
} }
} }
@@ -457,4 +754,111 @@ public class BlockStateWrapper implements IBlockStateWrapper
//==============//
// Iris methods //
//==============//
private EDhApiBlockMaterial calculateEDhApiBlockMaterialId()
{
if (this.blockState == null)
{
return EDhApiBlockMaterial.AIR;
}
String serialString = this.getSerialString().toLowerCase();
if (this.blockState.is(BlockTags.LEAVES)
|| serialString.contains("bamboo")
|| serialString.contains("cactus")
|| serialString.contains("chorus_flower")
|| serialString.contains("mushroom")
)
{
return EDhApiBlockMaterial.LEAVES;
}
else if (this.blockState.is(Blocks.LAVA))
{
return EDhApiBlockMaterial.LAVA;
}
else if (this.isLiquid() || this.blockState.is(Blocks.WATER))
{
return EDhApiBlockMaterial.WATER;
}
else if (this.blockState.getSoundType() == SoundType.WOOD
|| serialString.contains("root")
#if MC_VER >= MC_1_19_4
|| this.blockState.getSoundType() == SoundType.CHERRY_WOOD
#endif
)
{
return EDhApiBlockMaterial.WOOD;
}
else if (this.blockState.getSoundType() == SoundType.METAL
#if MC_VER >= MC_1_19_2
|| this.blockState.getSoundType() == SoundType.COPPER
#endif
#if MC_VER >= MC_1_20_4
|| this.blockState.getSoundType() == SoundType.COPPER_BULB
|| this.blockState.getSoundType() == SoundType.COPPER_GRATE
#endif
)
{
return EDhApiBlockMaterial.METAL;
}
else if (serialString.contains("grass_block"))
{
return EDhApiBlockMaterial.GRASS;
}
else if (
serialString.contains("dirt")
|| serialString.contains("gravel")
|| serialString.contains("mud")
|| serialString.contains("podzol")
|| serialString.contains("mycelium")
)
{
return EDhApiBlockMaterial.DIRT;
}
#if MC_VER >= MC_1_17_1
else if (this.blockState.getSoundType() == SoundType.DEEPSLATE
|| this.blockState.getSoundType() == SoundType.DEEPSLATE_BRICKS
|| this.blockState.getSoundType() == SoundType.DEEPSLATE_TILES
|| this.blockState.getSoundType() == SoundType.POLISHED_DEEPSLATE
|| serialString.contains("deepslate") )
{
return EDhApiBlockMaterial.DEEPSLATE;
}
#endif
else if (this.serialString.contains("snow"))
{
return EDhApiBlockMaterial.SNOW;
}
else if (serialString.contains("sand"))
{
return EDhApiBlockMaterial.SAND;
}
else if (serialString.contains("terracotta"))
{
return EDhApiBlockMaterial.TERRACOTTA;
}
else if (this.blockState.is(BlockTags.BASE_STONE_NETHER))
{
return EDhApiBlockMaterial.NETHER_STONE;
}
else if (serialString.contains("stone")
|| serialString.contains("ore"))
{
return EDhApiBlockMaterial.STONE;
}
else if (this.blockState.getLightEmission() > 0)
{
return EDhApiBlockMaterial.ILLUMINATED;
}
else
{
return EDhApiBlockMaterial.UNKNOWN;
}
}
} }
@@ -0,0 +1,542 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.block;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.util.ColorUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.core.Direction;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.FlowerBlock;
import net.minecraft.world.level.block.LeavesBlock;
import net.minecraft.world.level.block.RotatedPillarBlock;
#if MC_VER >= MC_1_19_2
import net.minecraft.util.RandomSource;
#else
import java.util.Random;
#endif
import net.minecraft.world.level.block.state.BlockState;
import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
#if MC_VER < MC_1_21_5
#else
import net.minecraft.client.renderer.block.model.BlockModelPart;
#endif
/**
* This stores and calculates the colors
* the given {@link BlockState} should have based
* on the given {@link IClientLevelWrapper}.
*
* @see ColorUtil
*/
public class ClientBlockStateColorCache
{
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private static final HashSet<BlockState> BLOCK_STATES_THAT_NEED_LEVEL = new HashSet<>();
private static final HashSet<BlockState> BROKEN_BLOCK_STATES = new HashSet<>();
/**
* Methods using MC's "RandomSource" object aren't thread safe <br>
* so we need to put locks around that logic. <br>
* specifically:
* <code>
* getBlockModel(this.blockState).getQuads(this.blockState, direction, RANDOM)
* </code>
*/
private static final ReentrantLock RESOLVE_LOCK = new ReentrantLock();
/** This is the order each direction on a block is processed when attempting to get the texture/color */
private static final Direction[] COLOR_RESOLUTION_DIRECTION_ORDER = { Direction.UP, Direction.NORTH, Direction.EAST, Direction.WEST, Direction.SOUTH, Direction.DOWN };
private static final int FLOWER_COLOR_SCALE = 5;
#if MC_VER < MC_1_19_2
private static final Random RANDOM = new Random(0);
#else
/** Note: this object isn't thread safe and must be put in a lock */
private static final RandomSource RANDOM = RandomSource.create();
#endif
private final IClientLevelWrapper clientLevelWrapper;
private final BlockState blockState;
private final LevelReader level;
private boolean isColorResolved = false;
private int baseColor = 0;
private boolean needShade = true;
private boolean needPostTinting = false;
private int tintIndex = 0;
//===========//
// constants //
//===========//
private static final int MIN_SRGB_BITS = 0x39000000; // 2^(-13)
private static final int MAX_SRGB_BITS = 0x3f7fffff; // 1.0 - f32::EPSILON
private static final float MIN_SRGB_BOUND = Float.intBitsToFloat(MIN_SRGB_BITS);
private static final float MAX_SRGB_BOUND = Float.intBitsToFloat(MAX_SRGB_BITS);
private static final int[] linearToSrgbTable = new int[]
{
0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
};
private static final float[] srgbToLinearTable = new float[]
{
0.0f, 0.000303527f, 0.000607054f, 0.00091058103f, 0.001214108f, 0.001517635f, 0.0018211621f, 0.002124689f,
0.002428216f, 0.002731743f, 0.00303527f, 0.0033465356f, 0.003676507f, 0.004024717f, 0.004391442f,
0.0047769533f, 0.005181517f, 0.0056053917f, 0.0060488326f, 0.006512091f, 0.00699541f, 0.0074990317f,
0.008023192f, 0.008568125f, 0.009134057f, 0.009721218f, 0.010329823f, 0.010960094f, 0.011612245f,
0.012286487f, 0.012983031f, 0.013702081f, 0.014443844f, 0.015208514f, 0.015996292f, 0.016807375f,
0.017641952f, 0.018500218f, 0.019382361f, 0.020288562f, 0.02121901f, 0.022173883f, 0.023153365f,
0.02415763f, 0.025186857f, 0.026241222f, 0.027320892f, 0.028426038f, 0.029556843f, 0.03071345f, 0.03189604f,
0.033104774f, 0.03433981f, 0.035601325f, 0.036889452f, 0.038204376f, 0.039546248f, 0.04091521f, 0.042311423f,
0.043735042f, 0.045186214f, 0.046665095f, 0.048171833f, 0.049706575f, 0.051269468f, 0.052860655f, 0.05448028f,
0.056128494f, 0.057805434f, 0.05951124f, 0.06124607f, 0.06301003f, 0.06480328f, 0.06662595f, 0.06847818f,
0.07036011f, 0.07227186f, 0.07421358f, 0.07618539f, 0.07818743f, 0.08021983f, 0.082282715f, 0.084376216f,
0.086500466f, 0.088655606f, 0.09084173f, 0.09305898f, 0.095307484f, 0.09758736f, 0.09989874f, 0.10224175f,
0.10461649f, 0.10702311f, 0.10946172f, 0.111932434f, 0.11443538f, 0.116970696f, 0.11953845f, 0.12213881f,
0.12477186f, 0.12743773f, 0.13013652f, 0.13286836f, 0.13563336f, 0.13843165f, 0.14126332f, 0.1441285f,
0.1470273f, 0.14995982f, 0.15292618f, 0.1559265f, 0.15896086f, 0.16202943f, 0.16513224f, 0.16826946f,
0.17144115f, 0.17464745f, 0.17788847f, 0.1811643f, 0.18447503f, 0.1878208f, 0.19120172f, 0.19461787f,
0.19806935f, 0.2015563f, 0.20507877f, 0.2086369f, 0.21223079f, 0.21586053f, 0.21952623f, 0.22322798f,
0.22696589f, 0.23074007f, 0.23455065f, 0.23839766f, 0.2422812f, 0.2462014f, 0.25015837f, 0.25415218f,
0.2581829f, 0.26225072f, 0.26635566f, 0.27049786f, 0.27467737f, 0.27889434f, 0.2831488f, 0.2874409f,
0.2917707f, 0.29613832f, 0.30054384f, 0.30498737f, 0.30946895f, 0.31398875f, 0.31854683f, 0.32314324f,
0.32777813f, 0.33245158f, 0.33716366f, 0.34191445f, 0.3467041f, 0.3515327f, 0.35640025f, 0.36130688f,
0.3662527f, 0.37123778f, 0.37626222f, 0.3813261f, 0.38642952f, 0.39157256f, 0.3967553f, 0.40197787f,
0.4072403f, 0.4125427f, 0.41788515f, 0.42326775f, 0.42869055f, 0.4341537f, 0.43965724f, 0.44520125f,
0.45078585f, 0.45641106f, 0.46207705f, 0.46778384f, 0.47353154f, 0.47932023f, 0.48514998f, 0.4910209f,
0.49693304f, 0.5028866f, 0.50888145f, 0.5149178f, 0.5209957f, 0.52711535f, 0.5332766f, 0.5394797f,
0.5457247f, 0.5520116f, 0.5583406f, 0.5647117f, 0.57112503f, 0.57758063f, 0.5840786f, 0.590619f, 0.597202f,
0.60382754f, 0.61049575f, 0.61720675f, 0.62396055f, 0.63075733f, 0.637597f, 0.6444799f, 0.6514058f,
0.65837497f, 0.66538745f, 0.67244333f, 0.6795426f, 0.68668544f, 0.69387203f, 0.70110214f, 0.70837605f,
0.7156938f, 0.72305536f, 0.730461f, 0.7379107f, 0.7454045f, 0.75294244f, 0.76052475f, 0.7681514f, 0.77582246f,
0.78353804f, 0.79129815f, 0.79910296f, 0.8069525f, 0.8148468f, 0.822786f, 0.8307701f, 0.83879924f, 0.84687346f,
0.8549928f, 0.8631574f, 0.87136734f, 0.8796226f, 0.8879232f, 0.89626956f, 0.90466136f, 0.913099f, 0.92158204f,
0.93011117f, 0.9386859f, 0.9473069f, 0.9559735f, 0.9646866f, 0.9734455f, 0.98225087f, 0.9911022f, 1.0f
};
//=============//
// constructor //
//=============//
public ClientBlockStateColorCache(BlockState blockState, IClientLevelWrapper samplingLevel)
{
this.blockState = blockState;
this.clientLevelWrapper = samplingLevel;
this.level = (LevelReader) samplingLevel.getWrappedMcObject();
this.resolveColors();
}
//===================//
// color calculation //
//===================//
private void resolveColors()
{
if (this.isColorResolved)
{
return;
}
try
{
// getQuads() isn't thread safe so we need to put this logic in a lock
RESOLVE_LOCK.lock();
if (this.blockState.getFluidState().isEmpty())
{
// look for the first non-empty direction
List<BakedQuad> quads = null;
for (Direction direction : COLOR_RESOLUTION_DIRECTION_ORDER)
{
quads = this.getQuadsForDirection(direction);
if (quads != null && !quads.isEmpty()
&& !(
this.blockState.getBlock() instanceof RotatedPillarBlock
&& direction == Direction.UP
)
)
{
break;
}
}
if (quads == null || quads.isEmpty())
{
quads = this.getUnculledQuads();
}
if (quads != null
&& !quads.isEmpty()
&& quads.get(0) != null)
{
BakedQuad firstQuad = quads.get(0);
this.needPostTinting = firstQuad.isTinted();
#if MC_VER <= MC_1_21_4
this.needShade = firstQuad.isShade();
this.tintIndex = firstQuad.getTintIndex();
#else
this.needShade = firstQuad.shade();
this.tintIndex = firstQuad.tintIndex();
#endif
#if MC_VER < MC_1_17_1
this.baseColor = calculateColorFromTexture(
firstQuad.sprite,
ColorMode.getColorMode(this.blockState.getBlock()));
#elif MC_VER < MC_1_21_5
this.baseColor = calculateColorFromTexture(
firstQuad.getSprite(),
ColorMode.getColorMode(this.blockState.getBlock()));
#else
this.baseColor = calculateColorFromTexture(
firstQuad.sprite(),
ColorMode.getColorMode(this.blockState.getBlock()));
#endif
}
else
{
// Backup method.
this.needPostTinting = false;
this.needShade = false;
this.tintIndex = 0;
this.baseColor = this.getParticleIconColor();
}
}
else
{
// Liquid Block
this.needPostTinting = true;
this.needShade = false;
this.tintIndex = 0;
this.baseColor = this.getParticleIconColor();
}
this.isColorResolved = true;
}
finally
{
RESOLVE_LOCK.unlock();
}
}
@Nullable
private List<BakedQuad> getUnculledQuads() { return this.getQuadsForDirection(null); }
@Nullable
private List<BakedQuad> getQuadsForDirection(@Nullable Direction direction)
{
List<BakedQuad> quads = null;
#if MC_VER < MC_1_21_5
quads = Minecraft.getInstance().getModelManager().getBlockModelShaper().
getBlockModel(this.blockState).getQuads(this.blockState, direction, RANDOM);
#else
List<BlockModelPart> blockModelPartList = Minecraft.getInstance().getModelManager().getBlockModelShaper().
getBlockModel(this.blockState).collectParts(RANDOM);
quads = new ArrayList<>();
if (blockModelPartList != null)
{
for (int i = 0; i < blockModelPartList.size(); i++)
{
// if direction is null this will return the unculled quads
quads.addAll(blockModelPartList.get(i).getQuads(direction));
}
}
#endif
return quads;
}
//TODO: Perhaps make this not just use the first frame?
private static int calculateColorFromTexture(TextureAtlasSprite texture, ColorMode colorMode)
{
int count = 0;
int alpha = 0;
double red = 0;
double green = 0;
double blue = 0;
int tempColor;
// don't render Chiseled blocks.
// Since ColorMode is set per block, you only need to check this once.
if (colorMode != ColorMode.Chisel)
{
// textures normally use u and v instead of x and y
for (int v = 0; v < getTextureHeight(texture); v++)
{
for (int u = 0; u < getTextureWidth(texture); u++)
{
//note: Minecraft color format is: 0xAA BB GG RR
//________ DH mod color format is: 0xAA RR GG BB
//OpenGL RGBA format native order: 0xRR GG BB AA
//_ OpenGL RGBA format Java Order: 0xAA BB GG RR
tempColor = TextureAtlasSpriteWrapper.getPixelRGBA(texture, 0, u, v);
int r = (tempColor & 0x000000FF);
int g = (tempColor & 0x0000FF00) >>> 8;
int b = (tempColor & 0x00FF0000) >>> 16;
int a = (tempColor & 0xFF000000) >>> 24;
int scale = 1;
if (colorMode == ColorMode.Leaves)
{
//switch (//FIXME add config option)
// case BLACK:
// a = 255; //simulate black background of fast leaves
// break;
// case IGNORE:
if (a == 0) {
continue; //same long grass
}
else
{
a = 255; //just in case there are semi transparent pixels
}
// break;
// case TRANSPARENT:
// break; //do nothing, let it count towards transparency
}
else if (a == 0 && colorMode != ColorMode.Glass)
{
continue;
}
else if (colorMode == ColorMode.Flower && (g + 25 < b || g + 25 < r))
{
scale = FLOWER_COLOR_SCALE;
}
count += scale;
//apparently alpha is linear
alpha += a * scale;
//gamma correction is complicated
red += srgbToLinearTable[r] * a * scale;
green += srgbToLinearTable[g] * a * scale;
blue += srgbToLinearTable[b] * a * scale;
}
}
}
if (count == 0)
{
// this block is entirely transparent
tempColor = ColorUtil.argbToInt(0, 255, 255, 255);
}
else
{
// determine the average color
tempColor = ColorUtil.argbToInt(
alpha / count,
linearToSrgb((float) (red / (double) alpha)),
linearToSrgb((float) (green / (double) alpha)),
linearToSrgb((float) (blue / (double) alpha)));
}
//check if not missing texture
if (tempColor == ColorUtil.argbToInt(255, 182, 0, 182))
{
//make it not render at all
tempColor = ColorUtil.argbToInt(0, 255, 255, 255);
}
return tempColor;
}
private static int getTextureWidth(TextureAtlasSprite texture)
{
#if MC_VER < MC_1_19_4
return texture.getWidth();
#else
return texture.contents().width();
#endif
}
private static int getTextureHeight(TextureAtlasSprite texture)
{
#if MC_VER < MC_1_19_4
return texture.getHeight();
#else
return texture.contents().height();
#endif
}
/**
* This method was suggested by IMS from the Iris/Sodium team.
* That's where the numbers and code are based.
*/
private static int linearToSrgb(float c)
{
if (!(c > MIN_SRGB_BOUND)) {
c = MIN_SRGB_BOUND;
}
if (c > MAX_SRGB_BOUND) {
c = MAX_SRGB_BOUND;
}
int inputBits = Float.floatToRawIntBits(c);
int entry = linearToSrgbTable[((inputBits - MIN_SRGB_BITS) >> 20)];
int bias = (entry >>> 16) << 9;
int scale = entry & 0xffff;
int t = (inputBits >>> 12) & 0xff;
return (bias + (scale * t)) >>> 16;
}
private int getParticleIconColor()
{
return calculateColorFromTexture(
Minecraft.getInstance().getModelManager().getBlockModelShaper().getParticleIcon(this.blockState),
ColorMode.getColorMode(this.blockState.getBlock()));
}
//===============//
// public getter //
//===============//
public int getColor(BiomeWrapper biome, DhBlockPos pos)
{
// only get the tint if the block needs to be tinted
if (!this.needPostTinting)
{
return this.baseColor;
}
// don't try tinting blocks that don't support our method of tint getting
if (BROKEN_BLOCK_STATES.contains(this.blockState))
{
return this.baseColor;
}
// attempt to get the tint
int tintColor = -1;
try
{
// try to use the fast tint getter logic first
if (!BLOCK_STATES_THAT_NEED_LEVEL.contains(this.blockState))
{
try
{
tintColor = Minecraft.getInstance().getBlockColors()
.getColor(this.blockState, new TintWithoutLevelOverrider(biome, this.clientLevelWrapper), McObjectConverter.Convert(pos), this.tintIndex);
}
catch (UnsupportedOperationException e)
{
// this exception generally occurs if the tint requires other blocks besides itself
LOGGER.debug("Unable to use ["+TintWithoutLevelOverrider.class.getSimpleName()+"] to get the block tint for block: [" + this.blockState + "] and biome: [" + biome + "] at pos: " + pos + ". Error: [" + e.getMessage() + "]. Attempting to use backup method...", e);
BLOCK_STATES_THAT_NEED_LEVEL.add(this.blockState);
}
}
// use the level logic only if requested
if (BLOCK_STATES_THAT_NEED_LEVEL.contains(this.blockState))
{
// this logic can't be used all the time due to it breaking some blocks tinting
// specifically oceans don't render correctly
tintColor = Minecraft.getInstance().getBlockColors()
.getColor(this.blockState, new TintGetterOverrideFast(this.level), McObjectConverter.Convert(pos), this.tintIndex);
}
}
catch (Exception e)
{
// only display the error once per block/biome type to reduce log spam
if (!BROKEN_BLOCK_STATES.contains(this.blockState))
{
LOGGER.warn("Failed to get block color for block: [" + this.blockState + "] and biome: [" + biome + "] at pos: " + pos + ". Error: ["+e.getMessage() + "]. Note: future errors for this block/biome will be ignored.", e);
BROKEN_BLOCK_STATES.add(this.blockState);
}
}
if (tintColor != -1)
{
return ColorUtil.multiplyARGBwithRGB(this.baseColor, tintColor);
}
else
{
// unable to get the tinted color, use the base color instead
return this.baseColor;
}
}
//================//
// helper classes //
//================//
enum ColorMode
{
Default,
Flower,
Leaves,
Chisel,
Glass;
static ColorMode getColorMode(Block block)
{
if (block instanceof LeavesBlock) return Leaves;
if (block instanceof FlowerBlock) return Flower;
if (block.toString().contains("glass")) return Glass;
if (block.toString().equals("Block{chiselsandbits:chiseled}")) return Chisel;
return Default;
}
}
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,9 +19,15 @@
package com.seibel.distanthorizons.common.wrappers.block; package com.seibel.distanthorizons.common.wrappers.block;
import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.TextureAtlasSprite;
#if MC_VER < MC_1_17_1
#elif MC_VER < MC_1_21_3
#else
import com.seibel.distanthorizons.core.util.ColorUtil;
import net.minecraft.client.renderer.texture.SpriteContents;
#endif
/** /**
* For wrapping/utilizing around TextureAtlasSprite * For wrapping/utilizing around TextureAtlasSprite
* *
@@ -29,35 +35,42 @@ import net.minecraft.client.renderer.texture.TextureAtlasSprite;
*/ */
public class TextureAtlasSpriteWrapper public class TextureAtlasSpriteWrapper
{ {
/**
* This code is from Minecraft Forge
* Which is licensed under the terms of GNU Lesser General Public License
* as published by the Free Software Foundation version 2.1
* of the License.
*
* The code has been modified to use TextureAtlasSprite
*/
public static int getPixelRGBA(TextureAtlasSprite sprite, int frameIndex, int x, int y) public static int getPixelRGBA(TextureAtlasSprite sprite, int frameIndex, int x, int y)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return sprite.mainImage[0].getPixelRGBA( return sprite.mainImage[0].getPixelRGBA(
x + sprite.framesX[frameIndex] * sprite.getWidth(), x + sprite.framesX[frameIndex] * sprite.getWidth(),
y + sprite.framesY[frameIndex] * sprite.getHeight()); y + sprite.framesY[frameIndex] * sprite.getHeight());
#elif PRE_MC_1_19_4 #elif MC_VER < MC_1_19_4
if (sprite.animatedTexture != null) if (sprite.animatedTexture != null)
{ {
x += sprite.animatedTexture.getFrameX(frameIndex) * sprite.width; x += sprite.animatedTexture.getFrameX(frameIndex) * sprite.width;
y += sprite.animatedTexture.getFrameY(frameIndex) * sprite.height; y += sprite.animatedTexture.getFrameY(frameIndex) * sprite.height;
} }
return sprite.mainImage[0].getPixelRGBA(x, y); return sprite.mainImage[0].getPixelRGBA(x, y);
#else #elif MC_VER < MC_1_21_3
if (sprite.contents().animatedTexture != null) if (sprite.contents().animatedTexture != null)
{ {
x += sprite.contents().animatedTexture.getFrameX(frameIndex) * sprite.contents().width(); x += sprite.contents().animatedTexture.getFrameX(frameIndex) * sprite.contents().width();
y += sprite.contents().animatedTexture.getFrameY(frameIndex) * sprite.contents().width(); y += sprite.contents().animatedTexture.getFrameY(frameIndex) * sprite.contents().width();
} }
return sprite.contents().originalImage.getPixelRGBA(x, y); return sprite.contents().originalImage.getPixelRGBA(x, y);
#else
SpriteContents content = sprite.contents(); // don't close, otherwise MC will be corrupted and you won't be able to re-access the texture
if (content.animatedTexture != null)
{
x += content.animatedTexture.getFrameX(frameIndex) * content.width();
y += content.animatedTexture.getFrameY(frameIndex) * content.width();
}
int abgr = content.originalImage.getPixel(x, y);
// re-pack the color so we can access it normally
int a = (abgr & 0xFF000000) >>> 24;
int b = (abgr & 0x00FF0000) >>> 16;
int g = (abgr & 0x0000FF00) >>> 8;
int r = (abgr & 0x000000FF);
return ColorUtil.argbToInt(a, r, g, b);
#endif #endif
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,7 +19,6 @@
package com.seibel.distanthorizons.common.wrappers.block; package com.seibel.distanthorizons.common.wrappers.block;
import com.seibel.distanthorizons.common.LodCommonMain;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction; import net.minecraft.core.Direction;
import net.minecraft.world.level.*; import net.minecraft.world.level.*;
@@ -43,201 +42,153 @@ public class TintGetterOverrideFast implements BlockAndTintGetter
{ {
LevelReader parent; LevelReader parent;
public TintGetterOverrideFast(LevelReader parent)
{
this.parent = parent; //=============//
} // constructor //
//=============//
public TintGetterOverrideFast(LevelReader parent) { this.parent = parent; }
//=========//
// methods //
//=========//
private Biome _getBiome(BlockPos pos) private Biome _getBiome(BlockPos pos)
{ {
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
return parent.getBiome(pos).value(); return this.parent.getBiome(pos).value();
#else #else
return parent.getBiome(pos); return parent.getBiome(pos);
#endif #endif
} }
@Override @Override
public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) { return colorResolver.getColor(this._getBiome(blockPos), blockPos.getX(), blockPos.getZ()); }
{
if (LodCommonMain.forgeMethodCaller != null)
{
return LodCommonMain.forgeMethodCaller.colorResolverGetColor(colorResolver, _getBiome(blockPos),
blockPos.getX(), blockPos.getZ());
}
else
{
return colorResolver.getColor(_getBiome(blockPos), blockPos.getX(), blockPos.getZ());
}
}
@Override @Override
public float getShade(Direction direction, boolean bl) { return this.parent.getShade(direction, bl); } public float getShade(Direction direction, boolean bl) { return this.parent.getShade(direction, bl); }
@Override @Override
public LevelLightEngine getLightEngine() public LevelLightEngine getLightEngine() { return this.parent.getLightEngine(); }
{
return parent.getLightEngine();
}
@Override @Override
public int getBrightness(LightLayer lightLayer, BlockPos blockPos) public int getBrightness(LightLayer lightLayer, BlockPos blockPos) { return this.parent.getBrightness(lightLayer, blockPos); }
{
return parent.getBrightness(lightLayer, blockPos);
}
@Override @Override
public int getRawBrightness(BlockPos blockPos, int i) public int getRawBrightness(BlockPos blockPos, int i) { return this.parent.getRawBrightness(blockPos, i); }
{
return parent.getRawBrightness(blockPos, i);
}
@Override @Override
public boolean canSeeSky(BlockPos blockPos) public boolean canSeeSky(BlockPos blockPos) { return this.parent.canSeeSky(blockPos); }
{
return parent.canSeeSky(blockPos);
}
@Override @Override
@Nullable @Nullable
public BlockEntity getBlockEntity(BlockPos blockPos) public BlockEntity getBlockEntity(BlockPos blockPos) { return this.parent.getBlockEntity(blockPos); }
{
return parent.getBlockEntity(blockPos);
}
@Override @Override
public BlockState getBlockState(BlockPos blockPos) public BlockState getBlockState(BlockPos blockPos) { return this.parent.getBlockState(blockPos); }
{
return parent.getBlockState(blockPos);
}
@Override @Override
public FluidState getFluidState(BlockPos blockPos) public FluidState getFluidState(BlockPos blockPos) { return this.parent.getFluidState(blockPos); }
{
return parent.getFluidState(blockPos);
}
@Override @Override
public int getLightEmission(BlockPos blockPos) public int getLightEmission(BlockPos blockPos) { return this.parent.getLightEmission(blockPos); }
{
return parent.getLightEmission(blockPos);
}
#if MC_VER < MC_1_21_3
@Override @Override
public int getMaxLightLevel() public int getMaxLightLevel() { return parent.getMaxLightLevel(); }
{ #else
return parent.getMaxLightLevel(); #endif
}
@Override @Override
public Stream<BlockState> getBlockStates(AABB aABB) public Stream<BlockState> getBlockStates(AABB aABB)
{ { return this.parent.getBlockStates(aABB); }
return parent.getBlockStates(aABB);
}
@Override @Override
public BlockHitResult clip(ClipContext clipContext) public BlockHitResult clip(ClipContext clipContext)
{ { return this.parent.clip(clipContext); }
return parent.clip(clipContext);
}
@Override @Override
@Nullable @Nullable
public BlockHitResult clipWithInteractionOverride(Vec3 vec3, Vec3 vec32, BlockPos blockPos, VoxelShape voxelShape, BlockState blockState) public BlockHitResult clipWithInteractionOverride(Vec3 vec3, Vec3 vec32, BlockPos blockPos, VoxelShape voxelShape, BlockState blockState)
{ { return this.parent.clipWithInteractionOverride(vec3, vec32, blockPos, voxelShape, blockState); }
return parent.clipWithInteractionOverride(vec3, vec32, blockPos, voxelShape, blockState);
}
@Override @Override
public double getBlockFloorHeight(VoxelShape voxelShape, Supplier<VoxelShape> supplier) public double getBlockFloorHeight(VoxelShape voxelShape, Supplier<VoxelShape> supplier)
{ { return this.parent.getBlockFloorHeight(voxelShape, supplier); }
return parent.getBlockFloorHeight(voxelShape, supplier);
}
@Override @Override
public double getBlockFloorHeight(BlockPos blockPos) public double getBlockFloorHeight(BlockPos blockPos) { return this.parent.getBlockFloorHeight(blockPos); }
{
return parent.getBlockFloorHeight(blockPos);
}
#if MC_VER < MC_1_21_3
@Override @Override
public int getMaxBuildHeight() public int getMaxBuildHeight() { return this.parent.getMaxBuildHeight(); }
{ #else
return parent.getMaxBuildHeight(); @Override
} public int getMaxY() { return this.parent.getMaxY(); }
#endif
#if POST_MC_1_17_1
//==============//
// post MC 1.17 //
//==============//
#if MC_VER >= MC_1_17_1
@Override @Override
public <T extends BlockEntity> Optional<T> getBlockEntity(BlockPos blockPos, BlockEntityType<T> blockEntityType) public <T extends BlockEntity> Optional<T> getBlockEntity(BlockPos blockPos, BlockEntityType<T> blockEntityType)
{ { return this.parent.getBlockEntity(blockPos, blockEntityType); }
return parent.getBlockEntity(blockPos, blockEntityType);
}
@Override @Override
public BlockHitResult isBlockInLine(ClipBlockStateContext clipBlockStateContext) public BlockHitResult isBlockInLine(ClipBlockStateContext clipBlockStateContext)
{ { return this.parent.isBlockInLine(clipBlockStateContext); }
return parent.isBlockInLine(clipBlockStateContext);
}
@Override @Override
public int getHeight() public int getHeight() { return this.parent.getHeight(); }
{
return parent.getHeight(); #if MC_VER < MC_1_21_3
} @Override
public int getMinBuildHeight() { return this.parent.getMinBuildHeight(); }
#else
@Override
public int getMinY() { return this.parent.getMinY(); }
#endif
@Override @Override
public int getMinBuildHeight() public int getSectionsCount() { return this.parent.getSectionsCount(); }
{
return parent.getMinBuildHeight(); #if MC_VER < MC_1_21_3
} @Override
public int getMinSection() { return this.parent.getMinSection(); }
#else
@Override
public int getMinSectionY() { return BlockAndTintGetter.super.getMinSectionY(); }
#endif
#if MC_VER < MC_1_21_3
@Override
public int getMaxSection() { return this.parent.getMaxSection(); }
#else
@Override
public int getMaxSectionY() { return this.parent.getMaxSectionY(); }
#endif
@Override @Override
public int getSectionsCount() public boolean isOutsideBuildHeight(BlockPos blockPos) { return this.parent.isOutsideBuildHeight(blockPos); }
{
return parent.getSectionsCount();
}
@Override @Override
public int getMinSection() public boolean isOutsideBuildHeight(int i) { return this.parent.isOutsideBuildHeight(i); }
{
return parent.getMinSection();
}
@Override @Override
public int getMaxSection() public int getSectionIndex(int i) { return this.parent.getSectionIndex(i); }
{
return parent.getMaxSection();
}
@Override @Override
public boolean isOutsideBuildHeight(BlockPos blockPos) public int getSectionIndexFromSectionY(int i) { return this.parent.getSectionIndexFromSectionY(i); }
{
return parent.isOutsideBuildHeight(blockPos);
}
@Override @Override
public boolean isOutsideBuildHeight(int i) public int getSectionYFromSectionIndex(int i) { return this.parent.getSectionYFromSectionIndex(i); }
{
return parent.isOutsideBuildHeight(i);
}
@Override
public int getSectionIndex(int i)
{
return parent.getSectionIndex(i);
}
@Override
public int getSectionIndexFromSectionY(int i)
{
return parent.getSectionIndexFromSectionY(i);
}
@Override
public int getSectionYFromSectionIndex(int i)
{
return parent.getSectionYFromSectionIndex(i);
}
#endif #endif
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,7 +19,7 @@
package com.seibel.distanthorizons.common.wrappers.block; package com.seibel.distanthorizons.common.wrappers.block;
import com.seibel.distanthorizons.common.LodCommonMain; import com.seibel.distanthorizons.core.util.LodUtil;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Cursor3D; import net.minecraft.core.Cursor3D;
import net.minecraft.core.Direction; import net.minecraft.core.Direction;
@@ -45,16 +45,28 @@ public class TintGetterOverrideSmooth implements BlockAndTintGetter
LevelReader parent; LevelReader parent;
public int smoothingRange; public int smoothingRange;
//=============//
// constructor //
//=============//
public TintGetterOverrideSmooth(LevelReader parent, int smoothingRange) public TintGetterOverrideSmooth(LevelReader parent, int smoothingRange)
{ {
this.parent = parent; this.parent = parent;
this.smoothingRange = smoothingRange; this.smoothingRange = smoothingRange;
} }
//=========//
// methods //
//=========//
private Biome _getBiome(BlockPos pos) private Biome _getBiome(BlockPos pos)
{ {
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
return parent.getBiome(pos).value(); return this.parent.getBiome(pos).value();
#else #else
return parent.getBiome(pos); return parent.getBiome(pos);
#endif #endif
@@ -74,16 +86,7 @@ public class TintGetterOverrideSmooth implements BlockAndTintGetter
while (cursor3D.advance()) while (cursor3D.advance())
{ {
mutableBlockPos.set(cursor3D.nextX(), cursor3D.nextY(), cursor3D.nextZ()); mutableBlockPos.set(cursor3D.nextX(), cursor3D.nextY(), cursor3D.nextZ());
int n; int n = colorResolver.getColor(this._getBiome(mutableBlockPos), mutableBlockPos.getX(), mutableBlockPos.getZ());
if (LodCommonMain.forgeMethodCaller != null)
{
n = LodCommonMain.forgeMethodCaller.colorResolverGetColor(colorResolver, _getBiome(mutableBlockPos),
mutableBlockPos.getX(), mutableBlockPos.getZ());
}
else
{
n = colorResolver.getColor(_getBiome(mutableBlockPos), mutableBlockPos.getX(), mutableBlockPos.getZ());
}
k += (n & 0xFF0000) >> 16; k += (n & 0xFF0000) >> 16;
l += (n & 0xFF00) >> 8; l += (n & 0xFF00) >> 8;
@@ -93,177 +96,119 @@ public class TintGetterOverrideSmooth implements BlockAndTintGetter
} }
@Override @Override
public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) { return this.calculateBlockTint(blockPos, colorResolver); }
{
return calculateBlockTint(blockPos, colorResolver);
}
@Override @Override
public float getShade(Direction direction, boolean bl) { return this.parent.getShade(direction, bl); } public float getShade(Direction direction, boolean bl) { return this.parent.getShade(direction, bl); }
@Override @Override
public LevelLightEngine getLightEngine() public LevelLightEngine getLightEngine() { return this.parent.getLightEngine(); }
{
return parent.getLightEngine();
}
@Override @Override
public int getBrightness(LightLayer lightLayer, BlockPos blockPos) public int getBrightness(LightLayer lightLayer, BlockPos blockPos) { return this.parent.getBrightness(lightLayer, blockPos); }
{
return parent.getBrightness(lightLayer, blockPos);
}
@Override @Override
public int getRawBrightness(BlockPos blockPos, int i) public int getRawBrightness(BlockPos blockPos, int i) { return this.parent.getRawBrightness(blockPos, i); }
{
return parent.getRawBrightness(blockPos, i);
}
@Override @Override
public boolean canSeeSky(BlockPos blockPos) public boolean canSeeSky(BlockPos blockPos) { return this.parent.canSeeSky(blockPos); }
{
return parent.canSeeSky(blockPos);
}
@Override @Override
@Nullable @Nullable
public BlockEntity getBlockEntity(BlockPos blockPos) public BlockEntity getBlockEntity(BlockPos blockPos) { return this.parent.getBlockEntity(blockPos); }
{
return parent.getBlockEntity(blockPos);
}
@Override @Override
public BlockState getBlockState(BlockPos blockPos) public BlockState getBlockState(BlockPos blockPos) { return this.parent.getBlockState(blockPos); }
{
return parent.getBlockState(blockPos);
}
@Override @Override
public FluidState getFluidState(BlockPos blockPos) public FluidState getFluidState(BlockPos blockPos) { return this.parent.getFluidState(blockPos); }
{
return parent.getFluidState(blockPos);
}
@Override @Override
public int getLightEmission(BlockPos blockPos) public int getLightEmission(BlockPos blockPos) { return this.parent.getLightEmission(blockPos); }
{
return parent.getLightEmission(blockPos); #if MC_VER < MC_1_21_3
} @Override
public int getMaxLightLevel() { return this.parent.getMaxLightLevel(); }
#else
#endif
@Override @Override
public int getMaxLightLevel() public Stream<BlockState> getBlockStates(AABB aABB) { return this.parent.getBlockStates(aABB); }
{
return parent.getMaxLightLevel();
}
@Override @Override
public Stream<BlockState> getBlockStates(AABB aABB) public BlockHitResult clip(ClipContext clipContext) { return this.parent.clip(clipContext); }
{
return parent.getBlockStates(aABB);
}
@Override
public BlockHitResult clip(ClipContext clipContext)
{
return parent.clip(clipContext);
}
@Override @Override
@Nullable @Nullable
public BlockHitResult clipWithInteractionOverride(Vec3 vec3, Vec3 vec32, BlockPos blockPos, VoxelShape voxelShape, BlockState blockState) public BlockHitResult clipWithInteractionOverride(Vec3 vec3, Vec3 vec32, BlockPos blockPos, VoxelShape voxelShape, BlockState blockState)
{ {
return parent.clipWithInteractionOverride(vec3, vec32, blockPos, voxelShape, blockState); return this.parent.clipWithInteractionOverride(vec3, vec32, blockPos, voxelShape, blockState);
} }
@Override @Override
public double getBlockFloorHeight(VoxelShape voxelShape, Supplier<VoxelShape> supplier) public double getBlockFloorHeight(VoxelShape voxelShape, Supplier<VoxelShape> supplier) { return this.parent.getBlockFloorHeight(voxelShape, supplier); }
{
return parent.getBlockFloorHeight(voxelShape, supplier);
}
@Override @Override
public double getBlockFloorHeight(BlockPos blockPos) public double getBlockFloorHeight(BlockPos blockPos) { return this.parent.getBlockFloorHeight(blockPos); }
{
return parent.getBlockFloorHeight(blockPos); #if MC_VER < MC_1_21_3
} @Override
public int getMaxBuildHeight() { return this.parent.getMaxBuildHeight(); }
#else
@Override
public int getMaxY() { return this.parent.getMaxY(); }
#endif
#if MC_VER >= MC_1_17_1
@Override
public <T extends BlockEntity> Optional<T> getBlockEntity(BlockPos blockPos, BlockEntityType<T> blockEntityType) { return this.parent.getBlockEntity(blockPos, blockEntityType); }
@Override @Override
public int getMaxBuildHeight() public BlockHitResult isBlockInLine(ClipBlockStateContext clipBlockStateContext) { return this.parent.isBlockInLine(clipBlockStateContext); }
{
return parent.getMaxBuildHeight();
}
#if POST_MC_1_17_1
@Override
public <T extends BlockEntity> Optional<T> getBlockEntity(BlockPos blockPos, BlockEntityType<T> blockEntityType)
{
return parent.getBlockEntity(blockPos, blockEntityType);
}
@Override @Override
public BlockHitResult isBlockInLine(ClipBlockStateContext clipBlockStateContext) public int getHeight() { return this.parent.getHeight(); }
{
return parent.isBlockInLine(clipBlockStateContext); #if MC_VER < MC_1_21_3
} @Override
public int getMinBuildHeight() { return this.parent.getMinBuildHeight(); }
#else
@Override
public int getMinY() { return this.parent.getMinY(); }
#endif
@Override @Override
public int getHeight() public int getSectionsCount() { return this.parent.getSectionsCount(); }
{
return parent.getHeight(); #if MC_VER < MC_1_21_3
} @Override
public int getMinSection() { return this.parent.getMinSection(); }
#else
@Override
public int getMinSectionY() { return BlockAndTintGetter.super.getMinSectionY(); }
#endif
#if MC_VER < MC_1_21_3
@Override
public int getMaxSection() { return this.parent.getMaxSection(); }
#else
@Override
public int getMaxSectionY() { return this.parent.getMaxSectionY(); }
#endif
@Override @Override
public int getMinBuildHeight() public boolean isOutsideBuildHeight(BlockPos blockPos) { return this.parent.isOutsideBuildHeight(blockPos); }
{
return parent.getMinBuildHeight();
}
@Override @Override
public int getSectionsCount() public boolean isOutsideBuildHeight(int i) { return this.parent.isOutsideBuildHeight(i); }
{
return parent.getSectionsCount();
}
@Override @Override
public int getMinSection() public int getSectionIndex(int i) { return this.parent.getSectionIndex(i); }
{
return parent.getMinSection();
}
@Override @Override
public int getMaxSection() public int getSectionIndexFromSectionY(int i) { return this.parent.getSectionIndexFromSectionY(i); }
{
return parent.getMaxSection();
}
@Override @Override
public boolean isOutsideBuildHeight(BlockPos blockPos) public int getSectionYFromSectionIndex(int i) { return this.parent.getSectionYFromSectionIndex(i); }
{
return parent.isOutsideBuildHeight(blockPos);
}
@Override
public boolean isOutsideBuildHeight(int i)
{
return parent.isOutsideBuildHeight(i);
}
@Override
public int getSectionIndex(int i)
{
return parent.getSectionIndex(i);
}
@Override
public int getSectionIndexFromSectionY(int i)
{
return parent.getSectionIndexFromSectionY(i);
}
@Override
public int getSectionYFromSectionIndex(int i)
{
return parent.getSectionYFromSectionIndex(i);
}
#endif #endif
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,6 +19,10 @@
package com.seibel.distanthorizons.common.wrappers.block; package com.seibel.distanthorizons.common.wrappers.block;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction; import net.minecraft.core.Direction;
import net.minecraft.world.level.*; import net.minecraft.world.level.*;
@@ -27,74 +31,209 @@ import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.lighting.LevelLightEngine; import net.minecraft.world.level.lighting.LevelLightEngine;
import net.minecraft.world.level.material.FluidState; import net.minecraft.world.level.material.FluidState;
import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
import net.minecraft.core.Holder; import net.minecraft.core.Holder;
#endif #endif
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
public class TintWithoutLevelOverrider implements BlockAndTintGetter public class TintWithoutLevelOverrider implements BlockAndTintGetter
{ {
final BiomeWrapper biome; private static final Logger LOGGER = DhLoggerBuilder.getLogger();
#if MC_VER < MC_1_18_2
public static final ConcurrentMap<String, Biome> BIOME_BY_RESOURCE_STRING = new ConcurrentHashMap<>();
#else
public static final ConcurrentMap<String, Holder<Biome>> BIOME_BY_RESOURCE_STRING = new ConcurrentHashMap<>();
#endif
@NotNull
private final BiomeWrapper biomeWrapper;
//=============//
// constructor //
//=============//
public TintWithoutLevelOverrider(@NotNull BiomeWrapper biomeWrapper, IClientLevelWrapper clientLevelWrapper)
{ this.biomeWrapper = biomeWrapper; }
//=========//
// methods //
//=========//
public TintWithoutLevelOverrider(BiomeWrapper biome)
{
this.biome = biome;
}
@Override @Override
public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) public int getBlockTint(@NotNull BlockPos blockPos, @NotNull ColorResolver colorResolver)
{ {
return colorResolver.getColor(_unwrap(biome.biome), blockPos.getX(), blockPos.getZ()); String biomeString = this.biomeWrapper.getSerialString();
if (biomeString == null
|| biomeString.isEmpty()
|| biomeString.equals(BiomeWrapper.EMPTY_BIOME_STRING))
{
// default to "plains" for empty/invalid biomes
biomeString = "minecraft:plains";
}
return colorResolver.getColor(unwrap(getClientBiome(biomeString)), blockPos.getX(), blockPos.getZ());
} }
private Biome _unwrap(#if POST_MC_1_18_2 Holder<Biome> #else Biome #endif biome) private static Biome unwrap(#if MC_VER >= MC_1_18_2 Holder<Biome> #else Biome #endif biome)
{ {
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
return biome.value(); return biome.value();
#else #else
return biome; return biome;
#endif #endif
} }
/**
* <p>Previously, this class might have immediately unwrapped the Holder like this:</p>
* <pre>{@code
* // Inside constructor (OLD WAY - PROBLEMATIC):
* Holder<Biome> biomeHolder = getTheHolderFromSomewhere();
* this.biome = biomeHolder.value(); // <-- PROBLEM HERE
* }</pre>
*
* <p>This approach is problematic because the {@link net.minecraft.core.Holder} system,
* particularly {@code Holder.Reference}, is designed for <strong>late binding</strong>. Here's why storing
* the Holder itself is now necessary:</p>
* <ol>
* <li>A {@code Holder.Reference<Biome>} might be created initially just with a
* {@link net.minecraft.resources.ResourceKey} (like {@code minecraft:plains}), but its actual
* {@link net.minecraft.core.Holder#value() value()} (the {@code Biome} object itself) might be {@code null}
* at construction time.</li>
* <li>Later, during game loading, registry population, or potentially due to modifications by other mods
* (e.g., Polytone), the system calls internal binding methods (like {@code bindValue(Biome)})
* on the {@code Holder} instance. This sets or <strong>updates</strong> the internal reference to the
* actual {@code Biome} object.</li>
* <li>Crucially, the binding process might assign a completely <strong>new</strong> {@code Biome} object
* instance to the {@code Holder} reference, replacing any previous one.</li>
* </ol>
*
* <p>If we unwrapped the {@code Holder} using {@code .value()} within the constructor (the old way),
* our class's internal {@code biome} field would permanently store a reference to whatever {@code Biome}
* object the {@code Holder} pointed to *at that exact moment*. It would have no link back to the
* {@code Holder} and would be unaware if the {@code Holder} was later updated to point to a different
* (or the initially missing) {@code Biome} object. This would lead to using stale or even {@code null} data.</p>
*
* <p>By storing the {@code Holder<Biome>} itself, this class can call {@link net.minecraft.core.Holder#value()}
* whenever the biome information is needed, ensuring it always retrieves the most current {@code Biome}
* instance associated with the holder at that time.</p>
*/
private static #if MC_VER < MC_1_18_2 Biome #else Holder<Biome> #endif getClientBiome(String biomeResourceString)
{
// cache the client biomes so we don't have to re-parse the resource location every time
return BIOME_BY_RESOURCE_STRING.compute(biomeResourceString,
(resourceString, existingBiome) ->
{
if (existingBiome != null)
{
return existingBiome;
}
ClientLevel clientLevel = Minecraft.getInstance().level;
if (clientLevel == null)
{
// shouldn't happen, but just in case
throw new IllegalStateException("Attempted to get client biome when no client level was loaded.");
}
BiomeWrapper.BiomeDeserializeResult result;
try
{
result = BiomeWrapper.deserializeBiome(resourceString, clientLevel.registryAccess());
}
catch (Exception e)
{
LOGGER.warn("Unable to deserialize client biome ["+resourceString+"], using fallback...");
try
{
result = BiomeWrapper.deserializeBiome("minecraft:plains", clientLevel.registryAccess());
}
catch (IOException ex)
{
// should never happen, if it does this log will explode, but just in case
LOGGER.error("Unable to deserialize fallback client biome [minecraft:plains], returning NULL.");
return null;
}
}
if (result.success)
{
existingBiome = result.biome;
}
return existingBiome;
});
}
//================//
// unused methods //
//================//
@Override @Override
public float getShade(Direction direction, boolean shade) public float getShade(@NotNull Direction direction, boolean shade)
{ {
throw new UnsupportedOperationException("ERROR: getShade() called on TintWithoutLevelOverrider. Object is for tinting only."); throw new UnsupportedOperationException("ERROR: getShade() called on TintWithoutLevelOverrider. Object is for tinting only.");
} }
@Override @Override
public LevelLightEngine getLightEngine() public @NotNull LevelLightEngine getLightEngine()
{ {
throw new UnsupportedOperationException("ERROR: getLightEngine() called on TintWithoutLevelOverrider. Object is for tinting only."); throw new UnsupportedOperationException("ERROR: getLightEngine() called on TintWithoutLevelOverrider. Object is for tinting only.");
} }
@Nullable @Nullable
@Override @Override
public BlockEntity getBlockEntity(BlockPos pos) public BlockEntity getBlockEntity(@NotNull BlockPos pos)
{ {
throw new UnsupportedOperationException("ERROR: getBlockEntity() called on TintWithoutLevelOverrider. Object is for tinting only."); throw new UnsupportedOperationException("ERROR: getBlockEntity() called on TintWithoutLevelOverrider. Object is for tinting only.");
} }
@Override @Override
public BlockState getBlockState(BlockPos pos) public @NotNull BlockState getBlockState(@NotNull BlockPos pos)
{ {
throw new UnsupportedOperationException("ERROR: getBlockState() called on TintWithoutLevelOverrider. Object is for tinting only."); throw new UnsupportedOperationException("ERROR: getBlockState() called on TintWithoutLevelOverrider. Object is for tinting only.");
} }
@Override @Override
public FluidState getFluidState(BlockPos pos) public @NotNull FluidState getFluidState(@NotNull BlockPos pos)
{ {
throw new UnsupportedOperationException("ERROR: getFluidState() called on TintWithoutLevelOverrider. Object is for tinting only."); throw new UnsupportedOperationException("ERROR: getFluidState() called on TintWithoutLevelOverrider. Object is for tinting only.");
} }
#if MC_1_17_1 || POST_MC_1_18_2
//==============//
// post MC 1.17 //
//==============//
#if MC_VER >= MC_1_17_1
@Override @Override
public int getHeight() public int getHeight()
{ { throw new UnsupportedOperationException("ERROR: getHeight() called on TintWithoutLevelOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getHeight() called on TintWithoutLevelOverrider. Object is for tinting only.");
} #if MC_VER < MC_1_21_3
@Override @Override
public int getMinBuildHeight() public int getMinBuildHeight()
{ { throw new UnsupportedOperationException("ERROR: getMinBuildHeight() called on TintWithoutLevelOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getMinBuildHeight() called on TintWithoutLevelOverrider. Object is for tinting only."); #else
} @Override
public int getMinY()
{ throw new UnsupportedOperationException("ERROR: getMinY() called on TintWithoutLevelOverrider. Object is for tinting only."); }
#endif
#endif #endif
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -30,7 +30,7 @@ import net.minecraft.world.level.lighting.LevelLightEngine;
import net.minecraft.world.level.material.FluidState; import net.minecraft.world.level.material.FluidState;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
import net.minecraft.core.Holder; import net.minecraft.core.Holder;
#endif #endif
@@ -39,25 +39,38 @@ public class TintWithoutLevelSmoothOverrider implements BlockAndTintGetter
final BiomeWrapper biome; final BiomeWrapper biome;
public int smoothingRange; public int smoothingRange;
//=============//
// constructor //
//=============//
public TintWithoutLevelSmoothOverrider(BiomeWrapper biome, int smoothingRange) public TintWithoutLevelSmoothOverrider(BiomeWrapper biome, int smoothingRange)
{ {
this.biome = biome; this.biome = biome;
this.smoothingRange = smoothingRange; this.smoothingRange = smoothingRange;
} }
//=========//
// methods //
//=========//
@Override @Override
public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver)
{ {
return colorResolver.getColor(_unwrap(biome.biome), blockPos.getX(), blockPos.getZ()); return colorResolver.getColor(_unwrap(biome.biome), blockPos.getX(), blockPos.getZ());
} }
private Biome _unwrap(#if POST_MC_1_18_2 Holder<Biome> #else Biome #endif biome) private Biome _unwrap(#if MC_VER >= MC_1_18_2 Holder<Biome> #else Biome #endif biome)
{ {
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
return biome.value(); return biome.value();
#else #else
return biome; return biome;
#endif #endif
} }
//
// public int calculateBlockTint(BlockPos blockPos, ColorResolver colorResolver) // public int calculateBlockTint(BlockPos blockPos, ColorResolver colorResolver)
// { // {
// int i = smoothingRange; // int i = smoothingRange;
@@ -89,44 +102,43 @@ public class TintWithoutLevelSmoothOverrider implements BlockAndTintGetter
@Override @Override
public float getShade(Direction direction, boolean shade) public float getShade(Direction direction, boolean shade)
{ { throw new UnsupportedOperationException("ERROR: getShade() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getShade() called on TintWithoutLevelOverrider. Object is for tinting only.");
}
@Override @Override
public LevelLightEngine getLightEngine() public LevelLightEngine getLightEngine()
{ { throw new UnsupportedOperationException("ERROR: getLightEngine() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getLightEngine() called on TintWithoutLevelOverrider. Object is for tinting only.");
}
@Nullable @Nullable
@Override @Override
public BlockEntity getBlockEntity(BlockPos pos) public BlockEntity getBlockEntity(BlockPos pos)
{ { throw new UnsupportedOperationException("ERROR: getBlockEntity() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getBlockEntity() called on TintWithoutLevelOverrider. Object is for tinting only.");
}
@Override @Override
public BlockState getBlockState(BlockPos pos) public BlockState getBlockState(BlockPos pos)
{ { throw new UnsupportedOperationException("ERROR: getBlockState() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getBlockState() called on TintWithoutLevelOverrider. Object is for tinting only.");
}
@Override @Override
public FluidState getFluidState(BlockPos pos) public FluidState getFluidState(BlockPos pos)
{ { throw new UnsupportedOperationException("ERROR: getFluidState() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getFluidState() called on TintWithoutLevelOverrider. Object is for tinting only.");
}
#if MC_1_17_1 || POST_MC_1_18_2 //==============//
// post MC 1.17 //
//==============//
#if MC_VER >= MC_1_17_1
@Override @Override
public int getHeight() public int getHeight()
{ { throw new UnsupportedOperationException("ERROR: getHeight() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getHeight() called on TintWithoutLevelOverrider. Object is for tinting only.");
} #if MC_VER < MC_1_21_3
@Override @Override
public int getMinBuildHeight() public int getMinBuildHeight()
{ { throw new UnsupportedOperationException("ERROR: getMinBuildHeight() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
throw new UnsupportedOperationException("ERROR: getMinBuildHeight() called on TintWithoutLevelOverrider. Object is for tinting only."); #else
} @Override
public int getMinY()
{ throw new UnsupportedOperationException("ERROR: getMinY() called on TintWithoutLevelSmoothOverrider. Object is for tinting only."); }
#endif
#endif #endif
} }
@@ -1,48 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.block.cache;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper;
import com.seibel.distanthorizons.core.pos.DhBlockPos;
import net.minecraft.world.level.block.state.BlockState;
import java.util.concurrent.ConcurrentHashMap;
public class ClientBlockDetailMap
{
private final ConcurrentHashMap<BlockState, ClientBlockStateCache> blockCache = new ConcurrentHashMap<>();
//private final ConcurrentHashMap<#if PRE_MC_1_18_2 Biome #else Holder<Biome> #endif, Biome> biomeMap = new ConcurrentHashMap<>();
private final ClientLevelWrapper level;
public ClientBlockDetailMap(ClientLevelWrapper level) { this.level = level; }
public ClientBlockStateCache getBlockStateData(BlockState state, DhBlockPos pos)
{ //TODO: Allow a per pos unique setting
return blockCache.computeIfAbsent(state, (s) -> new ClientBlockStateCache(s, level, pos));
}
public void clear() { blockCache.clear(); }
public int getColor(BlockState state, BiomeWrapper biome, DhBlockPos pos)
{
return getBlockStateData(state, pos).getAndResolveFaceColor(biome, pos);
}
}
@@ -1,307 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.block.cache;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.block.TextureAtlasSpriteWrapper;
import com.seibel.distanthorizons.common.wrappers.block.TintWithoutLevelOverrider;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.common.wrappers.block.*;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhBlockPos;
import com.seibel.distanthorizons.core.util.ColorUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.FlowerBlock;
import net.minecraft.world.level.block.LeavesBlock;
import net.minecraft.world.level.block.RotatedPillarBlock;
#if POST_MC_1_19_2
import net.minecraft.util.RandomSource;
#else
import java.util.Random;
#endif
import net.minecraft.world.level.block.state.BlockState;
import org.apache.logging.log4j.Logger;
import java.util.HashSet;
import java.util.List;
/**
* @version 2022-9-16
*/
public class ClientBlockStateCache
{
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private static final HashSet<BlockState> BLOCK_STATES_THAT_NEED_LEVEL = new HashSet<>();
private static final HashSet<BlockState> BROKEN_BLOCK_STATES = new HashSet<>();
#if PRE_MC_1_19_2
public static final Random random = new Random(0);
#else
public static final RandomSource random = RandomSource.create();
#endif
public final BlockState blockState;
public final LevelReader level;
public final BlockPos pos;
public ClientBlockStateCache(BlockState blockState, IClientLevelWrapper samplingLevel, DhBlockPos samplingPos)
{
this.blockState = blockState;
level = (LevelReader) samplingLevel.getWrappedMcObject();
pos = McObjectConverter.Convert(samplingPos);
resolveColors();
//LOGGER.info("ClientBlocKCache created for {}", blockState);
}
boolean isColorResolved = false;
int baseColor = 0; //TODO: Impl per-face color
boolean needShade = true;
boolean needPostTinting = false;
int tintIndex = 0;
public static final int FLOWER_COLOR_SCALE = 5;
enum ColorMode
{
Default,
Flower,
Leaves;
static ColorMode getColorMode(Block b)
{
if (b instanceof LeavesBlock) return Leaves;
if (b instanceof FlowerBlock) return Flower;
return Default;
}
}
private static int getWidth(TextureAtlasSprite texture)
{
#if PRE_MC_1_19_4
return texture.getWidth();
#else
return texture.contents().width();
#endif
}
private static int getHeight(TextureAtlasSprite texture)
{
#if PRE_MC_1_19_4
return texture.getHeight();
#else
return texture.contents().height();
#endif
}
//TODO: Perhaps make this not just use the first frame?
private static int calculateColorFromTexture(TextureAtlasSprite texture, ColorMode colorMode)
{
int count = 0;
double alpha = 0;
double red = 0;
double green = 0;
double blue = 0;
int tempColor;
{
// textures normally use u and v instead of x and y
for (int u = 0; u < getWidth(texture); u++)
{
for (int v = 0; v < getHeight(texture); v++)
{
//note: Minecraft color format is: 0xAA BB GG RR
//________ DH mod color format is: 0xAA RR GG BB
//OpenGL RGBA format native order: 0xRR GG BB AA
//_ OpenGL RGBA format Java Order: 0xAA BB GG RR
tempColor = TextureAtlasSpriteWrapper.getPixelRGBA(texture, 0, u, v);
double r = ((tempColor & 0x000000FF)) / 255.;
double g = ((tempColor & 0x0000FF00) >>> 8) / 255.;
double b = ((tempColor & 0x00FF0000) >>> 16) / 255.;
double a = ((tempColor & 0xFF000000) >>> 24) / 255.;
int scale = 1;
if (colorMode == ColorMode.Leaves)
{
r *= a;
g *= a;
b *= a;
a = 1.;
}
else if (a == 0.)
{
continue;
}
else if (colorMode == ColorMode.Flower && (g + 0.1 < b || g + 0.1 < r))
{
scale = FLOWER_COLOR_SCALE;
}
count += scale;
alpha += a * a * scale;
red += r * r * scale;
green += g * g * scale;
blue += b * b * scale;
}
}
}
if (count == 0)
// this block is entirely transparent
tempColor = ColorUtil.rgbToInt(0, 255, 255, 255);
else
{
// determine the average color
tempColor = ColorUtil.rgbToInt(
(int) (Math.sqrt(alpha / count) * 255.),
(int) (Math.sqrt(red / count) * 255.),
(int) (Math.sqrt(green / count) * 255.),
(int) (Math.sqrt(blue / count) * 255.));
}
return tempColor;
}
private static final Direction[] DIRECTION_ORDER = {Direction.UP, Direction.NORTH, Direction.EAST, Direction.WEST, Direction.SOUTH, Direction.DOWN};
private void resolveColors()
{
if (isColorResolved) return;
if (blockState.getFluidState().isEmpty())
{
List<BakedQuad> quads = null;
for (Direction direction : DIRECTION_ORDER)
{
quads = Minecraft.getInstance().getModelManager().getBlockModelShaper().
getBlockModel(blockState).getQuads(blockState, direction, random);
if (quads != null && !quads.isEmpty() &&
!(blockState.getBlock() instanceof RotatedPillarBlock && direction == Direction.UP))
break;
} ;
if (quads == null || quads.isEmpty())
{
quads = Minecraft.getInstance().getModelManager().getBlockModelShaper().
getBlockModel(blockState).getQuads(blockState, null, random);
}
if (quads != null && !quads.isEmpty())
{
needPostTinting = quads.get(0).isTinted();
needShade = quads.get(0).isShade();
tintIndex = quads.get(0).getTintIndex();
baseColor = calculateColorFromTexture(
#if PRE_MC_1_17_1 quads.get(0).sprite,
#else quads.get(0).getSprite(), #endif
ColorMode.getColorMode(blockState.getBlock()));
}
else
{ // Backup method.
needPostTinting = false;
needShade = false;
tintIndex = 0;
baseColor = calculateColorFromTexture(Minecraft.getInstance().getModelManager().getBlockModelShaper().getParticleIcon(blockState),
ColorMode.getColorMode(blockState.getBlock()));
}
}
else
{ // Liquid Block
needPostTinting = true;
needShade = false;
tintIndex = 0;
baseColor = calculateColorFromTexture(Minecraft.getInstance().getModelManager().getBlockModelShaper().getParticleIcon(blockState),
ColorMode.getColorMode(blockState.getBlock()));
}
isColorResolved = true;
}
public int getAndResolveFaceColor(BiomeWrapper biome, DhBlockPos pos)
{
// FIXME: impl per-face colors
// only get the tint if the block needs to be tinted
if (!this.needPostTinting)
{
return this.baseColor;
}
// don't try tinting blocks that don't support our method of tint getting
if (BROKEN_BLOCK_STATES.contains(this.blockState))
{
return this.baseColor;
}
// attempt to get the tint
int tintColor = -1;
try
{
// try to use the fast tint getter logic first
if (!BLOCK_STATES_THAT_NEED_LEVEL.contains(this.blockState))
{
try
{
tintColor = Minecraft.getInstance().getBlockColors()
.getColor(this.blockState, new TintWithoutLevelOverrider(biome), McObjectConverter.Convert(pos), this.tintIndex);
}
catch (UnsupportedOperationException e)
{
// this exception generally occurs if the tint requires other blocks besides itself
LOGGER.debug("Unable to use ["+TintWithoutLevelOverrider.class.getSimpleName()+"] to get the block tint for block: [" + this.blockState + "] and biome: [" + biome + "] at pos: " + pos + ". Error: [" + e.getMessage() + "]. Attempting to use backup method...", e);
BLOCK_STATES_THAT_NEED_LEVEL.add(this.blockState);
}
}
// use the level logic only if requested
if (BLOCK_STATES_THAT_NEED_LEVEL.contains(this.blockState))
{
// this logic can't be used all the time due to it breaking some blocks tinting
// specifically oceans don't render correctly
tintColor = Minecraft.getInstance().getBlockColors()
.getColor(this.blockState, new TintGetterOverrideFast(this.level), McObjectConverter.Convert(pos), this.tintIndex);
}
}
catch (Exception e)
{
// only display the error once per block/biome type to reduce log spam
if (!BROKEN_BLOCK_STATES.contains(this.blockState))
{
LOGGER.warn("Failed to get block color for block: [" + this.blockState + "] and biome: [" + biome + "] at pos: " + pos + ". Error: ["+e.getMessage() + "]. Note: future errors for this block/biome will be ignored.", e);
BROKEN_BLOCK_STATES.add(this.blockState);
}
}
if (tintColor != -1)
{
return ColorUtil.multiplyARGBwithRGB(this.baseColor, tintColor);
}
else
{
// unable to get the tinted color, use the base color instead
return this.baseColor;
}
}
}
@@ -1,43 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.block.cache;
import java.util.concurrent.ConcurrentHashMap;
import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.core.pos.DhBlockPos;
import net.minecraft.world.level.block.state.BlockState;
public class ServerBlockDetailMap
{
private final ConcurrentHashMap<BlockState, ServerBlockStateCache> blockCache = new ConcurrentHashMap<>();
//private final ConcurrentHashMap<#if PRE_MC_1_18_2 Biome #else Holder<Biome> #endif, Biome> biomeMap = new ConcurrentHashMap<>();
private final ServerLevelWrapper level;
public ServerBlockDetailMap(ServerLevelWrapper level) { this.level = level; }
public ServerBlockStateCache getBlockStateData(BlockState state, DhBlockPos pos)
{ //TODO: Allow a per pos unique setting
return blockCache.computeIfAbsent(state, (s) -> new ServerBlockStateCache(s, level, new DhBlockPos(0, 0, 0)));
}
public void clear() { blockCache.clear(); }
}
@@ -1,104 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.block.cache;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhBlockPos;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.shapes.VoxelShape;
import org.apache.logging.log4j.Logger;
import java.util.Arrays;
/**
* @version 2022-9-16
*/
public class ServerBlockStateCache
{
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
public final BlockState state;
public final LevelReader level;
public final BlockPos pos;
public ServerBlockStateCache(BlockState blockState, ILevelWrapper samplingLevel, DhBlockPos samplingPos)
{
state = blockState;
level = (LevelReader) samplingLevel.getWrappedMcObject();
pos = McObjectConverter.Convert(samplingPos);
resolveShapes();
//LOGGER.info("ServerBlockState created for {}", blockState);
}
boolean noCollision = false;
boolean[] occludeFaces = null;
boolean[] fullFaces = null;
boolean isShapeResolved = false;
public void resolveShapes()
{
if (isShapeResolved) return;
if (state.getFluidState().isEmpty())
{
noCollision = state.getCollisionShape(level, pos).isEmpty();
occludeFaces = new boolean[6];
if (state.canOcclude())
{
for (Direction dir : Direction.values())
{
// Note: isEmpty() isn't quite correct... best would be a isFull() or something...
occludeFaces[McObjectConverter.Convert(dir).ordinal()]
= !state.getFaceOcclusionShape(level, pos, dir).isEmpty();
}
}
VoxelShape voxelShape = state.getShape(level, pos);
fullFaces = new boolean[6];
if (!voxelShape.isEmpty())
{
for (Direction dir : Direction.values())
{
VoxelShape faceShape = voxelShape.getFaceShape(dir);
AABB aabb = faceShape.bounds();
boolean xFull = aabb.minX <= 0.01 && aabb.maxX >= 0.99;
boolean yFull = aabb.minY <= 0.01 && aabb.maxY >= 0.99;
boolean zFull = aabb.minZ <= 0.01 && aabb.maxZ >= 0.99;
fullFaces[McObjectConverter.Convert(dir).ordinal()] =
(xFull || dir.getAxis().equals(Direction.Axis.X))
&& (yFull || dir.getAxis().equals(Direction.Axis.Y))
&& (zFull || dir.getAxis().equals(Direction.Axis.Z));
}
}
}
else
{ // Liquid Block. Treat as full block
occludeFaces = new boolean[6];
Arrays.fill(occludeFaces, true);
fullFaces = new boolean[6];
Arrays.fill(fullFaces, true);
}
}
}
@@ -1,216 +0,0 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020-2023 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.chunk;
import com.seibel.distanthorizons.coreapi.util.BitShiftUtil;
import java.util.ArrayList;
import java.util.Arrays;
/**
* Compact, efficient storage for light levels.
* all blocks only take up 4 bits in total,
* and if a 16x16x16 area is detected to have the same light level in all positions,
* then we store a single byte for that light level, instead of 2 kilobytes.
*
* @author Builderb0y
*/
public class ChunkLightStorage
{
/** the minimum Y level in the chunk which this storage is storing light levels for (inclusive). */
public int minY;
/** the maximum Y level in the chunk which this storage is storing light levels for (exclusive). */
public int maxY;
/** the data stored in this storage, split up into 16x16x16 areas. */
public LightSection[] lightSections;
public ChunkLightStorage(int minY, int maxY)
{
this.minY = minY;
this.maxY = maxY;
}
public int get(int x, int y, int z)
{
if (y < this.minY)
{
return 0;
}
if (y >= this.maxY)
{
return 15;
}
if (this.lightSections != null)
{
LightSection lightSection = this.lightSections[BitShiftUtil.divideByPowerOfTwo(y - this.minY, 4)];
if (lightSection != null)
{
return lightSection.get(x, y, z);
}
}
return 0;
}
public void set(int x, int y, int z, int lightLevel)
{
if (y < this.minY || y >= this.maxY)
{
return;
}
//populate array if it doesn't exist.
if (this.lightSections == null)
{
this.lightSections = new LightSection[BitShiftUtil.divideByPowerOfTwo(this.maxY - this.minY, 4)];
}
int index = (y - this.minY) >> 4;
LightSection lightSection = this.lightSections[index];
//populate lightSection in array if it doesn't exist.
if (lightSection == null)
{
lightSection = new LightSection(0);
this.lightSections[index] = lightSection;
}
lightSection.set(x, y, z, lightLevel);
}
//================//
// helper classes //
//================//
public static class LightSection
{
public byte constantValue;
public long[] data;
public short[] counts;
public LightSection(int initialValue)
{
this.constantValue = (byte) (initialValue);
this.counts = new short[16];
this.counts[initialValue] = 16 * 16 * 16;
}
public int get(int x, int y, int z)
{
if (this.constantValue >= 0)
{
return this.constantValue;
}
x &= 15;
y &= 15;
z &= 15;
long bits = this.data[(z << 4) | x];
return ((int) (bits >>> (y << 2))) & 15;
}
public void set(int x, int y, int z, int lightLevel)
{
int oldLightLevel = -1;
if (this.constantValue >= 0)
{
oldLightLevel = this.constantValue;
//if the light level didn't change, then there's nothing to do.
if (oldLightLevel == lightLevel) return;
//if we are a constant value and need to change something,
//then that means we need to convert to a non-constant value.
this.data = DataRecycler.get();
//repeat oldLightLevel 16 times as a bit pattern.
long payload = oldLightLevel;
payload |= payload << 4;
payload |= payload << 8;
payload |= payload << 16;
payload |= payload << 32;
//fill our data with our constant value.
Arrays.fill(this.data, payload);
//we are no longer a constant value.
this.constantValue = -1;
}
x &= 15;
y &= 15;
z &= 15;
int index = (z << 4) | x;
long bits = this.data[index];
//if we weren't a constant value before, now's the time to initialize oldLightLevel.
if (oldLightLevel < 0)
{
oldLightLevel = ((int) (bits >>> (y << 2))) & 15;
}
//clear the 4 bits that correspond to the light level at x, y, z...
bits &= ~(15L << (y << 2));
//...and then re-populate those bits with the new light level.
bits |= ((long) (lightLevel)) << (y << 2);
//store the updated bits in our data.
this.data[index] = bits;
//we have one less of the old light level...
this.counts[oldLightLevel]--;
//...and one more of the new level.
//if the number associated with the new level is now 4096 (AKA 16 ^ 3),
//then this implies every position in this section has the same light level,
//and therefore we can convert back to a constant value.
if (++this.counts[lightLevel] == 4096)
{
this.constantValue = (byte) (lightLevel);
DataRecycler.reclaim(this.data);
this.data = null;
}
}
}
static class DataRecycler
{
private static final ArrayList<long[]> recycled = new ArrayList<>(256);
static synchronized long[] get()
{
if (recycled.isEmpty())
{
return new long[256];
}
else
{
return recycled.remove(recycled.size() - 1);
}
}
static synchronized void reclaim(long[] data) { if (recycled.size() < 256) recycled.add(data); }
}
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -16,102 +16,91 @@
* You should have received a copy of the GNU Lesser General Public License * You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
package com.seibel.distanthorizons.common.wrappers.chunk; package com.seibel.distanthorizons.common.wrappers.chunk;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject.DhLitWorldGenRegion; import com.seibel.distanthorizons.common.wrappers.misc.MutableBlockPosWrapper;
import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhBlockPos; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.LodUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.ChunkLightStorage;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IMutableBlockPosWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import com.seibel.distanthorizons.coreapi.ModInfo;
import net.minecraft.client.multiplayer.ClientChunkCache;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.LightLayer;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus; import net.minecraft.world.level.chunk.ProtoChunk;
import net.minecraft.world.level.chunk.LevelChunk;
import net.minecraft.world.level.levelgen.Heightmap; import net.minecraft.world.level.levelgen.Heightmap;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.*; import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
import net.minecraft.core.QuartPos; import net.minecraft.core.QuartPos;
#endif #endif
#if MC_1_16_5 #if MC_VER == MC_1_16_5
import net.minecraft.world.level.chunk.LevelChunkSection; import net.minecraft.world.level.chunk.LevelChunkSection;
#endif #endif
#if MC_1_17_1 #if MC_VER == MC_1_17_1
import net.minecraft.world.level.chunk.LevelChunkSection; import net.minecraft.world.level.chunk.LevelChunkSection;
#endif #endif
#if MC_1_18_2 #if MC_VER == MC_1_18_2
import net.minecraft.world.level.chunk.LevelChunkSection; import net.minecraft.world.level.chunk.LevelChunkSection;
#endif #endif
#if MC_1_19_2 || MC_1_19_4 #if MC_VER == MC_1_19_2 || MC_VER == MC_1_19_4
import net.minecraft.world.level.chunk.LevelChunkSection; import net.minecraft.world.level.chunk.LevelChunkSection;
#endif #endif
#if POST_MC_1_20_1 #if MC_VER >= MC_1_20_1
import net.minecraft.world.level.chunk.LevelChunkSection; import net.minecraft.world.level.chunk.LevelChunkSection;
import net.minecraft.world.level.lighting.LevelLightEngine;
import net.minecraft.core.SectionPos;
#endif #endif
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
public class ChunkWrapper implements IChunkWrapper public class ChunkWrapper implements IChunkWrapper
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger(); private static final Logger LOGGER = DhLoggerBuilder.getLogger();
/** useful for debugging, but can slow down chunk operations quite a bit due to being called every time. */
private static final boolean RUN_RELATIVE_POS_INDEX_VALIDATION = ModInfo.IS_DEV_BUILD;
/** can be used for interactions with the underlying chunk where creating new BlockPos objects could cause issues for the garbage collector. */ /** can be used for interactions with the underlying chunk where creating new BlockPos objects could cause issues for the garbage collector. */
private static final ThreadLocal<BlockPos.MutableBlockPos> MUTABLE_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new BlockPos.MutableBlockPos()); private static final ThreadLocal<BlockPos.MutableBlockPos> MUTABLE_BLOCK_POS_REF = ThreadLocal.withInitial(() -> new BlockPos.MutableBlockPos());
private static final ThreadLocal<MutableBlockPosWrapper> MUTABLE_BLOCK_POS_WRAPPER_REF = ThreadLocal.withInitial(() -> new MutableBlockPosWrapper());
private final ChunkAccess chunk; private final ChunkAccess chunk;
private final DhChunkPos chunkPos; private final DhChunkPos chunkPos;
private final LevelReader lightSource;
private final ILevelWrapper wrappedLevel; private final ILevelWrapper wrappedLevel;
private boolean isDhLightCorrect = false; private boolean isDhBlockLightCorrect = false;
/** only used when connected to a dedicated server */ private boolean isDhSkyLightCorrect = false;
private boolean isMcClientLightingCorrect = false;
private ChunkLightStorage blockLightStorage; private ChunkLightStorage blockLightStorage;
private ChunkLightStorage skyLightStorage; private ChunkLightStorage skyLightStorage;
private ArrayList<DhBlockPos> blockLightPosList = null; private ArrayList<DhBlockPos> blockLightPosList = null;
private boolean useDhLighting; private int minNonEmptyHeight = Integer.MIN_VALUE;
private int maxNonEmptyHeight = Integer.MAX_VALUE;
/** /** will be null if we are using MC heightmaps */
* Due to vanilla `isClientLightReady()` not being designed for use by a non-render thread, it may return 'true' private final int[][] solidHeightMap;
* before the light engine has ticked, (right after all light changes is marked by the engine to be processed). /** will be null if we are using MC heightmaps */
* To fix this, on client-only mode, we mixin-redirect the `isClientLightReady()` so that after the call, it will private final int[][] lightBlockingHeightMap;
* trigger a synchronous update of this flag here on all chunks that are wrapped. <br><br>
*
* Note: Using a static weak hash map to store the chunks that need to be updated, as instance of chunk wrapper
* can be duplicated, with same chunk instance. And the data stored here are all temporary, and thus will not be
* visible when a chunk is re-wrapped later. <br>
* (Also, thread safety done via a reader writer lock)
*/
private static final ConcurrentLinkedQueue<ChunkWrapper> chunksNeedingClientLightUpdating = new ConcurrentLinkedQueue<>();
@@ -119,54 +108,82 @@ public class ChunkWrapper implements IChunkWrapper
// constructor // // constructor //
//=============// //=============//
public ChunkWrapper(ChunkAccess chunk, LevelReader lightSource, ILevelWrapper wrappedLevel) public ChunkWrapper(ChunkAccess chunk, ILevelWrapper wrappedLevel)
{ {
this.chunk = chunk; this.chunk = chunk;
this.lightSource = lightSource;
this.wrappedLevel = wrappedLevel; this.wrappedLevel = wrappedLevel;
this.chunkPos = new DhChunkPos(chunk.getPos().x, chunk.getPos().z); this.chunkPos = new DhChunkPos(chunk.getPos().x, chunk.getPos().z);
// TODO is this the best way to differentiate between when we are generating chunks and when MC gave us a chunk? // use DH heightmaps if requested
boolean isDhGeneratedChunk = (this.lightSource.getClass() == DhLitWorldGenRegion.class); if (Config.Common.LodBuilding.recalculateChunkHeightmaps.get())
// MC loaded chunks should get their lighting from MC, DH generated chunks should get their lighting from DH {
this.useDhLighting = isDhGeneratedChunk; this.solidHeightMap = new int[LodUtil.CHUNK_WIDTH][LodUtil.CHUNK_WIDTH];
this.lightBlockingHeightMap = new int[LodUtil.CHUNK_WIDTH][LodUtil.CHUNK_WIDTH];
// FIXME +1 is to handle the fact that LodDataBuilder adds +1 to all block lighting calculations, also done in the relative position validator
this.recalculateDhHeightMapsIfNeeded();
chunksNeedingClientLightUpdating.add(this); }
else
{
this.solidHeightMap = null;
this.lightBlockingHeightMap = null;
}
} }
//=========// //=========//
// methods // // getters //
//=========// //=========//
@Override @Override
public int getHeight() public int getHeight() { return getHeight(this.chunk); }
public static int getHeight(ChunkAccess chunk)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return 255; return 255;
#else #else
return this.chunk.getHeight(); return chunk.getHeight();
#endif #endif
} }
@Override @Override
public int getMinBuildHeight() public int getInclusiveMinBuildHeight() { return getInclusiveMinBuildHeight(this.chunk); }
public static int getInclusiveMinBuildHeight(ChunkAccess chunk)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return 0; return 0;
#elif MC_VER < MC_1_21_3
return chunk.getMinBuildHeight();
#else #else
return this.chunk.getMinBuildHeight(); return chunk.getMinY();
#endif #endif
} }
@Override
public int getMaxBuildHeight() { return this.chunk.getMaxBuildHeight(); }
@Override @Override
public int getMinFilledHeight() public int getExclusiveMaxBuildHeight() { return getExclusiveMaxBuildHeight(this.chunk); }
public static int getExclusiveMaxBuildHeight(ChunkAccess chunk)
{ {
#if MC_VER < MC_1_21_3
return chunk.getMaxBuildHeight();
#else
// +1 since Minecraft made the max value inclusive
return chunk.getMaxY() + 1;
#endif
}
@Override
public int getMinNonEmptyHeight()
{
if (this.minNonEmptyHeight != Integer.MIN_VALUE)
{
return this.minNonEmptyHeight;
}
// default if every section is empty or missing
this.minNonEmptyHeight = this.getInclusiveMinBuildHeight();
// determine the lowest empty section (bottom up)
LevelChunkSection[] sections = this.chunk.getSections(); LevelChunkSection[] sections = this.chunk.getSections();
for (int index = 0; index < sections.length; index++) for (int index = 0; index < sections.length; index++)
{ {
@@ -175,50 +192,160 @@ public class ChunkWrapper implements IChunkWrapper
continue; continue;
} }
#if MC_1_16_5 if (!isChunkSectionEmpty(sections[index]))
if (!sections[index].isEmpty())
{ {
// convert from an index to a block coordinate this.minNonEmptyHeight = this.getChunkSectionMinHeight(index);
return this.chunk.getSections()[index].bottomBlockY() * 16; break;
} }
#elif MC_1_17_1
if (!sections[index].isEmpty())
{
// convert from an index to a block coordinate
return this.chunk.getSections()[index].bottomBlockY() * 16;
}
#else
if (!sections[index].hasOnlyAir())
{
// convert from an index to a block coordinate
return this.chunk.getSectionYFromSectionIndex(index) * 16;
}
#endif
} }
return Integer.MAX_VALUE;
return this.minNonEmptyHeight;
} }
@Override @Override
public int getSolidHeightMapValue(int xRel, int zRel) { return this.chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE).getFirstAvailable(xRel, zRel); } public int getMaxNonEmptyHeight()
{
if (this.maxNonEmptyHeight != Integer.MAX_VALUE)
{
return this.maxNonEmptyHeight;
}
// default if every section is empty or missing
this.maxNonEmptyHeight = this.getExclusiveMaxBuildHeight();
// determine the highest empty section (top down)
LevelChunkSection[] sections = this.chunk.getSections();
for (int index = sections.length-1; index >= 0; index--)
{
// update at each position to fix using the max height if the chunk is empty
this.maxNonEmptyHeight = this.getChunkSectionMinHeight(index) + 16;
if (sections[index] == null)
{
continue;
}
if (!isChunkSectionEmpty(sections[index]))
{
// non-empty section found
break;
}
}
return this.maxNonEmptyHeight;
}
private static boolean isChunkSectionEmpty(LevelChunkSection section)
{
#if MC_VER == MC_1_16_5
return section.isEmpty();
#elif MC_VER == MC_1_17_1
return section.isEmpty();
#else
return section.hasOnlyAir();
#endif
}
private int getChunkSectionMinHeight(int index) { return (index * 16) + this.getInclusiveMinBuildHeight(); }
/** Will only run if the config says the MC heightmaps shouldn't be trusted. */
public void recalculateDhHeightMapsIfNeeded()
{
// re-calculate the min/max heights for consistency (during world gen these may be wrong)
this.minNonEmptyHeight = Integer.MIN_VALUE;
this.maxNonEmptyHeight = Integer.MAX_VALUE;
// recalculate heightmaps if needed
if (this.solidHeightMap != null)
{
for (int x = 0; x < LodUtil.CHUNK_WIDTH; x++)
{
for (int z = 0; z < LodUtil.CHUNK_WIDTH; z++)
{
int minInclusiveBuildHeight = this.getMinNonEmptyHeight();
// if no blocks are found the height map will be at the bottom of the world
int solidHeight = minInclusiveBuildHeight;
int lightBlockingHeight = minInclusiveBuildHeight;
int y = this.getMaxNonEmptyHeight(); //this.getExclusiveMaxBuildHeight();
IBlockStateWrapper block = this.getBlockState(x, y, z);
while (// go down until we reach the minimum build height
y > minInclusiveBuildHeight
// keep going until we find both height map values
&& (solidHeight == minInclusiveBuildHeight || lightBlockingHeight == minInclusiveBuildHeight))
{
// is this block solid?
if (solidHeight == minInclusiveBuildHeight
&& block.isSolid())
{
solidHeight = y;
}
// is this block light blocking?
if (lightBlockingHeight == minInclusiveBuildHeight
&& block.getOpacity() != LodUtil.BLOCK_FULLY_TRANSPARENT)
{
lightBlockingHeight = y;
}
// get the next block down
y--;
block = this.getBlockState(x, y, z);
}
this.solidHeightMap[x][z] = solidHeight;
this.lightBlockingHeightMap[x][z] = lightBlockingHeight;
}
}
}
}
@Override @Override
public int getLightBlockingHeightMapValue(int xRel, int zRel) { return this.chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING).getFirstAvailable(xRel, zRel); } public int getSolidHeightMapValue(int xRel, int zRel)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(xRel, zRel);
// will be null if we want to use MC heightmaps
if (this.solidHeightMap == null)
{
return this.chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE).getFirstAvailable(xRel, zRel);
}
else
{
return this.solidHeightMap[xRel][zRel];
}
}
@Override
public int getLightBlockingHeightMapValue(int xRel, int zRel)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(xRel, zRel);
if (this.lightBlockingHeightMap == null)
{
return this.chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING).getFirstAvailable(xRel, zRel);
}
else
{
return this.lightBlockingHeightMap[xRel][zRel];
}
}
@Override @Override
public IBiomeWrapper getBiome(int relX, int relY, int relZ) public IBiomeWrapper getBiome(int relX, int relY, int relZ)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return BiomeWrapper.getBiomeWrapper(this.chunk.getBiomes().getNoiseBiome( return BiomeWrapper.getBiomeWrapper(this.chunk.getBiomes().getNoiseBiome(
relX >> 2, relY >> 2, relZ >> 2), relX >> 2, relY >> 2, relZ >> 2),
this.wrappedLevel); this.wrappedLevel);
#elif PRE_MC_1_18_2 #elif MC_VER < MC_1_18_2
return BiomeWrapper.getBiomeWrapper(this.chunk.getBiomes().getNoiseBiome( return BiomeWrapper.getBiomeWrapper(this.chunk.getBiomes().getNoiseBiome(
QuartPos.fromBlock(relX), QuartPos.fromBlock(relY), QuartPos.fromBlock(relZ)), QuartPos.fromBlock(relX), QuartPos.fromBlock(relY), QuartPos.fromBlock(relZ)),
this.wrappedLevel); this.wrappedLevel);
#elif PRE_MC_1_18_2 #elif MC_VER < MC_1_18_2
return BiomeWrapper.getBiomeWrapper(this.chunk.getNoiseBiome( return BiomeWrapper.getBiomeWrapper(this.chunk.getNoiseBiome(
QuartPos.fromBlock(relX), QuartPos.fromBlock(relY), QuartPos.fromBlock(relZ)), QuartPos.fromBlock(relX), QuartPos.fromBlock(relY), QuartPos.fromBlock(relZ)),
this.wrappedLevel); this.wrappedLevel);
@@ -230,11 +357,151 @@ public class ChunkWrapper implements IChunkWrapper
#endif #endif
} }
@Override
public IBlockStateWrapper getBlockState(int relX, int relY, int relZ)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, relY, relZ);
BlockPos.MutableBlockPos blockPos = MUTABLE_BLOCK_POS_REF.get();
blockPos.setX(relX);
blockPos.setY(relY);
blockPos.setZ(relZ);
// TODO copy into pooled array, this isn't thread safe and can cause MC to throw errors if the chunk is loaded
return BlockStateWrapper.fromBlockState(this.chunk.getBlockState(blockPos), this.wrappedLevel);
}
@Override
public IBlockStateWrapper getBlockState(int relX, int relY, int relZ, IMutableBlockPosWrapper mcBlockPos, IBlockStateWrapper guess)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, relY, relZ);
BlockPos.MutableBlockPos pos = (BlockPos.MutableBlockPos)mcBlockPos.getWrappedMcObject();
pos.setX(relX);
pos.setY(relY);
pos.setZ(relZ);
return BlockStateWrapper.fromBlockState(this.chunk.getBlockState(pos), this.wrappedLevel, guess);
}
/**
// Commented out experimental LevelChunkSection cloning logic to fix extremely rare concurrency modification issue
// James has only ever seen a report relating to LevelSection concurrent modification once,
// the issue can cause DH lighting/LOD building to fail due to the chunk being modified on the server.
// James has only heard of this issue once, so it isn't a high priority issue.
// And from James' quick look at a few different MC versions it appears the LevelChunkSection object changes quite drastically between MC versions,
// meaning any cloning logic would have to either be a new wrapper or very MC version dependent, either way a lot of additional work.
// Due to the large time cost and extremely rare nature of the issue, this logic is commented out unless this issue pops up again in the future.
// instance variable to hold the cloned sections
private final LevelChunkSection[] levelChunkSections;
// new constructor logic to clone the sections
public constructor(...)
{
// other constructor logic //
LevelChunkSection[] sections = this.chunk.getSections();
this.levelChunkSections = new LevelChunkSection[sections.length];
for (int i = 0; i < sections.length; i++)
{
LevelChunkSection section = sections[i];
if (section != null)
{
// TODO implement section cloning for older MC versions, only 1.21.4 MC (and maybe other semi recent versions) have a clean way to handle this
// TODO we probably want a wrapper object instead
#if MC_VER < MC_1_21_4
this.levelChunkSections[i] = section;
#else
this.levelChunkSections[i] = section.copy();
#endif
}
}
}
// replacement getters
@Override
public IBlockStateWrapper getBlockState(int relX, int relY, int relZ)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, relY, relZ);
return this.getBlockStateInternal(relX, relY, relZ, null);
}
@Override
public IBlockStateWrapper getBlockState(int relX, int relY, int relZ, IMutableBlockPosWrapper mcBlockPos, IBlockStateWrapper guess)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, relY, relZ);
return this.getBlockStateInternal(relX, relY, relZ, guess);
}
// internal getter logic
private IBlockStateWrapper getBlockStateInternal(int relX, int y, int relZ, @Nullable IBlockStateWrapper guess)
{
try
{
// attempt to get the section for this position
int i = (y - this.getInclusiveMinBuildHeight()) / 16;
if (i >= 0 && i < this.levelChunkSections.length)
{
LevelChunkSection section = this.levelChunkSections[i];
if (!section.hasOnlyAir())
{
if (guess != null)
{
return BlockStateWrapper.fromBlockState(section.getBlockState(relX & 15, y & 15, relZ & 15), this.wrappedLevel, guess);
}
else
{
return BlockStateWrapper.fromBlockState(section.getBlockState(relX & 15, y & 15, relZ & 15), this.wrappedLevel);
}
}
}
return BlockStateWrapper.AIR;
}
catch (Exception e)
{
return BlockStateWrapper.AIR;
}
}
*/
@Override
public IMutableBlockPosWrapper getMutableBlockPosWrapper() { return MUTABLE_BLOCK_POS_WRAPPER_REF.get(); }
@Override @Override
public DhChunkPos getChunkPos() { return this.chunkPos; } public DhChunkPos getChunkPos() { return this.chunkPos; }
public ChunkAccess getChunk() { return this.chunk; } public ChunkAccess getChunk() { return this.chunk; }
public void trySetStatus(ChunkStatus status) { trySetStatus(this.getChunk(), status); }
/** does nothing if the chunk object doesn't support setting it's status */
public static void trySetStatus(ChunkAccess chunk, ChunkStatus status)
{
if (chunk instanceof ProtoChunk)
{
#if MC_VER < MC_1_21_1
((ProtoChunk) chunk).setStatus(status);
#else
((ProtoChunk) chunk).setPersistedStatus(status);
#endif
}
}
public ChunkStatus getStatus() { return getStatus(this.getChunk()); }
public static ChunkStatus getStatus(ChunkAccess chunk)
{
#if MC_VER < MC_1_21_1
return chunk.getStatus();
#else
return chunk.getPersistedStatus();
#endif
}
@Override @Override
public int getMaxBlockX() { return this.chunk.getPos().getMaxBlockX(); } public int getMaxBlockX() { return this.chunk.getPos().getMaxBlockX(); }
@Override @Override
@@ -244,50 +511,21 @@ public class ChunkWrapper implements IChunkWrapper
@Override @Override
public int getMinBlockZ() { return this.chunk.getPos().getMinBlockZ(); } public int getMinBlockZ() { return this.chunk.getPos().getMinBlockZ(); }
@Override
public long getLongChunkPos() { return this.chunk.getPos().toLong(); }
//==========//
// lighting //
//==========//
@Override
public void setIsDhSkyLightCorrect(boolean isDhLightCorrect) { this.isDhSkyLightCorrect = isDhLightCorrect; }
@Override
public void setIsDhBlockLightCorrect(boolean isDhLightCorrect) { this.isDhBlockLightCorrect = isDhLightCorrect; }
@Override @Override
public void setIsDhLightCorrect(boolean isDhLightCorrect) { this.isDhLightCorrect = isDhLightCorrect; } public boolean isDhBlockLightingCorrect() { return this.isDhBlockLightCorrect; }
@Override @Override
public void setUseDhLighting(boolean useDhLighting) { this.useDhLighting = useDhLighting; } public boolean isDhSkyLightCorrect() { return this.isDhSkyLightCorrect; }
@Override
public boolean isLightCorrect()
{
if (this.useDhLighting)
{
return this.isDhLightCorrect;
}
#if MC_1_16_5 || MC_1_17_1
return false; // MC's lighting engine doesn't work consistently enough to trust for 1.16 or 1.17
#else
if (this.chunk instanceof LevelChunk)
{
LevelChunk levelChunk = (LevelChunk) this.chunk;
if (levelChunk.getLevel() instanceof ClientLevel)
{
// connected to a server
return this.isMcClientLightingCorrect;
}
else
{
// in a single player world
return this.chunk.isLightCorrect() && levelChunk.loaded;
}
}
else
{
// called when in a single player world and the chunk is a proto chunk (in world gen, and not active)
return this.chunk.isLightCorrect();
}
#endif
}
@Override @Override
@@ -307,10 +545,13 @@ public class ChunkWrapper implements IChunkWrapper
{ {
if (this.blockLightStorage == null) if (this.blockLightStorage == null)
{ {
this.blockLightStorage = new ChunkLightStorage(this.getMinBuildHeight(), this.getMaxBuildHeight()); this.blockLightStorage = ChunkLightStorage.createBlockLightStorage(this);
} }
return this.blockLightStorage; return this.blockLightStorage;
} }
public void setBlockLightStorage(ChunkLightStorage lightStorage) { this.blockLightStorage = lightStorage; }
@Override
public void clearDhBlockLighting() { this.getBlockLightStorage().clear(); }
@Override @Override
@@ -325,57 +566,26 @@ public class ChunkWrapper implements IChunkWrapper
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, y, relZ); this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, y, relZ);
this.getSkyLightStorage().set(relX, y, relZ, lightValue); this.getSkyLightStorage().set(relX, y, relZ, lightValue);
} }
@Override
public void clearDhSkyLighting() { this.getSkyLightStorage().clear(); }
private ChunkLightStorage getSkyLightStorage() private ChunkLightStorage getSkyLightStorage()
{ {
if (this.skyLightStorage == null) if (this.skyLightStorage == null)
{ {
this.skyLightStorage = new ChunkLightStorage(this.getMinBuildHeight(), this.getMaxBuildHeight()); this.skyLightStorage = ChunkLightStorage.createSkyLightStorage(this);
} }
return this.skyLightStorage; return this.skyLightStorage;
} }
public void setSkyLightStorage(ChunkLightStorage lightStorage) { this.skyLightStorage = lightStorage; }
/**
* FIXME synchronized is necessary for a rare issue where this method is called from two separate threads at the same time
* before the list has finished populating.
*/
@Override @Override
public int getBlockLight(int relX, int y, int relZ) public synchronized ArrayList<DhBlockPos> getWorldBlockLightPosList()
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, y, relZ);
// use the full lighting engine when the chunks are within render distance or the config requests it
if (this.useDhLighting)
{
// DH lighting method
return this.getBlockLightStorage().get(relX, y, relZ);
}
else
{
// note: this returns 0 if the chunk is unload
// MC lighting method
return this.lightSource.getBrightness(LightLayer.BLOCK, new BlockPos(relX + this.getMinBlockX(), y, relZ + this.getMinBlockZ()));
}
}
@Override
public int getSkyLight(int relX, int y, int relZ)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, y, relZ);
// use the full lighting engine when the chunks are within render distance or the config requests it
if (this.useDhLighting)
{
// DH lighting method
return this.getSkyLightStorage().get(relX, y, relZ);
}
else
{
// MC lighting method
return this.lightSource.getBrightness(LightLayer.SKY, new BlockPos(relX + this.getMinBlockX(), y, relZ + this.getMinBlockZ()));
}
}
@Override
public ArrayList<DhBlockPos> getBlockLightPosList()
{ {
// only populate the list once // only populate the list once
if (this.blockLightPosList == null) if (this.blockLightPosList == null)
@@ -383,7 +593,7 @@ public class ChunkWrapper implements IChunkWrapper
this.blockLightPosList = new ArrayList<>(); this.blockLightPosList = new ArrayList<>();
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
this.chunk.getLights().forEach((blockPos) -> this.chunk.getLights().forEach((blockPos) ->
{ {
this.blockLightPosList.add(new DhBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ())); this.blockLightPosList.add(new DhBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ()));
@@ -391,7 +601,13 @@ public class ChunkWrapper implements IChunkWrapper
#else #else
this.chunk.findBlockLightSources((blockPos, blockState) -> this.chunk.findBlockLightSources((blockPos, blockState) ->
{ {
this.blockLightPosList.add(new DhBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ())); DhBlockPos pos = new DhBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ());
// this can be uncommented if MC decides to return relative block positions in the future instead of world positions
//pos.mutateToChunkRelativePos(pos);
//pos.mutateOffset(this.chunkPos.getMinBlockX(), 0, this.chunkPos.getMinBlockZ(), pos);
this.blockLightPosList.add(pos);
}); });
#endif #endif
} }
@@ -399,172 +615,33 @@ public class ChunkWrapper implements IChunkWrapper
return this.blockLightPosList; return this.blockLightPosList;
} }
@Override
public boolean doNearbyChunksExist()
{
if (this.lightSource instanceof DhLitWorldGenRegion)
{
return true;
}
for (int dx = -1; dx <= 1; dx++)
{
for (int dz = -1; dz <= 1; dz++)
{
if (dx == 0 && dz == 0)
{
continue;
}
else if (this.lightSource.getChunk(dx + this.chunk.getPos().x, dz + this.chunk.getPos().z, ChunkStatus.BIOMES, false) == null)
{
return false;
}
}
}
return true;
}
public LevelReader getColorResolver() { return this.lightSource; }
@Override //===============//
public String toString() { return this.chunk.getClass().getSimpleName() + this.chunk.getPos(); } // other methods //
//===============//
@Override
public IBlockStateWrapper getBlockState(int relX, int relY, int relZ)
{
this.throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(relX, relY, relZ);
BlockPos.MutableBlockPos blockPos = MUTABLE_BLOCK_POS_REF.get();
blockPos.setX(relX);
blockPos.setY(relY);
blockPos.setZ(relZ);
return BlockStateWrapper.fromBlockState(this.chunk.getBlockState(blockPos), this.wrappedLevel);
}
@Override @Override
public boolean isStillValid() { return this.wrappedLevel.tryGetChunk(this.chunkPos) == this; } public boolean isStillValid() { return this.wrappedLevel.tryGetChunk(this.chunkPos) == this; }
public static void syncedUpdateClientLightStatus()
{
#if PRE_MC_1_18_2
// TODO: Check what to do in 1.18.1 and older
// since we don't currently handle this list,
// clear it to prevent memory leaks
chunksNeedingClientLightUpdating.clear();
#else
// update the chunks client lighting
ChunkWrapper chunkWrapper = chunksNeedingClientLightUpdating.poll();
while (chunkWrapper != null)
{
chunkWrapper.updateIsClientLightingCorrect();
chunkWrapper = chunksNeedingClientLightUpdating.poll();
}
#endif
}
/** Should be called after client light updates are triggered. */
private void updateIsClientLightingCorrect()
{
if (this.chunk instanceof LevelChunk && ((LevelChunk) this.chunk).getLevel() instanceof ClientLevel)
{
LevelChunk levelChunk = (LevelChunk) this.chunk;
ClientChunkCache clientChunkCache = ((ClientLevel) levelChunk.getLevel()).getChunkSource();
this.isMcClientLightingCorrect = clientChunkCache.getChunkForLighting(this.chunk.getPos().x, this.chunk.getPos().z) != null &&
#if MC_1_16_5 || MC_1_17_1
levelChunk.isLightCorrect();
#elif PRE_MC_1_20_1
levelChunk.isClientLightReady();
#else
checkLightSectionsOnChunk(levelChunk, levelChunk.getLevel().getLightEngine());
#endif
}
}
#if POST_MC_1_20_1
private static boolean checkLightSectionsOnChunk(LevelChunk chunk, LevelLightEngine engine)
{
LevelChunkSection[] sections = chunk.getSections();
int minY = chunk.getMinSection();
int maxY = chunk.getMaxSection();
for (int y = minY; y < maxY; ++y)
{
LevelChunkSection section = sections[chunk.getSectionIndexFromSectionY(y)];
if (section.hasOnlyAir()) continue;
if (!engine.lightOnInSection(SectionPos.of(chunk.getPos(), y)))
{
return false;
}
}
return true;
}
#endif
//================// //================//
// helper methods // // base overrides //
//================// //================//
/** used to prevent accidentally attempting to get/set values outside this chunk's boundaries */ @Override
private void throwIndexOutOfBoundsIfRelativePosOutsideChunkBounds(int x, int y, int z) throws IndexOutOfBoundsException public String toString() { return this.chunk.getClass().getSimpleName() + this.chunk.getPos(); }
{
if (!RUN_RELATIVE_POS_INDEX_VALIDATION)
{
return;
}
// FIXME +1 is to handle the fact that LodDataBuilder adds +1 to all block lighting calculations, also done in the constructor
int minHeight = this.getMinBuildHeight();
int maxHeight = this.getMaxBuildHeight() + 1;
if (x < 0 || x >= LodUtil.CHUNK_WIDTH
|| z < 0 || z >= LodUtil.CHUNK_WIDTH
|| y < minHeight || y > maxHeight)
{
String errorMessage = "Relative position [" + x + "," + y + "," + z + "] out of bounds. \n" +
"X/Z must be between 0 and 15 (inclusive) \n" +
"Y must be between [" + minHeight + "] and [" + maxHeight + "] (inclusive).";
throw new IndexOutOfBoundsException(errorMessage);
}
}
/**
* Converts a 3D position into a 1D array index. <br><br>
*
* Source: <br>
* <a href="https://stackoverflow.com/questions/7367770/how-to-flatten-or-index-3d-array-in-1d-array">stackoverflow</a>
*/
public int relativeBlockPosToIndex(int xRel, int y, int zRel)
{
int yRel = y - this.getMinBuildHeight();
return (zRel * LodUtil.CHUNK_WIDTH * this.getHeight()) + (yRel * LodUtil.CHUNK_WIDTH) + xRel;
}
/**
* Converts a 3D position into a 1D array index. <br><br>
*
* Source: <br>
* <a href="https://stackoverflow.com/questions/7367770/how-to-flatten-or-index-3d-array-in-1d-array">stackoverflow</a>
*/
public DhBlockPos indexToRelativeBlockPos(int index)
{
final int zRel = index / (LodUtil.CHUNK_WIDTH * this.getHeight());
index -= (zRel * LodUtil.CHUNK_WIDTH * this.getHeight());
final int y = index / LodUtil.CHUNK_WIDTH;
final int yRel = y + this.getMinBuildHeight();
final int xRel = index % LodUtil.CHUNK_WIDTH;
return new DhBlockPos(xRel, yRel, zRel);
}
//@Override
//public int hashCode()
//{
// if (this.blockBiomeHashCode == 0)
// {
// this.blockBiomeHashCode = this.getBlockBiomeHashCode();
// }
//
// return this.blockBiomeHashCode;
//}
} }
@@ -16,7 +16,6 @@ import java.util.regex.Pattern;
// Logger (for debug stuff) // Logger (for debug stuff)
import com.seibel.distanthorizons.api.enums.config.DisallowSelectingViaConfigGui; import com.seibel.distanthorizons.api.enums.config.DisallowSelectingViaConfigGui;
import com.seibel.distanthorizons.api.enums.config.EUpdateBranch;
import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.config.ConfigBase; import com.seibel.distanthorizons.core.config.ConfigBase;
import com.seibel.distanthorizons.core.config.types.*; import com.seibel.distanthorizons.core.config.types.*;
@@ -35,7 +34,7 @@ import com.seibel.distanthorizons.coreapi.ModInfo;
import net.minecraft.ChatFormatting; import net.minecraft.ChatFormatting;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Font; import net.minecraft.client.gui.Font;
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.gui.GuiComponent; import net.minecraft.client.gui.GuiComponent;
#else #else
@@ -49,7 +48,7 @@ import net.minecraft.client.gui.components.events.GuiEventListener;
import net.minecraft.client.gui.screens.Screen; import net.minecraft.client.gui.screens.Screen;
import net.minecraft.network.chat.Component; import net.minecraft.network.chat.Component;
import net.minecraft.client.resources.language.I18n; // translation import net.minecraft.client.resources.language.I18n; // translation
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
import net.minecraft.client.gui.narration.NarratableEntry; import net.minecraft.client.gui.narration.NarratableEntry;
#endif #endif
import net.minecraft.resources.ResourceLocation; import net.minecraft.resources.ResourceLocation;
@@ -57,20 +56,20 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import static com.seibel.distanthorizons.common.wrappers.gui.GuiHelper.*; import static com.seibel.distanthorizons.common.wrappers.gui.GuiHelper.*;
import static com.seibel.distanthorizons.common.wrappers.gui.GuiHelper.Translatable;
/** /*
* Based upon TinyConfig but is highly modified * Based upon TinyConfig but is highly modified
* https://github.com/Minenash/TinyConfig * https://github.com/Minenash/TinyConfig
* *
* Note: floats don't work with this system, use doubles.
*
* Credits to Motschen * Credits to Motschen
* *
* @author coolGi * @author coolGi
* @version 5-21-2022 * @version 5-21-2022
*/ */
// FLOATS DONT WORK WITH THIS
/** This file is going to be removed sometime soon, please dont hook onto anything within this file until the new UI is compleated */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public class ClassicConfigGUI public class ClassicConfigGUI
{ {
@@ -98,6 +97,7 @@ public class ClassicConfigGUI
public static final int SpaceFromRightScreen = 10; public static final int SpaceFromRightScreen = 10;
public static final int ButtonWidthSpacing = 5; public static final int ButtonWidthSpacing = 5;
public static final int ResetButtonWidth = 40; public static final int ResetButtonWidth = 40;
public static final int ResetButtonHeight = 20;
} }
@@ -118,14 +118,18 @@ public class ClassicConfigGUI
*/ */
private static void textField(AbstractConfigType info, Function<String, Number> func, Pattern pattern, boolean cast) private static void textField(AbstractConfigType info, Function<String, Number> func, Pattern pattern, boolean cast)
{ {
boolean isNumber = pattern != null;
((EntryInfo) info.guiValue).widget = (BiFunction<EditBox, Button, Predicate<String>>) (editBox, button) -> stringValue -> ((EntryInfo) info.guiValue).widget = (BiFunction<EditBox, Button, Predicate<String>>) (editBox, button) -> stringValue ->
{ {
boolean isNumber = (pattern != null);
stringValue = stringValue.trim(); stringValue = stringValue.trim();
if (!(stringValue.isEmpty() || !isNumber || pattern.matcher(stringValue).matches())) if (!(stringValue.isEmpty() || !isNumber || pattern.matcher(stringValue).matches()))
{
return false; return false;
}
Number value = 0;
Number value = info.typeIsFloatingPointNumber() ? 0.0 : 0; // different default values are needed so implicit casting works correctly (if not done casting from 0 (an int) to a double will cause an exception)
((EntryInfo) info.guiValue).error = null; ((EntryInfo) info.guiValue).error = null;
if (isNumber && !stringValue.isEmpty() && !stringValue.equals("-") && !stringValue.equals(".")) if (isNumber && !stringValue.isEmpty() && !stringValue.equals("-") && !stringValue.equals("."))
{ {
@@ -142,34 +146,41 @@ public class ClassicConfigGUI
switch (isValid) switch (isValid)
{ {
case 0: case 0:
((EntryInfo) info.guiValue).error = null; break; ((EntryInfo) info.guiValue).error = null;
break;
case -1: case -1:
((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cMinimum length is " + ((ConfigEntry) info).getMin())); break; ((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cMinimum length is " + ((ConfigEntry) info).getMin()));
break;
case 1: case 1:
((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cMaximum length is " + ((ConfigEntry) info).getMax())); break; ((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cMaximum length is " + ((ConfigEntry) info).getMax()));
break;
case 2: case 2:
((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cValue is invalid")); break; ((EntryInfo) info.guiValue).error = new AbstractMap.SimpleEntry<>(editBox, TextOrTranslatable("§cValue is invalid"));
break;
} }
} }
((EntryInfo) info.guiValue).tempValue = stringValue; ((EntryInfo) info.guiValue).tempValue = stringValue;
editBox.setTextColor(((ConfigEntry) info).isValid(value) == 0 ? 0xFFFFFFFF : 0xFFFF7777); editBox.setTextColor(((ConfigEntry) info).isValid(value) == 0 ? 0xFFFFFFFF : 0xFFFF7777); // white and red
// button.active = entries.stream().allMatch(e -> e.inLimits); // button.active = entries.stream().allMatch(e -> e.inLimits);
if (((ConfigEntry) info).isValid(value) == 0 && info.getType() != List.class) if (info.getType() == String.class
|| info.getType() == List.class)
{
((ConfigEntry) info).uiSetWithoutSaving(stringValue);
}
else if (((ConfigEntry) info).isValid(value) == 0)
{ {
if (!cast) if (!cast)
{
((ConfigEntry) info).uiSetWithoutSaving(value); ((ConfigEntry) info).uiSetWithoutSaving(value);
}
else else
((ConfigEntry) info).uiSetWithoutSaving(value.intValue()); {
((ConfigEntry) info).uiSetWithoutSaving(value != null ? value.intValue() : 0);
}
} }
// else if (((ConfigEntry) info).isValidMemoryAddress() == 0)
// {
// if (((List<String>) info.get()).size() == ((EntryInfo) info.guiValue).index)
// info.uiSet(((List<String>) info.get()).add(""));
// info.uiSet(((List<String>) info.get()).set(((EntryInfo) info.guiValue).index, Arrays.stream(((EntryInfo) info.guiValue).tempValue.replace("[", "").replace("]", "").split(", ")).collect(Collectors.toList()).get(0)));
// }
return true; return true;
}; };
@@ -238,28 +249,34 @@ public class ClassicConfigGUI
protected void init() protected void init()
{ {
super.init(); super.init();
if (!reload) if (!this.reload)
{ {
ConfigBase.INSTANCE.configFileINSTANCE.loadFromFile(); ConfigBase.INSTANCE.configFileINSTANCE.loadFromFile();
} }
// Changelog button // Changelog button
if (Config.Client.Advanced.AutoUpdater.enableAutoUpdater.get() && Config.Client.Advanced.AutoUpdater.updateBranch.get() == EUpdateBranch.STABLE) if (Config.Client.Advanced.AutoUpdater.enableAutoUpdater.get() && !ModInfo.IS_DEV_BUILD) // we only have changelogs for stable builds
{ {
this.addBtn(new TexturedButtonWidget( this.addBtn(new TexturedButtonWidget(
// Where the button is on the screen // Where the button is on the screen
this.width - 28, this.height - 28, this.width - 28, this.height - 28,
// Width and height of the button // Width and height of the button
20, 20, 20, 20,
// Offset // texture UV Offset
0, 0, 0, 0,
// Some textuary stuff // Some textuary stuff
0, new ResourceLocation(ModInfo.ID, "textures/gui/changelog.png"), 20, 20, 0,
#if MC_VER < MC_1_21_1
new ResourceLocation(ModInfo.ID, "textures/gui/changelog.png"),
#else
ResourceLocation.fromNamespaceAndPath(ModInfo.ID, "textures/gui/changelog.png"),
#endif
20, 20,
// Create the button and tell it where to go // Create the button and tell it where to go
(buttonWidget) -> { (buttonWidget) -> {
ChangelogScreen changelogScreen = new ChangelogScreen(this); ChangelogScreen changelogScreen = new ChangelogScreen(this);
if (changelogScreen.usable) if (changelogScreen.usable)
Objects.requireNonNull(minecraft).setScreen(changelogScreen); Objects.requireNonNull(this.minecraft).setScreen(changelogScreen);
else else
LOGGER.warn("Changelog was not able to open"); LOGGER.warn("Changelog was not able to open");
}, },
@@ -269,18 +286,25 @@ public class ClassicConfigGUI
} }
addBtn(MakeBtn(Translatable("distanthorizons.general.cancel"), this.width / 2 - 154, this.height - 28, 150, 20, button -> { this.addBtn(MakeBtn(Translatable("distanthorizons.general.cancel"),
ConfigBase.INSTANCE.configFileINSTANCE.loadFromFile(); this.width / 2 - 154, this.height - 28,
Objects.requireNonNull(minecraft).setScreen(parent); 150, 20,
})); button ->
doneButton = addBtn(MakeBtn(Translatable("distanthorizons.general.done"), this.width / 2 + 4, this.height - 28, 150, 20, (button) -> { {
ConfigBase.INSTANCE.configFileINSTANCE.loadFromFile();
Objects.requireNonNull(this.minecraft).setScreen(this.parent);
}));
this.doneButton = this.addBtn(MakeBtn(Translatable("distanthorizons.general.done"), this.width / 2 + 4, this.height - 28, 150, 20, (button) -> {
ConfigBase.INSTANCE.configFileINSTANCE.saveToFile(); ConfigBase.INSTANCE.configFileINSTANCE.saveToFile();
Objects.requireNonNull(minecraft).setScreen(parent); Objects.requireNonNull(this.minecraft).setScreen(this.parent);
})); }));
this.list = new ConfigListWidget(this.minecraft, this.width * 2, this.height, 32, this.height - 32, 25); this.list = new ConfigListWidget(this.minecraft, this.width * 2, this.height, 32, 32, 25);
#if MC_VER < MC_1_20_6 // no background is rendered in MC 1.20.6+
if (this.minecraft != null && this.minecraft.level != null) if (this.minecraft != null && this.minecraft.level != null)
this.list.setRenderBackground(false); this.list.setRenderBackground(false);
#endif
this.addWidget(this.list); this.addWidget(this.list);
@@ -288,15 +312,18 @@ public class ClassicConfigGUI
{ {
try try
{ {
if (info.getCategory().matches(category) && info.getAppearance().showInGui) if (info.getCategory().matches(this.category) && info.getAppearance().showInGui)
addMenuItem(info); this.addMenuItem(info);
} }
catch (Exception e) catch (Exception e)
{ {
System.out.println("ERROR: Failed to show [" + info.getNameWCategory() + "]"); String message = "ERROR: Failed to show [\" + info.getNameWCategory() + \"], error: ["+e.getMessage()+"]";
if (info.get() != null) if (info.get() != null)
System.out.print(" with the value [" + info.get() + "] with type [" + info.getType() + "]"); {
e.printStackTrace(); message += " with the value [" + info.get() + "] with type [" + info.getType() + "]";
}
LOGGER.error(message, e);
} }
} }
@@ -309,7 +336,8 @@ public class ClassicConfigGUI
private void addMenuItem(AbstractConfigType info) private void addMenuItem(AbstractConfigType info)
{ {
initEntry(info, this.translationPrefix); initEntry(info, this.translationPrefix);
Component name = Translatable(translationPrefix + info.getNameWCategory()); Component name = Translatable(this.translationPrefix + info.getNameWCategory());
if (ConfigEntry.class.isAssignableFrom(info.getClass())) if (ConfigEntry.class.isAssignableFrom(info.getClass()))
{ {
@@ -317,31 +345,31 @@ public class ClassicConfigGUI
((ConfigEntry) info).uiSetWithoutSaving(((ConfigEntry) info).getDefaultValue()); ((ConfigEntry) info).uiSetWithoutSaving(((ConfigEntry) info).getDefaultValue());
((EntryInfo) info.guiValue).index = 0; ((EntryInfo) info.guiValue).index = 0;
this.reload = true; this.reload = true;
Objects.requireNonNull(minecraft).setScreen(this); Objects.requireNonNull(this.minecraft).setScreen(this);
}; };
int a = this.width - ConfigScreenConfigs.SpaceFromRightScreen - 150 - ConfigScreenConfigs.ButtonWidthSpacing - ConfigScreenConfigs.ResetButtonWidth; int posX = this.width - ConfigScreenConfigs.SpaceFromRightScreen - 150 - ConfigScreenConfigs.ButtonWidthSpacing - ConfigScreenConfigs.ResetButtonWidth;
int b = 0; int posZ = 0;
int c = ConfigScreenConfigs.ResetButtonWidth;
int d = 20;
Button resetButton = MakeBtn(Translatable("distanthorizons.general.reset").withStyle(ChatFormatting.RED), a, b, c, d, btnAction); Button resetButton = MakeBtn(Translatable("distanthorizons.general.reset").withStyle(ChatFormatting.RED),
posX, posZ, ConfigScreenConfigs.ResetButtonWidth, ConfigScreenConfigs.ResetButtonHeight,
btnAction);
if (((EntryInfo) info.guiValue).widget instanceof Map.Entry) if (((EntryInfo) info.guiValue).widget instanceof Map.Entry)
{ {
Map.Entry<Button.OnPress, Function<Object, Component>> widget = (Map.Entry<Button.OnPress, Function<Object, Component>>) ((EntryInfo) info.guiValue).widget; Map.Entry<Button.OnPress, Function<Object, Component>> widget = (Map.Entry<Button.OnPress, Function<Object, Component>>) ((EntryInfo) info.guiValue).widget;
if (info.getType().isEnum()) if (info.getType().isEnum())
{ {
widget.setValue(value -> Translatable(translationPrefix + "enum." + info.getType().getSimpleName() + "." + info.get().toString())); widget.setValue(value -> Translatable(this.translationPrefix + "enum." + info.getType().getSimpleName() + "." + info.get().toString()));
} }
this.list.addButton(MakeBtn(widget.getValue().apply(info.get()), this.width - 150 - ConfigScreenConfigs.SpaceFromRightScreen, 0, 150, 20, widget.getKey()), resetButton, null, name); this.list.addButton(MakeBtn(widget.getValue().apply(info.get()), this.width - 150 - ConfigScreenConfigs.SpaceFromRightScreen, 0, 150, 20, widget.getKey()), resetButton, null, name);
return; return;
} }
else if (((EntryInfo) info.guiValue).widget != null) else if (((EntryInfo) info.guiValue).widget != null)
{ {
EditBox widget = new EditBox(font, this.width - 150 - ConfigScreenConfigs.SpaceFromRightScreen + 2, 0, 150 - 4, 20, null); EditBox widget = new EditBox(this.font, this.width - 150 - ConfigScreenConfigs.SpaceFromRightScreen + 2, 0, 150 - 4, 20, Translatable(""));
widget.setMaxLength(150); widget.setMaxLength(150);
widget.insertText(String.valueOf(info.get())); widget.insertText(String.valueOf(info.get()));
Predicate<String> processor = ((BiFunction<EditBox, Button, Predicate<String>>) ((EntryInfo) info.guiValue).widget).apply(widget, doneButton); Predicate<String> processor = ((BiFunction<EditBox, Button, Predicate<String>>) ((EntryInfo) info.guiValue).widget).apply(widget, this.doneButton);
widget.setFilter(processor); widget.setFilter(processor);
this.list.addButton(widget, resetButton, null, name); this.list.addButton(widget, resetButton, null, name);
return; return;
@@ -351,7 +379,7 @@ public class ClassicConfigGUI
{ {
Button widget = MakeBtn(name, this.width / 2 - 100, this.height - 28, 100 * 2, 20, (button -> { Button widget = MakeBtn(name, this.width / 2 - 100, this.height - 28, 100 * 2, 20, (button -> {
ConfigBase.INSTANCE.configFileINSTANCE.saveToFile(); ConfigBase.INSTANCE.configFileINSTANCE.saveToFile();
Objects.requireNonNull(minecraft).setScreen(ClassicConfigGUI.getScreen(this.configBase, this, ((ConfigCategory) info).getDestination())); Objects.requireNonNull(this.minecraft).setScreen(ClassicConfigGUI.getScreen(this.configBase, this, ((ConfigCategory) info).getDestination()));
})); }));
this.list.addButton(widget, null, null, null); this.list.addButton(widget, null, null, null);
return; return;
@@ -369,9 +397,9 @@ public class ClassicConfigGUI
this.list.addButton(null, null, null, name); this.list.addButton(null, null, null, name);
return; return;
} }
if (ConfigLinkedEntry.class.isAssignableFrom(info.getClass())) if (ConfigUiLinkedEntry.class.isAssignableFrom(info.getClass()))
{ {
this.addMenuItem(((ConfigLinkedEntry) info).get()); this.addMenuItem(((ConfigUiLinkedEntry) info).get());
return; return;
} }
@@ -379,29 +407,47 @@ public class ClassicConfigGUI
} }
@Override @Override
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
public void render(PoseStack matrices, int mouseX, int mouseY, float delta) public void render(PoseStack matrices, int mouseX, int mouseY, float delta)
#else #else
public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta) public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta)
#endif #endif
{ {
#if PRE_MC_1_20_2 // 1.20.2 now enables this by default in the `this.list.render` function #if MC_VER < MC_1_20_2 // 1.20.2 now enables this by default in the `this.list.render` function
this.renderBackground(matrices); // Renders background this.renderBackground(matrices); // Renders background
#else #else
super.render(matrices, mouseX, mouseY, delta); super.render(matrices, mouseX, mouseY, delta);
#endif #endif
this.list.render(matrices, mouseX, mouseY, delta); // Render buttons this.list.render(matrices, mouseX, mouseY, delta); // Render buttons
DhDrawCenteredString(matrices, font, title, width / 2, 15, 0xFFFFFF); // Render title // Render title
this.DhDrawCenteredString(matrices, this.font, this.title, this.width / 2, 15,
#if MC_VER < MC_1_21_6
0xFFFFFF // RGB white
#else
0xFFFFFFFF // ARGB white
#endif);
if (this.configBase.modID.equals("distanthorizons")) if (this.configBase.modID.equals("distanthorizons"))
{ {
// Display version // Display version
DhDrawString(matrices, font, TextOrLiteral(ModInfo.VERSION), 2, height - 10, 0xAAAAAA); this.DhDrawString(matrices, this.font, TextOrLiteral(ModInfo.VERSION), 2, this.height - 10,
#if MC_VER < MC_1_21_6
0xAAAAAA // RGB white
#else
0xFFAAAAAA // ARGB white
#endif);
// If the update is pending, display this message to inform the user that it will apply when the game restarts // If the update is pending, display this message to inform the user that it will apply when the game restarts
if (SelfUpdater.deleteOldJarOnJvmShutdown) if (SelfUpdater.deleteOldJarOnJvmShutdown)
DhDrawString(matrices, font, Translatable(configBase.modID + ".updater.waitingForClose"), 4, height - 38, 0xFFFFFF); {
this.DhDrawString(matrices, this.font, Translatable(this.configBase.modID + ".updater.waitingForClose"), 4, this.height - 38,
#if MC_VER < MC_1_21_6
0xFFFFFF // RGB white
#else
0xFFFFFFFF // ARGB white
#endif);
}
} }
@@ -420,15 +466,17 @@ public class ClassicConfigGUI
} }
// A quick fix for tooltips on linked entries // A quick fix for tooltips on linked entries
AbstractConfigType newInfo = ConfigLinkedEntry.class.isAssignableFrom(info.getClass()) ? AbstractConfigType newInfo = ConfigUiLinkedEntry.class.isAssignableFrom(info.getClass()) ?
((ConfigLinkedEntry) info).get() : ((ConfigUiLinkedEntry) info).get() :
info; info;
Component name = Translatable(this.translationPrefix + (info.category.isEmpty() ? "" : info.category + ".") + info.getName()); Component name = Translatable(this.translationPrefix + (info.category.isEmpty() ? "" : info.category + ".") + info.getName());
String key = translationPrefix + (newInfo.category.isEmpty() ? "" : newInfo.category + ".") + newInfo.getName() + ".@tooltip"; String key = translationPrefix + (newInfo.category.isEmpty() ? "" : newInfo.category + ".") + newInfo.getName() + ".@tooltip";
if (((EntryInfo) newInfo.guiValue).error != null && text.equals(name)) if (((EntryInfo) newInfo.guiValue).error != null && text.equals(name))
{
DhRenderTooltip(matrices, font, ((EntryInfo) newInfo.guiValue).error.getValue(), mouseX, mouseY); DhRenderTooltip(matrices, font, ((EntryInfo) newInfo.guiValue).error.getValue(), mouseX, mouseY);
}
else if (I18n.exists(key) && (text != null && text.equals(name))) else if (I18n.exists(key) && (text != null && text.equals(name)))
{ {
List<Component> list = new ArrayList<>(); List<Component> list = new ArrayList<>();
@@ -441,7 +489,7 @@ public class ClassicConfigGUI
} }
} }
} }
#if PRE_MC_1_20_2 #if MC_VER < MC_1_20_2
super.render(matrices, mouseX, mouseY, delta); super.render(matrices, mouseX, mouseY, delta);
#endif #endif
} }
@@ -452,47 +500,47 @@ public class ClassicConfigGUI
private static void initEntry(AbstractConfigType info, String translationPrefix) private static void initEntry(AbstractConfigType configType, String translationPrefix)
{ {
info.guiValue = new EntryInfo(); configType.guiValue = new EntryInfo();
Class<?> fieldClass = info.getType(); Class<?> fieldClass = configType.getType();
if (ConfigEntry.class.isAssignableFrom(info.getClass())) if (ConfigEntry.class.isAssignableFrom(configType.getClass()))
{ {
if (fieldClass == Integer.class) if (fieldClass == Integer.class)
{ {
// For int // For int
textField(info, Integer::parseInt, INTEGER_ONLY_REGEX, true); textField(configType, Integer::parseInt, INTEGER_ONLY_REGEX, true);
} }
else if (fieldClass == Double.class) else if (fieldClass == Double.class)
{ {
// For double // For double
textField(info, Double::parseDouble, DECIMAL_ONLY_REGEX, false); textField(configType, Double::parseDouble, DECIMAL_ONLY_REGEX, false);
} }
else if (fieldClass == String.class || fieldClass == List.class) else if (fieldClass == String.class || fieldClass == List.class)
{ {
// For string or list // For string or list
textField(info, String::length, null, true); textField(configType, String::length, null, true);
} }
else if (fieldClass == Boolean.class) else if (fieldClass == Boolean.class)
{ {
// For boolean // For boolean
Function<Object, Component> func = value -> Translatable("distanthorizons.general."+((Boolean) value ? "true" : "false")).withStyle((Boolean) value ? ChatFormatting.GREEN : ChatFormatting.RED); Function<Object, Component> func = value -> Translatable("distanthorizons.general."+((Boolean) value ? "true" : "false")).withStyle((Boolean) value ? ChatFormatting.GREEN : ChatFormatting.RED);
((EntryInfo) info.guiValue).widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> { ((EntryInfo) configType.guiValue).widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> {
((ConfigEntry) info).uiSetWithoutSaving(!(Boolean) info.get()); ((ConfigEntry) configType).uiSetWithoutSaving(!(Boolean) configType.get());
button.setMessage(func.apply(info.get())); button.setMessage(func.apply(configType.get()));
}, func); }, func);
} }
else if (fieldClass.isEnum()) else if (fieldClass.isEnum())
{ {
// For enum // For enum
List<?> values = Arrays.asList(info.getType().getEnumConstants()); List<?> values = Arrays.asList(configType.getType().getEnumConstants());
Function<Object, Component> func = value -> Translatable(translationPrefix + "enum." + fieldClass.getSimpleName() + "." + info.get().toString()); Function<Object, Component> func = value -> Translatable(translationPrefix + "enum." + fieldClass.getSimpleName() + "." + configType.get().toString());
((EntryInfo) info.guiValue).widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> { ((EntryInfo) configType.guiValue).widget = new AbstractMap.SimpleEntry<Button.OnPress, Function<Object, Component>>(button -> {
// get the currently selected enum and enum index // get the currently selected enum and enum index
int startingIndex = values.indexOf(info.get()); int startingIndex = values.indexOf(configType.get());
Enum<?> enumValue = (Enum<?>) values.get(startingIndex); Enum<?> enumValue = (Enum<?>) values.get(startingIndex);
// search for the next enum that is selectable // search for the next enum that is selectable
@@ -520,12 +568,12 @@ public class ClassicConfigGUI
} }
((ConfigEntry<Enum<?>>) info).uiSetWithoutSaving(enumValue); ((ConfigEntry<Enum<?>>) configType).uiSetWithoutSaving(enumValue);
button.setMessage(func.apply(info.get())); button.setMessage(func.apply(configType.get()));
}, func); }, func);
} }
} }
else if (ConfigCategory.class.isAssignableFrom(info.getClass())) else if (ConfigCategory.class.isAssignableFrom(configType.getClass()))
{ {
// if (!info.info.getName().equals("")) // if (!info.info.getName().equals(""))
// info.name = new TranslatableComponent(info.info.getName()); // info.name = new TranslatableComponent(info.info.getName());
@@ -537,9 +585,13 @@ public class ClassicConfigGUI
{ {
Font textRenderer; Font textRenderer;
public ConfigListWidget(Minecraft minecraftClient, int i, int j, int k, int l, int m) public ConfigListWidget(Minecraft minecraftClient, int canvasWidth, int canvasHeight, int topMargin, int botMargin, int itemSpacing)
{ {
super(minecraftClient, i, j, k, l, m); #if MC_VER < MC_1_20_4
super(minecraftClient, canvasWidth, canvasHeight, topMargin, canvasHeight - botMargin, itemSpacing);
#else
super(minecraftClient, canvasWidth, canvasHeight - (topMargin + botMargin), topMargin, itemSpacing);
#endif
this.centerListVertically = false; this.centerListVertically = false;
textRenderer = minecraftClient.font; textRenderer = minecraftClient.font;
} }
@@ -601,7 +653,7 @@ public class ClassicConfigGUI
} }
@Override @Override
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)
#else #else
public void render(GuiGraphics matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) public void render(GuiGraphics matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)
@@ -623,10 +675,12 @@ public class ClassicConfigGUI
indexButton.render(matrices, mouseX, mouseY, tickDelta); indexButton.render(matrices, mouseX, mouseY, tickDelta);
} }
if (text != null && (!text.getString().contains("spacer") || button != null)) if (text != null && (!text.getString().contains("spacer") || button != null))
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
GuiComponent.drawString(matrices, textRenderer, text, 12, y + 5, 0xFFFFFF); GuiComponent.drawString(matrices, textRenderer, text, 12, y + 5, 0xFFFFFF);
#elif MC_VER < MC_1_21_6
matrices.drawString(textRenderer, this.text, 12, y + 5, 0xFFFFFF);
#else #else
matrices.drawString(textRenderer, text, 12, y + 5, 0xFFFFFF); matrices.drawString(textRenderer, this.text, 12, y + 5, 0xFFFFFFFF);
#endif #endif
} }
@@ -638,7 +692,7 @@ public class ClassicConfigGUI
// Only for 1.17 and over // Only for 1.17 and over
// Remove in 1.16 and below // Remove in 1.16 and below
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
@Override @Override
public List<? extends NarratableEntry> narratables() public List<? extends NarratableEntry> narratables()
{ {
@@ -1,7 +1,7 @@
package com.seibel.distanthorizons.common.wrappers.gui; package com.seibel.distanthorizons.common.wrappers.gui;
import net.minecraft.client.gui.Font; import net.minecraft.client.gui.Font;
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.PoseStack;
#else #else
import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.GuiGraphics;
@@ -24,14 +24,14 @@ public class DhScreen extends Screen
// addButton in 1.16 and below // addButton in 1.16 and below
protected Button addBtn(Button button) protected Button addBtn(Button button)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return this.addButton(button); return this.addButton(button);
#else #else
return this.addRenderableWidget(button); return this.addRenderableWidget(button);
#endif #endif
} }
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
protected void DhDrawCenteredString(PoseStack guiStack, Font font, Component text, int x, int y, int color) protected void DhDrawCenteredString(PoseStack guiStack, Font font, Component text, int x, int y, int color)
{ {
drawCenteredString(guiStack, font, text, x, y, color); drawCenteredString(guiStack, font, text, x, y, color);
@@ -52,6 +52,27 @@ public class DhScreen extends Screen
{ {
renderTooltip(guiStack, comp, x, y); renderTooltip(guiStack, comp, x, y);
} }
#elif MC_VER < MC_1_21_6
protected void DhDrawCenteredString(GuiGraphics guiStack, Font font, Component text, int x, int y, int color)
{
guiStack.drawCenteredString(font, text, x, y, color);
}
protected void DhDrawString(GuiGraphics guiStack, Font font, Component text, int x, int y, int color)
{
guiStack.drawString(font, text, x, y, color);
}
//protected void DhRenderTooltip(GuiGraphics guiStack, Font font, List<? extends net.minecraft.util.FormattedCharSequence> text, int x, int y)
//{
// guiStack.renderTooltip(font, text, x, y);
//}
protected void DhRenderComponentTooltip(GuiGraphics guiStack, Font font, List<Component> comp, int x, int y)
{
guiStack.renderComponentTooltip(font, comp, x, y);
}
protected void DhRenderTooltip(GuiGraphics guiStack, Font font, Component text, int x, int y)
{
guiStack.renderTooltip(font, text, x, y);
}
#else #else
protected void DhDrawCenteredString(GuiGraphics guiStack, Font font, Component text, int x, int y, int color) protected void DhDrawCenteredString(GuiGraphics guiStack, Font font, Component text, int x, int y, int color)
{ {
@@ -61,17 +82,20 @@ public class DhScreen extends Screen
{ {
guiStack.drawString(font, text, x, y, color); guiStack.drawString(font, text, x, y, color);
} }
protected void DhRenderTooltip(GuiGraphics guiStack, Font font, List<? extends net.minecraft.util.FormattedCharSequence> text, int x, int y) //protected void DhRenderTooltip(GuiGraphics guiStack, Font font, List<? extends net.minecraft.util.FormattedCharSequence> text, int x, int y)
{ //{
guiStack.renderTooltip(font, text, x, y); // //guiStack.renderTooltip(font, text, x, y);
} //}
protected void DhRenderComponentTooltip(GuiGraphics guiStack, Font font, List<Component> comp, int x, int y) protected void DhRenderComponentTooltip(GuiGraphics guiStack, Font font, List<Component> comp, int x, int y)
{ {
guiStack.renderComponentTooltip(font, comp, x, y); guiStack.setComponentTooltipForNextFrame(font, comp, x, y);
} }
protected void DhRenderTooltip(GuiGraphics guiStack, Font font, Component text, int x, int y) protected void DhRenderTooltip(GuiGraphics guiStack, Font font, Component text, int x, int y)
{ {
guiStack.renderTooltip(font, text, x, y); guiStack.setTooltipForNextFrame(font, text, x, y);
} }
#endif #endif
} }
@@ -36,7 +36,7 @@ public class GetConfigScreen
case JavaFX: case JavaFX:
return MinecraftScreen.getScreen(parent, new JavaScreenHandlerScreen(new ConfigScreen()), ModInfo.ID + ".title"); return MinecraftScreen.getScreen(parent, new JavaScreenHandlerScreen(new ConfigScreen()), ModInfo.ID + ".title");
default: default:
return null; throw new IllegalArgumentException("No config screen implementation defined for ["+useScreen+"].");
} }
} }
@@ -5,7 +5,7 @@ import net.minecraft.client.gui.components.Button;
import net.minecraft.network.chat.Component; import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent; import net.minecraft.network.chat.MutableComponent;
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
import net.minecraft.network.chat.TextComponent; import net.minecraft.network.chat.TextComponent;
import net.minecraft.network.chat.TranslatableComponent; import net.minecraft.network.chat.TranslatableComponent;
#endif #endif
@@ -15,18 +15,18 @@ public class GuiHelper
/** /**
* Helper static methods for versional compat * Helper static methods for versional compat
*/ */
public static Button MakeBtn(Component base, int a, int b, int c, int d, Button.OnPress action) public static Button MakeBtn(Component base, int posX, int posZ, int width, int height, Button.OnPress action)
{ {
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
return new Button(a, b, c, d, base, action); return new Button(posX, posZ, width, height, base, action);
#else #else
return Button.builder(base, action).bounds(a, b, c, d).build(); return Button.builder(base, action).bounds(posX, posZ, width, height).build();
#endif #endif
} }
public static MutableComponent TextOrLiteral(String text) public static MutableComponent TextOrLiteral(String text)
{ {
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
return new TextComponent(text); return new TextComponent(text);
#else #else
return Component.literal(text); return Component.literal(text);
@@ -35,7 +35,7 @@ public class GuiHelper
public static MutableComponent TextOrTranslatable(String text) public static MutableComponent TextOrTranslatable(String text)
{ {
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
return new TextComponent(text); return new TextComponent(text);
#else #else
return Component.translatable(text); return Component.translatable(text);
@@ -44,7 +44,7 @@ public class GuiHelper
public static MutableComponent Translatable(String text, Object... args) public static MutableComponent Translatable(String text, Object... args)
{ {
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
return new TranslatableComponent(text, args); return new TranslatableComponent(text, args);
#else #else
return Component.translatable(text, args); return Component.translatable(text, args);
@@ -53,7 +53,7 @@ public class GuiHelper
public static void SetX(AbstractWidget w, int x) public static void SetX(AbstractWidget w, int x)
{ {
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
w.x = x; w.x = x;
#else #else
w.setX(x); w.setX(x);
@@ -62,7 +62,7 @@ public class GuiHelper
public static void SetY(AbstractWidget w, int y) public static void SetY(AbstractWidget w, int y)
{ {
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
w.y = y; w.y = y;
#else #else
w.setY(y); w.setY(y);
@@ -4,7 +4,7 @@ import com.mojang.blaze3d.platform.Window;
import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.PoseStack;
import com.seibel.distanthorizons.core.config.gui.AbstractScreen; import com.seibel.distanthorizons.core.config.gui.AbstractScreen;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
#if POST_MC_1_20_1 #if MC_VER >= MC_1_20_1
import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.GuiGraphics;
#endif #endif
import net.minecraft.client.gui.components.ContainerObjectSelectionList; import net.minecraft.client.gui.components.ContainerObjectSelectionList;
@@ -28,7 +28,7 @@ public class MinecraftScreen
private AbstractScreen screen; private AbstractScreen screen;
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
public static net.minecraft.network.chat.TranslatableComponent translate(String str, Object... args) public static net.minecraft.network.chat.TranslatableComponent translate(String str, Object... args)
{ {
return new net.minecraft.network.chat.TranslatableComponent(str, args); return new net.minecraft.network.chat.TranslatableComponent(str, args);
@@ -59,23 +59,27 @@ public class MinecraftScreen
screen.scaledHeight = this.height; screen.scaledHeight = this.height;
screen.init(); // Init our own config screen screen.init(); // Init our own config screen
this.list = new ConfigListWidget(this.minecraft, this.width, this.height, 0, this.height, 25); // Select the area to tint this.list = new ConfigListWidget(this.minecraft, this.width, this.height, 0, 0, 25); // Select the area to tint
#if MC_VER < MC_1_20_6 // no background is rendered in MC 1.20.6+
if (this.minecraft != null && this.minecraft.level != null) // Check if in game if (this.minecraft != null && this.minecraft.level != null) // Check if in game
this.list.setRenderBackground(false); // Disable from rendering this.list.setRenderBackground(false); // Disable from rendering
#endif
this.addWidget(this.list); // Add the tint to the things to be rendered this.addWidget(this.list); // Add the tint to the things to be rendered
} }
@Override @Override
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
public void render(PoseStack matrices, int mouseX, int mouseY, float delta) public void render(PoseStack matrices, int mouseX, int mouseY, float delta)
#else #else
public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta) public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta)
#endif #endif
{ {
#if MC_1_20_2 #if MC_VER < MC_1_20_2
this.renderBackground(matrices, mouseX, mouseY, delta); // Render background
#else
this.renderBackground(matrices); // Render background this.renderBackground(matrices); // Render background
#else
this.renderBackground(matrices, mouseX, mouseY, delta); // Render background
#endif #endif
this.list.render(matrices, mouseX, mouseY, delta); // Renders the items in the render list (currently only used to tint background darker) this.list.render(matrices, mouseX, mouseY, delta); // Renders the items in the render list (currently only used to tint background darker)
@@ -131,9 +135,13 @@ public class MinecraftScreen
public static class ConfigListWidget extends ContainerObjectSelectionList public static class ConfigListWidget extends ContainerObjectSelectionList
{ {
public ConfigListWidget(Minecraft minecraftClient, int i, int j, int k, int l, int m) public ConfigListWidget(Minecraft minecraftClient, int canvasWidth, int canvasHeight, int topMargin, int botMargin, int itemSpacing)
{ {
super(minecraftClient, i, j, k, l, m); #if MC_VER < MC_1_20_4
super(minecraftClient, canvasWidth, canvasHeight, topMargin, canvasHeight - botMargin, itemSpacing);
#else
super(minecraftClient, canvasWidth, canvasHeight - (topMargin + botMargin), topMargin, itemSpacing);
#endif
this.centerListVertically = false; this.centerListVertically = false;
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,32 +19,42 @@
package com.seibel.distanthorizons.common.wrappers.gui; package com.seibel.distanthorizons.common.wrappers.gui;
/**
* Creates a button with a texture on it (and a background) that works with all mc versions
*
* @author coolGi
* @version 2023-10-03
*/
import com.mojang.blaze3d.systems.RenderSystem;
import net.minecraft.client.gui.components.AbstractButton;
import net.minecraft.client.gui.components.Button;
import net.minecraft.client.gui.components.ImageButton;
import net.minecraft.network.chat.Component; import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceLocation; import net.minecraft.resources.ResourceLocation;
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
import net.minecraft.client.renderer.GameRenderer; import net.minecraft.client.gui.components.Button;
#endif
#if PRE_MC_1_20_1
import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.Minecraft;
#else
import net.minecraft.client.gui.GuiGraphics;
#endif #endif
#if PRE_MC_1_20_2 #if MC_VER < MC_1_17_1
import net.minecraft.client.gui.components.ImageButton;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.vertex.PoseStack;
import net.minecraft.client.Minecraft;
#elif MC_VER < MC_1_20_1
import net.minecraft.client.gui.components.ImageButton;
import com.mojang.blaze3d.vertex.PoseStack;
import com.mojang.blaze3d.systems.RenderSystem;
import net.minecraft.client.renderer.GameRenderer;
#elif MC_VER < MC_1_20_2
import net.minecraft.client.gui.components.ImageButton;
import net.minecraft.client.gui.GuiGraphics;
#elif MC_VER < MC_1_21_6
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.renderer.RenderType;
#else
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.RenderPipelines;
#endif
/**
* Creates a button with a texture on it (and a background) that works with all mc versions
*
* @author coolGi
* @version 2023-10-03
*/
#if MC_VER < MC_1_20_2
public class TexturedButtonWidget extends ImageButton public class TexturedButtonWidget extends ImageButton
#else #else
public class TexturedButtonWidget extends Button public class TexturedButtonWidget extends Button
@@ -52,25 +62,26 @@ public class TexturedButtonWidget extends Button
{ {
public final boolean renderBackground; public final boolean renderBackground;
#if POST_MC_1_20_2 #if MC_VER >= MC_1_20_2
private final int u; private final int u;
private final int v; private final int v;
private final int hoveredVOffset; private final int hoveredVOffset;
private final ResourceLocation texture; private final ResourceLocation textureResourceLocation;
private final int textureWidth; private final int textureWidth;
private final int textureHeight; private final int textureHeight;
#endif #endif
public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation texture, int textureWidth, int textureHeight, OnPress pressAction, Component text) { public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation textureResourceLocation, int textureWidth, int textureHeight, OnPress pressAction, Component text)
this(x, y, width, height, u, v, hoveredVOffset, texture, textureWidth, textureHeight, pressAction, text, true);
}
public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation texture, int textureWidth, int textureHeight, OnPress pressAction, Component text, boolean renderBackground)
{ {
#if PRE_MC_1_20_2 this(x, y, width, height, u, v, hoveredVOffset, textureResourceLocation, textureWidth, textureHeight, pressAction, text, true);
super(x, y, width, height, u, v, hoveredVOffset, texture, textureWidth, textureHeight, pressAction, text); }
public TexturedButtonWidget(int x, int y, int width, int height, int u, int v, int hoveredVOffset, ResourceLocation textureResourceLocation, int textureWidth, int textureHeight, OnPress pressAction, Component text, boolean renderBackground)
{
#if MC_VER < MC_1_20_2
super(x, y, width, height, u, v, hoveredVOffset, textureResourceLocation, textureWidth, textureHeight, pressAction, text);
#else #else
// We don't pass on the text option as otherwise it will render (we normally pass it for narration) // We don't pass on the text option as otherwise it will render (we normally pass it for narration)
// TODO: Find a fix for it // TODO: Find a fix for it
@@ -80,7 +91,7 @@ public class TexturedButtonWidget extends Button
this.v = v; this.v = v;
this.hoveredVOffset = hoveredVOffset; this.hoveredVOffset = hoveredVOffset;
this.texture = texture; this.textureResourceLocation = textureResourceLocation;
this.textureWidth = textureWidth; this.textureWidth = textureWidth;
this.textureHeight = textureHeight; this.textureHeight = textureHeight;
@@ -89,13 +100,14 @@ public class TexturedButtonWidget extends Button
this.renderBackground = renderBackground; this.renderBackground = renderBackground;
} }
#if PRE_MC_1_20_2 #if MC_VER < MC_1_20_2
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
@Override @Override
public void renderButton(PoseStack matrices, int mouseX, int mouseY, float delta) { public void renderButton(PoseStack matrices, int mouseX, int mouseY, float delta)
{
if (this.renderBackground) // Renders the background of the button if (this.renderBackground) // Renders the background of the button
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
Minecraft.getInstance().getTextureManager().bind(WIDGETS_LOCATION); Minecraft.getInstance().getTextureManager().bind(WIDGETS_LOCATION);
RenderSystem.color4f(1.0F, 1.0F, 1.0F, this.alpha); RenderSystem.color4f(1.0F, 1.0F, 1.0F, this.alpha);
#else #else
@@ -108,7 +120,7 @@ public class TexturedButtonWidget extends Button
RenderSystem.enableBlend(); RenderSystem.enableBlend();
RenderSystem.defaultBlendFunc(); RenderSystem.defaultBlendFunc();
RenderSystem.enableDepthTest(); RenderSystem.enableDepthTest();
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
this.blit(matrices, this.x, this.y, 0, 46 + i * 20, this.width / 2, this.height); this.blit(matrices, this.x, this.y, 0, 46 + i * 20, this.width / 2, this.height);
this.blit(matrices, this.x + this.width / 2, this.y, 200 - this.width / 2, 46 + i * 20, this.width / 2, this.height); this.blit(matrices, this.x + this.width / 2, this.y, 200 - this.width / 2, 46 + i * 20, this.width / 2, this.height);
#else #else
@@ -119,8 +131,9 @@ public class TexturedButtonWidget extends Button
super.renderButton(matrices, mouseX, mouseY, delta); super.renderButton(matrices, mouseX, mouseY, delta);
} }
#else #else
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
@Override @Override
public void renderWidget(PoseStack matrices, int mouseX, int mouseY, float delta) public void renderWidget(PoseStack matrices, int mouseX, int mouseY, float delta)
{ {
@@ -138,7 +151,7 @@ public class TexturedButtonWidget extends Button
if (!this.active) i = 0; if (!this.active) i = 0;
else if (this.isHovered) i = 2; else if (this.isHovered) i = 2;
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
RenderSystem.enableBlend(); RenderSystem.enableBlend();
RenderSystem.defaultBlendFunc(); RenderSystem.defaultBlendFunc();
RenderSystem.enableDepthTest(); RenderSystem.enableDepthTest();
@@ -154,24 +167,63 @@ public class TexturedButtonWidget extends Button
super.renderWidget(matrices, mouseX, mouseY, delta); super.renderWidget(matrices, mouseX, mouseY, delta);
} }
#endif #endif
#else #else
@Override @Override
public void renderWidget(GuiGraphics matrices, int mouseX, int mouseY, float delta) public void renderWidget(GuiGraphics matrices, int mouseX, int mouseY, float delta)
{ {
if (this.renderBackground) if (this.renderBackground)
{ {
//RenderSystem.enableBlend(); #if MC_VER < MC_1_21_3
//RenderSystem.enableDepthTest();
matrices.blitSprite(SPRITES.get(this.active, this.isHoveredOrFocused()), this.getX(), this.getY(), this.getWidth(), this.getHeight()); matrices.blitSprite(SPRITES.get(this.active, this.isHoveredOrFocused()), this.getX(), this.getY(), this.getWidth(), this.getHeight());
#elif MC_VER < MC_1_21_6
matrices.blitSprite(
RenderType::guiTextured,
SPRITES.get(this.active, this.isHoveredOrFocused()),
this.getX(), this.getY(),
this.getWidth(), this.getHeight());
#else
matrices.blitSprite(
RenderPipelines.GUI_TEXTURED,
SPRITES.get(this.active, this.isHoveredOrFocused()),
this.getX(), this.getY(),
this.getWidth(), this.getHeight());
#endif
} }
// Renders the sprite // Renders the sprite
int i = 0; int i = 0;
if (!this.active) i = 2; if (!this.active)
else if (this.isHovered) i = 1; {
i = 2;
}
else if (this.isHovered)
{
i = 1;
}
matrices.blit(this.texture, this.getX(), this.getY(), this.u, this.v + (this.hoveredVOffset * i), this.width, this.height, this.textureWidth, this.textureHeight); #if MC_VER < MC_1_21_3
matrices.blit(this.textureResourceLocation, this.getX(), this.getY(), this.u, this.v + (this.hoveredVOffset * i), this.width, this.height, this.textureWidth, this.textureHeight);
#elif MC_VER < MC_1_21_6
matrices.blit(
RenderType::guiTextured,
this.textureResourceLocation,
this.getX(), this.getY(),
this.u, this.v + (this.hoveredVOffset * i),
this.width, this.height,
this.textureWidth, this.textureHeight);
#else
matrices.blit(
RenderPipelines.GUI_TEXTURED,
this.textureResourceLocation,
this.getX(), this.getY(),
this.u, this.v + (this.hoveredVOffset * i),
this.width, this.height,
this.textureWidth, this.textureHeight);
#endif
} }
#endif #endif
} }
@@ -1,8 +1,8 @@
package com.seibel.distanthorizons.common.wrappers.gui.updater; package com.seibel.distanthorizons.common.wrappers.gui.updater;
import com.mojang.blaze3d.vertex.PoseStack;
import com.seibel.distanthorizons.common.wrappers.gui.DhScreen; import com.seibel.distanthorizons.common.wrappers.gui.DhScreen;
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants;
import com.seibel.distanthorizons.coreapi.ModInfo; import com.seibel.distanthorizons.coreapi.ModInfo;
import com.seibel.distanthorizons.core.jar.installer.MarkdownFormatter; import com.seibel.distanthorizons.core.jar.installer.MarkdownFormatter;
@@ -14,13 +14,15 @@ import net.minecraft.client.gui.components.ContainerObjectSelectionList;
import net.minecraft.client.gui.components.events.GuiEventListener; import net.minecraft.client.gui.components.events.GuiEventListener;
import net.minecraft.client.gui.screens.Screen; import net.minecraft.client.gui.screens.Screen;
import net.minecraft.network.chat.Component; import net.minecraft.network.chat.Component;
import org.apache.logging.log4j.Logger;
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
import net.minecraft.client.gui.narration.NarratableEntry; import net.minecraft.client.gui.narration.NarratableEntry;
#endif #endif
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
import net.minecraft.client.gui.GuiComponent; import net.minecraft.client.gui.GuiComponent;
import com.mojang.blaze3d.vertex.PoseStack;
#else #else
import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.GuiGraphics;
#endif #endif
@@ -39,6 +41,9 @@ import java.util.*;
// TODO: Make this // TODO: Make this
public class ChangelogScreen extends DhScreen public class ChangelogScreen extends DhScreen
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private Screen parent; private Screen parent;
private String versionID; private String versionID;
private List<String> changelog; private List<String> changelog;
@@ -51,24 +56,32 @@ public class ChangelogScreen extends DhScreen
this(parent, null); this(parent, null);
if (!ModrinthGetter.initted) // Make sure the modrinth stuff is initted if (!ModrinthGetter.initted) // Make sure the modrinth stuff is initted
{
ModrinthGetter.init(); ModrinthGetter.init();
}
if (!ModrinthGetter.initted) // If its not initted, then this isnt usable if (!ModrinthGetter.initted) // If its not initted, then this isnt usable
{
return; return;
}
if (!ModrinthGetter.mcVersions.contains(SingletonInjector.INSTANCE.get(IVersionConstants.class).getMinecraftVersion())) if (!ModrinthGetter.mcVersions.contains(SingletonInjector.INSTANCE.get(IVersionConstants.class).getMinecraftVersion()))
{
return; return;
}
String versionID = ModrinthGetter.getLatestIDForVersion(SingletonInjector.INSTANCE.get(IVersionConstants.class).getMinecraftVersion()); String versionID = ModrinthGetter.getLatestIDForVersion(SingletonInjector.INSTANCE.get(IVersionConstants.class).getMinecraftVersion());
if (versionID == null) if (versionID == null)
{
return; return;
}
try try
{ {
setupChangelog(versionID); this.setupChangelog(versionID);
usable = true; this.usable = true;
} }
catch (Exception e) catch (Exception e)
{ {
e.printStackTrace(); LOGGER.error("failed to setup changelog, error: ["+e.getMessage()+"].", e);
} }
} }
@@ -80,11 +93,13 @@ public class ChangelogScreen extends DhScreen
if (versionID == null) if (versionID == null)
{
return; return;
}
try try
{ {
setupChangelog(versionID); this.setupChangelog(versionID);
usable = true; this.usable = true;
} }
catch (Exception e) catch (Exception e)
{ {
@@ -101,11 +116,17 @@ public class ChangelogScreen extends DhScreen
this.changelog.add(""); this.changelog.add("");
this.changelog.add(""); this.changelog.add("");
String changelog = ModrinthGetter.changeLogs.get(versionID);
if (changelog == null)
{
// in case something goes wrong this will prevent null pointers
changelog = "";
}
// Get the release changelog and split it by the new lines // Get the release changelog and split it by the new lines
String[] unwrappedChangelog = // Arrays.asList could be used if a list object is desired here vs List.of which is only available for Java 9+ String[] unwrappedChangelog = // Arrays.asList could be used if a list object is desired here vs List.of which is only available for Java 9+
new MarkdownFormatter.MinecraftFormat().convertTo( // This formats markdown to minecraft's "§" characters // This formats markdown to minecraft's "§" charactersnew MarkdownFormatter.MinecraftFormat().convertTo(
ModrinthGetter.changeLogs.get(versionID) new MarkdownFormatter.MinecraftFormat().convertTo(changelog).split("\\n");
).split("\\n");
// Makes the words wrap around to not go off the screen // Makes the words wrap around to not go off the screen
for (String str : unwrappedChangelog) for (String str : unwrappedChangelog)
{ {
@@ -123,8 +144,10 @@ public class ChangelogScreen extends DhScreen
protected void init() protected void init()
{ {
super.init(); super.init();
if (!usable) if (!this.usable)
{
return; return;
}
this.addBtn( // Close this.addBtn( // Close
@@ -134,62 +157,77 @@ public class ChangelogScreen extends DhScreen
); );
this.changelogArea = new TextArea(this.minecraft, this.width * 2, this.height, 32, this.height - 32, 10); this.changelogArea = new TextArea(this.minecraft, this.width * 2, this.height, 32, 32, 10);
for (int i = 0; i < changelog.size(); i++) for (int i = 0; i < this.changelog.size(); i++)
{ {
this.changelogArea.addButton(TextOrLiteral(changelog.get(i))); this.changelogArea.addButton(TextOrLiteral(this.changelog.get(i)));
// drawString(matrices, this.font, changelog.get(i), this.width / 2 - 175, this.height / 2 - 100 + i*10, 0xFFFFFF); // drawString(matrices, this.font, changelog.get(i), this.width / 2 - 175, this.height / 2 - 100 + i*10, 0xFFFFFF);
} }
} }
@Override @Override
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
public void render(PoseStack matrices, int mouseX, int mouseY, float delta) public void render(PoseStack matrices, int mouseX, int mouseY, float delta)
#else #else
public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta) public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta)
#endif #endif
{ {
#if MC_1_20_2 #if MC_VER < MC_1_20_2
this.renderBackground(matrices, mouseX, mouseY, delta); // Render background
#else
this.renderBackground(matrices); // Render background this.renderBackground(matrices); // Render background
#else
this.renderBackground(matrices, mouseX, mouseY, delta); // Render background
#endif #endif
if (!usable) if (!this.usable)
{
return; return;
}
int maxScroll;
#if MC_VER <= MC_1_21_3
maxScroll = this.changelogArea.getMaxScroll();
#else
maxScroll = this.changelogArea.maxScrollAmount();
#endif
// Set the scroll position to the mouse height relative to the screen // Set the scroll position to the mouse height relative to the screen
// This is a bit of a hack as we cannot scroll on this area // This is a bit of a hack as we cannot scroll on this area
double scrollAmount = ((double) mouseY) / ((double) this.height) * 1.1 * this.changelogArea.getMaxScroll(); double scrollAmount = ((double) mouseY) / ((double) this.height) * 1.1 * maxScroll;
#if MC_1_16_5 || MC_1_17_1
#if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
this.changelogArea.setScrollAmount(scrollAmount); this.changelogArea.setScrollAmount(scrollAmount);
#else #elif MC_VER <= MC_1_21_3
this.changelogArea.scrollAmount = scrollAmount; this.changelogArea.scrollAmount = scrollAmount;
#else
this.changelogArea.setScrollAmount(scrollAmount);
#endif #endif
this.changelogArea.render(matrices, mouseX, mouseY, delta); // Render the changelog // render order matters, otherwise on 1.20.6+ the blurred background will render on top of the text
super.render(matrices, mouseX, mouseY, delta); // Render the buttons super.render(matrices, mouseX, mouseY, delta); // Render the buttons
this.changelogArea.render(matrices, mouseX, mouseY, delta); // Render the changelog
DhDrawCenteredString(matrices, font, title, width / 2, 15, 0xFFFFFF); // Render title this.DhDrawCenteredString(matrices, this.font, this.title, this.width / 2, 15, 0xFFFFFF); // Render title
} }
@Override @Override
public void onClose() public void onClose()
{ {
Objects.requireNonNull(minecraft).setScreen(this.parent); // Goto the parent screen Objects.requireNonNull(this.minecraft).setScreen(this.parent); // Goto the parent screen
} }
public static class TextArea extends ContainerObjectSelectionList<ButtonEntry> public static class TextArea extends ContainerObjectSelectionList<ButtonEntry>
{ {
Font textRenderer; Font textRenderer;
public TextArea(Minecraft minecraftClient, int i, int j, int k, int l, int m) public TextArea(Minecraft minecraftClient, int canvasWidth, int canvasHeight, int topMargin, int botMargin, int itemSpacing)
{ {
super(minecraftClient, i, j, k, l, m); #if MC_VER < MC_1_20_4
super(minecraftClient, canvasWidth, canvasHeight, topMargin, canvasHeight - botMargin, itemSpacing);
#else
super(minecraftClient, canvasWidth, canvasHeight - (topMargin + botMargin), topMargin, itemSpacing);
#endif
this.centerListVertically = false; this.centerListVertically = false;
textRenderer = minecraftClient.font; this.textRenderer = minecraftClient.font;
} }
public void addButton(Component text) public void addButton(Component text)
@@ -221,7 +259,7 @@ public class ChangelogScreen extends DhScreen
return new ButtonEntry(text); return new ButtonEntry(text);
} }
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
@Override @Override
public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)
{ {
@@ -231,20 +269,20 @@ public class ChangelogScreen extends DhScreen
@Override @Override
public void render(GuiGraphics matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) public void render(GuiGraphics matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)
{ {
matrices.drawString(textRenderer, text, 12, y + 5, 0xFFFFFF); matrices.drawString(textRenderer, this.text, 12, y + 5, 0xFFFFFF);
} }
#endif #endif
@Override @Override
public List<? extends GuiEventListener> children() public List<? extends GuiEventListener> children()
{ {
return children; return this.children;
} }
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
@Override @Override
public List<? extends NarratableEntry> narratables() public List<? extends NarratableEntry> narratables()
{ {
return children; return this.children;
} }
#endif #endif
} }
@@ -1,24 +1,22 @@
package com.seibel.distanthorizons.common.wrappers.gui.updater; package com.seibel.distanthorizons.common.wrappers.gui.updater;
import com.mojang.blaze3d.platform.NativeImage; import com.seibel.distanthorizons.api.enums.config.EDhApiUpdateBranch;
import com.seibel.distanthorizons.api.enums.config.EUpdateBranch;
import com.seibel.distanthorizons.common.wrappers.gui.DhScreen; import com.seibel.distanthorizons.common.wrappers.gui.DhScreen;
import com.seibel.distanthorizons.common.wrappers.gui.TexturedButtonWidget; import com.seibel.distanthorizons.common.wrappers.gui.TexturedButtonWidget;
import com.seibel.distanthorizons.core.jar.ModJarInfo; import com.seibel.distanthorizons.core.jar.ModJarInfo;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.coreapi.ModInfo; import com.seibel.distanthorizons.coreapi.ModInfo;
import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.jar.JarUtils;
import com.seibel.distanthorizons.core.jar.installer.ModrinthGetter; import com.seibel.distanthorizons.core.jar.installer.ModrinthGetter;
import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; import com.seibel.distanthorizons.core.jar.updater.SelfUpdater;
import net.minecraft.client.Minecraft; #if MC_VER >= MC_1_20_1
#if POST_MC_1_20_1
import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.GuiGraphics;
#else #else
import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.blaze3d.vertex.PoseStack;
#endif #endif
import net.minecraft.client.gui.screens.Screen; import net.minecraft.client.gui.screens.Screen;
import net.minecraft.client.renderer.texture.DynamicTexture;
import net.minecraft.resources.ResourceLocation; import net.minecraft.resources.ResourceLocation;
import org.apache.logging.log4j.Logger;
import static com.seibel.distanthorizons.common.wrappers.gui.GuiHelper.*; import static com.seibel.distanthorizons.common.wrappers.gui.GuiHelper.*;
@@ -33,6 +31,9 @@ import java.util.*;
// and also maybe add this suggestion https://discord.com/channels/881614130614767666/1035863487110467625/1035949054485594192 // and also maybe add this suggestion https://discord.com/channels/881614130614767666/1035863487110467625/1035949054485594192
public class UpdateModScreen extends DhScreen public class UpdateModScreen extends DhScreen
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private Screen parent; private Screen parent;
private String newVersionID; private String newVersionID;
@@ -40,22 +41,31 @@ public class UpdateModScreen extends DhScreen
private String nextVer; private String nextVer;
public UpdateModScreen(Screen parent, String newVersionID) public UpdateModScreen(Screen parent, String newVersionID) throws IllegalArgumentException
{ {
super(Translatable(ModInfo.ID + ".updater.title")); super(Translatable(ModInfo.ID + ".updater.title"));
this.parent = parent; this.parent = parent;
this.newVersionID = newVersionID; this.newVersionID = newVersionID;
switch (Config.Client.Advanced.AutoUpdater.updateBranch.get()) {
case STABLE: EDhApiUpdateBranch updateBranch = EDhApiUpdateBranch.convertAutoToStableOrNightly(Config.Client.Advanced.AutoUpdater.updateBranch.get());
currentVer = ModInfo.VERSION; if (updateBranch == EDhApiUpdateBranch.STABLE)
nextVer = ModrinthGetter.releaseNames.get(this.newVersionID); {
break; this.currentVer = ModInfo.VERSION;
case NIGHTLY: this.nextVer = ModrinthGetter.releaseNames.get(this.newVersionID);
currentVer = ModJarInfo.Git_Commit.substring(0,7);
nextVer = this.newVersionID.substring(0,7);
break;
} }
else
{
this.currentVer = ModJarInfo.Git_Commit.substring(0,7);
this.nextVer = this.newVersionID.substring(0,7);
}
// done to prevent trying to update to "null"
// (this can happen if no versions are available to check/download from modrinth/gitlab)
if (this.nextVer == null)
{
throw new IllegalArgumentException("No new version found with the ID ["+newVersionID+"].");
}
} }
@Override @Override
@@ -66,25 +76,24 @@ public class UpdateModScreen extends DhScreen
try try
{ {
// We cannot get assets from the root of the mod so we use this hack
// TODO: Load the icon.png and logo.png in the mod initialise rather than here
ResourceLocation logoLocation = new ResourceLocation(ModInfo.ID, "logo.png");
Minecraft.getInstance().getTextureManager().register(
logoLocation,
new DynamicTexture(NativeImage.read(JarUtils.accessFile("logo.png")))
);
// Logo image // Logo image
this.addBtn(new TexturedButtonWidget( this.addBtn(new TexturedButtonWidget(
// Where the button is on the screen // Where the button is on the screen
this.width / 2 - 65, this.height / 2 - 110, this.width / 2 - 95, this.height / 2 - 110,
// Width and height of the button // Width and height of the button
130, 65, 195, 65,
// Offset // Offset
0, 0, 0, 0,
// Some textuary stuff // Some textuary stuff
0, logoLocation, 130, 65, 0,
#if MC_VER < MC_1_21_1
new ResourceLocation(ModInfo.ID, "logo.png"),
#else
ResourceLocation.fromNamespaceAndPath(ModInfo.ID, "logo.png"),
#endif
195, 65,
// Create the button and tell it where to go // Create the button and tell it where to go
// For now it goes to the client option by default // For now it goes to the client option by default
(buttonWidget) -> System.out.println("Nice, you found an easter egg :)"), // TODO: Add a proper easter egg to pressing the logo (maybe with confetti) (buttonWidget) -> System.out.println("Nice, you found an easter egg :)"), // TODO: Add a proper easter egg to pressing the logo (maybe with confetti)
@@ -96,10 +105,10 @@ public class UpdateModScreen extends DhScreen
} }
catch (Exception e) catch (Exception e)
{ {
e.printStackTrace(); LOGGER.error("Failed to setup update mod screen, error: ["+e.getMessage()+"].", e);
} }
if (Config.Client.Advanced.AutoUpdater.updateBranch.get() == EUpdateBranch.STABLE) if (!ModInfo.IS_DEV_BUILD)
{ {
this.addBtn(new TexturedButtonWidget( this.addBtn(new TexturedButtonWidget(
// Where the button is on the screen // Where the button is on the screen
@@ -109,7 +118,13 @@ public class UpdateModScreen extends DhScreen
// Offset // Offset
0, 0, 0, 0,
// Some textuary stuff // Some textuary stuff
0, new ResourceLocation(ModInfo.ID, "textures/gui/changelog.png"), 20, 20, 0,
#if MC_VER < MC_1_21_1
new ResourceLocation(ModInfo.ID, "textures/gui/changelog.png"),
#else
ResourceLocation.fromNamespaceAndPath(ModInfo.ID, "textures/gui/changelog.png"),
#endif
20, 20,
// Create the button and tell it where to go // Create the button and tell it where to go
(buttonWidget) -> Objects.requireNonNull(minecraft).setScreen(new ChangelogScreen(this, this.newVersionID)), // TODO: Add a proper easter egg to pressing the logo (maybe with confetti) (buttonWidget) -> Objects.requireNonNull(minecraft).setScreen(new ChangelogScreen(this, this.newVersionID)), // TODO: Add a proper easter egg to pressing the logo (maybe with confetti)
// Add a title to the button // Add a title to the button
@@ -146,35 +161,49 @@ public class UpdateModScreen extends DhScreen
} }
@Override @Override
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
public void render(PoseStack matrices, int mouseX, int mouseY, float delta) public void render(PoseStack matrices, int mouseX, int mouseY, float delta)
#else #else
public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta) public void render(GuiGraphics matrices, int mouseX, int mouseY, float delta)
#endif #endif
{ {
#if MC_1_20_2 #if MC_VER < MC_1_20_2
this.renderBackground(matrices); // Render background
#elif MC_VER < MC_1_21_6
this.renderBackground(matrices, mouseX, mouseY, delta); // Render background this.renderBackground(matrices, mouseX, mouseY, delta); // Render background
#else #else
this.renderBackground(matrices); // Render background // background blur is already being rendered, rendering again causes the game to crash
#endif #endif
// Render the text's
DhDrawCenteredString(matrices, this.font, Translatable(ModInfo.ID + ".updater.text1"), this.width / 2, this.height / 2 - 35, 0xFFFFFF);
DhDrawCenteredString(matrices, this.font,
Translatable(ModInfo.ID + ".updater.text2", currentVer, nextVer),
this.width / 2, this.height / 2 - 20, 0x52FD52);
// TODO: add the tooltips for the buttons // TODO: add the tooltips for the buttons
super.render(matrices, mouseX, mouseY, delta); // Render the buttons super.render(matrices, mouseX, mouseY, delta); // Render the buttons
// TODO: Add tooltips // TODO: Add tooltips
// Render the text's
this.DhDrawCenteredString(matrices, this.font,
Translatable(ModInfo.ID + ".updater.text1"),
this.width / 2, this.height / 2 - 35,
#if MC_VER < MC_1_21_6
0xFFFFFF // RGB
#else
0xFFFFFFFF // ARGB
#endif
);
this.DhDrawCenteredString(matrices, this.font,
Translatable(ModInfo.ID + ".updater.text2", this.currentVer, this.nextVer),
this.width / 2, this.height / 2 - 20,
#if MC_VER < MC_1_21_6
0x52FD52 // RGB
#else
0xFF52FD52 // ARGB
#endif
);
} }
@Override @Override
public void onClose() public void onClose()
{ {
Objects.requireNonNull(minecraft).setScreen(this.parent); // Goto the parent screen Objects.requireNonNull(this.minecraft).setScreen(this.parent); // Go to the parent screen
} }
} }
@@ -1,21 +1,22 @@
package com.seibel.distanthorizons.common.wrappers.level; package com.seibel.distanthorizons.common.wrappers.level;
import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper;
import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel; import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.multiplayer.ClientLevel;
import org.jetbrains.annotations.Nullable;
import java.util.Objects;
public class KeyedClientLevelManager implements IKeyedClientLevelManager public class KeyedClientLevelManager implements IKeyedClientLevelManager
{ {
public static final KeyedClientLevelManager INSTANCE = new KeyedClientLevelManager(); public static final KeyedClientLevelManager INSTANCE = new KeyedClientLevelManager();
/** This is set and managed by the ClientApi for servers with support for DH. */ /** This is set and managed by the ClientApi for servers with support for DH. */
private IServerKeyedClientLevel overrideWrapper = null; @Nullable
private boolean useOverrideWrapper = false; private IServerKeyedClientLevel serverKeyedLevel = null;
/** Allows to keep level manager enabled between loading different keyed levels */
private boolean enabled = false;
//=============// //=============//
@@ -31,24 +32,24 @@ public class KeyedClientLevelManager implements IKeyedClientLevelManager
//======================// //======================//
@Override @Override
public void setServerKeyedLevel(IServerKeyedClientLevel clientLevel) { this.overrideWrapper = clientLevel; } @Nullable
@Override public IServerKeyedClientLevel getServerKeyedLevel() { return this.serverKeyedLevel; }
public IServerKeyedClientLevel getOverrideWrapper() { return this.overrideWrapper; }
@Override @Override
public IServerKeyedClientLevel getServerKeyedLevel(ILevelWrapper level, String serverLevelKey) public IServerKeyedClientLevel setServerKeyedLevel(IClientLevelWrapper clientLevel, String levelKey)
{ {
Objects.requireNonNull(level); IServerKeyedClientLevel keyedLevel = new ServerKeyedClientLevel((ClientLevel) clientLevel.getWrappedMcObject(), levelKey);
Objects.requireNonNull(serverLevelKey); this.serverKeyedLevel = keyedLevel;
return new ServerKeyedClientLevel((ClientLevel) level.getWrappedMcObject(), serverLevelKey); this.enabled = true;
return keyedLevel;
} }
@Override @Override
public void setUseOverrideWrapper(boolean useOverrideWrapper) { this.useOverrideWrapper = useOverrideWrapper; } public void clearKeyedLevel() { this.serverKeyedLevel = null; }
@Override @Override
public boolean getUseOverrideWrapper() { return this.useOverrideWrapper; } public boolean isEnabled() { return this.enabled; }
@Override
public void disable() { this.enabled = false; }
} }
@@ -2,6 +2,8 @@ package com.seibel.distanthorizons.common.wrappers.level;
import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper;
import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel; import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import com.seibel.distanthorizons.coreapi.util.StringUtil;
import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.multiplayer.ClientLevel;
public class ServerKeyedClientLevel extends ClientLevelWrapper implements IServerKeyedClientLevel public class ServerKeyedClientLevel extends ClientLevelWrapper implements IServerKeyedClientLevel
@@ -9,13 +11,20 @@ public class ServerKeyedClientLevel extends ClientLevelWrapper implements IServe
/** A unique identifier (generally the level's name) for differentiating multiverse levels */ /** A unique identifier (generally the level's name) for differentiating multiverse levels */
private final String serverLevelKey; private final String serverLevelKey;
public ServerKeyedClientLevel(ClientLevel level, String serverLevelKey) public ServerKeyedClientLevel(ClientLevel level, String serverLevelKey)
{ {
super(level); super(level);
this.serverLevelKey = serverLevelKey; this.serverLevelKey = serverLevelKey;
} }
@Override @Override
public String getServerLevelKey() { return this.serverLevelKey; } public String getServerLevelKey() { return this.serverLevelKey; }
@Override
public String getDhIdentifier() { return this.getServerLevelKey(); }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -22,15 +22,17 @@ package com.seibel.distanthorizons.common.wrappers.minecraft;
import java.io.File; import java.io.File;
import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Objects;
import java.util.UUID; import java.util.UUID;
import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.platform.NativeImage;
import com.seibel.distanthorizons.api.enums.config.ELodShading; import com.seibel.distanthorizons.api.enums.config.EDhApiLodShading;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter; import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper;
import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.config.Config;
import com.seibel.distanthorizons.core.enums.EDhDirection; import com.seibel.distanthorizons.core.enums.EDhDirection;
import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import com.seibel.distanthorizons.coreapi.ModInfo; import com.seibel.distanthorizons.coreapi.ModInfo;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
@@ -38,37 +40,43 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import com.seibel.distanthorizons.core.pos.DhBlockPos; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import net.minecraft.CrashReport; import net.minecraft.CrashReport;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.multiplayer.ServerData;
import net.minecraft.client.player.LocalPlayer; import net.minecraft.client.player.LocalPlayer;
import net.minecraft.client.resources.model.ModelManager;
import net.minecraft.core.BlockPos; import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction; import net.minecraft.core.Direction;
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
import net.minecraft.network.chat.TextComponent; import net.minecraft.network.chat.TextComponent;
#endif #endif
import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.profiling.ProfilerFiller;
import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.ChunkPos;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
#if MC_VER < MC_1_21_3
#else
import net.minecraft.util.profiling.Profiler;
#endif
/** /**
* A singleton that wraps the Minecraft object. * A singleton that wraps the Minecraft object.
* *
* @author James Seibel * @author James Seibel
* @version 3-5-2022
*/ */
//@Environment(EnvType.CLIENT)
public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecraftSharedWrapper public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecraftSharedWrapper
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName()); private static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());
private static final Minecraft MINECRAFT = Minecraft.getInstance();
public static final MinecraftClientWrapper INSTANCE = new MinecraftClientWrapper(); public static final MinecraftClientWrapper INSTANCE = new MinecraftClientWrapper();
public final Minecraft mc = Minecraft.getInstance();
/** /**
* The lightmap for the current: * The lightmap for the current:
@@ -99,10 +107,7 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
* This doesn't affect OpenGL objects in any way. * This doesn't affect OpenGL objects in any way.
*/ */
@Override @Override
public void clearFrameObjectCache() public void clearFrameObjectCache() { this.lightMap = null; }
{
lightMap = null;
}
@@ -113,22 +118,22 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
@Override @Override
public float getShade(EDhDirection lodDirection) public float getShade(EDhDirection lodDirection)
{ {
ELodShading lodShading = Config.Client.Advanced.Graphics.AdvancedGraphics.lodShading.get(); EDhApiLodShading lodShading = Config.Client.Advanced.Graphics.Quality.lodShading.get();
switch (lodShading) switch (lodShading)
{ {
default: default:
case MINECRAFT: case AUTO:
if (this.mc.level != null) if (MINECRAFT.level != null)
{ {
Direction mcDir = McObjectConverter.Convert(lodDirection); Direction mcDir = McObjectConverter.Convert(lodDirection);
return this.mc.level.getShade(mcDir, true); return MINECRAFT.level.getShade(mcDir, true);
} }
else else
{ {
return 0.0f; return 0.0f;
} }
case OLD_LIGHTING: case ENABLED:
switch (lodDirection) switch (lodDirection)
{ {
case DOWN: case DOWN:
@@ -144,100 +149,135 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
return 0.6F; return 0.6F;
} }
case NONE: case DISABLED:
return 1.0F; return 1.0F;
} }
} }
@Override @Override
public boolean hasSinglePlayerServer() { return mc.hasSingleplayerServer(); } public boolean hasSinglePlayerServer() { return MINECRAFT.hasSingleplayerServer(); }
@Override @Override
public boolean clientConnectedToDedicatedServer() { return mc.getCurrentServer() != null && !this.hasSinglePlayerServer(); } public boolean clientConnectedToDedicatedServer() { return MINECRAFT.getCurrentServer() != null && !this.hasSinglePlayerServer(); }
@Override
public boolean connectedToReplay() { return !MINECRAFT.hasSingleplayerServer() && MINECRAFT.getCurrentServer() == null; }
@Override @Override
public String getCurrentServerName() { return mc.getCurrentServer().name; } public String getCurrentServerName()
{
if (this.connectedToReplay())
{
return ClientOnlySaveStructure.REPLAY_SERVER_FOLDER_NAME;
}
else
{
ServerData server = MINECRAFT.getCurrentServer();
return (server != null) ? server.name : "NULL";
}
}
@Override @Override
public String getCurrentServerIp() { return mc.getCurrentServer().ip; } public String getCurrentServerIp()
{
if (this.connectedToReplay())
{
return "";
}
else
{
ServerData server = MINECRAFT.getCurrentServer();
return (server != null) ? server.ip : "NA";
}
}
@Override @Override
public String getCurrentServerVersion() public String getCurrentServerVersion()
{ {
return mc.getCurrentServer().version.getString(); ServerData server = MINECRAFT.getCurrentServer();
return (server != null) ? server.version.getString() : "UNKOWN";
} }
//=============// //=============//
// Simple gets // // Simple gets //
//=============// //=============//
public LocalPlayer getPlayer() public LocalPlayer getPlayer() { return MINECRAFT.player; }
{
return mc.player;
}
@Override @Override
public boolean playerExists() public boolean playerExists() { return MINECRAFT.player != null; }
{
return mc.player != null;
}
@Override @Override
public UUID getPlayerUUID() public UUID getPlayerUUID() { return this.getPlayer().getUUID(); }
{
return getPlayer().getUUID(); @Override
} public String getUsername() { return MINECRAFT.getUser().getName(); }
@Override @Override
public DhBlockPos getPlayerBlockPos() public DhBlockPos getPlayerBlockPos()
{ {
BlockPos playerPos = getPlayer().blockPosition(); LocalPlayer player = this.getPlayer();
if (player == null)
{
return new DhBlockPos(0, 0, 0);
}
BlockPos playerPos = player.blockPosition();
return new DhBlockPos(playerPos.getX(), playerPos.getY(), playerPos.getZ()); return new DhBlockPos(playerPos.getX(), playerPos.getY(), playerPos.getZ());
} }
@Override @Override
public DhChunkPos getPlayerChunkPos() public DhChunkPos getPlayerChunkPos()
{ {
#if PRE_MC_1_17_1 LocalPlayer player = this.getPlayer();
ChunkPos playerPos = new ChunkPos(getPlayer().blockPosition()); if (player == null)
{
return new DhChunkPos(0, 0);
}
#if MC_VER < MC_1_17_1
ChunkPos playerPos = new ChunkPos(player.blockPosition());
#else #else
ChunkPos playerPos = getPlayer().chunkPosition(); ChunkPos playerPos = player.chunkPosition();
#endif #endif
return new DhChunkPos(playerPos.x, playerPos.z); return new DhChunkPos(playerPos.x, playerPos.z);
} }
public ModelManager getModelManager()
{
return mc.getModelManager();
}
@Nullable @Nullable
@Override @Override
public IClientLevelWrapper getWrappedClientLevel() public IClientLevelWrapper getWrappedClientLevel() { return this.getWrappedClientLevel(false); }
@Override
@Nullable
public IClientLevelWrapper getWrappedClientLevel(boolean bypassLevelKeyManager)
{ {
if (this.mc.level == null) ClientLevel level = MINECRAFT.level;
if (level == null)
{ {
return null; return null;
} }
return ClientLevelWrapper.getWrapperIgnoringOverride(this.mc.level); return ClientLevelWrapper.getWrapper(level, bypassLevelKeyManager);
}
/** Please move over to getInstallationDirectory() */
@Deprecated
@Override
public File getGameDirectory()
{
return getInstallationDirectory();
} }
@Override @Override
public IProfilerWrapper getProfiler() public IProfilerWrapper getProfiler()
{ {
if (profilerWrapper == null) ProfilerFiller profiler;
profilerWrapper = new ProfilerWrapper(mc.getProfiler()); #if MC_VER < MC_1_21_3
else if (mc.getProfiler() != profilerWrapper.profiler) profiler = MINECRAFT.getProfiler();
profilerWrapper.profiler = mc.getProfiler(); #else
return profilerWrapper; profiler = Profiler.get();
#endif
if (this.profilerWrapper == null)
{
this.profilerWrapper = new ProfilerWrapper(profiler);
}
else if (profiler != this.profilerWrapper.profiler)
{
this.profilerWrapper.profiler = profiler;
}
return this.profilerWrapper;
} }
/** Returns all worlds available to the server */ /** Returns all worlds available to the server */
@@ -246,7 +286,7 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
{ {
ArrayList<ILevelWrapper> worlds = new ArrayList<ILevelWrapper>(); ArrayList<ILevelWrapper> worlds = new ArrayList<ILevelWrapper>();
Iterable<ServerLevel> serverWorlds = mc.getSingleplayerServer().getAllLevels(); Iterable<ServerLevel> serverWorlds = MINECRAFT.getSingleplayerServer().getAllLevels();
for (ServerLevel world : serverWorlds) for (ServerLevel world : serverWorlds)
{ {
worlds.add(ServerLevelWrapper.getWrapper(world)); worlds.add(ServerLevelWrapper.getWrapper(world));
@@ -260,12 +300,32 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
@Override @Override
public void sendChatMessage(String string) public void sendChatMessage(String string)
{ {
LocalPlayer p = getPlayer(); LocalPlayer player = this.getPlayer();
if (p == null) return; if (player == null)
#if PRE_MC_1_19_2 {
p.sendMessage(new TextComponent(string), getPlayer().getUUID()); return;
}
#if MC_VER < MC_1_19_2
player.sendMessage(new TextComponent(string), getPlayer().getUUID());
#else #else
p.sendSystemMessage(net.minecraft.network.chat.Component.translatable(string)); player.displayClientMessage(net.minecraft.network.chat.Component.translatable(string), /*isOverlay*/false);
#endif
}
@Override
public void sendOverlayMessage(String string)
{
LocalPlayer player = this.getPlayer();
if (player == null)
{
return;
}
#if MC_VER < MC_1_19_2
player.displayClientMessage(new TextComponent(string), /*isOverlay*/true);
#else
player.displayClientMessage(net.minecraft.network.chat.Component.translatable(string), /*isOverlay*/true);
#endif #endif
} }
@@ -282,28 +342,37 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra
{ {
LOGGER.error(ModInfo.READABLE_NAME + " had the following error: [" + errorMessage + "]. Crashing Minecraft...", exception); LOGGER.error(ModInfo.READABLE_NAME + " had the following error: [" + errorMessage + "]. Crashing Minecraft...", exception);
CrashReport report = new CrashReport(errorMessage, exception); CrashReport report = new CrashReport(errorMessage, exception);
#if MC_VER < MC_1_20_4
Minecraft.crash(report); Minecraft.crash(report);
#else
Minecraft.getInstance().delayCrash(report);
#endif
} }
@Override @Override
public Object getOptionsObject() public Object getOptionsObject() { return MINECRAFT.options; }
@Override
public boolean isDedicatedServer() { return false; }
@Override
public File getInstallationDirectory() { return MINECRAFT.gameDirectory; }
@Override
public void executeOnRenderThread(Runnable runnable) { MINECRAFT.execute(runnable); }
@Override
public int getPlayerCount()
{ {
return mc.options; // can be null if the server hasn't finished booting up yet
if (MINECRAFT.getSingleplayerServer() == null)
{
return 1;
}
else
{
return MINECRAFT.getSingleplayerServer().getPlayerCount();
}
} }
@Override
public boolean isDedicatedServer()
{
return false;
}
@Override
public File getInstallationDirectory()
{
return mc.gameDirectory;
}
@Override
public void executeOnRenderThread(Runnable runnable) { this.mc.execute(runnable); }
} }
@@ -1,27 +0,0 @@
package com.seibel.distanthorizons.common.wrappers.minecraft;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
import net.minecraft.server.dedicated.DedicatedServer;
import java.io.File;
//@Environment(EnvType.SERVER)
public class MinecraftDedicatedServerWrapper implements IMinecraftSharedWrapper
{
public static final MinecraftDedicatedServerWrapper INSTANCE = new MinecraftDedicatedServerWrapper();
private MinecraftDedicatedServerWrapper() { }
public DedicatedServer dedicatedServer = null;
@Override
public boolean isDedicatedServer()
{
return true;
}
@Override
public File getInstallationDirectory()
{
if (dedicatedServer == null)
throw new IllegalStateException("Trying to get Installation Direction before Dedicated server complete initialization!");
return dedicatedServer.getServerDirectory();
}
}
@@ -0,0 +1,252 @@
/*
* This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License.
*
* Copyright (C) 2020 James Seibel
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.seibel.distanthorizons.common.wrappers.minecraft;
#if MC_VER < MC_1_21_5
import com.mojang.blaze3d.platform.GlStateManager;
#elif MC_VER >= MC_1_21_5
import com.mojang.blaze3d.opengl.GlStateManager;
#endif
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper;
import org.apache.logging.log4j.Logger;
import org.lwjgl.opengl.GL32;
/**
* <b>Why does DH often call GL methods twice? </b><br>
* Once using the base {@link GL32} function and a second time using
* Minecraft's {@link GlStateManager}?<br><br>
*
* <b>Answer: </b><br>
* Compatibility and robustness<br>
* In general all MC rendering should go through MC's {@link GlStateManager},
* however that isn't always the case.
* So, to prevent issues if a mod (or MC itself) calls a direct GL function
* instead of the {@link GlStateManager} wrapper, we need to be sure about what the actual
* set value is (whether setting or getting) and that MC knows what DH has done.
* This way whether a mod (or MC) is using the {@link GlStateManager} or direct GL calls,
* they should always have the correct value for anything DH has modified.
* <br><br>
* This may slow down some low end GPUs that are driver limited,
* however James would rather have slow correct rendering vs fast broken rendering.
*/
public class MinecraftGLWrapper implements IMinecraftGLWrapper
{
public static final MinecraftGLWrapper INSTANCE = new MinecraftGLWrapper();
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
/*
private static final StencilState STENCIL;
*/
// scissor //
/** @see GL32#GL_SCISSOR_TEST */
@Override
public void enableScissorTest()
{
GL32.glEnable(GL32.GL_SCISSOR_TEST);
GlStateManager._enableScissorTest();
}
/** @see GL32#GL_SCISSOR_TEST */
@Override
public void disableScissorTest()
{
GL32.glDisable(GL32.GL_SCISSOR_TEST);
GlStateManager._disableScissorTest();
}
// stencil //
//
// /** @see GL32#GL_SCISSOR_TEST */
// public void enableScissorTest() { GlStateManager._stencilFunc(); }
// /** @see GL32#GL_SCISSOR_TEST */
// public void disableScissorTest() { GlStateManager._disableScissorTest(); }
// depth //
/** @see GL32#GL_DEPTH_TEST */
@Override
public void enableDepthTest()
{
GL32.glEnable(GL32.GL_DEPTH_TEST);
GlStateManager._enableDepthTest();
}
/** @see GL32#GL_DEPTH_TEST */
@Override
public void disableDepthTest()
{
GL32.glDisable(GL32.GL_DEPTH_TEST);
GlStateManager._disableDepthTest();
}
/** @see GL32#glDepthFunc(int) */
@Override
public void glDepthFunc(int func)
{
GL32.glDepthFunc(func);
GlStateManager._depthFunc(func);
}
/** @see GL32#glDepthMask(boolean) */
@Override
public void enableDepthMask()
{
GL32.glDepthMask(true);
GlStateManager._depthMask(true);
}
/** @see GL32#glDepthMask(boolean) */
@Override
public void disableDepthMask()
{
GL32.glDepthMask(false);
GlStateManager._depthMask(false);
}
// blending //
/** @see GL32#GL_BLEND */
@Override
public void enableBlend()
{
GL32.glEnable(GL32.GL_BLEND);
GlStateManager._enableBlend();
}
/** @see GL32#GL_BLEND */
@Override
public void disableBlend()
{
GL32.glDisable(GL32.GL_BLEND);
GlStateManager._disableBlend();
}
/** @see GL32#glBlendFunc */
@Override
public void glBlendFunc(int sfactor, int dfactor)
{
GL32.glBlendFunc(sfactor, dfactor);
#if MC_VER < MC_1_21_5
GlStateManager._blendFunc(sfactor, dfactor);
#endif
}
/** @see GL32#glBlendFuncSeparate */
@Override
public void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha)
{
GL32.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
GlStateManager._blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
// frame buffers //
/** @see GL32#glBindFramebuffer */
@Override
public void glBindFramebuffer(int target, int framebuffer)
{
GL32.glBindFramebuffer(target, framebuffer);
GlStateManager._glBindFramebuffer(target, framebuffer);
}
// buffers //
/** @see GL32#glGenBuffers() */
@Override
public int glGenBuffers()
{ return GlStateManager._glGenBuffers(); }
/** @see GL32#glDeleteBuffers(int) */
@Override
public void glDeleteBuffers(int buffer)
{
GL32.glDeleteBuffers(buffer);
// MC's implementation has a bug where it will throw:
// GL_INVALID_OPERATION in glBufferData(immutable)
// when attempting to delete Storage Buffers
// So we need to manually delete the buffers ourselves
//GlStateManager._glDeleteBuffers(buffer);
}
// culling //
/** @see GL32#GL_CULL_FACE */
@Override
public void enableFaceCulling()
{
GL32.glEnable(GL32.GL_CULL_FACE);
GlStateManager._enableCull();
}
/** @see GL32#GL_CULL_FACE */
@Override
public void disableFaceCulling()
{
GL32.glDisable(GL32.GL_CULL_FACE);
GlStateManager._disableCull();
}
// textures //
/** @see GL32#glGenTextures() */
@Override
public int glGenTextures() { return GlStateManager._genTexture(); }
/** @see GL32#glDeleteTextures(int) */
@Override
public void glDeleteTextures(int texture) { GlStateManager._deleteTexture(texture); }
/** @see GL32#glActiveTexture(int) */
@Override
public void glActiveTexture(int textureId)
{
GL32.glActiveTexture(textureId);
GlStateManager._activeTexture(textureId);
}
@Override
public int getActiveTexture() { return GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); }
/**
* Always binds to {@link GL32#GL_TEXTURE_2D}
* @see GL32#glBindTexture(int, int)
*/
@Override
public void glBindTexture(int texture)
{
GL32.glBindTexture(GL32.GL_TEXTURE_2D, texture);
GlStateManager._bindTexture(texture);
}
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -21,53 +21,46 @@ package com.seibel.distanthorizons.common.wrappers.minecraft;
import java.awt.Color; import java.awt.Color;
import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles;
import java.util.Collection; import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.stream.Collectors;
import com.mojang.blaze3d.pipeline.RenderTarget; import com.mojang.blaze3d.pipeline.RenderTarget;
import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.platform.NativeImage;
import com.mojang.blaze3d.systems.RenderSystem;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.common.wrappers.WrapperFactory; import com.seibel.distanthorizons.common.wrappers.WrapperFactory;
import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper;
import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.render.DhApiRenderProxy; import com.seibel.distanthorizons.core.util.ColorUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper;
#if PRE_MC_1_19_4 #if MC_VER < MC_1_17_1
import com.mojang.math.Vector3f; #elif MC_VER < MC_1_21_6
import net.minecraft.client.renderer.FogRenderer;
import com.mojang.blaze3d.systems.RenderSystem;
#else #else
import org.joml.Vector3f; import net.minecraft.client.renderer.fog.FogRenderer;
#endif #endif
#if MC_1_20_2
import net.minecraft.client.renderer.chunk.SectionRenderDispatcher; #if MC_VER < MC_1_19_4
import org.joml.Matrix4f;
import org.joml.Vector3f;
#else
#endif #endif
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper;
import com.seibel.distanthorizons.coreapi.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d;
import com.seibel.distanthorizons.coreapi.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f;
import com.seibel.distanthorizons.coreapi.util.math.Vec3f;
import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IOptifineAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IOptifineAccessor;
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.ISodiumAccessor;
import com.seibel.distanthorizons.core.pos.DhBlockPos;
import net.minecraft.client.Camera; import net.minecraft.client.Camera;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.FogRenderer;
import net.minecraft.client.renderer.LevelRenderer;
import net.minecraft.core.BlockPos;
import net.minecraft.world.effect.MobEffects; import net.minecraft.world.effect.MobEffects;
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
import net.minecraft.tags.FluidTags; import net.minecraft.tags.FluidTags;
import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.Entity;
import net.minecraft.world.level.material.FluidState; import net.minecraft.world.level.material.FluidState;
@@ -75,10 +68,13 @@ import org.lwjgl.opengl.GL15;
#else #else
import net.minecraft.world.level.material.FogType; import net.minecraft.world.level.material.FogType;
#endif #endif
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3; import net.minecraft.world.phys.Vec3;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.joml.Vector4f;
#if MC_VER >= MC_1_21_5
import com.mojang.blaze3d.opengl.GlTexture;
#endif
/** /**
* A singleton that contains everything * A singleton that contains everything
@@ -102,7 +98,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
* In the case of immersive portals multiple levels may be active at once, causing conflicting lightmaps. <br> * In the case of immersive portals multiple levels may be active at once, causing conflicting lightmaps. <br>
* Requiring the use of multiple {@link LightMapWrapper}. * Requiring the use of multiple {@link LightMapWrapper}.
*/ */
public HashMap<IDimensionTypeWrapper, LightMapWrapper> lightmapByDimensionType = new HashMap<>(); public ConcurrentHashMap<IDimensionTypeWrapper, LightMapWrapper> lightmapByDimensionType = new ConcurrentHashMap<>();
/** /**
* Holds the render buffer that should be used when displaying levels to the screen. * Holds the render buffer that should be used when displaying levels to the screen.
@@ -110,33 +106,47 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
*/ */
public int finalLevelFrameBufferId = -1; public int finalLevelFrameBufferId = -1;
public boolean colorTextureCastFailLogged = false;
public boolean depthTextureCastFailLogged = false;
#if MC_VER < MC_1_21_6
#else
private static FogRenderer mcFogRenderer = null;
#endif
//=========//
// methods //
//=========//
@Override @Override
public Vec3f getLookAtVector() public Vec3f getLookAtVector()
{ {
Camera camera = MC.gameRenderer.getMainCamera(); Camera camera = MC.gameRenderer.getMainCamera();
Vector3f cameraDir = camera.getLookVector(); return new Vec3f(camera.getLookVector().x(), camera.getLookVector().y(), camera.getLookVector().z());
return new Vec3f(cameraDir.x(), cameraDir.y(), cameraDir.z());
}
@Override
public DhBlockPos getCameraBlockPosition()
{
Camera camera = MC.gameRenderer.getMainCamera();
BlockPos blockPos = camera.getBlockPosition();
return new DhBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ());
} }
@Override @Override
/** Unless you really need to know if the player is blind, use {@link MinecraftRenderWrapper#isFogStateSpecial()}/{@link IMinecraftRenderWrapper#isFogStateSpecial()} instead */ /** Unless you really need to know if the player is blind, use {@link MinecraftRenderWrapper#isFogStateSpecial()}/{@link IMinecraftRenderWrapper#isFogStateSpecial()} instead */
public boolean playerHasBlindingEffect() public boolean playerHasBlindingEffect()
{ {
return MC.player.getActiveEffectsMap().get(MobEffects.BLINDNESS) != null if (MC.player == null)
#if POST_AND_MC_1_19_2 {
|| MC.player.getActiveEffectsMap().get(MobEffects.DARKNESS) != null // Deep dark effect return false;
}
else if (MC.player.getActiveEffectsMap() == null)
{
return false;
}
else
{
return MC.player.getActiveEffectsMap().get(MobEffects.BLINDNESS) != null
#if MC_VER >= MC_1_19_2
|| MC.player.getActiveEffectsMap().get(MobEffects.DARKNESS) != null // Deep dark effect
#endif #endif
; ;
}
} }
@Override @Override
@@ -148,42 +158,61 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
return new Vec3d(projectedView.x, projectedView.y, projectedView.z); return new Vec3d(projectedView.x, projectedView.y, projectedView.z);
} }
@Override
public Mat4f getDefaultProjectionMatrix(float partialTicks)
{
#if PRE_MC_1_17_1
return McObjectConverter.Convert(Minecraft.getInstance().gameRenderer.getProjectionMatrix(Minecraft.getInstance().gameRenderer.getMainCamera(), partialTicks, true));
#else
return McObjectConverter.Convert(MC.gameRenderer.getProjectionMatrix(MC.gameRenderer.getFov(MC.gameRenderer.getMainCamera(), partialTicks, true)));
#endif
}
@Override
public double getGamma()
{
#if PRE_MC_1_19_2
return MC.options.gamma;
#else
return MC.options.gamma().get();
#endif
}
@Override @Override
public Color getFogColor(float partialTicks) public Color getFogColor(float partialTicks)
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
float[] colorValues = new float[4]; float[] colorValues = new float[4];
GL15.glGetFloatv(GL15.GL_FOG_COLOR, colorValues); GL15.glGetFloatv(GL15.GL_FOG_COLOR, colorValues);
#else return new Color(
Math.max(0f, Math.min(colorValues[0], 1f)), // r
Math.max(0f, Math.min(colorValues[1], 1f)), // g
Math.max(0f, Math.min(colorValues[2], 1f)), // b
Math.max(0f, Math.min(colorValues[3], 1f)) // a
);
#elif MC_VER < MC_1_21_3
FogRenderer.setupColor(MC.gameRenderer.getMainCamera(), partialTicks, MC.level, 1, MC.gameRenderer.getDarkenWorldAmount(partialTicks)); FogRenderer.setupColor(MC.gameRenderer.getMainCamera(), partialTicks, MC.level, 1, MC.gameRenderer.getDarkenWorldAmount(partialTicks));
float[] colorValues = RenderSystem.getShaderFogColor(); float[] colorValues = RenderSystem.getShaderFogColor();
#endif
return new Color( return new Color(
Math.max(0f, Math.min(colorValues[0], 1f)), Math.max(0f, Math.min(colorValues[0], 1f)), // r
Math.max(0f, Math.min(colorValues[1], 1f)), Math.max(0f, Math.min(colorValues[1], 1f)), // g
Math.max(0f, Math.min(colorValues[2], 1f)), Math.max(0f, Math.min(colorValues[2], 1f)), // b
Math.max(0f, Math.min(colorValues[3], 1f)) Math.max(0f, Math.min(colorValues[3], 1f)) // a
); );
#elif MC_VER < MC_1_21_6
Vector4f colorValues = FogRenderer.computeFogColor(MC.gameRenderer.getMainCamera(), partialTicks, MC.level, 1, MC.gameRenderer.getDarkenWorldAmount(partialTicks));
return new Color(
Math.max(0f, Math.min(colorValues.x, 1f)), // r
Math.max(0f, Math.min(colorValues.y, 1f)), // g
Math.max(0f, Math.min(colorValues.z, 1f)), // b
Math.max(0f, Math.min(colorValues.w, 1f)) // a
);
#else
if (mcFogRenderer == null)
{
mcFogRenderer = new FogRenderer();
}
if (MC.level == null)
{
// shouldn't happen, but just in case
return Color.white;
}
boolean isFoggy =
MC.level.effects().isFoggyAt(
MC.gameRenderer.getMainCamera().getBlockPosition().getX(),
MC.gameRenderer.getMainCamera().getBlockPosition().getZ())
|| MC.gui.getBossOverlay().shouldCreateWorldFog();
Vector4f colorValues = mcFogRenderer.setupFog(MC.gameRenderer.getMainCamera(), MC.options.getEffectiveRenderDistance(), isFoggy, MC.deltaTracker, MC.gameRenderer.getDarkenWorldAmount(MC.deltaTracker.getGameTimeDeltaPartialTick(true)), MC.level);
return new Color(
Math.max(0f, Math.min(colorValues.x, 1f)), // r
Math.max(0f, Math.min(colorValues.y, 1f)), // g
Math.max(0f, Math.min(colorValues.z, 1f)), // b
Math.max(0f, Math.min(colorValues.w, 1f)) // a
);
#endif
} }
// getSpecialFogColor() is the same as getFogColor() // getSpecialFogColor() is the same as getFogColor()
@@ -192,15 +221,30 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
{ {
if (MC.level.dimensionType().hasSkyLight()) if (MC.level.dimensionType().hasSkyLight())
{ {
#if PRE_MC_1_17_1 float frameTime;
Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getBlockPosition(), MC.getFrameTime()); #if MC_VER < MC_1_21_1
frameTime = MC.getFrameTime();
#elif MC_VER < MC_1_21_3
frameTime = MC.getTimer().getRealtimeDeltaTicks();
#else #else
Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getPosition(), MC.getFrameTime()); frameTime = MC.deltaTracker.getGameTimeDeltaTicks();
#endif #endif
#if MC_VER < MC_1_17_1
Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getBlockPosition(), frameTime);
return new Color((float) colorValues.x, (float) colorValues.y, (float) colorValues.z); return new Color((float) colorValues.x, (float) colorValues.y, (float) colorValues.z);
#elif MC_VER < MC_1_21_3
Vec3 colorValues = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getPosition(), frameTime);
return new Color((float) colorValues.x, (float) colorValues.y, (float) colorValues.z);
#else
int argbColorInt = MC.level.getSkyColor(MC.gameRenderer.getMainCamera().getPosition(), frameTime);;
return ColorUtil.toColorObjARGB(argbColorInt); // TODO MC changed color formats
#endif
} }
else else
{
return new Color(0, 0, 0); return new Color(0, 0, 0);
}
} }
@Override @Override
@@ -213,7 +257,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
@Override @Override
public int getRenderDistance() public int getRenderDistance()
{ {
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
//FIXME: How to resolve this? //FIXME: How to resolve this?
return MC.options.renderDistance; return MC.options.renderDistance;
#else #else
@@ -258,111 +302,116 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
private RenderTarget getRenderTarget() { return MC.getMainRenderTarget(); } private RenderTarget getRenderTarget() { return MC.getMainRenderTarget(); }
@Override
public boolean mcRendersToFrameBuffer()
{
#if MC_VER < MC_1_21_5
return true;
#else
return false;
#endif
}
@Override
public boolean runningLegacyOpenGL()
{
#if MC_VER <= MC_1_16_5
return true;
#else
return false;
#endif
}
@Override @Override
public int getTargetFrameBuffer() public int getTargetFrameBuffer()
{ {
int frameBufferOverrideId = DhApiRenderProxy.INSTANCE.targetFrameBufferOverride;
if (frameBufferOverrideId != -1)
{
return frameBufferOverrideId;
}
// used so we can access the framebuffer shaders end up rendering to // used so we can access the framebuffer shaders end up rendering to
if (AbstractOptifineAccessor.optifinePresent()) if (AbstractOptifineAccessor.optifinePresent())
{ {
return this.finalLevelFrameBufferId; return this.finalLevelFrameBufferId;
} }
#if MC_VER < MC_1_21_5
return this.getRenderTarget().frameBufferId; return this.getRenderTarget().frameBufferId;
#else
// MC renders to a texture and then directly to the default FBO now
// we need to draw to their texture instead of the FBO
return 0; // 0 is the ID for the default frame buffer
#endif
} }
@Override @Override
public void clearTargetFrameBuffer() { this.finalLevelFrameBufferId = -1; } public void clearTargetFrameBuffer() { this.finalLevelFrameBufferId = -1; }
@Override @Override
public int getDepthTextureId() { return this.getRenderTarget().getDepthTextureId(); } public int getDepthTextureId()
{
#if MC_VER < MC_1_21_5
return this.getRenderTarget().getDepthTextureId();
#else
try
{
GlTexture glTexture = (GlTexture) this.getRenderTarget().getDepthTexture();
if (glTexture == null)
{
// shouldn't happen, but just in case
return 0;
}
return glTexture.glId();
}
catch (ClassCastException e)
{
// only log this error once per session
if (!this.depthTextureCastFailLogged)
{
this.depthTextureCastFailLogged = true;
LOGGER.error("Unable to cast render Target depth texture to GlTexture. MC or a rendering mod may have changed the object type.", e);
}
return 0;
}
#endif
}
@Override
public int getColorTextureId()
{
#if MC_VER < MC_1_21_5
return this.getRenderTarget().getColorTextureId();
#else
try
{
GlTexture glTexture = (GlTexture) this.getRenderTarget().getColorTexture();
if (glTexture == null)
{
// shouldn't happen, but just in case
return 0;
}
return glTexture.glId();
}
catch (ClassCastException e)
{
// only log this error once per session
if (!this.colorTextureCastFailLogged)
{
this.colorTextureCastFailLogged = true;
LOGGER.error("Unable to cast render Target color texture to GlTexture. MC or a rendering mod may have changed the object type.", e);
}
return 0;
}
#endif
}
@Override @Override
public int getTargetFrameBufferViewportWidth() public int getTargetFrameBufferViewportWidth()
{ {
return getRenderTarget().viewWidth; return this.getRenderTarget().viewWidth;
} }
@Override @Override
public int getTargetFrameBufferViewportHeight() public int getTargetFrameBufferViewportHeight()
{ {
return getRenderTarget().viewHeight; return this.getRenderTarget().viewHeight;
}
/**
* This method returns the ChunkPos of all chunks that Minecraft
* is going to render this frame. <br><br>
* <p>
*/
public boolean usingBackupGetVanillaRenderedChunks = false;
@Override
public HashSet<DhChunkPos> getVanillaRenderedChunks()
{
ISodiumAccessor sodium = ModAccessorInjector.INSTANCE.get(ISodiumAccessor.class);
if (sodium != null)
{
return sodium.getNormalRenderedChunks();
}
IOptifineAccessor optifine = ModAccessorInjector.INSTANCE.get(IOptifineAccessor.class);
if (optifine != null)
{
HashSet<DhChunkPos> pos = optifine.getNormalRenderedChunks();
if (pos == null)
pos = getMaximumRenderedChunks();
return pos;
}
if (!usingBackupGetVanillaRenderedChunks)
{
try
{
#if MC_1_20_2
LevelRenderer levelRenderer = MC.levelRenderer;
Collection<SectionRenderDispatcher.RenderSection> chunks = levelRenderer.visibleSections;
return (chunks.stream().map((chunk) -> {
AABB chunkBoundingBox = chunk.getBoundingBox();
return new DhChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),
Math.floorDiv((int) chunkBoundingBox.minZ, 16));
}).collect(Collectors.toCollection(HashSet::new)));
#else
LevelRenderer levelRenderer = MC.levelRenderer;
Collection<LevelRenderer.RenderChunkInfo> chunks =
#if PRE_MC_1_18_2 levelRenderer.renderChunks;
#else levelRenderer.renderChunkStorage.get().renderChunks; #endif
return (chunks.stream().map((chunk) -> {
AABB chunkBoundingBox =
#if PRE_MC_1_18_2 chunk.chunk.bb;
#else chunk.chunk.getBoundingBox(); #endif
return new DhChunkPos(Math.floorDiv((int) chunkBoundingBox.minX, 16),
Math.floorDiv((int) chunkBoundingBox.minZ, 16));
}).collect(Collectors.toCollection(HashSet::new)));
#endif
}
catch (LinkageError e)
{
try
{
MinecraftClientWrapper.INSTANCE.sendChatMessage(
"\u00A7e\u00A7l\u00A7uWARNING: Distant Horizons: getVanillaRenderedChunks method failed."
+ " Using Backup Method.");
MinecraftClientWrapper.INSTANCE.sendChatMessage(
"\u00A7eOverdraw prevention will be worse than normal.");
}
catch (Exception e2)
{
}
LOGGER.error("getVanillaRenderedChunks Error: ", e);
usingBackupGetVanillaRenderedChunks = true;
}
}
return getMaximumRenderedChunks();
} }
@Override @Override
@@ -371,7 +420,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
@Override @Override
public boolean isFogStateSpecial() public boolean isFogStateSpecial()
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
Camera camera = Minecraft.getInstance().gameRenderer.getMainCamera(); Camera camera = Minecraft.getInstance().gameRenderer.getMainCamera();
FluidState fluidState = camera.getFluidInCamera(); FluidState fluidState = camera.getFluidInCamera();
Entity entity = camera.getEntity(); Entity entity = camera.getEntity();
@@ -385,6 +434,10 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
#endif #endif
} }
/**
* It's better to use {@link MinecraftRenderWrapper#setLightmapId(int, IClientLevelWrapper)} if possible,
* however old MC versions don't support it.
*/
public void updateLightmap(NativeImage lightPixels, IClientLevelWrapper level) public void updateLightmap(NativeImage lightPixels, IClientLevelWrapper level)
{ {
// Using ClientLevelWrapper as the key would be better, but we don't have a consistent way to create the same // Using ClientLevelWrapper as the key would be better, but we don't have a consistent way to create the same
@@ -392,11 +445,18 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper
// so this will have to do for now // so this will have to do for now
IDimensionTypeWrapper dimensionType = level.getDimensionType(); IDimensionTypeWrapper dimensionType = level.getDimensionType();
if (!this.lightmapByDimensionType.containsKey(dimensionType)) LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper());
{ wrapper.uploadLightmap(lightPixels);
this.lightmapByDimensionType.put(dimensionType, new LightMapWrapper()); }
} public void setLightmapId(int tetxureId, IClientLevelWrapper level)
this.lightmapByDimensionType.get(dimensionType).uploadLightmap(lightPixels); {
// Using ClientLevelWrapper as the key would be better, but we don't have a consistent way to create the same
// object for the same MC level and/or the same hash,
// so this will have to do for now
IDimensionTypeWrapper dimensionType = level.getDimensionType();
LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper());
wrapper.setLightmapId(tetxureId);
} }
} }
@@ -0,0 +1,52 @@
package com.seibel.distanthorizons.common.wrappers.minecraft;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper;
import net.minecraft.server.dedicated.DedicatedServer;
import java.io.File;
//@Environment(EnvType.SERVER)
public class MinecraftServerWrapper implements IMinecraftSharedWrapper
{
public static final MinecraftServerWrapper INSTANCE = new MinecraftServerWrapper();
public DedicatedServer dedicatedServer = null;
//=============//
// constructor //
//=============//
private MinecraftServerWrapper() { }
//=========//
// methods //
//=========//
@Override
public boolean isDedicatedServer() { return true; }
@Override
public File getInstallationDirectory()
{
if (this.dedicatedServer == null)
{
throw new IllegalStateException("Trying to get Installation Direction before Dedicated server completed initialization!");
}
#if MC_VER < MC_1_21_1
return this.dedicatedServer.getServerDirectory();
#else
return this.dedicatedServer.getServerDirectory().toFile();
#endif
}
@Override
public int getPlayerCount()
{
return this.dedicatedServer.getPlayerCount();
}
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -31,31 +31,19 @@ public class ProfilerWrapper implements IProfilerWrapper
{ {
public ProfilerFiller profiler; public ProfilerFiller profiler;
public ProfilerWrapper(ProfilerFiller newProfiler) public ProfilerWrapper(ProfilerFiller newProfiler) { this.profiler = newProfiler; }
{
profiler = newProfiler;
}
/** starts a new section inside the currently running section */ /** starts a new section inside the currently running section */
@Override @Override
public void push(String newSection) public void push(String newSection) { this.profiler.push(newSection); }
{
profiler.push(newSection);
}
/** ends the currently running section and starts a new one */ /** ends the currently running section and starts a new one */
@Override @Override
public void popPush(String newSection) public void popPush(String newSection) { this.profiler.popPush(newSection); }
{
profiler.popPush(newSection);
}
/** ends the currently running section */ /** ends the currently running section */
@Override @Override
public void pop() public void pop() { this.profiler.pop(); }
{
profiler.pop();
}
} }
@@ -0,0 +1,15 @@
package com.seibel.distanthorizons.common.wrappers.misc;
import net.minecraft.server.level.ServerLevel;
import org.jetbrains.annotations.Nullable;
public interface IMixinServerPlayer
{
@Nullable
ServerLevel distantHorizons$getDimensionChangeDestination();
#if MC_VER == MC_1_16_5
void distantHorizons$setDimensionChangeDestination(ServerLevel dimensionChangeDestination);
#endif
}
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -20,55 +20,93 @@
package com.seibel.distanthorizons.common.wrappers.misc; package com.seibel.distanthorizons.common.wrappers.misc;
import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.platform.NativeImage;
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper;
import org.apache.logging.log4j.Logger;
import org.lwjgl.opengl.GL32; import org.lwjgl.opengl.GL32;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
/**
* @author James Seibel
* @version 11-21-2021
*/
public class LightMapWrapper implements ILightMapWrapper public class LightMapWrapper implements ILightMapWrapper
{ {
private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class);
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private int textureId = 0; private int textureId = 0;
public LightMapWrapper()
{
}
private void createLightmap(NativeImage image)
{ //==============//
textureId = GL32.glGenTextures(); // constructors //
GL32.glBindTexture(GL32.GL_TEXTURE_2D, textureId); //==============//
GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, image.format().glFormat(), image.getWidth(), image.getHeight(),
0, image.format().glFormat(), GL32.GL_UNSIGNED_BYTE, (ByteBuffer) null); public LightMapWrapper() { }
}
//==================//
// lightmap syncing //
//==================//
public void uploadLightmap(NativeImage image) public void uploadLightmap(NativeImage image)
{ {
int currentBind = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); #if MC_VER < MC_1_21_5
GL32.glBindTexture(GL32.GL_TEXTURE_2D, textureId); int currentTexture = GLMC.getActiveTexture();
if (textureId == 0) if (this.textureId == 0)
{ {
createLightmap(image); this.createLightmap(image);
}
else
{
GLMC.glBindTexture(this.textureId);
} }
// NativeImage::upload(int levelOfDetail, int xOffset, int yOffset, bool shouldCleanup?)
image.upload(0, 0, 0, false); image.upload(0, 0, 0, false);
GL32.glBindTexture(GL32.GL_TEXTURE_2D, currentBind);
// getActiveTexture() may return textures that aren't valid and attempting to bind them will
// throw a GL error in MC 1.21.1
if (GL32.glIsTexture(currentTexture))
{
GLMC.glBindTexture(currentTexture);
}
#else
throw new UnsupportedOperationException("setLightmapId should be used for MC versions after 1.21.5"); // TODO that MC version number is wrong, when did we actually start using setLightmapId()?
#endif
} }
private void createLightmap(NativeImage image)
{
#if MC_VER < MC_1_21_5
this.textureId = GLMC.glGenTextures();
GLMC.glBindTexture(this.textureId);
GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, image.format().glFormat(), image.getWidth(), image.getHeight(),
0, image.format().glFormat(), GL32.GL_UNSIGNED_BYTE, (ByteBuffer) null);
#else
throw new UnsupportedOperationException("setLightmapId should be used for MC versions after 1.21.5"); // TODO that MC version number is wrong, when did we actually start using setLightmapId()?
#endif
}
public void setLightmapId(int minecraftLightmapTetxureId)
{
// just use the MC texture ID
this.textureId = minecraftLightmapTetxureId;
}
//==============//
// lightmap use //
//==============//
@Override @Override
public void bind() public void bind()
{ {
GL32.glActiveTexture(GL32.GL_TEXTURE0); GLMC.glActiveTexture(GL32.GL_TEXTURE0);
GL32.glBindTexture(GL32.GL_TEXTURE_2D, this.textureId); GLMC.glBindTexture(this.textureId);
} }
@Override @Override
public void unbind() public void unbind() { GLMC.glBindTexture(0); }
{
GL32.glBindTexture(GL32.GL_TEXTURE_2D, 0);
}
} }
@@ -0,0 +1,30 @@
package com.seibel.distanthorizons.common.wrappers.misc;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IMutableBlockPosWrapper;
import net.minecraft.core.BlockPos;
public class MutableBlockPosWrapper implements IMutableBlockPosWrapper
{
public final BlockPos.MutableBlockPos pos;
//=============//
// constructor //
//=============//
public MutableBlockPosWrapper()
{
this.pos = new BlockPos.MutableBlockPos();
}
//===========//
// overrides //
//===========//
@Override
public Object getWrappedMcObject() { return this.pos; }
}
@@ -1,54 +1,124 @@
package com.seibel.distanthorizons.common.wrappers.misc; package com.seibel.distanthorizons.common.wrappers.misc;
import com.google.common.base.Objects;
import com.google.common.collect.MapMaker; import com.google.common.collect.MapMaker;
import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.misc.IServerPlayerWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
import com.seibel.distanthorizons.core.util.math.Vec3d;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer; import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.ServerGamePacketListenerImpl;
import net.minecraft.world.phys.Vec3;
import java.util.UUID; import java.net.SocketAddress;
import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ConcurrentMap;
/**
* This wrapper transparently ensures that the underlying {@link ServerPlayer} is always valid,
* unless the player has disconnected.
*/
public class ServerPlayerWrapper implements IServerPlayerWrapper public class ServerPlayerWrapper implements IServerPlayerWrapper
{ {
private static final ConcurrentMap<ServerPlayer, ServerPlayerWrapper> private static final ConcurrentMap<ServerGamePacketListenerImpl, ServerPlayerWrapper> serverPlayerWrapperMap = new MapMaker().weakKeys().weakValues().makeMap();
serverPlayerWrapperMap = new MapMaker().weakKeys().makeMap();
private final ServerPlayer serverPlayer; private final ServerGamePacketListenerImpl connection;
public static ServerPlayerWrapper getWrapper(ServerPlayer serverPlayer)
{
return serverPlayerWrapperMap.computeIfAbsent(serverPlayer, ServerPlayerWrapper::new);
}
private ServerPlayerWrapper(ServerPlayer serverPlayer)
{
this.serverPlayer = serverPlayer;
}
public UUID getUUID() //=============//
{ // constructor //
return serverPlayer.getUUID(); //=============//
}
public static ServerPlayerWrapper getWrapper(ServerPlayer serverPlayer)
{ return serverPlayerWrapperMap.computeIfAbsent(serverPlayer.connection, ignored -> new ServerPlayerWrapper(serverPlayer.connection)); }
private ServerPlayerWrapper(ServerGamePacketListenerImpl connection) { this.connection = connection; }
//=========//
// getters //
//=========//
private ServerPlayer getServerPlayer() { return this.connection.player; }
@Override
public String getName() { return this.getServerPlayer().getName().getString(); }
@Override
public IServerLevelWrapper getLevel() public IServerLevelWrapper getLevel()
{ {
#if PRE_MC_1_20_1 ServerLevel level = ((IMixinServerPlayer) this.getServerPlayer()).distantHorizons$getDimensionChangeDestination();
return ServerLevelWrapper.getWrapper(this.serverPlayer.getLevel()); if (level == null)
#else {
return ServerLevelWrapper.getWrapper(this.serverPlayer.serverLevel()); #if MC_VER < MC_1_20_1
#endif level = this.getServerPlayer().getLevel();
} #elif MC_VER < MC_1_21_6
level = this.getServerPlayer().serverLevel();
public Object getWrappedMcObject() #else
{ level = this.getServerPlayer().level();
return serverPlayer; #endif
}
return ServerLevelWrapper.getWrapper(level);
} }
@Override @Override
public String toString() public Vec3d getPosition()
{ {
return "Wrapped{" + serverPlayer.toString() + "}"; Vec3 position = this.getServerPlayer().position();
return new Vec3d(position.x, position.y, position.z);
} }
@Override
public int getViewDistance()
{
#if MC_VER < MC_1_21_6
return this.getServerPlayer().server.getPlayerList().getViewDistance();
#else
return this.getServerPlayer().getServer().getPlayerList().getViewDistance();
#endif
}
@Override
public SocketAddress getRemoteAddress()
{
#if MC_VER >= MC_1_19_4
return this.getServerPlayer().connection.getRemoteAddress();
#else // < 1.19.4
return this.getServerPlayer().connection.connection.getRemoteAddress();
#endif
}
//================//
// base overrides //
//================//
@Override
public Object getWrappedMcObject() { return this.getServerPlayer(); }
@Override
public String toString() { return "Wrapped{" + this.getServerPlayer() + "}"; }
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (!(obj instanceof ServerPlayerWrapper))
{
return false;
}
ServerPlayerWrapper that = (ServerPlayerWrapper) obj;
return Objects.equal(this.connection, that.connection);
}
@Override
public int hashCode() { return Objects.hashCode(this.connection); }
} }
@@ -1,17 +1,17 @@
package com.seibel.distanthorizons.common.wrappers.world; package com.seibel.distanthorizons.common.wrappers.world;
import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiLevelType; import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiLevelType;
import com.seibel.distanthorizons.api.interfaces.world.IDhApiDimensionTypeWrapper; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter; import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper;
import com.seibel.distanthorizons.common.wrappers.block.cache.ClientBlockDetailMap; import com.seibel.distanthorizons.common.wrappers.block.ClientBlockStateColorCache;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftClientWrapper;
import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector;
import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; import com.seibel.distanthorizons.core.level.*;
import com.seibel.distanthorizons.core.level.IServerKeyedClientLevel;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhBlockPos; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
@@ -19,27 +19,62 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IDimensionTypeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.ClientLevel; import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.core.BlockPos;
import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.LightLayer; import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkSource; import net.minecraft.world.level.chunk.ChunkSource;
import net.minecraft.world.level.chunk.ChunkStatus;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.awt.*;
import java.io.File;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
#if MC_VER < MC_1_21_3
import net.minecraft.world.phys.Vec3;
#else
import com.seibel.distanthorizons.core.util.ColorUtil;
#endif
public class ClientLevelWrapper implements IClientLevelWrapper public class ClientLevelWrapper implements IClientLevelWrapper
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger(ClientLevelWrapper.class.getSimpleName()); private static final Logger LOGGER = DhLoggerBuilder.getLogger(ClientLevelWrapper.class.getSimpleName());
private static final ConcurrentHashMap<ClientLevel, ClientLevelWrapper> LEVEL_WRAPPER_BY_CLIENT_LEVEL = new ConcurrentHashMap<>(); /**
* weak references are to prevent rare issues
* where, upon world closure, some levels aren't shutdown/removed properly
* and/or for servers were the level object isn't consistent
*/
private static final Map<ClientLevel, WeakReference<ClientLevelWrapper>> LEVEL_WRAPPER_REF_BY_CLIENT_LEVEL = Collections.synchronizedMap(new WeakHashMap<>());
private static final IKeyedClientLevelManager KEYED_CLIENT_LEVEL_MANAGER = SingletonInjector.INSTANCE.get(IKeyedClientLevelManager.class); private static final IKeyedClientLevelManager KEYED_CLIENT_LEVEL_MANAGER = SingletonInjector.INSTANCE.get(IKeyedClientLevelManager.class);
private static final Minecraft MINECRAFT = Minecraft.getInstance();
private final ClientLevel level; private final ClientLevel level;
private final ClientBlockDetailMap blockMap = new ClientBlockDetailMap(this); private final ConcurrentHashMap<BlockState, ClientBlockStateColorCache> blockCache = new ConcurrentHashMap<>();
/** cached method reference to reduce GC overhead */
private final Function<BlockState, ClientBlockStateColorCache> cachedBlockColorCacheFunction = (blockState) -> this.createBlockColorCache(blockState);
private BlockStateWrapper dirtBlockWrapper;
private BiomeWrapper plainsBiomeWrapper;
@Deprecated // TODO circular references are bad
private IDhLevel parentDhLevel;
@@ -51,27 +86,56 @@ public class ClientLevelWrapper implements IClientLevelWrapper
//===============// //==================//
// wrapper logic // // instance methods //
//===============// //==================//
public static IClientLevelWrapper getWrapper(@NotNull ClientLevel level) { return getWrapper(level, false); }
@Nullable @Nullable
public static IClientLevelWrapper getWrapper(@Nullable ClientLevel level) public static IClientLevelWrapper getWrapper(@Nullable ClientLevel level, boolean bypassLevelKeyManager)
{ {
if (level == null) if (!bypassLevelKeyManager)
{ {
return null; if (level == null)
{
return null;
}
// used if the client is connected to a server that defines the currently loaded level
IServerKeyedClientLevel overrideLevel = KEYED_CLIENT_LEVEL_MANAGER.getServerKeyedLevel();
if (overrideLevel != null)
{
return overrideLevel;
}
} }
// used if the client is connected to a server that defines the currently loaded level
if (KEYED_CLIENT_LEVEL_MANAGER.getUseOverrideWrapper()) WeakReference<ClientLevelWrapper> levelRef = LEVEL_WRAPPER_REF_BY_CLIENT_LEVEL.get(level);
if (levelRef != null)
{ {
return KEYED_CLIENT_LEVEL_MANAGER.getOverrideWrapper(); ClientLevelWrapper levelWrapper = levelRef.get();
if (levelWrapper != null)
{
return levelWrapper;
}
} }
return getWrapperIgnoringOverride(level);
return LEVEL_WRAPPER_REF_BY_CLIENT_LEVEL.compute(level, (newLevel, newLevelRef) ->
{
if (newLevelRef != null)
{
ClientLevelWrapper oldLevelWrapper = newLevelRef.get();
if (oldLevelWrapper != null)
{
return newLevelRef;
}
}
return new WeakReference<>(new ClientLevelWrapper(newLevel));
}).get();
} }
public static IClientLevelWrapper getWrapperIgnoringOverride(@NotNull ClientLevel level) { return LEVEL_WRAPPER_BY_CLIENT_LEVEL.computeIfAbsent(level, ClientLevelWrapper::new); }
@Nullable @Nullable
@Override @Override
@@ -79,7 +143,7 @@ public class ClientLevelWrapper implements IClientLevelWrapper
{ {
try try
{ {
Iterable<ServerLevel> serverLevels = MinecraftClientWrapper.INSTANCE.mc.getSingleplayerServer().getAllLevels(); Iterable<ServerLevel> serverLevels = MINECRAFT.getSingleplayerServer().getAllLevels();
// attempt to find the server level with the same dimension type // attempt to find the server level with the same dimension type
// TODO this assumes only one level per dimension type, the SubDimensionLevelMatcher will need to be added for supporting multiple levels per dimension // TODO this assumes only one level per dimension type, the SubDimensionLevelMatcher will need to be added for supporting multiple levels per dimension
@@ -99,7 +163,7 @@ public class ClientLevelWrapper implements IClientLevelWrapper
} }
catch (Exception e) catch (Exception e)
{ {
LOGGER.error("Failed to get server side wrapper for client level: " + level); LOGGER.error("Failed to get server side wrapper for client level: " + this.level);
return null; return null;
} }
} }
@@ -111,14 +175,74 @@ public class ClientLevelWrapper implements IClientLevelWrapper
//====================// //====================//
@Override @Override
public int computeBaseColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper blockState) public int getBlockColor(DhBlockPos pos, IBiomeWrapper biome, IBlockStateWrapper blockWrapper)
{ {
return this.blockMap.getColor(((BlockStateWrapper) blockState).blockState, (BiomeWrapper) biome, pos); ClientBlockStateColorCache blockColorCache = this.blockCache.computeIfAbsent(
((BlockStateWrapper) blockWrapper).blockState,
this.cachedBlockColorCacheFunction);
return blockColorCache.getColor((BiomeWrapper) biome, pos);
}
/** used by {@link ClientLevelWrapper#cachedBlockColorCacheFunction} */
private ClientBlockStateColorCache createBlockColorCache(BlockState block) { return new ClientBlockStateColorCache(block, this); }
@Override
public int getDirtBlockColor()
{
if (this.dirtBlockWrapper == null)
{
try
{
this.dirtBlockWrapper = (BlockStateWrapper) BlockStateWrapper.deserialize(BlockStateWrapper.DIRT_RESOURCE_LOCATION_STRING, this);
}
catch (IOException e)
{
// shouldn't happen, but just in case
LOGGER.warn("Unable to get dirt color with resource location ["+BlockStateWrapper.DIRT_RESOURCE_LOCATION_STRING+"] with level ["+this+"].", e);
return -1;
}
}
return this.getBlockColor(DhBlockPos.ZERO,BiomeWrapper.EMPTY_WRAPPER, this.dirtBlockWrapper);
}
@Override
public void clearBlockColorCache() { this.blockCache.clear(); }
@Override
public IBiomeWrapper getPlainsBiomeWrapper()
{
if (this.plainsBiomeWrapper == null)
{
try
{
this.plainsBiomeWrapper = (BiomeWrapper) BiomeWrapper.deserialize(BiomeWrapper.PLAINS_RESOURCE_LOCATION_STRING, this);
}
catch (IOException e)
{
// shouldn't happen, but just in case
LOGGER.warn("Unable to get planes biome with resource location ["+BiomeWrapper.PLAINS_RESOURCE_LOCATION_STRING+"] with level ["+this+"].", e);
return null;
}
}
return this.plainsBiomeWrapper;
} }
@Override @Override
public IDimensionTypeWrapper getDimensionType() { return DimensionTypeWrapper.getDimensionTypeWrapper(this.level.dimensionType()); } public IDimensionTypeWrapper getDimensionType() { return DimensionTypeWrapper.getDimensionTypeWrapper(this.level.dimensionType()); }
@Override
public String getDimensionName() { return this.level.dimension().location().toString(); }
@Override
public long getHashedSeed() { return this.level.getBiomeManager().biomeZoomSeed; }
@Override
public String getDhIdentifier() { return this.getHashedSeedEncoded() + "@" + this.getDimensionName(); }
@Override @Override
public EDhApiLevelType getLevelType() { return EDhApiLevelType.CLIENT_LEVEL; } public EDhApiLevelType getLevelType() { return EDhApiLevelType.CLIENT_LEVEL; }
@@ -131,33 +255,35 @@ public class ClientLevelWrapper implements IClientLevelWrapper
public boolean hasSkyLight() { return this.level.dimensionType().hasSkyLight(); } public boolean hasSkyLight() { return this.level.dimensionType().hasSkyLight(); }
@Override @Override
public int getHeight() { return this.level.getHeight(); } public int getMaxHeight() { return this.level.getHeight(); }
@Override @Override
public int getMinHeight() public int getMinHeight()
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return 0; return 0;
#else #elif MC_VER < MC_1_21_3
return this.level.getMinBuildHeight(); return this.level.getMinBuildHeight();
#else
return this.level.getMinY();
#endif #endif
} }
@Override @Override
public IChunkWrapper tryGetChunk(DhChunkPos pos) public IChunkWrapper tryGetChunk(DhChunkPos pos)
{ {
if (!this.level.hasChunk(pos.x, pos.z)) if (!this.level.hasChunk(pos.getX(), pos.getZ()))
{ {
return null; return null;
} }
ChunkAccess chunk = this.level.getChunk(pos.x, pos.z, ChunkStatus.EMPTY, false); ChunkAccess chunk = this.level.getChunk(pos.getX(), pos.getZ(), ChunkStatus.EMPTY, false);
if (chunk == null) if (chunk == null)
{ {
return null; return null;
} }
return new ChunkWrapper(chunk, this.level, this); return new ChunkWrapper(chunk, this);
} }
@Override @Override
@@ -169,9 +295,7 @@ public class ClientLevelWrapper implements IClientLevelWrapper
@Override @Override
public IBlockStateWrapper getBlockState(DhBlockPos pos) public IBlockStateWrapper getBlockState(DhBlockPos pos)
{ { return BlockStateWrapper.fromBlockState(this.level.getBlockState(McObjectConverter.Convert(pos)), this); }
return BlockStateWrapper.fromBlockState(this.level.getBlockState(McObjectConverter.Convert(pos)), this);
}
@Override @Override
public IBiomeWrapper getBiome(DhBlockPos pos) { return BiomeWrapper.getBiomeWrapper(this.level.getBiome(McObjectConverter.Convert(pos)), this); } public IBiomeWrapper getBiome(DhBlockPos pos) { return BiomeWrapper.getBiomeWrapper(this.level.getBiome(McObjectConverter.Convert(pos)), this); }
@@ -180,7 +304,61 @@ public class ClientLevelWrapper implements IClientLevelWrapper
public ClientLevel getWrappedMcObject() { return this.level; } public ClientLevel getWrappedMcObject() { return this.level; }
@Override @Override
public void onUnload() { LEVEL_WRAPPER_BY_CLIENT_LEVEL.remove(this.level); } public void onUnload()
{
LEVEL_WRAPPER_REF_BY_CLIENT_LEVEL.remove(this.level);
this.parentDhLevel = null;
}
@Override
public File getDhSaveFolder()
{
if (this.parentDhLevel == null)
{
return null;
}
return this.parentDhLevel.getSaveStructure().getSaveFolder(this);
}
//===================//
// generic rendering //
//===================//
@Override
public void setParentLevel(IDhLevel parentLevel) { this.parentDhLevel = parentLevel; }
@Override
public IDhApiCustomRenderRegister getRenderRegister()
{
if (this.parentDhLevel == null)
{
return null;
}
return this.parentDhLevel.getGenericRenderer();
}
@Override
public Color getCloudColor(float tickDelta)
{
#if MC_VER < MC_1_21_3
Vec3 colorVec3 = this.level.getCloudColor(tickDelta);
return new Color((float)colorVec3.x, (float)colorVec3.y, (float)colorVec3.z);
#else
int argbColor = this.level.getCloudColor(tickDelta);
return ColorUtil.toColorObjARGB(argbColor);
#endif
}
//================//
// base overrides //
//================//
@Override @Override
public String toString() public String toString()
@@ -190,7 +368,7 @@ public class ClientLevelWrapper implements IClientLevelWrapper
return "Wrapped{null}"; return "Wrapped{null}";
} }
return "Wrapped{" + this.level.toString() + "@" + this.getDimensionType().getDimensionName() + "}"; return "Wrapped{" + this.level.toString() + "@" + this.getDhIdentifier() + "}";
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -28,65 +28,81 @@ import net.minecraft.world.level.dimension.DimensionType;
/** /**
* @author James Seibel * @author James Seibel
* @version 2022-9-16
*/ */
public class DimensionTypeWrapper implements IDimensionTypeWrapper public class DimensionTypeWrapper implements IDimensionTypeWrapper
{ {
private static final ConcurrentMap<DimensionType, DimensionTypeWrapper> dimensionTypeWrapperMap = new ConcurrentHashMap<>(); private static final ConcurrentMap<String, DimensionTypeWrapper> DIMENSION_WRAPPER_BY_NAME = new ConcurrentHashMap<>();
private final DimensionType dimensionType; private final DimensionType dimensionType;
public DimensionTypeWrapper(DimensionType dimensionType)
{
this.dimensionType = dimensionType; //=============//
} // Constructor //
//=============//
public DimensionTypeWrapper(DimensionType dimensionType) { this.dimensionType = dimensionType; }
public static DimensionTypeWrapper getDimensionTypeWrapper(DimensionType dimensionType) public static DimensionTypeWrapper getDimensionTypeWrapper(DimensionType dimensionType)
{ {
//first we check if the biome has already been wrapped String dimName = getName(dimensionType);
if (dimensionTypeWrapperMap.containsKey(dimensionType) && dimensionTypeWrapperMap.get(dimensionType) != null)
return dimensionTypeWrapperMap.get(dimensionType); // check if the dimension has already been wrapped
if (DIMENSION_WRAPPER_BY_NAME.containsKey(dimName)
&& DIMENSION_WRAPPER_BY_NAME.get(dimName) != null)
{
return DIMENSION_WRAPPER_BY_NAME.get(dimName);
}
//if it hasn't been created yet, we create it and save it in the map // create the missing wrapper
DimensionTypeWrapper dimensionTypeWrapper = new DimensionTypeWrapper(dimensionType); DimensionTypeWrapper dimensionTypeWrapper = new DimensionTypeWrapper(dimensionType);
dimensionTypeWrapperMap.put(dimensionType, dimensionTypeWrapper); DIMENSION_WRAPPER_BY_NAME.put(dimName, dimensionTypeWrapper);
//we return the newly created wrapper
return dimensionTypeWrapper; return dimensionTypeWrapper;
} }
public static void clearMap() public static void clearMap() { DIMENSION_WRAPPER_BY_NAME.clear(); }
{
dimensionTypeWrapperMap.clear();
}
//=================//
// wrapper methods //
//=================//
@Override @Override
public String getDimensionName() public String getName() { return getName(this.dimensionType); }
public static String getName(DimensionType dimensionType)
{ {
#if MC_VER <= MC_1_16_5
// effectsLocation() is marked as client only, so using the backing field directly
return dimensionType.effectsLocation.getPath();
#else
return dimensionType.effectsLocation().getPath(); return dimensionType.effectsLocation().getPath();
#endif
} }
@Override @Override
public boolean hasCeiling() public boolean hasCeiling() { return this.dimensionType.hasCeiling(); }
{
return dimensionType.hasCeiling();
}
@Override @Override
public boolean hasSkyLight() public boolean hasSkyLight() { return this.dimensionType.hasSkyLight(); }
{
return dimensionType.hasSkyLight();
}
@Override @Override
public Object getWrappedMcObject() public Object getWrappedMcObject() { return this.dimensionType; }
{
return this.dimensionType; // there's definitely a better way of doing this, but it should work well enough for now
} @Override
public boolean isTheEnd() { return this.getName().equalsIgnoreCase("the_end"); }
@Override
public double getCoordinateScale() { return this.dimensionType.coordinateScale(); }
//================//
// base overrides //
//================//
@Override @Override
public boolean equals(Object obj) public boolean equals(Object obj)
{ {
@@ -97,9 +113,10 @@ public class DimensionTypeWrapper implements IDimensionTypeWrapper
else else
{ {
DimensionTypeWrapper other = (DimensionTypeWrapper) obj; DimensionTypeWrapper other = (DimensionTypeWrapper) obj;
return other.getDimensionName().equals(this.getDimensionName()); return other.getName().equals(this.getName());
} }
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -20,42 +20,57 @@
package com.seibel.distanthorizons.common.wrappers.world; package com.seibel.distanthorizons.common.wrappers.world;
import java.io.File; import java.io.File;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiLevelType; import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiLevelType;
import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister;
import com.seibel.distanthorizons.common.wrappers.McObjectConverter; import com.seibel.distanthorizons.common.wrappers.McObjectConverter;
import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper;
import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper;
import com.seibel.distanthorizons.common.wrappers.block.cache.ServerBlockDetailMap;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftClientWrapper; import com.seibel.distanthorizons.core.level.IDhLevel;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhBlockPos; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper;
import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IServerLevelWrapper;
import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkSource; import net.minecraft.world.level.chunk.ChunkSource;
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus; import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
#if MC_VER < MC_1_21_3
#else
import java.nio.file.Path;
#endif
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.Nullable;
/**
* @version 2022-9-16
*/
public class ServerLevelWrapper implements IServerLevelWrapper public class ServerLevelWrapper implements IServerLevelWrapper
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger(); private static final Logger LOGGER = DhLoggerBuilder.getLogger();
private static final ConcurrentHashMap<ServerLevel, ServerLevelWrapper> LEVEL_WRAPPER_BY_SERVER_LEVEL = new ConcurrentHashMap<>(); /**
* weak references are to prevent rare issues
* where, upon world closure, some levels aren't shutdown/removed properly
*/
private static final Map<ServerLevel, WeakReference<ServerLevelWrapper>> LEVEL_WRAPPER_REF_BY_SERVER_LEVEL = Collections.synchronizedMap(new WeakHashMap<>());
final ServerLevel level; private final ServerLevel level;
ServerBlockDetailMap blockMap = new ServerBlockDetailMap(this); @Deprecated // TODO circular references are bad
private IDhLevel parentDhLevel;
@@ -63,121 +78,168 @@ public class ServerLevelWrapper implements IServerLevelWrapper
// constructors // // constructors //
//==============// //==============//
public static ServerLevelWrapper getWrapper(ServerLevel level) { return LEVEL_WRAPPER_BY_SERVER_LEVEL.computeIfAbsent(level, ServerLevelWrapper::new); } public static ServerLevelWrapper getWrapper(ServerLevel level)
public ServerLevelWrapper(ServerLevel level)
{ {
this.level = level; return LEVEL_WRAPPER_REF_BY_SERVER_LEVEL.compute(level, (newLevel, levelRef) ->
}
//=========//
// methods //
//=========//
@Nullable
@Override
public IClientLevelWrapper tryGetClientLevelWrapper()
{
MinecraftClientWrapper client = MinecraftClientWrapper.INSTANCE;
if (client.mc.level == null)
{ {
return null; if (levelRef != null)
} {
ServerLevelWrapper oldLevelWrapper = levelRef.get();
if (oldLevelWrapper != null)
{
return levelRef;
}
}
return new WeakReference<>(new ServerLevelWrapper(newLevel));
}).get();
}
public ServerLevelWrapper(ServerLevel level) { this.level = level; }
//==================//
// instance methods //
//==================//
@Override
public File getMcSaveFolder()
{
#if MC_VER < MC_1_21_3
return this.level.getChunkSource().getDataStorage().dataFolder;
#else
return this.level.getChunkSource().getDataStorage().dataFolder.toFile();
#endif
}
@Override
public String getWorldFolderName()
{
// Need specifically overworld since it's the only dimension that is stored in a server root folder
return ClientLevelWrapper.getWrapper(client.mc.level); #if MC_VER >= MC_1_21_3
return this.level.getServer().getLevel(Level.OVERWORLD).getChunkSource().getDataStorage().dataFolder.getParent().getFileName().toString();
#else // <= 1.21.3
return this.level.getServer().getLevel(Level.OVERWORLD).getChunkSource().getDataStorage().dataFolder.getParentFile().getName();
#endif
} }
@Override @Override
public File getSaveFolder() public DimensionTypeWrapper getDimensionType() { return DimensionTypeWrapper.getDimensionTypeWrapper(this.level.dimensionType()); }
{
return level.getChunkSource().getDataStorage().dataFolder; @Override
} public String getDimensionName() { return this.level.dimension().location().toString(); }
@Override @Override
public DimensionTypeWrapper getDimensionType() public long getHashedSeed() { return this.level.getBiomeManager().biomeZoomSeed; }
{
return DimensionTypeWrapper.getDimensionTypeWrapper(level.dimensionType()); @Override
} public String getDhIdentifier() { return this.getDimensionName(); }
@Override @Override
public EDhApiLevelType getLevelType() { return EDhApiLevelType.SERVER_LEVEL; } public EDhApiLevelType getLevelType() { return EDhApiLevelType.SERVER_LEVEL; }
public ServerLevel getLevel() public ServerLevel getLevel() { return this.level; }
{
return level;
}
@Override @Override
public boolean hasCeiling() public boolean hasCeiling() { return this.level.dimensionType().hasCeiling(); }
{
return level.dimensionType().hasCeiling();
}
@Override @Override
public boolean hasSkyLight() public boolean hasSkyLight() { return this.level.dimensionType().hasSkyLight(); }
{
return level.dimensionType().hasSkyLight();
}
@Override @Override
public int getHeight() public int getMaxHeight() { return this.level.getHeight(); }
{
return level.getHeight();
}
@Override @Override
public int getMinHeight() public int getMinHeight()
{ {
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
return 0; return 0;
#elif MC_VER < MC_1_21_3
return this.level.getMinBuildHeight();
#else #else
return level.getMinBuildHeight(); return this.level.getMinY();
#endif #endif
} }
@Override @Override
public IChunkWrapper tryGetChunk(DhChunkPos pos) public IChunkWrapper tryGetChunk(DhChunkPos pos)
{ {
if (!level.hasChunk(pos.x, pos.z)) return null; if (!this.level.hasChunk(pos.getX(), pos.getZ()))
ChunkAccess chunk = level.getChunk(pos.x, pos.z, ChunkStatus.FULL, false); {
if (chunk == null) return null; return null;
return new ChunkWrapper(chunk, level, this); }
ChunkAccess chunk = this.level.getChunk(pos.getX(), pos.getZ(), ChunkStatus.FULL, false);
if (chunk == null)
{
return null;
}
return new ChunkWrapper(chunk, this);
} }
@Override @Override
public boolean hasChunkLoaded(int chunkX, int chunkZ) public boolean hasChunkLoaded(int chunkX, int chunkZ)
{ {
// world.hasChunk(chunkX, chunkZ); THIS DOES NOT WORK FOR CLIENT LEVEL CAUSE MOJANG ALWAYS RETURN TRUE FOR THAT! // world.hasChunk(chunkX, chunkZ); THIS DOES NOT WORK FOR CLIENT LEVEL CAUSE MOJANG ALWAYS RETURN TRUE FOR THAT!
ChunkSource source = level.getChunkSource(); ChunkSource source = this.level.getChunkSource();
return source.hasChunk(chunkX, chunkZ); return source.hasChunk(chunkX, chunkZ);
} }
@Override @Override
public IBlockStateWrapper getBlockState(DhBlockPos pos) public IBlockStateWrapper getBlockState(DhBlockPos pos)
{ {
return BlockStateWrapper.fromBlockState(level.getBlockState(McObjectConverter.Convert(pos)), this); return BlockStateWrapper.fromBlockState(this.level.getBlockState(McObjectConverter.Convert(pos)), this);
} }
@Override @Override
public IBiomeWrapper getBiome(DhBlockPos pos) public IBiomeWrapper getBiome(DhBlockPos pos)
{ {
return BiomeWrapper.getBiomeWrapper(level.getBiome(McObjectConverter.Convert(pos)), this); return BiomeWrapper.getBiomeWrapper(this.level.getBiome(McObjectConverter.Convert(pos)), this);
} }
@Override @Override
public ServerLevel getWrappedMcObject() public ServerLevel getWrappedMcObject() { return this.level; }
@Override
public void onUnload() { LEVEL_WRAPPER_REF_BY_SERVER_LEVEL.remove(this.level); }
@Override
public void setParentLevel(IDhLevel parentLevel) { this.parentDhLevel = parentLevel; }
@Override
public IDhApiCustomRenderRegister getRenderRegister()
{ {
return level; if (this.parentDhLevel == null)
{
return null;
}
return this.parentDhLevel.getGenericRenderer();
} }
@Override @Override
public void onUnload() { LEVEL_WRAPPER_BY_SERVER_LEVEL.remove(this.level); } public File getDhSaveFolder()
@Override
public String toString()
{ {
return "Wrapped{" + level.toString() + "@" + getDimensionType().getDimensionName() + "}"; if (this.parentDhLevel == null)
{
return null;
}
return this.parentDhLevel.getSaveStructure().getSaveFolder(this);
} }
//================//
// base overrides //
//================//
@Override
public String toString() { return "Wrapped{" + this.level.toString() + "@" + this.getDhIdentifier() + "}"; }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -20,19 +20,16 @@
package com.seibel.distanthorizons.common.wrappers.worldGeneration; package com.seibel.distanthorizons.common.wrappers.worldGeneration;
import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer; import java.util.function.Consumer;
import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiDistantGeneratorMode;
import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGenerationStep; import com.seibel.distanthorizons.api.enums.worldGeneration.EDhApiWorldGenerationStep;
import com.seibel.distanthorizons.core.generation.WorldGenerationQueue;
import com.seibel.distanthorizons.core.util.ThreadUtil;
import com.seibel.distanthorizons.core.util.objects.UncheckedInterruptedException; import com.seibel.distanthorizons.core.util.objects.UncheckedInterruptedException;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.pos.DhChunkPos; import com.seibel.distanthorizons.core.pos.DhChunkPos;
import com.seibel.distanthorizons.core.util.objects.EventTimer; import com.seibel.distanthorizons.core.util.objects.EventTimer;
import com.seibel.distanthorizons.core.util.threading.ThreadPools; import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil;
import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
@@ -45,8 +42,10 @@ public final class GenerationEvent
public final int id; public final int id;
public final ThreadedParameters threadedParam; public final ThreadedParameters threadedParam;
public final DhChunkPos minPos; public final DhChunkPos minPos;
/** the number of chunks wide this event is */
public final int size; public final int size;
public final EDhApiWorldGenerationStep targetGenerationStep; public final EDhApiWorldGenerationStep targetGenerationStep;
public final EDhApiDistantGeneratorMode generatorMode;
public EventTimer timer = null; public EventTimer timer = null;
public long inQueueTime; public long inQueueTime;
public long timeoutTime = -1; public long timeoutTime = -1;
@@ -57,12 +56,13 @@ public final class GenerationEvent
public GenerationEvent( public GenerationEvent(
DhChunkPos minPos, int size, BatchGenerationEnvironment generationGroup, DhChunkPos minPos, int size, BatchGenerationEnvironment generationGroup,
EDhApiWorldGenerationStep targetGenerationStep, Consumer<IChunkWrapper> resultConsumer) EDhApiDistantGeneratorMode generatorMode, EDhApiWorldGenerationStep targetGenerationStep, Consumer<IChunkWrapper> resultConsumer)
{ {
this.inQueueTime = System.nanoTime(); this.inQueueTime = System.nanoTime();
this.id = generationFutureDebugIDs++; this.id = generationFutureDebugIDs++;
this.minPos = minPos; this.minPos = minPos;
this.size = size; this.size = size;
this.generatorMode = generatorMode;
this.targetGenerationStep = targetGenerationStep; this.targetGenerationStep = targetGenerationStep;
this.threadedParam = ThreadedParameters.getOrMake(generationGroup.params); this.threadedParam = ThreadedParameters.getOrMake(generationGroup.params);
this.resultConsumer = resultConsumer; this.resultConsumer = resultConsumer;
@@ -72,17 +72,11 @@ public final class GenerationEvent
public static GenerationEvent startEvent( public static GenerationEvent startEvent(
DhChunkPos minPos, int size, BatchGenerationEnvironment genEnvironment, DhChunkPos minPos, int size, BatchGenerationEnvironment genEnvironment,
EDhApiWorldGenerationStep target, Consumer<IChunkWrapper> resultConsumer, EDhApiDistantGeneratorMode generatorMode, EDhApiWorldGenerationStep target, Consumer<IChunkWrapper> resultConsumer,
ExecutorService worldGeneratorThreadPool) ExecutorService worldGeneratorThreadPool)
{ {
if (size % 2 == 0) GenerationEvent generationEvent = new GenerationEvent(minPos, size, genEnvironment, generatorMode, target, resultConsumer);
{ generationEvent.future = CompletableFuture.supplyAsync(() ->
size += 1; // size must be odd for vanilla world gen regions to work
}
GenerationEvent generationEvent = new GenerationEvent(minPos, size, genEnvironment, target, resultConsumer);
generationEvent.future = CompletableFuture.runAsync(() ->
{ {
long runStartTime = System.nanoTime(); long runStartTime = System.nanoTime();
generationEvent.timeoutTime = runStartTime; generationEvent.timeoutTime = runStartTime;
@@ -90,21 +84,75 @@ public final class GenerationEvent
generationEvent.timer = new EventTimer("setup"); generationEvent.timer = new EventTimer("setup");
BatchGenerationEnvironment.isDistantGeneratorThread.set(true); BatchGenerationEnvironment.isDistantGeneratorThread.set(true);
try try
{ {
//LOGGER.info("generating [{}]", event.minPos); genEnvironment.generateLodFromListAsync(generationEvent, (runnable) ->
genEnvironment.generateLodFromList(generationEvent); {
worldGeneratorThreadPool.execute(() ->
{
boolean alreadyMarked = BatchGenerationEnvironment.isCurrentThreadDistantGeneratorThread();
if (!alreadyMarked)
{
BatchGenerationEnvironment.isDistantGeneratorThread.set(true);
}
try
{
runnable.run();
}
catch (Throwable throwable)
{
handleWorldGenThrowable(generationEvent, throwable);
}
finally
{
if (!alreadyMarked)
{
BatchGenerationEnvironment.isDistantGeneratorThread.set(false);
}
}
});
});
} }
catch (InterruptedException ignored) catch (Throwable initialThrowable)
{ {
handleWorldGenThrowable(generationEvent, initialThrowable);
} }
finally finally
{ {
BatchGenerationEnvironment.isDistantGeneratorThread.remove(); BatchGenerationEnvironment.isDistantGeneratorThread.remove();
} }
return null;
}, worldGeneratorThreadPool); }, worldGeneratorThreadPool);
return generationEvent; return generationEvent;
} }
/** There's probably a better way to handle this, but it'll work for now */
private static void handleWorldGenThrowable(GenerationEvent generationEvent, Throwable initialThrowable)
{
Throwable throwable = initialThrowable;
while (throwable instanceof CompletionException)
{
throwable = throwable.getCause();
}
if (throwable instanceof InterruptedException
|| throwable instanceof UncheckedInterruptedException
|| throwable instanceof RejectedExecutionException)
{
// these exceptions can be ignored, generally they just mean
// the thread is busy so it'll need to try again later.
// FIXME this should cause the world gen task to be re-queued so we can try again later
// however, currently it can cause large gaps in the world gen instead.
// These gaps will generate correctly if the level is reloaded and the world gen is re-queued,
// however this is makes it look like the generator isn't working or skipped something.
}
else
{
generationEvent.future.completeExceptionally(throwable);
}
}
public boolean isComplete() { return this.future.isDone(); } public boolean isComplete() { return this.future.isDone(); }
@@ -123,26 +171,11 @@ public final class GenerationEvent
public boolean terminate() public boolean terminate()
{ {
LOGGER.info("======================DUMPING ALL THREADS FOR WORLD GEN======================="); LOGGER.info("======================DUMPING ALL THREADS FOR WORLD GEN=======================");
ThreadPools.WORLD_GEN_THREAD_FACTORY.dumpAllThreadStacks(); ThreadPoolUtil.WORLD_GEN_THREAD_FACTORY.dumpAllThreadStacks();
this.future.cancel(true); this.future.cancel(true);
return this.future.isCancelled(); return this.future.isCancelled();
} }
public boolean tooClose(int minX, int minZ, int width)
{
int aMinX = this.minPos.x;
int aMinZ = this.minPos.z;
int aSize = this.size;
// Account for required empty chunks in the border
aSize += 1;
width += 1;
// Do a AABB to AABB intersection test
return (aMinX + aSize >= minX &&
aMinX <= minX + width &&
aMinZ + aSize >= minZ &&
aMinZ <= minZ + width);
}
public void refreshTimeout() public void refreshTimeout()
{ {
this.timeoutTime = System.nanoTime(); this.timeoutTime = System.nanoTime();
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -31,16 +31,16 @@ import net.minecraft.server.level.ThreadedLevelLightEngine;
import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.biome.BiomeManager; import net.minecraft.world.level.biome.BiomeManager;
import net.minecraft.world.level.chunk.ChunkGenerator; import net.minecraft.world.level.chunk.ChunkGenerator;
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
import net.minecraft.world.level.chunk.storage.ChunkScanAccess; import net.minecraft.world.level.chunk.storage.ChunkScanAccess;
#endif #endif
import net.minecraft.world.level.levelgen.WorldGenSettings; import net.minecraft.world.level.levelgen.WorldGenSettings;
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager; import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager;
#else #else
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager; import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
import net.minecraft.world.level.levelgen.RandomState; import net.minecraft.world.level.levelgen.RandomState;
#if POST_MC_1_19_4 #if MC_VER >= MC_1_19_4
import net.minecraft.world.level.levelgen.WorldOptions; import net.minecraft.world.level.levelgen.WorldOptions;
import net.minecraft.core.registries.Registries; import net.minecraft.core.registries.Registries;
#endif #endif
@@ -50,24 +50,27 @@ import net.minecraft.world.level.storage.WorldData;
public final class GlobalParameters public final class GlobalParameters
{ {
public final ChunkGenerator generator; public final ChunkGenerator generator;
#if PRE_MC_1_19_2
public final StructureManager structures;
#else
public final StructureTemplateManager structures;
public final RandomState randomState;
#endif
#if PRE_MC_1_19_4
public final WorldGenSettings worldGenSettings;
#else
public final WorldOptions worldOptions;
#endif
public final IDhServerLevel lodLevel; public final IDhServerLevel lodLevel;
public final ServerLevel level; public final ServerLevel level;
public final Registry<Biome> biomes; public final Registry<Biome> biomes;
public final RegistryAccess registry; public final RegistryAccess registry;
public final long worldSeed; public final long worldSeed;
public final DataFixer fixerUpper; public final DataFixer fixerUpper;
#if POST_MC_1_18_2
#if MC_VER < MC_1_19_2
public final StructureManager structures;
#else
public final StructureTemplateManager structures;
public final RandomState randomState;
#endif
#if MC_VER < MC_1_19_4
public final WorldGenSettings worldGenSettings;
#else
public final WorldOptions worldOptions;
#endif
#if MC_VER >= MC_1_18_2
public final BiomeManager biomeManager; public final BiomeManager biomeManager;
public final ChunkScanAccess chunkScanner; // FIXME: Figure out if this is actually needed public final ChunkScanAccess chunkScanner; // FIXME: Figure out if this is actually needed
#endif #endif
@@ -76,29 +79,34 @@ public final class GlobalParameters
{ {
this.lodLevel = lodLevel; this.lodLevel = lodLevel;
level = ((ServerLevelWrapper) lodLevel.getServerLevelWrapper()).getWrappedMcObject(); this.level = ((ServerLevelWrapper) lodLevel.getServerLevelWrapper()).getWrappedMcObject();
MinecraftServer server = level.getServer(); MinecraftServer server = this.level.getServer();
WorldData worldData = server.getWorldData(); WorldData worldData = server.getWorldData();
registry = server.registryAccess(); this.registry = server.registryAccess();
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
worldGenSettings = worldData.worldGenSettings(); this.worldGenSettings = worldData.worldGenSettings();
biomes = registry.registryOrThrow(Registry.BIOME_REGISTRY); this.biomes = registry.registryOrThrow(Registry.BIOME_REGISTRY);
worldSeed = worldGenSettings.seed(); this.worldSeed = worldGenSettings.seed();
#elif MC_VER < MC_1_21_3
this.worldOptions = worldData.worldGenOptions();
this.biomes = registry.registryOrThrow(Registries.BIOME);
this.worldSeed = worldOptions.seed();
#else #else
worldOptions = worldData.worldGenOptions(); this.worldOptions = worldData.worldGenOptions();
biomes = registry.registryOrThrow(Registries.BIOME); this.biomes = this.registry.lookupOrThrow(Registries.BIOME);
worldSeed = worldOptions.seed(); this.worldSeed = this.worldOptions.seed();
#endif #endif
#if POST_MC_1_18_2
biomeManager = new BiomeManager(level, BiomeManager.obfuscateSeed(worldSeed)); #if MC_VER >= MC_1_18_2
chunkScanner = level.getChunkSource().chunkScanner(); this.biomeManager = new BiomeManager(this.level, BiomeManager.obfuscateSeed(this.worldSeed));
this.chunkScanner = this.level.getChunkSource().chunkScanner();
#endif #endif
structures = server.getStructureManager(); this.structures = server.getStructureManager();
generator = level.getChunkSource().getGenerator(); this.generator = this.level.getChunkSource().getGenerator();
fixerUpper = server.getFixerUpper(); this.fixerUpper = server.getFixerUpper();
#if POST_MC_1_19_2 #if MC_VER >= MC_1_19_2
randomState = level.getChunkSource().randomState(); this.randomState = this.level.getChunkSource().randomState();
#endif #endif
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -25,7 +25,7 @@ import com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject.Wo
import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.WorldGenLevel; import net.minecraft.world.level.WorldGenLevel;
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
import net.minecraft.world.level.levelgen.structure.StructureCheck; import net.minecraft.world.level.levelgen.structure.StructureCheck;
#endif #endif
@@ -35,7 +35,7 @@ public final class ThreadedParameters
final ServerLevel level; final ServerLevel level;
public WorldGenStructFeatManager structFeat = null; public WorldGenStructFeatManager structFeat = null;
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
public StructureCheck structCheck; public StructureCheck structCheck;
#endif #endif
boolean isValid = true; boolean isValid = true;
@@ -63,9 +63,9 @@ public final class ThreadedParameters
previousGlobalParameters = param; previousGlobalParameters = param;
this.level = param.level; this.level = param.level;
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
this.structFeat = new WorldGenStructFeatManager(param.worldGenSettings, level); this.structFeat = new WorldGenStructFeatManager(param.worldGenSettings, level);
#elif PRE_MC_1_19_2 #elif MC_VER < MC_1_19_2
this.structCheck = this.createStructureCheck(param); this.structCheck = this.createStructureCheck(param);
#else #else
this.structCheck = new StructureCheck(param.chunkScanner, param.registry, param.structures, this.structCheck = new StructureCheck(param.chunkScanner, param.registry, param.structures,
@@ -80,15 +80,15 @@ public final class ThreadedParameters
public void makeStructFeat(WorldGenLevel genLevel, GlobalParameters param) public void makeStructFeat(WorldGenLevel genLevel, GlobalParameters param)
{ {
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
structFeat = new WorldGenStructFeatManager(param.worldGenSettings, genLevel #if POST_MC_1_18_2 , structCheck #endif ); structFeat = new WorldGenStructFeatManager(param.worldGenSettings, genLevel #if MC_VER >= MC_1_18_2 , structCheck #endif );
#else #else
structFeat = new WorldGenStructFeatManager(param.worldOptions, genLevel, structCheck); structFeat = new WorldGenStructFeatManager(param.worldOptions, genLevel, structCheck);
#endif #endif
} }
#if POST_MC_1_18_2 && PRE_MC_1_19_2 #if MC_VER >= MC_1_18_2 && MC_VER < MC_1_19_2
public void recreateStructureCheck() public void recreateStructureCheck()
{ {
if (previousGlobalParameters != null) if (previousGlobalParameters != null)
@@ -0,0 +1,28 @@
package com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject;
#if MC_VER >= MC_1_21_1
import net.minecraft.server.level.GenerationChunkHolder;
import net.minecraft.world.level.ChunkPos;
import java.util.concurrent.CompletableFuture;
public class DhGenerationChunkHolder extends GenerationChunkHolder
{
public DhGenerationChunkHolder(ChunkPos pos) { super(pos); }
@Override
public int getTicketLevel() { return 0; }
@Override
public int getQueueLevel() { return 0; }
#if MC_VER < MC_1_21_3
#else
@Override
protected void addSaveDependency(CompletableFuture<?> completableFuture) { }
#endif
}
#endif
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -22,12 +22,14 @@ package com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject;
import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles;
import java.util.List; import java.util.List;
import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantLock;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.util.LodUtil;
import net.minecraft.world.level.block.EntityBlock; import net.minecraft.world.level.block.EntityBlock;
import net.minecraft.world.level.block.SpawnerBlock; import net.minecraft.world.level.block.SpawnerBlock;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
@@ -41,7 +43,7 @@ import net.minecraft.util.Mth;
import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.Entity;
import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.ColorResolver; import net.minecraft.world.level.ColorResolver;
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
import net.minecraft.world.level.LevelHeightAccessor; import net.minecraft.world.level.LevelHeightAccessor;
#endif #endif
import net.minecraft.world.level.LightLayer; import net.minecraft.world.level.LightLayer;
@@ -50,34 +52,58 @@ import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.chunk.ImposterProtoChunk; import net.minecraft.world.level.chunk.ImposterProtoChunk;
import net.minecraft.world.level.chunk.LevelChunk; import net.minecraft.world.level.chunk.LevelChunk;
import net.minecraft.world.level.lighting.LevelLightEngine; import net.minecraft.world.level.lighting.LevelLightEngine;
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.*;
#endif
#if MC_VER >= MC_1_21_1
import net.minecraft.util.StaticCache2D;
import com.google.common.collect.ImmutableList;
import net.minecraft.server.level.GenerationChunkHolder;
#endif
#if MC_VER >= MC_1_18_2
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.material.Fluid;
import net.minecraft.world.ticks.BlackholeTickAccess;
import net.minecraft.world.ticks.LevelTickAccess;
#endif
public class DhLitWorldGenRegion extends WorldGenRegion public class DhLitWorldGenRegion extends WorldGenRegion
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName()); private static final Logger LOGGER = DhLoggerBuilder.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());
private static ChunkStatus debugTriggeredForStatus = null;
public final ServerLevel serverLevel;
public final DummyLightEngine lightEngine; public final DummyLightEngine lightEngine;
public final BatchGenerationEnvironment.EmptyChunkGenerator generator; public final BatchGenerationEnvironment.IEmptyChunkRetrievalFunc generator;
public final int writeRadius; public final int writeRadius;
public final int size; public final int size;
private final ChunkPos firstPos; private final ChunkPos firstPos;
private final List<ChunkAccess> cache; private final List<ChunkAccess> cache;
Long2ObjectOpenHashMap<ChunkAccess> chunkMap = new Long2ObjectOpenHashMap<ChunkAccess>(); private final Long2ObjectOpenHashMap<ChunkAccess> chunkMap = new Long2ObjectOpenHashMap<ChunkAccess>();
/** /**
* Present to reduce the chance that we accidentally break underlying MC code that isn't thread safe, * Present to reduce the chance that we accidentally break underlying MC code that isn't thread safe,
* specifically: "it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap.getAndMoveToFirst()" * specifically: "it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap.getAndMoveToFirst()"
*/ */
ReentrantLock getChunkLock = new ReentrantLock(); private final ReentrantLock getChunkLock = new ReentrantLock();
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
private ChunkPos overrideCenterPos = null; private ChunkPos overrideCenterPos = null;
public void setOverrideCenter(ChunkPos pos) { overrideCenterPos = pos; } public void setOverrideCenter(ChunkPos pos) { overrideCenterPos = pos; }
#if PRE_MC_1_17_1 #if MC_VER < MC_1_17_1
@Override @Override
public int getCenterX() public int getCenterX()
{ {
@@ -100,12 +126,31 @@ public class DhLitWorldGenRegion extends WorldGenRegion
public DhLitWorldGenRegion( public DhLitWorldGenRegion(
int centerChunkX, int centerChunkZ,
ChunkAccess centerChunk,
ServerLevel serverLevel, DummyLightEngine lightEngine, ServerLevel serverLevel, DummyLightEngine lightEngine,
List<ChunkAccess> chunkList, ChunkStatus chunkStatus, int writeRadius, List<ChunkAccess> chunkList, ChunkStatus chunkStatus, int writeRadius,
BatchGenerationEnvironment.EmptyChunkGenerator generator) BatchGenerationEnvironment.IEmptyChunkRetrievalFunc generator)
{ {
super(serverLevel, chunkList #if POST_MC_1_17_1 , chunkStatus, writeRadius #endif ); #if MC_VER == MC_1_16_5
super(serverLevel, chunkList);
#elif MC_VER < MC_1_21_1
super(serverLevel, chunkList, chunkStatus, writeRadius);
#else
super(serverLevel,
StaticCache2D.create(
centerChunkX, centerChunkZ,
writeRadius * 2, (x,z) -> new DhGenerationChunkHolder(new ChunkPos(x, z))),
new ChunkStep(chunkStatus,
// reverse is needed because MC uses the index of the chunkStatus to determine how many items are in the list instead of the actual list count
new ChunkDependencies(ImmutableList.copyOf(ChunkStatus.getStatusList()).reverse()),
new ChunkDependencies(ImmutableList.copyOf(ChunkStatus.getStatusList()).reverse()),
writeRadius, (WorldGenContext var1, ChunkStep var2, StaticCache2D<GenerationChunkHolder> var3, ChunkAccess var4) -> null),
centerChunk);
#endif
this.firstPos = chunkList.get(0).getPos(); this.firstPos = chunkList.get(0).getPos();
this.serverLevel = serverLevel;
this.generator = generator; this.generator = generator;
this.lightEngine = lightEngine; this.lightEngine = lightEngine;
this.writeRadius = writeRadius; this.writeRadius = writeRadius;
@@ -115,7 +160,7 @@ public class DhLitWorldGenRegion extends WorldGenRegion
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
// Bypass BCLib mixin overrides. // Bypass BCLib mixin overrides.
@Override @Override
public boolean ensureCanWrite(BlockPos blockPos) public boolean ensureCanWrite(BlockPos blockPos)
@@ -130,11 +175,22 @@ public class DhLitWorldGenRegion extends WorldGenRegion
{ {
return false; return false;
} }
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
if (center.isUpgrading()) if (center.isUpgrading())
{ {
LevelHeightAccessor levelHeightAccessor = center.getHeightAccessorForGeneration(); LevelHeightAccessor levelHeightAccessor = center.getHeightAccessorForGeneration();
if (blockPos.getY() < levelHeightAccessor.getMinBuildHeight() || blockPos.getY() >= levelHeightAccessor.getMaxBuildHeight())
int minY;
int maxY;
#if MC_VER < MC_1_21_3
minY = levelHeightAccessor.getMinBuildHeight();
maxY = levelHeightAccessor.getMaxBuildHeight();
#else
minY = levelHeightAccessor.getMinY();
maxY = levelHeightAccessor.getMaxY();
#endif
if (blockPos.getY() < minY || blockPos.getY() >= maxY)
{ {
return false; return false;
} }
@@ -144,6 +200,22 @@ public class DhLitWorldGenRegion extends WorldGenRegion
} }
#endif #endif
#if MC_VER >= MC_1_18_2
@Override
@NotNull
public LevelTickAccess<Block> getBlockTicks()
{
// DH world gen doesn't need ticking, so return the BlackholeTickAccess list (which causes all ticks to be ignored).
// If this isn't done the server may attempt to tick chunks outside the vanilla render distance,
// which can throw warnings or cause other issues
return BlackholeTickAccess.emptyLevelList();
}
@Override
@NotNull
public LevelTickAccess<Fluid> getFluidTicks() { return BlackholeTickAccess.emptyLevelList(); }
#endif
// TODO Check this // TODO Check this
// @Override // @Override
// public List<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos, // public List<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos,
@@ -157,8 +229,16 @@ public class DhLitWorldGenRegion extends WorldGenRegion
{ {
ChunkAccess chunkAccess = this.getChunk(blockPos); ChunkAccess chunkAccess = this.getChunk(blockPos);
if (chunkAccess instanceof LevelChunk) if (chunkAccess instanceof LevelChunk)
{
return true; return true;
chunkAccess.setBlockState(blockPos, blockState, false); }
#if MC_VER < MC_1_21_5
chunkAccess.setBlockState(blockPos, blockState, /*isBlockMoving*/false);
#else
chunkAccess.setBlockState(blockPos, blockState, /*flags*/0);
#endif
// This is for post ticking for water on gen and stuff like that. Not enabled // This is for post ticking for water on gen and stuff like that. Not enabled
// for now. // for now.
// if (blockState.hasPostProcess(this, blockPos)) // if (blockState.hasPostProcess(this, blockPos))
@@ -185,7 +265,7 @@ public class DhLitWorldGenRegion extends WorldGenRegion
BlockState blockState = this.getBlockState(blockPos); BlockState blockState = this.getBlockState(blockPos);
// This is a bypass for the spawner block since MC complains about not having it // This is a bypass for the spawner block since MC complains about not having it
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
if (blockState.getBlock() instanceof SpawnerBlock) if (blockState.getBlock() instanceof SpawnerBlock)
{ {
return ((EntityBlock) blockState.getBlock()).newBlockEntity(blockPos, blockState); return ((EntityBlock) blockState.getBlock()).newBlockEntity(blockPos, blockState);
@@ -198,13 +278,26 @@ public class DhLitWorldGenRegion extends WorldGenRegion
#endif #endif
} }
// Skip BlockEntity stuff. It aren't really needed /**
* This needs to be manually overridden to make sure Lithium 0.11.2 and lower
* don't try to get null chunks. <br><br>
*
* Problematic Lithium code was removed in 0.13.0 (MC 1.21.1) and higher: <br>
* https://github.com/CaffeineMC/lithium-fabric/commit/b7cfd53a1ed0197e1d13dea2799b898eb52ecab3
*/
@NotNull
@Override @Override
public boolean addFreshEntity(Entity entity) public BlockState getBlockState(BlockPos blockPos)
{ {
return true; int chunkX = SectionPos.blockToSectionCoord(blockPos.getX());
int chunkZ = SectionPos.blockToSectionCoord(blockPos.getZ());
return this.getChunk(chunkX, chunkZ).getBlockState(blockPos);
} }
/** Skip BlockEntity stuff. They aren't needed for our use case. */
@Override
public boolean addFreshEntity(@NotNull Entity entity) { return true; }
// Allays have empty chunks even if it's outside the worldGenRegion // Allays have empty chunks even if it's outside the worldGenRegion
// @Override // @Override
// public boolean hasChunk(int i, int j) { // public boolean hasChunk(int i, int j) {
@@ -214,13 +307,13 @@ public class DhLitWorldGenRegion extends WorldGenRegion
// Override to ensure no other mod mixins cause skipping the overrided // Override to ensure no other mod mixins cause skipping the overrided
// getChunk(...) // getChunk(...)
@Override @Override
public ChunkAccess getChunk(int i, int j) public @NotNull ChunkAccess getChunk(int chunkX, int chunkZ)
{ {
try try
{ {
// lock is to prevent issues with underlying MC code that doesn't support multithreading // lock is to prevent issues with underlying MC code that doesn't support multithreading
this.getChunkLock.lock(); this.getChunkLock.lock();
return this.getChunk(i, j, ChunkStatus.EMPTY); return this.getChunk(chunkX, chunkZ, ChunkStatus.EMPTY);
} }
finally finally
{ {
@@ -231,13 +324,19 @@ public class DhLitWorldGenRegion extends WorldGenRegion
// Override to ensure no other mod mixins cause skipping the overrided // Override to ensure no other mod mixins cause skipping the overrided
// getChunk(...) // getChunk(...)
@Override @Override
public ChunkAccess getChunk(int i, int j, ChunkStatus chunkStatus) public @NotNull ChunkAccess getChunk(int chunkX, int chunkZ, @NotNull ChunkStatus chunkStatus)
{ {
try try
{ {
// lock is to prevent issues with underlying MC code that doesn't support multithreading // lock is to prevent issues with underlying MC code that doesn't support multithreading
this.getChunkLock.lock(); this.getChunkLock.lock();
return this.getChunk(i, j, chunkStatus, true);
ChunkAccess chunk = this.getChunk(chunkX, chunkZ, chunkStatus, true);
if (chunk == null)
{
LodUtil.assertNotReach("getChunk shouldn't return null values");
}
return chunk;
} }
finally finally
{ {
@@ -245,102 +344,113 @@ public class DhLitWorldGenRegion extends WorldGenRegion
} }
} }
// Use this instead of super.getChunk() to bypass C2ME concurrency checks /** Allows creating empty chunks even if they're outside the worldGenRegion */
private ChunkAccess superGetChunk(int x, int z, ChunkStatus cs)
{
int k = x - firstPos.x;
int l = z - firstPos.z;
return cache.get(k + l * size);
}
// Use this instead of super.hasChunk() to bypass C2ME concurrency checks
public boolean superHasChunk(int x, int z)
{
int k = x - firstPos.x;
int l = z - firstPos.z;
return l >= 0 && l < size && k >= 0 && k < size;
}
// Allow creating empty chunks even if it's outside the worldGenRegion
@Override @Override
@Nullable @Nullable
public ChunkAccess getChunk(int i, int j, ChunkStatus chunkStatus, boolean bl) public ChunkAccess getChunk(int chunkX, int chunkZ, @NotNull ChunkStatus chunkStatus, boolean returnNonNull)
{ {
ChunkAccess chunk = getChunkAccess(i, j, chunkStatus, bl); ChunkAccess chunk = this.getChunkAccess(chunkX, chunkZ, chunkStatus, returnNonNull);
if (chunk instanceof LevelChunk) if (chunk instanceof LevelChunk)
{ {
chunk = new ImposterProtoChunk((LevelChunk) chunk #if POST_MC_1_18_2 , true #endif ); chunk = new ImposterProtoChunk((LevelChunk) chunk #if MC_VER >= MC_1_18_2 , true #endif );
} }
return chunk; return chunk;
} }
private static ChunkStatus debugTriggeredForStatus = null; /**
* @param returnNonNull if true this method will always return a non-null chunk,
private ChunkAccess getChunkAccess(int i, int j, ChunkStatus chunkStatus, boolean bl) * if false it will return null if no chunk exists at the given position with the given status
*/
private ChunkAccess getChunkAccess(int chunkX, int chunkZ, ChunkStatus chunkStatus, boolean returnNonNull)
{ {
ChunkAccess chunk = superHasChunk(i, j) ? superGetChunk(i, j, ChunkStatus.EMPTY) : null; ChunkAccess chunk = this.superHasChunk(chunkX, chunkZ) ? this.superGetChunk(chunkX, chunkZ) : null;
if (chunk != null && chunk.getStatus().isOrAfter(chunkStatus)) if (chunk != null && ChunkWrapper.getStatus(chunk).isOrAfter(chunkStatus))
{ {
return chunk; return chunk;
} }
if (!bl) else if (!returnNonNull)
{
// no chunk found with the necessary status and null return values are allowed
return null; return null;
}
// we need a non-null chunk
if (chunk == null) if (chunk == null)
{ {
chunk = chunkMap.get(ChunkPos.asLong(i, j)); // check memory
chunk = this.chunkMap.get(ChunkPos.asLong(chunkX, chunkZ));
if (chunk == null) if (chunk == null)
{ {
chunk = generator.generate(i, j); // chunk isn't in memory, generate a new one
chunk = this.generator.getChunk(chunkX, chunkZ);
if (chunk == null) if (chunk == null)
{
throw new NullPointerException("The provided generator should not return null!"); throw new NullPointerException("The provided generator should not return null!");
chunkMap.put(ChunkPos.asLong(i, j), chunk); }
this.chunkMap.put(ChunkPos.asLong(chunkX, chunkZ), chunk);
} }
} }
if (chunkStatus != ChunkStatus.EMPTY && chunkStatus != debugTriggeredForStatus) if (chunkStatus != ChunkStatus.EMPTY && chunkStatus != debugTriggeredForStatus)
{ {
LOGGER.info("WorldGen requiring " + chunkStatus LOGGER.info("WorldGen requiring " + chunkStatus
+ " outside expected range detected. Force passing EMPTY chunk and seeing if it works."); + " outside expected range detected. Force passing EMPTY chunk and seeing if it works.");
debugTriggeredForStatus = chunkStatus; debugTriggeredForStatus = chunkStatus;
} }
return chunk; return chunk;
} }
/** Overriding allows us to use our own lighting engine */ /** Use this instead of super.hasChunk() to bypass C2ME concurrency checks */
@Override public boolean superHasChunk(int x, int z)
public LevelLightEngine getLightEngine() { return this.lightEngine; }
/** Overriding allows us to use our own lighting engine */
@Override
public int getBrightness(LightLayer lightLayer, BlockPos blockPos) { return 0; }
/** Overriding allows us to use our own lighting engine */
@Override
public int getRawBrightness(BlockPos blockPos, int i) { return 0; }
/** Overriding allows us to use our own lighting engine */
@Override
public boolean canSeeSky(BlockPos blockPos)
{ {
return (getBrightness(LightLayer.SKY, blockPos) >= getMaxLightLevel()); int k = x - this.firstPos.x;
int l = z - this.firstPos.z;
return l >= 0 && l < this.size && k >= 0 && k < this.size;
} }
public int getBlockTint(BlockPos blockPos, ColorResolver colorResolver) /** Use this instead of super.getChunk() to bypass C2ME concurrency checks */
private ChunkAccess superGetChunk(int x, int z)
{ {
return calculateBlockTint(blockPos, colorResolver); int k = x - this.firstPos.x;
int l = z - this.firstPos.z;
return this.cache.get(k + l * this.size);
} }
/** Overriding allows us to use our own lighting engine */
@Override
public @NotNull LevelLightEngine getLightEngine() { return this.lightEngine; }
/** Overriding allows us to use our own lighting engine */
@Override
public int getBrightness(@NotNull LightLayer lightLayer, @NotNull BlockPos blockPos) { return 0; }
/** Overriding allows us to use our own lighting engine */
@Override
public int getRawBrightness(@NotNull BlockPos blockPos, int i) { return 0; }
/** Overriding allows us to use our own lighting engine */
@Override
public boolean canSeeSky(@NotNull BlockPos blockPos)
{ return (this.getBrightness(LightLayer.SKY, blockPos) >= LodUtil.MAX_MC_LIGHT); }
public int getBlockTint(@NotNull BlockPos blockPos, @NotNull ColorResolver colorResolver)
{ return this.calculateBlockTint(blockPos, colorResolver); }
private Biome _getBiome(BlockPos pos) private Biome _getBiome(BlockPos pos)
{ {
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
return getBiome(pos).value(); return this.getBiome(pos).value();
#else #else
return getBiome(pos); return this.getBiome(pos);
#endif #endif
} }
public int calculateBlockTint(BlockPos blockPos, ColorResolver colorResolver) public int calculateBlockTint(BlockPos blockPos, ColorResolver colorResolver)
{ {
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
int i = (Minecraft.getInstance()).options.biomeBlendRadius; int i = (Minecraft.getInstance()).options.biomeBlendRadius;
#else #else
int i = (Minecraft.getInstance()).options.biomeBlendRadius().get(); int i = (Minecraft.getInstance()).options.biomeBlendRadius().get();
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -39,7 +39,7 @@ public class DummyLightEngine extends LevelLightEngine
} }
#if PRE_MC_1_20_1 #if MC_VER < MC_1_20_1
@Override @Override
public void onBlockEmissionIncrease(BlockPos blockPos, int i) { } public void onBlockEmissionIncrease(BlockPos blockPos, int i) { }
@@ -63,7 +63,7 @@ public class DummyLightEngine extends LevelLightEngine
#endif #endif
@Override @Override
public void queueSectionData(LightLayer lightLayer, SectionPos sectionPos, @Nullable DataLayer dataLayer #if PRE_MC_1_20_1 , boolean bl #endif ) { } public void queueSectionData(LightLayer lightLayer, SectionPos sectionPos, @Nullable DataLayer dataLayer #if MC_VER < MC_1_20_1 , boolean bl #endif ) { }
@Override @Override
public void checkBlock(BlockPos blockPos) { } public void checkBlock(BlockPos blockPos) { }
@@ -87,7 +87,7 @@ public class DummyLightEngine extends LevelLightEngine
@Override @Override
public void retainData(ChunkPos chunkPos, boolean bl) { } public void retainData(ChunkPos chunkPos, boolean bl) { }
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
@Override @Override
public int getLightSectionCount() { throw new UnsupportedOperationException("This should never be used!"); } public int getLightSectionCount() { throw new UnsupportedOperationException("This should never be used!"); }
@Override @Override
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -23,15 +23,24 @@ import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector;
import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IStarlightAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IStarlightAccessor;
import net.minecraft.world.level.BlockGetter; import net.minecraft.world.level.BlockGetter;
#if POST_MC_1_17_1 import net.minecraft.world.level.chunk.LightChunkGetter;
#if MC_VER >= MC_1_17_1
import net.minecraft.world.level.LevelHeightAccessor; import net.minecraft.world.level.LevelHeightAccessor;
#endif #endif
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.chunk.LightChunkGetter; #if MC_VER >= MC_1_20_1
#if POST_MC_1_20_1
import net.minecraft.world.level.chunk.LightChunk; import net.minecraft.world.level.chunk.LightChunk;
#endif #endif
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
public class LightGetterAdaptor implements LightChunkGetter public class LightGetterAdaptor implements LightChunkGetter
{ {
private final BlockGetter heightGetter; private final BlockGetter heightGetter;
@@ -50,7 +59,7 @@ public class LightGetterAdaptor implements LightChunkGetter
} }
@Override @Override
public #if PRE_MC_1_20_1 BlockGetter #else LightChunk #endif getChunkForLighting(int chunkX, int chunkZ) public #if MC_VER < MC_1_20_1 BlockGetter #else LightChunk #endif getChunkForLighting(int chunkX, int chunkZ)
{ {
if (genRegion == null) if (genRegion == null)
throw new IllegalStateException("World Gen region has not been set!"); throw new IllegalStateException("World Gen region has not been set!");
@@ -64,7 +73,7 @@ public class LightGetterAdaptor implements LightChunkGetter
return shouldReturnNull ? null : (genRegion != null ? genRegion : heightGetter); return shouldReturnNull ? null : (genRegion != null ? genRegion : heightGetter);
} }
#if POST_MC_1_17_1 #if MC_VER >= MC_1_17_1
public LevelHeightAccessor getLevelHeightAccessor() public LevelHeightAccessor getLevelHeightAccessor()
{ {
return heightGetter; return heightGetter;
@@ -1,13 +1,15 @@
package com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject; package com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import net.minecraft.nbt.CompoundTag; import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.NbtIo; import net.minecraft.nbt.NbtIo;
import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.chunk.storage.RegionFile; import net.minecraft.world.level.chunk.storage.RegionFile;
import net.minecraft.world.level.chunk.storage.RegionFileStorage; import net.minecraft.world.level.chunk.storage.RegionFileStorage;
import org.apache.logging.log4j.Logger;
import javax.annotation.Nullable; import org.jetbrains.annotations.Nullable;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Files; import java.nio.file.Files;
@@ -15,11 +17,27 @@ import java.nio.file.Path;
import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantLock;
#if MC_VER >= MC_1_20_6
import net.minecraft.world.level.chunk.storage.RegionStorageInfo;
#endif
/**
* Shouldn't be used when the C2ME mod is present,
* otherwise there may be potential file corruption.
* When C2ME is present use (via MC ServerLevel) level.getChunkSource().chunkMap.worker#loadAsync()
* instead.
*/
public class RegionFileStorageExternalCache implements AutoCloseable public class RegionFileStorageExternalCache implements AutoCloseable
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
/** Can be null due to the C2ME mod */
@Nullable
public final RegionFileStorage storage; public final RegionFileStorage storage;
public static final int MAX_CACHE_SIZE = 16; public static final int MAX_CACHE_SIZE = 16;
public static boolean regionCacheNullPointerWarningSent = false;
/** /**
* Present to reduce the chance that we accidentally break underlying MC code that isn't thread safe, * Present to reduce the chance that we accidentally break underlying MC code that isn't thread safe,
* specifically: "it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap.getAndMoveToFirst()" * specifically: "it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap.getAndMoveToFirst()"
@@ -28,28 +46,30 @@ public class RegionFileStorageExternalCache implements AutoCloseable
static class RegionFileCache
{
public final long pos;
public final RegionFile file;
public RegionFileCache(long pos, RegionFile file)
{
this.pos = pos;
this.file = file;
}
}
private final ConcurrentLinkedQueue<RegionFileCache> regionFileCache = new ConcurrentLinkedQueue<>();
public ConcurrentLinkedQueue<RegionFileCache> regionFileCache = new ConcurrentLinkedQueue<>();
public RegionFileStorageExternalCache(RegionFileStorage storage) { this.storage = storage; } public RegionFileStorageExternalCache(RegionFileStorage storage) { this.storage = storage; }
@Nullable @Nullable
public RegionFile getRegionFile(ChunkPos pos) throws IOException public RegionFile getRegionFile(ChunkPos pos) throws IOException
{ {
if (this.storage == null)
{
if (!regionCacheNullPointerWarningSent)
{
regionCacheNullPointerWarningSent = true;
LOGGER.warn("Unable to access Minecraft's chunk cache. This may be due to another mod changing said cache. DH will be unable to access any Minecraft chunk data until said mod is removed.");
}
return null;
}
long posLong = ChunkPos.asLong(pos.getRegionX(), pos.getRegionZ()); long posLong = ChunkPos.asLong(pos.getRegionX(), pos.getRegionZ());
RegionFile rFile = null; RegionFile rFile = null;
@@ -64,7 +84,7 @@ public class RegionFileStorageExternalCache implements AutoCloseable
{ {
this.getRegionFileLock.lock(); this.getRegionFileLock.lock();
#if MC_1_16_5 || MC_1_17_1 #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
rFile = this.storage.getRegionFile(pos); rFile = this.storage.getRegionFile(pos);
// keeping the region cache size low helps prevent concurrency issues // keeping the region cache size low helps prevent concurrency issues
@@ -84,7 +104,7 @@ public class RegionFileStorageExternalCache implements AutoCloseable
} }
catch (ArrayIndexOutOfBoundsException e) catch (ArrayIndexOutOfBoundsException e)
{ {
#if MC_1_16_5 || MC_1_17_1 #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
// the file just wasn't cached // the file just wasn't cached
break; break;
#else #else
@@ -98,6 +118,19 @@ public class RegionFileStorageExternalCache implements AutoCloseable
} }
#endif #endif
} }
catch (NullPointerException e)
{
// Can sometimes happen when other mods modify the region cache system (IE C2ME)
// instead of blowing up, just use DH's cache instead
if (!regionCacheNullPointerWarningSent)
{
regionCacheNullPointerWarningSent = true;
LOGGER.warn("Unable to access Minecraft's chunk cache. This may be due to another mod changing said cache. Falling back to DH's internal cache.");
}
break;
}
finally finally
{ {
this.getRegionFileLock.unlock(); this.getRegionFileLock.unlock();
@@ -106,7 +139,7 @@ public class RegionFileStorageExternalCache implements AutoCloseable
if (retryCount >= maxRetryCount) if (retryCount >= maxRetryCount)
{ {
BatchGenerationEnvironment.LOAD_LOGGER.warn("Concurrency issue detected when getting region file for chunk at " + pos + "."); BatchGenerationEnvironment.LOAD_LOGGER.warn("Concurrency issue detected when getting region file for chunk at [" + pos + "].");
} }
@@ -126,7 +159,7 @@ public class RegionFileStorageExternalCache implements AutoCloseable
// Otherwise, check if file exist, and if so, add it to the cache // Otherwise, check if file exist, and if so, add it to the cache
Path storageFolderPath; Path storageFolderPath;
#if MC_1_16_5 || MC_1_17_1 #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
storageFolderPath = this.storage.folder.toPath(); storageFolderPath = this.storage.folder.toPath();
#else #else
storageFolderPath = this.storage.folder; storageFolderPath = this.storage.folder;
@@ -138,10 +171,12 @@ public class RegionFileStorageExternalCache implements AutoCloseable
} }
Path regionFilePath = storageFolderPath.resolve("r." + pos.getRegionX() + "." + pos.getRegionZ() + ".mca"); Path regionFilePath = storageFolderPath.resolve("r." + pos.getRegionX() + "." + pos.getRegionZ() + ".mca");
#if MC_1_16_5 || MC_1_17_1 #if MC_VER == MC_1_16_5 || MC_VER == MC_1_17_1
rFile = new RegionFile(regionFilePath.toFile(), storageFolderPath.toFile(), false); rFile = new RegionFile(regionFilePath.toFile(), storageFolderPath.toFile(), false);
#else #elif MC_VER <= MC_1_20_4
rFile = new RegionFile(regionFilePath, storageFolderPath, false); rFile = new RegionFile(regionFilePath, storageFolderPath, false);
#else
rFile = new RegionFile(new RegionStorageInfo("level", null, "level type"), regionFilePath, storageFolderPath, false);
#endif #endif
this.regionFileCache.add(new RegionFileCache(ChunkPos.asLong(pos.getRegionX(), pos.getRegionZ()), rFile)); this.regionFileCache.add(new RegionFileCache(ChunkPos.asLong(pos.getRegionX(), pos.getRegionZ()), rFile));
@@ -191,4 +226,22 @@ public class RegionFileStorageExternalCache implements AutoCloseable
} }
//================//
// helper classes //
//================//
private static class RegionFileCache
{
public final long pos;
public final RegionFile file;
public RegionFileCache(long pos, RegionFile file)
{
this.pos = pos;
this.file = file;
}
}
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -35,51 +35,56 @@ import net.minecraft.server.level.WorldGenRegion;
import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.WorldGenLevel; import net.minecraft.world.level.WorldGenLevel;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.levelgen.WorldGenSettings; import net.minecraft.world.level.levelgen.WorldGenSettings;
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
import net.minecraft.world.level.levelgen.feature.ConfiguredStructureFeature; import net.minecraft.world.level.levelgen.feature.ConfiguredStructureFeature;
import net.minecraft.world.level.StructureFeatureManager; import net.minecraft.world.level.StructureFeatureManager;
#else #else
#if POST_MC_1_19_4 #if MC_VER >= MC_1_19_4
import net.minecraft.world.level.levelgen.WorldOptions; import net.minecraft.world.level.levelgen.WorldOptions;
#endif #endif
import net.minecraft.world.level.levelgen.structure.Structure; import net.minecraft.world.level.levelgen.structure.Structure;
import net.minecraft.world.level.StructureManager; import net.minecraft.world.level.StructureManager;
#endif #endif
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
import net.minecraft.world.level.levelgen.structure.StructureCheck; import net.minecraft.world.level.levelgen.structure.StructureCheck;
#endif #endif
import net.minecraft.world.level.levelgen.structure.StructureStart; import net.minecraft.world.level.levelgen.structure.StructureStart;
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
import net.minecraft.world.level.levelgen.feature.StructureFeature; import net.minecraft.world.level.levelgen.feature.StructureFeature;
#endif #endif
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
public class WorldGenStructFeatManager extends #if PRE_MC_1_19_2 StructureFeatureManager #else StructureManager #endif public class WorldGenStructFeatManager extends #if MC_VER < MC_1_19_2 StructureFeatureManager #else StructureManager #endif
{ {
final WorldGenLevel genLevel; final WorldGenLevel genLevel;
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
WorldGenSettings worldGenSettings; WorldGenSettings worldGenSettings;
#else #else
WorldOptions worldOptions; WorldOptions worldOptions;
#endif #endif
#if POST_MC_1_18_2 #if MC_VER >= MC_1_18_2
StructureCheck structureCheck; StructureCheck structureCheck;
#endif #endif
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
public WorldGenStructFeatManager( public WorldGenStructFeatManager(
WorldGenSettings worldGenSettings, WorldGenSettings worldGenSettings,
WorldGenLevel genLevel #if POST_MC_1_18_2 , StructureCheck structureCheck #endif ) WorldGenLevel genLevel #if MC_VER >= MC_1_18_2 , StructureCheck structureCheck #endif )
{ {
super(genLevel, worldGenSettings #if POST_MC_1_18_2 , structureCheck #endif ); super(genLevel, worldGenSettings #if MC_VER >= MC_1_18_2 , structureCheck #endif );
this.genLevel = genLevel; this.genLevel = genLevel;
this.worldGenSettings = worldGenSettings; this.worldGenSettings = worldGenSettings;
} }
@@ -100,8 +105,8 @@ public class WorldGenStructFeatManager extends #if PRE_MC_1_19_2 StructureFeatur
{ {
if (worldGenRegion == genLevel) if (worldGenRegion == genLevel)
return this; return this;
#if PRE_MC_1_19_4 #if MC_VER < MC_1_19_4
return new WorldGenStructFeatManager(worldGenSettings, worldGenRegion #if POST_MC_1_18_2 , structureCheck #endif ); return new WorldGenStructFeatManager(worldGenSettings, worldGenRegion #if MC_VER >= MC_1_18_2 , structureCheck #endif );
#else #else
return new WorldGenStructFeatManager(worldOptions, worldGenRegion, structureCheck); return new WorldGenStructFeatManager(worldOptions, worldGenRegion, structureCheck);
#endif #endif
@@ -113,7 +118,7 @@ public class WorldGenStructFeatManager extends #if PRE_MC_1_19_2 StructureFeatur
return genLevel.getChunk(x, z, status, false); return genLevel.getChunk(x, z, status, false);
} }
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
@Override @Override
public Stream<? extends StructureStart<?>> startsForFeature( public Stream<? extends StructureStart<?>> startsForFeature(
SectionPos sectionPos2, SectionPos sectionPos2,
@@ -140,7 +145,7 @@ public class WorldGenStructFeatManager extends #if PRE_MC_1_19_2 StructureFeatur
return chunk.hasAnyStructureReferences(); return chunk.hasAnyStructureReferences();
} }
#if MC_1_18_1 #if MC_VER == MC_1_18_1
@Override @Override
@SuppressWarnings({ "rawtypes", "unchecked" }) @SuppressWarnings({ "rawtypes", "unchecked" })
public List<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos, public List<? extends StructureStart<?>> startsForFeature(SectionPos sectionPos,
@@ -165,7 +170,7 @@ public class WorldGenStructFeatManager extends #if PRE_MC_1_19_2 StructureFeatur
return builder.build(); return builder.build();
} }
#else #else
#if PRE_MC_1_19_2 #if MC_VER < MC_1_19_2
@Override @Override
public List<StructureStart> startsForFeature(SectionPos sectionPos, Predicate<ConfiguredStructureFeature<?, ?>> predicate) public List<StructureStart> startsForFeature(SectionPos sectionPos, Predicate<ConfiguredStructureFeature<?, ?>> predicate)
{ {
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -27,15 +27,19 @@ import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGeneratio
import com.seibel.distanthorizons.common.wrappers.worldGeneration.ThreadedParameters; import com.seibel.distanthorizons.common.wrappers.worldGeneration.ThreadedParameters;
import net.minecraft.server.level.WorldGenRegion; import net.minecraft.server.level.WorldGenRegion;
#if PRE_MC_1_19_2
#endif
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.chunk.ProtoChunk; import net.minecraft.world.level.chunk.ProtoChunk;
#if POST_MC_1_18_2
#if MC_VER >= MC_1_18_2
import net.minecraft.world.level.levelgen.blending.Blender; import net.minecraft.world.level.levelgen.blending.Blender;
#endif #endif
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif
public final class StepBiomes public final class StepBiomes
{ {
public static final ChunkStatus STATUS = ChunkStatus.BIOMES; public static final ChunkStatus STATUS = ChunkStatus.BIOMES;
@@ -52,30 +56,62 @@ public final class StepBiomes
List<ChunkWrapper> chunkWrappers) List<ChunkWrapper> chunkWrappers)
{ {
ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>(); ArrayList<ChunkAccess> chunksToDo = new ArrayList<>();
for (ChunkWrapper chunkWrapper : chunkWrappers) for (ChunkWrapper chunkWrapper : chunkWrappers)
{ {
ChunkAccess chunk = chunkWrapper.getChunk(); ChunkAccess chunk = chunkWrapper.getChunk();
if (chunk.getStatus().isOrAfter(STATUS)) continue; if (chunkWrapper.getStatus().isOrAfter(STATUS))
((ProtoChunk) chunk).setStatus(STATUS); {
chunksToDo.add(chunk); // this chunk has already generated this step
continue;
}
else if (chunk instanceof ProtoChunk)
{
chunkWrapper.trySetStatus(STATUS);
chunksToDo.add(chunk);
}
} }
for (ChunkAccess chunk : chunksToDo) for (ChunkAccess chunk : chunksToDo)
{ {
// System.out.println("StepBiomes: "+chunk.getPos()); #if MC_VER < MC_1_18_2
#if PRE_MC_1_18_2 this.environment.params.generator.createBiomes(this.environment.params.biomes, chunk);
environment.params.generator.createBiomes(environment.params.biomes, chunk); #elif MC_VER < MC_1_19_2
#elif PRE_MC_1_19_2 chunk = this.environment.confirmFutureWasRunSynchronously(
chunk = environment.joinSync(environment.params.generator.createBiomes(environment.params.biomes, Runnable::run, Blender.of(worldGenRegion), this.environment.params.generator.createBiomes(
tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk)); this.environment.params.biomes,
#elif PRE_MC_1_19_4 Runnable::run,
chunk = environment.joinSync(environment.params.generator.createBiomes(environment.params.biomes, Runnable::run, environment.params.randomState, Blender.of(worldGenRegion), Blender.of(worldGenRegion),
tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk)); tParams.structFeat.forWorldGenRegion(worldGenRegion),
chunk)
);
#elif MC_VER < MC_1_19_4
chunk = this.environment.confirmFutureWasRunSynchronously(
this.environment.params.generator.createBiomes(
this.environment.params.biomes,
Runnable::run,
this.environment.params.randomState, Blender.of(worldGenRegion),
tParams.structFeat.forWorldGenRegion(worldGenRegion),
chunk)
);
#elif MC_VER < MC_1_21_1
chunk = this.environment.confirmFutureWasRunSynchronously(
this.environment.params.generator.createBiomes(
Runnable::run,
this.environment.params.randomState,
Blender.of(worldGenRegion),
tParams.structFeat.forWorldGenRegion(worldGenRegion),
chunk)
);
#else #else
chunk = environment.joinSync(environment.params.generator.createBiomes(Runnable::run, environment.params.randomState, Blender.of(worldGenRegion), chunk = this.environment.confirmFutureWasRunSynchronously(
tParams.structFeat.forWorldGenRegion(worldGenRegion), chunk)); this.environment.params.generator.createBiomes(
this.environment.params.randomState,
Blender.of(worldGenRegion),
tParams.structFeat.forWorldGenRegion(worldGenRegion),
chunk)
);
#endif #endif
} }
} }
@@ -2,7 +2,7 @@
* This file is part of the Distant Horizons mod * This file is part of the Distant Horizons mod
* licensed under the GNU LGPL v3 License. * licensed under the GNU LGPL v3 License.
* *
* Copyright (C) 2020-2023 James Seibel * Copyright (C) 2020 James Seibel
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
@@ -19,24 +19,29 @@
package com.seibel.distanthorizons.common.wrappers.worldGeneration.step; package com.seibel.distanthorizons.common.wrappers.worldGeneration.step;
import java.util.ArrayList;
import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.ThreadedParameters; import com.seibel.distanthorizons.common.wrappers.worldGeneration.ThreadedParameters;
import com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject.DhLitWorldGenRegion; import com.seibel.distanthorizons.common.wrappers.worldGeneration.mimicObject.DhLitWorldGenRegion;
import com.seibel.distanthorizons.core.logging.DhLoggerBuilder;
import com.seibel.distanthorizons.core.util.gridList.ArrayGridList; import com.seibel.distanthorizons.core.util.gridList.ArrayGridList;
import net.minecraft.ReportedException;
import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.chunk.ProtoChunk; import net.minecraft.world.level.chunk.ProtoChunk;
import net.minecraft.world.level.levelgen.Heightmap; import net.minecraft.world.level.levelgen.Heightmap;
#if POST_MC_1_18_2 import org.apache.logging.log4j.Logger;
#if MC_VER <= MC_1_20_4
import net.minecraft.world.level.chunk.ChunkStatus;
#else
import net.minecraft.world.level.chunk.status.ChunkStatus;
#endif #endif
public final class StepFeatures public final class StepFeatures
{ {
private static final Logger LOGGER = DhLoggerBuilder.getLogger();
public static final ChunkStatus STATUS = ChunkStatus.FEATURES; public static final ChunkStatus STATUS = ChunkStatus.FEATURES;
private final BatchGenerationEnvironment environment; private final BatchGenerationEnvironment environment;
@@ -51,36 +56,43 @@ public final class StepFeatures
ThreadedParameters tParams, DhLitWorldGenRegion worldGenRegion, ThreadedParameters tParams, DhLitWorldGenRegion worldGenRegion,
ArrayGridList<ChunkWrapper> chunkWrappers) ArrayGridList<ChunkWrapper> chunkWrappers)
{ {
ArrayList<ChunkAccess> chunksToDo = new ArrayList<ChunkAccess>();
for (ChunkWrapper chunkWrapper : chunkWrappers) for (ChunkWrapper chunkWrapper : chunkWrappers)
{ {
ChunkAccess chunk = chunkWrapper.getChunk(); ChunkAccess chunk = chunkWrapper.getChunk();
if (chunk.getStatus().isOrAfter(STATUS)) continue; if (chunkWrapper.getStatus().isOrAfter(STATUS))
((ProtoChunk) chunk).setStatus(STATUS); {
chunksToDo.add(chunk); // this chunk has already generated this step
} continue;
}
for (ChunkAccess chunk : chunksToDo) else if (chunk instanceof ProtoChunk)
{ {
chunkWrapper.trySetStatus(STATUS);
}
try try
{ {
#if PRE_MC_1_18_2 #if MC_VER < MC_1_18_2
worldGenRegion.setOverrideCenter(chunk.getPos()); worldGenRegion.setOverrideCenter(chunk.getPos());
environment.params.generator.applyBiomeDecoration(worldGenRegion, tParams.structFeat); environment.params.generator.applyBiomeDecoration(worldGenRegion, tParams.structFeat);
#else #else
environment.params.generator.applyBiomeDecoration(worldGenRegion, chunk, if (worldGenRegion.hasChunk(chunkWrapper.getChunkPos().getX(), chunkWrapper.getChunkPos().getZ()))
tParams.structFeat.forWorldGenRegion(worldGenRegion)); {
this.environment.params.generator.applyBiomeDecoration(worldGenRegion, chunk, tParams.structFeat.forWorldGenRegion(worldGenRegion));
}
else
{
LOGGER.warn("Unable to generate features for chunk at pos ["+chunkWrapper.getChunkPos()+"], world gen region doesn't contain the chunk.");
}
#endif #endif
Heightmap.primeHeightmaps(chunk, STATUS.heightmapsAfter()); Heightmap.primeHeightmaps(chunk, STATUS.heightmapsAfter());
BatchGenerationEnvironment.clearDistantGenerationMixinData();
} }
catch (ReportedException e) catch (Exception e)
{ {
e.printStackTrace(); LOGGER.warn("Unexpected issue when generating features for chunk at pos ["+chunkWrapper.getChunkPos()+"], error: ["+e.getMessage()+"].", e);
// FIXME: Features concurrent modification issue. Something about cocobeans might just // FIXME: Features concurrent modification issue. Something about cocobeans might just
// error out. For now just retry. // error out. For now just retry.
} }
} }
} }

Some files were not shown because too many files have changed in this diff Show More