Compare commits

...
Author SHA1 Message Date
Jason Mitchell 852bcbb38b Check before casting.
Fixes https://github.com/GTNewHorizons/Angelica/issues/388
2024-03-16 11:24:38 -07:00
ah-OOG-ah 464af945b2 Fix AIOBE in debug screen and NPE on world join (#385)
* Fix AIIOBE

* Fix NPE

* Actually fix
2024-03-15 21:42:38 -04:00
makamys 996b3df9cb Use vanilla field to count number of chunk updates
Fixes D-Tools compat
2024-03-15 15:23:48 -07:00
makamys 22d28abce6 Use ByteBuffer overload when indirect buffer is in client memory
Fixes #373
2024-03-15 15:23:37 -07:00
Jason Mitchell 636b616f64 Stop blacklisting bartworks. (#369)
Needs https://github.com/GTNewHorizons/bartworks/commit/50dfbb44acdd28bc183dc58b9cd40d5ba5121685
2024-03-09 09:27:22 -08:00
Caedis 14b7178419 Initialize toggle keybind when registering (#366)
* Initialize toggle keybind when registering

* Add comment
2024-03-08 15:26:36 -08:00
Caedis 22bf48c093 Potential fix for splash screen crashes (#363)
* Move framebuffer static initializor to getter

* missed one

* Revert "missed one"

This reverts commit 97027c1372.

* Revert "Move framebuffer static initializor to getter"

This reverts commit 6ef65735ff.

* Initialize HudCaching on world join

* run it on the client only

* remove unused imports
2024-03-08 12:40:51 -06:00
Caedis 4600bca2d0 Mixin to override FOV multiplier instead of using the forge event (#361)
* Mixin to speed check instead of using fov event

* scratch that, override return value entirely

* Revert "scratch that, override return value entirely"

This reverts commit 20a379d766.

* Revert "Mixin to speed check instead of using fov event"

This reverts commit 22db36d677.

* Change to lowest priority event so it is ran last (hopefully)
2024-03-08 10:26:34 -06:00
Jason Mitchell fcb9536d93 Don't blacklist gregtech from the render thread (#356) 2024-03-03 15:20:04 -08:00
embeddedt 51a6a72ae5 Only track rendered sprites on specific RenderBlocks instances (#355)
* Only track rendered sprites on specific RenderBlocks instances
2024-03-03 10:10:47 -08:00
Jason Mitchell f41f27e706 Some misbehaving mods *cough GT5u cough* enjoy reallocating textures all the time, so try a normal hash set instead of a reference one... 2024-03-03 09:26:33 -08:00
ah-OOG-ah 346a305f1d Refactor Quad, BlockPos, and QuadProvider API
Also optimize static models
2024-02-29 21:17:46 -05:00
ah-OOG-ah da8f700068 Update LICENSE 2024-02-29 21:17:46 -05:00
ah-OOG-ah f2445fabba Minor patches + license rewording 2024-02-29 21:17:46 -05:00
makamys bc3ca5209f Clean up tags
Also fixes names of enum compound tags missing
2024-02-29 21:17:46 -05:00
makamys 00517079d2 Fix broken links 2024-02-29 21:17:46 -05:00
makamys 7b8a64ec94 Move model-spec.md to docs dir 2024-02-29 21:17:46 -05:00
ah-OOG-ah 794e59b6de Readd CapturingTesselator workaround 2024-02-29 21:17:46 -05:00
ah-OOG-ah 9710801cb1 Fix underwater lighting on QuadProviders 2024-02-29 21:17:46 -05:00
ah-OOG-ah c5bda3b19c Update JsonModel.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah f9678a3793 Batch colorizing 2024-02-29 21:17:46 -05:00
ah-OOG-ah 091290b218 Clean all the things 2024-02-29 21:17:46 -05:00
ah-OOG-ah d991b55af7 Update ClientProxy.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 1530a8f6fe Clean up CubeModel 2024-02-29 21:17:46 -05:00
ah-OOG-ah 98156191fe Update Loader.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 956914efa3 Delete ModelHelper.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 51c3beea9e The purge continues 2024-02-29 21:17:46 -05:00
ah-OOG-ah 657ff921de Fix sided lighting on copied quads 2024-02-29 21:17:46 -05:00
ah-OOG-ah c9539faf44 Update JsonModel.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 2ca4d5338f Purge FRAPI code
Also use a baked stone model and fix a stupid in JSON
2024-02-29 21:17:46 -05:00
ah-OOG-ah 236a513705 FRAPI materials + NdQuadBuilder performance
Also speed up the offThreadSafety map
2024-02-29 21:17:46 -05:00
ah-OOG-ah 6d49e82a0c Revert "Set aside JSON model code for now"
This reverts commit 31fdf3383195b65a00e999a5634ed3ead8f060b2.
2024-02-29 21:17:46 -05:00
ah-OOG-ah 2fea614a45 Revert "Remove unready code, for now"
This reverts commit b626e3fa8f83013e5b4a68e787ffed9b75d8a679.
2024-02-29 21:17:46 -05:00
ah-OOG-ah 85ed121158 Remove unready code, for now 2024-02-29 21:17:46 -05:00
ah-OOG-ah 9316f42808 Set aside JSON model code for now
Item models my behated
2024-02-29 21:17:46 -05:00
ah-OOG-ah 74b66746eb Dual-license the model package for Fabric 2024-02-29 21:17:46 -05:00
ah-OOG-ah 5abeb9709e Credit FRAPI 2024-02-29 21:17:46 -05:00
ah-OOG-ah 5ec50f22d9 Remove Fabric license headers 2024-02-29 21:17:46 -05:00
ah-OOG-ah dfe3a4220b Add convenience methods 2024-02-29 21:17:46 -05:00
ah-OOG-ah 1e1e95f249 Variant handling 2024-02-29 21:17:46 -05:00
ah-OOG-ah 02b0d1b728 Update JsonModel.java
This fixes things and I don't know why
2024-02-29 21:17:46 -05:00
ah-OOG-ah 9c81c96bb3 Dang, BlockState is hard
YEET
2024-02-29 21:17:46 -05:00
ah-OOG-ah fff5b2cb01 Implement initial BlockState API 2024-02-29 21:17:46 -05:00
ah-OOG-ah 77f1e9b5a2 Support element rotation 2024-02-29 21:17:46 -05:00
ah-OOG-ah 3158a33a65 Texture loading 2024-02-29 21:17:46 -05:00
ah-OOG-ah f6f840235e Does everything but textures 2024-02-29 21:17:46 -05:00
ah-OOG-ah 793f668ef8 Copyright-clear model parsing 2024-02-29 21:17:46 -05:00
Jason Mitchell da01393799 Try an Int2ObjectMap instead of an ObjectList 2024-02-28 23:02:02 -08:00
Jason Mitchell 3030be32f4 Apparently some mods rely on ForgeHooksClient.getWorldRenderPass() (#347)
* Apparently some mods rely on ForgeHooksClient.getWorldRenderPass()
2024-02-28 19:00:26 +00:00
Caedis dbdeba9865 Up required gtnhlib version to 0.2.9 (#340)
* Update README.MD

* Update AngelicaMod.java
2024-02-27 16:49:23 +00:00
Caedis 80ff6af14e Replace config with gtnhlib's config (#337)
* Remove own config

* update bs + deps

* update gtnhlib

* Replace config with gtnhlib's config
2024-02-27 08:37:17 -08:00
Jason Mitchell c34290d182 Ignore the iris/mcpf configs, hardcode angelica-modules.cfg filename 2024-02-26 12:57:47 -08:00
Jason Mitchell 6e3235a985 Gate some advanced/beta features behind java properties 2024-02-26 10:31:54 -08:00
Caedis 419fa9f0c0 Add Dynamic FOV toggle (#331) 2024-02-26 09:19:32 -08:00
Raven Szewczyk c996e5e58c Use a RFB plugin for GLSM transforms when available (#329) 2024-02-25 12:58:19 -08:00
mts2200 6d28df74a6 Fix #320 (#325)
* Fix https://github.com/GTNewHorizons/Angelica/issues/320

* Fix tests on AMD
2024-02-25 01:00:32 -08:00
Jason Mitchell ce97ef876d Switch up the signature to take ints instead of a blockpos and stop allocating one (#324) 2024-02-21 21:29:56 -08:00
Jason Mitchell 8898a6f252 Switcharoo on detecting ThreadSafeISBRHFactory... (#318)
other method apparently wasn't working
2024-02-20 22:17:00 -08:00
Jason Mitchell 37f638ac34 scheduleRebuildOffThread (#316)
* scheduleRebuildOffThread
2024-02-20 08:58:03 -08:00
Jason Mitchell f73c698a5a Don't crash wit invalid lightquality/particalmode options 2024-02-17 22:46:31 -08:00
Jason Mitchell 029da0e7fa Fix glLoadMatrix and add a test for it
Fixes https://github.com/GTNewHorizons/Angelica/issues/299
2024-02-17 18:15:58 -08:00
Darren Eberly e40ee19ac8 Move JOML dependency to GTNHLib (#301)
* Move JOML dependency to GTNHLib

* Update GTNHLib version in README
2024-02-15 10:51:44 -08:00
jss2a98aj 33832fe547 Sync with NotFine (#296)
* Sync with NotFine

* Fix mistake in package name

* Re-separate stars mode and stars total settings
2024-02-15 10:20:13 -08:00
Jason Mitchell 671a776952 Test Matrix operations (#295)
* Test Matrix operations
2024-02-13 23:20:01 -08:00
Matthew William Noel 445b6a3e68 Partially fix entity shaders (#294)
* Partially fix entity shaders
2024-02-13 20:57:44 +00:00
Jason Mitchell ff65370cc5 Blacklist bartworks from the main thread (#286)
Fixes #181
2024-02-12 22:34:24 -08:00
Jason MitchellandCaedis ff290c19e2 GLSM Tests & AMD Driver Workaround (#290)
* Store graphics vendor
* AMD driver workarounds

* Test TRANSFORM_BIT

* Test GL_TEXTURE_BIT
* Fix handling of bound textures on glDeleteTextures

* Switch up the LOGGER in RenderSystem so we don't trigger a Forge Configuration load; AMD driver default matrix mode workaround

* Switch BatchingFontRenderer to use the gl methods via GLSM to better respect cache bypassing
Fix a few instances of GLSM not respecting the bypass

* Start with "runningSplash" true always to disable the cache until loaded into the world

---------

Co-authored-by: Caedis <[email protected]>
2024-02-12 22:33:23 -08:00
Jason Mitchell d1e505308c Ask for graphics card vendor on bugs 2024-02-12 08:36:24 -08:00
Caedis 594799103b Exclude AMD in testPushPopEnableBit 2024-02-11 20:01:53 -08:00
Jason Mitchell 8a65f471a0 Make getBlockType and getBlockMetadata atomic
* Sidesteps/fixes a race condition in the WIP carpenter block thread safe ISBRH implementation
2024-02-11 19:29:17 -08:00
Jason Mitchellandembeddedt d52e2b0454 Do not return null results in translucency sort task if not cancelled (#284)
* Do not return null results in translucency sort task if not cancelled

Co-authored-by: embeddedt <[email protected]>
2024-02-11 22:55:16 +00:00
Raven Szewczyk 9b31bae1c8 Log more information in the no-result task exception (#283) 2024-02-11 22:12:05 +00:00
Ginsway 7cbb905bd7 Update Chinese translation (#261)
* 固有的

* 自己翻译的

* Update src/main/resources/assets/angelica/lang/zh_CN.lang
2024-02-11 13:32:18 -08:00
Jason Mitchell 8a50ed036d More GLSM Tests (#282)
* Properly Cache GL_SHADE_MODEL and make it a stack

* Add opengl_32_core to docs, so we can easily see what is needed to be deprecated/emulated
Add some stub functions to be fleshed out later
2024-02-11 12:13:51 -08:00
Jason Mitchell f1394382ab Make note of required versions of mods if present 2024-02-11 10:45:20 -08:00
Raven Szewczyk 74e6c80aad A few buildscript and test tweaks (#281)
* Kotlin buildscript for better IDE integration

* Fix transitive Bauble dep, move CoreTweaks to a fake-ivy dependency

* Don't scan fullscreen modes for window creation

* Update GTNHGradle
2024-02-11 05:24:08 -08:00
ah-OOG-ah da9d6bad56 Fix typo in issue template (#280) 2024-02-10 20:57:40 -08:00
Jason Mitchell 58a6fabf3c Enough with the bug reports about disabled features 2024-02-10 20:51:18 -08:00
Jason MitchellandDarren Eberly f8c11967d1 Glsm tests (#275)
* Tests for GL_DEPTH_BUFFER_BIT
* Swizzle DepthState.mask ~> enabled
* Use AssertAll so we can clearly see gl/glsm state differences
* Reset test state leakage from ColorBufferBit
* Add start of test for GL_CURRENT_BIT
* Initial basic display list tests
* Print mismatched array index for array comparisions
* Add message for all tests
* Test GL_CURRENT_BIT
* Implement GLSM stub functions
* Test GL_ENABLE_BIT
* Add verifyNotDefaultState when we don't care about the values, just that they're not the default
* GL_MULTISAMPLE seems to be broken on Nvidia
* Test GL_FOG_BIT
* Check glGetError() after every test
* Exclude some tests based on vendor
* Test most of GL_LIGHTING_BIT

---------

Co-authored-by: Darren Eberly <[email protected]>
2024-02-10 16:51:12 -08:00
Jason Mitchell 6d1c4bf39c Revert "fix release workaround"
This reverts commit 018a47e400.
2024-02-10 09:43:48 -08:00
Jason Mitchell 018a47e400 fix release workaround 2024-02-09 17:53:26 -08:00
ah-OOG-ahandmakamys 509017551a Initial QuadProvider API (#256)
* Initial model testing

* Fix UV

* More quad work

* Update BlockRenderer.java

* QuadProvider renders right!

* Clean up

* Update CubeModel.java

* Initial colorization work

* (Badly) color grass

Unbreaks vanilla blocks

* Leaves are easier

* Add separate AO back

* Relocate to Angelica

* Cleanup + pool quads

* Add TODOs for future reference

* Update LightDataAccess.java

* Replace code comment with TODO

* Update WorldSlice.java

Co-authored-by: makamys <[email protected]>

* Default quads to UP

* Only coerce facing in Quad#getFace

Mirrors 1.16's face handling more accurately.
Fixes face culling not working properly for blocks like tall grass

* Iterate over unaligned quads too

* Don't cull unaligned faces

* Release QP quads

---------

Co-authored-by: makamys <[email protected]>
2024-02-09 17:41:15 -08:00
Jason Mitchell cf454f287c GLSM Improvements (#272)
* GLSM Improvements
* Add an IntegerStateStack
* Use IntegerStateStack to track the active texture unit
* Track activeTextureUnit with GL_TEXTURE_BIT
* Bugfix - Don't include color with GL_COLOR_BUFFER_BIT
* Fully test glPush/PopAttrib for GL_COLOR_BUFFER_BIT
* Split GLStateManager init into two pieces
2024-02-09 17:35:58 -08:00
Darren Eberly 0e3e4283af Compat with NotEnoughIDs 16-bit Metadata (#271)
* Compat with NotEnoughIDs 16-bit Metadata

* Less bad(maybe) version parsing
2024-02-09 00:33:42 -05:00
Bogdan 8176e1cd1c Don't put excessive buffer size (#267) 2024-02-04 13:57:04 -08:00
ah-OOG-ah d2cba7c321 Update settings.gradle (#268) 2024-02-04 13:56:22 -08:00
Raven Szewczyk f791b0dab3 [ci skip] upgraded build system 2024-02-04 19:56:28 +00:00
Jason Mitchell 5093531811 Cleanup 2024-02-03 16:04:19 -08:00
185 changed files with 6425 additions and 3400 deletions

No files matched your search

+15 -1
View File
@@ -34,6 +34,20 @@ body:
- Other (Please Specify)
validations:
required: true
- type: dropdown
id: graphics
attributes:
label: Graphics Card Vendor
description: What graphics card vendor are you using?
options:
- Other (Please Specify)
- NVidia
- AMD/ATI
- Intel iGPU
- AMD iGPU
- Mesa/Software
validations:
required: true
- type: textarea
id: report
attributes:
@@ -62,6 +76,6 @@ body:
required: true
- label: "I am running an officially released version. (Or, if I've compiled it myself I plan to fix the issue)"
required: true
- label: "This issue is not shader related (they aren't ready yet for testing)"
- label: "This issue is not related to a feature that is disabed by default - Shaders, MCPF, etc. [They'll be enabled when they're ready for testing]"
required: true
+5 -1
View File
@@ -8,7 +8,8 @@
# Required Dependencies
* [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.14
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.2.1
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.2.9
* NOTE: Some mods are not required, but a specific version is required if present - see: `Permanent Incompatibilities` below.
# Known (temporary) Incompatibilities
* Forge Relocation - Currently non Thread Safe; safe if not in use
@@ -58,3 +59,6 @@
* IMS, jss2a98aj, || dbp ||, roadhog360 for advice and moral support
* Forge 1.12+
* Some files have been taken from Minecraft Forge under the LGPL 2.1 license and are marked as such
* FRAPI and Indigo
* Model building API heavily inspired by/copied from Fabric's; upstream may use it under the original Apache 2.0
license, see LICENSE in `com.gtnewhorizons.angelica.models`
-7
View File
@@ -1,7 +0,0 @@
allprojects {
gradle.projectsEvaluated {
tasks.withType(JavaCompile) {
options.compilerArgs << "-Xmaxerrs" << "2000"
}
}
}
-1624
View File
File diff suppressed because it is too large. Load diff
+33
View File
@@ -0,0 +1,33 @@
plugins {
id("com.gtnewhorizons.gtnhconvention")
}
minecraft {
extraRunJvmArguments.add("-Dangelica.enableTestBlocks=true")
}
tasks.test {
useJUnitPlatform()
testLogging {
events("passed", "skipped", "failed")
}
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(8)
}
dependsOn(tasks.extractNatives2)
jvmArgs("-Djava.library.path=${tasks.extractNatives2.get().destinationFolder.asFile.get().path}")
}
tasks.processResources {
inputs.property("version", project.version.toString())
filesMatching("META-INF/rfb-plugin/*") {
expand("version" to project.version.toString())
}
}
tasks.register<Copy>("copyDependencies") {
group = "Angelica"
description = "Collect dependencies into the testDependencies folder"
from(configurations.default)
into("testDependencies")
}
+20 -12
View File
@@ -49,15 +49,16 @@ configurations {
}
dependencies {
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.4.4")
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.4.31")
compileOnly("org.projectlombok:lombok:1.18.22") {transitive = false }
compileOnly("com.gtnewhorizons.retrofuturabootstrap:RetroFuturaBootstrap:0.4.0") { transitive = false }
compileOnly("org.projectlombok:lombok:1.18.22") { transitive = false }
annotationProcessor("org.projectlombok:lombok:1.18.22")
// Iris Shaders
compileOnly('org.jetbrains:annotations:24.0.1')
api("com.github.GTNewHorizons:GTNHLib:0.2.1:dev")
shadowImplementation("org.joml:joml:1.10.5") // MIT
api("com.github.GTNewHorizons:GTNHLib:0.2.9:dev")
shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
implementation("io.github.douira:glsl-transformer:1.0.0")
shadowImplementation("io.github.douira:glsl-transformer:1.0.0") { // glsl-transformer Noncommercial License 1.0.0
@@ -66,30 +67,37 @@ dependencies {
compileOnly "org.apache.ant:ant:1.8.2"
// Because who doesn't want NEI
compileOnly('com.github.GTNewHorizons:NotEnoughItems:2.4.9-GTNH:dev')
compileOnly('com.github.GTNewHorizons:CodeChickenCore:1.2.0:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.4.9-GTNH:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:CodeChickenCore:1.2.0:dev')
// Notfine Deps
compileOnly("thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev")
runtimeOnly("com.github.GTNewHorizons:Baubles:1.0.1.16:dev")
compileOnly("com.github.GTNewHorizons:twilightforest:2.5.1:dev") {transitive = false }
runtimeOnlyNonPublishable("com.github.GTNewHorizons:Baubles:1.0.4:dev")
compileOnly("com.github.GTNewHorizons:twilightforest:2.5.16:dev") { transitive = false }
compileOnly(rfg.deobf('curse.maven:witchery-69673:2234410'))
compileOnly("com.falsepattern:chunkapi-mc1.7.10:0.5.0:api")
compileOnly("com.falsepattern:endlessids-mc1.7.10:1.5-beta0002:dev")
compileOnly("com.falsepattern:chunkapi-mc1.7.10:0.5.0:api") { transitive = false }
compileOnly("com.falsepattern:endlessids-mc1.7.10:1.5-beta0002:dev") { transitive = false }
compileOnly(rfg.deobf("curse.maven:extrautils-225561:2264383"))
compileOnly(rfg.deobf("curse.maven:dynamiclights-227874:2337326"))
compileOnly("com.github.GTNewHorizons:NotEnoughIds:1.5.3:dev") // Mixin Version
compileOnly("com.github.GTNewHorizons:NotEnoughIds:2.0.3:dev") // Mixin Version
compileOnly("com.github.GTNewHorizons:NotEnoughIds-Legacy:1.4.7:dev") // ASM Version
compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
// HMMMMM
compileOnly(rfg.deobf("curse.maven:journeymap-32274:2367915"))
runtimeOnly(deobf("https://github.com/makamys/CoreTweaks/releases/download/0.3.3.2/CoreTweaks-1.7.10-0.3.3.2+nomixin.jar"))
runtimeOnlyNonPublishable(rfg.deobf("CoreTweaks:CoreTweaks:0.3.3.2"))
// Hodgepodge
transformedMod("net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev")
// Tests
testImplementation(platform('org.junit:junit-bom:5.9.2'))
testImplementation('org.junit.jupiter:junit-jupiter')
testImplementation("org.mockito:mockito-core:3.+")
testImplementation("org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209")
}
+34
View File
@@ -0,0 +1,34 @@
# A specification for models
This is borrowed from [the unofficial Minecraft wiki](https://minecraft.wiki/w/Tutorials/Models) under the CC BY-NC-SA 3.0.
The folder `assets/<namespace>/models/block` holds the model files for all the specified variants. The names of the files can be changed, but must always correspond with the names used in the variant files.
* `[TAG_compound]` The root tag
* `[TAG_string]` **parent**: Loads a different model from the given path, in form of a [resource location](https://minecraft.wiki/w/Tutorials/Models#File_path). If both `"parent"` and `"elements"` are set, the `"elements"` tag overrides the `"elements"` tag from the previous model.
* Can be set to `"builtin/generated"` to use a model that is created out of the specified icon. Note that only the first layer is supported, and rotation can be achieved only by using block states files.
* `[TAG_byte]` **ambientocclusion**: Whether to use [ambient occlusion](http://en.wikipedia.org/wiki/Ambient_occlusion) (`true` - default), or not (`false`). Note:only works on Parent file
* `[TAG_object]` **display**: Holds the different places where item models are displayed.
* `[TAG_compound]` ***Position***: Named `thirdperson_righthand`, `thirdperson_lefthand`, `firstperson_righthand`, `firstperson_lefthand`, `gui`, `head`, `ground`, or `fixed`. Place where an item model is displayed. Holds its rotation, translation and scale for the specified situation. '''fixed''' refers to item frames, while the rest are as their name states. Note that translations are applied to the model before rotations.
* `[TAG_list]` **rotation**: Specifies the rotation of the model according to the scheme `[x, y, z]`.
* `[TAG_list]` **translation**: Specifies the position of the model according to the scheme `[x, y, z]`. The values are clamped between -80 and 80.
* `[TAG_list]` **scale**: Specifies the scale of the model according to the scheme `[x, y, z]`. If the value is greater than 4, it is displayed as 4.
* `[TAG_compound]` **textures**: Holds the textures of the model, in form of a [resource location](https://minecraft.wiki/w/Tutorials/Models#File_path) or can be another texture variable.
* `[TAG_string]` **particle**: What texture to load particles from. This texture is also used as an overlay if you are in a [nether portal](https://minecraft.wiki/w/Nether_portal), and used for [water](https://minecraft.wiki/w/water) and [lava](https://minecraft.wiki/w/Lava)'s still textures.<sup>[[1]](https://bugs.mojang.com/browse/MC-240042)</sup> This texture is also considered a texture variable that can be referenced as `"#particle"`. Note: All breaking particles from non-model blocks are hard-coded, such as for [barriers](https://minecraft.wiki/w/Barrier).
* `[TAG_string]` ***Texture variable***: Defines a texture variable with `name` and assigns it to a texture or another variable.
* `[TAG_list]` **elements**: Contains all the elements of the model. They can have only cubic forms. If both `"parent"` and `"elements"` are set, the `"elements"` tag overrides the `"elements"` tag from the previous model.
* `[TAG_compound]` An element.
* `[TAG_list]` **from**: Start point of a cuboid according to the scheme `[x, y, z]`. Values must be between -16 and 32.
* `[TAG_list]` **to**: Stop point of a cuboid according to the scheme `[x, y, z]`. Values must be between -16 and 32.
* `[TAG_compound]` **rotation**: Defines the rotation of an element.
* `[TAG_list]` **origin**: Sets the center of the rotation according to the scheme `[x, y, z]`.
* `[TAG_string]` **axis**: Specifies the direction of rotation, can be `"x"`, `"y"` or `"z"`.
* `[TAG_float]` **angle**: Specifies the angle of rotation. Can be 45 through -45 degrees in 22.5 degree increments.
* `[TAG_byte]` **rescale**: Specifies whether or not to scale the faces across the whole block. Can be true or false. Defaults to false.
* `[TAG_byte]` **shade**: Defines if shadows are rendered (`true` - default), not (`false`).
* `[TAG_compound]` **faces**: Holds all the faces of the cuboid. If a face is left out, it does not render.
* `[TAG_compound]` ***Face***: Named `down`, `up`, `north`, `south`, `west` or `east`. Contains the properties of the specified face.
* `[TAG_list]` **uv**: Defines the area of the texture to use according to the scheme `[x1, y1, x2, y2]`. The texture behavior is inconsistent if UV extends below 0 or above 16. If the numbers of `x1` and `x2` are swapped (e.g. from `0, 0, 16, 16` to `16, 0, 0, 16`), the texture flips. UV is optional, and if not supplied it automatically generates based on the element's position.
* `[TAG_string]` **texture**: Specifies the texture in form of the texture variable prepended with a `#`.
* `[TAG_string]` **cullface**: Specifies whether a face does not need to be rendered when there is a block touching it in the specified position. The position can be: `down`, `up`, `north`, `south`, `west`, or `east`. It also determines the side of the block to use the light level from for lighting the face, and if unset, defaults to the side.
* `[TAG_int]` **rotation**: Rotates the texture clockwise by the specified number of degrees. Can be 0, 90, 180, or 270. Defaults to 0. Rotation does not affect which part of the texture is used. Instead, it amounts to permutation of the selected texture vertexes (selected implicitly, or explicitly though `uv`).
* `[TAG_int]` **tintindex**: Determines whether to tint the texture using a hardcoded tint index. The default value, -1, indicates not to use the tint. Any other number is provided to BlockColors to get the tint value corresponding to that index. However, most blocks do not have a tint value defined (in which case white is used). Furthermore, no vanilla block currently uses multiple tint values, and thus the tint index value is ignored (as long as it is set to something other than -1); it could be used for modded blocks that need multiple distinct tint values in the same block though.
File diff suppressed because it is too large. Load diff
+91 -47
View File
@@ -1,81 +1,104 @@
# ExampleMod tag to use as Blowdryer (Spotless, etc.) settings version, leave empty to disable.
# LOCAL to test local config updates.
gtnh.settings.blowdryerTag = 0.2.2
# Human-readable mod name, available for mcmod.info population.
modName = Angelica
# This is a case-sensitive string to identify your mod. Convention is to use lower case.
# Case-sensitive identifier string, available for mcmod.info population and used for automatic mixin JSON generation.
# Conventionally lowercase.
modId = angelica
# Root package of the mod, used to find various classes in other properties,
# mcmod.info substitution, enabling assertions in run tasks, etc.
modGroup = com.gtnewhorizons.angelica
# WHY is there no version field?
# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
# Whether to use modGroup as the maven publishing group.
# Due to a history of using JitPack, the default is com.github.GTNewHorizons for all mods.
useModGroupForPublishing = false
# Will update your build.gradle automatically whenever an update is available
# Updates your build.gradle and settings.gradle automatically whenever an update is available.
autoUpdateBuildScript = false
# Version of Minecraft to target
minecraftVersion = 1.7.10
# Version of Minecraft Forge to target
forgeVersion = 10.13.4.1614
# Specify a MCP channel and mappings version for dependency deobfuscation and the deobfParams task.
# Specify an MCP channel for dependency deobfuscation and the deobfParams task.
channel = stable
# Specify an MCP mappings version for dependency deobfuscation and the deobfParams task.
mappingsVersion = 12
# Define other MCP mappings for dependency deobfuscation
remoteMappings = https://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/conf/
# Defines other MCP mappings for dependency deobfuscation.
remoteMappings = https\://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/conf/
# Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you
# restart Minecraft in development. Choose this dependent on your mod:
# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
# Select a default username for testing your mod. You can always override this per-run by running
# `./gradlew runClient --username=AnotherPlayer`, or configuring this command in your IDE.
developmentEnvironmentUserName = Developer
# Enables using modern java syntax (up to version 17) via Jabel, while still targetting JVM 8.
# Enables using modern Java syntax (up to version 17) via Jabel, while still targeting JVM 8.
# See https://github.com/bsideup/jabel for details on how this works.
enableModernJavaSyntax = true
# Enables injecting missing generics into the decompiled source code for a better coding experience
# Turns most publically visible List, Map, etc. into proper List<Type>, Map<K, V> types
# Enables injecting missing generics into the decompiled source code for a better coding experience.
# Turns most publicly visible List, Map, etc. into proper List<E>, Map<K, V> types.
enableGenericInjection = true
# Define a source file of your project with:
# public static final String VERSION = "GRADLETOKEN_VERSION";
# The string's content will be replaced with your mod's version when compiled. You should use this to specify your mod's
# version in @Mod([...], version = VERSION, [...])
# Leave these properties empty to skip individual token replacements
# Generate a class with a String field for the mod version named as defined below.
# If generateGradleTokenClass is empty or not missing, no such class will be generated.
# If gradleTokenVersion is empty or missing, the field will not be present in the class.
generateGradleTokenClass = com.gtnewhorizons.angelica.Tags
gradleTokenModId =
gradleTokenModName =
# Name of the token containing the project's current version to generate/replace.
gradleTokenVersion = VERSION
# [DEPRECATED] Mod ID replacement token.
gradleTokenModId =
# [DEPRECATED] Mod name replacement token.
gradleTokenModName =
# [DEPRECATED] Mod Group replacement token.
gradleTokenGroupName =
# [DEPRECATED]
# Multiple source files can be defined here by providing a comma-seperated list: Class1.java,Class2.java,Class3.java
# Multiple source files can be defined here by providing a comma-separated list: Class1.java,Class2.java,Class3.java
# public static final String VERSION = "GRADLETOKEN_VERSION";
# The string's content will be replaced with your mod's version when compiled. You should use this to specify your mod's
# version in @Mod([...], version = VERSION, [...])
# Leave these properties empty to skip individual token replacements
# version in @Mod([...], version = VERSION, [...]).
# Leave these properties empty to skip individual token replacements.
replaceGradleTokenInFile =
# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
# leave this property empty.
# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
# Example value: (apiPackage = api) + (modGroup = com.myname.mymodid) -> com.myname.mymodid.api
apiPackage = api
# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
# There can be multiple files in a comma-separated list.
# Example value: mymodid_at.cfg,nei_at.cfg
# There can be multiple files in a space-separated list.
# Example value: mymodid_at.cfg nei_at.cfg
accessTransformersFile = angelica_at.cfg notfine_at.cfg archaicfix_at.cfg mcpatcherforge_at.cfg
# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
usesMixins = true
# Adds some debug arguments like verbose output and export
# Adds some debug arguments like verbose output and class export.
usesMixinDebug = false
# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
mixinPlugin =
# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
mixinsPackage = mixins
# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
# This parameter is for legacy compatibility only
# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
# Example value: (coreModClass = asm.FMLPlugin) + (modGroup = com.myname.mymodid) -> com.myname.mymodid.asm.FMLPlugin
coreModClass = loading.AngelicaTweaker
# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class
# that is annotated with @Mod) you want this to be true. When in doubt: leave it on false!
containsMixinsAndOrCoreModOnly = false
@@ -83,22 +106,32 @@ containsMixinsAndOrCoreModOnly = false
# Enables Mixins even if this mod doesn't use them, useful if one of the dependencies uses mixins.
forceEnableMixins = false
# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated in your jar. It is your
# responsibility check the licence and request permission for distribution, if required.
# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated into your jar. It is your
# responsibility to check the license and request permission for distribution if required.
usesShadowedDependencies = true
# If disabled, won't remove unused classes from shaded dependencies. Some libraries use reflection to access
# If disabled, won't remove unused classes from shadowed dependencies. Some libraries use reflection to access
# their own classes, making the minimization unreliable.
minimizeShadowedDependencies = true
# If disabled, won't rename the shadowed classes.
relocateShadowedDependencies = true
# Adds the GTNH maven, CurseMaven, IC2/Player maven, and some more well-known 1.7.10 repositories
# Adds the GTNH maven, CurseMaven, IC2/Player maven, and some more well-known 1.7.10 repositories.
includeWellKnownRepositories = true
# Publishing to modrinth requires you to set the MODRINTH_TOKEN environment variable to your current modrinth API token.
# Change these to your Maven coordinates if you want to publish to a custom Maven repository instead of the default GTNH Maven.
# Authenticate with the MAVEN_USER and MAVEN_PASSWORD environment variables.
# If you need a more complex setup disable maven publishing here and add a publishing repository to addon.gradle.
usesMavenPublishing = true
# Maven repository to publish the mod to.
# mavenPublishUrl = https\://nexus.gtnewhorizons.com/repository/releases/
# Publishing to Modrinth requires you to set the MODRINTH_TOKEN environment variable to your current Modrinth API token.
#
# The project's ID on Modrinth. Can be either the slug or the ID.
# Leave this empty if you don't want to publish on Modrinth.
# Leave this empty if you don't want to publish to Modrinth.
modrinthProjectId =
# The project's relations on Modrinth. You can use this to refer to other projects on Modrinth.
@@ -110,9 +143,8 @@ modrinthProjectId =
# Note: GTNH Mixins is automatically set as a required dependency if usesMixins = true
modrinthRelations =
# Publishing to CurseForge requires you to set the CURSEFORGE_TOKEN environment variable to one of your CurseForge API tokens.
#
# The project's numeric ID on CurseForge. You can find this in the About Project box.
# Leave this empty if you don't want to publish on CurseForge.
curseForgeProjectId =
@@ -122,27 +154,39 @@ curseForgeProjectId =
# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
# and the name is the CurseForge project slug of the other mod.
# Example: requiredDependency:railcraft;embeddedLibrary:cofhlib;incompatible:buildcraft
# Note: GTNH Mixins is automatically set as a required dependency if usesMixins = true
# Note: UniMixins is automatically set as a required dependency if usesMixins = true.
curseForgeRelations =
# Optional parameter to customize the produced artifacts. Use this to preserver artifact naming when migrating older
# Optional parameter to customize the produced artifacts. Use this to preserve artifact naming when migrating older
# projects. New projects should not use this parameter.
# customArchiveBaseName =
# Optional parameter to prevent the source code from being published
# noPublishedSources =
# Optional parameter to have the build automatically fail if an illegal version is used.
# This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
# The check is ONLY performed if the version is a git tag.
# Note: the specified string must be escaped, so e.g. 1\\.1\\.\\d+ instead of 1\.1\.\d+
# versionPattern =
# Uncomment this to disable spotless checks
# Uncomment to prevent the source code from being published.
# noPublishedSources = true
# Uncomment this to disable Spotless checks.
# This should only be uncommented to keep it easier to sync with upstream/other forks.
# That is, if there is no other active fork/upstream, NEVER change this.
# Disabling to make easier to sync if some of the additional mods get any changes upstream
disableSpotless = true
# Override the IDEA build type. Valid value is "" (leave blank, do not override), "idea" (force use native IDEA build), "gradle"
# Uncomment this to disable Checkstyle checks (currently wildcard import check).
# disableCheckstyle = true
# Override the IDEA build type. Valid values are: "" (leave blank, do not override), "idea" (force use native IDEA build), "gradle"
# (force use delegated build).
# This is meant to be set in $HOME/.gradle/gradle.properties.
# e.g. add "systemProp.org.gradle.project.ideaOverrideBuildType=idea" will override the build type to be always native build.
# e.g. add "systemProp.org.gradle.project.ideaOverrideBuildType=idea" will override the build type to be native build.
# WARNING: If you do use this option, it will overwrite whatever you have in your existing projects. This might not be what you want!
# Usually there is no need to uncomment this here as other developers do not necessarily use the same build type as you.
# ideaOverrideBuildType = idea
# Whether IDEA should run spotless checks when pressing the Build button.
# This is meant to be set in $HOME/.gradle/gradle.properties.
# ideaCheckSpotlessOnBuild = true
+1 -1
View File
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
Vendored
+10 -10
View File
@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
+18 -1
View File
@@ -5,7 +5,24 @@ repositories {
name = 'mavenpattern'
url = 'https://mvn.falsepattern.com/releases'
content {
includeGroup "com.falsepattern"
includeGroup 'com.falsepattern'
}
}
exclusiveContent {
forRepository {
ivy {
name = 'CoreTweaks releases'
url = 'https://github.com/makamys/CoreTweaks/releases/download/'
patternLayout {
artifact '[revision]/[module]-1.7.10-[revision]+nomixin(-[classifier])(.[ext])'
}
metadataSources {
artifact()
}
}
}
filter {
includeGroup('CoreTweaks')
}
}
mavenLocal()
+2 -9
View File
@@ -1,4 +1,3 @@
pluginManagement {
repositories {
maven {
@@ -6,6 +5,7 @@ pluginManagement {
name "GTNH Maven"
url "https://nexus.gtnewhorizons.com/repository/public/"
mavenContent {
includeGroup("com.gtnewhorizons")
includeGroupByRegex("com\\.gtnewhorizons\\..+")
}
}
@@ -16,12 +16,5 @@ pluginManagement {
}
plugins {
id 'com.diffplug.blowdryerSetup' version '1.7.1'
id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0' // Provides java toolchains
}
blowdryerSetup {
repoSubfolder 'gtnhShared'
github('GTNewHorizons/ExampleMod1.7.10', 'tag', '0.2.2')
//devLocal '.' // Use this when testing config updates locally
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.18'
}
@@ -15,7 +15,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
name = "Angelica",
version = Tags.VERSION,
dependencies = " before:lwjgl3ify@[1.5.3,);" + " after:hodgepodge@[2.4.4,);" + " after:CodeChickenCore@[1.2.0,);"
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.2.1,);",
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.2.9,);",
acceptedMinecraftVersions = "[1.7.10]",
acceptableRemoteVersions = "*",
guiFactory = "com.gtnewhorizons.angelica.config.AngelicaGuiConfigFactory")
@@ -0,0 +1,49 @@
package com.gtnewhorizons.angelica.api;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import net.minecraft.util.MathHelper;
import net.minecraftforge.common.util.ForgeDirection;
import java.math.RoundingMode;
import static com.google.common.math.IntMath.log2;
public interface BlockPos {
int SIZE_BITS_X = 1 + log2(MathHelper.roundUpToPowerOfTwo(30000000), RoundingMode.UNNECESSARY);
int SIZE_BITS_Z = SIZE_BITS_X;
int SIZE_BITS_Y = 64 - SIZE_BITS_X - SIZE_BITS_Z;
long BITS_X = (1L << SIZE_BITS_X) - 1L;
long BITS_Y = (1L << SIZE_BITS_Y) - 1L;
long BITS_Z = (1L << SIZE_BITS_Z) - 1L;
int BIT_SHIFT_Z = SIZE_BITS_Y;
int BIT_SHIFT_X = SIZE_BITS_Y + SIZE_BITS_Z;
int getX();
int getY();
int getZ();
BlockPosImpl offset(ForgeDirection d);
BlockPosImpl down();
BlockPosImpl up();
long asLong();
static long asLong(int x, int y, int z) {
long l = 0L;
l |= ((long) x & BITS_X) << BIT_SHIFT_X;
l |= ((long) y & BITS_Y) << 0;
l |= ((long) z & BITS_Z) << BIT_SHIFT_Z;
return l;
}
public static int unpackLongX(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);
}
public static int unpackLongY(long packedPos) {
return (int)(packedPos << 64 - SIZE_BITS_Y >> 64 - SIZE_BITS_Y);
}
public static int unpackLongZ(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_Z - SIZE_BITS_Z >> 64 - SIZE_BITS_Z);
}
}
@@ -0,0 +1,8 @@
package com.gtnewhorizons.angelica.api;
public interface MutableBlockPos extends BlockPos {
MutableBlockPos set(int x, int y, int z);
MutableBlockPos set(long packedPos);
}
@@ -0,0 +1,43 @@
package com.gtnewhorizons.angelica.api;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public interface QuadProvider {
int R_MASK = 0xFF << 16;
int G_MASK = 0xFF << 8;
int B_MASK = 0xFF;
/**
* Returns the color packed as ABGR. If you want to vary colors within a block, just ignore the color passed into
* {@link #getQuads} and use whatever you want. You might want to override this to return a constant if you're
* extending a block with an expensive color call, like leaves.
*/
default int getColor(IBlockAccess world, BlockPos pos, Block block, int meta, Random random) {
final int cin = block.colorMultiplier(world, pos.getX(), pos.getY(), pos.getZ());
return (0xFF << 24) | ((cin & B_MASK) << 16) | (cin & G_MASK) | ((cin & R_MASK) >>> 16);
}
/**
* If you need to allocate new quads, set this to true. If true, the quads returned by {@link #getQuads} are
* recycled, and you should not keep a reference to them. Example: stone can return a static list every time, but a
* modded block which adds or removes quads based on location would need dynamic quads.
*/
default boolean isDynamic() {
return false;
}
/**
* Provide quads to render. If you need new quads, they should be obtained with the passed supplier and
* {@link #isDynamic} overridden to return true. If so, all quads in the list are recycled and references to them
* should not be kept.
*/
List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool);
}
@@ -0,0 +1,22 @@
package com.gtnewhorizons.angelica.api;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadViewMutable;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraftforge.common.util.ForgeDirection;
import javax.annotation.Nullable;
public interface QuadView extends ModelQuadViewMutable {
boolean isShade();
boolean isDeleted();
ForgeDirection getFace();
void copyFrom(QuadView src);
void setRaw(int[] data, boolean shade, @Nullable ForgeDirection face, int colorIndex, int flags);
int[] getRawVertexes();
/**
* Present for compatibility with the Tesselator, not recommended for general use.
*/
void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ);
}
@@ -248,7 +248,7 @@ public class BatchingFontRenderer {
batchCommands.sort(FontDrawCmd.DRAW_ORDER_COMPARATOR);
final boolean isTextureEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_TEXTURE_2D);
final int boundTextureBefore = GLStateManager.getBoundTexture();
final int boundTextureBefore = GLStateManager.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
boolean textureChanged = false;
ResourceLocation lastTexture = DUMMY_RESOURCE_LOCATION;
@@ -265,7 +265,7 @@ public class BatchingFontRenderer {
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, 0, batchVtxPositions);
glEnableClientState(GL_VERTEX_ARRAY);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
// Use plain for loop to avoid allocations
final FontDrawCmd[] cmdsData = batchCommands.elements();
@@ -274,9 +274,9 @@ public class BatchingFontRenderer {
final FontDrawCmd cmd = cmdsData[i];
if (!Objects.equals(lastTexture, cmd.texture)) {
if (lastTexture == null) {
GLStateManager.enableTexture();
GLStateManager.glEnable(GL11.GL_TEXTURE_2D);
} else if (cmd.texture == null) {
GLStateManager.disableTexture();
GLStateManager.glDisable(GL11.GL_TEXTURE_2D);
}
if (cmd.texture != null) {
((FontRendererAccessor) underlying).angelica$bindTexture(cmd.texture);
@@ -292,7 +292,7 @@ public class BatchingFontRenderer {
glPopClientAttrib();
if (isTextureEnabledBefore) {
GLStateManager.enableTexture();
GLStateManager.glEnable(GL11.GL_TEXTURE_2D);
}
if (textureChanged) {
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, boundTextureBefore);
@@ -1,8 +1,9 @@
package com.gtnewhorizons.angelica.client.renderer;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.glsm.stacks.Vector3dStack;
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
@@ -39,15 +40,15 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
private static final MethodHandle sRawBufferSize;
private static final MethodHandle gRawBufferSize;
private final BlockRenderer.Flags FLAGS = new BlockRenderer.Flags(true, true, true, true);
private final ObjectPooler<Quad> quadBuf = new ObjectPooler<>(Quad::new);
private final List<Quad> collectedQuads = new ObjectArrayList<>();
private final ObjectPooler<QuadView> quadBuf = new ObjectPooler<>(Quad::new);
private final List<QuadView> collectedQuads = new ObjectArrayList<>();
// Any offset we need to the Tesselator's offset!
private final BlockPos offset = new BlockPos();
private final BlockPosImpl offset = new BlockPosImpl();
private final Vector3dStack storedTranslation = new Vector3dStack();
public void setOffset(BlockPos pos) {
public void setOffset(BlockPosImpl pos) {
this.offset.set(pos);
}
public void resetOffset() {
@@ -93,10 +94,10 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
for(int quadI = 0; quadI < this.vertexCount / verticesPerPrimitive; quadI++) {
final Quad quad = quadBuf.getInstance();
final QuadView quad = quadBuf.getInstance();
quad.setState(this.rawBuffer, quadI * (verticesPerPrimitive * 8), FLAGS, this.drawMode, -offset.x, -offset.y, -offset.z);
if(quad.deleted) {
if(quad.isDeleted()) {
quadBuf.releaseInstance(quad);
} else {
this.collectedQuads.add(quad);
@@ -115,7 +116,7 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
}
public List<Quad> getQuads() {
public List<QuadView> getQuads() {
return collectedQuads;
}
@@ -127,7 +128,7 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
this.collectedQuads.clear();
}
public static ByteBuffer quadsToBuffer(List<Quad> quads, VertexFormat format) {
public static ByteBuffer quadsToBuffer(List<QuadView> quads, VertexFormat format) {
if(!format.canWriteQuads()) {
throw new IllegalStateException("Vertex format has no quad writer: " + format);
}
@@ -0,0 +1,102 @@
package com.gtnewhorizons.angelica.common;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.models.json.JsonModel;
import com.gtnewhorizons.angelica.models.json.Loader;
import com.gtnewhorizons.angelica.models.json.Variant;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class BlockTest extends Block implements QuadProvider {
public static final Variant[] modelId = {
new Variant(
new ResourceLocation("blocks/lectern"),
0,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
180,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
90,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
270,
0,
false
),
};
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
private static final JsonModel[] model = new JsonModel[4];
public BlockTest() {
super(Material.rock);
}
public static void loadModel() {
for (int i = 0; i < 4; ++i)
model[i] = Loader.getModel(modelId[i]);
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public void registerBlockIcons(IIconRegister reg) {
reg.registerIcon("angelica:test_block");
reg.registerIcon("lectern_base");
reg.registerIcon("lectern_front");
reg.registerIcon("lectern_sides");
reg.registerIcon("lectern_top");
reg.registerIcon("oak_planks");
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
if (meta < 2 || meta > 5) meta = 2;
return (model[meta - 2] != null) ? model[meta - 2].getQuads(world, pos, block, meta, dir, random, color, quadPool) : EMPTY;
}
/**
* Called when a block is placed using its ItemBlock. Args: World, X, Y, Z, side, hitX, hitY, hitZ, block metadata
*/
@Override
public int onBlockPlaced(@NotNull World worldIn, int x, int y, int z, int side, float subX, float subY, float subZ, int meta) {
// Face NORTH if placed up or down
final ForgeDirection s = ForgeDirection.values()[side];
if (s == ForgeDirection.UP || s == ForgeDirection.DOWN)
return 2;
// Face the placed side
return side;
}
}
@@ -36,6 +36,10 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
copyNibbleArray((ExtendedNibbleArray) storage.getBlockMSBArray(), (ExtendedNibbleArray) this.getBlockMSBArray());
}
arrayLen = block16BArray.length;
if (ModStatus.isNEIDMetadataExtended) {
final short[] block16BMetaArray = ((IExtendedBlockStorageMixin)(Object)this).getBlock16BMetaArray();
System.arraycopy(((IExtendedBlockStorageMixin)(Object)storage).getBlock16BMetaArray(), 0, block16BMetaArray, 0, block16BMetaArray.length);
}
}
else if (ModStatus.isOldNEIDLoaded){
final short[] blockLSBArray = Hooks.get(this);
@@ -54,7 +58,7 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
}
copyNibbleArray((ExtendedNibbleArray) storage.getMetadataArray(), (ExtendedNibbleArray)this.getMetadataArray());
if (!ModStatus.isNEIDMetadataExtended) copyNibbleArray((ExtendedNibbleArray) storage.getMetadataArray(), (ExtendedNibbleArray)this.getMetadataArray());
copyNibbleArray((ExtendedNibbleArray) storage.getBlocklightArray(), (ExtendedNibbleArray)this.getBlocklightArray());
if(storage.getSkylightArray() != null) {
hasSky = true;
@@ -11,6 +11,8 @@ public class ModStatus {
* ASM Version
*/
public static boolean isOldNEIDLoaded;
public static boolean isNEIDMetadataExtended;
public static boolean isLotrLoaded;
public static boolean isChunkAPILoaded;
public static boolean isEIDBiomeLoaded;
@@ -21,5 +23,13 @@ public class ModStatus {
isLotrLoaded = Loader.isModLoaded("lotr");
isChunkAPILoaded = Loader.isModLoaded("chunkapi");
isEIDBiomeLoaded = Loader.isModLoaded("endlessids_biome");
isNEIDMetadataExtended = false;
if (isNEIDLoaded) {
int majorVersion = Integer.parseInt(Loader.instance().getIndexedModList().get("neid").getVersion().split("\\.")[0]);
if (majorVersion >= 2) {
isNEIDMetadataExtended = true;
}
}
}
}
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.compat.mojang;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
import net.minecraftforge.common.util.ForgeDirection;
public enum Axis {
X,
@@ -12,8 +13,39 @@ public enum Axis {
case DOWN, UP -> Y;
case NORTH, SOUTH -> Z;
case WEST, EAST -> X;
case UNASSIGNED -> null;
};
}
public static Axis fromDirection(ForgeDirection dir) {
return switch (dir) {
case DOWN, UP -> Y;
case NORTH, SOUTH -> Z;
case WEST, EAST -> X;
case UNKNOWN -> null;
};
}
public static Axis fromName(String dir) {
return switch (dir) {
case "y" -> Y;
case "z" -> Z;
case "x" -> X;
default -> null;
};
}
public enum Direction {
POSITIVE,
NEGATIVE;
public static Direction fromDirection(ForgeDirection dir) {
return switch (dir) {
case DOWN, NORTH, WEST -> NEGATIVE;
case UP, SOUTH, EAST -> POSITIVE;
case UNKNOWN -> null;
};
}
}
}
@@ -1,102 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3i;
import java.math.RoundingMode;
import static com.google.common.math.IntMath.log2;
// Should we keep this?
public class BlockPos extends Vector3i {
private static final int SIZE_BITS_X = 1 + log2(MathHelper.roundUpToPowerOfTwo(30000000), RoundingMode.UNNECESSARY);
private static final int SIZE_BITS_Z = SIZE_BITS_X;
private static final int SIZE_BITS_Y = 64 - SIZE_BITS_X - SIZE_BITS_Z;
private static final long BITS_X = (1L << SIZE_BITS_X) - 1L;
private static final long BITS_Y = (1L << SIZE_BITS_Y) - 1L;
private static final long BITS_Z = (1L << SIZE_BITS_Z) - 1L;
private static final int BIT_SHIFT_Z = SIZE_BITS_Y;
private static final int BIT_SHIFT_X = SIZE_BITS_Y + SIZE_BITS_Z;
public BlockPos() {
super();
}
public BlockPos(int x, int y, int z) {
super(x, y, z);
}
public BlockPos(ChunkPosition chunkPosition) {
super(chunkPosition.chunkPosX, chunkPosition.chunkPosY, chunkPosition.chunkPosZ);
}
public int getX() {
return this.x;
}
public int getY() {
return this.y;
}
public int getZ() {
return this.z;
}
public BlockPos set(int x, int y, int z) {
super.set(x, y, z);
return this;
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos offset(ForgeDirection d) {
return new BlockPos(this.x + d.offsetX, this.y + d.offsetY, this.z + d.offsetZ);
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos down() {
return offset(ForgeDirection.DOWN);
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos up() {
return offset(ForgeDirection.UP);
}
public long asLong() {
return asLong(this.x, this.y, this.z);
}
public static long asLong(int x, int y, int z) {
long l = 0L;
l |= ((long)x & BITS_X) << BIT_SHIFT_X;
l |= ((long)y & BITS_Y) << 0;
l |= ((long)z & BITS_Z) << BIT_SHIFT_Z;
return l;
}
public BlockPos set(long packedPos) {
return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
}
public static int unpackLongX(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);
}
public static int unpackLongY(long packedPos) {
return (int)(packedPos << 64 - SIZE_BITS_Y >> 64 - SIZE_BITS_Y);
}
public static int unpackLongZ(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_Z - SIZE_BITS_Z >> 64 - SIZE_BITS_Z);
}
public static class Mutable extends BlockPos {
}
}
@@ -0,0 +1,70 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.MutableBlockPos;
import net.minecraft.world.ChunkPosition;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3i;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongX;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongY;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongZ;
// Should we keep this?
public class BlockPosImpl extends Vector3i implements MutableBlockPos {
public BlockPosImpl() {
super();
}
public BlockPosImpl(int x, int y, int z) {
super(x, y, z);
}
public BlockPosImpl(ChunkPosition chunkPosition) {
super(chunkPosition.chunkPosX, chunkPosition.chunkPosY, chunkPosition.chunkPosZ);
}
@Override
public int getX() {
return this.x;
}
@Override
public int getY() {
return this.y;
}
@Override
public int getZ() {
return this.z;
}
@Override
public BlockPosImpl offset(ForgeDirection d) {
return new BlockPosImpl(this.x + d.offsetX, this.y + d.offsetY, this.z + d.offsetZ);
}
@Override
public BlockPosImpl down() {
return offset(ForgeDirection.DOWN);
}
@Override
public BlockPosImpl up() {
return offset(ForgeDirection.UP);
}
@Override
public long asLong() {
return BlockPos.asLong(this.x, this.y, this.z);
}
@Override
public BlockPosImpl set(int x, int y, int z) {
super.set(x, y, z);
return this;
}
@Override
public BlockPosImpl set(long packedPos) {
return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
}
}
@@ -13,7 +13,7 @@ import org.joml.Vector4f;
@Getter
public class Camera {
final Vector3d pos = new Vector3d();
final BlockPos.Mutable blockPos = new BlockPos.Mutable();
final BlockPosImpl blockPos = new BlockPosImpl();
float pitch;
float yaw;
EntityLivingBase entity;
@@ -36,12 +36,12 @@ public class ChunkOcclusionDataBuilder {
}
private int openCount = 4096;
public void markClosed(BlockPos pos) {
public void markClosed(BlockPosImpl pos) {
this.closed.set(pack(pos), true);
--this.openCount;
}
private static int pack(BlockPos pos) {
private static int pack(BlockPosImpl pos) {
return pack(pos.getX() & 15, pos.getY() & 15, pos.getZ() & 15);
}
@@ -12,7 +12,7 @@ public class ChunkPos {
this.z = z;
}
public ChunkPos(BlockPos pos) {
public ChunkPos(BlockPosImpl pos) {
this.x = pos.getX() >> 4;
this.z = pos.getZ() >> 4;
}
@@ -19,7 +19,7 @@ public class ChunkSectionPos extends Vector3i {
return new ChunkSectionPos(x, y, z);
}
public static ChunkSectionPos from(BlockPos pos) {
public static ChunkSectionPos from(BlockPosImpl pos) {
return new ChunkSectionPos(getSectionCoord(pos.getX()), getSectionCoord(pos.getY()), getSectionCoord(pos.getZ()));
}
@@ -35,10 +35,10 @@ public class ChunkSectionPos extends Vector3i {
return coord & 15;
}
public static short packLocal(BlockPos pos) {
int i = getLocalCoord(pos.x);
int j = getLocalCoord(pos.y);
int k = getLocalCoord(pos.z);
public static short packLocal(int x, int y, int z) {
final int i = getLocalCoord(x);
final int j = getLocalCoord(y);
final int k = getLocalCoord(z);
return (short)(i << 8 | k << 4 | j << 0);
}
@@ -1,8 +1,8 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import lombok.Getter;
@@ -79,7 +79,7 @@ public class VertexFormat {
return quadWriter != null;
}
public void writeQuad(Quad quad, ByteBuffer byteBuffer) {
public void writeQuad(QuadView quad, ByteBuffer byteBuffer) {
if(quadWriter == null) {
throw new IllegalStateException("No quad writer set");
}
@@ -1,7 +1,9 @@
package com.gtnewhorizons.angelica.compat.nd;
import com.gtnewhorizons.angelica.api.QuadView;
import java.nio.ByteBuffer;
public interface IWriteQuads {
void writeQuad(Quad quad, ByteBuffer buf);
void writeQuad(QuadView quad, ByteBuffer buf);
}
@@ -1,179 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3f;
import org.lwjgl.opengl.GL11;
import java.util.Locale;
public class Quad implements ModelQuadView {
// Adapted from Neodymium
private final static int DEFAULT_BRIGHTNESS = 15 << 20 | 15 << 4;
private final static int DEFAULT_COLOR = 0xFFFFFFFF;
public float[] xs = new float[4];
public float[] ys = new float[4];
public float[] zs = new float[4];
public float[] us = new float[4];
public float[] vs = new float[4];
public int[] cs = new int[4];
public int[] ns = new int[4];
public int[] bs = new int[4];
public boolean deleted;
public ModelQuadFacing normal;
private final Vector3f vectorA = new Vector3f(), vectorB = new Vector3f(), vectorC = new Vector3f();
private boolean hasColor;
private boolean hasShade;
private boolean hasNormals;
public boolean hasColor() {
return this.hasColor;
}
public int[] getColors() {
return this.cs;
}
public boolean hasShade() {
return this.hasShade;
}
public boolean hasNormals() {
return this.hasNormals;
}
public ForgeDirection getFace() {
// TODO: Sodium/Quad Facing
return ForgeDirection.UP;
}
@Override
public float getX(int idx) {
return xs[idx];
}
@Override
public float getY(int idx) {
return ys[idx];
}
@Override
public float getZ(int idx) {
return zs[idx];
}
@Override
public int getColor(int idx) {
return cs[idx];
}
@Override
public float getTexU(int idx) {
return us[idx];
}
@Override
public float getTexV(int idx) {
return vs[idx];
}
@Override
public int getFlags() {
return 0;
}
@Override
public int getLight(int idx) {
return bs[idx];
}
@Override
public int getNormal(int idx) {
return ns[idx];
}
@Override
public int getColorIndex() {
return 0;
}
@Override
public TextureAtlasSprite rubidium$getSprite() {
return null;
}
private void read(int[] rawBuffer, int offset, float offsetX, float offsetY, float offsetZ, int drawMode, BlockRenderer.Flags flags) {
final int vertices = drawMode == GL11.GL_TRIANGLES ? 3 : 4;
for(int vi = 0; vi < vertices; vi++) {
int i = offset + vi * 8;
xs[vi] = Float.intBitsToFloat(rawBuffer[i + 0]) + offsetX;
ys[vi] = Float.intBitsToFloat(rawBuffer[i + 1]) + offsetY;
zs[vi] = Float.intBitsToFloat(rawBuffer[i + 2]) + offsetZ;
us[vi] = Float.intBitsToFloat(rawBuffer[i + 3]);
vs[vi] = Float.intBitsToFloat(rawBuffer[i + 4]);
cs[vi] = flags.hasColor ? rawBuffer[i + 5] : DEFAULT_COLOR;
ns[vi] = flags.hasNormals ? rawBuffer[i + 6] : 0;
bs[vi] = flags.hasBrightness ? rawBuffer[i + 7] : DEFAULT_BRIGHTNESS;
this.hasColor = flags.hasColor;
this.hasShade = flags.hasBrightness;
this.hasNormals = flags.hasNormals;
i += 8;
}
if(vertices == 3) {
// Quadrangulate!
xs[3] = xs[2];
ys[3] = ys[2];
zs[3] = zs[2];
us[3] = us[2];
vs[3] = vs[2];
bs[3] = bs[2];
cs[3] = cs[2];
ns[3] = ns[2];
}
}
public void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ) {
deleted = false;
read(rawBuffer, offset, offsetX, offsetY, offsetZ, drawMode, flags);
if(xs[0] == xs[1] && xs[1] == xs[2] && xs[2] == xs[3] && ys[0] == ys[1] && ys[1] == ys[2] && ys[2] == ys[3]) {
// ignore empty quads (e.g. alpha pass of EnderIO item conduits)
deleted = true;
return;
}
vectorA.set(xs[1] - xs[0], ys[1] - ys[0], zs[1] - zs[0]);
vectorB.set(xs[2] - xs[1], ys[2] - ys[1], zs[2] - zs[1]);
vectorA.cross(vectorB, vectorC);
normal = ModelQuadFacing.fromVector(vectorC);
}
public static boolean isValid(Quad q) {
return q != null && !q.deleted;
}
@Override
public String toString() {
return String.format(Locale.ENGLISH, "%s[(%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f)]", deleted ? "XXX " : "", xs[0], ys[0], zs[0], xs[1], ys[1], zs[1], xs[2], ys[2], zs[2], xs[3], ys[3], zs[3]);
}
}
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class ItemVBOQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class ItemVBOQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionColorTextureQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionColorTextureQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionTextureColorQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionTextureColorQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionTextureQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionTextureQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,6 +1,8 @@
package com.gtnewhorizons.angelica.config;
@Config(modid = "angelica")
import com.gtnewhorizon.gtnhlib.config.Config;
@Config(modid = "angelica", filename = "angelica-modules")
public class AngelicaConfig {
@Config.Comment("Enable Sodium rendering")
@Config.DefaultBoolean(true)
@@ -16,14 +18,26 @@ public class AngelicaConfig {
@Config.RequiresMcRestart
public static boolean enableSodiumFluidRendering;
@Config.Comment("Inject QuadProvider rendering into some vanilla blocks")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
public static boolean injectQPRendering;
@Config.Comment("Enable Angelica's test blocks")
@Config.DefaultBoolean(false)
@Config.Ignore()
public static boolean enableTestBlocks;
@Config.Comment("Enable Iris Shaders [Requires Sodium]")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
@Config.Ignore()
public static boolean enableIris;
@Config.Comment("Enable MCPatcherForge features, still in Alpha. Individual features are toggled in mcpatcher.json")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
@Config.Ignore()
public static boolean enableMCPatcherForgeFeatures;
@Config.Comment("Enable NotFine optimizations")
@@ -1,5 +1,7 @@
package com.gtnewhorizons.angelica.config;
import com.gtnewhorizon.gtnhlib.config.ConfigException;
import com.gtnewhorizon.gtnhlib.config.SimpleGuiConfig;
import net.minecraft.client.gui.GuiScreen;
public class AngelicaGuiConfig extends SimpleGuiConfig {
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.config;
import com.gtnewhorizon.gtnhlib.config.SimpleGuiFactory;
import net.minecraft.client.gui.GuiScreen;
public class AngelicaGuiConfigFactory implements SimpleGuiFactory {
@@ -1,113 +0,0 @@
package com.gtnewhorizons.angelica.config;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Config {
/**
* The mod id that this configuration is associated with.
*/
String modid();
/**
* Root element category, defaults to "general". You must not specify an empty string.
*/
String category() default "general";
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@interface LangKey {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Comment {
String[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Ignore {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultBoolean {
boolean value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface RangeInt {
int min() default Integer.MIN_VALUE;
int max() default Integer.MAX_VALUE;
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultInt {
int value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface RangeFloat {
float min() default Float.MIN_VALUE;
float max() default Float.MAX_VALUE;
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultFloat {
float value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultString {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Pattern {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultEnum {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DefaultStringList {
String[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Name {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@interface RequiresMcRestart {
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@interface RequiresWorldRestart {
}
}
@@ -1,15 +0,0 @@
package com.gtnewhorizons.angelica.config;
/**
* A really basic wrapper for config to simplify handling them in external code.
*/
public class ConfigException extends Exception {
public ConfigException(String message) {
super(message);
}
public ConfigException(Throwable cause) {
super(cause);
}
}
@@ -1,267 +0,0 @@
package com.gtnewhorizons.angelica.config;
import cpw.mods.fml.client.config.IConfigElement;
import cpw.mods.fml.client.event.ConfigChangedEvent;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.SneakyThrows;
import lombok.val;
import net.minecraft.launchwrapper.Launch;
import net.minecraftforge.common.config.ConfigElement;
import net.minecraftforge.common.config.Configuration;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* Class for controlling the loading of configuration files.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ConfigurationManager {
private static final Logger LOGGER = LogManager.getLogger("ArchaicConfig");
private static final Map<String, Configuration> configs = new HashMap<>();
private static final Map<Configuration, Set<Class<?>>> configToClassMap = new HashMap<>();
private static final ConfigurationManager instance = new ConfigurationManager();
private static boolean initialized = false;
private static Path configDir;
/**
* Registers a configuration class to be loaded. This should be done in preInit.
*
* @param configClass The class to register.
*/
public static void registerConfig(Class<?> configClass) throws ConfigException {
init();
val cfg = Optional.ofNullable(configClass.getAnnotation(Config.class))
.orElseThrow(() -> new ConfigException(
"Class " + configClass.getName() + " does not have a @Config annotation!"));
val category = Optional.of(cfg.category().trim())
.map((cat) -> cat.length() == 0 ? null : cat)
.orElseThrow(() -> new ConfigException(
"Config class " + configClass.getName() + " has an empty category!"));
val rawConfig = configs.computeIfAbsent(cfg.modid(), (ignored) -> {
val c = new Configuration(configDir.resolve(cfg.modid() + ".cfg").toFile());
c.load();
return c;
});
configToClassMap.computeIfAbsent(rawConfig, (ignored) -> new HashSet<>()).add(configClass);
try {
processConfigInternal(configClass, category, rawConfig);
rawConfig.save();
} catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException | NoSuchFieldException e) {
throw new ConfigException(e);
}
}
private static void processConfigInternal(Class<?> configClass, String category, Configuration rawConfig)
throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException,
ConfigException {
val cat = rawConfig.getCategory(category);
for (val field : configClass.getDeclaredFields()) {
if (field.getAnnotation(Config.Ignore.class) != null) {
continue;
}
field.setAccessible(true);
val comment = Optional.ofNullable(field.getAnnotation(Config.Comment.class))
.map(Config.Comment::value)
.map((lines) -> String.join("\n", lines))
.orElse("");
val name = Optional.ofNullable(field.getAnnotation(Config.Name.class))
.map(Config.Name::value)
.orElse(field.getName());
val langKey = Optional.ofNullable(field.getAnnotation(Config.LangKey.class))
.map(Config.LangKey::value)
.orElse(name);
val fieldClass = field.getType();
var boxed = false;
if ((boxed = fieldClass.equals(Boolean.class)) || fieldClass.equals(boolean.class)) {
val defaultValue = Optional.ofNullable(field.getAnnotation(Config.DefaultBoolean.class))
.map(Config.DefaultBoolean::value)
.orElse(boxed ? (Boolean) field.get(null) : field.getBoolean(null));
field.setBoolean(null, rawConfig.getBoolean(name, category, defaultValue, comment, langKey));
} else if ((boxed = fieldClass.equals(Integer.class)) || fieldClass.equals(int.class)) {
val range = Optional.ofNullable(field.getAnnotation(Config.RangeInt.class));
val min = range.map(Config.RangeInt::min).orElse(Integer.MIN_VALUE);
val max = range.map(Config.RangeInt::max).orElse(Integer.MAX_VALUE);
val defaultValue = Optional.ofNullable(field.getAnnotation(Config.DefaultInt.class))
.map(Config.DefaultInt::value)
.orElse(boxed ? (Integer) field.get(null) : field.getInt(null));
field.setInt(null, rawConfig.getInt(name, category, defaultValue, min, max, comment, langKey));
} else if ((boxed = fieldClass.equals(Float.class)) || fieldClass.equals(float.class)) {
val range = Optional.ofNullable(field.getAnnotation(Config.RangeFloat.class));
val min = range.map(Config.RangeFloat::min).orElse(Float.MIN_VALUE);
val max = range.map(Config.RangeFloat::max).orElse(Float.MAX_VALUE);
val defaultValue = Optional.ofNullable(field.getAnnotation(Config.DefaultFloat.class))
.map(Config.DefaultFloat::value)
.orElse(boxed ? (Float) field.get(null) : field.getFloat(null));
field.setFloat(null, rawConfig.getFloat(name, category, defaultValue, min, max, comment, langKey));
} else if (fieldClass.equals(String.class)) {
val defaultValue = Optional.ofNullable(field.getAnnotation(Config.DefaultString.class))
.map(Config.DefaultString::value)
.orElse((String) field.get(null));
val pattern = Optional.ofNullable(field.getAnnotation(Config.Pattern.class))
.map(Config.Pattern::value)
.map(Pattern::compile)
.orElse(null);
field.set(null, rawConfig.getString(name, category, defaultValue, comment, langKey, pattern));
} else if (fieldClass.isEnum()) {
val enumValues = Arrays.stream((Object[]) fieldClass.getDeclaredMethod("values").invoke(null))
.map((obj) -> (Enum<?>) obj)
.collect(Collectors.toList());
val defaultValue = (Enum<?>) Optional.ofNullable(field.getAnnotation(Config.DefaultEnum.class))
.map(Config.DefaultEnum::value)
.map((defName) -> extractField(fieldClass, defName))
.map(ConfigurationManager::extractValue)
.orElse(field.get(null));
val possibleValues = enumValues.stream().map(Enum::name).toArray(String[]::new);
var value = rawConfig.getString(name,
category,
defaultValue.name(),
comment + "\nPossible values: " + Arrays.toString(possibleValues) +
"\n",
possibleValues,
langKey);
try {
if (!Arrays.asList(possibleValues).contains(value)) {
throw new NoSuchFieldException();
}
val enumField = fieldClass.getDeclaredField(value);
if (!enumField.isEnumConstant()) {
throw new NoSuchFieldException();
}
field.set(null, enumField.get(null));
} catch (NoSuchFieldException e) {
LOGGER
.warn("Invalid value " + value + " for enum configuration field " + field.getName() +
" of type " + fieldClass.getName() + " in config class " +
configClass.getName() + "! Using default value of " + defaultValue + "!");
field.set(null, defaultValue);
}
} else if (fieldClass.isArray() && fieldClass.getComponentType().equals(String.class)) {
val defaultValue = Optional.ofNullable(field.getAnnotation(Config.DefaultStringList.class)).map(Config.DefaultStringList::value).orElse((String[])field.get(null));
var value = rawConfig.getStringList(name, category, defaultValue, comment, null, langKey);
field.set(null, value);
} else {
throw new ConfigException("Illegal config field: " + field.getName() + " in " + configClass.getName() +
": Unsupported type " + fieldClass.getName() +
"! Did you forget an @Ignore annotation?");
}
if (field.isAnnotationPresent(Config.RequiresMcRestart.class)) {
cat.setRequiresMcRestart(true);
}
if (field.isAnnotationPresent(Config.RequiresWorldRestart.class)) {
cat.setRequiresWorldRestart(true);
}
}
}
@SneakyThrows
private static Field extractField(Class<?> clazz, String field) {
return clazz.getDeclaredField(field);
}
@SneakyThrows
private static Object extractValue(Field field) {
return field.get(null);
}
/**
* Process the configuration into a list of config elements usable in config GUI code.
*
* @param configClass The class to process.
*
* @return The configuration elements.
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public static List<IConfigElement> getConfigElements(Class<?> configClass) throws ConfigException {
init();
val cfg = Optional.ofNullable(configClass.getAnnotation(Config.class))
.orElseThrow(() -> new ConfigException(
"Class " + configClass.getName() + " does not have a @Config annotation!"));
val rawConfig = Optional.ofNullable(configs.get(cfg.modid()))
.map((conf) -> Optional.ofNullable(configToClassMap.get(conf))
.map((l) -> l.contains(configClass))
.orElse(false) ? conf : null)
.orElseThrow(() -> new ConfigException(
"Tried to get config elements for non-registered config class!"));
val category = cfg.category();
val elements = new ConfigElement<>(rawConfig.getCategory(category)).getChildElements();
return elements.stream().map((element) -> new IConfigElementProxy(element, () -> {
try {
processConfigInternal(configClass, category, rawConfig);
rawConfig.save();
} catch (IllegalAccessException |
NoSuchMethodException |
InvocationTargetException |
NoSuchFieldException |
ConfigException e) {
e.printStackTrace();
}
})).collect(Collectors.toList());
}
private static File minecraftHome() {
return Launch.minecraftHome != null ? Launch.minecraftHome : new File(".");
}
private static void init() {
if (initialized) {
return;
}
configDir = minecraftHome().toPath().resolve("config");
initialized = true;
}
/**
* Internal, do not use.
*/
public static void registerBus() {
FMLCommonHandler.instance().bus().register(instance);
}
/**
* Internal, do not use.
*
* @param event The event.
*/
@SubscribeEvent
public void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
init();
val config = configs.get(event.modID);
if (config == null) {
return;
}
val configClasses = configToClassMap.get(config);
configClasses.forEach((configClass) -> {
try {
val category = Optional.ofNullable(configClass.getAnnotation(Config.class))
.map(Config::category)
.orElseThrow(() -> new ConfigException(
"Failed to get config category for class " + configClass.getName()));
processConfigInternal(configClass, category, config);
} catch (Exception e) {
e.printStackTrace();
}
});
}
}
@@ -1,158 +0,0 @@
package com.gtnewhorizons.angelica.config;
import cpw.mods.fml.client.config.ConfigGuiType;
import cpw.mods.fml.client.config.GuiConfigEntries;
import cpw.mods.fml.client.config.GuiEditArrayEntries;
import cpw.mods.fml.client.config.IConfigElement;
import java.util.List;
import java.util.regex.Pattern;
public class IConfigElementProxy<T> implements IConfigElement<T> {
private final IConfigElement<T> proxied;
private final Runnable onUpdate;
public IConfigElementProxy(IConfigElement<T> proxied, Runnable onUpdate) {
this.proxied = proxied;
this.onUpdate = onUpdate;
}
@Override
public boolean isProperty() {
return proxied.isProperty();
}
@SuppressWarnings("rawtypes")
@Override
public Class<? extends GuiConfigEntries.IConfigEntry> getConfigEntryClass() {
return proxied.getConfigEntryClass();
}
@Override
public Class<? extends GuiEditArrayEntries.IArrayEntry> getArrayEntryClass() {
return proxied.getArrayEntryClass();
}
@Override
public String getName() {
return proxied.getName();
}
@Override
public String getQualifiedName() {
return proxied.getQualifiedName();
}
@Override
public String getLanguageKey() {
return proxied.getLanguageKey();
}
@Override
public String getComment() {
return proxied.getComment();
}
@SuppressWarnings("rawtypes")
@Override
public List<IConfigElement> getChildElements() {
return proxied.getChildElements();
}
@Override
public ConfigGuiType getType() {
return proxied.getType();
}
@Override
public boolean isList() {
return proxied.isList();
}
@Override
public boolean isListLengthFixed() {
return proxied.isListLengthFixed();
}
@Override
public int getMaxListLength() {
return proxied.getMaxListLength();
}
@Override
public boolean isDefault() {
return proxied.isDefault();
}
@Override
public Object getDefault() {
return proxied.getDefault();
}
@Override
public Object[] getDefaults() {
return proxied.getDefaults();
}
@Override
public void setToDefault() {
proxied.setToDefault();
}
@Override
public boolean requiresWorldRestart() {
return proxied.requiresWorldRestart();
}
@Override
public boolean showInGui() {
return proxied.showInGui();
}
@Override
public boolean requiresMcRestart() {
return proxied.requiresMcRestart();
}
@Override
public Object get() {
return proxied.get();
}
@Override
public Object[] getList() {
return proxied.getList();
}
@Override
public void set(T value) {
proxied.set(value);
onUpdate.run();
}
@Override
public void set(T[] aVal) {
proxied.set(aVal);
onUpdate.run();
}
@Override
public String[] getValidValues() {
return proxied.getValidValues();
}
@Override
public T getMinValue() {
return proxied.getMinValue();
}
@Override
public T getMaxValue() {
return proxied.getMaxValue();
}
@Override
public Pattern getValidationPattern() {
return proxied.getValidationPattern();
}
}
@@ -1,13 +0,0 @@
package com.gtnewhorizons.angelica.config;
import cpw.mods.fml.client.config.GuiConfig;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.client.gui.GuiScreen;
@SideOnly(Side.CLIENT)
public class SimpleGuiConfig extends GuiConfig {
public SimpleGuiConfig(GuiScreen parent, Class<?> configClass, String modID, String modName) throws ConfigException {
super(parent, ConfigurationManager.getConfigElements(configClass), modID, false, false, modName + " Configuration");
}
}
@@ -1,26 +0,0 @@
package com.gtnewhorizons.angelica.config;
import cpw.mods.fml.client.IModGuiFactory;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.client.Minecraft;
import java.util.Set;
@SideOnly(Side.CLIENT)
public interface SimpleGuiFactory extends IModGuiFactory {
@Override
default void initialize(Minecraft minecraftInstance) {
}
@Override
default Set<RuntimeOptionCategoryElement> runtimeGuiCategories() {
return null;
}
@Override
default RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
return null;
}
}
@@ -50,9 +50,8 @@ public class Feature {
// GL_COLOR_LOGIC_OP enable bit
// GL_INDEX_LOGIC_OP enable bit
// Logic op function
, GLStateManager.colorMask // Color mode and index mode writemasks
, GLStateManager.color // Color mode and index mode writemasks
, GLStateManager.clearColor // Color mode and index mode clear values
, GLStateManager.colorMask // Color-mode and index-mode writemasks
, GLStateManager.clearColor // Color-mode and index-mode clear values
));
attribToFeatures.put(GL11.GL_CURRENT_BIT, ImmutableSet.of(
GLStateManager.color // Current RGBA color
@@ -156,7 +155,7 @@ public class Feature {
// Ambient, diffuse, specular, and emissive color for each material
// Ambient, diffuse, and specular color indices for each material
// Specular exponent for each material
// GL_SHADE_MODEL setting
, GLStateManager.shadeModelState // GL_SHADE_MODEL setting
));
attribToFeatures.put(GL11.GL_LINE_BIT, ImmutableSet.of(
// GL_LINE_SMOOTH flag
@@ -219,11 +218,14 @@ public class Feature {
// Stencil buffer writemask
));
final Set<IStateStack<?>> textureAttribs = new HashSet<>(ImmutableSet.of(
GLStateManager.activeTextureUnit // Active texture unit
// Enable bits for the four texture coordinates
// Border color for each texture image
// Minification function for each texture image
// Magnification function for each texture image
// Texture coordinates and wrap mode for each texture image
// Color and mode for each texture environment
// Enable bits GL_TEXTURE_GEN_x, x is S, T, R, and Q
// GL_TEXTURE_GEN_MODE setting for S, T, R, and Q
@@ -234,9 +236,11 @@ public class Feature {
// Current Texture Bindings - GL_TEXTURE_BINDING_2D
for(int i = 0 ; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
textureAttribs.add(GLStateManager.textures.getTextureUnitBindings(i));
// textureAttribs.add(GLStateManager.textures.getInfo(i))
}
attribToFeatures.put(GL11.GL_TEXTURE_BIT, textureAttribs);
attribToFeatures.put(GL11.GL_TRANSFORM_BIT, ImmutableSet.of(
// Coefficients of the six clipping planes
// Enable bits for the user-definable clipping planes
@@ -10,6 +10,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.ColorMaskStack;
import com.gtnewhorizons.angelica.glsm.stacks.DepthStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.FogStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.IntegerStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
import com.gtnewhorizons.angelica.glsm.states.Color4;
@@ -73,6 +74,7 @@ import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
public class GLStateManager {
public static ContextCapabilities capabilities;
@Getter protected static boolean poppingAttributes;
public static boolean BYPASS_CACHE = Boolean.parseBoolean(System.getProperty("angelica.disableGlCache", "false"));
public static final int MAX_ATTRIB_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_ATTRIB_STACK_DEPTH);
public static final int MAX_MODELVIEW_STACK_DEPTH = GL11.glGetInteger(GL11.GL_MAX_MODELVIEW_STACK_DEPTH);
@@ -82,11 +84,19 @@ public class GLStateManager {
public static final GLFeatureSet HAS_MULTIPLE_SET = new GLFeatureSet();
@Getter protected static boolean NVIDIA;
@Getter protected static boolean AMD;
@Getter protected static boolean INTEL;
@Getter protected static boolean MESA;
// GLStateManager State Trackers
private static final IntStack attribs = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
private static final IntStack activeTextureUnit = new IntArrayList(MAX_ATTRIB_STACK_DEPTH);
protected static final IntegerStateStack activeTextureUnit = new IntegerStateStack();
protected static final IntegerStateStack shadeModelState = new IntegerStateStack();
static {
activeTextureUnit.push(0); // GL_TEXTURE0
activeTextureUnit.setValue(0); // GL_TEXTURE0
shadeModelState.setValue(GL11.GL_SMOOTH);
}
@Getter protected static final TextureUnitArray textures = new TextureUnitArray();
@Getter protected static final BlendStateStack blendState = new BlendStateStack();
@@ -99,7 +109,7 @@ public class GLStateManager {
@Getter protected static final FogStateStack fogState = new FogStateStack();
@Getter protected static final BooleanStateStack fogMode = new BooleanStateStack(GL11.GL_FOG);
@Getter protected static final Color4Stack color = new Color4Stack();
@Getter protected static final Color4Stack clearColor = new Color4Stack();
@Getter protected static final Color4Stack clearColor = new Color4Stack(new Color4(0.0F, 0.0F, 0.0F, 0.0F));
@Getter protected static final ColorMaskStack colorMask = new ColorMaskStack();
@Getter protected static final BooleanStateStack cullState = new BooleanStateStack(GL11.GL_CULL_FACE);
@Getter protected static final AlphaStateStack alphaState = new AlphaStateStack();
@@ -115,7 +125,6 @@ public class GLStateManager {
@Getter protected static final ViewPortStateStack viewportState = new ViewPortStateStack();
private static int modelShadeMode;
// Iris Listeners
private static Runnable blendFuncListener = null;
@@ -128,13 +137,15 @@ public class GLStateManager {
// Thread Checking
@Getter private static final Thread MainThread = Thread.currentThread();
private static Thread CurrentThread = MainThread;
@Setter @Getter private static boolean runningSplash = false;
@Setter @Getter private static boolean runningSplash = true;
private static int glListMode = 0;
private static int glListId = -1;
private static final Map<IStateStack<?>, ISettableState<?>> glListStates = new Object2ObjectArrayMap<>();
private static final Int2ObjectMap<Set<Map.Entry<IStateStack<?>, ISettableState<?>>>> glListChanges = new Int2ObjectOpenHashMap<>();
public static class GLFeatureSet extends IntOpenHashSet {
public GLFeatureSet addFeature(int feature) {
super.add(feature);
@@ -143,10 +154,11 @@ public class GLStateManager {
}
public static void init() {
public static void preInit() {
capabilities = GLContext.getCapabilities();
HAS_MULTIPLE_SET
.addFeature(GL11.GL_ACCUM_CLEAR_VALUE)
.addFeature(GL14.GL_BLEND_COLOR)
.addFeature(GL11.GL_COLOR_CLEAR_VALUE)
.addFeature(GL11.GL_COLOR_WRITEMASK)
.addFeature(GL11.GL_CURRENT_COLOR)
@@ -172,6 +184,22 @@ public class GLStateManager {
.addFeature(GL11.GL_TEXTURE_MATRIX)
.addFeature(GL11.GL_VIEWPORT);
String glVendor = GL11.glGetString(GL11.GL_VENDOR);
NVIDIA = glVendor.toLowerCase().contains("nvidia");
AMD = glVendor.toLowerCase().contains("ati") || glVendor.toLowerCase().contains("amd");
INTEL = glVendor.toLowerCase().contains("intel");
MESA = glVendor.toLowerCase().contains("mesa");
if(AMD) {
// AMD Drivers seem to default to 0 for the matrix mode, so we need to set it to the default
GL11.glMatrixMode(GL11.GL_MODELVIEW);
}
}
public static void init() {
RenderSystem.initRenderer();
if (AngelicaConfig.enableIris) {
@@ -239,6 +267,9 @@ public class GLStateManager {
}
public static boolean glIsEnabled(int cap) {
if(shouldBypassCache()) {
return GL11.glIsEnabled(cap);
}
return switch (cap) {
case GL11.GL_ALPHA_TEST -> alphaTest.isEnabled();
case GL11.GL_BLEND -> blendMode.isEnabled();
@@ -247,7 +278,7 @@ public class GLStateManager {
case GL11.GL_FOG -> fogMode.isEnabled();
case GL11.GL_LIGHTING -> lightingState.isEnabled();
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.topInt()).isEnabled();
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.getValue()).isEnabled();
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
default -> GL11.glIsEnabled(cap);
};
@@ -262,11 +293,11 @@ public class GLStateManager {
case GL11.GL_BLEND -> blendMode.isEnabled();
case GL11.GL_CULL_FACE -> cullState.isEnabled();
case GL11.GL_DEPTH_TEST -> depthTest.isEnabled();
case GL11.GL_DEPTH_WRITEMASK -> depthState.isMask();
case GL11.GL_DEPTH_WRITEMASK -> depthState.isEnabled();
case GL11.GL_FOG -> fogMode.isEnabled();
case GL11.GL_LIGHTING -> lightingState.isEnabled();
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.topInt()).isEnabled();
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.getValue()).isEnabled();
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
default -> GL11.glGetBoolean(pname);
};
@@ -305,6 +336,7 @@ public class GLStateManager {
case GL11.GL_DEPTH_FUNC -> depthState.getFunc();
case GL11.GL_LIST_MODE -> glListMode;
case GL11.GL_MATRIX_MODE -> matrixMode.getMode();
case GL11.GL_SHADE_MODEL -> shadeModelState.getValue();
case GL11.GL_TEXTURE_BINDING_2D -> getBoundTexture();
case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
@@ -333,6 +365,10 @@ public class GLStateManager {
}
}
public static void glGetLight(int light, int pname, FloatBuffer params) {
GL11.glGetLight(light, pname, params);
}
public static void glGetFloat(int pname, FloatBuffer params) {
if(shouldBypassCache()) {
GL11.glGetFloat(pname, params);
@@ -342,8 +378,9 @@ public class GLStateManager {
switch (pname) {
case GL11.GL_MODELVIEW_MATRIX -> modelViewMatrix.get(0, params);
case GL11.GL_PROJECTION_MATRIX -> projectionMatrix.get(0, params);
case GL11.GL_TEXTURE_MATRIX -> textures.getTextureUnitMatrix(getActiveTextureUnit()).get(0, params);
// case GL11.GL_TEXTURE_MATRIX -> textures.getTextureUnitMatrix(getActiveTextureUnit()).get(0, params);
case GL11.GL_COLOR_CLEAR_VALUE -> clearColor.get(params);
case GL11.GL_CURRENT_COLOR -> color.get(params);
default -> {
if(!HAS_MULTIPLE_SET.contains(pname)) {
params.put(0, glGetFloat(pname));
@@ -360,6 +397,10 @@ public class GLStateManager {
// GLStateManager Functions
public static void glBlendColor(float red, float green, float blue, float alpha) {
GL14.glBlendColor(red, green, blue, alpha);
}
public static void enableBlend() {
if (AngelicaConfig.enableIris) {
if (BlendModeStorage.isBlendLocked()) {
@@ -413,6 +454,14 @@ public class GLStateManager {
if (blendFuncListener != null) blendFuncListener.run();
}
public static void glBlendEquation(int mode) {
GL14.glBlendEquation(mode);
}
public static void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
GL20.glBlendEquationSeparate(modeRGB, modeAlpha);
}
public static void tryBlendFuncSeparate(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
if (AngelicaConfig.enableIris) {
if (BlendModeStorage.isBlendLocked()) {
@@ -437,6 +486,19 @@ public class GLStateManager {
if (blendFuncListener != null) blendFuncListener.run();
}
public static void glNormal3b(byte nx, byte ny, byte nz) {
GL11.glNormal3b(nx, ny, nz);
}
public static void glNormal3d(double nx, double ny, double nz) {
GL11.glNormal3d(nx, ny, nz);
}
public static void glNormal3f(float nx, float ny, float nz) {
GL11.glNormal3f(nx, ny, nz);
}
public static void glNormal3i(int nx, int ny, int nz) {
GL11.glNormal3i(nx, ny, nz);
}
public static void glDepthFunc(int func) {
if (shouldBypassCache() || func != depthState.getFunc() ) {
depthState.setFunc(func);
@@ -452,12 +514,16 @@ public class GLStateManager {
}
}
if (mask != depthState.isMask()) {
depthState.setMask(mask);
if (shouldBypassCache() || mask != depthState.isEnabled()) {
depthState.setEnabled(mask);
GL11.glDepthMask(mask);
}
}
public static void glEdgeFlag(boolean flag) {
GL11.glEdgeFlag(flag);
}
public static void glColor4f(float red, float green, float blue, float alpha) {
if (changeColor(red, green, blue, alpha)) {
GL11.glColor4f(red, green, blue, alpha);
@@ -559,6 +625,10 @@ public class GLStateManager {
}
}
public static void glClearDepth(double depth) {
GL11.glClearDepth(depth);
}
// ALPHA
public static void enableAlphaTest() {
if (AngelicaConfig.enableIris) {
@@ -596,8 +666,7 @@ public class GLStateManager {
public static void glActiveTexture(int texture) {
final int newTexture = texture - GL13.GL_TEXTURE0;
if (shouldBypassCache() || getActiveTextureUnit() != newTexture) {
activeTextureUnit.popInt();
activeTextureUnit.push(newTexture);
activeTextureUnit.setValue(newTexture);
GL13.glActiveTexture(texture);
}
}
@@ -605,14 +674,13 @@ public class GLStateManager {
public static void glActiveTextureARB(int texture) {
final int newTexture = texture - GL13.GL_TEXTURE0;
if (shouldBypassCache() || getActiveTextureUnit() != newTexture) {
activeTextureUnit.popInt();
activeTextureUnit.push(newTexture);
activeTextureUnit.setValue(newTexture);
ARBMultitexture.glActiveTextureARB(texture);
}
}
public static int getBoundTexture() {
return getBoundTexture(activeTextureUnit.topInt());
return getBoundTexture(activeTextureUnit.getValue());
}
public static int getBoundTexture(int unit) {
@@ -626,7 +694,7 @@ public class GLStateManager {
return;
}
final TextureBinding textureUnit = textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt());
final TextureBinding textureUnit = textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.getValue());
if (shouldBypassCache() || textureUnit.getBinding() != texture) {
GL11.glBindTexture(target, texture);
@@ -650,10 +718,34 @@ public class GLStateManager {
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_buffer_offset);
}
public static void glTexCoord1f(float s) {
GL11.glTexCoord1f(s);
}
public static void glTexCoord1d(double s) {
GL11.glTexCoord1d(s);
}
public static void glTexCoord2f(float s, float t) {
GL11.glTexCoord2f(s, t);
}
public static void glTexCoord2d(double s, double t) {
GL11.glTexCoord2d(s, t);
}
public static void glTexCoord3f(float s, float t, float r) {
GL11.glTexCoord3f(s, t, r);
}
public static void glTexCoord3d(double s, double t, double r) {
GL11.glTexCoord3d(s, t, r);
}
public static void glTexCoord4f(float s, float t, float r, float q) {
GL11.glTexCoord4f(s, t, r, q);
}
public static void glTexCoord4d(double s, double t, double r, double q) {
GL11.glTexCoord4d(s, t, r, q);
}
public static void glDeleteTextures(int id) {
onDeleteTexture(id);
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
GL11.glDeleteTextures(id);
}
@@ -662,7 +754,6 @@ public class GLStateManager {
onDeleteTexture(ids.get(i));
}
textures.getTextureUnitBindings(GLStateManager.activeTextureUnit.topInt()).setBinding(-1);
GL11.glDeleteTextures(ids);
}
@@ -712,6 +803,35 @@ public class GLStateManager {
textures.getTextureUnitStates(textureUnit).disable();
}
public static void glRasterPos2f(float x, float y) {
GL11.glRasterPos2f(x, y);
}
public static void glRasterPos2d(double x, double y) {
GL11.glRasterPos2d(x, y);
}
public static void glRasterPos2i(int x, int y) {
GL11.glRasterPos2i(x, y);
}
public static void glRasterPos3f(float x, float y, float z) {
GL11.glRasterPos3f(x, y, z);
}
public static void glRasterPos3d(double x, double y, double z) {
GL11.glRasterPos3d(x, y, z);
}
public static void glRasterPos3i(int x, int y, int z) {
GL11.glRasterPos3i(x, y, z);
}
public static void glRasterPos4f(float x, float y, float z, float w) {
GL11.glRasterPos4f(x, y, z, w);
}
public static void glRasterPos4d(double x, double y, double z, double w) {
GL11.glRasterPos4d(x, y, z, w);
}
public static void glRasterPos4i(int x, int y, int z, int w) {
GL11.glRasterPos4i(x, y, z, w);
}
public static void setFilter(boolean bilinear, boolean mipmap) {
int i, j;
if (bilinear) {
@@ -727,10 +847,20 @@ public class GLStateManager {
public static void glDrawArrays(int mode, int first, int count) {
// Iris -- TODO: This doesn't seem to work and is related to matchPass()
Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::syncProgram);
if(AngelicaConfig.enableIris) {
Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::syncProgram);
}
GL11.glDrawArrays(mode, first, count);
}
public static void glDrawBuffer(int mode) {
GL11.glDrawBuffer(mode);
}
public static void glLogicOp(int opcode) {
GL11.glLogicOp(opcode);
}
public static void defaultBlendFunc() {
tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
}
@@ -783,16 +913,20 @@ public class GLStateManager {
public static void glFog(int pname, FloatBuffer param) {
// TODO: Iris Notifier
GL11.glFog(pname, param);
if (pname == GL11.GL_FOG_COLOR) {
final float red = param.get(0);
final float green = param.get(1);
final float blue = param.get(2);
if (HAS_MULTIPLE_SET.contains(pname)) {
GL11.glFog(pname, param);
if (pname == GL11.GL_FOG_COLOR) {
final float red = param.get(0);
final float green = param.get(1);
final float blue = param.get(2);
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(param.get(3));
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put((FloatBuffer) param.position(0)).flip();
fogState.getFogColor().set(red, green, blue);
fogState.setFogAlpha(param.get(3));
fogState.getFogColorBuffer().clear();
fogState.getFogColorBuffer().put((FloatBuffer) param.position(0)).flip();
}
} else {
GLStateManager.glFogf(pname, param.get(0));
}
}
@@ -850,8 +984,8 @@ public class GLStateManager {
}
public static void glShadeModel(int mode) {
if (shouldBypassCache() || modelShadeMode != mode) {
modelShadeMode = mode;
if (shouldBypassCache() || shadeModelState.getValue() != mode) {
shadeModelState.setValue(mode);
GL11.glShadeModel(mode);
}
}
@@ -863,6 +997,12 @@ public class GLStateManager {
if (AngelicaConfig.enableIris) {
PBRTextureManager.INSTANCE.onDeleteTexture(id);
}
for(int i = 0; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
if(textures.getTextureUnitBindings(i).getBinding() == id) {
textures.getTextureUnitBindings(i).setBinding(0);
}
}
}
public static void makeCurrent(Drawable drawable) throws LWJGLException {
@@ -945,14 +1085,20 @@ public class GLStateManager {
}
}
public static void glClear(int mask) {
// TODO: Implement
GL11.glClear(mask);
}
public static void glPushAttrib(int mask) {
pushState(mask);
GL11.glPushAttrib(mask);
}
public static void glPopAttrib() {
poppingAttributes = true;
popState();
GL11.glPopAttrib();
poppingAttributes = false;
}
// Matrix Operations
@@ -962,6 +1108,13 @@ public class GLStateManager {
public static void glLoadMatrix(FloatBuffer m) {
getMatrixStack().set(m);
GL11.glLoadMatrix(m);
}
public static void glLoadMatrix(DoubleBuffer m) {
conersionMatrix4d.set(m);
getMatrixStack().set(conersionMatrix4d);
GL11.glLoadMatrix(m);
}
public static Matrix4fStack getMatrixStack() {
@@ -1081,7 +1234,7 @@ public class GLStateManager {
}
public static int getActiveTextureUnit() {
return activeTextureUnit.topInt();
return activeTextureUnit.getValue();
}
public static int getListMode() {
@@ -1235,4 +1388,32 @@ public class GLStateManager {
default -> GL11.glGetTexLevelParameteri(target, level, pname);
};
}
public static void glLight(int light, int pname, FloatBuffer params) {
GL11.glLight(light, pname, params);
}
public static void glLight(int light, int pname, IntBuffer params) {
GL11.glLight(light, pname, params);
}
public static void glLightModel(int pname, FloatBuffer params) {
GL11.glLightModel(pname, params);
}
public static void glLightModel(int pname, IntBuffer params) {
GL11.glLightModel(pname, params);
}
public static void glLightModelf(int pname, float param) {
GL11.glLightModelf(pname, param);
}
public static void glLightModeli(int pname, int param) {
GL11.glLightModeli(pname, param);
}
public static void glColorMaterial(int face, int mode) {
GL11.glColorMaterial(face, mode);
}
public static void glDepthRange(double near, double far) {
GL11.glDepthRange(near, far);
}
}
@@ -4,6 +4,8 @@ import com.gtnewhorizons.angelica.glsm.dsa.DSAARB;
import com.gtnewhorizons.angelica.glsm.dsa.DSAAccess;
import com.gtnewhorizons.angelica.glsm.dsa.DSACore;
import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3i;
@@ -21,12 +23,12 @@ import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
/**
* This class is responsible for abstracting calls to OpenGL and asserting that calls are run on the render thread.
*/
public class RenderSystem {
private static final Logger LOGGER = LogManager.getLogger("RenderSystem");
private static DSAAccess dsaState;
private static boolean hasMultibind;
private static boolean supportsCompute;
@@ -50,6 +52,7 @@ public class RenderSystem {
} catch (NoSuchFieldError ignored) {}
if (dsaState == null) {
dsaState = new DSAUnsupported();
LOGGER.info("No DSA support detected, falling back to legacy OpenGL.");
}
try {
@@ -1,16 +1,15 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.util.List;
import org.lwjgl.opengl.GL11;
@SuppressWarnings("unused")
public class TessellatorManager {
private static final ThreadLocal<CapturingTessellator> capturingTessellator = ThreadLocal.withInitial(CapturingTessellator::new);
@@ -51,7 +50,7 @@ public class TessellatorManager {
* Stop the CapturingTessellator and return the pooled quads. The quads are valid until clearQuads() is
* called on the CapturingTesselator, which must be done before starting capturing again.
*/
public static List<Quad> stopCapturingToPooledQuads() {
public static List<QuadView> stopCapturingToPooledQuads() {
if(!currentlyCapturing.get()) throw new IllegalStateException("Tried to stop capturing when not capturing!");
currentlyCapturing.set(false);
final CapturingTessellator tess = capturingTessellator.get();
@@ -59,7 +58,7 @@ public class TessellatorManager {
// Be sure we got all the quads
if(tess.isDrawing) tess.draw();
final List<Quad> quads = tess.getQuads();
final List<QuadView> quads = tess.getQuads();
tess.discard();
tess.restoreTranslation();
@@ -1,8 +1,8 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectList;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
public class VBOManager {
// Not thread safe, only expected to be called from the main thread
@@ -13,7 +13,7 @@ public class VBOManager {
return nextDisplayList++;
}
private static ObjectList<VertexBuffer> vertexBuffers = new ObjectArrayList<>(1);
private static Int2ObjectMap<VertexBuffer> vertexBuffers = new Int2ObjectOpenHashMap<>();
/*
* Allocate a (range) of "display list IDs" that will refer to a VBO in the arraylist of vertex buffers.
@@ -33,16 +33,13 @@ public class VBOManager {
public static VertexBuffer registerVBO(int displayList, VertexBuffer vertexBuffer) {
if(displayList > 0) throw new IllegalArgumentException("Display list must be negative!");
displayList -= Integer.MIN_VALUE;
final int requestedSize = displayList + 1;
if(requestedSize + 1 > vertexBuffers.size()) {
vertexBuffers.size(requestedSize);
}
vertexBuffers.set(displayList, vertexBuffer);
vertexBuffers.put(displayList, vertexBuffer);
return vertexBuffer;
}
public static VertexBuffer get(int list) {
list -= Integer.MIN_VALUE;
return vertexBuffers.get(list);
return vertexBuffers.getOrDefault(list, null);
}
}
@@ -32,12 +32,12 @@ public class OpenGLDebugging {
public class GLproperty {
public GLproperty(int init_gLconstant, String init_name, String init_description, String init_category, String init_fetchCommand) {
gLConstant = init_gLconstant;
name = init_name;
description = init_description;
category = init_category;
fetchCommand = init_fetchCommand;
public GLproperty(int glConstant, String name, String description, String category, String fetchCommand) {
this.gLConstant = glConstant;
this.name = name;
this.description = description;
this.category = category;
this.fetchCommand = fetchCommand;
}
public int gLConstant;
@@ -46,10 +46,9 @@ public class OpenGLDebugging {
public String category;
public String fetchCommand;
final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(16);
final IntBuffer intBuffer = BufferUtils.createIntBuffer(16);
final FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(16);
static final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(16);
static final IntBuffer intBuffer = BufferUtils.createIntBuffer(16);
static final FloatBuffer floatBuffer = BufferUtils.createFloatBuffer(16);
public String getAsString(boolean glsm) {
switch(fetchCommand) {
@@ -111,8 +110,8 @@ public class OpenGLDebugging {
}
}
final Matrix4f cachedMatrix = new Matrix4f();
final Matrix4f uncachedMatrix = new Matrix4f();
static final Matrix4f cachedMatrix = new Matrix4f();
static final Matrix4f uncachedMatrix = new Matrix4f();
public Matrix4f getAsMatrix4f(boolean glsm) {
if(!fetchCommand.equals(GL_GET_FLOATV)) {
throw new IllegalArgumentException("This property does not return a matrix");
@@ -403,25 +402,17 @@ public class OpenGLDebugging {
public static void dumpState(Consumer<String> printer, boolean glsm) {
for (int i = 0; i < instance.propertyList.length; ++i) {
final GLproperty gLproperty = instance.propertyList[i];
printer.accept(gLproperty.name + ":" + gLproperty.getAsString(glsm) + " (" + gLproperty.description + ")");
final GLproperty gLProperty = instance.propertyList[i];
printer.accept(gLProperty.name + ":" + gLProperty.getAsString(glsm) + " (" + gLProperty.description + ")");
}
}
public static void dumpIsEnabledToFile() {
dumpToFile(p -> dumpIsEnabled(p, false), "gl-dump-enabled.txt");
public static void dumpIsEnabledToFile(boolean glsm) {
dumpToFile(p -> dumpIsEnabled(p, glsm), (glsm ? "glsm" : "gl") + "-dump-enabled.txt");
}
public static void dumpIsEnabledGLSMToFile() {
dumpToFile(p -> dumpIsEnabled(p, true), "gl-dump-enabled.txt");
}
public static void dumpIsEnabled() {
dumpIsEnabled(LINE_LOGGER, false);
}
public static void dumpIsEnabledGLSM() {
dumpIsEnabled(LINE_LOGGER, true);
public static void dumpIsEnabled(boolean glsm) {
dumpIsEnabled(LINE_LOGGER, glsm);
}
public static void dumpIsEnabled(Consumer<String> printer, boolean glsm) {
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.BooleanState;
import org.lwjgl.opengl.GL11;
public class BooleanStateStack extends BooleanState implements IStateStack<BooleanStateStack> {
@@ -32,6 +33,9 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
}
set(stack[--pointer]);
if (GLStateManager.isAMD() && glCap == GL11.GL_BLEND) {
setEnabled(enabled);
}
return this;
}
@@ -16,6 +16,11 @@ public class Color4Stack extends Color4 implements IStateStack<Color4Stack> {
}
}
public Color4Stack(Color4 color4) {
this();
set(color4);
}
public Color4Stack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
@@ -0,0 +1,42 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.IntegerState;
public class IntegerStateStack extends IntegerState implements IStateStack<IntegerStateStack> {
protected final IntegerState[] stack;
protected int pointer;
public IntegerStateStack() {
stack = new IntegerState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new IntegerState();
}
}
public IntegerStateStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
public IntegerStateStack push(int value) {
push().setValue(value);
return this;
}
public IntegerStateStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
}
@@ -5,10 +5,9 @@ import lombok.Getter;
import org.lwjgl.opengl.GL11;
public class BooleanState implements ISettableState<BooleanState> {
private final int glCap;
protected final int glCap;
@Getter
private boolean enabled;
@Getter protected boolean enabled;
public BooleanState(int glCap) {
this.glCap = glCap;
@@ -23,7 +22,7 @@ public class BooleanState implements ISettableState<BooleanState> {
}
public void setEnabled(boolean enabled) {
if (GLStateManager.shouldBypassCache() || enabled != this.enabled) {
if (GLStateManager.shouldBypassCache() || enabled != this.enabled || (this.glCap == GL11.GL_BLEND && GLStateManager.isAMD() && GLStateManager.isPoppingAttributes())) {
this.enabled = enabled;
if (enabled) {
GL11.glEnable(this.glCap);
@@ -6,12 +6,12 @@ import org.lwjgl.opengl.GL11;
@Getter @Setter
public class DepthState implements ISettableState<DepthState> {
protected boolean mask = true;
protected boolean enabled = true;
protected int func = GL11.GL_LESS;
@Override
public DepthState set(DepthState state) {
this.mask = state.mask;
this.enabled = state.enabled;
this.func = state.func;
return this;
}
@@ -20,7 +20,7 @@ public class DepthState implements ISettableState<DepthState> {
public boolean sameAs(Object state) {
if (this == state) return true;
if (!(state instanceof DepthState depthState)) return false;
return mask == depthState.mask && func == depthState.func;
return enabled == depthState.enabled && func == depthState.func;
}
@Override
public DepthState copy() {
@@ -0,0 +1,26 @@
package com.gtnewhorizons.angelica.glsm.states;
import lombok.Getter;
import lombok.Setter;
public class IntegerState implements ISettableState<IntegerState> {
@Getter @Setter private int value;
@Override
public IntegerState set(IntegerState state) {
this.value = state.value;
return this;
}
@Override
public boolean sameAs(Object state) {
if (this == state) return true;
if (!(state instanceof IntegerState integerState)) return false;
return value == integerState.value;
}
@Override
public IntegerState copy() {
return new IntegerState().set(this);
}
}
@@ -3,6 +3,8 @@ package com.gtnewhorizons.angelica.hudcaching;
import java.util.ArrayList;
import java.util.List;
import cpw.mods.fml.common.eventhandler.EventPriority;
import net.minecraftforge.event.world.WorldEvent;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL30;
@@ -27,20 +29,18 @@ import net.minecraft.client.shader.Framebuffer;
import net.minecraft.util.ChatComponentText;
import net.minecraftforge.client.GuiIngameForge;
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
// See LICENSE+HUDCaching.md for license information.
public class HUDCaching {
private static final Minecraft mc = Minecraft.getMinecraft();
public static Framebuffer framebuffer;
static {
framebuffer = new Framebuffer(0, 0, true);
framebuffer.setFramebufferColor(0, 0, 0, 0);
}
private static boolean dirty = true;
public static boolean renderingCacheOverride;
/*
* Some HUD features cause problems/inaccuracies when being rendered into cache.
* We capture those and render them later
@@ -55,7 +55,7 @@ public class HUDCaching {
public static boolean renderCrosshairsCaptured;
public static final HUDCaching INSTANCE = new HUDCaching();
private HUDCaching() {}
@@ -63,13 +63,17 @@ public class HUDCaching {
private final List<Long> updateTimeList = new ArrayList<>(21);
private static boolean isEnabled = true;
private static final KeyBinding toggle = new KeyBinding("Toggle HUDCaching", 0, "Debug");
static {
// moved initialization to when its registered to avoid an empty Debug category, which can cause crashes when
// opening the controls menu and hudcaching is disabled in the config
private static KeyBinding toggle;
public static void registerKeyBindings() {
toggle = new KeyBinding("Toggle HUDCaching", 0, "Debug");
ClientRegistry.registerKeyBinding(toggle);
}
// @SubscribeEvent
// @SubscribeEvent
// public void onFrame(RenderGameOverlayEvent.Post event) {
// if (event.type == RenderGameOverlayEvent.ElementType.TEXT) {
// final long currentTimeMillis = System.currentTimeMillis();
@@ -86,7 +90,7 @@ public class HUDCaching {
@SubscribeEvent
public void onKeypress(InputEvent.KeyInputEvent event) {
if (toggle.isPressed()) {
if (toggle != null && toggle.isPressed()) {
isEnabled = !isEnabled;
final String msg = isEnabled ? "Enabled HUDCaching" : "Disabled HUDCaching";
if (mc.thePlayer != null) mc.thePlayer.addChatMessage(new ChatComponentText(msg));
@@ -102,10 +106,20 @@ public class HUDCaching {
}
}
// highest so it runs before the GLSM load event
@SubscribeEvent(priority = EventPriority.HIGH)
public void onJoinWorld(WorldEvent.Load event) {
if (event.world.isRemote){
LOGGER.info("World loaded - Initializing HUDCaching");
HUDCaching.framebuffer = new Framebuffer(0, 0, true);
HUDCaching.framebuffer.setFramebufferColor(0, 0, 0, 0);
}
}
@SuppressWarnings("unused")
public static void renderCachedHud(EntityRenderer renderer, GuiIngame ingame, float partialTicks, boolean hasScreen, int mouseX, int mouseY) {
if (!OpenGlHelper.isFramebufferEnabled() || !isEnabled) {
if (!OpenGlHelper.isFramebufferEnabled() || !isEnabled || framebuffer == null) {
ingame.renderGameOverlay(partialTicks, hasScreen, mouseX, mouseY);
return;
}
@@ -121,15 +135,15 @@ public class HUDCaching {
} else {
renderer.setupOverlayRendering();
}
ScaledResolution resolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
int width = resolution.getScaledWidth();
int height = resolution.getScaledHeight();
GLStateManager.enableBlend();
// reset the color that may be applied by some items
GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
// render bits that were captured when rendering into cache
GuiIngameAccessor gui = (GuiIngameAccessor) ingame;
if (renderVignetteCaptured)
@@ -138,7 +152,7 @@ public class HUDCaching {
} else {
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
}
if (ingame instanceof GuiIngameForge) {
GuiIngameForgeAccessor guiForge = ((GuiIngameForgeAccessor) ingame);
if (renderHelmetCaptured) {
@@ -168,11 +182,11 @@ public class HUDCaching {
GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
framebuffer.bindFramebufferTexture();
drawTexturedRect(tessellator, (float) resolution.getScaledWidth_double(), (float) resolution.getScaledHeight_double());
GLStateManager.tryBlendFuncSeparate(GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
mc.getTextureManager().bindTexture(Gui.icons);
}
/**
* We are skipping certain render calls when rendering into cache,
* however, we cannot skip the GL state changes. This will fix
@@ -1,13 +1,12 @@
package com.gtnewhorizons.angelica.loading;
import com.google.common.collect.ImmutableMap;
import com.gtnewhorizon.gtnhlib.config.ConfigException;
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
import com.gtnewhorizon.gtnhmixins.IEarlyMixinLoader;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.config.ConfigException;
import com.gtnewhorizons.angelica.config.ConfigurationManager;
import com.gtnewhorizons.angelica.mixins.Mixins;
import com.gtnewhorizons.angelica.mixins.TargetedMod;
import cpw.mods.fml.relauncher.FMLLaunchHandler;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
import mist475.mcpatcherforge.asm.AsmTransformers;
import mist475.mcpatcherforge.asm.mappings.Namer;
@@ -20,8 +19,6 @@ import org.apache.logging.log4j.core.config.LoggerConfig;
import org.spongepowered.asm.launch.GlobalProperties;
import org.spongepowered.asm.service.mojang.MixinServiceLaunchWrapper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -47,6 +44,15 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader {
loggerConfig.setLevel(Level.DEBUG);
}
ctx.updateLoggers();
// Too many bug reports because people refuse to read or just want to try it - so make these only able
// to be enabled by system properties for now.
AngelicaConfig.enableIris = Boolean.parseBoolean(System.getProperty("angelica.enableShaders", "false"));
AngelicaConfig.enableMCPatcherForgeFeatures = Boolean.parseBoolean(System.getProperty("angelica.enableMCPatcherForgeFeatures", "false"));
// Debug features
AngelicaConfig.enableTestBlocks = Boolean.parseBoolean(System.getProperty("angelica.enableTestBlocks", "false"));
} catch (ConfigException e) {
throw new RuntimeException(e);
}
@@ -21,13 +21,13 @@ public class MixinCompatHackTweaker implements ITweaker {
@Override
public void acceptOptions(List<String> args, File gameDir, File assetsDir, String profile) {
verifyDependencies();
if(DISABLE_OPTIFINE_AND_FASTCRAFT) {
LOGGER.info("Disabling Optifine and Fastcraft (if present)");
disableOptifineAndFastcraft();
}
}
private void verifyDependencies() {
if(MixinCompatHackTweaker.class.getResource("/it/unimi/dsi/fastutil/ints/Int2ObjectMap.class") == null) {
throw new RuntimeException("Missing dependency: Angelica requires GTNHLib 0.2.1 or newer! Download: https://modrinth.com/mod/gtnhlib");
@@ -82,8 +82,12 @@ public class MixinCompatHackTweaker implements ITweaker {
@Override
public String[] getLaunchArguments() {
if (FMLLaunchHandler.side().isClient()) {
// Run after Mixins, but before LWJGl3ify
Launch.classLoader.registerTransformer(RedirectorTransformer.class.getName());
final boolean rfbLoaded = Launch.blackboard.getOrDefault("angelica.rfbPluginLoaded", Boolean.FALSE) == Boolean.TRUE;
if (!rfbLoaded) {
// Run after Mixins, but before LWJGl3ify
Launch.classLoader.registerTransformer(RedirectorTransformer.class.getName());
}
if(AngelicaConfig.enableSodium) {
Launch.classLoader.registerTransformer(BlockTransformer.class.getName());
}
@@ -0,0 +1,28 @@
package com.gtnewhorizons.angelica.loading.rfb;
import com.gtnewhorizons.retrofuturabootstrap.api.PluginContext;
import com.gtnewhorizons.retrofuturabootstrap.api.RetroFuturaBootstrap;
import com.gtnewhorizons.retrofuturabootstrap.api.RfbClassTransformer;
import com.gtnewhorizons.retrofuturabootstrap.api.RfbPlugin;
import net.minecraft.launchwrapper.Launch;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class AngelicaRfbPlugin implements RfbPlugin {
@Override
public void onConstruction(@NotNull PluginContext ctx) {
Launch.blackboard.put("angelica.rfbPluginLoaded", Boolean.TRUE);
}
@Override
public @NotNull RfbClassTransformer @Nullable [] makeTransformers() {
final boolean isServer = (null == RetroFuturaBootstrap.API.launchClassLoader().findClassMetadata("net.minecraft.client.main.Main"));
if (isServer) {
return null;
}
return new RfbClassTransformer[] {
new RedirectorTransformerWrapper()
};
}
}
@@ -0,0 +1,61 @@
package com.gtnewhorizons.angelica.loading.rfb;
import com.gtnewhorizons.angelica.transform.RedirectorTransformer;
import com.gtnewhorizons.retrofuturabootstrap.api.ClassNodeHandle;
import com.gtnewhorizons.retrofuturabootstrap.api.ExtensibleClassLoader;
import com.gtnewhorizons.retrofuturabootstrap.api.RfbClassTransformer;
import org.intellij.lang.annotations.Pattern;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.jar.Manifest;
/** RFB wrapper for {@link com.gtnewhorizons.angelica.transform.RedirectorTransformer} */
public class RedirectorTransformerWrapper implements RfbClassTransformer {
public final RedirectorTransformer inner = new RedirectorTransformer();
@Pattern("[a-z0-9-]+")
@Override
public @NotNull String id() {
return "redirector";
}
@Override
public @NotNull String @Nullable [] sortAfter() {
return new String[] {"*", "mixin:mixin"};
}
@Override
public @NotNull String @Nullable [] sortBefore() {
return new String[] {"lwjgl3ify:redirect"};
}
@Override
public @NotNull String @Nullable [] additionalExclusions() {
return RedirectorTransformer.getTransformerExclusions().toArray(new String[0]);
}
@Override
public boolean shouldTransformClass(@NotNull ExtensibleClassLoader classLoader,
@NotNull RfbClassTransformer.Context context, @Nullable Manifest manifest, @NotNull String className,
@NotNull ClassNodeHandle classNode) {
if (!classNode.isPresent()) {
return false;
}
if (!classNode.isOriginal()) {
// If a class is already a transformed ClassNode, conservatively continue processing.
return true;
}
return inner.shouldRfbTransform(classNode.getOriginalBytes());
}
@Override
public void transformClass(@NotNull ExtensibleClassLoader classLoader, @NotNull RfbClassTransformer.Context context,
@Nullable Manifest manifest, @NotNull String className, @NotNull ClassNodeHandle classNode) {
final boolean changed = inner.transformClassNode(className, classNode.getNode());
if (changed) {
classNode.computeMaxs();
}
}
}
@@ -18,7 +18,6 @@ public enum Mixins {
ANGELICA_STARTUP(new Builder("Angelica Startup").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
.setPhase(Phase.EARLY).addMixinClasses(
"angelica.startup.MixinInitGLStateManager"
,"angelica.startup.MixinSplashProgress"
)
),
@@ -97,6 +96,7 @@ public enum Mixins {
,"sodium.MixinExtendedBlockStorage"
,"sodium.MixinEntityRenderer"
,"sodium.MixinFMLClientHandler"
,"sodium.MixinForgeHooksClient"
,"sodium.MixinGameSettings"
,"sodium.MixinFrustrum"
,"sodium.MixinMaterial"
@@ -106,6 +106,7 @@ public enum Mixins {
,"sodium.MixinRenderGlobal"
,"sodium.MixinWorldClient"
,"sodium.MixinTessellator"
,"sodium.MixinTileEntity"
,"sodium.MixinGuiIngameForge"
,"sodium.MixinEffectRenderer"
,"sodium.MixinTileEntityRendererDispatcher"
@@ -136,6 +137,7 @@ public enum Mixins {
,"shaders.MixinOpenGlHelper"
,"shaders.MixinRender"
,"shaders.MixinRenderGlobal"
,"shaders.MixinRenderManager"
)
),
@@ -214,8 +216,8 @@ public enum Mixins {
//,"notfine.clouds.MixinGameSettings"
//,"notfine.clouds.MixinRenderGlobal"
//,"notfine.clouds.MixinWorldType"
"notfine.glint.MixinRenderBiped"
,"notfine.glint.MixinRenderItem"
"notfine.fix.MixinRenderItem"
,"notfine.glint.MixinRenderBiped"
,"notfine.glint.MixinRenderPlayer"
,"notfine.gui.MixinGuiSlot"
,"notfine.leaves.MixinBlockLeaves"
@@ -225,7 +227,6 @@ public enum Mixins {
//,"notfine.particles.MixinWorldClient"
//,"notfine.particles.MixinWorldProvider"
,"notfine.renderer.MixinRenderGlobal"
,"notfine.settings.MixinGameSettings"
//,"notfine.toggle.MixinGuiIngame"
//,"notfine.toggle.MixinEntityRenderer"
//,"notfine.toggle.MixinRender" --> No Sodium below
@@ -241,8 +242,8 @@ public enum Mixins {
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableNotFineFeatures &&
!(AngelicaConfig.enableMCPatcherForgeFeatures && MCPatcherForgeConfig.instance().customItemTexturesEnabled)
).addMixinClasses(
"notfine.glint.MixinItemRenderer",
"notfine.glint.MixinRenderItemGlint"
"notfine.glint.MixinItemRenderer"
,"notfine.glint.MixinRenderItem"
)),
NOTFINE_LATE_TWILIGHT_FOREST_LEAVES(new Builder("NotFine Mod Leaves").addTargetedMod(TargetedMod.TWILIGHT_FOREST).setSide(Side.CLIENT)
@@ -453,6 +454,17 @@ public enum Mixins {
.addTargetedMod(TargetedMod.VANILLA)
.addMixinClasses("mcpatcherforge.ctm_cc.MixinTextureMap")),
NOVIS_OCULIS(new Builder("Non-Tessellator Quad provider")
.setSide(Side.CLIENT)
.setPhase(Phase.EARLY)
.setApplyIf(() -> AngelicaConfig.injectQPRendering)
.addTargetedMod(TargetedMod.VANILLA)
.addMixinClasses(
"angelica.models.MixinBlockStone",
"angelica.models.MixinBlockAir",
"angelica.models.MixinBlockWorkbench",
"angelica.models.MixinBlockLeaves")),
;
private final List<String> mixinClasses;
@@ -18,4 +18,9 @@ public class MixinChunkCache implements ITexturesCache {
public HashSet<IIcon> getRenderedTextures() {
return renderedIcons;
}
@Override
public void enableTextureTracking() {
}
}
@@ -28,6 +28,7 @@ public class MixinRenderBlocks implements ITexturesCache {
public IIcon overrideBlockTexture;
private Set<IIcon> renderedSprites = new ReferenceOpenHashSet<>();
private boolean enableSpriteTracking;
/**
* @author laetansky Here where things get very tricky. We can't just mark blocks textures for update because this
@@ -46,14 +47,17 @@ public class MixinRenderBlocks implements ITexturesCache {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
this.renderedSprites.add(icon);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
}
@Inject(method = "renderBlockFire", at = @At("HEAD"))
public void angelica$markFireBlockAnimationForUpdate(BlockFire instance, int x, int y, int z,
CallbackInfoReturnable<Boolean> cir) {
this.renderedSprites.add(instance.getFireIcon(0));
this.renderedSprites.add(instance.getFireIcon(1));
if(this.enableSpriteTracking) {
this.renderedSprites.add(instance.getFireIcon(0));
this.renderedSprites.add(instance.getFireIcon(1));
}
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(0), blockAccess);
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(1), blockAccess);
}
@@ -62,21 +66,28 @@ public class MixinRenderBlocks implements ITexturesCache {
public IIcon angelica$markFluidAnimationForUpdate(IIcon icon) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
this.renderedSprites.add(icon);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
return icon;
}
@Inject(method = "drawCrossedSquares", at = @At("HEAD"))
public void angelica$markCrossedSquaresAnimationForUpdate(IIcon icon, double p_147765_2_, double p_147765_4_, double p_147765_6_, float p_147765_8_,
CallbackInfo ci) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
this.renderedSprites.add(icon);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
}
@Override
public Set<IIcon> getRenderedTextures() {
return renderedSprites;
}
@Override
public void enableTextureTracking() {
enableSpriteTracking = true;
}
}
@@ -26,6 +26,7 @@ public class MixinWorldRenderer implements ITexturesCache {
@ModifyArg(method = "updateRenderer", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderBlocks;<init>(Lnet/minecraft/world/IBlockAccess;)V"))
private IBlockAccess angelica$onUpdateRenderer(IBlockAccess chunkCache) {
((ITexturesCache) chunkCache).enableTextureTracking();
renderedIcons = ((ITexturesCache) chunkCache).getRenderedTextures();
return chunkCache;
}
@@ -43,4 +44,9 @@ public class MixinWorldRenderer implements ITexturesCache {
public Set<IIcon> getRenderedTextures() {
return renderedIcons;
}
@Override
public void enableTextureTracking() {
}
}
@@ -0,0 +1,28 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import net.minecraft.block.Block;
import net.minecraft.block.BlockAir;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Unique;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockAir.class)
public abstract class MixinBlockAir implements QuadProvider {
@Unique
private static final List<QuadView> angelica$EMPTY = ObjectImmutableList.of();
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return angelica$EMPTY;
}
}
@@ -0,0 +1,35 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import net.minecraft.block.Block;
import net.minecraft.block.BlockLeaves;
import net.minecraft.block.material.Material;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import static com.gtnewhorizons.angelica.models.CubeModel.INSTANCE;
@Mixin(BlockLeaves.class)
public abstract class MixinBlockLeaves extends Block implements QuadProvider {
@Override
public boolean isDynamic() {
return true;
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return INSTANCE.get().getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
private MixinBlockLeaves(Material materialIn) {
super(materialIn);
}
}
@@ -0,0 +1,24 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.models.VanillaModels;
import net.minecraft.block.Block;
import net.minecraft.block.BlockStone;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockStone.class)
public abstract class MixinBlockStone implements QuadProvider {
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return VanillaModels.stoneModel.getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
}
@@ -0,0 +1,24 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.models.CubeModel;
import net.minecraft.block.Block;
import net.minecraft.block.BlockWorkbench;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockWorkbench.class)
public class MixinBlockWorkbench implements QuadProvider {
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return CubeModel.INSTANCE.get().getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
}
@@ -11,6 +11,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
public class MixinInitGLStateManager {
@Inject(method = "initializeTextures", at = @At("RETURN"))
private static void angelica$initializeGLStateManager(CallbackInfo ci) {
GLStateManager.preInit();
GLStateManager.init();
}
}
@@ -1,16 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.startup;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(targets="cpw/mods/fml/client/SplashProgress$3", remap = false)
public abstract class MixinSplashProgress {
@Inject(method = "setGL", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/locks/Lock;lock()V", shift = At.Shift.AFTER))
private void angelica$startSplash(CallbackInfo ci) {
GLStateManager.setRunningSplash(true);
}
}
@@ -10,7 +10,7 @@ public abstract class MixinGameSettings {
/**
* @author jss2a98aj
* @reason Make clouds drawScreen at any drawScreen distance.
* @reason Make clouds render at any render distance.
*/
@Overwrite
public boolean shouldRenderClouds() {
@@ -24,7 +24,7 @@ public abstract class MixinRenderGlobal {
/**
* @author jss2a98aj
* @reason Adjust how cloud drawScreen mode is selected.
* @reason Adjust how cloud render mode is selected.
*/
@Overwrite
public void renderClouds(float partialTicks) {
@@ -45,7 +45,7 @@ public abstract class MixinRenderGlobal {
/**
* @author jss2a98aj
* @reason Adjust fancy cloud drawScreen.
* @reason Adjust fancy cloud render.
*/
@Overwrite
public void renderCloudsFancy(float partialTicks) {
@@ -0,0 +1,66 @@
package com.gtnewhorizons.angelica.mixins.early.notfine.fix;
import jss.notfine.core.Settings;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.ItemStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(value = RenderItem.class)
public abstract class MixinRenderItem {
/**
* @author jss2a98aj
* @reason Makes renderGlint faster and fixes glBlendFunc being left with the wrong values.
*/
@Overwrite
private void renderGlint(int unused, int posX, int posY, int width, int height) {
if(!(boolean)Settings.MODE_GLINT_INV.option.getStore()) {
return;
}
final float timeUVSpeed = 0.00390625F;
final Tessellator tessellator = Tessellator.instance;
final long time = Minecraft.getSystemTime();
float layerUVNoise = 4.0F;
OpenGlHelper.glBlendFunc(772, 1, 0, 1);
//for(int layer = 0; layer < 2; ++layer) {
final int timeUVDenominator = 3000 /*+ layer * 1873*/;
final float timeUVNoise = (float)(time % (long)timeUVDenominator) / (float)timeUVDenominator * 256F;
tessellator.startDrawingQuads();
tessellator.addVertexWithUV(
posX, (posY + height), zLevel,
((timeUVNoise + (float)height * layerUVNoise) * timeUVSpeed), ((float)height * timeUVSpeed)
);
tessellator.addVertexWithUV(
(posX + width), (posY + height), zLevel,
((timeUVNoise + (float)width + (float)height * layerUVNoise) * timeUVSpeed), ((float)height * timeUVSpeed)
);
tessellator.addVertexWithUV(
(posX + width), posY, zLevel,
((timeUVNoise + (float)width) * timeUVSpeed), 0D
);
tessellator.addVertexWithUV(
posX, posY, zLevel,
(timeUVNoise * timeUVSpeed), 0D
);
tessellator.draw();
//layerUVNoise = -1.0F;
//}
OpenGlHelper.glBlendFunc(770, 771, 1, 0);
}
@Shadow public float zLevel;
}
@@ -1,63 +1,25 @@
package com.gtnewhorizons.angelica.mixins.early.notfine.glint;
import jss.notfine.core.Settings;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.ItemStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(value = RenderItem.class)
public abstract class MixinRenderItem {
/**
* @author jss2a98aj
* @reason Makes renderGlint faster and fixes glBlendFunc being left with the wrong values.
*/
@Overwrite
private void renderGlint(int unused, int posX, int posY, int width, int height) {
if(!(boolean)Settings.MODE_GLINT_INV.option.getStore()) {
return;
}
final float timeUVSpeed = 0.00390625F;
final Tessellator tessellator = Tessellator.instance;
final long time = Minecraft.getSystemTime();
float layerUVNoise = 4.0F;
OpenGlHelper.glBlendFunc(772, 1, 0, 1);
//for(int layer = 0; layer < 2; ++layer) {
final int timeUVDenominator = 3000 /*+ layer * 1873*/;
final float timeUVNoise = (float)(time % (long)timeUVDenominator) / (float)timeUVDenominator * 256F;
tessellator.startDrawingQuads();
tessellator.addVertexWithUV(
posX, (posY + height), zLevel,
((timeUVNoise + (float)height * layerUVNoise) * timeUVSpeed), ((float)height * timeUVSpeed)
);
tessellator.addVertexWithUV(
(posX + width), (posY + height), zLevel,
((timeUVNoise + (float)width + (float)height * layerUVNoise) * timeUVSpeed), ((float)height * timeUVSpeed)
);
tessellator.addVertexWithUV(
(posX + width), posY, zLevel,
((timeUVNoise + (float)width) * timeUVSpeed), 0D
);
tessellator.addVertexWithUV(
posX, posY, zLevel,
(timeUVNoise * timeUVSpeed), 0D
);
tessellator.draw();
//layerUVNoise = -1.0F;
//}
OpenGlHelper.glBlendFunc(770, 771, 1, 0);
@Redirect(
method = "renderDroppedItem(Lnet/minecraft/entity/item/EntityItem;Lnet/minecraft/util/IIcon;IFFFFI)V",
at = @At(
value = "INVOKE",
target = "Lnet/minecraft/item/ItemStack;hasEffect(I)Z"
),
remap = false
)
private boolean notFine$toggleGlint(ItemStack stack, int pass) {
return stack.hasEffect(pass) && (boolean)Settings.MODE_GLINT_WORLD.option.getStore();
}
@Shadow public float zLevel;
}
@@ -1,25 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.notfine.glint;
import jss.notfine.core.Settings;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.ItemStack;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
// Separated for compat with MCPF
@Mixin(RenderItem.class)
public class MixinRenderItemGlint {
@Redirect(
method = "renderDroppedItem(Lnet/minecraft/entity/item/EntityItem;Lnet/minecraft/util/IIcon;IFFFFI)V",
at = @At(
value = "INVOKE",
target = "Lnet/minecraft/item/ItemStack;hasEffect(I)Z"
),
remap = false
)
private boolean notFine$toggleGlint(ItemStack stack, int pass) {
return stack.hasEffect(pass) && (boolean) Settings.MODE_GLINT_WORLD.option.getStore();
}
}
@@ -10,7 +10,7 @@ public abstract class MixinEffectRenderer {
/**
* @author jss2a98aj
* @reason Makes most particles drawScreen with the expected depth.
* @reason Makes most particles render with the expected depth.
*/
@Redirect(
method = "renderParticles",
@@ -19,11 +19,9 @@ import com.llamalad7.mixinextras.injector.WrapWithCondition;
@Mixin(value = RenderGlobal.class)
public abstract class MixinRenderGlobal {
@Shadow private int glSkyList;
@Shadow private int starGLCallList;
@Shadow private int glSkyList2;
@WrapWithCondition(
method = "renderSky(F)V",
at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glCallList(I)V", remap = false))
@@ -34,42 +32,42 @@ public abstract class MixinRenderGlobal {
return (boolean)Settings.MODE_SKY.option.getStore();
}
}
@WrapWithCondition(
method = "renderSky(F)V",
at = @At(value = "INVOKE", target = "Lnet/minecraftforge/client/IRenderHandler;render(FLnet/minecraft/client/multiplayer/WorldClient;Lnet/minecraft/client/Minecraft;)V", remap = false))
private boolean conditionalRenderHandlerRender(IRenderHandler irh, float f, WorldClient wc, Minecraft mc) {
return (boolean)Settings.MODE_SKY.option.getStore();
}
@Inject(method="renderSky(F)V", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/Tessellator;draw()I", ordinal = 0))
private void conditionalTessellatorDrawEndSkybox(CallbackInfo ci) {
if(!(boolean)Settings.MODE_SKY.option.getStore()) {
Tessellator.instance.vertexCount = 0;
}
}
@Inject(method="renderSky(F)V", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/Tessellator;draw()I", ordinal = 1))
private void conditionalTessellatorDrawSunsetSunrise(CallbackInfo ci) {
if(!(boolean)Settings.MODE_SKY.option.getStore()) {
Tessellator.instance.vertexCount = 0;
}
}
@Inject(method="renderSky(F)V", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/Tessellator;draw()I", ordinal = 2))
private void conditionalTessellatorDrawSun(CallbackInfo ci) {
if(!(boolean)Settings.MODE_SUN_MOON.option.getStore()) {
Tessellator.instance.vertexCount = 0;
}
}
@Inject(method="renderSky(F)V", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/Tessellator;draw()I", ordinal = 3))
private void conditionalTessellatorDrawMoon(CallbackInfo ci) {
if(!(boolean)Settings.MODE_SUN_MOON.option.getStore()) {
Tessellator.instance.vertexCount = 0;
}
}
@Inject(method="renderSky(F)V", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/Tessellator;draw()I", ordinal = 4))
private void conditionalTessellatorDrawHorizon(CallbackInfo ci) {
if(!(boolean)Settings.MODE_SKY.option.getStore()) {
@@ -1,235 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.notfine.settings;
import jss.notfine.core.SettingsManager;
import net.minecraft.client.Minecraft;
import net.minecraft.client.settings.GameSettings;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.EnumDifficulty;
import org.lwjgl.opengl.Display;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
@Mixin(value = GameSettings.class, priority = 990)
public abstract class MixinGameSettings {
@Final
private static String[] GUISCALES = new String[] {
"options.guiScale.auto",
"options.guiScale.small",
"options.guiScale.normal",
"options.guiScale.large",
"options.guiScale.massive"
};
/**
* @author jss2a98aj
* @reason Makes this function not unreasonably slow.
*/
@Overwrite
public void setOptionFloatValue(GameSettings.Options option, float value) {
switch (option) {
case SENSITIVITY -> mouseSensitivity = value;
case FOV -> fovSetting = value;
case GAMMA -> gammaSetting = value;
case FRAMERATE_LIMIT -> limitFramerate = (int) value;
case CHAT_OPACITY -> {
chatOpacity = value;
mc.ingameGUI.getChatGUI().refreshChat();
}
case CHAT_HEIGHT_FOCUSED -> {
chatHeightFocused = value;
mc.ingameGUI.getChatGUI().refreshChat();
}
case CHAT_HEIGHT_UNFOCUSED -> {
chatHeightUnfocused = value;
mc.ingameGUI.getChatGUI().refreshChat();
}
case CHAT_WIDTH -> {
chatWidth = value;
mc.ingameGUI.getChatGUI().refreshChat();
}
case CHAT_SCALE -> {
chatScale = value;
mc.ingameGUI.getChatGUI().refreshChat();
}
case ANISOTROPIC_FILTERING -> {
if (anisotropicFiltering != (int) value) {
anisotropicFiltering = (int) value;
mc.getTextureMapBlocks().setAnisotropicFiltering(this.anisotropicFiltering);
mc.scheduleResourcesRefresh();
}
}
case MIPMAP_LEVELS -> {
if (mipmapLevels != (int) value) {
mipmapLevels = (int) value;
mc.getTextureMapBlocks().setMipmapLevels(this.mipmapLevels);
mc.scheduleResourcesRefresh();
}
}
case RENDER_DISTANCE -> renderDistanceChunks = (int) value;
case STREAM_BYTES_PER_PIXEL -> field_152400_J = value;
case STREAM_VOLUME_MIC -> {
field_152401_K = value;
mc.func_152346_Z().func_152915_s();
}
case STREAM_VOLUME_SYSTEM -> {
field_152402_L = value;
mc.func_152346_Z().func_152915_s();
}
case STREAM_KBPS -> field_152403_M = value;
case STREAM_FPS -> field_152404_N = value;
}
}
/**
* @author jss2a98aj
* @reason Makes this function not unreasonably slow.
*/
@Overwrite
public void setOptionValue(GameSettings.Options option, int value) {
switch(option) {
case INVERT_MOUSE:
invertMouse = !invertMouse;
break;
case GUI_SCALE:
guiScale = (guiScale + value) % 5;
break;
case PARTICLES:
particleSetting = (particleSetting + value) % 3;
break;
case VIEW_BOBBING:
viewBobbing = !viewBobbing;
break;
case RENDER_CLOUDS:
clouds = !clouds;
break;
case FORCE_UNICODE_FONT:
forceUnicodeFont = !forceUnicodeFont;
mc.fontRenderer.setUnicodeFlag(mc.getLanguageManager().isCurrentLocaleUnicode() || forceUnicodeFont);
break;
case ADVANCED_OPENGL:
advancedOpengl = !advancedOpengl;
mc.renderGlobal.loadRenderers();
case FBO_ENABLE:
fboEnable = !fboEnable;
break;
case ANAGLYPH:
anaglyph = !anaglyph;
//refreshResources was overkill.
mc.renderGlobal.loadRenderers();
break;
case DIFFICULTY:
difficulty = EnumDifficulty.getDifficultyEnum(difficulty.getDifficultyId() + value & 3);
break;
case GRAPHICS:
fancyGraphics = !fancyGraphics;
SettingsManager.graphicsUpdated();
mc.renderGlobal.loadRenderers();
break;
case AMBIENT_OCCLUSION:
ambientOcclusion = (ambientOcclusion + value) % 3;
mc.renderGlobal.loadRenderers();
break;
case CHAT_VISIBILITY:
chatVisibility = EntityPlayer.EnumChatVisibility.getEnumChatVisibility((chatVisibility.getChatVisibility() + value) % 3);
break;
case STREAM_COMPRESSION:
field_152405_O = (field_152405_O + value) % 3;
break;
case STREAM_SEND_METADATA:
field_152406_P = !field_152406_P;
break;
case STREAM_CHAT_ENABLED:
field_152408_R = (field_152408_R + value) % 3;
break;
case STREAM_CHAT_USER_FILTER:
field_152409_S = (field_152409_S + value) % 3;
break;
case STREAM_MIC_TOGGLE_BEHAVIOR:
field_152410_T = (field_152410_T + value) % 2;
break;
case CHAT_COLOR:
chatColours = !chatColours;
break;
case CHAT_LINKS:
chatLinks = !chatLinks;
break;
case CHAT_LINKS_PROMPT:
chatLinksPrompt = !chatLinksPrompt;
break;
case SNOOPER_ENABLED:
snooperEnabled = !snooperEnabled;
break;
case SHOW_CAPE:
showCape = !showCape;
break;
case TOUCHSCREEN:
touchscreen = !touchscreen;
break;
case USE_FULLSCREEN:
fullScreen = !fullScreen;
if (mc.isFullScreen() != fullScreen) {
mc.toggleFullscreen();
}
break;
case ENABLE_VSYNC:
enableVsync = !enableVsync;
Display.setVSyncEnabled(enableVsync);
break;
}
saveOptions();
}
@Shadow
public void saveOptions() {
}
@Shadow protected Minecraft mc;
@Shadow public float mouseSensitivity;
@Shadow public boolean invertMouse;
@Shadow public float fovSetting;
@Shadow public float gammaSetting;
@Shadow public int renderDistanceChunks;
@Shadow public int guiScale;
@Shadow public int particleSetting;
@Shadow public boolean viewBobbing;
@Shadow public boolean anaglyph;
@Shadow public boolean advancedOpengl;
@Shadow public int limitFramerate;
@Shadow public boolean fboEnable;
@Shadow public EnumDifficulty difficulty;
@Shadow public boolean fancyGraphics;
@Shadow public int ambientOcclusion;
@Shadow public boolean clouds;
@Shadow public EntityPlayer.EnumChatVisibility chatVisibility;
@Shadow public boolean chatColours;
@Shadow public boolean chatLinks;
@Shadow public boolean chatLinksPrompt;
@Shadow public float chatOpacity;
@Shadow public boolean snooperEnabled;
@Shadow public boolean fullScreen;
@Shadow public boolean enableVsync;
@Shadow public boolean showCape;
@Shadow public boolean touchscreen;
@Shadow public float chatHeightFocused;
@Shadow public float chatHeightUnfocused;
@Shadow public float chatScale;
@Shadow public float chatWidth;
@Shadow public int mipmapLevels;
@Shadow public int anisotropicFiltering;
@Shadow public float field_152400_J;
@Shadow public float field_152401_K;
@Shadow public float field_152402_L;
@Shadow public float field_152403_M;
@Shadow public float field_152404_N;
@Shadow public int field_152405_O;
@Shadow public boolean field_152406_P;
@Shadow public int field_152408_R;
@Shadow public int field_152409_S;
@Shadow public int field_152410_T;
@Shadow public boolean forceUnicodeFont;
}
@@ -8,7 +8,7 @@ import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(RenderItem.class)
@Mixin(value = RenderItem.class, priority = 1100)
abstract public class MixinRenderItem {
@Redirect(
@@ -0,0 +1,30 @@
package com.gtnewhorizons.angelica.mixins.early.shaders;
import net.coderbot.iris.layer.GbufferPrograms;
import net.coderbot.iris.uniforms.CapturedRenderingState;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(RenderManager.class)
public class MixinRenderManager {
@Unique
private static final String DO_RENDER = "Lnet/minecraft/client/renderer/entity/Render;doRender(Lnet/minecraft/entity/Entity;DDDFF)V";
@Inject(method = "func_147939_a", at = @At(value = "INVOKE", target = DO_RENDER))
private void iris$onRenderEntityPre(Entity entity, double x, double y, double z, float yaw, float partialTicks, boolean rebuild, CallbackInfoReturnable<Boolean> cir) {
CapturedRenderingState.INSTANCE.setCurrentEntity(entity.getEntityId());
GbufferPrograms.beginEntities();
}
@Inject(method = "func_147939_a", at = @At(value = "INVOKE", target = DO_RENDER, shift = At.Shift.AFTER))
private void iris$onRenderEntityPost(Entity entity, double x, double y, double z, float yaw, float partialTicks, boolean rebuild, CallbackInfoReturnable<Boolean> cir) {
CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
GbufferPrograms.endEntities();
}
}
@@ -0,0 +1,19 @@
package com.gtnewhorizons.angelica.mixins.early.sodium;
import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderManager;
import net.minecraftforge.client.ForgeHooksClient;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
@Mixin(value = ForgeHooksClient.class, remap = false)
public class MixinForgeHooksClient {
/**
* @author mitchej123
* @reason thread safe world render pass
*/
@Overwrite
public static int getWorldRenderPass() {
return ChunkRenderManager.getWorldRenderPass();
}
}
@@ -25,11 +25,6 @@ public class MixinMinecraft {
}
}
@Redirect(method="runGameLoop", at=@At(value="FIELD", target="Lnet/minecraft/client/renderer/WorldRenderer;chunksUpdated:I", ordinal=0))
private int sodium$chunksUpdated() {
return ((IRenderGlobalExt)this.renderGlobal).getChunksSubmitted();
}
@Redirect(method = "runGameLoop", at = @At(value = "FIELD", target = "Lnet/minecraft/client/settings/GameSettings;fancyGraphics:Z"))
private boolean sodium$overrideFancyGrass(GameSettings gameSettings) {
return SodiumClientMod.options().quality.grassQuality.isFancy();
@@ -60,11 +60,6 @@ public class MixinRenderGlobal implements IRenderGlobalExt {
this.renderer.scheduleTerrainUpdate();
}
@Override
public int getChunksSubmitted() {
return this.renderer.getChunksSubmitted();
}
@Inject(method="<init>", at=@At("RETURN"))
private void sodium$initRenderer(Minecraft mc, CallbackInfo ci) {
this.renderer = SodiumWorldRenderer.create(mc);
@@ -45,7 +45,7 @@ public class MixinRenderingRegistry implements IRenderingRegistryExt {
throw new RuntimeException(e.getCause());
}
});
} else if (mainThreadHandler.getClass().isInstance(ThreadSafeISBRHFactory.class)) {
} else if (ThreadSafeISBRHFactory.class.isAssignableFrom(mainThreadHandler.getClass())) {
return THREAD_LOCAL_MAP.get().computeIfAbsent(mainThreadHandler.getClass(), k -> ((ThreadSafeISBRHFactory) mainThreadHandler).newInstance());
}
}
@@ -0,0 +1,46 @@
package com.gtnewhorizons.angelica.mixins.early.sodium;
import net.minecraft.block.Block;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
@Mixin(TileEntity.class)
public class MixinTileEntity {
@Shadow private Block blockType;
@Shadow private int blockMetadata;
@Shadow World worldObj;
@Shadow int xCoord;
@Shadow int yCoord;
@Shadow int zCoord;
/**
* @author mitchej123
* @reason Make it atomic
*/
@Overwrite
public Block getBlockType() {
Block block = this.blockType;
if (block == null) {
this.blockType = block = this.worldObj.getBlock(this.xCoord, this.yCoord, this.zCoord);
}
return block;
}
/**
* @author mitchej123
* @reason Make it atomic
*/
@Overwrite
public int getBlockMetadata() {
int metadata = this.blockMetadata;
if (metadata == -1) {
this.blockMetadata = metadata = this.worldObj.getBlockMetadata(this.xCoord, this.yCoord, this.zCoord);
}
return metadata;
}
}
@@ -2,6 +2,5 @@ package com.gtnewhorizons.angelica.mixins.interfaces;
public interface IRenderGlobalExt {
void scheduleTerrainUpdate();
int getChunksSubmitted();
}
@@ -7,4 +7,5 @@ import java.util.Set;
public interface ITexturesCache {
Set<IIcon> getRenderedTextures();
void enableTextureTracking();
}
@@ -0,0 +1,54 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class CubeModel implements QuadProvider {
/*
* By the power of ~~theft~~ inspiration, this class is wayyy simpler.
* It's also a basic example of dynamic model building.
*/
public static final ThreadLocal<CubeModel> INSTANCE = ThreadLocal.withInitial(CubeModel::new);
private final NdQuadBuilder builder = new NdQuadBuilder();
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
private final List<QuadView> ONE = new ObjectArrayList<>(1);
public CubeModel() {
this.ONE.add(null);
}
@Override
public boolean isDynamic() {
return true;
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
if (dir == ForgeDirection.UNKNOWN)
return EMPTY;
this.builder.square(dir, 0, 0, 1, 1, 0);
final IIcon tex = block.getIcon(dir.ordinal(), meta);
this.builder.spriteBake(tex, NdQuadBuilder.BAKE_LOCK_UV);
this.builder.color(color, color, color, color);
ONE.set(0, this.builder.build(quadPool.get()));
return ONE;
}
}
@@ -0,0 +1,68 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3f;
import static me.jellysquid.mods.sodium.client.util.MathUtil.fuzzy_eq;
/**
* Static routines of general utility for renderer implementations.
* Renderers are not required to use these helpers, but they were
* designed to be usable without the default renderer.
*/
public abstract class GeometryHelper {
/**
* Returns true if quad is parallel to the given face.
* Does not validate quad winding order.
* Expects convex quads with all points co-planar.
*/
public static boolean isQuadParallelToFace(ForgeDirection face, NdQuadBuilder quad) {
int i = Axis.fromDirection(face).ordinal();
final float val = quad.posByIndex(0, i);
return fuzzy_eq(val, quad.posByIndex(1, i)) && fuzzy_eq(val, quad.posByIndex(2, i)) && fuzzy_eq(val, quad.posByIndex(3, i));
}
/**
* Identifies the face to which the quad is most closely aligned.
* This mimics the value that {@link Quad#getLightFace()} returns, and is
* used in the vanilla renderer for all diffuse lighting.
*
* <p>Derived from the quad face normal and expects convex quads with all points co-planar.
*/
public static ForgeDirection lightFace(NdQuadBuilder quad) {
final Vector3f normal = quad.faceNormal;
return switch (GeometryHelper.longestAxis(normal)) {
case X -> normal.x() > 0 ? ForgeDirection.EAST : ForgeDirection.WEST;
case Y -> normal.y() > 0 ? ForgeDirection.UP : ForgeDirection.DOWN;
case Z -> normal.z() > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
default -> ForgeDirection.UP; // handle WTF case
};
}
/**
* @see #longestAxis(float, float, float)
*/
public static Axis longestAxis(Vector3f vec) {
return longestAxis(vec.x(), vec.y(), vec.z());
}
/**
* Identifies the largest (max absolute magnitude) component (X, Y, Z) in the given vector.
*/
public static Axis longestAxis(float normalX, float normalY, float normalZ) {
Axis result = Axis.Y;
float longest = Math.abs(normalY);
float a = Math.abs(normalX);
if (a > longest) {
result = Axis.X;
longest = a;
}
return Math.abs(normalZ) > longest
? Axis.Z : result;
}
}
@@ -0,0 +1,208 @@
This package is licensed under the LGPLv3 for the general public, as noted in the main license file.
The original files were licensed under the Apache License, Version 2.0.
Copyright (c) 2016, 2017, 2018, 2019 FabricMC
Fabric may use this package under either the LGPLv3 or the Apache License, Version 2.0, reproduced below.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
@@ -0,0 +1,55 @@
package com.gtnewhorizons.angelica.models;
import org.antlr.v4.codegen.model.TestSetInline;
import java.util.BitSet;
public class Material {
/**
* The following masks control whether the property is enabled.
*/
// If true, renders face as fullbright
private static final int EMISSIVE_MASK = 1;
private static final int COLOR_MASK = 1 << 1;
// If true, uses diffuse shading/shadows
private static final int DIFFUSE_MASK = 1 << 2;
private static final int AO_MASK = 1 << 3;
// By default, quads use diffuse shading and AO
private static final int DEFAULTS = DIFFUSE_MASK | AO_MASK;
private int flags = DEFAULTS;
public void reset() {
this.flags = DEFAULTS;
}
private void setMask(int mask, boolean val) {
if (val)
this.flags |= mask;
else
this.flags &= ~mask;
}
private boolean getMask(int mask) {
return (this.flags & mask) == mask;
}
public void setAO(boolean val) {
this.setMask(AO_MASK, val);
}
public boolean getAO() {
return getMask(AO_MASK);
}
public void setDiffuse(boolean val) {
this.setMask(DIFFUSE_MASK, val);
}
public boolean getDiffuse() {
return getMask(DIFFUSE_MASK);
}
}
@@ -0,0 +1,462 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.api.QuadView;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFlags;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.joml.Vector3f;
import java.util.Arrays;
public class NdQuadBuilder implements ModelQuadView {
/**
* Causes texture to appear with no rotation.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_NONE = 0;
/**
* Causes texture to appear rotated 90 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_90 = 1;
/**
* Causes texture to appear rotated 180 deg. relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_180 = 2;
/**
* Causes texture to appear rotated 270 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_270 = 3;
/**
* When enabled, texture coordinate are assigned based on vertex position.
* Any existing UV coordinates will be replaced.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*
* <p>UV lock always derives texture coordinates based on nominal face, even
* when the quad is not co-planar with that face, and the result is
* the same as if the quad were projected onto the nominal face, which
* is usually the desired result.
*/
public static final int BAKE_LOCK_UV = 4;
/**
* When set, U texture coordinates for the given sprite are
* flipped as part of baking. Can be useful for some randomization
* and texture mapping scenarios. Results are different from what
* can be obtained via rotation and both can be applied.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_FLIP_U = 8;
/**
* Same as {@link #BAKE_FLIP_U} but for V coordinate.
*/
public static final int BAKE_FLIP_V = 16;
/**
* UV coordinates by default are assumed to be 0-16 scale for consistency
* with conventional Minecraft model format. This is scaled to 0-1 during
* baking before interpolation. Model loaders that already have 0-1 coordinates
* can avoid wasteful multiplication/division by passing 0-1 coordinates directly.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_NORMALIZED = 32;
/**
* Tolerance for determining if the depth parameter to {@link #square(ForgeDirection, float, float, float, float, float)}
* is effectively zero - meaning the face is a cull face.
*/
public static float CULL_FACE_EPSILON = 0.00001f;
private ForgeDirection cullFace = ForgeDirection.UNKNOWN;
private ForgeDirection nominalFace = ForgeDirection.UNKNOWN;
// Defaults to UP, but only because it can't be UNKNOWN or null
private ForgeDirection lightFace = ForgeDirection.UP;
// It's called a header, but because I'm lazy it's at the end
// The header is an int with flags -------- -------- -------- -GGGNNNN, then an int for the normal
private final int[] data = new int[Quad.QUAD_STRIDE];
private int geometryFlags = 0;
private boolean isGeometryInvalid = true;
private int tag = 0;
@Getter
private int colorIndex = -1;
final Vector3f faceNormal = new Vector3f();
public final Material mat = new Material();
/**
* Dumps to {@param out} and returns it.
*/
public QuadView build(QuadView out) {
// FRAPI does this late, but we need to do it before baking to Nd quads
this.computeGeometry();
out.setRaw(this.data, this.hasShade(), this.cullFace(), this.colorIndex, this.geometryFlags);
this.clear();
return out;
}
public void clear() {
Arrays.fill(this.data, 0);
this.cullFace = ForgeDirection.UNKNOWN;
this.nominalFace = ForgeDirection.UNKNOWN;
this.lightFace = ForgeDirection.UP;
this.geometryFlags = 0;
this.isGeometryInvalid = true;
this.tag(0);
this.colorIndex(-1);
this.mat.reset();
}
/**
* Set vertex color in ARGB format (0xAARRGGBB).
*/
public void color(int vertexIndex, int color) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.COLOR_INDEX] = color;
}
/**
* Convenience: set vertex color for all vertices at once.
*/
public void color(int c0, int c1, int c2, int c3) {
this.color(0, c0);
this.color(1, c1);
this.color(2, c2);
this.color(3, c3);
}
/**
* Value functions identically to {@link Quad#getColorIndex()} and is
* used by renderer / model builder in same way. Default value is -1.
*/
public void colorIndex(int colorIndex) {
this.colorIndex = colorIndex;
}
private void computeGeometry() {
if (this.isGeometryInvalid) {
this.isGeometryInvalid = false;
NormalHelper.computeFaceNormal(this.faceNormal, this);
// depends on face normal
this.lightFace = GeometryHelper.lightFace(this);
// depends on light face
this.geometryFlags = ModelQuadFlags.getQuadFlags(this);
}
}
/**
* If not {@link ForgeDirection#UNKNOWN}, quad should not be rendered in-world if the
* opposite face of a neighbor block occludes it.
*
* @see NdQuadBuilder#cullFace(ForgeDirection)
*/
public final ForgeDirection cullFace() {
return this.cullFace;
}
/**
* If not {@link ForgeDirection#UNKNOWN}, quad is coplanar with a block face which, if known, simplifies
* or shortcuts geometric analysis that might otherwise be needed.
* Set to {@link ForgeDirection#UNKNOWN} if quad is not coplanar or if this is not known.
* Also controls face culling during block rendering.
*
* <p>{@link ForgeDirection#UNKNOWN} by default.
*
* <p>When called with a non-{@link ForgeDirection#UNKNOWN} value, also sets {@link #nominalFace(ForgeDirection)}
* to the same value.
*
* <p>This is different from the value reported by {@link Quad#getLightFace()}. That value
* is computed based on face geometry and must be non-{@link ForgeDirection#UNKNOWN} in vanilla quads.
* That computed value is returned by {@link #getLightFace()}.
*/
public void cullFace(ForgeDirection dir) {
this.cullFace = dir;
this.nominalFace(dir);
}
private boolean hasShade() {
return this.mat.getDiffuse();
}
@Override
@NotNull
public ForgeDirection getLightFace() {
this.computeGeometry();
return this.lightFace;
}
/**
* Provides a hint to renderer about the facing of this quad. Not required,
* but if provided can shortcut some geometric analysis if the quad is parallel to a block face.
* Should be the expected value of {@link #getLightFace()}. Value will be confirmed
* and if invalid the correct light face will be calculated.
*
* <p>Null by default, and set automatically by {@link #cullFace(ForgeDirection)}.
*
* <p>Models may also find this useful as the face for texture UV locking and rotation semantics.
*
* <p>Note: This value is not persisted independently when the quad is encoded.
* When reading encoded quads, this value will always be the same as {@link #getLightFace()}.
*/
public void nominalFace(@Nullable ForgeDirection face) {
nominalFace = face;
}
/**
* See {@link #nominalFace(ForgeDirection)}
*/
public ForgeDirection nominalFace() {
return nominalFace;
}
/**
* Sets the geometric vertex position for the given vertex,
* relative to block origin, (0,0,0). Minecraft rendering is designed
* for models that fit within a single block space and is recommended
* that coordinates remain in the 0-1 range, with multi-block meshes
* split into multiple per-block models.
*/
public void pos(int vertexIndex, float x, float y, float z) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX] = Float.floatToRawIntBits(x);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX] = Float.floatToRawIntBits(y);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX] = Float.floatToRawIntBits(z);
isGeometryInvalid = true;
}
public Vector3f pos(int vertexIndex) {
return new Vector3f(
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX]),
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX]),
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX])
);
}
/**
* Convenience: access x, y, z by index 0-2.
*/
float posByIndex(int vertexIndex, int coordinateIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX + coordinateIndex]);
}
/**
* Convienence, gets the icon from the block atlas. See {@link #spriteBake(IIcon, int)}
*/
public void spriteBake(String spriteName, int bakeFlags) {
final IIcon icon = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(spriteName);
TexHelper.bakeSprite(this, icon, bakeFlags);
}
/**
* Assigns sprite atlas u,v coordinates to this quad for the given sprite.
* Can handle UV locking, rotation, interpolation, etc. Control this behavior
* by passing additive combinations of the BAKE_ flags defined in this interface.
*/
public void spriteBake(IIcon sprite, int bakeFlags) {
TexHelper.bakeSprite(this, sprite, bakeFlags);
}
/**
* Helper method to assign vertex coordinates for a square aligned with the given face.
* Ensures that vertex order is consistent with vanilla convention. (Incorrect order can
* lead to bad AO lighting unless enhanced lighting logic is available/enabled.)
*
* <p>Square will be parallel to the given face and coplanar with the face (and culled if the
* face is occluded) if the depth parameter is approximately zero. See {@link #CULL_FACE_EPSILON}.
*
* <p>All coordinates should be normalized (0-1).
*
* <p>The directions for the faces assume you're looking at them. For top and bottom, they assume you're looking north.
*/
public void square(ForgeDirection nominalFace, float left, float bottom, float right, float top, float depth) {
if (Math.abs(depth) < CULL_FACE_EPSILON) {
cullFace(nominalFace);
depth = 0; // avoid any inconsistency for face quads
} else {
cullFace(ForgeDirection.UNKNOWN);
}
nominalFace(nominalFace);
switch (nominalFace) {
case UP:
depth = 1 - depth;
top = 1 - top;
bottom = 1 - bottom;
case DOWN:
pos(0, left, depth, top);
pos(1, left, depth, bottom);
pos(2, right, depth, bottom);
pos(3, right, depth, top);
break;
case EAST:
depth = 1 - depth;
left = 1 - left;
right = 1 - right;
case WEST:
pos(0, depth, top, left);
pos(1, depth, bottom, left);
pos(2, depth, bottom, right);
pos(3, depth, top, right);
break;
case SOUTH:
depth = 1 - depth;
left = 1 - left;
right = 1 - right;
case NORTH:
pos(0, 1 - left, top, depth);
pos(1, 1 - left, bottom, depth);
pos(2, 1 - right, bottom, depth);
pos(3, 1 - right, top, depth);
break;
}
}
public int tag() {
return this.tag;
}
/**
* Encodes an integer tag with this quad that can later be retrieved via
* {@link NdQuadBuilder#tag()}. Useful for models that want to perform conditional
* transformation or filtering on static meshes.
*/
public void tag(int tag) {
this.tag = tag;
}
/**
* Set texture coordinates.
*/
public void uv(int vertexIndex, float u, float v) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.U_INDEX] = Float.floatToRawIntBits(u);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.V_INDEX] = Float.floatToRawIntBits(v);
}
@Override
public float getX(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX]);
}
@Override
public float getY(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX]);
}
@Override
public float getZ(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX]);
}
@Override
public float getTexU(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.U_INDEX]);
}
@Override
public float getTexV(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.V_INDEX]);
}
@Override
public int getColor(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.COLOR_INDEX];
}
@Override
public int getNormal(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.NORMAL_INDEX];
}
@Override
public int getLight(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.LIGHTMAP_INDEX];
}
@Override
public int getFlags() {
return this.geometryFlags;
}
@Override
public TextureAtlasSprite rubidium$getSprite() {
return null;
}
/**
* Modern Minecraft uses magic arrays to do this without breaking AO. This is the same thing, but without arrays.
*/
public static Vector3f mapSideToVertex(Vector3f from, Vector3f to, int index, ForgeDirection side) {
return switch (side) {
case DOWN -> switch (index) {
case 0 -> new Vector3f(from.x, from.y, to.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, from.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case UP -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, to.y, to.z);
case 2 -> new Vector3f(to.x, to.y, to.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case NORTH -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, from.z);
case 1 -> new Vector3f(to.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, from.z);
case 3 -> new Vector3f(from.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case SOUTH -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, to.z);
case 1 -> new Vector3f(from.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, to.z);
case 3 -> new Vector3f(to.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case WEST -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, to.z);
case 3 -> new Vector3f(from.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case EAST -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, to.z);
case 1 -> new Vector3f(to.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case UNKNOWN -> null;
};
}
}
@@ -0,0 +1,85 @@
package com.gtnewhorizons.angelica.models;
import net.minecraft.util.MathHelper;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
import org.joml.Vector3f;
import org.joml.Vector3i;
import static me.jellysquid.mods.sodium.common.util.DirectionUtil.STEP;
public class NormalHelper {
private static final float PACK = 127.0f;
private static final float UNPACK = 1.0f / PACK;
/**
* Computes the face normal of the given quad and saves it in the provided non-null vector.
* If {@link NdQuadBuilder#nominalFace()} is set will optimize by confirming quad is parallel to that
* face and, if so, use the standard normal for that face direction.
*
* <p>Will work with triangles also. Assumes counter-clockwise winding order, which is the norm.
* Expects convex quads with all points co-planar.
*/
public static void computeFaceNormal(@NotNull Vector3f saveTo, NdQuadBuilder q) {
final ForgeDirection nominalFace = q.nominalFace();
if (nominalFace != null && GeometryHelper.isQuadParallelToFace(nominalFace, q)) {
Vector3i vec = STEP[nominalFace.ordinal()];
saveTo.set(vec.x, vec.y, vec.z);
return;
}
final float x0 = q.getX(0);
final float y0 = q.getY(0);
final float z0 = q.getZ(0);
final float x1 = q.getX(1);
final float y1 = q.getY(1);
final float z1 = q.getZ(1);
final float x2 = q.getX(2);
final float y2 = q.getY(2);
final float z2 = q.getZ(2);
final float x3 = q.getX(3);
final float y3 = q.getY(3);
final float z3 = q.getZ(3);
final float dx0 = x2 - x0;
final float dy0 = y2 - y0;
final float dz0 = z2 - z0;
final float dx1 = x3 - x1;
final float dy1 = y3 - y1;
final float dz1 = z3 - z1;
float normX = dy0 * dz1 - dz0 * dy1;
float normY = dz0 * dx1 - dx0 * dz1;
float normZ = dx0 * dy1 - dy0 * dx1;
float l = (float) Math.sqrt(normX * normX + normY * normY + normZ * normZ);
if (l != 0) {
normX /= l;
normY /= l;
normZ /= l;
}
saveTo.set(normX, normY, normZ);
}
/**
* Like {@link #packNormal(float, float, float, float)}, but without a {@code w} value.
*/
public static int packNormal(float x, float y, float z) {
x = MathHelper.clamp_float(x, -1, 1);
y = MathHelper.clamp_float(y, -1, 1);
z = MathHelper.clamp_float(z, -1, 1);
return ((int) (x * PACK) & 0xFF) | (((int) (y * PACK) & 0xFF) << 8) | (((int) (z * PACK) & 0xFF) << 16);
}
/**
* Like {@link #packNormal(Vector3f, float)}, but without a {@code w} value.
*/
public static int packNormal(Vector3f normal) {
return packNormal(normal.x, normal.y, normal.z);
}
}
@@ -0,0 +1,86 @@
package com.gtnewhorizons.angelica.models;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
public class TexHelper {
private static final float NORMALIZER = 1f / 16f;
private static final VertexModifier[] UVLOCKERS = new VertexModifier[6];
static {
UVLOCKERS[ForgeDirection.EAST.ordinal()] = (q, i) -> q.uv(i, 1 - q.getZ(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.WEST.ordinal()] = (q, i) -> q.uv(i, q.getZ(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.NORTH.ordinal()] = (q, i) -> q.uv(i, 1 - q.getX(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.SOUTH.ordinal()] = (q, i) -> q.uv(i, q.getX(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.DOWN.ordinal()] = (q, i) -> q.uv(i, q.getX(i), 1 - q.getZ(i));
UVLOCKERS[ForgeDirection.UP.ordinal()] = (q, i) -> q.uv(i, q.getX(i), q.getZ(i));
}
private static final VertexModifier[] ROTATIONS = new VertexModifier[] {
null,
(q, i) -> q.uv(i, q.getTexV(i), 1 - q.getTexU(i)), //90
(q, i) -> q.uv(i, 1 - q.getTexU(i), 1 - q.getTexV(i)), //180
(q, i) -> q.uv(i, 1 - q.getTexV(i), q.getTexU(i)) // 270
};
private static void applyModifier(NdQuadBuilder quad, VertexModifier modifier) {
for (int i = 0; i < 4; i++) {
modifier.apply(quad, i);
}
}
/**
* Bakes textures in the provided vertex data, handling UV locking,
* rotation, interpolation, etc. Textures must not be already baked.
*/
public static void bakeSprite(NdQuadBuilder quad, IIcon sprite, int bakeFlags) {
if (quad.nominalFace() != ForgeDirection.UNKNOWN && (NdQuadBuilder.BAKE_LOCK_UV & bakeFlags) != 0) {
// Assigns normalized UV coordinates based on vertex positions
applyModifier(quad, UVLOCKERS[quad.nominalFace().ordinal()]);
} else if ((NdQuadBuilder.BAKE_NORMALIZED & bakeFlags) == 0) { // flag is NOT set, UVs are assumed to not be normalized yet as is the default, normalize through dividing by 16
// Scales from 0-16 to 0-1
applyModifier(quad, (q, i) -> q.uv(i, q.getTexU(i) * NORMALIZER, q.getTexV(i) * NORMALIZER));
}
final int rotation = bakeFlags & 3;
if (rotation != 0) {
// Rotates texture around the center of sprite.
// Assumes normalized coordinates.
applyModifier(quad, ROTATIONS[rotation]);
}
if ((NdQuadBuilder.BAKE_FLIP_U & bakeFlags) != 0) {
// Inverts U coordinates. Assumes normalized (0-1) values.
applyModifier(quad, (q, i) -> q.uv(i, 1 - q.getTexU(i), q.getTexV(i)));
}
if ((NdQuadBuilder.BAKE_FLIP_V & bakeFlags) != 0) {
// Inverts V coordinates. Assumes normalized (0-1) values.
applyModifier(quad, (q, i) -> q.uv(i, q.getTexU(i), 1 - q.getTexV(i)));
}
interpolate(quad, sprite);
}
/**
* Faster than sprite method. Sprite computes span and normalizes inputs each call,
* so we'd have to denormalize before we called, only to have the sprite renormalize immediately.
*/
private static void interpolate(NdQuadBuilder q, IIcon sprite) {
final float uMin = sprite.getMinU();
final float uSpan = sprite.getMaxU() - uMin;
final float vMin = sprite.getMinV();
final float vSpan = sprite.getMaxV() - vMin;
for (int i = 0; i < 4; i++) {
q.uv(i, uMin + q.getTexU(i) * uSpan, vMin + q.getTexV(i) * vSpan);
}
}
@FunctionalInterface
private interface VertexModifier {
void apply(NdQuadBuilder quad, int vertexIndex);
}
}
@@ -0,0 +1,22 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.models.json.JsonModel;
import com.gtnewhorizons.angelica.models.json.Loader;
import com.gtnewhorizons.angelica.models.json.Variant;
import net.minecraft.util.ResourceLocation;
public class VanillaModels {
public static final Variant stoneVariant = new Variant(
new ResourceLocation("blocks/stone"),
0,
0,
true
);
public static JsonModel stoneModel;
public static void loadModels() {
stoneModel = Loader.getModel(stoneVariant);
}
}
@@ -0,0 +1,365 @@
package com.gtnewhorizons.angelica.models.json;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.models.NdQuadBuilder;
import com.gtnewhorizons.angelica.utils.DirUtil;
import it.unimi.dsi.fastutil.Function;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import lombok.Getter;
import net.minecraft.block.Block;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
import org.joml.Vector4f;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Supplier;
import static com.gtnewhorizons.angelica.utils.JsonUtil.*;
import static me.jellysquid.mods.sodium.common.util.DirectionUtil.ALL_DIRECTIONS;
public class JsonModel implements QuadProvider {
@Nullable
private final ResourceLocation parentId;
@Nullable
private JsonModel parent;
@Getter
private final boolean useAO;
private final Map<ModelDisplay.Position, ModelDisplay> display;
private final Map<String, String> textures;
private List<ModelElement> elements;
private List<QuadView> allQuadStore = new ObjectArrayList<>();
private final Map<ForgeDirection, List<QuadView>> sidedQuadStore = new Object2ObjectOpenHashMap<>();
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
JsonModel(@Nullable ResourceLocation parentId, boolean useAO, Map<ModelDisplay.Position, ModelDisplay> display, Map<String, String> textures, List<ModelElement> elements) {
this.parentId = parentId;
this.useAO = useAO;
this.display = display;
this.textures = textures;
this.elements = elements;
}
/**
* Makes a shallow copy of og. This allows you to bake the same model multiple times with various transformations.
*/
JsonModel(JsonModel og) {
this.parentId = og.parentId;
this.parent = og.parent;
this.useAO = og.useAO;
this.display = og.display;
this.textures = og.textures;
this.elements = og.elements;
}
public void bake(Variant v) {
final Matrix4f vRot = v.getAffineMatrix();
final NdQuadBuilder builder = new NdQuadBuilder();
// Append faces from each element
for (ModelElement e : this.elements) {
final Matrix4f rot = (e.getRotation() == null)
? ModelElement.Rotation.NOOP.getAffineMatrix()
: e.getRotation().getAffineMatrix();
final Vector3f from = e.getFrom();
final Vector3f to = e.getTo();
for (ModelElement.Face f : e.getFaces()) {
// Assign vertexes
for (int i = 0; i < 4; ++i) {
final Vector3f vert =
rot.transformPosition(NdQuadBuilder.mapSideToVertex(from, to, i, f.getName()));
vRot.transformPosition(vert);
builder.pos(i, vert.x, vert.y, vert.z);
}
// Set culling and nominal faces
builder.cullFace(f.getCullFace());
builder.nominalFace(f.getName());
// Set bake flags
int flags = switch(f.getRotation()) {
case 90 -> NdQuadBuilder.BAKE_ROTATE_90;
case 180 -> NdQuadBuilder.BAKE_ROTATE_180;
case 270 -> NdQuadBuilder.BAKE_ROTATE_270;
default -> NdQuadBuilder.BAKE_ROTATE_NONE;
};
// Set UV
final Vector4f uv = f.getUv();
if (uv != null) {
builder.uv(0, uv.x, uv.y);
builder.uv(1, uv.x, uv.w);
builder.uv(2, uv.z, uv.w);
builder.uv(3, uv.z, uv.y);
} else {
// Not sure if this is correct, but it seems to fix things
flags |= NdQuadBuilder.BAKE_LOCK_UV;
}
// Set the sprite
builder.spriteBake(this.textures.get(f.getTexture()), flags);
// Set the tint index
final int tint = f.getTintIndex();
builder.color(tint, tint, tint, tint);
// Set AO
builder.mat.setAO(this.useAO);
// Bake and add it
final QuadView q = builder.build(new Quad());
this.allQuadStore.add(q);
this.sidedQuadStore.computeIfAbsent(f.getCullFace(),
o -> new ObjectArrayList<>()).add(q);
}
}
// Lock the lists.
this.allQuadStore = new ObjectImmutableList<>(this.allQuadStore);
for (ForgeDirection f : ALL_DIRECTIONS) {
List<QuadView> l = this.sidedQuadStore.computeIfAbsent(f, o -> EMPTY);
if (!l.isEmpty())
this.sidedQuadStore.put(f, new ObjectImmutableList<>(l));
}
}
public List<ResourceLocation> getParents() {
return Arrays.asList(parentId);
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return this.sidedQuadStore.getOrDefault(dir, EMPTY);
}
public void resolveParents(Function<ResourceLocation, JsonModel> modelLoader) {
if (this.parentId != null && this.parent == null) {
final JsonModel p = modelLoader.apply(this.parentId);
p.resolveParents(modelLoader);
// Inherit properties
this.parent = p;
if (this.elements.isEmpty()) this.elements = this.parent.elements;
// Resolve texture variables
// Add parent texture mappings, but prioritize ours.
for (Map.Entry<String, String> e : this.parent.textures.entrySet()) {
this.textures.putIfAbsent(e.getKey(), e.getValue());
}
// Flatten them, merging s -> s1, s1 -> s2 to s -> s2, s1 -> s2.
boolean flat = false;
final Map<String, String> tmp = new Object2ObjectOpenHashMap<>();
while (!flat) {
flat = true;
for (Map.Entry<String, String> e : this.textures.entrySet()) {
// If there is a value in the key set, replace with the value it points to
// Also avoid adding a loop
if (this.textures.containsKey(e.getValue())) {
if (!e.getKey().equals(e.getValue()))
tmp.put(e.getKey(), this.textures.get(e.getValue()));
else tmp.put(e.getKey(), "");
flat = false;
} else {
tmp.put(e.getKey(), e.getValue());
}
}
this.textures.putAll(tmp);
}
}
}
static class Deserializer implements JsonDeserializer<JsonModel> {
private Vector3f loadVec3(JsonObject in, String name) {
final JsonArray arr = in.getAsJsonArray(name);
final Vector3f ret = new Vector3f();
for (int i = 0; i < 3; ++i) {
ret.setComponent(i, arr.get(i).getAsFloat());
}
return ret;
}
private Vector4f loadVec4(JsonObject in, String name) {
final JsonArray arr = in.getAsJsonArray(name);
final Vector4f ret = new Vector4f();
for (int i = 0; i < 4; ++i) {
ret.setComponent(i, arr.get(i).getAsFloat());
}
return ret;
}
private ModelDisplay loadADisplay(JsonObject in) {
final Vector3f rotation = loadVec3(in, "rotation");
final Vector3f translation = loadVec3(in, "translation");
final Vector3f scale = loadVec3(in, "scale");
return new ModelDisplay(rotation, translation, scale);
}
private Map<ModelDisplay.Position, ModelDisplay> loadDisplay(JsonObject in) {
// wow such long
final Map<ModelDisplay.Position, ModelDisplay> ret = new Object2ObjectOpenHashMap<>(ModelDisplay.Position.values().length);
if (in.has("display")) {
final JsonObject display = in.getAsJsonObject("display");
for (Map.Entry<String, JsonElement> j : display.entrySet()) {
final String name = j.getKey();
final ModelDisplay.Position pos = ModelDisplay.Position.getByName(name);
ret.put(pos, loadADisplay(j.getValue().getAsJsonObject()));
}
}
for (ModelDisplay.Position p : ModelDisplay.Position.values()) {
ret.putIfAbsent(p, ModelDisplay.DEFAULT);
}
return ret;
}
private Map<String, String> loadTextures(JsonObject in) {
final Map<String, String> textures = new Object2ObjectOpenHashMap<>();
if (in.has("textures")) {
for (Map.Entry<String, JsonElement> e : in.getAsJsonObject("textures").entrySet()) {
// Trim leading octothorpes. They indicate a texture variable, but I don't actually care.
String s = e.getValue().getAsString();
if (s.startsWith("#")) s = s.substring(1);
textures.put(e.getKey(), s);
}
}
return textures;
}
private ModelElement.Rotation loadRotation(JsonObject in) {
if (in.has("rotation")) {
final JsonObject json = in.getAsJsonObject("rotation");
final Vector3f origin = loadVec3(json, "origin").div(16);
final Axis axis = Axis.fromName(loadStr(json, "axis"));
final float angle = loadFloat(json, "angle");
final boolean rescale = loadBool(json, "rescale", false);
return new ModelElement.Rotation(origin, axis, angle, rescale);
} else {
return null;
}
}
private List<ModelElement.Face> loadFaces(JsonObject in) {
final List<ModelElement.Face> ret = new ObjectArrayList<>();
final JsonObject json = in.getAsJsonObject("faces");
for (Map.Entry<String, JsonElement> e : json.entrySet()) {
final ForgeDirection side = DirUtil.fromName(e.getKey());
final JsonObject face = e.getValue().getAsJsonObject();
final Vector4f uv = (face.has("uv")) ? loadVec4(face, "uv") : null;
String texture = loadStr(face, "texture");
if (texture.startsWith("#")) texture = texture.substring(1);
final ForgeDirection cullFace = DirUtil.fromName(loadStr(face, "cullface", "unknown"));
final int rotation = loadInt(face, "rotation", 0);
final int tintIndex = loadInt(face, "tintindex", -1);
ret.add(new ModelElement.Face(side, uv, texture, cullFace, rotation, tintIndex));
}
return ret;
}
private List<ModelElement> loadElements(JsonObject in) {
final List<ModelElement> ret = new ObjectArrayList<>();
if (in.has("elements")) {
final JsonArray arr = in.getAsJsonArray("elements");
for (JsonElement e : arr) {
final JsonObject json = e.getAsJsonObject();
final Vector3f from = loadVec3(json, "from").div(16);
final Vector3f to = loadVec3(json, "to").div(16);
final ModelElement.Rotation rotation = loadRotation(json);
final boolean shade = loadBool(json, "shade", true);
final List<ModelElement.Face> faces = loadFaces(json);
ret.add(new ModelElement(from, to, rotation, shade, faces));
}
}
return ret;
}
@Override
public JsonModel deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
final JsonObject in = json.getAsJsonObject();
final String parent = loadStr(in, "parent", "");
final ResourceLocation parentId = (parent.isEmpty()) ? null : new ResourceLocation(parent);
final boolean useAO = loadBool(in, "ambientocclusion", true);
final Map<ModelDisplay.Position, ModelDisplay> display = loadDisplay(in);
final Map<String, String> textures = loadTextures(in);
final List<ModelElement> elements = loadElements(in);
return new JsonModel(parentId, useAO, display, textures, elements);
}
}
}
Loaded 100 of 185 files, more files were not shown because too many files have changed in this diff. Show more