From b5f36332ad93ac3afda1e3977ee3e11bb66d6e56 Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Tue, 23 Aug 2022 15:34:08 +0100 Subject: [PATCH] Make it build (#1) * Adapt to examplemod1.7.10 structure * Fix broken static imports * apply spotless * Update mcmod.info * Start work on ATs * More ATs * Compile stubs * Recursive compilation stubs to fix missing items in stubs * Stub out the tesselator * Switch to IFMLLoadingPlugin * Move the namer classes out of todo * Yeet ATs * Change transformers paths * spotless, remove MANIFEST.MF as it is no longer needed * Use MCF namer * Revert "spotless, remove MANIFEST.MF as it is no longer needed" This reverts commit 9be1abfe705f3dcb2d9bba6b0a648c0ee11eca5c. * Revert "Switch to IFMLLoadingPlugin" This reverts commit 089a01e14806f97dd5434a27a555b58c81af1390. * At least make it work for now * Dirty implementation of include preprocessing * spotlessApply (#6) Co-authored-by: GitHub GTNH Actions <> Co-authored-by: Vladislav Laetansky Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .editorconfig | 22 + .gitattributes | 35 + .github/scripts/update_version | 12 + .github/workflows/build-and-test.yml | 13 + .github/workflows/release-tags.yml | 14 + .gitignore | 32 + CODEOWNERS | 3 + LICENCE => LICENSE | 0 addon.gradle | 21 + build.gradle | 968 ++++ dependencies.gradle | 5 + gradle.properties | 84 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 55616 bytes gradle/wrapper/gradle-wrapper.properties | 5 + gradlew | 188 + gradlew.bat | 100 + .../shadersmodcore/client/DefaultTexture.java | 19 - java/shadersmodcore/client/GuiShaders.java | 355 -- .../shadersmodcore/client/GuiSlotShaders.java | 73 - java/shadersmodcore/client/MultiTexID.java | 17 - .../client/ShaderPackDefault.java | 18 - .../client/ShaderPackFolder.java | 38 - .../shadersmodcore/client/ShaderPackNone.java | 22 - java/shadersmodcore/client/ShaderPackZip.java | 65 - java/shadersmodcore/client/Shaders.java | 3871 ---------------- java/shadersmodcore/client/ShadersRender.java | 105 - java/shadersmodcore/client/ShadersTess.java | 279 -- java/shadersmodcore/client/ShadersTex.java | 969 ---- java/shadersmodcore/loading/SMCTweaker.java | 57 - java/shadersmodcore/transform/InitNames.java | 8 - java/shadersmodcore/transform/Namer.java | 43 - java/shadersmodcore/transform/NamerSrg.java | 205 - java/shadersmodcore/transform/Names.java | 256 -- java/shadersmodcore/transform/SMCCTBlock.java | 76 - .../transform/SMCCTEntityRenderer.java | 636 --- .../transform/SMCCTGuiOptions.java | 169 - .../transform/SMCCTItemBlock.java | 50 - .../transform/SMCCTItemRenderer.java | 118 - .../transform/SMCCTMinecraft.java | 99 - .../transform/SMCCTModelRenderer.java | 134 - .../transform/SMCCTOpenGlHelper.java | 96 - .../transform/SMCCTPrjRedIlluRenderHalo.java | 96 - .../shadersmodcore/transform/SMCCTRender.java | 82 - .../transform/SMCCTRenderBlocks.java | 388 -- .../transform/SMCCTRenderGlobal.java | 354 -- .../transform/SMCCTRenderManager.java | 60 - .../transform/SMCCTRenderSpider.java | 87 - .../transform/SMCCTRendererLivingEntity.java | 290 -- .../SMCCTSmartMoveModelRotationRenderer.java | 83 - .../transform/SMCCTTessellator.java | 464 -- .../transform/SMCCTTextureAbstract.java | 107 - .../transform/SMCCTTextureAtlasSprite.java | 191 - .../transform/SMCCTTextureClock.java | 62 - .../transform/SMCCTTextureCompass.java | 62 - .../transform/SMCCTTextureDownload.java | 95 - .../transform/SMCCTTextureDynamic.java | 117 - .../transform/SMCCTTextureLayered.java | 87 - .../transform/SMCCTTextureManager.java | 104 - .../transform/SMCCTTextureMap.java | 191 - .../transform/SMCCTTextureObject.java | 69 - .../transform/SMCCTTextureSimple.java | 89 - .../transform/SMCClassTransformer.java | 84 - java/shadersmodcore/transform/SMCLog.java | 105 - .../shadersmodcore/transform/InitNames.java | 8 - .../shadersmodcore/transform/Namer1_7_10.java | 205 - .../shadersmodcore/transform/Namer1_7_2.java | 183 - .../shadersmodcore/transform/Namer1_7_4.java | 191 - .../shadersmodcore/transform/Namer1_7_5.java | 191 - .../shadersmodcore/transform/NamerMcf.java | 16 - .../shadersmodcore/transform/NamerMcp.java | 129 - jitpack.yml | 2 + repositories.gradle | 5 + resources/META-INF/MANIFEST.MF | 3 - resources/mcmod.info | 17 - settings.gradle | 10 + .../net/minecraft/client/model/ModelBase.java | 7 + .../minecraft/client/model/ModelRenderer.java | 10 + .../client/renderer/EntityRenderer.java | 14 + .../client/renderer/RenderGlobal.java | 8 + .../client/renderer/Tessellator.java | 180 + .../client/renderer/WorldRenderer.java | 13 + .../client/renderer/culling/Frustrum.java | 6 + .../client/renderer/culling/ICamera.java | 3 + .../client/renderer/entity/Render.java | 3 + .../renderer/entity/RendererLivingEntity.java | 10 + .../renderer/texture/AbstractTexture.java | 17 + .../renderer/texture/DynamicTexture.java | 13 + .../renderer/texture/ITextureObject.java | 10 + .../renderer/texture/TextureAtlasSprite.java | 8 + .../client/renderer/texture/TextureMap.java | 18 + src/compileStubsStubs/README.MD | 1 + .../angelica/client/MultiTexID.java | 3 + .../client/shader/TesselatorVertexState.java | 3 + .../net/minecraft/util/ResourceLocation.java | 3 + .../java/com/gtnewhorizons/angelica/Tags.java | 12 + .../angelica/client/DefaultTexture.java | 16 + .../angelica/client/GuiShaders.java | 354 ++ .../angelica/client/GuiSlotShaders.java | 75 + .../angelica}/client/HFNoiseTexture.java | 156 +- .../angelica}/client/IShaderPack.java | 21 +- .../angelica/client/MultiTexID.java | 13 + .../angelica/client/ShaderPackDefault.java | 16 + .../angelica/client/ShaderPackFolder.java | 30 + .../angelica/client/ShaderPackNone.java | 16 + .../angelica/client/ShaderPackZip.java | 48 + .../angelica/client/Shaders.java | 3925 +++++++++++++++++ .../angelica/client/ShadersRender.java | 87 + .../angelica/client/ShadersTess.java | 243 + .../angelica/client/ShadersTex.java | 988 +++++ .../angelica/loading/SMCTweaker.java | 55 + .../angelica/transform/InitNames.java | 7 + .../angelica/transform/Namer.java | 45 + .../angelica/transform/Namer1_7_10.java | 209 + .../angelica/transform/NamerMcf.java | 9 + .../angelica/transform/NamerMcp.java | 118 + .../angelica/transform/NamerSrg.java | 216 + .../angelica/transform/Names.java | 266 ++ .../angelica/transform}/Names.txt | 334 +- .../angelica/transform/SMCCTBlock.java | 66 + .../transform/SMCCTEntityRenderer.java | 671 +++ .../angelica/transform/SMCCTGuiOptions.java | 181 + .../angelica/transform/SMCCTItemBlock.java | 47 + .../angelica/transform/SMCCTItemRenderer.java | 107 + .../angelica/transform/SMCCTMinecraft.java | 88 + .../transform/SMCCTModelRenderer.java | 149 + .../angelica/transform/SMCCTOpenGlHelper.java | 81 + .../transform/SMCCTPrjRedIlluRenderHalo.java | 90 + .../angelica/transform/SMCCTRender.java | 69 + .../angelica/transform/SMCCTRenderBlocks.java | 378 ++ .../angelica/transform/SMCCTRenderGlobal.java | 348 ++ .../transform/SMCCTRenderManager.java | 49 + .../angelica/transform/SMCCTRenderSpider.java | 71 + .../transform/SMCCTRendererLivingEntity.java | 273 ++ .../SMCCTSmartMoveModelRotationRenderer.java | 73 + .../angelica/transform/SMCCTTessellator.java | 476 ++ .../transform/SMCCTTextureAbstract.java | 110 + .../transform/SMCCTTextureAtlasSprite.java | 178 + .../angelica/transform/SMCCTTextureClock.java | 50 + .../transform/SMCCTTextureCompass.java | 50 + .../transform/SMCCTTextureDownload.java | 99 + .../transform/SMCCTTextureDynamic.java | 105 + .../transform/SMCCTTextureLayered.java | 82 + .../transform/SMCCTTextureManager.java | 92 + .../angelica/transform/SMCCTTextureMap.java | 196 + .../transform/SMCCTTextureObject.java | 63 + .../transform/SMCCTTextureSimple.java | 86 + .../transform/SMCClassTransformer.java | 67 + .../angelica/transform/SMCLog.java | 107 + src/main/resources/LICENSE | 173 + src/main/resources/mcmod.info | 17 + .../shadersmod-mcf.patch | 488 +- 151 files changed, 13774 insertions(+), 12502 deletions(-) create mode 100644 .editorconfig create mode 100644 .gitattributes create mode 100644 .github/scripts/update_version create mode 100644 .github/workflows/build-and-test.yml create mode 100644 .github/workflows/release-tags.yml create mode 100644 .gitignore create mode 100644 CODEOWNERS rename LICENCE => LICENSE (100%) create mode 100644 addon.gradle create mode 100644 build.gradle create mode 100644 dependencies.gradle create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100644 gradlew create mode 100644 gradlew.bat delete mode 100644 java/shadersmodcore/client/DefaultTexture.java delete mode 100644 java/shadersmodcore/client/GuiShaders.java delete mode 100644 java/shadersmodcore/client/GuiSlotShaders.java delete mode 100644 java/shadersmodcore/client/MultiTexID.java delete mode 100644 java/shadersmodcore/client/ShaderPackDefault.java delete mode 100644 java/shadersmodcore/client/ShaderPackFolder.java delete mode 100644 java/shadersmodcore/client/ShaderPackNone.java delete mode 100644 java/shadersmodcore/client/ShaderPackZip.java delete mode 100644 java/shadersmodcore/client/Shaders.java delete mode 100644 java/shadersmodcore/client/ShadersRender.java delete mode 100644 java/shadersmodcore/client/ShadersTess.java delete mode 100644 java/shadersmodcore/client/ShadersTex.java delete mode 100644 java/shadersmodcore/loading/SMCTweaker.java delete mode 100644 java/shadersmodcore/transform/InitNames.java delete mode 100644 java/shadersmodcore/transform/Namer.java delete mode 100644 java/shadersmodcore/transform/NamerSrg.java delete mode 100644 java/shadersmodcore/transform/Names.java delete mode 100644 java/shadersmodcore/transform/SMCCTBlock.java delete mode 100644 java/shadersmodcore/transform/SMCCTEntityRenderer.java delete mode 100644 java/shadersmodcore/transform/SMCCTGuiOptions.java delete mode 100644 java/shadersmodcore/transform/SMCCTItemBlock.java delete mode 100644 java/shadersmodcore/transform/SMCCTItemRenderer.java delete mode 100644 java/shadersmodcore/transform/SMCCTMinecraft.java delete mode 100644 java/shadersmodcore/transform/SMCCTModelRenderer.java delete mode 100644 java/shadersmodcore/transform/SMCCTOpenGlHelper.java delete mode 100644 java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java delete mode 100644 java/shadersmodcore/transform/SMCCTRender.java delete mode 100644 java/shadersmodcore/transform/SMCCTRenderBlocks.java delete mode 100644 java/shadersmodcore/transform/SMCCTRenderGlobal.java delete mode 100644 java/shadersmodcore/transform/SMCCTRenderManager.java delete mode 100644 java/shadersmodcore/transform/SMCCTRenderSpider.java delete mode 100644 java/shadersmodcore/transform/SMCCTRendererLivingEntity.java delete mode 100644 java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java delete mode 100644 java/shadersmodcore/transform/SMCCTTessellator.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureAbstract.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureClock.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureCompass.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureDownload.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureDynamic.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureLayered.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureManager.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureMap.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureObject.java delete mode 100644 java/shadersmodcore/transform/SMCCTTextureSimple.java delete mode 100644 java/shadersmodcore/transform/SMCClassTransformer.java delete mode 100644 java/shadersmodcore/transform/SMCLog.java delete mode 100644 java_dev/shadersmodcore/transform/InitNames.java delete mode 100644 java_dev/shadersmodcore/transform/Namer1_7_10.java delete mode 100644 java_dev/shadersmodcore/transform/Namer1_7_2.java delete mode 100644 java_dev/shadersmodcore/transform/Namer1_7_4.java delete mode 100644 java_dev/shadersmodcore/transform/Namer1_7_5.java delete mode 100644 java_dev/shadersmodcore/transform/NamerMcf.java delete mode 100644 java_dev/shadersmodcore/transform/NamerMcp.java create mode 100644 jitpack.yml create mode 100644 repositories.gradle delete mode 100644 resources/META-INF/MANIFEST.MF delete mode 100644 resources/mcmod.info create mode 100644 settings.gradle create mode 100644 src/compileStubs/java/net/minecraft/client/model/ModelBase.java create mode 100644 src/compileStubs/java/net/minecraft/client/model/ModelRenderer.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/EntityRenderer.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/RenderGlobal.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/Tessellator.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/WorldRenderer.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/culling/Frustrum.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/culling/ICamera.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/entity/Render.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/entity/RendererLivingEntity.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/texture/AbstractTexture.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/texture/DynamicTexture.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/texture/ITextureObject.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/texture/TextureAtlasSprite.java create mode 100644 src/compileStubs/java/net/minecraft/client/renderer/texture/TextureMap.java create mode 100644 src/compileStubsStubs/README.MD create mode 100644 src/compileStubsStubs/java/com/gtnewhorizons/angelica/client/MultiTexID.java create mode 100644 src/compileStubsStubs/java/net/minecraft/client/shader/TesselatorVertexState.java create mode 100644 src/compileStubsStubs/java/net/minecraft/util/ResourceLocation.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/Tags.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/DefaultTexture.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/GuiShaders.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/GuiSlotShaders.java rename {java/shadersmodcore => src/main/java/com/gtnewhorizons/angelica}/client/HFNoiseTexture.java (52%) rename {java/shadersmodcore => src/main/java/com/gtnewhorizons/angelica}/client/IShaderPack.java (71%) create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/MultiTexID.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShaderPackDefault.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShaderPackFolder.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShaderPackNone.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShaderPackZip.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/Shaders.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShadersRender.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShadersTess.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/client/ShadersTex.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/loading/SMCTweaker.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/InitNames.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/Namer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/Namer1_7_10.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/NamerMcf.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/NamerMcp.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/NamerSrg.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/Names.java rename {java_dev/shadersmodcore/devel => src/main/java/com/gtnewhorizons/angelica/transform}/Names.txt (75%) create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTBlock.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTEntityRenderer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTGuiOptions.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemBlock.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemRenderer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTMinecraft.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTModelRenderer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTOpenGlHelper.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTPrjRedIlluRenderHalo.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRender.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderBlocks.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderGlobal.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderManager.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderSpider.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRendererLivingEntity.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTSmartMoveModelRotationRenderer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTessellator.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAbstract.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAtlasSprite.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureClock.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureCompass.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDownload.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDynamic.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureLayered.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureManager.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureMap.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureObject.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureSimple.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCClassTransformer.java create mode 100644 src/main/java/com/gtnewhorizons/angelica/transform/SMCLog.java create mode 100644 src/main/resources/LICENSE create mode 100644 src/main/resources/mcmod.info rename shadersmod-mcf.patch => todo/shadersmod-mcf.patch (86%) diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 000000000..4ffbd9082 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,22 @@ +# This is the universal Text Editor Configuration +# for all GTNewHorizons projects +# See: https://editorconfig.org/ + +root = true + +[*] +charset = utf-8 +end_of_line = lf +indent_size = 4 +indent_style = space +insert_final_newline = true +trim_trailing_whitespace = true + +[*.{bat,ini}] +end_of_line = crlf + +[*.{dtd,json,info,mcmeta,md,sh,svg,xml,xsd,xsl,yaml,yml}] +indent_size = 2 + +[*.lang] +trim_trailing_whitespace = false diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..9917fc4ab --- /dev/null +++ b/.gitattributes @@ -0,0 +1,35 @@ +* text eol=lf + +*.jar binary + +*.png binary +*.jpg binary +*.jpeg binary +*.gif binary +*.tif binary +*.tiff binary +*.ico binary +*.svg text +*.eps binary + +*.kar binary +*.m4a binary +*.mid binary +*.midi binary +*.mp3 binary +*.ogg binary +*.ra binary + +*.7z binary +*.gz binary +*.tar binary +*.tgz binary +*.zip binary + +*.patch -text + +*.bat text eol=crlf +*.cmd text eol=crlf +*.ps1 text eol=crlf + +*autogenerated binary \ No newline at end of file diff --git a/.github/scripts/update_version b/.github/scripts/update_version new file mode 100644 index 000000000..3e5f752b0 --- /dev/null +++ b/.github/scripts/update_version @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +if ! git diff --name-only HEAD HEAD~1 | grep -qF 'build.gradle'; then + new_version="$(date +%s)" + sed --in-place "s!^//version:.*!//version: $new_version!g" build.gradle + git add build.gradle + git commit -m "[ci skip] update build script version to $new_version" + git push + printf 'Updated buildscript version to %s\n' "$new_version" +else + printf 'Ignored buildscript version update: no changes detected\n' +fi diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml new file mode 100644 index 000000000..3ee2f686f --- /dev/null +++ b/.github/workflows/build-and-test.yml @@ -0,0 +1,13 @@ + +name: Build and test + +on: + pull_request: + branches: [ master, main ] + push: + branches: [ master, main ] + +jobs: + build-and-test: + uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master + secrets: inherit diff --git a/.github/workflows/release-tags.yml b/.github/workflows/release-tags.yml new file mode 100644 index 000000000..e4c0be6b0 --- /dev/null +++ b/.github/workflows/release-tags.yml @@ -0,0 +1,14 @@ + +name: Release tagged build + +on: + push: + tags: [ '*' ] + +permissions: + contents: write + +jobs: + release-tags: + uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master + secrets: inherit diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..48c525b13 --- /dev/null +++ b/.gitignore @@ -0,0 +1,32 @@ +.gradle +.settings +/.idea/ +/.vscode/ +/run/ +/build/ +/eclipse/ +.classpath +.project +/bin/ +/config/ +/crash-reports/ +/logs/ +options.txt +/saves/ +usernamecache.json +banned-ips.json +banned-players.json +eula.txt +ops.json +server.properties +servers.dat +usercache.json +whitelist.json +/out/ +*.iml +*.ipr +*.iws +src/main/resources/mixins.*.json +*.bat +*.DS_Store +!gradlew.bat diff --git a/CODEOWNERS b/CODEOWNERS new file mode 100644 index 000000000..a6b5f68cd --- /dev/null +++ b/CODEOWNERS @@ -0,0 +1,3 @@ +# Any Github changes require admin approval +/.github/** @GTNewHorizons/admin + diff --git a/LICENCE b/LICENSE similarity index 100% rename from LICENCE rename to LICENSE diff --git a/addon.gradle b/addon.gradle new file mode 100644 index 000000000..21f4fdd9a --- /dev/null +++ b/addon.gradle @@ -0,0 +1,21 @@ + +configurations { + compileStubs +} + +sourceSets { + compileStubsStubs + compileStubs { + compileClasspath += configurations.compileStubs + } +} + +jar { + manifest { + attributes([ + "Manifest-Version" : 1.0, + "TweakClass" : "com.gtnewhorizons.angelica.loading.SMCTweaker", + "TweakOrder" : 1100, + ]) + } +} diff --git a/build.gradle b/build.gradle new file mode 100644 index 000000000..997b94dc3 --- /dev/null +++ b/build.gradle @@ -0,0 +1,968 @@ +//version: 1661114848 +/* + DO NOT CHANGE THIS FILE! + Also, you may replace this file at any time if there is an update available. + Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates. + */ + + +import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar +import org.gradle.internal.logging.text.StyledTextOutput.Style +import org.gradle.internal.logging.text.StyledTextOutputFactory + +import java.nio.file.Files +import java.nio.file.Paths +import java.util.concurrent.TimeUnit +import java.util.zip.ZipEntry +import java.util.zip.ZipInputStream +import java.util.zip.ZipOutputStream + +buildscript { + repositories { + mavenCentral() + + maven { + name 'forge' + url 'https://maven.minecraftforge.net' + } + maven { + // GTNH ForgeGradle Fork + name = "GTNH Maven" + url = "http://jenkins.usrv.eu:8081/nexus/content/groups/public/" + } + maven { + name 'sonatype' + url 'https://oss.sonatype.org/content/repositories/snapshots/' + } + maven { + name 'Scala CI dependencies' + url 'https://repo1.maven.org/maven2/' + } + } + dependencies { + classpath 'net.minecraftforge.gradle:ForgeGradle:1.2.9' + } +} +plugins { + id 'java-library' + id 'idea' + id 'eclipse' + id 'scala' + id 'maven-publish' + id 'org.jetbrains.kotlin.jvm' version '1.5.30' apply false + id 'org.jetbrains.kotlin.kapt' version '1.5.30' apply false + id 'com.google.devtools.ksp' version '1.5.30-1.0.0' apply false + id 'org.ajoberstar.grgit' version '4.1.1' + id 'com.github.johnrengelman.shadow' version '4.0.4' + id 'com.palantir.git-version' version '0.13.0' apply false + id 'de.undercouch.download' version '5.0.1' + id 'com.github.gmazzo.buildconfig' version '3.0.3' apply false + id 'com.diffplug.spotless' version '6.7.2' apply false +} +boolean settingsupdated = verifySettingsGradle() +settingsupdated = verifyGitAttributes() || settingsupdated +if (settingsupdated) + throw new GradleException("Settings has been updated, please re-run task.") + +dependencies { + implementation 'com.diffplug:blowdryer:1.6.0' +} + +apply plugin: 'com.diffplug.blowdryer' + +if (project.file('.git/HEAD').isFile()) { + apply plugin: 'com.palantir.git-version' +} + +def out = services.get(StyledTextOutputFactory).create('an-output') + +apply plugin: 'forge' + +def projectJavaVersion = JavaLanguageVersion.of(8) + +java { + toolchain { + languageVersion.set(projectJavaVersion) + } +} + +idea { + module { + inheritOutputDirs = true + downloadJavadoc = true + downloadSources = true + } +} + +boolean disableSpotless = project.hasProperty("disableSpotless") ? project.disableSpotless.toBoolean() : false + +if (!disableSpotless) { + apply plugin: 'com.diffplug.spotless' + apply from: Blowdryer.file('spotless.gradle') +} + +if (JavaVersion.current() != JavaVersion.VERSION_1_8) { + throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current()) +} + +checkPropertyExists("modName") +checkPropertyExists("modId") +checkPropertyExists("modGroup") +checkPropertyExists("autoUpdateBuildScript") +checkPropertyExists("minecraftVersion") +checkPropertyExists("forgeVersion") +checkPropertyExists("replaceGradleTokenInFile") +checkPropertyExists("gradleTokenModId") +checkPropertyExists("gradleTokenModName") +checkPropertyExists("gradleTokenVersion") +checkPropertyExists("gradleTokenGroupName") +checkPropertyExists("apiPackage") +checkPropertyExists("accessTransformersFile") +checkPropertyExists("usesMixins") +checkPropertyExists("mixinPlugin") +checkPropertyExists("mixinsPackage") +checkPropertyExists("coreModClass") +checkPropertyExists("containsMixinsAndOrCoreModOnly") +checkPropertyExists("usesShadowedDependencies") +checkPropertyExists("developmentEnvironmentUserName") + +boolean noPublishedSources = project.hasProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false +boolean usesMixinDebug = project.hasProperty('usesMixinDebug') ?: project.usesMixins.toBoolean() +boolean forceEnableMixins = project.hasProperty('forceEnableMixins') ? project.forceEnableMixins.toBoolean() : false +String channel = project.hasProperty('channel') ? project.channel : 'stable' +String mappingsVersion = project.hasProperty('mappingsVersion') ? project.mappingsVersion : '12' +String javaSourceDir = "src/main/java/" +String scalaSourceDir = "src/main/scala/" +String kotlinSourceDir = "src/main/kotlin/" + +String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") +String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") +String targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") +if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) { + throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin) +} + +if (apiPackage) { + targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) { + throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin) + } +} + +if (accessTransformersFile) { + String targetFile = "src/main/resources/META-INF/" + accessTransformersFile + if (!getFile(targetFile).exists()) { + throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile) + } +} + +if (usesMixins.toBoolean()) { + if (mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) { + throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!") + } + + targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/") + targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/") + targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/") + if (!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) { + throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin) + } + + String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java" + String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala" + String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java" + String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".kt" + if (!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) { + throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin) + } +} + +if (coreModClass) { + String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java" + String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala" + String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java" + String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".kt" + if (!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) { + throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin) + } +} + +configurations.all { + resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS) + + // Make sure GregTech build won't time out + System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String) + System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String) +} + +// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version +try { + 'git config core.fileMode false'.execute() +} +catch (Exception ignored) { + out.style(Style.Failure).println("git isn't installed at all") +} + +// Pulls version first from the VERSION env and then git tag +String identifiedVersion +String versionOverride = System.getenv("VERSION") ?: null +try { + identifiedVersion = versionOverride == null ? gitVersion() : versionOverride +} +catch (Exception ignored) { + out.style(Style.Failure).text( + 'This mod must be version controlled by Git AND the repository must provide at least one tag,\n' + + 'or the VERSION override must be set! ').style(Style.SuccessHeader).text('(Do NOT download from GitHub using the ZIP option, instead\n' + + 'clone the repository, see ').style(Style.Info).text('https://gtnh.miraheze.org/wiki/Development').style(Style.SuccessHeader).println(' for details.)' + ) + versionOverride = 'NO-GIT-TAG-SET' + identifiedVersion = versionOverride +} +version = minecraftVersion + '-' + identifiedVersion +ext { + modVersion = identifiedVersion +} + +if (identifiedVersion == versionOverride) { + out.style(Style.Failure).text('Override version to ').style(Style.Identifier).text(modVersion).style(Style.Failure).println('!\7') +} + +group = modGroup +if (project.hasProperty("customArchiveBaseName") && customArchiveBaseName) { + archivesBaseName = customArchiveBaseName +} else { + archivesBaseName = modId +} + +def arguments = [] +def jvmArguments = [] + +if (usesMixins.toBoolean() || forceEnableMixins) { + arguments += [ + "--tweakClass org.spongepowered.asm.launch.MixinTweaker" + ] + if (usesMixinDebug.toBoolean()) { + jvmArguments += [ + "-Dmixin.debug.countInjections=true", + "-Dmixin.debug.verbose=true", + "-Dmixin.debug.export=true" + ] + } +} + +minecraft { + version = minecraftVersion + '-' + forgeVersion + '-' + minecraftVersion + runDir = 'run' + + if (replaceGradleTokenInFile) { + replaceIn replaceGradleTokenInFile + if (gradleTokenModId) { + replace gradleTokenModId, modId + } + if (gradleTokenModName) { + replace gradleTokenModName, modName + } + if (gradleTokenVersion) { + replace gradleTokenVersion, modVersion + } + if (gradleTokenGroupName) { + replace gradleTokenGroupName, modGroup + } + } + + clientIntellijRun { + args(arguments) + jvmArgs(jvmArguments) + + if (developmentEnvironmentUserName) { + args("--username", developmentEnvironmentUserName) + } + } + + serverIntellijRun { + args(arguments) + jvmArgs(jvmArguments) + } +} + +if (file('addon.gradle').exists()) { + apply from: 'addon.gradle' +} + +apply from: 'repositories.gradle' + +configurations { + implementation.extendsFrom(shadowImplementation) // TODO: remove after all uses are refactored + implementation.extendsFrom(shadowCompile) + implementation.extendsFrom(shadeCompile) +} + +repositories { + maven { + name 'Overmind forge repo mirror' + url 'https://gregtech.overminddl1.com/' + } + if (usesMixins.toBoolean() || forceEnableMixins) { + maven { + name 'sponge' + url 'https://repo.spongepowered.org/repository/maven-public' + } + maven { + url 'https://jitpack.io' + } + } +} + +dependencies { + if (usesMixins.toBoolean()) { + annotationProcessor('org.ow2.asm:asm-debug-all:5.0.3') + annotationProcessor('com.google.guava:guava:24.1.1-jre') + annotationProcessor('com.google.code.gson:gson:2.8.6') + annotationProcessor('org.spongepowered:mixin:0.8-SNAPSHOT') + } + if (usesMixins.toBoolean() || forceEnableMixins) { + // using 0.8 to workaround a issue in 0.7 which fails mixin application + compile('com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH') { + // Mixin includes a lot of dependencies that are too up-to-date + exclude module: 'launchwrapper' + exclude module: 'guava' + exclude module: 'gson' + exclude module: 'commons-io' + exclude module: 'log4j-core' + } + compile('com.github.GTNewHorizons:SpongeMixins:1.5.0') + } +} + +apply from: 'dependencies.gradle' + +def mixingConfigRefMap = 'mixins.' + modId + '.refmap.json' +def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap +def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg" + +task generateAssets { + if (usesMixins.toBoolean()) { + def mixinConfigFile = getFile("/src/main/resources/mixins." + modId + ".json"); + if (!mixinConfigFile.exists()) { + mixinConfigFile.text = """{ + "required": true, + "minVersion": "0.7.11", + "package": "${modGroup}.${mixinsPackage}", + "plugin": "${modGroup}.${mixinPlugin}", + "refmap": "${mixingConfigRefMap}", + "target": "@env(DEFAULT)", + "compatibilityLevel": "JAVA_8", + "mixins": [], + "client": [], + "server": [] +} +""" + } + } +} + +task relocateShadowJar(type: ConfigureShadowRelocation) { + target = tasks.shadowJar + prefix = modGroup + ".shadow" +} + +shadowJar { + project.configurations.shadeCompile.each { dep -> + from(project.zipTree(dep)) { + exclude 'META-INF', 'META-INF/**' + } + } + + manifest { + attributes(getManifestAttributes()) + } + + minimize() // This will only allow shading for actually used classes + configurations = [ + project.configurations.shadowImplementation, + project.configurations.shadowCompile + ] + dependsOn(relocateShadowJar) +} + +jar { + project.configurations.shadeCompile.each { dep -> + from(project.zipTree(dep)) { + exclude 'META-INF', 'META-INF/**' + } + } + + manifest { + attributes(getManifestAttributes()) + } + + if (usesShadowedDependencies.toBoolean()) { + dependsOn(shadowJar) + enabled = false + } +} + +reobf { + if (usesMixins.toBoolean()) { + addExtraSrgFile mixinSrg + } +} + +afterEvaluate { + if (usesMixins.toBoolean()) { + tasks.compileJava { + options.compilerArgs += [ + "-AreobfSrgFile=${tasks.reobf.srg}", + "-AoutSrgFile=${mixinSrg}", + "-AoutRefMapFile=${refMap}", + // Elan: from what I understand they are just some linter configs so you get some warning on how to properly code + "-XDenableSunApiLintControl", + "-XDignore.symbol.file" + ] + } + } +} + +runClient { + if (developmentEnvironmentUserName) { + arguments += [ + "--username", + developmentEnvironmentUserName + ] + } + + args(arguments) + jvmArgs(jvmArguments) +} + +runServer { + args(arguments) + jvmArgs(jvmArguments) +} + +tasks.withType(JavaExec).configureEach { + javaLauncher.set( + javaToolchains.launcherFor { + languageVersion = projectJavaVersion + } + ) +} + +processResources { + // this will ensure that this task is redone when the versions change. + inputs.property "version", project.version + inputs.property "mcversion", project.minecraft.version + exclude("spotless.gradle") + + // replace stuff in mcmod.info, nothing else + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info' + + // replace modVersion and minecraftVersion + expand "minecraftVersion": project.minecraft.version, + "modVersion": modVersion, + "modId": modId, + "modName": modName + } + + if (usesMixins.toBoolean()) { + from refMap + } + + // copy everything else that's not the mcmod.info + from(sourceSets.main.resources.srcDirs) { + exclude 'mcmod.info' + exclude 'spotless.gradle' + } +} + +def getManifestAttributes() { + def manifestAttributes = [:] + if (!containsMixinsAndOrCoreModOnly.toBoolean() && (usesMixins.toBoolean() || coreModClass)) { + manifestAttributes += ["FMLCorePluginContainsFMLMod": true] + } + + if (accessTransformersFile) { + manifestAttributes += ["FMLAT": accessTransformersFile.toString()] + } + + if (coreModClass) { + manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass] + } + + if (usesMixins.toBoolean()) { + manifestAttributes += [ + "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker", + "MixinConfigs" : "mixins." + modId + ".json", + "ForceLoadAsMod": !containsMixinsAndOrCoreModOnly.toBoolean() + ] + } + return manifestAttributes +} + +task sourcesJar(type: Jar) { + from(sourceSets.main.allSource) + from(file("$projectDir/LICENSE")) + getArchiveClassifier().set('sources') +} + +task shadowDevJar(type: ShadowJar) { + project.configurations.shadeCompile.each { dep -> + from(project.zipTree(dep)) { + exclude 'META-INF', 'META-INF/**' + } + } + + from sourceSets.main.output + getArchiveClassifier().set("dev") + + manifest { + attributes(getManifestAttributes()) + } + + minimize() // This will only allow shading for actually used classes + configurations = [ + project.configurations.shadowImplementation, + project.configurations.shadowCompile + ] +} + +task relocateShadowDevJar(type: ConfigureShadowRelocation) { + target = tasks.shadowDevJar + prefix = modGroup + ".shadow" +} + +task circularResolverJar(type: Jar) { + dependsOn(relocateShadowDevJar) + dependsOn(shadowDevJar) + enabled = false +} + +task devJar(type: Jar) { + project.configurations.shadeCompile.each { dep -> + from(project.zipTree(dep)) { + exclude 'META-INF', 'META-INF/**' + } + } + + from sourceSets.main.output + getArchiveClassifier().set("dev") + + manifest { + attributes(getManifestAttributes()) + } + + if (usesShadowedDependencies.toBoolean()) { + dependsOn(circularResolverJar) + enabled = false + } +} + +task apiJar(type: Jar) { + from(sourceSets.main.allSource) { + include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**' + } + + from(sourceSets.main.output) { + include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**' + } + + from(sourceSets.main.resources.srcDirs) { + include("LICENSE") + } + + getArchiveClassifier().set('api') +} + +artifacts { + if (!noPublishedSources) { + archives sourcesJar + } + archives devJar + if (apiPackage) { + archives apiJar + } +} + +// The gradle metadata includes all of the additional deps that we disabled from POM generation (including forgeBin with no groupID), +// and isn't strictly needed with the POM so just disable it. +tasks.withType(GenerateModuleMetadata) { + enabled = false +} + +// workaround variable hiding in pom processing +def projectConfigs = project.configurations + +publishing { + publications { + maven(MavenPublication) { + from components.java + if (usesShadowedDependencies.toBoolean()) { + artifact source: shadowJar, classifier: "" + } + if (!noPublishedSources) { + artifact source: sourcesJar, classifier: "sources" + } + artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev" + if (apiPackage) { + artifact source: apiJar, classifier: "api" + } + + groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons" + artifactId = System.getenv("ARTIFACT_ID") ?: project.name + // Using the identified version, not project.version as it has the prepended 1.7.10 + version = System.getenv("RELEASE_VERSION") ?: identifiedVersion + + // remove extra garbage from minecraft and minecraftDeps configuration + pom.withXml { + def badArtifacts = [:].withDefault { [] as Set } + for (configuration in [ + projectConfigs.minecraft, + projectConfigs.minecraftDeps + ]) { + for (dependency in configuration.allDependencies) { + badArtifacts[dependency.group == null ? "" : dependency.group] += dependency.name + } + } + // example for specifying extra stuff to ignore + // badArtifacts["org.example.group"] += "artifactName" + + Node pomNode = asNode() + pomNode.dependencies.'*'.findAll() { + badArtifacts[it.groupId.text()].contains(it.artifactId.text()) + }.each() { + it.parent().remove(it) + } + } + } + } + + repositories { + maven { + url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases" + credentials { + username = System.getenv("MAVEN_USER") ?: "NONE" + password = System.getenv("MAVEN_PASSWORD") ?: "NONE" + } + } + } +} + +// Updating +task updateBuildScript { + doLast { + if (performBuildScriptUpdate(projectDir.toString())) return + + print("Build script already up-to-date!") + } +} + +if (!project.getGradle().startParameter.isOffline() && isNewBuildScriptVersionAvailable(projectDir.toString())) { + if (autoUpdateBuildScript.toBoolean()) { + performBuildScriptUpdate(projectDir.toString()) + } else { + out.style(Style.SuccessHeader).println("Build script update available! Run 'gradle updateBuildScript'") + } +} + +static URL availableBuildScriptUrl() { + new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/build.gradle") +} + +static URL exampleSettingsGradleUrl() { + new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/settings.gradle.example") +} + +static URL exampleGitAttributesUrl() { + new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/master/.gitattributes") +} + + +boolean verifyGitAttributes() { + def gitattributesFile = getFile(".gitattributes") + if (!gitattributesFile.exists()) { + println("Downloading default .gitattributes") + exampleGitAttributesUrl().withInputStream { i -> gitattributesFile.withOutputStream { it << i } } + exec { + workingDir '.' + commandLine 'git', 'add', '--renormalize', '.' + } + return true + } + return false +} + +boolean verifySettingsGradle() { + def settingsFile = getFile("settings.gradle") + if (!settingsFile.exists()) { + println("Downloading default settings.gradle") + exampleSettingsGradleUrl().withInputStream { i -> settingsFile.withOutputStream { it << i } } + return true + } + return false +} + +boolean performBuildScriptUpdate(String projectDir) { + if (isNewBuildScriptVersionAvailable(projectDir)) { + def buildscriptFile = getFile("build.gradle") + availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } } + out.style(Style.Success).print("Build script updated. Please REIMPORT the project or RESTART your IDE!") + boolean settingsupdated = verifySettingsGradle() + settingsupdated = verifyGitAttributes() || settingsupdated + if (settingsupdated) + throw new GradleException("Settings has been updated, please re-run task.") + return true + } + return false +} + +boolean isNewBuildScriptVersionAvailable(String projectDir) { + Map parameters = ["connectTimeout": 2000, "readTimeout": 2000] + + String currentBuildScript = getFile("build.gradle").getText() + String currentBuildScriptHash = getVersionHash(currentBuildScript) + String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText() + String availableBuildScriptHash = getVersionHash(availableBuildScript) + + boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash + return !isUpToDate +} + +static String getVersionHash(String buildScriptContent) { + String versionLine = buildScriptContent.find("^//version: [a-z0-9]*") + if (versionLine != null) { + return versionLine.split(": ").last() + } + return "" +} + +configure(updateBuildScript) { + group = 'forgegradle' + description = 'Updates the build script to the latest version' +} + +// Parameter Deobfuscation + +task deobfParams { + doLast { + + String mcpDir = "$project.gradle.gradleUserHomeDir/caches/minecraft/de/oceanlabs/mcp/mcp_$channel/$mappingsVersion" + String mcpZIP = "$mcpDir/mcp_$channel-$mappingsVersion-${minecraftVersion}.zip" + String paramsCSV = "$mcpDir/params.csv" + + download.run { + src "https://maven.minecraftforge.net/de/oceanlabs/mcp/mcp_$channel/$mappingsVersion-$minecraftVersion/mcp_$channel-$mappingsVersion-${minecraftVersion}.zip" + dest mcpZIP + overwrite false + } + + if (!file(paramsCSV).exists()) { + println("Extracting MCP archive ...") + unzip(mcpZIP, mcpDir) + } + + println("Parsing params.csv ...") + Map params = new HashMap<>() + Files.lines(Paths.get(paramsCSV)).forEach { line -> + String[] cells = line.split(",") + if (cells.length > 2 && cells[0].matches("p_i?\\d+_\\d+_")) { + params.put(cells[0], cells[1]) + } + } + + out.style(Style.Success).println("Modified ${replaceParams(file("$projectDir/src/main/java"), params)} files!") + out.style(Style.Failure).println("Don't forget to verify that the code still works as before!\n It could be broken due to duplicate variables existing now\n or parameters taking priority over other variables.") + } +} + +static int replaceParams(File file, Map params) { + int fileCount = 0 + + if (file.isDirectory()) { + for (File f : file.listFiles()) { + fileCount += replaceParams(f, params) + } + return fileCount + } + println("Visiting ${file.getName()} ...") + try { + String content = new String(Files.readAllBytes(file.toPath())) + int hash = content.hashCode() + params.forEach { key, value -> + content = content.replaceAll(key, value) + } + if (hash != content.hashCode()) { + Files.write(file.toPath(), content.getBytes("UTF-8")) + return 1 + } + } catch (Exception e) { + e.printStackTrace() + } + return 0 +} + +// Credit: bitsnaps (https://gist.github.com/bitsnaps/00947f2dce66f4bbdabc67d7e7b33681) +static unzip(String zipFileName, String outputDir) { + byte[] buffer = new byte[16384] + ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFileName)) + ZipEntry zipEntry = zis.getNextEntry() + while (zipEntry != null) { + File newFile = new File(outputDir + File.separator, zipEntry.name) + if (zipEntry.isDirectory()) { + if (!newFile.isDirectory() && !newFile.mkdirs()) { + throw new IOException("Failed to create directory $newFile") + } + } else { + // fix for Windows-created archives + File parent = newFile.parentFile + if (!parent.isDirectory() && !parent.mkdirs()) { + throw new IOException("Failed to create directory $parent") + } + // write file content + FileOutputStream fos = new FileOutputStream(newFile) + int len = 0 + while ((len = zis.read(buffer)) > 0) { + fos.write(buffer, 0, len) + } + fos.close() + } + zipEntry = zis.getNextEntry() + } + zis.closeEntry() + zis.close() +} + +configure(deobfParams) { + group = 'forgegradle' + description = 'Rename all obfuscated parameter names inherited from Minecraft classes' +} + +// Dependency Deobfuscation + +def deobf(String sourceURL) { + try { + URL url = new URL(sourceURL) + String fileName = url.getFile() + + //get rid of directories: + int lastSlash = fileName.lastIndexOf("/") + if (lastSlash > 0) { + fileName = fileName.substring(lastSlash + 1) + } + //get rid of extension: + if (fileName.endsWith(".jar") || fileName.endsWith(".litemod")) { + fileName = fileName.substring(0, fileName.lastIndexOf(".")) + } + + String hostName = url.getHost() + if (hostName.startsWith("www.")) { + hostName = hostName.substring(4) + } + List parts = Arrays.asList(hostName.split("\\.")) + Collections.reverse(parts) + hostName = String.join(".", parts) + + return deobf(sourceURL, "$hostName/$fileName") + } catch (Exception e) { + return deobf(sourceURL, "deobf/${sourceURL.hashCode()}") + } +} + +// The method above is to be preferred. Use this method if the filename is not at the end of the URL. +def deobf(String sourceURL, String rawFileName) { + String bon2Version = "2.5.1" + String fileName = URLDecoder.decode(rawFileName, "UTF-8") + String cacheDir = "$project.gradle.gradleUserHomeDir/caches" + String bon2Dir = "$cacheDir/forge_gradle/deobf" + String bon2File = "$bon2Dir/BON2-${bon2Version}.jar" + String obfFile = "$cacheDir/modules-2/files-2.1/${fileName}.jar" + String deobfFile = "$cacheDir/modules-2/files-2.1/${fileName}-deobf.jar" + + if (file(deobfFile).exists()) { + return files(deobfFile) + } + + String mappingsVer + String remoteMappings = project.hasProperty('remoteMappings') ? project.remoteMappings : 'https://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/conf/' + if (remoteMappings) { + String id = "${forgeVersion.split("\\.")[3]}-$minecraftVersion" + String mappingsZIP = "$cacheDir/forge_gradle/maven_downloader/de/oceanlabs/mcp/mcp_snapshot_nodoc/$id/mcp_snapshot_nodoc-${id}.zip" + + zipMappings(mappingsZIP, remoteMappings, bon2Dir) + + mappingsVer = "snapshot_$id" + } else { + mappingsVer = "${channel}_$mappingsVersion" + } + + download.run { + src "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases/com/github/parker8283/BON2/$bon2Version-CUSTOM/BON2-$bon2Version-CUSTOM-all.jar" + dest bon2File + quiet true + overwrite false + } + + download.run { + src sourceURL + dest obfFile + quiet true + overwrite false + } + + exec { + commandLine 'java', '-jar', bon2File, '--inputJar', obfFile, '--outputJar', deobfFile, '--mcVer', minecraftVersion, '--mappingsVer', mappingsVer, '--notch' + workingDir bon2Dir + standardOutput = new FileOutputStream("${deobfFile}.log") + } + + return files(deobfFile) +} + +def zipMappings(String zipPath, String url, String bon2Dir) { + File zipFile = new File(zipPath) + if (zipFile.exists()) { + return + } + + String fieldsCache = "$bon2Dir/data/fields.csv" + String methodsCache = "$bon2Dir/data/methods.csv" + + download.run { + src "${url}fields.csv" + dest fieldsCache + quiet true + } + download.run { + src "${url}methods.csv" + dest methodsCache + quiet true + } + + zipFile.getParentFile().mkdirs() + ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile)) + + zos.putNextEntry(new ZipEntry("fields.csv")) + Files.copy(Paths.get(fieldsCache), zos) + zos.closeEntry() + + zos.putNextEntry(new ZipEntry("methods.csv")) + Files.copy(Paths.get(methodsCache), zos) + zos.closeEntry() + + zos.close() +} + +// Helper methods + +def checkPropertyExists(String propertyName) { + if (!project.hasProperty(propertyName)) { + throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties") + } +} + +def getFile(String relativePath) { + return new File(projectDir, relativePath) +} diff --git a/dependencies.gradle b/dependencies.gradle new file mode 100644 index 000000000..93926c9dd --- /dev/null +++ b/dependencies.gradle @@ -0,0 +1,5 @@ + +dependencies { + compileOnly(sourceSets.compileStubs.output) + compileStubs(sourceSets.compileStubsStubs.output) +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 000000000..47048b6ef --- /dev/null +++ b/gradle.properties @@ -0,0 +1,84 @@ +modName = Angelica + +# This is a case-sensitive string to identify your mod. Convention is to use lower case. +modId = angelica + +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/ + +# Will update your build.gradle automatically whenever an update is available +autoUpdateBuildScript = false + +minecraftVersion = 1.7.10 +forgeVersion = 10.13.4.1614 + +# Specify a MCP channel and mappings version for dependency deobfuscation and the deobfParams task. +channel = stable +mappingsVersion = 12 + +# Define 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 +developmentEnvironmentUserName = Developer + +# 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 +replaceGradleTokenInFile = Tags.java +gradleTokenModId = GRADLETOKEN_MODID +gradleTokenModName = GRADLETOKEN_MODNAME +gradleTokenVersion = GRADLETOKEN_VERSION +gradleTokenGroupName = GRADLETOKEN_GROUPNAME + +# 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 +apiPackage = + +# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/ +# Example value: mymodid_at.cfg +accessTransformersFile = + +# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled! +usesMixins = false +# Adds some debug arguments like verbose output and 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 = +# 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 +coreModClass = +# 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 + +# 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. +usesShadowedDependencies = false + +# Optional parameter to customize the produced artifacts. Use this to preserver 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 = + +# 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. +# disableSpotless = true diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..5c2d1cf016b3885f6930543d57b744ea8c220a1a GIT binary patch literal 55616 zcmafaW0WS*vSoFbZJS-TZP!<}ZQEV8ZQHihW!tvx>6!c9%-lQoy;&DmfdT@8fB*sl68LLCKtKQ283+jS?^Q-bNq|NIAW8=eB==8_)^)r*{C^$z z{u;{v?IMYnO`JhmPq7|LA_@Iz75S9h~8`iX>QrjrmMeu{>hn4U;+$dor zz+`T8Q0f}p^Ao)LsYq74!W*)&dTnv}E8;7H*Zetclpo2zf_f>9>HT8;`O^F8;M%l@ z57Z8dk34kG-~Wg7n48qF2xwPp;SOUpd1}9Moir5$VSyf4gF)Mp-?`wO3;2x9gYj59oFwG>?Leva43@e(z{mjm0b*@OAYLC`O9q|s+FQLOE z!+*Y;%_0(6Sr<(cxE0c=lS&-FGBFGWd_R<5$vwHRJG=tB&Mi8@hq_U7@IMyVyKkOo6wgR(<% zQw1O!nnQl3T9QJ)Vh=(`cZM{nsEKChjbJhx@UQH+G>6p z;beBQ1L!3Zl>^&*?cSZjy$B3(1=Zyn~>@`!j%5v7IBRt6X`O)yDpVLS^9EqmHxBcisVG$TRwiip#ViN|4( zYn!Av841_Z@Ys=T7w#>RT&iXvNgDq3*d?$N(SznG^wR`x{%w<6^qj&|g})La;iD?`M=p>99p><39r9+e z`dNhQ&tol5)P#;x8{tT47i*blMHaDKqJs8!Pi*F{#)9%USFxTVMfMOy{mp2ZrLR40 z2a9?TJgFyqgx~|j0eA6SegKVk@|Pd|_6P$HvwTrLTK)Re`~%kg8o9`EAE1oAiY5Jgo=H}0*D?tSCn^=SIN~fvv453Ia(<1|s07aTVVtsRxY6+tT3589iQdi^ zC92D$ewm9O6FA*u*{Fe_=b`%q`pmFvAz@hfF@OC_${IPmD#QMpPNo0mE9U=Ch;k0L zZteokPG-h7PUeRCPPYG%H!WswC?cp7M|w42pbtwj!m_&4%hB6MdLQe&}@5-h~! zkOt;w0BbDc0H!RBw;1UeVckHpJ@^|j%FBZlC} zsm?nFOT$`F_i#1_gh4|n$rDe>0md6HvA=B%hlX*3Z%y@a&W>Rq`Fe(8smIgxTGb#8 zZ`->%h!?QCk>v*~{!qp=w?a*};Y**1uH`)OX`Gi+L%-d6{rV?@}MU#qfCU(!hLz;kWH=0A%W7E^pA zD;A%Jg5SsRe!O*0TyYkAHe&O9z*Ij-YA$%-rR?sc`xz_v{>x%xY39!8g#!Z0#03H( z{O=drKfb0cbx1F*5%q81xvTDy#rfUGw(fesh1!xiS2XT;7_wBi(Rh4i(!rR^9=C+- z+**b9;icxfq@<7}Y!PW-0rTW+A^$o*#ZKenSkxLB$Qi$%gJSL>x!jc86`GmGGhai9 zOHq~hxh}KqQHJeN$2U{M>qd*t8_e&lyCs69{bm1?KGTYoj=c0`rTg>pS6G&J4&)xp zLEGIHSTEjC0-s-@+e6o&w=h1sEWWvJUvezID1&exb$)ahF9`(6`?3KLyVL$|c)CjS zx(bsy87~n8TQNOKle(BM^>1I!2-CZ^{x6zdA}qeDBIdrfd-(n@Vjl^9zO1(%2pP9@ zKBc~ozr$+4ZfjmzEIzoth(k?pbI87=d5OfjVZ`Bn)J|urr8yJq`ol^>_VAl^P)>2r)s+*3z5d<3rP+-fniCkjmk=2hTYRa@t zCQcSxF&w%mHmA?!vaXnj7ZA$)te}ds+n8$2lH{NeD4mwk$>xZCBFhRy$8PE>q$wS`}8pI%45Y;Mg;HH+}Dp=PL)m77nKF68FggQ-l3iXlVZuM2BDrR8AQbK;bn1%jzahl0; zqz0(mNe;f~h8(fPzPKKf2qRsG8`+Ca)>|<&lw>KEqM&Lpnvig>69%YQpK6fx=8YFj zHKrfzy>(7h2OhUVasdwKY`praH?>qU0326-kiSyOU_Qh>ytIs^htlBA62xU6xg?*l z)&REdn*f9U3?u4$j-@ndD#D3l!viAUtw}i5*Vgd0Y6`^hHF5R=No7j8G-*$NWl%?t z`7Nilf_Yre@Oe}QT3z+jOUVgYtT_Ym3PS5(D>kDLLas8~F+5kW%~ZYppSrf1C$gL* zCVy}fWpZ3s%2rPL-E63^tA|8OdqKsZ4TH5fny47ENs1#^C`_NLg~H^uf3&bAj#fGV zDe&#Ot%_Vhj$}yBrC3J1Xqj>Y%&k{B?lhxKrtYy;^E9DkyNHk5#6`4cuP&V7S8ce9 zTUF5PQIRO7TT4P2a*4;M&hk;Q7&{(83hJe5BSm=9qt~;U)NTf=4uKUcnxC`;iPJeI zW#~w?HIOM+0j3ptB0{UU{^6_#B*Q2gs;1x^YFey(%DJHNWz@e_NEL?$fv?CDxG`jk zH|52WFdVsZR;n!Up;K;4E$|w4h>ZIN+@Z}EwFXI{w_`?5x+SJFY_e4J@|f8U08%dd z#Qsa9JLdO$jv)?4F@&z_^{Q($tG`?|9bzt8ZfH9P`epY`soPYqi1`oC3x&|@m{hc6 zs0R!t$g>sR@#SPfNV6Pf`a^E?q3QIaY30IO%yKjx#Njj@gro1YH2Q(0+7D7mM~c>C zk&_?9Ye>B%*MA+77$Pa!?G~5tm`=p{NaZsUsOgm6Yzclr_P^2)r(7r%n(0?4B#$e7 z!fP;+l)$)0kPbMk#WOjm07+e?{E)(v)2|Ijo{o1+Z8#8ET#=kcT*OwM#K68fSNo%< zvZFdHrOrr;>`zq!_welWh!X}=oN5+V01WJn7=;z5uo6l_$7wSNkXuh=8Y>`TjDbO< z!yF}c42&QWYXl}XaRr0uL?BNPXlGw=QpDUMo`v8pXzzG(=!G;t+mfCsg8 zJb9v&a)E!zg8|%9#U?SJqW!|oBHMsOu}U2Uwq8}RnWeUBJ>FtHKAhP~;&T4mn(9pB zu9jPnnnH0`8ywm-4OWV91y1GY$!qiQCOB04DzfDDFlNy}S{$Vg9o^AY!XHMueN<{y zYPo$cJZ6f7``tmlR5h8WUGm;G*i}ff!h`}L#ypFyV7iuca!J+C-4m@7*Pmj9>m+jh zlpWbud)8j9zvQ`8-oQF#u=4!uK4kMFh>qS_pZciyq3NC(dQ{577lr-!+HD*QO_zB9 z_Rv<#qB{AAEF8Gbr7xQly%nMA%oR`a-i7nJw95F3iH&IX5hhy3CCV5y>mK4)&5aC*12 zI`{(g%MHq<(ocY5+@OK-Qn-$%!Nl%AGCgHl>e8ogTgepIKOf3)WoaOkuRJQt%MN8W z=N-kW+FLw=1^}yN@*-_c>;0N{-B!aXy#O}`%_~Nk?{e|O=JmU8@+92Q-Y6h)>@omP=9i~ zi`krLQK^!=@2BH?-R83DyFkejZkhHJqV%^} zUa&K22zwz7b*@CQV6BQ9X*RB177VCVa{Z!Lf?*c~PwS~V3K{id1TB^WZh=aMqiws5)qWylK#^SG9!tqg3-)p_o(ABJsC!0;0v36;0tC= z!zMQ_@se(*`KkTxJ~$nIx$7ez&_2EI+{4=uI~dwKD$deb5?mwLJ~ema_0Z z6A8Q$1~=tY&l5_EBZ?nAvn$3hIExWo_ZH2R)tYPjxTH5mAw#3n-*sOMVjpUrdnj1DBm4G!J+Ke}a|oQN9f?!p-TcYej+(6FNh_A? zJ3C%AOjc<8%9SPJ)U(md`W5_pzYpLEMwK<_jgeg-VXSX1Nk1oX-{yHz z-;CW!^2ds%PH{L{#12WonyeK5A=`O@s0Uc%s!@22etgSZW!K<%0(FHC+5(BxsXW@e zAvMWiO~XSkmcz%-@s{|F76uFaBJ8L5H>nq6QM-8FsX08ug_=E)r#DC>d_!6Nr+rXe zzUt30Du_d0oSfX~u>qOVR*BmrPBwL@WhF^5+dHjWRB;kB$`m8|46efLBXLkiF|*W= zg|Hd(W}ZnlJLotYZCYKoL7YsQdLXZ!F`rLqLf8n$OZOyAzK`uKcbC-n0qoH!5-rh&k-`VADETKHxrhK<5C zhF0BB4azs%j~_q_HA#fYPO0r;YTlaa-eb)Le+!IeP>4S{b8&STp|Y0if*`-A&DQ$^ z-%=i73HvEMf_V6zSEF?G>G-Eqn+|k`0=q?(^|ZcqWsuLlMF2!E*8dDAx%)}y=lyMa z$Nn0_f8YN8g<4D>8IL3)GPf#dJYU@|NZqIX$;Lco?Qj=?W6J;D@pa`T=Yh z-ybpFyFr*3^gRt!9NnbSJWs2R-S?Y4+s~J8vfrPd_&_*)HBQ{&rW(2X>P-_CZU8Y9 z-32><7|wL*K+3{ZXE5}nn~t@NNT#Bc0F6kKI4pVwLrpU@C#T-&f{Vm}0h1N3#89@d zgcx3QyS;Pb?V*XAq;3(W&rjLBazm69XX;%^n6r}0!CR2zTU1!x#TypCr`yrII%wk8 z+g)fyQ!&xIX(*>?T}HYL^>wGC2E}euj{DD_RYKK@w=yF+44367X17)GP8DCmBK!xS zE{WRfQ(WB-v>DAr!{F2-cQKHIjIUnLk^D}7XcTI#HyjSiEX)BO^GBI9NjxojYfQza zWsX@GkLc7EqtP8(UM^cq5zP~{?j~*2T^Bb={@PV)DTkrP<9&hxDwN2@hEq~8(ZiF! z3FuQH_iHyQ_s-#EmAC5~K$j_$cw{+!T>dm#8`t%CYA+->rWp09jvXY`AJQ-l%C{SJ z1c~@<5*7$`1%b}n7ivSo(1(j8k+*Gek(m^rQ!+LPvb=xA@co<|(XDK+(tb46xJ4) zcw7w<0p3=Idb_FjQ@ttoyDmF?cT4JRGrX5xl&|ViA@Lg!vRR}p#$A?0=Qe+1)Mizl zn;!zhm`B&9t0GA67GF09t_ceE(bGdJ0mbXYrUoV2iuc3c69e;!%)xNOGG*?x*@5k( zh)snvm0s&gRq^{yyeE)>hk~w8)nTN`8HJRtY0~1f`f9ue%RV4~V(K*B;jFfJY4dBb z*BGFK`9M-tpWzayiD>p_`U(29f$R|V-qEB;+_4T939BPb=XRw~8n2cGiRi`o$2qm~ zN&5N7JU{L*QGM@lO8VI)fUA0D7bPrhV(GjJ$+@=dcE5vAVyCy6r&R#4D=GyoEVOnu z8``8q`PN-pEy>xiA_@+EN?EJpY<#}BhrsUJC0afQFx7-pBeLXR9Mr+#w@!wSNR7vxHy@r`!9MFecB4O zh9jye3iSzL0@t3)OZ=OxFjjyK#KSF|zz@K}-+HaY6gW+O{T6%Zky@gD$6SW)Jq;V0 zt&LAG*YFO^+=ULohZZW*=3>7YgND-!$2}2)Mt~c>JO3j6QiPC-*ayH2xBF)2m7+}# z`@m#q{J9r~Dr^eBgrF(l^#sOjlVNFgDs5NR*Xp;V*wr~HqBx7?qBUZ8w)%vIbhhe) zt4(#1S~c$Cq7b_A%wpuah1Qn(X9#obljoY)VUoK%OiQZ#Fa|@ZvGD0_oxR=vz{>U* znC(W7HaUDTc5F!T77GswL-jj7e0#83DH2+lS-T@_^SaWfROz9btt*5zDGck${}*njAwf}3hLqKGLTeV&5(8FC+IP>s;p{L@a~RyCu)MIa zs~vA?_JQ1^2Xc&^cjDq02tT_Z0gkElR0Aa$v@VHi+5*)1(@&}gEXxP5Xon?lxE@is z9sxd|h#w2&P5uHJxWgmtVZJv5w>cl2ALzri;r57qg){6`urTu(2}EI?D?##g=!Sbh z*L*>c9xN1a3CH$u7C~u_!g81`W|xp=54oZl9CM)&V9~ATCC-Q!yfKD@vp#2EKh0(S zgt~aJ^oq-TM0IBol!w1S2j7tJ8H7;SR7yn4-H}iz&U^*zW95HrHiT!H&E|rSlnCYr z7Y1|V7xebn=TFbkH;>WIH6H>8;0?HS#b6lCke9rSsH%3AM1#2U-^*NVhXEIDSFtE^ z=jOo1>j!c__Bub(R*dHyGa)@3h?!ls1&M)d2{?W5#1|M@6|ENYYa`X=2EA_oJUw=I zjQ)K6;C!@>^i7vdf`pBOjH>Ts$97}B=lkb07<&;&?f#cy3I0p5{1=?O*#8m$C_5TE zh}&8lOWWF7I@|pRC$G2;Sm#IJfhKW@^jk=jfM1MdJP(v2fIrYTc{;e5;5gsp`}X8-!{9{S1{h+)<@?+D13s^B zq9(1Pu(Dfl#&z|~qJGuGSWDT&u{sq|huEsbJhiqMUae}K*g+R(vG7P$p6g}w*eYWn zQ7luPl1@{vX?PMK%-IBt+N7TMn~GB z!Ldy^(2Mp{fw_0;<$dgHAv1gZgyJAx%}dA?jR=NPW1K`FkoY zNDgag#YWI6-a2#&_E9NMIE~gQ+*)i<>0c)dSRUMHpg!+AL;a;^u|M1jp#0b<+#14z z+#LuQ1jCyV_GNj#lHWG3e9P@H34~n0VgP#(SBX=v|RSuOiY>L87 z#KA{JDDj2EOBX^{`a;xQxHtY1?q5^B5?up1akjEPhi1-KUsK|J9XEBAbt%^F`t0I- zjRYYKI4OB7Zq3FqJFBZwbI=RuT~J|4tA8x)(v2yB^^+TYYJS>Et`_&yge##PuQ%0I z^|X!Vtof}`UuIxPjoH8kofw4u1pT5h`Ip}d8;l>WcG^qTe>@x63s#zoJiGmDM@_h= zo;8IZR`@AJRLnBNtatipUvL^(1P_a;q8P%&voqy#R!0(bNBTlV&*W9QU?kRV1B*~I zWvI?SNo2cB<7bgVY{F_CF$7z!02Qxfw-Ew#p!8PC#! z1sRfOl`d-Y@&=)l(Sl4CS=>fVvor5lYm61C!!iF3NMocKQHUYr0%QM}a4v2>rzPfM zUO}YRDb7-NEqW+p_;e0{Zi%0C$&B3CKx6|4BW`@`AwsxE?Vu}@Jm<3%T5O&05z+Yq zkK!QF(vlN}Rm}m_J+*W4`8i~R&`P0&5!;^@S#>7qkfb9wxFv@(wN@$k%2*sEwen$a zQnWymf+#Uyv)0lQVd?L1gpS}jMQZ(NHHCKRyu zjK|Zai0|N_)5iv)67(zDBCK4Ktm#ygP|0(m5tU`*AzR&{TSeSY8W=v5^=Ic`ahxM-LBWO+uoL~wxZmgcSJMUF9q%<%>jsvh9Dnp^_e>J_V=ySx4p?SF0Y zg4ZpZt@!h>WR76~P3_YchYOak7oOzR|`t+h!BbN}?zd zq+vMTt0!duALNWDwWVIA$O=%{lWJEj;5(QD()huhFL5=6x_=1h|5ESMW&S|*oxgF# z-0GRIb ziolwI13hJ-Rl(4Rj@*^=&Zz3vD$RX8bFWvBM{niz(%?z0gWNh_vUvpBDoa>-N=P4c zbw-XEJ@txIbc<`wC883;&yE4ayVh>+N($SJ01m}fumz!#!aOg*;y4Hl{V{b;&ux3& zBEmSq2jQ7#IbVm3TPBw?2vVN z0wzj|Y6EBS(V%Pb+@OPkMvEKHW~%DZk#u|A18pZMmCrjWh%7J4Ph>vG61 zRBgJ6w^8dNRg2*=K$Wvh$t>$Q^SMaIX*UpBG)0bqcvY%*by=$EfZAy{ZOA#^tB(D( zh}T(SZgdTj?bG9u+G{Avs5Yr1x=f3k7%K|eJp^>BHK#~dsG<&+=`mM@>kQ-cAJ2k) zT+Ht5liXdc^(aMi9su~{pJUhe)!^U&qn%mV6PS%lye+Iw5F@Xv8E zdR4#?iz+R4--iiHDQmQWfNre=iofAbF~1oGTa1Ce?hId~W^kPuN(5vhNx++ZLkn?l zUA7L~{0x|qA%%%P=8+-Ck{&2$UHn#OQncFS@uUVuE39c9o~#hl)v#!$X(X*4ban2c z{buYr9!`H2;6n73n^W3Vg(!gdBV7$e#v3qubWALaUEAf@`ava{UTx%2~VVQbEE(*Q8_ zv#me9i+0=QnY)$IT+@3vP1l9Wrne+MlZNGO6|zUVG+v&lm7Xw3P*+gS6e#6mVx~(w zyuaXogGTw4!!&P3oZ1|4oc_sGEa&m3Jsqy^lzUdJ^y8RlvUjDmbC^NZ0AmO-c*&m( zSI%4P9f|s!B#073b>Eet`T@J;3qY!NrABuUaED6M^=s-Q^2oZS`jVzuA z>g&g$!Tc>`u-Q9PmKu0SLu-X(tZeZ<%7F+$j3qOOftaoXO5=4!+P!%Cx0rNU+@E~{ zxCclYb~G(Ci%o{}4PC(Bu>TyX9slm5A^2Yi$$kCq-M#Jl)a2W9L-bq5%@Pw^ zh*iuuAz`x6N_rJ1LZ7J^MU9~}RYh+EVIVP+-62u+7IC%1p@;xmmQ`dGCx$QpnIUtK z0`++;Ddz7{_R^~KDh%_yo8WM$IQhcNOALCIGC$3_PtUs?Y44@Osw;OZ()Lk=(H&Vc zXjkHt+^1@M|J%Q&?4>;%T-i%#h|Tb1u;pO5rKst8(Cv2!3U{TRXdm&>fWTJG)n*q&wQPjRzg%pS1RO9}U0*C6fhUi&f#qoV`1{U<&mWKS<$oVFW>{&*$6)r6Rx)F4W zdUL8Mm_qNk6ycFVkI5F?V+cYFUch$92|8O^-Z1JC94GU+Nuk zA#n3Z1q4<6zRiv%W5`NGk*Ym{#0E~IA6*)H-=RmfWIY%mEC0? zSih7uchi`9-WkF2@z1ev6J_N~u;d$QfSNLMgPVpHZoh9oH-8D*;EhoCr~*kJ<|-VD z_jklPveOxWZq40E!SV@0XXy+~Vfn!7nZ1GXsn~U$>#u0d*f?RL9!NMlz^qxYmz|xt zz6A&MUAV#eD%^GcP#@5}QH5e7AV`}(N2#(3xpc!7dDmgu7C3TpgX5Z|$%Vu8=&SQI zdxUk*XS-#C^-cM*O>k}WD5K81e2ayyRA)R&5>KT1QL!T!%@}fw{>BsF+-pzu>;7{g z^CCSWfH;YtJGT@+An0Ded#zM9>UEFOdR_Xq zS~!5R*{p1Whq62ynHo|n$4p7&d|bal{iGsxAY?opi3R${)Zt*8YyOU!$TWMYXF?|i zPXYr}wJp#EH;keSG5WYJ*(~oiu#GDR>C4%-HpIWr7v`W`lzQN-lb?*vpoit z8FqJ)`LC4w8fO8Fu}AYV`awF2NLMS4$f+?=KisU4P6@#+_t)5WDz@f*qE|NG0*hwO z&gv^k^kC6Fg;5>Gr`Q46C{6>3F(p0QukG6NM07rxa&?)_C*eyU(jtli>9Zh#eUb(y zt9NbC-bp0>^m?i`?$aJUyBmF`N0zQ% zvF_;vLVI{tq%Ji%u*8s2p4iBirv*uD(?t~PEz$CfxVa=@R z^HQu6-+I9w>a35kX!P)TfnJDD!)j8!%38(vWNe9vK0{k*`FS$ABZ`rdwfQe@IGDki zssfXnsa6teKXCZUTd^qhhhUZ}>GG_>F0~LG7*<*x;8e39nb-0Bka(l)%+QZ_IVy3q zcmm2uKO0p)9|HGxk*e_$mX2?->&-MXe`=Fz3FRTFfM!$_y}G?{F9jmNgD+L%R`jM1 zIP-kb=3Hlsb35Q&qo(%Ja(LwQj>~!GI|Hgq65J9^A!ibChYB3kxLn@&=#pr}BwON0Q=e5;#sF8GGGuzx6O}z%u3l?jlKF&8Y#lUA)Cs6ZiW8DgOk|q z=YBPAMsO7AoAhWgnSKae2I7%7*Xk>#AyLX-InyBO?OD_^2^nI4#;G|tBvg3C0ldO0 z*`$g(q^es4VqXH2t~0-u^m5cfK8eECh3Rb2h1kW%%^8A!+ya3OHLw$8kHorx4(vJO zAlVu$nC>D{7i?7xDg3116Y2e+)Zb4FPAdZaX}qA!WW{$d?u+sK(iIKqOE-YM zH7y^hkny24==(1;qEacfFU{W{xSXhffC&DJV&oqw`u~WAl@=HIel>KC-mLs2ggFld zsSm-03=Jd^XNDA4i$vKqJ|e|TBc19bglw{)QL${Q(xlN?E;lPumO~;4w_McND6d+R zsc2p*&uRWd`wTDszTcWKiii1mNBrF7n&LQp$2Z<}zkv=8k2s6-^+#siy_K1`5R+n( z++5VOU^LDo(kt3ok?@$3drI`<%+SWcF*`CUWqAJxl3PAq!X|q{al;8%HfgxxM#2Vb zeBS756iU|BzB>bN2NP=AX&!{uZXS;|F`LLd9F^97UTMnNks_t7EPnjZF`2ocD2*u+ z?oKP{xXrD*AKGYGkZtlnvCuazg6g16ZAF{Nu%w+LCZ+v_*`0R$NK)tOh_c#cze;o$ z)kY(eZ5Viv<5zl1XfL(#GO|2FlXL#w3T?hpj3BZ&OAl^L!7@ zy;+iJWYQYP?$(`li_!|bfn!h~k#=v-#XXyjTLd+_txOqZZETqSEp>m+O0ji7MxZ*W zSdq+yqEmafrsLErZG8&;kH2kbCwluSa<@1yU3^Q#5HmW(hYVR0E6!4ZvH;Cr<$`qf zSvqRc`Pq_9b+xrtN3qLmds9;d7HdtlR!2NV$rZPCh6>(7f7M}>C^LeM_5^b$B~mn| z#)?`E=zeo9(9?{O_ko>51~h|c?8{F=2=_-o(-eRc z9p)o51krhCmff^U2oUi#$AG2p-*wSq8DZ(i!Jmu1wzD*)#%J&r)yZTq`3e|v4>EI- z=c|^$Qhv}lEyG@!{G~@}Wbx~vxTxwKoe9zn%5_Z^H$F1?JG_Kadc(G8#|@yaf2-4< zM1bdQF$b5R!W1f`j(S>Id;CHMzfpyjYEC_95VQ*$U3y5piVy=9Rdwg7g&)%#6;U%b2W}_VVdh}qPnM4FY9zFP(5eR zWuCEFox6e;COjs$1RV}IbpE0EV;}5IP}Oq|zcb*77PEDIZU{;@_;8*22{~JRvG~1t zc+ln^I+)Q*+Ha>(@=ra&L&a-kD;l$WEN;YL0q^GE8+})U_A_StHjX_gO{)N>tx4&F zRK?99!6JqktfeS-IsD@74yuq*aFJoV{5&K(W`6Oa2Qy0O5JG>O`zZ-p7vBGh!MxS;}}h6(96Wp`dci3DY?|B@1p8fVsDf$|0S zfE{WL5g3<9&{~yygYyR?jK!>;eZ2L#tpL2)H#89*b zycE?VViXbH7M}m33{#tI69PUPD=r)EVPTBku={Qh{ zKi*pht1jJ+yRhVE)1=Y()iS9j`FesMo$bjLSqPMF-i<42Hxl6%y7{#vw5YT(C}x0? z$rJU7fFmoiR&%b|Y*pG?7O&+Jb#Z%S8&%o~fc?S9c`Dwdnc4BJC7njo7?3bp#Yonz zPC>y`DVK~nzN^n}jB5RhE4N>LzhCZD#WQseohYXvqp5^%Ns!q^B z&8zQN(jgPS(2ty~g2t9!x9;Dao~lYVujG-QEq{vZp<1Nlp;oj#kFVsBnJssU^p-4% zKF_A?5sRmA>d*~^og-I95z$>T*K*33TGBPzs{OMoV2i+(P6K|95UwSj$Zn<@Rt(g%|iY z$SkSjYVJ)I<@S(kMQ6md{HxAa8S`^lXGV?ktLX!ngTVI~%WW+p#A#XTWaFWeBAl%U z&rVhve#Yse*h4BC4nrq7A1n>Rlf^ErbOceJC`o#fyCu@H;y)`E#a#)w)3eg^{Hw&E7);N5*6V+z%olvLj zp^aJ4`h*4L4ij)K+uYvdpil(Z{EO@u{BcMI&}5{ephilI%zCkBhBMCvOQT#zp|!18 zuNl=idd81|{FpGkt%ty=$fnZnWXxem!t4x{ zat@68CPmac(xYaOIeF}@O1j8O?2jbR!KkMSuix;L8x?m01}|bS2=&gsjg^t2O|+0{ zlzfu5r5_l4)py8uPb5~NHPG>!lYVynw;;T-gk1Pl6PQ39Mwgd2O+iHDB397H)2grN zHwbd>8i%GY>Pfy7;y5X7AN>qGLZVH>N_ZuJZ-`z9UA> zfyb$nbmPqxyF2F;UW}7`Cu>SS%0W6h^Wq5e{PWAjxlh=#Fq+6SiPa-L*551SZKX&w zc9TkPv4eao?kqomkZ#X%tA{`UIvf|_=Y7p~mHZKqO>i_;q4PrwVtUDTk?M7NCssa?Y4uxYrsXj!+k@`Cxl;&{NLs*6!R<6k9$Bq z%grLhxJ#G_j~ytJpiND8neLfvD0+xu>wa$-%5v;4;RYYM66PUab)c9ruUm%d{^s{# zTBBY??@^foRv9H}iEf{w_J%rV<%T1wv^`)Jm#snLTIifjgRkX``x2wV(D6(=VTLL4 zI-o}&5WuwBl~(XSLIn5~{cGWorl#z+=(vXuBXC#lp}SdW=_)~8Z(Vv!#3h2@pdA3d z{cIPYK@Ojc9(ph=H3T7;aY>(S3~iuIn05Puh^32WObj%hVN(Y{Ty?n?Cm#!kGNZFa zW6Ybz!tq|@erhtMo4xAus|H8V_c+XfE5mu|lYe|{$V3mKnb1~fqoFim;&_ZHN_=?t zysQwC4qO}rTi}k8_f=R&i27RdBB)@bTeV9Wcd}Rysvod}7I%ujwYbTI*cN7Kbp_hO z=eU521!#cx$0O@k9b$;pnCTRtLIzv){nVW6Ux1<0@te6`S5%Ew3{Z^9=lbL5$NFvd4eUtK?%zgmB;_I&p`)YtpN`2Im(?jPN<(7Ua_ZWJRF(CChv`(gHfWodK%+joy>8Vaa;H1w zIJ?!kA|x7V;4U1BNr(UrhfvjPii7YENLIm`LtnL9Sx z5E9TYaILoB2nSwDe|BVmrpLT43*dJ8;T@1l zJE)4LEzIE{IN}+Nvpo3=ZtV!U#D;rB@9OXYw^4QH+(52&pQEcZq&~u9bTg63ikW9! z=!_RjN2xO=F+bk>fSPhsjQA;)%M1My#34T`I7tUf>Q_L>DRa=>Eo(sapm>}}LUsN% zVw!C~a)xcca`G#g*Xqo>_uCJTz>LoWGSKOwp-tv`yvfqw{17t`9Z}U4o+q2JGP^&9 z(m}|d13XhYSnEm$_8vH-Lq$A^>oWUz1)bnv|AVn_0FwM$vYu&8+qUg$+qP}nwrykD zwmIF?wr$()X@33oz1@B9zi+?Th^nZnsES)rb@O*K^JL~ZH|pRRk$i0+ohh?Il)y&~ zQaq{}9YxPt5~_2|+r#{k#~SUhO6yFq)uBGtYMMg4h1qddg!`TGHocYROyNFJtYjNe z3oezNpq6%TP5V1g(?^5DMeKV|i6vdBq)aGJ)BRv;K(EL0_q7$h@s?BV$)w31*c(jd z{@hDGl3QdXxS=#?0y3KmPd4JL(q(>0ikTk6nt98ptq$6_M|qrPi)N>HY>wKFbnCKY z%0`~`9p)MDESQJ#A`_>@iL7qOCmCJ(p^>f+zqaMuDRk!z01Nd2A_W^D%~M73jTqC* zKu8u$$r({vP~TE8rPk?8RSjlRvG*BLF}ye~Su%s~rivmjg2F z24dhh6-1EQF(c>Z1E8DWY)Jw#9U#wR<@6J)3hjA&2qN$X%piJ4s={|>d-|Gzl~RNu z##iR(m;9TN3|zh+>HgTI&82iR>$YVoOq$a(2%l*2mNP(AsV=lR^>=tIP-R9Tw!BYnZROx`PN*JiNH>8bG}&@h0_v$yOTk#@1;Mh;-={ZU7e@JE(~@@y0AuETvsqQV@7hbKe2wiWk@QvV=Kz`%@$rN z_0Hadkl?7oEdp5eaaMqBm;#Xj^`fxNO^GQ9S3|Fb#%{lN;1b`~yxLGEcy8~!cz{!! z=7tS!I)Qq%w(t9sTSMWNhoV#f=l5+a{a=}--?S!rA0w}QF!_Eq>V4NbmYKV&^OndM z4WiLbqeC5+P@g_!_rs01AY6HwF7)$~%Ok^(NPD9I@fn5I?f$(rcOQjP+z?_|V0DiN zb}l0fy*el9E3Q7fVRKw$EIlb&T0fG~fDJZL7Qn8*a5{)vUblM)*)NTLf1ll$ zpQ^(0pkSTol`|t~`Y4wzl;%NRn>689mpQrW=SJ*rB;7}w zVHB?&sVa2%-q@ANA~v)FXb`?Nz8M1rHKiZB4xC9<{Q3T!XaS#fEk=sXI4IFMnlRqG+yaFw< zF{}7tcMjV04!-_FFD8(FtuOZx+|CjF@-xl6-{qSFF!r7L3yD()=*Ss6fT?lDhy(h$ zt#%F575$U(3-e2LsJd>ksuUZZ%=c}2dWvu8f!V%>z3gajZ!Dlk zm=0|(wKY`c?r$|pX6XVo6padb9{EH}px)jIsdHoqG^(XH(7}r^bRa8BC(%M+wtcB? z6G2%tui|Tx6C3*#RFgNZi9emm*v~txI}~xV4C`Ns)qEoczZ>j*r zqQCa5k90Gntl?EX!{iWh=1t$~jVoXjs&*jKu0Ay`^k)hC^v_y0xU~brMZ6PPcmt5$ z@_h`f#qnI$6BD(`#IR0PrITIV^~O{uo=)+Bi$oHA$G* zH0a^PRoeYD3jU_k%!rTFh)v#@cq`P3_y=6D(M~GBud;4 zCk$LuxPgJ5=8OEDlnU!R^4QDM4jGni}~C zy;t2E%Qy;A^bz_5HSb5pq{x{g59U!ReE?6ULOw58DJcJy;H?g*ofr(X7+8wF;*3{rx>j&27Syl6A~{|w{pHb zeFgu0E>OC81~6a9(2F13r7NZDGdQxR8T68&t`-BK zE>ZV0*0Ba9HkF_(AwfAds-r=|dA&p`G&B_zn5f9Zfrz9n#Rvso`x%u~SwE4SzYj!G zVQ0@jrLwbYP=awX$21Aq!I%M{x?|C`narFWhp4n;=>Sj!0_J!k7|A0;N4!+z%Oqlk z1>l=MHhw3bi1vT}1!}zR=6JOIYSm==qEN#7_fVsht?7SFCj=*2+Ro}B4}HR=D%%)F z?eHy=I#Qx(vvx)@Fc3?MT_@D))w@oOCRR5zRw7614#?(-nC?RH`r(bb{Zzn+VV0bm zJ93!(bfrDH;^p=IZkCH73f*GR8nDKoBo|!}($3^s*hV$c45Zu>6QCV(JhBW=3(Tpf z=4PT6@|s1Uz+U=zJXil3K(N6;ePhAJhCIo`%XDJYW@x#7Za);~`ANTvi$N4(Fy!K- z?CQ3KeEK64F0@ykv$-0oWCWhYI-5ZC1pDqui@B|+LVJmU`WJ=&C|{I_))TlREOc4* zSd%N=pJ_5$G5d^3XK+yj2UZasg2) zXMLtMp<5XWWfh-o@ywb*nCnGdK{&S{YI54Wh2|h}yZ})+NCM;~i9H@1GMCgYf`d5n zwOR(*EEkE4-V#R2+Rc>@cAEho+GAS2L!tzisLl${42Y=A7v}h;#@71_Gh2MV=hPr0_a% z0!={Fcv5^GwuEU^5rD|sP;+y<%5o9;#m>ssbtVR2g<420(I-@fSqfBVMv z?`>61-^q;M(b3r2z{=QxSjyH=-%99fpvb}8z}d;%_8$$J$qJg1Sp3KzlO_!nCn|g8 zzg8skdHNsfgkf8A7PWs;YBz_S$S%!hWQ@G>guCgS--P!!Ui9#%GQ#Jh?s!U-4)7ozR?i>JXHU$| zg0^vuti{!=N|kWorZNFX`dJgdphgic#(8sOBHQdBkY}Qzp3V%T{DFb{nGPgS;QwnH9B9;-Xhy{? z(QVwtzkn9I)vHEmjY!T3ifk1l5B?%%TgP#;CqG-?16lTz;S_mHOzu#MY0w}XuF{lk z*dt`2?&plYn(B>FFXo+fd&CS3q^hquSLVEn6TMAZ6e*WC{Q2e&U7l|)*W;^4l~|Q= zt+yFlLVqPz!I40}NHv zE2t1meCuGH%<`5iJ(~8ji#VD{?uhP%F(TnG#uRZW-V}1=N%ev&+Gd4v!0(f`2Ar-Y z)GO6eYj7S{T_vxV?5^%l6TF{ygS_9e2DXT>9caP~xq*~oE<5KkngGtsv)sdCC zaQH#kSL%c*gLj6tV)zE6SGq|0iX*DPV|I`byc9kn_tNQkPU%y<`rj zMC}lD<93=Oj+D6Y2GNMZb|m$^)RVdi`&0*}mxNy0BW#0iq!GGN2BGx5I0LS>I|4op z(6^xWULBr=QRpbxIJDK~?h;K#>LwQI4N<8V?%3>9I5l+e*yG zFOZTIM0c3(q?y9f7qDHKX|%zsUF%2zN9jDa7%AK*qrI5@z~IruFP+IJy7!s~TE%V3 z_PSSxXlr!FU|Za>G_JL>DD3KVZ7u&}6VWbwWmSg?5;MabycEB)JT(eK8wg`^wvw!Q zH5h24_E$2cuib&9>Ue&@%Cly}6YZN-oO_ei5#33VvqV%L*~ZehqMe;)m;$9)$HBsM zfJ96Hk8GJyWwQ0$iiGjwhxGgQX$sN8ij%XJzW`pxqgwW=79hgMOMnC|0Q@ed%Y~=_ z?OnjUB|5rS+R$Q-p)vvM(eFS+Qr{_w$?#Y;0Iknw3u(+wA=2?gPyl~NyYa3me{-Su zhH#8;01jEm%r#5g5oy-f&F>VA5TE_9=a0aO4!|gJpu470WIrfGo~v}HkF91m6qEG2 zK4j=7C?wWUMG$kYbIp^+@)<#ArZ$3k^EQxraLk0qav9TynuE7T79%MsBxl3|nRn?L zD&8kt6*RJB6*a7=5c57wp!pg)p6O?WHQarI{o9@3a32zQ3FH8cK@P!DZ?CPN_LtmC6U4F zlv8T2?sau&+(i@EL6+tvP^&=|aq3@QgL4 zOu6S3wSWeYtgCnKqg*H4ifIQlR4hd^n{F+3>h3;u_q~qw-Sh;4dYtp^VYymX12$`? z;V2_NiRt82RC=yC+aG?=t&a81!gso$hQUb)LM2D4Z{)S zI1S9f020mSm(Dn$&Rlj0UX}H@ zv={G+fFC>Sad0~8yB%62V(NB4Z|b%6%Co8j!>D(VyAvjFBP%gB+`b*&KnJ zU8s}&F+?iFKE(AT913mq;57|)q?ZrA&8YD3Hw*$yhkm;p5G6PNiO3VdFlnH-&U#JH zEX+y>hB(4$R<6k|pt0?$?8l@zeWk&1Y5tlbgs3540F>A@@rfvY;KdnVncEh@N6Mfi zY)8tFRY~Z?Qw!{@{sE~vQy)0&fKsJpj?yR`Yj+H5SDO1PBId3~d!yjh>FcI#Ug|^M z7-%>aeyQhL8Zmj1!O0D7A2pZE-$>+-6m<#`QX8(n)Fg>}l404xFmPR~at%$(h$hYD zoTzbxo`O{S{E}s8Mv6WviXMP}(YPZoL11xfd>bggPx;#&pFd;*#Yx%TtN1cp)MuHf z+Z*5CG_AFPwk624V9@&aL0;=@Ql=2h6aJoqWx|hPQQzdF{e7|fe(m){0==hk_!$ou zI|p_?kzdO9&d^GBS1u+$>JE-6Ov*o{mu@MF-?$r9V>i%;>>Fo~U`ac2hD*X}-gx*v z1&;@ey`rA0qNcD9-5;3_K&jg|qvn@m^+t?8(GTF0l#|({Zwp^5Ywik@bW9mN+5`MU zJ#_Ju|jtsq{tv)xA zY$5SnHgHj}c%qlQG72VS_(OSv;H~1GLUAegygT3T-J{<#h}))pk$FjfRQ+Kr%`2ZiI)@$96Nivh82#K@t>ze^H?R8wHii6Pxy z0o#T(lh=V>ZD6EXf0U}sG~nQ1dFI`bx;vivBkYSVkxXn?yx1aGxbUiNBawMGad;6? zm{zp?xqAoogt=I2H0g@826=7z^DmTTLB11byYvAO;ir|O0xmNN3Ec0w%yHO({-%q(go%?_X{LP?=E1uXoQgrEGOfL1?~ zI%uPHC23dn-RC@UPs;mxq6cFr{UrgG@e3ONEL^SoxFm%kE^LBhe_D6+Ia+u0J=)BC zf8FB!0J$dYg33jb2SxfmkB|8qeN&De!%r5|@H@GiqReK(YEpnXC;-v~*o<#JmYuze zW}p-K=9?0=*fZyYTE7A}?QR6}m_vMPK!r~y*6%My)d;x4R?-=~MMLC_02KejX9q6= z4sUB4AD0+H4ulSYz4;6mL8uaD07eXFvpy*i5X@dmx--+9`ur@rcJ5<L#s%nq3MRi4Dpr;#28}dl36M{MkVs4+Fm3Pjo5qSV)h}i(2^$Ty|<7N z>*LiBzFKH30D!$@n^3B@HYI_V1?yM(G$2Ml{oZ}?frfPU+{i|dHQOP^M0N2#NN_$+ zs*E=MXUOd=$Z2F4jSA^XIW=?KN=w6{_vJ4f(ZYhLxvFtPozPJv9k%7+z!Zj+_0|HC zMU0(8`8c`Sa=%e$|Mu2+CT22Ifbac@7Vn*he`|6Bl81j`44IRcTu8aw_Y%;I$Hnyd zdWz~I!tkWuGZx4Yjof(?jM;exFlUsrj5qO=@2F;56&^gM9D^ZUQ!6TMMUw19zslEu zwB^^D&nG96Y+Qwbvgk?Zmkn9%d{+V;DGKmBE(yBWX6H#wbaAm&O1U^ zS4YS7j2!1LDC6|>cfdQa`}_^satOz6vc$BfFIG07LoU^IhVMS_u+N=|QCJao0{F>p z-^UkM)ODJW9#9*o;?LPCRV1y~k9B`&U)jbTdvuxG&2%!n_Z&udT=0mb@e;tZ$_l3bj6d0K2;Ya!&)q`A${SmdG_*4WfjubB)Mn+vaLV+)L5$yD zYSTGxpVok&fJDG9iS8#oMN{vQneO|W{Y_xL2Hhb%YhQJgq7j~X7?bcA|B||C?R=Eo z!z;=sSeKiw4mM$Qm>|aIP3nw36Tbh6Eml?hL#&PlR5xf9^vQGN6J8op1dpLfwFg}p zlqYx$610Zf?=vCbB_^~~(e4IMic7C}X(L6~AjDp^;|=d$`=!gd%iwCi5E9<6Y~z0! zX8p$qprEadiMgq>gZ_V~n$d~YUqqqsL#BE6t9ufXIUrs@DCTfGg^-Yh5Ms(wD1xAf zTX8g52V!jr9TlWLl+whcUDv?Rc~JmYs3haeG*UnV;4bI=;__i?OSk)bF3=c9;qTdP zeW1exJwD+;Q3yAw9j_42Zj9nuvs%qGF=6I@($2Ue(a9QGRMZTd4ZAlxbT5W~7(alP1u<^YY!c3B7QV z@jm$vn34XnA6Gh1I)NBgTmgmR=O1PKp#dT*mYDPRZ=}~X3B8}H*e_;;BHlr$FO}Eq zJ9oWk0y#h;N1~ho724x~d)A4Z-{V%F6#e5?Z^(`GGC}sYp5%DKnnB+i-NWxwL-CuF+^JWNl`t@VbXZ{K3#aIX+h9-{T*+t(b0BM&MymW9AA*{p^&-9 zWpWQ?*z(Yw!y%AoeoYS|E!(3IlLksr@?Z9Hqlig?Q4|cGe;0rg#FC}tXTmTNfpE}; z$sfUYEG@hLHUb$(K{A{R%~%6MQN|Bu949`f#H6YC*E(p3lBBKcx z-~Bsd6^QsKzB0)$FteBf*b3i7CN4hccSa-&lfQz4qHm>eC|_X!_E#?=`M(bZ{$cvU zZpMbr|4omp`s9mrgz@>4=Fk3~8Y7q$G{T@?oE0<(I91_t+U}xYlT{c&6}zPAE8ikT z3DP!l#>}i!A(eGT+@;fWdK#(~CTkwjs?*i4SJVBuNB2$6!bCRmcm6AnpHHvnN8G<| zuh4YCYC%5}Zo;BO1>L0hQ8p>}tRVx~O89!${_NXhT!HUoGj0}bLvL2)qRNt|g*q~B z7U&U7E+8Ixy1U`QT^&W@ZSRN|`_Ko$-Mk^^c%`YzhF(KY9l5))1jSyz$&>mWJHZzHt0Jje%BQFxEV}C00{|qo5_Hz7c!FlJ|T(JD^0*yjkDm zL}4S%JU(mBV|3G2jVWU>DX413;d+h0C3{g3v|U8cUj`tZL37Sf@1d*jpwt4^B)`bK zZdlwnPB6jfc7rIKsldW81$C$a9BukX%=V}yPnaBz|i6(h>S)+Bn44@i8RtBZf0XetH&kAb?iAL zD%Ge{>Jo3sy2hgrD?15PM}X_)(6$LV`&t*D`IP)m}bzM)+x-xRJ zavhA)>hu2cD;LUTvN38FEtB94ee|~lIvk~3MBPzmTsN|7V}Kzi!h&za#NyY zX^0BnB+lfBuW!oR#8G&S#Er2bCVtA@5FI`Q+a-e?G)LhzW_chWN-ZQmjtR

eWu-UOPu^G}|k=o=;ffg>8|Z*qev7qS&oqA7%Z{4Ezb!t$f3& z^NuT8CSNp`VHScyikB1YO{BgaBVJR&>dNIEEBwYkfOkWN;(I8CJ|vIfD}STN z{097)R9iC@6($s$#dsb*4BXBx7 zb{6S2O}QUk>upEfij9C2tjqWy7%%V@Xfpe)vo6}PG+hmuY1Tc}peynUJLLmm)8pshG zb}HWl^|sOPtYk)CD-7{L+l(=F zOp}fX8)|n{JDa&9uI!*@jh^^9qP&SbZ(xxDhR)y|bjnn|K3MeR3gl6xcvh9uqzb#K zYkVjnK$;lUky~??mcqN-)d5~mk{wXhrf^<)!Jjqc zG~hX0P_@KvOKwV=X9H&KR3GnP3U)DfqafBt$e10}iuVRFBXx@uBQ)sn0J%%c<;R+! zQz;ETTVa+ma>+VF%U43w?_F6s0=x@N2(oisjA7LUOM<$|6iE|$WcO67W|KY8JUV_# zg7P9K3Yo-c*;EmbsqT!M4(WT`%9uk+s9Em-yB0bE{B%F4X<8fT!%4??vezaJ(wJhj zfOb%wKfkY3RU}7^FRq`UEbB-#A-%7)NJQwQd1As=!$u#~2vQ*CE~qp`u=_kL<`{OL zk>753UqJVx1-4~+d@(pnX-i zV4&=eRWbJ)9YEGMV53poXpv$vd@^yd05z$$@i5J7%>gYKBx?mR2qGv&BPn!tE-_aW zg*C!Z&!B zH>3J16dTJC(@M0*kIc}Jn}jf=f*agba|!HVm|^@+7A?V>Woo!$SJko*Jv1mu>;d}z z^vF{3u5Mvo_94`4kq2&R2`32oyoWc2lJco3`Ls0Ew4E7*AdiMbn^LCV%7%mU)hr4S3UVJjDLUoIKRQ)gm?^{1Z}OYzd$1?a~tEY ztjXmIM*2_qC|OC{7V%430T?RsY?ZLN$w!bkDOQ0}wiq69){Kdu3SqW?NMC))S}zq^ zu)w!>E1!;OrXO!RmT?m&PA;YKUjJy5-Seu=@o;m4*Vp$0OipBl4~Ub)1xBdWkZ47=UkJd$`Z}O8ZbpGN$i_WtY^00`S8=EHG#Ff{&MU1L(^wYjTchB zMTK%1LZ(eLLP($0UR2JVLaL|C2~IFbWirNjp|^=Fl48~Sp9zNOCZ@t&;;^avfN(NpNfq}~VYA{q%yjHo4D>JB>XEv(~Z!`1~SoY=9v zTq;hrjObE_h)cmHXLJ>LC_&XQ2BgGfV}e#v}ZF}iF97bG`Nog&O+SA`2zsn%bbB309}I$ zYi;vW$k@fC^muYBL?XB#CBuhC&^H)F4E&vw(5Q^PF{7~}(b&lF4^%DQzL0(BVk?lM zTHXTo4?Ps|dRICEiux#y77_RF8?5!1D-*h5UY&gRY`WO|V`xxB{f{DHzBwvt1W==r zdfAUyd({^*>Y7lObr;_fO zxDDw7X^dO`n!PLqHZ`by0h#BJ-@bAFPs{yJQ~Ylj^M5zWsxO_WFHG}8hH>OK{Q)9` zSRP94d{AM(q-2x0yhK@aNMv!qGA5@~2tB;X?l{Pf?DM5Y*QK`{mGA? zjx;gwnR~#Nep12dFk<^@-U{`&`P1Z}Z3T2~m8^J&7y}GaMElsTXg|GqfF3>E#HG=j zMt;6hfbfjHSQ&pN9(AT8q$FLKXo`N(WNHDY!K6;JrHZCO&ISBdX`g8sXvIf?|8 zX$-W^ut!FhBxY|+R49o44IgWHt}$1BuE|6|kvn1OR#zhyrw}4H*~cpmFk%K(CTGYc zNkJ8L$eS;UYDa=ZHWZy`rO`!w0oIcgZnK&xC|93#nHvfb^n1xgxf{$LB`H1ao+OGb zKG_}>N-RHSqL(RBdlc7J-Z$Gaay`wEGJ_u-lo88{`aQ*+T~+x(H5j?Q{uRA~>2R+} zB+{wM2m?$->unwg8-GaFrG%ZmoHEceOj{W21)Mi2lAfT)EQuNVo+Do%nHPuq7Ttt7 z%^6J5Yo64dH671tOUrA7I2hL@HKZq;S#Ejxt;*m-l*pPj?=i`=E~FAXAb#QH+a}-% z#3u^pFlg%p{hGiIp>05T$RiE*V7bPXtkz(G<+^E}Risi6F!R~Mbf(Qz*<@2&F#vDr zaL#!8!&ughWxjA(o9xtK{BzzYwm_z2t*c>2jI)c0-xo8ahnEqZ&K;8uF*!Hg0?Gd* z=eJK`FkAr>7$_i$;kq3Ks5NNJkNBnw|1f-&Ys56c9Y@tdM3VTTuXOCbWqye9va6+ZSeF0eh} zYb^ct&4lQTfNZ3M3(9?{;s><(zq%hza7zcxlZ+`F8J*>%4wq8s$cC6Z=F@ zhbvdv;n$%vEI$B~B)Q&LkTse!8Vt};7Szv2@YB!_Ztp@JA>rc(#R1`EZcIdE+JiI% zC2!hgYt+~@%xU?;ir+g92W`*j z3`@S;I6@2rO28zqj&SWO^CvA5MeNEhBF+8-U0O0Q1Co=I^WvPl%#}UFDMBVl z5iXV@d|`QTa$>iw;m$^}6JeuW zjr;{)S2TfK0Q%xgHvONSJb#NA|LOmg{U=k;R?&1tQbylMEY4<1*9mJh&(qo`G#9{X zYRs)#*PtEHnO;PV0G~6G`ca%tpKgb6<@)xc^SQY58lTo*S$*sv5w7bG+8YLKYU`8{ zNBVlvgaDu7icvyf;N&%42z2L4(rR<*Jd48X8Jnw zN>!R$%MZ@~Xu9jH?$2Se&I|ZcW>!26BJP?H7og0hT(S`nXh6{sR36O^7%v=31T+eL z)~BeC)15v>1m#(LN>OEwYFG?TE0_z)MrT%3SkMBBjvCd6!uD+03Jz#!s#Y~b1jf>S z&Rz5&8rbLj5!Y;(Hx|UY(2aw~W(8!3q3D}LRE%XX(@h5TnP@PhDoLVQx;6|r^+Bvs zaR55cR%Db9hZ<<|I%dDkone+8Sq7dqPOMnGoHk~-R*#a8w$c)`>4U`k+o?2|E>Sd4 zZ0ZVT{95pY$qKJ54K}3JB!(WcES>F+x56oJBRg))tMJ^#Qc(2rVcd5add=Us6vpBNkIg9b#ulk%!XBU zV^fH1uY(rGIAiFew|z#MM!qsVv%ZNb#why9%9In4Kj-hDYtMdirWLFzn~de!nnH(V zv0>I3;X#N)bo1$dFzqo(tzmvqNUKraAz~?)OSv42MeM!OYu;2VKn2-s7#fucX`|l~ zplxtG1Pgk#(;V=`P_PZ`MV{Bt4$a7;aLvG@KQo%E=;7ZO&Ws-r@XL+AhnPn>PAKc7 zQ_iQ4mXa-a4)QS>cJzt_j;AjuVCp8g^|dIV=DI0>v-f_|w5YWAX61lNBjZEZax3aV znher(j)f+a9_s8n#|u=kj0(unR1P-*L7`{F28xv054|#DMh}q=@rs@-fbyf(2+52L zN>hn3v!I~%jfOV=j(@xLOsl$Jv-+yR5{3pX)$rIdDarl7(C3)})P`QoHN|y<<2n;` zJ0UrF=Zv}d=F(Uj}~Yv9(@1pqUSRa5_bB*AvQ|Z-6YZ*N%p(U z<;Bpqr9iEBe^LFF!t{1UnRtaH-9=@p35fMQJ~1^&)(2D|^&z?m z855r&diVS6}jmt2)A7LZDiv;&Ys6@W5P{JHY!!n7W zvj3(2{1R9Y=TJ|{^2DK&be*ZaMiRHw>WVI^701fC) zAp1?8?oiU%Faj?Qhou6S^d11_7@tEK-XQ~%q!!7hha-Im^>NcRF7OH7s{IO7arZQ{ zE8n?2><7*!*lH}~usWPWZ}2&M+)VQo7C!AWJSQc>8g_r-P`N&uybK5)p$5_o;+58Q z-Ux2l<3i|hxqqur*qAfHq=)?GDchq}ShV#m6&w|mi~ar~`EO_S=fb~<}66U>5i7$H#m~wR;L~4yHL2R&;L*u7-SPdHxLS&Iy76q$2j#Pe)$WulRiCICG*t+ zeehM8`!{**KRL{Q{8WCEFLXu3+`-XF(b?c1Z~wg?c0lD!21y?NLq?O$STk3NzmrHM zsCgQS5I+nxDH0iyU;KKjzS24GJmG?{D`08|N-v+Egy92lBku)fnAM<}tELA_U`)xKYb=pq|hejMCT1-rg0Edt6(*E9l9WCKI1a=@c99swp2t6Tx zFHy`8Hb#iXS(8c>F~({`NV@F4w0lu5X;MH6I$&|h*qfx{~DJ*h5e|61t1QP}tZEIcjC%!Fa)omJTfpX%aI+OD*Y(l|xc0$1Zip;4rx; zV=qI!5tSuXG7h?jLR)pBEx!B15HCoVycD&Z2dlqN*MFQDb!|yi0j~JciNC!>){~ zQQgmZvc}0l$XB0VIWdg&ShDTbTkArryp3x)T8%ulR;Z?6APx{JZyUm=LC-ACkFm`6 z(x7zm5ULIU-xGi*V6x|eF~CN`PUM%`!4S;Uv_J>b#&OT9IT=jx5#nydC4=0htcDme zDUH*Hk-`Jsa>&Z<7zJ{K4AZE1BVW%zk&MZ^lHyj8mWmk|Pq8WwHROz0Kwj-AFqvR)H2gDN*6dzVk>R3@_CV zw3Z@6s^73xW)XY->AFwUlk^4Q=hXE;ckW=|RcZFchyOM0vqBW{2l*QR#v^SZNnT6j zZv|?ZO1-C_wLWVuYORQryj29JA; zS4BsxfVl@X!W{!2GkG9fL4}58Srv{$-GYngg>JuHz!7ZPQbfIQr4@6ZC4T$`;Vr@t zD#-uJ8A!kSM*gA&^6yWi|F}&59^*Rx{qn3z{(JYxrzg!X2b#uGd>&O0e=0k_2*N?3 zYXV{v={ONL{rW~z_FtFj7kSSJZ?s);LL@W&aND7blR8rlvkAb48RwJZlOHA~t~RfC zOD%ZcOzhYEV&s9%qns0&ste5U!^MFWYn`Od()5RwIz6%@Ek+Pn`s79unJY-$7n-Uf z&eUYvtd)f7h7zG_hDiFC!psCg#q&0c=GHKOik~$$>$Fw*k z;G)HS$IR)Cu72HH|JjeeauX;U6IgZ_IfxFCE_bGPAU25$!j8Etsl0Rk@R`$jXuHo8 z3Hhj-rTR$Gq(x)4Tu6;6rHQhoCvL4Q+h0Y+@Zdt=KTb0~wj7-(Z9G%J+aQu05@k6JHeCC|YRFWGdDCV}ja;-yl^9<`>f=AwOqML1a~* z9@cQYb?!+Fmkf}9VQrL8$uyq8k(r8)#;##xG9lJ-B)Fg@15&To(@xgk9SP*bkHlxiy8I*wJQylh(+9X~H-Is!g&C!q*eIYuhl&fS&|w)dAzXBdGJ&Mp$+8D| zZaD<+RtjI90QT{R0YLk6_dm=GfCg>7;$ zlyLsNYf@MfLH<}ott5)t2CXiQos zFLt^`%ygB2Vy^I$W3J_Rt4olRn~Gh}AW(`F@LsUN{d$sR%bU&3;rsD=2KCL+4c`zv zlI%D>9-)U&R3;>d1Vdd5b{DeR!HXDm44Vq*u?`wziLLsFUEp4El;*S0;I~D#TgG0s zBXYZS{o|Hy0A?LVNS)V4c_CFwyYj-E#)4SQq9yaf`Y2Yhk7yHSdos~|fImZG5_3~~o<@jTOH@Mc7`*xn-aO5F zyFT-|LBsm(NbWkL^oB-Nd31djBaYebhIGXhsJyn~`SQ6_4>{fqIjRp#Vb|~+Qi}Mdz!Zsw= zz?5L%F{c{;Cv3Q8ab>dsHp)z`DEKHf%e9sT(aE6$az?A}3P`Lm(~W$8Jr=;d8#?dm_cmv>2673NqAOenze z=&QW`?TQAu5~LzFLJvaJ zaBU3mQFtl5z?4XQDBWNPaH4y)McRpX#$(3o5Nx@hVoOYOL&-P+gqS1cQ~J;~1roGH zVzi46?FaI@w-MJ0Y7BuAg*3;D%?<_OGsB3)c|^s3A{UoAOLP8scn`!5?MFa|^cTvq z#%bYG3m3UO9(sH@LyK9-LSnlVcm#5^NRs9BXFtRN9kBY2mPO|@b7K#IH{B{=0W06) zl|s#cIYcreZ5p3j>@Ly@35wr-q8z5f9=R42IsII=->1stLo@Q%VooDvg@*K(H@*5g zUPS&cM~k4oqp`S+qp^*nxzm^0mg3h8ppEHQ@cXyQ=YKV-6)FB*$KCa{POe2^EHr{J zOxcVd)s3Mzs8m`iV?MSp=qV59blW9$+$P+2;PZDRUD~sr*CQUr&EDiCSfH@wuHez+ z`d5p(r;I7D@8>nbZ&DVhT6qe+accH;<}q$8Nzz|d1twqW?UV%FMP4Y@NQ`3(+5*i8 zP9*yIMP7frrneG3M9 zf>GsjA!O#Bifr5np-H~9lR(>#9vhE6W-r`EjjeQ_wdWp+rt{{L5t5t(Ho|4O24@}4 z_^=_CkbI`3;~sXTnnsv=^b3J}`;IYyvb1gM>#J9{$l#Zd*W!;meMn&yXO7x`Epx_Y zm-1wlu~@Ii_7D}>%tzlXW;zQT=uQXSG@t$<#6-W*^vy7Vr2TCpnix@7!_|aNXEnN<-m?Oq;DpN*x6f>w za1Wa5entFEDtA0SD%iZv#3{wl-S`0{{i3a9cmgNW`!TH{J*~{@|5f%CKy@uk*8~af zt_d34U4y&3y9IZ5cXxLQ?(XjH5?q3Z0KxK~y!-CUyWG6{<)5lkhbox0HnV&7^zNBn zjc|?X!Y=63(Vg>#&Wx%=LUr5{i@~OdzT#?P8xu#P*I_?Jl7xM4dq)4vi}3Wj_c=XI zSbc)@Q2Et4=(nBDU{aD(F&*%Ix!53_^0`+nOFk)}*34#b0Egffld|t_RV91}S0m)0 zap{cQDWzW$geKzYMcDZDAw480!1e1!1Onpv9fK9Ov~sfi!~OeXb(FW)wKx335nNY! za6*~K{k~=pw`~3z!Uq%?MMzSl#s%rZM{gzB7nB*A83XIGyNbi|H8X>a5i?}Rs+z^; z2iXrmK4|eDOu@{MdS+?@(!-Ar4P4?H_yjTEMqm7`rbV4P275(-#TW##v#Dt14Yn9UB-Sg3`WmL0+H~N;iC`Mg%pBl?1AAOfZ&e; z*G=dR>=h_Mz@i;lrGpIOQwezI=S=R8#);d*;G8I(39ZZGIpWU)y?qew(t!j23B9fD z?Uo?-Gx3}6r8u1fUy!u)7LthD2(}boE#uhO&mKBau8W8`XV7vO>zb^ZVWiH-DOjl2 zf~^o1CYVU8eBdmpAB=T%i(=y}!@3N%G-*{BT_|f=egqtucEtjRJJhSf)tiBhpPDpgzOpG12UgvOFnab&16Zn^2ZHjs)pbd&W1jpx%%EXmE^ zdn#R73^BHp3w%&v!0~azw(Fg*TT*~5#dJw%-UdxX&^^(~V&C4hBpc+bPcLRZizWlc zjR;$4X3Sw*Rp4-o+a4$cUmrz05RucTNoXRINYG*DPpzM&;d1GNHFiyl(_x#wspacQ zL)wVFXz2Rh0k5i>?Ao5zEVzT)R(4Pjmjv5pzPrav{T(bgr|CM4jH1wDp6z*_jnN{V ziN56m1T)PBp1%`OCFYcJJ+T09`=&=Y$Z#!0l0J2sIuGQtAr>dLfq5S;{XGJzNk@a^ zk^eHlC4Gch`t+ue3RviiOlhz81CD9z~d|n5;A>AGtkZMUQ#f>5M14f2d}2 z8<*LNZvYVob!p9lbmb!0jt)xn6O&JS)`}7v}j+csS3e;&Awj zoNyjnqLzC(QQ;!jvEYUTy73t_%16p)qMb?ihbU{y$i?=a7@JJoXS!#CE#y}PGMK~3 zeeqqmo7G-W_S97s2eed^erB2qeh4P25)RO1>MH7ai5cZJTEevogLNii=oKG)0(&f` z&hh8cO{of0;6KiNWZ6q$cO(1)9r{`}Q&%p*O0W7N--sw3Us;)EJgB)6iSOg(9p_mc zRw{M^qf|?rs2wGPtjVKTOMAfQ+ZNNkb$Ok0;Pe=dNc7__TPCzw^H$5J0l4D z%p(_0w(oLmn0)YDwrcFsc*8q)J@ORBRoZ54GkJpxSvnagp|8H5sxB|ZKirp%_mQt_ z81+*Y8{0Oy!r8Gmih48VuRPwoO$dDW@h53$C)duL4_(osryhwZSj%~KsZ?2n?b`Z* z#C8aMdZxYmCWSM{mFNw1ov*W}Dl=%GQpp90qgZ{(T}GOS8#>sbiEU;zYvA?=wbD5g+ahbd1#s`=| zV6&f#ofJC261~Ua6>0M$w?V1j##jh-lBJ2vQ%&z`7pO%frhLP-1l)wMs=3Q&?oth1 zefkPr@3Z(&OL@~|<0X-)?!AdK)ShtFJ;84G2(izo3cCuKc{>`+aDoziL z6gLTL(=RYeD7x^FYA%sPXswOKhVa4i(S4>h&mLvS##6-H?w8q!B<8Alk>nQEwUG)SFXK zETfcTwi=R3!ck|hSM`|-^N3NWLav&UTO{a9=&Tuz-Kq963;XaRFq#-1R18fi^Gb-; zVO>Q{Oe<^b0WA!hkBi9iJp3`kGwacXX2CVQ0xQn@Y2OhrM%e4)Ea7Y*Df$dY2BpbL zv$kX}*#`R1uNA(7lk_FAk~{~9Z*Si5xd(WKQdD&I?8Y^cK|9H&huMU1I(251D7(LL z+){kRc=ALmD;#SH#YJ+|7EJL6e~w!D7_IrK5Q=1DCulUcN(3j`+D_a|GP}?KYx}V+ zx_vLTYCLb0C?h;e<{K0`)-|-qfM16y{mnfX(GGs2H-;-lRMXyb@kiY^D;i1haxoEk zsQ7C_o2wv?;3KS_0w^G5#Qgf*>u)3bT<3kGQL-z#YiN9QH7<(oDdNlSdeHD zQJN-U*_wJM_cU}1YOH=m>DW~{%MAPxL;gLdU6S5xLb$gJt#4c2KYaEaL8ORWf=^(l z-2`8^J;&YG@vb9em%s~QpU)gG@24BQD69;*y&-#0NBkxumqg#YYomd2tyo0NGCr8N z5<5-E%utH?Ixt!(Y4x>zIz4R^9SABVMpLl(>oXnBNWs8w&xygh_e4*I$y_cVm?W-^ ze!9mPy^vTLRclXRGf$>g%Y{(#Bbm2xxr_Mrsvd7ci|X|`qGe5=54Zt2Tb)N zlykxE&re1ny+O7g#`6e_zyjVjRi5!DeTvSJ9^BJqQ*ovJ%?dkaQl!8r{F`@KuDEJB3#ho5 zmT$A&L=?}gF+!YACb=%Y@}8{SnhaGCHRmmuAh{LxAn0sg#R6P_^cJ-9)+-{YU@<^- zlYnH&^;mLVYE+tyjFj4gaAPCD4CnwP75BBXA`O*H(ULnYD!7K14C!kGL_&hak)udZ zkQN8)EAh&9I|TY~F{Z6mBv7sz3?<^o(#(NXGL898S3yZPTaT|CzZpZ~pK~*9Zcf2F zgwuG)jy^OTZD`|wf&bEdq4Vt$ir-+qM7BosXvu`>W1;iFN7yTvcpN_#at)Q4n+(Jh zYX1A-24l9H5jgY?wdEbW{(6U1=Kc?Utren80bP`K?J0+v@{-RDA7Y8yJYafdI<7-I z_XA!xeh#R4N7>rJ_?(VECa6iWhMJ$qdK0Ms27xG&$gLAy(|SO7_M|AH`fIY)1FGDp zlsLwIDshDU;*n`dF@8vV;B4~jRFpiHrJhQ6TcEm%OjWTi+KmE7+X{19 z>e!sg0--lE2(S0tK}zD&ov-{6bMUc%dNFIn{2^vjXWlt>+uxw#d)T6HNk6MjsfN~4 zDlq#Jjp_!wn}$wfs!f8NX3Rk#9)Q6-jD;D9D=1{$`3?o~caZjXU*U32^JkJ$ZzJ_% zQWNfcImxb!AV1DRBq`-qTV@g1#BT>TlvktYOBviCY!13Bv?_hGYDK}MINVi;pg)V- z($Bx1Tj`c?1I3pYg+i_cvFtcQ$SV9%%9QBPg&8R~Ig$eL+xKZY!C=;M1|r)$&9J2x z;l^a*Ph+isNl*%y1T4SviuK1Nco_spQ25v5-}7u?T9zHB5~{-+W*y3p{yjn{1obqf zYL`J^Uz8zZZN8c4Dxy~)k3Ws)E5eYi+V2C!+7Sm0uu{xq)S8o{9uszFTnE>lPhY=5 zdke-B8_*KwWOd%tQs_zf0x9+YixHp+Qi_V$aYVc$P-1mg?2|_{BUr$6WtLdIX2FaF zGmPRTrdIz)DNE)j*_>b9E}sp*(1-16}u za`dgT`KtA3;+e~9{KV48RT=CGPaVt;>-35}%nlFUMK0y7nOjoYds7&Ft~#>0$^ciZ zM}!J5Mz{&|&lyG^bnmh?YtR z*Z5EfDxkrI{QS#Iq752aiA~V)DRlC*2jlA|nCU!@CJwxO#<=j6ssn;muv zhBT9~35VtwsoSLf*(7vl&{u7d_K_CSBMbzr zzyjt&V5O#8VswCRK3AvVbS7U5(KvTPyUc0BhQ}wy0z3LjcdqH8`6F3!`)b3(mOSxL z>i4f8xor(#V+&#ph~ycJMcj#qeehjxt=~Na>dx#Tcq6Xi4?BnDeu5WBBxt603*BY& zZ#;o1kv?qpZjwK-E{8r4v1@g*lwb|8w@oR3BTDcbiGKs)a>Fpxfzh&b ziQANuJ_tNHdx;a*JeCo^RkGC$(TXS;jnxk=dx++D8|dmPP<0@ z$wh#ZYI%Rx$NKe-)BlJzB*bot0ras3I%`#HTMDthGtM_G6u-(tSroGp1Lz+W1Y`$@ zP`9NK^|IHbBrJ#AL3!X*g3{arc@)nuqa{=*2y+DvSwE=f*{>z1HX(>V zNE$>bbc}_yAu4OVn;8LG^naq5HZY zh{Hec==MD+kJhy6t=Nro&+V)RqORK&ssAxioc7-L#UQuPi#3V2pzfh6Ar400@iuV5 z@r>+{-yOZ%XQhsSfw%;|a4}XHaloW#uGluLKux0II9S1W4w=X9J=(k&8KU()m}b{H zFtoD$u5JlGfpX^&SXHlp$J~wk|DL^YVNh2w(oZ~1*W156YRmenU;g=mI zw({B(QVo2JpJ?pJqu9vijk$Cn+%PSw&b4c@uU6vw)DjGm2WJKt!X}uZ43XYlDIz%& z=~RlgZpU-tu_rD`5!t?289PTyQ zZgAEp=zMK>RW9^~gyc*x%vG;l+c-V?}Bm;^{RpgbEnt_B!FqvnvSy)T=R zGa!5GACDk{9801o@j>L8IbKp#!*Td5@vgFKI4w!5?R{>@^hd8ax{l=vQnd2RDHopo zwA+qb2cu4Rx9^Bu1WNYT`a(g}=&&vT`&Sqn-irxzX_j1=tIE#li`Hn=ht4KQXp zzZj`JO+wojs0dRA#(bXBOFn**o+7rPY{bM9m<+UBF{orv$#yF8)AiOWfuas5Fo`CJ zqa;jAZU^!bh8sjE7fsoPn%Tw11+vufr;NMm3*zC=;jB{R49e~BDeMR+H6MGzDlcA^ zKg>JEL~6_6iaR4i`tSfUhkgPaLXZ<@L7poRF?dw_DzodYG{Gp7#24<}=18PBT}aY` z{)rrt`g}930jr3^RBQNA$j!vzTh#Mo1VL`QCA&US?;<2`P+xy8b9D_Hz>FGHC2r$m zW>S9ywTSdQI5hh%7^e`#r#2906T?))i59O(V^Rpxw42rCAu-+I3y#Pg6cm#&AX%dy ze=hv0cUMxxxh1NQEIYXR{IBM&Bk8FK3NZI3z+M>r@A$ocd*e%x-?W;M0pv50p+MVt zugo<@_ij*6RZ;IPtT_sOf2Zv}-3R_1=sW37GgaF9Ti(>V z1L4ju8RzM%&(B}JpnHSVSs2LH#_&@`4Kg1)>*)^i`9-^JiPE@=4l$+?NbAP?44hX&XAZy&?}1;=8c(e0#-3bltVWg6h=k!(mCx=6DqOJ-I!-(g;*f~DDe={{JGtH7=UY|0F zNk(YyXsGi;g%hB8x)QLpp;;`~4rx>zr3?A|W$>xj>^D~%CyzRctVqtiIz7O3pc@r@JdGJiH@%XR_9vaYoV?J3K1cT%g1xOYqhXfSa`fg=bCLy% zWG74UTdouXiH$?H()lyx6QXt}AS)cOa~3IdBxddcQp;(H-O}btpXR-iwZ5E)di9Jf zfToEu%bOR11xf=Knw7JovRJJ#xZDgAvhBDF<8mDu+Q|!}Z?m_=Oy%Ur4p<71cD@0OGZW+{-1QT?U%_PJJ8T!0d2*a9I2;%|A z9LrfBU!r9qh4=3Mm3nR_~X-EyNc<;?m`?dKUNetCnS)}_-%QcWuOpw zAdZF`4c_24z&m{H9-LIL`=Hrx%{IjrNZ~U<7k6p{_wRkR84g>`eUBOQd3x5 zT^kISYq)gGw?IB8(lu1=$#Vl?iZdrx$H0%NxW)?MO$MhRHn8$F^&mzfMCu>|`{)FL z`ZgOt`z%W~^&kzMAuWy9=q~$ldBftH0}T#(K5e8;j~!x$JjyspJ1IISI?ON5OIPB$ z-5_|YUMb+QUsiv3R%Ys4tVYW+x$}dg;hw%EdoH%SXMp`)v?cxR4wic{X9pVBH>=`#`Kcj!}x4 zV!`6tj|*q?jZdG(CSevn(}4Ogij5 z-kp;sZs}7oNu0x+NHs~(aWaKGV@l~TBkmW&mPj==N!f|1e1SndS6(rPxsn7dz$q_{ zL0jSrihO)1t?gh8N zosMjR3n#YC()CVKv zos2TbnL&)lHEIiYdz|%6N^vAUvTs6?s|~kwI4uXjc9fim`KCqW3D838Xu{48p$2?I zOeEqQe1}JUZECrZSO_m=2<$^rB#B6?nrFXFpi8jw)NmoKV^*Utg6i8aEW|^QNJuW& z4cbXpHSp4|7~TW(%JP%q9W2~@&@5Y5%cXL#fMhV59AGj<3$Hhtfa>24DLk{7GZUtr z5ql**-e58|mbz%5Kk~|f!;g+Ze^b);F+5~^jdoq#m+s?Y*+=d5ruym%-Tnn8htCV; zDyyUrWydgDNM&bI{yp<_wd-q&?Ig+BN-^JjWo6Zu3%Eov^Ja>%eKqrk&7kUqeM8PL zs5D}lTe_Yx;e=K`TDya!-u%y$)r*Cr4bSfN*eZk$XT(Lv2Y}qj&_UaiTevxs_=HXjnOuBpmT> zBg|ty8?|1rD1~Ev^6=C$L9%+RkmBSQxlnj3j$XN?%QBstXdx+Vl!N$f2Ey`i3p@!f zzqhI3jC(TZUx|sP%yValu^nzEV96o%*CljO>I_YKa8wMfc3$_L()k4PB6kglP@IT#wBd*3RITYADL}g+hlzLYxFmCt=_XWS}=jg8`RgJefB57z(2n&&q>m ze&F(YMmoRZW7sQ;cZgd(!A9>7mQ2d#!-?$%G8IQ0`p1|*L&P$GnU0i0^(S;Rua4v8 z_7Qhmv#@+kjS-M|($c*ZOo?V2PgT;GKJyP1REABlZhPyf!kR(0UA7Bww~R<7_u6#t z{XNbiKT&tjne(&=UDZ+gNxf&@9EV|fblS^gxNhI-DH;|`1!YNlMcC{d7I{u_E~cJOalFEzDY|I?S3kHtbrN&}R3k zK(Ph_Ty}*L3Et6$cUW`0}**BY@44KtwEy(jW@pAt`>g> z&8>-TmJiDwc;H%Ae%k6$ndZlfKruu1GocgZrLN=sYI52}_I%d)~ z6z40!%W4I6ch$CE2m>Dl3iwWIbcm27QNY#J!}3hqc&~(F8K{^gIT6E&L!APVaQhj^ zjTJEO&?**pivl^xqfD(rpLu;`Tm1MV+Wtd4u>X6u5V{Yp%)xH$k410o{pGoKdtY0t@GgqFN zO=!hTcYoa^dEPKvPX4ukgUTmR#q840gRMMi%{3kvh9gt(wK;Fniqu9A%BMsq?U&B5DFXC8t8FBN1&UIwS#=S zF(6^Eyn8T}p)4)yRvs2rCXZ{L?N6{hgE_dkH_HA#L3a0$@UMoBw6RE9h|k_rx~%rB zUqeEPL|!Pbp|up2Q=8AcUxflck(fPNJYP1OM_4I(bc24a**Qnd-@;Bkb^2z8Xv?;3yZp*| zoy9KhLo=;8n0rPdQ}yAoS8eb zAtG5QYB|~z@Z(Fxdu`LmoO>f&(JzsO|v0V?1HYsfMvF!3| zka=}6U13(l@$9&=1!CLTCMS~L01CMs@Abl4^Q^YgVgizWaJa%{7t)2sVcZg0mh7>d z(tN=$5$r?s={yA@IX~2ot9`ZGjUgVlul$IU4N}{ zIFBzY3O0;g$BZ#X|VjuTPKyw*|IJ+&pQ` z(NpzU`o=D86kZ3E5#!3Ry$#0AW!6wZe)_xZ8EPidvJ0f+MQJZ6|ZJ$CEV6;Yt{OJnL`dewc1k>AGbkK9Gf5BbB-fg? zgC4#CPYX+9%LLHg@=c;_Vai_~#ksI~)5|9k(W()g6ylc(wP2uSeJ$QLATtq%e#zpT zp^6Y)bV+e_pqIE7#-hURQhfQvIZpMUzD8&-t$esrKJ}4`ZhT|woYi>rP~y~LRf`*2!6 z6prDzJ~1VOlYhYAuBHcu9m>k_F>;N3rpLg>pr;{EDkeQPHfPv~woj$?UTF=txmaZy z?RrVthxVcqUM;X*(=UNg4(L|0d250Xk)6GF&DKD@r6{aZo;(}dnO5@CP7pMmdsI)- zeYH*@#+|)L8x7)@GNBu0Npyyh6r z^~!3$x&w8N)T;|LVgnwx1jHmZn{b2V zO|8s#F0NZhvux?0W9NH5;qZ?P_JtPW86)4J>AS{0F1S0d}=L2`{F z_y;o;17%{j4I)znptnB z%No1W>o}H2%?~CFo~0j?pzWk?dV4ayb!s{#>Yj`ZJ!H)xn}*Z_gFHy~JDis)?9-P=z4iOQg{26~n?dTms7)+F}? zcXvnHHnnbNTzc!$t+V}=<2L<7l(84v1I3b;-)F*Q?cwLNlgg{zi#iS)*rQ5AFWe&~ zWHPPGy{8wEC9JSL?qNVY76=es`bA{vUr~L7f9G@mP}2MNF0Qhv6Sgs`r_k!qRbSXK zv16Qqq`rFM9!4zCrCeiVS~P2e{Pw^A8I?p?NSVR{XfwlQo*wj|Ctqz4X-j+dU7eGkC(2y`(P?FM?P4gKki3Msw#fM6paBq#VNc>T2@``L{DlnnA-_*i10Kre&@-H!Z7gzn9pRF61?^^ z8dJ5kEeVKb%Bly}6NLV}<0(*eZM$QTLcH#+@iWS^>$Of_@Mu1JwM!>&3evymgY6>C_)sK+n|A5G6(3RJz0k>(z2uLdzXeTw)e4*g!h} zn*UvIx-Ozx<3rCF#C`khSv`Y-b&R4gX>d5osr$6jlq^8vi!M$QGx05pJZoY#RGr*J zsJmOhfodAzYQxv-MoU?m_|h^aEwgEHt5h_HMkHwtE+OA03(7{hm1V?AlYAS7G$u5n zO+6?51qo@aQK5#l6pM`kD5OmI28g!J2Z{5kNlSuKl=Yj3QZ|bvVHU}FlM+{QV=<=) z+b|%Q!R)FE z@ycDMSKV2?*XfcAc5@IOrSI&3&aR$|oAD8WNA6O;p~q-J@ll{x`jP<*eEpIYOYnT zer_t=dYw6a0avjQtKN&#n&(KJ5Kr$RXPOp1@Fq#0Of zTXQkq4qQxKWR>x#d{Hyh?6Y)U07;Q$?BTl7mx2bSPY_juXub1 z%-$)NKXzE<%}q>RX25*oeMVjiz&r_z;BrQV-(u>!U>C*OisXNU*UftsrH6vAhTEm@ zoKA`?fZL1sdd!+G@*NNvZa>}37u^x8^T>VH0_6Bx{3@x5NAg&55{2jUE-w3zCJNJi z^IlU=+DJz-9K&4c@7iKj(zlj@%V}27?vYmxo*;!jZVXJMeDg;5T!4Y1rxNV-e$WAu zkk6^Xao8HC=w2hpLvM(!xwo|~$eG6jJj39zyQHf)E+NPJlfspUhzRv&_qr8+Z1`DA zz`EV=A)d=;2&J;eypNx~q&Ir_7e_^xXg(L9>k=X4pxZ3y#-ch$^TN}i>X&uwF%75c(9cjO6`E5 z16vbMYb!lEIM?jxn)^+Ld8*hmEXR4a8TSfqwBg1(@^8$p&#@?iyGd}uhWTVS`Mlpa zGc+kV)K7DJwd46aco@=?iASsx?sDjbHoDVU9=+^tk46|Fxxey1u)_}c1j z^(`5~PU%og1LdSBE5x4N&5&%Nh$sy0oANXwUcGa>@CCMqP`4W$ZPSaykK|giiuMIw zu#j)&VRKWP55I(5K1^cog|iXgaK1Z%wm%T;;M3X`-`TTWaI}NtIZj;CS)S%S(h}qq zRFQ#{m4Qk$7;1i*0PC^|X1@a1pcMq1aiRSCHq+mnfj^FS{oxWs0McCN-lK4>SDp#` z7=Duh)kXC;lr1g3dqogzBBDg6>et<<>m>KO^|bI5X{+eMd^-$2xfoP*&e$vdQc7J% zmFO~OHf7aqlIvg%P`Gu|3n;lKjtRd@;;x#$>_xU(HpZos7?ShZlQSU)bY?qyQM3cHh5twS6^bF8NBKDnJgXHa)? zBYv=GjsZuYC2QFS+jc#uCsaEPEzLSJCL=}SIk9!*2Eo(V*SAUqKw#?um$mUIbqQQb zF1Nn(y?7;gP#@ws$W76>TuGcG=U_f6q2uJq?j#mv7g;llvqu{Yk~Mo>id)jMD7;T> zSB$1!g)QpIf*f}IgmV;!B+3u(ifW%xrD=`RKt*PDC?M5KI)DO`VXw(7X-OMLd3iVU z0CihUN(eNrY;m?vwK{55MU`p1;JDF=6ITN$+!q8W#`iIsN8;W7H?`htf%RS9Lh+KQ z_p_4?qO4#*`t+8l-N|kAKDcOt zoHsqz_oO&n?@4^Mr*4YrkDX44BeS*0zaA1j@*c}{$;jUxRXx1rq7z^*NX6d`DcQ}L z6*cN7e%`2#_J4z8=^GM6>%*i>>X^_0u9qn%0JTUo)c0zIz|7a`%_UnB)-I1cc+ z0}jAK0}jBl|6-2VT759oxBnf%-;7vs>7Mr}0h3^$0`5FAy}2h{ps5%RJA|^~6uCqg zxBMK5bQVD{Aduh1lu4)`Up*&( zCJQ>nafDb#MuhSZ5>YmD@|TcrNv~Q%!tca;tyy8Iy2vu2CeA+AsV^q*Wohg%69XYq zP0ppEDEYJ9>Se&X(v=U#ibxg()m=83pLc*|otbG;`CYZ z*YgsakGO$E$E_$|3bns7`m9ARe%myU3$DE;RoQ<6hR8e;%`pxO1{GXb$cCZl9lVnJ$(c` z``G?|PhXaz`>)rb7jm2#v7=(W?@ zjUhrNndRFMQ}%^^(-nmD&J>}9w@)>l;mhRr@$}|4ueOd?U9ZfO-oi%^n4{#V`i}#f zqh<@f^%~(MnS?Z0xsQI|Fghrby<&{FA+e4a>c(yxFL!Pi#?DW!!YI{OmR{xEC7T7k zS_g*9VWI}d0IvIXx*d5<7$5Vs=2^=ews4qZGmAVyC^9e;wxJ%BmB(F5*&!yyABCtLVGL@`qW>X9K zpv=W~+EszGef=am3LG+#yIq5oLXMnZ_dxSLQ_&bwjC^0e8qN@v!p?7mg02H<9`uaJ zy0GKA&YQV2CxynI3T&J*m!rf4@J*eo235*!cB1zEMQZ%h5>GBF;8r37K0h?@|E*0A zIHUg0y7zm(rFKvJS48W7RJwl!i~<6X2Zw+Fbm9ekev0M;#MS=Y5P(kq^(#q11zsvq zDIppe@xOMnsOIK+5BTFB=cWLalK#{3eE>&7fd11>l2=MpNKjsZT2kmG!jCQh`~Fu0 z9P0ab`$3!r`1yz8>_7DYsO|h$kIsMh__s*^KXv?Z1O8|~sEz?Y{+GDzze^GPjk$E$ zXbA-1gd77#=tn)YKU=;JE?}De0)WrT%H9s3`fn|%YibEdyZov3|MJ>QWS>290eCZj z58i<*>dC9=kz?s$sP_9kK1p>nV3qvbleExyq56|o+oQsb{ZVmuu1n~JG z0sUvo_i4fSM>xRs8rvG$*+~GZof}&ISxn(2JU*K{L<3+b{bBw{68H&Uiup@;fWWl5 zgB?IWMab0LkXK(Hz#yq>scZbd2%=B?DO~^q9tarlzZysN+g}n0+v);JhbjUT8AYrt z3?;0r%p9zLJv1r$%q&HKF@;3~0wVwO!U5m;J`Mm|`Nc^80sZd+Wj}21*SPoF82hCF zoK?Vw;4ioafdAkZxT1er-LLVi-*0`@2Ur&*!b?0U>R;no+S%)xoBuBxRw$?weN-u~tKE}8xb@7Gs%(aC;e1-LIlSfXDK(faFW)mnHdrLc3`F z6ZBsT^u0uVS&il=>YVX^*5`k!P4g1)2LQmz{?&dgf`7JrA4ZeE0sikL`k!Eb6r=g0 z{aCy_0I>fxSAXQYz3lw5G|ivg^L@(x-uch!AphH+d;E4`175`R0#b^)Zp>EM1Ks=zx6_261>!7 z{7F#a{Tl@Tpw9S`>7_i|PbScS-(dPJv9_0-FBP_aa@Gg^2IoKNZM~#=sW$SH3MJ|{ zsQy8F43lX7hYx<{v^Q9`2QsMzeen3cGpiTgzVp- z`aj3&Wv0(he1qKI!2jpGpO-i0Wpcz%vdn`2o9x&3;^nsZPt3c \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 000000000..9618d8d96 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,100 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +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. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +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. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/java/shadersmodcore/client/DefaultTexture.java b/java/shadersmodcore/client/DefaultTexture.java deleted file mode 100644 index 03c1e6c64..000000000 --- a/java/shadersmodcore/client/DefaultTexture.java +++ /dev/null @@ -1,19 +0,0 @@ -package shadersmodcore.client; - -import net.minecraft.client.renderer.texture.AbstractTexture; -import net.minecraft.client.resources.IResourceManager; - -public class DefaultTexture extends AbstractTexture { - - public DefaultTexture() - { - loadTexture(null); - } - - @Override - public void loadTexture(IResourceManager resourcemanager) - { - int[] aint = ShadersTex.createAIntImage(1,0xFFFFFFFF); - ShadersTex.setupTexture(this.getMultiTexID(), aint, 1, 1, false, false); - } -} diff --git a/java/shadersmodcore/client/GuiShaders.java b/java/shadersmodcore/client/GuiShaders.java deleted file mode 100644 index 57f031296..000000000 --- a/java/shadersmodcore/client/GuiShaders.java +++ /dev/null @@ -1,355 +0,0 @@ -package shadersmodcore.client; - -import java.io.File; -import java.io.IOException; -import java.net.URI; -import java.util.ArrayList; -import java.util.List; - -import net.minecraft.client.Minecraft; -import net.minecraft.client.gui.GuiButton; -import net.minecraft.client.gui.GuiScreen; -import net.minecraft.client.renderer.Tessellator; -import net.minecraft.client.settings.GameSettings; - -import org.lwjgl.Sys; - -public class GuiShaders extends GuiScreen -{ - /** This GUI's parent GUI. */ - protected GuiScreen parentGui; - - private int updateTimer = -1; - public boolean needReinit; - - /* - private class GuiListShaderpacks { - int posX,posY,sizeX,sizeY; - int viewPosY; - int itemHeight = 20; - int selection; - ArrayList listShaderpacks; - public void draw() { - Tessellator tess = Tessellator.instance; - int listSize = listShaderpacks.size(); - int i,j; - for (i=viewPosY/itemHeight, j=Math.min((viewPosY+sizeY)/itemHeight,listSize); i=0 && val<=choices[i]; --i) {} - if (i<0) i=choices.length-1; - } - Shaders.configHandDepthMul = choices[i]; - par1GuiButton.displayString = "HandDepth: "+String.format("%.4f",Shaders.configHandDepthMul); - break; - } - - case 15: /* Render Resolution Multiplier */ - { - float val = Shaders.configRenderResMul; - float[] choices = { 0.25f,0.3333333333f,0.5f,0.7071067812f,1.0f,1.414213562f,2.0f }; - int i; - if (!isShiftKeyDown()) { - for (i=0; i=0 && val<=choices[i]; --i) {} - if (i<0) i=choices.length-1; - } - Shaders.configRenderResMul = choices[i]; - par1GuiButton.displayString = "RenderResMul: "+String.format("%.4f",Shaders.configRenderResMul); - Shaders.scheduleResize(); - break; - } - - case 16: /* Shadow Resolution Multiplier */ - { - float val = Shaders.configShadowResMul; - float[] choices = { 0.25f,0.3333333333f,0.5f,0.7071067812f,1.0f,1.414213562f,2.0f,3.0f,4.0f }; - int i; - if (!isShiftKeyDown()) { - for (i=0; i=0 && val<=choices[i]; --i) {} - if (i<0) i=choices.length-1; - } - Shaders.configShadowResMul = choices[i]; - par1GuiButton.displayString = "ShadowResMul: "+String.format("%.4f",Shaders.configShadowResMul); - Shaders.scheduleResizeShadow(); - break; - } - - case 17: /* Normal Map */ - { - Shaders.configNormalMap = !Shaders.configNormalMap; - //displayString - par1GuiButton.displayString = "NormapMap: " +toStringOnOff(Shaders.configNormalMap); - mc.scheduleResourcesRefresh(); // schedule refresh texture - break; - } - - case 18: /* Normal Map */ - { - Shaders.configSpecularMap = !Shaders.configSpecularMap; - //displayString - par1GuiButton.displayString = "SpecularMap: " +toStringOnOff(Shaders.configSpecularMap); - mc.scheduleResourcesRefresh(); // schedule refresh texture - break; - } - - case 19: /* old Lighting */ - { - Shaders.configOldLighting = !Shaders.configOldLighting; - //displayString - par1GuiButton.displayString = "OldLighting: " +toStringOnOff(Shaders.configOldLighting); - Shaders.updateBlockLightLevel(); - mc.renderGlobal.loadRenderers(); - break; - } - - case 11: /* texture filter */ - { - Shaders.configTexMinFilB = (Shaders.configTexMinFilB+1)%Shaders.texMinFilRange; - Shaders.configTexMinFilN = Shaders.configTexMinFilS = Shaders.configTexMinFilB; - par1GuiButton.displayString = "Tex Min: " +Shaders.texMinFilDesc[Shaders.configTexMinFilB]; - ShadersTex.updateTextureMinMagFilter(); - break; - } - - case 12: /* texture filter */ - { - Shaders.configTexMagFilN = (Shaders.configTexMagFilN+1)%Shaders.texMagFilRange; - par1GuiButton.displayString = "Tex_n Mag: " +Shaders.texMagFilDesc[Shaders.configTexMagFilN]; - ShadersTex.updateTextureMinMagFilter(); - break; - } - - case 13: /* texture filter */ - { - Shaders.configTexMagFilS = (Shaders.configTexMagFilS+1)%Shaders.texMagFilRange; - par1GuiButton.displayString = "Tex_s Mag: " +Shaders.texMagFilDesc[Shaders.configTexMagFilS]; - ShadersTex.updateTextureMinMagFilter(); - break; - } - - case 14: /* shadow frustum clipping */ - { - Shaders.configShadowClipFrustrum = !Shaders.configShadowClipFrustrum; - par1GuiButton.displayString = "ShadowClipFrustrum: " +toStringOnOff(Shaders.configShadowClipFrustrum); - ShadersTex.updateTextureMinMagFilter(); - break; - } - - case 5: /* Open shaderpacks folder */ - switch(net.minecraft.util.Util.getOSType()) - { - case OSX: - { - try - { - Runtime.getRuntime().exec(new String[] {"/usr/bin/open", Shaders.shaderpacksdir.getAbsolutePath()}); - return; - } - catch (IOException var7) - { - var7.printStackTrace(); - } - } - break; - case WINDOWS: - { - String var2 = String.format("cmd.exe /C start \"Open file\" \"%s\"", new Object[] {Shaders.shaderpacksdir.getAbsolutePath()}); - - try - { - Runtime.getRuntime().exec(var2); - return; - } - catch (IOException var6) - { - var6.printStackTrace(); - } - } - break; - default: - break; - } - boolean var8 = false; - - try - { - Class var3 = Class.forName("java.awt.Desktop"); - Object var4 = var3.getMethod("getDesktop", new Class[0]).invoke((Object)null, new Object[0]); - var3.getMethod("browse", new Class[] {URI.class}).invoke(var4, new Object[] {(new File(mc.mcDataDir, Shaders.shaderpacksdirname)).toURI()}); - } - catch (Throwable var5) - { - var5.printStackTrace(); - var8 = true; - } - - if (var8) - { - System.out.println("Opening via system class!"); - Sys.openURL("file://" + Shaders.shaderpacksdir.getAbsolutePath()); - } - break; - - case 6: /* Done */ - File confshader = new File(Shaders.shadersdir,"current.cfg"); - try - { - Shaders.storeConfig(); - } - catch (Exception ex) - { - } - if (needReinit) - { - needReinit = false; - Shaders.loadShaderPack(); - Shaders.uninit(); - this.mc.renderGlobal.loadRenderers(); - } - this.mc.displayGuiScreen(this.parentGui);//displayGuiScreen - break; - - default: - this.shaderList.actionPerformed(par1GuiButton);//actionPerformed - } - } - } - - @Override - /** - * Draws the screen and all the components in it. - */ - public void drawScreen(int par1, int par2, float par3) - { - drawDefaultBackground(); // background - this.shaderList.drawScreen(par1, par2, par3);//drawScreen - - if (this.updateTimer <= 0) - { - this.shaderList.updateList(); - this.updateTimer += 20; - } - - this.drawCenteredString(this.fontRendererObj, "Shaders " , this.width / 2, 16, 0xffffff); - this.drawCenteredString(this.fontRendererObj, " v"+Shaders.versionString, this.width - 40, 10, 0x808080); - //this.drawCenteredString(this.fontRenderer, "( Place zipped Shader files here. )", this.width / 4 + 10, this.height - 26, 0x808080); - super.drawScreen(par1, par2, par3); - } - - @Override - /** - * Called from the main game loop to update the screen. - */ - public void updateScreen() - { - super.updateScreen(); - --this.updateTimer; - } - - public Minecraft getMc() - { - return this.mc; - } - - public void drawCenteredString(String par1, int par2, int par3, int par4) - { - this.drawCenteredString(this.fontRendererObj, par1, par2, par3, par4); - } - -} diff --git a/java/shadersmodcore/client/GuiSlotShaders.java b/java/shadersmodcore/client/GuiSlotShaders.java deleted file mode 100644 index 0b2da0d17..000000000 --- a/java/shadersmodcore/client/GuiSlotShaders.java +++ /dev/null @@ -1,73 +0,0 @@ -package shadersmodcore.client; - -import java.util.ArrayList; - -import net.minecraft.client.Minecraft; -import net.minecraft.client.gui.GuiSlot; -import net.minecraft.client.renderer.Tessellator; - -class GuiSlotShaders extends GuiSlot -{ - private ArrayList shaderslist; - - final GuiShaders shadersGui; - - public GuiSlotShaders(GuiShaders par1GuiShaders) - { - //super(par1GuiShaders.getMc(), par1GuiShaders.width / 2 + 20, par1GuiShaders.height, 40, par1GuiShaders.height - 70, 16); - super(par1GuiShaders.getMc(), par1GuiShaders.width / 2 + 20, par1GuiShaders.height, 40, par1GuiShaders.height - 70, 16); - this.shadersGui = par1GuiShaders; - this.shaderslist = Shaders.listofShaders(); - } - - public void updateList() - { - this.shaderslist = Shaders.listofShaders(); - } - - @Override - /** getSize */ - protected int getSize() { - return this.shaderslist.size(); - } - - @Override - /** elementClicked */ - protected void elementClicked(int par1, boolean par2, int par3, int par4) { - Shaders.setShaderPack((String)shaderslist.get(par1)); - shadersGui.needReinit = false; - Shaders.loadShaderPack(); - Shaders.uninit(); - } - - @Override - /** isSelected */ - protected boolean isSelected(int par1) { - return ((String)this.shaderslist.get(par1)).equals(Shaders.currentshadername); - } - - @Override - /** getScrollBarX */ - protected int getScrollBarX() { - return this.width - 6; - } - - @Override - /** getContentHeight */ - protected int getContentHeight() { - return this.getSize() * 18; - } - - @Override - /** drawBackground */ - protected void drawBackground() { - //this.shadersGui.drawDefaultBackground(); - } - - @Override - /** drawSlot */ - protected void drawSlot(int par1, int par2, int par3, int par4, - Tessellator par5, int par6, int par7) { - this.shadersGui.drawCenteredString((String)this.shaderslist.get(par1), this.shadersGui.width / 4 + 10, par3 + 1, 0xffffff); - } -} diff --git a/java/shadersmodcore/client/MultiTexID.java b/java/shadersmodcore/client/MultiTexID.java deleted file mode 100644 index 3013ecc0a..000000000 --- a/java/shadersmodcore/client/MultiTexID.java +++ /dev/null @@ -1,17 +0,0 @@ -package shadersmodcore.client; - -import java.util.HashMap; -import java.util.Map; - -public class MultiTexID { - public int base; - public int norm; - public int spec; - - public MultiTexID(int baseTex, int normTex, int specTex) - { - base = baseTex; - norm = normTex; - spec = specTex; - } -} diff --git a/java/shadersmodcore/client/ShaderPackDefault.java b/java/shadersmodcore/client/ShaderPackDefault.java deleted file mode 100644 index 45353f85e..000000000 --- a/java/shadersmodcore/client/ShaderPackDefault.java +++ /dev/null @@ -1,18 +0,0 @@ -package shadersmodcore.client; - -import java.io.InputStream; - -public class ShaderPackDefault implements IShaderPack { - - public ShaderPackDefault() { - } - - @Override - public void close() { - } - - @Override - public InputStream getResourceAsStream(String resName) { - return ShaderPackDefault.class.getResourceAsStream(resName); - } -} diff --git a/java/shadersmodcore/client/ShaderPackFolder.java b/java/shadersmodcore/client/ShaderPackFolder.java deleted file mode 100644 index 71f62cd10..000000000 --- a/java/shadersmodcore/client/ShaderPackFolder.java +++ /dev/null @@ -1,38 +0,0 @@ -package shadersmodcore.client; - -import java.io.BufferedInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.InputStream; - -public class ShaderPackFolder implements IShaderPack { - - protected File packFile; - - public ShaderPackFolder(String name, File file) - { - packFile = file; - } - - @Override - public void close() { - } - - @Override - public InputStream getResourceAsStream(String resName) - { - try - { - File resFile = new File(packFile, resName.substring(1)); - if (resFile != null) - { - return new BufferedInputStream(new FileInputStream(resFile)); - } - } - catch (Exception excp) - { - } - return null; - } - -} diff --git a/java/shadersmodcore/client/ShaderPackNone.java b/java/shadersmodcore/client/ShaderPackNone.java deleted file mode 100644 index bc71008ac..000000000 --- a/java/shadersmodcore/client/ShaderPackNone.java +++ /dev/null @@ -1,22 +0,0 @@ -package shadersmodcore.client; - -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; - -import javax.imageio.ImageIO; - -public class ShaderPackNone implements IShaderPack { - - public ShaderPackNone() { - } - - @Override - public void close() { - } - - @Override - public InputStream getResourceAsStream(String resName) { - return null; - } -} diff --git a/java/shadersmodcore/client/ShaderPackZip.java b/java/shadersmodcore/client/ShaderPackZip.java deleted file mode 100644 index 2343b2eb9..000000000 --- a/java/shadersmodcore/client/ShaderPackZip.java +++ /dev/null @@ -1,65 +0,0 @@ -package shadersmodcore.client; - -import java.io.File; -import java.io.InputStream; -import java.util.zip.ZipEntry; -import java.util.zip.ZipFile; - -public class ShaderPackZip implements IShaderPack { - - protected File packFile; - protected ZipFile packZipFile; - - public ShaderPackZip(String name, File file) - { - packFile = file; - packZipFile = null; - } - - @Override - public void close() - { - if(packZipFile != null) - { - try - { - packZipFile.close(); - } - catch (Exception excp) - { - } - packZipFile = null; - } - } - - @Override - public InputStream getResourceAsStream(String resName) - { - if (packZipFile == null) - { - try - { - packZipFile = new ZipFile(packFile); - } - catch (Exception excp) - { - } - } - if (packZipFile != null) - { - try - { - ZipEntry entry = packZipFile.getEntry(resName.substring(1)); - if (entry != null) - { - return packZipFile.getInputStream(entry); - } - } - catch (Exception excp) - { - } - } - return null; - } - -} diff --git a/java/shadersmodcore/client/Shaders.java b/java/shadersmodcore/client/Shaders.java deleted file mode 100644 index 490fb5e33..000000000 --- a/java/shadersmodcore/client/Shaders.java +++ /dev/null @@ -1,3871 +0,0 @@ -// Code written by daxnitro modified by id_miner and karyonix. -// Do what you want with it but give us some credit if you use it in whole or in part. - -package shadersmodcore.client; - -import static org.lwjgl.opengl.ARBFragmentShader.GL_FRAGMENT_SHADER_ARB; -import static org.lwjgl.opengl.ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB; -import static org.lwjgl.opengl.ARBShaderObjects.glAttachObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glCompileShaderARB; -import static org.lwjgl.opengl.ARBShaderObjects.glCreateProgramObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glCreateShaderObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glDeleteObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glDetachObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glGetInfoLogARB; -import static org.lwjgl.opengl.ARBShaderObjects.glGetObjectParameterARB; -import static org.lwjgl.opengl.ARBShaderObjects.glGetUniformLocationARB; -import static org.lwjgl.opengl.ARBShaderObjects.glLinkProgramARB; -import static org.lwjgl.opengl.ARBShaderObjects.glShaderSourceARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUniform1fARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUniform1iARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUniform2iARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUniform3fARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUniformMatrix4ARB; -import static org.lwjgl.opengl.ARBShaderObjects.glUseProgramObjectARB; -import static org.lwjgl.opengl.ARBShaderObjects.glValidateProgramARB; -import static org.lwjgl.opengl.ARBVertexShader.GL_VERTEX_SHADER_ARB; -import static org.lwjgl.opengl.ARBVertexShader.glBindAttribLocationARB; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_INVALID_FRAMEBUFFER_OPERATION_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.GL_MAX_COLOR_ATTACHMENTS_EXT; -import static org.lwjgl.opengl.EXTFramebufferObject.glBindFramebufferEXT; -import static org.lwjgl.opengl.EXTFramebufferObject.glCheckFramebufferStatusEXT; -import static org.lwjgl.opengl.EXTFramebufferObject.glDeleteFramebuffersEXT; -import static org.lwjgl.opengl.EXTFramebufferObject.glFramebufferTexture2DEXT; -import static org.lwjgl.opengl.EXTFramebufferObject.glGenFramebuffersEXT; -import static org.lwjgl.opengl.GL11.GL_ALPHA_TEST; -import static org.lwjgl.opengl.GL11.GL_ALWAYS; -import static org.lwjgl.opengl.GL11.GL_BLEND; -import static org.lwjgl.opengl.GL11.GL_CLAMP; -import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT; -import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT; -import static org.lwjgl.opengl.GL11.GL_DEPTH_COMPONENT; -import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST; -import static org.lwjgl.opengl.GL11.GL_FOG; -import static org.lwjgl.opengl.GL11.GL_LEQUAL; -import static org.lwjgl.opengl.GL11.GL_LINEAR; -import static org.lwjgl.opengl.GL11.GL_LINEAR_MIPMAP_LINEAR; -import static org.lwjgl.opengl.GL11.GL_LUMINANCE; -import static org.lwjgl.opengl.GL11.GL_MODELVIEW; -import static org.lwjgl.opengl.GL11.GL_MODELVIEW_MATRIX; -import static org.lwjgl.opengl.GL11.GL_NEAREST; -import static org.lwjgl.opengl.GL11.GL_NEAREST_MIPMAP_NEAREST; -import static org.lwjgl.opengl.GL11.GL_NONE; -import static org.lwjgl.opengl.GL11.GL_NO_ERROR; -import static org.lwjgl.opengl.GL11.GL_PROJECTION; -import static org.lwjgl.opengl.GL11.GL_PROJECTION_MATRIX; -import static org.lwjgl.opengl.GL11.GL_QUADS; -import static org.lwjgl.opengl.GL11.GL_RGB16; -import static org.lwjgl.opengl.GL11.GL_RGB8; -import static org.lwjgl.opengl.GL11.GL_RGBA; -import static org.lwjgl.opengl.GL11.GL_RGBA16; -import static org.lwjgl.opengl.GL11.GL_RGBA8; -import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D; -import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER; -import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER; -import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_S; -import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_T; -import static org.lwjgl.opengl.GL11.GL_TRUE; -import static org.lwjgl.opengl.GL11.glBegin; -import static org.lwjgl.opengl.GL11.glBindTexture; -import static org.lwjgl.opengl.GL11.glClear; -import static org.lwjgl.opengl.GL11.glClearColor; -import static org.lwjgl.opengl.GL11.glColor4f; -import static org.lwjgl.opengl.GL11.glColorMask; -import static org.lwjgl.opengl.GL11.glCopyTexSubImage2D; -import static org.lwjgl.opengl.GL11.glDeleteTextures; -import static org.lwjgl.opengl.GL11.glDepthFunc; -import static org.lwjgl.opengl.GL11.glDepthMask; -import static org.lwjgl.opengl.GL11.glDisable; -import static org.lwjgl.opengl.GL11.glEnable; -import static org.lwjgl.opengl.GL11.glEnd; -import static org.lwjgl.opengl.GL11.glFlush; -import static org.lwjgl.opengl.GL11.glGenTextures; -import static org.lwjgl.opengl.GL11.glGetError; -import static org.lwjgl.opengl.GL11.glGetFloat; -import static org.lwjgl.opengl.GL11.glGetInteger; -import static org.lwjgl.opengl.GL11.glLoadIdentity; -import static org.lwjgl.opengl.GL11.glMatrixMode; -import static org.lwjgl.opengl.GL11.glOrtho; -import static org.lwjgl.opengl.GL11.glPopMatrix; -import static org.lwjgl.opengl.GL11.glPushMatrix; -import static org.lwjgl.opengl.GL11.glReadBuffer; -import static org.lwjgl.opengl.GL11.glReadPixels; -import static org.lwjgl.opengl.GL11.glRotatef; -import static org.lwjgl.opengl.GL11.glTexCoord2f; -import static org.lwjgl.opengl.GL11.glTexImage2D; -import static org.lwjgl.opengl.GL11.glTexParameterf; -import static org.lwjgl.opengl.GL11.glTexParameteri; -import static org.lwjgl.opengl.GL11.glTranslatef; -import static org.lwjgl.opengl.GL11.glVertex3f; -import static org.lwjgl.opengl.GL11.glViewport; -import static org.lwjgl.opengl.GL13.GL_TEXTURE0; -import static org.lwjgl.opengl.GL13.GL_TEXTURE1; -import static org.lwjgl.opengl.GL13.GL_TEXTURE11; -import static org.lwjgl.opengl.GL13.GL_TEXTURE12; -import static org.lwjgl.opengl.GL13.GL_TEXTURE13; -import static org.lwjgl.opengl.GL13.GL_TEXTURE14; -import static org.lwjgl.opengl.GL13.GL_TEXTURE2; -import static org.lwjgl.opengl.GL13.GL_TEXTURE3; -import static org.lwjgl.opengl.GL13.GL_TEXTURE4; -import static org.lwjgl.opengl.GL13.GL_TEXTURE5; -import static org.lwjgl.opengl.GL13.GL_TEXTURE6; -import static org.lwjgl.opengl.GL13.GL_TEXTURE7; -import static org.lwjgl.opengl.GL13.glActiveTexture; -import static org.lwjgl.opengl.GL14.GL_DEPTH_TEXTURE_MODE; -import static org.lwjgl.opengl.GL14.GL_TEXTURE_COMPARE_MODE; -import static org.lwjgl.opengl.GL20.GL_MAX_DRAW_BUFFERS; -import static org.lwjgl.opengl.GL20.GL_MAX_TEXTURE_IMAGE_UNITS; -import static org.lwjgl.opengl.GL20.GL_VALIDATE_STATUS; -import static org.lwjgl.opengl.GL20.glDrawBuffers; -import static org.lwjgl.opengl.GL20.glGetProgrami; -import static org.lwjgl.opengl.GL30.GL_COMPARE_REF_TO_TEXTURE; -import static org.lwjgl.opengl.GL30.GL_R16; -import static org.lwjgl.opengl.GL30.GL_R32F; -import static org.lwjgl.opengl.GL30.GL_R8; -import static org.lwjgl.opengl.GL30.GL_RG16; -import static org.lwjgl.opengl.GL30.GL_RG32F; -import static org.lwjgl.opengl.GL30.GL_RG8; -import static org.lwjgl.opengl.GL30.GL_RGB32F; -import static org.lwjgl.opengl.GL30.GL_RGBA32F; -import static org.lwjgl.opengl.GL30.glGenerateMipmap; -import static org.lwjgl.util.glu.GLU.gluErrorString; -import static org.lwjgl.util.glu.GLU.gluPerspective; - -import java.io.BufferedReader; -import java.io.File; -import java.io.FileReader; -import java.io.FileWriter; -import java.io.InputStreamReader; -import java.nio.ByteBuffer; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Map; -import java.util.Properties; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import net.minecraft.block.Block; -import net.minecraft.block.material.Material; -import net.minecraft.client.Minecraft; -import net.minecraft.client.model.ModelBase; -import net.minecraft.client.model.ModelRenderer; -import net.minecraft.client.renderer.EntityRenderer; -import net.minecraft.client.renderer.RenderBlocks; -import net.minecraft.client.renderer.Tessellator; -import net.minecraft.client.renderer.entity.Render; -import net.minecraft.client.renderer.entity.RenderManager; -import net.minecraft.client.renderer.entity.RendererLivingEntity; -import net.minecraft.client.renderer.texture.ITextureObject; -import net.minecraft.client.settings.GameSettings; -import net.minecraft.entity.EntityLivingBase; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.util.ChatComponentText; -import net.minecraft.util.Vec3; - -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.ContextCapabilities; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL12; -import org.lwjgl.opengl.GLContext; -//import org.lwjgl.opengl.ARBVertexProgram; - -public class Shaders { - - public static final String versionString = "2.3.18"; - public static final int versionNumber = 0x020312; - public static final int buildNumber = 53; - - private static Minecraft mc; - - public static boolean isInitialized = false; - private static boolean notFirstInit = false; - public static ContextCapabilities capabilities; - public static boolean hasGlGenMipmap = false; - public static int numberResetDisplayList = 0; - - private static int renderDisplayWidth = 0; - private static int renderDisplayHeight = 0; - public static int renderWidth = 0; - public static int renderHeight = 0; - - public static boolean isRenderingWorld = false; - public static boolean isRenderingSky = false; - public static boolean isCompositeRendered = false; - public static boolean isRenderingDfb = false; - public static boolean isShadowPass = false; - public static int activeTexUnit = 0; - - public static boolean isHandRendered; - public static ItemStack itemToRender; - - private static float[] sunPosition = new float[4]; - private static float[] moonPosition = new float[4]; - private static float[] upPosition = new float[4]; - - private static float[] upPosModelView = new float[]{ 0.0F, 100.0F, 0.0F, 0.0F}; - private static float[] sunPosModelView = new float[]{ 0.0F, 100.0F, 0.0F, 0.0F}; - private static float[] moonPosModelView = new float[]{ 0.0F,-100.0F, 0.0F, 0.0F}; - private static float[] tempMat = new float[16]; - - private static float clearColorR; - private static float clearColorG; - private static float clearColorB; - - private static float skyColorR; - private static float skyColorG; - private static float skyColorB; - - private static long worldTime = 0; - private static long lastWorldTime = 0; - private static long diffWorldTime = 0; - private static float sunAngle = 0; - private static float shadowAngle = 0; - private static int moonPhase = 0; - - private static long systemTime = 0; - private static long lastSystemTime = 0; - private static long diffSystemTime = 0; - - private static int frameCounter = 0; - private static float frameTimeCounter = 0.0f; - - private static int systemTimeInt32 = 0; - - private static float rainStrength = 0.0f; - private static float wetness = 0.0f; - public static float wetnessHalfLife = 30*20; - public static float drynessHalfLife = 10*20; - public static float eyeBrightnessHalflife = 10.0f; - private static boolean usewetness = false; - private static int isEyeInWater = 0; - private static int eyeBrightness = 0; - private static float eyeBrightnessFadeX = 0; - private static float eyeBrightnessFadeY = 0; - private static float eyePosY = 0; - private static float centerDepth = 0; - private static float centerDepthSmooth = 0; - private static float centerDepthSmoothHalflife = 1.0f; - private static boolean centerDepthSmoothEnabled = false; - private static int superSamplingLevel = 1; - - private static boolean updateChunksErrorRecorded = false; - - private static boolean lightmapEnabled = false; - private static boolean fogEnabled = true; - - public static int entityAttrib = 10; - public static int midTexCoordAttrib = 11; - public static boolean useEntityAttrib = false; - public static boolean useMidTexCoordAttrib = false; - public static boolean useMultiTexCoord3Attrib = false; - public static boolean progUseEntityAttrib = false; - public static boolean progUseMidTexCoordAttrib = false; - - public static int atlasSizeX = 0, atlasSizeY = 0; - public static int uniformEntityHurt = -1; - public static int uniformEntityFlash = -1; - public static boolean useEntityHurtFlash; - - private static double[] previousCameraPosition = new double[3]; - private static double[] cameraPosition = new double[3]; - - // Shadow stuff - - // configuration - private static int shadowPassInterval = 0; - public static boolean needResizeShadow = false; - private static int shadowMapWidth = 1024; - private static int shadowMapHeight = 1024; - private static int spShadowMapWidth = 1024; - private static int spShadowMapHeight = 1024; - private static float shadowMapFOV = 90.0f; - private static float shadowMapHalfPlane = 160.0f; - private static boolean shadowMapIsOrtho = true; - - private static int shadowPassCounter = 0; - - private static int preShadowPassThirdPersonView; - - public static boolean shouldSkipDefaultShadow = false; - - - private static boolean waterShadowEnabled = false; - - - // Color attachment stuff - - private static final int MaxDrawBuffers = 8; - private static final int MaxColorBuffers = 8; - private static final int MaxDepthBuffers = 3; - private static final int MaxShadowColorBuffers = 8; - private static final int MaxShadowDepthBuffers = 2; - private static int usedColorBuffers = 0; - private static int usedDepthBuffers = 0; - private static int usedShadowColorBuffers = 0; - private static int usedShadowDepthBuffers = 0; - private static int usedColorAttachs = 0; - private static int usedDrawBuffers = 0; - - private static int dfb = 0; - private static int sfb = 0; - - private static int[] gbuffersFormat = new int[MaxColorBuffers]; - - // Program stuff - - public static int activeProgram = 0; - - public final static int ProgramNone = 0; - public final static int ProgramBasic = 1; - public final static int ProgramTextured = 2; - public final static int ProgramTexturedLit = 3; - public final static int ProgramSkyBasic = 4; - public final static int ProgramSkyTextured = 5; - public final static int ProgramTerrain = 6; - public final static int ProgramWater = 7; - public final static int ProgramEntities = 8; - public final static int ProgramSpiderEyes = 9; - public final static int ProgramHand = 10; - public final static int ProgramWeather = 11; - public final static int ProgramComposite = 12; - public final static int ProgramComposite1 = 13; - public final static int ProgramComposite2 = 14; - public final static int ProgramComposite3 = 15; - public final static int ProgramComposite4 = 16; - public final static int ProgramComposite5 = 17; - public final static int ProgramComposite6 = 18; - public final static int ProgramComposite7 = 19; - public final static int ProgramFinal = 20; - public final static int ProgramShadow = 21; - public final static int ProgramCount = 22; - public final static int MaxCompositePasses = 8; - - private static final String[] programNames = new String[] { - "", - "gbuffers_basic", - "gbuffers_textured", - "gbuffers_textured_lit", - "gbuffers_skybasic", - "gbuffers_skytextured", - "gbuffers_terrain", - "gbuffers_water", - "gbuffers_entities", - "gbuffers_spidereyes", - "gbuffers_hand", - "gbuffers_weather", - "composite", - "composite1", - "composite2", - "composite3", - "composite4", - "composite5", - "composite6", - "composite7", - "final", - "shadow", - }; - - private static final int[] programBackups = new int[] { - ProgramNone, // none - ProgramNone, // basic - ProgramBasic, // textured - ProgramTextured, // textured/lit - ProgramBasic, // skybasic - ProgramTextured, // skytextured - ProgramTexturedLit, // terrain - ProgramTerrain, // water - ProgramTexturedLit, // entities - ProgramTextured, // spidereyes - ProgramTexturedLit, // hand - ProgramTexturedLit, // weather - ProgramNone, // composite - ProgramNone, // composite1 - ProgramNone, // composite2 - ProgramNone, // composite3 - ProgramNone, // composite4 - ProgramNone, // composite5 - ProgramNone, // composite6 - ProgramNone, // composite7 - ProgramNone, // final - ProgramNone, // shadow - }; - - private static int[] programsID = new int[ProgramCount]; - private static int[] programsRef = new int[ProgramCount]; - private static int programIDCopyDepth = 0; - - private static String[] programsDrawBufSettings = new String[ProgramCount]; - private static String newDrawBufSetting = null; - private static IntBuffer[] programsDrawBuffers = new IntBuffer[ProgramCount]; - static IntBuffer activeDrawBuffers = null; - - private static String[] programsColorAtmSettings = new String[ProgramCount]; - private static String newColorAtmSetting = null; - private static String activeColorAtmSettings = null; - - private static int[] programsCompositeMipmapSetting = new int[ProgramCount]; - private static int newCompositeMipmapSetting = 0; - private static int activeCompositeMipmapSetting = 0; - - public static Properties loadedShaders = null; - public static Properties shadersConfig = null; - - //public static TextureManager textureManager = null; - public static ITextureObject defaultTexture = null; - public static boolean normalMapEnabled = false; - public static boolean[] shadowHardwareFilteringEnabled = new boolean[MaxShadowDepthBuffers]; - public static boolean[] shadowMipmapEnabled = new boolean[MaxShadowDepthBuffers]; - public static boolean[] shadowFilterNearest = new boolean[MaxShadowDepthBuffers]; - public static boolean[] shadowColorMipmapEnabled = new boolean[MaxShadowColorBuffers]; - public static boolean[] shadowColorFilterNearest = new boolean[MaxShadowColorBuffers]; - - // config - public static boolean configTweakBlockDamage = false; - public static boolean configCloudShadow = true; - public static float configHandDepthMul = 0.125f; - public static float configRenderResMul = 1.0f; - public static float configShadowResMul = 1.0f; - public static int configTexMinFilB = 0; - public static int configTexMinFilN = 0; - public static int configTexMinFilS = 0; - public static int configTexMagFilB = 0; - public static int configTexMagFilN = 0; - public static int configTexMagFilS = 0; - public static boolean configShadowClipFrustrum = true; - public static boolean configNormalMap = true; - public static boolean configSpecularMap = true; - public static boolean configOldLighting = false; - - // related to config - public static final int texMinFilRange = 3; - public static final int texMagFilRange = 2; - public static final String[] texMinFilDesc = { "Nearest","Nearest-Nearest","Nearest-Linear" }; - public static final String[] texMagFilDesc = { "Nearest","Linear" }; - public static final int[] texMinFilValue = { GL11.GL_NEAREST, GL11.GL_NEAREST_MIPMAP_NEAREST, GL11.GL_NEAREST_MIPMAP_LINEAR }; - public static final int[] texMagFilValue = { GL11.GL_NEAREST, GL11.GL_LINEAR }; - - // shaderpack - static IShaderPack shaderPack = null; - static File currentshader; - static String currentshadername; - static String packNameNone = "(none)"; - static String packNameDefault = "(internal)"; - static String shaderpacksdirname = "shaderpacks"; - static String optionsfilename = "optionsshaders.txt"; - static File shadersdir = new File(Minecraft.getMinecraft().mcDataDir,"shaders"); - static File shaderpacksdir = new File(Minecraft.getMinecraft().mcDataDir,shaderpacksdirname); - static File configFile = new File(Minecraft.getMinecraft().mcDataDir, optionsfilename); - - public static final boolean enableShadersOption = true; - private static final boolean enableShadersDebug = true; - - public static float blockLightLevel05 = 0.5f; - public static float blockLightLevel06 = 0.6f; - public static float blockLightLevel08 = 0.8f; - - public static float aoLevel = 0.8f; - public static float blockAoLight = 1.0f - aoLevel; - - public static float sunPathRotation = 0.0f; - public static float shadowAngleInterval = 0.0f; - public static int fogMode = 0; - public static float fogColorR, fogColorG, fogColorB; - public static float shadowIntervalSize = 2.0f; - public static int terrainIconSize = 16; - public static int[] terrainTextureSize = new int[2]; - - private static HFNoiseTexture noiseTexture; - private static boolean noiseTextureEnabled = false; - private static int noiseTextureResolution = 256; - - // direct buffers - private static final int bigBufferSize = ( - 16*12 - + MaxColorBuffers + MaxDepthBuffers + MaxShadowColorBuffers + MaxShadowDepthBuffers - + MaxDrawBuffers*8 + MaxDrawBuffers*ProgramCount - )*4; - private static final ByteBuffer bigBuffer = (ByteBuffer)BufferUtils.createByteBuffer(bigBufferSize).limit(0); - - private static final FloatBuffer previousProjection = nextFloatBuffer(16); - private static final FloatBuffer projection = nextFloatBuffer(16); - private static final FloatBuffer projectionInverse = nextFloatBuffer(16); - private static final FloatBuffer previousModelView = nextFloatBuffer(16); - private static final FloatBuffer modelView = nextFloatBuffer(16); - private static final FloatBuffer modelViewInverse = nextFloatBuffer(16); - private static final FloatBuffer shadowProjection = nextFloatBuffer(16); - private static final FloatBuffer shadowProjectionInverse = nextFloatBuffer(16); - private static final FloatBuffer shadowModelView = nextFloatBuffer(16); - private static final FloatBuffer shadowModelViewInverse = nextFloatBuffer(16); - private static final FloatBuffer tempMatrixDirectBuffer = nextFloatBuffer(16); - private static final FloatBuffer tempDirectFloatBuffer = nextFloatBuffer(16); - - private static final IntBuffer dfbColorTextures = nextIntBuffer(MaxColorBuffers); - private static final IntBuffer dfbDepthTextures = nextIntBuffer(MaxDepthBuffers); - private static final IntBuffer sfbColorTextures = nextIntBuffer(MaxShadowColorBuffers); - private static final IntBuffer sfbDepthTextures = nextIntBuffer(MaxShadowDepthBuffers); - - static final IntBuffer dfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer sfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersNone = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersAll = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersClear0 = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersClear1 = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersClearColor = nextIntBuffer(MaxDrawBuffers); - static final IntBuffer drawBuffersColorAtt0 = nextIntBuffer(MaxDrawBuffers); - - static final IntBuffer[] drawBuffersBuffer = nextIntBufferArray(ProgramCount, MaxDrawBuffers); - - //static final String ofVersion = "OptiFine_x.x.x_HD_U_xx"; - //static final String ofVersion = Config.VERSION; - - //static int lastversion = version; - //static int updateinterval = 48; - //public static final String siteurl = "http://glslshadersof.no-ip.org"; - //public static final String updatecheckurl = "http:....../lastversion145.html"; - //static JFrame frame; - - static { - drawBuffersNone.limit(0); - drawBuffersColorAtt0.put(GL_COLOR_ATTACHMENT0_EXT).position(0).limit(1); - } - - private Shaders() { - } - - /** set position to limit and advance limit by size */ - private static ByteBuffer nextByteBuffer(int size) - { - ByteBuffer buffer = bigBuffer; - int pos = buffer.limit(); - buffer.position(pos).limit(pos+size); - return buffer.slice(); - } - - private static IntBuffer nextIntBuffer(int size) - { - ByteBuffer buffer = bigBuffer; - int pos = buffer.limit(); - buffer.position(pos).limit(pos+size*4); - return buffer.asIntBuffer(); - } - - private static FloatBuffer nextFloatBuffer(int size) - { - ByteBuffer buffer = bigBuffer; - int pos = buffer.limit(); - buffer.position(pos).limit(pos+size*4); - return buffer.asFloatBuffer(); - } - - private static IntBuffer[] nextIntBufferArray(int count, int size) - { - IntBuffer[] aib = new IntBuffer[count]; - for (int i=0; i 0 && vv < 24 ) || vv > 736) - { - System.out.println("[Shaders] Skipping bad option: updateinterval, range is: 0, 24-736"); - } - else - { - updateinterval = vv; - } - } - else if (as[0].equals("lastcheck")) - { - lastcheck = Integer.parseInt(as[1]); - } - else if (as[0].equals("lastversion")) - { - lastversion = Integer.parseInt(as[1]); - } - } - catch (Exception exception1) - { - System.out.println("[Shaders] "+(new StringBuilder()).append("Skipping bad option: ").append(s).toString()); - } - } - bufferedreader2.close(); - } - } - catch(Exception ex){} - - if (updateinterval > 0) - { - try - { - if (lastversion > version) - { - updatenotify(versiontostring(lastversion)); - System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); - } - else - { - int currenthours = (int) (System.currentTimeMillis() / 3600000); - if (currenthours - lastcheck > updateinterval ) - { - System.out.println("[Shaders] Checking for updates. Last checked "+Integer.toString(currenthours - lastcheck)+" hours ago."); - lastcheck = currenthours; - try - { - URL url = new URL( updatecheckurl ); - HttpURLConnection.setFollowRedirects(true); - HttpURLConnection uconn; - uconn = (HttpURLConnection) url.openConnection(); - uconn.setConnectTimeout(2500); - uconn.setReadTimeout(1500); - try - { - uconn.connect(); - } - catch (SocketTimeoutException excep) - { - System.out.println("[Shaders] Failed to connect to " + updatecheckurl); - return; - } - - BufferedReader bufferedreader2 = new BufferedReader(new InputStreamReader( uconn.getInputStream())); - - for (String s = ""; (s = bufferedreader2.readLine()) != null;) - { - try - { - String as[] = s.split(":"); - if (as[1].equals("lastversion")) - { - lastversion = Integer.parseInt(as[2]); - break; - } - } - catch (Exception exception1){} - } - bufferedreader2.close(); - } - catch (Exception exception) - { - System.out.println("[Shaders] Failed to download " + updatecheckurl); - return; - } - - BufferedWriter bufferedwriter2 = new BufferedWriter(new FileWriter(updatecheck)); - bufferedwriter2.write("updateinterval:"+updateinterval); - bufferedwriter2.newLine(); - bufferedwriter2.write("lastcheck:"+Integer.toString(lastcheck)); - bufferedwriter2.newLine(); - bufferedwriter2.write("lastversion:"+Integer.toString(lastversion)); - bufferedwriter2.newLine(); - bufferedwriter2.close(); - - if (lastversion > version) - { - updatenotify(versiontostring(lastversion)); - System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); - } - } - } - } - catch (Exception exception) - { - System.out.println("[Shaders] Failed to load GLSL Shaders update file."); - exception.printStackTrace(); - } - } - } - - public static void updatenotify(String lastversion) - { - try - { - frame = new JFrame("GLSL Shaders OF mod update"); - } - catch(Exception e) - { - return; - } - - Color bgcolor=new Color(194,205,234); - Color txcolor=new Color(50,50,50); - frame.setLocation(20,20); - JLabel label=new JLabel("New version of the GLSL Shaders OF mod is available! (v"+lastversion+") "); - JPanel panel = new JPanel(); - panel.setBackground(bgcolor); - label.setForeground(txcolor); - label.setFont(new Font("Dialog", 1, 14)); - panel.add(label); - - if( java.awt.Desktop.isDesktopSupported() ) - { - JButton button; - final java.awt.Desktop desktop = java.awt.Desktop.getDesktop(); - if( desktop.isSupported( java.awt.Desktop.Action.BROWSE ) ) - { - button = new JButton("Download"); - button.setActionCommand("BPUPD"); - - } - else - { - button = new JButton("Copy URL to Clipboard"); - button.setActionCommand("CPURL"); - } - button.setFont(new Font("Dialog", 1, 14)); - button.addActionListener(new ButtonListener()); - panel.add(button); - } - frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); - frame.getContentPane().add(panel); - frame.pack(); - frame.setFocusableWindowState(false); - frame.setVisible(true); - frame.setFocusableWindowState(true); - } - - static class ButtonListener implements ActionListener - { - ButtonListener() - { - } - public void actionPerformed(ActionEvent e) - { - String cmd = e.getActionCommand(); - if (cmd == "BPUPD") - { - try - { - java.net.URI uri = new java.net.URI( siteurl ); - java.awt.Desktop.getDesktop().browse( uri ); - frame.dispose(); - } - catch ( Exception exx ) {} - } - else if (cmd == "CPURL") - { - StringSelection ss = new StringSelection(siteurl); - Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null); - } - - } - } -*/ - - public static void loadConfig() - { - System.out.println("[Shaders] Loading configuration."); - try { - if (!shaderpacksdir.exists()) - shaderpacksdir.mkdir(); - } catch (Exception e) { - System.err.println("[Shaders] Failed openning shaderpacks directory."); - } - - shadersConfig = new Properties(); - shadersConfig.setProperty("shaderPack", ""); - if (configFile.exists()) - { - try { - FileReader reader = new FileReader(configFile); - shadersConfig.load(reader); - reader.close(); - } catch (Exception e) { - } - } - - if (!configFile.exists()) - { - try { - storeConfig(); - } catch (Exception e) { - } - } - String value = null; - configNormalMap = Boolean.parseBoolean(shadersConfig.getProperty("normalMapEnabled","true")); - configSpecularMap = Boolean.parseBoolean(shadersConfig.getProperty("specularMapEnabled","true")); - configTweakBlockDamage = Boolean.parseBoolean(shadersConfig.getProperty("tweakBlockDamage",shadersConfig.getProperty("dtweak","false"))); - configCloudShadow = Boolean.parseBoolean(shadersConfig.getProperty("cloudShadow","true")); - configHandDepthMul = Float.parseFloat(shadersConfig.getProperty("handDepthMul","0.125")); - configRenderResMul = Float.parseFloat(shadersConfig.getProperty("renderResMul","1.0")); - configShadowResMul = Float.parseFloat(shadersConfig.getProperty("shadowResMul","1.0")); - configShadowClipFrustrum = Boolean.parseBoolean(shadersConfig.getProperty("shadowClipFrustrum","true")); - configOldLighting = Boolean.parseBoolean(shadersConfig.getProperty("oldLighting","false")); - configTexMinFilB = Integer.parseInt(shadersConfig.getProperty("TexMinFilB","0")) % texMinFilRange; - configTexMinFilN = Integer.parseInt(shadersConfig.getProperty("TexMinFilN",Integer.toString(configTexMinFilB))) % texMinFilRange; - configTexMinFilS = Integer.parseInt(shadersConfig.getProperty("TexMinFilS",Integer.toString(configTexMinFilB))) % texMinFilRange; - configTexMagFilB = Integer.parseInt(shadersConfig.getProperty("TexMagFilB","0")) % texMagFilRange; - configTexMagFilN = Integer.parseInt(shadersConfig.getProperty("TexMagFilN","0")) % texMagFilRange; - configTexMagFilS = Integer.parseInt(shadersConfig.getProperty("TexMagFilS","0")) % texMagFilRange; - currentshadername = shadersConfig.getProperty("shaderPack", packNameDefault); - loadShaderPack(); - } - - public static void storeConfig() - { - System.out.println("[Shaders] Save configuration."); - shadersConfig.setProperty("normalMapEnabled", Boolean.toString(configNormalMap)); - shadersConfig.setProperty("specularMapEnabled", Boolean.toString(configSpecularMap)); - shadersConfig.setProperty("tweakBlockDamage", Boolean.toString(configTweakBlockDamage)); - shadersConfig.setProperty("cloudShadow", Boolean.toString(configCloudShadow)); - shadersConfig.setProperty("handDepthMul", Float.toString(configHandDepthMul)); - shadersConfig.setProperty("renderResMul", Float.toString(configRenderResMul)); - shadersConfig.setProperty("shadowResMul", Float.toString(configShadowResMul)); - shadersConfig.setProperty("shadowClipFrustrum", Boolean.toString(configShadowClipFrustrum)); - shadersConfig.setProperty("oldLighting", Boolean.toString(configOldLighting)); - shadersConfig.setProperty("TexMinFilB", Integer.toString(configTexMinFilB)); - shadersConfig.setProperty("TexMinFilN", Integer.toString(configTexMinFilN)); - shadersConfig.setProperty("TexMinFilS", Integer.toString(configTexMinFilS)); - shadersConfig.setProperty("TexMagFilB", Integer.toString(configTexMagFilB)); - shadersConfig.setProperty("TexMagFilN", Integer.toString(configTexMagFilN)); - shadersConfig.setProperty("TexMagFilS", Integer.toString(configTexMagFilS)); - try - { - FileWriter writer = new FileWriter(configFile); - shadersConfig.store(writer, null); - writer.close(); - } - catch (Exception ex) - {} - } - - public static void setShaderPack(String par1name) { - currentshadername = par1name; - shadersConfig.setProperty("shaderPack", par1name); - //loadShaderPack(); - } - - public static void loadShaderPack() - { - if (shaderPack != null) { - shaderPack.close(); - shaderPack = null; - } - String packName = shadersConfig.getProperty("shaderPack", packNameDefault); - if (!packName.isEmpty() && !packName.equals(packNameNone)) { - if (packName.equals(packNameDefault)) { - shaderPack = new ShaderPackDefault(); - } else { - try { - File packFile = new File(shaderpacksdir, packName); - if (packFile.isDirectory()) { - shaderPack = new ShaderPackFolder(packName, packFile); - } else if (packFile.isFile() && packName.toLowerCase().endsWith(".zip")) { - shaderPack = new ShaderPackZip(packName, packFile); - } - } - catch(Exception e) - { - } - } - } - if (shaderPack != null) { - System.out.println("[Shaders] Loaded shaderpack."); - } else { - System.out.println("[Shaders] Did not load shaderpack."); - shaderPack = new ShaderPackNone(); - } - } - -// public static void loadShader0() -// { -// Set shaderfiles = new HashSet(); -// for (int si = 1; si < 10; si++) -// { -// shaderfiles.add(programNames[si]+".fsh"); -// shaderfiles.add(programNames[si]+".vsh"); -// } -// -// try -// { -// -// ZipInputStream inp = new ZipInputStream(new FileInputStream(currentshader)); -// System.out.println("[Shaders] Shader selected: " + currentshadername); -// boolean found = false; -// -// ZipEntry entry = inp.getNextEntry(); -// while(entry != null ) -// { -// if (entry.isDirectory()) -// { -// if (entry.getName().toLowerCase().contains("shaders/contents/files/shaders/")) -// { -// found = true; -// break; -// } -// } -// entry = inp.getNextEntry(); -// } -// -// if (!found) -// { -// inp.close(); -// inp = new ZipInputStream(new FileInputStream(currentshader)); -// entry = inp.getNextEntry(); -// while(entry != null ) -// { -// if (entry.isDirectory()) -// { -// if (entry.getName().toLowerCase().contains("shaders/")) -// { -// found = true; -// break; -// } -// } -// entry = inp.getNextEntry(); -// } -// } -// -// if (!found) -// { -// inp.close(); -// inp = new ZipInputStream(new FileInputStream(currentshader)); -// entry = inp.getNextEntry(); -// } -// -// byte[] buf = new byte[1024]; -// int n; -// String zipfile; -// String zippath = ""; -// String zippathfile; -// -// FileOutputStream fileoutputstream, fileoutputstream2; -// boolean seusrc5tweak = false; -// -// while(entry != null && shaderfiles.size() > 0) -// { -// zipfile = new File(entry.getName()).getName(); -// if (shaderfiles.contains(zipfile) && !entry.isDirectory()) -// { -// zippathfile = new File(entry.getName()).getPath(); -// if (shaderfiles.size() == 18) -// { -// zippath = zippathfile.substring(0,zippathfile.length()-zipfile.length()); -// } -// if (zippathfile.equals(zippath+zipfile)) -// { -// shaderfiles.remove(zipfile); -// if (zipfile.equals("gbuffers_water.vsh") && entry.getCrc() == 2530345120L ) seusrc5tweak = true; -// -// fileoutputstream = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + zipfile); -// while ((n = inp.read(buf, 0, 1024)) > -1) fileoutputstream.write(buf, 0, n); -// fileoutputstream.close(); -// System.out.println("[Shaders] Shader loaded: " + zippathfile); -// } -// } -// entry = inp.getNextEntry(); -// } -// inp.close(); -// -// if (seusrc5tweak) -// { -// new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.fsh").delete(); -// new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.vsh").delete(); -// FileInputStream file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_textured_lit.fsh"); -// FileOutputStream file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.fsh",false); -// while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); -// file.close(); -// file2.close(); -// file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_textured_lit.vsh"); -// file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.vsh",false); -// while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); -// file.close(); -// file2.close(); -// System.out.println("[Shaders] Detected SEUS v10 RC5, copied gbuffers_textured_lit. to gbuffers_water."); -// } -// } -// catch (Exception exc) -// {} -// -// isInitialized = false; -// if (shaderfiles.size() == 18 ) System.out.println("[Shaders] No Shader found in: " + currentshadername); -// else System.out.println("[Shaders] Shader loaded: " + currentshadername); -// } - - - static ArrayList listofShaders() - { - ArrayList list = new ArrayList(); - list.add(packNameNone); - list.add(packNameDefault); - try { - if (!shaderpacksdir.exists()) - shaderpacksdir.mkdir(); - File[] listOfFiles = shaderpacksdir.listFiles(); - for (int i = 0; i < listOfFiles.length; i++) - { - File file = listOfFiles[i]; - String name = file.getName(); - if (file.isDirectory() || - file.isFile() && name.toLowerCase().endsWith(".zip")) - { - list.add(name); - } - } - } - catch (Exception e) { - } - return list; - } - - - static String versiontostring(int vv) - { - String vs = Integer.toString(vv); - return Integer.toString(Integer.parseInt(vs.substring(1,3)))+"."+Integer.toString(Integer.parseInt(vs.substring(3,5)))+"."+Integer.toString(Integer.parseInt(vs.substring(5))); - } - - - static void checkOptifine() - { - /* - try - { - System.out.println("[Shaders] Required OptiFine version : " + ofVersion); - String configVersion = (String)(Config.class.getDeclaredField("VERSION").get(null)); - System.out.println("[Shaders] Detected OptiFine version : "+ configVersion); - if (configVersion.equals(ofVersion) ) - { - System.out.println("[Shaders] ShadersMod loaded. version: " + versiontostring(version)); - } - else - { - System.err.println("[Shaders] Wrong OptiFine version!"); - System.exit(-1); - } - } - catch(Exception e) - { - System.err.println("[Shaders] OptiFine missing or wrong version! Install OptiFine "+ofVersion+" first and then the ShadersMod!"); - System.exit(-1); - } - //Tessellator.shaders = true; - */ - } - - - public static int checkFramebufferStatus(String location) - { - int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); - if (status != GL_FRAMEBUFFER_COMPLETE_EXT) - System.err.format("FramebufferStatus 0x%04X at %s\n", status, location); - return status; - } - - public static int checkGLError(String location) - { - int errorCode = glGetError(); - if (errorCode != GL_NO_ERROR) { - boolean skipPrint = false; - //if (location.equals("updatechunks")) { - // if (updateChunksErrorRecorded) { - // skipPrint = true; - // } else { - // updateChunksErrorRecorded = true; - // } - //} - if (!skipPrint) { - if (errorCode == GL_INVALID_FRAMEBUFFER_OPERATION_EXT) { - int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); - System.err.format("GL error 0x%04X: %s (Fb status 0x%04X) at %s\n", errorCode, gluErrorString(errorCode), status, location); - } else { - System.err.format("GL error 0x%04X: %s at %s\n", errorCode, gluErrorString(errorCode), location); - } - } - } - return errorCode; - } - - public static int checkGLError(String location, String info) - { - int errorCode = glGetError(); - if (errorCode != GL_NO_ERROR) { - System.err.format("GL error 0x%04x: %s at %s %s\n", errorCode, gluErrorString(errorCode), location, info); - } - return errorCode; - } - - public static int checkGLError(String location, String info1, String info2) - { - int errorCode = glGetError(); - if (errorCode != GL_NO_ERROR) { - System.err.format("GL error 0x%04x: %s at %s %s %s\n", errorCode, gluErrorString(errorCode), location, info1, info2); - } - return errorCode; - } - - private static String printChatAndLogError(String str) - { - mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText(str)); - System.err.println(str); - return str; - } - - public static void printIntBuffer(String title, IntBuffer buf) { - StringBuilder sb = new StringBuilder(128); - sb.append(title).append(" [pos ").append(buf.position()) - .append(" lim ").append(buf.limit()) - .append(" cap ").append(buf.capacity()) - .append(" :"); - for (int lim=buf.limit(),i=0; i drawBuffersMap = new HashMap(); - for (int p = 0; p < ProgramCount; ++p) { - if (p==ProgramFinal) - { - programsDrawBuffers[p] = null; - } - else if (programsID[p] == 0) - { - if (p==ProgramShadow) { - programsDrawBuffers[p] = drawBuffersNone; - } else { - programsDrawBuffers[p] = drawBuffersColorAtt0; - } - } - else - { - String str = programsDrawBufSettings[p]; - if (str != null) { - IntBuffer intbuf = drawBuffersBuffer[p]; - int numDB = str.length(); - if (numDB > usedDrawBuffers) - { - usedDrawBuffers = numDB; - } - if (numDB > maxDrawBuffers) - { - numDB = maxDrawBuffers; - } - programsDrawBuffers[p] = intbuf; - intbuf.limit(numDB); - for (int i = 0; i < numDB; ++i) { - int d = GL_NONE; - if (str.length()>i) - { - int ca = str.charAt(i) - '0'; - if (p!=ProgramShadow) { - if (ca>=0 && ca<=7) - { - d = ca + GL_COLOR_ATTACHMENT0_EXT; - if (ca > usedColorAttachs) - { - usedColorAttachs = ca; - } - if (ca > usedColorBuffers) - { - usedColorBuffers = ca; - } - } - } else { - if (ca>=0 && ca<=1) - { - d = ca + GL_COLOR_ATTACHMENT0_EXT; - if (ca > usedShadowColorBuffers) - { - usedShadowColorBuffers = ca; - } - } - } - } - intbuf.put(i, d); - } - } else { - if (p!=ProgramShadow) { - programsDrawBuffers[p] = dfbDrawBuffers; - usedDrawBuffers = usedColorBuffers; - } else { - programsDrawBuffers[p] = sfbDrawBuffers; - } - } - } - } - - //if (programIDCopyDepth==0) - // programIDCopyDepth = setupProgramCopyDepth(); - - // TO DO: add color attachment option - usedColorAttachs = usedColorBuffers; - - shadowPassInterval = (usedShadowDepthBuffers > 0)? 1 : 0; - shouldSkipDefaultShadow = (usedShadowDepthBuffers > 0); - - - dfbDrawBuffers.position(0).limit(usedDrawBuffers); - dfbColorTextures.position(0).limit(usedColorBuffers); - //dfbRenderBuffers.limit(colorAttachments); - - for (int i = 0; i < usedDrawBuffers; ++i) { - dfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); - } - - if (usedDrawBuffers > maxDrawBuffers) { - printChatAndLogError("[Shaders] Not enough draw buffers! Requires "+ usedDrawBuffers + ". Has " + maxDrawBuffers + "."); - } - //if (usedColorBuffers > maxColorAttach) { - // printChatAndLogError("[Shaders] Not enough color attachment! Requires "+ usedColorBuffers + ". Has " + maxColorAttach + "."); - //} - - sfbDrawBuffers.position(0).limit(usedShadowColorBuffers); - for (int i = 0; i < usedShadowColorBuffers; ++i) { - sfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); - } - - - // Use programBackups for missing programs - for (int i = 0; i < ProgramCount; ++i) { - int n = i; - while (programsID[n]==0 && programBackups[n]!=n) - n = programBackups[n]; - if (n != i && i != ProgramShadow) - { - programsID[i] = programsID[n]; - programsDrawBufSettings[i] = programsDrawBufSettings[n]; - programsDrawBuffers[i] = programsDrawBuffers[n]; - } - } - - //printIntBuffer("dfb drawbuffers",dfbDrawBuffers); - //printIntBuffer("sfb drawbuffers",sfbDrawBuffers); - //printIntBuffer("pgshadow drawbf",programsDrawBuffers[ProgramShadow]); - - // setup scene frame buffer and textures - resize(); - - // setup shadow frame buffer and texture - resizeShadow(); - - if (noiseTextureEnabled) - setupNoiseTexture(); - - if (defaultTexture==null) - defaultTexture = ShadersTex.createDefaultTexture(); - //TextureNM texBlocks = (TextureNM)textureManager.textureMapBlocks.getTexture(); - //TextureNM texItems = (TextureNM)textureManager.textureMapBlocks.getTexture(); - //terrainTextureIdArray = new int[] { texBlocks.getGlTextureId(), texBlocks.normalMap.getGlTextureId(), texBlocks.specularMap.getGlTextureId() }; - //textureIdMap.put(terrainTextureIdArray[0], terrainTextureIdArray); - //int[] itemsTextureIdArray; - //itemsTextureIdArray = new int[] { texItems.getGlTextureId(), texItems.normalMap.getGlTextureId(), texItems.specularMap.getGlTextureId() }; - //textureIdMap.put(itemsTextureIdArray[0], itemsTextureIdArray); - - - isInitialized = true; - - resetDisplayList(); - if (notFirstInit) { - mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText("Shaders initialized.")); - } - checkGLError("Shaders.init"); - } - } - - public static void resetDisplayList() - { - ++numberResetDisplayList; - System.out.println("Reset model renderers"); - if (Shaders.useMidTexCoordAttrib || Shaders.useMultiTexCoord3Attrib) { - Iterator it = RenderManager.instance.entityRenderMap.values().iterator(); - while (it.hasNext()) - { - Render ren = it.next(); - if (ren instanceof RendererLivingEntity) - { - RendererLivingEntity rle = (RendererLivingEntity)ren; - //System.out.format("Reset %s\n", rle.toString()); - resetDisplayListModel(rle.mainModel); - resetDisplayListModel(rle.renderPassModel); - } - } - } - System.out.println("Reset world renderers"); - mc.renderGlobal.loadRenderers(); - } - public static void resetDisplayListModel(ModelBase mbase) - { - if (mbase != null) - { - Iterator it = mbase.boxList.iterator(); - while (it.hasNext()) { - Object obj = it.next(); - if (obj instanceof ModelRenderer) { - resetDisplayListModelRenderer((ModelRenderer)obj); - } - } - } - } - public static void resetDisplayListModelRenderer(ModelRenderer mrr) - { - mrr.resetDisplayList(); -// if (mrr.compiled) -// { -// GLAllocation.deleteDisplayLists(mrr.displayList); -// mrr.displayList = 0; -// mrr.compiled = false; -// if (mrr instanceof ModelRotationRenderer) { -// ModelRotationRenderer mrt = (ModelRotationRenderer)mrr; -// mrt.compiled = false; -// } -// } - if (mrr.childModels != null) { - for (int i=0, n=mrr.childModels.size(); i < n; ++i) - { - resetDisplayListModelRenderer((ModelRenderer)mrr.childModels.get(i)); - } - } - } - - // ---------------------------------------- - -// private static final String shaderCodeCopyDepthV = -// "#version 120\n"+ -// "varying vec4 texcoord;\n"+ -// "void main()\n"+ -// "{\n"+ -// " texcoord = gl_MultiTexCoord0;\n"+ -// " gl_Position = ftransform();\n"+ -// "}\n" -// ; -// private static final String shaderCodeCopyDepthF = -// "#version 120\n"+ -// "varying vec4 texcoord;\n"+ -// "uniform sampler2D depthtex0;\n"+ -// "void main()\n"+ -// "{\n"+ -// " gl_FragDepth = texture2D(depthtex0,texcoord.st).r;\n"+ -// " gl_FragColor = texture2D(depthtex0,texcoord.st);\n"+ -// "}\n" -// ; -// -// private static int setupProgramCopyDepth() { -// int program = glCreateProgramObjectARB(); -// if (program !=0) { -// int vShader = createVertShaderFromCode(shaderCodeCopyDepthV); -// int fShader = createFragShaderFromCode(shaderCodeCopyDepthF); -// if (vShader != 0 || fShader != 0) { -// if (vShader != 0) { -// glAttachObjectARB(program, vShader); -// } -// if (fShader != 0) { -// glAttachObjectARB(program, fShader); -// } -// glLinkProgramARB(program); -// if (vShader != 0) { -// glDetachObjectARB(program, vShader); -// glDeleteObjectARB(vShader); -// } -// if (fShader != 0) { -// glDetachObjectARB(program, fShader); -// glDeleteObjectARB(fShader); -// } -// int valid = glGetProgrami(program, GL_VALIDATE_STATUS); // glGetProgrami in LWJGL 3.0+ -// if (valid == GL_TRUE) { -// System.out.println("Program copydepth created"); -// } else { -// printChatAndLogError("[Shaders] Error : Invalid program copydepth"); -// glDeleteObjectARB(program); -// program = 0; -// } -// } else { -// glDeleteObjectARB(program); -// program = 0; -// } -// } -// return program; -// } -// -// -// private static int createVertShaderFromCode(String code) { -// int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); -// if (vertShader == 0) { -// return 0; -// } -// glShaderSourceARB(vertShader, code); -// glCompileShaderARB(vertShader); -// printLogInfo(vertShader,"copydepth vert"); -// return vertShader; -// } -// -// -// private static int createFragShaderFromCode(String code) { -// int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); -// if (fragShader == 0) { -// return 0; -// } -// glShaderSourceARB(fragShader, code); -// glCompileShaderARB(fragShader); -// printLogInfo(fragShader,"copydepth frag"); -// return fragShader; -// } - - - private static int setupProgram(int program, String vShaderPath, String fShaderPath) { - checkGLError("pre setupProgram"); - int programid = glCreateProgramObjectARB(); - checkGLError("create"); - if (programid != 0) { - progUseEntityAttrib = false; - progUseMidTexCoordAttrib = false; - int vShader = createVertShader(vShaderPath); - int fShader = createFragShader(fShaderPath); - checkGLError("create"); - if (vShader != 0 || fShader != 0) { - if (vShader != 0) { - glAttachObjectARB(programid, vShader); - checkGLError("attach"); - } - if (fShader != 0) { - glAttachObjectARB(programid, fShader); - checkGLError("attach"); - } - if (progUseEntityAttrib) { - glBindAttribLocationARB(programid, entityAttrib, "mc_Entity"); - checkGLError("mc_Entity"); - } - if (progUseMidTexCoordAttrib) { - glBindAttribLocationARB(programid, midTexCoordAttrib, "mc_midTexCoord"); - checkGLError("mc_midTexCoord"); - } - glLinkProgramARB(programid); - if (vShader != 0) { - glDetachObjectARB(programid, vShader); - glDeleteObjectARB(vShader); - } - if (fShader != 0) { - glDetachObjectARB(programid, fShader); - glDeleteObjectARB(fShader); - } - programsID[program] = programid; - useProgram(program); - glValidateProgramARB(programid); - useProgram(ProgramNone); - printLogInfo(programid, vShaderPath+","+fShaderPath); - int valid = glGetProgrami(programid, GL_VALIDATE_STATUS); - if (valid == GL_TRUE) { - System.out.println("Program "+programNames[program]+" loaded"); - } else { - printChatAndLogError("[Shaders] Error : Invalid program " + programNames[program]); - glDeleteObjectARB(programid); - programid = 0; - } - } else { - glDeleteObjectARB(programid); - programid = 0; - } - } - return programid; - } - - - private static int createVertShader(String filename) { - int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); - if (vertShader == 0) { - return 0; - } - String vertexCode = ""; - String line; - - BufferedReader reader = null; - try { - reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); - } catch (Exception e) { - try { - reader = new BufferedReader(new FileReader(new File(filename))); - } catch (Exception e2) { - //System.out.println("Couldn't open " + filename); - glDeleteObjectARB(vertShader); - return 0; - } - } - - if (reader != null) - try { - while ((line = reader.readLine()) != null) { - vertexCode += line + "\n"; - if (line.matches("attribute [_a-zA-Z0-9]+ mc_Entity.*")) { - useEntityAttrib = true; - progUseEntityAttrib = true; - } - else if (line.matches("attribute [_a-zA-Z0-9]+ mc_midTexCoord.*")) { - useMidTexCoordAttrib = true; - progUseMidTexCoordAttrib = true; - } - else if (line.matches(".*gl_MultiTexCoord3.*")) { - useMultiTexCoord3Attrib = true; - } - } - } catch (Exception e) { - System.out.println("Couldn't read " + filename + "!"); - e.printStackTrace(); - glDeleteObjectARB(vertShader); - return 0; - } - - if (reader != null) - try { - reader.close(); - } catch (Exception e) { - System.out.println("Couldn't close " + filename + "!"); - } - - glShaderSourceARB(vertShader, vertexCode); - glCompileShaderARB(vertShader); - printLogInfo(vertShader,filename); - return vertShader; - } - - private static Pattern gbufferFormatPattern = Pattern.compile("[ \t]*const[ \t]*int[ \t]*(\\w+)Format[ \t]*=[ \t]*([RGBA81632F]*)[ \t]*;.*"); - private static Pattern gbufferMipmapEnabledPattern = Pattern.compile("[ \t]*const[ \t]*bool[ \t]*(\\w+)MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*"); - - private static int createFragShader(String filename) { - int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); - if (fragShader == 0) { - return 0; - } - StringBuilder fragCode = new StringBuilder(1048576); - String line; - - BufferedReader reader = null; - try { - reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); - } catch (Exception e) { - try { - reader = new BufferedReader(new FileReader(new File(filename))); - } catch (Exception e2) { - //System.out.println("Couldn't open " + filename); - glDeleteObjectARB(fragShader); - return 0; - } - } - - if (reader != null) - try { - while ((line = reader.readLine()) != null) { - fragCode.append(line).append('\n'); - if (line.matches("#version .*")) { - - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadow;.*")) { - if (usedShadowDepthBuffers < 1) - usedShadowDepthBuffers = 1; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ watershadow;.*")) { - waterShadowEnabled = true; - if (usedShadowDepthBuffers < 2) - usedShadowDepthBuffers = 2; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex0;.*")) { - if (usedShadowDepthBuffers < 1) - usedShadowDepthBuffers = 1; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex1;.*")) { - if (usedShadowDepthBuffers < 2) - usedShadowDepthBuffers = 2; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor;.*")) { - if (usedShadowColorBuffers < 1) - usedShadowColorBuffers = 1; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor0;.*")) { - if (usedShadowColorBuffers < 1) - usedShadowColorBuffers = 1; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor1;.*")) { - if (usedShadowColorBuffers < 2) - usedShadowColorBuffers = 2; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex0;.*")) { - if (usedDepthBuffers < 1) - usedDepthBuffers = 1; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex1;.*")) { - if (usedDepthBuffers < 2) - usedDepthBuffers = 2; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex2;.*")) { - if (usedDepthBuffers < 3) - usedDepthBuffers = 3; - } else if (line.matches("uniform [ _a-zA-Z0-9]+ gdepth;.*")) { - if (gbuffersFormat[1] == GL_RGBA) - gbuffersFormat[1] = GL_RGBA32F; - } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ gaux1;.*")) { - usedColorBuffers = 5; - } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ gaux2;.*")) { - usedColorBuffers = 6; - } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ gaux3;.*")) { - usedColorBuffers = 7; - } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ gaux4;.*")) { - usedColorBuffers = 8; - } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ colortex4;.*")) { - usedColorBuffers = 5; - } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ colortex5;.*")) { - usedColorBuffers = 6; - } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ colortex6;.*")) { - usedColorBuffers = 7; - } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ colortex7;.*")) { - usedColorBuffers = 8; - - } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ centerDepthSmooth;.*")) { - centerDepthSmoothEnabled = true; - - //Shadow resolution - } else if (line.matches("/\\* SHADOWRES:[0-9]+ \\*/.*")) { - String[] parts = line.split("(:| )", 4); - System.out.println("Shadow map resolution: " + parts[2]); - spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[2]); - shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); - - } else if (line.matches("[ \t]*const[ \t]*int[ \t]*shadowMapResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Shadow map resolution: " + parts[1]); - spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[1]); - shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); - - } else if (line.matches("/\\* SHADOWFOV:[0-9\\.]+ \\*/.*")) { - String[] parts = line.split("(:| )", 4); - System.out.println("Shadow map field of view: " + parts[2]); - shadowMapFOV = Float.parseFloat(parts[2]); - shadowMapIsOrtho = false; - - - //Shadow distance - } else if (line.matches("/\\* SHADOWHPL:[0-9\\.]+ \\*/.*")) { - String[] parts = line.split("(:| )", 4); - System.out.println("Shadow map half-plane: " + parts[2]); - shadowMapHalfPlane = Float.parseFloat(parts[2]); - shadowMapIsOrtho = true; - - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowDistance[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Shadow map distance: " + parts[1]); - shadowMapHalfPlane = Float.parseFloat(parts[1]); - shadowMapIsOrtho = true; - - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowIntervalSize[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Shadow map interval size: " + parts[1]); - shadowIntervalSize = Float.parseFloat(parts[1]); - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("Generate shadow mipmap"); - Arrays.fill(shadowMipmapEnabled, true); - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowColorMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("Generate shadow color mipmap"); - Arrays.fill(shadowColorMipmapEnabled, true); - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("Hardware shadow filtering enabled."); - Arrays.fill(shadowHardwareFilteringEnabled, true); - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering0[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowHardwareFiltering0"); - shadowHardwareFilteringEnabled[0] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering1[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowHardwareFiltering1"); - shadowHardwareFilteringEnabled[1] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex0Mipmap|shadowtexMipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowtex0Mipmap"); - shadowMipmapEnabled[0] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowtex1Mipmap"); - shadowMipmapEnabled[1] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Mipmap|shadowColor0Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowcolor0Mipmap"); - shadowColorMipmapEnabled[0] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Mipmap|shadowColor1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowcolor1Mipmap"); - shadowColorMipmapEnabled[1] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex0Nearest|shadowtexNearest|shadow0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowtex0Nearest"); - shadowFilterNearest[0] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex1Nearest|shadow1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowtex1Nearest"); - shadowFilterNearest[1] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Nearest|shadowColor0Nearest|shadowColor0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowcolor0Nearest"); - shadowColorFilterNearest[0] = true; - - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Nearest|shadowColor1Nearest|shadowColor1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { - System.out.println("shadowcolor1Nearest"); - shadowColorFilterNearest[1] = true; - - //Wetness half life - } else if (line.matches("/\\* WETNESSHL:[0-9\\.]+ \\*/.*")) { - String[] parts = line.split("(:| )", 4); - System.out.println("Wetness halflife: " + parts[2]); - wetnessHalfLife = Float.parseFloat(parts[2]); - - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*wetnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Wetness halflife: " + parts[1]); - wetnessHalfLife = Float.parseFloat(parts[1]); - - - //Dryness halflife - } else if (line.matches("/\\* DRYNESSHL:[0-9\\.]+ \\*/.*")) { - String[] parts = line.split("(:| )", 4); - System.out.println("Dryness halflife: " + parts[2]); - drynessHalfLife = Float.parseFloat(parts[2]); - - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*drynessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Dryness halflife: " + parts[1]); - drynessHalfLife = Float.parseFloat(parts[1]); - - - //Eye brightness halflife - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*eyeBrightnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Eye brightness halflife: " + parts[1]); - eyeBrightnessHalflife = Float.parseFloat(parts[1]); - - - //Center depth halflife - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*centerDepthHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Center depth halflife: " + parts[1]); - centerDepthSmoothHalflife = Float.parseFloat(parts[1]); - - - //Sun path rotation - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*sunPathRotation[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Sun path rotation: " + parts[1]); - sunPathRotation = Float.parseFloat(parts[1]); - - - //Ambient occlusion level - } else if (line.matches("[ \t]*const[ \t]*float[ \t]*ambientOcclusionLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("AO Level: " + parts[1]); - aoLevel = Float.parseFloat(parts[1]); - blockAoLight = 1.0f - aoLevel; - - - //super sampling - } else if (line.matches("[ \t]*const[ \t]*int[ \t]*superSamplingLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - int ssaa = Integer.parseInt(parts[1]); - if (ssaa > 1) { - System.out.println("Super sampling level: " + ssaa + "x"); - superSamplingLevel = ssaa; - } else { - superSamplingLevel = 1; - } - - - //noise texture - } else if (line.matches("[ \t]*const[ \t]*int[ \t]*noiseTextureResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { - String[] parts = line.split("(=[ \t]*|;)"); - System.out.println("Noise texture enabled"); - System.out.println("Noise texture resolution: " + parts[1]); - noiseTextureResolution = Integer.parseInt(parts[1]); - noiseTextureEnabled = true; - - } else if (line.matches("[ \t]*const[ \t]*int[ \t]*\\w+Format[ \t]*=[ \t]*[RGBA81632F]*[ \t]*;.*")) { - Matcher m = gbufferFormatPattern.matcher(line); - m.matches(); - String name = m.group(1); - String value =m.group(2); - int bufferindex = getBufferIndexFromString(name); - int format = getTextureFormatFromString(value); - if (bufferindex >= 0 && format != 0) - { - gbuffersFormat[bufferindex] = format; - System.out.format("%s format: %s\n", name, value); - } - //gaux4 - } else if (line.matches("/\\* GAUX4FORMAT:RGBA32F \\*/.*")) { - System.out.println("gaux4 format : RGB32AF"); - gbuffersFormat[7] = GL_RGBA32F; - } else if (line.matches("/\\* GAUX4FORMAT:RGB32F \\*/.*")) { - System.out.println("gaux4 format : RGB32F"); - gbuffersFormat[7] = GL_RGB32F; - } else if (line.matches("/\\* GAUX4FORMAT:RGB16 \\*/.*")) { - System.out.println("gaux4 format : RGB16"); - gbuffersFormat[7] = GL_RGB16; - - //Mipmap stuff - } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*\\w+MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*")) { - if (filename.matches(".*composite[0-9]?.fsh") || filename.matches(".*final.fsh")) { - Matcher m = gbufferMipmapEnabledPattern.matcher(line); - m.matches(); - String name = m.group(1); - //String value =m.group(2); - int bufferindex = getBufferIndexFromString(name); - if (bufferindex >= 0) { - newCompositeMipmapSetting |= (1< 1) { - ByteBuffer infoLog = BufferUtils.createByteBuffer(length); - iVal.flip(); - glGetInfoLogARB(obj, iVal, infoLog); - byte[] infoBytes = new byte[length]; - infoLog.get(infoBytes); - if (infoBytes[length-1] == 0) infoBytes[length-1] = 10; - String out = new String(infoBytes); - System.out.println("Info log: " + name + "\n" + out); - return false; - } - return true; - } - - - public static void setDrawBuffers(IntBuffer drawBuffers) - { - if (activeDrawBuffers != drawBuffers) - { - //printIntBuffer("setDrawBuffers", drawBuffers); - activeDrawBuffers = drawBuffers; - glDrawBuffers(drawBuffers); - } else { - //printIntBuffer("setDrawBf skip", drawBuffers); - } - } - - public static void useProgram(int program) { - //System.out.println((new StringBuilder(32)).append("useProgram ").append(programNames[program])); - Shaders.checkGLError("pre-useProgram"); - if (isShadowPass) { - program = ProgramShadow; - if (programsID[ProgramShadow]==0) { - normalMapEnabled = false; - return; - } - } - if (activeProgram == program) { - return; - } - activeProgram = program; - glUseProgramObjectARB(programsID[program]); - if (programsID[program] == 0) { - normalMapEnabled = false; - return; - } - if (checkGLError("useProgram ",programNames[program]) != 0) - { - programsID[program] = 0; - } - IntBuffer drawBuffers = programsDrawBuffers[program]; - if (isRenderingDfb) { - setDrawBuffers(drawBuffers); - checkGLError(programNames[program], " draw buffers = ", programsDrawBufSettings[program]); - //SMCLog.info("%s",programNames[program] + " draw buffers = " + programsDrawBufSettings[program]); - } - activeCompositeMipmapSetting = programsCompositeMipmapSetting[program]; - uniformEntityHurt = glGetUniformLocationARB(programsID[activeProgram], "entityHurt"); - uniformEntityFlash = glGetUniformLocationARB(programsID[activeProgram], "entityFlash"); - switch (program) { - case ProgramBasic: - case ProgramTextured: - case ProgramTexturedLit: - case ProgramSkyBasic: - case ProgramSkyTextured: - case ProgramTerrain: - case ProgramWater: - case ProgramEntities: - case ProgramHand: - case ProgramWeather: - normalMapEnabled = true; - setProgramUniform1i("texture", 0); - setProgramUniform1i("lightmap", 1); - setProgramUniform1i("normals", 2); - setProgramUniform1i("specular", 3); - setProgramUniform1i("shadow", waterShadowEnabled?5:4); - setProgramUniform1i("watershadow",4); - setProgramUniform1i("shadowtex0", 4); - setProgramUniform1i("shadowtex1", 5); - setProgramUniform1i("depthtex0", 6); - setProgramUniform1i("depthtex1", 12); - setProgramUniform1i("shadowcolor",13); - setProgramUniform1i("shadowcolor0",13); - setProgramUniform1i("shadowcolor1",14); - setProgramUniform1i("noisetex",15); - break; - case ProgramComposite: - case ProgramComposite1: - case ProgramComposite2: - case ProgramComposite3: - case ProgramComposite4: - case ProgramComposite5: - case ProgramComposite6: - case ProgramComposite7: - case ProgramFinal: - normalMapEnabled = false; - setProgramUniform1i("gcolor", 0); - setProgramUniform1i("gdepth", 1); - setProgramUniform1i("gnormal", 2); - setProgramUniform1i("composite", 3); - setProgramUniform1i("gaux1", 7); - setProgramUniform1i("gaux2", 8); - setProgramUniform1i("gaux3", 9); - setProgramUniform1i("gaux4", 10); - setProgramUniform1i("colortex0", 0); - setProgramUniform1i("colortex1", 1); - setProgramUniform1i("colortex2", 2); - setProgramUniform1i("colortex3", 3); - setProgramUniform1i("colortex4", 7); - setProgramUniform1i("colortex5", 8); - setProgramUniform1i("colortex6", 9); - setProgramUniform1i("colortex7", 10); - setProgramUniform1i("shadow", waterShadowEnabled?5:4); - setProgramUniform1i("watershadow",4); - setProgramUniform1i("shadowtex0", 4); - setProgramUniform1i("shadowtex1", 5); - setProgramUniform1i("gdepthtex", 6); - setProgramUniform1i("depthtex0", 6); - setProgramUniform1i("depthtex1", 11); - setProgramUniform1i("depthtex2", 12); - setProgramUniform1i("shadowcolor",13); - setProgramUniform1i("shadowcolor0",13); - setProgramUniform1i("shadowcolor1",14); - setProgramUniform1i("noisetex",15); - break; - case ProgramShadow: - setProgramUniform1i("tex", 0); - setProgramUniform1i("texture", 0); - setProgramUniform1i("lightmap", 1); - setProgramUniform1i("normals", 2); - setProgramUniform1i("specular", 3); - setProgramUniform1i("shadow", waterShadowEnabled?5:4); - setProgramUniform1i("watershadow",4); - setProgramUniform1i("shadowtex0", 4); - setProgramUniform1i("shadowtex1", 5); - setProgramUniform1i("shadowcolor",13); - setProgramUniform1i("shadowcolor0",13); - setProgramUniform1i("shadowcolor1",14); - setProgramUniform1i("noisetex",15); - break; - default: - normalMapEnabled = false; - break; - } - ItemStack stack = mc.thePlayer.getCurrentEquippedItem(); - Item item = (stack!=null)? stack.getItem(): null; - int itemID; - Block block; - if (item!=null) { - itemID = Item.itemRegistry.getIDForObject(item); - block = (Block) Block.blockRegistry.getObjectById(itemID); - } else { - itemID = -1; - block = null; - } - setProgramUniform1i("heldItemId", (itemID)); - setProgramUniform1i("heldBlockLightValue", (block!=null)?block.getLightValue():0); - setProgramUniform1i("fogMode", (fogEnabled ? fogMode : 0)); - setProgramUniform3f("fogColor", fogColorR, fogColorG, fogColorB); - setProgramUniform3f("skyColor", skyColorR, skyColorG, skyColorB); - setProgramUniform1i("worldTime", (int)worldTime%24000); - setProgramUniform1i("moonPhase", moonPhase); - setProgramUniform1f("frameTimeCounter", frameTimeCounter); - setProgramUniform1f("sunAngle", sunAngle); - setProgramUniform1f("shadowAngle", shadowAngle); - setProgramUniform1f("rainStrength", rainStrength); - setProgramUniform1f("aspectRatio", (float)renderWidth / (float)renderHeight); - setProgramUniform1f("viewWidth", (float)renderWidth); - setProgramUniform1f("viewHeight", (float)renderHeight); - setProgramUniform1f("near", 0.05F); - setProgramUniform1f("far", mc.gameSettings.renderDistanceChunks * 16); - setProgramUniform3f("sunPosition", sunPosition[0], sunPosition[1], sunPosition[2]); - setProgramUniform3f("moonPosition", moonPosition[0], moonPosition[1], moonPosition[2]); - setProgramUniform3f("upPosition", upPosition[0], upPosition[1], upPosition[2]); - setProgramUniform3f("previousCameraPosition", (float)previousCameraPosition[0], (float)previousCameraPosition[1], (float)previousCameraPosition[2]); - setProgramUniform3f("cameraPosition", (float)cameraPosition[0], (float)cameraPosition[1], (float)cameraPosition[2]); - setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); - setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); - setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); - setProgramUniformMatrix4ARB("gbufferProjection", false, projection); - setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); - setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); - if (usedShadowDepthBuffers > 0) { - setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); - setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); - setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); - setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); - } - setProgramUniform1f("wetness", wetness); - setProgramUniform1f("eyeAltitude", eyePosY); - // .x = block brightness .y = sky brightness - // value : 0,16,32,64,96,112,128,160,192,208,224,240 for light level 0 to 15 - setProgramUniform2i("eyeBrightness", (eyeBrightness & 0xffff), (eyeBrightness>>16)); - setProgramUniform2i("eyeBrightnessSmooth", Math.round(eyeBrightnessFadeX), Math.round(eyeBrightnessFadeY)); - setProgramUniform2i("terrainTextureSize", terrainTextureSize[0], terrainTextureSize[1]); - setProgramUniform1i("terrainIconSize", terrainIconSize); - setProgramUniform1i("isEyeInWater", isEyeInWater); - setProgramUniform1i("hideGUI", mc.gameSettings.hideGUI?1:0); - setProgramUniform1f("centerDepthSmooth", centerDepthSmooth); - setProgramUniform2i("atlasSize", atlasSizeX, atlasSizeY); - Shaders.checkGLError("useProgram ",programNames[program]); - } - - - public static void setProgramUniform1i(String name, int x) { - int gp = programsID[activeProgram]; - if (gp != GL_NONE) { - int uniform = glGetUniformLocationARB(gp, name); - glUniform1iARB(uniform, x); - if(enableShadersDebug) checkGLError(programNames[activeProgram],name); - } - } - - - public static void setProgramUniform2i(String name, int x, int y) { - int gp = programsID[activeProgram]; - if (gp != GL_NONE) { - int uniform = glGetUniformLocationARB(gp, name); - glUniform2iARB(uniform, x, y); - if(enableShadersDebug) checkGLError(programNames[activeProgram],name); - } - } - - - public static void setProgramUniform1f(String name, float x) { - int gp = programsID[activeProgram]; - if (gp != GL_NONE) { - int uniform = glGetUniformLocationARB(gp, name); - glUniform1fARB(uniform, x); - if(enableShadersDebug) checkGLError(programNames[activeProgram],name); - } - } - - - public static void setProgramUniform3f(String name, float x, float y, float z) { - int gp = programsID[activeProgram]; - if (gp != GL_NONE) { - int uniform = glGetUniformLocationARB(gp, name); - glUniform3fARB(uniform, x, y, z); - if(enableShadersDebug) checkGLError(programNames[activeProgram],name); - } - } - - - public static void setProgramUniformMatrix4ARB(String name, boolean transpose, FloatBuffer matrix) { - int gp = programsID[activeProgram]; - if (gp != GL_NONE && matrix != null) { - int uniform = glGetUniformLocationARB(gp, name); - glUniformMatrix4ARB(uniform, transpose, matrix); - if(enableShadersDebug) checkGLError(programNames[activeProgram],name); - } - } - - private static int getBufferIndexFromString(String name) - { - if (name.equals("colortex0")||name.equals("gcolor" )) return 0; - else if (name.equals("colortex1")||name.equals("gdepth" )) return 1; - else if (name.equals("colortex2")||name.equals("gnormal" )) return 2; - else if (name.equals("colortex3")||name.equals("composite")) return 3; - else if (name.equals("colortex4")||name.equals("gaux1" )) return 4; - else if (name.equals("colortex5")||name.equals("gaux2" )) return 5; - else if (name.equals("colortex6")||name.equals("gaux3" )) return 6; - else if (name.equals("colortex7")||name.equals("gaux4" )) return 7; - else return -1; - } - - private static int getTextureFormatFromString(String par) - { - if (par.matches("[ \t]*R8[ \t]*")) - return GL_R8; - - else if (par.matches("[ \t]*RG8[ \t]*")) - return GL_RG8; - - else if (par.matches("[ \t]*RGB8[ \t]*")) - return GL_RGB8; - - else if (par.matches("[ \t]*RGBA8[ \t]*")) - return GL_RGBA8; - - else if (par.matches("[ \t]*R16[ \t]*")) - return GL_R16; - - else if (par.matches("[ \t]*RG16[ \t]*")) - return GL_RG16; - - else if (par.matches("[ \t]*RGB16[ \t]*")) - return GL_RGB16; - - else if (par.matches("[ \t]*RGBA16[ \t]*")) - return GL_RGBA16; - - else if (par.matches("[ \t]*R32F[ \t]*")) - return GL_R32F; - - else if (par.matches("[ \t]*RG32F[ \t]*")) - return GL_RG32F; - - else if (par.matches("[ \t]*RGB32F[ \t]*")) - return GL_RGB32F; - - else if (par.matches("[ \t]*RGBA32F[ \t]*")) - return GL_RGBA32F; - - else - return 0; - } - - - private static void setupNoiseTexture() - { - if (noiseTexture == null) - noiseTexture = new HFNoiseTexture(noiseTextureResolution, noiseTextureResolution); - } - - private static IntBuffer fillIntBufferZero(IntBuffer buf) - { - int limit = buf.limit(); - for (int i=buf.position(); i> 16 )*(1-temp2); - } - - isEyeInWater = (mc.gameSettings.thirdPersonView == 0 - && !mc.renderViewEntity.isPlayerSleeping() - && mc.thePlayer.isInsideOfMaterial(Material.water)) ? - 1: 0; - - { - Vec3 skyColorV = mc.theWorld.getSkyColor(mc.renderViewEntity, f); - skyColorR = (float) skyColorV.xCoord; - skyColorG = (float) skyColorV.yCoord; - skyColorB = (float) skyColorV.zCoord; - } - - //Determine average color -// { -// int searchWidth = renderWidth / 2; -// int searchHeight = renderHeight / 2; -// -// ByteBuffer colorByteBuffer = ByteBuffer.allocateDirect(searchWidth * searchHeight * 4 * 3); -// glReadPixels((renderWidth / 2) - (searchWidth / 2), (renderHeight / 2) - (searchHeight / 2), searchWidth, searchHeight, GL11.GL_RGB, GL11.GL_FLOAT, colorByteBuffer); -// -// colorByteBuffer.order(ByteOrder.LITTLE_ENDIAN); -// -// -// float averageColor = 0.0f; -// for (int i = 0; i < searchWidth; i++) { -// for (int j = 0; j < searchHeight; j++) { -// averageColor += colorByteBuffer.getFloat(i * 4 + (searchWidth * 4 * 3 * j)); -// } -// } -// -// System.out.println("Color: " + averageColor / (searchWidth * searchHeight)); -// -// } - - isRenderingWorld = true; - isCompositeRendered = false; - isHandRendered = false; - - if (usedShadowDepthBuffers >= 1) { - glActiveTexture(GL_TEXTURE4); - glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); - if (usedShadowDepthBuffers >= 2) { - glActiveTexture(GL_TEXTURE5); - glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); - } - } - - for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) - { - glActiveTexture(GL_TEXTURE7+i); - glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4+i)); - } - - glActiveTexture(GL_TEXTURE6); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); - - if (usedDepthBuffers >= 2) { - glActiveTexture(GL_TEXTURE11); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); - - if (usedDepthBuffers >= 3) { - glActiveTexture(GL_TEXTURE12); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); - } - } - - for (int i = 0; i < usedShadowColorBuffers; ++i) - { - glActiveTexture(GL_TEXTURE13+i); - glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); - } - - if (noiseTextureEnabled) { - glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); - glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); - } - - glActiveTexture(GL_TEXTURE0); - - previousCameraPosition[0] = cameraPosition[0]; - previousCameraPosition[1] = cameraPosition[1]; - previousCameraPosition[2] = cameraPosition[2]; - - previousProjection.position(0); projection.position(0); - previousProjection.put(projection); - previousProjection.position(0); projection.position(0); - previousModelView.position(0); modelView.position(0); - previousModelView.put(modelView); - previousModelView.position(0); modelView.position(0); - - EntityRenderer.anaglyphField = 0; - - if (usedShadowDepthBuffers > 0 && --shadowPassCounter <= 0) { - // do shadow pass - //System.out.println("shadow pass start"); - mc.mcProfiler.endStartSection("shadow pass"); - preShadowPassThirdPersonView = mc.gameSettings.thirdPersonView; - boolean preShadowPassAdvancedOpengl = mc.gameSettings.advancedOpengl; - mc.gameSettings.advancedOpengl = false; - - // moved to setCamera - //mc.gameSettings.thirdPersonView = 1; - - isShadowPass = true; - shadowPassCounter = shadowPassInterval; - - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); - glDrawBuffers(programsDrawBuffers[ProgramShadow]); - - useProgram(ProgramShadow); - - mc.entityRenderer.renderWorld(f, l); - - glFlush(); - - isShadowPass = false; - - mc.gameSettings.advancedOpengl = preShadowPassAdvancedOpengl; - mc.gameSettings.thirdPersonView = preShadowPassThirdPersonView; - - if (hasGlGenMipmap) { - if (usedShadowDepthBuffers >= 1) { - if (shadowMipmapEnabled[0]) { - glActiveTexture(GL_TEXTURE4); - glGenerateMipmap(GL_TEXTURE_2D); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowFilterNearest[0]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); - } - if (usedShadowDepthBuffers >= 2) { - if (shadowMipmapEnabled[1]) { - glActiveTexture(GL_TEXTURE5); - glGenerateMipmap(GL_TEXTURE_2D); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowFilterNearest[1]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); - } - } - glActiveTexture(GL_TEXTURE0); - } - if (usedShadowColorBuffers >= 1) { - if (shadowColorMipmapEnabled[0]) { - glActiveTexture(GL_TEXTURE13); - glGenerateMipmap(GL_TEXTURE_2D); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowColorFilterNearest[0]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); - } - if (usedShadowColorBuffers >= 2) { - if (shadowColorMipmapEnabled[1]) { - glActiveTexture(GL_TEXTURE14); - glGenerateMipmap(GL_TEXTURE_2D); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, shadowColorFilterNearest[1]? GL_NEAREST_MIPMAP_NEAREST: GL_LINEAR_MIPMAP_LINEAR); - } - } - glActiveTexture(GL_TEXTURE0); - } - } - - //System.out.println("shadow pass end"); - } - mc.mcProfiler.endSection(); - - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); - GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); - activeDrawBuffers = null; - ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); - useProgram(ProgramTextured); - - checkGLError("end beginRender"); - } - - - public static void setViewport(int vx, int vy, int vw, int vh) { - GL11.glColorMask(true, true, true, true); - if (isShadowPass) { - GL11.glViewport(0, 0, shadowMapWidth, shadowMapHeight); - } else { - GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); - isRenderingDfb = true; - GL11.glEnable(GL11.GL_CULL_FACE); - GL11.glEnable(GL11.GL_DEPTH_TEST); - setDrawBuffers(drawBuffersNone); - useProgram(ProgramTextured); - checkGLError("beginRenderPass"); - } - } - - - public static int setFogMode(int val) - { - return fogMode = val; - } - - - public static void setFogColor(float r, float g, float b) - { - fogColorR = r; - fogColorG = g; - fogColorB = b; - } - - public static void setClearColor(float red, float green, float blue, float alpha) - { - GL11.glClearColor(red, green, blue, alpha); - clearColorR = red; - clearColorG = green; - clearColorB = blue; - } - - public static void clearRenderBuffer() { - //clearColorR = fogColorR; - //clearColorG = fogColorG; - //clearColorB = fogColorB; - - if (isShadowPass) { - // No need to clear shadow depth 1. It will be overwritten. - //if (waterShadowEnabled) { - // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(1), 0); - // glClear(GL_DEPTH_BUFFER_BIT); - //} - checkGLError("shadow clear pre"); - glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(0), 0); - glClearColor(1.0f, 1.0f, 1.0f, 1.0f); - //printIntBuffer(programsDrawBuffers[ProgramShadow]); - glDrawBuffers(programsDrawBuffers[ProgramShadow]); - checkFramebufferStatus("shadow clear"); - glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); - checkGLError("shadow clear"); - return; - } - checkGLError("clear pre"); - - /* - glDrawBuffers(dfbDrawBuffers); - glClearColor(0.0f, 0.0f, 0.0f, 0.0f); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - */ - - glDrawBuffers(GL_COLOR_ATTACHMENT0_EXT); - //glClearColor(clearColorR, clearColorG, clearColorB, 1.0f); - //glClearColor(1f, 0f, 0f, 1.0f); // for debug - glClear(GL_COLOR_BUFFER_BIT); - - glDrawBuffers(GL_COLOR_ATTACHMENT1_EXT); - glClearColor(1.0f, 1.0f, 1.0f, 1.0f); - glClear(GL_COLOR_BUFFER_BIT); - - for (int i=2; i 0.0f ? (angle % shadowAngleInterval - (shadowAngleInterval * 0.5f)) : 0.0f; - if (sunAngle <= 0.5) { - // day time - glRotatef(angle - angleInterval, 0.0f, 0.0f, 1.0f); - glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); //rotate - shadowAngle = sunAngle; - } else { - // night time - glRotatef(angle + 180.0f - angleInterval, 0.0f, 0.0f, 1.0f); - glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); //rotate - shadowAngle = sunAngle - 0.5f; - } - if (shadowMapIsOrtho) { - // reduces jitter - float trans = shadowIntervalSize; - float trans2 = trans / 2.0f; - glTranslatef((float)x % trans - trans2, (float)y % trans - trans2, (float)z % trans - trans2); - } - - glGetFloat(GL_PROJECTION_MATRIX, (FloatBuffer)shadowProjection.position(0)); - invertMat4x((FloatBuffer)shadowProjection.position(0), (FloatBuffer)shadowProjectionInverse.position(0)); - shadowProjection.position(0); shadowProjectionInverse.position(0); - - glGetFloat(GL_MODELVIEW_MATRIX, (FloatBuffer)shadowModelView.position(0)); - invertMat4x((FloatBuffer)shadowModelView.position(0), (FloatBuffer)shadowModelViewInverse.position(0)); - shadowModelView.position(0); shadowModelViewInverse.position(0); - - setProgramUniformMatrix4ARB("gbufferProjection", false, projection); - setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); - setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); - setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); - setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); - setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); - setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); - setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); - setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); - setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); - - // Also render player shadow - mc.gameSettings.thirdPersonView = 1; - checkGLError("setCamera"); - return; - } - checkGLError("setCamera"); - } - - public static void preCelestialRotate() { - Shaders.setUpPosition(); - GL11.glRotatef(Shaders.sunPathRotation * 1.0f, 0.0f, 0.0f, 1.0f); - checkGLError("preCelestialRotate"); - } - - public static void postCelestialRotate() { - // This is called when the current matrix is the modelview matrix based on the celestial angle. - // The sun is at (0, 100, 0), and the moon is at (0, -100, 0). - FloatBuffer modelView = tempMatrixDirectBuffer; - modelView.clear(); - glGetFloat(GL_MODELVIEW_MATRIX, modelView); - modelView.get(tempMat, 0, 16); - multiplyMat4xVec4(tempMat, sunPosModelView, sunPosition); - multiplyMat4xVec4(tempMat, moonPosModelView, moonPosition); - checkGLError("postCelestialRotate"); - } - - public static void setUpPosition() { - // Up direction in model view while rendering sky. - FloatBuffer modelView = tempMatrixDirectBuffer; - modelView.clear(); - glGetFloat(GL_MODELVIEW_MATRIX, modelView); - modelView.get(tempMat, 0, 16); - multiplyMat4xVec4(tempMat, upPosModelView, upPosition); - } - - private static float[] multiplyMat4xVec4(float[] matA, float[] vecB, float[] vecOut) { - vecOut[0] = matA[0] * vecB[0] + matA[4] * vecB[1] + matA[8] * vecB[2] + matA[12] * vecB[3]; - vecOut[1] = matA[1] * vecB[0] + matA[5] * vecB[1] + matA[9] * vecB[2] + matA[13] * vecB[3]; - vecOut[2] = matA[2] * vecB[0] + matA[6] * vecB[1] + matA[10] * vecB[2] + matA[14] * vecB[3]; - vecOut[3] = matA[3] * vecB[0] + matA[7] * vecB[1] + matA[11] * vecB[2] + matA[15] * vecB[3]; - return vecOut; - } - - static float[] invertMat4x_m = new float[16]; - static float[] invertMat4x_inv = new float[16]; - - private static FloatBuffer invertMat4x(FloatBuffer matIn, FloatBuffer invMatOut) { - float[] m = invertMat4x_m; - float[] inv = invertMat4x_inv; - float det; - int i; - - matIn.get(m); - - inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15] + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10]; - inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15] - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10]; - inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15] + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9]; - inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14] - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9]; - inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15] - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10]; - inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15] + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10]; - inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15] - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9]; - inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14] + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9]; - inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15] + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6]; - inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15] - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6]; - inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15] + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5]; - inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14] - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5]; - inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11] - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6]; - inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11] + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6]; - inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11] - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5]; - inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10] + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5]; - - det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12]; - - if (det != 0.0) { - for (i = 0; i < 16; ++i) - inv[i] /= det; - } else { - // no inverse - Arrays.fill(inv, 0); - } - - invMatOut.put(inv); - - return invMatOut; - } - - public static void genCompositeMipmap() - { - if (hasGlGenMipmap) { - if ((activeCompositeMipmapSetting & (1<<0)) != 0) { - glActiveTexture(GL_TEXTURE0); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glGenerateMipmap(GL_TEXTURE_2D); - } - - if ((activeCompositeMipmapSetting & (1<<1)) != 0) { - glActiveTexture(GL_TEXTURE1); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glGenerateMipmap(GL_TEXTURE_2D); - } - - if ((activeCompositeMipmapSetting & (1<<2)) != 0) { - glActiveTexture(GL_TEXTURE2); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glGenerateMipmap(GL_TEXTURE_2D); - } - - if ((activeCompositeMipmapSetting & (1<<3)) != 0) { - glActiveTexture(GL_TEXTURE3); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glGenerateMipmap(GL_TEXTURE_2D); - } - - for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) - { - if ((activeCompositeMipmapSetting & ((1<<4)<= 1) { - glActiveTexture(GL_TEXTURE4); - glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); - if (usedShadowDepthBuffers >= 2) { - glActiveTexture(GL_TEXTURE5); - glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); - } - } - - for (int i = 0; i < 4 && 4+i < usedColorBuffers; ++i) - { - glActiveTexture(GL_TEXTURE7+i); - glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4+i)); - } - - glActiveTexture(GL_TEXTURE6); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); - - if (usedDepthBuffers >= 2) { - glActiveTexture(GL_TEXTURE11); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); - - if (usedDepthBuffers >= 3) { - glActiveTexture(GL_TEXTURE12); - glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); - } - } - - for (int i = 0; i < usedShadowColorBuffers; ++i) - { - glActiveTexture(GL_TEXTURE13+i); - glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); - } - - if (noiseTextureEnabled) { - glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); - glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); - } - - glActiveTexture(GL_TEXTURE0); - - // set depth buffer - glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTextures.get(0), 0); - // detach depth buffer - //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0); - - // composite - glDrawBuffers(dfbDrawBuffers); - checkGLError("pre-composite"); - - for (int i=0; i>24); - checkGLError("setEntityHurtFlash"); - } - } - - public static void resetEntityHurtFlash() { - setEntityHurtFlash(0,0); - } - - public static void beginLivingDamage() { - if (isRenderingWorld) - { - ShadersTex.bindTexture(defaultTexture); - if (!isShadowPass) { - //useProgram(ProgramBasic); - setDrawBuffers(drawBuffersColorAtt0); - } - } - } - - public static void endLivingDamage() { - if (isRenderingWorld) - { - if (!isShadowPass) { - //useProgram(ProgramEntities); - setDrawBuffers(programsDrawBuffers[ProgramEntities]); - } - } - } - - public static void beginLitParticles() { - //GL11.glDepthMask(false); - Tessellator.instance.setNormal(0f,0f,0f); - useProgram(ProgramTexturedLit); - } - - public static void beginParticles() { - //GL11.glDepthMask(false); - Tessellator.instance.setNormal(0f,0f,0f); - useProgram(ProgramTextured); - } - - public static void endParticles() { - Tessellator.instance.setNormal(0f,0f,0f); - useProgram(ProgramTexturedLit); - } - - public static void preWater() { - if (isShadowPass) { - if (usedShadowDepthBuffers >= 2) { - // copy depth buffer to shadowtex1 - glActiveTexture(GL_TEXTURE5); - checkGLError("pre copy shadow depth"); - glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowMapWidth, shadowMapHeight); - checkGLError("copy shadow depth"); - glActiveTexture(GL_TEXTURE0); - } - } else { - if (usedDepthBuffers >= 2) { - // copy depth buffer to depthtex1 - glActiveTexture(GL_TEXTURE11); - checkGLError("pre copy depth"); - glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); - checkGLError("copy depth"); - glActiveTexture(GL_TEXTURE0); - } - ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); // flat - } - } - -// public static void beginWaterFancy() { -// if (isRenderingWorld) -// { -// if (!isShadowPass) { -// // program water -// useProgram(Shaders.ProgramWater); -// GL11.glEnable(GL11.GL_BLEND); -// //setDrawBuffers(drawBuffersNone); -// } -// } -// } -// -// public static void midWaterFancy() { -// if (isRenderingWorld) -// { -// if (!isShadowPass) { -// setDrawBuffers(programsDrawBuffers[Shaders.ProgramWater]); -// } -// } -// } - - public static void beginWater() { - if (isRenderingWorld) - { - if (!isShadowPass) { - // program water - useProgram(Shaders.ProgramWater); - GL11.glEnable(GL11.GL_BLEND); - GL11.glDepthMask(true); - } else { - GL11.glDepthMask(true); - } - } - } - - public static void endWater() { - if (isRenderingWorld) - { - if (isShadowPass) { - //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTexture, 0); - } else { - //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); - } - useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); - } - } - - public static void readCenterDepth() { - if (!isShadowPass) { - //Read depth buffer at center of screen for DOF - if (centerDepthSmoothEnabled) - { - tempDirectFloatBuffer.clear(); - glReadPixels(renderWidth / 2, renderHeight / 2, 1, 1, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, tempDirectFloatBuffer); - centerDepth = tempDirectFloatBuffer.get(0); - - //Smooth depth value - float fadeScalar = diffSystemTime * 0.01f; - float fadeFactor = (float)Math.exp(Math.log(0.5)*fadeScalar / centerDepthSmoothHalflife); - centerDepthSmooth = centerDepthSmooth*(fadeFactor) + centerDepth*(1-fadeFactor); - } - } - } - - public static void beginWeather() { - if(!isShadowPass) - { - if (usedDepthBuffers >= 3) { - // copy depth buffer to depthtex2 - glActiveTexture(GL_TEXTURE12); - glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); - glActiveTexture(GL_TEXTURE0); - } - //GL11.glDepthMask(false); - glEnable(GL_DEPTH_TEST); - glEnable(GL_BLEND); - GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); - glEnable(GL_ALPHA_TEST); - useProgram(Shaders.ProgramWeather); - //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbWaterDepthTexture, 0); - } - - //if (isShadowPass) { - // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // will be set to sbf in endHand() - //} - } - - public static void endWeather() { - //GL11.glDepthMask(true); - glDisable(GL_BLEND); - useProgram(ProgramTexturedLit); - //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); - - //if (isShadowPass) { - // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); // was set to 0 in beginWeather() - //} - } - - public static void beginProjectRedHalo() { - useProgram(ProgramBasic); - } - public static void endProjectRedHalo() { - useProgram(ProgramTexturedLit); - } - - public static void applyHandDepth() - { - if (Shaders.configHandDepthMul != 1.0) - { - GL11.glScaled(1.0, 1.0, Shaders.configHandDepthMul); - } - } - - public static void beginHand() { - //glEnable(GL_BLEND); - //glDisable(GL_BLEND); - glMatrixMode(GL_MODELVIEW); - glPushMatrix(); - glMatrixMode(GL_PROJECTION); - glPushMatrix(); - glMatrixMode(GL_MODELVIEW); - useProgram(Shaders.ProgramHand); - checkGLError("beginHand"); - checkFramebufferStatus("beginHand"); - } - - public static void endHand() { - //glDisable(GL_BLEND); - checkGLError("pre endHand"); - checkFramebufferStatus("pre endHand"); - glMatrixMode(GL_PROJECTION); - glPopMatrix(); - glMatrixMode(GL_MODELVIEW); - glPopMatrix(); - GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); - //useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); - checkGLError("endHand"); - } - - public static void beginFPOverlay() { - //GL11.glDisable(GL11.GL_BLEND); - //GL11.glEnable(GL11.GL_BLEND); - //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); - } - - public static void endFPOverlay() { - //GL11.glDisable(GL11.GL_BLEND); - } - - // ---------------------------------------- - - public static void glEnableWrapper(int cap) { - glEnable(cap); - if (cap == GL_TEXTURE_2D) - enableTexture2D(); - else if (cap == GL_FOG) - enableFog(); - } - - public static void glDisableWrapper(int cap) { - glDisable(cap); - if (cap == GL_TEXTURE_2D) - disableTexture2D(); - else if (cap == GL_FOG) - disableFog(); - } - - public static void sglEnableT2D(int cap) - { - glEnable(cap); //GL_TEXTURE_2D - enableTexture2D(); - } - public static void sglDisableT2D(int cap) - { - glDisable(cap); //GL_TEXTURE_2D - disableTexture2D(); - } - - public static void sglEnableFog(int cap) - { - glEnable(cap); //GL_FOG - enableFog(); - } - public static void sglDisableFog(int cap) - { - glDisable(cap); //GL_FOG - disableFog(); - } - - public static void enableTexture2D() - { - if (isRenderingSky) { - useProgram(ProgramSkyTextured); - } else if (activeProgram == ProgramBasic) { - useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); - } - } - public static void disableTexture2D() - { - if (isRenderingSky) { - useProgram(ProgramSkyBasic); - } else if (activeProgram == ProgramTextured || activeProgram == ProgramTexturedLit) { - useProgram(ProgramBasic); - } - } - - public static void enableFog() - { - fogEnabled = true; - setProgramUniform1i("fogMode", fogMode); - } - public static void disableFog() - { - fogEnabled = false; - setProgramUniform1i("fogMode", 0); - } - - public static void sglFogi(int pname, int param) - { - GL11.glFogi(pname, param); - if (pname == GL11.GL_FOG_MODE) { - fogMode = param; - if (fogEnabled) - setProgramUniform1i("fogMode", fogMode); - } - } - - - public static void enableLightmap() { - lightmapEnabled = true; - if (activeProgram == ProgramTextured) { - useProgram(ProgramTexturedLit); - } - } - - public static void disableLightmap() { - lightmapEnabled = false; - if (activeProgram == ProgramTexturedLit) { - useProgram(ProgramTextured); - } - } - - public static int entityData[] = new int[32]; - public static int entityDataIndex = 0; - - public static int getEntityData() - { - return entityData[entityDataIndex*2]; - } - - public static int getEntityData2() { - return entityData[entityDataIndex*2+1]; - } - - public static int setEntityData1(int data1) - { - entityData[entityDataIndex*2 ] = (entityData[entityDataIndex*2 ] & 0xFFFF) | (data1<<16); - return data1; - } - - public static int setEntityData2(int data2) - { - entityData[entityDataIndex*2+1] = (entityData[entityDataIndex*2+1] & 0xFFFF0000) | (data2 & 0xFFFF); - return data2; - } - - public static void pushEntity(int data0, int data1) - { - entityDataIndex++; - entityData[entityDataIndex*2 ] = (data0 & 0xFFFF) | (data1<<16); - entityData[entityDataIndex*2+1] = 0; - } - - public static void pushEntity(int data0) - { - entityDataIndex++; - entityData[entityDataIndex*2 ] = (data0 & 0xFFFF); - entityData[entityDataIndex*2+1] = 0; - } - - public static void pushEntity(Block block) - { - entityDataIndex++; - entityData[entityDataIndex*2 ] = (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); - entityData[entityDataIndex*2+1] = 0; - } - - public static void pushEntity(RenderBlocks rb, Block block, int x, int y, int z) - { - entityDataIndex++; - entityData[entityDataIndex*2 ] = (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); - entityData[entityDataIndex*2+1] = rb.blockAccess.getBlockMetadata(x, y, z); - } - - public static void popEntity() - { - entityData[entityDataIndex*2 ] = 0; - entityData[entityDataIndex*2+1] = 0; - entityDataIndex--; - } - - // ---------------------------------------- - -} diff --git a/java/shadersmodcore/client/ShadersRender.java b/java/shadersmodcore/client/ShadersRender.java deleted file mode 100644 index d0693aec1..000000000 --- a/java/shadersmodcore/client/ShadersRender.java +++ /dev/null @@ -1,105 +0,0 @@ -package shadersmodcore.client; - -import static org.objectweb.asm.Opcodes.INVOKESTATIC; - -import java.nio.IntBuffer; - -import org.lwjgl.opengl.GL11; -import shadersmodcore.transform.Names; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockIce; -import net.minecraft.client.renderer.EntityRenderer; -import net.minecraft.client.renderer.ItemRenderer; -import net.minecraft.client.renderer.RenderGlobal; -import net.minecraft.client.renderer.Tessellator; -import net.minecraft.client.renderer.WorldRenderer; -import net.minecraft.client.renderer.culling.Frustrum; -import net.minecraft.item.Item; -import net.minecraft.item.ItemBlock; -import net.minecraft.item.ItemCloth; - -public class ShadersRender { - - public static void setFrustrumPosition(Frustrum frustrum, double x, double y, double z) - { - frustrum.setPosition(x, y, z); - } - - public static void clipRenderersByFrustrum(RenderGlobal renderGlobal, Frustrum frustrum, float par2) - { - Shaders.checkGLError("pre clip"); - if (!Shaders.isShadowPass) { - WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; - for (int i = 0; i < worldRenderers.length; ++i) - { - if (!worldRenderers[i].skipAllRenderPasses()) - { - worldRenderers[i].updateInFrustum(frustrum); - } - } - } else { - WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; - for (int i = 0; i < worldRenderers.length; ++i) - { - if (!worldRenderers[i].skipAllRenderPasses()) - { - worldRenderers[i].isInFrustum = true; - } - } - } - } - - public static void renderHand0(EntityRenderer er, float par1, int par2) { - if (!Shaders.isShadowPass) - { - Item item = (Shaders.itemToRender!=null)? Shaders.itemToRender.getItem(): null; - Block block = (item instanceof ItemBlock)? ((ItemBlock)item).field_150939_a: null; - // ItemCloth is for semitransparent block : stained glass, wool - if (!(item instanceof ItemBlock) && !(block instanceof BlockIce)) - { - Shaders.readCenterDepth(); - Shaders.beginHand(); - er.renderHand(par1, par2); - Shaders.endHand(); - Shaders.isHandRendered = true; - } - } - } - - public static void renderHand1(EntityRenderer er, float par1, int par2) { - if (!Shaders.isShadowPass) - { - if (!Shaders.isHandRendered) { - Shaders.readCenterDepth(); - GL11.glEnable(GL11.GL_BLEND); - Shaders.beginHand(); - er.renderHand(par1, par2); - Shaders.endHand(); - Shaders.isHandRendered = true; - } - } - } - - public static void renderItemFP(ItemRenderer itemRenderer, float par1) { - // clear depth buffer locally - GL11.glDepthFunc(GL11.GL_GEQUAL); - GL11.glPushMatrix(); - IntBuffer drawBuffers = Shaders.activeDrawBuffers; - Shaders.setDrawBuffers(Shaders.drawBuffersNone); - itemRenderer.renderItemInFirstPerson(par1); - Shaders.setDrawBuffers(drawBuffers); - GL11.glPopMatrix(); - GL11.glDepthFunc(GL11.GL_LEQUAL); - // really render item or hand - itemRenderer.renderItemInFirstPerson(par1); - } - - public static void renderFPOverlay(EntityRenderer er, float par1, int par2) { - Shaders.beginFPOverlay(); - er.renderHand(par1, par2); - Shaders.endFPOverlay(); - } - -} - diff --git a/java/shadersmodcore/client/ShadersTess.java b/java/shadersmodcore/client/ShadersTess.java deleted file mode 100644 index acb2b2993..000000000 --- a/java/shadersmodcore/client/ShadersTess.java +++ /dev/null @@ -1,279 +0,0 @@ -package shadersmodcore.client; - -import static org.lwjgl.opengl.ARBVertexShader.glDisableVertexAttribArrayARB; -import static org.lwjgl.opengl.ARBVertexShader.glEnableVertexAttribArrayARB; -import static org.lwjgl.opengl.ARBVertexShader.glVertexAttribPointerARB; - -import java.nio.FloatBuffer; -import java.nio.ShortBuffer; -import java.util.Arrays; - -import org.lwjgl.opengl.ARBVertexBufferObject; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL13; - -import shadersmodcore.transform.SMCLog; - -import net.minecraft.client.renderer.OpenGlHelper; -import net.minecraft.client.renderer.Tessellator; - -public class ShadersTess { - - public static final int vertexStride = 16; - - public static int draw(Tessellator tess) { - if (!tess.isDrawing) - { - throw new IllegalStateException("Not tesselating!"); - } - else - { - tess.isDrawing = false; - if (tess.drawMode == GL11.GL_QUADS && tess.vertexCount % 4 != 0) { - SMCLog.warning("%s", "bad vertexCount"); - } - int voffset = 0; - int realDrawMode = tess.drawMode; - while (voffset < tess.vertexCount) - { - int vcount; - vcount = Math.min(tess.vertexCount - voffset, tess.byteBuffer.capacity() / (vertexStride*4)); - if (realDrawMode == GL11.GL_QUADS) - vcount = vcount /4 *4; - tess.floatBuffer.clear(); - tess.shortBuffer.clear(); - tess.intBuffer.clear(); - tess.intBuffer.put(tess.rawBuffer, voffset * vertexStride, vcount * vertexStride); - tess.byteBuffer.position(0); - tess.byteBuffer.limit(vcount * (vertexStride * 4)); - voffset += vcount; - - if (tess.hasTexture) - { - tess.floatBuffer.position(3); - GL11.glTexCoordPointer(2, (vertexStride * 4), tess.floatBuffer); - GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - } - if (tess.hasBrightness) - { - OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); - tess.shortBuffer.position(6*2); - GL11.glTexCoordPointer(2, (vertexStride * 4), tess.shortBuffer); - GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); - } - if (tess.hasColor) - { - tess.byteBuffer.position(5*4); - GL11.glColorPointer(4, true, (vertexStride * 4), tess.byteBuffer); - GL11.glEnableClientState(GL11.GL_COLOR_ARRAY); - } - if (tess.hasNormals) - { - tess.floatBuffer.position(9); - GL11.glNormalPointer((vertexStride * 4), tess.floatBuffer); - GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY); - } - tess.floatBuffer.position(0); - GL11.glVertexPointer(3, (vertexStride * 4), tess.floatBuffer); - ShadersTess.preDrawArray(tess); - - GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY); - GL11.glDrawArrays(realDrawMode, 0, vcount); - } - // end loop - - GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY); - ShadersTess.postDrawArray(tess); - if (tess.hasTexture) - { - GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - } - if (tess.hasBrightness) - { - OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); - GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); - } - if (tess.hasColor) - { - GL11.glDisableClientState(GL11.GL_COLOR_ARRAY); - } - if (tess.hasNormals) - { - GL11.glDisableClientState(GL11.GL_NORMAL_ARRAY); - } - - int n = tess.rawBufferIndex * 4; - tess.reset(); - return n; - } - } - - public static void preDrawArray(Tessellator tess) - { - //Shaders.checkGLError("preDrawArray"); - if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) - { - GL13.glClientActiveTexture(GL13.GL_TEXTURE3); - GL11.glTexCoordPointer(2, (vertexStride * 4), (FloatBuffer)tess.floatBuffer.position(12)); - GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - GL13.glClientActiveTexture(GL13.GL_TEXTURE0); - } - if (Shaders.useMidTexCoordAttrib && tess.hasTexture) - { - glVertexAttribPointerARB(Shaders.midTexCoordAttrib, 2, false, vertexStride*4, (FloatBuffer)tess.floatBuffer.position(12)); - glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); - } - if (Shaders.useEntityAttrib) - { - glVertexAttribPointerARB(Shaders.entityAttrib, 3, false, false, vertexStride*4, (ShortBuffer)tess.shortBuffer.position(7*2)); - glEnableVertexAttribArrayARB(Shaders.entityAttrib); - } - //Shaders.checkGLError("preDrawArray"); - } - public static void preDrawArrayVBO(Tessellator tess) - { - //Shaders.checkGLError("preDrawArray"); - if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) - { - GL13.glClientActiveTexture(GL13.GL_TEXTURE3); - GL11.glTexCoordPointer(2, GL11.GL_FLOAT, (vertexStride * 4), 12*4L); - GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - GL13.glClientActiveTexture(GL13.GL_TEXTURE0); - } - if (Shaders.useMidTexCoordAttrib && tess.hasTexture) - { - glVertexAttribPointerARB(Shaders.midTexCoordAttrib, 2, GL11.GL_FLOAT, false, vertexStride*4, 12*4L); - glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); - } - if (Shaders.useEntityAttrib) - { - glVertexAttribPointerARB(Shaders.entityAttrib, 3, GL11.GL_SHORT, false, vertexStride*4, 7*4L); - glEnableVertexAttribArrayARB(Shaders.entityAttrib); - } - //Shaders.checkGLError("preDrawArray"); - } - - public static void postDrawArray(Tessellator tess) - { - //Shaders.checkGLError("postDrawArray"); - if (Shaders.useEntityAttrib) - { - glDisableVertexAttribArrayARB(Shaders.entityAttrib); - } - if (Shaders.useMidTexCoordAttrib && tess.hasTexture) - { - glDisableVertexAttribArrayARB(Shaders.midTexCoordAttrib); - } - if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) - { - GL13.glClientActiveTexture(GL13.GL_TEXTURE3); - GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - GL13.glClientActiveTexture(GL13.GL_TEXTURE0); - } - //Shaders.checkGLError("postDrawArray"); - } - - public static void addVertex(Tessellator tess, double parx, double pary, double parz) { - int[] rawBuffer = tess.rawBuffer; - int rbi = tess.rawBufferIndex; - float fx = (float) (parx + tess.xOffset); - float fy = (float) (pary + tess.yOffset); - float fz = (float) (parz + tess.zOffset); - // Check if buffer is nearly full - if (rbi >= tess.bufferSize - vertexStride*4) - { - if (tess.bufferSize >= 0x1000000) { - // Max size reached. Just draw. - if (tess.addedVertices % 4 == 0) - { - tess.draw(); - tess.isDrawing = true; - } - } else if (tess.bufferSize > 0) { - // Expand - tess.bufferSize *= 2; - tess.rawBuffer = rawBuffer = Arrays.copyOf(tess.rawBuffer, tess.bufferSize); - System.out.format("Expand tesselator buffer %d\n",tess.bufferSize); - } else { - // Initialize - tess.bufferSize = 0x10000; - tess.rawBuffer = rawBuffer = new int[tess.bufferSize]; - } - } - - // shaders mod calculate normal and mid UV - if (tess.drawMode == 7) - { - int i = tess.addedVertices % 4; - float[] vertexPos = tess.vertexPos; - vertexPos[i*4+0] = fx; - vertexPos[i*4+1] = fy; - vertexPos[i*4+2] = fz; - if (i==3) - { - // calculate normal - float x1 = vertexPos[ 8+0] - vertexPos[ +0]; - float y1 = vertexPos[ 8+1] - vertexPos[ +1]; - float z1 = vertexPos[ 8+2] - vertexPos[ +2]; - float x2 = vertexPos[12+0] - vertexPos[ 4+0]; - float y2 = vertexPos[12+1] - vertexPos[ 4+1]; - float z2 = vertexPos[12+2] - vertexPos[ 4+2]; - float vnx = y1*z2-y2*z1; - float vny = z1*x2-z2*x1; - float vnz = x1*y2-x2*y1; - float lensq = vnx*vnx+vny*vny+vnz*vnz; - float mult = (lensq!=0.0)? (float)(1f/Math.sqrt(lensq)): 1f; - rawBuffer[rbi+( 9-vertexStride*3)] = - rawBuffer[rbi+( 9-vertexStride*2)] = - rawBuffer[rbi+( 9-vertexStride*1)] = Float.floatToRawIntBits(tess.normalX = vnx*mult); - rawBuffer[rbi+(10-vertexStride*3)] = - rawBuffer[rbi+(10-vertexStride*2)] = - rawBuffer[rbi+(10-vertexStride*1)] = Float.floatToRawIntBits(tess.normalY = vny*mult); - rawBuffer[rbi+(11-vertexStride*3)] = - rawBuffer[rbi+(11-vertexStride*2)] = - rawBuffer[rbi+(11-vertexStride*1)] = Float.floatToRawIntBits(tess.normalZ = vnz*mult); - tess.hasNormals = true; - // mid UV - tess.midTextureU = ( - Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*3)])+ - Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*2)])+ - Float.intBitsToFloat(rawBuffer[rbi+(3-vertexStride*1)])+ - (float)tess.textureU )/4; - tess.midTextureV = ( - Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*3)])+ - Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*2)])+ - Float.intBitsToFloat(rawBuffer[rbi+(4-vertexStride*1)])+ - (float)tess.textureV )/4; - rawBuffer[rbi+(12-vertexStride*3)] = - rawBuffer[rbi+(12-vertexStride*2)] = - rawBuffer[rbi+(12-vertexStride*1)] = Float.floatToRawIntBits(tess.midTextureU); - rawBuffer[rbi+(13-vertexStride*3)] = - rawBuffer[rbi+(13-vertexStride*2)] = - rawBuffer[rbi+(13-vertexStride*1)] = Float.floatToRawIntBits(tess.midTextureV); - } - } - // end normal and mid UV calculation - - ++tess.addedVertices; - rawBuffer[rbi + 0] = Float.floatToRawIntBits((float)fx); - rawBuffer[rbi + 1] = Float.floatToRawIntBits((float)fy); - rawBuffer[rbi + 2] = Float.floatToRawIntBits((float)fz); - rawBuffer[rbi + 3] = Float.floatToRawIntBits((float)tess.textureU); - rawBuffer[rbi + 4] = Float.floatToRawIntBits((float)tess.textureV); - rawBuffer[rbi + 5] = tess.color; - rawBuffer[rbi + 6] = tess.brightness; - rawBuffer[rbi + 7] = Shaders.getEntityData(); - rawBuffer[rbi + 8] = Shaders.getEntityData2(); - rawBuffer[rbi + 9] = Float.floatToRawIntBits((float)tess.normalX); - rawBuffer[rbi +10] = Float.floatToRawIntBits((float)tess.normalY); - rawBuffer[rbi +11] = Float.floatToRawIntBits((float)tess.normalZ); - rawBuffer[rbi +12] = Float.floatToRawIntBits((float)tess.midTextureU); - rawBuffer[rbi +13] = Float.floatToRawIntBits((float)tess.midTextureV); - - tess.rawBufferIndex = rbi += vertexStride; - ++tess.vertexCount; - } -} - diff --git a/java/shadersmodcore/client/ShadersTex.java b/java/shadersmodcore/client/ShadersTex.java deleted file mode 100644 index f764116c1..000000000 --- a/java/shadersmodcore/client/ShadersTex.java +++ /dev/null @@ -1,969 +0,0 @@ -package shadersmodcore.client; - -import java.awt.image.BufferedImage; -import java.awt.image.ImageObserver; -import java.io.IOException; -import java.io.InputStream; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.IntBuffer; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import javax.imageio.ImageIO; - -import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.GLAllocation; -import net.minecraft.client.renderer.OpenGlHelper; -import net.minecraft.client.renderer.texture.AbstractTexture; -import net.minecraft.client.renderer.texture.DynamicTexture; -import net.minecraft.client.renderer.texture.ITextureObject; -import net.minecraft.client.renderer.texture.LayeredTexture; -import net.minecraft.client.renderer.texture.Stitcher; -import net.minecraft.client.renderer.texture.TextureManager; -import net.minecraft.client.renderer.texture.TextureMap; -import net.minecraft.client.renderer.texture.TextureUtil; -import net.minecraft.util.ResourceLocation; -import net.minecraft.client.renderer.texture.TextureAtlasSprite; -import net.minecraft.client.resources.IResource; -import net.minecraft.client.resources.IResourceManager; - -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.ARBTextureStorage; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL12; -import org.lwjgl.opengl.GL13; -import org.lwjgl.opengl.GL14; -import org.lwjgl.opengl.GL20; -import org.lwjgl.opengl.GL30; -import org.lwjgl.opengl.GL30.*; - -public class ShadersTex { - public static final int initialBufferSize = 1048576; - public static ByteBuffer byteBuffer = BufferUtils.createByteBuffer(initialBufferSize*4); - public static IntBuffer intBuffer = byteBuffer.asIntBuffer(); - public static int[] intArray = new int[initialBufferSize]; - public static final int defBaseTexColor = 0x00000000; - public static final int defNormTexColor = 0xFF7F7FFF; - public static final int defSpecTexColor = 0x00000000; - public static Map multiTexMap = new HashMap(); - public static TextureMap updatingTextureMap = null; - public static TextureAtlasSprite updatingSprite = null; - public static MultiTexID updatingTex = null; - public static MultiTexID boundTex = null; - public static int updatingPage = 0; - public static String iconName = null; - - public static IntBuffer getIntBuffer(int size) - { - if (intBuffer.capacity() < size) - { - int bufferSize = roundUpPOT(size); - byteBuffer = BufferUtils.createByteBuffer(bufferSize*4); - intBuffer = byteBuffer.asIntBuffer(); - } - return intBuffer; - } - - public static int[] getIntArray(int size) - { - if (intArray.length < size) - { - intArray = null; - intArray = new int[roundUpPOT(size)]; - } - return intArray; - } - - public static int roundUpPOT(int x) - { - int i = x-1; - i |= (i>>1); - i |= (i>>2); - i |= (i>>4); - i |= (i>>8); - i |= (i>>16); - return i+1; - } - - public static IntBuffer fillIntBuffer(int size, int value) - { - int[] aint = getIntArray(size); - IntBuffer intBuf = getIntBuffer(size); - Arrays.fill(intArray, 0, size, value); - intBuffer.put(intArray, 0, size); - return intBuffer; - } - - public static int[] createAIntImage(int size) - { - int[] aint = new int[size*3]; - Arrays.fill(aint, 0, size, defBaseTexColor); - Arrays.fill(aint, size, size*2, defNormTexColor); - Arrays.fill(aint, size*2, size*3, defSpecTexColor); - return aint; - } - - public static int[] createAIntImage(int size, int color) - { - int[] aint = new int[size*3]; - Arrays.fill(aint, 0, size, color); - Arrays.fill(aint, size, size*2, defNormTexColor); - Arrays.fill(aint, size*2, size*3, defSpecTexColor); - return aint; - } - - public static MultiTexID getMultiTexID(AbstractTexture tex) - { - MultiTexID multiTex = tex.multiTex; - if (multiTex==null) - { - int baseTex = tex.getGlTextureId(); - multiTex = multiTexMap.get(Integer.valueOf(baseTex)); - if (multiTex == null) - { - multiTex = new MultiTexID(baseTex, GL11.glGenTextures(), GL11.glGenTextures()); - multiTexMap.put(baseTex, multiTex); - } - tex.multiTex = multiTex; - } - return multiTex; - } - - public static void deleteTextures(AbstractTexture atex) - { - int texid = atex.glTextureId; - if (texid != -1) - { - GL11.glDeleteTextures(texid); - atex.glTextureId = -1; - } - MultiTexID multiTex = atex.multiTex; - if (multiTex != null) - { - atex.multiTex = null; - multiTexMap.remove(Integer.valueOf(multiTex.base)); - GL11.glDeleteTextures(multiTex.norm); - GL11.glDeleteTextures(multiTex.spec); - if (multiTex.base != texid) - { - System.err.println("Error : MultiTexID.base mismatch."); - GL11.glDeleteTextures(multiTex.base); - } - } - } - - /** Remove MultiTexID object reference and delete textures */ - public static int deleteMultiTex(ITextureObject tex) - { - if (tex instanceof AbstractTexture) { - deleteTextures((AbstractTexture)tex); - } else { - GL11.glDeleteTextures(tex.getGlTextureId()); - } - return 0; - } - - public static void bindNSTextures(int normTex, int specTex) - { - //Shaders.checkGLError("pre bindNSTextures"); - if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) - { - GL13.glActiveTexture(GL13.GL_TEXTURE2); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); - GL13.glActiveTexture(GL13.GL_TEXTURE3); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); - GL13.glActiveTexture(GL13.GL_TEXTURE0); - } - //Shaders.checkGLError("bindNSTextures"); - } - - public static void bindNSTextures(MultiTexID multiTex) - { - bindNSTextures(multiTex.norm, multiTex.spec); - } - - public static void bindTextures(int baseTex, int normTex, int specTex) - { - //Shaders.checkGLError("pre bindTextures"); - if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) - { - GL13.glActiveTexture(GL13.GL_TEXTURE2); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); - GL13.glActiveTexture(GL13.GL_TEXTURE3); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); - GL13.glActiveTexture(GL13.GL_TEXTURE0); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, baseTex); - //Shaders.checkGLError("bindTextures"); - } - - public static void bindTextures(MultiTexID multiTex) - { - boundTex = multiTex; - if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) - { - if (Shaders.configNormalMap) { - GL13.glActiveTexture(GL13.GL_TEXTURE2); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - } - if (Shaders.configSpecularMap) { - GL13.glActiveTexture(GL13.GL_TEXTURE3); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); - } - GL13.glActiveTexture(GL13.GL_TEXTURE0); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - } - - public static void bindTexture(ITextureObject tex) - { - if (tex instanceof TextureMap) { - Shaders.atlasSizeX = ((TextureMap)tex).atlasWidth; - Shaders.atlasSizeY = ((TextureMap)tex).atlasHeight; - } else { - Shaders.atlasSizeX = 0; - Shaders.atlasSizeY = 0; - } - bindTextures(tex.getMultiTexID()); - } - - /** not used */ - public static void bindTextures(int baseTex) - { - MultiTexID multiTex = multiTexMap.get(Integer.valueOf(baseTex)); - bindTextures(multiTex); - } - - public static void allocTexStorage(int width, int height, int maxLevel) - { - Shaders.checkGLError("pre allocTexStorage"); - int level; - for (level=0; (width>>level)>0 && (height>>level)>0 /*&& level<=maxLevel*/; ++level) { - GL11.glTexImage2D(GL11.GL_TEXTURE_2D, level, GL11.GL_RGBA, (width>>level), (height>>level), 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (IntBuffer)null); - } - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, level-1); - Shaders.checkGLError("allocTexStorage"); - //clear unused level otherwise glTexSubImage2D will crash on AMD when reallocation texture of different size. - //for ( ; level < 16 ; ++level) { - // GL11.glTexImage2D(GL11.GL_TEXTURE_2D, level, GL11.GL_RGBA, 0, 0, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (IntBuffer)null); - //} - GL11.glGetError(); // It usually returns error 0x0501 Invalid value for width 0 height 0. Ignore it. - } - - // for Dynamic Texture - public static void initDynamicTexture(int texID, int width, int height, DynamicTexture tex) - { - MultiTexID multiTex = tex.getMultiTexID(); - int[] aint = tex.getTextureData(); - int size = width * height; - Arrays.fill(aint, size, size*2, defNormTexColor); - Arrays.fill(aint, size*2, size*3, defSpecTexColor); - // base texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - allocTexStorage(width,height,0); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); - - // norm texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - allocTexStorage(width,height,0); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); - - // spec texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); - allocTexStorage(width,height,0); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); - - // base texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - } - - public static ITextureObject createDefaultTexture() - { - DynamicTexture tex = new DynamicTexture(1,1); - tex.getTextureData()[0] = 0xffffffff; - tex.updateDynamicTexture(); - return tex; - } - - // for TextureMap - public static void allocateTextureMap(int texID, int mipmapLevels, int width, int height, float anisotropy, Stitcher stitcher, TextureMap tex) - { - System.out.println("allocateTextureMap "+tex.getTextureType()+" "+mipmapLevels+" "+width+" "+height+" "+anisotropy+" "); - updatingTextureMap = tex; - tex.atlasWidth = width; - tex.atlasHeight = height; - MultiTexID multiTex = getMultiTexID(tex); - updatingTex = multiTex; - TextureUtil.allocateTextureImpl(multiTex.base, mipmapLevels, width, height, anisotropy); - if (Shaders.configNormalMap ) - TextureUtil.allocateTextureImpl(multiTex.norm, mipmapLevels, width, height, anisotropy); - if (Shaders.configSpecularMap) - TextureUtil.allocateTextureImpl(multiTex.spec, mipmapLevels, width, height, anisotropy); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); - } - - public static TextureAtlasSprite setSprite(TextureAtlasSprite tas) - { - return updatingSprite = tas; - } - - public static String setIconName(String name) - { - return iconName = name; - } - - public static void uploadTexSubForLoadAtlas(int[][] data, int width, int height, int xoffset, int yoffset, boolean linear, boolean clamp) - { - TextureUtil.uploadTextureMipmap(data, width, height, xoffset, yoffset, linear, clamp); - boolean border = updatingSprite.useAnisotropicFiltering; - int[][] aaint; - // - if (Shaders.configNormalMap ) { - aaint = readImageAndMipmaps(iconName+"_n", width, height, data.length, border, defNormTexColor); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.norm); - TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); - } - // - if (Shaders.configSpecularMap) { - aaint = readImageAndMipmaps(iconName+"_s", width, height, data.length, border, defSpecTexColor); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); - TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); - } - // - GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.base); - } - - public static int[][] readImageAndMipmaps(String name, int width, int height, int numLevels, boolean border, int defColor) - { - int[][] aaint = new int[numLevels][]; - int[] aint; - aaint[0] = aint = new int[width*height]; - boolean goodImage = false; - BufferedImage image = readImage(updatingTextureMap.completeResourceLocation(new ResourceLocation(name), 0)); - if (image != null) { - int imageWidth = image.getWidth(); - int imageHeight = image.getHeight(); - if (imageWidth + (border? 16: 0) == width) - { - goodImage = true; - image.getRGB(0, 0, imageWidth, imageWidth, aint, 0, imageWidth); - if (border) - TextureUtil.prepareAnisotropicData(aint, imageWidth, imageWidth, 8); - } - } - if (!goodImage) { - Arrays.fill(aint, defColor); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); - aaint = genMipmapsSimple(aaint.length-1, width, aaint); - return aaint; - } - - public static BufferedImage readImage(ResourceLocation resLoc) - { - BufferedImage image = null; - InputStream istr = null; - try { - istr = resManager.getResource(resLoc).getInputStream(); - image = ImageIO.read(istr); - } catch (IOException e) { - } - if (istr != null) { - try { - istr.close(); - } catch (IOException e) { - } - istr = null; - } - return image; - } - - public static int[][] genMipmapsSimple(int maxLevel, int width, int[][]data) - { - int level; - for (level=1; level<=maxLevel; ++level) - { - if (data[level]==null) - { - int cw = width>>level; - int pw = cw*2; - int[] aintp = data[level-1]; - int[] aintc = data[level] = new int[cw*cw]; - int x,y; - for (y=0; y>> 24) & 255; - int a1 = (c1 >>> 24) & 255; - int a2 = (c2 >>> 24) & 255; - int a3 = (c3 >>> 24) & 255; - int as = a0+a1+a2+a3; - int an = (as+2)/4; - //int an = Math.min(Math.min(Math.min(a0,a1),a2),a3); - int dv; - if (as != 0) { - dv = as; - } else { - dv=4; a3=a2=a1=a0=1; - } - int frac = (dv+1)/2; - //return (((Math.min(Math.min(Math.min(a0,a1),a2),a3)/ 4) << 24) | - int color = (an << 24) | - (((((c0>>>16)&255)*a0 + ((c1>>>16)&255)*a1 + ((c2>>>16)&255)*a2 + ((c3>>>16)&255)*a3 + frac)/dv) << 16) | - (((((c0>>> 8)&255)*a0 + ((c1>>> 8)&255)*a1 + ((c2>>> 8)&255)*a2 + ((c3>>> 8)&255)*a3 + frac)/dv) << 8) | - (((((c0>>> 0)&255)*a0 + ((c1>>> 0)&255)*a1 + ((c2>>> 0)&255)*a2 + ((c3>>> 0)&255)*a3 + frac)/dv) << 0) ; - return color; - } - - public static int blend4Simple(int c0, int c1, int c2, int c3) - { - int color = - (((((c0>>>24)&255) + ((c1>>>24)&255) + ((c2>>>24)&255) + ((c3>>>24)&255) + 2)/4) << 24) | - (((((c0>>>16)&255) + ((c1>>>16)&255) + ((c2>>>16)&255) + ((c3>>>16)&255) + 2)/4) << 16) | - (((((c0>>> 8)&255) + ((c1>>> 8)&255) + ((c2>>> 8)&255) + ((c3>>> 8)&255) + 2)/4) << 8) | - (((((c0>>> 0)&255) + ((c1>>> 0)&255) + ((c2>>> 0)&255) + ((c3>>> 0)&255) + 2)/4) << 0) ; - return color; - } - - - public static void genMipmapAlpha(int[] aint, int offset, int width, int height) - { - int minwh = Math.min(width, height); - int level; - int w1, w2, h1, h2, o1, o2; - w1 = w2 = width; - h1 = h2 = height; - o1 = o2 = offset; - // generate mipmap from big to small - o2 = offset; w2 = width; h2 = height; - o1 = 0; w1 = 0; h1 = 0; - for (level=0; w2>1 && h2>1; ++level,w2=w1,h2=h1,o2=o1) { - o1 = o2 + w2*h2; - w1 = w2/2; h1 = h2/2; - for (int y=0; y0) - { - --level; - w2 = width>>level; - h2 = height>>level; - o2 = o1 - w2*h2; - int p2 = o2; - for (int y=0; y1 && h2>1; ++level,w2=w1,h2=h1,o2=o1) { - o1 = o2 + w2*h2; - w1 = w2/2; h1 = h2/2; - for (int y=0; y0) - { - --level; - w2 = width>>level; - h2 = height>>level; - o2 = o1 - w2*h2; - int p2 = o2; - for (int y=0; y>> 24 == 255 && aint[size-1] == 0) - return true; - for (int i=0; i>> 24; - if (alpha!=0 && alpha!=255) - return true; - } - return false; - } - - public static void updateSubImage1(int[] src, int width, int height, int posX, int posY, int page, int color) - { - int size = width * height; - IntBuffer intBuf = getIntBuffer(size); - int[] aint = getIntArray((size*4+2)/3); - if (src.length >= size*(page+1)) - { - System.arraycopy(src, size*page, aint, 0, size); - } - else - { - Arrays.fill(aint, color); - } - // -// if (page == 0) - genMipmapAlpha(aint,0,width,height); -// else -// genMipmapSimple(aint,0,width,height); - // - for (int level=0, offset=0, lw=width, lh=height, px=posX, py=posY; - lw>0 && lh>0; - ++level) - { - int lsize = lw*lh; - intBuf.clear(); - intBuf.put(aint, offset, lsize).position(0).limit(lsize); - GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, level, px, py, lw, lh, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - offset += lsize; lw/=2; lh/=2; px/=2; py/=2; - } - intBuf.clear(); - } - - public static void updateSubTex1(int[] src, int width, int height, int posX, int posY) - { - int level; - int cw; - int ch; - int cx; - int cy; - for (level = 0, cw=width, ch=height, cx=posX, cy=posY; - cw>0 && ch>0; - ++level, cw/=2, ch/=2, cx/=2, cy/=2) - { - GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, level, cx, cy, 0, 0, cw, ch); - } - } - - /* updateSubImage for single Texture with mipmap */ - public static void updateSubImage1(int[][] src, int width, int height, int posX, int posY, int page, int color) - { - int size = width * height; - IntBuffer intBuf = getIntBuffer(size); - int numLevel = src.length; - for (int level=0, //offset=0, - lw=width, lh=height, px=posX, py=posY; - lw>0 && lh>0 && level iterator; - MultiTexID multiTex = tex.getMultiTexID(); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - for (iterator = tasList.iterator(); iterator.hasNext(); ) - { - TextureAtlasSprite tas = iterator.next(); - tas.updateAnimation(); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - for (iterator = tasList.iterator(); iterator.hasNext(); ) - { - TextureAtlasSprite tas = iterator.next(); - tas.updateAnimation(); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - for (iterator = tasList.iterator(); iterator.hasNext(); ) - { - TextureAtlasSprite tas = iterator.next(); - tas.updateAnimation(); - } - } - - public static void setupTexture(MultiTexID multiTex, int[] src, int width, int height, boolean linear, boolean clamp) - { - int mmfilter = linear? GL11.GL_LINEAR: GL11.GL_NEAREST; - int wraptype = clamp? GL11.GL_CLAMP: GL11.GL_REPEAT; - int size = width * height; - IntBuffer intBuf = getIntBuffer(size); - // - intBuf.clear(); - intBuf.put(src, 0, size).position(0).limit(size); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); - // - intBuf.put(src, size, size).position(0).limit(size); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); - // - intBuf.put(src, size*2, size).position(0).limit(size); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); - GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); - // - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - } - - /* currently not used */ - public static void updateSubImage(MultiTexID multiTex, int[] src, int width, int height, int posX, int posY, boolean linear, boolean clamp) - { - int size = width * height; - IntBuffer intBuf = getIntBuffer(size); - // - intBuf.clear(); - intBuf.put(src, 0, size); - intBuf.position(0).limit(size); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - if (src.length == size*3) - { - intBuf.clear(); - intBuf.put(src, size, size).position(0); - intBuf.position(0).limit(size); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - if (src.length == size*3) - { - intBuf.clear(); - intBuf.put(src, size*2, size); - intBuf.position(0).limit(size); - } - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, posX, posY, width, height, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); - GL13.glActiveTexture(GL13.GL_TEXTURE0); - } - - public static ResourceLocation getNSMapLocation(ResourceLocation location, String mapName) - { - String basename = location.getResourcePath(); - String[] basenameParts = basename.split(".png"); - String basenameNoFileType = basenameParts[0]; - return new ResourceLocation(location.getResourceDomain(),basenameNoFileType+"_"+mapName+".png"); - } - - public static void loadNSMap(IResourceManager manager, ResourceLocation location, int width, int height, int[] aint) - { - if (Shaders.configNormalMap) - ShadersTex.loadNSMap1(manager, getNSMapLocation(location,"n"), width, height, aint, width*height , defNormTexColor); - if (Shaders.configSpecularMap) - ShadersTex.loadNSMap1(manager, getNSMapLocation(location,"s"), width, height, aint, width*height*2, defSpecTexColor); - } - - public static void loadNSMap1(IResourceManager manager, ResourceLocation location, int width, int height, int[] aint, int offset, int defaultColor) - { - boolean good = false; - try - { - IResource res = manager.getResource(location); - BufferedImage bufferedimage = ImageIO.read(res.getInputStream()); - if (bufferedimage.getWidth()==width && bufferedimage.getHeight()==height) - { - bufferedimage.getRGB(0, 0, width, height, aint, offset, width); - good = true; - } - } - catch (IOException ex) - { - } - if (!good) - { - java.util.Arrays.fill(aint,offset,offset+width*height,defaultColor); - } - } - - /** init and upload from BufferedImage */ - /* Replacement for TextureUtil.func_110989_a call in SimpleTexture.func_110551_a. - Keep par0...par5 the same as func_110989_a for easy patching. - More parameters added for reading N-S-Map. */ - public static int loadSimpleTexture(int textureID, - BufferedImage bufferedimage, boolean linear, boolean clamp, - IResourceManager resourceManager, ResourceLocation location, MultiTexID multiTex) - { - int width = bufferedimage.getWidth(); - int height = bufferedimage.getHeight(); - int size = width*height; - int[] aint = getIntArray(size*3); - bufferedimage.getRGB(0, 0, width, height, aint, 0, width); - loadNSMap(resourceManager, location, width, height, aint); - setupTexture(multiTex, aint, width, height, linear, clamp); - return textureID; - } - - public static void mergeImage(int[] aint, int dstoff, int srcoff, int size) - { - - } - - public static int blendColor(int color1, int color2, int factor1) - { - int factor2 = 255-factor1; - return - (( (((color1>>>24)&255)*factor1 + ((color2>>>24)&255)*factor2) /255 ) << 24) | - (( (((color1>>>16)&255)*factor1 + ((color2>>>16)&255)*factor2) /255 ) << 16) | - (( (((color1>>> 8)&255)*factor1 + ((color2>>> 8)&255)*factor2) /255 ) << 8) | - (( (((color1>>> 0)&255)*factor1 + ((color2>>> 0)&255)*factor2) /255 ) << 0); - } - - public static void loadLayeredTexture(LayeredTexture tex, IResourceManager manager, List list) - { - int width = 0; - int height = 0; - int size = 0; - int[] image = null; - Iterator iterator; - for (iterator = list.iterator(); iterator.hasNext(); ) - { - String s = iterator.next(); - if (s != null) - { - try - { - ResourceLocation location = new ResourceLocation(s); - InputStream inputstream = manager.getResource(location).getInputStream(); - BufferedImage bufimg = ImageIO.read(inputstream); - - if (size == 0) - { - width = bufimg.getWidth(); - height = bufimg.getHeight(); - size = width*height; - image = createAIntImage(size,0x00000000); - } - int[] aint = getIntArray(size * 3); - bufimg.getRGB(0, 0, width, height, aint, 0, width); - loadNSMap(manager, location, width, height, aint); - // merge - for (int i = 0; i < size; ++i) - { - int alpha = (aint[i] >>> 24) & 255; - image[size*0+i] = blendColor(aint[size*0+i], image[size*0+i], alpha); - image[size*1+i] = blendColor(aint[size*1+i], image[size*1+i], alpha); - image[size*2+i] = blendColor(aint[size*2+i], image[size*2+i], alpha); - } - } - catch (IOException ex) - { - ex.printStackTrace(); - } - } - } - // init and upload - setupTexture(tex.getMultiTexID(), image, width, height, false, false); - } - - /* update block texture filter +/- items texture */ - static void updateTextureMinMagFilter() - { - TextureManager texman = Minecraft.getMinecraft().getTextureManager(); - ITextureObject texObj = texman.getTexture(TextureMap.locationBlocksTexture); - if (texObj != null) - { - MultiTexID multiTex = texObj.getMultiTexID(); - // base texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilB]); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilB]); - // norm texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilN]); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilN]); - - // spec texture - GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilS]); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilS]); - - GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); - } - } - - - static IResourceManager resManager = null; - static ResourceLocation resLocation = null; - static int imageSize = 0; - - public static IResource loadResource(IResourceManager manager, ResourceLocation location) throws IOException - { - resManager = manager; - resLocation = location; - return manager.getResource(location); - } - - public static int[] loadAtlasSprite(BufferedImage bufferedimage, int startX, int startY, int w, int h, int[] aint, int offset, int scansize) - { - imageSize = w*h; - bufferedimage.getRGB(startX, startY, w, h, aint, offset, scansize); - loadNSMap(resManager, resLocation, w, h, aint); - return aint; - } - - public static int[] extractFrame(int[] src, int width, int height, int frameIndex) - { - int srcSize = imageSize; - int frameSize = width * height; - int[] dst = new int[frameSize * 3]; - int srcPos = frameSize * frameIndex; - int dstPos = 0; - System.arraycopy(src, srcPos, dst, dstPos, frameSize); - srcPos += srcSize; dstPos += frameSize; - System.arraycopy(src, srcPos, dst, dstPos, frameSize); - srcPos += srcSize; dstPos += frameSize; - System.arraycopy(src, srcPos, dst, dstPos, frameSize); - return dst; - } - - public static void fixTransparentColor(TextureAtlasSprite tas, int[] aint) { - } -} diff --git a/java/shadersmodcore/loading/SMCTweaker.java b/java/shadersmodcore/loading/SMCTweaker.java deleted file mode 100644 index 1f05d7435..000000000 --- a/java/shadersmodcore/loading/SMCTweaker.java +++ /dev/null @@ -1,57 +0,0 @@ -package shadersmodcore.loading; - -import java.io.File; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import net.minecraft.launchwrapper.ITweaker; -import net.minecraft.launchwrapper.Launch; -import net.minecraft.launchwrapper.LaunchClassLoader; - -public class SMCTweaker implements ITweaker { - public List args; - public File gameDir; - public File assetsDir; - public String version; - - @Override - public void acceptOptions(List args, File gameDir, File assetsDir, String version) { - this.args = args; - this.gameDir = gameDir; - this.assetsDir = assetsDir; - this.version = version; - } - - @Override - public void injectIntoClassLoader(LaunchClassLoader launchClassLoader) { - launchClassLoader.addTransformerExclusion("shadersmodcore.loading."); - launchClassLoader.addTransformerExclusion("shadersmodcore.transform."); - launchClassLoader.registerTransformer("shadersmodcore.transform.SMCClassTransformer"); - } - - @Override - public String[] getLaunchArguments() { - ArrayList argumentList = (ArrayList)Launch.blackboard.get("ArgumentList"); - if (argumentList.isEmpty()) { - List argsList = new ArrayList(); - if (gameDir != null) { - argumentList.add("--gameDir"); - argumentList.add(gameDir.getPath()); - } - if (assetsDir != null) { - argumentList.add("--assetsDir"); - argumentList.add(assetsDir.getPath()); - } - argumentList.add("--version"); - argumentList.add(version); - argumentList.addAll(args); - } - return new String[0]; - } - - @Override - public String getLaunchTarget() { - return "net.minecraft.client.main.Main"; - } -} diff --git a/java/shadersmodcore/transform/InitNames.java b/java/shadersmodcore/transform/InitNames.java deleted file mode 100644 index 8506d328b..000000000 --- a/java/shadersmodcore/transform/InitNames.java +++ /dev/null @@ -1,8 +0,0 @@ -package shadersmodcore.transform; - -public class InitNames { - public static void init() - { - new NamerSrg().setNames(); - } -} diff --git a/java/shadersmodcore/transform/Namer.java b/java/shadersmodcore/transform/Namer.java deleted file mode 100644 index 047b4a12e..000000000 --- a/java/shadersmodcore/transform/Namer.java +++ /dev/null @@ -1,43 +0,0 @@ -package shadersmodcore.transform; - -import java.util.ArrayList; - -import shadersmodcore.transform.Names.Clas; -import shadersmodcore.transform.Names.Fiel; -import shadersmodcore.transform.Names.Meth; - -public class Namer { - - ArrayList ac = new ArrayList(); - ArrayList af = new ArrayList(); - ArrayList am = new ArrayList(); - - Clas c(String name) { - Clas x = new Clas(name); - if (ac!=null) ac.add(x); - return x; - } - Fiel f(Clas clas, String name, String desc) { - Fiel x = new Fiel(clas, name, desc); - if (af!=null) af.add(x); - return x; - } - Fiel f(Clas clas, Fiel fiel) { - Fiel x = new Fiel(clas, fiel.name, fiel.desc); - if (af!=null) af.add(x); - return x; - } - Meth m(Clas clas, String name, String desc) { - Meth x = new Meth(clas, name, desc); - if (am!=null) am.add(x); - return x; - } - Meth m(Clas clas, Meth meth) { - Meth x = new Meth(clas, meth.name, meth.desc); - if (am!=null) am.add(x); - return x; - } - - public void setNames() { - } -} diff --git a/java/shadersmodcore/transform/NamerSrg.java b/java/shadersmodcore/transform/NamerSrg.java deleted file mode 100644 index db2da825d..000000000 --- a/java/shadersmodcore/transform/NamerSrg.java +++ /dev/null @@ -1,205 +0,0 @@ -package shadersmodcore.transform; - -import static shadersmodcore.transform.Names.*; - -public class NamerSrg extends Namer { - - public void setNames() { - setNamesSrg(); - } - public void setNamesSrg() { - block_ = c("net/minecraft/block/Block"); - blockFlowerPot_ = c("net/minecraft/block/BlockFlowerPot"); - minecraft_ = c("net/minecraft/client/Minecraft"); - guiButton_ = c("net/minecraft/client/gui/GuiButton"); - guiOptions_ = c("net/minecraft/client/gui/GuiOptions"); - guiScreen_ = c("net/minecraft/client/gui/GuiScreen"); - modelRenderer_ = c("net/minecraft/client/model/ModelRenderer"); - worldClient_ = c("net/minecraft/client/multiplayer/WorldClient"); - effectRenderer_ = c("net/minecraft/client/particle/EffectRenderer"); - entityRenderer_ = c("net/minecraft/client/renderer/EntityRenderer"); - glAllocation_ = c("net/minecraft/client/renderer/GLAllocation"); - itemRenderer_ = c("net/minecraft/client/renderer/ItemRenderer"); - openGlHelper_ = c("net/minecraft/client/renderer/OpenGlHelper"); - renderBlocks_ = c("net/minecraft/client/renderer/RenderBlocks"); - renderGlobal_ = c("net/minecraft/client/renderer/RenderGlobal"); - tessellator_ = c("net/minecraft/client/renderer/Tessellator"); - worldRenderer_ = c("net/minecraft/client/renderer/WorldRenderer"); - frustrum_ = c("net/minecraft/client/renderer/culling/Frustrum"); - iCamera_ = c("net/minecraft/client/renderer/culling/ICamera"); - render_ = c("net/minecraft/client/renderer/entity/Render"); - renderDragon_ = c("net/minecraft/client/renderer/entity/RenderDragon"); - renderEnderman_ = c("net/minecraft/client/renderer/entity/RenderEnderman"); - renderSpider_ = c("net/minecraft/client/renderer/entity/RenderSpider"); - renderManager_ = c("net/minecraft/client/renderer/entity/RenderManager"); - rendererLivingE_ = c("net/minecraft/client/renderer/entity/RendererLivingEntity"); - abstractTexture_ = c("net/minecraft/client/renderer/texture/AbstractTexture"); - dynamicTexture_ = c("net/minecraft/client/renderer/texture/DynamicTexture"); - iTextureObject_ = c("net/minecraft/client/renderer/texture/ITextureObject"); - layeredTexture_ = c("net/minecraft/client/renderer/texture/LayeredTexture"); - simpleTexture_ = c("net/minecraft/client/renderer/texture/SimpleTexture"); - stitcher_ = c("net/minecraft/client/renderer/texture/Stitcher"); - textureAtlasSpri_ = c("net/minecraft/client/renderer/texture/TextureAtlasSprite"); - textureClock_ = c("net/minecraft/client/renderer/texture/TextureClock"); - textureCompass_ = c("net/minecraft/client/renderer/texture/TextureCompass"); - textureManager_ = c("net/minecraft/client/renderer/texture/TextureManager"); - textureMap_ = c("net/minecraft/client/renderer/texture/TextureMap"); - textureUtil_ = c("net/minecraft/client/renderer/texture/TextureUtil"); - textureDownload_ = c("net/minecraft/client/renderer/ThreadDownloadImageData"); - iResource_ = c("net/minecraft/client/resources/IResource"); - iResourceManager_ = c("net/minecraft/client/resources/IResourceManager"); - gameSettings_ = c("net/minecraft/client/settings/GameSettings"); - tessVertexState_ = c("net/minecraft/client/shader/TesselatorVertexState"); - entity_ = c("net/minecraft/entity/Entity"); - entityLivingBase_ = c("net/minecraft/entity/EntityLivingBase"); - entityDragon_ = c("net/minecraft/entity/boss/EntityDragon"); - entityEnderman_ = c("net/minecraft/entity/monster/EntityEnderman"); - entitySpider_ = c("net/minecraft/entity/monster/EntitySpider"); - entityPlayer_ = c("net/minecraft/entity/player/EntityPlayer"); - item_ = c("net/minecraft/item/Item"); - itemBlock_ = c("net/minecraft/item/ItemBlock"); - itemStack_ = c("net/minecraft/item/ItemStack"); - movingObjectPos_ = c("net/minecraft/util/MovingObjectPosition"); - resourceLocation_ = c("net/minecraft/util/ResourceLocation"); - vec3_ = c("net/minecraft/util/Vec3"); - iBlockAccess_ = c("net/minecraft/world/IBlockAccess"); - world_ = c("net/minecraft/world/World"); - - entityLivingBase_deathTime = f(entityLivingBase_,"field_70725_aQ","I"); - entityLivingBase_hurtTime = f(entityLivingBase_,"field_70737_aN","I"); - entityRenderer_cameraZoom = f(entityRenderer_ ,"field_78503_V" ,"D"); - entityRenderer_mc = f(entityRenderer_ ,"field_78531_r" ,minecraft_.desc); - gameSettings_renderDistance = f(gameSettings_ ,"field_151451_c","I"); - guiButton_id = f(guiButton_ ,"field_146127_k","I"); - guiScreen_buttonList = f(guiScreen_ ,"field_146292_n","Ljava/util/List;"); - guiScreen_width = f(guiScreen_ ,"field_146294_l","I"); - guiScreen_height = f(guiScreen_ ,"field_146295_m","I"); - guiScreen_mc = f(guiScreen_ ,"field_146297_k",minecraft_.desc); - guiOptions_options = f(guiOptions_ ,"field_146443_h",gameSettings_.desc); - itemBlock_block = f(itemBlock_ ,"field_150939_a",block_.desc); - itemRenderer_itemToRender = f(itemRenderer_ ,"field_78453_b",itemStack_.desc); - layeredTexture_layeredTextureNames = f(layeredTexture_,"field_110567_b","Ljava/util/List;"); - minecraft_renderGlobal = f(minecraft_ ,"field_71438_f" ,renderGlobal_.desc); - minecraft_gameSettings = f(minecraft_ ,"field_71474_y" ,gameSettings_.desc); - modelRenderer_displayList = f(modelRenderer_ ,"field_78811_r" ,"I"); - modelRenderer_compiled = f(modelRenderer_ ,"field_78812_q" ,"Z"); - renderGlobal_glSkyList = f(renderGlobal_ ,"field_72771_w" ,"I"); - renderGlobal_worldRenderers = f(renderGlobal_ ,"field_72765_l" ,"["+worldRenderer_.desc); - rendererLivingE_mainModel = f(rendererLivingE_ ,"field_77045_g" ,null); - rendererLivingE_renderPassModel = f(rendererLivingE_,"field_77046_h",null); - renderManager_entityRenderMap = f(renderManager_ ,"field_78729_o" ,"Ljava/util/Map;"); - renderManager_instance = f(renderManager_ ,"field_78727_a" ,renderManager_.desc); - simpleTexture_textureLocation = f(simpleTexture_ ,"field_110568_b",resourceLocation_.desc); - tessellator_floatBuffer = f(tessellator_ ,"field_147566_d","Ljava/nio/FloatBuffer;"); - tessellator_shortBuffer = f(tessellator_ ,"field_147567_e","Ljava/nio/ShortBuffer;"); - tessellator_intBuffer = f(tessellator_ ,"field_147568_c","Ljava/nio/IntBuffer;"); - tessellator_byteBuffer = f(tessellator_ ,"field_78394_d" ,"Ljava/nio/ByteBuffer;"); - tessellator_rawBuffer = f(tessellator_ ,"field_78405_h" ,"[I"); - tessellator_vertexCount = f(tessellator_ ,"field_78406_i" ,"I"); - tessellator_hasNormals = f(tessellator_ ,"field_78413_q" ,"Z"); - textureAtlasSpri_width = f(textureAtlasSpri_,"field_130223_c",null); - textureAtlasSpri_height = f(textureAtlasSpri_,"field_130224_d",null); - textureAtlasSpri_border = f(textureAtlasSpri_,"field_147966_k",null); - textureMap_anisotropic = f(textureMap_ ,"field_147637_k",null); - textureDownload_textureUploaded = f(textureDownload_,"field_110559_g","Z"); - vec3_xCoord = f(vec3_ ,"field_72450_a" ,"D"); - - abstractTexture_deleteGlTexture = m(abstractTexture_,"func_147631_c","()V"); - block_getAoLight = m(block_ ,"func_149685_I","()F"); - block_getBlockFromItem = m(block_ ,"func_149634_a","("+item_.desc+")"+block_.desc); - dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"func_110564_a","()V"); - effectRenderer_renderLitParticles = m(effectRenderer_ ,"func_78872_b" ,"("+entity_.desc+"F)V"); - effectRenderer_renderParticles = m(effectRenderer_ ,"func_78874_a" ,"("+entity_.desc+"F)V"); - entity_getBrightness = m(entity_ ,"func_70013_c" ,"(F)F"); - entityRenderer_enableLightmap = m(entityRenderer_ ,"func_78463_b" ,"(D)V"); - entityRenderer_updateFogColor = m(entityRenderer_ ,"func_78466_h" ,"(F)V"); - entityRenderer_setupFog = m(entityRenderer_ ,"func_78468_a" ,"(IF)V"); - entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"func_78469_a" ,"(FFFF)Ljava/nio/FloatBuffer;"); - entityRenderer_renderWorld = m(entityRenderer_ ,"func_78471_a" ,"(FJ)V"); - entityRenderer_renderRainSnow = m(entityRenderer_ ,"func_78474_d" ,"(F)V"); - entityRenderer_renderHand = m(entityRenderer_ ,"func_78476_b" ,"(FI)V"); - entityRenderer_setupCameraTransform= m(entityRenderer_ ,"func_78479_a" ,"(FI)V"); - entityRenderer_disableLightmap = m(entityRenderer_ ,"func_78483_a" ,"(D)V"); - entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"func_82829_a" ,"("+renderGlobal_.desc+"F)V"); - gameSettings_saveOptions = m(gameSettings_ ,"func_74303_b" ,"()V"); - gameSettings_shouldRenderClouds = m(gameSettings_ ,"func_74309_c" ,"()Z"); - glAllocation_createDirectByteBuffer= m(glAllocation_ ,"func_74524_c" ,"(I)Ljava/nio/ByteBuffer;"); - glAllocation_createDirectIntBuffer = m(glAllocation_ ,"func_74527_f" ,"(I)Ljava/nio/IntBuffer;"); - glAllocation_deleteDisplayLists = m(glAllocation_ ,"func_74523_b" ,"(I)V"); - guiOptions_actionPerformed = m(guiOptions_ ,"func_146284_a","("+guiButton_.desc+")V"); - guiOptions_initGui = m(guiOptions_ ,"func_73866_w_","()V"); - iCamera_setPosition = m(iCamera_ ,"func_78547_a" ,"(DDD)V"); - iResourceManager_getResource = m(iResourceManager_,"func_110536_a","("+resourceLocation_.desc+")"+iResource_.desc); - itemRenderer_renderItem = m(itemRenderer_ ,"func_78443_a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); - itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"func_78440_a" ,"(F)V"); - itemRenderer_renderOverlays = m(itemRenderer_ ,"func_78447_b" ,"(F)V"); - itemRenderer_updateEquipped = m(itemRenderer_ ,"func_78441_a" ,"()V"); - iTextureObject_loadTexture = m(iTextureObject_ ,"func_110551_a","("+iResourceManager_.desc+")V"); - iTextureObject_getGlTextureId = m(iTextureObject_ ,"func_110552_b","()I"); - minecraft_displayGuiScreen = m(minecraft_ ,"func_147108_a","("+guiScreen_.desc+")V"); - minecraft_startGame = m(minecraft_ ,"func_71384_a" ,"()V"); - openGlHelper_setActiveTexture = m(openGlHelper_ ,"func_77473_a" ,"(I)V"); - render_renderShadow = m(render_ ,"func_76975_c" ,"("+entity_.desc+"DDDFF)V"); - renderBlocks_renderBlockFluids = m(renderBlocks_ ,"func_147721_p","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"func_147736_d","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockSandFalling= m(renderBlocks_ ,"func_147749_a","("+block_.desc+world_.desc+"IIII)V"); - renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"func_147751_a","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"func_147754_e","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockDoor = m(renderBlocks_ ,"func_147760_u","("+block_.desc+"III)Z"); - renderBlocks_renderBlockBed = m(renderBlocks_ ,"func_147773_v","("+block_.desc+"III)Z"); - renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"func_147805_b","("+block_.desc+"III)Z"); - renderBlocks_renderBlockFlowerPot = m(renderBlocks_ ,"func_147752_a","("+blockFlowerPot_.desc+"III)Z"); - renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"func_147808_b","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderPistonExtension = m(renderBlocks_ ,"func_147809_c","("+block_.desc+"IIIZ)Z"); - renderDragon_shouldRenderPass = m(renderDragon_ ,"func_77032_a" , "("+entityDragon_.desc+"IF)I"); - renderEnderman_shouldRenderPass = m(renderEnderman_ ,"func_77032_a" , "("+entityEnderman_.desc+"IF)I"); - renderSpider_shouldRenderPass = m(renderSpider_ ,"func_77032_a" , "("+entitySpider_.desc+"IF)I"); - rendererLivingE_doRender = m(rendererLivingE_,"func_76986_a" ,"("+entityLivingBase_.desc+"DDDFF)V"); - rendererLivingE_renderEquippedItems= m(rendererLivingE_,"func_77029_c" ,"("+entityLivingBase_.desc+"F)V"); - rendererLivingE_getColorMultiplier = m(rendererLivingE_,"func_77030_a" ,"("+entityLivingBase_.desc+"FF)I"); - rendererLivingE_renderLabel = m(rendererLivingE_,"func_96449_a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); - renderGlobal_renderEntities = m(renderGlobal_ ,"func_147589_a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); - renderGlobal_renderSky = m(renderGlobal_ ,"func_72714_a" ,"(F)V"); - renderGlobal_drawBlockDamageTexture= m(renderGlobal_ ,"func_72717_a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); - renderGlobal_renderClouds = m(renderGlobal_ ,"func_72718_b" ,"(F)V"); - renderGlobal_sortAndRender = m(renderGlobal_ ,"func_72719_a" ,"("+entityLivingBase_.desc+"ID)I"); - renderGlobal_clipRenderersByFrustum= m(renderGlobal_ ,"func_72729_a" ,"("+iCamera_.desc+"F)V"); - renderGlobal_drawSelectionBox = m(renderGlobal_ ,"func_72731_b" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); - renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"func_72733_a" ,"(ID)V"); - stitcher_getCurrentWidth = m(stitcher_ ,"func_110935_a","()I"); - tessellator_sortQuad = m(tessellator_ ,"func_147564_a","(FFF)"+tessVertexState_.desc); - tessellator_addTranslation = m(tessellator_ ,"func_78372_c" ,"(FFF)V"); - tessellator_setNormal = m(tessellator_ ,"func_78375_b" ,"(FFF)V"); - tessellator_addVertex = m(tessellator_ ,"func_78377_a" ,"(DDD)V"); - tessellator_reset = m(tessellator_ ,"func_78379_d" ,"()V"); - tessellator_draw = m(tessellator_ ,"func_78381_a" ,"()I"); - textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"func_130100_a","("+iResource_.desc+")V"); - textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"func_147965_a","(I)[[I"); - textureAtlasSpri_getIconName = m(textureAtlasSpri_,"func_94215_i","()Ljava/lang/String;"); - textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"func_94219_l","()V"); - textureCompass_updateCompass = m(textureCompass_ ,"func_94241_a" ,"("+world_.desc+"DDDZZ)V"); - textureManager_onResourceManagerReload = m(textureManager_,"func_110549_a","("+iResourceManager_.desc+")V"); - textureManager_bindTexture = m(textureManager_ ,"func_110577_a","("+resourceLocation_.desc+")V"); - textureMap_loadTextureAtlas = m(textureMap_ ,"func_110571_b","("+iResourceManager_.desc+")V"); - textureMap_getIconResLoc = m(textureMap_ ,"func_147634_a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); - textureMap_updateAnimations = m(textureMap_ ,"func_94248_c" ,"()V"); - textureUtil_uploadTexture = m(textureUtil_ ,"func_110988_a","(I[III)V"); - textureUtil_uploadTextureImageAllocate = m(textureUtil_,"func_110989_a","(ILjava/awt/image/BufferedImage;ZZ)I"); - textureUtil_allocateTexture = m(textureUtil_ ,"func_110991_a","(III)V"); - textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"func_147946_a","(IIIIF)V"); - textureUtil_uploadTexSub = m(textureUtil_ ,"func_147955_a","([[IIIIIZZ)V"); - textureUtil_bindTexture = m(textureUtil_ ,"func_94277_a" ,"(I)V"); - world_getCelestialAngle = m(world_ ,"func_72826_c" ,"(F)F"); - world_getRainStrength = m(world_ ,"func_72867_j" ,"(F)F"); - modelRenderer_render = m(modelRenderer_ ,"func_78785_a" ,"(F)V"); - modelRenderer_renderWithRotation = m(modelRenderer_ ,"func_78791_b" ,"(F)V"); - - guiOptions_buttonList = f(guiOptions_,guiScreen_buttonList); - guiOptions_width = f(guiOptions_,guiScreen_width); - guiOptions_height = f(guiOptions_,guiScreen_height); - guiOptions_mc = f(guiOptions_,guiScreen_mc); - frustrum_setPosition = m(frustrum_,iCamera_setPosition); - worldClient_getCelestialAngle = m(worldClient_,world_getCelestialAngle); - worldClient_getRainStrength = m(worldClient_,world_getRainStrength); - } -} diff --git a/java/shadersmodcore/transform/Names.java b/java/shadersmodcore/transform/Names.java deleted file mode 100644 index 7efc50281..000000000 --- a/java/shadersmodcore/transform/Names.java +++ /dev/null @@ -1,256 +0,0 @@ -package shadersmodcore.transform; - -public class Names { - - public static class Name { - String clas; - String name; - String desc; - public Name(String clas, String name, String desc) { - this.clas = clas; - this.name = name; - this.desc = desc; - } - public Name set(String clas, String name, String desc) { - this.clas = clas; - this.name = name; - this.desc = desc; - return this; - } - public boolean equals(String clas, String name, String desc) { - return this.clas.equals(clas) && this.name.equals(name) && this.desc.equals(desc); - } - } - - public static class Type extends Name { - public Type(String desc) { - super("","",desc); - } - public Type(String name, String desc) { - super(name,name,desc); - } - } - public static class Clas extends Type { - public Clas(String name) { - super(name,"L"+name+";"); - } - public boolean equals(String clas) { - return this.clas.equals(clas); - } - } - public static class Fiel extends Name { - public Fiel(Clas clas, String name, String desc) { - super(clas.clas,name,desc); - } - public boolean equals(String clas, String name) { - return this.clas.equals(clas) && this.name.equals(name); - } - } - public static class Meth extends Name { - public Meth(Clas clas, String name, String desc) { - super(clas.clas,name,desc); - } - public boolean equalsNameDesc(String name, String desc) { - return this.name.equals(name) && this.desc.equals(desc); - } - } - - static Clas block_; - static Clas blockFlowerPot_; - static Clas minecraft_; - static Clas guiButton_; - static Clas guiOptions_; - static Clas guiScreen_; - static Clas modelRenderer_; - static Clas worldClient_; - static Clas effectRenderer_; - static Clas entityRenderer_; - static Clas glAllocation_; - static Clas itemRenderer_; - static Clas openGlHelper_; - static Clas renderBlocks_; - static Clas renderGlobal_; - static Clas tessellator_; - static Clas worldRenderer_; - static Clas frustrum_; - static Clas iCamera_; - static Clas render_; - static Clas renderDragon_; - static Clas renderEnderman_; - static Clas renderSpider_; - static Clas renderManager_; - static Clas rendererLivingE_; - static Clas abstractTexture_; - static Clas dynamicTexture_; - static Clas iTextureObject_; - static Clas layeredTexture_; - static Clas simpleTexture_; - static Clas stitcher_; - static Clas textureAtlasSpri_; - static Clas textureClock_; - static Clas textureCompass_; - static Clas textureManager_; - static Clas textureMap_; - static Clas textureUtil_; - static Clas textureDownload_; - static Clas iResource_; - static Clas iResourceManager_; - static Clas gameSettings_; - static Clas tessVertexState_; - static Clas entity_; - static Clas entityLivingBase_; - static Clas entityDragon_; - static Clas entityEnderman_; - static Clas entitySpider_; - static Clas entityPlayer_; - static Clas item_; - static Clas itemBlock_; - static Clas itemStack_; - static Clas movingObjectPos_; - static Clas resourceLocation_; - static Clas vec3_; - static Clas iBlockAccess_; - static Clas world_; - - static Fiel entityLivingBase_deathTime; - static Fiel entityLivingBase_hurtTime; - static Fiel entityRenderer_cameraZoom; - static Fiel entityRenderer_mc; - static Fiel gameSettings_renderDistance; - static Fiel guiButton_id; - static Fiel guiScreen_buttonList; - static Fiel guiScreen_width; - static Fiel guiScreen_height; - static Fiel guiScreen_mc; - static Fiel guiOptions_options; - static Fiel itemBlock_block; - static Fiel itemRenderer_itemToRender; - static Fiel layeredTexture_layeredTextureNames; - static Fiel minecraft_renderGlobal; - static Fiel minecraft_gameSettings; - static Fiel modelRenderer_displayList; - static Fiel modelRenderer_compiled; - static Fiel renderGlobal_glSkyList; - static Fiel renderGlobal_worldRenderers; - static Fiel rendererLivingE_mainModel; - static Fiel rendererLivingE_renderPassModel; - static Fiel renderManager_entityRenderMap; - static Fiel renderManager_instance; - static Fiel simpleTexture_textureLocation; - static Fiel tessellator_floatBuffer; - static Fiel tessellator_shortBuffer; - static Fiel tessellator_intBuffer; - static Fiel tessellator_byteBuffer; - static Fiel tessellator_rawBuffer; - static Fiel tessellator_vertexCount; - static Fiel tessellator_hasNormals; - static Fiel textureAtlasSpri_width; - static Fiel textureAtlasSpri_height; - static Fiel textureAtlasSpri_border; - static Fiel textureMap_anisotropic; - static Fiel textureDownload_textureUploaded; - static Fiel vec3_xCoord; - - static Fiel guiOptions_buttonList; - static Fiel guiOptions_width; - static Fiel guiOptions_height; - static Fiel guiOptions_mc; - - static Meth abstractTexture_deleteGlTexture; - static Meth block_getAoLight; - static Meth block_getBlockFromItem; - static Meth dynamicTexture_updateDynamicTexture; - static Meth effectRenderer_renderLitParticles; - static Meth effectRenderer_renderParticles; - static Meth entity_getBrightness; - static Meth entityRenderer_enableLightmap; - static Meth entityRenderer_updateFogColor; - static Meth entityRenderer_setupFog; - static Meth entityRenderer_setFogColorBuffer; - static Meth entityRenderer_renderWorld; - static Meth entityRenderer_renderRainSnow; - static Meth entityRenderer_renderHand; - static Meth entityRenderer_setupCameraTransform; - static Meth entityRenderer_disableLightmap; - static Meth entityRenderer_renderCloudsCheck; - static Meth gameSettings_saveOptions; - static Meth gameSettings_shouldRenderClouds; - static Meth glAllocation_createDirectByteBuffer; - static Meth glAllocation_createDirectIntBuffer; - static Meth glAllocation_deleteDisplayLists; - static Meth guiOptions_actionPerformed; - static Meth guiOptions_initGui; - static Meth iCamera_setPosition; - static Meth iResourceManager_getResource; - static Meth itemRenderer_renderItem; - static Meth itemRenderer_renderItemInFirstPerson; - static Meth itemRenderer_renderOverlays; - static Meth itemRenderer_updateEquipped; - static Meth iTextureObject_loadTexture; - static Meth iTextureObject_getGlTextureId; - static Meth minecraft_displayGuiScreen; - static Meth minecraft_startGame; - static Meth openGlHelper_setActiveTexture; - static Meth render_renderShadow; - static Meth renderBlocks_renderBlockFluids; - static Meth renderBlocks_renderStdBlockWithCM; - static Meth renderBlocks_renderBlockSandFalling; - static Meth renderBlocks_renderStdBlockWithAO; - static Meth renderBlocks_renderBlockCactusImpl; - static Meth renderBlocks_renderBlockDoor; - static Meth renderBlocks_renderBlockBed; - static Meth renderBlocks_renderBlockByRenderType; - static Meth renderBlocks_renderBlockFlowerPot; - static Meth renderBlocks_renderStdBlockWithAOP; - static Meth renderBlocks_renderPistonExtension; - static Meth renderDragon_shouldRenderPass; - static Meth renderEnderman_shouldRenderPass; - static Meth renderSpider_shouldRenderPass; - static Meth rendererLivingE_doRender; - static Meth rendererLivingE_renderEquippedItems; - static Meth rendererLivingE_getColorMultiplier; - static Meth rendererLivingE_renderLabel; - static Meth renderGlobal_renderEntities; - static Meth renderGlobal_renderSky; - static Meth renderGlobal_drawBlockDamageTexture; - static Meth renderGlobal_renderClouds; - static Meth renderGlobal_sortAndRender; - static Meth renderGlobal_clipRenderersByFrustum; - static Meth renderGlobal_drawSelectionBox; - static Meth renderGlobal_renderAllRenderLists; - static Meth stitcher_getCurrentWidth; - static Meth tessellator_sortQuad; - static Meth tessellator_addTranslation; - static Meth tessellator_setNormal; - static Meth tessellator_addVertex; - static Meth tessellator_reset; - static Meth tessellator_draw; - static Meth textureAtlasSpri_loadSprite; - static Meth textureAtlasSpri_getFrameTextureData; - static Meth textureAtlasSpri_getIconName; - static Meth textureAtlasSpri_updateAnimation; - static Meth textureCompass_updateCompass; - static Meth textureManager_onResourceManagerReload; - static Meth textureManager_bindTexture; - static Meth textureMap_loadTextureAtlas; - static Meth textureMap_getIconResLoc; - static Meth textureMap_updateAnimations; - static Meth textureUtil_uploadTexture; - static Meth textureUtil_uploadTextureImageAllocate; - static Meth textureUtil_allocateTexture; - static Meth textureUtil_allocateTextureMipmapAniso; - static Meth textureUtil_uploadTexSub; - static Meth textureUtil_bindTexture; - static Meth world_getCelestialAngle; - static Meth world_getRainStrength; - static Meth modelRenderer_render; - static Meth modelRenderer_renderWithRotation; - - static Meth frustrum_setPosition; - static Meth worldClient_getCelestialAngle; - static Meth worldClient_getRainStrength; - - public static boolean equals(String clas1, String name1, String desc1, String clas2, String name2, String desc2) { - return clas1.equals(clas2) && name1.equals(name2) && desc1.equals(desc2); - } -} diff --git a/java/shadersmodcore/transform/SMCCTBlock.java b/java/shadersmodcore/transform/SMCCTBlock.java deleted file mode 100644 index a692df7ce..000000000 --- a/java/shadersmodcore/transform/SMCCTBlock.java +++ /dev/null @@ -1,76 +0,0 @@ -package shadersmodcore.transform; - -import static org.objectweb.asm.Opcodes.*; -import net.minecraft.launchwrapper.IClassTransformer; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; - -public class SMCCTBlock implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, 0); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - this.classname = name; - //SMCLog.info(" class %s",name); - super.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - if (Names.block_getAoLight.equalsNameDesc(name, desc)) - { - //SMCLog.info(" patching"); - return new MVgetAoLight(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVgetAoLight extends MethodVisitor - { - public MVgetAoLight(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof Float) - { - if (((Float)cst).floatValue() == 0.2f) - { - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "blockAoLight", "F"); - SMCLog.info(" blockAoLight"); - return; - } - } - mv.visitLdcInsn(cst); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTEntityRenderer.java b/java/shadersmodcore/transform/SMCCTEntityRenderer.java deleted file mode 100644 index 2b7be80ba..000000000 --- a/java/shadersmodcore/transform/SMCCTEntityRenderer.java +++ /dev/null @@ -1,636 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; -import org.objectweb.asm.util.Textifier; -import org.objectweb.asm.util.TraceMethodVisitor; - - -import net.minecraft.launchwrapper.IClassTransformer; -import shadersmodcore.transform.SMCLog; - -/** transformer for net.minecraft.client.renderer.EntityRenderer */ -public class SMCCTEntityRenderer implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - if (Names.entityRenderer_disableLightmap.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVdisableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_enableLightmap.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVenableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_updateFogColor.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVupdateFogColor(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_setFogColorBuffer.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVsetFogColorBuffer(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_setupFog.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVsetupFog(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_renderCloudsCheck.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderCloudsCheck(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_renderHand.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - return new MVrenderHand(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.entityRenderer_renderWorld.equalsNameDesc(name,desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderWorld( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVdisableLightmap extends MethodVisitor - { - public MVdisableLightmap(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitInsn(int opcode) { - if (opcode==RETURN) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableLightmap", "()V"); - } - mv.visitInsn(opcode); - } - } - - private static class MVenableLightmap extends MethodVisitor - { - public MVenableLightmap(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitInsn(int opcode) { - if (opcode==RETURN) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableLightmap", "()V"); - } - mv.visitInsn(opcode); - } - } - - private static class MVupdateFogColor extends MethodVisitor - { - public MVupdateFogColor(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.equals("org/lwjgl/opengl/GL11","glClearColor","(FFFF)V",owner,name,desc)) - { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setClearColor", "(FFFF)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVsetFogColorBuffer extends MethodVisitor - { - public MVsetFogColorBuffer(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(FLOAD, 1); - mv.visitVarInsn(FLOAD, 2); - mv.visitVarInsn(FLOAD, 3); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setFogColor", "(FFF)V"); - } - } - - private static class MVsetupFog extends MethodVisitor - { - public MVsetupFog(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.equals("org/lwjgl/opengl/GL11","glFogi","(II)V",owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "sglFogi", "(II)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVrenderCloudsCheck extends MethodVisitor - { - public MVrenderCloudsCheck(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.gameSettings_shouldRenderClouds.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "shouldRenderClouds", "("+Names.gameSettings_.desc+")Z"); - return; - } else - if (Names.renderGlobal_renderClouds.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginClouds", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endClouds", "()V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVrenderHand extends MethodVisitor - { - Label la1, la2; - public MVrenderHand(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - la1 = new Label(); - la2 = new Label(); - } - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.equals("org/lwjgl/util/glu/Project","gluPerspective","(FFFF)V",owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "applyHandDepth", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } else - if (Names.equals("org/lwjgl/opengl/GL11","glPushMatrix","()V",owner,name,desc)) { - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isHandRendered", "Z"); - mv.visitJumpInsn(IFNE, la1); - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } else - if (Names.equals("org/lwjgl/opengl/GL11","glPopMatrix","()V",owner,name,desc)) { - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitLabel(la1); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isCompositeRendered", "Z"); - mv.visitJumpInsn(IFNE, la2); - mv.visitInsn(RETURN); - mv.visitLabel(la2); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 1); - mv.visitInsn(F2D); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.entityRenderer_disableLightmap.clas, Names.entityRenderer_disableLightmap.name, Names.entityRenderer_disableLightmap.desc); - return; - } else if (Names.itemRenderer_renderItemInFirstPerson.equals(owner, name, desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderItemFP", "("+Names.itemRenderer_.desc+"F)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVrenderWorld extends MethodVisitor - { - public MVrenderWorld(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - private static final int stateEnd = 32; - int state = 0; - String section = ""; - Label labelAfterUpdate = null; - Label labelEndUpdate = null; - Label labelNoSky = null; - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.entityRenderer_mc.clas, Names.entityRenderer_mc.name, Names.entityRenderer_mc.desc); - mv.visitVarInsn(FLOAD, 1); - mv.visitVarInsn(LLOAD, 2); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginRender", "("+Names.minecraft_.desc+"FJ)V"); - } - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof String) { - String scst = (String)cst; - //SMCLog.finest(" %d Ldc %s", state, scst); - section = scst; - } - mv.visitLdcInsn(cst); - } - @Override - public void visitIntInsn(int opcode, int operand) { - //SMCLog.finest(" %d Int %d %d", state ,opcode, operand); - //switch (state) { - //case 23: - //case 25: - // if (opcode == SIPUSH && operand == 256) { - // state = 26; - // mv.visitInsn(ICONST_0); - // return; - // } - // break; - //} - mv.visitIntInsn(opcode, operand); - } - @Override - public void visitJumpInsn(int opcode, Label label) { - //SMCLog.finest(" %d, Jump %d", state, opcode); - switch (state) { - case 4: - if (opcode==IF_ICMPLT) { - ++state; - mv.visitInsn(POP2); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); - mv.visitJumpInsn(IFNE, label); - return; - } - break; - case 10: - if (opcode==IFNE) { - ++state; - labelAfterUpdate = label; - labelEndUpdate = new Label(); - mv.visitJumpInsn(opcode, label); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginUpdateChunks", "()V"); - return; - } - break; - case 11: - if (label==labelAfterUpdate) { - mv.visitJumpInsn(opcode, labelEndUpdate); - return; - } - break; - case 28: - if (opcode==IFNE) { - ++state; - mv.visitJumpInsn(opcode, label); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); - mv.visitJumpInsn(IFNE, label); -// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "readCenterDepth", "()V"); -// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginHand", "()V"); -// mv.visitVarInsn(ALOAD, 0); -// mv.visitVarInsn(FLOAD, 1); -// mv.visitVarInsn(ILOAD, 13); -// mv.visitMethodInsn(INVOKESPECIAL, Names.EntityRenderer_, Names.EntityRenderer_renderHand, Names.EntityRenderer_renderHand_desc); -// mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endHand", "()V"); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 1); - mv.visitVarInsn(ILOAD, 13); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderHand1", "("+Names.entityRenderer_.desc+"FI)V"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "renderCompositeFinal", "()V"); - return; - } - break; - } - mv.visitJumpInsn(opcode, label); - } - @Override - public void visitLabel(Label label) { - switch (state) { - case 11: - if (label==labelAfterUpdate) { - ++state; - mv.visitLabel(labelEndUpdate); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endUpdateChunks", "()V"); - mv.visitLabel(label); - labelAfterUpdate = labelEndUpdate = null; - return; - } - } - mv.visitLabel(label); - } - @Override - public void visitFrame(int type, int nLocal, Object[] local, - int nStack, Object[] stack) { - //SMCLog.finest(" %d, Frame",state); - switch (state) { - case 7: - { - state = 8; - mv.visitLabel(labelNoSky); labelNoSky = null; - mv.visitFrame(type, nLocal, local, nStack, stack); - return; - } - - case 31: - { - ++state; - mv.visitFrame(type, nLocal, local, nStack, stack); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endRender", "()V"); - return; - } - } - mv.visitFrame(type, nLocal, local, nStack, stack); - } - @Override - public void visitFieldInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.finest(" %d F %d %s.%s %s", state, opcode, ownerM, nameM, descM); - switch (state) { - case 3: - if (Names.gameSettings_renderDistance.equals(owner,name)) { - ++state; - } - break; - case 24: - case 26: - if (Names.entityRenderer_cameraZoom.equals(owner,name)) { - state = 28; - mv.visitFieldInsn(opcode, owner, name, desc); - return; - } - break; - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - @Override - public void visitVarInsn(int opcode, int var) { - switch (state) - { - case 29: - if (opcode==ALOAD) { - ++state; - mv.visitVarInsn(opcode, var); - return; - } - break; - } - mv.visitVarInsn(opcode, var); - } - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.finest(" %d M %d %s.%s%s", state, opcode, ownerM, nameM, descM); - switch (state) - { - case 0: - if (Names.equals("org/lwjgl/opengl/GL11","glViewport","(IIII)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setViewport", "(IIII)V"); - return; - } - break; - case 1: - if (Names.equals("org/lwjgl/opengl/GL11","glClear","(I)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "clearRenderBuffer", "()V"); - return; - } - break; - case 2: - if (Names.entityRenderer_setupCameraTransform.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitVarInsn(FLOAD, 1); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setCamera", "(F)V"); - return; - } - break; - case 3: - if (Names.equals("Config","isSkyEnabled","()Z",owner,name,desc)) { - state = 6; - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "isShadowPass", "Z"); - labelNoSky = new Label(); - mv.visitJumpInsn(IFNE, labelNoSky); - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - case 5: - if (Names.renderGlobal_renderSky.equals(owner,name,desc)) { - state = 8; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSky", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endSky", "()V"); - return; - } - break; - case 6: - if (Names.renderGlobal_renderSky.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSky", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endSky", "()V"); - return; - } - break; - case 8: - if (Names.iCamera_setPosition.equals(owner,name,desc) || Names.frustrum_setPosition.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "setFrustrumPosition", "("+Names.frustrum_.desc+"DDD)V"); - return; - } - break; - case 9: - if (Names.renderGlobal_clipRenderersByFrustum.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "clipRenderersByFrustrum", "("+Names.renderGlobal_.desc+Names.frustrum_.desc+"F)V"); - return; - } - break; - case 12: - if (Names.renderGlobal_sortAndRender.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginTerrain", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endTerrain", "()V"); - return; - } - break; - case 13: - if (Names.effectRenderer_renderLitParticles.equals(owner,name,desc)) { - // vanilla or forge. not optfine - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLitParticles", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } else - if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { - // optifine - state = 16; - break; - } - break; - case 14: // vanilla or forge. not optfine - if (Names.effectRenderer_renderParticles.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginParticles", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endParticles", "()V"); - return; - } - break; - case 15: // vanilla or forge. not optfine - if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { - ++state; - break; - } - break; - case 16: - if (Names.entityRenderer_renderRainSnow.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWeather", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWeather", "()V"); - return; - } - break; - case 17: - if (Names.equals("org/lwjgl/opengl/GL11","glDepthMask","(Z)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 1); - mv.visitVarInsn(ILOAD, 13); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderHand0", "("+Names.entityRenderer_.desc+"FI)V"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preWater", "()V"); - return; - } - case 18: - case 19: - case 20: - if (Names.renderGlobal_sortAndRender.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWater", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWater", "()V"); - return; - } else if (Names.equals(Names.renderGlobal_.clas,"renderAllSortedRenderers","(ID)I",owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginWater", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endWater", "()V"); - return; - } - break; - case 21: - if (Names.equals("org/lwjgl/opengl/GL11","glDepthMask","(Z)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - case 22: - if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - case 23: - if (Names.equals("org/lwjgl/opengl/GL11","glDisable","(I)V",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); - return; - } - break; - case 24: - if (Names.effectRenderer_renderLitParticles.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLitParticles", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - case 25: - if (Names.effectRenderer_renderParticles.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginParticles", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endParticles", "()V"); - return; - } - break; - case 30: - if (Names.entityRenderer_renderHand.equals(owner,name,desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersRender", "renderFPOverlay", "("+Names.entityRenderer_.desc+"FI)V"); - return; - } - break; - } - /* - case : - if (Namer.equals(SMCNames.,SMCNames.,SMCNames._desc,owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - case : - if (Namer.equals("","","",owner,name,desc)) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - return; - } - break; - */ - mv.visitMethodInsn(opcode, owner, name, desc); - } - @Override - public void visitEnd() { - if (state!=stateEnd) - SMCLog.severe(" state %d expect %d",state,stateEnd); - mv.visitEnd(); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTGuiOptions.java b/java/shadersmodcore/transform/SMCCTGuiOptions.java deleted file mode 100644 index 62717b477..000000000 --- a/java/shadersmodcore/transform/SMCCTGuiOptions.java +++ /dev/null @@ -1,169 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTGuiOptions implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - this.classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.guiOptions_initGui.equalsNameDesc(name, desc)) - { - //SMCLog.info(" patching"); - return new MVinitGui( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - if (Names.guiOptions_actionPerformed.equalsNameDesc(name, desc)) - { - //SMCLog.info(" patching"); - return new MVactionPerformed( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVinitGui extends MethodVisitor - { - int state = 0; - - public MVinitGui(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitInsn(int opcode) { - super.visitInsn(opcode); - if (opcode == Opcodes.POP){ - if (state == 1) { - state = 2; - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_buttonList.clas, Names.guiOptions_buttonList.name, Names.guiOptions_buttonList.desc); - mv.visitTypeInsn(NEW, Names.guiButton_.clas); - mv.visitInsn(DUP); - mv.visitIntInsn(SIPUSH, 190); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_width.clas, Names.guiOptions_width.name, Names.guiOptions_width.desc); - mv.visitInsn(ICONST_2); - mv.visitInsn(IDIV); - mv.visitIntInsn(SIPUSH, 155); - mv.visitInsn(ISUB); - mv.visitIntInsn(BIPUSH, 76); - mv.visitInsn(IADD); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_height.clas, Names.guiOptions_height.name, Names.guiOptions_height.desc); - mv.visitIntInsn(BIPUSH, 6); - mv.visitInsn(IDIV); - mv.visitIntInsn(BIPUSH, 120); - mv.visitInsn(IADD); - mv.visitIntInsn(BIPUSH, 6); - mv.visitInsn(ISUB); - mv.visitIntInsn(BIPUSH, 74); - mv.visitIntInsn(BIPUSH, 20); - mv.visitLdcInsn("Shaders..."); - mv.visitMethodInsn(INVOKESPECIAL, Names.guiButton_.clas, "", "(IIIIILjava/lang/String;)V"); - mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z"); - mv.visitInsn(POP); - SMCLog.finest(" add shaders button"); - } - } - } - - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof String) - { - if (((String)cst).equals("options.language")) - { - if (state == 0) { - state = 1; - mv.visitInsn(POP); - mv.visitInsn(POP); - mv.visitIntInsn(BIPUSH, 74); - mv.visitIntInsn(BIPUSH, 20); - SMCLog.finest(" decrease language button size"); - } - } - } - super.visitLdcInsn(cst); - } - - } - - private static class MVactionPerformed extends MethodVisitor - { - public MVactionPerformed(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitCode() { - super.visitCode(); - mv.visitVarInsn(ALOAD, 1); - mv.visitFieldInsn(GETFIELD, Names.guiButton_id.clas, Names.guiButton_id.name, Names.guiButton_id.desc); - mv.visitIntInsn(SIPUSH, 190); - Label l1 = new Label(); - mv.visitJumpInsn(IF_ICMPNE, l1); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); - mv.visitFieldInsn(GETFIELD, Names.minecraft_gameSettings.clas, Names.minecraft_gameSettings.name, Names.minecraft_gameSettings.desc); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.gameSettings_saveOptions.clas, Names.gameSettings_saveOptions.name, Names.gameSettings_saveOptions.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); - mv.visitTypeInsn(NEW, "shadersmodcore/client/GuiShaders"); - mv.visitInsn(DUP); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.guiOptions_options.clas, Names.guiOptions_options.name, Names.guiOptions_options.desc); - mv.visitMethodInsn(INVOKESPECIAL, "shadersmodcore/client/GuiShaders", "", "("+Names.guiScreen_.desc+Names.gameSettings_.desc+")V"); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.minecraft_displayGuiScreen.clas, Names.minecraft_displayGuiScreen.name, Names.minecraft_displayGuiScreen.desc); - mv.visitLabel(l1); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - SMCLog.finest(" shaders button action"); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTItemBlock.java b/java/shadersmodcore/transform/SMCCTItemBlock.java deleted file mode 100644 index 88d198828..000000000 --- a/java/shadersmodcore/transform/SMCCTItemBlock.java +++ /dev/null @@ -1,50 +0,0 @@ -package shadersmodcore.transform; - -import static org.objectweb.asm.Opcodes.*; -import net.minecraft.launchwrapper.IClassTransformer; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Opcodes; - -public class SMCCTItemBlock implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (Names.itemBlock_block.name.equals(name)) { - access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - - } -} diff --git a/java/shadersmodcore/transform/SMCCTItemRenderer.java b/java/shadersmodcore/transform/SMCCTItemRenderer.java deleted file mode 100644 index 8d0d14551..000000000 --- a/java/shadersmodcore/transform/SMCCTItemRenderer.java +++ /dev/null @@ -1,118 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.lwjgl.opengl.GL11; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTItemRenderer implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - Names.Meth renderItemIrt = new Names.Meth(Names.itemRenderer_,"renderItem","("+Names.entityLivingBase_.desc+Names.itemStack_.desc+"ILnet/minecraftforge/client/IItemRenderer$ItemRenderType;)V"); - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s",classname,name,desc); - if (Names.itemRenderer_updateEquipped.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); - } else if (Names.itemRenderer_renderItem.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); - } else if (renderItemIrt.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVupdate extends MethodVisitor - { - public MVupdate(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitFieldInsn(int opcode, String owner, String name, String desc) { - if (opcode==PUTFIELD && Names.itemRenderer_itemToRender.equals(owner, name, desc)) { - mv.visitInsn(DUP); - mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/Shaders", "itemToRender", Names.itemStack_.desc); - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - - } - - private static class MVrenderItem extends MethodVisitor - { - public MVrenderItem(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - int state = 0; - - @Override - public void visitInsn(int opcode) { - if (state==1) { - if (opcode==ICONST_0) { - ++state; - opcode = ICONST_1; - } - } - mv.visitInsn(opcode); - } - - @Override - public void visitIntInsn(int opcode, int operand) { - if (state==0) { - if (opcode==SIPUSH && operand==GL11.GL_BLEND) { - ++state; - } - } - mv.visitIntInsn(opcode, operand); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTMinecraft.java b/java/shadersmodcore/transform/SMCCTMinecraft.java deleted file mode 100644 index 36e77cf63..000000000 --- a/java/shadersmodcore/transform/SMCCTMinecraft.java +++ /dev/null @@ -1,99 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTMinecraft implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - this.classname = name; - //SMCLog.info(" class %s",name); - super.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.minecraft_startGame.equalsNameDesc(name, desc)) - { - //SMCLog.info(" patching"); - return new MVstartGame(super.visitMethod(access, name, desc, signature, exceptions)); - } - return super.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVstartGame extends MethodVisitor - { - int state = 0; - - public MVstartGame(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof String) - { - if (((String)cst).equals("Startup")) - { - if (state == 0) { - state = 1; - } - } - } - super.visitLdcInsn(cst); - } - - @Override - public void visitVarInsn(int opcode, int var) { - if (opcode == Opcodes.ALOAD) { - if (var == 0) { - if (state == 1) { - state = 2; - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "startup", "("+Names.minecraft_.desc+")V"); - //SMCLog.finest(" startup"); - } - } - } - super.visitVarInsn(opcode, var); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTModelRenderer.java b/java/shadersmodcore/transform/SMCCTModelRenderer.java deleted file mode 100644 index 3cf15443f..000000000 --- a/java/shadersmodcore/transform/SMCCTModelRenderer.java +++ /dev/null @@ -1,134 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; -import java.util.ListIterator; - -import org.lwjgl.opengl.GL12; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.AbstractInsnNode; -import org.objectweb.asm.tree.MethodNode; -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTModelRenderer implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - -// @Override -// public FieldVisitor visitField(int access, String name, String desc, -// String signature, Object value) { -// if (Names.modelRenderer_compiled.name.equals(name) || -// Names.modelRenderer_displayList.name.equals(name)) { -// access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; -// } -// return cv.visitField(access, name, desc, signature, value); -// } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); -// if (Names.modelRenderer_render.equalsNameDesc(name, desc)) -// { -// //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); -// return new MVrender( -// cv.visitMethod(access, name, desc, signature, exceptions)); -// } -// else -// if (Names.modelRenderer_renderWithRotation.equalsNameDesc(name, desc)) -// { -// //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); -// return new MVrender( -// cv.visitMethod(access, name, desc, signature, exceptions)); -// } -// else - if ("resetDisplayList".equals(name) && "()V".equals(desc) - || "getCompiled".equals(name) && "()Z".equals(desc) - || "getDisplayList".equals(name) && "()I".equals(desc) - ) { - return null; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - @Override - public void visitEnd() { - MethodVisitor mv; - { - mv = cv.visitMethod(ACC_PUBLIC, "getCompiled", "()Z", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); - mv.visitInsn(IRETURN); - mv.visitMaxs(1, 1); - mv.visitEnd(); - } - { - mv = cv.visitMethod(ACC_PUBLIC, "getDisplayList", "()I", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); - mv.visitInsn(IRETURN); - mv.visitMaxs(1, 1); - mv.visitEnd(); - } - { - mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); - Label l1 = new Label(); - mv.visitJumpInsn(IFEQ, l1); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); - mv.visitMethodInsn(INVOKESTATIC, Names.glAllocation_deleteDisplayLists.clas, Names.glAllocation_deleteDisplayLists.name, Names.glAllocation_deleteDisplayLists.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - mv.visitFieldInsn(PUTFIELD, Names.modelRenderer_displayList.clas, Names.modelRenderer_displayList.name, Names.modelRenderer_displayList.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - mv.visitFieldInsn(PUTFIELD, Names.modelRenderer_compiled.clas, Names.modelRenderer_compiled.name, Names.modelRenderer_compiled.desc); - mv.visitLabel(l1); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitInsn(RETURN); - mv.visitMaxs(2, 1); - mv.visitEnd(); - } - super.visitEnd(); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTOpenGlHelper.java b/java/shadersmodcore/transform/SMCCTOpenGlHelper.java deleted file mode 100644 index 09de7fabb..000000000 --- a/java/shadersmodcore/transform/SMCCTOpenGlHelper.java +++ /dev/null @@ -1,96 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTOpenGlHelper implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - //boolean has_activeTexUnit = false; - -// @Override -// public FieldVisitor visitField(int access, String name, String desc, -// String signature, Object value) { -// //if (name.equals("activeTexUnit")) { -// // has_activeTexUnit = true; -// //} -// return cv.visitField(access, name, desc, signature, value); -// } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //if (!has_activeTexUnit) { - // has_activeTexUnit = true; - // FieldVisitor fv = cv.visitField(ACC_PUBLIC + ACC_STATIC, "activeTexUnit", "I", null, null); - // fv.visitEnd(); - // SMCLog.finest(" add field activeTexUnit"); - //} - - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.openGlHelper_setActiveTexture.equalsNameDesc(name, desc)) - { - //SMCLog.info(" patching"); - return new MVsetActiveTexture(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVsetActiveTexture extends MethodVisitor - { - public MVsetActiveTexture(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ILOAD, 0); - mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/Shaders", "activeTexUnit", "I"); - SMCLog.finest(" set activeTexUnit"); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java b/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java deleted file mode 100644 index 70fa81115..000000000 --- a/java/shadersmodcore/transform/SMCCTPrjRedIlluRenderHalo.java +++ /dev/null @@ -1,96 +0,0 @@ -package shadersmodcore.transform; - -import static org.objectweb.asm.Opcodes.INVOKESTATIC; -import net.minecraft.launchwrapper.IClassTransformer; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; - -public class SMCCTPrjRedIlluRenderHalo implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, 0); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - this.classname = name; - //SMCLog.info(" class %s",name); - super.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" %s%s",name,desc); - if ("prepareRenderState".equals(name) && "()V".equals(desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVprepare(cv.visitMethod(access, name, desc, signature, exceptions)); - } - if ("restoreRenderState".equals(name) && "()V".equals(desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrestore(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - } - - private static class MVprepare extends MethodVisitor - { - public MVprepare(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.equals("codechicken/lib/render/CCRenderState", "reset", "()V", owner, name, desc)) { - SMCLog.info(" beginHalo"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginProjectRedHalo", "()V"); - } - super.visitMethodInsn(opcode, owner, name, desc); - } - - @Override - public void visitInsn(int opcode) { - super.visitInsn(opcode); - } - } - private static class MVrestore extends MethodVisitor - { - public MVrestore(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - super.visitMethodInsn(opcode, owner, name, desc); - if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { - SMCLog.info(" endHalo"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endProjectRedHalo", "()V"); - } - } - } - -} diff --git a/java/shadersmodcore/transform/SMCCTRender.java b/java/shadersmodcore/transform/SMCCTRender.java deleted file mode 100644 index 97e673118..000000000 --- a/java/shadersmodcore/transform/SMCCTRender.java +++ /dev/null @@ -1,82 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTRender implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.render_renderShadow.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVrenderShadow(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVrenderShadow extends MethodVisitor - { - //protected MethodVisitor mv; - public MVrenderShadow(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "shouldSkipDefaultShadow", "Z"); - Label l1 = new Label(); - mv.visitJumpInsn(IFEQ, l1); - mv.visitInsn(RETURN); - mv.visitLabel(l1); - SMCLog.finer(" conditionally skip default shadow"); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTRenderBlocks.java b/java/shadersmodcore/transform/SMCCTRenderBlocks.java deleted file mode 100644 index e1900fec3..000000000 --- a/java/shadersmodcore/transform/SMCCTRenderBlocks.java +++ /dev/null @@ -1,388 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; -import java.util.ListIterator; - -import org.lwjgl.opengl.GL12; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.AbstractInsnNode; -import org.objectweb.asm.tree.InsnList; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTRenderBlocks implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.renderBlocks_renderBlockByRenderType.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); - return new MVrenBlkByRenType( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.renderBlocks_renderBlockFlowerPot.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); - return new MVrenBlkFlowerPot( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.renderBlocks_renderStdBlockWithAOP.equalsNameDesc(name, desc) || - Names.renderBlocks_renderStdBlockWithAO.equalsNameDesc(name, desc) - ) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); - return new MVrenBlkWithAO(access, name, desc, signature, exceptions, - cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.renderBlocks_renderStdBlockWithCM.equalsNameDesc(name, desc) || - Names.renderBlocks_renderBlockCactusImpl.equalsNameDesc(name, desc) || - Names.renderBlocks_renderBlockBed.equalsNameDesc(name, desc) || - Names.renderBlocks_renderBlockFluids.equalsNameDesc(name, desc) || - Names.renderBlocks_renderBlockDoor.equalsNameDesc(name, desc) || - Names.renderBlocks_renderBlockSandFalling.equalsNameDesc(name, desc) - ) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); - return new MVrenBlkFVar( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.renderBlocks_renderPistonExtension.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); - return new MVrenBlkPistonExt( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVrenBlkByRenType extends MethodVisitor - { - public MVrenBlkByRenType(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - int nPatch = 0; - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(ILOAD, 2); - mv.visitVarInsn(ILOAD, 3); - mv.visitVarInsn(ILOAD, 4); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.renderBlocks_.desc+Names.block_.desc+"III)V"); - //SMCLog.info(" pushEntity"); - ++nPatch; - } - - @Override - public void visitInsn(int opcode) { - if (opcode==Opcodes.IRETURN) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); - //SMCLog.info(" popEntity"); - ++nPatch; - } - mv.visitInsn(opcode); - } - - @Override - public void visitEnd() { - mv.visitEnd(); - //SMCLog.info(" %d", nPatch); - } - - } - - private static class MVrenBlkFlowerPot extends MethodVisitor - { - public MVrenBlkFlowerPot(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - int nPatch = 0; - int state = 0; - - @Override - public void visitVarInsn(int opcode, int var) { - super.visitVarInsn(opcode, var); - if (state==1) { - ++state; - mv.visitVarInsn(ALOAD, var); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.block_.desc+")V"); - } - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - super.visitMethodInsn(opcode, owner, name, desc); - switch (state) { - case 0: - if (Names.block_getBlockFromItem.equals(owner, name, desc)) { - ++state; - } - break; - case 2: - if (Names.tessellator_addTranslation.equals(owner, name, desc)) { - ++state; - } - break; - case 3: - if (Names.tessellator_addTranslation.equals(owner, name, desc)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); - } - break; - } - } - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(ILOAD, 2); - mv.visitVarInsn(ILOAD, 3); - mv.visitVarInsn(ILOAD, 4); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "pushEntity", "("+Names.renderBlocks_.desc+Names.block_.desc+"III)V"); - //SMCLog.info(" pushEntity"); - ++nPatch; - } - - @Override - public void visitInsn(int opcode) { - if (opcode==Opcodes.IRETURN) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "popEntity", "()V"); - //SMCLog.info(" popEntity"); - ++nPatch; - } - mv.visitInsn(opcode); - } - - @Override - public void visitEnd() { - mv.visitEnd(); - //SMCLog.info(" %d", nPatch); - } - - } - - static final String[] fieldsBlockLightLevel = {null,"blockLightLevel05","blockLightLevel06","blockLightLevel08"}; - - private static class MVrenBlkWithAO extends MethodVisitor - { - MethodVisitor mv1; - MethodNode mn; - int nPatch = 0; - public MVrenBlkWithAO(final int access, final String name, final String desc, - final String signature, final String[] exceptions, - MethodVisitor mv) { - super(Opcodes.ASM4); - super.mv = this.mn = new MethodNode(access, name, desc, signature, exceptions); - this.mv1 = mv; - } - @Override - public void visitEnd() { - mn.visitEnd(); - mn.accept(mv1); - //SMCLog.info(" %d", nPatch); - } - - @Override - public void visitLdcInsn(Object cst) { - int match1 = 0; - if (cst instanceof Float) { - float fcst = ((Float)cst).floatValue(); - if (fcst == 0.5f) match1 = 1; - else if (fcst == 0.6f) match1 = 2; - else if (fcst == 0.8f) match1 = 3; - } - if (match1 != 0) { - int match2 = 0; - InsnList insns = mn.instructions; - AbstractInsnNode insn = insns.getLast(); - if (insn!=null && insn.getOpcode()==Opcodes.FLOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - match2 = match1; - } - } - } - } - } - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - insn=insn.getPrevious(); - if (insn!=null && insn.getOpcode()==Opcodes.ALOAD) { - match2 = match1; - } - } - } - } - if (match2 != 0) { - String fieldName = fieldsBlockLightLevel[match2]; - mn.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); - //SMCLog.info(" %s", fieldName); - ++nPatch; - return; - } - } - mn.visitLdcInsn(cst); - } - - } - - private static class MVrenBlkFVar extends MethodVisitor - { - int nPatch = 0; - public MVrenBlkFVar(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - int state = 0; - - @Override - public void visitLdcInsn(Object cst) { - int match1 = 0; - if (cst instanceof Float) { - float fcst = ((Float)cst).floatValue(); - if (fcst == 0.5f) match1 = 1; - else if (fcst == 0.6f) match1 = 2; - else if (fcst == 0.8f) match1 = 3; - } - if (match1 != 0 && state < 3) { - ++state; - String fieldName = fieldsBlockLightLevel[match1]; - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); - //SMCLog.info(" %s", fieldName); - ++nPatch; - return; - } - mv.visitLdcInsn(cst); - } - - @Override - public void visitEnd() { - mv.visitEnd(); - //SMCLog.info(" %d", nPatch); - } - } - - private static class MVrenBlkPistonExt extends MethodVisitor - { - int nPatch = 0; - public MVrenBlkPistonExt(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - int state = 0; - - @Override - public void visitTableSwitchInsn(int min, int max, Label dflt, - Label... labels) { - state = 1; - mv.visitTableSwitchInsn(min, max, dflt, labels); - } - - @Override - public void visitLdcInsn(Object cst) { - int match1 = 0; - if (cst instanceof Float) { - float fcst = ((Float)cst).floatValue(); - if (fcst == 0.5f) match1 = 1; - else if (fcst == 0.6f) match1 = 2; - else if (fcst == 0.8f) match1 = 3; - } - if (match1 != 0 && state == 1) { - String fieldName = fieldsBlockLightLevel[match1]; - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", fieldName, "F"); - //SMCLog.info(" %s", fieldName); - ++nPatch; - return; - } - mv.visitLdcInsn(cst); - } - - @Override - public void visitEnd() { - mv.visitEnd(); - //SMCLog.info(" %d", nPatch); - } - } - -// private static class MVNTransform extends MethodVisitor -// { -// protected MethodVisitor mv; -// protected MethodNode mn; -// public MVNTransform(MethodNode mn, MethodVisitor mv) { -// super(Opcodes.ASM4); -// super.mv = this.mn = mn; -// this.mv = mv; -// } -// -// @Override -// public void visitEnd() { -// super.visitEnd(); -// Iterator it = mn.instructions.iterator(); -// while (it.hasNext()) -// { -// AbstractInsnNode node = it.next(); -// System.out.println(node.toString()); -// } -// // send to target -// mn.accept(mv); -// } -// } - -} diff --git a/java/shadersmodcore/transform/SMCCTRenderGlobal.java b/java/shadersmodcore/transform/SMCCTRenderGlobal.java deleted file mode 100644 index 65fc4c7db..000000000 --- a/java/shadersmodcore/transform/SMCCTRenderGlobal.java +++ /dev/null @@ -1,354 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.lwjgl.opengl.GL11; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTRenderGlobal implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (Names.renderGlobal_worldRenderers.name.equals(name)) { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //String remappedName = SMCRemap.remapper.mapMethodName(classname, name, desc); - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.renderGlobal_renderEntities.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderEntities(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else if (Names.renderGlobal_sortAndRender.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else if (Names.renderGlobal_renderSky.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVrenderSky(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else if (Names.renderGlobal_drawBlockDamageTexture.equalsNameDesc(name, desc) - || name.equals("drawBlockDamageTexture") ) // Optifine - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVdrawBlockDamageTexture(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else if (Names.renderGlobal_drawSelectionBox.equalsNameDesc(name, desc)) - { - SMCLog.finer(" patch method %s.%s%s",classname,name,desc); - return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVrenderEntities extends MethodVisitor - { - public MVrenderEntities(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - int state = 0; - - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof String) { - String scst = (String)cst; - if (scst.equals("entities")) { - state = 1; - } - else if (scst.equals("blockentities")) { - state = 4; - } - } - mv.visitLdcInsn(cst); - } - - @Override - public void visitFieldInsn(int opcode, String owner, String name, - String desc) { - if (state==2) { - if (Names.renderManager_instance.equals(owner, name, desc)) { - state = 3; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "nextEntity", "()V"); - } - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, String desc) { - mv.visitMethodInsn(opcode, owner, name, desc); - if (state == 1) { - state = 2; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginEntities", "()V"); - SMCLog.finest(" %s","beginEntities"); - } else if (state == 4) { - state = 5; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endEntities", "()V"); - SMCLog.finest(" %s","endEntities"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginBlockEntities", "()V"); - SMCLog.finest(" %s","beginTileEntities"); - } else if (state == 5) { - if (Names.entityRenderer_disableLightmap.equals(owner, name, desc)) { - state = 6; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endBlockEntities", "()V"); - SMCLog.finest(" %s","endTileEntities"); - } - } - } - - } - - /* detect glEnable or glDisable (TEXTURE_2D or FOG) */ - private static class MVendisTexFog extends MethodVisitor - { - public MVendisTexFog(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - int lastInt = 0; - - @Override - public void visitIntInsn(int opcode, int operand) { - mv.visitIntInsn(opcode, operand); - if (opcode == SIPUSH && (operand==3553 || operand==2912)) { - lastInt = operand; - } - else { - lastInt = 0; - } - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, String desc) { - mv.visitMethodInsn(opcode, owner, name, desc); - if (owner.equals("org/lwjgl/opengl/GL11")) { - if (name.equals("glEnable")) { - if (lastInt==GL11.GL_TEXTURE_2D) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableTexture2D", "()V"); - SMCLog.finest(" %s","enableTexture2D"); - } else if (lastInt==GL11.GL_FOG) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableFog", "()V"); - SMCLog.finest(" %s","enableFog"); - } - } else if (name.equals("glDisable")) { - if (lastInt==GL11.GL_TEXTURE_2D) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableTexture2D", "()V"); - SMCLog.finest(" %s","disableTexture2D"); - } else if (lastInt==GL11.GL_FOG) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); - SMCLog.finest(" %s","disableFog"); - } - } - } - lastInt = 0; - } - } - - /* extends MVenableTF */ - private static class MVrenderSky extends MVendisTexFog - { - public MVrenderSky(MethodVisitor mv) { - super(mv); - } - - int state = 0; - boolean detectedOptifine = false; - - int lastInt = 0; - int lastVar = 0; - - @Override - public void visitIntInsn(int opcode, int operand) { - mv.visitIntInsn(opcode, operand); - if (opcode == SIPUSH) { - lastInt = operand; - } else { - lastInt = 0; - } - } - - @Override - public void visitVarInsn(int opcode, int var) { - mv.visitVarInsn(opcode, var); - if (opcode == ALOAD) { - lastVar = var; - } else { - lastVar = 0; - } - } - - - - @Override - public void visitFieldInsn(int opcode, String owner, String name, String desc) { - switch (state) - { - case 0: - if (Names.vec3_xCoord.equals(owner, name)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setSkyColor", "("+Names.vec3_.desc+")V"); - mv.visitVarInsn(ALOAD, lastVar); - break; - } - break; - case 1: - if (Names.renderGlobal_glSkyList.equals(owner, name)) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preSkyList", "()V"); - break; - } - break; - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, String desc) { - //SMCLog.info(" %s.%s%s",ownerM,nameM,descM); - switch (state) { - case 0: - if (owner.equals("Config") && name.equals("isSkyEnabled")) { - detectedOptifine = true; - } - break; - case 2: - if (Names.worldClient_getRainStrength.equals(owner, name, desc)) { - ++state; - } - break; - } - // - mv.visitMethodInsn(opcode, owner, name, desc); - // - if (owner.equals("org/lwjgl/opengl/GL11")) { - if (name.equals("glEnable")) { - if (lastInt==GL11.GL_TEXTURE_2D) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableTexture2D", "()V"); - SMCLog.finest(" %s","enableTexture2D"); - } else if (lastInt==GL11.GL_FOG) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableFog", "()V"); - SMCLog.finest(" %s","enableFog"); - } - } else if (name.equals("glDisable")) { - if (lastInt==GL11.GL_TEXTURE_2D) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableTexture2D", "()V"); - SMCLog.finest(" %s","disableTexture2D"); - } else if (lastInt==GL11.GL_FOG) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableFog", "()V"); - SMCLog.finest(" %s","disableFog"); - } - } else if (name.equals("glRotatef")) { - SMCLog.finest(" *%s %d","glRotatef",state); - if (state == 3) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "preCelestialRotate", "()V"); - SMCLog.finest(" %s","preCelestialRotate"); - } else if (state == 4) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "postCelestialRotate", "()V"); - SMCLog.finest(" %s","postCelestialRotate"); - } - } - } - } - } - - private static class MVdrawBlockDamageTexture extends MethodVisitor - { - int state = 0; - - public MVdrawBlockDamageTexture(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitIntInsn(int opcode, int operand) { - switch(state) - { - case 0: - if (opcode==SIPUSH && operand==GL11.GL_ALPHA_TEST) { - ++state; - } - break; - case 2: - if (opcode==SIPUSH && operand==GL11.GL_ALPHA_TEST) { - ++state; - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endBlockDestroyProgress", "()V"); - SMCLog.finest(" %s","endBlockDestroyProgress"); - } - break; - } - mv.visitIntInsn(opcode, operand); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, String desc) { - switch(state) - { - case 1: - if (owner.equals("org/lwjgl/opengl/GL11") && name.equals("glEnable")) { - ++state; - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginBlockDestroyProgress", "()V"); - SMCLog.finest(" %s","beginBlockDestroyProgress"); - return; - } - break; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - -} diff --git a/java/shadersmodcore/transform/SMCCTRenderManager.java b/java/shadersmodcore/transform/SMCCTRenderManager.java deleted file mode 100644 index a40b29b0e..000000000 --- a/java/shadersmodcore/transform/SMCCTRenderManager.java +++ /dev/null @@ -1,60 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -/** transformer for net.minecraft.client.renderer.Tessellator */ -public class SMCCTRenderManager implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, 0); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - boolean endFields = false; - - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (Names.renderManager_entityRenderMap.name.equals(name)) { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTRenderSpider.java b/java/shadersmodcore/transform/SMCCTRenderSpider.java deleted file mode 100644 index d70ff3ac9..000000000 --- a/java/shadersmodcore/transform/SMCCTRenderSpider.java +++ /dev/null @@ -1,87 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTRenderSpider implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.renderDragon_shouldRenderPass.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); - } - if (Names.renderEnderman_shouldRenderPass.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); - } - if (Names.renderSpider_shouldRenderPass.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVshouldRenderPass extends MethodVisitor - { - public MVshouldRenderPass(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - mv.visitMethodInsn(opcode, owner, name, desc); - if (Names.equals("org/lwjgl/opengl/GL11","glColor4f","(FFFF)V",owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginSpiderEyes", "()V"); - } - } - } - -} diff --git a/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java b/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java deleted file mode 100644 index 8c2ba9649..000000000 --- a/java/shadersmodcore/transform/SMCCTRendererLivingEntity.java +++ /dev/null @@ -1,290 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; -import java.util.ListIterator; - -import org.lwjgl.opengl.GL12; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.AbstractInsnNode; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTRendererLivingEntity implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (Names.rendererLivingE_mainModel.name.equals(name) || - Names.rendererLivingE_renderPassModel.name.equals(name)) { - access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.rendererLivingE_doRender.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVdoRenderLiving( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.rendererLivingE_renderLabel.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVrenderLivingLabel( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVdoRenderLiving extends MethodVisitor - { - public MVdoRenderLiving(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitCode() { - //SMCLog.info(" insert code"); - mv.visitCode(); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "useEntityHurtFlash", "Z"); - Label label1 = new Label(); - mv.visitJumpInsn(IFEQ, label1); - mv.visitVarInsn(ALOAD, 1); - mv.visitFieldInsn(GETFIELD, Names.entityLivingBase_hurtTime.clas, - Names.entityLivingBase_hurtTime.name, - Names.entityLivingBase_hurtTime.desc); - Label label2 = new Label(); - mv.visitJumpInsn(IFGT, label2); - mv.visitVarInsn(ALOAD, 1); - mv.visitFieldInsn(GETFIELD, Names.entityLivingBase_deathTime.clas, - Names.entityLivingBase_deathTime.name, - Names.entityLivingBase_deathTime.desc); - Label label3 = new Label(); - mv.visitJumpInsn(IFLE, label3); - mv.visitLabel(label2); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitIntInsn(BIPUSH, 102); - Label label4 = new Label(); - mv.visitJumpInsn(GOTO, label4); - mv.visitLabel(label3); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitInsn(ICONST_0); - mv.visitLabel(label4); - mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.INTEGER}); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(FLOAD, 9); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.entity_getBrightness.clas, - Names.entity_getBrightness.name, - Names.entity_getBrightness.desc); - mv.visitVarInsn(FLOAD, 9); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.rendererLivingE_getColorMultiplier.clas, - Names.rendererLivingE_getColorMultiplier.name, - Names.rendererLivingE_getColorMultiplier.desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "setEntityHurtFlash", "(II)V"); - mv.visitLabel(label1); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - //SMCLog.info(" end insert"); - } - - /** last SIPUSH operand */ - private int lastInt = 0; - /** state */ - private int state = 0; - private static final int stateEnd = 7; - /** end of vanilla hurt rendering */ - Label labelEndVH = null; - - @Override - public void visitIntInsn(int opcode, int operand) { - if (opcode==SIPUSH) { - lastInt = operand; - } - mv.visitIntInsn(opcode, operand); - } - - @Override - public void visitLdcInsn(Object cst) { - if (cst instanceof Integer) - { - int icst = ((Integer)cst).intValue(); - if (icst == GL12.GL_RESCALE_NORMAL) { - //SMCLog.info(" rescale_normal"); - if (labelEndVH != null) { - //SMCLog.info(" jump target"); - mv.visitLabel(labelEndVH); - labelEndVH = null; - } - } - } - mv.visitLdcInsn(cst); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.info(" %s.%s%s",ownerM,nameM,descM); - if (opcode==INVOKEVIRTUAL) { - if (Names.rendererLivingE_renderEquippedItems.equals(owner, name, desc)) { - //SMCLog.info(" renderEquippedItems"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "resetEntityHurtFlash", "()V"); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitFieldInsn(GETSTATIC, "shadersmodcore/client/Shaders", "useEntityHurtFlash", "Z"); - labelEndVH = new Label(); - mv.visitJumpInsn(IFNE, labelEndVH); - state = 1; - return; - } - } - // - mv.visitMethodInsn(opcode, owner, name, desc); - // - if (opcode==INVOKESTATIC) { - if (Names.equals("org/lwjgl/opengl/GL11","glDepthFunc","(I)V",owner,name,desc)) { - //SMCLog.info(" glDepthFunc"); - if (state==3) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "beginLivingDamage", "()V"); - ++state; - } else if (state==4) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "endLivingDamage", "()V"); - ++state; - } - } else if (Names.openGlHelper_setActiveTexture.equals(owner,name,desc)) { - //SMCLog.info(" setActiveTexture"); - if (state==1) { - ++state; - } else if (state==2) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "disableLightmap", "()V"); - ++state; - } else if (state==5) { - ++state; - } else if (state==6) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/Shaders", "enableLightmap", "()V"); - ++state; - } - } - } - - } - - @Override - public void visitEnd() { - mv.visitEnd(); - if (state != stateEnd) { - SMCLog.severe("state %d expected %d", state, stateEnd); - } - } - } - - private static class MVrenderLivingLabel extends MethodVisitor - { - public MVrenderLivingLabel(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - int pushedInt = 0; - - @Override - public void visitIntInsn(int opcode, int operand) { - mv.visitIntInsn(opcode, operand); - if (opcode == SIPUSH && operand == 3553) - pushedInt = 3553; - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (pushedInt == 3553) - { - pushedInt = 0; - if (opcode==INVOKESTATIC && owner.equals("org/lwjgl/opengl/GL11") && desc.equals("(I)V")) - { - if (name.equals("glDisable")) - { - owner = "shadersmodcore/client/Shaders"; - name = "sglDisableT2D"; - } - else - if (name.equals("glEnable")) - { - owner = "shadersmodcore/client/Shaders"; - name = "sglEnableT2D"; - } - } - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - - -// private static class MVNTransform extends MethodVisitor -// { -// protected MethodVisitor mv; -// protected MethodNode mn; -// public MVNTransform(MethodNode mn, MethodVisitor mv) { -// super(Opcodes.ASM4); -// super.mv = this.mn = mn; -// this.mv = mv; -// } -// -// @Override -// public void visitEnd() { -// super.visitEnd(); -// Iterator it = mn.instructions.iterator(); -// while (it.hasNext()) -// { -// AbstractInsnNode node = it.next(); -// System.out.println(node.toString()); -// } -// // send to target -// mn.accept(mv); -// } -// } - -} diff --git a/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java b/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java deleted file mode 100644 index 01921a927..000000000 --- a/java/shadersmodcore/transform/SMCCTSmartMoveModelRotationRenderer.java +++ /dev/null @@ -1,83 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; -import java.util.ListIterator; - -import org.lwjgl.opengl.GL12; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.AbstractInsnNode; -import org.objectweb.asm.tree.MethodNode; -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTSmartMoveModelRotationRenderer implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if ("resetDisplayList".equals(name) && "()V".equals(desc)) { - return null; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - @Override - public void visitEnd() { - MethodVisitor mv; - { - mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESPECIAL, Names.modelRenderer_.clas, "resetDisplayList", "()V"); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - //mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "compiled", "Z"); - mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_compiled.name, "Z"); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - //mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "displayList", "I"); - mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_displayList.name, "I"); - mv.visitInsn(RETURN); - mv.visitMaxs(2, 1); - mv.visitEnd(); - } - super.visitEnd(); - } - - } -} diff --git a/java/shadersmodcore/transform/SMCCTTessellator.java b/java/shadersmodcore/transform/SMCCTTessellator.java deleted file mode 100644 index 15c64c4e1..000000000 --- a/java/shadersmodcore/transform/SMCCTTessellator.java +++ /dev/null @@ -1,464 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -/** transformer for net.minecraft.client.renderer.Tessellator */ -public class SMCCTTessellator implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static boolean inputHasStaticBuffer = false; - - private static class CVTransform extends ClassVisitor - { - String classname; - boolean endFields = false; - - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - //SMCLog.fine("%x %s %s %s",access,desc,name,nameM); - if ( name.equals("vertexPos") || - name.equals("normalX") || - name.equals("normalY") || - name.equals("normalZ") || - name.equals("midTextureU") || - name.equals("midTextureV") - ) { - return null; - } else if (((access & ACC_STATIC) != 0) && ( - Names.tessellator_byteBuffer.name.equals(name) || - Names.tessellator_intBuffer.name.equals(name) || - Names.tessellator_floatBuffer.name.equals(name) || - Names.tessellator_shortBuffer.name.equals(name) || - Names.tessellator_vertexCount.name.equals(name) - //nameM.equals(Names.Tessellator_useVBO) || - //nameM.equals(Names.Tessellator_vertexBuffers) - )) { - inputHasStaticBuffer = true; - //SMCLog.finest(" input has static buffer"); - access = access & (~ACC_STATIC & ~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } else { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - if (!endFields) { - endFields = true; - FieldVisitor fv; - fv = cv.visitField(ACC_PUBLIC, "vertexPos", "[F", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "normalX", "F", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "normalY", "F", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "normalZ", "F", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "midTextureU", "F", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "midTextureV", "F", null, null); - fv.visitEnd(); - } - //SMCLog.fine(" method %s.%s%s = %s",classname,name,desc,nameM); - if (name.equals("")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVclinit(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (name.equals("") && desc.equals("()V")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (name.equals("") && desc.equals("(I)V")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVinitI( - cv.visitMethod(access, name, desc, signature, exceptions) - ); - } else - if (Names.tessellator_draw.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVdraw(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.tessellator_reset.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - return new MVreset(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.tessellator_addVertex.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVaddVertex(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.tessellator_setNormal.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVsetNormal( - cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.tessellator_sortQuad.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVsortQuad( - cv.visitMethod(access, name, desc, signature, exceptions)); - } else - { - access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - } - - /*private static class MVclinit extends MethodVisitor - { - public MVclinit(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - } - - private static class MVinit extends MethodVisitor - { - public MVinit(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitInsn(int opcode) { - if (opcode == RETURN) { - mv.visitVarInsn(ALOAD, 0); - mv.visitIntInsn(BIPUSH, 16); - mv.visitIntInsn(NEWARRAY, T_FLOAT); - mv.visitFieldInsn(PUTFIELD, SMCNames.Tessellator_, "vertexPos", "[F"); - } - mv.visitInsn(opcode); - } - }*/ - - private static class MVclinit extends MethodVisitor - { - public MVclinit(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitFieldInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); - if (opcode==PUTSTATIC && ( - Names.tessellator_byteBuffer.equals(owner, name) || - Names.tessellator_intBuffer.equals(owner, name) || - Names.tessellator_floatBuffer.equals(owner, name) || - Names.tessellator_shortBuffer.equals(owner, name) || - Names.tessellator_vertexCount.equals(owner, name) - //nameM.equals(Names.Tessellator_useVBO)|| - //nameM.equals(Names.Tessellator_vertexBuffers) - )) - { - mv.visitInsn(POP); - return; - } else - if (opcode==GETSTATIC && ( - Names.tessellator_byteBuffer.equals(owner, name) - //nameM.equals(Names.Tessellator_vertexBuffers) - )) - { - mv.visitInsn(ACONST_NULL); - return; - //} else - //if (opcode==GETSTATIC && ( - // nameM.equals(Names.Tessellator_useVBO) - // )) - //{ - // mv.visitInsn(ICONST_0); - // return; - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.finest(" M %d %s.%s %s", opcode, ownerM, nameM, descM); - if (Names.glAllocation_createDirectByteBuffer.equals(owner, name, desc)) { - mv.visitInsn(POP); - mv.visitInsn(ACONST_NULL); - return; - } else if (Names.glAllocation_createDirectIntBuffer.equals(owner, name, desc)) { - mv.visitInsn(POP); - mv.visitInsn(ACONST_NULL); - return; - } else if (Names.equals("java/nio/ByteBuffer","asIntBuffer","()Ljava/nio/IntBuffer;",owner,name,desc) ) { - mv.visitInsn(POP); - mv.visitInsn(ACONST_NULL); - return; - } else if (Names.equals("java/nio/ByteBuffer","asFloatBuffer","()Ljava/nio/FloatBuffer;",owner,name,desc) ) { - mv.visitInsn(POP); - mv.visitInsn(ACONST_NULL); - return; - } else if (Names.equals("java/nio/ByteBuffer","asShortBuffer","()Ljava/nio/ShortBuffer;",owner,name,desc) ) { - mv.visitInsn(POP); - mv.visitInsn(ACONST_NULL); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVinit extends MethodVisitor - { - public MVinit(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, String desc) { - if (opcode==INVOKESPECIAL - && Names.equals("java/lang/Object","","()V",owner, name, desc) ) - { - mv.visitLdcInsn(new Integer(65536)); - mv.visitMethodInsn(INVOKESPECIAL, Names.tessellator_.clas, "", "(I)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVinitI extends MethodVisitor - { - public MVinitI(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitInsn(int opcode) { - if (opcode == RETURN) { - if (inputHasStaticBuffer) { - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ILOAD, 1); - mv.visitInsn(ICONST_4); - mv.visitInsn(IMUL); - mv.visitMethodInsn(INVOKESTATIC, Names.glAllocation_createDirectByteBuffer.clas, Names.glAllocation_createDirectByteBuffer.name, Names.glAllocation_createDirectByteBuffer.desc); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asIntBuffer", "()Ljava/nio/IntBuffer;"); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_intBuffer.clas, Names.tessellator_intBuffer.name, Names.tessellator_intBuffer.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asFloatBuffer", "()Ljava/nio/FloatBuffer;"); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_floatBuffer.clas, Names.tessellator_floatBuffer.name, Names.tessellator_floatBuffer.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.tessellator_byteBuffer.clas, Names.tessellator_byteBuffer.name, Names.tessellator_byteBuffer.desc); - mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asShortBuffer", "()Ljava/nio/ShortBuffer;"); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_shortBuffer.clas, Names.tessellator_shortBuffer.name, Names.tessellator_shortBuffer.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ILOAD, 1); - mv.visitIntInsn(NEWARRAY, T_INT); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_rawBuffer.clas, Names.tessellator_rawBuffer.name, Names.tessellator_rawBuffer.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_vertexCount.clas, Names.tessellator_vertexCount.name, Names.tessellator_vertexCount.desc); - //mv.visitVarInsn(ALOAD, 0); - //mv.visitFieldInsn(GETSTATIC, Names.Tessellator_, Names.Tessellator_tryVBO, "Z"); - //Label l28 = new Label(); - //mv.visitJumpInsn(IFEQ, l28); - //mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/GLContext", "getCapabilities", "()Lorg/lwjgl/opengl/ContextCapabilities;"); - //mv.visitFieldInsn(GETFIELD, "org/lwjgl/opengl/ContextCapabilities", "GL_ARB_vertex_buffer_object", "Z"); - //mv.visitJumpInsn(IFEQ, l28); - //mv.visitInsn(ICONST_1); - //Label l29 = new Label(); - //mv.visitJumpInsn(GOTO, l29); - //mv.visitLabel(l28); - //mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 1, new Object[] {Names.Tessellator_}); - //mv.visitInsn(ICONST_0); - //mv.visitLabel(l29); - //mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}); - //mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); - //mv.visitVarInsn(ALOAD, 0); - //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); - //Label l31 = new Label(); - //mv.visitJumpInsn(IFEQ, l31); - //mv.visitVarInsn(ALOAD, 0); - //mv.visitVarInsn(ALOAD, 0); - //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vboCount, "I"); - //mv.visitMethodInsn(INVOKESTATIC, Names.GLAllocation_, Names.GLAllocation_createDirectIntBuffer, Names.GLAllocation_createDirectIntBuffer_desc); - //mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, "Ljava/nio/IntBuffer;"); - //mv.visitVarInsn(ALOAD, 0); - //mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, "Ljava/nio/IntBuffer;"); - //mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/ARBVertexBufferObject", "glGenBuffersARB", "(Ljava/nio/IntBuffer;)V"); - //mv.visitLabel(l31); - //mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - } - mv.visitVarInsn(ALOAD, 0); - mv.visitIntInsn(BIPUSH, 16); - mv.visitIntInsn(NEWARRAY, T_FLOAT); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "vertexPos", "[F"); - } - mv.visitInsn(opcode); - } - } - - private static class MVdraw extends MethodVisitor - { - public MVdraw(MethodVisitor mv) { - super(Opcodes.ASM4, null); - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitLineNumber(185, l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTess", "draw", "("+Names.tessellator_.desc+")I"); - mv.visitInsn(IRETURN); - Label l1 = new Label(); - mv.visitLabel(l1); - mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l1, 0); - mv.visitMaxs(1, 1); - mv.visitEnd(); - } - } - - private static class MVreset extends MethodVisitor - { - public MVreset(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitFieldInsn(int opcode, String owner, String name, - String desc) { - //SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); - if (opcode==GETSTATIC && Names.tessellator_byteBuffer.equals(owner, name)) - { - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, owner, name, desc); - return; - } - mv.visitFieldInsn(opcode, owner, name, desc); - } - } - - private static class MVaddVertex extends MethodVisitor - { - public MVaddVertex(MethodVisitor mv) { - super(Opcodes.ASM4, null); - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitLineNumber(466, l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(DLOAD, 1); - mv.visitVarInsn(DLOAD, 3); - mv.visitVarInsn(DLOAD, 5); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTess", "addVertex", "("+Names.tessellator_.desc+"DDD)V"); - Label l1 = new Label(); - mv.visitLabel(l1); - mv.visitLineNumber(467, l1); - mv.visitInsn(RETURN); - Label l2 = new Label(); - mv.visitLabel(l2); - mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l2, 0); - mv.visitLocalVariable("par1", "D", null, l0, l2, 1); - mv.visitLocalVariable("par3", "D", null, l0, l2, 3); - mv.visitLocalVariable("par5", "D", null, l0, l2, 5); - mv.visitMaxs(7, 7); - mv.visitEnd(); - } - } - - private static class MVsetNormal extends MethodVisitor - { - public MVsetNormal(MethodVisitor mv) { - super(Opcodes.ASM4, null); - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_1); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_hasNormals.clas, Names.tessellator_hasNormals.name, Names.tessellator_hasNormals.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 1); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalX", "F"); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 2); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalY", "F"); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(FLOAD, 3); - mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalZ", "F"); - mv.visitInsn(RETURN); - Label l5 = new Label(); - mv.visitLabel(l5); - mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l5, 0); - mv.visitLocalVariable("par1", "F", null, l0, l5, 1); - mv.visitLocalVariable("par2", "F", null, l0, l5, 2); - mv.visitLocalVariable("par3", "F", null, l0, l5, 3); - mv.visitMaxs(2, 4); - mv.visitEnd(); - } - } - - private static class MVsortQuad extends MethodVisitor - { - public MVsortQuad(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitIntInsn(int opcode, int operand) { - if (opcode == BIPUSH && operand == 32) - { - operand = 64; - } - super.visitIntInsn(opcode, operand); - } - - } - - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureAbstract.java b/java/shadersmodcore/transform/SMCCTTextureAbstract.java deleted file mode 100644 index 71ab1aab1..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureAbstract.java +++ /dev/null @@ -1,107 +0,0 @@ -package shadersmodcore.transform; - -import net.minecraft.launchwrapper.IClassTransformer; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -/** transformer for net.minecraft.client.renderer.texture.AbstractTexture */ -public class SMCCTTextureAbstract implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - boolean endFields = false; - - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (name.equals("multiTex")) { - return null; - } else { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - return cv.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - if (!endFields) { - endFields = true; - FieldVisitor fv; - // multiTex - fv = cv.visitField(ACC_PUBLIC, "multiTex", "Lshadersmodcore/client/MultiTexID;", null, null); - fv.visitEnd(); - } - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.abstractTexture_deleteGlTexture.equalsNameDesc(name, desc)) { - //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - return new MVdeleteGlTexture( - cv.visitMethod(access, name, desc, signature, exceptions)); - } else if (name.equals("getMultiTexID") && desc.equals("()Lshadersmodcore/client/MultiTexID;")) { - return null; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - @Override - public void visitEnd() { - MethodVisitor mv; - // getMultiTexID - mv = cv.visitMethod(ACC_PUBLIC, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "getMultiTexID", "("+Names.abstractTexture_.desc+")Lshadersmodcore/client/MultiTexID;"); - mv.visitInsn(ARETURN); - mv.visitMaxs(1, 1); - mv.visitEnd(); - // end - cv.visitEnd(); - } - } - - private static class MVdeleteGlTexture extends MethodVisitor - { - public MVdeleteGlTexture(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "deleteTextures", "("+Names.abstractTexture_.desc+")V"); - } - - } -} diff --git a/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java b/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java deleted file mode 100644 index ea2a82e7f..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureAtlasSprite.java +++ /dev/null @@ -1,191 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -/** transformer for net.minecraft.client.renderer.texture.TextureAtlasSprite */ -public class SMCCTTextureAtlasSprite implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - //String nameM = SMCRemap.remapper.mapFieldName(classname, name, desc); - access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - return cv.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - access = access & ~(ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; - if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (name.equals("load") && desc.equals("("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")Z")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVload(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.textureAtlasSpri_loadSprite.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVloadSprite(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (name.equals("uploadFrameTexture") && desc.equals("(III)V")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVuploadFrameTexture(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - // also used by clock and compass - protected static class MVanimation extends MethodVisitor - { - //protected MethodVisitor mv; - public MVanimation(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.textureUtil_uploadTexSub.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadTexSub", "([[IIIIIZZ)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - private static class MVload extends MethodVisitor - { - //protected MethodVisitor mv; - public MVload(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.iResourceManager_getResource.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadResource", - "("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")"+Names.iResource_.desc); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - - private static class MVloadSprite extends MethodVisitor - { - //protected MethodVisitor mv; - public MVloadSprite(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitIntInsn(int opcode, int operand) { - if (opcode == NEWARRAY && operand == T_INT) { - mv.visitInsn(ICONST_3); - mv.visitInsn(IMUL); - } - mv.visitIntInsn(opcode, operand); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.equals("java/awt/image/BufferedImage","getRGB","(IIII[III)[I",owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadAtlasSprite", "(Ljava/awt/image/BufferedImage;IIII[III)[I"); - return; - } else - if (Names.textureAtlasSpri_getFrameTextureData.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "extractFrame", "([IIII)[I"); - return; - } else - if (Names.equals(Names.textureAtlasSpri_.clas,"fixTransparentColor","([I)V",owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "fixTransparentColor", "("+Names.textureAtlasSpri_.desc+"[I)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } - - - private static class MVuploadFrameTexture extends MethodVisitor - { - public MVuploadFrameTexture(MethodVisitor mv) { - super(Opcodes.ASM4, null); - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ILOAD, 1); - mv.visitVarInsn(ILOAD, 2); - mv.visitVarInsn(ILOAD, 3); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadFrameTexture", "("+Names.textureAtlasSpri_.desc+"III)V"); - mv.visitInsn(RETURN); - Label l2 = new Label(); - mv.visitLabel(l2); - mv.visitLocalVariable("this", Names.textureAtlasSpri_.desc, null, l0, l2, 0); - mv.visitLocalVariable("frameIndex", "I", null, l0, l2, 1); - mv.visitLocalVariable("xPos", "I", null, l0, l2, 2); - mv.visitLocalVariable("yPos", "I", null, l0, l2, 3); - mv.visitMaxs(4, 4); - mv.visitEnd(); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTTextureClock.java b/java/shadersmodcore/transform/SMCCTTextureClock.java deleted file mode 100644 index c4df5c40d..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureClock.java +++ /dev/null @@ -1,62 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureClock implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new SMCCTTextureAtlasSprite.MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureCompass.java b/java/shadersmodcore/transform/SMCCTTextureCompass.java deleted file mode 100644 index 97dc520eb..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureCompass.java +++ /dev/null @@ -1,62 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureCompass implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.textureCompass_updateCompass.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new SMCCTTextureAtlasSprite.MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureDownload.java b/java/shadersmodcore/transform/SMCCTTextureDownload.java deleted file mode 100644 index 879be08d4..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureDownload.java +++ /dev/null @@ -1,95 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureDownload implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - //SMCLog.finest(" field %s %s %s %d", classname, name, desc, access); - return super.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //String nameM = SMCRemap.remapper.mapMethodName(classname, name, desc); - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (name.equals("getMultiTexID")) { - return null; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - @Override - public void visitEnd() { - MethodVisitor mv; - //getMultiTexID - mv = cv.visitMethod(ACC_PUBLIC, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.textureDownload_textureUploaded.clas, Names.textureDownload_textureUploaded.name, Names.textureDownload_textureUploaded.desc); - Label l1 = new Label(); - mv.visitJumpInsn(IFNE, l1); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.textureDownload_.clas, Names.iTextureObject_getGlTextureId.name, Names.iTextureObject_getGlTextureId.desc); - mv.visitInsn(POP); - mv.visitLabel(l1); - mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESPECIAL, Names.abstractTexture_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); - mv.visitInsn(ARETURN); - Label l3 = new Label(); - mv.visitLabel(l3); - mv.visitLocalVariable("this", Names.textureDownload_.desc, null, l0, l3, 0); - mv.visitMaxs(1, 1); - mv.visitEnd(); - //end - cv.visitEnd(); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTTextureDynamic.java b/java/shadersmodcore/transform/SMCCTTextureDynamic.java deleted file mode 100644 index 3633c6948..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureDynamic.java +++ /dev/null @@ -1,117 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureDynamic implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (name.equals("") && desc.equals("(II)V")) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.dynamicTexture_updateDynamicTexture.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVinit extends MethodVisitor - { - //protected MethodVisitor mv; - public MVinit(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitIntInsn(int opcode, int operand) { - if (opcode == NEWARRAY && operand == T_INT) { - mv.visitInsn(ICONST_3); - mv.visitInsn(IMUL); - } - mv.visitIntInsn(opcode, operand); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.textureUtil_allocateTexture.equals(owner, name, desc)) { - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "initDynamicTexture", "(III"+Names.dynamicTexture_.desc+")V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - - private static class MVupdate extends MethodVisitor - { - //protected MethodVisitor mv; - public MVupdate(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.textureUtil_uploadTexture.equals(owner, name, desc)) { - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "updateDynamicTexture", "(I[III"+Names.dynamicTexture_.desc+")V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureLayered.java b/java/shadersmodcore/transform/SMCCTTextureLayered.java deleted file mode 100644 index f5188416e..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureLayered.java +++ /dev/null @@ -1,87 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureLayered implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //String descM = SMCNames.remapper.mapMethodDesc(desc); - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVloadTexture( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVloadTexture extends MethodVisitor - { - //protected MethodVisitor mv; - public MVloadTexture(MethodVisitor mv) { - super(Opcodes.ASM4); - // replace method body - mv.visitCode(); - Label l0 = new Label(); - mv.visitLabel(l0); - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.layeredTexture_layeredTextureNames.clas, Names.layeredTexture_layeredTextureNames.name, Names.layeredTexture_layeredTextureNames.desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadLayeredTexture", "("+Names.layeredTexture_.desc+Names.iResourceManager_.desc+"Ljava/util/List;)V"); - mv.visitInsn(RETURN); - Label l2 = new Label(); - mv.visitLabel(l2); - mv.visitLocalVariable("this", Names.layeredTexture_.desc, null, l0, l2, 0); - mv.visitLocalVariable("manager", Names.iResourceManager_.desc, null, l0, l2, 1); - mv.visitMaxs(3, 2); - mv.visitEnd(); - } - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureManager.java b/java/shadersmodcore/transform/SMCCTTextureManager.java deleted file mode 100644 index bd99b50a6..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureManager.java +++ /dev/null @@ -1,104 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureManager implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - if (Names.textureManager_bindTexture.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - return new MVbindTexture(cv.visitMethod(access, name, desc, signature, exceptions)); - } else - if (Names.textureManager_onResourceManagerReload.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - return new MVonReload(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVbindTexture extends MethodVisitor - { - public MVbindTexture(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.iTextureObject_getGlTextureId.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "bindTexture", "("+Names.iTextureObject_.desc+")V"); - return; - } else - if (Names.textureUtil_bindTexture.equals(owner,name,desc)) { - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - - private static class MVonReload extends MethodVisitor - { - public MVonReload(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.iTextureObject_getGlTextureId.equals(owner,name,desc)) { - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "deleteMultiTex", "("+Names.iTextureObject_.desc+")I"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - } -} diff --git a/java/shadersmodcore/transform/SMCCTTextureMap.java b/java/shadersmodcore/transform/SMCCTTextureMap.java deleted file mode 100644 index eb300e689..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureMap.java +++ /dev/null @@ -1,191 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.FieldVisitor; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; - -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureMap implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - boolean endFields = false; - - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public FieldVisitor visitField(int access, String name, String desc, - String signature, Object value) { - if (name.equals("atlasWidth")) { - return null; - } else if (name.equals("atlasHeight")) { - return null; - } else if (Names.textureMap_anisotropic.name.equals(name)) { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - return super.visitField(access, name, desc, signature, value); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - if (!endFields) { - endFields = true; - FieldVisitor fv; - fv = cv.visitField(ACC_PUBLIC, "atlasWidth", "I", null, null); - fv.visitEnd(); - fv = cv.visitField(ACC_PUBLIC, "atlasHeight", "I", null, null); - fv.visitEnd(); - } - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (Names.textureMap_getIconResLoc.equalsNameDesc(name, desc)) - { - access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; - } - else - if (Names.textureMap_loadTextureAtlas.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVloadAtlas(cv.visitMethod(access, name, desc, signature, exceptions)); - } - else - if (Names.textureMap_updateAnimations.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); - return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - } - - private static class MVloadAtlas extends MethodVisitor - { - //protected MethodVisitor mv; - public MVloadAtlas(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - //this.mv = mv; - } - - @Override - public void visitIntInsn(int opcode, int operand) { - if (opcode == NEWARRAY && operand == T_INT) { - mv.visitInsn(ICONST_3); - mv.visitInsn(IMUL); - } - mv.visitIntInsn(opcode, operand); - } - - int varStitcher = 0; - boolean isStitcher = false; - int state = 0; - - @Override - public void visitVarInsn(int opcode, int var) { - if (opcode==ASTORE) { - if (isStitcher) { - isStitcher = false; - varStitcher = var; - } - } - mv.visitVarInsn(opcode, var); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name,String desc) { - //SMCLog.finest(" %s.%s%s",ownerM,nameM,descM); - if (Names.iResourceManager_getResource.equals(owner,name,desc)) { - SMCLog.finest(" %s","loadRes"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadResource", "("+Names.iResourceManager_.desc+Names.resourceLocation_.desc+")"+Names.iResource_.desc); - return; - } - else if (opcode==INVOKESPECIAL && Names.equals(Names.stitcher_.clas,"","(IIZII)V",owner,name,desc)) { - isStitcher = true; - } - else if (Names.textureUtil_allocateTextureMipmapAniso.equals(owner,name,desc)) { - SMCLog.finest(" %s","allocateTextureMap"); - mv.visitVarInsn(ALOAD, varStitcher); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "allocateTextureMap", "(IIIIF"+Names.stitcher_.desc+Names.textureMap_.desc+")V"); - state = 1; - return; - } - else if (state==1 && - Names.textureAtlasSpri_getIconName.equals(owner,name,desc)) { - SMCLog.finest(" %s","setSprite setIconName"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "setSprite", "("+Names.textureAtlasSpri_.desc+")"+Names.textureAtlasSpri_.desc); - mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "setIconName", "(Ljava/lang/String;)Ljava/lang/String;"); - state = 0; - return; - } - else if (Names.textureUtil_uploadTexSub.equals(owner,name,desc)) { - SMCLog.finest(" %s","uploadTexSubForLoadAtlas"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "uploadTexSubForLoadAtlas", "([[IIIIIZZ)V"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - - private static class MVanimation extends MethodVisitor - { - public MVanimation(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitCode() { - mv.visitCode(); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.textureMap_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); - mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/ShadersTex", "updatingTex", "Lshadersmodcore/client/MultiTexID;"); - } - - @Override - public void visitInsn(int opcode) { - if (opcode==RETURN) { - mv.visitInsn(ACONST_NULL); - mv.visitFieldInsn(PUTSTATIC, "shadersmodcore/client/ShadersTex", "updatingTex", "Lshadersmodcore/client/MultiTexID;"); - } - mv.visitInsn(opcode); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureObject.java b/java/shadersmodcore/transform/SMCCTTextureObject.java deleted file mode 100644 index bbca308b4..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureObject.java +++ /dev/null @@ -1,69 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureObject implements IClassTransformer { - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, 0); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); - if (name.equals("getMultiTexID") && desc.equals("()Lshadersmodcore/client/MultiTexID;")) { - return null; - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - @Override - public void visitEnd() { - MethodVisitor mv; - // getMultiTexID - mv = cv.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;", null, null); - mv.visitEnd(); - // end - cv.visitEnd(); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCCTTextureSimple.java b/java/shadersmodcore/transform/SMCCTTextureSimple.java deleted file mode 100644 index 98771f9d8..000000000 --- a/java/shadersmodcore/transform/SMCCTTextureSimple.java +++ /dev/null @@ -1,89 +0,0 @@ -package shadersmodcore.transform; - -import java.util.Iterator; - -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Label; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import static org.objectweb.asm.Opcodes.*; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.tree.MethodNode; - - -import net.minecraft.launchwrapper.IClassTransformer; - -public class SMCCTTextureSimple implements IClassTransformer { - - private static final int logDetail = 0; - - @Override - public byte[] transform(String par1, String par2, byte[] par3) { - SMCLog.fine("transforming %s %s",par1,par2); - ClassReader cr = new ClassReader(par3); - ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); - CVTransform cv = new CVTransform(cw); - cr.accept(cv,0); - return cw.toByteArray(); - } - - private static class CVTransform extends ClassVisitor - { - String classname; - public CVTransform(ClassVisitor cv) - { - super(Opcodes.ASM4, cv); - } - - @Override - public void visit(int version, int access, String name, - String signature, String superName, String[] interfaces) { - classname = name; - //SMCLog.info(" class %s",name); - cv.visit(version, access, name, signature, superName, interfaces); - } - - @Override - public MethodVisitor visitMethod(int access, String name, String desc, - String signature, String[] exceptions) - { - //SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) - { - //SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); - return new MVloadTexture( - cv.visitMethod(access, name, desc, signature, exceptions)); - } - return cv.visitMethod(access, name, desc, signature, exceptions); - } - - } - - private static class MVloadTexture extends MethodVisitor - { - public MVloadTexture(MethodVisitor mv) { - super(Opcodes.ASM4, mv); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String name, - String desc) { - if (Names.textureUtil_uploadTextureImageAllocate.equals(owner,name,desc)) { - //mv.visitMethodInsn(opcode, owner, name, desc); - mv.visitVarInsn(ALOAD, 1); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, Names.simpleTexture_textureLocation.clas, Names.simpleTexture_textureLocation.name, Names.simpleTexture_textureLocation.desc); - mv.visitVarInsn(ALOAD, 0); - mv.visitMethodInsn(INVOKEVIRTUAL, Names.simpleTexture_.clas, "getMultiTexID", "()Lshadersmodcore/client/MultiTexID;"); - mv.visitMethodInsn(INVOKESTATIC, "shadersmodcore/client/ShadersTex", "loadSimpleTexture", "(ILjava/awt/image/BufferedImage;ZZ"+Names.iResourceManager_.desc+Names.resourceLocation_.desc+"Lshadersmodcore/client/MultiTexID;)I"); - SMCLog.finer(" loadSimpleTexture"); - return; - } - mv.visitMethodInsn(opcode, owner, name, desc); - } - - } - -} diff --git a/java/shadersmodcore/transform/SMCClassTransformer.java b/java/shadersmodcore/transform/SMCClassTransformer.java deleted file mode 100644 index 61ef76299..000000000 --- a/java/shadersmodcore/transform/SMCClassTransformer.java +++ /dev/null @@ -1,84 +0,0 @@ -package shadersmodcore.transform; - -import java.io.IOException; -import java.io.InputStream; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; -import java.util.zip.ZipEntry; -import java.util.zip.ZipException; -import java.util.zip.ZipFile; - -import net.minecraft.launchwrapper.IClassTransformer; -import org.objectweb.asm.Opcodes; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.commons.Remapper; - -public class SMCClassTransformer implements IClassTransformer { - - Names names; - /** map of class transformer */ - protected Map ctMap; - - public void put(Names.Clas clas, IClassTransformer ct) - { - ctMap.put(clas.clas.replace('/', '.'), ct); - } - - // constructor - public SMCClassTransformer() - { - names = new Names(); - InitNames.init(); - ctMap = new HashMap(); - put(Names.block_ , new SMCCTBlock()); - put(Names.itemBlock_ , new SMCCTItemBlock()); - put(Names.minecraft_ , new SMCCTMinecraft()); - put(Names.guiOptions_ , new SMCCTGuiOptions()); - put(Names.modelRenderer_ , new SMCCTModelRenderer()); - put(Names.openGlHelper_ , new SMCCTOpenGlHelper()); - put(Names.tessellator_ , new SMCCTTessellator()); - put(Names.renderBlocks_ , new SMCCTRenderBlocks()); - put(Names.renderGlobal_ , new SMCCTRenderGlobal()); - put(Names.entityRenderer_ , new SMCCTEntityRenderer()); - put(Names.render_ , new SMCCTRender()); - put(Names.renderManager_ , new SMCCTRenderManager()); - put(Names.rendererLivingE_ , new SMCCTRendererLivingEntity()); - put(Names.renderDragon_ , new SMCCTRenderSpider()); - put(Names.renderEnderman_ , new SMCCTRenderSpider()); - put(Names.renderSpider_ , new SMCCTRenderSpider()); - put(Names.itemRenderer_ , new SMCCTItemRenderer()); - put(Names.textureDownload_ , new SMCCTTextureDownload()); - put(Names.abstractTexture_ , new SMCCTTextureAbstract()); - put(Names.iTextureObject_ , new SMCCTTextureObject()); - put(Names.simpleTexture_ , new SMCCTTextureSimple()); - put(Names.layeredTexture_ , new SMCCTTextureLayered()); - put(Names.dynamicTexture_ , new SMCCTTextureDynamic()); - put(Names.textureMap_ , new SMCCTTextureMap()); - put(Names.textureAtlasSpri_, new SMCCTTextureAtlasSprite()); - put(Names.textureClock_ , new SMCCTTextureClock()); - put(Names.textureCompass_ , new SMCCTTextureCompass()); - put(Names.textureManager_ , new SMCCTTextureManager()); - ctMap.put("mrtjp.projectred.illumination.RenderHalo$", new SMCCTPrjRedIlluRenderHalo()); - ctMap.put("net.smart.render.ModelRotationRenderer", new SMCCTSmartMoveModelRotationRenderer()); - } - - @Override - public byte[] transform(String par1, String par2, byte[] par3) - { - byte[] bytecode = par3; - //if (par2.startsWith("mrtjp")) SMCLog.info("**** [%s]", par2); - IClassTransformer ct = ctMap.get(par2); - if (ct != null) - { - bytecode = ct.transform(par1, par2, bytecode); - int len1 = par3.length; //arg2!=null?arg2.length:0; - int len2 = bytecode.length; //bytecode!=null?bytecode.length:0; - SMCLog.fine(" %d (%+d)", len2, len2-len1); - } - return bytecode; - } - -} \ No newline at end of file diff --git a/java/shadersmodcore/transform/SMCLog.java b/java/shadersmodcore/transform/SMCLog.java deleted file mode 100644 index 96a63b216..000000000 --- a/java/shadersmodcore/transform/SMCLog.java +++ /dev/null @@ -1,105 +0,0 @@ -package shadersmodcore.transform; - -import java.io.IOException; -import java.util.Calendar; -import java.util.logging.ConsoleHandler; -import java.util.logging.FileHandler; -import java.util.logging.Formatter; -import java.util.logging.Handler; -import java.util.logging.Level; -import java.util.logging.LogRecord; -import java.util.logging.Logger; -import java.util.logging.SimpleFormatter; - -import static java.util.logging.Level.*; - -public abstract class SMCLog { - - private static class SMCFormatter extends Formatter { - int tzOffset; - SMCFormatter() { - tzOffset = Calendar.getInstance().getTimeZone().getRawOffset(); - } - @Override - public String format(LogRecord record) { - StringBuilder sb = new StringBuilder(); - //int time = (int)((record.getMillis() + tzOffset) % (24*60*60*1000)); - sb.append("[") - //.append(time/36000000).append(time/3600000%10)//.append(":") - //.append(time/600000%6).append(time/60000%10)//.append(":") - //.append(time/10000%6).append(time/10000%10).append(".") - //.append(time/100%10).append(time/10%10).append(time%10).append(" ") - .append(record.getLoggerName()).append(" ") - .append(record.getLevel()).append("]") - .append(record.getMessage()).append("\n"); - return sb.toString(); - } - } - - private static class SMCLogger extends Logger { - SMCLogger(String name) { - super(name,null); - setUseParentHandlers(false); - Formatter formatter = new SMCFormatter(); - Handler handler = new ConsoleHandler(); - handler.setFormatter(formatter); - addHandler(handler); - try { - handler = new FileHandler("shadersmod-%u.log",8*1048576,1,false); - handler.setFormatter(formatter); - addHandler(handler); - } catch (IOException e) { - e.printStackTrace(); - } - setLevel(ALL); - } - } - - private static class SMCLevel extends Level { - private SMCLevel(String name, int value) { - super(name,value); - } - } - - public static final String smcLogName = "SMC"; - public static final Logger logger = new SMCLogger(smcLogName); - public static final Level SMCINFO = new SMCLevel("INF",850); - public static final Level SMCCONFIG = new SMCLevel("CFG",840); - public static final Level SMCFINE = new SMCLevel("FNE",830); - public static final Level SMCFINER = new SMCLevel("FNR",820); - public static final Level SMCFINEST = new SMCLevel("FNT",810); - - public static void log(Level level, String format, Object ... args) { - if (logger.isLoggable(level)) - logger.log(level,String.format(format, args)); - } - public static void severe(String format, Object ... args) { - if (logger.isLoggable(SEVERE)) - logger.log(SEVERE,String.format(format, args)); - } - public static void warning(String format, Object ... args) { - if (logger.isLoggable(WARNING)) - logger.log(WARNING,String.format(format, args)); - } - public static void info(String format, Object ... args) { - if (logger.isLoggable(SMCINFO)) - logger.log(SMCINFO,String.format(format, args)); - } - public static void config(String format, Object ... args) { - if (logger.isLoggable(SMCCONFIG)) - logger.log(SMCCONFIG,String.format(format, args)); - } - public static void fine(String format, Object ... args) { - if (logger.isLoggable(SMCFINE)) - logger.log(SMCFINE,String.format(format, args)); - } - public static void finer(String format, Object ... args) { - if (logger.isLoggable(SMCFINER)) - logger.log(SMCFINER,String.format(format, args)); - } - public static void finest(String format, Object ... args) { - if (logger.isLoggable(SMCFINEST)) - logger.log(SMCFINEST,String.format(format, args)); - } - -} diff --git a/java_dev/shadersmodcore/transform/InitNames.java b/java_dev/shadersmodcore/transform/InitNames.java deleted file mode 100644 index 447718831..000000000 --- a/java_dev/shadersmodcore/transform/InitNames.java +++ /dev/null @@ -1,8 +0,0 @@ -package shadersmodcore.transform; - -public class InitNames { - public static void init() - { - new NamerMcp().setNames(); - } -} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_10.java b/java_dev/shadersmodcore/transform/Namer1_7_10.java deleted file mode 100644 index e576d8ac4..000000000 --- a/java_dev/shadersmodcore/transform/Namer1_7_10.java +++ /dev/null @@ -1,205 +0,0 @@ -package shadersmodcore.transform; - -import static shadersmodcore.transform.Names.*; - -public class Namer1_7_10 extends Namer { - - public void setNames() { - setNames1_7_10(); - } - public void setNames1_7_10() { - block_ = c("aji"); - blockFlowerPot_ = c("ald"); - minecraft_ = c("bao"); - guiButton_ = c("bcb"); - guiOptions_ = c("bdm"); - guiScreen_ = c("bdw"); - modelRenderer_ = c("bix"); - worldClient_ = c("bjf"); - effectRenderer_ = c("bkn"); - entityRenderer_ = c("blt"); - glAllocation_ = c("ban"); - itemRenderer_ = c("bly"); - openGlHelper_ = c("buu"); - renderBlocks_ = c("blm"); - renderGlobal_ = c("bma"); - tessellator_ = c("bmh"); - worldRenderer_ = c("blo"); - frustrum_ = c("bmx"); - iCamera_ = c("bmv"); - render_ = c("bno"); - renderDragon_ = c("bnl"); - renderEnderman_ = c("bnm"); - renderSpider_ = c("bov"); - renderManager_ = c("bnn"); - rendererLivingE_ = c("boh"); - abstractTexture_ = c("bpp"); - dynamicTexture_ = c("bpq"); - iTextureObject_ = c("bqh"); - layeredTexture_ = c("bpt"); - simpleTexture_ = c("bpu"); - stitcher_ = c("bpv"); - textureAtlasSpri_ = c("bqd"); - textureClock_ = c("bql"); - textureCompass_ = c("bqm"); - textureManager_ = c("bqf"); - textureMap_ = c("bpz"); - textureUtil_ = c("bqi"); - textureDownload_ = c("bpr"); - iResource_ = c("bqw"); - iResourceManager_ = c("bqy"); - gameSettings_ = c("bbj"); - tessVertexState_ = c("bmi"); - entity_ = c("sa"); - entityLivingBase_ = c("sv"); - entityDragon_ = c("xa"); - entityEnderman_ = c("ya"); - entitySpider_ = c("yn"); - entityPlayer_ = c("yz"); - item_ = c("adb"); - itemBlock_ = c("abh"); - itemStack_ = c("add"); - movingObjectPos_ = c("azu"); - resourceLocation_ = c("bqx"); - vec3_ = c("azw"); - iBlockAccess_ = c("ahl"); - world_ = c("ahb"); - - entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); - entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); - entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); - entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); - gameSettings_renderDistance = f(gameSettings_ ,"c","I"); - guiButton_id = f(guiButton_ ,"k","I"); - guiScreen_buttonList = f(guiScreen_ ,"n","Ljava/util/List;"); - guiScreen_width = f(guiScreen_ ,"l","I"); - guiScreen_height = f(guiScreen_ ,"m","I"); - guiScreen_mc = f(guiScreen_ ,"k",minecraft_.desc); - guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); - itemBlock_block = f(itemBlock_ ,"a",block_.desc); - itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); - layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); - minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); - minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); - modelRenderer_displayList = f(modelRenderer_ ,"u" ,"I"); - modelRenderer_compiled = f(modelRenderer_ ,"t" ,"Z"); - renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,"I"); - renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); - rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); - rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); - renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); - renderManager_instance = f(renderManager_ ,"a" ,renderManager_.desc); - simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); - tessellator_floatBuffer = f(tessellator_ ,"d","Ljava/nio/FloatBuffer;"); - tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); - tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); - tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); - tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); - tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); - tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); - textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); - textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); - textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); - textureMap_anisotropic = f(textureMap_ ,"k",null); - textureDownload_textureUploaded = f(textureDownload_,"j","Z"); - vec3_xCoord = f(vec3_ ,"a" ,"D"); - - abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); - block_getAoLight = m(block_ ,"I","()F"); - block_getBlockFromItem = m(block_ ,"a","("+item_.desc+")"+block_.desc); - dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"a","()V"); - effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); - effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); - entity_getBrightness = m(entity_ ,"d" ,"(F)F"); - entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); - entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); - entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); - entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); - entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); - entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); - entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); - entityRenderer_setupCameraTransform = m(entityRenderer_,"a" ,"(FI)V"); - entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); - entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); - gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); - gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); - glAllocation_createDirectByteBuffer = m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); - glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); - glAllocation_deleteDisplayLists = m(glAllocation_ ,"b" ,"(I)V"); - guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); - guiOptions_initGui = m(guiOptions_ ,"b","()V"); - iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); - iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); - itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); - itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); - itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); - itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); - iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); - iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); - minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); - minecraft_startGame = m(minecraft_ ,"ag" ,"()V"); - openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); - render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); - renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); - renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); - renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); - renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); - renderBlocks_renderBlockFlowerPot = m(renderBlocks_ ,"a","("+blockFlowerPot_.desc+"III)Z"); - renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); - renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); - renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); - renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); - rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); - rendererLivingE_renderEquippedItems = m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); - rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); - rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); - renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); - renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); - renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); - renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); - renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); - renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); - renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); - renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); - stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); - tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); - tessellator_addTranslation = m(tessellator_ ,"d" ,"(FFF)V"); - tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); - tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); - tessellator_reset = m(tessellator_ ,"d" ,"()V"); - tessellator_draw = m(tessellator_ ,"a" ,"()I"); - textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"-","("+iResource_.desc+")V"); - textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); - textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); - textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); - textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); - textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); - textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); - textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); - textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); - textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); - textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); - textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); - textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); - textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); - textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); - textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); - world_getCelestialAngle = m(world_ ,"c" ,"(F)F"); - world_getRainStrength = m(world_ ,"j" ,"(F)F"); - modelRenderer_render = m(modelRenderer_ ,"a" ,"(F)V"); - modelRenderer_renderWithRotation = m(modelRenderer_ ,"b" ,"(F)V"); - - guiOptions_buttonList = f(guiOptions_,guiScreen_buttonList); - guiOptions_width = f(guiOptions_,guiScreen_width); - guiOptions_height = f(guiOptions_,guiScreen_height); - guiOptions_mc = f(guiOptions_,guiScreen_mc); - frustrum_setPosition = m(frustrum_,iCamera_setPosition); - worldClient_getCelestialAngle = m(worldClient_,world_getCelestialAngle); - worldClient_getRainStrength = m(worldClient_,world_getRainStrength); - } -} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_2.java b/java_dev/shadersmodcore/transform/Namer1_7_2.java deleted file mode 100644 index e1adc2423..000000000 --- a/java_dev/shadersmodcore/transform/Namer1_7_2.java +++ /dev/null @@ -1,183 +0,0 @@ -package shadersmodcore.transform; - -import static shadersmodcore.transform.Names.*; - -public class Namer1_7_2 extends Namer { - - public void setNames() { - block_ = c("net/minecraft/block/Block"); - minecraft_ = c("net/minecraft/client/Minecraft"); - guiButton_ = c("net/minecraft/client/gui/GuiButton"); - guiOptions_ = c("net/minecraft/client/gui/GuiOptions"); - guiScreen_ = c("net/minecraft/client/gui/GuiScreen"); - modelRenderer_ = c("net/minecraft/client/model/ModelRenderer"); - worldClient_ = c("net/minecraft/client/multiplayer/WorldClient"); - effectRenderer_ = c("net/minecraft/client/particle/EffectRenderer"); - entityRenderer_ = c("net/minecraft/client/renderer/EntityRenderer"); - glAllocation_ = c("net/minecraft/client/renderer/GLAllocation"); - itemRenderer_ = c("net/minecraft/client/renderer/ItemRenderer"); - openGlHelper_ = c("net/minecraft/client/renderer/OpenGlHelper"); - renderBlocks_ = c("net/minecraft/client/renderer/RenderBlocks"); - renderGlobal_ = c("net/minecraft/client/renderer/RenderGlobal"); - tessellator_ = c("net/minecraft/client/renderer/Tessellator"); - worldRenderer_ = c("net/minecraft/client/renderer/WorldRenderer"); - frustrum_ = c("net/minecraft/client/renderer/culling/Frustrum"); - iCamera_ = c("net/minecraft/client/renderer/culling/ICamera"); - render_ = c("net/minecraft/client/renderer/entity/Render"); - renderDragon_ = c("net/minecraft/client/renderer/entity/RenderDragon"); - renderEnderman_ = c("net/minecraft/client/renderer/entity/RenderEnderman"); - renderSpider_ = c("net/minecraft/client/renderer/entity/RenderSpider"); - renderManager_ = c("net/minecraft/client/renderer/entity/RenderManager"); - rendererLivingE_ = c("net/minecraft/client/renderer/entity/RendererLivingEntity"); - abstractTexture_ = c("net/minecraft/client/renderer/texture/AbstractTexture"); - dynamicTexture_ = c("net/minecraft/client/renderer/texture/DynamicTexture"); - iTextureObject_ = c("net/minecraft/client/renderer/texture/ITextureObject"); - layeredTexture_ = c("net/minecraft/client/renderer/texture/LayeredTexture"); - simpleTexture_ = c("net/minecraft/client/renderer/texture/SimpleTexture"); - stitcher_ = c("net/minecraft/client/renderer/texture/Stitcher"); - textureAtlasSpri_ = c("net/minecraft/client/renderer/texture/TextureAtlasSprite"); - textureClock_ = c("net/minecraft/client/renderer/texture/TextureClock"); - textureCompass_ = c("net/minecraft/client/renderer/texture/TextureCompass"); - textureManager_ = c("net/minecraft/client/renderer/texture/TextureManager"); - textureMap_ = c("net/minecraft/client/renderer/texture/TextureMap"); - textureUtil_ = c("net/minecraft/client/renderer/texture/TextureUtil"); - textureDownload_ = c("net/minecraft/client/renderer/ThreadDownloadImageData"); - iResource_ = c("net/minecraft/client/resources/IResource"); - iResourceManager_ = c("net/minecraft/client/resources/IResourceManager"); - gameSettings_ = c("net/minecraft/client/settings/GameSettings"); - tessVertexState_ = c("net/minecraft/client/shader/TesselatorVertexState"); - entity_ = c("net/minecraft/entity/Entity"); - entityLivingBase_ = c("net/minecraft/entity/EntityLivingBase"); - entityDragon_ = c("net/minecraft/entity/boss/EntityDragon"); - entityEnderman_ = c("net/minecraft/entity/monster/EntityEnderman"); - entitySpider_ = c("net/minecraft/entity/monster/EntitySpider"); - entityPlayer_ = c("net/minecraft/entity/player/EntityPlayer"); - movingObjectPos_ = c("net/minecraft/util/MovingObjectPosition"); - resourceLocation_ = c("net/minecraft/util/ResourceLocation"); - vec3_ = c("net/minecraft/util/Vec3"); - iBlockAccess_ = c("net/minecraft/world/IBlockAccess"); - world_ = c("net/minecraft/world/World"); - - entityLivingBase_deathTime = f(entityLivingBase_,"field_70725_aQ","I"); - entityLivingBase_hurtTime = f(entityLivingBase_,"field_70737_aN","I"); - entityRenderer_cameraZoom = f(entityRenderer_ ,"field_78503_V" ,"D"); - entityRenderer_mc = f(entityRenderer_ ,"field_78531_r" ,minecraft_.desc); - gameSettings_renderDistance = f(gameSettings_ ,"field_151451_c","I"); - guiButton_id = f(guiButton_ ,"field_146127_k",null); - guiOptions_buttonList = f(guiOptions_ ,"field_146292_n",null); - guiOptions_width = f(guiOptions_ ,"field_146294_l",null); - guiOptions_height = f(guiOptions_ ,"field_146295_m",null); - guiOptions_mc = f(guiOptions_ ,"field_146297_k",null); - guiOptions_options = f(guiOptions_ ,"field_146443_h",null); - layeredTexture_layeredTextureNames = f(layeredTexture_,"field_110567_b",null); - minecraft_renderGlobal = f(minecraft_ ,"field_71438_f" ,null); - minecraft_gameSettings = f(minecraft_ ,"field_71474_y" ,null); - modelRenderer_displayList = f(modelRenderer_ ,"field_78811_r" ,null); - modelRenderer_compiled = f(modelRenderer_ ,"field_78812_q" ,null); - renderGlobal_glSkyList = f(renderGlobal_ ,"field_72771_w" ,null); - renderGlobal_worldRenderers = f(renderGlobal_ ,"field_72765_l" ,"["+worldRenderer_.desc); - rendererLivingE_mainModel = f(rendererLivingE_ ,"field_77045_g" ,null); - rendererLivingE_renderPassModel = f(rendererLivingE_,"field_77046_h",null); - renderManager_instance = f(renderManager_ , "field_78727_a",renderManager_.desc); - simpleTexture_textureLocation = f(simpleTexture_ ,"field_110568_b",resourceLocation_.desc); - tessellator_floatBuffer = f(tessellator_ ,"field_147566_d",null); - tessellator_shortBuffer = f(tessellator_ ,"field_147567_e",null); - tessellator_intBuffer = f(tessellator_ ,"field_147568_c",null); - tessellator_byteBuffer = f(tessellator_ ,"field_78394_d" ,null); - tessellator_rawBuffer = f(tessellator_ ,"field_78405_h" ,null); - tessellator_vertexCount = f(tessellator_ ,"field_78406_i" ,null); - tessellator_hasNormals = f(tessellator_ ,"field_78413_q" ,"Z"); - textureAtlasSpri_width = f(textureAtlasSpri_,"field_130223_c",null); - textureAtlasSpri_height = f(textureAtlasSpri_,"field_130224_d",null); - textureAtlasSpri_border = f(textureAtlasSpri_,"field_147966_k",null); - textureMap_anisotropic = f(textureMap_ ,"field_147637_k",null); - textureDownload_textureUploaded = f(textureDownload_,"field_110559_g","Z"); - vec3_xCoord = f(vec3_ ,"field_72450_a" ,"D"); - - abstractTexture_deleteGlTexture = m(abstractTexture_,"func_147631_c","()V"); - block_getAoLight = m(block_ ,"func_149685_I","("+iBlockAccess_.desc+"III)F"); - dynamicTexture_updateDynamicTexture = m(dynamicTexture_ ,"func_110564_a","()V"); - effectRenderer_renderLitParticles = m(effectRenderer_ ,"func_78872_b" ,"("+entity_.desc+"F)V"); - effectRenderer_renderParticles = m(effectRenderer_ ,"func_78874_a" ,"("+entity_.desc+"F)V"); - entity_getBrightness = m(entity_ ,"func_70013_c" ,"(F)F"); - entityRenderer_enableLightmap = m(entityRenderer_ ,"func_78463_b" ,"(D)V"); - entityRenderer_updateFogColor = m(entityRenderer_ ,"func_78466_h" ,"(F)V"); - entityRenderer_setupFog = m(entityRenderer_ ,"func_78468_a" ,"(IF)V"); - entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"func_78469_a" ,"(FFFF)Ljava/nio/FloatBuffer;"); - entityRenderer_renderWorld = m(entityRenderer_ ,"func_78471_a" ,"(FJ)V"); - entityRenderer_renderRainSnow = m(entityRenderer_ ,"func_78474_d" ,"(F)V"); - entityRenderer_renderHand = m(entityRenderer_ ,"func_78476_b" ,"(FI)V"); - entityRenderer_setupCameraTransform = m(entityRenderer_,"func_78479_a" ,"(FI)V"); - entityRenderer_disableLightmap = m(entityRenderer_ ,"func_78483_a" ,"(D)V"); - entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"func_82829_a" ,"("+renderGlobal_.desc+"F)V"); - gameSettings_saveOptions = m(gameSettings_ ,"func_74303_b" ,"()V"); - gameSettings_shouldRenderClouds = m(gameSettings_ ,"func_74309_c" ,"()Z"); - glAllocation_createDirectByteBuffer = m(glAllocation_ ,"func_74524_c" ,"(I)Ljava/nio/ByteBuffer;"); - glAllocation_createDirectIntBuffer = m(glAllocation_ ,"func_74527_f" ,"(I)Ljava/nio/IntBuffer;"); - guiOptions_actionPerformed = m(guiOptions_ ,"func_146284_a","("+guiButton_.desc+")V"); - guiOptions_initGui = m(guiOptions_ ,"func_73866_w_","()V"); - iCamera_setPosition = m(iCamera_ ,"func_78547_a" ,"(DDD)V"); - iResourceManager_getResource = m(iResourceManager_,"func_110536_a","("+resourceLocation_.desc+")"+iResource_.desc); - itemRenderer_renderItem = m(itemRenderer_ ,"func_78443_a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); - itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"func_78440_a" ,"(F)V"); - itemRenderer_renderOverlays = m(itemRenderer_ ,"func_78447_b" ,"(F)V"); - itemRenderer_updateEquipped = m(itemRenderer_ ,"func_78441_a" ,"()V"); - iTextureObject_loadTexture = m(iTextureObject_ ,"func_110551_a","("+iResourceManager_.desc+")V"); - iTextureObject_getGlTextureId = m(iTextureObject_ ,"func_110552_b","()I"); - minecraft_displayGuiScreen = m(minecraft_ ,"func_147108_a","("+guiScreen_.desc+")V"); - minecraft_startGame = m(minecraft_ ,"func_71384_a" ,"()V"); - openGlHelper_setActiveTexture = m(openGlHelper_ ,"func_77473_a" ,"(I)V"); - render_renderShadow = m(render_ ,"func_76975_c" ,"("+entity_.desc+"DDDFF)V"); - renderBlocks_renderBlockFluids = m(renderBlocks_ ,"func_147721_p","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"func_147736_d","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"func_147749_a","("+block_.desc+world_.desc+"IIII)V"); - renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"func_147751_a","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"func_147754_e","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockDoor = m(renderBlocks_ ,"func_147760_u","("+block_.desc+"III)Z"); - renderBlocks_renderBlockBed = m(renderBlocks_ ,"func_147773_v","("+block_.desc+"III)Z"); - renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"func_147805_b","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"func_147808_b","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderPistonExtension = m(renderBlocks_ ,"func_147809_c","("+block_.desc+"IIIZ)Z"); - renderDragon_shouldRenderPass = m(renderDragon_ ,"func_77032_a" , "("+entityDragon_.desc+"IF)I"); - renderEnderman_shouldRenderPass = m(renderEnderman_ ,"func_77032_a" , "("+entityEnderman_.desc+"IF)I"); - renderSpider_shouldRenderPass = m(renderSpider_ ,"func_77032_a" , "("+entitySpider_.desc+"IF)I"); - rendererLivingE_doRender = m(rendererLivingE_,"func_76986_a" ,"("+entityLivingBase_.desc+"DDDFF)V"); - rendererLivingE_renderEquippedItems = m(rendererLivingE_,"func_77029_c","("+entityLivingBase_.desc+"F)V"); - rendererLivingE_getColorMultiplier = m(rendererLivingE_,"func_77030_a" ,"("+entityLivingBase_.desc+"FF)I"); - rendererLivingE_renderLabel = m(rendererLivingE_,"func_96449_a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); - renderGlobal_renderEntities = m(renderGlobal_ ,"func_147589_a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); - renderGlobal_renderSky = m(renderGlobal_ ,"func_72714_a" ,"(F)V"); - renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"func_72717_a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); - renderGlobal_renderClouds = m(renderGlobal_ ,"func_72718_b" ,"(F)V"); - renderGlobal_sortAndRender = m(renderGlobal_ ,"func_72719_a" ,"("+entityLivingBase_.desc+"ID)I"); - renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"func_72729_a" ,"("+iCamera_.desc+"F)V"); - renderGlobal_drawSelectionBox = m(renderGlobal_ ,"func_72731_b" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); - renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"func_72733_a" ,"(ID)V"); - stitcher_getCurrentWidth = m(stitcher_ ,"func_110935_a","()I"); - tessellator_sortQuad = m(tessellator_ ,"func_147564_a","(FFF)"+tessVertexState_.desc); - tessellator_setNormal = m(tessellator_ ,"func_78375_b" ,"(FFF)V"); - tessellator_addVertex = m(tessellator_ ,"func_78377_a" ,"(DDD)V"); - tessellator_reset = m(tessellator_ ,"func_78379_d" ,"()V"); - tessellator_draw = m(tessellator_ ,"func_78381_a" ,"()I"); - textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"func_130100_a","("+iResource_.desc+")V"); - textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"func_147965_a","(I)[[I"); - textureAtlasSpri_getIconName = m(textureAtlasSpri_,"func_94215_i","()Ljava/lang/String;"); - textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"func_94219_l","()V"); - textureCompass_updateCompass = m(textureCompass_ ,"func_94241_a" ,"("+world_.desc+"DDDZZ)V"); - textureManager_onResourceManagerReload = m(textureManager_,"func_110549_a","("+iResourceManager_.desc+")V"); - textureManager_bindTexture = m(textureManager_ ,"func_110577_a","("+resourceLocation_.desc+")V"); - textureMap_loadTextureAtlas = m(textureMap_ ,"func_110571_b","("+iResourceManager_.desc+")V"); - textureMap_getIconResLoc = m(textureMap_ ,"func_147634_a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); - textureMap_updateAnimations = m(textureMap_ ,"func_94248_c" ,"()V"); - textureUtil_uploadTexture = m(textureUtil_ ,"func_110988_a","(I[III)V"); - textureUtil_uploadTextureImageAllocate = m(textureUtil_,"func_110989_a","(ILjava/awt/image/BufferedImage;ZZ)I"); - textureUtil_allocateTexture = m(textureUtil_ ,"func_110991_a","(III)V"); - textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"func_147946_a","(IIIIF)V"); - textureUtil_uploadTexSub = m(textureUtil_ ,"func_147955_a","([[IIIIIZZ)V"); - textureUtil_bindTexture = m(textureUtil_ ,"func_94277_a" ,"(I)V"); - worldClient_getCelestialAngle = m(worldClient_ ,"func_72826_c" ,"(F)F"); - worldClient_getRainStrength = m(worldClient_ ,"func_72867_j" ,"(F)F"); - - frustrum_setPosition = m(frustrum_,iCamera_setPosition); - } -} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_4.java b/java_dev/shadersmodcore/transform/Namer1_7_4.java deleted file mode 100644 index ce86cac87..000000000 --- a/java_dev/shadersmodcore/transform/Namer1_7_4.java +++ /dev/null @@ -1,191 +0,0 @@ -package shadersmodcore.transform; - -import static shadersmodcore.transform.Names.*; - -public class Namer1_7_4 extends Namer { - - public void setNames() { - setNames1_7_4(); - } - public void setNames1_7_4() { - block_ = c("ahz"); - minecraft_ = c("azi"); - guiButton_ = c("bau"); - guiOptions_ = c("bcb"); - guiScreen_ = c("bcl"); - modelRenderer_ = c("bjs"); - worldClient_ = c("bka"); - effectRenderer_ = c("blh"); - entityRenderer_ = c("bmm"); - glAllocation_ = c("azh"); - itemRenderer_ = c("bmr"); - openGlHelper_ = c("bwg"); - renderBlocks_ = c("bmf"); - renderGlobal_ = c("bmt"); - tessellator_ = c("bna"); - worldRenderer_ = c("bmh"); - frustrum_ = c("bnq"); - iCamera_ = c("bno"); - render_ = c("boh"); - renderDragon_ = c("boe"); - renderEnderman_ = c("bof"); - renderSpider_ = c("bpo"); - renderManager_ = c("bog"); - rendererLivingE_ = c("bpa"); - abstractTexture_ = c("bqi"); - dynamicTexture_ = c("bqj"); - iTextureObject_ = c("bra"); - layeredTexture_ = c("bqm"); - simpleTexture_ = c("bqn"); - stitcher_ = c("bqo"); - textureAtlasSpri_ = c("bqw"); - textureClock_ = c("bre"); - textureCompass_ = c("brf"); - textureManager_ = c("bqy"); - textureMap_ = c("bqs"); - textureUtil_ = c("brb"); - textureDownload_ = c("bqk"); - iResource_ = c("brp"); - iResourceManager_ = c("brr"); - gameSettings_ = c("bac"); - tessVertexState_ = c("bnb"); - entity_ = c("qr"); - entityLivingBase_ = c("rm"); - entityDragon_ = c("vr"); - entityEnderman_ = c("wr"); - entitySpider_ = c("xe"); - entityPlayer_ = c("xq"); - itemBlock_ = c("zy"); - itemStack_ = c("abu"); - movingObjectPos_ = c("ayn"); - resourceLocation_ = c("brq"); - vec3_ = c("ayp"); - iBlockAccess_ = c("agc"); - world_ = c("afs"); - - entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); - entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); - entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); - entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); - gameSettings_renderDistance = f(gameSettings_ ,"c","I"); - guiButton_id = f(guiButton_ ,"k","I"); - guiOptions_buttonList = f(guiOptions_ ,"n","Ljava/util/List;"); - guiOptions_width = f(guiOptions_ ,"l","I"); - guiOptions_height = f(guiOptions_ ,"m","I"); - guiOptions_mc = f(guiOptions_ ,"k",minecraft_.desc); - guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); - itemBlock_block = f(itemBlock_ ,"a",block_.desc); - itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); - layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); - minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); - minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); - modelRenderer_displayList = f(modelRenderer_ ,"u" ,null); - modelRenderer_compiled = f(modelRenderer_ ,"t" ,null); - renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,null); - renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); - rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); - rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); - renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); - renderManager_instance = f(renderManager_ , "a",renderManager_.desc); - simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); - tessellator_floatBuffer = f(tessellator_ ,"d","Ljava/nio/FloatBuffer;"); - tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); - tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); - tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); - tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); - tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); - tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); - textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); - textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); - textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); - textureMap_anisotropic = f(textureMap_ ,"k",null); - textureDownload_textureUploaded = f(textureDownload_,"i","Z"); - vec3_xCoord = f(vec3_ ,"c" ,"D"); - - abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); - block_getAoLight = m(block_ ,"I","("+iBlockAccess_.desc+"III)F"); - dynamicTexture_updateDynamicTexture= m(dynamicTexture_ ,"a","()V"); - effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); - effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); - entity_getBrightness = m(entity_ ,"d" ,"(F)F"); - entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); - entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); - entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); - entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); - entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); - entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); - entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); - entityRenderer_setupCameraTransform= m(entityRenderer_ ,"a" ,"(FI)V"); - entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); - entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); - gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); - gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); - glAllocation_createDirectByteBuffer= m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); - glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); - guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); - guiOptions_initGui = m(guiOptions_ ,"r_","()V"); - iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); - iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); - itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); - itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); - itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); - itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); - iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); - iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); - minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); - minecraft_startGame = m(minecraft_ ,"ad" ,"()V"); - openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); - render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); - renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockSandFalling= m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); - renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); - renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); - renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); - renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); - renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); - renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); - rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); - rendererLivingE_renderEquippedItems= m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); - rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); - rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); - renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); - renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); - renderGlobal_drawBlockDamageTexture= m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); - renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); - renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); - renderGlobal_clipRenderersByFrustum= m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); - renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); - renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); - stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); - tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); - tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); - tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); - tessellator_reset = m(tessellator_ ,"d" ,"()V"); - tessellator_draw = m(tessellator_ ,"a" ,"()I"); - textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"####","("+iResource_.desc+")V"); - textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); - textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); - textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); - textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); - textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); - textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); - textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); - textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); - textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); - textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); - textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); - textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); - textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); - textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); - textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); - worldClient_getCelestialAngle = m(worldClient_ ,"c" ,"(F)F"); - worldClient_getRainStrength = m(worldClient_ ,"j" ,"(F)F"); - - frustrum_setPosition = m(frustrum_,iCamera_setPosition); - } -} diff --git a/java_dev/shadersmodcore/transform/Namer1_7_5.java b/java_dev/shadersmodcore/transform/Namer1_7_5.java deleted file mode 100644 index 40e22ffb0..000000000 --- a/java_dev/shadersmodcore/transform/Namer1_7_5.java +++ /dev/null @@ -1,191 +0,0 @@ -package shadersmodcore.transform; - -import static shadersmodcore.transform.Names.*; - -public class Namer1_7_5 extends Namer { - - public void setNames() { - setNames1_7_5(); - } - public void setNames1_7_5() { - block_ = c("aif"); - minecraft_ = c("azl"); - guiButton_ = c("bax"); - guiOptions_ = c("bce"); - guiScreen_ = c("bco"); - modelRenderer_ = c("bjy"); - worldClient_ = c("bkg"); - effectRenderer_ = c("bln"); - entityRenderer_ = c("bms"); - glAllocation_ = c("azk"); - itemRenderer_ = c("bmx"); - openGlHelper_ = c("bwq"); - renderBlocks_ = c("bml"); - renderGlobal_ = c("bmz"); - tessellator_ = c("bng"); - worldRenderer_ = c("bmn"); - frustrum_ = c("bnw"); - iCamera_ = c("bnu"); - render_ = c("bon"); - renderDragon_ = c("bok"); - renderEnderman_ = c("bol"); - renderSpider_ = c("bpu"); - renderManager_ = c("bom"); - rendererLivingE_ = c("bpg"); - abstractTexture_ = c("bqo"); - dynamicTexture_ = c("bqp"); - iTextureObject_ = c("brg"); - layeredTexture_ = c("bqs"); - simpleTexture_ = c("bqt"); - stitcher_ = c("bqu"); - textureAtlasSpri_ = c("brc"); - textureClock_ = c("brk"); - textureCompass_ = c("brl"); - textureManager_ = c("bre"); - textureMap_ = c("bqy"); - textureUtil_ = c("brh"); - textureDownload_ = c("bqq"); - iResource_ = c("brv"); - iResourceManager_ = c("brx"); - gameSettings_ = c("baf"); - tessVertexState_ = c("bnh"); - entity_ = c("qx"); - entityLivingBase_ = c("rs"); - entityDragon_ = c("vx"); - entityEnderman_ = c("wx"); - entitySpider_ = c("xk"); - entityPlayer_ = c("xw"); - itemBlock_ = c("aae"); - itemStack_ = c("aca"); - movingObjectPos_ = c("ayr"); - resourceLocation_ = c("brw"); - vec3_ = c("ayt"); - iBlockAccess_ = c("agi"); - world_ = c("afy"); - - entityLivingBase_deathTime = f(entityLivingBase_,"aA","I"); - entityLivingBase_hurtTime = f(entityLivingBase_,"ax","I"); - entityRenderer_cameraZoom = f(entityRenderer_ ,"af" ,"D"); - entityRenderer_mc = f(entityRenderer_ ,"t" ,minecraft_.desc); - gameSettings_renderDistance = f(gameSettings_ ,"c","I"); - guiButton_id = f(guiButton_ ,"k","I"); - guiOptions_buttonList = f(guiOptions_ ,"n","Ljava/util/List;"); - guiOptions_width = f(guiOptions_ ,"l","I"); - guiOptions_height = f(guiOptions_ ,"m","I"); - guiOptions_mc = f(guiOptions_ ,"k",minecraft_.desc); - guiOptions_options = f(guiOptions_ ,"h",gameSettings_.desc); - itemBlock_block = f(itemBlock_ ,"a",block_.desc); - itemRenderer_itemToRender = f(itemRenderer_ ,"e",itemStack_.desc); - layeredTexture_layeredTextureNames = f(layeredTexture_,"b","Ljava/util/List;"); - minecraft_renderGlobal = f(minecraft_ ,"g" ,renderGlobal_.desc); - minecraft_gameSettings = f(minecraft_ ,"u" ,gameSettings_.desc); - modelRenderer_displayList = f(modelRenderer_ ,"u" ,null); - modelRenderer_compiled = f(modelRenderer_ ,"t" ,null); - renderGlobal_glSkyList = f(renderGlobal_ ,"G" ,null); - renderGlobal_worldRenderers = f(renderGlobal_ ,"v" ,"["+worldRenderer_.desc); - rendererLivingE_mainModel = f(rendererLivingE_ ,"i" ,null); - rendererLivingE_renderPassModel = f(rendererLivingE_,"j",null); - renderManager_entityRenderMap = f(renderManager_ ,"q" ,"Ljava/util/Map;"); - renderManager_instance = f(renderManager_ ,"a" ,renderManager_.desc); - simpleTexture_textureLocation = f(simpleTexture_ ,"b",resourceLocation_.desc); - tessellator_floatBuffer = f(tessellator_ ,"f","Ljava/nio/FloatBuffer;"); - tessellator_shortBuffer = f(tessellator_ ,"e","Ljava/nio/ShortBuffer;"); - tessellator_intBuffer = f(tessellator_ ,"c","Ljava/nio/IntBuffer;"); - tessellator_byteBuffer = f(tessellator_ ,"b" ,"Ljava/nio/ByteBuffer;"); - tessellator_rawBuffer = f(tessellator_ ,"f" ,"[I"); - tessellator_vertexCount = f(tessellator_ ,"g" ,"I"); - tessellator_hasNormals = f(tessellator_ ,"o" ,"Z"); - textureAtlasSpri_width = f(textureAtlasSpri_,"e",null); - textureAtlasSpri_height = f(textureAtlasSpri_,"f",null); - textureAtlasSpri_border = f(textureAtlasSpri_,"k",null); - textureMap_anisotropic = f(textureMap_ ,"k",null); - textureDownload_textureUploaded = f(textureDownload_,"i","Z"); - vec3_xCoord = f(vec3_ ,"a" ,"D"); - - abstractTexture_deleteGlTexture = m(abstractTexture_,"c","()V"); - block_getAoLight = m(block_ ,"I","("+iBlockAccess_.desc+"III)F"); - dynamicTexture_updateDynamicTexture = m(dynamicTexture_ ,"a","()V"); - effectRenderer_renderLitParticles = m(effectRenderer_ ,"b" ,"("+entity_.desc+"F)V"); - effectRenderer_renderParticles = m(effectRenderer_ ,"a" ,"("+entity_.desc+"F)V"); - entity_getBrightness = m(entity_ ,"d" ,"(F)F"); - entityRenderer_enableLightmap = m(entityRenderer_ ,"b" ,"(D)V"); - entityRenderer_updateFogColor = m(entityRenderer_ ,"j" ,"(F)V"); - entityRenderer_setupFog = m(entityRenderer_ ,"a" ,"(IF)V"); - entityRenderer_setFogColorBuffer = m(entityRenderer_ ,"a" ,"(FFFF)Ljava/nio/FloatBuffer;"); - entityRenderer_renderWorld = m(entityRenderer_ ,"a" ,"(FJ)V"); - entityRenderer_renderRainSnow = m(entityRenderer_ ,"e" ,"(F)V"); - entityRenderer_renderHand = m(entityRenderer_ ,"b" ,"(FI)V"); - entityRenderer_setupCameraTransform = m(entityRenderer_,"a" ,"(FI)V"); - entityRenderer_disableLightmap = m(entityRenderer_ ,"a" ,"(D)V"); - entityRenderer_renderCloudsCheck = m(entityRenderer_ ,"a" ,"("+renderGlobal_.desc+"F)V"); - gameSettings_saveOptions = m(gameSettings_ ,"b" ,"()V"); - gameSettings_shouldRenderClouds = m(gameSettings_ ,"d" ,"()Z"); - glAllocation_createDirectByteBuffer = m(glAllocation_ ,"c" ,"(I)Ljava/nio/ByteBuffer;"); - glAllocation_createDirectIntBuffer = m(glAllocation_ ,"f" ,"(I)Ljava/nio/IntBuffer;"); - guiOptions_actionPerformed = m(guiOptions_ ,"a","("+guiButton_.desc+")V"); - guiOptions_initGui = m(guiOptions_ ,"r_","()V"); - iCamera_setPosition = m(iCamera_ ,"a" ,"(DDD)V"); - iResourceManager_getResource = m(iResourceManager_,"a","("+resourceLocation_.desc+")"+iResource_.desc); - itemRenderer_renderItem = m(itemRenderer_ ,"a" ,"("+entityLivingBase_.desc+itemStack_.desc+"I)V"); - itemRenderer_renderItemInFirstPerson = m(itemRenderer_ ,"a" ,"(F)V"); - itemRenderer_renderOverlays = m(itemRenderer_ ,"b" ,"(F)V"); - itemRenderer_updateEquipped = m(itemRenderer_ ,"a" ,"()V"); - iTextureObject_loadTexture = m(iTextureObject_ ,"a","("+iResourceManager_.desc+")V"); - iTextureObject_getGlTextureId = m(iTextureObject_ ,"b","()I"); - minecraft_displayGuiScreen = m(minecraft_ ,"a","("+guiScreen_.desc+")V"); - minecraft_startGame = m(minecraft_ ,"ad" ,"()V"); - openGlHelper_setActiveTexture = m(openGlHelper_ ,"j" ,"(I)V"); - render_renderShadow = m(render_ ,"c" ,"("+entity_.desc+"DDDFF)V"); - renderBlocks_renderBlockFluids = m(renderBlocks_ ,"p","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithCM = m(renderBlocks_ ,"d","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockSandFalling = m(renderBlocks_ ,"a","("+block_.desc+world_.desc+"IIII)V"); - renderBlocks_renderStdBlockWithAO = m(renderBlocks_ ,"a","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockCactusImpl = m(renderBlocks_ ,"e","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderBlockDoor = m(renderBlocks_ ,"u","("+block_.desc+"III)Z"); - renderBlocks_renderBlockBed = m(renderBlocks_ ,"v","("+block_.desc+"III)Z"); - renderBlocks_renderBlockByRenderType = m(renderBlocks_ ,"b","("+block_.desc+"III)Z"); - renderBlocks_renderStdBlockWithAOP = m(renderBlocks_ ,"b","("+block_.desc+"IIIFFF)Z"); - renderBlocks_renderPistonExtension = m(renderBlocks_ ,"c","("+block_.desc+"IIIZ)Z"); - renderDragon_shouldRenderPass = m(renderDragon_ ,"a" , "("+entityDragon_.desc+"IF)I"); - renderEnderman_shouldRenderPass = m(renderEnderman_ ,"a" , "("+entityEnderman_.desc+"IF)I"); - renderSpider_shouldRenderPass = m(renderSpider_ ,"a" , "("+entitySpider_.desc+"IF)I"); - rendererLivingE_doRender = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDFF)V"); - rendererLivingE_renderEquippedItems = m(rendererLivingE_,"c","("+entityLivingBase_.desc+"F)V"); - rendererLivingE_getColorMultiplier = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"FF)I"); - rendererLivingE_renderLabel = m(rendererLivingE_,"a" ,"("+entityLivingBase_.desc+"DDDLjava/lang/String;FD)V"); - renderGlobal_renderEntities = m(renderGlobal_ ,"a","("+entityLivingBase_.desc+iCamera_.desc+"F)V"); - renderGlobal_renderSky = m(renderGlobal_ ,"a" ,"(F)V"); - renderGlobal_drawBlockDamageTexture = m(renderGlobal_ ,"a" ,"("+tessellator_.desc+entityPlayer_.desc+"F)V"); - renderGlobal_renderClouds = m(renderGlobal_ ,"b" ,"(F)V"); - renderGlobal_sortAndRender = m(renderGlobal_ ,"a" ,"("+entityLivingBase_.desc+"ID)I"); - renderGlobal_clipRenderersByFrustum = m(renderGlobal_ ,"a" ,"("+iCamera_.desc+"F)V"); - renderGlobal_drawSelectionBox = m(renderGlobal_ ,"a" ,"("+entityPlayer_.desc+movingObjectPos_.desc+"IF)V"); - renderGlobal_renderAllRenderLists = m(renderGlobal_ ,"a" ,"(ID)V"); - stitcher_getCurrentWidth = m(stitcher_ ,"a","()I"); - tessellator_sortQuad = m(tessellator_ ,"a","(FFF)"+tessVertexState_.desc); - tessellator_setNormal = m(tessellator_ ,"c" ,"(FFF)V"); - tessellator_addVertex = m(tessellator_ ,"a" ,"(DDD)V"); - tessellator_reset = m(tessellator_ ,"d" ,"()V"); - tessellator_draw = m(tessellator_ ,"a" ,"()I"); - textureAtlasSpri_loadSprite = m(textureAtlasSpri_,"####","("+iResource_.desc+")V"); - textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_,"a","(I)[[I"); - textureAtlasSpri_getIconName = m(textureAtlasSpri_,"g","()Ljava/lang/String;"); - textureAtlasSpri_updateAnimation = m(textureAtlasSpri_,"j","()V"); - textureCompass_updateCompass = m(textureCompass_ ,"a" ,"("+world_.desc+"DDDZZ)V"); - textureManager_onResourceManagerReload = m(textureManager_,"a","("+iResourceManager_.desc+")V"); - textureManager_bindTexture = m(textureManager_ ,"a","("+resourceLocation_.desc+")V"); - textureMap_loadTextureAtlas = m(textureMap_ ,"b","("+iResourceManager_.desc+")V"); - textureMap_getIconResLoc = m(textureMap_ ,"a","("+resourceLocation_.desc+"I)"+resourceLocation_.desc); - textureMap_updateAnimations = m(textureMap_ ,"d" ,"()V"); - textureUtil_uploadTexture = m(textureUtil_ ,"a","(I[III)V"); - textureUtil_uploadTextureImageAllocate = m(textureUtil_,"a","(ILjava/awt/image/BufferedImage;ZZ)I"); - textureUtil_allocateTexture = m(textureUtil_ ,"a","(III)V"); - textureUtil_allocateTextureMipmapAniso = m(textureUtil_,"a","(IIIIF)V"); - textureUtil_uploadTexSub = m(textureUtil_ ,"a","([[IIIIIZZ)V"); - textureUtil_bindTexture = m(textureUtil_ ,"b" ,"(I)V"); - worldClient_getCelestialAngle = m(worldClient_ ,"c" ,"(F)F"); - worldClient_getRainStrength = m(worldClient_ ,"j" ,"(F)F"); - - frustrum_setPosition = m(frustrum_,iCamera_setPosition); - } -} diff --git a/java_dev/shadersmodcore/transform/NamerMcf.java b/java_dev/shadersmodcore/transform/NamerMcf.java deleted file mode 100644 index 1266f9bf9..000000000 --- a/java_dev/shadersmodcore/transform/NamerMcf.java +++ /dev/null @@ -1,16 +0,0 @@ -package shadersmodcore.transform; - -import java.util.HashMap; -import java.util.Map; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.commons.SimpleRemapper; - -public class NamerMcf extends NamerMcp { - - public void setNames() - { - setNamesSrg(); - rename("../build/unpacked/conf/"); - } - -} diff --git a/java_dev/shadersmodcore/transform/NamerMcp.java b/java_dev/shadersmodcore/transform/NamerMcp.java deleted file mode 100644 index d830635bd..000000000 --- a/java_dev/shadersmodcore/transform/NamerMcp.java +++ /dev/null @@ -1,129 +0,0 @@ -package shadersmodcore.transform; - -import java.io.BufferedReader; -import java.io.FileNotFoundException; -import java.io.FileReader; -import java.io.IOException; -import java.util.HashMap; -import java.util.Map; -import org.objectweb.asm.commons.Remapper; -import org.objectweb.asm.commons.SimpleRemapper; - -import shadersmodcore.transform.Names.Clas; -import shadersmodcore.transform.Names.Fiel; -import shadersmodcore.transform.Names.Meth; - -public class NamerMcp extends NamerSrg { - - public void setNames() - { - setNamesSrg(); - lookupReobfName("../conf/"); - rename("../conf/"); - } - - public void rename(String confPath) - { - Map nameMap; - nameMap = loadNameMapCSV(confPath+"fields.csv"); - for (Fiel f : af) { - String s = nameMap.get(f.name); - if (s!= null) { - f.name = s; - } - } - nameMap = loadNameMapCSV(confPath+"methods.csv"); - for (Meth m : am) { - String s = nameMap.get(m.name); - if (s!= null) { - m.name = s; - } - } - } - - Map loadNameMapCSV(String fileName) - { - Map map = new HashMap(); - BufferedReader rd = null; - try { - rd = new BufferedReader(new FileReader(fileName)); - String line; - rd.readLine(); // skip first line; - while ((line = rd.readLine()) != null) { - String[] tokens = line.split(","); - if(tokens.length>1) - { - map.put(tokens[0],tokens[1]); - } - } - } catch (FileNotFoundException e) { - e.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - } finally { - if (rd != null) { - try { - rd.close(); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - return map; - } - - void lookupReobfName(String confPath) - { - Map nameMap; - nameMap = loadReobfMap(confPath+"joined.srg"); - for (Clas c : ac) { - String s = nameMap.get(c.name); - System.out.printf("C %s %s\n",c.name,s); - } - for (Fiel f : af) { - String s = nameMap.get(f.clas+"/"+f.name); - System.out.printf("F %s %s\n",f.name,s); - } - for (Meth m : am) { - String s = nameMap.get(m.clas+"/"+m.name+m.desc); - System.out.printf("M %s %s\n",m.name,s); - } - } - - - Map loadReobfMap(String fileName) - { - Map map = new HashMap(); - BufferedReader rd = null; - try { - rd = new BufferedReader(new FileReader(fileName)); - String line; - while ((line = rd.readLine()) != null) { - String[] tokens = line.split(" "); - if(tokens.length>1) - { - if ("CL:".equals(tokens[0])) { - map.put(tokens[2], tokens[1]); - } else if ("FD:".equals(tokens[0])) { - map.put(tokens[2], tokens[1]); - } else if ("MD:".equals(tokens[0])) { - map.put(tokens[3]+tokens[4], tokens[1].substring(tokens[1].lastIndexOf('/')+1)); - } - } - } - } catch (FileNotFoundException e) { - e.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - } finally { - if (rd != null) { - try { - rd.close(); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - return map; - } -} diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 000000000..09bbb514f --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,2 @@ +before_install: + - ./gradlew setupCIWorkspace \ No newline at end of file diff --git a/repositories.gradle b/repositories.gradle new file mode 100644 index 000000000..c8843905d --- /dev/null +++ b/repositories.gradle @@ -0,0 +1,5 @@ +// Add any additional repositories for your dependencies here + +repositories { + +} diff --git a/resources/META-INF/MANIFEST.MF b/resources/META-INF/MANIFEST.MF deleted file mode 100644 index f1c6f5a7d..000000000 --- a/resources/META-INF/MANIFEST.MF +++ /dev/null @@ -1,3 +0,0 @@ -Manifest-Version: 1.0 -TweakClass: shadersmodcore.loading.SMCTweaker -TweakOrder: 1100 diff --git a/resources/mcmod.info b/resources/mcmod.info deleted file mode 100644 index 4d0014b72..000000000 --- a/resources/mcmod.info +++ /dev/null @@ -1,17 +0,0 @@ -[ -{ - "modid": "shadersmod", - "name": "GLSL Shaders Mod", - "description": "Use custom GLSL shaders to render world.", - "version": "2.3.18", - "mcversion": "1.7.10", - "url": "http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1286604", - "updateUrl": "", - "authors": ["karyonix","sonic ether","id_miner","daxnitro"], - "credits": "Based on daxnitro's GLSL Shaders Mod. Updated by karyonix, id_miner, sonic ether.", - "logoFile": "", - "screenshots": [], - "parent":"", - "dependencies": [] -} -] \ No newline at end of file diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 000000000..93c852a12 --- /dev/null +++ b/settings.gradle @@ -0,0 +1,10 @@ +plugins { + id 'com.diffplug.blowdryerSetup' version '1.6.0' +} + +apply plugin: 'com.diffplug.blowdryerSetup' + +blowdryerSetup { + github('GTNewHorizons/ExampleMod1.7.10', 'tag', '0.1.5') + //devLocal '.' // Use this when testing config updates locally +} diff --git a/src/compileStubs/java/net/minecraft/client/model/ModelBase.java b/src/compileStubs/java/net/minecraft/client/model/ModelBase.java new file mode 100644 index 000000000..480e8afb4 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/model/ModelBase.java @@ -0,0 +1,7 @@ +package net.minecraft.client.model; + +import java.util.List; + +public class ModelBase { + public List boxList; +} diff --git a/src/compileStubs/java/net/minecraft/client/model/ModelRenderer.java b/src/compileStubs/java/net/minecraft/client/model/ModelRenderer.java new file mode 100644 index 000000000..855bde053 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/model/ModelRenderer.java @@ -0,0 +1,10 @@ +package net.minecraft.client.model; + +import java.util.List; + +public class ModelRenderer { + + public List childModels; + + public void resetDisplayList() {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/EntityRenderer.java b/src/compileStubs/java/net/minecraft/client/renderer/EntityRenderer.java new file mode 100644 index 000000000..48c59a9ae --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/EntityRenderer.java @@ -0,0 +1,14 @@ +package net.minecraft.client.renderer; + +public class EntityRenderer { + + public static int anaglyphField; + public static boolean anaglyphEnable; + + /** + * Render player hand + */ + public void renderHand(float p_78476_1_, int p_78476_2_) {} + + public void renderWorld(float f, long l) {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/RenderGlobal.java b/src/compileStubs/java/net/minecraft/client/renderer/RenderGlobal.java new file mode 100644 index 000000000..3ce14b167 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/RenderGlobal.java @@ -0,0 +1,8 @@ +package net.minecraft.client.renderer; + +public class RenderGlobal { + + public WorldRenderer[] worldRenderers; + + public void loadRenderers() {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/Tessellator.java b/src/compileStubs/java/net/minecraft/client/renderer/Tessellator.java new file mode 100644 index 000000000..b770cd61a --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/Tessellator.java @@ -0,0 +1,180 @@ +package net.minecraft.client.renderer; + +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.ShortBuffer; +import net.minecraft.client.shader.TesselatorVertexState; + +public class Tessellator { + private static int nativeBufferSize; + private static int trivertsInBuffer; + public static boolean renderingWorldRenderer; + public boolean defaultTexture; + private int rawBufferSize; + public int textureID; + + /** The byte buffer used for GL allocation. */ + public ByteBuffer byteBuffer; + /** The same memory as byteBuffer, but referenced as an integer buffer. */ + public IntBuffer intBuffer; + /** The same memory as byteBuffer, but referenced as an float buffer. */ + public FloatBuffer floatBuffer; + /** The same memory as byteBuffer, but referenced as an short buffer. */ + public ShortBuffer shortBuffer; + /** Raw integer array. */ + public int[] rawBuffer; + /** The number of vertices to be drawn in the next draw call. Reset to 0 between draw calls. */ + public int vertexCount; + /** The first coordinate to be used for the texture. */ + public double textureU; + /** The second coordinate to be used for the texture. */ + public double textureV; + + public int brightness; + /** The color (RGBA) value to be used for the following draw call. */ + public int color; + /** Whether the current draw object for this tessellator has color values. */ + public boolean hasColor; + /** Whether the current draw object for this tessellator has texture coordinates. */ + public boolean hasTexture; + + public boolean hasBrightness; + /** Whether the current draw object for this tessellator has normal values. */ + public boolean hasNormals; + /** The index into the raw buffer to be used for the next data. */ + public int rawBufferIndex; + /** + * The number of vertices manually added to the given draw call. This differs from vertexCount because it adds extra + * vertices when converting quads to triangles. + */ + public int addedVertices; + /** Disables all color information for the following draw call. */ + public boolean isColorDisabled; + /** The draw mode currently being used by the tessellator. */ + public int drawMode; + /** An offset to be applied along the x-axis for all vertices in this draw call. */ + public double xOffset; + /** An offset to be applied along the y-axis for all vertices in this draw call. */ + public double yOffset; + /** An offset to be applied along the z-axis for all vertices in this draw call. */ + public double zOffset; + /** The normal to be applied to the face being drawn. */ + public int normal; + /** The static instance of the Tessellator. */ + public static final Tessellator instance = new Tessellator(); + /** Whether this tessellator is currently in draw mode. */ + public boolean isDrawing; + /** The size of the buffers used (in integers). */ + public int bufferSize; + + public float midTextureU; + public float midTextureV; + public float normalX; + public float normalY; + public float normalZ; + public float[] vertexPos = new float[16]; + + private Tessellator(int p_i1250_1_) {} + + public Tessellator() {} + + /** + * Draws the data set up in this tessellator and resets the state to prepare for new drawing. + */ + public int draw() { + return 0; + } + + public TesselatorVertexState getVertexState(float p_147564_1_, float p_147564_2_, float p_147564_3_) { + return null; + } + + public void setVertexState(TesselatorVertexState p_147565_1_) {} + + /** + * Clears the tessellator state in preparation for new drawing. + */ + public void reset() {} + + /** + * Sets draw mode in the tessellator to draw quads. + */ + public void startDrawingQuads() {} + + /** + * Resets tessellator state and prepares for drawing (with the specified draw mode). + */ + public void startDrawing(int p_78371_1_) {} + + /** + * Sets the texture coordinates. + */ + public void setTextureUV(double p_78385_1_, double p_78385_3_) {} + + public void setBrightness(int p_78380_1_) {} + + /** + * Sets the RGB values as specified, converting from floats between 0 and 1 to integers from 0-255. + */ + public void setColorOpaque_F(float p_78386_1_, float p_78386_2_, float p_78386_3_) {} + + /** + * Sets the RGBA values for the color, converting from floats between 0 and 1 to integers from 0-255. + */ + public void setColorRGBA_F(float p_78369_1_, float p_78369_2_, float p_78369_3_, float p_78369_4_) {} + + /** + * Sets the RGB values as specified, and sets alpha to opaque. + */ + public void setColorOpaque(int p_78376_1_, int p_78376_2_, int p_78376_3_) {} + + /** + * Sets the RGBA values for the color. Also clamps them to 0-255. + */ + public void setColorRGBA(int p_78370_1_, int p_78370_2_, int p_78370_3_, int p_78370_4_) {} + + public void func_154352_a(byte p_154352_1_, byte p_154352_2_, byte p_154352_3_) {} + + /** + * Adds a vertex specifying both x,y,z and the texture u,v for it. + */ + public void addVertexWithUV( + double p_78374_1_, double p_78374_3_, double p_78374_5_, double p_78374_7_, double p_78374_9_) {} + + /** + * Adds a vertex with the specified x,y,z to the current draw call. It will trigger a draw() if the buffer gets + * full. + */ + public void addVertex(double p_78377_1_, double p_78377_3_, double p_78377_5_) {} + + /** + * Sets the color to the given opaque value (stored as byte values packed in an integer). + */ + public void setColorOpaque_I(int p_78378_1_) {} + + /** + * Sets the color to the given color (packed as bytes in integer) and alpha values. + */ + public void setColorRGBA_I(int p_78384_1_, int p_78384_2_) {} + + /** + * Disables colors for the current draw call. + */ + public void disableColor() {} + + /** + * Sets the normal for the current draw call. + */ + public void setNormal(float p_78375_1_, float p_78375_2_, float p_78375_3_) {} + + /** + * Sets the translation for all vertices in the current draw call. + */ + public void setTranslation(double p_78373_1_, double p_78373_3_, double p_78373_5_) {} + + /** + * Offsets the translation for all vertices in the current draw call. + */ + public void addTranslation(float p_78372_1_, float p_78372_2_, float p_78372_3_) {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/WorldRenderer.java b/src/compileStubs/java/net/minecraft/client/renderer/WorldRenderer.java new file mode 100644 index 000000000..7bcc5cb4c --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/WorldRenderer.java @@ -0,0 +1,13 @@ +package net.minecraft.client.renderer; + +import net.minecraft.client.renderer.culling.ICamera; + +public class WorldRenderer { + public boolean isInFrustum; + + public boolean skipAllRenderPasses() { + return false; + } + + public void updateInFrustum(ICamera frustrum) {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/culling/Frustrum.java b/src/compileStubs/java/net/minecraft/client/renderer/culling/Frustrum.java new file mode 100644 index 000000000..1c7c3bb5d --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/culling/Frustrum.java @@ -0,0 +1,6 @@ +package net.minecraft.client.renderer.culling; + +public class Frustrum implements ICamera { + + public void setPosition(double x, double y, double z) {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/culling/ICamera.java b/src/compileStubs/java/net/minecraft/client/renderer/culling/ICamera.java new file mode 100644 index 000000000..98743f36e --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/culling/ICamera.java @@ -0,0 +1,3 @@ +package net.minecraft.client.renderer.culling; + +public interface ICamera {} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/entity/Render.java b/src/compileStubs/java/net/minecraft/client/renderer/entity/Render.java new file mode 100644 index 000000000..eea0a974d --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/entity/Render.java @@ -0,0 +1,3 @@ +package net.minecraft.client.renderer.entity; + +public abstract class Render {} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/entity/RendererLivingEntity.java b/src/compileStubs/java/net/minecraft/client/renderer/entity/RendererLivingEntity.java new file mode 100644 index 000000000..6eebbba3a --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/entity/RendererLivingEntity.java @@ -0,0 +1,10 @@ +package net.minecraft.client.renderer.entity; + +import net.minecraft.client.model.ModelBase; + +public abstract class RendererLivingEntity extends Render { + + public ModelBase mainModel; + /** The model to be used during the render passes. */ + public ModelBase renderPassModel; +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/texture/AbstractTexture.java b/src/compileStubs/java/net/minecraft/client/renderer/texture/AbstractTexture.java new file mode 100644 index 000000000..0ae4a91d5 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/texture/AbstractTexture.java @@ -0,0 +1,17 @@ +package net.minecraft.client.renderer.texture; + +import com.gtnewhorizons.angelica.client.MultiTexID; + +public abstract class AbstractTexture implements ITextureObject { + + public int glTextureId = -1; + public MultiTexID multiTex; + + public int getGlTextureId() { + return 0; + } + + public MultiTexID getMultiTexID() { + return null; + } +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/texture/DynamicTexture.java b/src/compileStubs/java/net/minecraft/client/renderer/texture/DynamicTexture.java new file mode 100644 index 000000000..7353916e7 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/texture/DynamicTexture.java @@ -0,0 +1,13 @@ +package net.minecraft.client.renderer.texture; + +public class DynamicTexture extends AbstractTexture { + public DynamicTexture(int i, int i1) { + super(); + } + + public int[] getTextureData() { + return null; + } + + public void updateDynamicTexture() {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/texture/ITextureObject.java b/src/compileStubs/java/net/minecraft/client/renderer/texture/ITextureObject.java new file mode 100644 index 000000000..7553c634f --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/texture/ITextureObject.java @@ -0,0 +1,10 @@ +package net.minecraft.client.renderer.texture; + +import com.gtnewhorizons.angelica.client.MultiTexID; + +public interface ITextureObject { + + MultiTexID getMultiTexID(); + + int getGlTextureId(); +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureAtlasSprite.java b/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureAtlasSprite.java new file mode 100644 index 000000000..b9fa17b36 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureAtlasSprite.java @@ -0,0 +1,8 @@ +package net.minecraft.client.renderer.texture; + +public class TextureAtlasSprite { + + public boolean useAnisotropicFiltering; + + public void updateAnimation() {} +} diff --git a/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureMap.java b/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureMap.java new file mode 100644 index 000000000..1413c8129 --- /dev/null +++ b/src/compileStubs/java/net/minecraft/client/renderer/texture/TextureMap.java @@ -0,0 +1,18 @@ +package net.minecraft.client.renderer.texture; + +import net.minecraft.util.ResourceLocation; + +public class TextureMap extends AbstractTexture { + + public static ResourceLocation locationBlocksTexture; + public int atlasWidth; + public int atlasHeight; + + public int getTextureType() { + return 0; + } + + public ResourceLocation completeResourceLocation(ResourceLocation resourceLocation, int i) { + return null; + } +} diff --git a/src/compileStubsStubs/README.MD b/src/compileStubsStubs/README.MD new file mode 100644 index 000000000..41a7b63cf --- /dev/null +++ b/src/compileStubsStubs/README.MD @@ -0,0 +1 @@ +Stubs for the compile stubs diff --git a/src/compileStubsStubs/java/com/gtnewhorizons/angelica/client/MultiTexID.java b/src/compileStubsStubs/java/com/gtnewhorizons/angelica/client/MultiTexID.java new file mode 100644 index 000000000..9c937b516 --- /dev/null +++ b/src/compileStubsStubs/java/com/gtnewhorizons/angelica/client/MultiTexID.java @@ -0,0 +1,3 @@ +package com.gtnewhorizons.angelica.client; + +public class MultiTexID {} diff --git a/src/compileStubsStubs/java/net/minecraft/client/shader/TesselatorVertexState.java b/src/compileStubsStubs/java/net/minecraft/client/shader/TesselatorVertexState.java new file mode 100644 index 000000000..a046460da --- /dev/null +++ b/src/compileStubsStubs/java/net/minecraft/client/shader/TesselatorVertexState.java @@ -0,0 +1,3 @@ +package net.minecraft.client.shader; + +public class TesselatorVertexState {} diff --git a/src/compileStubsStubs/java/net/minecraft/util/ResourceLocation.java b/src/compileStubsStubs/java/net/minecraft/util/ResourceLocation.java new file mode 100644 index 000000000..129e7bbf5 --- /dev/null +++ b/src/compileStubsStubs/java/net/minecraft/util/ResourceLocation.java @@ -0,0 +1,3 @@ +package net.minecraft.util; + +public class ResourceLocation {} diff --git a/src/main/java/com/gtnewhorizons/angelica/Tags.java b/src/main/java/com/gtnewhorizons/angelica/Tags.java new file mode 100644 index 000000000..ef804e511 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/Tags.java @@ -0,0 +1,12 @@ +package com.gtnewhorizons.angelica; + +// Use this class for Strings only. Do not import any classes here. It will lead to issues with Mixins if in use! + +public class Tags { + + // GRADLETOKEN_* will be replaced by your configuration values at build time + public static final String MODID = "GRADLETOKEN_MODID"; + public static final String MODNAME = "GRADLETOKEN_MODNAME"; + public static final String VERSION = "GRADLETOKEN_VERSION"; + public static final String GROUPNAME = "GRADLETOKEN_GROUPNAME"; +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/DefaultTexture.java b/src/main/java/com/gtnewhorizons/angelica/client/DefaultTexture.java new file mode 100644 index 000000000..866c377c3 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/DefaultTexture.java @@ -0,0 +1,16 @@ +package com.gtnewhorizons.angelica.client; + +import net.minecraft.client.renderer.texture.AbstractTexture; +import net.minecraft.client.resources.IResourceManager; + +public class DefaultTexture extends AbstractTexture { + + public DefaultTexture() { + loadTexture(null); + } + + public void loadTexture(IResourceManager resourcemanager) { + int[] aint = ShadersTex.createAIntImage(1, 0xFFFFFFFF); + ShadersTex.setupTexture(this.getMultiTexID(), aint, 1, 1, false, false); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/GuiShaders.java b/src/main/java/com/gtnewhorizons/angelica/client/GuiShaders.java new file mode 100644 index 000000000..d4d519b72 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/GuiShaders.java @@ -0,0 +1,354 @@ +package com.gtnewhorizons.angelica.client; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.util.List; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.settings.GameSettings; +import org.lwjgl.Sys; + +public class GuiShaders extends GuiScreen { + /** This GUI's parent GUI. */ + protected GuiScreen parentGui; + + private int updateTimer = -1; + public boolean needReinit; + + /* + private class GuiListShaderpacks { + int posX,posY,sizeX,sizeY; + int viewPosY; + int itemHeight = 20; + int selection; + ArrayList listShaderpacks; + public void draw() { + Tessellator tess = Tessellator.instance; + int listSize = listShaderpacks.size(); + int i,j; + for (i=viewPosY/itemHeight, j=Math.min((viewPosY+sizeY)/itemHeight,listSize); i= 0 && val <= choices[i]; --i) {} + if (i < 0) i = choices.length - 1; + } + Shaders.configHandDepthMul = choices[i]; + par1GuiButton.displayString = "HandDepth: " + String.format("%.4f", Shaders.configHandDepthMul); + break; + } + + case 15: /* Render Resolution Multiplier */ { + float val = Shaders.configRenderResMul; + float[] choices = {0.25f, 0.3333333333f, 0.5f, 0.7071067812f, 1.0f, 1.414213562f, 2.0f}; + int i; + if (!isShiftKeyDown()) { + for (i = 0; i < choices.length && choices[i] <= val; ++i) {} + if (i == choices.length) i = 0; + } else { + for (i = choices.length - 1; i >= 0 && val <= choices[i]; --i) {} + if (i < 0) i = choices.length - 1; + } + Shaders.configRenderResMul = choices[i]; + par1GuiButton.displayString = "RenderResMul: " + String.format("%.4f", Shaders.configRenderResMul); + Shaders.scheduleResize(); + break; + } + + case 16: /* Shadow Resolution Multiplier */ { + float val = Shaders.configShadowResMul; + float[] choices = {0.25f, 0.3333333333f, 0.5f, 0.7071067812f, 1.0f, 1.414213562f, 2.0f, 3.0f, 4.0f}; + int i; + if (!isShiftKeyDown()) { + for (i = 0; i < choices.length && choices[i] <= val; ++i) {} + if (i == choices.length) i = 0; + } else { + for (i = choices.length - 1; i >= 0 && val <= choices[i]; --i) {} + if (i < 0) i = choices.length - 1; + } + Shaders.configShadowResMul = choices[i]; + par1GuiButton.displayString = "ShadowResMul: " + String.format("%.4f", Shaders.configShadowResMul); + Shaders.scheduleResizeShadow(); + break; + } + + case 17: /* Normal Map */ { + Shaders.configNormalMap = !Shaders.configNormalMap; + // displayString + par1GuiButton.displayString = "NormapMap: " + toStringOnOff(Shaders.configNormalMap); + mc.scheduleResourcesRefresh(); // schedule refresh texture + break; + } + + case 18: /* Normal Map */ { + Shaders.configSpecularMap = !Shaders.configSpecularMap; + // displayString + par1GuiButton.displayString = "SpecularMap: " + toStringOnOff(Shaders.configSpecularMap); + mc.scheduleResourcesRefresh(); // schedule refresh texture + break; + } + + case 19: /* old Lighting */ { + Shaders.configOldLighting = !Shaders.configOldLighting; + // displayString + par1GuiButton.displayString = "OldLighting: " + toStringOnOff(Shaders.configOldLighting); + Shaders.updateBlockLightLevel(); + mc.renderGlobal.loadRenderers(); + break; + } + + case 11: /* texture filter */ { + Shaders.configTexMinFilB = (Shaders.configTexMinFilB + 1) % Shaders.texMinFilRange; + Shaders.configTexMinFilN = Shaders.configTexMinFilS = Shaders.configTexMinFilB; + par1GuiButton.displayString = "Tex Min: " + Shaders.texMinFilDesc[Shaders.configTexMinFilB]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 12: /* texture filter */ { + Shaders.configTexMagFilN = (Shaders.configTexMagFilN + 1) % Shaders.texMagFilRange; + par1GuiButton.displayString = "Tex_n Mag: " + Shaders.texMagFilDesc[Shaders.configTexMagFilN]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 13: /* texture filter */ { + Shaders.configTexMagFilS = (Shaders.configTexMagFilS + 1) % Shaders.texMagFilRange; + par1GuiButton.displayString = "Tex_s Mag: " + Shaders.texMagFilDesc[Shaders.configTexMagFilS]; + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 14: /* shadow frustum clipping */ { + Shaders.configShadowClipFrustrum = !Shaders.configShadowClipFrustrum; + par1GuiButton.displayString = + "ShadowClipFrustrum: " + toStringOnOff(Shaders.configShadowClipFrustrum); + ShadersTex.updateTextureMinMagFilter(); + break; + } + + case 5: /* Open shaderpacks folder */ + switch (net.minecraft.util.Util.getOSType()) { + case OSX: + { + try { + Runtime.getRuntime().exec(new String[] { + "/usr/bin/open", Shaders.shaderpacksdir.getAbsolutePath() + }); + return; + } catch (IOException var7) { + var7.printStackTrace(); + } + } + break; + case WINDOWS: + { + String var2 = String.format( + "cmd.exe /C start \"Open file\" \"%s\"", + new Object[] {Shaders.shaderpacksdir.getAbsolutePath()}); + + try { + Runtime.getRuntime().exec(var2); + return; + } catch (IOException var6) { + var6.printStackTrace(); + } + } + break; + default: + break; + } + boolean var8 = false; + + try { + Class var3 = Class.forName("java.awt.Desktop"); + Object var4 = var3.getMethod("getDesktop", new Class[0]).invoke((Object) null, new Object[0]); + var3.getMethod("browse", new Class[] {URI.class}) + .invoke(var4, new Object[] {(new File(mc.mcDataDir, Shaders.shaderpacksdirname)).toURI() + }); + } catch (Throwable var5) { + var5.printStackTrace(); + var8 = true; + } + + if (var8) { + System.out.println("Opening via system class!"); + Sys.openURL("file://" + Shaders.shaderpacksdir.getAbsolutePath()); + } + break; + + case 6: /* Done */ + File confshader = new File(Shaders.shadersdir, "current.cfg"); + try { + Shaders.storeConfig(); + } catch (Exception ex) { + } + if (needReinit) { + needReinit = false; + Shaders.loadShaderPack(); + Shaders.uninit(); + this.mc.renderGlobal.loadRenderers(); + } + this.mc.displayGuiScreen(this.parentGui); // displayGuiScreen + break; + + default: + this.shaderList.actionPerformed(par1GuiButton); // actionPerformed + } + } + } + + @Override + /** + * Draws the screen and all the components in it. + */ + public void drawScreen(int par1, int par2, float par3) { + drawDefaultBackground(); // background + this.shaderList.drawScreen(par1, par2, par3); // drawScreen + + if (this.updateTimer <= 0) { + this.shaderList.updateList(); + this.updateTimer += 20; + } + + this.drawCenteredString(this.fontRendererObj, "Shaders ", this.width / 2, 16, 0xffffff); + this.drawCenteredString(this.fontRendererObj, " v" + Shaders.versionString, this.width - 40, 10, 0x808080); + // this.drawCenteredString(this.fontRenderer, "( Place zipped Shader files here. )", this.width / 4 + 10, + // this.height - 26, 0x808080); + super.drawScreen(par1, par2, par3); + } + + @Override + /** + * Called from the main game loop to update the screen. + */ + public void updateScreen() { + super.updateScreen(); + --this.updateTimer; + } + + public Minecraft getMc() { + return this.mc; + } + + public void drawCenteredString(String par1, int par2, int par3, int par4) { + this.drawCenteredString(this.fontRendererObj, par1, par2, par3, par4); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/GuiSlotShaders.java b/src/main/java/com/gtnewhorizons/angelica/client/GuiSlotShaders.java new file mode 100644 index 000000000..2e948278e --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/GuiSlotShaders.java @@ -0,0 +1,75 @@ +package com.gtnewhorizons.angelica.client; + +import java.util.ArrayList; +import net.minecraft.client.gui.GuiSlot; +import net.minecraft.client.renderer.Tessellator; + +class GuiSlotShaders extends GuiSlot { + private ArrayList shaderslist; + + final GuiShaders shadersGui; + + public GuiSlotShaders(GuiShaders par1GuiShaders) { + // super(par1GuiShaders.getMc(), par1GuiShaders.width / 2 + 20, par1GuiShaders.height, 40, par1GuiShaders.height + // - 70, 16); + super( + par1GuiShaders.getMc(), + par1GuiShaders.width / 2 + 20, + par1GuiShaders.height, + 40, + par1GuiShaders.height - 70, + 16); + this.shadersGui = par1GuiShaders; + this.shaderslist = Shaders.listofShaders(); + } + + public void updateList() { + this.shaderslist = Shaders.listofShaders(); + } + + @Override + /** getSize */ + protected int getSize() { + return this.shaderslist.size(); + } + + @Override + /** elementClicked */ + protected void elementClicked(int par1, boolean par2, int par3, int par4) { + Shaders.setShaderPack((String) shaderslist.get(par1)); + shadersGui.needReinit = false; + Shaders.loadShaderPack(); + Shaders.uninit(); + } + + @Override + /** isSelected */ + protected boolean isSelected(int par1) { + return ((String) this.shaderslist.get(par1)).equals(Shaders.currentshadername); + } + + @Override + /** getScrollBarX */ + protected int getScrollBarX() { + return this.width - 6; + } + + @Override + /** getContentHeight */ + protected int getContentHeight() { + return this.getSize() * 18; + } + + @Override + /** drawBackground */ + protected void drawBackground() { + // this.shadersGui.drawDefaultBackground(); + } + + @Override + /** drawSlot */ + protected void drawSlot(int par1, int par2, int par3, int par4, Tessellator par5, int par6, int par7) { + this.shadersGui.drawCenteredString( + (String) this.shaderslist.get(par1), this.shadersGui.width / 4 + 10, par3 + 1, 0xffffff); + } +} diff --git a/java/shadersmodcore/client/HFNoiseTexture.java b/src/main/java/com/gtnewhorizons/angelica/client/HFNoiseTexture.java similarity index 52% rename from java/shadersmodcore/client/HFNoiseTexture.java rename to src/main/java/com/gtnewhorizons/angelica/client/HFNoiseTexture.java index 4f4a4efe9..2b7061180 100644 --- a/java/shadersmodcore/client/HFNoiseTexture.java +++ b/src/main/java/com/gtnewhorizons/angelica/client/HFNoiseTexture.java @@ -1,80 +1,76 @@ -package shadersmodcore.client; - -import java.nio.ByteBuffer; -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL13; -import org.lwjgl.opengl.GL30; - -/** - * - * @author Nathanael Lane - */ -public class HFNoiseTexture { - public int texID; - public int textureUnit; - - public HFNoiseTexture(int width, int height){ - texID = GL11.glGenTextures(); - textureUnit = 15; - - byte[] image = genHFNoiseImage(width, height); - ByteBuffer data = BufferUtils.createByteBuffer(image.length); - data.put(image); - data.flip(); - - //GL13.glActiveTexture(GL13.GL_TEXTURE0 + this.textureUnit); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); - GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, width, height, 0, - GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, data); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); - GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); - //GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); - GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); - } - - public int getID(){ - return texID; - } - - public void destroy(){ - GL11.glDeleteTextures(texID); - texID = 0; - } - - - //from George Marsaglia's paper on XORshift PRNGs - private int random(int seed){ - seed ^= (seed << 13); - seed ^= (seed >> 17); - seed ^= (seed << 5); - return seed; - } - - private byte random(int x, int y, int z){ - int seed = (random(x) + random(y * 19)) * random(z * 23) - z; - return (byte) (random(seed) % 128); - } - - /* - * Just a random value for each pixel to get maximum frequency - */ - private byte[] genHFNoiseImage(int width, int height){ - - byte[] image = new byte[width * height * 3]; - int index = 0; - - for(int y = 0; y < height; y++){ - for(int x = 0; x < width; x++){ - for(int z = 1; z < 4; z++){ - image[index++] = random(x, y, z); - } - } - } - - return image; - } - -} +package com.gtnewhorizons.angelica.client; + +import java.nio.ByteBuffer; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; + +/** + * + * @author Nathanael Lane + */ +public class HFNoiseTexture { + public int texID; + public int textureUnit; + + public HFNoiseTexture(int width, int height) { + texID = GL11.glGenTextures(); + textureUnit = 15; + + byte[] image = genHFNoiseImage(width, height); + ByteBuffer data = BufferUtils.createByteBuffer(image.length); + data.put(image); + data.flip(); + + // GL13.glActiveTexture(GL13.GL_TEXTURE0 + this.textureUnit); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); + GL11.glTexImage2D( + GL11.GL_TEXTURE_2D, 0, GL11.GL_RGB, width, height, 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, data); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); + // GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); + } + + public int getID() { + return texID; + } + + public void destroy() { + GL11.glDeleteTextures(texID); + texID = 0; + } + + // from George Marsaglia's paper on XORshift PRNGs + private int random(int seed) { + seed ^= (seed << 13); + seed ^= (seed >> 17); + seed ^= (seed << 5); + return seed; + } + + private byte random(int x, int y, int z) { + int seed = (random(x) + random(y * 19)) * random(z * 23) - z; + return (byte) (random(seed) % 128); + } + + /* + * Just a random value for each pixel to get maximum frequency + */ + private byte[] genHFNoiseImage(int width, int height) { + + byte[] image = new byte[width * height * 3]; + int index = 0; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + for (int z = 1; z < 4; z++) { + image[index++] = random(x, y, z); + } + } + } + + return image; + } +} diff --git a/java/shadersmodcore/client/IShaderPack.java b/src/main/java/com/gtnewhorizons/angelica/client/IShaderPack.java similarity index 71% rename from java/shadersmodcore/client/IShaderPack.java rename to src/main/java/com/gtnewhorizons/angelica/client/IShaderPack.java index 32bbddcdd..3b9979e0b 100644 --- a/java/shadersmodcore/client/IShaderPack.java +++ b/src/main/java/com/gtnewhorizons/angelica/client/IShaderPack.java @@ -1,11 +1,10 @@ -package shadersmodcore.client; - -import java.io.InputStream; - -public interface IShaderPack { - - void close(); - - InputStream getResourceAsStream(String resName); - -} +package com.gtnewhorizons.angelica.client; + +import java.io.InputStream; + +public interface IShaderPack { + + void close(); + + InputStream getResourceAsStream(String resName); +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/MultiTexID.java b/src/main/java/com/gtnewhorizons/angelica/client/MultiTexID.java new file mode 100644 index 000000000..5049cbfac --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/MultiTexID.java @@ -0,0 +1,13 @@ +package com.gtnewhorizons.angelica.client; + +public class MultiTexID { + public int base; + public int norm; + public int spec; + + public MultiTexID(int baseTex, int normTex, int specTex) { + base = baseTex; + norm = normTex; + spec = specTex; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackDefault.java b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackDefault.java new file mode 100644 index 000000000..e407d4c9f --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackDefault.java @@ -0,0 +1,16 @@ +package com.gtnewhorizons.angelica.client; + +import java.io.InputStream; + +public class ShaderPackDefault implements IShaderPack { + + public ShaderPackDefault() {} + + @Override + public void close() {} + + @Override + public InputStream getResourceAsStream(String resName) { + return ShaderPackDefault.class.getResourceAsStream(resName); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackFolder.java b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackFolder.java new file mode 100644 index 000000000..1ab3f1f0a --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackFolder.java @@ -0,0 +1,30 @@ +package com.gtnewhorizons.angelica.client; + +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; + +public class ShaderPackFolder implements IShaderPack { + + protected File packFile; + + public ShaderPackFolder(String name, File file) { + packFile = file; + } + + @Override + public void close() {} + + @Override + public InputStream getResourceAsStream(String resName) { + try { + File resFile = new File(packFile, resName.substring(1)); + if (resFile != null) { + return new BufferedInputStream(new FileInputStream(resFile)); + } + } catch (Exception excp) { + } + return null; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackNone.java b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackNone.java new file mode 100644 index 000000000..552bb1606 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackNone.java @@ -0,0 +1,16 @@ +package com.gtnewhorizons.angelica.client; + +import java.io.InputStream; + +public class ShaderPackNone implements IShaderPack { + + public ShaderPackNone() {} + + @Override + public void close() {} + + @Override + public InputStream getResourceAsStream(String resName) { + return null; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackZip.java b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackZip.java new file mode 100644 index 000000000..4709cd9cb --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShaderPackZip.java @@ -0,0 +1,48 @@ +package com.gtnewhorizons.angelica.client; + +import java.io.File; +import java.io.InputStream; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +public class ShaderPackZip implements IShaderPack { + + protected File packFile; + protected ZipFile packZipFile; + + public ShaderPackZip(String name, File file) { + packFile = file; + packZipFile = null; + } + + @Override + public void close() { + if (packZipFile != null) { + try { + packZipFile.close(); + } catch (Exception excp) { + } + packZipFile = null; + } + } + + @Override + public InputStream getResourceAsStream(String resName) { + if (packZipFile == null) { + try { + packZipFile = new ZipFile(packFile); + } catch (Exception excp) { + } + } + if (packZipFile != null) { + try { + ZipEntry entry = packZipFile.getEntry(resName.substring(1)); + if (entry != null) { + return packZipFile.getInputStream(entry); + } + } catch (Exception excp) { + } + } + return null; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/Shaders.java b/src/main/java/com/gtnewhorizons/angelica/client/Shaders.java new file mode 100644 index 000000000..cfdb43f9b --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/Shaders.java @@ -0,0 +1,3925 @@ +// Code written by daxnitro modified by id_miner and karyonix. +// Do what you want with it but give us some credit if you use it in whole or in part. + +package com.gtnewhorizons.angelica.client; + +import static org.lwjgl.opengl.ARBFragmentShader.GL_FRAGMENT_SHADER_ARB; +import static org.lwjgl.opengl.ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB; +import static org.lwjgl.opengl.ARBShaderObjects.glAttachObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCompileShaderARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCreateProgramObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glCreateShaderObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glDeleteObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glDetachObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetInfoLogARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetObjectParameterARB; +import static org.lwjgl.opengl.ARBShaderObjects.glGetUniformLocationARB; +import static org.lwjgl.opengl.ARBShaderObjects.glLinkProgramARB; +import static org.lwjgl.opengl.ARBShaderObjects.glShaderSourceARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform1fARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform1iARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform2iARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniform3fARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUniformMatrix4ARB; +import static org.lwjgl.opengl.ARBShaderObjects.glUseProgramObjectARB; +import static org.lwjgl.opengl.ARBShaderObjects.glValidateProgramARB; +import static org.lwjgl.opengl.ARBVertexShader.GL_VERTEX_SHADER_ARB; +import static org.lwjgl.opengl.ARBVertexShader.glBindAttribLocationARB; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_INVALID_FRAMEBUFFER_OPERATION_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.GL_MAX_COLOR_ATTACHMENTS_EXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glBindFramebufferEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glCheckFramebufferStatusEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glDeleteFramebuffersEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glFramebufferTexture2DEXT; +import static org.lwjgl.opengl.EXTFramebufferObject.glGenFramebuffersEXT; +import static org.lwjgl.opengl.GL11.GL_ALPHA_TEST; +import static org.lwjgl.opengl.GL11.GL_ALWAYS; +import static org.lwjgl.opengl.GL11.GL_BLEND; +import static org.lwjgl.opengl.GL11.GL_CLAMP; +import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_COMPONENT; +import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST; +import static org.lwjgl.opengl.GL11.GL_FOG; +import static org.lwjgl.opengl.GL11.GL_LEQUAL; +import static org.lwjgl.opengl.GL11.GL_LINEAR; +import static org.lwjgl.opengl.GL11.GL_LINEAR_MIPMAP_LINEAR; +import static org.lwjgl.opengl.GL11.GL_LUMINANCE; +import static org.lwjgl.opengl.GL11.GL_MODELVIEW; +import static org.lwjgl.opengl.GL11.GL_MODELVIEW_MATRIX; +import static org.lwjgl.opengl.GL11.GL_NEAREST; +import static org.lwjgl.opengl.GL11.GL_NEAREST_MIPMAP_NEAREST; +import static org.lwjgl.opengl.GL11.GL_NONE; +import static org.lwjgl.opengl.GL11.GL_NO_ERROR; +import static org.lwjgl.opengl.GL11.GL_PROJECTION; +import static org.lwjgl.opengl.GL11.GL_PROJECTION_MATRIX; +import static org.lwjgl.opengl.GL11.GL_QUADS; +import static org.lwjgl.opengl.GL11.GL_RGB16; +import static org.lwjgl.opengl.GL11.GL_RGB8; +import static org.lwjgl.opengl.GL11.GL_RGBA; +import static org.lwjgl.opengl.GL11.GL_RGBA16; +import static org.lwjgl.opengl.GL11.GL_RGBA8; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_S; +import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_T; +import static org.lwjgl.opengl.GL11.GL_TRUE; +import static org.lwjgl.opengl.GL11.glBegin; +import static org.lwjgl.opengl.GL11.glBindTexture; +import static org.lwjgl.opengl.GL11.glClear; +import static org.lwjgl.opengl.GL11.glClearColor; +import static org.lwjgl.opengl.GL11.glColor4f; +import static org.lwjgl.opengl.GL11.glColorMask; +import static org.lwjgl.opengl.GL11.glCopyTexSubImage2D; +import static org.lwjgl.opengl.GL11.glDeleteTextures; +import static org.lwjgl.opengl.GL11.glDepthFunc; +import static org.lwjgl.opengl.GL11.glDepthMask; +import static org.lwjgl.opengl.GL11.glDisable; +import static org.lwjgl.opengl.GL11.glEnable; +import static org.lwjgl.opengl.GL11.glEnd; +import static org.lwjgl.opengl.GL11.glFlush; +import static org.lwjgl.opengl.GL11.glGenTextures; +import static org.lwjgl.opengl.GL11.glGetError; +import static org.lwjgl.opengl.GL11.glGetFloat; +import static org.lwjgl.opengl.GL11.glGetInteger; +import static org.lwjgl.opengl.GL11.glLoadIdentity; +import static org.lwjgl.opengl.GL11.glMatrixMode; +import static org.lwjgl.opengl.GL11.glOrtho; +import static org.lwjgl.opengl.GL11.glPopMatrix; +import static org.lwjgl.opengl.GL11.glPushMatrix; +import static org.lwjgl.opengl.GL11.glReadBuffer; +import static org.lwjgl.opengl.GL11.glReadPixels; +import static org.lwjgl.opengl.GL11.glRotatef; +import static org.lwjgl.opengl.GL11.glTexCoord2f; +import static org.lwjgl.opengl.GL11.glTexImage2D; +import static org.lwjgl.opengl.GL11.glTexParameterf; +import static org.lwjgl.opengl.GL11.glTexParameteri; +import static org.lwjgl.opengl.GL11.glTranslatef; +import static org.lwjgl.opengl.GL11.glVertex3f; +import static org.lwjgl.opengl.GL11.glViewport; +import static org.lwjgl.opengl.GL13.GL_TEXTURE0; +import static org.lwjgl.opengl.GL13.GL_TEXTURE1; +import static org.lwjgl.opengl.GL13.GL_TEXTURE11; +import static org.lwjgl.opengl.GL13.GL_TEXTURE12; +import static org.lwjgl.opengl.GL13.GL_TEXTURE13; +import static org.lwjgl.opengl.GL13.GL_TEXTURE14; +import static org.lwjgl.opengl.GL13.GL_TEXTURE2; +import static org.lwjgl.opengl.GL13.GL_TEXTURE3; +import static org.lwjgl.opengl.GL13.GL_TEXTURE4; +import static org.lwjgl.opengl.GL13.GL_TEXTURE5; +import static org.lwjgl.opengl.GL13.GL_TEXTURE6; +import static org.lwjgl.opengl.GL13.GL_TEXTURE7; +import static org.lwjgl.opengl.GL13.glActiveTexture; +import static org.lwjgl.opengl.GL14.GL_DEPTH_TEXTURE_MODE; +import static org.lwjgl.opengl.GL14.GL_TEXTURE_COMPARE_MODE; +import static org.lwjgl.opengl.GL20.GL_MAX_DRAW_BUFFERS; +import static org.lwjgl.opengl.GL20.GL_MAX_TEXTURE_IMAGE_UNITS; +import static org.lwjgl.opengl.GL20.GL_VALIDATE_STATUS; +import static org.lwjgl.opengl.GL20.glDrawBuffers; +import static org.lwjgl.opengl.GL20.glGetProgrami; +import static org.lwjgl.opengl.GL30.GL_COMPARE_REF_TO_TEXTURE; +import static org.lwjgl.opengl.GL30.GL_R16; +import static org.lwjgl.opengl.GL30.GL_R32F; +import static org.lwjgl.opengl.GL30.GL_R8; +import static org.lwjgl.opengl.GL30.GL_RG16; +import static org.lwjgl.opengl.GL30.GL_RG32F; +import static org.lwjgl.opengl.GL30.GL_RG8; +import static org.lwjgl.opengl.GL30.GL_RGB32F; +import static org.lwjgl.opengl.GL30.GL_RGBA32F; +import static org.lwjgl.opengl.GL30.glGenerateMipmap; +import static org.lwjgl.util.glu.GLU.gluErrorString; +import static org.lwjgl.util.glu.GLU.gluPerspective; + +import java.io.*; +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Properties; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.Minecraft; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.Render; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.client.renderer.entity.RendererLivingEntity; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.settings.GameSettings; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.Vec3; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.ContextCapabilities; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GLContext; +// import org.lwjgl.opengl.ARBVertexProgram; + +public class Shaders { + + public static final String versionString = "2.3.18"; + public static final int versionNumber = 0x020312; + public static final int buildNumber = 53; + + private static Minecraft mc; + + public static boolean isInitialized = false; + private static boolean notFirstInit = false; + public static ContextCapabilities capabilities; + public static boolean hasGlGenMipmap = false; + public static int numberResetDisplayList = 0; + + private static int renderDisplayWidth = 0; + private static int renderDisplayHeight = 0; + public static int renderWidth = 0; + public static int renderHeight = 0; + + public static boolean isRenderingWorld = false; + public static boolean isRenderingSky = false; + public static boolean isCompositeRendered = false; + public static boolean isRenderingDfb = false; + public static boolean isShadowPass = false; + public static int activeTexUnit = 0; + + public static boolean isHandRendered; + public static ItemStack itemToRender; + + private static float[] sunPosition = new float[4]; + private static float[] moonPosition = new float[4]; + private static float[] upPosition = new float[4]; + + private static float[] upPosModelView = new float[] {0.0F, 100.0F, 0.0F, 0.0F}; + private static float[] sunPosModelView = new float[] {0.0F, 100.0F, 0.0F, 0.0F}; + private static float[] moonPosModelView = new float[] {0.0F, -100.0F, 0.0F, 0.0F}; + private static float[] tempMat = new float[16]; + + private static float clearColorR; + private static float clearColorG; + private static float clearColorB; + + private static float skyColorR; + private static float skyColorG; + private static float skyColorB; + + private static long worldTime = 0; + private static long lastWorldTime = 0; + private static long diffWorldTime = 0; + private static float sunAngle = 0; + private static float shadowAngle = 0; + private static int moonPhase = 0; + + private static long systemTime = 0; + private static long lastSystemTime = 0; + private static long diffSystemTime = 0; + + private static int frameCounter = 0; + private static float frameTimeCounter = 0.0f; + + private static int systemTimeInt32 = 0; + + private static float rainStrength = 0.0f; + private static float wetness = 0.0f; + public static float wetnessHalfLife = 30 * 20; + public static float drynessHalfLife = 10 * 20; + public static float eyeBrightnessHalflife = 10.0f; + private static boolean usewetness = false; + private static int isEyeInWater = 0; + private static int eyeBrightness = 0; + private static float eyeBrightnessFadeX = 0; + private static float eyeBrightnessFadeY = 0; + private static float eyePosY = 0; + private static float centerDepth = 0; + private static float centerDepthSmooth = 0; + private static float centerDepthSmoothHalflife = 1.0f; + private static boolean centerDepthSmoothEnabled = false; + private static int superSamplingLevel = 1; + + private static boolean updateChunksErrorRecorded = false; + + private static boolean lightmapEnabled = false; + private static boolean fogEnabled = true; + + public static int entityAttrib = 10; + public static int midTexCoordAttrib = 11; + public static boolean useEntityAttrib = false; + public static boolean useMidTexCoordAttrib = false; + public static boolean useMultiTexCoord3Attrib = false; + public static boolean progUseEntityAttrib = false; + public static boolean progUseMidTexCoordAttrib = false; + + public static int atlasSizeX = 0, atlasSizeY = 0; + public static int uniformEntityHurt = -1; + public static int uniformEntityFlash = -1; + public static boolean useEntityHurtFlash; + + private static double[] previousCameraPosition = new double[3]; + private static double[] cameraPosition = new double[3]; + + // Shadow stuff + + // configuration + private static int shadowPassInterval = 0; + public static boolean needResizeShadow = false; + private static int shadowMapWidth = 1024; + private static int shadowMapHeight = 1024; + private static int spShadowMapWidth = 1024; + private static int spShadowMapHeight = 1024; + private static float shadowMapFOV = 90.0f; + private static float shadowMapHalfPlane = 160.0f; + private static boolean shadowMapIsOrtho = true; + + private static int shadowPassCounter = 0; + + private static int preShadowPassThirdPersonView; + + public static boolean shouldSkipDefaultShadow = false; + + private static boolean waterShadowEnabled = false; + + // Color attachment stuff + + private static final int MaxDrawBuffers = 8; + private static final int MaxColorBuffers = 8; + private static final int MaxDepthBuffers = 3; + private static final int MaxShadowColorBuffers = 8; + private static final int MaxShadowDepthBuffers = 2; + private static int usedColorBuffers = 0; + private static int usedDepthBuffers = 0; + private static int usedShadowColorBuffers = 0; + private static int usedShadowDepthBuffers = 0; + private static int usedColorAttachs = 0; + private static int usedDrawBuffers = 0; + + private static int dfb = 0; + private static int sfb = 0; + + private static int[] gbuffersFormat = new int[MaxColorBuffers]; + + // Program stuff + + public static int activeProgram = 0; + + public static final int ProgramNone = 0; + public static final int ProgramBasic = 1; + public static final int ProgramTextured = 2; + public static final int ProgramTexturedLit = 3; + public static final int ProgramSkyBasic = 4; + public static final int ProgramSkyTextured = 5; + public static final int ProgramTerrain = 6; + public static final int ProgramWater = 7; + public static final int ProgramEntities = 8; + public static final int ProgramSpiderEyes = 9; + public static final int ProgramHand = 10; + public static final int ProgramWeather = 11; + public static final int ProgramComposite = 12; + public static final int ProgramComposite1 = 13; + public static final int ProgramComposite2 = 14; + public static final int ProgramComposite3 = 15; + public static final int ProgramComposite4 = 16; + public static final int ProgramComposite5 = 17; + public static final int ProgramComposite6 = 18; + public static final int ProgramComposite7 = 19; + public static final int ProgramFinal = 20; + public static final int ProgramShadow = 21; + public static final int ProgramCount = 22; + public static final int MaxCompositePasses = 8; + + private static final String[] programNames = new String[] { + "", + "gbuffers_basic", + "gbuffers_textured", + "gbuffers_textured_lit", + "gbuffers_skybasic", + "gbuffers_skytextured", + "gbuffers_terrain", + "gbuffers_water", + "gbuffers_entities", + "gbuffers_spidereyes", + "gbuffers_hand", + "gbuffers_weather", + "composite", + "composite1", + "composite2", + "composite3", + "composite4", + "composite5", + "composite6", + "composite7", + "final", + "shadow", + }; + + private static final int[] programBackups = new int[] { + ProgramNone, // none + ProgramNone, // basic + ProgramBasic, // textured + ProgramTextured, // textured/lit + ProgramBasic, // skybasic + ProgramTextured, // skytextured + ProgramTexturedLit, // terrain + ProgramTerrain, // water + ProgramTexturedLit, // entities + ProgramTextured, // spidereyes + ProgramTexturedLit, // hand + ProgramTexturedLit, // weather + ProgramNone, // composite + ProgramNone, // composite1 + ProgramNone, // composite2 + ProgramNone, // composite3 + ProgramNone, // composite4 + ProgramNone, // composite5 + ProgramNone, // composite6 + ProgramNone, // composite7 + ProgramNone, // final + ProgramNone, // shadow + }; + + private static int[] programsID = new int[ProgramCount]; + private static int[] programsRef = new int[ProgramCount]; + private static int programIDCopyDepth = 0; + + private static String[] programsDrawBufSettings = new String[ProgramCount]; + private static String newDrawBufSetting = null; + private static IntBuffer[] programsDrawBuffers = new IntBuffer[ProgramCount]; + static IntBuffer activeDrawBuffers = null; + + private static String[] programsColorAtmSettings = new String[ProgramCount]; + private static String newColorAtmSetting = null; + private static String activeColorAtmSettings = null; + + private static int[] programsCompositeMipmapSetting = new int[ProgramCount]; + private static int newCompositeMipmapSetting = 0; + private static int activeCompositeMipmapSetting = 0; + + public static Properties loadedShaders = null; + public static Properties shadersConfig = null; + + // public static TextureManager textureManager = null; + public static ITextureObject defaultTexture = null; + public static boolean normalMapEnabled = false; + public static boolean[] shadowHardwareFilteringEnabled = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowMipmapEnabled = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowFilterNearest = new boolean[MaxShadowDepthBuffers]; + public static boolean[] shadowColorMipmapEnabled = new boolean[MaxShadowColorBuffers]; + public static boolean[] shadowColorFilterNearest = new boolean[MaxShadowColorBuffers]; + + // config + public static boolean configTweakBlockDamage = false; + public static boolean configCloudShadow = true; + public static float configHandDepthMul = 0.125f; + public static float configRenderResMul = 1.0f; + public static float configShadowResMul = 1.0f; + public static int configTexMinFilB = 0; + public static int configTexMinFilN = 0; + public static int configTexMinFilS = 0; + public static int configTexMagFilB = 0; + public static int configTexMagFilN = 0; + public static int configTexMagFilS = 0; + public static boolean configShadowClipFrustrum = true; + public static boolean configNormalMap = true; + public static boolean configSpecularMap = true; + public static boolean configOldLighting = false; + + // related to config + public static final int texMinFilRange = 3; + public static final int texMagFilRange = 2; + public static final String[] texMinFilDesc = {"Nearest", "Nearest-Nearest", "Nearest-Linear"}; + public static final String[] texMagFilDesc = {"Nearest", "Linear"}; + public static final int[] texMinFilValue = { + GL11.GL_NEAREST, GL11.GL_NEAREST_MIPMAP_NEAREST, GL11.GL_NEAREST_MIPMAP_LINEAR + }; + public static final int[] texMagFilValue = {GL11.GL_NEAREST, GL11.GL_LINEAR}; + + // shaderpack + static IShaderPack shaderPack = null; + static File currentshader; + static String currentshadername; + static String packNameNone = "(none)"; + static String packNameDefault = "(internal)"; + static String shaderpacksdirname = "shaderpacks"; + static String optionsfilename = "optionsshaders.txt"; + static File shadersdir = new File(Minecraft.getMinecraft().mcDataDir, "shaders"); + static File shaderpacksdir = new File(Minecraft.getMinecraft().mcDataDir, shaderpacksdirname); + static File configFile = new File(Minecraft.getMinecraft().mcDataDir, optionsfilename); + + public static final boolean enableShadersOption = true; + private static final boolean enableShadersDebug = true; + + public static float blockLightLevel05 = 0.5f; + public static float blockLightLevel06 = 0.6f; + public static float blockLightLevel08 = 0.8f; + + public static float aoLevel = 0.8f; + public static float blockAoLight = 1.0f - aoLevel; + + public static float sunPathRotation = 0.0f; + public static float shadowAngleInterval = 0.0f; + public static int fogMode = 0; + public static float fogColorR, fogColorG, fogColorB; + public static float shadowIntervalSize = 2.0f; + public static int terrainIconSize = 16; + public static int[] terrainTextureSize = new int[2]; + + private static HFNoiseTexture noiseTexture; + private static boolean noiseTextureEnabled = false; + private static int noiseTextureResolution = 256; + + // direct buffers + private static final int bigBufferSize = (16 * 12 + + MaxColorBuffers + + MaxDepthBuffers + + MaxShadowColorBuffers + + MaxShadowDepthBuffers + + MaxDrawBuffers * 8 + + MaxDrawBuffers * ProgramCount) + * 4; + private static final ByteBuffer bigBuffer = + (ByteBuffer) BufferUtils.createByteBuffer(bigBufferSize).limit(0); + + private static final FloatBuffer previousProjection = nextFloatBuffer(16); + private static final FloatBuffer projection = nextFloatBuffer(16); + private static final FloatBuffer projectionInverse = nextFloatBuffer(16); + private static final FloatBuffer previousModelView = nextFloatBuffer(16); + private static final FloatBuffer modelView = nextFloatBuffer(16); + private static final FloatBuffer modelViewInverse = nextFloatBuffer(16); + private static final FloatBuffer shadowProjection = nextFloatBuffer(16); + private static final FloatBuffer shadowProjectionInverse = nextFloatBuffer(16); + private static final FloatBuffer shadowModelView = nextFloatBuffer(16); + private static final FloatBuffer shadowModelViewInverse = nextFloatBuffer(16); + private static final FloatBuffer tempMatrixDirectBuffer = nextFloatBuffer(16); + private static final FloatBuffer tempDirectFloatBuffer = nextFloatBuffer(16); + + private static final IntBuffer dfbColorTextures = nextIntBuffer(MaxColorBuffers); + private static final IntBuffer dfbDepthTextures = nextIntBuffer(MaxDepthBuffers); + private static final IntBuffer sfbColorTextures = nextIntBuffer(MaxShadowColorBuffers); + private static final IntBuffer sfbDepthTextures = nextIntBuffer(MaxShadowDepthBuffers); + + static final IntBuffer dfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer sfbDrawBuffers = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersNone = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersAll = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClear0 = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClear1 = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersClearColor = nextIntBuffer(MaxDrawBuffers); + static final IntBuffer drawBuffersColorAtt0 = nextIntBuffer(MaxDrawBuffers); + + static final IntBuffer[] drawBuffersBuffer = nextIntBufferArray(ProgramCount, MaxDrawBuffers); + + // static final String ofVersion = "OptiFine_x.x.x_HD_U_xx"; + // static final String ofVersion = Config.VERSION; + + // static int lastversion = version; + // static int updateinterval = 48; + // public static final String siteurl = "http://glslshadersof.no-ip.org"; + // public static final String updatecheckurl = "http:....../lastversion145.html"; + // static JFrame frame; + + static { + drawBuffersNone.limit(0); + drawBuffersColorAtt0.put(GL_COLOR_ATTACHMENT0_EXT).position(0).limit(1); + } + + private Shaders() {} + + /** set position to limit and advance limit by size */ + private static ByteBuffer nextByteBuffer(int size) { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos + size); + return buffer.slice(); + } + + private static IntBuffer nextIntBuffer(int size) { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos + size * 4); + return buffer.asIntBuffer(); + } + + private static FloatBuffer nextFloatBuffer(int size) { + ByteBuffer buffer = bigBuffer; + int pos = buffer.limit(); + buffer.position(pos).limit(pos + size * 4); + return buffer.asFloatBuffer(); + } + + private static IntBuffer[] nextIntBufferArray(int count, int size) { + IntBuffer[] aib = new IntBuffer[count]; + for (int i = 0; i < count; ++i) aib[i] = nextIntBuffer(size); + return aib; + } + + /* + static void checkForUpdate() + { + if (!shadersdir.exists()) shadersdir.mkdir(); + lastversion = version; + int lastcheck = 0; + File updatecheck = new File(shadersdir,"updatecheck.cfg"); + try + { + if (updatecheck.exists()) + { + BufferedReader bufferedreader2 = new BufferedReader(new FileReader(updatecheck)); + + for (String s = ""; (s = bufferedreader2.readLine()) != null;) + { + try + { + String as[] = s.split(":"); + int vv; + if (as[0].equals("updateinterval")) + { + vv = Integer.parseInt(as[1]); + if (vv < 0 || ( vv > 0 && vv < 24 ) || vv > 736) + { + System.out.println("[Shaders] Skipping bad option: updateinterval, range is: 0, 24-736"); + } + else + { + updateinterval = vv; + } + } + else if (as[0].equals("lastcheck")) + { + lastcheck = Integer.parseInt(as[1]); + } + else if (as[0].equals("lastversion")) + { + lastversion = Integer.parseInt(as[1]); + } + } + catch (Exception exception1) + { + System.out.println("[Shaders] "+(new StringBuilder()).append("Skipping bad option: ").append(s).toString()); + } + } + bufferedreader2.close(); + } + } + catch(Exception ex){} + + if (updateinterval > 0) + { + try + { + if (lastversion > version) + { + updatenotify(versiontostring(lastversion)); + System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); + } + else + { + int currenthours = (int) (System.currentTimeMillis() / 3600000); + if (currenthours - lastcheck > updateinterval ) + { + System.out.println("[Shaders] Checking for updates. Last checked "+Integer.toString(currenthours - lastcheck)+" hours ago."); + lastcheck = currenthours; + try + { + URL url = new URL( updatecheckurl ); + HttpURLConnection.setFollowRedirects(true); + HttpURLConnection uconn; + uconn = (HttpURLConnection) url.openConnection(); + uconn.setConnectTimeout(2500); + uconn.setReadTimeout(1500); + try + { + uconn.connect(); + } + catch (SocketTimeoutException excep) + { + System.out.println("[Shaders] Failed to connect to " + updatecheckurl); + return; + } + + BufferedReader bufferedreader2 = new BufferedReader(new InputStreamReader( uconn.getInputStream())); + + for (String s = ""; (s = bufferedreader2.readLine()) != null;) + { + try + { + String as[] = s.split(":"); + if (as[1].equals("lastversion")) + { + lastversion = Integer.parseInt(as[2]); + break; + } + } + catch (Exception exception1){} + } + bufferedreader2.close(); + } + catch (Exception exception) + { + System.out.println("[Shaders] Failed to download " + updatecheckurl); + return; + } + + BufferedWriter bufferedwriter2 = new BufferedWriter(new FileWriter(updatecheck)); + bufferedwriter2.write("updateinterval:"+updateinterval); + bufferedwriter2.newLine(); + bufferedwriter2.write("lastcheck:"+Integer.toString(lastcheck)); + bufferedwriter2.newLine(); + bufferedwriter2.write("lastversion:"+Integer.toString(lastversion)); + bufferedwriter2.newLine(); + bufferedwriter2.close(); + + if (lastversion > version) + { + updatenotify(versiontostring(lastversion)); + System.out.println("[Shaders] New version "+versiontostring(lastversion)+" of the GLSL Shaders OF mod is available, go to "+ siteurl +" to download."); + } + } + } + } + catch (Exception exception) + { + System.out.println("[Shaders] Failed to load GLSL Shaders update file."); + exception.printStackTrace(); + } + } + } + + public static void updatenotify(String lastversion) + { + try + { + frame = new JFrame("GLSL Shaders OF mod update"); + } + catch(Exception e) + { + return; + } + + Color bgcolor=new Color(194,205,234); + Color txcolor=new Color(50,50,50); + frame.setLocation(20,20); + JLabel label=new JLabel("New version of the GLSL Shaders OF mod is available! (v"+lastversion+") "); + JPanel panel = new JPanel(); + panel.setBackground(bgcolor); + label.setForeground(txcolor); + label.setFont(new Font("Dialog", 1, 14)); + panel.add(label); + + if( java.awt.Desktop.isDesktopSupported() ) + { + JButton button; + final java.awt.Desktop desktop = java.awt.Desktop.getDesktop(); + if( desktop.isSupported( java.awt.Desktop.Action.BROWSE ) ) + { + button = new JButton("Download"); + button.setActionCommand("BPUPD"); + + } + else + { + button = new JButton("Copy URL to Clipboard"); + button.setActionCommand("CPURL"); + } + button.setFont(new Font("Dialog", 1, 14)); + button.addActionListener(new ButtonListener()); + panel.add(button); + } + frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); + frame.getContentPane().add(panel); + frame.pack(); + frame.setFocusableWindowState(false); + frame.setVisible(true); + frame.setFocusableWindowState(true); + } + + static class ButtonListener implements ActionListener + { + ButtonListener() + { + } + public void actionPerformed(ActionEvent e) + { + String cmd = e.getActionCommand(); + if (cmd == "BPUPD") + { + try + { + java.net.URI uri = new java.net.URI( siteurl ); + java.awt.Desktop.getDesktop().browse( uri ); + frame.dispose(); + } + catch ( Exception exx ) {} + } + else if (cmd == "CPURL") + { + StringSelection ss = new StringSelection(siteurl); + Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null); + } + + } + } + */ + + public static void loadConfig() { + System.out.println("[Shaders] Loading configuration."); + try { + if (!shaderpacksdir.exists()) shaderpacksdir.mkdir(); + } catch (Exception e) { + System.err.println("[Shaders] Failed openning shaderpacks directory."); + } + + shadersConfig = new Properties(); + shadersConfig.setProperty("shaderPack", ""); + if (configFile.exists()) { + try { + FileReader reader = new FileReader(configFile); + shadersConfig.load(reader); + reader.close(); + } catch (Exception e) { + } + } + + if (!configFile.exists()) { + try { + storeConfig(); + } catch (Exception e) { + } + } + String value = null; + configNormalMap = Boolean.parseBoolean(shadersConfig.getProperty("normalMapEnabled", "true")); + configSpecularMap = Boolean.parseBoolean(shadersConfig.getProperty("specularMapEnabled", "true")); + configTweakBlockDamage = Boolean.parseBoolean( + shadersConfig.getProperty("tweakBlockDamage", shadersConfig.getProperty("dtweak", "false"))); + configCloudShadow = Boolean.parseBoolean(shadersConfig.getProperty("cloudShadow", "true")); + configHandDepthMul = Float.parseFloat(shadersConfig.getProperty("handDepthMul", "0.125")); + configRenderResMul = Float.parseFloat(shadersConfig.getProperty("renderResMul", "1.0")); + configShadowResMul = Float.parseFloat(shadersConfig.getProperty("shadowResMul", "1.0")); + configShadowClipFrustrum = Boolean.parseBoolean(shadersConfig.getProperty("shadowClipFrustrum", "true")); + configOldLighting = Boolean.parseBoolean(shadersConfig.getProperty("oldLighting", "false")); + configTexMinFilB = Integer.parseInt(shadersConfig.getProperty("TexMinFilB", "0")) % texMinFilRange; + configTexMinFilN = Integer.parseInt(shadersConfig.getProperty("TexMinFilN", Integer.toString(configTexMinFilB))) + % texMinFilRange; + configTexMinFilS = Integer.parseInt(shadersConfig.getProperty("TexMinFilS", Integer.toString(configTexMinFilB))) + % texMinFilRange; + configTexMagFilB = Integer.parseInt(shadersConfig.getProperty("TexMagFilB", "0")) % texMagFilRange; + configTexMagFilN = Integer.parseInt(shadersConfig.getProperty("TexMagFilN", "0")) % texMagFilRange; + configTexMagFilS = Integer.parseInt(shadersConfig.getProperty("TexMagFilS", "0")) % texMagFilRange; + currentshadername = shadersConfig.getProperty("shaderPack", packNameDefault); + loadShaderPack(); + } + + public static void storeConfig() { + System.out.println("[Shaders] Save configuration."); + shadersConfig.setProperty("normalMapEnabled", Boolean.toString(configNormalMap)); + shadersConfig.setProperty("specularMapEnabled", Boolean.toString(configSpecularMap)); + shadersConfig.setProperty("tweakBlockDamage", Boolean.toString(configTweakBlockDamage)); + shadersConfig.setProperty("cloudShadow", Boolean.toString(configCloudShadow)); + shadersConfig.setProperty("handDepthMul", Float.toString(configHandDepthMul)); + shadersConfig.setProperty("renderResMul", Float.toString(configRenderResMul)); + shadersConfig.setProperty("shadowResMul", Float.toString(configShadowResMul)); + shadersConfig.setProperty("shadowClipFrustrum", Boolean.toString(configShadowClipFrustrum)); + shadersConfig.setProperty("oldLighting", Boolean.toString(configOldLighting)); + shadersConfig.setProperty("TexMinFilB", Integer.toString(configTexMinFilB)); + shadersConfig.setProperty("TexMinFilN", Integer.toString(configTexMinFilN)); + shadersConfig.setProperty("TexMinFilS", Integer.toString(configTexMinFilS)); + shadersConfig.setProperty("TexMagFilB", Integer.toString(configTexMagFilB)); + shadersConfig.setProperty("TexMagFilN", Integer.toString(configTexMagFilN)); + shadersConfig.setProperty("TexMagFilS", Integer.toString(configTexMagFilS)); + try { + FileWriter writer = new FileWriter(configFile); + shadersConfig.store(writer, null); + writer.close(); + } catch (Exception ex) { + } + } + + public static void setShaderPack(String par1name) { + currentshadername = par1name; + shadersConfig.setProperty("shaderPack", par1name); + // loadShaderPack(); + } + + public static void loadShaderPack() { + if (shaderPack != null) { + shaderPack.close(); + shaderPack = null; + } + String packName = shadersConfig.getProperty("shaderPack", packNameDefault); + if (!packName.isEmpty() && !packName.equals(packNameNone)) { + if (packName.equals(packNameDefault)) { + shaderPack = new ShaderPackDefault(); + } else { + try { + File packFile = new File(shaderpacksdir, packName); + if (packFile.isDirectory()) { + shaderPack = new ShaderPackFolder(packName, packFile); + } else if (packFile.isFile() && packName.toLowerCase().endsWith(".zip")) { + shaderPack = new ShaderPackZip(packName, packFile); + } + } catch (Exception e) { + } + } + } + if (shaderPack != null) { + System.out.println("[Shaders] Loaded shaderpack."); + } else { + System.out.println("[Shaders] Did not load shaderpack."); + shaderPack = new ShaderPackNone(); + } + } + + // public static void loadShader0() + // { + // Set shaderfiles = new HashSet(); + // for (int si = 1; si < 10; si++) + // { + // shaderfiles.add(programNames[si]+".fsh"); + // shaderfiles.add(programNames[si]+".vsh"); + // } + // + // try + // { + // + // ZipInputStream inp = new ZipInputStream(new FileInputStream(currentshader)); + // System.out.println("[Shaders] Shader selected: " + currentshadername); + // boolean found = false; + // + // ZipEntry entry = inp.getNextEntry(); + // while(entry != null ) + // { + // if (entry.isDirectory()) + // { + // if (entry.getName().toLowerCase().contains("shaders/contents/files/shaders/")) + // { + // found = true; + // break; + // } + // } + // entry = inp.getNextEntry(); + // } + // + // if (!found) + // { + // inp.close(); + // inp = new ZipInputStream(new FileInputStream(currentshader)); + // entry = inp.getNextEntry(); + // while(entry != null ) + // { + // if (entry.isDirectory()) + // { + // if (entry.getName().toLowerCase().contains("shaders/")) + // { + // found = true; + // break; + // } + // } + // entry = inp.getNextEntry(); + // } + // } + // + // if (!found) + // { + // inp.close(); + // inp = new ZipInputStream(new FileInputStream(currentshader)); + // entry = inp.getNextEntry(); + // } + // + // byte[] buf = new byte[1024]; + // int n; + // String zipfile; + // String zippath = ""; + // String zippathfile; + // + // FileOutputStream fileoutputstream, fileoutputstream2; + // boolean seusrc5tweak = false; + // + // while(entry != null && shaderfiles.size() > 0) + // { + // zipfile = new File(entry.getName()).getName(); + // if (shaderfiles.contains(zipfile) && !entry.isDirectory()) + // { + // zippathfile = new File(entry.getName()).getPath(); + // if (shaderfiles.size() == 18) + // { + // zippath = zippathfile.substring(0,zippathfile.length()-zipfile.length()); + // } + // if (zippathfile.equals(zippath+zipfile)) + // { + // shaderfiles.remove(zipfile); + // if (zipfile.equals("gbuffers_water.vsh") && entry.getCrc() == 2530345120L ) seusrc5tweak = true; + // + // fileoutputstream = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + zipfile); + // while ((n = inp.read(buf, 0, 1024)) > -1) fileoutputstream.write(buf, 0, n); + // fileoutputstream.close(); + // System.out.println("[Shaders] Shader loaded: " + zippathfile); + // } + // } + // entry = inp.getNextEntry(); + // } + // inp.close(); + // + // if (seusrc5tweak) + // { + // new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.fsh").delete(); + // new File(shadersdir + File.separator + "temp" + File.separator + "gbuffers_water.vsh").delete(); + // FileInputStream file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + + // "gbuffers_textured_lit.fsh"); + // FileOutputStream file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + + // "gbuffers_water.fsh",false); + // while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); + // file.close(); + // file2.close(); + // file = new FileInputStream(shadersdir + File.separator + "temp" + File.separator + + // "gbuffers_textured_lit.vsh"); + // file2 = new FileOutputStream(shadersdir + File.separator + "temp" + File.separator + + // "gbuffers_water.vsh",false); + // while ((n = file.read(buf, 0, 1024)) > -1) file2.write(buf, 0, n); + // file.close(); + // file2.close(); + // System.out.println("[Shaders] Detected SEUS v10 RC5, copied gbuffers_textured_lit. to gbuffers_water."); + // } + // } + // catch (Exception exc) + // {} + // + // isInitialized = false; + // if (shaderfiles.size() == 18 ) System.out.println("[Shaders] No Shader found in: " + currentshadername); + // else System.out.println("[Shaders] Shader loaded: " + currentshadername); + // } + + static ArrayList listofShaders() { + ArrayList list = new ArrayList(); + list.add(packNameNone); + list.add(packNameDefault); + try { + if (!shaderpacksdir.exists()) shaderpacksdir.mkdir(); + File[] listOfFiles = shaderpacksdir.listFiles(); + for (int i = 0; i < listOfFiles.length; i++) { + File file = listOfFiles[i]; + String name = file.getName(); + if (file.isDirectory() || file.isFile() && name.toLowerCase().endsWith(".zip")) { + list.add(name); + } + } + } catch (Exception e) { + } + return list; + } + + static String versiontostring(int vv) { + String vs = Integer.toString(vv); + return Integer.toString(Integer.parseInt(vs.substring(1, 3))) + "." + + Integer.toString(Integer.parseInt(vs.substring(3, 5))) + "." + + Integer.toString(Integer.parseInt(vs.substring(5))); + } + + static void checkOptifine() { + /* + try + { + System.out.println("[Shaders] Required OptiFine version : " + ofVersion); + String configVersion = (String)(Config.class.getDeclaredField("VERSION").get(null)); + System.out.println("[Shaders] Detected OptiFine version : "+ configVersion); + if (configVersion.equals(ofVersion) ) + { + System.out.println("[Shaders] ShadersMod loaded. version: " + versiontostring(version)); + } + else + { + System.err.println("[Shaders] Wrong OptiFine version!"); + System.exit(-1); + } + } + catch(Exception e) + { + System.err.println("[Shaders] OptiFine missing or wrong version! Install OptiFine "+ofVersion+" first and then the ShadersMod!"); + System.exit(-1); + } + //Tessellator.shaders = true; + */ + } + + public static int checkFramebufferStatus(String location) { + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) + System.err.format("FramebufferStatus 0x%04X at %s\n", status, location); + return status; + } + + public static int checkGLError(String location) { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + boolean skipPrint = false; + // if (location.equals("updatechunks")) { + // if (updateChunksErrorRecorded) { + // skipPrint = true; + // } else { + // updateChunksErrorRecorded = true; + // } + // } + if (!skipPrint) { + if (errorCode == GL_INVALID_FRAMEBUFFER_OPERATION_EXT) { + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + System.err.format( + "GL error 0x%04X: %s (Fb status 0x%04X) at %s\n", + errorCode, gluErrorString(errorCode), status, location); + } else { + System.err.format("GL error 0x%04X: %s at %s\n", errorCode, gluErrorString(errorCode), location); + } + } + } + return errorCode; + } + + public static int checkGLError(String location, String info) { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + System.err.format("GL error 0x%04x: %s at %s %s\n", errorCode, gluErrorString(errorCode), location, info); + } + return errorCode; + } + + public static int checkGLError(String location, String info1, String info2) { + int errorCode = glGetError(); + if (errorCode != GL_NO_ERROR) { + System.err.format( + "GL error 0x%04x: %s at %s %s %s\n", errorCode, gluErrorString(errorCode), location, info1, info2); + } + return errorCode; + } + + private static String printChatAndLogError(String str) { + mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText(str)); + System.err.println(str); + return str; + } + + public static void printIntBuffer(String title, IntBuffer buf) { + StringBuilder sb = new StringBuilder(128); + sb.append(title) + .append(" [pos ") + .append(buf.position()) + .append(" lim ") + .append(buf.limit()) + .append(" cap ") + .append(buf.capacity()) + .append(" :"); + for (int lim = buf.limit(), i = 0; i < lim; ++i) sb.append(" ").append(buf.get(i)); + sb.append("]"); + System.out.println(sb); + } + + public static void startup(Minecraft mc) { + Shaders.mc = mc; + System.out.println("ShadersMod version " + versionString); + Shaders.loadConfig(); + } + + private static String toStringYN(boolean b) { + return b ? "Y" : "N"; + } + + public static void updateBlockLightLevel() { + if (configOldLighting) { + blockLightLevel05 = 0.5f; + blockLightLevel06 = 0.6f; + blockLightLevel08 = 0.8f; + } else { + blockLightLevel05 = 1.0f; + blockLightLevel06 = 1.0f; + blockLightLevel08 = 1.0f; + } + } + + public static void init() { + if (!isInitialized) { + mc = Minecraft.getMinecraft(); + checkGLError("Shaders.init pre"); + capabilities = GLContext.getCapabilities(); + System.out.println("[Shaders] OpenGL 2.0 = " + toStringYN(capabilities.OpenGL20) + " 2.1 = " + + toStringYN(capabilities.OpenGL21) + " 3.0 = " + + toStringYN(capabilities.OpenGL30) + " 3.2 = " + + toStringYN(capabilities.OpenGL32)); + if (!capabilities.OpenGL21) { + printChatAndLogError("[Shaders] No OpenGL 2.1."); + } + if (!capabilities.GL_EXT_framebuffer_object) { + printChatAndLogError("[Shaders] No EXT_framebuffer_object."); + } + if (!capabilities.OpenGL20 || !capabilities.GL_EXT_framebuffer_object) { + printChatAndLogError("[Shaders] Your GPU is not compatible with the Shaders mod."); + } + + hasGlGenMipmap = capabilities.OpenGL30; + dfbDrawBuffers.position(0).limit(MaxDrawBuffers); + dfbColorTextures.position(0).limit(MaxColorBuffers); + dfbDepthTextures.position(0).limit(MaxDepthBuffers); + sfbDrawBuffers.position(0).limit(MaxDrawBuffers); + sfbDepthTextures.position(0).limit(MaxShadowDepthBuffers); + sfbColorTextures.position(0).limit(MaxShadowColorBuffers); + + int maxDrawBuffers = glGetInteger(GL_MAX_DRAW_BUFFERS); + int maxColorAttach = glGetInteger(GL_MAX_COLOR_ATTACHMENTS_EXT); + System.out.println("[Shaders] GL_MAX_DRAW_BUFFERS = " + maxDrawBuffers); + System.out.println("[Shaders] GL_MAX_COLOR_ATTACHMENTS_EXT = " + maxColorAttach); + System.out.println("[Shaders] GL_MAX_TEXTURE_IMAGE_UNITS = " + glGetInteger(GL_MAX_TEXTURE_IMAGE_UNITS)); + + usedColorBuffers = 4; + usedDepthBuffers = 1; + usedShadowColorBuffers = 0; + usedShadowDepthBuffers = 0; + usedColorAttachs = 1; + usedDrawBuffers = 1; + Arrays.fill(gbuffersFormat, GL_RGBA); + Arrays.fill(shadowHardwareFilteringEnabled, false); + Arrays.fill(shadowMipmapEnabled, false); + Arrays.fill(shadowFilterNearest, false); + Arrays.fill(shadowColorMipmapEnabled, false); + Arrays.fill(shadowColorFilterNearest, false); + centerDepthSmoothEnabled = false; + noiseTextureEnabled = false; + sunPathRotation = 0f; + shadowIntervalSize = 2.0f; + aoLevel = 0.8f; + blockAoLight = 1.0f - aoLevel; + useEntityAttrib = false; + useMidTexCoordAttrib = false; + useMultiTexCoord3Attrib = false; + waterShadowEnabled = false; + updateChunksErrorRecorded = false; + updateBlockLightLevel(); + + for (int i = 0; i < ProgramCount; ++i) { + if (programNames[i] == "") { + programsID[i] = programsRef[i] = 0; + programsDrawBufSettings[i] = null; + programsColorAtmSettings[i] = null; + programsCompositeMipmapSetting[i] = 0; + } else { + newDrawBufSetting = null; + newColorAtmSetting = null; + newCompositeMipmapSetting = 0; + int pr = setupProgram( + i, "/shaders/" + programNames[i] + ".vsh", "/shaders/" + programNames[i] + ".fsh"); + programsID[i] = programsRef[i] = pr; + programsDrawBufSettings[i] = (pr != 0) ? newDrawBufSetting : null; + programsColorAtmSettings[i] = (pr != 0) ? newColorAtmSetting : null; + programsCompositeMipmapSetting[i] = (pr != 0) ? newCompositeMipmapSetting : 0; + } + } + + Map drawBuffersMap = new HashMap(); + for (int p = 0; p < ProgramCount; ++p) { + if (p == ProgramFinal) { + programsDrawBuffers[p] = null; + } else if (programsID[p] == 0) { + if (p == ProgramShadow) { + programsDrawBuffers[p] = drawBuffersNone; + } else { + programsDrawBuffers[p] = drawBuffersColorAtt0; + } + } else { + String str = programsDrawBufSettings[p]; + if (str != null) { + IntBuffer intbuf = drawBuffersBuffer[p]; + int numDB = str.length(); + if (numDB > usedDrawBuffers) { + usedDrawBuffers = numDB; + } + if (numDB > maxDrawBuffers) { + numDB = maxDrawBuffers; + } + programsDrawBuffers[p] = intbuf; + intbuf.limit(numDB); + for (int i = 0; i < numDB; ++i) { + int d = GL_NONE; + if (str.length() > i) { + int ca = str.charAt(i) - '0'; + if (p != ProgramShadow) { + if (ca >= 0 && ca <= 7) { + d = ca + GL_COLOR_ATTACHMENT0_EXT; + if (ca > usedColorAttachs) { + usedColorAttachs = ca; + } + if (ca > usedColorBuffers) { + usedColorBuffers = ca; + } + } + } else { + if (ca >= 0 && ca <= 1) { + d = ca + GL_COLOR_ATTACHMENT0_EXT; + if (ca > usedShadowColorBuffers) { + usedShadowColorBuffers = ca; + } + } + } + } + intbuf.put(i, d); + } + } else { + if (p != ProgramShadow) { + programsDrawBuffers[p] = dfbDrawBuffers; + usedDrawBuffers = usedColorBuffers; + } else { + programsDrawBuffers[p] = sfbDrawBuffers; + } + } + } + } + + // if (programIDCopyDepth==0) + // programIDCopyDepth = setupProgramCopyDepth(); + + // TO DO: add color attachment option + usedColorAttachs = usedColorBuffers; + + shadowPassInterval = (usedShadowDepthBuffers > 0) ? 1 : 0; + shouldSkipDefaultShadow = (usedShadowDepthBuffers > 0); + + dfbDrawBuffers.position(0).limit(usedDrawBuffers); + dfbColorTextures.position(0).limit(usedColorBuffers); + // dfbRenderBuffers.limit(colorAttachments); + + for (int i = 0; i < usedDrawBuffers; ++i) { + dfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); + } + + if (usedDrawBuffers > maxDrawBuffers) { + printChatAndLogError("[Shaders] Not enough draw buffers! Requires " + usedDrawBuffers + ". Has " + + maxDrawBuffers + "."); + } + // if (usedColorBuffers > maxColorAttach) { + // printChatAndLogError("[Shaders] Not enough color attachment! Requires "+ usedColorBuffers + ". Has " + + // maxColorAttach + "."); + // } + + sfbDrawBuffers.position(0).limit(usedShadowColorBuffers); + for (int i = 0; i < usedShadowColorBuffers; ++i) { + sfbDrawBuffers.put(i, GL_COLOR_ATTACHMENT0_EXT + i); + } + + // Use programBackups for missing programs + for (int i = 0; i < ProgramCount; ++i) { + int n = i; + while (programsID[n] == 0 && programBackups[n] != n) n = programBackups[n]; + if (n != i && i != ProgramShadow) { + programsID[i] = programsID[n]; + programsDrawBufSettings[i] = programsDrawBufSettings[n]; + programsDrawBuffers[i] = programsDrawBuffers[n]; + } + } + + // printIntBuffer("dfb drawbuffers",dfbDrawBuffers); + // printIntBuffer("sfb drawbuffers",sfbDrawBuffers); + // printIntBuffer("pgshadow drawbf",programsDrawBuffers[ProgramShadow]); + + // setup scene frame buffer and textures + resize(); + + // setup shadow frame buffer and texture + resizeShadow(); + + if (noiseTextureEnabled) setupNoiseTexture(); + + if (defaultTexture == null) defaultTexture = ShadersTex.createDefaultTexture(); + // TextureNM texBlocks = (TextureNM)textureManager.textureMapBlocks.getTexture(); + // TextureNM texItems = (TextureNM)textureManager.textureMapBlocks.getTexture(); + // terrainTextureIdArray = new int[] { texBlocks.getGlTextureId(), texBlocks.normalMap.getGlTextureId(), + // texBlocks.specularMap.getGlTextureId() }; + // textureIdMap.put(terrainTextureIdArray[0], terrainTextureIdArray); + // int[] itemsTextureIdArray; + // itemsTextureIdArray = new int[] { texItems.getGlTextureId(), texItems.normalMap.getGlTextureId(), + // texItems.specularMap.getGlTextureId() }; + // textureIdMap.put(itemsTextureIdArray[0], itemsTextureIdArray); + + isInitialized = true; + + resetDisplayList(); + if (notFirstInit) { + mc.ingameGUI.getChatGUI().printChatMessage(new ChatComponentText("Shaders initialized.")); + } + checkGLError("Shaders.init"); + } + } + + public static void resetDisplayList() { + ++numberResetDisplayList; + System.out.println("Reset model renderers"); + if (Shaders.useMidTexCoordAttrib || Shaders.useMultiTexCoord3Attrib) { + Iterator it = + RenderManager.instance.entityRenderMap.values().iterator(); + while (it.hasNext()) { + Render ren = it.next(); + if (ren instanceof RendererLivingEntity) { + RendererLivingEntity rle = (RendererLivingEntity) ren; + // System.out.format("Reset %s\n", rle.toString()); + resetDisplayListModel(rle.mainModel); + resetDisplayListModel(rle.renderPassModel); + } + } + } + System.out.println("Reset world renderers"); + mc.renderGlobal.loadRenderers(); + } + + public static void resetDisplayListModel(ModelBase mbase) { + if (mbase != null) { + Iterator it = mbase.boxList.iterator(); + while (it.hasNext()) { + Object obj = it.next(); + if (obj instanceof ModelRenderer) { + resetDisplayListModelRenderer((ModelRenderer) obj); + } + } + } + } + + public static void resetDisplayListModelRenderer(ModelRenderer mrr) { + mrr.resetDisplayList(); + // if (mrr.compiled) + // { + // GLAllocation.deleteDisplayLists(mrr.displayList); + // mrr.displayList = 0; + // mrr.compiled = false; + // if (mrr instanceof ModelRotationRenderer) { + // ModelRotationRenderer mrt = (ModelRotationRenderer)mrr; + // mrt.compiled = false; + // } + // } + if (mrr.childModels != null) { + for (int i = 0, n = mrr.childModels.size(); i < n; ++i) { + resetDisplayListModelRenderer((ModelRenderer) mrr.childModels.get(i)); + } + } + } + + // ---------------------------------------- + + // private static final String shaderCodeCopyDepthV = + // "#version 120\n"+ + // "varying vec4 texcoord;\n"+ + // "void main()\n"+ + // "{\n"+ + // " texcoord = gl_MultiTexCoord0;\n"+ + // " gl_Position = ftransform();\n"+ + // "}\n" + // ; + // private static final String shaderCodeCopyDepthF = + // "#version 120\n"+ + // "varying vec4 texcoord;\n"+ + // "uniform sampler2D depthtex0;\n"+ + // "void main()\n"+ + // "{\n"+ + // " gl_FragDepth = texture2D(depthtex0,texcoord.st).r;\n"+ + // " gl_FragColor = texture2D(depthtex0,texcoord.st);\n"+ + // "}\n" + // ; + // + // private static int setupProgramCopyDepth() { + // int program = glCreateProgramObjectARB(); + // if (program !=0) { + // int vShader = createVertShaderFromCode(shaderCodeCopyDepthV); + // int fShader = createFragShaderFromCode(shaderCodeCopyDepthF); + // if (vShader != 0 || fShader != 0) { + // if (vShader != 0) { + // glAttachObjectARB(program, vShader); + // } + // if (fShader != 0) { + // glAttachObjectARB(program, fShader); + // } + // glLinkProgramARB(program); + // if (vShader != 0) { + // glDetachObjectARB(program, vShader); + // glDeleteObjectARB(vShader); + // } + // if (fShader != 0) { + // glDetachObjectARB(program, fShader); + // glDeleteObjectARB(fShader); + // } + // int valid = glGetProgrami(program, GL_VALIDATE_STATUS); // glGetProgrami in LWJGL 3.0+ + // if (valid == GL_TRUE) { + // System.out.println("Program copydepth created"); + // } else { + // printChatAndLogError("[Shaders] Error : Invalid program copydepth"); + // glDeleteObjectARB(program); + // program = 0; + // } + // } else { + // glDeleteObjectARB(program); + // program = 0; + // } + // } + // return program; + // } + // + // + // private static int createVertShaderFromCode(String code) { + // int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); + // if (vertShader == 0) { + // return 0; + // } + // glShaderSourceARB(vertShader, code); + // glCompileShaderARB(vertShader); + // printLogInfo(vertShader,"copydepth vert"); + // return vertShader; + // } + // + // + // private static int createFragShaderFromCode(String code) { + // int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); + // if (fragShader == 0) { + // return 0; + // } + // glShaderSourceARB(fragShader, code); + // glCompileShaderARB(fragShader); + // printLogInfo(fragShader,"copydepth frag"); + // return fragShader; + // } + + private static int setupProgram(int program, String vShaderPath, String fShaderPath) { + checkGLError("pre setupProgram"); + int programid = glCreateProgramObjectARB(); + checkGLError("create"); + if (programid != 0) { + progUseEntityAttrib = false; + progUseMidTexCoordAttrib = false; + int vShader = createVertShader(vShaderPath); + int fShader = createFragShader(fShaderPath); + checkGLError("create"); + if (vShader != 0 || fShader != 0) { + if (vShader != 0) { + glAttachObjectARB(programid, vShader); + checkGLError("attach"); + } + if (fShader != 0) { + glAttachObjectARB(programid, fShader); + checkGLError("attach"); + } + if (progUseEntityAttrib) { + glBindAttribLocationARB(programid, entityAttrib, "mc_Entity"); + checkGLError("mc_Entity"); + } + if (progUseMidTexCoordAttrib) { + glBindAttribLocationARB(programid, midTexCoordAttrib, "mc_midTexCoord"); + checkGLError("mc_midTexCoord"); + } + glLinkProgramARB(programid); + if (vShader != 0) { + glDetachObjectARB(programid, vShader); + glDeleteObjectARB(vShader); + } + if (fShader != 0) { + glDetachObjectARB(programid, fShader); + glDeleteObjectARB(fShader); + } + programsID[program] = programid; + useProgram(program); + glValidateProgramARB(programid); + useProgram(ProgramNone); + printLogInfo(programid, vShaderPath + "," + fShaderPath); + int valid = glGetProgrami(programid, GL_VALIDATE_STATUS); + if (valid == GL_TRUE) { + System.out.println("Program " + programNames[program] + " loaded"); + } else { + printChatAndLogError("[Shaders] Error : Invalid program " + programNames[program]); + glDeleteObjectARB(programid); + programid = 0; + } + } else { + glDeleteObjectARB(programid); + programid = 0; + } + } + return programid; + } + + private static int createVertShader(String filename) { + int vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); + if (vertShader == 0) { + return 0; + } + StringBuilder vertexCode = new StringBuilder(1048576); + String line; + + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); + } catch (Exception e) { + try { + reader = new BufferedReader(new FileReader(new File(filename))); + } catch (Exception e2) { + // System.out.println("Couldn't open " + filename); + glDeleteObjectARB(vertShader); + return 0; + } + } + + if (reader != null) + try { + while ((line = reader.readLine()) != null) { + + if (preprocessIncludeDirective(line, vertexCode, false)) continue; + + vertexCode.append(line).append("\n"); + processVertShaderLine(line); + } + } catch (Exception e) { + System.out.println("Couldn't read " + filename + "!"); + e.printStackTrace(); + glDeleteObjectARB(vertShader); + return 0; + } + + if (reader != null) + try { + reader.close(); + } catch (Exception e) { + System.out.println("Couldn't close " + filename + "!"); + } + + glShaderSourceARB(vertShader, vertexCode); + glCompileShaderARB(vertShader); + printLogInfo(vertShader, filename); + return vertShader; + } + + private static void processVertShaderLine(String line) { + if (line.matches("attribute [_a-zA-Z0-9]+ mc_Entity.*")) { + useEntityAttrib = true; + progUseEntityAttrib = true; + } else if (line.matches("attribute [_a-zA-Z0-9]+ mc_midTexCoord.*")) { + useMidTexCoordAttrib = true; + progUseMidTexCoordAttrib = true; + } else if (line.matches(".*gl_MultiTexCoord3.*")) { + useMultiTexCoord3Attrib = true; + } + } + + private static final Pattern gbufferFormatPattern = + Pattern.compile("[ \t]*const[ \t]*int[ \t]*(\\w+)Format[ \t]*=[ \t]*([RGBA81632F]*)[ \t]*;.*"); + private static final Pattern gbufferMipmapEnabledPattern = + Pattern.compile("[ \t]*const[ \t]*bool[ \t]*(\\w+)MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*"); + + private static final Pattern INCLUDE_PATTERN = Pattern.compile("^\\s*#include\\s+\"([A-Za-z0-9_/\\.]+)\".*$"); + + // TODO: dirty non-recursive implementation, also does not support any includes referencing anything but shaders + // directory + private static boolean preprocessIncludeDirective(String line, StringBuilder code, boolean type) { + Matcher includePattern = INCLUDE_PATTERN.matcher(line); + + if (includePattern.matches()) { + String path = includePattern.group(1); + + InputStream inputStream = shaderPack.getResourceAsStream("/shaders" + path); + BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); + + String l; + try { + while ((l = reader.readLine()) != null) { + code.append(l).append("\n"); + // TODO: type is a dirty hack to get includes working for now, must be refactored + if (type) { + processFragShaderLine(line, path); + } else { + processVertShaderLine(line); + } + } + } catch (IOException e) { + printChatAndLogError(e.getLocalizedMessage()); + e.printStackTrace(); + } + + return true; + } + + return false; + } + + private static int createFragShader(String filename) { + int fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); + if (fragShader == 0) { + return 0; + } + StringBuilder fragCode = new StringBuilder(1048576); + String line; + + BufferedReader reader; + try { + reader = new BufferedReader(new InputStreamReader(shaderPack.getResourceAsStream(filename))); + } catch (Exception e) { + try { + reader = new BufferedReader(new FileReader(new File(filename))); + } catch (Exception e2) { + // System.out.println("Couldn't open " + filename); + glDeleteObjectARB(fragShader); + return 0; + } + } + + if (reader != null) + try { + while ((line = reader.readLine()) != null) { + + if (preprocessIncludeDirective(line, fragCode, true)) continue; + + fragCode.append(line).append('\n'); + processFragShaderLine(line, filename); + } + } catch (Exception e) { + System.out.println("Couldn't read " + filename + "!"); + e.printStackTrace(); + glDeleteObjectARB(fragShader); + return 0; + } + + if (reader != null) + try { + reader.close(); + } catch (Exception e) { + System.out.println("Couldn't close " + filename + "!"); + } + + glShaderSourceARB(fragShader, fragCode); + glCompileShaderARB(fragShader); + printLogInfo(fragShader, filename); + return fragShader; + } + + // TODO: refactor this mess + private static void processFragShaderLine(String line, String filename) { + if (line.matches("#version .*")) { + + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadow;.*")) { + if (usedShadowDepthBuffers < 1) usedShadowDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ watershadow;.*")) { + waterShadowEnabled = true; + if (usedShadowDepthBuffers < 2) usedShadowDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex0;.*")) { + if (usedShadowDepthBuffers < 1) usedShadowDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowtex1;.*")) { + if (usedShadowDepthBuffers < 2) usedShadowDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor;.*")) { + if (usedShadowColorBuffers < 1) usedShadowColorBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor0;.*")) { + if (usedShadowColorBuffers < 1) usedShadowColorBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ shadowcolor1;.*")) { + if (usedShadowColorBuffers < 2) usedShadowColorBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex0;.*")) { + if (usedDepthBuffers < 1) usedDepthBuffers = 1; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex1;.*")) { + if (usedDepthBuffers < 2) usedDepthBuffers = 2; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ depthtex2;.*")) { + if (usedDepthBuffers < 3) usedDepthBuffers = 3; + } else if (line.matches("uniform [ _a-zA-Z0-9]+ gdepth;.*")) { + if (gbuffersFormat[1] == GL_RGBA) gbuffersFormat[1] = GL_RGBA32F; + } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ gaux1;.*")) { + usedColorBuffers = 5; + } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ gaux2;.*")) { + usedColorBuffers = 6; + } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ gaux3;.*")) { + usedColorBuffers = 7; + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ gaux4;.*")) { + usedColorBuffers = 8; + } else if (usedColorBuffers < 5 && line.matches("uniform [ _a-zA-Z0-9]+ colortex4;.*")) { + usedColorBuffers = 5; + } else if (usedColorBuffers < 6 && line.matches("uniform [ _a-zA-Z0-9]+ colortex5;.*")) { + usedColorBuffers = 6; + } else if (usedColorBuffers < 7 && line.matches("uniform [ _a-zA-Z0-9]+ colortex6;.*")) { + usedColorBuffers = 7; + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ colortex7;.*")) { + usedColorBuffers = 8; + + } else if (usedColorBuffers < 8 && line.matches("uniform [ _a-zA-Z0-9]+ centerDepthSmooth;.*")) { + centerDepthSmoothEnabled = true; + + // Shadow resolution + } else if (line.matches("/\\* SHADOWRES:[0-9]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map resolution: " + parts[2]); + spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[2]); + shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); + + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*shadowMapResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map resolution: " + parts[1]); + spShadowMapWidth = spShadowMapHeight = Integer.parseInt(parts[1]); + shadowMapWidth = shadowMapHeight = Math.round(spShadowMapWidth * configShadowResMul); + + } else if (line.matches("/\\* SHADOWFOV:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map field of view: " + parts[2]); + shadowMapFOV = Float.parseFloat(parts[2]); + shadowMapIsOrtho = false; + + // Shadow distance + } else if (line.matches("/\\* SHADOWHPL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Shadow map half-plane: " + parts[2]); + shadowMapHalfPlane = Float.parseFloat(parts[2]); + shadowMapIsOrtho = true; + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowDistance[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map distance: " + parts[1]); + shadowMapHalfPlane = Float.parseFloat(parts[1]); + shadowMapIsOrtho = true; + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*shadowIntervalSize[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Shadow map interval size: " + parts[1]); + shadowIntervalSize = Float.parseFloat(parts[1]); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Generate shadow mipmap"); + Arrays.fill(shadowMipmapEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*generateShadowColorMipmap[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Generate shadow color mipmap"); + Arrays.fill(shadowColorMipmapEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("Hardware shadow filtering enabled."); + Arrays.fill(shadowHardwareFilteringEnabled, true); + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering0[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowHardwareFiltering0"); + shadowHardwareFilteringEnabled[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*shadowHardwareFiltering1[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowHardwareFiltering1"); + shadowHardwareFilteringEnabled[1] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowtex0Mipmap|shadowtexMipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex0Mipmap"); + shadowMipmapEnabled[0] = true; + + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*(shadowtex1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex1Mipmap"); + shadowMipmapEnabled[1] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Mipmap|shadowColor0Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor0Mipmap"); + shadowColorMipmapEnabled[0] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Mipmap|shadowColor1Mipmap)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor1Mipmap"); + shadowColorMipmapEnabled[1] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowtex0Nearest|shadowtexNearest|shadow0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex0Nearest"); + shadowFilterNearest[0] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowtex1Nearest|shadow1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowtex1Nearest"); + shadowFilterNearest[1] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowcolor0Nearest|shadowColor0Nearest|shadowColor0MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor0Nearest"); + shadowColorFilterNearest[0] = true; + + } else if (line.matches( + "[ \t]*const[ \t]*bool[ \t]*(shadowcolor1Nearest|shadowColor1Nearest|shadowColor1MinMagNearest)[ \t]*=[ \t]*true[ \t]*;.*")) { + System.out.println("shadowcolor1Nearest"); + shadowColorFilterNearest[1] = true; + + // Wetness half life + } else if (line.matches("/\\* WETNESSHL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Wetness halflife: " + parts[2]); + wetnessHalfLife = Float.parseFloat(parts[2]); + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*wetnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Wetness halflife: " + parts[1]); + wetnessHalfLife = Float.parseFloat(parts[1]); + + // Dryness halflife + } else if (line.matches("/\\* DRYNESSHL:[0-9\\.]+ \\*/.*")) { + String[] parts = line.split("(:| )", 4); + System.out.println("Dryness halflife: " + parts[2]); + drynessHalfLife = Float.parseFloat(parts[2]); + + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*drynessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Dryness halflife: " + parts[1]); + drynessHalfLife = Float.parseFloat(parts[1]); + + // Eye brightness halflife + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*eyeBrightnessHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Eye brightness halflife: " + parts[1]); + eyeBrightnessHalflife = Float.parseFloat(parts[1]); + + // Center depth halflife + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*centerDepthHalflife[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Center depth halflife: " + parts[1]); + centerDepthSmoothHalflife = Float.parseFloat(parts[1]); + + // Sun path rotation + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*sunPathRotation[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Sun path rotation: " + parts[1]); + sunPathRotation = Float.parseFloat(parts[1]); + + // Ambient occlusion level + } else if (line.matches("[ \t]*const[ \t]*float[ \t]*ambientOcclusionLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("AO Level: " + parts[1]); + aoLevel = Float.parseFloat(parts[1]); + blockAoLight = 1.0f - aoLevel; + + // super sampling + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*superSamplingLevel[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + int ssaa = Integer.parseInt(parts[1]); + if (ssaa > 1) { + System.out.println("Super sampling level: " + ssaa + "x"); + superSamplingLevel = ssaa; + } else { + superSamplingLevel = 1; + } + + // noise texture + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*noiseTextureResolution[ \t]*=[ \t]*-?[0-9.]+f?;.*")) { + String[] parts = line.split("(=[ \t]*|;)"); + System.out.println("Noise texture enabled"); + System.out.println("Noise texture resolution: " + parts[1]); + noiseTextureResolution = Integer.parseInt(parts[1]); + noiseTextureEnabled = true; + + } else if (line.matches("[ \t]*const[ \t]*int[ \t]*\\w+Format[ \t]*=[ \t]*[RGBA81632F]*[ \t]*;.*")) { + Matcher m = gbufferFormatPattern.matcher(line); + m.matches(); + String name = m.group(1); + String value = m.group(2); + int bufferindex = getBufferIndexFromString(name); + int format = getTextureFormatFromString(value); + if (bufferindex >= 0 && format != 0) { + gbuffersFormat[bufferindex] = format; + System.out.format("%s format: %s\n", name, value); + } + // gaux4 + } else if (line.matches("/\\* GAUX4FORMAT:RGBA32F \\*/.*")) { + System.out.println("gaux4 format : RGB32AF"); + gbuffersFormat[7] = GL_RGBA32F; + } else if (line.matches("/\\* GAUX4FORMAT:RGB32F \\*/.*")) { + System.out.println("gaux4 format : RGB32F"); + gbuffersFormat[7] = GL_RGB32F; + } else if (line.matches("/\\* GAUX4FORMAT:RGB16 \\*/.*")) { + System.out.println("gaux4 format : RGB16"); + gbuffersFormat[7] = GL_RGB16; + + // Mipmap stuff + } else if (line.matches("[ \t]*const[ \t]*bool[ \t]*\\w+MipmapEnabled[ \t]*=[ \t]*true[ \t]*;.*")) { + if (filename.matches(".*composite[0-9]?.fsh") || filename.matches(".*final.fsh")) { + Matcher m = gbufferMipmapEnabledPattern.matcher(line); + m.matches(); + String name = m.group(1); + // String value =m.group(2); + int bufferindex = getBufferIndexFromString(name); + if (bufferindex >= 0) { + newCompositeMipmapSetting |= (1 << bufferindex); + System.out.format("%s mipmap enabled for %s\n", name, filename); + } + } + } else if (line.matches("/\\* DRAWBUFFERS:[0-7N]* \\*/.*")) { + String[] parts = line.split("(:| )", 4); + newDrawBufSetting = parts[2]; + } + } + + private static boolean printLogInfo(int obj, String name) { + IntBuffer iVal = BufferUtils.createIntBuffer(1); + glGetObjectParameterARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal); + + int length = iVal.get(); + if (length > 1) { + ByteBuffer infoLog = BufferUtils.createByteBuffer(length); + iVal.flip(); + glGetInfoLogARB(obj, iVal, infoLog); + byte[] infoBytes = new byte[length]; + infoLog.get(infoBytes); + if (infoBytes[length - 1] == 0) infoBytes[length - 1] = 10; + String out = new String(infoBytes); + System.out.println("Info log: " + name + "\n" + out); + return false; + } + return true; + } + + public static void setDrawBuffers(IntBuffer drawBuffers) { + if (activeDrawBuffers != drawBuffers) { + // printIntBuffer("setDrawBuffers", drawBuffers); + activeDrawBuffers = drawBuffers; + glDrawBuffers(drawBuffers); + } else { + // printIntBuffer("setDrawBf skip", drawBuffers); + } + } + + public static void useProgram(int program) { + // System.out.println((new StringBuilder(32)).append("useProgram ").append(programNames[program])); + Shaders.checkGLError("pre-useProgram"); + if (isShadowPass) { + program = ProgramShadow; + if (programsID[ProgramShadow] == 0) { + normalMapEnabled = false; + return; + } + } + if (activeProgram == program) { + return; + } + activeProgram = program; + glUseProgramObjectARB(programsID[program]); + if (programsID[program] == 0) { + normalMapEnabled = false; + return; + } + if (checkGLError("useProgram ", programNames[program]) != 0) { + programsID[program] = 0; + } + IntBuffer drawBuffers = programsDrawBuffers[program]; + if (isRenderingDfb) { + setDrawBuffers(drawBuffers); + checkGLError(programNames[program], " draw buffers = ", programsDrawBufSettings[program]); + // SMCLog.info("%s",programNames[program] + " draw buffers = " + programsDrawBufSettings[program]); + } + activeCompositeMipmapSetting = programsCompositeMipmapSetting[program]; + uniformEntityHurt = glGetUniformLocationARB(programsID[activeProgram], "entityHurt"); + uniformEntityFlash = glGetUniformLocationARB(programsID[activeProgram], "entityFlash"); + switch (program) { + case ProgramBasic: + case ProgramTextured: + case ProgramTexturedLit: + case ProgramSkyBasic: + case ProgramSkyTextured: + case ProgramTerrain: + case ProgramWater: + case ProgramEntities: + case ProgramHand: + case ProgramWeather: + normalMapEnabled = true; + setProgramUniform1i("texture", 0); + setProgramUniform1i("lightmap", 1); + setProgramUniform1i("normals", 2); + setProgramUniform1i("specular", 3); + setProgramUniform1i("shadow", waterShadowEnabled ? 5 : 4); + setProgramUniform1i("watershadow", 4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("depthtex0", 6); + setProgramUniform1i("depthtex1", 12); + setProgramUniform1i("shadowcolor", 13); + setProgramUniform1i("shadowcolor0", 13); + setProgramUniform1i("shadowcolor1", 14); + setProgramUniform1i("noisetex", 15); + break; + case ProgramComposite: + case ProgramComposite1: + case ProgramComposite2: + case ProgramComposite3: + case ProgramComposite4: + case ProgramComposite5: + case ProgramComposite6: + case ProgramComposite7: + case ProgramFinal: + normalMapEnabled = false; + setProgramUniform1i("gcolor", 0); + setProgramUniform1i("gdepth", 1); + setProgramUniform1i("gnormal", 2); + setProgramUniform1i("composite", 3); + setProgramUniform1i("gaux1", 7); + setProgramUniform1i("gaux2", 8); + setProgramUniform1i("gaux3", 9); + setProgramUniform1i("gaux4", 10); + setProgramUniform1i("colortex0", 0); + setProgramUniform1i("colortex1", 1); + setProgramUniform1i("colortex2", 2); + setProgramUniform1i("colortex3", 3); + setProgramUniform1i("colortex4", 7); + setProgramUniform1i("colortex5", 8); + setProgramUniform1i("colortex6", 9); + setProgramUniform1i("colortex7", 10); + setProgramUniform1i("shadow", waterShadowEnabled ? 5 : 4); + setProgramUniform1i("watershadow", 4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("gdepthtex", 6); + setProgramUniform1i("depthtex0", 6); + setProgramUniform1i("depthtex1", 11); + setProgramUniform1i("depthtex2", 12); + setProgramUniform1i("shadowcolor", 13); + setProgramUniform1i("shadowcolor0", 13); + setProgramUniform1i("shadowcolor1", 14); + setProgramUniform1i("noisetex", 15); + break; + case ProgramShadow: + setProgramUniform1i("tex", 0); + setProgramUniform1i("texture", 0); + setProgramUniform1i("lightmap", 1); + setProgramUniform1i("normals", 2); + setProgramUniform1i("specular", 3); + setProgramUniform1i("shadow", waterShadowEnabled ? 5 : 4); + setProgramUniform1i("watershadow", 4); + setProgramUniform1i("shadowtex0", 4); + setProgramUniform1i("shadowtex1", 5); + setProgramUniform1i("shadowcolor", 13); + setProgramUniform1i("shadowcolor0", 13); + setProgramUniform1i("shadowcolor1", 14); + setProgramUniform1i("noisetex", 15); + break; + default: + normalMapEnabled = false; + break; + } + ItemStack stack = mc.thePlayer.getCurrentEquippedItem(); + Item item = (stack != null) ? stack.getItem() : null; + int itemID; + Block block; + if (item != null) { + itemID = Item.itemRegistry.getIDForObject(item); + block = (Block) Block.blockRegistry.getObjectById(itemID); + } else { + itemID = -1; + block = null; + } + setProgramUniform1i("heldItemId", (itemID)); + setProgramUniform1i("heldBlockLightValue", (block != null) ? block.getLightValue() : 0); + setProgramUniform1i("fogMode", (fogEnabled ? fogMode : 0)); + setProgramUniform3f("fogColor", fogColorR, fogColorG, fogColorB); + setProgramUniform3f("skyColor", skyColorR, skyColorG, skyColorB); + setProgramUniform1i("worldTime", (int) worldTime % 24000); + setProgramUniform1i("moonPhase", moonPhase); + setProgramUniform1f("frameTimeCounter", frameTimeCounter); + setProgramUniform1f("sunAngle", sunAngle); + setProgramUniform1f("shadowAngle", shadowAngle); + setProgramUniform1f("rainStrength", rainStrength); + setProgramUniform1f("aspectRatio", (float) renderWidth / (float) renderHeight); + setProgramUniform1f("viewWidth", (float) renderWidth); + setProgramUniform1f("viewHeight", (float) renderHeight); + setProgramUniform1f("near", 0.05F); + setProgramUniform1f("far", mc.gameSettings.renderDistanceChunks * 16); + setProgramUniform3f("sunPosition", sunPosition[0], sunPosition[1], sunPosition[2]); + setProgramUniform3f("moonPosition", moonPosition[0], moonPosition[1], moonPosition[2]); + setProgramUniform3f("upPosition", upPosition[0], upPosition[1], upPosition[2]); + setProgramUniform3f( + "previousCameraPosition", (float) previousCameraPosition[0], (float) previousCameraPosition[1], (float) + previousCameraPosition[2]); + setProgramUniform3f( + "cameraPosition", (float) cameraPosition[0], (float) cameraPosition[1], (float) cameraPosition[2]); + setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); + setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); + setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); + setProgramUniformMatrix4ARB("gbufferProjection", false, projection); + setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); + setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); + if (usedShadowDepthBuffers > 0) { + setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); + setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); + setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); + setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); + } + setProgramUniform1f("wetness", wetness); + setProgramUniform1f("eyeAltitude", eyePosY); + // .x = block brightness .y = sky brightness + // value : 0,16,32,64,96,112,128,160,192,208,224,240 for light level 0 to 15 + setProgramUniform2i("eyeBrightness", (eyeBrightness & 0xffff), (eyeBrightness >> 16)); + setProgramUniform2i("eyeBrightnessSmooth", Math.round(eyeBrightnessFadeX), Math.round(eyeBrightnessFadeY)); + setProgramUniform2i("terrainTextureSize", terrainTextureSize[0], terrainTextureSize[1]); + setProgramUniform1i("terrainIconSize", terrainIconSize); + setProgramUniform1i("isEyeInWater", isEyeInWater); + setProgramUniform1i("hideGUI", mc.gameSettings.hideGUI ? 1 : 0); + setProgramUniform1f("centerDepthSmooth", centerDepthSmooth); + setProgramUniform2i("atlasSize", atlasSizeX, atlasSizeY); + Shaders.checkGLError("useProgram ", programNames[program]); + } + + public static void setProgramUniform1i(String name, int x) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform1iARB(uniform, x); + if (enableShadersDebug) checkGLError(programNames[activeProgram], name); + } + } + + public static void setProgramUniform2i(String name, int x, int y) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform2iARB(uniform, x, y); + if (enableShadersDebug) checkGLError(programNames[activeProgram], name); + } + } + + public static void setProgramUniform1f(String name, float x) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform1fARB(uniform, x); + if (enableShadersDebug) checkGLError(programNames[activeProgram], name); + } + } + + public static void setProgramUniform3f(String name, float x, float y, float z) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE) { + int uniform = glGetUniformLocationARB(gp, name); + glUniform3fARB(uniform, x, y, z); + if (enableShadersDebug) checkGLError(programNames[activeProgram], name); + } + } + + public static void setProgramUniformMatrix4ARB(String name, boolean transpose, FloatBuffer matrix) { + int gp = programsID[activeProgram]; + if (gp != GL_NONE && matrix != null) { + int uniform = glGetUniformLocationARB(gp, name); + glUniformMatrix4ARB(uniform, transpose, matrix); + if (enableShadersDebug) checkGLError(programNames[activeProgram], name); + } + } + + private static int getBufferIndexFromString(String name) { + if (name.equals("colortex0") || name.equals("gcolor")) return 0; + else if (name.equals("colortex1") || name.equals("gdepth")) return 1; + else if (name.equals("colortex2") || name.equals("gnormal")) return 2; + else if (name.equals("colortex3") || name.equals("composite")) return 3; + else if (name.equals("colortex4") || name.equals("gaux1")) return 4; + else if (name.equals("colortex5") || name.equals("gaux2")) return 5; + else if (name.equals("colortex6") || name.equals("gaux3")) return 6; + else if (name.equals("colortex7") || name.equals("gaux4")) return 7; + else return -1; + } + + private static int getTextureFormatFromString(String par) { + if (par.matches("[ \t]*R8[ \t]*")) return GL_R8; + else if (par.matches("[ \t]*RG8[ \t]*")) return GL_RG8; + else if (par.matches("[ \t]*RGB8[ \t]*")) return GL_RGB8; + else if (par.matches("[ \t]*RGBA8[ \t]*")) return GL_RGBA8; + else if (par.matches("[ \t]*R16[ \t]*")) return GL_R16; + else if (par.matches("[ \t]*RG16[ \t]*")) return GL_RG16; + else if (par.matches("[ \t]*RGB16[ \t]*")) return GL_RGB16; + else if (par.matches("[ \t]*RGBA16[ \t]*")) return GL_RGBA16; + else if (par.matches("[ \t]*R32F[ \t]*")) return GL_R32F; + else if (par.matches("[ \t]*RG32F[ \t]*")) return GL_RG32F; + else if (par.matches("[ \t]*RGB32F[ \t]*")) return GL_RGB32F; + else if (par.matches("[ \t]*RGBA32F[ \t]*")) return GL_RGBA32F; + else return 0; + } + + private static void setupNoiseTexture() { + if (noiseTexture == null) noiseTexture = new HFNoiseTexture(noiseTextureResolution, noiseTextureResolution); + } + + private static IntBuffer fillIntBufferZero(IntBuffer buf) { + int limit = buf.limit(); + for (int i = buf.position(); i < limit; ++i) buf.put(i, 0); + return buf; + } + + public static void uninit() { + if (isInitialized) { + checkGLError("Shaders.uninit pre"); + for (int i = 0; i < ProgramCount; ++i) { + if (programsRef[i] != 0) { + glDeleteObjectARB(programsRef[i]); + checkGLError("del programRef"); + } + programsRef[i] = 0; + programsID[i] = 0; + programsDrawBufSettings[i] = null; + programsDrawBuffers[i] = null; + programsCompositeMipmapSetting[i] = 0; + } + if (dfb != 0) { + glDeleteFramebuffersEXT(dfb); + dfb = 0; + checkGLError("del dfb"); + } + if (sfb != 0) { + glDeleteFramebuffersEXT(sfb); + sfb = 0; + checkGLError("del sfb"); + } + // glDeleteRenderbuffersEXT(dfbDepthBuffer); dfbDepthBuffer = 0; + // if (dfbRenderBuffers != null) { + // glDeleteRenderbuffersEXT(dfbRenderBuffers); + // fillIntBufferZero(dfbRenderBuffers); + // } + if (dfbDepthTextures != null) { + glDeleteTextures(dfbDepthTextures); + fillIntBufferZero(dfbDepthTextures); + checkGLError("del dfbDepthTextures"); + } + if (dfbColorTextures != null) { + glDeleteTextures(dfbColorTextures); + fillIntBufferZero(dfbColorTextures); + checkGLError("del dfbTextures"); + } + if (sfbDepthTextures != null) { + glDeleteTextures(sfbDepthTextures); + fillIntBufferZero(sfbDepthTextures); + checkGLError("del shadow depth"); + } + if (sfbColorTextures != null) { + glDeleteTextures(sfbColorTextures); + fillIntBufferZero(sfbColorTextures); + checkGLError("del shadow color"); + } + if (dfbDrawBuffers != null) { + fillIntBufferZero(dfbDrawBuffers); + } + if (noiseTexture != null) { + noiseTexture.destroy(); + noiseTexture = null; + } + + System.out.println("UNINIT"); + + shadowPassInterval = 0; + shouldSkipDefaultShadow = false; + isInitialized = false; + notFirstInit = true; + checkGLError("Shaders.uninit"); + } + } + + public static void scheduleResize() { + renderDisplayHeight = 0; + } + + public static void scheduleResizeShadow() { + needResizeShadow = true; + } + + private static void resize() { + renderDisplayWidth = mc.displayWidth; + renderDisplayHeight = mc.displayHeight; + // renderWidth = mc.displayWidth * superSamplingLevel; + // renderHeight = mc.displayHeight * superSamplingLevel; + renderWidth = Math.round(renderDisplayWidth * configRenderResMul); + renderHeight = Math.round(renderDisplayHeight * configRenderResMul); + setupFrameBuffer(); + } + + private static void resizeShadow() { + needResizeShadow = false; + shadowMapWidth = Math.round(spShadowMapWidth * configShadowResMul); + shadowMapHeight = Math.round(spShadowMapHeight * configShadowResMul); + setupShadowFrameBuffer(); + } + + private static void setupFrameBuffer() { + if (dfb != 0) { + glDeleteFramebuffersEXT(dfb); + glDeleteTextures(dfbDepthTextures); + glDeleteTextures(dfbColorTextures); + } + + dfb = glGenFramebuffersEXT(); + glGenTextures((IntBuffer) dfbDepthTextures.clear().limit(usedDepthBuffers)); + glGenTextures((IntBuffer) dfbColorTextures.clear().limit(usedColorBuffers)); + dfbDepthTextures.position(0); + dfbColorTextures.position(0); + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); + glDrawBuffers(GL_NONE); + glReadBuffer(GL_NONE); + + for (int i = 0; i < usedDepthBuffers; ++i) { + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(i)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_DEPTH_COMPONENT, + renderWidth, + renderHeight, + 0, + GL_DEPTH_COMPONENT, + GL11.GL_FLOAT, + (ByteBuffer) null); + } + + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTextures.get(0), 0); + glDrawBuffers(dfbDrawBuffers); + glReadBuffer(GL_NONE); + checkGLError("FT d"); + + for (int i = 0; i < usedColorBuffers; ++i) { + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(i)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexImage2D( + GL_TEXTURE_2D, + 0, + gbuffersFormat[i], + renderWidth, + renderHeight, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + (ByteBuffer) null); + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, GL_TEXTURE_2D, dfbColorTextures.get(i), 0); + checkGLError("FT c"); + } + + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + + if (status == GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT) { + printChatAndLogError("Failed using multiple internal formats in frame buffer."); + for (int i = 0; i < usedColorBuffers; ++i) { + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(i)); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_RGBA, + renderWidth, + renderHeight, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + (ByteBuffer) null); + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, GL_TEXTURE_2D, dfbColorTextures.get(i), 0); + checkGLError("FT c"); + } + status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status == GL_FRAMEBUFFER_COMPLETE_EXT) { + printChatAndLogError("Please update graphics driver."); + } + } + + glBindTexture(GL_TEXTURE_2D, 0); + + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + printChatAndLogError("Failed creating framebuffer! (Status " + status + ")"); + } else { + System.out.println("Framebuffer created."); + } + } + + private static void setupShadowFrameBuffer() { + if (usedShadowDepthBuffers == 0) { + return; + } + + if (sfb != 0) { + glDeleteFramebuffersEXT(sfb); + glDeleteTextures(sfbDepthTextures); + glDeleteTextures(sfbColorTextures); + } + + sfb = glGenFramebuffersEXT(); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); + glDrawBuffers(GL_NONE); + glReadBuffer(GL_NONE); + + glGenTextures((IntBuffer) sfbDepthTextures.clear().limit(usedShadowDepthBuffers)); + glGenTextures((IntBuffer) sfbColorTextures.clear().limit(usedShadowColorBuffers)); + // printIntBuffer(sfbDepthTextures); + // printIntBuffer(sfbColorTextures); + sfbDepthTextures.position(0); + sfbColorTextures.position(0); + + // depth + for (int i = 0; i < usedShadowDepthBuffers; ++i) { + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(i)); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + int filter = shadowFilterNearest[i] ? GL_NEAREST : GL_LINEAR; + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); + if (shadowHardwareFilteringEnabled[i]) + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_DEPTH_COMPONENT, + shadowMapWidth, + shadowMapHeight, + 0, + GL_DEPTH_COMPONENT, + GL11.GL_FLOAT, + (FloatBuffer) null); + } + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(0), 0); + checkGLError("FT sd"); + + // color shadow + for (int i = 0; i < usedShadowColorBuffers; ++i) { + glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + int filter = shadowColorFilterNearest[i] ? GL_NEAREST : GL_LINEAR; + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_RGBA, + shadowMapWidth, + shadowMapHeight, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + (ByteBuffer) null); + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, GL_TEXTURE_2D, sfbColorTextures.get(i), 0); + checkGLError("FT sc"); + } + + glBindTexture(GL_TEXTURE_2D, 0); + + int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + printChatAndLogError("Failed creating shadow framebuffer! (Status " + status + ")"); + } else { + System.out.println("Shadow framebuffer created."); + } + } + + /*public static void linkTextureNormalMap(int tex0, int tex2, int tex3) + { + textureIdMap_n.put(tex0, tex2); + textureIdMap_s.put(tex0, tex3); + int[] ast0,ast2,ast3; + if (tex0 < Tessellator.atlasSubTextures.length && (ast0 = Tessellator.atlasSubTextures[tex0]) != null) + { + if (tex2 < Tessellator.atlasSubTextures.length && (ast2 = Tessellator.atlasSubTextures[tex2]) != null) + for (int it = 0, size = Math.min(ast0.length,ast2.length); it < size; ++it) + textureIdMap_n.put(ast0[it], ast2[it]); + if (tex3 < Tessellator.atlasSubTextures.length && (ast3 = Tessellator.atlasSubTextures[tex3]) != null) + for (int it = 0, size = Math.min(ast0.length,ast3.length); it < size; ++it) + textureIdMap_s.put(ast0[it], ast3[it]); + } + }*/ + + public static void beginRender(Minecraft minecraft, float f, long l) { + if (isShadowPass) { + return; + } + checkGLError("pre beginRender"); + + mc = minecraft; + mc.mcProfiler.startSection("init"); + + if (!isInitialized) { + init(); + } + if (mc.displayWidth != renderDisplayWidth || mc.displayHeight != renderDisplayHeight) { + resize(); + } + if (needResizeShadow) { + resizeShadow(); + } + + worldTime = mc.theWorld.getWorldTime(); + diffWorldTime = (worldTime - lastWorldTime) % 24000; + if (diffWorldTime < 0) diffWorldTime += 24000; + lastWorldTime = worldTime; + moonPhase = mc.theWorld.getMoonPhase(); + + systemTime = System.currentTimeMillis(); + if (lastSystemTime == 0) { + lastSystemTime = + systemTime; // Initialize lastSystemTime on the first tick so that it is equal to current system + // time + } + diffSystemTime = systemTime - lastSystemTime; + lastSystemTime = systemTime; + + frameTimeCounter += diffSystemTime * 0.001f; + frameTimeCounter = frameTimeCounter % 100000.0f; + + rainStrength = minecraft.theWorld.getRainStrength(f); + { + float fadeScalar = diffSystemTime * 0.01f; + // float temp1 = (float)Math.exp(Math.log(0.5)*diffWorldTime/((wetness < rainStrength)? drynessHalfLife : + // wetnessHalfLife)); + float temp1 = (float) Math.exp( + Math.log(0.5) * fadeScalar / ((wetness < rainStrength) ? drynessHalfLife : wetnessHalfLife)); + wetness = wetness * (temp1) + rainStrength * (1 - temp1); + } + + EntityLivingBase eye = mc.renderViewEntity; + eyePosY = (float) eye.posY * f + (float) eye.lastTickPosY * (1 - f); + eyeBrightness = eye.getBrightnessForRender(f); + { + // float temp2 = (float)Math.exp(Math.log(0.5)*1.0f/eyeBrightnessHalfLife); + float fadeScalar = diffSystemTime * 0.01f; + float temp2 = (float) Math.exp(Math.log(0.5) * fadeScalar / eyeBrightnessHalflife); + eyeBrightnessFadeX = eyeBrightnessFadeX * temp2 + (eyeBrightness & 0xffff) * (1 - temp2); + eyeBrightnessFadeY = eyeBrightnessFadeY * temp2 + (eyeBrightness >> 16) * (1 - temp2); + } + + isEyeInWater = (mc.gameSettings.thirdPersonView == 0 + && !mc.renderViewEntity.isPlayerSleeping() + && mc.thePlayer.isInsideOfMaterial(Material.water)) + ? 1 + : 0; + + { + Vec3 skyColorV = mc.theWorld.getSkyColor(mc.renderViewEntity, f); + skyColorR = (float) skyColorV.xCoord; + skyColorG = (float) skyColorV.yCoord; + skyColorB = (float) skyColorV.zCoord; + } + + // Determine average color + // { + // int searchWidth = renderWidth / 2; + // int searchHeight = renderHeight / 2; + // + // ByteBuffer colorByteBuffer = ByteBuffer.allocateDirect(searchWidth * searchHeight * 4 * 3); + // glReadPixels((renderWidth / 2) - (searchWidth / 2), (renderHeight / 2) - (searchHeight / 2), searchWidth, + // searchHeight, GL11.GL_RGB, GL11.GL_FLOAT, colorByteBuffer); + // + // colorByteBuffer.order(ByteOrder.LITTLE_ENDIAN); + // + // + // float averageColor = 0.0f; + // for (int i = 0; i < searchWidth; i++) { + // for (int j = 0; j < searchHeight; j++) { + // averageColor += colorByteBuffer.getFloat(i * 4 + (searchWidth * 4 * 3 * j)); + // } + // } + // + // System.out.println("Color: " + averageColor / (searchWidth * searchHeight)); + // + // } + + isRenderingWorld = true; + isCompositeRendered = false; + isHandRendered = false; + + if (usedShadowDepthBuffers >= 1) { + glActiveTexture(GL_TEXTURE4); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); + if (usedShadowDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE5); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); + } + } + + for (int i = 0; i < 4 && 4 + i < usedColorBuffers; ++i) { + glActiveTexture(GL_TEXTURE7 + i); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4 + i)); + } + + glActiveTexture(GL_TEXTURE6); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); + + if (usedDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE11); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); + + if (usedDepthBuffers >= 3) { + glActiveTexture(GL_TEXTURE12); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); + } + } + + for (int i = 0; i < usedShadowColorBuffers; ++i) { + glActiveTexture(GL_TEXTURE13 + i); + glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); + } + + if (noiseTextureEnabled) { + glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); + glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); + } + + glActiveTexture(GL_TEXTURE0); + + previousCameraPosition[0] = cameraPosition[0]; + previousCameraPosition[1] = cameraPosition[1]; + previousCameraPosition[2] = cameraPosition[2]; + + previousProjection.position(0); + projection.position(0); + previousProjection.put(projection); + previousProjection.position(0); + projection.position(0); + previousModelView.position(0); + modelView.position(0); + previousModelView.put(modelView); + previousModelView.position(0); + modelView.position(0); + + EntityRenderer.anaglyphField = 0; + + if (usedShadowDepthBuffers > 0 && --shadowPassCounter <= 0) { + // do shadow pass + // System.out.println("shadow pass start"); + mc.mcProfiler.endStartSection("shadow pass"); + preShadowPassThirdPersonView = mc.gameSettings.thirdPersonView; + boolean preShadowPassAdvancedOpengl = mc.gameSettings.advancedOpengl; + mc.gameSettings.advancedOpengl = false; + + // moved to setCamera + // mc.gameSettings.thirdPersonView = 1; + + isShadowPass = true; + shadowPassCounter = shadowPassInterval; + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); + glDrawBuffers(programsDrawBuffers[ProgramShadow]); + + useProgram(ProgramShadow); + + mc.entityRenderer.renderWorld(f, l); + + glFlush(); + + isShadowPass = false; + + mc.gameSettings.advancedOpengl = preShadowPassAdvancedOpengl; + mc.gameSettings.thirdPersonView = preShadowPassThirdPersonView; + + if (hasGlGenMipmap) { + if (usedShadowDepthBuffers >= 1) { + if (shadowMipmapEnabled[0]) { + glActiveTexture(GL_TEXTURE4); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri( + GL_TEXTURE_2D, + GL_TEXTURE_MIN_FILTER, + shadowFilterNearest[0] ? GL_NEAREST_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR); + } + if (usedShadowDepthBuffers >= 2) { + if (shadowMipmapEnabled[1]) { + glActiveTexture(GL_TEXTURE5); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri( + GL_TEXTURE_2D, + GL_TEXTURE_MIN_FILTER, + shadowFilterNearest[1] ? GL_NEAREST_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR); + } + } + glActiveTexture(GL_TEXTURE0); + } + if (usedShadowColorBuffers >= 1) { + if (shadowColorMipmapEnabled[0]) { + glActiveTexture(GL_TEXTURE13); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri( + GL_TEXTURE_2D, + GL_TEXTURE_MIN_FILTER, + shadowColorFilterNearest[0] ? GL_NEAREST_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR); + } + if (usedShadowColorBuffers >= 2) { + if (shadowColorMipmapEnabled[1]) { + glActiveTexture(GL_TEXTURE14); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri( + GL_TEXTURE_2D, + GL_TEXTURE_MIN_FILTER, + shadowColorFilterNearest[1] ? GL_NEAREST_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR); + } + } + glActiveTexture(GL_TEXTURE0); + } + } + + // System.out.println("shadow pass end"); + } + mc.mcProfiler.endSection(); + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); + GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); + activeDrawBuffers = null; + ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); + useProgram(ProgramTextured); + + checkGLError("end beginRender"); + } + + public static void setViewport(int vx, int vy, int vw, int vh) { + GL11.glColorMask(true, true, true, true); + if (isShadowPass) { + GL11.glViewport(0, 0, shadowMapWidth, shadowMapHeight); + } else { + GL11.glViewport(0, 0, Shaders.renderWidth, Shaders.renderHeight); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dfb); + isRenderingDfb = true; + GL11.glEnable(GL11.GL_CULL_FACE); + GL11.glEnable(GL11.GL_DEPTH_TEST); + setDrawBuffers(drawBuffersNone); + useProgram(ProgramTextured); + checkGLError("beginRenderPass"); + } + } + + public static int setFogMode(int val) { + return fogMode = val; + } + + public static void setFogColor(float r, float g, float b) { + fogColorR = r; + fogColorG = g; + fogColorB = b; + } + + public static void setClearColor(float red, float green, float blue, float alpha) { + GL11.glClearColor(red, green, blue, alpha); + clearColorR = red; + clearColorG = green; + clearColorB = blue; + } + + public static void clearRenderBuffer() { + // clearColorR = fogColorR; + // clearColorG = fogColorG; + // clearColorB = fogColorB; + + if (isShadowPass) { + // No need to clear shadow depth 1. It will be overwritten. + // if (waterShadowEnabled) { + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, + // sfbDepthTextures.get(1), 0); + // glClear(GL_DEPTH_BUFFER_BIT); + // } + checkGLError("shadow clear pre"); + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, sfbDepthTextures.get(0), 0); + glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + // printIntBuffer(programsDrawBuffers[ProgramShadow]); + glDrawBuffers(programsDrawBuffers[ProgramShadow]); + checkFramebufferStatus("shadow clear"); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + checkGLError("shadow clear"); + return; + } + checkGLError("clear pre"); + + /* + glDrawBuffers(dfbDrawBuffers); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + */ + + glDrawBuffers(GL_COLOR_ATTACHMENT0_EXT); + // glClearColor(clearColorR, clearColorG, clearColorB, 1.0f); + // glClearColor(1f, 0f, 0f, 1.0f); // for debug + glClear(GL_COLOR_BUFFER_BIT); + + glDrawBuffers(GL_COLOR_ATTACHMENT1_EXT); + glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + for (int i = 2; i < usedColorBuffers; ++i) { + glDrawBuffers(GL_COLOR_ATTACHMENT0_EXT + i); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT); + } + + setDrawBuffers(dfbDrawBuffers); + checkFramebufferStatus("clear"); + checkGLError("clear"); + } + + public static void setCamera(float f) { + EntityLivingBase viewEntity = mc.renderViewEntity; + + double x = viewEntity.lastTickPosX + (viewEntity.posX - viewEntity.lastTickPosX) * f; + double y = viewEntity.lastTickPosY + (viewEntity.posY - viewEntity.lastTickPosY) * f; + double z = viewEntity.lastTickPosZ + (viewEntity.posZ - viewEntity.lastTickPosZ) * f; + + cameraPosition[0] = x; + cameraPosition[1] = y; + cameraPosition[2] = z; + + glGetFloat(GL_PROJECTION_MATRIX, (FloatBuffer) projection.position(0)); + invertMat4x((FloatBuffer) projection.position(0), (FloatBuffer) projectionInverse.position(0)); + projection.position(0); + projectionInverse.position(0); + + glGetFloat(GL_MODELVIEW_MATRIX, (FloatBuffer) modelView.position(0)); + invertMat4x((FloatBuffer) modelView.position(0), (FloatBuffer) modelViewInverse.position(0)); + modelView.position(0); + modelViewInverse.position(0); + + if (isShadowPass) { + glViewport(0, 0, shadowMapWidth, shadowMapHeight); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + + if (shadowMapIsOrtho) { + glOrtho( + -shadowMapHalfPlane, + shadowMapHalfPlane, + -shadowMapHalfPlane, + shadowMapHalfPlane, + 0.05f, + 256.0f); + } else { + // just backwards compatibility. it's only used when SHADOWFOV is set in the shaders. + gluPerspective(shadowMapFOV, (float) shadowMapWidth / (float) shadowMapHeight, 0.05f, 256.0f); + } + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0f, 0.0f, -100.0f); + glRotatef(90.0f, 1.0f, 0.0f, 0.0f); + float celestialAngle = mc.theWorld.getCelestialAngle(f); + sunAngle = (celestialAngle < 0.75f) ? celestialAngle + 0.25f : celestialAngle - 0.75f; + float angle = celestialAngle * (-360.0f); + float angleInterval = + shadowAngleInterval > 0.0f ? (angle % shadowAngleInterval - (shadowAngleInterval * 0.5f)) : 0.0f; + if (sunAngle <= 0.5) { + // day time + glRotatef(angle - angleInterval, 0.0f, 0.0f, 1.0f); + glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); // rotate + shadowAngle = sunAngle; + } else { + // night time + glRotatef(angle + 180.0f - angleInterval, 0.0f, 0.0f, 1.0f); + glRotatef(sunPathRotation, 1.0f, 0.0f, 0.0f); // rotate + shadowAngle = sunAngle - 0.5f; + } + if (shadowMapIsOrtho) { + // reduces jitter + float trans = shadowIntervalSize; + float trans2 = trans / 2.0f; + glTranslatef((float) x % trans - trans2, (float) y % trans - trans2, (float) z % trans - trans2); + } + + glGetFloat(GL_PROJECTION_MATRIX, (FloatBuffer) shadowProjection.position(0)); + invertMat4x((FloatBuffer) shadowProjection.position(0), (FloatBuffer) shadowProjectionInverse.position(0)); + shadowProjection.position(0); + shadowProjectionInverse.position(0); + + glGetFloat(GL_MODELVIEW_MATRIX, (FloatBuffer) shadowModelView.position(0)); + invertMat4x((FloatBuffer) shadowModelView.position(0), (FloatBuffer) shadowModelViewInverse.position(0)); + shadowModelView.position(0); + shadowModelViewInverse.position(0); + + setProgramUniformMatrix4ARB("gbufferProjection", false, projection); + setProgramUniformMatrix4ARB("gbufferProjectionInverse", false, projectionInverse); + setProgramUniformMatrix4ARB("gbufferPreviousProjection", false, previousProjection); + setProgramUniformMatrix4ARB("gbufferModelView", false, modelView); + setProgramUniformMatrix4ARB("gbufferModelViewInverse", false, modelViewInverse); + setProgramUniformMatrix4ARB("gbufferPreviousModelView", false, previousModelView); + setProgramUniformMatrix4ARB("shadowProjection", false, shadowProjection); + setProgramUniformMatrix4ARB("shadowProjectionInverse", false, shadowProjectionInverse); + setProgramUniformMatrix4ARB("shadowModelView", false, shadowModelView); + setProgramUniformMatrix4ARB("shadowModelViewInverse", false, shadowModelViewInverse); + + // Also render player shadow + mc.gameSettings.thirdPersonView = 1; + checkGLError("setCamera"); + return; + } + checkGLError("setCamera"); + } + + public static void preCelestialRotate() { + Shaders.setUpPosition(); + GL11.glRotatef(Shaders.sunPathRotation * 1.0f, 0.0f, 0.0f, 1.0f); + checkGLError("preCelestialRotate"); + } + + public static void postCelestialRotate() { + // This is called when the current matrix is the modelview matrix based on the celestial angle. + // The sun is at (0, 100, 0), and the moon is at (0, -100, 0). + FloatBuffer modelView = tempMatrixDirectBuffer; + modelView.clear(); + glGetFloat(GL_MODELVIEW_MATRIX, modelView); + modelView.get(tempMat, 0, 16); + multiplyMat4xVec4(tempMat, sunPosModelView, sunPosition); + multiplyMat4xVec4(tempMat, moonPosModelView, moonPosition); + checkGLError("postCelestialRotate"); + } + + public static void setUpPosition() { + // Up direction in model view while rendering sky. + FloatBuffer modelView = tempMatrixDirectBuffer; + modelView.clear(); + glGetFloat(GL_MODELVIEW_MATRIX, modelView); + modelView.get(tempMat, 0, 16); + multiplyMat4xVec4(tempMat, upPosModelView, upPosition); + } + + private static float[] multiplyMat4xVec4(float[] matA, float[] vecB, float[] vecOut) { + vecOut[0] = matA[0] * vecB[0] + matA[4] * vecB[1] + matA[8] * vecB[2] + matA[12] * vecB[3]; + vecOut[1] = matA[1] * vecB[0] + matA[5] * vecB[1] + matA[9] * vecB[2] + matA[13] * vecB[3]; + vecOut[2] = matA[2] * vecB[0] + matA[6] * vecB[1] + matA[10] * vecB[2] + matA[14] * vecB[3]; + vecOut[3] = matA[3] * vecB[0] + matA[7] * vecB[1] + matA[11] * vecB[2] + matA[15] * vecB[3]; + return vecOut; + } + + static float[] invertMat4x_m = new float[16]; + static float[] invertMat4x_inv = new float[16]; + + private static FloatBuffer invertMat4x(FloatBuffer matIn, FloatBuffer invMatOut) { + float[] m = invertMat4x_m; + float[] inv = invertMat4x_inv; + float det; + int i; + + matIn.get(m); + + inv[0] = m[5] * m[10] * m[15] + - m[5] * m[11] * m[14] + - m[9] * m[6] * m[15] + + m[9] * m[7] * m[14] + + m[13] * m[6] * m[11] + - m[13] * m[7] * m[10]; + inv[4] = -m[4] * m[10] * m[15] + + m[4] * m[11] * m[14] + + m[8] * m[6] * m[15] + - m[8] * m[7] * m[14] + - m[12] * m[6] * m[11] + + m[12] * m[7] * m[10]; + inv[8] = m[4] * m[9] * m[15] + - m[4] * m[11] * m[13] + - m[8] * m[5] * m[15] + + m[8] * m[7] * m[13] + + m[12] * m[5] * m[11] + - m[12] * m[7] * m[9]; + inv[12] = -m[4] * m[9] * m[14] + + m[4] * m[10] * m[13] + + m[8] * m[5] * m[14] + - m[8] * m[6] * m[13] + - m[12] * m[5] * m[10] + + m[12] * m[6] * m[9]; + inv[1] = -m[1] * m[10] * m[15] + + m[1] * m[11] * m[14] + + m[9] * m[2] * m[15] + - m[9] * m[3] * m[14] + - m[13] * m[2] * m[11] + + m[13] * m[3] * m[10]; + inv[5] = m[0] * m[10] * m[15] + - m[0] * m[11] * m[14] + - m[8] * m[2] * m[15] + + m[8] * m[3] * m[14] + + m[12] * m[2] * m[11] + - m[12] * m[3] * m[10]; + inv[9] = -m[0] * m[9] * m[15] + + m[0] * m[11] * m[13] + + m[8] * m[1] * m[15] + - m[8] * m[3] * m[13] + - m[12] * m[1] * m[11] + + m[12] * m[3] * m[9]; + inv[13] = m[0] * m[9] * m[14] + - m[0] * m[10] * m[13] + - m[8] * m[1] * m[14] + + m[8] * m[2] * m[13] + + m[12] * m[1] * m[10] + - m[12] * m[2] * m[9]; + inv[2] = m[1] * m[6] * m[15] + - m[1] * m[7] * m[14] + - m[5] * m[2] * m[15] + + m[5] * m[3] * m[14] + + m[13] * m[2] * m[7] + - m[13] * m[3] * m[6]; + inv[6] = -m[0] * m[6] * m[15] + + m[0] * m[7] * m[14] + + m[4] * m[2] * m[15] + - m[4] * m[3] * m[14] + - m[12] * m[2] * m[7] + + m[12] * m[3] * m[6]; + inv[10] = m[0] * m[5] * m[15] + - m[0] * m[7] * m[13] + - m[4] * m[1] * m[15] + + m[4] * m[3] * m[13] + + m[12] * m[1] * m[7] + - m[12] * m[3] * m[5]; + inv[14] = -m[0] * m[5] * m[14] + + m[0] * m[6] * m[13] + + m[4] * m[1] * m[14] + - m[4] * m[2] * m[13] + - m[12] * m[1] * m[6] + + m[12] * m[2] * m[5]; + inv[3] = -m[1] * m[6] * m[11] + + m[1] * m[7] * m[10] + + m[5] * m[2] * m[11] + - m[5] * m[3] * m[10] + - m[9] * m[2] * m[7] + + m[9] * m[3] * m[6]; + inv[7] = m[0] * m[6] * m[11] + - m[0] * m[7] * m[10] + - m[4] * m[2] * m[11] + + m[4] * m[3] * m[10] + + m[8] * m[2] * m[7] + - m[8] * m[3] * m[6]; + inv[11] = -m[0] * m[5] * m[11] + + m[0] * m[7] * m[9] + + m[4] * m[1] * m[11] + - m[4] * m[3] * m[9] + - m[8] * m[1] * m[7] + + m[8] * m[3] * m[5]; + inv[15] = m[0] * m[5] * m[10] + - m[0] * m[6] * m[9] + - m[4] * m[1] * m[10] + + m[4] * m[2] * m[9] + + m[8] * m[1] * m[6] + - m[8] * m[2] * m[5]; + + det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12]; + + if (det != 0.0) { + for (i = 0; i < 16; ++i) inv[i] /= det; + } else { + // no inverse + Arrays.fill(inv, 0); + } + + invMatOut.put(inv); + + return invMatOut; + } + + public static void genCompositeMipmap() { + if (hasGlGenMipmap) { + if ((activeCompositeMipmapSetting & (1 << 0)) != 0) { + glActiveTexture(GL_TEXTURE0); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1 << 1)) != 0) { + glActiveTexture(GL_TEXTURE1); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1 << 2)) != 0) { + glActiveTexture(GL_TEXTURE2); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + if ((activeCompositeMipmapSetting & (1 << 3)) != 0) { + glActiveTexture(GL_TEXTURE3); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + + for (int i = 0; i < 4 && 4 + i < usedColorBuffers; ++i) { + if ((activeCompositeMipmapSetting & ((1 << 4) << i)) != 0) { + glActiveTexture(GL_TEXTURE7 + i); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glGenerateMipmap(GL_TEXTURE_2D); + } + } + + glActiveTexture(GL_TEXTURE0); + } + } + + public static void drawComposite() { + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + glBegin(GL_QUADS); + glTexCoord2f(0.0f, 0.0f); + glVertex3f(0.0f, 0.0f, 0.0f); + glTexCoord2f(1.0f, 0.0f); + glVertex3f(1.0f, 0.0f, 0.0f); + glTexCoord2f(1.0f, 1.0f); + glVertex3f(1.0f, 1.0f, 0.0f); + glTexCoord2f(0.0f, 1.0f); + glVertex3f(0.0f, 1.0f, 0.0f); + glEnd(); + } + + public static void renderCompositeFinal() { + if (isShadowPass) { + // useProgram(ProgramNone); + return; + } + + checkGLError("pre-renderCompositeFinal"); + // fogColorR = clearColorR; + // fogColorG = clearColorG; + // fogColorB = clearColorB; + + // glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glLoadIdentity(); + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glLoadIdentity(); + glOrtho(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + glEnable(GL_TEXTURE_2D); + glDisable(GL_ALPHA_TEST); + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_ALWAYS); + glDepthMask(false); + + // textures + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(0)); + + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(1)); + + glActiveTexture(GL_TEXTURE2); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(2)); + + glActiveTexture(GL_TEXTURE3); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(3)); + + if (usedShadowDepthBuffers >= 1) { + glActiveTexture(GL_TEXTURE4); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(0)); + if (usedShadowDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE5); + glBindTexture(GL_TEXTURE_2D, sfbDepthTextures.get(1)); + } + } + + for (int i = 0; i < 4 && 4 + i < usedColorBuffers; ++i) { + glActiveTexture(GL_TEXTURE7 + i); + glBindTexture(GL_TEXTURE_2D, dfbColorTextures.get(4 + i)); + } + + glActiveTexture(GL_TEXTURE6); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(0)); + + if (usedDepthBuffers >= 2) { + glActiveTexture(GL_TEXTURE11); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(1)); + + if (usedDepthBuffers >= 3) { + glActiveTexture(GL_TEXTURE12); + glBindTexture(GL_TEXTURE_2D, dfbDepthTextures.get(2)); + } + } + + for (int i = 0; i < usedShadowColorBuffers; ++i) { + glActiveTexture(GL_TEXTURE13 + i); + glBindTexture(GL_TEXTURE_2D, sfbColorTextures.get(i)); + } + + if (noiseTextureEnabled) { + glActiveTexture(GL_TEXTURE0 + noiseTexture.textureUnit); + glBindTexture(GL_TEXTURE_2D, noiseTexture.getID()); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); + } + + glActiveTexture(GL_TEXTURE0); + + // set depth buffer + glFramebufferTexture2DEXT( + GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTextures.get(0), 0); + // detach depth buffer + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0); + + // composite + glDrawBuffers(dfbDrawBuffers); + checkGLError("pre-composite"); + + for (int i = 0; i < MaxCompositePasses; ++i) { + if (programsID[ProgramComposite + i] != 0) { + useProgram(ProgramComposite + i); + checkGLError(programNames[ProgramComposite + i]); + if (activeCompositeMipmapSetting != 0) genCompositeMipmap(); + drawComposite(); + } + } + + // reattach depth buffer + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); + + // final render target + isRenderingDfb = false; + // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + // GL11.glViewport(0, 0, mc.displayWidth, mc.displayHeight); + mc.getFramebuffer().bindFramebuffer(true); + if (EntityRenderer.anaglyphEnable) { + boolean maskR = (EntityRenderer.anaglyphField != 0); + glColorMask(maskR, !maskR, !maskR, true); + } + glDepthMask(true); + glClearColor(clearColorR, clearColorG, clearColorB, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + glEnable(GL_TEXTURE_2D); + glDisable(GL_ALPHA_TEST); + glDisable(GL_BLEND); + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_ALWAYS); + glDepthMask(false); + + // final + checkGLError("pre-final"); + useProgram(ProgramFinal); + checkGLError("final"); + if (activeCompositeMipmapSetting != 0) genCompositeMipmap(); + drawComposite(); + + // Read gl_FragColor + // ByteBuffer centerPixelColor = ByteBuffer.allocateDirect(3); + // glReadPixels(renderWidth / 2, renderHeight / 2, 1, 1, GL11.GL_RGB, GL11.GL_BYTE, centerPixelColor); + // System.out.println(centerPixelColor.get(0)); + + // end + checkGLError("renderCompositeFinal"); + isCompositeRendered = true; + glEnable(GL_TEXTURE_2D); + glEnable(GL_ALPHA_TEST); + glEnable(GL_BLEND); + glDepthFunc(GL_LEQUAL); + glDepthMask(true); + + // glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); + glPopMatrix(); + + useProgram(ProgramNone); + } + + public static void endRender() { + if (isShadowPass) { + // useProgram(ProgramNone); + checkGLError("shadow endRender"); + return; + } + + if (!isCompositeRendered) renderCompositeFinal(); + isRenderingWorld = false; + + glColorMask(true, true, true, true); + glEnable(GL_BLEND); + useProgram(ProgramNone); + checkGLError("endRender end"); + + // defaultTexture.bind(); + } + + public static void beginSky() { + isRenderingSky = true; + fogEnabled = true; + setDrawBuffers(dfbDrawBuffers); + useProgram(ProgramSkyTextured); + pushEntity(-2, 0); + } + + public static void setSkyColor(Vec3 v3color) { + skyColorR = (float) v3color.xCoord; + skyColorG = (float) v3color.yCoord; + skyColorB = (float) v3color.zCoord; + setProgramUniform3f("skyColor", skyColorR, skyColorG, skyColorB); + } + + public static void drawHorizon() { + Tessellator tess = Tessellator.instance; + float farDistance = mc.gameSettings.renderDistanceChunks * 16; + double xzq = farDistance * 0.9238; + double xzp = farDistance * 0.3826; + double xzn = -xzp; + double xzm = -xzq; + double top = 16f; // 256f-cameraPosition[1]; + double bot = -cameraPosition[1]; + + tess.startDrawingQuads(); + // horizon + tess.addVertex(xzn, bot, xzm); + tess.addVertex(xzn, top, xzm); + tess.addVertex(xzm, top, xzn); + tess.addVertex(xzm, bot, xzn); + + tess.addVertex(xzm, bot, xzn); + tess.addVertex(xzm, top, xzn); + tess.addVertex(xzm, top, xzp); + tess.addVertex(xzm, bot, xzp); + + tess.addVertex(xzm, bot, xzp); + tess.addVertex(xzm, top, xzp); + tess.addVertex(xzn, top, xzp); + tess.addVertex(xzn, bot, xzp); + + tess.addVertex(xzn, bot, xzp); + tess.addVertex(xzn, top, xzp); + tess.addVertex(xzp, top, xzq); + tess.addVertex(xzp, bot, xzq); + + tess.addVertex(xzp, bot, xzq); + tess.addVertex(xzp, top, xzq); + tess.addVertex(xzq, top, xzp); + tess.addVertex(xzq, bot, xzp); + + tess.addVertex(xzq, bot, xzp); + tess.addVertex(xzq, top, xzp); + tess.addVertex(xzq, top, xzn); + tess.addVertex(xzq, bot, xzn); + + tess.addVertex(xzq, bot, xzn); + tess.addVertex(xzq, top, xzn); + tess.addVertex(xzp, top, xzm); + tess.addVertex(xzp, bot, xzm); + + tess.addVertex(xzp, bot, xzm); + tess.addVertex(xzp, top, xzm); + tess.addVertex(xzn, top, xzm); + tess.addVertex(xzn, bot, xzm); + // bottom + // tess.addVertex(xzm, bot, xzm); + // tess.addVertex(xzm, bot, xzq); + // tess.addVertex(xzq, bot, xzq); + // tess.addVertex(xzq, bot, xzm); + + tess.draw(); + } + + public static void preSkyList() { + GL11.glColor3f(fogColorR, fogColorG, fogColorB); + // GL11.glColor3f(0f, 1f, 0f); + // glDisable(GL_FOG); + + drawHorizon(); + + // glEnable(GL_FOG); + GL11.glColor3f(skyColorR, skyColorG, skyColorB); + } + + public static void endSky() { + isRenderingSky = false; + setDrawBuffers(dfbDrawBuffers); + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + popEntity(); + } + + // public static void beginSunMoon() { + // useProgram(ProgramNone); + // } + + // public static void endSunMoon() { + // useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + // } + public static void beginUpdateChunks() { + // System.out.println("beginUpdateChunks"); + checkGLError("beginUpdateChunks1"); + checkFramebufferStatus("beginUpdateChunks1"); + if (!isShadowPass) { + useProgram(ProgramTerrain); + } + checkGLError("beginUpdateChunks2"); + checkFramebufferStatus("beginUpdateChunks2"); + } + + public static void endUpdateChunks() { + // System.out.println("endUpdateChunks"); + checkGLError("endUpdateChunks1"); + checkFramebufferStatus("endUpdateChunks1"); + if (!isShadowPass) { + useProgram(ProgramTerrain); + } + checkGLError("endUpdateChunks2"); + checkFramebufferStatus("endUpdateChunks2"); + } + + public static boolean shouldRenderClouds(GameSettings gs) { + checkGLError("shouldRenderClouds"); + return isShadowPass ? configCloudShadow : gs.clouds; + } + + public static void beginClouds() { + fogEnabled = true; + pushEntity(-3, 0); + useProgram(ProgramTextured); + } + + public static void endClouds() { + disableFog(); + popEntity(); + } + + public static void beginTerrain() { + if (isRenderingWorld) { + if (isShadowPass) { + glDisable(GL11.GL_CULL_FACE); + } + fogEnabled = true; + useProgram(Shaders.ProgramTerrain); + // ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); // flat + } + } + + public static void endTerrain() { + if (isRenderingWorld) { + if (isShadowPass) { + glEnable(GL11.GL_CULL_FACE); + } + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + // ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); // flat + } + } + + public static void beginBlockEntities() { + if (isRenderingWorld) { + checkGLError("beginBlockEntities"); + useProgram(Shaders.ProgramTerrain); + } + } + + public static void endBlockEntities() { + if (isRenderingWorld) { + checkGLError("endBlockEntities"); + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); + } + } + + public static void beginBlockDestroyProgress() { + if (isRenderingWorld) { + useProgram(ProgramTerrain); + if (Shaders.configTweakBlockDamage) { + setDrawBuffers(drawBuffersColorAtt0); + glDepthMask(false); + // GL14.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA,GL11.GL_ONE,GL11.GL_ZERO); + } + } + } + + public static void endBlockDestroyProgress() { + if (isRenderingWorld) { + glDepthMask(true); + useProgram(ProgramTexturedLit); + } + } + + public static void beginEntities() { + if (isRenderingWorld) { + useProgram(ProgramEntities); + if (programsID[activeProgram] != 0) { + useEntityHurtFlash = (uniformEntityHurt != -1) || (uniformEntityFlash != -1); + if (uniformEntityHurt != -1) glUniform1iARB(uniformEntityHurt, 0); + if (uniformEntityHurt != -1) glUniform1iARB(uniformEntityFlash, 0); + } else { + useEntityHurtFlash = false; + } + } + } + + public static void nextEntity() { + if (isRenderingWorld) { + useProgram(ProgramEntities); + } + } + + public static void beginSpiderEyes() { + if (isRenderingWorld) { + useProgram(ProgramSpiderEyes); + if (programsID[ProgramSpiderEyes] == programsID[ProgramTextured]) { + GL11.glEnable(GL11.GL_ALPHA_TEST); + GL11.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE); + } + } + } + + public static void endEntities() { + if (isRenderingWorld) { + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + } + } + + public static void setEntityHurtFlash(int hurt, int flash) { + if (useEntityHurtFlash && isRenderingWorld && !isShadowPass) { + if (uniformEntityHurt != -1) glUniform1iARB(uniformEntityHurt, hurt); + if (uniformEntityFlash != -1) glUniform1iARB(uniformEntityFlash, flash >> 24); + checkGLError("setEntityHurtFlash"); + } + } + + public static void resetEntityHurtFlash() { + setEntityHurtFlash(0, 0); + } + + public static void beginLivingDamage() { + if (isRenderingWorld) { + ShadersTex.bindTexture(defaultTexture); + if (!isShadowPass) { + // useProgram(ProgramBasic); + setDrawBuffers(drawBuffersColorAtt0); + } + } + } + + public static void endLivingDamage() { + if (isRenderingWorld) { + if (!isShadowPass) { + // useProgram(ProgramEntities); + setDrawBuffers(programsDrawBuffers[ProgramEntities]); + } + } + } + + public static void beginLitParticles() { + // GL11.glDepthMask(false); + Tessellator.instance.setNormal(0f, 0f, 0f); + useProgram(ProgramTexturedLit); + } + + public static void beginParticles() { + // GL11.glDepthMask(false); + Tessellator.instance.setNormal(0f, 0f, 0f); + useProgram(ProgramTextured); + } + + public static void endParticles() { + Tessellator.instance.setNormal(0f, 0f, 0f); + useProgram(ProgramTexturedLit); + } + + public static void preWater() { + if (isShadowPass) { + if (usedShadowDepthBuffers >= 2) { + // copy depth buffer to shadowtex1 + glActiveTexture(GL_TEXTURE5); + checkGLError("pre copy shadow depth"); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowMapWidth, shadowMapHeight); + checkGLError("copy shadow depth"); + glActiveTexture(GL_TEXTURE0); + } + } else { + if (usedDepthBuffers >= 2) { + // copy depth buffer to depthtex1 + glActiveTexture(GL_TEXTURE11); + checkGLError("pre copy depth"); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); + checkGLError("copy depth"); + glActiveTexture(GL_TEXTURE0); + } + ShadersTex.bindNSTextures(defaultTexture.getMultiTexID()); // flat + } + } + + // public static void beginWaterFancy() { + // if (isRenderingWorld) + // { + // if (!isShadowPass) { + // // program water + // useProgram(Shaders.ProgramWater); + // GL11.glEnable(GL11.GL_BLEND); + // //setDrawBuffers(drawBuffersNone); + // } + // } + // } + // + // public static void midWaterFancy() { + // if (isRenderingWorld) + // { + // if (!isShadowPass) { + // setDrawBuffers(programsDrawBuffers[Shaders.ProgramWater]); + // } + // } + // } + + public static void beginWater() { + if (isRenderingWorld) { + if (!isShadowPass) { + // program water + useProgram(Shaders.ProgramWater); + GL11.glEnable(GL11.GL_BLEND); + GL11.glDepthMask(true); + } else { + GL11.glDepthMask(true); + } + } + } + + public static void endWater() { + if (isRenderingWorld) { + if (isShadowPass) { + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, + // sfbDepthTexture, 0); + } else { + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, + // dfbDepthTexture, 0); + } + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + } + } + + public static void readCenterDepth() { + if (!isShadowPass) { + // Read depth buffer at center of screen for DOF + if (centerDepthSmoothEnabled) { + tempDirectFloatBuffer.clear(); + glReadPixels( + renderWidth / 2, + renderHeight / 2, + 1, + 1, + GL11.GL_DEPTH_COMPONENT, + GL11.GL_FLOAT, + tempDirectFloatBuffer); + centerDepth = tempDirectFloatBuffer.get(0); + + // Smooth depth value + float fadeScalar = diffSystemTime * 0.01f; + float fadeFactor = (float) Math.exp(Math.log(0.5) * fadeScalar / centerDepthSmoothHalflife); + centerDepthSmooth = centerDepthSmooth * (fadeFactor) + centerDepth * (1 - fadeFactor); + } + } + } + + public static void beginWeather() { + if (!isShadowPass) { + if (usedDepthBuffers >= 3) { + // copy depth buffer to depthtex2 + glActiveTexture(GL_TEXTURE12); + glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, renderWidth, renderHeight); + glActiveTexture(GL_TEXTURE0); + } + // GL11.glDepthMask(false); + glEnable(GL_DEPTH_TEST); + glEnable(GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_ALPHA_TEST); + useProgram(Shaders.ProgramWeather); + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, + // dfbWaterDepthTexture, 0); + } + + // if (isShadowPass) { + // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // will be set to sbf in endHand() + // } + } + + public static void endWeather() { + // GL11.glDepthMask(true); + glDisable(GL_BLEND); + useProgram(ProgramTexturedLit); + // glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, dfbDepthTexture, 0); + + // if (isShadowPass) { + // glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sfb); // was set to 0 in beginWeather() + // } + } + + public static void beginProjectRedHalo() { + useProgram(ProgramBasic); + } + + public static void endProjectRedHalo() { + useProgram(ProgramTexturedLit); + } + + public static void applyHandDepth() { + if (Shaders.configHandDepthMul != 1.0) { + GL11.glScaled(1.0, 1.0, Shaders.configHandDepthMul); + } + } + + public static void beginHand() { + // glEnable(GL_BLEND); + // glDisable(GL_BLEND); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glMatrixMode(GL_MODELVIEW); + useProgram(Shaders.ProgramHand); + checkGLError("beginHand"); + checkFramebufferStatus("beginHand"); + } + + public static void endHand() { + // glDisable(GL_BLEND); + checkGLError("pre endHand"); + checkFramebufferStatus("pre endHand"); + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); + glPopMatrix(); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + // useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + checkGLError("endHand"); + } + + public static void beginFPOverlay() { + // GL11.glDisable(GL11.GL_BLEND); + // GL11.glEnable(GL11.GL_BLEND); + // GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + } + + public static void endFPOverlay() { + // GL11.glDisable(GL11.GL_BLEND); + } + + // ---------------------------------------- + + public static void glEnableWrapper(int cap) { + glEnable(cap); + if (cap == GL_TEXTURE_2D) enableTexture2D(); + else if (cap == GL_FOG) enableFog(); + } + + public static void glDisableWrapper(int cap) { + glDisable(cap); + if (cap == GL_TEXTURE_2D) disableTexture2D(); + else if (cap == GL_FOG) disableFog(); + } + + public static void sglEnableT2D(int cap) { + glEnable(cap); // GL_TEXTURE_2D + enableTexture2D(); + } + + public static void sglDisableT2D(int cap) { + glDisable(cap); // GL_TEXTURE_2D + disableTexture2D(); + } + + public static void sglEnableFog(int cap) { + glEnable(cap); // GL_FOG + enableFog(); + } + + public static void sglDisableFog(int cap) { + glDisable(cap); // GL_FOG + disableFog(); + } + + public static void enableTexture2D() { + if (isRenderingSky) { + useProgram(ProgramSkyTextured); + } else if (activeProgram == ProgramBasic) { + useProgram(lightmapEnabled ? ProgramTexturedLit : ProgramTextured); + } + } + + public static void disableTexture2D() { + if (isRenderingSky) { + useProgram(ProgramSkyBasic); + } else if (activeProgram == ProgramTextured || activeProgram == ProgramTexturedLit) { + useProgram(ProgramBasic); + } + } + + public static void enableFog() { + fogEnabled = true; + setProgramUniform1i("fogMode", fogMode); + } + + public static void disableFog() { + fogEnabled = false; + setProgramUniform1i("fogMode", 0); + } + + public static void sglFogi(int pname, int param) { + GL11.glFogi(pname, param); + if (pname == GL11.GL_FOG_MODE) { + fogMode = param; + if (fogEnabled) setProgramUniform1i("fogMode", fogMode); + } + } + + public static void enableLightmap() { + lightmapEnabled = true; + if (activeProgram == ProgramTextured) { + useProgram(ProgramTexturedLit); + } + } + + public static void disableLightmap() { + lightmapEnabled = false; + if (activeProgram == ProgramTexturedLit) { + useProgram(ProgramTextured); + } + } + + public static int entityData[] = new int[32]; + public static int entityDataIndex = 0; + + public static int getEntityData() { + return entityData[entityDataIndex * 2]; + } + + public static int getEntityData2() { + return entityData[entityDataIndex * 2 + 1]; + } + + public static int setEntityData1(int data1) { + entityData[entityDataIndex * 2] = (entityData[entityDataIndex * 2] & 0xFFFF) | (data1 << 16); + return data1; + } + + public static int setEntityData2(int data2) { + entityData[entityDataIndex * 2 + 1] = (entityData[entityDataIndex * 2 + 1] & 0xFFFF0000) | (data2 & 0xFFFF); + return data2; + } + + public static void pushEntity(int data0, int data1) { + entityDataIndex++; + entityData[entityDataIndex * 2] = (data0 & 0xFFFF) | (data1 << 16); + entityData[entityDataIndex * 2 + 1] = 0; + } + + public static void pushEntity(int data0) { + entityDataIndex++; + entityData[entityDataIndex * 2] = (data0 & 0xFFFF); + entityData[entityDataIndex * 2 + 1] = 0; + } + + public static void pushEntity(Block block) { + entityDataIndex++; + entityData[entityDataIndex * 2] = + (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); + entityData[entityDataIndex * 2 + 1] = 0; + } + + public static void pushEntity(RenderBlocks rb, Block block, int x, int y, int z) { + entityDataIndex++; + entityData[entityDataIndex * 2] = + (block.blockRegistry.getIDForObject(block) & 0xFFFF) | (block.getRenderType() << 16); + entityData[entityDataIndex * 2 + 1] = rb.blockAccess.getBlockMetadata(x, y, z); + } + + public static void popEntity() { + entityData[entityDataIndex * 2] = 0; + entityData[entityDataIndex * 2 + 1] = 0; + entityDataIndex--; + } + + // ---------------------------------------- + +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShadersRender.java b/src/main/java/com/gtnewhorizons/angelica/client/ShadersRender.java new file mode 100644 index 000000000..f31675fcc --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShadersRender.java @@ -0,0 +1,87 @@ +package com.gtnewhorizons.angelica.client; + +import java.nio.IntBuffer; +import net.minecraft.block.Block; +import net.minecraft.block.BlockIce; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.ItemRenderer; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.client.renderer.WorldRenderer; +import net.minecraft.client.renderer.culling.Frustrum; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import org.lwjgl.opengl.GL11; + +public class ShadersRender { + + public static void setFrustrumPosition(Frustrum frustrum, double x, double y, double z) { + frustrum.setPosition(x, y, z); + } + + public static void clipRenderersByFrustrum(RenderGlobal renderGlobal, Frustrum frustrum, float par2) { + Shaders.checkGLError("pre clip"); + if (!Shaders.isShadowPass) { + WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; + for (int i = 0; i < worldRenderers.length; ++i) { + if (!worldRenderers[i].skipAllRenderPasses()) { + worldRenderers[i].updateInFrustum(frustrum); + } + } + } else { + WorldRenderer[] worldRenderers = renderGlobal.worldRenderers; + for (int i = 0; i < worldRenderers.length; ++i) { + if (!worldRenderers[i].skipAllRenderPasses()) { + worldRenderers[i].isInFrustum = true; + } + } + } + } + + public static void renderHand0(EntityRenderer er, float par1, int par2) { + if (!Shaders.isShadowPass) { + Item item = (Shaders.itemToRender != null) ? Shaders.itemToRender.getItem() : null; + Block block = (item instanceof ItemBlock) ? ((ItemBlock) item).field_150939_a : null; + // ItemCloth is for semitransparent block : stained glass, wool + if (!(item instanceof ItemBlock) && !(block instanceof BlockIce)) { + Shaders.readCenterDepth(); + Shaders.beginHand(); + er.renderHand(par1, par2); + Shaders.endHand(); + Shaders.isHandRendered = true; + } + } + } + + public static void renderHand1(EntityRenderer er, float par1, int par2) { + if (!Shaders.isShadowPass) { + if (!Shaders.isHandRendered) { + Shaders.readCenterDepth(); + GL11.glEnable(GL11.GL_BLEND); + Shaders.beginHand(); + er.renderHand(par1, par2); + Shaders.endHand(); + Shaders.isHandRendered = true; + } + } + } + + public static void renderItemFP(ItemRenderer itemRenderer, float par1) { + // clear depth buffer locally + GL11.glDepthFunc(GL11.GL_GEQUAL); + GL11.glPushMatrix(); + IntBuffer drawBuffers = Shaders.activeDrawBuffers; + Shaders.setDrawBuffers(Shaders.drawBuffersNone); + itemRenderer.renderItemInFirstPerson(par1); + Shaders.setDrawBuffers(drawBuffers); + GL11.glPopMatrix(); + GL11.glDepthFunc(GL11.GL_LEQUAL); + // really render item or hand + itemRenderer.renderItemInFirstPerson(par1); + } + + public static void renderFPOverlay(EntityRenderer er, float par1, int par2) { + Shaders.beginFPOverlay(); + er.renderHand(par1, par2); + Shaders.endFPOverlay(); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShadersTess.java b/src/main/java/com/gtnewhorizons/angelica/client/ShadersTess.java new file mode 100644 index 000000000..b9662b35e --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShadersTess.java @@ -0,0 +1,243 @@ +package com.gtnewhorizons.angelica.client; + +import static org.lwjgl.opengl.ARBVertexShader.glDisableVertexAttribArrayARB; +import static org.lwjgl.opengl.ARBVertexShader.glEnableVertexAttribArrayARB; +import static org.lwjgl.opengl.ARBVertexShader.glVertexAttribPointerARB; + +import com.gtnewhorizons.angelica.transform.SMCLog; +import java.nio.FloatBuffer; +import java.nio.ShortBuffer; +import java.util.Arrays; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.Tessellator; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL13; + +public class ShadersTess { + + public static final int vertexStride = 16; + + public static int draw(Tessellator tess) { + if (!tess.isDrawing) { + throw new IllegalStateException("Not tesselating!"); + } else { + tess.isDrawing = false; + if (tess.drawMode == GL11.GL_QUADS && tess.vertexCount % 4 != 0) { + SMCLog.warning("%s", "bad vertexCount"); + } + int voffset = 0; + int realDrawMode = tess.drawMode; + while (voffset < tess.vertexCount) { + int vcount; + vcount = Math.min(tess.vertexCount - voffset, tess.byteBuffer.capacity() / (vertexStride * 4)); + if (realDrawMode == GL11.GL_QUADS) vcount = vcount / 4 * 4; + tess.floatBuffer.clear(); + tess.shortBuffer.clear(); + tess.intBuffer.clear(); + tess.intBuffer.put(tess.rawBuffer, voffset * vertexStride, vcount * vertexStride); + tess.byteBuffer.position(0); + tess.byteBuffer.limit(vcount * (vertexStride * 4)); + voffset += vcount; + + if (tess.hasTexture) { + tess.floatBuffer.position(3); + GL11.glTexCoordPointer(2, (vertexStride * 4), tess.floatBuffer); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + } + if (tess.hasBrightness) { + OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); + tess.shortBuffer.position(6 * 2); + GL11.glTexCoordPointer(2, (vertexStride * 4), tess.shortBuffer); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); + } + if (tess.hasColor) { + tess.byteBuffer.position(5 * 4); + GL11.glColorPointer(4, true, (vertexStride * 4), tess.byteBuffer); + GL11.glEnableClientState(GL11.GL_COLOR_ARRAY); + } + if (tess.hasNormals) { + tess.floatBuffer.position(9); + GL11.glNormalPointer((vertexStride * 4), tess.floatBuffer); + GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY); + } + tess.floatBuffer.position(0); + GL11.glVertexPointer(3, (vertexStride * 4), tess.floatBuffer); + ShadersTess.preDrawArray(tess); + + GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY); + GL11.glDrawArrays(realDrawMode, 0, vcount); + } + // end loop + + GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY); + ShadersTess.postDrawArray(tess); + if (tess.hasTexture) { + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + } + if (tess.hasBrightness) { + OpenGlHelper.setClientActiveTexture(OpenGlHelper.lightmapTexUnit); + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit); + } + if (tess.hasColor) { + GL11.glDisableClientState(GL11.GL_COLOR_ARRAY); + } + if (tess.hasNormals) { + GL11.glDisableClientState(GL11.GL_NORMAL_ARRAY); + } + + int n = tess.rawBufferIndex * 4; + tess.reset(); + return n; + } + } + + public static void preDrawArray(Tessellator tess) { + // Shaders.checkGLError("preDrawArray"); + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glTexCoordPointer(2, (vertexStride * 4), (FloatBuffer) tess.floatBuffer.position(12)); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) { + glVertexAttribPointerARB( + Shaders.midTexCoordAttrib, 2, false, vertexStride * 4, (FloatBuffer) tess.floatBuffer.position(12)); + glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useEntityAttrib) { + glVertexAttribPointerARB(Shaders.entityAttrib, 3, false, false, vertexStride * 4, (ShortBuffer) + tess.shortBuffer.position(7 * 2)); + glEnableVertexAttribArrayARB(Shaders.entityAttrib); + } + // Shaders.checkGLError("preDrawArray"); + } + + public static void preDrawArrayVBO(Tessellator tess) { + // Shaders.checkGLError("preDrawArray"); + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glTexCoordPointer(2, GL11.GL_FLOAT, (vertexStride * 4), 12 * 4L); + GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) { + glVertexAttribPointerARB(Shaders.midTexCoordAttrib, 2, GL11.GL_FLOAT, false, vertexStride * 4, 12 * 4L); + glEnableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useEntityAttrib) { + glVertexAttribPointerARB(Shaders.entityAttrib, 3, GL11.GL_SHORT, false, vertexStride * 4, 7 * 4L); + glEnableVertexAttribArrayARB(Shaders.entityAttrib); + } + // Shaders.checkGLError("preDrawArray"); + } + + public static void postDrawArray(Tessellator tess) { + // Shaders.checkGLError("postDrawArray"); + if (Shaders.useEntityAttrib) { + glDisableVertexAttribArrayARB(Shaders.entityAttrib); + } + if (Shaders.useMidTexCoordAttrib && tess.hasTexture) { + glDisableVertexAttribArrayARB(Shaders.midTexCoordAttrib); + } + if (Shaders.useMultiTexCoord3Attrib && tess.hasTexture) { + GL13.glClientActiveTexture(GL13.GL_TEXTURE3); + GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY); + GL13.glClientActiveTexture(GL13.GL_TEXTURE0); + } + // Shaders.checkGLError("postDrawArray"); + } + + public static void addVertex(Tessellator tess, double parx, double pary, double parz) { + int[] rawBuffer = tess.rawBuffer; + int rbi = tess.rawBufferIndex; + float fx = (float) (parx + tess.xOffset); + float fy = (float) (pary + tess.yOffset); + float fz = (float) (parz + tess.zOffset); + // Check if buffer is nearly full + if (rbi >= tess.bufferSize - vertexStride * 4) { + if (tess.bufferSize >= 0x1000000) { + // Max size reached. Just draw. + if (tess.addedVertices % 4 == 0) { + tess.draw(); + tess.isDrawing = true; + } + } else if (tess.bufferSize > 0) { + // Expand + tess.bufferSize *= 2; + tess.rawBuffer = rawBuffer = Arrays.copyOf(tess.rawBuffer, tess.bufferSize); + System.out.format("Expand tesselator buffer %d\n", tess.bufferSize); + } else { + // Initialize + tess.bufferSize = 0x10000; + tess.rawBuffer = rawBuffer = new int[tess.bufferSize]; + } + } + + // shaders mod calculate normal and mid UV + if (tess.drawMode == 7) { + int i = tess.addedVertices % 4; + float[] vertexPos = tess.vertexPos; + vertexPos[i * 4 + 0] = fx; + vertexPos[i * 4 + 1] = fy; + vertexPos[i * 4 + 2] = fz; + if (i == 3) { + // calculate normal + float x1 = vertexPos[8 + 0] - vertexPos[+0]; + float y1 = vertexPos[8 + 1] - vertexPos[+1]; + float z1 = vertexPos[8 + 2] - vertexPos[+2]; + float x2 = vertexPos[12 + 0] - vertexPos[4 + 0]; + float y2 = vertexPos[12 + 1] - vertexPos[4 + 1]; + float z2 = vertexPos[12 + 2] - vertexPos[4 + 2]; + float vnx = y1 * z2 - y2 * z1; + float vny = z1 * x2 - z2 * x1; + float vnz = x1 * y2 - x2 * y1; + float lensq = vnx * vnx + vny * vny + vnz * vnz; + float mult = (lensq != 0.0) ? (float) (1f / Math.sqrt(lensq)) : 1f; + rawBuffer[rbi + (9 - vertexStride * 3)] = rawBuffer[rbi + (9 - vertexStride * 2)] = + rawBuffer[rbi + (9 - vertexStride * 1)] = Float.floatToRawIntBits(tess.normalX = vnx * mult); + rawBuffer[rbi + (10 - vertexStride * 3)] = rawBuffer[rbi + (10 - vertexStride * 2)] = + rawBuffer[rbi + (10 - vertexStride * 1)] = Float.floatToRawIntBits(tess.normalY = vny * mult); + rawBuffer[rbi + (11 - vertexStride * 3)] = rawBuffer[rbi + (11 - vertexStride * 2)] = + rawBuffer[rbi + (11 - vertexStride * 1)] = Float.floatToRawIntBits(tess.normalZ = vnz * mult); + tess.hasNormals = true; + // mid UV + tess.midTextureU = (Float.intBitsToFloat(rawBuffer[rbi + (3 - vertexStride * 3)]) + + Float.intBitsToFloat(rawBuffer[rbi + (3 - vertexStride * 2)]) + + Float.intBitsToFloat(rawBuffer[rbi + (3 - vertexStride * 1)]) + + (float) tess.textureU) + / 4; + tess.midTextureV = (Float.intBitsToFloat(rawBuffer[rbi + (4 - vertexStride * 3)]) + + Float.intBitsToFloat(rawBuffer[rbi + (4 - vertexStride * 2)]) + + Float.intBitsToFloat(rawBuffer[rbi + (4 - vertexStride * 1)]) + + (float) tess.textureV) + / 4; + rawBuffer[rbi + (12 - vertexStride * 3)] = rawBuffer[rbi + (12 - vertexStride * 2)] = + rawBuffer[rbi + (12 - vertexStride * 1)] = Float.floatToRawIntBits(tess.midTextureU); + rawBuffer[rbi + (13 - vertexStride * 3)] = rawBuffer[rbi + (13 - vertexStride * 2)] = + rawBuffer[rbi + (13 - vertexStride * 1)] = Float.floatToRawIntBits(tess.midTextureV); + } + } + // end normal and mid UV calculation + + ++tess.addedVertices; + rawBuffer[rbi + 0] = Float.floatToRawIntBits((float) fx); + rawBuffer[rbi + 1] = Float.floatToRawIntBits((float) fy); + rawBuffer[rbi + 2] = Float.floatToRawIntBits((float) fz); + rawBuffer[rbi + 3] = Float.floatToRawIntBits((float) tess.textureU); + rawBuffer[rbi + 4] = Float.floatToRawIntBits((float) tess.textureV); + rawBuffer[rbi + 5] = tess.color; + rawBuffer[rbi + 6] = tess.brightness; + rawBuffer[rbi + 7] = Shaders.getEntityData(); + rawBuffer[rbi + 8] = Shaders.getEntityData2(); + rawBuffer[rbi + 9] = Float.floatToRawIntBits((float) tess.normalX); + rawBuffer[rbi + 10] = Float.floatToRawIntBits((float) tess.normalY); + rawBuffer[rbi + 11] = Float.floatToRawIntBits((float) tess.normalZ); + rawBuffer[rbi + 12] = Float.floatToRawIntBits((float) tess.midTextureU); + rawBuffer[rbi + 13] = Float.floatToRawIntBits((float) tess.midTextureV); + + tess.rawBufferIndex = rbi += vertexStride; + ++tess.vertexCount; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/client/ShadersTex.java b/src/main/java/com/gtnewhorizons/angelica/client/ShadersTex.java new file mode 100644 index 000000000..d9b82c046 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/client/ShadersTex.java @@ -0,0 +1,988 @@ +package com.gtnewhorizons.angelica.client; + +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import javax.imageio.ImageIO; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.AbstractTexture; +import net.minecraft.client.renderer.texture.DynamicTexture; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.renderer.texture.LayeredTexture; +import net.minecraft.client.renderer.texture.Stitcher; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.texture.TextureUtil; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.IResourceManager; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; +import org.lwjgl.opengl.GL13; +import org.lwjgl.opengl.GL30.*; + +public class ShadersTex { + public static final int initialBufferSize = 1048576; + public static ByteBuffer byteBuffer = BufferUtils.createByteBuffer(initialBufferSize * 4); + public static IntBuffer intBuffer = byteBuffer.asIntBuffer(); + public static int[] intArray = new int[initialBufferSize]; + public static final int defBaseTexColor = 0x00000000; + public static final int defNormTexColor = 0xFF7F7FFF; + public static final int defSpecTexColor = 0x00000000; + public static Map multiTexMap = new HashMap(); + public static TextureMap updatingTextureMap = null; + public static TextureAtlasSprite updatingSprite = null; + public static MultiTexID updatingTex = null; + public static MultiTexID boundTex = null; + public static int updatingPage = 0; + public static String iconName = null; + + public static IntBuffer getIntBuffer(int size) { + if (intBuffer.capacity() < size) { + int bufferSize = roundUpPOT(size); + byteBuffer = BufferUtils.createByteBuffer(bufferSize * 4); + intBuffer = byteBuffer.asIntBuffer(); + } + return intBuffer; + } + + public static int[] getIntArray(int size) { + if (intArray.length < size) { + intArray = null; + intArray = new int[roundUpPOT(size)]; + } + return intArray; + } + + public static int roundUpPOT(int x) { + int i = x - 1; + i |= (i >> 1); + i |= (i >> 2); + i |= (i >> 4); + i |= (i >> 8); + i |= (i >> 16); + return i + 1; + } + + public static IntBuffer fillIntBuffer(int size, int value) { + int[] aint = getIntArray(size); + IntBuffer intBuf = getIntBuffer(size); + Arrays.fill(intArray, 0, size, value); + intBuffer.put(intArray, 0, size); + return intBuffer; + } + + public static int[] createAIntImage(int size) { + int[] aint = new int[size * 3]; + Arrays.fill(aint, 0, size, defBaseTexColor); + Arrays.fill(aint, size, size * 2, defNormTexColor); + Arrays.fill(aint, size * 2, size * 3, defSpecTexColor); + return aint; + } + + public static int[] createAIntImage(int size, int color) { + int[] aint = new int[size * 3]; + Arrays.fill(aint, 0, size, color); + Arrays.fill(aint, size, size * 2, defNormTexColor); + Arrays.fill(aint, size * 2, size * 3, defSpecTexColor); + return aint; + } + + public static MultiTexID getMultiTexID(AbstractTexture tex) { + MultiTexID multiTex = tex.multiTex; + if (multiTex == null) { + int baseTex = tex.getGlTextureId(); + multiTex = multiTexMap.get(Integer.valueOf(baseTex)); + if (multiTex == null) { + multiTex = new MultiTexID(baseTex, GL11.glGenTextures(), GL11.glGenTextures()); + multiTexMap.put(baseTex, multiTex); + } + tex.multiTex = multiTex; + } + return multiTex; + } + + public static void deleteTextures(AbstractTexture atex) { + int texid = atex.glTextureId; + if (texid != -1) { + GL11.glDeleteTextures(texid); + atex.glTextureId = -1; + } + MultiTexID multiTex = atex.multiTex; + if (multiTex != null) { + atex.multiTex = null; + multiTexMap.remove(Integer.valueOf(multiTex.base)); + GL11.glDeleteTextures(multiTex.norm); + GL11.glDeleteTextures(multiTex.spec); + if (multiTex.base != texid) { + System.err.println("Error : MultiTexID.base mismatch."); + GL11.glDeleteTextures(multiTex.base); + } + } + } + + /** Remove MultiTexID object reference and delete textures */ + public static int deleteMultiTex(ITextureObject tex) { + if (tex instanceof AbstractTexture) { + deleteTextures((AbstractTexture) tex); + } else { + GL11.glDeleteTextures(tex.getGlTextureId()); + } + return 0; + } + + public static void bindNSTextures(int normTex, int specTex) { + // Shaders.checkGLError("pre bindNSTextures"); + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + // Shaders.checkGLError("bindNSTextures"); + } + + public static void bindNSTextures(MultiTexID multiTex) { + bindNSTextures(multiTex.norm, multiTex.spec); + } + + public static void bindTextures(int baseTex, int normTex, int specTex) { + // Shaders.checkGLError("pre bindTextures"); + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, normTex); + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, specTex); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, baseTex); + // Shaders.checkGLError("bindTextures"); + } + + public static void bindTextures(MultiTexID multiTex) { + boundTex = multiTex; + if (Shaders.isRenderingWorld && Shaders.activeTexUnit == GL13.GL_TEXTURE0) { + if (Shaders.configNormalMap) { + GL13.glActiveTexture(GL13.GL_TEXTURE2); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + } + if (Shaders.configSpecularMap) { + GL13.glActiveTexture(GL13.GL_TEXTURE3); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + } + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + public static void bindTexture(ITextureObject tex) { + if (tex instanceof TextureMap) { + Shaders.atlasSizeX = ((TextureMap) tex).atlasWidth; + Shaders.atlasSizeY = ((TextureMap) tex).atlasHeight; + } else { + Shaders.atlasSizeX = 0; + Shaders.atlasSizeY = 0; + } + bindTextures(tex.getMultiTexID()); + } + + /** not used */ + public static void bindTextures(int baseTex) { + MultiTexID multiTex = multiTexMap.get(Integer.valueOf(baseTex)); + bindTextures(multiTex); + } + + public static void allocTexStorage(int width, int height, int maxLevel) { + Shaders.checkGLError("pre allocTexStorage"); + int level; + for (level = 0; (width >> level) > 0 && (height >> level) > 0 /*&& level<=maxLevel*/; ++level) { + GL11.glTexImage2D( + GL11.GL_TEXTURE_2D, + level, + GL11.GL_RGBA, + (width >> level), + (height >> level), + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + (IntBuffer) null); + } + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, level - 1); + Shaders.checkGLError("allocTexStorage"); + // clear unused level otherwise glTexSubImage2D will crash on AMD when reallocation texture of different size. + // for ( ; level < 16 ; ++level) { + // GL11.glTexImage2D(GL11.GL_TEXTURE_2D, level, GL11.GL_RGBA, 0, 0, 0, GL12.GL_BGRA, + // GL12.GL_UNSIGNED_INT_8_8_8_8_REV, (IntBuffer)null); + // } + GL11.glGetError(); // It usually returns error 0x0501 Invalid value for width 0 height 0. Ignore it. + } + + // for Dynamic Texture + public static void initDynamicTexture(int texID, int width, int height, DynamicTexture tex) { + MultiTexID multiTex = tex.getMultiTexID(); + int[] aint = tex.getTextureData(); + int size = width * height; + Arrays.fill(aint, size, size * 2, defNormTexColor); + Arrays.fill(aint, size * 2, size * 3, defSpecTexColor); + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + allocTexStorage(width, height, 0); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // norm texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + allocTexStorage(width, height, 0); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // spec texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + allocTexStorage(width, height, 0); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, 0); + + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + public static ITextureObject createDefaultTexture() { + DynamicTexture tex = new DynamicTexture(1, 1); + tex.getTextureData()[0] = 0xffffffff; + tex.updateDynamicTexture(); + return tex; + } + + // for TextureMap + public static void allocateTextureMap( + int texID, int mipmapLevels, int width, int height, float anisotropy, Stitcher stitcher, TextureMap tex) { + System.out.println("allocateTextureMap " + tex.getTextureType() + " " + mipmapLevels + " " + width + " " + + height + " " + anisotropy + " "); + updatingTextureMap = tex; + tex.atlasWidth = width; + tex.atlasHeight = height; + MultiTexID multiTex = getMultiTexID(tex); + updatingTex = multiTex; + TextureUtil.allocateTextureImpl(multiTex.base, mipmapLevels, width, height, anisotropy); + if (Shaders.configNormalMap) + TextureUtil.allocateTextureImpl(multiTex.norm, mipmapLevels, width, height, anisotropy); + if (Shaders.configSpecularMap) + TextureUtil.allocateTextureImpl(multiTex.spec, mipmapLevels, width, height, anisotropy); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, texID); + } + + public static TextureAtlasSprite setSprite(TextureAtlasSprite tas) { + return updatingSprite = tas; + } + + public static String setIconName(String name) { + return iconName = name; + } + + public static void uploadTexSubForLoadAtlas( + int[][] data, int width, int height, int xoffset, int yoffset, boolean linear, boolean clamp) { + TextureUtil.uploadTextureMipmap(data, width, height, xoffset, yoffset, linear, clamp); + boolean border = updatingSprite.useAnisotropicFiltering; + int[][] aaint; + // + if (Shaders.configNormalMap) { + aaint = readImageAndMipmaps(iconName + "_n", width, height, data.length, border, defNormTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.norm); + TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); + } + // + if (Shaders.configSpecularMap) { + aaint = readImageAndMipmaps(iconName + "_s", width, height, data.length, border, defSpecTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); + TextureUtil.uploadTextureMipmap(aaint, width, height, xoffset, yoffset, linear, clamp); + } + // + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.base); + } + + public static int[][] readImageAndMipmaps( + String name, int width, int height, int numLevels, boolean border, int defColor) { + int[][] aaint = new int[numLevels][]; + int[] aint; + aaint[0] = aint = new int[width * height]; + boolean goodImage = false; + BufferedImage image = readImage(updatingTextureMap.completeResourceLocation(new ResourceLocation(name), 0)); + if (image != null) { + int imageWidth = image.getWidth(); + int imageHeight = image.getHeight(); + if (imageWidth + (border ? 16 : 0) == width) { + goodImage = true; + image.getRGB(0, 0, imageWidth, imageWidth, aint, 0, imageWidth); + if (border) TextureUtil.prepareAnisotropicData(aint, imageWidth, imageWidth, 8); + } + } + if (!goodImage) { + Arrays.fill(aint, defColor); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); + aaint = genMipmapsSimple(aaint.length - 1, width, aaint); + return aaint; + } + + public static BufferedImage readImage(ResourceLocation resLoc) { + BufferedImage image = null; + InputStream istr = null; + if (resManager != null) { + try { + istr = resManager.getResource(resLoc).getInputStream(); + image = ImageIO.read(istr); + } catch (IOException e) { + } + if (istr != null) { + try { + istr.close(); + } catch (IOException e) { + } + istr = null; + } + } + return image; + } + + public static int[][] genMipmapsSimple(int maxLevel, int width, int[][] data) { + int level; + for (level = 1; level <= maxLevel; ++level) { + if (data[level] == null) { + int cw = width >> level; + int pw = cw * 2; + int[] aintp = data[level - 1]; + int[] aintc = data[level] = new int[cw * cw]; + int x, y; + for (y = 0; y < cw; ++y) { + for (x = 0; x < cw; ++x) { + int ppos = y * 2 * pw + x * 2; + aintc[y * cw + x] = + blend4Simple(aintp[ppos], aintp[ppos + 1], aintp[ppos + pw], aintp[ppos + pw + 1]); + } + } + } + } + return data; + } + + public static void uploadTexSub( + int[][] data, int width, int height, int xoffset, int yoffset, boolean linear, boolean clamp) { + TextureUtil.uploadTextureMipmap(data, width, height, xoffset, yoffset, linear, clamp); + } + + public static int blend4Alpha(int c0, int c1, int c2, int c3) { + int a0 = (c0 >>> 24) & 255; + int a1 = (c1 >>> 24) & 255; + int a2 = (c2 >>> 24) & 255; + int a3 = (c3 >>> 24) & 255; + int as = a0 + a1 + a2 + a3; + int an = (as + 2) / 4; + // int an = Math.min(Math.min(Math.min(a0,a1),a2),a3); + int dv; + if (as != 0) { + dv = as; + } else { + dv = 4; + a3 = a2 = a1 = a0 = 1; + } + int frac = (dv + 1) / 2; + // return (((Math.min(Math.min(Math.min(a0,a1),a2),a3)/ 4) << 24) | + int color = (an << 24) + | (((((c0 >>> 16) & 255) * a0 + + ((c1 >>> 16) & 255) * a1 + + ((c2 >>> 16) & 255) * a2 + + ((c3 >>> 16) & 255) * a3 + + frac) + / dv) + << 16) + | (((((c0 >>> 8) & 255) * a0 + + ((c1 >>> 8) & 255) * a1 + + ((c2 >>> 8) & 255) * a2 + + ((c3 >>> 8) & 255) * a3 + + frac) + / dv) + << 8) + | (((((c0 >>> 0) & 255) * a0 + + ((c1 >>> 0) & 255) * a1 + + ((c2 >>> 0) & 255) * a2 + + ((c3 >>> 0) & 255) * a3 + + frac) + / dv) + << 0); + return color; + } + + public static int blend4Simple(int c0, int c1, int c2, int c3) { + int color = (((((c0 >>> 24) & 255) + ((c1 >>> 24) & 255) + ((c2 >>> 24) & 255) + ((c3 >>> 24) & 255) + 2) / 4) + << 24) + | (((((c0 >>> 16) & 255) + ((c1 >>> 16) & 255) + ((c2 >>> 16) & 255) + ((c3 >>> 16) & 255) + 2) / 4) + << 16) + | (((((c0 >>> 8) & 255) + ((c1 >>> 8) & 255) + ((c2 >>> 8) & 255) + ((c3 >>> 8) & 255) + 2) / 4) << 8) + | (((((c0 >>> 0) & 255) + ((c1 >>> 0) & 255) + ((c2 >>> 0) & 255) + ((c3 >>> 0) & 255) + 2) / 4) << 0); + return color; + } + + public static void genMipmapAlpha(int[] aint, int offset, int width, int height) { + int minwh = Math.min(width, height); + int level; + int w1, w2, h1, h2, o1, o2; + w1 = w2 = width; + h1 = h2 = height; + o1 = o2 = offset; + // generate mipmap from big to small + o2 = offset; + w2 = width; + h2 = height; + o1 = 0; + w1 = 0; + h1 = 0; + for (level = 0; w2 > 1 && h2 > 1; ++level, w2 = w1, h2 = h1, o2 = o1) { + o1 = o2 + w2 * h2; + w1 = w2 / 2; + h1 = h2 / 2; + for (int y = 0; y < h1; ++y) { + int p1 = o1 + y * w1; + int p2 = o2 + y * 2 * w2; + for (int x = 0; x < w1; ++x) { + aint[p1 + x] = blend4Alpha( + aint[p2 + (x * 2)], + aint[p2 + (x * 2 + 1)], + aint[p2 + w2 + (x * 2)], + aint[p2 + w2 + (x * 2 + 1)]); + } + } + } + // fix black pixels from small to big + while (level > 0) { + --level; + w2 = width >> level; + h2 = height >> level; + o2 = o1 - w2 * h2; + int p2 = o2; + for (int y = 0; y < h2; ++y) { + for (int x = 0; x < w2; ++x) { + // p2 = o2 + y*w2 + x; + if (aint[p2] == 0) { + aint[p2] = aint[o1 + (y / 2) * w1 + (x / 2)] & 0x00ffffff; + } + ++p2; + } + } + o1 = o2; + w1 = w2; + h1 = h2; + } + } + + public static void genMipmapSimple(int[] aint, int offset, int width, int height) { + int minwh = Math.min(width, height); + int level; + int w1, w2, h1, h2, o1, o2; + w1 = w2 = width; + h1 = h2 = height; + o1 = o2 = offset; + // generate mipmap from big to small + o2 = offset; + w2 = width; + h2 = height; + o1 = 0; + w1 = 0; + h1 = 0; + for (level = 0; w2 > 1 && h2 > 1; ++level, w2 = w1, h2 = h1, o2 = o1) { + o1 = o2 + w2 * h2; + w1 = w2 / 2; + h1 = h2 / 2; + for (int y = 0; y < h1; ++y) { + int p1 = o1 + y * w1; + int p2 = o2 + y * 2 * w2; + for (int x = 0; x < w1; ++x) { + aint[p1 + x] = blend4Simple( + aint[p2 + (x * 2)], + aint[p2 + (x * 2 + 1)], + aint[p2 + w2 + (x * 2)], + aint[p2 + w2 + (x * 2 + 1)]); + } + } + } + // fix black pixels from small to big + while (level > 0) { + --level; + w2 = width >> level; + h2 = height >> level; + o2 = o1 - w2 * h2; + int p2 = o2; + for (int y = 0; y < h2; ++y) { + for (int x = 0; x < w2; ++x) { + // p2 = o2 + y*w2 + x; + if (aint[p2] == 0) { + aint[p2] = aint[o1 + (y / 2) * w1 + (x / 2)] & 0x00ffffff; + } + ++p2; + } + } + o1 = o2; + w1 = w2; + h1 = h2; + } + } + + public static boolean isSemiTransparent(int[] aint, int width, int height) { + int size = width * height; + // grass side texture ?; + if (aint[0] >>> 24 == 255 && aint[size - 1] == 0) return true; + for (int i = 0; i < size; ++i) { + int alpha = aint[i] >>> 24; + if (alpha != 0 && alpha != 255) return true; + } + return false; + } + + public static void updateSubImage1(int[] src, int width, int height, int posX, int posY, int page, int color) { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + int[] aint = getIntArray((size * 4 + 2) / 3); + if (src.length >= size * (page + 1)) { + System.arraycopy(src, size * page, aint, 0, size); + } else { + Arrays.fill(aint, color); + } + // + // if (page == 0) + genMipmapAlpha(aint, 0, width, height); + // else + // genMipmapSimple(aint,0,width,height); + // + for (int level = 0, offset = 0, lw = width, lh = height, px = posX, py = posY; lw > 0 && lh > 0; ++level) { + int lsize = lw * lh; + intBuf.clear(); + intBuf.put(aint, offset, lsize).position(0).limit(lsize); + GL11.glTexSubImage2D( + GL11.GL_TEXTURE_2D, level, px, py, lw, lh, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + offset += lsize; + lw /= 2; + lh /= 2; + px /= 2; + py /= 2; + } + intBuf.clear(); + } + + public static void updateSubTex1(int[] src, int width, int height, int posX, int posY) { + int level; + int cw; + int ch; + int cx; + int cy; + for (level = 0, cw = width, ch = height, cx = posX, cy = posY; + cw > 0 && ch > 0; + ++level, cw /= 2, ch /= 2, cx /= 2, cy /= 2) { + GL11.glCopyTexSubImage2D(GL11.GL_TEXTURE_2D, level, cx, cy, 0, 0, cw, ch); + } + } + + /* updateSubImage for single Texture with mipmap */ + public static void updateSubImage1(int[][] src, int width, int height, int posX, int posY, int page, int color) { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + int numLevel = src.length; + for (int level = 0, // offset=0, + lw = width, + lh = height, + px = posX, + py = posY; + lw > 0 && lh > 0 && level < numLevel; + ++level) { + int lsize = lw * lh; + intBuf.clear(); + intBuf.put(src[level], 0 /*offset*/, lsize).position(0).limit(lsize); + GL11.glTexSubImage2D( + GL11.GL_TEXTURE_2D, level, px, py, lw, lh, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, intBuf); + // offset += lsize; + lw /= 2; + lh /= 2; + px /= 2; + py /= 2; + } + intBuf.clear(); + } + + public static void setupTextureMipmap(TextureMap tex) { + /* + MultiTexID multiTex = tex.getMultiTexID(); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL30.glGenerateMipmap(GL11.GL_TEXTURE_2D); + */ + } + + public static void updateDynamicTexture(int texID, int[] src, int width, int height, DynamicTexture tex) { + MultiTexID multiTex = tex.getMultiTexID(); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + updateSubImage1(src, width, height, 0, 0, 1, defNormTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + updateSubImage1(src, width, height, 0, 0, 2, defSpecTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + updateSubImage1(src, width, height, 0, 0, 0, defBaseTexColor); + } + + public static void updateSubImage( + int[] src, int width, int height, int posX, int posY, boolean linear, boolean clamp) { + if (updatingTex != null) { + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.norm); + updateSubImage1(src, width, height, posX, posY, 1, defNormTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.spec); + updateSubImage1(src, width, height, posX, posY, 2, defSpecTexColor); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, updatingTex.base); + } + updateSubImage1(src, width, height, posX, posY, 0, defBaseTexColor); + } + + // not used + public static void updateAnimationTextureMap(TextureMap tex, List tasList) { + Iterator iterator; + MultiTexID multiTex = tex.getMultiTexID(); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + for (iterator = tasList.iterator(); iterator.hasNext(); ) { + TextureAtlasSprite tas = iterator.next(); + tas.updateAnimation(); + } + } + + public static void setupTexture( + MultiTexID multiTex, int[] src, int width, int height, boolean linear, boolean clamp) { + int mmfilter = linear ? GL11.GL_LINEAR : GL11.GL_NEAREST; + int wraptype = clamp ? GL11.GL_CLAMP : GL11.GL_REPEAT; + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + // + intBuf.clear(); + intBuf.put(src, 0, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL11.glTexImage2D( + GL11.GL_TEXTURE_2D, + 0, + GL11.GL_RGBA, + width, + height, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + intBuf.put(src, size, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL11.glTexImage2D( + GL11.GL_TEXTURE_2D, + 0, + GL11.GL_RGBA, + width, + height, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + intBuf.put(src, size * 2, size).position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL11.glTexImage2D( + GL11.GL_TEXTURE_2D, + 0, + GL11.GL_RGBA, + width, + height, + 0, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, mmfilter); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, wraptype); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, wraptype); + // + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + } + + /* currently not used */ + public static void updateSubImage( + MultiTexID multiTex, int[] src, int width, int height, int posX, int posY, boolean linear, boolean clamp) { + int size = width * height; + IntBuffer intBuf = getIntBuffer(size); + // + intBuf.clear(); + intBuf.put(src, 0, size); + intBuf.position(0).limit(size); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexSubImage2D( + GL11.GL_TEXTURE_2D, + 0, + posX, + posY, + width, + height, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + if (src.length == size * 3) { + intBuf.clear(); + intBuf.put(src, size, size).position(0); + intBuf.position(0).limit(size); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexSubImage2D( + GL11.GL_TEXTURE_2D, + 0, + posX, + posY, + width, + height, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + if (src.length == size * 3) { + intBuf.clear(); + intBuf.put(src, size * 2, size); + intBuf.position(0).limit(size); + } + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT); + GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT); + GL11.glTexSubImage2D( + GL11.GL_TEXTURE_2D, + 0, + posX, + posY, + width, + height, + GL12.GL_BGRA, + GL12.GL_UNSIGNED_INT_8_8_8_8_REV, + intBuf); + GL13.glActiveTexture(GL13.GL_TEXTURE0); + } + + public static ResourceLocation getNSMapLocation(ResourceLocation location, String mapName) { + String basename = location.getResourcePath(); + String[] basenameParts = basename.split(".png"); + String basenameNoFileType = basenameParts[0]; + return new ResourceLocation(location.getResourceDomain(), basenameNoFileType + "_" + mapName + ".png"); + } + + public static void loadNSMap( + IResourceManager manager, ResourceLocation location, int width, int height, int[] aint) { + if (Shaders.configNormalMap) + ShadersTex.loadNSMap1( + manager, getNSMapLocation(location, "n"), width, height, aint, width * height, defNormTexColor); + if (Shaders.configSpecularMap) + ShadersTex.loadNSMap1( + manager, getNSMapLocation(location, "s"), width, height, aint, width * height * 2, defSpecTexColor); + } + + public static void loadNSMap1( + IResourceManager manager, + ResourceLocation location, + int width, + int height, + int[] aint, + int offset, + int defaultColor) { + boolean good = false; + try { + IResource res = manager.getResource(location); + BufferedImage bufferedimage = ImageIO.read(res.getInputStream()); + if (bufferedimage.getWidth() == width && bufferedimage.getHeight() == height) { + bufferedimage.getRGB(0, 0, width, height, aint, offset, width); + good = true; + } + } catch (IOException ex) { + } + if (!good) { + java.util.Arrays.fill(aint, offset, offset + width * height, defaultColor); + } + } + + /** init and upload from BufferedImage */ + /* Replacement for TextureUtil.func_110989_a call in SimpleTexture.func_110551_a. + Keep par0...par5 the same as func_110989_a for easy patching. + More parameters added for reading N-S-Map. */ + public static int loadSimpleTexture( + int textureID, + BufferedImage bufferedimage, + boolean linear, + boolean clamp, + IResourceManager resourceManager, + ResourceLocation location, + MultiTexID multiTex) { + int width = bufferedimage.getWidth(); + int height = bufferedimage.getHeight(); + int size = width * height; + int[] aint = getIntArray(size * 3); + bufferedimage.getRGB(0, 0, width, height, aint, 0, width); + loadNSMap(resourceManager, location, width, height, aint); + setupTexture(multiTex, aint, width, height, linear, clamp); + return textureID; + } + + public static void mergeImage(int[] aint, int dstoff, int srcoff, int size) {} + + public static int blendColor(int color1, int color2, int factor1) { + int factor2 = 255 - factor1; + return (((((color1 >>> 24) & 255) * factor1 + ((color2 >>> 24) & 255) * factor2) / 255) << 24) + | (((((color1 >>> 16) & 255) * factor1 + ((color2 >>> 16) & 255) * factor2) / 255) << 16) + | (((((color1 >>> 8) & 255) * factor1 + ((color2 >>> 8) & 255) * factor2) / 255) << 8) + | (((((color1 >>> 0) & 255) * factor1 + ((color2 >>> 0) & 255) * factor2) / 255) << 0); + } + + public static void loadLayeredTexture(LayeredTexture tex, IResourceManager manager, List list) { + int width = 0; + int height = 0; + int size = 0; + int[] image = null; + Iterator iterator; + for (iterator = list.iterator(); iterator.hasNext(); ) { + String s = iterator.next(); + if (s != null) { + try { + ResourceLocation location = new ResourceLocation(s); + InputStream inputstream = manager.getResource(location).getInputStream(); + BufferedImage bufimg = ImageIO.read(inputstream); + + if (size == 0) { + width = bufimg.getWidth(); + height = bufimg.getHeight(); + size = width * height; + image = createAIntImage(size, 0x00000000); + } + int[] aint = getIntArray(size * 3); + bufimg.getRGB(0, 0, width, height, aint, 0, width); + loadNSMap(manager, location, width, height, aint); + // merge + for (int i = 0; i < size; ++i) { + int alpha = (aint[i] >>> 24) & 255; + image[size * 0 + i] = blendColor(aint[size * 0 + i], image[size * 0 + i], alpha); + image[size * 1 + i] = blendColor(aint[size * 1 + i], image[size * 1 + i], alpha); + image[size * 2 + i] = blendColor(aint[size * 2 + i], image[size * 2 + i], alpha); + } + } catch (IOException ex) { + ex.printStackTrace(); + } + } + } + // init and upload + setupTexture(tex.getMultiTexID(), image, width, height, false, false); + } + + /* update block texture filter +/- items texture */ + static void updateTextureMinMagFilter() { + TextureManager texman = Minecraft.getMinecraft().getTextureManager(); + ITextureObject texObj = texman.getTexture(TextureMap.locationBlocksTexture); + if (texObj != null) { + MultiTexID multiTex = texObj.getMultiTexID(); + // base texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.base); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilB]); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilB]); + // norm texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.norm); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilN]); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilN]); + + // spec texture + GL11.glBindTexture(GL11.GL_TEXTURE_2D, multiTex.spec); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, Shaders.texMinFilValue[Shaders.configTexMinFilS]); + GL11.glTexParameteri( + GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, Shaders.texMagFilValue[Shaders.configTexMagFilS]); + + GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0); + } + } + + static IResourceManager resManager = null; + static ResourceLocation resLocation = null; + static int imageSize = 0; + + public static IResource loadResource(IResourceManager manager, ResourceLocation location) throws IOException { + resManager = manager; + resLocation = location; + return manager.getResource(location); + } + + public static int[] loadAtlasSprite( + BufferedImage bufferedimage, int startX, int startY, int w, int h, int[] aint, int offset, int scansize) { + imageSize = w * h; + bufferedimage.getRGB(startX, startY, w, h, aint, offset, scansize); + loadNSMap(resManager, resLocation, w, h, aint); + return aint; + } + + public static int[] extractFrame(int[] src, int width, int height, int frameIndex) { + int srcSize = imageSize; + int frameSize = width * height; + int[] dst = new int[frameSize * 3]; + int srcPos = frameSize * frameIndex; + int dstPos = 0; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + srcPos += srcSize; + dstPos += frameSize; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + srcPos += srcSize; + dstPos += frameSize; + System.arraycopy(src, srcPos, dst, dstPos, frameSize); + return dst; + } + + public static void fixTransparentColor(TextureAtlasSprite tas, int[] aint) {} +} diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/SMCTweaker.java b/src/main/java/com/gtnewhorizons/angelica/loading/SMCTweaker.java new file mode 100644 index 000000000..a96ccd31c --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/loading/SMCTweaker.java @@ -0,0 +1,55 @@ +package com.gtnewhorizons.angelica.loading; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import net.minecraft.launchwrapper.ITweaker; +import net.minecraft.launchwrapper.Launch; +import net.minecraft.launchwrapper.LaunchClassLoader; + +public class SMCTweaker implements ITweaker { + public List args; + public File gameDir; + public File assetsDir; + public String version; + + @Override + public void acceptOptions(List args, File gameDir, File assetsDir, String version) { + this.args = args; + this.gameDir = gameDir; + this.assetsDir = assetsDir; + this.version = version; + } + + @Override + public void injectIntoClassLoader(LaunchClassLoader launchClassLoader) { + launchClassLoader.addTransformerExclusion("com.gtnewhorizons.angelica.loading."); + launchClassLoader.addTransformerExclusion("com.gtnewhorizons.angelica.transform."); + launchClassLoader.registerTransformer("com.gtnewhorizons.angelica.transform.SMCClassTransformer"); + } + + @Override + public String[] getLaunchArguments() { + ArrayList argumentList = (ArrayList) Launch.blackboard.get("ArgumentList"); + if (argumentList.isEmpty()) { + List argsList = new ArrayList(); + if (gameDir != null) { + argumentList.add("--gameDir"); + argumentList.add(gameDir.getPath()); + } + if (assetsDir != null) { + argumentList.add("--assetsDir"); + argumentList.add(assetsDir.getPath()); + } + argumentList.add("--version"); + argumentList.add(version); + argumentList.addAll(args); + } + return new String[0]; + } + + @Override + public String getLaunchTarget() { + return "net.minecraft.client.main.Main"; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/InitNames.java b/src/main/java/com/gtnewhorizons/angelica/transform/InitNames.java new file mode 100644 index 000000000..ee0ee644e --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/InitNames.java @@ -0,0 +1,7 @@ +package com.gtnewhorizons.angelica.transform; + +public class InitNames { + public static void init() { + new NamerSrg().setNames(); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/Namer.java b/src/main/java/com/gtnewhorizons/angelica/transform/Namer.java new file mode 100644 index 000000000..1f83dd8f5 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/Namer.java @@ -0,0 +1,45 @@ +package com.gtnewhorizons.angelica.transform; + +import com.gtnewhorizons.angelica.transform.Names.Clas; +import com.gtnewhorizons.angelica.transform.Names.Fiel; +import com.gtnewhorizons.angelica.transform.Names.Meth; +import java.util.ArrayList; + +public class Namer { + + ArrayList ac = new ArrayList(); + ArrayList af = new ArrayList(); + ArrayList am = new ArrayList(); + + Clas c(String name) { + Clas x = new Clas(name); + if (ac != null) ac.add(x); + return x; + } + + Fiel f(Clas clas, String name, String desc) { + Fiel x = new Fiel(clas, name, desc); + if (af != null) af.add(x); + return x; + } + + Fiel f(Clas clas, Fiel fiel) { + Fiel x = new Fiel(clas, fiel.name, fiel.desc); + if (af != null) af.add(x); + return x; + } + + Meth m(Clas clas, String name, String desc) { + Meth x = new Meth(clas, name, desc); + if (am != null) am.add(x); + return x; + } + + Meth m(Clas clas, Meth meth) { + Meth x = new Meth(clas, meth.name, meth.desc); + if (am != null) am.add(x); + return x; + } + + public void setNames() {} +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/Namer1_7_10.java b/src/main/java/com/gtnewhorizons/angelica/transform/Namer1_7_10.java new file mode 100644 index 000000000..7deb0aaca --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/Namer1_7_10.java @@ -0,0 +1,209 @@ +package com.gtnewhorizons.angelica.transform; + +import static com.gtnewhorizons.angelica.transform.Names.*; + +public class Namer1_7_10 extends Namer { + + public void setNames() { + setNames1_7_10(); + } + + public void setNames1_7_10() { + block_ = c("aji"); + blockFlowerPot_ = c("ald"); + minecraft_ = c("bao"); + guiButton_ = c("bcb"); + guiOptions_ = c("bdm"); + guiScreen_ = c("bdw"); + modelRenderer_ = c("bix"); + worldClient_ = c("bjf"); + effectRenderer_ = c("bkn"); + entityRenderer_ = c("blt"); + glAllocation_ = c("ban"); + itemRenderer_ = c("bly"); + openGlHelper_ = c("buu"); + renderBlocks_ = c("blm"); + renderGlobal_ = c("bma"); + tessellator_ = c("bmh"); + worldRenderer_ = c("blo"); + frustrum_ = c("bmx"); + iCamera_ = c("bmv"); + render_ = c("bno"); + renderDragon_ = c("bnl"); + renderEnderman_ = c("bnm"); + renderSpider_ = c("bov"); + renderManager_ = c("bnn"); + rendererLivingE_ = c("boh"); + abstractTexture_ = c("bpp"); + dynamicTexture_ = c("bpq"); + iTextureObject_ = c("bqh"); + layeredTexture_ = c("bpt"); + simpleTexture_ = c("bpu"); + stitcher_ = c("bpv"); + textureAtlasSpri_ = c("bqd"); + textureClock_ = c("bql"); + textureCompass_ = c("bqm"); + textureManager_ = c("bqf"); + textureMap_ = c("bpz"); + textureUtil_ = c("bqi"); + textureDownload_ = c("bpr"); + iResource_ = c("bqw"); + iResourceManager_ = c("bqy"); + gameSettings_ = c("bbj"); + tessVertexState_ = c("bmi"); + entity_ = c("sa"); + entityLivingBase_ = c("sv"); + entityDragon_ = c("xa"); + entityEnderman_ = c("ya"); + entitySpider_ = c("yn"); + entityPlayer_ = c("yz"); + item_ = c("adb"); + itemBlock_ = c("abh"); + itemStack_ = c("add"); + movingObjectPos_ = c("azu"); + resourceLocation_ = c("bqx"); + vec3_ = c("azw"); + iBlockAccess_ = c("ahl"); + world_ = c("ahb"); + + entityLivingBase_deathTime = f(entityLivingBase_, "aA", "I"); + entityLivingBase_hurtTime = f(entityLivingBase_, "ax", "I"); + entityRenderer_cameraZoom = f(entityRenderer_, "af", "D"); + entityRenderer_mc = f(entityRenderer_, "t", minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_, "c", "I"); + guiButton_id = f(guiButton_, "k", "I"); + guiScreen_buttonList = f(guiScreen_, "n", "Ljava/util/List;"); + guiScreen_width = f(guiScreen_, "l", "I"); + guiScreen_height = f(guiScreen_, "m", "I"); + guiScreen_mc = f(guiScreen_, "k", minecraft_.desc); + guiOptions_options = f(guiOptions_, "h", gameSettings_.desc); + itemBlock_block = f(itemBlock_, "a", block_.desc); + itemRenderer_itemToRender = f(itemRenderer_, "e", itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_, "b", "Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_, "g", renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_, "u", gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_, "u", "I"); + modelRenderer_compiled = f(modelRenderer_, "t", "Z"); + renderGlobal_glSkyList = f(renderGlobal_, "G", "I"); + renderGlobal_worldRenderers = f(renderGlobal_, "v", "[" + worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_, "i", null); + rendererLivingE_renderPassModel = f(rendererLivingE_, "j", null); + renderManager_entityRenderMap = f(renderManager_, "q", "Ljava/util/Map;"); + renderManager_instance = f(renderManager_, "a", renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_, "b", resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_, "d", "Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_, "e", "Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_, "c", "Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_, "b", "Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_, "f", "[I"); + tessellator_vertexCount = f(tessellator_, "g", "I"); + tessellator_hasNormals = f(tessellator_, "o", "Z"); + textureAtlasSpri_width = f(textureAtlasSpri_, "e", null); + textureAtlasSpri_height = f(textureAtlasSpri_, "f", null); + textureAtlasSpri_border = f(textureAtlasSpri_, "k", null); + textureMap_anisotropic = f(textureMap_, "k", null); + textureDownload_textureUploaded = f(textureDownload_, "j", "Z"); + vec3_xCoord = f(vec3_, "a", "D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_, "c", "()V"); + block_getAoLight = m(block_, "I", "()F"); + block_getBlockFromItem = m(block_, "a", "(" + item_.desc + ")" + block_.desc); + dynamicTexture_updateDynamicTexture = m(dynamicTexture_, "a", "()V"); + effectRenderer_renderLitParticles = m(effectRenderer_, "b", "(" + entity_.desc + "F)V"); + effectRenderer_renderParticles = m(effectRenderer_, "a", "(" + entity_.desc + "F)V"); + entity_getBrightness = m(entity_, "d", "(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_, "b", "(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_, "j", "(F)V"); + entityRenderer_setupFog = m(entityRenderer_, "a", "(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_, "a", "(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_, "a", "(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_, "e", "(F)V"); + entityRenderer_renderHand = m(entityRenderer_, "b", "(FI)V"); + entityRenderer_setupCameraTransform = m(entityRenderer_, "a", "(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_, "a", "(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_, "a", "(" + renderGlobal_.desc + "F)V"); + gameSettings_saveOptions = m(gameSettings_, "b", "()V"); + gameSettings_shouldRenderClouds = m(gameSettings_, "d", "()Z"); + glAllocation_createDirectByteBuffer = m(glAllocation_, "c", "(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_, "f", "(I)Ljava/nio/IntBuffer;"); + glAllocation_deleteDisplayLists = m(glAllocation_, "b", "(I)V"); + guiOptions_actionPerformed = m(guiOptions_, "a", "(" + guiButton_.desc + ")V"); + guiOptions_initGui = m(guiOptions_, "b", "()V"); + iCamera_setPosition = m(iCamera_, "a", "(DDD)V"); + iResourceManager_getResource = m(iResourceManager_, "a", "(" + resourceLocation_.desc + ")" + iResource_.desc); + itemRenderer_renderItem = m(itemRenderer_, "a", "(" + entityLivingBase_.desc + itemStack_.desc + "I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_, "a", "(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_, "b", "(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_, "a", "()V"); + iTextureObject_loadTexture = m(iTextureObject_, "a", "(" + iResourceManager_.desc + ")V"); + iTextureObject_getGlTextureId = m(iTextureObject_, "b", "()I"); + minecraft_displayGuiScreen = m(minecraft_, "a", "(" + guiScreen_.desc + ")V"); + minecraft_startGame = m(minecraft_, "ag", "()V"); + openGlHelper_setActiveTexture = m(openGlHelper_, "j", "(I)V"); + render_renderShadow = m(render_, "c", "(" + entity_.desc + "DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_, "p", "(" + block_.desc + "III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_, "d", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockSandFalling = m(renderBlocks_, "a", "(" + block_.desc + world_.desc + "IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_, "a", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_, "e", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_, "u", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_, "v", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_, "b", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockFlowerPot = m(renderBlocks_, "a", "(" + blockFlowerPot_.desc + "III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_, "b", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_, "c", "(" + block_.desc + "IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_, "a", "(" + entityDragon_.desc + "IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_, "a", "(" + entityEnderman_.desc + "IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_, "a", "(" + entitySpider_.desc + "IF)I"); + rendererLivingE_doRender = m(rendererLivingE_, "a", "(" + entityLivingBase_.desc + "DDDFF)V"); + rendererLivingE_renderEquippedItems = m(rendererLivingE_, "c", "(" + entityLivingBase_.desc + "F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_, "a", "(" + entityLivingBase_.desc + "FF)I"); + rendererLivingE_renderLabel = + m(rendererLivingE_, "a", "(" + entityLivingBase_.desc + "DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = m(renderGlobal_, "a", "(" + entityLivingBase_.desc + iCamera_.desc + "F)V"); + renderGlobal_renderSky = m(renderGlobal_, "a", "(F)V"); + renderGlobal_drawBlockDamageTexture = + m(renderGlobal_, "a", "(" + tessellator_.desc + entityPlayer_.desc + "F)V"); + renderGlobal_renderClouds = m(renderGlobal_, "b", "(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_, "a", "(" + entityLivingBase_.desc + "ID)I"); + renderGlobal_clipRenderersByFrustum = m(renderGlobal_, "a", "(" + iCamera_.desc + "F)V"); + renderGlobal_drawSelectionBox = + m(renderGlobal_, "a", "(" + entityPlayer_.desc + movingObjectPos_.desc + "IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_, "a", "(ID)V"); + stitcher_getCurrentWidth = m(stitcher_, "a", "()I"); + tessellator_sortQuad = m(tessellator_, "a", "(FFF)" + tessVertexState_.desc); + tessellator_addTranslation = m(tessellator_, "d", "(FFF)V"); + tessellator_setNormal = m(tessellator_, "c", "(FFF)V"); + tessellator_addVertex = m(tessellator_, "a", "(DDD)V"); + tessellator_reset = m(tessellator_, "d", "()V"); + tessellator_draw = m(tessellator_, "a", "()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_, "-", "(" + iResource_.desc + ")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_, "a", "(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_, "g", "()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_, "j", "()V"); + textureCompass_updateCompass = m(textureCompass_, "a", "(" + world_.desc + "DDDZZ)V"); + textureManager_onResourceManagerReload = m(textureManager_, "a", "(" + iResourceManager_.desc + ")V"); + textureManager_bindTexture = m(textureManager_, "a", "(" + resourceLocation_.desc + ")V"); + textureMap_loadTextureAtlas = m(textureMap_, "b", "(" + iResourceManager_.desc + ")V"); + textureMap_getIconResLoc = m(textureMap_, "a", "(" + resourceLocation_.desc + "I)" + resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_, "d", "()V"); + textureUtil_uploadTexture = m(textureUtil_, "a", "(I[III)V"); + textureUtil_uploadTextureImageAllocate = m(textureUtil_, "a", "(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_, "a", "(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_, "a", "(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_, "a", "([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_, "b", "(I)V"); + world_getCelestialAngle = m(world_, "c", "(F)F"); + world_getRainStrength = m(world_, "j", "(F)F"); + modelRenderer_render = m(modelRenderer_, "a", "(F)V"); + modelRenderer_renderWithRotation = m(modelRenderer_, "b", "(F)V"); + + guiOptions_buttonList = f(guiOptions_, guiScreen_buttonList); + guiOptions_width = f(guiOptions_, guiScreen_width); + guiOptions_height = f(guiOptions_, guiScreen_height); + guiOptions_mc = f(guiOptions_, guiScreen_mc); + frustrum_setPosition = m(frustrum_, iCamera_setPosition); + worldClient_getCelestialAngle = m(worldClient_, world_getCelestialAngle); + worldClient_getRainStrength = m(worldClient_, world_getRainStrength); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcf.java b/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcf.java new file mode 100644 index 000000000..1a7f08ca2 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcf.java @@ -0,0 +1,9 @@ +package com.gtnewhorizons.angelica.transform; + +public class NamerMcf extends NamerMcp { + + public void setNames() { + setNamesSrg(); + rename("../build/unpacked/conf/"); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcp.java b/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcp.java new file mode 100644 index 000000000..3ad5c9654 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/NamerMcp.java @@ -0,0 +1,118 @@ +package com.gtnewhorizons.angelica.transform; + +import com.gtnewhorizons.angelica.transform.Names.Clas; +import com.gtnewhorizons.angelica.transform.Names.Fiel; +import com.gtnewhorizons.angelica.transform.Names.Meth; +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +public class NamerMcp extends NamerSrg { + + public void setNames() { + setNamesSrg(); + lookupReobfName("../conf/"); + rename("../conf/"); + } + + public void rename(String confPath) { + Map nameMap; + nameMap = loadNameMapCSV(confPath + "fields.csv"); + for (Fiel f : af) { + String s = nameMap.get(f.name); + if (s != null) { + f.name = s; + } + } + nameMap = loadNameMapCSV(confPath + "methods.csv"); + for (Meth m : am) { + String s = nameMap.get(m.name); + if (s != null) { + m.name = s; + } + } + } + + Map loadNameMapCSV(String fileName) { + Map map = new HashMap(); + BufferedReader rd = null; + try { + rd = new BufferedReader(new FileReader(fileName)); + String line; + rd.readLine(); // skip first line; + while ((line = rd.readLine()) != null) { + String[] tokens = line.split(","); + if (tokens.length > 1) { + map.put(tokens[0], tokens[1]); + } + } + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } finally { + if (rd != null) { + try { + rd.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return map; + } + + void lookupReobfName(String confPath) { + Map nameMap; + nameMap = loadReobfMap(confPath + "joined.srg"); + for (Clas c : ac) { + String s = nameMap.get(c.name); + System.out.printf("C %s %s\n", c.name, s); + } + for (Fiel f : af) { + String s = nameMap.get(f.clas + "/" + f.name); + System.out.printf("F %s %s\n", f.name, s); + } + for (Meth m : am) { + String s = nameMap.get(m.clas + "/" + m.name + m.desc); + System.out.printf("M %s %s\n", m.name, s); + } + } + + Map loadReobfMap(String fileName) { + Map map = new HashMap(); + BufferedReader rd = null; + try { + rd = new BufferedReader(new FileReader(fileName)); + String line; + while ((line = rd.readLine()) != null) { + String[] tokens = line.split(" "); + if (tokens.length > 1) { + if ("CL:".equals(tokens[0])) { + map.put(tokens[2], tokens[1]); + } else if ("FD:".equals(tokens[0])) { + map.put(tokens[2], tokens[1]); + } else if ("MD:".equals(tokens[0])) { + map.put(tokens[3] + tokens[4], tokens[1].substring(tokens[1].lastIndexOf('/') + 1)); + } + } + } + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } finally { + if (rd != null) { + try { + rd.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return map; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/NamerSrg.java b/src/main/java/com/gtnewhorizons/angelica/transform/NamerSrg.java new file mode 100644 index 000000000..96e4562f1 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/NamerSrg.java @@ -0,0 +1,216 @@ +package com.gtnewhorizons.angelica.transform; + +import static com.gtnewhorizons.angelica.transform.Names.*; + +public class NamerSrg extends Namer { + + public void setNames() { + setNamesSrg(); + } + + public void setNamesSrg() { + block_ = c("net/minecraft/block/Block"); + blockFlowerPot_ = c("net/minecraft/block/BlockFlowerPot"); + minecraft_ = c("net/minecraft/client/Minecraft"); + guiButton_ = c("net/minecraft/client/gui/GuiButton"); + guiOptions_ = c("net/minecraft/client/gui/GuiOptions"); + guiScreen_ = c("net/minecraft/client/gui/GuiScreen"); + modelRenderer_ = c("net/minecraft/client/model/ModelRenderer"); + worldClient_ = c("net/minecraft/client/multiplayer/WorldClient"); + effectRenderer_ = c("net/minecraft/client/particle/EffectRenderer"); + entityRenderer_ = c("net/minecraft/client/renderer/EntityRenderer"); + glAllocation_ = c("net/minecraft/client/renderer/GLAllocation"); + itemRenderer_ = c("net/minecraft/client/renderer/ItemRenderer"); + openGlHelper_ = c("net/minecraft/client/renderer/OpenGlHelper"); + renderBlocks_ = c("net/minecraft/client/renderer/RenderBlocks"); + renderGlobal_ = c("net/minecraft/client/renderer/RenderGlobal"); + tessellator_ = c("net/minecraft/client/renderer/Tessellator"); + worldRenderer_ = c("net/minecraft/client/renderer/WorldRenderer"); + frustrum_ = c("net/minecraft/client/renderer/culling/Frustrum"); + iCamera_ = c("net/minecraft/client/renderer/culling/ICamera"); + render_ = c("net/minecraft/client/renderer/entity/Render"); + renderDragon_ = c("net/minecraft/client/renderer/entity/RenderDragon"); + renderEnderman_ = c("net/minecraft/client/renderer/entity/RenderEnderman"); + renderSpider_ = c("net/minecraft/client/renderer/entity/RenderSpider"); + renderManager_ = c("net/minecraft/client/renderer/entity/RenderManager"); + rendererLivingE_ = c("net/minecraft/client/renderer/entity/RendererLivingEntity"); + abstractTexture_ = c("net/minecraft/client/renderer/texture/AbstractTexture"); + dynamicTexture_ = c("net/minecraft/client/renderer/texture/DynamicTexture"); + iTextureObject_ = c("net/minecraft/client/renderer/texture/ITextureObject"); + layeredTexture_ = c("net/minecraft/client/renderer/texture/LayeredTexture"); + simpleTexture_ = c("net/minecraft/client/renderer/texture/SimpleTexture"); + stitcher_ = c("net/minecraft/client/renderer/texture/Stitcher"); + textureAtlasSpri_ = c("net/minecraft/client/renderer/texture/TextureAtlasSprite"); + textureClock_ = c("net/minecraft/client/renderer/texture/TextureClock"); + textureCompass_ = c("net/minecraft/client/renderer/texture/TextureCompass"); + textureManager_ = c("net/minecraft/client/renderer/texture/TextureManager"); + textureMap_ = c("net/minecraft/client/renderer/texture/TextureMap"); + textureUtil_ = c("net/minecraft/client/renderer/texture/TextureUtil"); + textureDownload_ = c("net/minecraft/client/renderer/ThreadDownloadImageData"); + iResource_ = c("net/minecraft/client/resources/IResource"); + iResourceManager_ = c("net/minecraft/client/resources/IResourceManager"); + gameSettings_ = c("net/minecraft/client/settings/GameSettings"); + tessVertexState_ = c("net/minecraft/client/shader/TesselatorVertexState"); + entity_ = c("net/minecraft/entity/Entity"); + entityLivingBase_ = c("net/minecraft/entity/EntityLivingBase"); + entityDragon_ = c("net/minecraft/entity/boss/EntityDragon"); + entityEnderman_ = c("net/minecraft/entity/monster/EntityEnderman"); + entitySpider_ = c("net/minecraft/entity/monster/EntitySpider"); + entityPlayer_ = c("net/minecraft/entity/player/EntityPlayer"); + item_ = c("net/minecraft/item/Item"); + itemBlock_ = c("net/minecraft/item/ItemBlock"); + itemStack_ = c("net/minecraft/item/ItemStack"); + movingObjectPos_ = c("net/minecraft/util/MovingObjectPosition"); + resourceLocation_ = c("net/minecraft/util/ResourceLocation"); + vec3_ = c("net/minecraft/util/Vec3"); + iBlockAccess_ = c("net/minecraft/world/IBlockAccess"); + world_ = c("net/minecraft/world/World"); + + entityLivingBase_deathTime = f(entityLivingBase_, "field_70725_aQ", "I"); + entityLivingBase_hurtTime = f(entityLivingBase_, "field_70737_aN", "I"); + entityRenderer_cameraZoom = f(entityRenderer_, "field_78503_V", "D"); + entityRenderer_mc = f(entityRenderer_, "field_78531_r", minecraft_.desc); + gameSettings_renderDistance = f(gameSettings_, "field_151451_c", "I"); + guiButton_id = f(guiButton_, "field_146127_k", "I"); + guiScreen_buttonList = f(guiScreen_, "field_146292_n", "Ljava/util/List;"); + guiScreen_width = f(guiScreen_, "field_146294_l", "I"); + guiScreen_height = f(guiScreen_, "field_146295_m", "I"); + guiScreen_mc = f(guiScreen_, "field_146297_k", minecraft_.desc); + guiOptions_options = f(guiOptions_, "field_146443_h", gameSettings_.desc); + itemBlock_block = f(itemBlock_, "field_150939_a", block_.desc); + itemRenderer_itemToRender = f(itemRenderer_, "field_78453_b", itemStack_.desc); + layeredTexture_layeredTextureNames = f(layeredTexture_, "field_110567_b", "Ljava/util/List;"); + minecraft_renderGlobal = f(minecraft_, "field_71438_f", renderGlobal_.desc); + minecraft_gameSettings = f(minecraft_, "field_71474_y", gameSettings_.desc); + modelRenderer_displayList = f(modelRenderer_, "field_78811_r", "I"); + modelRenderer_compiled = f(modelRenderer_, "field_78812_q", "Z"); + renderGlobal_glSkyList = f(renderGlobal_, "field_72771_w", "I"); + renderGlobal_worldRenderers = f(renderGlobal_, "field_72765_l", "[" + worldRenderer_.desc); + rendererLivingE_mainModel = f(rendererLivingE_, "field_77045_g", null); + rendererLivingE_renderPassModel = f(rendererLivingE_, "field_77046_h", null); + renderManager_entityRenderMap = f(renderManager_, "field_78729_o", "Ljava/util/Map;"); + renderManager_instance = f(renderManager_, "field_78727_a", renderManager_.desc); + simpleTexture_textureLocation = f(simpleTexture_, "field_110568_b", resourceLocation_.desc); + tessellator_floatBuffer = f(tessellator_, "field_147566_d", "Ljava/nio/FloatBuffer;"); + tessellator_shortBuffer = f(tessellator_, "field_147567_e", "Ljava/nio/ShortBuffer;"); + tessellator_intBuffer = f(tessellator_, "field_147568_c", "Ljava/nio/IntBuffer;"); + tessellator_byteBuffer = f(tessellator_, "field_78394_d", "Ljava/nio/ByteBuffer;"); + tessellator_rawBuffer = f(tessellator_, "field_78405_h", "[I"); + tessellator_vertexCount = f(tessellator_, "field_78406_i", "I"); + tessellator_hasNormals = f(tessellator_, "field_78413_q", "Z"); + textureAtlasSpri_width = f(textureAtlasSpri_, "field_130223_c", null); + textureAtlasSpri_height = f(textureAtlasSpri_, "field_130224_d", null); + textureAtlasSpri_border = f(textureAtlasSpri_, "field_147966_k", null); + textureMap_anisotropic = f(textureMap_, "field_147637_k", null); + textureDownload_textureUploaded = f(textureDownload_, "field_110559_g", "Z"); + vec3_xCoord = f(vec3_, "field_72450_a", "D"); + + abstractTexture_deleteGlTexture = m(abstractTexture_, "func_147631_c", "()V"); + block_getAoLight = m(block_, "func_149685_I", "()F"); + block_getBlockFromItem = m(block_, "func_149634_a", "(" + item_.desc + ")" + block_.desc); + dynamicTexture_updateDynamicTexture = m(dynamicTexture_, "func_110564_a", "()V"); + effectRenderer_renderLitParticles = m(effectRenderer_, "func_78872_b", "(" + entity_.desc + "F)V"); + effectRenderer_renderParticles = m(effectRenderer_, "func_78874_a", "(" + entity_.desc + "F)V"); + entity_getBrightness = m(entity_, "func_70013_c", "(F)F"); + entityRenderer_enableLightmap = m(entityRenderer_, "func_78463_b", "(D)V"); + entityRenderer_updateFogColor = m(entityRenderer_, "func_78466_h", "(F)V"); + entityRenderer_setupFog = m(entityRenderer_, "func_78468_a", "(IF)V"); + entityRenderer_setFogColorBuffer = m(entityRenderer_, "func_78469_a", "(FFFF)Ljava/nio/FloatBuffer;"); + entityRenderer_renderWorld = m(entityRenderer_, "func_78471_a", "(FJ)V"); + entityRenderer_renderRainSnow = m(entityRenderer_, "func_78474_d", "(F)V"); + entityRenderer_renderHand = m(entityRenderer_, "func_78476_b", "(FI)V"); + entityRenderer_setupCameraTransform = m(entityRenderer_, "func_78479_a", "(FI)V"); + entityRenderer_disableLightmap = m(entityRenderer_, "func_78483_a", "(D)V"); + entityRenderer_renderCloudsCheck = m(entityRenderer_, "func_82829_a", "(" + renderGlobal_.desc + "F)V"); + gameSettings_saveOptions = m(gameSettings_, "func_74303_b", "()V"); + gameSettings_shouldRenderClouds = m(gameSettings_, "func_74309_c", "()Z"); + glAllocation_createDirectByteBuffer = m(glAllocation_, "func_74524_c", "(I)Ljava/nio/ByteBuffer;"); + glAllocation_createDirectIntBuffer = m(glAllocation_, "func_74527_f", "(I)Ljava/nio/IntBuffer;"); + glAllocation_deleteDisplayLists = m(glAllocation_, "func_74523_b", "(I)V"); + guiOptions_actionPerformed = m(guiOptions_, "func_146284_a", "(" + guiButton_.desc + ")V"); + guiOptions_initGui = m(guiOptions_, "func_73866_w_", "()V"); + iCamera_setPosition = m(iCamera_, "func_78547_a", "(DDD)V"); + iResourceManager_getResource = + m(iResourceManager_, "func_110536_a", "(" + resourceLocation_.desc + ")" + iResource_.desc); + itemRenderer_renderItem = + m(itemRenderer_, "func_78443_a", "(" + entityLivingBase_.desc + itemStack_.desc + "I)V"); + itemRenderer_renderItemInFirstPerson = m(itemRenderer_, "func_78440_a", "(F)V"); + itemRenderer_renderOverlays = m(itemRenderer_, "func_78447_b", "(F)V"); + itemRenderer_updateEquipped = m(itemRenderer_, "func_78441_a", "()V"); + iTextureObject_loadTexture = m(iTextureObject_, "func_110551_a", "(" + iResourceManager_.desc + ")V"); + iTextureObject_getGlTextureId = m(iTextureObject_, "func_110552_b", "()I"); + minecraft_displayGuiScreen = m(minecraft_, "func_147108_a", "(" + guiScreen_.desc + ")V"); + minecraft_startGame = m(minecraft_, "func_71384_a", "()V"); + openGlHelper_setActiveTexture = m(openGlHelper_, "func_77473_a", "(I)V"); + render_renderShadow = m(render_, "func_76975_c", "(" + entity_.desc + "DDDFF)V"); + renderBlocks_renderBlockFluids = m(renderBlocks_, "func_147721_p", "(" + block_.desc + "III)Z"); + renderBlocks_renderStdBlockWithCM = m(renderBlocks_, "func_147736_d", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockSandFalling = + m(renderBlocks_, "func_147749_a", "(" + block_.desc + world_.desc + "IIII)V"); + renderBlocks_renderStdBlockWithAO = m(renderBlocks_, "func_147751_a", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockCactusImpl = m(renderBlocks_, "func_147754_e", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderBlockDoor = m(renderBlocks_, "func_147760_u", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockBed = m(renderBlocks_, "func_147773_v", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockByRenderType = m(renderBlocks_, "func_147805_b", "(" + block_.desc + "III)Z"); + renderBlocks_renderBlockFlowerPot = m(renderBlocks_, "func_147752_a", "(" + blockFlowerPot_.desc + "III)Z"); + renderBlocks_renderStdBlockWithAOP = m(renderBlocks_, "func_147808_b", "(" + block_.desc + "IIIFFF)Z"); + renderBlocks_renderPistonExtension = m(renderBlocks_, "func_147809_c", "(" + block_.desc + "IIIZ)Z"); + renderDragon_shouldRenderPass = m(renderDragon_, "func_77032_a", "(" + entityDragon_.desc + "IF)I"); + renderEnderman_shouldRenderPass = m(renderEnderman_, "func_77032_a", "(" + entityEnderman_.desc + "IF)I"); + renderSpider_shouldRenderPass = m(renderSpider_, "func_77032_a", "(" + entitySpider_.desc + "IF)I"); + rendererLivingE_doRender = m(rendererLivingE_, "func_76986_a", "(" + entityLivingBase_.desc + "DDDFF)V"); + rendererLivingE_renderEquippedItems = m(rendererLivingE_, "func_77029_c", "(" + entityLivingBase_.desc + "F)V"); + rendererLivingE_getColorMultiplier = m(rendererLivingE_, "func_77030_a", "(" + entityLivingBase_.desc + "FF)I"); + rendererLivingE_renderLabel = + m(rendererLivingE_, "func_96449_a", "(" + entityLivingBase_.desc + "DDDLjava/lang/String;FD)V"); + renderGlobal_renderEntities = + m(renderGlobal_, "func_147589_a", "(" + entityLivingBase_.desc + iCamera_.desc + "F)V"); + renderGlobal_renderSky = m(renderGlobal_, "func_72714_a", "(F)V"); + renderGlobal_drawBlockDamageTexture = + m(renderGlobal_, "func_72717_a", "(" + tessellator_.desc + entityPlayer_.desc + "F)V"); + renderGlobal_renderClouds = m(renderGlobal_, "func_72718_b", "(F)V"); + renderGlobal_sortAndRender = m(renderGlobal_, "func_72719_a", "(" + entityLivingBase_.desc + "ID)I"); + renderGlobal_clipRenderersByFrustum = m(renderGlobal_, "func_72729_a", "(" + iCamera_.desc + "F)V"); + renderGlobal_drawSelectionBox = + m(renderGlobal_, "func_72731_b", "(" + entityPlayer_.desc + movingObjectPos_.desc + "IF)V"); + renderGlobal_renderAllRenderLists = m(renderGlobal_, "func_72733_a", "(ID)V"); + stitcher_getCurrentWidth = m(stitcher_, "func_110935_a", "()I"); + tessellator_sortQuad = m(tessellator_, "func_147564_a", "(FFF)" + tessVertexState_.desc); + tessellator_addTranslation = m(tessellator_, "func_78372_c", "(FFF)V"); + tessellator_setNormal = m(tessellator_, "func_78375_b", "(FFF)V"); + tessellator_addVertex = m(tessellator_, "func_78377_a", "(DDD)V"); + tessellator_reset = m(tessellator_, "func_78379_d", "()V"); + tessellator_draw = m(tessellator_, "func_78381_a", "()I"); + textureAtlasSpri_loadSprite = m(textureAtlasSpri_, "func_130100_a", "(" + iResource_.desc + ")V"); + textureAtlasSpri_getFrameTextureData = m(textureAtlasSpri_, "func_147965_a", "(I)[[I"); + textureAtlasSpri_getIconName = m(textureAtlasSpri_, "func_94215_i", "()Ljava/lang/String;"); + textureAtlasSpri_updateAnimation = m(textureAtlasSpri_, "func_94219_l", "()V"); + textureCompass_updateCompass = m(textureCompass_, "func_94241_a", "(" + world_.desc + "DDDZZ)V"); + textureManager_onResourceManagerReload = + m(textureManager_, "func_110549_a", "(" + iResourceManager_.desc + ")V"); + textureManager_bindTexture = m(textureManager_, "func_110577_a", "(" + resourceLocation_.desc + ")V"); + textureMap_loadTextureAtlas = m(textureMap_, "func_110571_b", "(" + iResourceManager_.desc + ")V"); + textureMap_getIconResLoc = + m(textureMap_, "func_147634_a", "(" + resourceLocation_.desc + "I)" + resourceLocation_.desc); + textureMap_updateAnimations = m(textureMap_, "func_94248_c", "()V"); + textureUtil_uploadTexture = m(textureUtil_, "func_110988_a", "(I[III)V"); + textureUtil_uploadTextureImageAllocate = + m(textureUtil_, "func_110989_a", "(ILjava/awt/image/BufferedImage;ZZ)I"); + textureUtil_allocateTexture = m(textureUtil_, "func_110991_a", "(III)V"); + textureUtil_allocateTextureMipmapAniso = m(textureUtil_, "func_147946_a", "(IIIIF)V"); + textureUtil_uploadTexSub = m(textureUtil_, "func_147955_a", "([[IIIIIZZ)V"); + textureUtil_bindTexture = m(textureUtil_, "func_94277_a", "(I)V"); + world_getCelestialAngle = m(world_, "func_72826_c", "(F)F"); + world_getRainStrength = m(world_, "func_72867_j", "(F)F"); + modelRenderer_render = m(modelRenderer_, "func_78785_a", "(F)V"); + modelRenderer_renderWithRotation = m(modelRenderer_, "func_78791_b", "(F)V"); + + guiOptions_buttonList = f(guiOptions_, guiScreen_buttonList); + guiOptions_width = f(guiOptions_, guiScreen_width); + guiOptions_height = f(guiOptions_, guiScreen_height); + guiOptions_mc = f(guiOptions_, guiScreen_mc); + frustrum_setPosition = m(frustrum_, iCamera_setPosition); + worldClient_getCelestialAngle = m(worldClient_, world_getCelestialAngle); + worldClient_getRainStrength = m(worldClient_, world_getRainStrength); + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/Names.java b/src/main/java/com/gtnewhorizons/angelica/transform/Names.java new file mode 100644 index 000000000..cad1d66e6 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/Names.java @@ -0,0 +1,266 @@ +package com.gtnewhorizons.angelica.transform; + +public class Names { + + public static class Name { + String clas; + String name; + String desc; + + public Name(String clas, String name, String desc) { + this.clas = clas; + this.name = name; + this.desc = desc; + } + + public Name set(String clas, String name, String desc) { + this.clas = clas; + this.name = name; + this.desc = desc; + return this; + } + + public boolean equals(String clas, String name, String desc) { + return this.clas.equals(clas) && this.name.equals(name) && this.desc.equals(desc); + } + } + + public static class Type extends Name { + public Type(String desc) { + super("", "", desc); + } + + public Type(String name, String desc) { + super(name, name, desc); + } + } + + public static class Clas extends Type { + public Clas(String name) { + super(name, "L" + name + ";"); + } + + public boolean equals(String clas) { + return this.clas.equals(clas); + } + } + + public static class Fiel extends Name { + public Fiel(Clas clas, String name, String desc) { + super(clas.clas, name, desc); + } + + public boolean equals(String clas, String name) { + return this.clas.equals(clas) && this.name.equals(name); + } + } + + public static class Meth extends Name { + public Meth(Clas clas, String name, String desc) { + super(clas.clas, name, desc); + } + + public boolean equalsNameDesc(String name, String desc) { + return this.name.equals(name) && this.desc.equals(desc); + } + } + + static Clas block_; + static Clas blockFlowerPot_; + static Clas minecraft_; + static Clas guiButton_; + static Clas guiOptions_; + static Clas guiScreen_; + static Clas modelRenderer_; + static Clas worldClient_; + static Clas effectRenderer_; + static Clas entityRenderer_; + static Clas glAllocation_; + static Clas itemRenderer_; + static Clas openGlHelper_; + static Clas renderBlocks_; + static Clas renderGlobal_; + static Clas tessellator_; + static Clas worldRenderer_; + static Clas frustrum_; + static Clas iCamera_; + static Clas render_; + static Clas renderDragon_; + static Clas renderEnderman_; + static Clas renderSpider_; + static Clas renderManager_; + static Clas rendererLivingE_; + static Clas abstractTexture_; + static Clas dynamicTexture_; + static Clas iTextureObject_; + static Clas layeredTexture_; + static Clas simpleTexture_; + static Clas stitcher_; + static Clas textureAtlasSpri_; + static Clas textureClock_; + static Clas textureCompass_; + static Clas textureManager_; + static Clas textureMap_; + static Clas textureUtil_; + static Clas textureDownload_; + static Clas iResource_; + static Clas iResourceManager_; + static Clas gameSettings_; + static Clas tessVertexState_; + static Clas entity_; + static Clas entityLivingBase_; + static Clas entityDragon_; + static Clas entityEnderman_; + static Clas entitySpider_; + static Clas entityPlayer_; + static Clas item_; + static Clas itemBlock_; + static Clas itemStack_; + static Clas movingObjectPos_; + static Clas resourceLocation_; + static Clas vec3_; + static Clas iBlockAccess_; + static Clas world_; + + static Fiel entityLivingBase_deathTime; + static Fiel entityLivingBase_hurtTime; + static Fiel entityRenderer_cameraZoom; + static Fiel entityRenderer_mc; + static Fiel gameSettings_renderDistance; + static Fiel guiButton_id; + static Fiel guiScreen_buttonList; + static Fiel guiScreen_width; + static Fiel guiScreen_height; + static Fiel guiScreen_mc; + static Fiel guiOptions_options; + static Fiel itemBlock_block; + static Fiel itemRenderer_itemToRender; + static Fiel layeredTexture_layeredTextureNames; + static Fiel minecraft_renderGlobal; + static Fiel minecraft_gameSettings; + static Fiel modelRenderer_displayList; + static Fiel modelRenderer_compiled; + static Fiel renderGlobal_glSkyList; + static Fiel renderGlobal_worldRenderers; + static Fiel rendererLivingE_mainModel; + static Fiel rendererLivingE_renderPassModel; + static Fiel renderManager_entityRenderMap; + static Fiel renderManager_instance; + static Fiel simpleTexture_textureLocation; + static Fiel tessellator_floatBuffer; + static Fiel tessellator_shortBuffer; + static Fiel tessellator_intBuffer; + static Fiel tessellator_byteBuffer; + static Fiel tessellator_rawBuffer; + static Fiel tessellator_vertexCount; + static Fiel tessellator_hasNormals; + static Fiel textureAtlasSpri_width; + static Fiel textureAtlasSpri_height; + static Fiel textureAtlasSpri_border; + static Fiel textureMap_anisotropic; + static Fiel textureDownload_textureUploaded; + static Fiel vec3_xCoord; + + static Fiel guiOptions_buttonList; + static Fiel guiOptions_width; + static Fiel guiOptions_height; + static Fiel guiOptions_mc; + + static Meth abstractTexture_deleteGlTexture; + static Meth block_getAoLight; + static Meth block_getBlockFromItem; + static Meth dynamicTexture_updateDynamicTexture; + static Meth effectRenderer_renderLitParticles; + static Meth effectRenderer_renderParticles; + static Meth entity_getBrightness; + static Meth entityRenderer_enableLightmap; + static Meth entityRenderer_updateFogColor; + static Meth entityRenderer_setupFog; + static Meth entityRenderer_setFogColorBuffer; + static Meth entityRenderer_renderWorld; + static Meth entityRenderer_renderRainSnow; + static Meth entityRenderer_renderHand; + static Meth entityRenderer_setupCameraTransform; + static Meth entityRenderer_disableLightmap; + static Meth entityRenderer_renderCloudsCheck; + static Meth gameSettings_saveOptions; + static Meth gameSettings_shouldRenderClouds; + static Meth glAllocation_createDirectByteBuffer; + static Meth glAllocation_createDirectIntBuffer; + static Meth glAllocation_deleteDisplayLists; + static Meth guiOptions_actionPerformed; + static Meth guiOptions_initGui; + static Meth iCamera_setPosition; + static Meth iResourceManager_getResource; + static Meth itemRenderer_renderItem; + static Meth itemRenderer_renderItemInFirstPerson; + static Meth itemRenderer_renderOverlays; + static Meth itemRenderer_updateEquipped; + static Meth iTextureObject_loadTexture; + static Meth iTextureObject_getGlTextureId; + static Meth minecraft_displayGuiScreen; + static Meth minecraft_startGame; + static Meth openGlHelper_setActiveTexture; + static Meth render_renderShadow; + static Meth renderBlocks_renderBlockFluids; + static Meth renderBlocks_renderStdBlockWithCM; + static Meth renderBlocks_renderBlockSandFalling; + static Meth renderBlocks_renderStdBlockWithAO; + static Meth renderBlocks_renderBlockCactusImpl; + static Meth renderBlocks_renderBlockDoor; + static Meth renderBlocks_renderBlockBed; + static Meth renderBlocks_renderBlockByRenderType; + static Meth renderBlocks_renderBlockFlowerPot; + static Meth renderBlocks_renderStdBlockWithAOP; + static Meth renderBlocks_renderPistonExtension; + static Meth renderDragon_shouldRenderPass; + static Meth renderEnderman_shouldRenderPass; + static Meth renderSpider_shouldRenderPass; + static Meth rendererLivingE_doRender; + static Meth rendererLivingE_renderEquippedItems; + static Meth rendererLivingE_getColorMultiplier; + static Meth rendererLivingE_renderLabel; + static Meth renderGlobal_renderEntities; + static Meth renderGlobal_renderSky; + static Meth renderGlobal_drawBlockDamageTexture; + static Meth renderGlobal_renderClouds; + static Meth renderGlobal_sortAndRender; + static Meth renderGlobal_clipRenderersByFrustum; + static Meth renderGlobal_drawSelectionBox; + static Meth renderGlobal_renderAllRenderLists; + static Meth stitcher_getCurrentWidth; + static Meth tessellator_sortQuad; + static Meth tessellator_addTranslation; + static Meth tessellator_setNormal; + static Meth tessellator_addVertex; + static Meth tessellator_reset; + static Meth tessellator_draw; + static Meth textureAtlasSpri_loadSprite; + static Meth textureAtlasSpri_getFrameTextureData; + static Meth textureAtlasSpri_getIconName; + static Meth textureAtlasSpri_updateAnimation; + static Meth textureCompass_updateCompass; + static Meth textureManager_onResourceManagerReload; + static Meth textureManager_bindTexture; + static Meth textureMap_loadTextureAtlas; + static Meth textureMap_getIconResLoc; + static Meth textureMap_updateAnimations; + static Meth textureUtil_uploadTexture; + static Meth textureUtil_uploadTextureImageAllocate; + static Meth textureUtil_allocateTexture; + static Meth textureUtil_allocateTextureMipmapAniso; + static Meth textureUtil_uploadTexSub; + static Meth textureUtil_bindTexture; + static Meth world_getCelestialAngle; + static Meth world_getRainStrength; + static Meth modelRenderer_render; + static Meth modelRenderer_renderWithRotation; + + static Meth frustrum_setPosition; + static Meth worldClient_getCelestialAngle; + static Meth worldClient_getRainStrength; + + public static boolean equals(String clas1, String name1, String desc1, String clas2, String name2, String desc2) { + return clas1.equals(clas2) && name1.equals(name2) && desc1.equals(desc2); + } +} diff --git a/java_dev/shadersmodcore/devel/Names.txt b/src/main/java/com/gtnewhorizons/angelica/transform/Names.txt similarity index 75% rename from java_dev/shadersmodcore/devel/Names.txt rename to src/main/java/com/gtnewhorizons/angelica/transform/Names.txt index 49d3e7805..c6b60dbdf 100644 --- a/java_dev/shadersmodcore/devel/Names.txt +++ b/src/main/java/com/gtnewhorizons/angelica/transform/Names.txt @@ -1,167 +1,167 @@ -Block_ "net/minecraft/block/Block" -GuiButton_ "net/minecraft/client/gui/GuiButton" -GuiOptions_ "net/minecraft/client/gui/GuiOptions" -GuiScreen_ "net/minecraft/client/gui/GuiScreen" -Minecraft_ "net/minecraft/client/Minecraft" -ModelRenderer_ "net/minecraft/client/model/ModelRenderer" -WorldClient_ "net/minecraft/client/multiplayer/WorldClient" -EffectRenderer_ "net/minecraft/client/particle/EffectRenderer" -Frustrum_ "net/minecraft/client/renderer/culling/Frustrum" -ICamera_ "net/minecraft/client/renderer/culling/ICamera" -Render_ "net/minecraft/client/renderer/entity/Render" -RenderDragon_ "net/minecraft/client/renderer/entity/RenderDragon" -RenderEnderman_ "net/minecraft/client/renderer/entity/RenderEnderman" -RenderSpider_ "net/minecraft/client/renderer/entity/RenderSpider" -EntityRenderer_ "net/minecraft/client/renderer/EntityRenderer" -RendererLivingEntity_ "net/minecraft/client/renderer/entity/RendererLivingEntity" -GLAllocation_ "net/minecraft/client/renderer/GLAllocation" -ItemRenderer_ "net/minecraft/client/renderer/ItemRenderer" -OpenGlHelper_ "net/minecraft/client/renderer/OpenGlHelper" -RenderBlocks_ "net/minecraft/client/renderer/RenderBlocks" -RenderGlobal_ "net/minecraft/client/renderer/RenderGlobal" -Tessellator_ "net/minecraft/client/renderer/Tessellator" -TesselatorVertexState_ "net/minecraft/client/shader/TesselatorVertexState" -AbstractTexture_ "net/minecraft/client/renderer/texture/AbstractTexture" -DynamicTexure_ "net/minecraft/client/renderer/texture/DynamicTexture" -ITextureObject_ "net/minecraft/client/renderer/texture/ITextureObject" -LayeredTexture_ "net/minecraft/client/renderer/texture/LayeredTexture" -SimpleTexture_ "net/minecraft/client/renderer/texture/SimpleTexture" -Stitcher_ "net/minecraft/client/renderer/texture/Stitcher" -TextureAtlasSprite_ "net/minecraft/client/renderer/texture/TextureAtlasSprite" -TextureClock_ "net/minecraft/client/renderer/texture/TextureClock" -TextureCompass_ "net/minecraft/client/renderer/texture/TextureCompass" -TextureManager_ "net/minecraft/client/renderer/texture/TextureManager" -TextureMap_ "net/minecraft/client/renderer/texture/TextureMap" -TextureUtil_ "net/minecraft/client/renderer/texture/TextureUtil" -ThreadDownloadImageData_ "net/minecraft/client/renderer/ThreadDownloadImageData" -IResource_ "net/minecraft/client/resources/IResource" -IResourceManager_ "net/minecraft/client/resources/IResourceManager" -GameSettings_ "net/minecraft/client/settings/GameSettings" -Entity_ "net/minecraft/entity/Entity" -EntityLivingBase_ "net/minecraft/entity/EntityLivingBase" -EntityDragon_ "net/minecraft/entity/boss/EntityDragon" -EntityEnderman_ "net/minecraft/entity/monster/EntityEnderman" -EntitySpider_ "net/minecraft/entity/monster/EntitySpider" -EntityPlayer_ "net/minecraft/entity/player/EntityPlayer" -MovingObjectPosition "net/minecraft/util/MovingObjectPosition" -ResourceLocation_ "net/minecraft/util/ResourceLocation" -Vec3_ "net/minecraft/util/Vec3" -IBlockAccess_ "net/minecraft/world/IBlockAccess" -World_ "net/minecraft/world/World" - -EntityLivingBase_deathTime EntityLivingBase_ "field_70725_aQ" "I" -EntityLivingBase_hurtTime EntityLivingBase_ "field_70737_aN" "I" -EntityRenderer_cameraZoom EntityRenderer_ "field_78503_V" "D" -EntityRenderer_mc EntityRenderer_ "field_78531_r" "L"+Minecraft_.name+";" -GameSettings_renderDistance GameSettings_ "field_151451_c" "I" -GuiButton_id GuiButton_ "field_146127_k" -GuiOptions_buttonList GuiOptions_ "field_146292_n" -GuiOptions_width GuiOptions_ "field_146294_l" -GuiOptions_height GuiOptions_ "field_146295_m" -GuiOptions_mc GuiOptions_ "field_146297_k" -GuiOptions_options GuiOptions_ "field_146443_h" -LayeredTexture_layeredTextureNames LayeredTexture_ "field_110567_b" -Minecraft_renderGlobal Minecraft_ "field_71438_f" -Minecraft_gameSettings Minecraft_ "field_71474_y" -ModelRenderer_displayList ModelRenderer_ "field_78811_r" -ModelRenderer_compiled ModelRenderer_ "field_78812_q" -RendererLivingEntity_mainModel RendererLivingEntity_ "field_77045_g" -RendererLivingEntity_renderPassModel RendererLivingEntity_ "field_77046_h" -RenderGlobal_glSkyList RenderGlobal_ "field_72771_w" -SimpleTexture_textureLocation SimpleTexture_ "field_110568_b" "L"+ResourceLocation_.name+";" -Tessellator_floatBuffer Tessellator_ "field_147566_d" -Tessellator_shortBuffer Tessellator_ "field_147567_e" -Tessellator_intBuffer Tessellator_ "field_147568_c" -Tessellator_byteBuffer Tessellator_ "field_78394_d" -Tessellator_rawBuffer Tessellator_ "field_78405_h" -Tessellator_vertexCount Tessellator_ "field_78406_i" -Tessellator_hasNormals Tessellator_ "field_78413_q" "Z" -TextureAtlasSprite_width TextureAtlasSprite_ "field_130223_c" -TextureAtlasSprite_height TextureAtlasSprite_ "field_130224_d" -TextureAtlasSprite_border TextureAtlasSprite_ "field_147966_k" -TextureMap_anisotropic TextureMap_ "field_147637_k" -ThreadDownloadImageData_textureUploaded ThreadDownloadImageData_ "field_110559_g" "Z" -Vec3_xCoord Vec3_ "field_72450_a" "D" - -AbstractTexture_deleteGlTexture AbstractTexture_ "func_147631_c" "()V" -Block_getAoLight Block_ "func_149685_I" "(L"+IBlockAccess_+";III)F" -DynamicTexure_updateDynamicTexture DynamicTexure_ "func_110564_a" "()V" -EffectRenderer_renderLitParticles EffectRenderer_ "func_78872_b" "(L"+Entity_.name+";F)V" -EffectRenderer_renderParticles EffectRenderer_ "func_78874_a" "(L"+Entity_.name+";F)V" -Entity_getBrightness Entity_ "func_70013_c" "(F)F" -EntityRenderer_enableLightmap EntityRenderer_ "func_78463_b" "(D)V" -EntityRenderer_updateFogColor EntityRenderer_ "func_78466_h" "(F)V" -EntityRenderer_setupFog EntityRenderer_ "func_78468_a" "(IF)V" -EntityRenderer_setFogColorBuffer EntityRenderer_ "func_78469_a" "(FFFF)Ljava/nio/FloatBuffer;" -EntityRenderer_renderWorld EntityRenderer_ "func_78471_a" "(FJ)V" -EntityRenderer_renderRainSnow EntityRenderer_ "func_78474_d" "(F)V" -EntityRenderer_renderHand EntityRenderer_ "func_78476_b" "(FI)V" -EntityRenderer_setupCameraTransform EntityRenderer_ "func_78479_a" "(FI)V" -EntityRenderer_disableLightmap EntityRenderer_ "func_78483_a" "(D)V" -EntityRenderer_renderCloudsCheck EntityRenderer_ "func_82829_a" "(L"+RenderGlobal_.name+";F)V" -GameSettings_saveOptions GameSettings_ "func_74303_b" "()V" -GameSettings_shouldRenderClouds GameSettings_ "func_74309_c" "()Z" -GLAllocation_createDirectByteBuffer GLAllocation_ "func_74524_c" "(I)Ljava/nio/ByteBuffer;" -GLAllocation_createDirectIntBuffer GLAllocation_ "func_74527_f" "(I)Ljava/nio/IntBuffer;" -GuiOptions_actionPerformed GuiOptions_ "func_146284_a" "(L"+GuiButton_+";)V" -GuiOptions_initGui GuiOptions_ "func_73866_w_" "()V" -ICamera_setPosition ICamera_ "func_78547_a" "(DDD)V" -ItemRenderer_renderItemInFirstPerson ItemRenderer_ "func_78440_a" "(F)V" -ItemRenderer_renderOverlays ItemRenderer_ "func_78447_b" "(F)V" -Minecraft_displayGuiScreen Minecraft_ "func_147108_a" "(L"+GuiScreen_+";)V" -Minecraft_startGame Minecraft_ "func_71384_a" "()V" -OpenGlHelper_setActiveTexture OpenGlHelper_ "func_77473_a" "(I)V" -Render_renderShadow Render_ "func_76975_c" "(L"+Entity_.name+";DDDFF)V" -RenderBlocks_renderBlockFluids RenderBlocks_ "func_147721_p" "(L"+Block_+";III)Z" -RenderBlocks_renderStdBlockWithCM RenderBlocks_ "func_147736_d" "(L"+Block_+";IIIFFF)Z" -RenderBlocks_renderBlockSandFalling RenderBlocks_ "func_147749_a" "(L"+Block_+";L"+World_+";IIII)V" -RenderBlocks_renderStdBlockWithAO RenderBlocks_ "func_147751_a" "(L"+Block_+";IIIFFF)Z" -RenderBlocks_renderBlockCactusImpl RenderBlocks_ "func_147754_e" "(L"+Block_+";IIIFFF)Z" -RenderBlocks_renderBlockDoor RenderBlocks_ "func_147760_u" "(L"+Block_+";III)Z" -RenderBlocks_renderBlockBed RenderBlocks_ "func_147773_v" "(L"+Block_+";III)Z" -RenderBlocks_renderBlockByRenderType RenderBlocks_ "func_147805_b" "(L"+Block_+";III)Z" -RenderBlocks_renderStdBlockWithAOP RenderBlocks_ "func_147808_b" "(L"+Block_+";IIIFFF)Z" -RenderBlocks_renderPistonExtension RenderBlocks_ "func_147809_c" "(L"+Block_+";IIIZ)Z" -RenderDragon_shouldRenderPass RenderDragon_ "func_77032_a" "(L"+EntityDragon_+";IF)I" -RenderEnderman_shouldRenderPass RenderEnderman_ "func_77032_a" "(L"+EntityEnderman_+";IF)I" -RenderSpider_shouldRenderPass RenderSpider_ "func_77032_a" "(L"+EntitySpider_+";IF)I" -RendererLivingEntity_doRender RendererLivingEntity_ "func_76986_a" "(L"+EntityLivingBase_+";DDDFF)V" -RendererLivingEntity_renderEquippedItems RendererLivingEntity_ "func_77029_c" "(L"+EntityLivingBase_+";F)V" -RendererLivingEntity_getColorMultiplier RendererLivingEntity_ "func_77030_a" "(L"+EntityLivingBase_+";FF)I" -RendererLivingEntity_renderLabel RendererLivingEntity_ "func_96449_a" "(L"+EntityLivingBase_+";DDDLjava/lang/String;FD)V" -RenderGlobal_renderEntities RenderGlobal_ "func_147589_a" "(L"+EntityLivingBase_.name+";L"+ICamera_.name+";F)V" -RenderGlobal_renderSky RenderGlobal_ "func_72714_a" "(F)V" -RenderGlobal_drawBlockDamageTexture RenderGlobal_ "func_72717_a" "(L"+Tessellator_.name+";L"+EntityPlayer_.name+";F)V" -RenderGlobal_renderClouds RenderGlobal_ "func_72718_b" "(F)V" -RenderGlobal_sortAndRender RenderGlobal_ "func_72719_a" "(L"+EntityLivingBase_.name+";ID)I" -RenderGlobal_clipRenderersByFrustum RenderGlobal_ "func_72729_a" "(L"+ICamera_.name+";F)V" -RenderGlobal_drawSelectionBox RenderGlobal_ "func_72731_b" "(L"+EntityPlayer_.name+";L"+MovingObjectPosition_.name+";IF)V" -RenderGlobal_renderAllRenderLists RenderGlobal_ "func_72733_a" "(ID)V" -IResourceManager_getResource IResourceManager_ "func_110536_a" "(L"+ResourceLocation_.name+";)L"+IResource_.name+";" -Stitcher_getCurrentWidth Stitcher_ "func_110935_a" "()I" -Tessellator_sortQuad Tessellator_ "func_147564_a" "(FFF)L"+TesselatorVertexState_.name+";" -Tessellator_setNormal Tessellator_ "func_78375_b" "(FFF)V" -Tessellator_addVertex Tessellator_ "func_78377_a" "(DDD)V" -Tessellator_reset Tessellator_ "func_78379_d" "()V" -Tessellator_draw Tessellator_ "func_78381_a" "()I" -TextureAtlasSprite_loadSprite TextureAtlasSprite_ "func_130100_a" "(L"+IResource_.name+";)V" -TextureAtlasSprite_getFrameTextureData TextureAtlasSprite_ "func_147965_a" "(I)[[I" -TextureAtlasSprite_getIconName TextureAtlasSprite_ "func_94215_i" "()Ljava/lang/String;" -TextureAtlasSprite_updateAnimation TextureAtlasSprite_ "func_94219_l" "()V" -TextureCompass_updateCompass TextureCompass_ "func_94241_a" "(L"+World_.name+";DDDZZ)V" -TextureManager_onResourceManagerReload TextureManager_ "func_110549_a" "(L"+IResourceManager_.name+";)V" -TextureManager_bindTexture TextureManager_ "func_110577_a" "(L"+ResourceLocation_.name+";)V" -TextureMap_loadTextureAtlas TextureMap_ "func_110571_b" "(L"+IResourceManager_.name+";)V" -TextureMap_getIconResLoc TextureMap_ "func_147634_a" "(L"+ResourceLocation_.name+";I)L"+ResourceLocation_.name+";" -TextureMap_updateAnimations TextureMap_ "func_94248_c" "()V" -ITextureObject_loadTexture ITextureObject_ "func_110551_a" "(L"+IResourceManager_.name+";)V" -ITextureObject_getGlTextureId ITextureObject_ "func_110552_b" "()I" -TextureUtil_uploadTexture TextureUtil_ "func_110988_a" "(I[III)V" -TextureUtil_uploadTextureImageAllocate TextureUtil_ "func_110989_a" "(ILjava/awt/image/BufferedImage;ZZ)I" -TextureUtil_allocateTexture TextureUtil_ "func_110991_a" "(III)V" -TextureUtil_allocateTextureMipmapAniso TextureUtil_ "func_147946_a" "(IIIIF)V" -TextureUtil_uploadTexSub TextureUtil_ "func_147955_a" "([[IIIIIZZ)V" -TextureUtil_bindTexture TextureUtil_ "func_94277_a" "(I)V" -WorldClient_getCelestialAngle WorldClient_ "func_72826_c" "(F)F" -WorldClient_getRainStrength WorldClient_ "func_72867_j" "(F)F" -Frustrum_setPosition Frustrum_ ICamera_setPosition.name ICamera_setPosition.desc +Block_ "net/minecraft/block/Block" +GuiButton_ "net/minecraft/client/gui/GuiButton" +GuiOptions_ "net/minecraft/client/gui/GuiOptions" +GuiScreen_ "net/minecraft/client/gui/GuiScreen" +Minecraft_ "net/minecraft/client/Minecraft" +ModelRenderer_ "net/minecraft/client/model/ModelRenderer" +WorldClient_ "net/minecraft/client/multiplayer/WorldClient" +EffectRenderer_ "net/minecraft/client/particle/EffectRenderer" +Frustrum_ "net/minecraft/client/renderer/culling/Frustrum" +ICamera_ "net/minecraft/client/renderer/culling/ICamera" +Render_ "net/minecraft/client/renderer/entity/Render" +RenderDragon_ "net/minecraft/client/renderer/entity/RenderDragon" +RenderEnderman_ "net/minecraft/client/renderer/entity/RenderEnderman" +RenderSpider_ "net/minecraft/client/renderer/entity/RenderSpider" +EntityRenderer_ "net/minecraft/client/renderer/EntityRenderer" +RendererLivingEntity_ "net/minecraft/client/renderer/entity/RendererLivingEntity" +GLAllocation_ "net/minecraft/client/renderer/GLAllocation" +ItemRenderer_ "net/minecraft/client/renderer/ItemRenderer" +OpenGlHelper_ "net/minecraft/client/renderer/OpenGlHelper" +RenderBlocks_ "net/minecraft/client/renderer/RenderBlocks" +RenderGlobal_ "net/minecraft/client/renderer/RenderGlobal" +Tessellator_ "net/minecraft/client/renderer/Tessellator" +TesselatorVertexState_ "net/minecraft/client/shader/TesselatorVertexState" +AbstractTexture_ "net/minecraft/client/renderer/texture/AbstractTexture" +DynamicTexure_ "net/minecraft/client/renderer/texture/DynamicTexture" +ITextureObject_ "net/minecraft/client/renderer/texture/ITextureObject" +LayeredTexture_ "net/minecraft/client/renderer/texture/LayeredTexture" +SimpleTexture_ "net/minecraft/client/renderer/texture/SimpleTexture" +Stitcher_ "net/minecraft/client/renderer/texture/Stitcher" +TextureAtlasSprite_ "net/minecraft/client/renderer/texture/TextureAtlasSprite" +TextureClock_ "net/minecraft/client/renderer/texture/TextureClock" +TextureCompass_ "net/minecraft/client/renderer/texture/TextureCompass" +TextureManager_ "net/minecraft/client/renderer/texture/TextureManager" +TextureMap_ "net/minecraft/client/renderer/texture/TextureMap" +TextureUtil_ "net/minecraft/client/renderer/texture/TextureUtil" +ThreadDownloadImageData_ "net/minecraft/client/renderer/ThreadDownloadImageData" +IResource_ "net/minecraft/client/resources/IResource" +IResourceManager_ "net/minecraft/client/resources/IResourceManager" +GameSettings_ "net/minecraft/client/settings/GameSettings" +Entity_ "net/minecraft/entity/Entity" +EntityLivingBase_ "net/minecraft/entity/EntityLivingBase" +EntityDragon_ "net/minecraft/entity/boss/EntityDragon" +EntityEnderman_ "net/minecraft/entity/monster/EntityEnderman" +EntitySpider_ "net/minecraft/entity/monster/EntitySpider" +EntityPlayer_ "net/minecraft/entity/player/EntityPlayer" +MovingObjectPosition "net/minecraft/util/MovingObjectPosition" +ResourceLocation_ "net/minecraft/util/ResourceLocation" +Vec3_ "net/minecraft/util/Vec3" +IBlockAccess_ "net/minecraft/world/IBlockAccess" +World_ "net/minecraft/world/World" + +EntityLivingBase_deathTime EntityLivingBase_ "field_70725_aQ" "I" +EntityLivingBase_hurtTime EntityLivingBase_ "field_70737_aN" "I" +EntityRenderer_cameraZoom EntityRenderer_ "field_78503_V" "D" +EntityRenderer_mc EntityRenderer_ "field_78531_r" "L"+Minecraft_.name+";" +GameSettings_renderDistance GameSettings_ "field_151451_c" "I" +GuiButton_id GuiButton_ "field_146127_k" +GuiOptions_buttonList GuiOptions_ "field_146292_n" +GuiOptions_width GuiOptions_ "field_146294_l" +GuiOptions_height GuiOptions_ "field_146295_m" +GuiOptions_mc GuiOptions_ "field_146297_k" +GuiOptions_options GuiOptions_ "field_146443_h" +LayeredTexture_layeredTextureNames LayeredTexture_ "field_110567_b" +Minecraft_renderGlobal Minecraft_ "field_71438_f" +Minecraft_gameSettings Minecraft_ "field_71474_y" +ModelRenderer_displayList ModelRenderer_ "field_78811_r" +ModelRenderer_compiled ModelRenderer_ "field_78812_q" +RendererLivingEntity_mainModel RendererLivingEntity_ "field_77045_g" +RendererLivingEntity_renderPassModel RendererLivingEntity_ "field_77046_h" +RenderGlobal_glSkyList RenderGlobal_ "field_72771_w" +SimpleTexture_textureLocation SimpleTexture_ "field_110568_b" "L"+ResourceLocation_.name+";" +Tessellator_floatBuffer Tessellator_ "field_147566_d" +Tessellator_shortBuffer Tessellator_ "field_147567_e" +Tessellator_intBuffer Tessellator_ "field_147568_c" +Tessellator_byteBuffer Tessellator_ "field_78394_d" +Tessellator_rawBuffer Tessellator_ "field_78405_h" +Tessellator_vertexCount Tessellator_ "field_78406_i" +Tessellator_hasNormals Tessellator_ "field_78413_q" "Z" +TextureAtlasSprite_width TextureAtlasSprite_ "field_130223_c" +TextureAtlasSprite_height TextureAtlasSprite_ "field_130224_d" +TextureAtlasSprite_border TextureAtlasSprite_ "field_147966_k" +TextureMap_anisotropic TextureMap_ "field_147637_k" +ThreadDownloadImageData_textureUploaded ThreadDownloadImageData_ "field_110559_g" "Z" +Vec3_xCoord Vec3_ "field_72450_a" "D" + +AbstractTexture_deleteGlTexture AbstractTexture_ "func_147631_c" "()V" +Block_getAoLight Block_ "func_149685_I" "(L"+IBlockAccess_+";III)F" +DynamicTexure_updateDynamicTexture DynamicTexure_ "func_110564_a" "()V" +EffectRenderer_renderLitParticles EffectRenderer_ "func_78872_b" "(L"+Entity_.name+";F)V" +EffectRenderer_renderParticles EffectRenderer_ "func_78874_a" "(L"+Entity_.name+";F)V" +Entity_getBrightness Entity_ "func_70013_c" "(F)F" +EntityRenderer_enableLightmap EntityRenderer_ "func_78463_b" "(D)V" +EntityRenderer_updateFogColor EntityRenderer_ "func_78466_h" "(F)V" +EntityRenderer_setupFog EntityRenderer_ "func_78468_a" "(IF)V" +EntityRenderer_setFogColorBuffer EntityRenderer_ "func_78469_a" "(FFFF)Ljava/nio/FloatBuffer;" +EntityRenderer_renderWorld EntityRenderer_ "func_78471_a" "(FJ)V" +EntityRenderer_renderRainSnow EntityRenderer_ "func_78474_d" "(F)V" +EntityRenderer_renderHand EntityRenderer_ "func_78476_b" "(FI)V" +EntityRenderer_setupCameraTransform EntityRenderer_ "func_78479_a" "(FI)V" +EntityRenderer_disableLightmap EntityRenderer_ "func_78483_a" "(D)V" +EntityRenderer_renderCloudsCheck EntityRenderer_ "func_82829_a" "(L"+RenderGlobal_.name+";F)V" +GameSettings_saveOptions GameSettings_ "func_74303_b" "()V" +GameSettings_shouldRenderClouds GameSettings_ "func_74309_c" "()Z" +GLAllocation_createDirectByteBuffer GLAllocation_ "func_74524_c" "(I)Ljava/nio/ByteBuffer;" +GLAllocation_createDirectIntBuffer GLAllocation_ "func_74527_f" "(I)Ljava/nio/IntBuffer;" +GuiOptions_actionPerformed GuiOptions_ "func_146284_a" "(L"+GuiButton_+";)V" +GuiOptions_initGui GuiOptions_ "func_73866_w_" "()V" +ICamera_setPosition ICamera_ "func_78547_a" "(DDD)V" +ItemRenderer_renderItemInFirstPerson ItemRenderer_ "func_78440_a" "(F)V" +ItemRenderer_renderOverlays ItemRenderer_ "func_78447_b" "(F)V" +Minecraft_displayGuiScreen Minecraft_ "func_147108_a" "(L"+GuiScreen_+";)V" +Minecraft_startGame Minecraft_ "func_71384_a" "()V" +OpenGlHelper_setActiveTexture OpenGlHelper_ "func_77473_a" "(I)V" +Render_renderShadow Render_ "func_76975_c" "(L"+Entity_.name+";DDDFF)V" +RenderBlocks_renderBlockFluids RenderBlocks_ "func_147721_p" "(L"+Block_+";III)Z" +RenderBlocks_renderStdBlockWithCM RenderBlocks_ "func_147736_d" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockSandFalling RenderBlocks_ "func_147749_a" "(L"+Block_+";L"+World_+";IIII)V" +RenderBlocks_renderStdBlockWithAO RenderBlocks_ "func_147751_a" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockCactusImpl RenderBlocks_ "func_147754_e" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderBlockDoor RenderBlocks_ "func_147760_u" "(L"+Block_+";III)Z" +RenderBlocks_renderBlockBed RenderBlocks_ "func_147773_v" "(L"+Block_+";III)Z" +RenderBlocks_renderBlockByRenderType RenderBlocks_ "func_147805_b" "(L"+Block_+";III)Z" +RenderBlocks_renderStdBlockWithAOP RenderBlocks_ "func_147808_b" "(L"+Block_+";IIIFFF)Z" +RenderBlocks_renderPistonExtension RenderBlocks_ "func_147809_c" "(L"+Block_+";IIIZ)Z" +RenderDragon_shouldRenderPass RenderDragon_ "func_77032_a" "(L"+EntityDragon_+";IF)I" +RenderEnderman_shouldRenderPass RenderEnderman_ "func_77032_a" "(L"+EntityEnderman_+";IF)I" +RenderSpider_shouldRenderPass RenderSpider_ "func_77032_a" "(L"+EntitySpider_+";IF)I" +RendererLivingEntity_doRender RendererLivingEntity_ "func_76986_a" "(L"+EntityLivingBase_+";DDDFF)V" +RendererLivingEntity_renderEquippedItems RendererLivingEntity_ "func_77029_c" "(L"+EntityLivingBase_+";F)V" +RendererLivingEntity_getColorMultiplier RendererLivingEntity_ "func_77030_a" "(L"+EntityLivingBase_+";FF)I" +RendererLivingEntity_renderLabel RendererLivingEntity_ "func_96449_a" "(L"+EntityLivingBase_+";DDDLjava/lang/String;FD)V" +RenderGlobal_renderEntities RenderGlobal_ "func_147589_a" "(L"+EntityLivingBase_.name+";L"+ICamera_.name+";F)V" +RenderGlobal_renderSky RenderGlobal_ "func_72714_a" "(F)V" +RenderGlobal_drawBlockDamageTexture RenderGlobal_ "func_72717_a" "(L"+Tessellator_.name+";L"+EntityPlayer_.name+";F)V" +RenderGlobal_renderClouds RenderGlobal_ "func_72718_b" "(F)V" +RenderGlobal_sortAndRender RenderGlobal_ "func_72719_a" "(L"+EntityLivingBase_.name+";ID)I" +RenderGlobal_clipRenderersByFrustum RenderGlobal_ "func_72729_a" "(L"+ICamera_.name+";F)V" +RenderGlobal_drawSelectionBox RenderGlobal_ "func_72731_b" "(L"+EntityPlayer_.name+";L"+MovingObjectPosition_.name+";IF)V" +RenderGlobal_renderAllRenderLists RenderGlobal_ "func_72733_a" "(ID)V" +IResourceManager_getResource IResourceManager_ "func_110536_a" "(L"+ResourceLocation_.name+";)L"+IResource_.name+";" +Stitcher_getCurrentWidth Stitcher_ "func_110935_a" "()I" +Tessellator_sortQuad Tessellator_ "func_147564_a" "(FFF)L"+TesselatorVertexState_.name+";" +Tessellator_setNormal Tessellator_ "func_78375_b" "(FFF)V" +Tessellator_addVertex Tessellator_ "func_78377_a" "(DDD)V" +Tessellator_reset Tessellator_ "func_78379_d" "()V" +Tessellator_draw Tessellator_ "func_78381_a" "()I" +TextureAtlasSprite_loadSprite TextureAtlasSprite_ "func_130100_a" "(L"+IResource_.name+";)V" +TextureAtlasSprite_getFrameTextureData TextureAtlasSprite_ "func_147965_a" "(I)[[I" +TextureAtlasSprite_getIconName TextureAtlasSprite_ "func_94215_i" "()Ljava/lang/String;" +TextureAtlasSprite_updateAnimation TextureAtlasSprite_ "func_94219_l" "()V" +TextureCompass_updateCompass TextureCompass_ "func_94241_a" "(L"+World_.name+";DDDZZ)V" +TextureManager_onResourceManagerReload TextureManager_ "func_110549_a" "(L"+IResourceManager_.name+";)V" +TextureManager_bindTexture TextureManager_ "func_110577_a" "(L"+ResourceLocation_.name+";)V" +TextureMap_loadTextureAtlas TextureMap_ "func_110571_b" "(L"+IResourceManager_.name+";)V" +TextureMap_getIconResLoc TextureMap_ "func_147634_a" "(L"+ResourceLocation_.name+";I)L"+ResourceLocation_.name+";" +TextureMap_updateAnimations TextureMap_ "func_94248_c" "()V" +ITextureObject_loadTexture ITextureObject_ "func_110551_a" "(L"+IResourceManager_.name+";)V" +ITextureObject_getGlTextureId ITextureObject_ "func_110552_b" "()I" +TextureUtil_uploadTexture TextureUtil_ "func_110988_a" "(I[III)V" +TextureUtil_uploadTextureImageAllocate TextureUtil_ "func_110989_a" "(ILjava/awt/image/BufferedImage;ZZ)I" +TextureUtil_allocateTexture TextureUtil_ "func_110991_a" "(III)V" +TextureUtil_allocateTextureMipmapAniso TextureUtil_ "func_147946_a" "(IIIIF)V" +TextureUtil_uploadTexSub TextureUtil_ "func_147955_a" "([[IIIIIZZ)V" +TextureUtil_bindTexture TextureUtil_ "func_94277_a" "(I)V" +WorldClient_getCelestialAngle WorldClient_ "func_72826_c" "(F)F" +WorldClient_getRainStrength WorldClient_ "func_72867_j" "(F)F" +Frustrum_setPosition Frustrum_ ICamera_setPosition.name ICamera_setPosition.desc diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTBlock.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTBlock.java new file mode 100644 index 000000000..6d9b89460 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTBlock.java @@ -0,0 +1,66 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTBlock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + this.classname = name; + // SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if (Names.block_getAoLight.equalsNameDesc(name, desc)) { + // SMCLog.info(" patching"); + return new MVgetAoLight(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVgetAoLight extends MethodVisitor { + public MVgetAoLight(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof Float) { + if (((Float) cst).floatValue() == 0.2f) { + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "blockAoLight", "F"); + SMCLog.info(" blockAoLight"); + return; + } + } + mv.visitLdcInsn(cst); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTEntityRenderer.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTEntityRenderer.java new file mode 100644 index 000000000..4cca1a870 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTEntityRenderer.java @@ -0,0 +1,671 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +/** transformer for net.minecraft.client.renderer.EntityRenderer */ +public class SMCCTEntityRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if (Names.entityRenderer_disableLightmap.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVdisableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_enableLightmap.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVenableLightmap(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_updateFogColor.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVupdateFogColor(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_setFogColorBuffer.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVsetFogColorBuffer(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_setupFog.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVsetupFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_renderCloudsCheck.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderCloudsCheck(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_renderHand.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + return new MVrenderHand(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.entityRenderer_renderWorld.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderWorld(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVdisableLightmap extends MethodVisitor { + public MVdisableLightmap(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableLightmap", "()V"); + } + mv.visitInsn(opcode); + } + } + + private static class MVenableLightmap extends MethodVisitor { + public MVenableLightmap(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableLightmap", "()V"); + } + mv.visitInsn(opcode); + } + } + + private static class MVupdateFogColor extends MethodVisitor { + public MVupdateFogColor(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.equals("org/lwjgl/opengl/GL11", "glClearColor", "(FFFF)V", owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "setClearColor", "(FFFF)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVsetFogColorBuffer extends MethodVisitor { + public MVsetFogColorBuffer(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(FLOAD, 2); + mv.visitVarInsn(FLOAD, 3); + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "setFogColor", "(FFF)V"); + } + } + + private static class MVsetupFog extends MethodVisitor { + public MVsetupFog(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.equals("org/lwjgl/opengl/GL11", "glFogi", "(II)V", owner, name, desc)) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "sglFogi", "(II)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderCloudsCheck extends MethodVisitor { + public MVrenderCloudsCheck(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.gameSettings_shouldRenderClouds.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "shouldRenderClouds", + "(" + Names.gameSettings_.desc + ")Z"); + return; + } else if (Names.renderGlobal_renderClouds.equals(owner, name, desc)) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginClouds", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endClouds", "()V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderHand extends MethodVisitor { + Label la1, la2; + + public MVrenderHand(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + la1 = new Label(); + la2 = new Label(); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.equals("org/lwjgl/util/glu/Project", "gluPerspective", "(FFFF)V", owner, name, desc)) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "applyHandDepth", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else if (Names.equals("org/lwjgl/opengl/GL11", "glPushMatrix", "()V", owner, name, desc)) { + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "isHandRendered", "Z"); + mv.visitJumpInsn(IFNE, la1); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else if (Names.equals("org/lwjgl/opengl/GL11", "glPopMatrix", "()V", owner, name, desc)) { + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitLabel(la1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "isCompositeRendered", "Z"); + mv.visitJumpInsn(IFNE, la2); + mv.visitInsn(RETURN); + mv.visitLabel(la2); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitInsn(F2D); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.entityRenderer_disableLightmap.clas, + Names.entityRenderer_disableLightmap.name, + Names.entityRenderer_disableLightmap.desc); + return; + } else if (Names.itemRenderer_renderItemInFirstPerson.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "renderItemFP", + "(" + Names.itemRenderer_.desc + "F)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderWorld extends MethodVisitor { + public MVrenderWorld(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + private static final int stateEnd = 32; + int state = 0; + String section = ""; + Label labelAfterUpdate = null; + Label labelEndUpdate = null; + Label labelNoSky = null; + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, Names.entityRenderer_mc.clas, Names.entityRenderer_mc.name, Names.entityRenderer_mc.desc); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(LLOAD, 2); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "beginRender", + "(" + Names.minecraft_.desc + "FJ)V"); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + String scst = (String) cst; + // SMCLog.finest(" %d Ldc %s", state, scst); + section = scst; + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + // SMCLog.finest(" %d Int %d %d", state ,opcode, operand); + // switch (state) { + // case 23: + // case 25: + // if (opcode == SIPUSH && operand == 256) { + // state = 26; + // mv.visitInsn(ICONST_0); + // return; + // } + // break; + // } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitJumpInsn(int opcode, Label label) { + // SMCLog.finest(" %d, Jump %d", state, opcode); + switch (state) { + case 4: + if (opcode == IF_ICMPLT) { + ++state; + mv.visitInsn(POP2); + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "isShadowPass", "Z"); + mv.visitJumpInsn(IFNE, label); + return; + } + break; + case 10: + if (opcode == IFNE) { + ++state; + labelAfterUpdate = label; + labelEndUpdate = new Label(); + mv.visitJumpInsn(opcode, label); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginUpdateChunks", "()V"); + return; + } + break; + case 11: + if (label == labelAfterUpdate) { + mv.visitJumpInsn(opcode, labelEndUpdate); + return; + } + break; + case 28: + if (opcode == IFNE) { + ++state; + mv.visitJumpInsn(opcode, label); + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "isShadowPass", "Z"); + mv.visitJumpInsn(IFNE, label); + // mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", + // "readCenterDepth", + // "()V"); + // mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", + // "beginHand", "()V"); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitVarInsn(FLOAD, 1); + // mv.visitVarInsn(ILOAD, 13); + // mv.visitMethodInsn(INVOKESPECIAL, Names.EntityRenderer_, Names.EntityRenderer_renderHand, + // Names.EntityRenderer_renderHand_desc); + // mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endHand", + // "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(ILOAD, 13); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "renderHand1", + "(" + Names.entityRenderer_.desc + "FI)V"); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "renderCompositeFinal", + "()V"); + return; + } + break; + } + mv.visitJumpInsn(opcode, label); + } + + @Override + public void visitLabel(Label label) { + switch (state) { + case 11: + if (label == labelAfterUpdate) { + ++state; + mv.visitLabel(labelEndUpdate); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endUpdateChunks", "()V"); + mv.visitLabel(label); + labelAfterUpdate = labelEndUpdate = null; + return; + } + } + mv.visitLabel(label); + } + + @Override + public void visitFrame(int type, int nLocal, Object[] local, int nStack, Object[] stack) { + // SMCLog.finest(" %d, Frame",state); + switch (state) { + case 7: { + state = 8; + mv.visitLabel(labelNoSky); + labelNoSky = null; + mv.visitFrame(type, nLocal, local, nStack, stack); + return; + } + + case 31: { + ++state; + mv.visitFrame(type, nLocal, local, nStack, stack); + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endRender", "()V"); + return; + } + } + mv.visitFrame(type, nLocal, local, nStack, stack); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" %d F %d %s.%s %s", state, opcode, ownerM, nameM, descM); + switch (state) { + case 3: + if (Names.gameSettings_renderDistance.equals(owner, name)) { + ++state; + } + break; + case 24: + case 26: + if (Names.entityRenderer_cameraZoom.equals(owner, name)) { + state = 28; + mv.visitFieldInsn(opcode, owner, name, desc); + return; + } + break; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitVarInsn(int opcode, int var) { + switch (state) { + case 29: + if (opcode == ALOAD) { + ++state; + mv.visitVarInsn(opcode, var); + return; + } + break; + } + mv.visitVarInsn(opcode, var); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" %d M %d %s.%s%s", state, opcode, ownerM, nameM, descM); + switch (state) { + case 0: + if (Names.equals("org/lwjgl/opengl/GL11", "glViewport", "(IIII)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "setViewport", "(IIII)V"); + return; + } + break; + case 1: + if (Names.equals("org/lwjgl/opengl/GL11", "glClear", "(I)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "clearRenderBuffer", "()V"); + return; + } + break; + case 2: + if (Names.entityRenderer_setupCameraTransform.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(FLOAD, 1); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "setCamera", "(F)V"); + return; + } + break; + case 3: + if (Names.equals("Config", "isSkyEnabled", "()Z", owner, name, desc)) { + state = 6; + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "isShadowPass", "Z"); + labelNoSky = new Label(); + mv.visitJumpInsn(IFNE, labelNoSky); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 5: + if (Names.renderGlobal_renderSky.equals(owner, name, desc)) { + state = 8; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginSky", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endSky", "()V"); + return; + } + break; + case 6: + if (Names.renderGlobal_renderSky.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginSky", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endSky", "()V"); + return; + } + break; + case 8: + if (Names.iCamera_setPosition.equals(owner, name, desc) + || Names.frustrum_setPosition.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "setFrustrumPosition", + "(" + Names.frustrum_.desc + "DDD)V"); + return; + } + break; + case 9: + if (Names.renderGlobal_clipRenderersByFrustum.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "clipRenderersByFrustrum", + "(" + Names.renderGlobal_.desc + Names.frustrum_.desc + "F)V"); + return; + } + break; + case 12: + if (Names.renderGlobal_sortAndRender.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginTerrain", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endTerrain", "()V"); + return; + } + break; + case 13: + if (Names.effectRenderer_renderLitParticles.equals(owner, name, desc)) { + // vanilla or forge. not optfine + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginLitParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } else if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + // optifine + state = 16; + break; + } + break; + case 14: // vanilla or forge. not optfine + if (Names.effectRenderer_renderParticles.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endParticles", "()V"); + return; + } + break; + case 15: // vanilla or forge. not optfine + if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + ++state; + break; + } + break; + case 16: + if (Names.entityRenderer_renderRainSnow.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginWeather", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endWeather", "()V"); + return; + } + break; + case 17: + if (Names.equals("org/lwjgl/opengl/GL11", "glDepthMask", "(Z)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitVarInsn(ILOAD, 13); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "renderHand0", + "(" + Names.entityRenderer_.desc + "FI)V"); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "preWater", "()V"); + return; + } + case 18: + case 19: + case 20: + if (Names.renderGlobal_sortAndRender.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginWater", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endWater", "()V"); + return; + } else if (Names.equals( + Names.renderGlobal_.clas, "renderAllSortedRenderers", "(ID)I", owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginWater", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endWater", "()V"); + return; + } + break; + case 21: + if (Names.equals("org/lwjgl/opengl/GL11", "glDepthMask", "(Z)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 22: + if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 23: + if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableFog", "()V"); + return; + } + break; + case 24: + if (Names.effectRenderer_renderLitParticles.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginLitParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case 25: + if (Names.effectRenderer_renderParticles.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginParticles", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endParticles", "()V"); + return; + } + break; + case 30: + if (Names.entityRenderer_renderHand.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersRender", + "renderFPOverlay", + "(" + Names.entityRenderer_.desc + "FI)V"); + return; + } + break; + } + /* + case : + if (Namer.equals(SMCNames.,SMCNames.,SMCNames._desc,owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + case : + if (Namer.equals("","","",owner,name,desc)) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + return; + } + break; + */ + mv.visitMethodInsn(opcode, owner, name, desc); + } + + @Override + public void visitEnd() { + if (state != stateEnd) SMCLog.severe(" state %d expect %d", state, stateEnd); + mv.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTGuiOptions.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTGuiOptions.java new file mode 100644 index 000000000..f06282a75 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTGuiOptions.java @@ -0,0 +1,181 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTGuiOptions implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + this.classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.guiOptions_initGui.equalsNameDesc(name, desc)) { + // SMCLog.info(" patching"); + return new MVinitGui(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.guiOptions_actionPerformed.equalsNameDesc(name, desc)) { + // SMCLog.info(" patching"); + return new MVactionPerformed(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVinitGui extends MethodVisitor { + int state = 0; + + public MVinitGui(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + super.visitInsn(opcode); + if (opcode == Opcodes.POP) { + if (state == 1) { + state = 2; + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.guiOptions_buttonList.clas, + Names.guiOptions_buttonList.name, + Names.guiOptions_buttonList.desc); + mv.visitTypeInsn(NEW, Names.guiButton_.clas); + mv.visitInsn(DUP); + mv.visitIntInsn(SIPUSH, 190); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.guiOptions_width.clas, + Names.guiOptions_width.name, + Names.guiOptions_width.desc); + mv.visitInsn(ICONST_2); + mv.visitInsn(IDIV); + mv.visitIntInsn(SIPUSH, 155); + mv.visitInsn(ISUB); + mv.visitIntInsn(BIPUSH, 76); + mv.visitInsn(IADD); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.guiOptions_height.clas, + Names.guiOptions_height.name, + Names.guiOptions_height.desc); + mv.visitIntInsn(BIPUSH, 6); + mv.visitInsn(IDIV); + mv.visitIntInsn(BIPUSH, 120); + mv.visitInsn(IADD); + mv.visitIntInsn(BIPUSH, 6); + mv.visitInsn(ISUB); + mv.visitIntInsn(BIPUSH, 74); + mv.visitIntInsn(BIPUSH, 20); + mv.visitLdcInsn("Shaders..."); + mv.visitMethodInsn(INVOKESPECIAL, Names.guiButton_.clas, "", "(IIIIILjava/lang/String;)V"); + mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z"); + mv.visitInsn(POP); + SMCLog.finest(" add shaders button"); + } + } + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + if (((String) cst).equals("options.language")) { + if (state == 0) { + state = 1; + mv.visitInsn(POP); + mv.visitInsn(POP); + mv.visitIntInsn(BIPUSH, 74); + mv.visitIntInsn(BIPUSH, 20); + SMCLog.finest(" decrease language button size"); + } + } + } + super.visitLdcInsn(cst); + } + } + + private static class MVactionPerformed extends MethodVisitor { + public MVactionPerformed(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + super.visitCode(); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(GETFIELD, Names.guiButton_id.clas, Names.guiButton_id.name, Names.guiButton_id.desc); + mv.visitIntInsn(SIPUSH, 190); + Label l1 = new Label(); + mv.visitJumpInsn(IF_ICMPNE, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); + mv.visitFieldInsn( + GETFIELD, + Names.minecraft_gameSettings.clas, + Names.minecraft_gameSettings.name, + Names.minecraft_gameSettings.desc); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.gameSettings_saveOptions.clas, + Names.gameSettings_saveOptions.name, + Names.gameSettings_saveOptions.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, Names.guiOptions_mc.clas, Names.guiOptions_mc.name, Names.guiOptions_mc.desc); + mv.visitTypeInsn(NEW, "com/gtnewhorizons/angelica/client/GuiShaders"); + mv.visitInsn(DUP); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.guiOptions_options.clas, + Names.guiOptions_options.name, + Names.guiOptions_options.desc); + mv.visitMethodInsn( + INVOKESPECIAL, + "com/gtnewhorizons/angelica/client/GuiShaders", + "", + "(" + Names.guiScreen_.desc + Names.gameSettings_.desc + ")V"); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.minecraft_displayGuiScreen.clas, + Names.minecraft_displayGuiScreen.name, + Names.minecraft_displayGuiScreen.desc); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + SMCLog.finest(" shaders button action"); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemBlock.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemBlock.java new file mode 100644 index 000000000..9ea63deff --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemBlock.java @@ -0,0 +1,47 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTItemBlock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (Names.itemBlock_block.name.equals(name)) { + access = access & ~(ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemRenderer.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemRenderer.java new file mode 100644 index 000000000..418575719 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTItemRenderer.java @@ -0,0 +1,107 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.lwjgl.opengl.GL11; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTItemRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + Names.Meth renderItemIrt = new Names.Meth( + Names.itemRenderer_, + "renderItem", + "(" + Names.entityLivingBase_.desc + Names.itemStack_.desc + + "ILnet/minecraftforge/client/IItemRenderer$ItemRenderType;)V"); + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s",classname,name,desc); + if (Names.itemRenderer_updateEquipped.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.itemRenderer_renderItem.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (renderItemIrt.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderItem(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVupdate extends MethodVisitor { + public MVupdate(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + if (opcode == PUTFIELD && Names.itemRenderer_itemToRender.equals(owner, name, desc)) { + mv.visitInsn(DUP); + mv.visitFieldInsn( + PUTSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "itemToRender", Names.itemStack_.desc); + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + } + + private static class MVrenderItem extends MethodVisitor { + public MVrenderItem(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitInsn(int opcode) { + if (state == 1) { + if (opcode == ICONST_0) { + ++state; + opcode = ICONST_1; + } + } + mv.visitInsn(opcode); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (state == 0) { + if (opcode == SIPUSH && operand == GL11.GL_BLEND) { + ++state; + } + } + mv.visitIntInsn(opcode, operand); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTMinecraft.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTMinecraft.java new file mode 100644 index 000000000..6d8058a52 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTMinecraft.java @@ -0,0 +1,88 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTMinecraft implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + this.classname = name; + // SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.minecraft_startGame.equalsNameDesc(name, desc)) { + // SMCLog.info(" patching"); + return new MVstartGame(super.visitMethod(access, name, desc, signature, exceptions)); + } + return super.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVstartGame extends MethodVisitor { + int state = 0; + + public MVstartGame(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + if (((String) cst).equals("Startup")) { + if (state == 0) { + state = 1; + } + } + } + super.visitLdcInsn(cst); + } + + @Override + public void visitVarInsn(int opcode, int var) { + if (opcode == Opcodes.ALOAD) { + if (var == 0) { + if (state == 1) { + state = 2; + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "startup", + "(" + Names.minecraft_.desc + ")V"); + // SMCLog.finest(" startup"); + } + } + } + super.visitVarInsn(opcode, var); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTModelRenderer.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTModelRenderer.java new file mode 100644 index 000000000..75bf6b3de --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTModelRenderer.java @@ -0,0 +1,149 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTModelRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + // @Override + // public FieldVisitor visitField(int access, String name, String desc, + // String signature, Object value) { + // if (Names.modelRenderer_compiled.name.equals(name) || + // Names.modelRenderer_displayList.name.equals(name)) { + // access = access & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED) | ACC_PUBLIC; + // } + // return cv.visitField(access, name, desc, signature, value); + // } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + // if (Names.modelRenderer_render.equalsNameDesc(name, desc)) + // { + // //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + // return new MVrender( + // cv.visitMethod(access, name, desc, signature, exceptions)); + // } + // else + // if (Names.modelRenderer_renderWithRotation.equalsNameDesc(name, desc)) + // { + // //SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + // return new MVrender( + // cv.visitMethod(access, name, desc, signature, exceptions)); + // } + // else + if ("resetDisplayList".equals(name) && "()V".equals(desc) + || "getCompiled".equals(name) && "()Z".equals(desc) + || "getDisplayList".equals(name) && "()I".equals(desc)) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + { + mv = cv.visitMethod(ACC_PUBLIC, "getCompiled", "()Z", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.modelRenderer_compiled.clas, + Names.modelRenderer_compiled.name, + Names.modelRenderer_compiled.desc); + mv.visitInsn(IRETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cv.visitMethod(ACC_PUBLIC, "getDisplayList", "()I", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.modelRenderer_displayList.clas, + Names.modelRenderer_displayList.name, + Names.modelRenderer_displayList.desc); + mv.visitInsn(IRETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + { + mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.modelRenderer_compiled.clas, + Names.modelRenderer_compiled.name, + Names.modelRenderer_compiled.desc); + Label l1 = new Label(); + mv.visitJumpInsn(IFEQ, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.modelRenderer_displayList.clas, + Names.modelRenderer_displayList.name, + Names.modelRenderer_displayList.desc); + mv.visitMethodInsn( + INVOKESTATIC, + Names.glAllocation_deleteDisplayLists.clas, + Names.glAllocation_deleteDisplayLists.name, + Names.glAllocation_deleteDisplayLists.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn( + PUTFIELD, + Names.modelRenderer_displayList.clas, + Names.modelRenderer_displayList.name, + Names.modelRenderer_displayList.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn( + PUTFIELD, + Names.modelRenderer_compiled.clas, + Names.modelRenderer_compiled.name, + Names.modelRenderer_compiled.desc); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + } + super.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTOpenGlHelper.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTOpenGlHelper.java new file mode 100644 index 000000000..746b44f2d --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTOpenGlHelper.java @@ -0,0 +1,81 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTOpenGlHelper implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + // boolean has_activeTexUnit = false; + + // @Override + // public FieldVisitor visitField(int access, String name, String desc, + // String signature, Object value) { + // //if (name.equals("activeTexUnit")) { + // // has_activeTexUnit = true; + // //} + // return cv.visitField(access, name, desc, signature, value); + // } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // if (!has_activeTexUnit) { + // has_activeTexUnit = true; + // FieldVisitor fv = cv.visitField(ACC_PUBLIC + ACC_STATIC, "activeTexUnit", "I", null, null); + // fv.visitEnd(); + // SMCLog.finest(" add field activeTexUnit"); + // } + + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.openGlHelper_setActiveTexture.equalsNameDesc(name, desc)) { + // SMCLog.info(" patching"); + return new MVsetActiveTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVsetActiveTexture extends MethodVisitor { + public MVsetActiveTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ILOAD, 0); + mv.visitFieldInsn(PUTSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "activeTexUnit", "I"); + SMCLog.finest(" set activeTexUnit"); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTPrjRedIlluRenderHalo.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTPrjRedIlluRenderHalo.java new file mode 100644 index 000000000..c66d80274 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTPrjRedIlluRenderHalo.java @@ -0,0 +1,90 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.INVOKESTATIC; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTPrjRedIlluRenderHalo implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + this.classname = name; + // SMCLog.info(" class %s",name); + super.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" %s%s",name,desc); + if ("prepareRenderState".equals(name) && "()V".equals(desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVprepare(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if ("restoreRenderState".equals(name) && "()V".equals(desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrestore(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVprepare extends MethodVisitor { + public MVprepare(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.equals("codechicken/lib/render/CCRenderState", "reset", "()V", owner, name, desc)) { + SMCLog.info(" beginHalo"); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginProjectRedHalo", "()V"); + } + super.visitMethodInsn(opcode, owner, name, desc); + } + + @Override + public void visitInsn(int opcode) { + super.visitInsn(opcode); + } + } + + private static class MVrestore extends MethodVisitor { + public MVrestore(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + super.visitMethodInsn(opcode, owner, name, desc); + if (Names.equals("org/lwjgl/opengl/GL11", "glDisable", "(I)V", owner, name, desc)) { + SMCLog.info(" endHalo"); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endProjectRedHalo", "()V"); + } + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRender.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRender.java new file mode 100644 index 000000000..231c2a5be --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRender.java @@ -0,0 +1,69 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTRender implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.render_renderShadow.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVrenderShadow(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVrenderShadow extends MethodVisitor { + // protected MethodVisitor mv; + public MVrenderShadow(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "shouldSkipDefaultShadow", "Z"); + Label l1 = new Label(); + mv.visitJumpInsn(IFEQ, l1); + mv.visitInsn(RETURN); + mv.visitLabel(l1); + SMCLog.finer(" conditionally skip default shadow"); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderBlocks.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderBlocks.java new file mode 100644 index 000000000..50da31862 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderBlocks.java @@ -0,0 +1,378 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.InsnList; +import org.objectweb.asm.tree.MethodNode; + +public class SMCCTRenderBlocks implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderBlocks_renderBlockByRenderType.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkByRenType(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderBlocks_renderBlockFlowerPot.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkFlowerPot(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderBlocks_renderStdBlockWithAOP.equalsNameDesc(name, desc) + || Names.renderBlocks_renderStdBlockWithAO.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkWithAO( + access, + name, + desc, + signature, + exceptions, + cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderBlocks_renderStdBlockWithCM.equalsNameDesc(name, desc) + || Names.renderBlocks_renderBlockCactusImpl.equalsNameDesc(name, desc) + || Names.renderBlocks_renderBlockBed.equalsNameDesc(name, desc) + || Names.renderBlocks_renderBlockFluids.equalsNameDesc(name, desc) + || Names.renderBlocks_renderBlockDoor.equalsNameDesc(name, desc) + || Names.renderBlocks_renderBlockSandFalling.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkFVar(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderBlocks_renderPistonExtension.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,remappedName); + return new MVrenBlkPistonExt(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVrenBlkByRenType extends MethodVisitor { + public MVrenBlkByRenType(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int nPatch = 0; + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "pushEntity", + "(" + Names.renderBlocks_.desc + Names.block_.desc + "III)V"); + // SMCLog.info(" pushEntity"); + ++nPatch; + } + + @Override + public void visitInsn(int opcode) { + if (opcode == Opcodes.IRETURN) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "popEntity", "()V"); + // SMCLog.info(" popEntity"); + ++nPatch; + } + mv.visitInsn(opcode); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + // SMCLog.info(" %d", nPatch); + } + } + + private static class MVrenBlkFlowerPot extends MethodVisitor { + public MVrenBlkFlowerPot(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int nPatch = 0; + int state = 0; + + @Override + public void visitVarInsn(int opcode, int var) { + super.visitVarInsn(opcode, var); + if (state == 1) { + ++state; + mv.visitVarInsn(ALOAD, var); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "pushEntity", + "(" + Names.block_.desc + ")V"); + } + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + super.visitMethodInsn(opcode, owner, name, desc); + switch (state) { + case 0: + if (Names.block_getBlockFromItem.equals(owner, name, desc)) { + ++state; + } + break; + case 2: + if (Names.tessellator_addTranslation.equals(owner, name, desc)) { + ++state; + } + break; + case 3: + if (Names.tessellator_addTranslation.equals(owner, name, desc)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "popEntity", "()V"); + } + break; + } + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "pushEntity", + "(" + Names.renderBlocks_.desc + Names.block_.desc + "III)V"); + // SMCLog.info(" pushEntity"); + ++nPatch; + } + + @Override + public void visitInsn(int opcode) { + if (opcode == Opcodes.IRETURN) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "popEntity", "()V"); + // SMCLog.info(" popEntity"); + ++nPatch; + } + mv.visitInsn(opcode); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + // SMCLog.info(" %d", nPatch); + } + } + + static final String[] fieldsBlockLightLevel = {null, "blockLightLevel05", "blockLightLevel06", "blockLightLevel08"}; + + private static class MVrenBlkWithAO extends MethodVisitor { + MethodVisitor mv1; + MethodNode mn; + int nPatch = 0; + + public MVrenBlkWithAO( + final int access, + final String name, + final String desc, + final String signature, + final String[] exceptions, + MethodVisitor mv) { + super(Opcodes.ASM4); + super.mv = this.mn = new MethodNode(access, name, desc, signature, exceptions); + this.mv1 = mv; + } + + @Override + public void visitEnd() { + mn.visitEnd(); + mn.accept(mv1); + // SMCLog.info(" %d", nPatch); + } + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float) cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0) { + int match2 = 0; + InsnList insns = mn.instructions; + AbstractInsnNode insn = insns.getLast(); + if (insn != null && insn.getOpcode() == Opcodes.FLOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + match2 = match1; + } + } + } + } + } + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + insn = insn.getPrevious(); + if (insn != null && insn.getOpcode() == Opcodes.ALOAD) { + match2 = match1; + } + } + } + } + if (match2 != 0) { + String fieldName = fieldsBlockLightLevel[match2]; + mn.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", fieldName, "F"); + // SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + } + mn.visitLdcInsn(cst); + } + } + + private static class MVrenBlkFVar extends MethodVisitor { + int nPatch = 0; + + public MVrenBlkFVar(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float) cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0 && state < 3) { + ++state; + String fieldName = fieldsBlockLightLevel[match1]; + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", fieldName, "F"); + // SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + // SMCLog.info(" %d", nPatch); + } + } + + private static class MVrenBlkPistonExt extends MethodVisitor { + int nPatch = 0; + + public MVrenBlkPistonExt(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) { + state = 1; + mv.visitTableSwitchInsn(min, max, dflt, labels); + } + + @Override + public void visitLdcInsn(Object cst) { + int match1 = 0; + if (cst instanceof Float) { + float fcst = ((Float) cst).floatValue(); + if (fcst == 0.5f) match1 = 1; + else if (fcst == 0.6f) match1 = 2; + else if (fcst == 0.8f) match1 = 3; + } + if (match1 != 0 && state == 1) { + String fieldName = fieldsBlockLightLevel[match1]; + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", fieldName, "F"); + // SMCLog.info(" %s", fieldName); + ++nPatch; + return; + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitEnd() { + mv.visitEnd(); + // SMCLog.info(" %d", nPatch); + } + } + + // private static class MVNTransform extends MethodVisitor + // { + // protected MethodVisitor mv; + // protected MethodNode mn; + // public MVNTransform(MethodNode mn, MethodVisitor mv) { + // super(Opcodes.ASM4); + // super.mv = this.mn = mn; + // this.mv = mv; + // } + // + // @Override + // public void visitEnd() { + // super.visitEnd(); + // Iterator it = mn.instructions.iterator(); + // while (it.hasNext()) + // { + // AbstractInsnNode node = it.next(); + // System.out.println(node.toString()); + // } + // // send to target + // mn.accept(mv); + // } + // } + +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderGlobal.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderGlobal.java new file mode 100644 index 000000000..fccf295cf --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderGlobal.java @@ -0,0 +1,348 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.lwjgl.opengl.GL11; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTRenderGlobal implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (Names.renderGlobal_worldRenderers.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // String remappedName = SMCRemap.remapper.mapMethodName(classname, name, desc); + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderGlobal_renderEntities.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderEntities(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderGlobal_sortAndRender.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderGlobal_renderSky.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVrenderSky(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderGlobal_drawBlockDamageTexture.equalsNameDesc(name, desc) + || name.equals("drawBlockDamageTexture")) // Optifine + { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVdrawBlockDamageTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.renderGlobal_drawSelectionBox.equalsNameDesc(name, desc)) { + SMCLog.finer(" patch method %s.%s%s", classname, name, desc); + return new MVendisTexFog(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVrenderEntities extends MethodVisitor { + public MVrenderEntities(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int state = 0; + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { + String scst = (String) cst; + if (scst.equals("entities")) { + state = 1; + } else if (scst.equals("blockentities")) { + state = 4; + } + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + if (state == 2) { + if (Names.renderManager_instance.equals(owner, name, desc)) { + state = 3; + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "nextEntity", "()V"); + } + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (state == 1) { + state = 2; + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginEntities", "()V"); + SMCLog.finest(" %s", "beginEntities"); + } else if (state == 4) { + state = 5; + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endEntities", "()V"); + SMCLog.finest(" %s", "endEntities"); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginBlockEntities", "()V"); + SMCLog.finest(" %s", "beginTileEntities"); + } else if (state == 5) { + if (Names.entityRenderer_disableLightmap.equals(owner, name, desc)) { + state = 6; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endBlockEntities", "()V"); + SMCLog.finest(" %s", "endTileEntities"); + } + } + } + } + + /* detect glEnable or glDisable (TEXTURE_2D or FOG) */ + private static class MVendisTexFog extends MethodVisitor { + public MVendisTexFog(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int lastInt = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH && (operand == 3553 || operand == 2912)) { + lastInt = operand; + } else { + lastInt = 0; + } + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (owner.equals("org/lwjgl/opengl/GL11")) { + if (name.equals("glEnable")) { + if (lastInt == GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableTexture2D", "()V"); + SMCLog.finest(" %s", "enableTexture2D"); + } else if (lastInt == GL11.GL_FOG) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableFog", "()V"); + SMCLog.finest(" %s", "enableFog"); + } + } else if (name.equals("glDisable")) { + if (lastInt == GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableTexture2D", "()V"); + SMCLog.finest(" %s", "disableTexture2D"); + } else if (lastInt == GL11.GL_FOG) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableFog", "()V"); + SMCLog.finest(" %s", "disableFog"); + } + } + } + lastInt = 0; + } + } + + /* extends MVenableTF */ + private static class MVrenderSky extends MVendisTexFog { + public MVrenderSky(MethodVisitor mv) { + super(mv); + } + + int state = 0; + boolean detectedOptifine = false; + + int lastInt = 0; + int lastVar = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH) { + lastInt = operand; + } else { + lastInt = 0; + } + } + + @Override + public void visitVarInsn(int opcode, int var) { + mv.visitVarInsn(opcode, var); + if (opcode == ALOAD) { + lastVar = var; + } else { + lastVar = 0; + } + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + switch (state) { + case 0: + if (Names.vec3_xCoord.equals(owner, name)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "setSkyColor", + "(" + Names.vec3_.desc + ")V"); + mv.visitVarInsn(ALOAD, lastVar); + break; + } + break; + case 1: + if (Names.renderGlobal_glSkyList.equals(owner, name)) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "preSkyList", "()V"); + break; + } + break; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + // SMCLog.info(" %s.%s%s",ownerM,nameM,descM); + switch (state) { + case 0: + if (owner.equals("Config") && name.equals("isSkyEnabled")) { + detectedOptifine = true; + } + break; + case 2: + if (Names.worldClient_getRainStrength.equals(owner, name, desc)) { + ++state; + } + break; + } + // + mv.visitMethodInsn(opcode, owner, name, desc); + // + if (owner.equals("org/lwjgl/opengl/GL11")) { + if (name.equals("glEnable")) { + if (lastInt == GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableTexture2D", "()V"); + SMCLog.finest(" %s", "enableTexture2D"); + } else if (lastInt == GL11.GL_FOG) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableFog", "()V"); + SMCLog.finest(" %s", "enableFog"); + } + } else if (name.equals("glDisable")) { + if (lastInt == GL11.GL_TEXTURE_2D) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableTexture2D", "()V"); + SMCLog.finest(" %s", "disableTexture2D"); + } else if (lastInt == GL11.GL_FOG) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableFog", "()V"); + SMCLog.finest(" %s", "disableFog"); + } + } else if (name.equals("glRotatef")) { + SMCLog.finest(" *%s %d", "glRotatef", state); + if (state == 3) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "preCelestialRotate", "()V"); + SMCLog.finest(" %s", "preCelestialRotate"); + } else if (state == 4) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "postCelestialRotate", + "()V"); + SMCLog.finest(" %s", "postCelestialRotate"); + } + } + } + } + } + + private static class MVdrawBlockDamageTexture extends MethodVisitor { + int state = 0; + + public MVdrawBlockDamageTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + switch (state) { + case 0: + if (opcode == SIPUSH && operand == GL11.GL_ALPHA_TEST) { + ++state; + } + break; + case 2: + if (opcode == SIPUSH && operand == GL11.GL_ALPHA_TEST) { + ++state; + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "endBlockDestroyProgress", + "()V"); + SMCLog.finest(" %s", "endBlockDestroyProgress"); + } + break; + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + switch (state) { + case 1: + if (owner.equals("org/lwjgl/opengl/GL11") && name.equals("glEnable")) { + ++state; + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/Shaders", + "beginBlockDestroyProgress", + "()V"); + SMCLog.finest(" %s", "beginBlockDestroyProgress"); + return; + } + break; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderManager.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderManager.java new file mode 100644 index 000000000..46434a419 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderManager.java @@ -0,0 +1,49 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Opcodes; + +/** transformer for net.minecraft.client.renderer.Tessellator */ +public class SMCCTRenderManager implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (Names.renderManager_entityRenderMap.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderSpider.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderSpider.java new file mode 100644 index 000000000..68bed3cc7 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRenderSpider.java @@ -0,0 +1,71 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTRenderSpider implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.renderDragon_shouldRenderPass.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.renderEnderman_shouldRenderPass.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + if (Names.renderSpider_shouldRenderPass.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVshouldRenderPass(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVshouldRenderPass extends MethodVisitor { + public MVshouldRenderPass(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + mv.visitMethodInsn(opcode, owner, name, desc); + if (Names.equals("org/lwjgl/opengl/GL11", "glColor4f", "(FFFF)V", owner, name, desc)) { + mv.visitMethodInsn(INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginSpiderEyes", "()V"); + } + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRendererLivingEntity.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRendererLivingEntity.java new file mode 100644 index 000000000..34f8086ed --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTRendererLivingEntity.java @@ -0,0 +1,273 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.lwjgl.opengl.GL12; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTRendererLivingEntity implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (Names.rendererLivingE_mainModel.name.equals(name) + || Names.rendererLivingE_renderPassModel.name.equals(name)) { + access = access & ~(ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.rendererLivingE_doRender.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVdoRenderLiving(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.rendererLivingE_renderLabel.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVrenderLivingLabel(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVdoRenderLiving extends MethodVisitor { + public MVdoRenderLiving(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + // SMCLog.info(" insert code"); + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "useEntityHurtFlash", "Z"); + Label label1 = new Label(); + mv.visitJumpInsn(IFEQ, label1); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn( + GETFIELD, + Names.entityLivingBase_hurtTime.clas, + Names.entityLivingBase_hurtTime.name, + Names.entityLivingBase_hurtTime.desc); + Label label2 = new Label(); + mv.visitJumpInsn(IFGT, label2); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn( + GETFIELD, + Names.entityLivingBase_deathTime.clas, + Names.entityLivingBase_deathTime.name, + Names.entityLivingBase_deathTime.desc); + Label label3 = new Label(); + mv.visitJumpInsn(IFLE, label3); + mv.visitLabel(label2); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitIntInsn(BIPUSH, 102); + Label label4 = new Label(); + mv.visitJumpInsn(GOTO, label4); + mv.visitLabel(label3); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitInsn(ICONST_0); + mv.visitLabel(label4); + mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.INTEGER}); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(FLOAD, 9); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.entity_getBrightness.clas, + Names.entity_getBrightness.name, + Names.entity_getBrightness.desc); + mv.visitVarInsn(FLOAD, 9); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.rendererLivingE_getColorMultiplier.clas, + Names.rendererLivingE_getColorMultiplier.name, + Names.rendererLivingE_getColorMultiplier.desc); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "setEntityHurtFlash", "(II)V"); + mv.visitLabel(label1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + // SMCLog.info(" end insert"); + } + + /** last SIPUSH operand */ + private int lastInt = 0; + /** state */ + private int state = 0; + + private static final int stateEnd = 7; + /** end of vanilla hurt rendering */ + Label labelEndVH = null; + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == SIPUSH) { + lastInt = operand; + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof Integer) { + int icst = ((Integer) cst).intValue(); + if (icst == GL12.GL_RESCALE_NORMAL) { + // SMCLog.info(" rescale_normal"); + if (labelEndVH != null) { + // SMCLog.info(" jump target"); + mv.visitLabel(labelEndVH); + labelEndVH = null; + } + } + } + mv.visitLdcInsn(cst); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + // SMCLog.info(" %s.%s%s",ownerM,nameM,descM); + if (opcode == INVOKEVIRTUAL) { + if (Names.rendererLivingE_renderEquippedItems.equals(owner, name, desc)) { + // SMCLog.info(" renderEquippedItems"); + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "resetEntityHurtFlash", "()V"); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitFieldInsn( + GETSTATIC, "com/gtnewhorizons/angelica/client/Shaders", "useEntityHurtFlash", "Z"); + labelEndVH = new Label(); + mv.visitJumpInsn(IFNE, labelEndVH); + state = 1; + return; + } + } + // + mv.visitMethodInsn(opcode, owner, name, desc); + // + if (opcode == INVOKESTATIC) { + if (Names.equals("org/lwjgl/opengl/GL11", "glDepthFunc", "(I)V", owner, name, desc)) { + // SMCLog.info(" glDepthFunc"); + if (state == 3) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "beginLivingDamage", "()V"); + ++state; + } else if (state == 4) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "endLivingDamage", "()V"); + ++state; + } + } else if (Names.openGlHelper_setActiveTexture.equals(owner, name, desc)) { + // SMCLog.info(" setActiveTexture"); + if (state == 1) { + ++state; + } else if (state == 2) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "disableLightmap", "()V"); + ++state; + } else if (state == 5) { + ++state; + } else if (state == 6) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/Shaders", "enableLightmap", "()V"); + ++state; + } + } + } + } + + @Override + public void visitEnd() { + mv.visitEnd(); + if (state != stateEnd) { + SMCLog.severe("state %d expected %d", state, stateEnd); + } + } + } + + private static class MVrenderLivingLabel extends MethodVisitor { + public MVrenderLivingLabel(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + int pushedInt = 0; + + @Override + public void visitIntInsn(int opcode, int operand) { + mv.visitIntInsn(opcode, operand); + if (opcode == SIPUSH && operand == 3553) pushedInt = 3553; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (pushedInt == 3553) { + pushedInt = 0; + if (opcode == INVOKESTATIC && owner.equals("org/lwjgl/opengl/GL11") && desc.equals("(I)V")) { + if (name.equals("glDisable")) { + owner = "com/gtnewhorizons/angelica/client/Shaders"; + name = "sglDisableT2D"; + } else if (name.equals("glEnable")) { + owner = "com/gtnewhorizons/angelica/client/Shaders"; + name = "sglEnableT2D"; + } + } + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + // private static class MVNTransform extends MethodVisitor + // { + // protected MethodVisitor mv; + // protected MethodNode mn; + // public MVNTransform(MethodNode mn, MethodVisitor mv) { + // super(Opcodes.ASM4); + // super.mv = this.mn = mn; + // this.mv = mv; + // } + // + // @Override + // public void visitEnd() { + // super.visitEnd(); + // Iterator it = mn.instructions.iterator(); + // while (it.hasNext()) + // { + // AbstractInsnNode node = it.next(); + // System.out.println(node.toString()); + // } + // // send to target + // mn.accept(mv); + // } + // } + +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTSmartMoveModelRotationRenderer.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTSmartMoveModelRotationRenderer.java new file mode 100644 index 000000000..2a6957196 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTSmartMoveModelRotationRenderer.java @@ -0,0 +1,73 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTSmartMoveModelRotationRenderer implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if ("resetDisplayList".equals(name) && "()V".equals(desc)) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + { + mv = cv.visitMethod(ACC_PUBLIC, "resetDisplayList", "()V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, Names.modelRenderer_.clas, "resetDisplayList", "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + // mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "compiled", "Z"); + mv.visitFieldInsn( + PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_compiled.name, "Z"); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + // mv.visitFieldInsn(PUTFIELD, "net/smart/render/ModelRotationRenderer", "displayList", "I"); + mv.visitFieldInsn( + PUTFIELD, "net/smart/render/ModelRotationRenderer", Names.modelRenderer_displayList.name, "I"); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 1); + mv.visitEnd(); + } + super.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTessellator.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTessellator.java new file mode 100644 index 000000000..b372ed521 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTessellator.java @@ -0,0 +1,476 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +/** transformer for net.minecraft.client.renderer.Tessellator */ +public class SMCCTTessellator implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static boolean inputHasStaticBuffer = false; + + private static class CVTransform extends ClassVisitor { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + // SMCLog.fine("%x %s %s %s",access,desc,name,nameM); + if (name.equals("vertexPos") + || name.equals("normalX") + || name.equals("normalY") + || name.equals("normalZ") + || name.equals("midTextureU") + || name.equals("midTextureV")) { + return null; + } else if (((access & ACC_STATIC) != 0) + && (Names.tessellator_byteBuffer.name.equals(name) + || Names.tessellator_intBuffer.name.equals(name) + || Names.tessellator_floatBuffer.name.equals(name) + || Names.tessellator_shortBuffer.name.equals(name) + || Names.tessellator_vertexCount.name.equals(name) + // nameM.equals(Names.Tessellator_useVBO) || + // nameM.equals(Names.Tessellator_vertexBuffers) + )) { + inputHasStaticBuffer = true; + // SMCLog.finest(" input has static buffer"); + access = access & (~ACC_STATIC & ~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } else { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if (!endFields) { + endFields = true; + FieldVisitor fv; + fv = cv.visitField(ACC_PUBLIC, "vertexPos", "[F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalX", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalY", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "normalZ", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "midTextureU", "F", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "midTextureV", "F", null, null); + fv.visitEnd(); + } + // SMCLog.fine(" method %s.%s%s = %s",classname,name,desc,nameM); + if (name.equals("")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVclinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("") && desc.equals("()V")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("") && desc.equals("(I)V")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinitI(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.tessellator_draw.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVdraw(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.tessellator_reset.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + access = access & ~(ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + return new MVreset(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.tessellator_addVertex.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVaddVertex(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.tessellator_setNormal.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVsetNormal(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.tessellator_sortQuad.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVsortQuad(cv.visitMethod(access, name, desc, signature, exceptions)); + } else { + access = access & ~(ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + /*private static class MVclinit extends MethodVisitor + { + public MVclinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + } + + private static class MVinit extends MethodVisitor + { + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + mv.visitVarInsn(ALOAD, 0); + mv.visitIntInsn(BIPUSH, 16); + mv.visitIntInsn(NEWARRAY, T_FLOAT); + mv.visitFieldInsn(PUTFIELD, SMCNames.Tessellator_, "vertexPos", "[F"); + } + mv.visitInsn(opcode); + } + }*/ + + private static class MVclinit extends MethodVisitor { + public MVclinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); + if (opcode == PUTSTATIC + && (Names.tessellator_byteBuffer.equals(owner, name) + || Names.tessellator_intBuffer.equals(owner, name) + || Names.tessellator_floatBuffer.equals(owner, name) + || Names.tessellator_shortBuffer.equals(owner, name) + || Names.tessellator_vertexCount.equals(owner, name) + // nameM.equals(Names.Tessellator_useVBO)|| + // nameM.equals(Names.Tessellator_vertexBuffers) + )) { + mv.visitInsn(POP); + return; + } else if (opcode == GETSTATIC + && (Names.tessellator_byteBuffer.equals(owner, name) + // nameM.equals(Names.Tessellator_vertexBuffers) + )) { + mv.visitInsn(ACONST_NULL); + return; + // } else + // if (opcode==GETSTATIC && ( + // nameM.equals(Names.Tessellator_useVBO) + // )) + // { + // mv.visitInsn(ICONST_0); + // return; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" M %d %s.%s %s", opcode, ownerM, nameM, descM); + if (Names.glAllocation_createDirectByteBuffer.equals(owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.glAllocation_createDirectIntBuffer.equals(owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals( + "java/nio/ByteBuffer", "asIntBuffer", "()Ljava/nio/IntBuffer;", owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals( + "java/nio/ByteBuffer", "asFloatBuffer", "()Ljava/nio/FloatBuffer;", owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } else if (Names.equals( + "java/nio/ByteBuffer", "asShortBuffer", "()Ljava/nio/ShortBuffer;", owner, name, desc)) { + mv.visitInsn(POP); + mv.visitInsn(ACONST_NULL); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVinit extends MethodVisitor { + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (opcode == INVOKESPECIAL && Names.equals("java/lang/Object", "", "()V", owner, name, desc)) { + mv.visitLdcInsn(new Integer(65536)); + mv.visitMethodInsn(INVOKESPECIAL, Names.tessellator_.clas, "", "(I)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVinitI extends MethodVisitor { + public MVinitI(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + if (inputHasStaticBuffer) { + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitInsn(ICONST_4); + mv.visitInsn(IMUL); + mv.visitMethodInsn( + INVOKESTATIC, + Names.glAllocation_createDirectByteBuffer.clas, + Names.glAllocation_createDirectByteBuffer.name, + Names.glAllocation_createDirectByteBuffer.desc); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_byteBuffer.clas, + Names.tessellator_byteBuffer.name, + Names.tessellator_byteBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.tessellator_byteBuffer.clas, + Names.tessellator_byteBuffer.name, + Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/nio/ByteBuffer", "asIntBuffer", "()Ljava/nio/IntBuffer;"); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_intBuffer.clas, + Names.tessellator_intBuffer.name, + Names.tessellator_intBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.tessellator_byteBuffer.clas, + Names.tessellator_byteBuffer.name, + Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn( + INVOKEVIRTUAL, "java/nio/ByteBuffer", "asFloatBuffer", "()Ljava/nio/FloatBuffer;"); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_floatBuffer.clas, + Names.tessellator_floatBuffer.name, + Names.tessellator_floatBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.tessellator_byteBuffer.clas, + Names.tessellator_byteBuffer.name, + Names.tessellator_byteBuffer.desc); + mv.visitMethodInsn( + INVOKEVIRTUAL, "java/nio/ByteBuffer", "asShortBuffer", "()Ljava/nio/ShortBuffer;"); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_shortBuffer.clas, + Names.tessellator_shortBuffer.name, + Names.tessellator_shortBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitIntInsn(NEWARRAY, T_INT); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_rawBuffer.clas, + Names.tessellator_rawBuffer.name, + Names.tessellator_rawBuffer.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_0); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_vertexCount.clas, + Names.tessellator_vertexCount.name, + Names.tessellator_vertexCount.desc); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitFieldInsn(GETSTATIC, Names.Tessellator_, Names.Tessellator_tryVBO, "Z"); + // Label l28 = new Label(); + // mv.visitJumpInsn(IFEQ, l28); + // mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/GLContext", "getCapabilities", + // "()Lorg/lwjgl/opengl/ContextCapabilities;"); + // mv.visitFieldInsn(GETFIELD, "org/lwjgl/opengl/ContextCapabilities", + // "GL_ARB_vertex_buffer_object", "Z"); + // mv.visitJumpInsn(IFEQ, l28); + // mv.visitInsn(ICONST_1); + // Label l29 = new Label(); + // mv.visitJumpInsn(GOTO, l29); + // mv.visitLabel(l28); + // mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 1, new + // Object[] {Names.Tessellator_}); + // mv.visitInsn(ICONST_0); + // mv.visitLabel(l29); + // mv.visitFrame(Opcodes.F_FULL, 2, new Object[] {Names.Tessellator_, Opcodes.INTEGER}, 2, new + // Object[] {Names.Tessellator_, Opcodes.INTEGER}); + // mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_useVBO, "Z"); + // Label l31 = new Label(); + // mv.visitJumpInsn(IFEQ, l31); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vboCount, "I"); + // mv.visitMethodInsn(INVOKESTATIC, Names.GLAllocation_, Names.GLAllocation_createDirectIntBuffer, + // Names.GLAllocation_createDirectIntBuffer_desc); + // mv.visitFieldInsn(PUTFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, + // "Ljava/nio/IntBuffer;"); + // mv.visitVarInsn(ALOAD, 0); + // mv.visitFieldInsn(GETFIELD, Names.Tessellator_, Names.Tessellator_vertexBuffers, + // "Ljava/nio/IntBuffer;"); + // mv.visitMethodInsn(INVOKESTATIC, "org/lwjgl/opengl/ARBVertexBufferObject", "glGenBuffersARB", + // "(Ljava/nio/IntBuffer;)V"); + // mv.visitLabel(l31); + // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + } + mv.visitVarInsn(ALOAD, 0); + mv.visitIntInsn(BIPUSH, 16); + mv.visitIntInsn(NEWARRAY, T_FLOAT); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "vertexPos", "[F"); + } + mv.visitInsn(opcode); + } + } + + private static class MVdraw extends MethodVisitor { + public MVdraw(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(185, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTess", + "draw", + "(" + Names.tessellator_.desc + ")I"); + mv.visitInsn(IRETURN); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l1, 0); + mv.visitMaxs(1, 1); + mv.visitEnd(); + } + } + + private static class MVreset extends MethodVisitor { + public MVreset(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" F %d %s.%s %s", opcode, ownerM, nameM, descM); + if (opcode == GETSTATIC && Names.tessellator_byteBuffer.equals(owner, name)) { + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, owner, name, desc); + return; + } + mv.visitFieldInsn(opcode, owner, name, desc); + } + } + + private static class MVaddVertex extends MethodVisitor { + public MVaddVertex(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(466, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(DLOAD, 1); + mv.visitVarInsn(DLOAD, 3); + mv.visitVarInsn(DLOAD, 5); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTess", + "addVertex", + "(" + Names.tessellator_.desc + "DDD)V"); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(467, l1); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l2, 0); + mv.visitLocalVariable("par1", "D", null, l0, l2, 1); + mv.visitLocalVariable("par3", "D", null, l0, l2, 3); + mv.visitLocalVariable("par5", "D", null, l0, l2, 5); + mv.visitMaxs(7, 7); + mv.visitEnd(); + } + } + + private static class MVsetNormal extends MethodVisitor { + public MVsetNormal(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ICONST_1); + mv.visitFieldInsn( + PUTFIELD, + Names.tessellator_hasNormals.clas, + Names.tessellator_hasNormals.name, + Names.tessellator_hasNormals.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 1); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalX", "F"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 2); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalY", "F"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(FLOAD, 3); + mv.visitFieldInsn(PUTFIELD, Names.tessellator_.clas, "normalZ", "F"); + mv.visitInsn(RETURN); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitLocalVariable("this", Names.tessellator_.desc, null, l0, l5, 0); + mv.visitLocalVariable("par1", "F", null, l0, l5, 1); + mv.visitLocalVariable("par2", "F", null, l0, l5, 2); + mv.visitLocalVariable("par3", "F", null, l0, l5, 3); + mv.visitMaxs(2, 4); + mv.visitEnd(); + } + } + + private static class MVsortQuad extends MethodVisitor { + public MVsortQuad(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == BIPUSH && operand == 32) { + operand = 64; + } + super.visitIntInsn(opcode, operand); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAbstract.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAbstract.java new file mode 100644 index 000000000..bf8d49f5d --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAbstract.java @@ -0,0 +1,110 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +/** transformer for net.minecraft.client.renderer.texture.AbstractTexture */ +public class SMCCTTextureAbstract implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (name.equals("multiTex")) { + return null; + } else { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if (!endFields) { + endFields = true; + FieldVisitor fv; + // multiTex + fv = cv.visitField( + ACC_PUBLIC, "multiTex", "Lcom/gtnewhorizons/angelica/client/MultiTexID;", null, null); + fv.visitEnd(); + } + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.abstractTexture_deleteGlTexture.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVdeleteGlTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("getMultiTexID") + && desc.equals("()Lcom/gtnewhorizons/angelica/client/MultiTexID;")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + // getMultiTexID + mv = cv.visitMethod( + ACC_PUBLIC, "getMultiTexID", "()Lcom/gtnewhorizons/angelica/client/MultiTexID;", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "getMultiTexID", + "(" + Names.abstractTexture_.desc + ")Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + mv.visitInsn(ARETURN); + mv.visitMaxs(1, 1); + mv.visitEnd(); + // end + cv.visitEnd(); + } + } + + private static class MVdeleteGlTexture extends MethodVisitor { + public MVdeleteGlTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "deleteTextures", + "(" + Names.abstractTexture_.desc + ")V"); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAtlasSprite.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAtlasSprite.java new file mode 100644 index 000000000..73c4d2245 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureAtlasSprite.java @@ -0,0 +1,178 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +/** transformer for net.minecraft.client.renderer.texture.TextureAtlasSprite */ +public class SMCCTTextureAtlasSprite implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + // String nameM = SMCRemap.remapper.mapFieldName(classname, name, desc); + access = access & ~(ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + return cv.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + access = access & ~(ACC_PRIVATE | ACC_PROTECTED) | ACC_PUBLIC; + if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("load") + && desc.equals("(" + Names.iResourceManager_.desc + Names.resourceLocation_.desc + ")Z")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVload(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.textureAtlasSpri_loadSprite.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadSprite(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (name.equals("uploadFrameTexture") && desc.equals("(III)V")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVuploadFrameTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + // also used by clock and compass + protected static class MVanimation extends MethodVisitor { + // protected MethodVisitor mv; + public MVanimation(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.textureUtil_uploadTexSub.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/ShadersTex", "uploadTexSub", "([[IIIIIZZ)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVload extends MethodVisitor { + // protected MethodVisitor mv; + public MVload(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.iResourceManager_getResource.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "loadResource", + "(" + Names.iResourceManager_.desc + Names.resourceLocation_.desc + ")" + + Names.iResource_.desc); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVloadSprite extends MethodVisitor { + // protected MethodVisitor mv; + public MVloadSprite(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.equals("java/awt/image/BufferedImage", "getRGB", "(IIII[III)[I", owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "loadAtlasSprite", + "(Ljava/awt/image/BufferedImage;IIII[III)[I"); + return; + } else if (Names.textureAtlasSpri_getFrameTextureData.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, "com/gtnewhorizons/angelica/client/ShadersTex", "extractFrame", "([IIII)[I"); + return; + } else if (Names.equals(Names.textureAtlasSpri_.clas, "fixTransparentColor", "([I)V", owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "fixTransparentColor", + "(" + Names.textureAtlasSpri_.desc + "[I)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVuploadFrameTexture extends MethodVisitor { + public MVuploadFrameTexture(MethodVisitor mv) { + super(Opcodes.ASM4, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ILOAD, 2); + mv.visitVarInsn(ILOAD, 3); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "uploadFrameTexture", + "(" + Names.textureAtlasSpri_.desc + "III)V"); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.textureAtlasSpri_.desc, null, l0, l2, 0); + mv.visitLocalVariable("frameIndex", "I", null, l0, l2, 1); + mv.visitLocalVariable("xPos", "I", null, l0, l2, 2); + mv.visitLocalVariable("yPos", "I", null, l0, l2, 3); + mv.visitMaxs(4, 4); + mv.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureClock.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureClock.java new file mode 100644 index 000000000..c4cf2f618 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureClock.java @@ -0,0 +1,50 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureClock implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureAtlasSpri_updateAnimation.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new SMCCTTextureAtlasSprite.MVanimation( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureCompass.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureCompass.java new file mode 100644 index 000000000..11cfbaeda --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureCompass.java @@ -0,0 +1,50 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureCompass implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureCompass_updateCompass.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new SMCCTTextureAtlasSprite.MVanimation( + cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDownload.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDownload.java new file mode 100644 index 000000000..cdcca0aa3 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDownload.java @@ -0,0 +1,99 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureDownload implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + // SMCLog.finest(" field %s %s %s %d", classname, name, desc, access); + return super.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // String nameM = SMCRemap.remapper.mapMethodName(classname, name, desc); + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("getMultiTexID")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + // getMultiTexID + mv = cv.visitMethod( + ACC_PUBLIC, "getMultiTexID", "()Lcom/gtnewhorizons/angelica/client/MultiTexID;", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.textureDownload_textureUploaded.clas, + Names.textureDownload_textureUploaded.name, + Names.textureDownload_textureUploaded.desc); + Label l1 = new Label(); + mv.visitJumpInsn(IFNE, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.textureDownload_.clas, + Names.iTextureObject_getGlTextureId.name, + Names.iTextureObject_getGlTextureId.desc); + mv.visitInsn(POP); + mv.visitLabel(l1); + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESPECIAL, + Names.abstractTexture_.clas, + "getMultiTexID", + "()Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + mv.visitInsn(ARETURN); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitLocalVariable("this", Names.textureDownload_.desc, null, l0, l3, 0); + mv.visitMaxs(1, 1); + mv.visitEnd(); + // end + cv.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDynamic.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDynamic.java new file mode 100644 index 000000000..916a99a1c --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureDynamic.java @@ -0,0 +1,105 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureDynamic implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("") && desc.equals("(II)V")) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVinit(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.dynamicTexture_updateDynamicTexture.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVupdate(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVinit extends MethodVisitor { + // protected MethodVisitor mv; + public MVinit(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.textureUtil_allocateTexture.equals(owner, name, desc)) { + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "initDynamicTexture", + "(III" + Names.dynamicTexture_.desc + ")V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVupdate extends MethodVisitor { + // protected MethodVisitor mv; + public MVupdate(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.textureUtil_uploadTexture.equals(owner, name, desc)) { + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "updateDynamicTexture", + "(I[III" + Names.dynamicTexture_.desc + ")V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureLayered.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureLayered.java new file mode 100644 index 000000000..7c2316895 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureLayered.java @@ -0,0 +1,82 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureLayered implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // String descM = SMCNames.remapper.mapMethodDesc(desc); + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVloadTexture extends MethodVisitor { + // protected MethodVisitor mv; + public MVloadTexture(MethodVisitor mv) { + super(Opcodes.ASM4); + // replace method body + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.layeredTexture_layeredTextureNames.clas, + Names.layeredTexture_layeredTextureNames.name, + Names.layeredTexture_layeredTextureNames.desc); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "loadLayeredTexture", + "(" + Names.layeredTexture_.desc + Names.iResourceManager_.desc + "Ljava/util/List;)V"); + mv.visitInsn(RETURN); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLocalVariable("this", Names.layeredTexture_.desc, null, l0, l2, 0); + mv.visitLocalVariable("manager", Names.iResourceManager_.desc, null, l0, l2, 1); + mv.visitMaxs(3, 2); + mv.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureManager.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureManager.java new file mode 100644 index 000000000..255784c4b --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureManager.java @@ -0,0 +1,92 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureManager implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + if (Names.textureManager_bindTexture.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVbindTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.textureManager_onResourceManagerReload.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVonReload(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVbindTexture extends MethodVisitor { + public MVbindTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.iTextureObject_getGlTextureId.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "bindTexture", + "(" + Names.iTextureObject_.desc + ")V"); + return; + } else if (Names.textureUtil_bindTexture.equals(owner, name, desc)) { + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVonReload extends MethodVisitor { + public MVonReload(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.iTextureObject_getGlTextureId.equals(owner, name, desc)) { + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "deleteMultiTex", + "(" + Names.iTextureObject_.desc + ")I"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureMap.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureMap.java new file mode 100644 index 000000000..b23c6132f --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureMap.java @@ -0,0 +1,196 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureMap implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + boolean endFields = false; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if (name.equals("atlasWidth")) { + return null; + } else if (name.equals("atlasHeight")) { + return null; + } else if (Names.textureMap_anisotropic.name.equals(name)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } + return super.visitField(access, name, desc, signature, value); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if (!endFields) { + endFields = true; + FieldVisitor fv; + fv = cv.visitField(ACC_PUBLIC, "atlasWidth", "I", null, null); + fv.visitEnd(); + fv = cv.visitField(ACC_PUBLIC, "atlasHeight", "I", null, null); + fv.visitEnd(); + } + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (Names.textureMap_getIconResLoc.equalsNameDesc(name, desc)) { + access = access & (~ACC_PRIVATE & ~ACC_PROTECTED) | ACC_PUBLIC; + } else if (Names.textureMap_loadTextureAtlas.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVloadAtlas(cv.visitMethod(access, name, desc, signature, exceptions)); + } else if (Names.textureMap_updateAnimations.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s",classname,name,desc,nameM); + return new MVanimation(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVloadAtlas extends MethodVisitor { + // protected MethodVisitor mv; + public MVloadAtlas(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + // this.mv = mv; + } + + @Override + public void visitIntInsn(int opcode, int operand) { + if (opcode == NEWARRAY && operand == T_INT) { + mv.visitInsn(ICONST_3); + mv.visitInsn(IMUL); + } + mv.visitIntInsn(opcode, operand); + } + + int varStitcher = 0; + boolean isStitcher = false; + int state = 0; + + @Override + public void visitVarInsn(int opcode, int var) { + if (opcode == ASTORE) { + if (isStitcher) { + isStitcher = false; + varStitcher = var; + } + } + mv.visitVarInsn(opcode, var); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + // SMCLog.finest(" %s.%s%s",ownerM,nameM,descM); + if (Names.iResourceManager_getResource.equals(owner, name, desc)) { + SMCLog.finest(" %s", "loadRes"); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "loadResource", + "(" + Names.iResourceManager_.desc + Names.resourceLocation_.desc + ")" + + Names.iResource_.desc); + return; + } else if (opcode == INVOKESPECIAL + && Names.equals(Names.stitcher_.clas, "", "(IIZII)V", owner, name, desc)) { + isStitcher = true; + } else if (Names.textureUtil_allocateTextureMipmapAniso.equals(owner, name, desc)) { + SMCLog.finest(" %s", "allocateTextureMap"); + mv.visitVarInsn(ALOAD, varStitcher); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "allocateTextureMap", + "(IIIIF" + Names.stitcher_.desc + Names.textureMap_.desc + ")V"); + state = 1; + return; + } else if (state == 1 && Names.textureAtlasSpri_getIconName.equals(owner, name, desc)) { + SMCLog.finest(" %s", "setSprite setIconName"); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "setSprite", + "(" + Names.textureAtlasSpri_.desc + ")" + Names.textureAtlasSpri_.desc); + mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "setIconName", + "(Ljava/lang/String;)Ljava/lang/String;"); + state = 0; + return; + } else if (Names.textureUtil_uploadTexSub.equals(owner, name, desc)) { + SMCLog.finest(" %s", "uploadTexSubForLoadAtlas"); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "uploadTexSubForLoadAtlas", + "([[IIIIIZZ)V"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + private static class MVanimation extends MethodVisitor { + public MVanimation(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitCode() { + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.textureMap_.clas, + "getMultiTexID", + "()Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + mv.visitFieldInsn( + PUTSTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "updatingTex", + "Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + } + + @Override + public void visitInsn(int opcode) { + if (opcode == RETURN) { + mv.visitInsn(ACONST_NULL); + mv.visitFieldInsn( + PUTSTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "updatingTex", + "Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + } + mv.visitInsn(opcode); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureObject.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureObject.java new file mode 100644 index 000000000..9a8df24b3 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureObject.java @@ -0,0 +1,63 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureObject implements IClassTransformer { + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, 0); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s",classname,name,desc,remappedName); + if (name.equals("getMultiTexID") && desc.equals("()Lcom/gtnewhorizons/angelica/client/MultiTexID;")) { + return null; + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + + @Override + public void visitEnd() { + MethodVisitor mv; + // getMultiTexID + mv = cv.visitMethod( + ACC_PUBLIC + ACC_ABSTRACT, + "getMultiTexID", + "()Lcom/gtnewhorizons/angelica/client/MultiTexID;", + null, + null); + mv.visitEnd(); + // end + cv.visitEnd(); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureSimple.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureSimple.java new file mode 100644 index 000000000..6cab56dad --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCCTTextureSimple.java @@ -0,0 +1,86 @@ +package com.gtnewhorizons.angelica.transform; + +import static org.objectweb.asm.Opcodes.*; + +import net.minecraft.launchwrapper.IClassTransformer; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +public class SMCCTTextureSimple implements IClassTransformer { + + private static final int logDetail = 0; + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + SMCLog.fine("transforming %s %s", par1, par2); + ClassReader cr = new ClassReader(par3); + ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS); + CVTransform cv = new CVTransform(cw); + cr.accept(cv, 0); + return cw.toByteArray(); + } + + private static class CVTransform extends ClassVisitor { + String classname; + + public CVTransform(ClassVisitor cv) { + super(Opcodes.ASM4, cv); + } + + @Override + public void visit( + int version, int access, String name, String signature, String superName, String[] interfaces) { + classname = name; + // SMCLog.info(" class %s",name); + cv.visit(version, access, name, signature, superName, interfaces); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + // SMCLog.info(" method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + if (Names.iTextureObject_loadTexture.equalsNameDesc(name, desc)) { + // SMCLog.finer(" patching method %s.%s%s = %s%s",classname,name,desc,nameM,descM); + return new MVloadTexture(cv.visitMethod(access, name, desc, signature, exceptions)); + } + return cv.visitMethod(access, name, desc, signature, exceptions); + } + } + + private static class MVloadTexture extends MethodVisitor { + public MVloadTexture(MethodVisitor mv) { + super(Opcodes.ASM4, mv); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (Names.textureUtil_uploadTextureImageAllocate.equals(owner, name, desc)) { + // mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitVarInsn(ALOAD, 1); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn( + GETFIELD, + Names.simpleTexture_textureLocation.clas, + Names.simpleTexture_textureLocation.name, + Names.simpleTexture_textureLocation.desc); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn( + INVOKEVIRTUAL, + Names.simpleTexture_.clas, + "getMultiTexID", + "()Lcom/gtnewhorizons/angelica/client/MultiTexID;"); + mv.visitMethodInsn( + INVOKESTATIC, + "com/gtnewhorizons/angelica/client/ShadersTex", + "loadSimpleTexture", + "(ILjava/awt/image/BufferedImage;ZZ" + Names.iResourceManager_.desc + + Names.resourceLocation_.desc + "Lcom/gtnewhorizons/angelica/client/MultiTexID;)I"); + SMCLog.finer(" loadSimpleTexture"); + return; + } + mv.visitMethodInsn(opcode, owner, name, desc); + } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCClassTransformer.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCClassTransformer.java new file mode 100644 index 000000000..9d6525357 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCClassTransformer.java @@ -0,0 +1,67 @@ +package com.gtnewhorizons.angelica.transform; + +import java.util.HashMap; +import java.util.Map; +import net.minecraft.launchwrapper.IClassTransformer; + +public class SMCClassTransformer implements IClassTransformer { + + Names names; + /** map of class transformer */ + protected Map ctMap; + + public void put(Names.Clas clas, IClassTransformer ct) { + ctMap.put(clas.clas.replace('/', '.'), ct); + } + + // constructor + public SMCClassTransformer() { + names = new Names(); + InitNames.init(); + ctMap = new HashMap(); + put(Names.block_, new SMCCTBlock()); + put(Names.itemBlock_, new SMCCTItemBlock()); + put(Names.minecraft_, new SMCCTMinecraft()); + put(Names.guiOptions_, new SMCCTGuiOptions()); + put(Names.modelRenderer_, new SMCCTModelRenderer()); + put(Names.openGlHelper_, new SMCCTOpenGlHelper()); + put(Names.tessellator_, new SMCCTTessellator()); + put(Names.renderBlocks_, new SMCCTRenderBlocks()); + put(Names.renderGlobal_, new SMCCTRenderGlobal()); + put(Names.entityRenderer_, new SMCCTEntityRenderer()); + put(Names.render_, new SMCCTRender()); + put(Names.renderManager_, new SMCCTRenderManager()); + put(Names.rendererLivingE_, new SMCCTRendererLivingEntity()); + put(Names.renderDragon_, new SMCCTRenderSpider()); + put(Names.renderEnderman_, new SMCCTRenderSpider()); + put(Names.renderSpider_, new SMCCTRenderSpider()); + put(Names.itemRenderer_, new SMCCTItemRenderer()); + put(Names.textureDownload_, new SMCCTTextureDownload()); + put(Names.abstractTexture_, new SMCCTTextureAbstract()); + put(Names.iTextureObject_, new SMCCTTextureObject()); + put(Names.simpleTexture_, new SMCCTTextureSimple()); + put(Names.layeredTexture_, new SMCCTTextureLayered()); + put(Names.dynamicTexture_, new SMCCTTextureDynamic()); + put(Names.textureMap_, new SMCCTTextureMap()); + put(Names.textureAtlasSpri_, new SMCCTTextureAtlasSprite()); + put(Names.textureClock_, new SMCCTTextureClock()); + put(Names.textureCompass_, new SMCCTTextureCompass()); + put(Names.textureManager_, new SMCCTTextureManager()); + ctMap.put("mrtjp.projectred.illumination.RenderHalo$", new SMCCTPrjRedIlluRenderHalo()); + ctMap.put("net.smart.render.ModelRotationRenderer", new SMCCTSmartMoveModelRotationRenderer()); + } + + @Override + public byte[] transform(String par1, String par2, byte[] par3) { + byte[] bytecode = par3; + // if (par2.startsWith("mrtjp")) SMCLog.info("**** [%s]", par2); + IClassTransformer ct = ctMap.get(par2); + if (ct != null) { + bytecode = ct.transform(par1, par2, bytecode); + int len1 = par3.length; // arg2!=null?arg2.length:0; + int len2 = bytecode.length; // bytecode!=null?bytecode.length:0; + SMCLog.fine(" %d (%+d)", len2, len2 - len1); + } + return bytecode; + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/transform/SMCLog.java b/src/main/java/com/gtnewhorizons/angelica/transform/SMCLog.java new file mode 100644 index 000000000..466ede26e --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/transform/SMCLog.java @@ -0,0 +1,107 @@ +package com.gtnewhorizons.angelica.transform; + +import static java.util.logging.Level.*; + +import java.io.IOException; +import java.util.Calendar; +import java.util.logging.ConsoleHandler; +import java.util.logging.FileHandler; +import java.util.logging.Formatter; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.LogRecord; +import java.util.logging.Logger; + +public abstract class SMCLog { + + private static class SMCFormatter extends Formatter { + int tzOffset; + + SMCFormatter() { + tzOffset = Calendar.getInstance().getTimeZone().getRawOffset(); + } + + @Override + public String format(LogRecord record) { + StringBuilder sb = new StringBuilder(); + // int time = (int)((record.getMillis() + tzOffset) % (24*60*60*1000)); + sb.append("[") + // .append(time/36000000).append(time/3600000%10)//.append(":") + // .append(time/600000%6).append(time/60000%10)//.append(":") + // .append(time/10000%6).append(time/10000%10).append(".") + // .append(time/100%10).append(time/10%10).append(time%10).append(" ") + .append(record.getLoggerName()) + .append(" ") + .append(record.getLevel()) + .append("]") + .append(record.getMessage()) + .append("\n"); + return sb.toString(); + } + } + + private static class SMCLogger extends Logger { + SMCLogger(String name) { + super(name, null); + setUseParentHandlers(false); + Formatter formatter = new SMCFormatter(); + Handler handler = new ConsoleHandler(); + handler.setFormatter(formatter); + addHandler(handler); + try { + handler = new FileHandler("shadersmod-%u.log", 8 * 1048576, 1, false); + handler.setFormatter(formatter); + addHandler(handler); + } catch (IOException e) { + e.printStackTrace(); + } + setLevel(ALL); + } + } + + private static class SMCLevel extends Level { + private SMCLevel(String name, int value) { + super(name, value); + } + } + + public static final String smcLogName = "SMC"; + public static final Logger logger = new SMCLogger(smcLogName); + public static final Level SMCINFO = new SMCLevel("INF", 850); + public static final Level SMCCONFIG = new SMCLevel("CFG", 840); + public static final Level SMCFINE = new SMCLevel("FNE", 830); + public static final Level SMCFINER = new SMCLevel("FNR", 820); + public static final Level SMCFINEST = new SMCLevel("FNT", 810); + + public static void log(Level level, String format, Object... args) { + if (logger.isLoggable(level)) logger.log(level, String.format(format, args)); + } + + public static void severe(String format, Object... args) { + if (logger.isLoggable(SEVERE)) logger.log(SEVERE, String.format(format, args)); + } + + public static void warning(String format, Object... args) { + if (logger.isLoggable(WARNING)) logger.log(WARNING, String.format(format, args)); + } + + public static void info(String format, Object... args) { + if (logger.isLoggable(SMCINFO)) logger.log(SMCINFO, String.format(format, args)); + } + + public static void config(String format, Object... args) { + if (logger.isLoggable(SMCCONFIG)) logger.log(SMCCONFIG, String.format(format, args)); + } + + public static void fine(String format, Object... args) { + if (logger.isLoggable(SMCFINE)) logger.log(SMCFINE, String.format(format, args)); + } + + public static void finer(String format, Object... args) { + if (logger.isLoggable(SMCFINER)) logger.log(SMCFINER, String.format(format, args)); + } + + public static void finest(String format, Object... args) { + if (logger.isLoggable(SMCFINEST)) logger.log(SMCFINEST, String.format(format, args)); + } +} diff --git a/src/main/resources/LICENSE b/src/main/resources/LICENSE new file mode 100644 index 000000000..9cb340ac3 --- /dev/null +++ b/src/main/resources/LICENSE @@ -0,0 +1,173 @@ +Original license from java/com/gtnewhorizons/angelica/client/Shaders.java, we (as GTNH developers) relicense it under LGPL. + +// Code written by daxnitro modified by id_miner and karyonix. +// Do what you want with it but give us some credit if you use it in whole or in part. + +New license: + + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. + diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info new file mode 100644 index 000000000..7d3e599d6 --- /dev/null +++ b/src/main/resources/mcmod.info @@ -0,0 +1,17 @@ +[ +{ + "modid": "${modId}", + "name": "${modName}", + "description": "The little angle that supports shaders while saving your FPS from a certain death", + "version": "2.3.18", + "mcversion": "1.7.10", + "url": "", + "updateUrl": "", + "authors": ["karyonix","sonic ether","id_miner","daxnitro"], + "credits": "Based on daxnitro's GLSL Shaders Mod.", + "logoFile": "", + "screenshots": [], + "parent":"", + "dependencies": [] +} +] diff --git a/shadersmod-mcf.patch b/todo/shadersmod-mcf.patch similarity index 86% rename from shadersmod-mcf.patch rename to todo/shadersmod-mcf.patch index a2fbda4c7..2e4c08f61 100644 --- a/shadersmod-mcf.patch +++ b/todo/shadersmod-mcf.patch @@ -1,256 +1,232 @@ -diff U3 net/minecraft/client/model/ModelRenderer.java net/minecraft/client/model/ModelRenderer.java ---- net/minecraft/client/model/ModelRenderer.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/model/ModelRenderer.java Sat Jul 12 03:12:44 2014 -@@ -305,4 +305,18 @@ - this.textureHeight = (float)p_78787_2_; - return this; - } -+ -+ public boolean getCompiled() { -+ return compiled; -+ } -+ public int getDisplayList() { -+ return displayList; -+ } -+ public void resetDisplayList() { -+ if (this.compiled) { -+ GLAllocation.deleteDisplayLists(this.displayList); -+ this.displayList = 0; -+ this.compiled = false; -+ } -+ } - } -\ No newline at end of file -diff U3 net/minecraft/client/renderer/EntityRenderer.java net/minecraft/client/renderer/EntityRenderer.java ---- net/minecraft/client/renderer/EntityRenderer.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/EntityRenderer.java Sun Jul 06 20:40:40 2014 -@@ -756,7 +756,7 @@ - /** - * Render player hand - */ -- private void renderHand(float p_78476_1_, int p_78476_2_) -+ public void renderHand(float p_78476_1_, int p_78476_2_) - { - if (this.debugViewDirection <= 0) - { -diff U3 net/minecraft/client/renderer/RenderGlobal.java net/minecraft/client/renderer/RenderGlobal.java ---- net/minecraft/client/renderer/RenderGlobal.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/RenderGlobal.java Sat Jul 12 03:14:01 2014 -@@ -96,7 +96,7 @@ - private final TextureManager renderEngine; - private List worldRenderersToUpdate = new ArrayList(); - private WorldRenderer[] sortedWorldRenderers; -- private WorldRenderer[] worldRenderers; -+ public WorldRenderer[] worldRenderers; - private int renderChunksWide; - private int renderChunksTall; - private int renderChunksDeep; -diff U3 net/minecraft/client/renderer/Tessellator.java net/minecraft/client/renderer/Tessellator.java ---- net/minecraft/client/renderer/Tessellator.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/Tessellator.java Sun Jul 06 21:01:03 2014 -@@ -24,70 +24,76 @@ - public int textureID = 0; - - /** The byte buffer used for GL allocation. */ -- private static ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); -+ public /*static*/ ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); - /** The same memory as byteBuffer, but referenced as an integer buffer. */ -- private static IntBuffer intBuffer = byteBuffer.asIntBuffer(); -+ public /*static*/ IntBuffer intBuffer = byteBuffer.asIntBuffer(); - /** The same memory as byteBuffer, but referenced as an float buffer. */ -- private static FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); -+ public /*static*/ FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); - /** The same memory as byteBuffer, but referenced as an short buffer. */ -- private static ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); -+ public /*static*/ ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); - /** Raw integer array. */ -- private int[] rawBuffer; -+ public int[] rawBuffer; - /** - * The number of vertices to be drawn in the next draw call. Reset to 0 between draw calls. - */ -- private int vertexCount; -+ public int vertexCount; - /** The first coordinate to be used for the texture. */ -- private double textureU; -+ public double textureU; - /** The second coordinate to be used for the texture. */ -- private double textureV; -- private int brightness; -+ public double textureV; -+ public int brightness; - /** The color (RGBA) value to be used for the following draw call. */ -- private int color; -+ public int color; - /** - * Whether the current draw object for this tessellator has color values. - */ -- private boolean hasColor; -+ public boolean hasColor; - /** - * Whether the current draw object for this tessellator has texture coordinates. - */ -- private boolean hasTexture; -- private boolean hasBrightness; -+ public boolean hasTexture; -+ public boolean hasBrightness; - /** - * Whether the current draw object for this tessellator has normal values. - */ -- private boolean hasNormals; -+ public boolean hasNormals; - /** The index into the raw buffer to be used for the next data. */ -- private int rawBufferIndex; -+ public int rawBufferIndex; - /** - * The number of vertices manually added to the given draw call. This differs from vertexCount because it adds extra - * vertices when converting quads to triangles. - */ -- private int addedVertices; -+ public int addedVertices; - /** Disables all color information for the following draw call. */ - private boolean isColorDisabled; - /** The draw mode currently being used by the tessellator. */ -- private int drawMode; -+ public int drawMode; - /** - * An offset to be applied along the x-axis for all vertices in this draw call. - */ -- private double xOffset; -+ public double xOffset; - /** - * An offset to be applied along the y-axis for all vertices in this draw call. - */ -- private double yOffset; -+ public double yOffset; - /** - * An offset to be applied along the z-axis for all vertices in this draw call. - */ -- private double zOffset; -+ public double zOffset; - /** The normal to be applied to the face being drawn. */ - private int normal; - /** The static instance of the Tessellator. */ - public static final Tessellator instance = new Tessellator(2097152); - /** Whether this tessellator is currently in draw mode. */ -- private boolean isDrawing; -+ public boolean isDrawing; - /** The size of the buffers used (in integers). */ -- private int bufferSize; -+ public int bufferSize; -+ public float midTextureU; -+ public float midTextureV; -+ public float normalX; -+ public float normalY; -+ public float normalZ; -+ public float[] vertexPos = new float[16]; - private static final String __OBFID = "CL_00000960"; - - private Tessellator(int p_i1250_1_) -@@ -245,7 +251,7 @@ - /** - * Clears the tessellator state in preparation for new drawing. - */ -- private void reset() -+ public void reset() - { - this.vertexCount = 0; - this.byteBuffer.clear(); -diff U3 net/minecraft/client/renderer/entity/RendererLivingEntity.java net/minecraft/client/renderer/entity/RendererLivingEntity.java ---- net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:40:40 2014 -@@ -31,9 +31,9 @@ - { - private static final Logger logger = LogManager.getLogger(); - private static final ResourceLocation RES_ITEM_GLINT = new ResourceLocation("textures/misc/enchanted_item_glint.png"); -- protected ModelBase mainModel; -+ public ModelBase mainModel; - /** The model to be used during the render passes. */ -- protected ModelBase renderPassModel; -+ public ModelBase renderPassModel; - private static final String __OBFID = "CL_00001012"; - - public static float NAME_TAG_RANGE = 64.0f; -diff U3 net/minecraft/client/renderer/texture/AbstractTexture.java net/minecraft/client/renderer/texture/AbstractTexture.java ---- net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:40:40 2014 -@@ -1,12 +1,14 @@ - package net.minecraft.client.renderer.texture; - -+import shadersmodcore.client.MultiTexID; - import cpw.mods.fml.relauncher.Side; - import cpw.mods.fml.relauncher.SideOnly; - - @SideOnly(Side.CLIENT) - public abstract class AbstractTexture implements ITextureObject - { -- protected int glTextureId = -1; -+ public int glTextureId = -1; -+ public MultiTexID multiTex; - private static final String __OBFID = "CL_00001047"; - - public int getGlTextureId() -@@ -27,4 +29,10 @@ - this.glTextureId = -1; - } - } -+ -+ @Override -+ public MultiTexID getMultiTexID() { -+ // TODO Auto-generated method stub -+ return null; -+ } - } -\ No newline at end of file -diff U3 net/minecraft/client/renderer/texture/ITextureObject.java net/minecraft/client/renderer/texture/ITextureObject.java ---- net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:40:40 2014 -@@ -3,6 +3,8 @@ - import cpw.mods.fml.relauncher.Side; - import cpw.mods.fml.relauncher.SideOnly; - import java.io.IOException; -+ -+import shadersmodcore.client.MultiTexID; - import net.minecraft.client.resources.IResourceManager; - - @SideOnly(Side.CLIENT) -@@ -11,4 +13,6 @@ - void loadTexture(IResourceManager p_110551_1_) throws IOException; - - int getGlTextureId(); -+ -+ MultiTexID getMultiTexID(); - } -\ No newline at end of file -diff U3 net/minecraft/client/renderer/texture/TextureAtlasSprite.java net/minecraft/client/renderer/texture/TextureAtlasSprite.java ---- net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:40:40 2014 -@@ -24,7 +24,7 @@ - protected List framesTextureData = Lists.newArrayList(); - private AnimationMetadataSection animationMetadata; - protected boolean rotated; -- private boolean useAnisotropicFiltering; -+ public boolean useAnisotropicFiltering; - protected int originX; - protected int originY; - protected int width; -diff U3 net/minecraft/client/renderer/texture/TextureMap.java net/minecraft/client/renderer/texture/TextureMap.java ---- net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:27:14 2014 -+++ net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:40:40 2014 -@@ -49,6 +49,7 @@ - private int anisotropicFiltering = 1; - private final TextureAtlasSprite missingImage = new TextureAtlasSprite("missingno"); - private static final String __OBFID = "CL_00001058"; -+ public int atlasWidth, atlasHeight; // shadersmod - - public TextureMap(int p_i1281_1_, String p_i1281_2_) - { -@@ -292,7 +293,7 @@ - ForgeHooksClient.onTextureStitchedPost(this); - } - -- private ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) -+ public ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) - { - return p_147634_2_ == 0 ? new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/%s%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), ".png"})): new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/mipmaps/%s.%d%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), Integer.valueOf(p_147634_2_), ".png"})); - } +diff U3 net/minecraft/client/model/ModelRenderer.java net/minecraft/client/model/ModelRenderer.java +--- net/minecraft/client/model/ModelRenderer.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/model/ModelRenderer.java Sat Jul 12 03:12:44 2014 +@@ -305,4 +305,18 @@ + this.textureHeight = (float)p_78787_2_; + return this; + } ++ ++ public boolean getCompiled() { ++ return compiled; ++ } ++ public int getDisplayList() { ++ return displayList; ++ } ++ public void resetDisplayList() { ++ if (this.compiled) { ++ GLAllocation.deleteDisplayLists(this.displayList); ++ this.displayList = 0; ++ this.compiled = false; ++ } ++ } + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/Tessellator.java net/minecraft/client/renderer/Tessellator.java +--- net/minecraft/client/renderer/Tessellator.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/Tessellator.java Sun Jul 06 21:01:03 2014 +@@ -24,70 +24,76 @@ + public int textureID = 0; + + /** The byte buffer used for GL allocation. */ +- private static ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); ++ public /*static*/ ByteBuffer byteBuffer = GLAllocation.createDirectByteBuffer(nativeBufferSize * 4); + /** The same memory as byteBuffer, but referenced as an integer buffer. */ +- private static IntBuffer intBuffer = byteBuffer.asIntBuffer(); ++ public /*static*/ IntBuffer intBuffer = byteBuffer.asIntBuffer(); + /** The same memory as byteBuffer, but referenced as an float buffer. */ +- private static FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); ++ public /*static*/ FloatBuffer floatBuffer = byteBuffer.asFloatBuffer(); + /** The same memory as byteBuffer, but referenced as an short buffer. */ +- private static ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); ++ public /*static*/ ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); + /** Raw integer array. */ +- private int[] rawBuffer; ++ public int[] rawBuffer; + /** + * The number of vertices to be drawn in the next draw call. Reset to 0 between draw calls. + */ +- private int vertexCount; ++ public int vertexCount; + /** The first coordinate to be used for the texture. */ +- private double textureU; ++ public double textureU; + /** The second coordinate to be used for the texture. */ +- private double textureV; +- private int brightness; ++ public double textureV; ++ public int brightness; + /** The color (RGBA) value to be used for the following draw call. */ +- private int color; ++ public int color; + /** + * Whether the current draw object for this tessellator has color values. + */ +- private boolean hasColor; ++ public boolean hasColor; + /** + * Whether the current draw object for this tessellator has texture coordinates. + */ +- private boolean hasTexture; +- private boolean hasBrightness; ++ public boolean hasTexture; ++ public boolean hasBrightness; + /** + * Whether the current draw object for this tessellator has normal values. + */ +- private boolean hasNormals; ++ public boolean hasNormals; + /** The index into the raw buffer to be used for the next data. */ +- private int rawBufferIndex; ++ public int rawBufferIndex; + /** + * The number of vertices manually added to the given draw call. This differs from vertexCount because it adds extra + * vertices when converting quads to triangles. + */ +- private int addedVertices; ++ public int addedVertices; + /** Disables all color information for the following draw call. */ + private boolean isColorDisabled; + /** The draw mode currently being used by the tessellator. */ +- private int drawMode; ++ public int drawMode; + /** + * An offset to be applied along the x-axis for all vertices in this draw call. + */ +- private double xOffset; ++ public double xOffset; + /** + * An offset to be applied along the y-axis for all vertices in this draw call. + */ +- private double yOffset; ++ public double yOffset; + /** + * An offset to be applied along the z-axis for all vertices in this draw call. + */ +- private double zOffset; ++ public double zOffset; + /** The normal to be applied to the face being drawn. */ + private int normal; + /** The static instance of the Tessellator. */ + public static final Tessellator instance = new Tessellator(2097152); + /** Whether this tessellator is currently in draw mode. */ +- private boolean isDrawing; ++ public boolean isDrawing; + /** The size of the buffers used (in integers). */ +- private int bufferSize; ++ public int bufferSize; ++ public float midTextureU; ++ public float midTextureV; ++ public float normalX; ++ public float normalY; ++ public float normalZ; ++ public float[] vertexPos = new float[16]; + private static final String __OBFID = "CL_00000960"; + + private Tessellator(int p_i1250_1_) +@@ -245,7 +251,7 @@ + /** + * Clears the tessellator state in preparation for new drawing. + */ +- private void reset() ++ public void reset() + { + this.vertexCount = 0; + this.byteBuffer.clear(); +diff U3 net/minecraft/client/renderer/entity/RendererLivingEntity.java net/minecraft/client/renderer/entity/RendererLivingEntity.java +--- net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/entity/RendererLivingEntity.java Sun Jul 06 20:40:40 2014 +@@ -31,9 +31,9 @@ + { + private static final Logger logger = LogManager.getLogger(); + private static final ResourceLocation RES_ITEM_GLINT = new ResourceLocation("textures/misc/enchanted_item_glint.png"); +- protected ModelBase mainModel; ++ public ModelBase mainModel; + /** The model to be used during the render passes. */ +- protected ModelBase renderPassModel; ++ public ModelBase renderPassModel; + private static final String __OBFID = "CL_00001012"; + + public static float NAME_TAG_RANGE = 64.0f; +diff U3 net/minecraft/client/renderer/texture/AbstractTexture.java net/minecraft/client/renderer/texture/AbstractTexture.java +--- net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/AbstractTexture.java Sun Jul 06 20:40:40 2014 +@@ -1,12 +1,14 @@ + package net.minecraft.client.renderer.texture; + ++import com.gtnewhorizons.angelica.client.MultiTexID; + import cpw.mods.fml.relauncher.Side; + import cpw.mods.fml.relauncher.SideOnly; + + @SideOnly(Side.CLIENT) + public abstract class AbstractTexture implements ITextureObject + { +- protected int glTextureId = -1; ++ public int glTextureId = -1; ++ public MultiTexID multiTex; + private static final String __OBFID = "CL_00001047"; + + public int getGlTextureId() +@@ -27,4 +29,10 @@ + this.glTextureId = -1; + } + } ++ ++ @Override ++ public MultiTexID getMultiTexID() { ++ // TODO Auto-generated method stub ++ return null; ++ } + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/texture/ITextureObject.java net/minecraft/client/renderer/texture/ITextureObject.java +--- net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/ITextureObject.java Sun Jul 06 20:40:40 2014 +@@ -3,6 +3,8 @@ + import cpw.mods.fml.relauncher.Side; + import cpw.mods.fml.relauncher.SideOnly; + import java.io.IOException; ++ ++import com.gtnewhorizons.angelica.client.MultiTexID; + import net.minecraft.client.resources.IResourceManager; + + @SideOnly(Side.CLIENT) +@@ -11,4 +13,6 @@ + void loadTexture(IResourceManager p_110551_1_) throws IOException; + + int getGlTextureId(); ++ ++ MultiTexID getMultiTexID(); + } +\ No newline at end of file +diff U3 net/minecraft/client/renderer/texture/TextureAtlasSprite.java net/minecraft/client/renderer/texture/TextureAtlasSprite.java +--- net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/TextureAtlasSprite.java Sun Jul 06 20:40:40 2014 +@@ -24,7 +24,7 @@ + protected List framesTextureData = Lists.newArrayList(); + private AnimationMetadataSection animationMetadata; + protected boolean rotated; +- private boolean useAnisotropicFiltering; ++ public boolean useAnisotropicFiltering; + protected int originX; + protected int originY; + protected int width; +diff U3 net/minecraft/client/renderer/texture/TextureMap.java net/minecraft/client/renderer/texture/TextureMap.java +--- net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:27:14 2014 ++++ net/minecraft/client/renderer/texture/TextureMap.java Sun Jul 06 20:40:40 2014 +@@ -49,6 +49,7 @@ + private int anisotropicFiltering = 1; + private final TextureAtlasSprite missingImage = new TextureAtlasSprite("missingno"); + private static final String __OBFID = "CL_00001058"; ++ public int atlasWidth, atlasHeight; // shadersmod + + public TextureMap(int p_i1281_1_, String p_i1281_2_) + { +@@ -292,7 +293,7 @@ + ForgeHooksClient.onTextureStitchedPost(this); + } + +- private ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) ++ public ResourceLocation completeResourceLocation(ResourceLocation p_147634_1_, int p_147634_2_) + { + return p_147634_2_ == 0 ? new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/%s%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), ".png"})): new ResourceLocation(p_147634_1_.getResourceDomain(), String.format("%s/mipmaps/%s.%d%s", new Object[] {this.basePath, p_147634_1_.getResourcePath(), Integer.valueOf(p_147634_2_), ".png"})); + }