
# Eagler Context Redacted Diff
# Copyright (c) 2024 lax1dude. All rights reserved.

# Version: 1.0
# Author: lax1dude

> DELETE  2  @  2 : 5

> INSERT  1 : 2  @  1

+ import java.util.Collection;

> INSERT  6 : 20  @  6

+ 
+ import com.google.common.collect.Lists;
+ import com.google.common.collect.Maps;
+ 
+ import net.lax1dude.eaglercraft.v1_8.HString;
+ import net.lax1dude.eaglercraft.v1_8.internal.IFramebufferGL;
+ import net.lax1dude.eaglercraft.v1_8.log4j.LogManager;
+ import net.lax1dude.eaglercraft.v1_8.log4j.Logger;
+ import net.lax1dude.eaglercraft.v1_8.minecraft.EaglerTextureAtlasSprite;
+ import net.lax1dude.eaglercraft.v1_8.opengl.EaglercraftGPU;
+ import net.lax1dude.eaglercraft.v1_8.opengl.GlStateManager;
+ import net.lax1dude.eaglercraft.v1_8.opengl.ImageData;
+ import net.lax1dude.eaglercraft.v1_8.opengl.ext.deferred.texture.EaglerTextureAtlasSpritePBR;
+ import net.lax1dude.eaglercraft.v1_8.opengl.ext.deferred.texture.PBRTextureMapUtils;

> DELETE  2  @  2 : 8

> DELETE  9  @  9 : 11

> INSERT  1 : 3  @  1

+ import static net.lax1dude.eaglercraft.v1_8.internal.PlatformOpenGL.*;
+ 

> CHANGE  4 : 7  @  4 : 7

~ 	private final List<EaglerTextureAtlasSprite> listAnimatedSprites;
~ 	private final Map<String, EaglerTextureAtlasSprite> mapRegisteredSprites;
~ 	private final Map<String, EaglerTextureAtlasSprite> mapUploadedSprites;

> CHANGE  3 : 10  @  3 : 4

~ 	private final EaglerTextureAtlasSprite missingImage;
~ 	private final EaglerTextureAtlasSpritePBR missingImagePBR;
~ 	private int width;
~ 	private int height;
~ 	private boolean isEaglerPBRMode = false;
~ 	public int eaglerPBRMaterialTexture = -1;
~ 	private boolean hasAllocatedEaglerPBRMaterialTexture = false;

> INSERT  1 : 7  @  1

+ 	public static final int _GL_FRAMEBUFFER = 0x8D40;
+ 	public static final int _GL_COLOR_ATTACHMENT0 = 0x8CE0;
+ 
+ 	private IFramebufferGL[] copyColorFramebuffer = null;
+ 	private IFramebufferGL[] copyMaterialFramebuffer = null;
+ 

> CHANGE  8 : 10  @  8 : 9

~ 		this.missingImage = new EaglerTextureAtlasSprite("missingno");
~ 		this.missingImagePBR = new EaglerTextureAtlasSpritePBR("missingno");

> INSERT  11 : 27  @  11

+ 		this.missingImagePBR.setIconWidth(16);
+ 		this.missingImagePBR.setIconHeight(16);
+ 		int[][][] aint2 = new int[3][this.mipmapLevels + 1][];
+ 		aint2[0][0] = aint;
+ 		int[] missingNormals = new int[256];
+ 		for (int i = 0; i < missingNormals.length; ++i) {
+ 			missingNormals[i] = 0xFF7F7F;
+ 		}
+ 		aint2[1][0] = missingNormals;
+ 		int[] missingMaterial = new int[256];
+ 		for (int i = 0; i < missingMaterial.length; ++i) {
+ 			missingMaterial[i] = 0x00000077;
+ 		}
+ 		aint2[2][0] = missingMaterial;
+ 		this.missingImagePBR.setFramesTextureDataPBR(new List[] { Lists.newArrayList(new int[][][] { aint2[0] }),
+ 				Lists.newArrayList(new int[][][] { aint2[1] }), Lists.newArrayList(new int[][][] { aint2[2] }) });

> DELETE  6  @  6 : 7

> INSERT  3 : 4  @  3

+ 		destroyAnimationCaches();

> INSERT  7 : 27  @  7

+ 	public void deleteGlTexture() {
+ 		super.deleteGlTexture();
+ 		if (eaglerPBRMaterialTexture != -1) {
+ 			GlStateManager.deleteTexture(eaglerPBRMaterialTexture);
+ 			eaglerPBRMaterialTexture = -1;
+ 		}
+ 		if (copyColorFramebuffer != null) {
+ 			for (int i = 0; i < copyColorFramebuffer.length; ++i) {
+ 				_wglDeleteFramebuffer(copyColorFramebuffer[i]);
+ 			}
+ 			copyColorFramebuffer = null;
+ 		}
+ 		if (copyMaterialFramebuffer != null) {
+ 			for (int i = 0; i < copyMaterialFramebuffer.length; ++i) {
+ 				_wglDeleteFramebuffer(copyMaterialFramebuffer[i]);
+ 			}
+ 			copyMaterialFramebuffer = null;
+ 		}
+ 	}
+ 

> INSERT  8 : 44  @  8

+ 		if (copyColorFramebuffer != null) {
+ 			for (int l = 0; l < copyColorFramebuffer.length; ++l) {
+ 				_wglDeleteFramebuffer(copyColorFramebuffer[l]);
+ 			}
+ 			copyColorFramebuffer = null;
+ 		}
+ 
+ 		if (isEaglerPBRMode) {
+ 			if (eaglerPBRMaterialTexture == -1) {
+ 				eaglerPBRMaterialTexture = GlStateManager.generateTexture();
+ 				hasAllocatedEaglerPBRMaterialTexture = false;
+ 			}
+ 			if (copyMaterialFramebuffer == null) {
+ 				GlStateManager.bindTexture(eaglerPBRMaterialTexture);
+ 				copyMaterialFramebuffer = new IFramebufferGL[this.mipmapLevels + 1];
+ 				for (int l = 0; l < copyMaterialFramebuffer.length; ++l) {
+ 					copyMaterialFramebuffer[l] = _wglCreateFramebuffer();
+ 					_wglBindFramebuffer(_GL_FRAMEBUFFER, copyMaterialFramebuffer[l]);
+ 					_wglFramebufferTexture2D(_GL_FRAMEBUFFER, _GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+ 							EaglercraftGPU.getNativeTexture(eaglerPBRMaterialTexture), l);
+ 				}
+ 				_wglBindFramebuffer(_GL_FRAMEBUFFER, null);
+ 			}
+ 		} else {
+ 			if (eaglerPBRMaterialTexture != -1) {
+ 				GlStateManager.deleteTexture(eaglerPBRMaterialTexture);
+ 				eaglerPBRMaterialTexture = -1;
+ 			}
+ 			if (copyMaterialFramebuffer != null) {
+ 				for (int l = 0; l < copyMaterialFramebuffer.length; ++l) {
+ 					_wglDeleteFramebuffer(copyMaterialFramebuffer[l]);
+ 				}
+ 				copyMaterialFramebuffer = null;
+ 			}
+ 		}
+ 

> CHANGE  1 : 2  @  1 : 2

~ 			EaglerTextureAtlasSprite textureatlassprite = (EaglerTextureAtlasSprite) entry.getValue();

> INSERT  3 : 108  @  3

+ 			if (isEaglerPBRMode) {
+ 				try {
+ 					IResource iresource = resourceManager.getResource(resourcelocation1);
+ 					ImageData[] abufferedimageColor = new ImageData[1 + this.mipmapLevels];
+ 					ImageData[] abufferedimageNormal = new ImageData[1 + this.mipmapLevels];
+ 					ImageData[] abufferedimageMaterial = new ImageData[1 + this.mipmapLevels];
+ 					abufferedimageColor[0] = TextureUtil.readBufferedImage(iresource.getInputStream());
+ 					abufferedimageNormal[0] = PBRTextureMapUtils.locateCompanionTexture(resourceManager, iresource,
+ 							"_n");
+ 					abufferedimageMaterial[0] = PBRTextureMapUtils.locateCompanionTexture(resourceManager, iresource,
+ 							"_s");
+ 					boolean dontAnimateNormals = false;
+ 					boolean dontAnimateMaterial = false;
+ 					if (abufferedimageNormal[0] == null) {
+ 						abufferedimageNormal[0] = PBRTextureMapUtils.defaultNormalsTexture;
+ 						dontAnimateNormals = true;
+ 					}
+ 					if (abufferedimageMaterial[0] == null) {
+ 						abufferedimageMaterial[0] = PBRTextureMapUtils.generateMaterialTextureFor(
+ 								((EaglerTextureAtlasSprite) (entry.getValue())).getIconName());
+ 						dontAnimateMaterial = true;
+ 					}
+ 					PBRTextureMapUtils.unifySizes(0, abufferedimageColor, abufferedimageNormal, abufferedimageMaterial);
+ 
+ 					TextureMetadataSection texturemetadatasection = (TextureMetadataSection) iresource
+ 							.getMetadata("texture");
+ 					if (texturemetadatasection != null) {
+ 						List list = texturemetadatasection.getListMipmaps();
+ 						if (!list.isEmpty()) {
+ 							int l = abufferedimageColor[0].width;
+ 							int i1 = abufferedimageColor[0].height;
+ 							if (MathHelper.roundUpToPowerOfTwo(l) != l || MathHelper.roundUpToPowerOfTwo(i1) != i1) {
+ 								throw new RuntimeException(
+ 										"Unable to load extra miplevels, source-texture is not power of two");
+ 							}
+ 						}
+ 
+ 						Iterator iterator = list.iterator();
+ 
+ 						while (iterator.hasNext()) {
+ 							int i2 = ((Integer) iterator.next()).intValue();
+ 							if (i2 > 0 && i2 < abufferedimageColor.length - 1 && abufferedimageColor[i2] == null) {
+ 								ResourceLocation resourcelocation2 = this.completeResourceLocation(resourcelocation,
+ 										i2);
+ 
+ 								try {
+ 									IResource mipLevelResource = resourceManager.getResource(resourcelocation2);
+ 									abufferedimageColor[i2] = TextureUtil
+ 											.readBufferedImage(mipLevelResource.getInputStream());
+ 									abufferedimageNormal[i2] = PBRTextureMapUtils
+ 											.locateCompanionTexture(resourceManager, mipLevelResource, "_n");
+ 									abufferedimageMaterial[i2] = PBRTextureMapUtils
+ 											.locateCompanionTexture(resourceManager, mipLevelResource, "_s");
+ 									if (abufferedimageNormal[i2] == null) {
+ 										abufferedimageNormal[i2] = PBRTextureMapUtils.defaultNormalsTexture;
+ 									}
+ 									if (abufferedimageMaterial[i2] == null) {
+ 										abufferedimageMaterial[i2] = PBRTextureMapUtils.generateMaterialTextureFor(
+ 												((EaglerTextureAtlasSprite) (entry.getValue())).getIconName());
+ 									}
+ 									PBRTextureMapUtils.unifySizes(i2, abufferedimageColor, abufferedimageNormal,
+ 											abufferedimageMaterial);
+ 									if ((abufferedimageColor[0].width >> i2) != abufferedimageColor[i2].width) {
+ 										throw new IOException("Mipmap level " + i2 + " is the wrong size, should be "
+ 												+ (abufferedimageColor[0].width >> i2) + " pixels");
+ 									}
+ 								} catch (Throwable exc) {
+ 									logger.error("Unable to load miplevel {} from: {}", i2, resourcelocation2);
+ 									logger.error(exc);
+ 								}
+ 							}
+ 						}
+ 					}
+ 
+ 					AnimationMetadataSection animationmetadatasection = (AnimationMetadataSection) iresource
+ 							.getMetadata("animation");
+ 					textureatlassprite.loadSpritePBR(
+ 							new ImageData[][] { abufferedimageColor, abufferedimageNormal, abufferedimageMaterial },
+ 							animationmetadatasection, dontAnimateNormals, dontAnimateMaterial);
+ 				} catch (RuntimeException runtimeexception) {
+ 					logger.error("Unable to parse metadata from " + resourcelocation1);
+ 					logger.error(runtimeexception);
+ 					continue;
+ 				} catch (IOException ioexception1) {
+ 					logger.error("Using missing texture, unable to load " + resourcelocation1);
+ 					logger.error(ioexception1);
+ 					continue;
+ 				}
+ 
+ 				j = Math.min(j, Math.min(textureatlassprite.getIconWidth(), textureatlassprite.getIconHeight()));
+ 				int l1 = Math.min(Integer.lowestOneBit(textureatlassprite.getIconWidth()),
+ 						Integer.lowestOneBit(textureatlassprite.getIconHeight()));
+ 				if (l1 < k) {
+ 					logger.warn("Texture {} with size {}x{} limits mip level from {} to {}",
+ 							new Object[] { resourcelocation1, Integer.valueOf(textureatlassprite.getIconWidth()),
+ 									Integer.valueOf(textureatlassprite.getIconHeight()),
+ 									Integer.valueOf(MathHelper.calculateLogBaseTwo(k)),
+ 									Integer.valueOf(MathHelper.calculateLogBaseTwo(l1)) });
+ 					k = l1;
+ 				}
+ 
+ 				stitcher.addSprite(textureatlassprite);
+ 				continue;
+ 			}
+ 

> CHANGE  2 : 3  @  2 : 3

~ 				ImageData[] abufferedimage = new ImageData[1 + this.mipmapLevels];

> CHANGE  6 : 8  @  6 : 8

~ 						int l = abufferedimage[0].width;
~ 						int i1 = abufferedimage[0].height;

> CHANGE  18 : 20  @  18 : 19

~ 										new Object[] { Integer.valueOf(i2), resourcelocation2 });
~ 								logger.error(ioexception);

> CHANGE  9 : 11  @  9 : 10

~ 				logger.error("Unable to parse metadata from " + resourcelocation1);
~ 				logger.error(runtimeexception);

> CHANGE  2 : 4  @  2 : 3

~ 				logger.error("Using missing texture, unable to load " + resourcelocation1);
~ 				logger.error(ioexception1);

> CHANGE  26 : 27  @  26 : 27

~ 		for (final EaglerTextureAtlasSprite textureatlassprite1 : this.mapRegisteredSprites.values()) {

> CHANGE  25 : 32  @  25 : 27

~ 		if (isEaglerPBRMode) {
~ 			this.missingImagePBR.generateMipmaps(this.mipmapLevels);
~ 			stitcher.addSprite(this.missingImagePBR);
~ 		} else {
~ 			this.missingImage.generateMipmaps(this.mipmapLevels);
~ 			stitcher.addSprite(this.missingImage);
~ 		}

> INSERT  9 : 10  @  9

+ 		regenerateIfNotAllocated();

> INSERT  2 : 23  @  2

+ 		if (isEaglerPBRMode) {
+ 			if (hasAllocatedEaglerPBRMaterialTexture) {
+ 				EaglercraftGPU.regenerateTexture(eaglerPBRMaterialTexture);
+ 			}
+ 			hasAllocatedEaglerPBRMaterialTexture = true;
+ 			TextureUtil.allocateTextureImpl(eaglerPBRMaterialTexture, this.mipmapLevels, stitcher.getCurrentWidth(),
+ 					stitcher.getCurrentHeight() * 2);
+ 		}
+ 
+ 		TextureUtil.bindTexture(this.glTextureId);
+ 
+ 		copyColorFramebuffer = new IFramebufferGL[this.mipmapLevels + 1];
+ 		for (int l = 0; l < copyColorFramebuffer.length; ++l) {
+ 			copyColorFramebuffer[l] = _wglCreateFramebuffer();
+ 			_wglBindFramebuffer(_GL_FRAMEBUFFER, copyColorFramebuffer[l]);
+ 			_wglFramebufferTexture2D(_GL_FRAMEBUFFER, _GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+ 					EaglercraftGPU.getNativeTexture(this.glTextureId), l);
+ 		}
+ 
+ 		_wglBindFramebuffer(_GL_FRAMEBUFFER, null);
+ 

> CHANGE  2 : 8  @  2 : 3

~ 		width = stitcher.getCurrentWidth();
~ 		height = stitcher.getCurrentHeight();
~ 
~ 		List<EaglerTextureAtlasSprite> spriteList = stitcher.getStichSlots();
~ 		for (int l = 0, m = spriteList.size(); l < m; ++l) {
~ 			EaglerTextureAtlasSprite textureatlassprite2 = spriteList.get(l);

> INSERT  5 : 6  @  5

+ 				TextureUtil.bindTexture(this.glTextureId);

> INSERT  3 : 13  @  3

+ 				if (isEaglerPBRMode) {
+ 					TextureUtil.bindTexture(eaglerPBRMaterialTexture);
+ 					int[][][] pixels = ((EaglerTextureAtlasSpritePBR) textureatlassprite2).getFramePBRTextureData(0);
+ 					TextureUtil.uploadTextureMipmap(pixels[1], textureatlassprite2.getIconWidth(),
+ 							textureatlassprite2.getIconHeight(), textureatlassprite2.getOriginX(),
+ 							textureatlassprite2.getOriginY(), false, false);
+ 					TextureUtil.uploadTextureMipmap(pixels[2], textureatlassprite2.getIconWidth(),
+ 							textureatlassprite2.getIconHeight(), textureatlassprite2.getOriginX(),
+ 							textureatlassprite2.getOriginY() + height, false, false);
+ 				}

> CHANGE  13 : 14  @  13 : 14

~ 		for (EaglerTextureAtlasSprite textureatlassprite3 : (Collection<EaglerTextureAtlasSprite>) hashmap.values()) {

> INSERT  3 : 4  @  3

+ 		_wglBindFramebuffer(_GL_FRAMEBUFFER, null);

> CHANGE  5 : 7  @  5 : 7

~ 						HString.format("%s/%s%s", new Object[] { this.basePath, location.getResourcePath(), ".png" }))
~ 				: new ResourceLocation(location.getResourceDomain(), HString.format("%s/mipmaps/%s.%d%s",

> CHANGE  3 : 5  @  3 : 5

~ 	public EaglerTextureAtlasSprite getAtlasSprite(String iconName) {
~ 		EaglerTextureAtlasSprite textureatlassprite = (EaglerTextureAtlasSprite) this.mapUploadedSprites.get(iconName);

> CHANGE  1 : 2  @  1 : 2

~ 			textureatlassprite = isEaglerPBRMode ? missingImagePBR : missingImage;

> CHANGE  6 : 14  @  6 : 7

~ 		if (isEaglerPBRMode) {
~ 			for (int i = 0, l = this.listAnimatedSprites.size(); i < l; ++i) {
~ 				this.listAnimatedSprites.get(i).updateAnimationPBR(copyColorFramebuffer, copyMaterialFramebuffer,
~ 						height);
~ 			}
~ 			_wglBindFramebuffer(_GL_FRAMEBUFFER, null);
~ 			return;
~ 		}

> CHANGE  1 : 3  @  1 : 3

~ 		for (int i = 0, l = this.listAnimatedSprites.size(); i < l; ++i) {
~ 			this.listAnimatedSprites.get(i).updateAnimation(copyColorFramebuffer);

> INSERT  2 : 3  @  2

+ 		_wglBindFramebuffer(_GL_FRAMEBUFFER, null);

> CHANGE  2 : 9  @  2 : 3

~ 	private void destroyAnimationCaches() {
~ 		for (int i = 0, l = this.listAnimatedSprites.size(); i < l; ++i) {
~ 			this.listAnimatedSprites.get(i).clearFramesTextureData();
~ 		}
~ 	}
~ 
~ 	public EaglerTextureAtlasSprite registerSprite(ResourceLocation location) {

> CHANGE  3 : 5  @  3 : 4

~ 			EaglerTextureAtlasSprite textureatlassprite = (EaglerTextureAtlasSprite) this.mapRegisteredSprites
~ 					.get(location);

> CHANGE  1 : 6  @  1 : 2

~ 				if (isEaglerPBRMode) {
~ 					textureatlassprite = EaglerTextureAtlasSpritePBR.makeAtlasSprite(location);
~ 				} else {
~ 					textureatlassprite = EaglerTextureAtlasSprite.makeAtlasSprite(location);
~ 				}

> CHANGE  15 : 17  @  15 : 17

~ 	public EaglerTextureAtlasSprite getMissingSprite() {
~ 		return isEaglerPBRMode ? missingImagePBR : missingImage;

> INSERT  1 : 23  @  1

+ 
+ 	public int getWidth() {
+ 		return width;
+ 	}
+ 
+ 	public int getHeight() {
+ 		return height;
+ 	}
+ 
+ 	public void setEnablePBREagler(boolean enable) {
+ 		isEaglerPBRMode = enable;
+ 	}
+ 
+ 	public void setBlurMipmapDirect0(boolean parFlag, boolean parFlag2) {
+ 		super.setBlurMipmapDirect0(parFlag, parFlag2);
+ 		if (isEaglerPBRMode && eaglerPBRMaterialTexture != -1) {
+ 			GlStateManager.setActiveTexture(33986);
+ 			GlStateManager.bindTexture(eaglerPBRMaterialTexture);
+ 			super.setBlurMipmapDirect0(parFlag, parFlag2);
+ 			GlStateManager.setActiveTexture(33984);
+ 		}
+ 	}

> EOF
