diff options
Diffstat (limited to 'src')
12 files changed, 734 insertions, 0 deletions
diff --git a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt index 5b0806042..17aa52347 100644 --- a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt +++ b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt @@ -103,6 +103,7 @@ import at.hannibal2.skyhanni.features.summonings.SummoningSoulsName import at.hannibal2.skyhanni.mixins.hooks.RenderLivingEntityHelper import at.hannibal2.skyhanni.test.* import at.hannibal2.skyhanni.test.command.CopyNearbyParticlesCommand +import at.hannibal2.skyhanni.utils.EntityOutlineRenderer import at.hannibal2.skyhanni.utils.MinecraftConsoleFilter.Companion.initLogging import at.hannibal2.skyhanni.utils.NEUVersionCheck.checkIfNeuIsLoaded import at.hannibal2.skyhanni.utils.TabListData @@ -140,6 +141,7 @@ class SkyHanniMod { loadModule(HypixelData()) loadModule(DungeonData()) loadModule(ScoreboardData()) + loadModule(SeaCreatureFeatures()) loadModule(SeaCreatureManager()) loadModule(ItemRenderBackground()) loadModule(EntityData()) @@ -171,6 +173,7 @@ class SkyHanniMod { loadModule(TitleData()) loadModule(BlockData()) loadModule(DefaultConfigFeatures) + loadModule(EntityOutlineRenderer) // APIs loadModule(BazaarApi()) diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/FishingConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/FishingConfig.java index 3dccd1b3c..896c572f0 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/FishingConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/FishingConfig.java @@ -192,6 +192,12 @@ public class FishingConfig { } @Expose + @ConfigOption(name = "Rare Sea Creature Highlight", desc = "Highlight rare sea creatures in blue color.") + @ConfigEditorBoolean + @FeatureToggle + public boolean rareSeaCreatureHighlight = false; + + @Expose @ConfigOption( name = "Shark Fish Counter", desc = "Counts how many sharks have been caught." diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/MiscConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/MiscConfig.java index 3830f175b..efceff92b 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/MiscConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/MiscConfig.java @@ -1036,6 +1036,12 @@ public class MiscConfig { public boolean configButtonOnPause = true; @Expose + @ConfigOption(name = "Entity Outlines", desc = "Enable entity outlines for applicable features.") + @ConfigEditorBoolean + @FeatureToggle + public boolean enableEntityOutlines = true; + + @Expose public Position inventoryLoadPos = new Position(394, 124, false, true); diff --git a/src/main/java/at/hannibal2/skyhanni/events/RenderEntityOutlineEvent.kt b/src/main/java/at/hannibal2/skyhanni/events/RenderEntityOutlineEvent.kt new file mode 100644 index 000000000..5efc7cd94 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/events/RenderEntityOutlineEvent.kt @@ -0,0 +1,118 @@ +package at.hannibal2.skyhanni.events
+
+import net.minecraft.client.Minecraft
+import net.minecraft.entity.Entity
+import net.minecraft.entity.item.EntityArmorStand
+import net.minecraft.entity.item.EntityItemFrame
+import java.util.function.Consumer
+
+class RenderEntityOutlineEvent(theType: Type?, potentialEntities: HashSet<Entity>?) :
+ LorenzEvent() {
+
+ /**
+ * The phase of the event (see [Type]
+ */
+ var type: Type? = null
+
+ /**
+ * The entities to outline. This is progressively cumulated from [.entitiesToChooseFrom]
+ */
+ var entitiesToOutline: HashMap<Entity, Int>? = null
+
+ /**
+ * The entities we can outline. Note that this set and [.entitiesToOutline] are disjoint at all times.
+ */
+ var entitiesToChooseFrom: HashSet<Entity>? = null
+
+ /**
+ * Constructs the event, given the type and optional entities to outline.
+ *
+ *
+ * This will modify {@param potentialEntities} internally, so make a copy before passing it if necessary.
+ *
+ * @param theType of the event (see [Type]
+ */
+ init {
+ type = theType
+ entitiesToChooseFrom = potentialEntities
+ if (potentialEntities != null) {
+ entitiesToOutline = HashMap(potentialEntities.size)
+ }
+ }
+
+ /**
+ * Conditionally queue entities around which to render entities
+ * Selects from the pool of [.entitiesToChooseFrom] to speed up the predicate testing on subsequent calls.
+ * Is more efficient (theoretically) than calling [.queueEntityToOutline] for each entity because lists are handled internally.
+ *
+ *
+ * This function loops through all entities and so is not very efficient.
+ * It's advisable to encapsulate calls to this function with global checks (those not dependent on an individual entity) for efficiency purposes.
+ *
+ * @param outlineColor a function to test
+ */
+ fun queueEntitiesToOutline(outlineColor: ((entity: Entity) -> Int?)? = null) {
+ if (outlineColor == null) {
+ return
+ }
+ if (entitiesToChooseFrom == null) {
+ computeAndCacheEntitiesToChooseFrom()
+ }
+ val itr: MutableIterator<Entity> = entitiesToChooseFrom!!.iterator()
+ while (itr.hasNext()) {
+ val e: Entity = itr.next()
+ val i: Int? = outlineColor(e)
+ if (i != null) {
+ entitiesToOutline!![e] = i
+ itr.remove()
+ }
+ }
+ }
+
+ /**
+ * Adds a single entity to the list of the entities to outline
+ *
+ * @param entity the entity to add
+ * @param outlineColor the color with which to outline
+ */
+ fun queueEntityToOutline(entity: Entity?, outlineColor: Int) {
+ if (entity == null) {
+ return
+ }
+ if (entitiesToChooseFrom == null) {
+ computeAndCacheEntitiesToChooseFrom()
+ }
+ if (!entitiesToChooseFrom!!.contains(entity)) {
+ return
+ }
+ entitiesToOutline!![entity] = outlineColor
+ entitiesToChooseFrom!!.remove(entity)
+ }
+
+ /**
+ * Used for on-the-fly generation of entities. Driven by event handlers in a decentralized fashion
+ */
+ private fun computeAndCacheEntitiesToChooseFrom() {
+ val entities: List<Entity> = Minecraft.getMinecraft().theWorld.getLoadedEntityList()
+ // Only render outlines around non-null entities within the camera frustum
+ entitiesToChooseFrom = HashSet(entities.size)
+ // Only consider entities that aren't invisible armorstands to increase FPS significantly
+ entities.forEach(Consumer<Entity> { e: Entity? ->
+ if (e != null && !(e is EntityArmorStand && e.isInvisible()) && e !is EntityItemFrame) {
+ entitiesToChooseFrom!!.add(e)
+ }
+ })
+ entitiesToOutline = HashMap(entitiesToChooseFrom!!.size)
+ }
+
+ /**
+ * The phase of the event.
+ * [.XRAY] means that this directly precedes entities whose outlines are rendered through walls (Vanilla 1.9+)
+ * [.NO_XRAY] means that this directly precedes entities whose outlines are rendered only when visible to the client
+ */
+ enum class Type {
+ XRAY,
+ NO_XRAY
+ }
+
+}
\ No newline at end of file diff --git a/src/main/java/at/hannibal2/skyhanni/features/fishing/SeaCreatureFeatures.kt b/src/main/java/at/hannibal2/skyhanni/features/fishing/SeaCreatureFeatures.kt new file mode 100644 index 000000000..9f7ef0fa5 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/fishing/SeaCreatureFeatures.kt @@ -0,0 +1,100 @@ +package at.hannibal2.skyhanni.features.fishing + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.events.EntityMaxHealthUpdateEvent +import at.hannibal2.skyhanni.events.LorenzWorldChangeEvent +import at.hannibal2.skyhanni.events.RenderEntityOutlineEvent +import at.hannibal2.skyhanni.events.withAlpha +import at.hannibal2.skyhanni.features.damageindicator.DamageIndicatorManager +import at.hannibal2.skyhanni.mixins.hooks.RenderLivingEntityHelper +import at.hannibal2.skyhanni.utils.* +import at.hannibal2.skyhanni.utils.EntityUtils.getSkinTexture +import at.hannibal2.skyhanni.utils.EntityUtils.hasMaxHealth +import at.hannibal2.skyhanni.utils.LocationUtils.distanceToPlayer +import at.hannibal2.skyhanni.utils.LorenzUtils.baseMaxHealth +import at.hannibal2.skyhanni.utils.LorenzUtils.editCopy +import net.minecraft.client.Minecraft +import net.minecraft.client.entity.EntityOtherPlayerMP +import net.minecraft.client.gui.FontRenderer +import net.minecraft.entity.Entity +import net.minecraft.entity.EntityLivingBase +import net.minecraft.entity.item.EntityItem +import net.minecraft.entity.monster.EntityGuardian +import net.minecraft.entity.monster.EntitySkeleton +import net.minecraft.entity.monster.EntityZombie +import net.minecraft.entity.player.EntityPlayer +import net.minecraft.scoreboard.ScorePlayerTeam +import net.minecraft.scoreboard.Team.EnumVisible +import net.minecraftforge.client.event.RenderWorldLastEvent +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent +import java.awt.Color + + +class SeaCreatureFeatures { + private val config get() = SkyHanniMod.feature.fishing + private var rareSeaCreatures = listOf<EntityLivingBase>() + + @SubscribeEvent + fun onEntityHealthUpdate(event: EntityMaxHealthUpdateEvent) { + if (!isEnabled()) return + val entity = event.entity as? EntityLivingBase ?: return + if (DamageIndicatorManager.isBoss(entity)) return + + val maxHealth = event.maxHealth + for (creatureType in RareSeaCreatureType.entries) { + if (EntityGuardian::class.java.isInstance(entity) && entity.baseMaxHealth > 1000) { + LorenzUtils.consoleLog("FISHING CREATURE NAME: ${entity.baseMaxHealth} ${(entity as EntityGuardian).customNameTag}") + } + + if (!creatureType.health.any { entity.hasMaxHealth(it, false, maxHealth) }) continue + if (!creatureType.clazz.isInstance(entity)) continue + + if (EntityPlayer::class.java.isInstance(entity)) { + LorenzUtils.consoleLog("FISHING CREATURE NAME: ${(entity as EntityPlayer).customNameTag}") + } + + if (creatureType.nametag.isNotBlank() && EntityPlayer::class.java.isInstance(entity) && (entity as EntityPlayer).name != creatureType.nametag) { + continue + } + + rareSeaCreatures = rareSeaCreatures.editCopy { add(entity) } + RenderLivingEntityHelper.setEntityColor(entity, LorenzColor.RED.toColor().withAlpha(50)) + { config.rareSeaCreatureHighlight } + RenderLivingEntityHelper.setNoHurtTime(entity) { config.rareSeaCreatureHighlight } + } + } + + @SubscribeEvent + fun onWorldChange(event: LorenzWorldChangeEvent) { + rareSeaCreatures = emptyList() + } + + @SubscribeEvent + fun onRenderEntityOutlines(event: RenderEntityOutlineEvent) { + if (isEnabled() && config.rareSeaCreatureHighlight && event.type === RenderEntityOutlineEvent.Type.XRAY) { + event.queueEntitiesToOutline(getEntityOutlineColor) + } + } + + private fun isEnabled() = LorenzUtils.inSkyBlock && !LorenzUtils.inDungeons && !LorenzUtils.inKuudraFight + + private val getEntityOutlineColor: (entity: Entity) -> Int? = { e -> + if (EntityLivingBase::class.java.isInstance(e) && e in rareSeaCreatures && e.distanceToPlayer() < 30) { + LorenzColor.GREEN.toColor().rgb + } else { + null + } + } + + enum class RareSeaCreatureType(val clazz: Class<out EntityLivingBase>, val nametag: String, vararg val health: Int) { + WATER_HYDRA(EntityZombie::class.java, "Water Hydra", 500_000, 1_500_000), + SEA_EMPEROR(EntityGuardian::class.java, "The Sea Emperors", 750_000, 800_000, 2_250_000, 2_400_000), + ZOMBIE_MINER(EntityPlayer::class.java, "", 2_000_000, 6_000_000), + PHANTOM_FISHERMAN(EntityPlayer::class.java, "Phantom Fisher", 1_000_000, 3_000_000), + GRIM_REAPER(EntityPlayer::class.java, "Grim Reaper", 3_000_000, 9_000_000), + YETI(EntityPlayer::class.java, "", 2_000_000, 6_000_000), + NUTCRACKER(EntityPlayer::class.java, "", 4_000_000, 12_000_000), + GREAT_WHITE_SHARK(EntityPlayer::class.java, "GWS ", 1_500_000, 4_500_000), + ; + } +} diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RenderGlobalHook.kt b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RenderGlobalHook.kt new file mode 100644 index 000000000..57305c5bd --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RenderGlobalHook.kt @@ -0,0 +1,20 @@ +package at.hannibal2.skyhanni.mixins.hooks
+
+import at.hannibal2.skyhanni.utils.EntityOutlineRenderer
+import at.hannibal2.skyhanni.utils.RenderUtils
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.culling.ICamera
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
+
+class RenderGlobalHook {
+ fun renderEntitiesOutlines(camera: ICamera?, partialTicks: Float): Boolean {
+ val vec = RenderUtils.exactLocation(Minecraft.getMinecraft().renderViewEntity, partialTicks)
+ return EntityOutlineRenderer.renderEntityOutlines(camera!!, partialTicks, vec)
+ }
+
+ fun shouldRenderEntityOutlines(cir: CallbackInfoReturnable<Boolean?>) {
+ if (EntityOutlineRenderer.shouldRenderEntityOutlines()) {
+ cir.returnValue = true
+ }
+ }
+}
\ No newline at end of file diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RendererLivingEntityHook.kt b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RendererLivingEntityHook.kt new file mode 100644 index 000000000..a06e6d89e --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/mixins/hooks/RendererLivingEntityHook.kt @@ -0,0 +1,20 @@ +package at.hannibal2.skyhanni.mixins.hooks
+
+import at.hannibal2.skyhanni.utils.EntityOutlineRenderer
+import net.minecraft.client.renderer.GlStateManager
+import net.minecraft.entity.EntityLivingBase
+
+class RendererLivingEntityHook {
+ fun setOutlineColor(red: Float, green: Float, blue: Float, alpha: Float, entity: EntityLivingBase) {
+ val color = EntityOutlineRenderer.getCustomOutlineColor(entity);
+
+ if (color != null) {
+ val colorRed = (color shr 16 and 255).toFloat() / 255.0f
+ val colorGreen = (color shr 8 and 255).toFloat() / 255.0f
+ val colorBlue = (color and 255).toFloat() / 255.0f
+ GlStateManager.color(colorRed, colorGreen, colorBlue, alpha);
+ } else {
+ GlStateManager.color(red, green, blue, alpha);
+ }
+ }
+}
\ No newline at end of file diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/transformers/CustomRenderGlobal.java b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/CustomRenderGlobal.java new file mode 100644 index 000000000..bd440d3ea --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/CustomRenderGlobal.java @@ -0,0 +1,17 @@ +package at.hannibal2.skyhanni.mixins.transformers;
+
+import net.minecraft.client.renderer.RenderGlobal;
+import net.minecraft.client.shader.Framebuffer;
+import net.minecraft.client.shader.ShaderGroup;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(RenderGlobal.class)
+public interface CustomRenderGlobal {
+ @Accessor("entityOutlineFramebuffer")
+ Framebuffer getEntityOutlineFramebuffer_skyhanni();
+
+ @Accessor("entityOutlineShader")
+ ShaderGroup getEntityOutlineShader_skyhanni();
+
+}
\ No newline at end of file diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRenderGlobal.java b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRenderGlobal.java new file mode 100644 index 000000000..630fb1381 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRenderGlobal.java @@ -0,0 +1,42 @@ +package at.hannibal2.skyhanni.mixins.transformers;
+
+import at.hannibal2.skyhanni.mixins.hooks.RenderGlobalHook;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderGlobal;
+import at.hannibal2.skyhanni.utils.EntityOutlineRenderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.culling.ICamera;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(RenderGlobal.class)
+public abstract class MixinRenderGlobal {
+
+ @Shadow
+ abstract boolean isRenderEntityOutlines();
+
+ @Unique
+ private final RenderGlobalHook skyHanni$hook = new RenderGlobalHook();
+
+ @Redirect(method = "renderEntities", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;isRenderEntityOutlines()Z"))
+ public boolean renderEntitiesOutlines(RenderGlobal self, Entity renderViewEntity, ICamera camera, float partialTicks) {
+ return skyHanni$hook.renderEntitiesOutlines(camera, partialTicks) && this.isRenderEntityOutlines();
+ }
+
+ @Inject(method = "isRenderEntityOutlines", at = @At(value = "HEAD"), cancellable = true)
+ public void isRenderEntityOutlinesWrapper(CallbackInfoReturnable<Boolean> cir) {
+ skyHanni$hook.shouldRenderEntityOutlines(cir);
+ }
+
+ @Inject(method = "renderEntityOutlineFramebuffer", at = @At(value = "RETURN"))
+ public void afterFramebufferDraw(CallbackInfo callbackInfo) {
+ GlStateManager.enableDepth();
+ }
+}
diff --git a/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRendererLivingEntity.java b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRendererLivingEntity.java new file mode 100644 index 000000000..281137ae5 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/mixins/transformers/MixinRendererLivingEntity.java @@ -0,0 +1,23 @@ +package at.hannibal2.skyhanni.mixins.transformers;
+
+import at.hannibal2.skyhanni.mixins.hooks.RendererLivingEntityHook;
+import at.hannibal2.skyhanni.utils.EntityOutlineRenderer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.EntityLivingBase;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.Unique;
+
+@Mixin(RendererLivingEntity.class)
+public class MixinRendererLivingEntity {
+
+ @Unique
+ private final RendererLivingEntityHook skyHanni$hook = new RendererLivingEntityHook();
+
+ @Redirect(method = "setScoreTeamColor", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;color(FFFF)V"))
+ public void setOutlineColor(float colorRed, float colorGreen, float colorBlue, float colorAlpha, EntityLivingBase entity) {
+ skyHanni$hook.setOutlineColor(colorRed, colorGreen, colorBlue, colorAlpha, entity);
+ }
+}
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/EntityOutlineRenderer.kt b/src/main/java/at/hannibal2/skyhanni/utils/EntityOutlineRenderer.kt new file mode 100644 index 000000000..454df1454 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/utils/EntityOutlineRenderer.kt @@ -0,0 +1,376 @@ +package at.hannibal2.skyhanni.utils
+
+import at.hannibal2.skyhanni.SkyHanniMod
+import at.hannibal2.skyhanni.events.LorenzTickEvent
+import at.hannibal2.skyhanni.events.RenderEntityOutlineEvent
+import at.hannibal2.skyhanni.mixins.transformers.CustomRenderGlobal
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.GlStateManager
+import net.minecraft.client.renderer.OpenGlHelper
+import net.minecraft.client.renderer.RenderHelper
+import net.minecraft.client.renderer.culling.ICamera
+import net.minecraft.client.shader.Framebuffer
+import net.minecraft.entity.Entity
+import net.minecraft.entity.EntityLivingBase
+import net.minecraft.util.BlockPos
+import net.minecraftforge.client.MinecraftForgeClient
+import net.minecraftforge.common.MinecraftForge
+import net.minecraftforge.fml.common.eventhandler.EventPriority
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import net.minecraftforge.fml.common.gameevent.TickEvent
+import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent
+import org.lwjgl.opengl.GL11
+import org.lwjgl.opengl.GL13
+import org.lwjgl.opengl.GL30
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+
+/**
+ * Class to handle all entity outlining, including xray and no-xray rendering
+ * Features that include entity outlining should subscribe to the {@link RenderEntityOutlineEvent}.
+ *
+ * Credit to SkyblockAddons and Biscuit Development
+ * https://github.com/BiscuitDevelopment/SkyblockAddons/blob/main/src/main/java/codes/biscuit/skyblockaddons/features/EntityOutlines/EntityOutlineRenderer.java
+ *
+ */
+ object EntityOutlineRenderer {
+ private val entityRenderCache: CachedInfo = CachedInfo(null, null, null)
+ private var stopLookingForOptifine = false
+ private var isFastRender: Method? = null
+ private var isShaders: Method? = null
+ private var isAntialiasing: Method? = null
+ private var emptyLastTick = false
+ private val swapBuffer by lazy { initSwapBuffer() }
+ private val logger = LorenzLogger("entity_outline_renderer")
+ private val config get() = SkyHanniMod.feature.misc
+ private val mc get() = Minecraft.getMinecraft()
+ private val BUF_FLOAT_4: java.nio.FloatBuffer = org.lwjgl.BufferUtils.createFloatBuffer(4)
+
+ /**
+ * @return a new framebuffer with the size of the main framebuffer
+ */
+ private fun initSwapBuffer(): Framebuffer {
+ val main = mc.framebuffer
+ val framebuffer = Framebuffer(main.framebufferTextureWidth, main.framebufferTextureHeight, true)
+ framebuffer.setFramebufferFilter(GL11.GL_NEAREST)
+ framebuffer.setFramebufferColor(0.0f, 0.0f, 0.0f, 0.0f)
+ return framebuffer
+ }
+
+ private fun updateFramebufferSize() {
+ val width = mc.displayWidth
+ val height = mc.displayHeight
+ if (swapBuffer.framebufferWidth != width || swapBuffer.framebufferHeight != height) {
+ swapBuffer.createBindFramebuffer(width, height)
+ }
+ val rg = mc.renderGlobal as CustomRenderGlobal
+ val outlineBuffer = rg.entityOutlineFramebuffer_skyhanni
+ if (outlineBuffer.framebufferWidth != width || outlineBuffer.framebufferHeight != height) {
+ outlineBuffer.createBindFramebuffer(width, height)
+ rg.entityOutlineShader_skyhanni.createBindFramebuffers(width, height)
+ }
+ }
+
+ /**
+ * Renders xray and no-xray entity outlines.
+ *
+ * @param camera the current camera
+ * @param partialTicks the progress to the next tick
+ * @param x the camera x position
+ * @param y the camera y position
+ * @param z the camera z position
+ */
+ @JvmStatic
+ fun renderEntityOutlines(camera: ICamera, partialTicks: Float, vector: LorenzVec): Boolean {
+ val shouldRenderOutlines = shouldRenderEntityOutlines()
+
+ if (!(shouldRenderOutlines && !isCacheEmpty() && MinecraftForgeClient.getRenderPass() == 0)) {
+ return !shouldRenderOutlines
+ }
+
+ val renderGlobal = mc.renderGlobal as CustomRenderGlobal
+ val renderManager = mc.renderManager
+ mc.theWorld.theProfiler.endStartSection("entityOutlines")
+ updateFramebufferSize()
+
+ // Clear and bind the outline framebuffer
+ renderGlobal.entityOutlineFramebuffer_skyhanni.framebufferClear()
+ renderGlobal.entityOutlineFramebuffer_skyhanni.bindFramebuffer(false)
+
+ // Vanilla options
+ RenderHelper.disableStandardItemLighting()
+ GlStateManager.disableFog()
+ mc.renderManager.setRenderOutlines(true)
+
+ // Enable outline mode
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL11.GL_REPLACE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_SOURCE0_RGB, GL13.GL_CONSTANT);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_OPERAND0_RGB, GL11.GL_SRC_COLOR);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_REPLACE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_SOURCE0_ALPHA, GL11.GL_TEXTURE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_OPERAND0_ALPHA, GL11.GL_SRC_ALPHA);
+
+ // Render x-ray outlines first, ignoring the depth buffer bit
+ if (!isXrayCacheEmpty()) {
+ // Xray is enabled by disabling depth testing
+ GlStateManager.depthFunc(GL11.GL_ALWAYS)
+
+ entityRenderCache.xrayCache?.forEach { (key, value) ->
+ // Test if the entity should render, given the player's camera position
+ if (!shouldRender(camera, key, vector)) return@forEach
+
+ try {
+ if (key !is EntityLivingBase) outlineColor(value)
+ renderManager.renderEntityStatic(key, partialTicks, true)
+ } catch (ignored: Exception) {
+ }
+ }
+
+ // Reset depth function
+ GlStateManager.depthFunc(GL11.GL_LEQUAL)
+ }
+
+ // Render no-xray outlines second, taking into consideration the depth bit
+ if (!isNoXrayCacheEmpty()) {
+ if (!isNoOutlineCacheEmpty()) {
+ // Render other entities + terrain that may occlude an entity outline into a depth buffer
+ swapBuffer.framebufferClear()
+ copyBuffers(mc.framebuffer, swapBuffer, GL11.GL_DEPTH_BUFFER_BIT)
+ swapBuffer.bindFramebuffer(false)
+
+ // Copy terrain + other entities depth into outline frame buffer to now switch to no-xray outlines
+ entityRenderCache.noOutlineCache?.forEach { entity ->
+ // Test if the entity should render, given the player's instantaneous camera position
+ if (!shouldRender(camera, entity, vector)) return@forEach
+
+ try {
+ renderManager.renderEntityStatic(entity, partialTicks, true)
+ } catch (ignored: Exception) {
+ }
+ }
+
+ // Copy the entire depth buffer of everything that might occlude outline to outline framebuffer
+ copyBuffers(swapBuffer, renderGlobal.entityOutlineFramebuffer_skyhanni, GL11.GL_DEPTH_BUFFER_BIT)
+ renderGlobal.entityOutlineFramebuffer_skyhanni.bindFramebuffer(false)
+ } else {
+ copyBuffers(mc.framebuffer, renderGlobal.entityOutlineFramebuffer_skyhanni, GL11.GL_DEPTH_BUFFER_BIT)
+ }
+
+ // Xray disabled by re-enabling traditional depth testing
+ entityRenderCache.noXrayCache?.forEach { (key, value) ->
+ // Test if the entity should render, given the player's instantaneous camera position
+ if (!shouldRender(camera, key, vector)) return@forEach
+
+ try {
+ if (key !is EntityLivingBase) outlineColor(value)
+ renderManager.renderEntityStatic(key, partialTicks, true)
+ } catch (ignored: Exception) {
+ }
+ }
+ }
+
+ // Disable outline mode
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL11.GL_MODULATE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_SOURCE0_RGB, GL11.GL_TEXTURE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_OPERAND0_RGB, GL11.GL_SRC_COLOR);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_MODULATE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_SOURCE0_ALPHA, GL11.GL_TEXTURE);
+ GL11.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_OPERAND0_ALPHA, GL11.GL_SRC_ALPHA);
+
+ // Vanilla options
+ RenderHelper.enableStandardItemLighting()
+ mc.renderManager.setRenderOutlines(false)
+
+ // Load the outline shader
+ GlStateManager.depthMask(false)
+ renderGlobal.entityOutlineShader_skyhanni.loadShaderGroup(partialTicks)
+ GlStateManager.depthMask(true)
+
+ // Reset GL/framebuffers for next render layers
+ GlStateManager.enableLighting()
+ mc.framebuffer.bindFramebuffer(false)
+ GlStateManager.enableFog()
+ GlStateManager.enableBlend()
+ GlStateManager.enableColorMaterial()
+ GlStateManager.enableDepth()
+ GlStateManager.enableAlpha()
+
+ return !shouldRenderOutlines
+ }
+
+ @JvmStatic
+ fun getCustomOutlineColor(entity: Entity?): Int? {
+ if (entityRenderCache.xrayCache?.containsKey(entity) == true) {
+ return entityRenderCache.xrayCache!![entity]
+ }
+ return if (entityRenderCache.noXrayCache?.containsKey(entity) == true) {
+ entityRenderCache.noXrayCache!![entity]
+ } else null
+ }
+
+ /**
+ * Caches optifine settings and determines whether outlines should be rendered
+ *
+ * @return `true` iff outlines should be rendered
+ */
+ @JvmStatic
+ fun shouldRenderEntityOutlines(): Boolean {
+ val renderGlobal = mc.renderGlobal as CustomRenderGlobal
+
+ // Vanilla Conditions
+ if (renderGlobal.entityOutlineFramebuffer_skyhanni == null || renderGlobal.entityOutlineShader_skyhanni == null || mc.thePlayer == null) return false
+
+ // Skyblock Conditions
+ if (!LorenzUtils.inSkyBlock) {
+ return false
+ }
+
+ // Main toggle for outlines features
+ if (!config.enableEntityOutlines) {
+ return false
+ }
+
+ // Optifine Conditions
+ if (!stopLookingForOptifine && isFastRender == null) {
+ try {
+ val config = Class.forName("Config")
+ try {
+ isFastRender = config.getMethod("isFastRender")
+ isShaders = config.getMethod("isShaders")
+ isAntialiasing = config.getMethod("isAntialiasing")
+ } catch (ex: Exception) {
+ logger.log("Couldn't find Optifine methods for entity outlines.")
+ stopLookingForOptifine = true
+ }
+ } catch (ex: Exception) {
+ logger.log("Couldn't find Optifine for entity outlines.")
+ stopLookingForOptifine = true
+ }
+ }
+ var isFastRenderValue = false
+ var isShadersValue = false
+ var isAntialiasingValue = false
+ if (isFastRender != null) {
+ try {
+ isFastRenderValue = isFastRender!!.invoke(null) as Boolean
+ isShadersValue = isShaders!!.invoke(null) as Boolean
+ isAntialiasingValue = isAntialiasing!!.invoke(null) as Boolean
+ } catch (ex: IllegalAccessException) {
+ logger.log("An error occurred while calling Optifine methods for entity outlines... $ex")
+ } catch (ex: InvocationTargetException) {
+ logger.log("An error occurred while calling Optifine methods for entity outlines... $ex")
+ }
+ }
+ return !isFastRenderValue && !isShadersValue && !isAntialiasingValue
+ }
+
+ /**
+ * Apply the same rendering standards as in [net.minecraft.client.renderer.RenderGlobal.renderEntities] lines 659 to 669
+ *
+ * @param camera the current camera
+ * @param entity the entity to render
+ * @param x the camera x position
+ * @param y the camera y position
+ * @param z the camera z position
+ * @return whether the entity should be rendered
+ */
+ private fun shouldRender(camera: ICamera, entity: Entity, vector: LorenzVec): Boolean =
+ // Only render the view entity when sleeping or in 3rd person mode
+ if (entity === mc.renderViewEntity &&
+ !(mc.renderViewEntity is EntityLivingBase && (mc.renderViewEntity as EntityLivingBase).isPlayerSleeping ||
+ mc.gameSettings.thirdPersonView != 0)) {
+ false
+ } else mc.theWorld.isBlockLoaded(BlockPos(entity)) && (mc.renderManager.shouldRender(entity, camera, vector.x, vector.y, vector.z) || entity.riddenByEntity === mc.thePlayer)
+ // Only render if renderManager would render and the world is loaded at the entity
+
+ private fun outlineColor(color: Int) {
+ BUF_FLOAT_4.put(0, (color shr 16 and 255).toFloat() / 255.0f)
+ BUF_FLOAT_4.put(1, (color shr 8 and 255).toFloat() / 255.0f)
+ BUF_FLOAT_4.put(2, (color and 255).toFloat() / 255.0f)
+ BUF_FLOAT_4.put(3, 1f)
+ GL11.glTexEnv(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_COLOR, BUF_FLOAT_4)
+ }
+
+ /**
+ * Function that copies a portion of a framebuffer to another framebuffer.
+ *
+ *
+ * Note that this requires GL3.0 to function properly
+ *
+ *
+ * The major use of this function is to copy the depth-buffer portion of the world framebuffer to the entity outline framebuffer.
+ * This enables us to perform no-xray outlining on entities, as we can use the world framebuffer's depth testing on the outline frame buffer
+ *
+ * @param frameToCopy the framebuffer from which we are copying data
+ * @param frameToPaste the framebuffer onto which we are copying the data
+ * @param buffersToCopy the bit mask indicating the sections to copy (see [GL11.GL_DEPTH_BUFFER_BIT], [GL11.GL_COLOR_BUFFER_BIT], [GL11.GL_STENCIL_BUFFER_BIT])
+ */
+ private fun copyBuffers(frameToCopy: Framebuffer?, frameToPaste: Framebuffer?, buffersToCopy: Int) {
+ if (OpenGlHelper.isFramebufferEnabled()) {
+ OpenGlHelper.glBindFramebuffer(GL30.GL_READ_FRAMEBUFFER, frameToCopy!!.framebufferObject)
+ OpenGlHelper.glBindFramebuffer(GL30.GL_DRAW_FRAMEBUFFER, frameToPaste!!.framebufferObject)
+ GL30.glBlitFramebuffer(0, 0, frameToCopy.framebufferWidth, frameToCopy.framebufferHeight,
+ 0, 0, frameToPaste.framebufferWidth, frameToPaste.framebufferHeight,
+ buffersToCopy, GL11.GL_NEAREST)
+ }
+ }
+
+ fun isCacheEmpty() = isXrayCacheEmpty() && isNoXrayCacheEmpty()
+
+ private fun isXrayCacheEmpty() = entityRenderCache.xrayCache?.isEmpty() ?: true
+ private fun isNoXrayCacheEmpty() = entityRenderCache.noXrayCache?.isEmpty() ?: true
+ private fun isNoOutlineCacheEmpty() = entityRenderCache.noOutlineCache?.isEmpty() ?: true
+
+ /**
+ * Updates the cache at the start of every minecraft tick to improve efficiency.
+ * Identifies and caches all entities in the world that should be outlined.
+ *
+ *
+ * Calls to [.shouldRender] are frustum based, rely on partialTicks,
+ * and so can't be updated on a per-tick basis without losing information.
+ *
+ *
+ * This works since entities are only updated once per tick, so the inclusion or exclusion of an entity
+ * to be outlined can be cached each tick with no loss of data
+ *
+ * @param event the client tick event
+ */
+ @SubscribeEvent
+ fun onTick(event: LorenzTickEvent) {
+ if (event.phase == EventPriority.NORMAL) {
+ val rg = mc.renderGlobal as CustomRenderGlobal
+
+ if (mc.theWorld != null && shouldRenderEntityOutlines()) {
+ // These events need to be called in this specific order for the xray to have priority over the no xray
+ // Get all entities to render xray outlines
+ val xrayOutlineEvent = RenderEntityOutlineEvent(RenderEntityOutlineEvent.Type.XRAY, null)
+ MinecraftForge.EVENT_BUS.post(xrayOutlineEvent)
+ // Get all entities to render no xray outlines, using pre-filtered entities (no need to test xray outlined entities)
+ val noxrayOutlineEvent = RenderEntityOutlineEvent(RenderEntityOutlineEvent.Type.NO_XRAY, xrayOutlineEvent.entitiesToChooseFrom)
+ MinecraftForge.EVENT_BUS.post(noxrayOutlineEvent)
+ // Cache the entities for future use
+ entityRenderCache.xrayCache = xrayOutlineEvent.entitiesToOutline
+ entityRenderCache.noXrayCache = noxrayOutlineEvent.entitiesToOutline
+ entityRenderCache.noOutlineCache = noxrayOutlineEvent.entitiesToChooseFrom
+ emptyLastTick = if (isCacheEmpty()) {
+ if (!emptyLastTick) {
+ rg.entityOutlineFramebuffer_skyhanni.framebufferClear()
+ }
+ true
+ } else {
+ false
+ }
+ } else if (!emptyLastTick) {
+ entityRenderCache.xrayCache = null
+ entityRenderCache.noXrayCache = null
+ entityRenderCache.noOutlineCache = null
+ if (rg.entityOutlineFramebuffer_skyhanni != null) rg.entityOutlineFramebuffer_skyhanni.framebufferClear()
+ emptyLastTick = true
+ }
+ }
+ }
+
+ private class CachedInfo(var xrayCache: HashMap<Entity, Int>?, var noXrayCache: HashMap<Entity, Int>?, var noOutlineCache: HashSet<Entity>?)
+}
\ No newline at end of file diff --git a/src/main/resources/mixins.skyhanni.json b/src/main/resources/mixins.skyhanni.json index ed342797f..3982dd3c8 100644 --- a/src/main/resources/mixins.skyhanni.json +++ b/src/main/resources/mixins.skyhanni.json @@ -12,6 +12,8 @@ "MixinItemStack", "MixinNetHandlerPlayClient", "MixinNetworkManager", + "MixinRenderGlobal", + "MixinRendererLivingEntity", "MixinRenderItem", "MixinRenderManager", "gui.AccessorGuiContainer", @@ -20,6 +22,7 @@ ], "client": [ "AccessorKeyBinding", + "CustomRenderGlobal", "MixinEntityRenderer", "MixinGuiChat", "MixinGuiIngame", |