Moves CapturingTesselator, JSON Models, and misc utility classes to GTNHlib (#587)

* Moves CapturingTesselator, JSON Models, and misc utility classes to GTNHlib
* Switch to separate source set for mixins - faster incremental builds
This commit is contained in:
Jason Mitchell authored and GitHub committed 2024-08-04 15:41:58 -07:00
1 parent 1315d8971a
commit 558ea0fe12
404 files changed
+631 -5190

No files matched your search

@@ -15,7 +15,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
name = "Angelica",
version = Tags.VERSION,
dependencies = " before:lwjgl3ify@[1.5.3,);" + " after:hodgepodge@[2.4.4,);" + " after:CodeChickenCore@[1.2.0,);"
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.3.2,);",
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.4.0,);",
acceptedMinecraftVersions = "[1.7.10]",
acceptableRemoteVersions = "*",
guiFactory = "com.gtnewhorizons.angelica.config.AngelicaGuiConfigFactory")
@@ -1,10 +0,0 @@
- [x] Frustum (Seems related to Frustrum)
- [X] NativeImage
- [ ] PoseStack
- [ ] RenderType
- [ ] MultiBufferSource.BufferSource
- [ ] VertexBuffer
- [ ] VertexConsumer
- [ ] VertextFormat
- [ ] TextureAtlas (Seems related to TextureManager) - PBR related
- [ ] GUI
@@ -1,19 +0,0 @@
package com.gtnewhorizons.angelica.api;
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import net.minecraftforge.common.util.ForgeDirection;
public interface BlockPos {
int getX();
int getY();
int getZ();
BlockPosImpl offset(ForgeDirection d);
BlockPosImpl down();
BlockPosImpl up();
long asLong();
static long asLong(int x, int y, int z) {
return CoordinatePacker.pack(x, y, z);
}
}
@@ -1,122 +0,0 @@
package com.gtnewhorizons.angelica.api;
import com.google.common.annotations.Beta;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import com.gtnewhorizons.angelica.models.json.JsonModel;
import com.gtnewhorizons.angelica.utils.Callback;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.util.ResourceLocation;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* Model loading is as follows: <ul>
* <li>Models to load are registered in PREINIT or INIT. See {@link #registerModels(Callback, Collection)}.</li>
* <li>A resource rebuild is triggered, then registered models and their parents are recursively loaded in POSTINIT.
* </li>
* <li>Models registered for baking are baked on the first client tick.</li>
*</ul>
* <p>As for icons, register them in {@link Block#registerBlockIcons}. Whatever gets them in the block texture atlas.
*/
@Beta
public class ModelLoader {
private static final Gson GSON = new GsonBuilder()
.registerTypeAdapter(JsonModel.class, new JsonModel.Deserializer()).create();
private static final List<ResourceLocation> unloadedModels = new ObjectArrayList<>();
private static final Map<ResourceLocation, JsonModel> loadedModels = new Object2ObjectOpenHashMap<>();
private static final Map<Variant, JsonModel> modelsToBake = new Object2ObjectOpenHashMap<>();
private static final List<Callback> postBakeCallbacks = new ObjectArrayList<>();
/**
* Convenience method to register a baker callback, which will be run after JSON models are baked. Useful if
* you implemented your own non-JSON model that still needs baking.
*/
public static void registerBaker(Callback baker) {
postBakeCallbacks.add(baker);
}
/**
* Convenience method to register multiple variants. See {@link #registerModels(Callback, Collection)}.
*/
public static void registerModels(Callback loader, Variant... variants) {
registerModels(loader, Arrays.asList(variants));
}
/**
* Pass the variant(s) you want to load, and if needed a callback which puts the models in a useful place, e.g.
* saving them to a static field after baking.
*/
public static void registerModels(Callback loader, Collection<Variant> variants) {
for (Variant v : variants) {
unloadedModels.add(v.getModel());
modelsToBake.put(v, null);
}
postBakeCallbacks.add(loader);
}
public static void loadModels() {
for (ResourceLocation l : unloadedModels) {
if (l == null) continue;
if (loadedModels.containsKey(l)) continue;
final JsonModel model = loadJson(l, JsonModel.class);
unloadedModels.addAll(model.getParents());
loadedModels.put(l, model);
}
}
private static <T> T loadJson(ResourceLocation path, Class<T> clazz) {
try {
final InputStream is = Minecraft.getMinecraft().getResourceManager().getResource(path).getInputStream();
return GSON.fromJson(new InputStreamReader(is), clazz);
} catch (IOException e) {
AngelicaTweaker.LOGGER.fatal("Could not find " + path.getResourceDomain() + " " + path.getResourcePath());
throw new RuntimeException(e);
}
}
public static void bakeModels() {
for (Map.Entry<Variant, JsonModel> l : modelsToBake.entrySet()) {
final JsonModel dough = new JsonModel(loadedModels.get(l.getKey().getModel()));
// Resolve the parent chain
//noinspection SuspiciousMethodCalls
dough.resolveParents(loadedModels::get);
// Bake
dough.bake(l.getKey());
l.setValue(dough);
}
for (Callback c : postBakeCallbacks)
c.run();
}
public static QuadProvider getModel(Variant loc) {
return modelsToBake.get(loc);
}
}
@@ -1,8 +0,0 @@
package com.gtnewhorizons.angelica.api;
public interface MutableBlockPos extends BlockPos {
MutableBlockPos set(int x, int y, int z);
MutableBlockPos set(long packedPos);
}
@@ -1,233 +0,0 @@
package com.gtnewhorizons.angelica.api;
import com.gtnewhorizons.angelica.models.NdQuadBuilder;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadViewMutable;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
public interface QuadBuilder {
/**
* Causes texture to appear with no rotation.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_ROTATE_NONE = 0;
/**
* Causes texture to appear rotated 90 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_ROTATE_90 = 1;
/**
* Causes texture to appear rotated 180 deg. relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_ROTATE_180 = 2;
/**
* Causes texture to appear rotated 270 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_ROTATE_270 = 3;
/**
* When enabled, texture coordinate are assigned based on vertex position.
* Any existing UV coordinates will be replaced.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*
* <p>UV lock always derives texture coordinates based on nominal face, even
* when the quad is not co-planar with that face, and the result is
* the same as if the quad were projected onto the nominal face, which
* is usually the desired result.
*/
int BAKE_LOCK_UV = 4;
/**
* When set, U texture coordinates for the given sprite are
* flipped as part of baking. Can be useful for some randomization
* and texture mapping scenarios. Results are different from what
* can be obtained via rotation and both can be applied.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_FLIP_U = 8;
/**
* Same as {@link #BAKE_FLIP_U} but for V coordinate.
*/
int BAKE_FLIP_V = 16;
/**
* UV coordinates by default are assumed to be 0-16 scale for consistency
* with conventional Minecraft model format. This is scaled to 0-1 during
* baking before interpolation. Model loaders that already have 0-1 coordinates
* can avoid wasteful multiplication/division by passing 0-1 coordinates directly.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
int BAKE_NORMALIZED = 32;
/**
* Tolerance for determining if the depth parameter to {@link #square(ForgeDirection, float, float, float, float, float)}
* is effectively zero - meaning the face is a cull face.
*/
float CULL_FACE_EPSILON = 0.00001f;
static QuadBuilder getBuilder() {
return new NdQuadBuilder();
}
/**
* Copies data to out, returns it, and resets builder for further use.
*/
QuadView build(QuadView out);
/**
* See {@link #build(QuadView)}. This also rotates the output by the given matrix.
*/
QuadView build(QuadView out, Matrix4f rotMat);
/**
* Tries to automatically set the culling and nominal face from the quad's geometry.
*/
void setCullFace();
/**
* Provides a hint to renderer about the facing of this quad. Not required,
* but if provided can shortcut some geometric analysis if the quad is parallel to a block face.
* Should be the expected value of {@link ModelQuadView#getLightFace()}. Value will be confirmed
* and if invalid the correct light face will be calculated.
*
* <p>Null by default, and set automatically by {@link ModelQuadViewMutable#setCullFace(ForgeDirection)}.
*
* <p>Models may also find this useful as the face for texture UV locking and rotation semantics.
*
* <p>Note: This value is not persisted independently when the quad is encoded.
* When reading encoded quads, this value will always be the same as {@link ModelQuadView#getLightFace()}.
*/
void nominalFace(@Nullable ForgeDirection face);
/**
* See {@link #nominalFace(ForgeDirection)}
*/
ForgeDirection nominalFace();
/**
* Sets the geometric vertex position for the given vertex,
* relative to block origin, (0,0,0). Minecraft rendering is designed
* for models that fit within a single block space and is recommended
* that coordinates remain in the 0-1 range, with multi-block meshes
* split into multiple per-block models.
*/
void pos(int vertexIndex, float x, float y, float z);
/**
* Convenience: set pos with a vector. See {@link #pos(int, float, float, float)}.
*/
void pos(int vertexIndex, Vector3f vec);
/**
* Gets the vertex position as a vector. This allocates a new vector, do not use in dynamic rendering!
*/
Vector3f pos(int vertexIndex);
/**
* Convenience: access x, y, z by index 0-2.
*/
float posByIndex(int vertexIndex, int coordinateIndex);
/**
* Convienence, gets the icon from the block atlas. See {@link #spriteBake(IIcon, int)}
*/
void spriteBake(String spriteName, int bakeFlags);
/**
* Assigns sprite atlas u,v coordinates to this quad for the given sprite.
* Can handle UV locking, rotation, interpolation, etc. Control this behavior
* by passing additive combinations of the BAKE_ flags defined in this interface.
*/
void spriteBake(IIcon sprite, int bakeFlags);
/**
* Helper method to assign vertex coordinates for a square aligned with the given face.
* Ensures that vertex order is consistent with vanilla convention. (Incorrect order can
* lead to bad AO lighting unless enhanced lighting logic is available/enabled.)
*
* <p>Square will be parallel to the given face and coplanar with the face (and culled if the
* face is occluded) if the depth parameter is approximately zero. See {@link #CULL_FACE_EPSILON}.
*
* <p>All coordinates should be normalized (0-1).
*
* <p>The directions for the faces assume you're looking at them. For top and bottom, they assume you're looking north.
*/
void square(ForgeDirection nominalFace, float left, float bottom, float right, float top, float depth);
int tag();
/**
* Encodes an integer tag with this quad that can later be retrieved via
* {@link #tag()}. Useful for models that want to perform conditional
* transformation or filtering on static meshes.
*/
void tag(int tag);
/**
* Set texture coordinates.
*/
void uv(int vertexIndex, float u, float v);
/**
* Modern Minecraft uses magic arrays to do this without breaking AO. This is the same thing, but without arrays.
*/
static Vector3f mapSideToVertex(Vector3f from, Vector3f to, int index, ForgeDirection side) {
return switch (side) {
case DOWN -> switch (index) {
case 0 -> new Vector3f(from.x, from.y, to.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, from.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case UP -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, to.y, to.z);
case 2 -> new Vector3f(to.x, to.y, to.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case NORTH -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, from.z);
case 1 -> new Vector3f(to.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, from.z);
case 3 -> new Vector3f(from.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case SOUTH -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, to.z);
case 1 -> new Vector3f(from.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, to.z);
case 3 -> new Vector3f(to.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case WEST -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, to.z);
case 3 -> new Vector3f(from.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case EAST -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, to.z);
case 1 -> new Vector3f(to.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case UNKNOWN -> null;
};
}
}
@@ -1,49 +0,0 @@
package com.gtnewhorizons.angelica.api;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public interface QuadProvider {
int R_MASK = 0xFF << 16;
int G_MASK = 0xFF << 8;
int B_MASK = 0xFF;
/**
* Called once per block and returns the color packed as ABGR. If you want to vary colors within a block, just
* ignore the color passed into {@link #getQuads} and use your own function, don't override this. But if you only
* want to change color once per block, like vanilla leaves, override this. The default vanilla adapter is
* {@link #getDefaultColor}
*/
default int getColor(IBlockAccess world, BlockPos pos, Block block, int meta, Random random) {
return -1;
}
static int getDefaultColor(IBlockAccess world, BlockPos pos, Block block) {
final int cin = block.colorMultiplier(world, pos.getX(), pos.getY(), pos.getZ());
return (0xFF << 24) | ((cin & B_MASK) << 16) | (cin & G_MASK) | ((cin & R_MASK) >>> 16);
}
/**
* If you need to allocate new quads, set this to true. If true, the quads returned by {@link #getQuads} are
* recycled, and you should not keep a reference to them. Example: stone can return a static list every time, but a
* modded block which adds or removes quads based on location would need dynamic quads.
*/
default boolean isDynamic() {
return false;
}
/**
* Provide quads to render. If you need new quads, they should be obtained with the passed supplier and
* {@link #isDynamic} overridden to return true. If so, all quads in the list are recycled and references to them
* should not be kept.
*/
List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool);
}
@@ -1,28 +0,0 @@
package com.gtnewhorizons.angelica.api;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadViewMutable;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraftforge.common.util.ForgeDirection;
public interface QuadView extends ModelQuadViewMutable {
/**
* Allocates a new quad - use sparingly, and not at all in render paths if you can help it. We don't need another
* Malice Doors.
*/
static QuadView allocate() {
return new Quad();
}
boolean isShade();
boolean isDeleted();
ForgeDirection getFace();
QuadView copyFrom(QuadView src);
int[] getRawData();
/**
* Present for compatibility with the Tesselator, not recommended for general use.
*/
void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ);
}
@@ -1,34 +0,0 @@
package com.gtnewhorizons.angelica.api;
import com.google.common.annotations.Beta;
import lombok.Getter;
import net.minecraft.util.ResourceLocation;
import org.joml.Matrix4f;
import static java.lang.Math.toRadians;
@Beta
public class Variant {
@Getter
private final ResourceLocation model;
private final float x;
private final float y;
private final boolean uvLock;
public Variant(ResourceLocation model, int x, int y, boolean uvLock) {
this.model = model;
this.x = (float) toRadians(x);
this.y = (float) toRadians(y);
this.uvLock = uvLock;
}
public Matrix4f getAffineMatrix() {
return new Matrix4f()
.translation(-.5f, -.5f, -.5f)
.rotateLocalY(x)
.rotateLocalX(y)
.translateLocal(.5f, .5f, .5f);
}
}
@@ -20,8 +20,6 @@ import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;
import static org.lwjgl.opengl.GL11.*;
/**
* A batching replacement for {@code FontRenderer}
*
@@ -255,15 +253,15 @@ public class BatchingFontRenderer {
GLStateManager.enableTexture();
GLStateManager.enableAlphaTest();
GLStateManager.enableBlend();
GLStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
GLStateManager.glShadeModel(GL_FLAT);
GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
GLStateManager.glShadeModel(GL11.GL_FLAT);
glTexCoordPointer(2, 0, batchVtxTexCoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, batchVtxColors);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, 0, batchVtxPositions);
glEnableClientState(GL_VERTEX_ARRAY);
GL11.glTexCoordPointer(2, 0, batchVtxTexCoords);
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
GL11.glColorPointer(4, GL11.GL_UNSIGNED_BYTE, 0, batchVtxColors);
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
GL11.glVertexPointer(2, 0, batchVtxPositions);
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
// Use plain for loop to avoid allocations
@@ -285,12 +283,12 @@ public class BatchingFontRenderer {
}
batchIndices.limit(cmd.startVtx + cmd.idxCount);
batchIndices.position(cmd.startVtx);
glDrawElements(GL_TRIANGLES, batchIndices);
GL11.glDrawElements(GL11.GL_TRIANGLES, batchIndices);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
GL11.glDisableClientState(GL11.GL_COLOR_ARRAY);
GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);
if (isTextureEnabledBefore) {
GLStateManager.glEnable(GL11.GL_TEXTURE_2D);
@@ -1,247 +0,0 @@
package com.gtnewhorizons.angelica.client.renderer;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.glsm.stacks.Vector3dStack;
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
import cpw.mods.fml.relauncher.ReflectionHelper;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.List;
import static net.minecraft.util.MathHelper.clamp_int;
/*
* To be used in conjunction with the TessellatorManager
*
* Used to capture the quads generated by the Tessellator across multiple draw calls and make the quad
* list available for usage.
*
* NOTE: This will _not_ (currently) capture, integrate, or stop any GL calls made around the tessellator draw calls.
*
*/
@SuppressWarnings("unused")
public class CapturingTessellator extends Tessellator implements ITessellatorInstance {
// Access Transformers don't work on Forge Fields :rage:
private static final MethodHandle sRawBufferSize;
private static final MethodHandle gRawBufferSize;
private final BlockRenderer.Flags FLAGS = new BlockRenderer.Flags(true, true, true, true);
private final ObjectPooler<QuadView> quadBuf = new ObjectPooler<>(Quad::new);
private final List<QuadView> collectedQuads = new ObjectArrayList<>();
// Any offset we need to the Tesselator's offset!
private final BlockPosImpl offset = new BlockPosImpl();
private final Vector3dStack storedTranslation = new Vector3dStack();
public void setOffset(BlockPosImpl pos) {
this.offset.set(pos);
}
public void resetOffset() {
this.offset.zero();
}
static {
final Field rbs = ReflectionHelper.findField(Tessellator.class, "rawBufferSize");
rbs.setAccessible(true);
try {
sRawBufferSize = MethodHandles.lookup().unreflectSetter(rbs);
gRawBufferSize = MethodHandles.lookup().unreflectGetter(rbs);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public void setRawBufferSize(int size) {
try {
sRawBufferSize.invokeExact((Tessellator)this, size);
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
}
public int getRawBufferSize() {
try {
return (int) gRawBufferSize.invokeExact((Tessellator)this);
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
}
@Override
public int draw() {
// Adapted from Neodymium
FLAGS.hasBrightness = this.hasBrightness;
FLAGS.hasColor = this.hasColor;
FLAGS.hasNormals = this.hasNormals;
final int verticesPerPrimitive = this.drawMode == GL11.GL_QUADS ? 4 : 3;
for(int quadI = 0; quadI < this.vertexCount / verticesPerPrimitive; quadI++) {
final QuadView quad = quadBuf.getInstance();
quad.setState(this.rawBuffer, quadI * (verticesPerPrimitive * 8), FLAGS, this.drawMode, -offset.x, -offset.y, -offset.z);
if(quad.isDeleted()) {
quadBuf.releaseInstance(quad);
} else {
this.collectedQuads.add(quad);
}
}
final int i = this.rawBufferIndex * 4;
this.discard();
return i;
}
@Override
public void discard() {
isDrawing = false;
reset();
}
public List<QuadView> getQuads() {
return collectedQuads;
}
public void clearQuads() {
//noinspection ForLoopReplaceableByForEach
for(int i = 0; i < this.collectedQuads.size(); i++) {
this.quadBuf.releaseInstance(this.collectedQuads.get(i));
}
this.collectedQuads.clear();
}
public static ByteBuffer quadsToBuffer(List<QuadView> quads, VertexFormat format) {
if(!format.canWriteQuads()) {
throw new IllegalStateException("Vertex format has no quad writer: " + format);
}
final ByteBuffer byteBuffer = BufferUtils.createByteBuffer(format.getVertexSize() * quads.size() * 4);
// noinspection ForLoopReplaceableByForEach
for (int i = 0, quadsSize = quads.size(); i < quadsSize; i++) {
format.writeQuad(quads.get(i), byteBuffer);
}
byteBuffer.rewind();
return byteBuffer;
}
public void storeTranslation() {
storedTranslation.push();
this.storedTranslation.set(xOffset, yOffset, zOffset);
}
public void restoreTranslation() {
xOffset = storedTranslation.x;
yOffset = storedTranslation.y;
zOffset = storedTranslation.z;
storedTranslation.pop();
}
public static int createBrightness(int sky, int block) {
return sky << 20 | block << 4;
}
// API from newer MC
public CapturingTessellator pos(double x, double y, double z) {
ensureBuffer();
this.rawBuffer[this.rawBufferIndex + 0] = Float.floatToRawIntBits((float)(x + this.xOffset));
this.rawBuffer[this.rawBufferIndex + 1] = Float.floatToRawIntBits((float)(y + this.yOffset));
this.rawBuffer[this.rawBufferIndex + 2] = Float.floatToRawIntBits((float)(z + this.zOffset));
return this;
}
public CapturingTessellator tex(double u, double v) {
this.rawBuffer[this.rawBufferIndex + 3] = Float.floatToRawIntBits((float)u);
this.rawBuffer[this.rawBufferIndex + 4] = Float.floatToRawIntBits((float)v);
this.hasTexture = true;
return this;
}
public CapturingTessellator color(float red, float green, float blue, float alpha) {
return this.color((int)(red * 255.0F), (int)(green * 255.0F), (int)(blue * 255.0F), (int)(alpha * 255.0F));
}
public CapturingTessellator color(int red, int green, int blue, int alpha) {
if(this.isColorDisabled) return this;
red = clamp_int(red, 0, 255);
green = clamp_int(green, 0, 255);
blue = clamp_int(blue, 0, 255);
alpha = clamp_int(alpha, 0, 255);
final int color;
if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
color = alpha << 24 | blue << 16 | green << 8 | red;
} else {
color = red << 24 | green << 16 | blue << 8 | alpha;
}
this.rawBuffer[this.rawBufferIndex + 5] = color;
this.hasColor = true;
return this;
}
public CapturingTessellator normal(float x, float y, float z) {
final byte b0 = (byte)((int)(x * 127.0F));
final byte b1 = (byte)((int)(y * 127.0F));
final byte b2 = (byte)((int)(z * 127.0F));
this.rawBuffer[this.rawBufferIndex + 6] = b0 & 255 | (b1 & 255) << 8 | (b2 & 255) << 16;
this.hasNormals = true;
return this;
}
public CapturingTessellator lightmap(int skyLight, int blockLight) {
return brightness(createBrightness(skyLight, blockLight));
}
public CapturingTessellator brightness(int brightness) {
this.rawBuffer[this.rawBufferIndex + 7] = brightness;
this.hasBrightness = true;
return this;
}
public CapturingTessellator endVertex() {
this.rawBufferIndex += 8;
++this.vertexCount;
return this;
}
public void ensureBuffer() {
int rawBufferSize = getRawBufferSize();
if (rawBufferIndex >= rawBufferSize - 32) {
if (rawBufferSize == 0) {
rawBufferSize = 0x10000;
setRawBufferSize(rawBufferSize);
rawBuffer = new int[rawBufferSize];
} else {
rawBufferSize *= 2;
setRawBufferSize(rawBufferSize);
rawBuffer = Arrays.copyOf(rawBuffer, rawBufferSize);
}
}
}
}
@@ -1,11 +1,11 @@
package com.gtnewhorizons.angelica.common;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadProvider;
import com.gtnewhorizon.gtnhlib.client.renderer.util.DirectionUtil;
import com.gtnewhorizons.angelica.mixins.interfaces.ModeledBlock;
import com.gtnewhorizons.angelica.utils.AssetLoader;
import lombok.Getter;
import lombok.Setter;
import me.jellysquid.mods.sodium.common.util.DirectionUtil;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat;
import com.falsepattern.chunk.api.DataRegistry;
import com.gtnewhorizons.angelica.mixins.early.sodium.MixinExtendedBlockStorage;
import com.gtnewhorizons.angelica.mixins.interfaces.ExtendedBlockStorageAccessor;
import com.gtnewhorizons.angelica.mixins.interfaces.ExtendedNibbleArray;
import com.gtnewhorizons.neid.mixins.interfaces.IExtendedBlockStorageMixin;
@@ -19,7 +19,7 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
}
public ExtendedBlockStorageExt(Chunk chunk, ExtendedBlockStorage storage) {
super(((MixinExtendedBlockStorage) storage).getYBase(), storage.getSkylightArray() != null);
super(((ExtendedBlockStorageAccessor) storage).getYBase(), storage.getSkylightArray() != null);
if (ModStatus.isChunkAPILoaded) {
if (storage.getSkylightArray() != null) {
@@ -68,7 +68,7 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
copyNibbleArray((ExtendedNibbleArray) storage.getSkylightArray(), (ExtendedNibbleArray) this.getSkylightArray());
}
}
((MixinExtendedBlockStorage) this).setBlockRefCount(((MixinExtendedBlockStorage) storage).getBlockRefCount());
((ExtendedBlockStorageAccessor) this).setBlockRefCount(((ExtendedBlockStorageAccessor) storage).getBlockRefCount());
}
@@ -1,51 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
import net.minecraftforge.common.util.ForgeDirection;
public enum Axis {
X,
Y,
Z;
public static Axis fromDirection(ModelQuadFacing dir) {
return switch (dir) {
case DOWN, UP -> Y;
case NORTH, SOUTH -> Z;
case WEST, EAST -> X;
case UNASSIGNED -> null;
};
}
public static Axis fromDirection(ForgeDirection dir) {
return switch (dir) {
case DOWN, UP -> Y;
case NORTH, SOUTH -> Z;
case WEST, EAST -> X;
case UNKNOWN -> null;
};
}
public static Axis fromName(String dir) {
return switch (dir) {
case "y" -> Y;
case "z" -> Z;
case "x" -> X;
default -> null;
};
}
public enum Direction {
POSITIVE,
NEGATIVE;
public static Direction fromDirection(ForgeDirection dir) {
return switch (dir) {
case DOWN, NORTH, WEST -> NEGATIVE;
case UP, SOUTH, EAST -> POSITIVE;
case UNKNOWN -> null;
};
}
}
}
@@ -1,68 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
import com.gtnewhorizons.angelica.api.MutableBlockPos;
import net.minecraft.world.ChunkPosition;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3i;
// Should we keep this?
public class BlockPosImpl extends Vector3i implements MutableBlockPos {
public BlockPosImpl() {
super();
}
public BlockPosImpl(int x, int y, int z) {
super(x, y, z);
}
public BlockPosImpl(ChunkPosition chunkPosition) {
super(chunkPosition.chunkPosX, chunkPosition.chunkPosY, chunkPosition.chunkPosZ);
}
@Override
public int getX() {
return this.x;
}
@Override
public int getY() {
return this.y;
}
@Override
public int getZ() {
return this.z;
}
@Override
public BlockPosImpl offset(ForgeDirection d) {
return new BlockPosImpl(this.x + d.offsetX, this.y + d.offsetY, this.z + d.offsetZ);
}
@Override
public BlockPosImpl down() {
return offset(ForgeDirection.DOWN);
}
@Override
public BlockPosImpl up() {
return offset(ForgeDirection.UP);
}
@Override
public long asLong() {
return CoordinatePacker.pack(this.x, this.y, this.z);
}
@Override
public BlockPosImpl set(int x, int y, int z) {
super.set(x, y, z);
return this;
}
@Override
public BlockPosImpl set(long packedPos) {
CoordinatePacker.unpack(packedPos, this);
return this;
}
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import lombok.Getter;
import net.minecraft.client.Minecraft;
@@ -13,7 +14,7 @@ import org.joml.Vector4f;
@Getter
public class Camera {
final Vector3d pos = new Vector3d();
final BlockPosImpl blockPos = new BlockPosImpl();
final BlockPos blockPos = new BlockPos();
float pitch;
float yaw;
EntityLivingBase entity;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
import it.unimi.dsi.fastutil.ints.IntPriorityQueue;
import net.minecraftforge.common.util.ForgeDirection;
@@ -35,12 +36,12 @@ public class ChunkOcclusionDataBuilder {
}
private int openCount = 4096;
public void markClosed(BlockPosImpl pos) {
public void markClosed(BlockPos pos) {
this.closed.set(pack(pos), true);
--this.openCount;
}
private static int pack(BlockPosImpl pos) {
private static int pack(BlockPos pos) {
return pack(pos.getX() & 15, pos.getY() & 15, pos.getZ() & 15);
}
@@ -1,5 +1,7 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
// See if we can merge/mixin/extend ChunkCoordIntPair?
public class ChunkPos {
public static long INT_MASK = (1L << Integer.SIZE) - 1;
@@ -12,7 +14,7 @@ public class ChunkPos {
this.z = z;
}
public ChunkPos(BlockPosImpl pos) {
public ChunkPos(BlockPos pos) {
this.x = pos.getX() >> 4;
this.z = pos.getZ() >> 4;
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import org.joml.Vector3i;
// See if we can merge/mixin/extend ChunkPosition maybe?
@@ -19,7 +20,7 @@ public class ChunkSectionPos extends Vector3i {
return new ChunkSectionPos(x, y, z);
}
public static ChunkSectionPos from(BlockPosImpl pos) {
public static ChunkSectionPos from(BlockPos pos) {
return new ChunkSectionPos(getSectionCoord(pos.getX()), getSectionCoord(pos.getY()), getSectionCoord(pos.getZ()));
}
@@ -1,37 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement.Type;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormatElement.Usage;
import com.gtnewhorizons.angelica.compat.nd.writers.ItemVBOQuadWriter;
import com.gtnewhorizons.angelica.compat.nd.writers.PositionColorTextureQuadWriter;
import com.gtnewhorizons.angelica.compat.nd.writers.PositionQuadWriter;
import com.gtnewhorizons.angelica.compat.nd.writers.PositionTextureColorQuadWriter;
import com.gtnewhorizons.angelica.compat.nd.writers.PositionTextureQuadWriter;
public class DefaultVertexFormat {
public static final VertexFormatElement POSITION_ELEMENT = new VertexFormatElement(0, Type.FLOAT, Usage.POSITION, 3);
public static final VertexFormatElement COLOR_ELEMENT = new VertexFormatElement(0, Type.UBYTE, Usage.COLOR, 4);
public static final VertexFormatElement TEXTURE_ELEMENT = new VertexFormatElement(0, Type.FLOAT, Usage.UV, 2);
public static final VertexFormatElement LIGHT_ELEMENT = new VertexFormatElement(1, Type.SHORT, Usage.UV, 2);
// TODO: The overlay element index is wrong, need to find a 1.7.10 equivalent
public static final VertexFormatElement OVERLAY_ELEMENT = new VertexFormatElement(1, Type.SHORT, Usage.UV, 2);
public static final VertexFormatElement NORMAL_ELEMENT = new VertexFormatElement(0, Type.BYTE, Usage.NORMAL, 3);
public static final VertexFormatElement PADDING_ELEMENT = new VertexFormatElement(0, Type.BYTE, Usage.PADDING, 1);
public static final VertexFormat POSITION_TEXTURE_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build(), new ItemVBOQuadWriter());
public static final VertexFormat POSITION_COLOR_TEXTURE_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
public static final VertexFormat POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(OVERLAY_ELEMENT).add(LIGHT_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
public static final VertexFormat POSITION_TEXTURE_COLOR_LIGHT = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).add(LIGHT_ELEMENT).build());
public static final VertexFormat POSITION = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).build(), new PositionQuadWriter());
public static final VertexFormat POSITION_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).build());
public static final VertexFormat POSITION_COLOR_LIGHT = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(LIGHT_ELEMENT).build());
public static final VertexFormat POSITION_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).build(), new PositionTextureQuadWriter());
public static final VertexFormat POSITION_COLOR_TEXTURE = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).build(), new PositionColorTextureQuadWriter());
public static final VertexFormat POSITION_TEXTURE_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).build(), new PositionTextureColorQuadWriter());
public static final VertexFormat POSITION_COLOR_TEX_LIGHTMAP = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(COLOR_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).build());
public static final VertexFormat POSITION_TEXTURE_LIGHT_COLOR = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(LIGHT_ELEMENT).add(COLOR_ELEMENT).build());
public static final VertexFormat POSITION_TEXTURE_COLOR_NORMAL = new VertexFormat(new ImmutableList.Builder<VertexFormatElement>().add(POSITION_ELEMENT).add(TEXTURE_ELEMENT).add(COLOR_ELEMENT).add(NORMAL_ELEMENT).add(PADDING_ELEMENT).build());
}
@@ -1,82 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
public class VertexBuffer implements AutoCloseable {
private int id;
private int vertexCount;
private VertexFormat format;
private int drawMode;
public VertexBuffer() {
this.id = GL15.glGenBuffers();
}
public VertexBuffer(VertexFormat format, int drawMode) {
this();
this.format = format;
this.drawMode = drawMode;
}
public void bind() {
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, this.id);
}
public void unbind() {
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
}
public void upload(ByteBuffer buffer, int vertexCount) {
if (this.id == -1) return;
this.vertexCount = vertexCount;
this.bind();
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
this.unbind();
}
public VertexBuffer upload(ByteBuffer buffer) {
if(format == null) throw new IllegalStateException("No format specified for VBO upload");
upload(buffer, buffer.remaining() / format.getVertexSize());
return this;
}
public void close() {
if (this.id >= 0) {
GL15.glDeleteBuffers(this.id);
this.id = -1;
}
}
public void draw(FloatBuffer floatBuffer) {
GL11.glPushMatrix();
GL11.glLoadIdentity();
GL11.glMultMatrix(floatBuffer);
draw();
GL11.glPopMatrix();
}
public void draw() {
GL11.glDrawArrays(drawMode, 0, this.vertexCount);
}
public void setupState() {
if(format == null) throw new IllegalStateException("No format specified for VBO setup");
bind();
format.setupBufferState(0L);
}
public void cleanupState() {
format.clearBufferState();
unbind();
}
public void render() {
setupState();
draw();
cleanupState();
}
}
@@ -1,88 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import lombok.Getter;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.coderbot.iris.vertices.ImmediateState;
import net.coderbot.iris.vertices.IrisVertexFormats;
import java.nio.ByteBuffer;
import java.util.List;
public class VertexFormat {
@Getter
protected final ImmutableList<VertexFormatElement> elements;
protected final IntList offsets = new IntArrayList();
@Getter
protected final int vertexSize;
protected IWriteQuads quadWriter;
public VertexFormat(ImmutableList<VertexFormatElement> elements) {
this(elements, null);
}
public VertexFormat(ImmutableList<VertexFormatElement> elements, IWriteQuads quadWriter) {
this.elements = elements;
int i = 0;
for (VertexFormatElement element : elements) {
offsets.add(i);
i += element.getByteSize();
}
vertexSize = i;
this.quadWriter = quadWriter;
}
public void setupBufferState(long l) {
if (BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat() && ImmediateState.renderWithExtendedVertexFormat) {
if (this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL || this == DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP) {
IrisVertexFormats.TERRAIN.setupBufferState(l);
return;
} else if (this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL) {
IrisVertexFormats.ENTITY.setupBufferState(l);
return;
}
}
final int i = this.getVertexSize();
final List<VertexFormatElement> list = this.getElements();
final int listSize = list.size();
for(int j = 0; j < listSize; ++j) {
list.get(j).setupBufferState(l + this.offsets.getInt(j), i);
}
}
public void clearBufferState() {
if (BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat() && ImmediateState.renderWithExtendedVertexFormat) {
if (this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL || this == DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP) {
IrisVertexFormats.TERRAIN.clearBufferState();
return;
} else if ( this == DefaultVertexFormat.POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL) {
IrisVertexFormats.ENTITY.clearBufferState();
return;
}
}
final List<VertexFormatElement> list = this.getElements();
final int listSize = list.size();
for(int i = 0 ; i < listSize; ++i) {
list.get(i).clearBufferState();
}
}
public boolean canWriteQuads() {
return quadWriter != null;
}
public void writeQuad(QuadView quad, ByteBuffer byteBuffer) {
if(quadWriter == null) {
throw new IllegalStateException("No quad writer set");
}
quadWriter.writeQuad(quad, byteBuffer);
}
}
@@ -1,107 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import lombok.Getter;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;
import org.lwjgl.opengl.GL20;
import java.util.function.IntConsumer;
@Getter
public class VertexFormatElement {
protected final Type type;
protected final Usage usage;
protected final int index;
protected final int count;
protected final int byteSize;
public VertexFormatElement(int index, Type type, Usage usage, int count) {
this.index = index;
this.type = type;
this.usage = usage;
this.count = count;
this.byteSize = type.getSize() * count;
}
public void setupBufferState(long offset, int stride) {
this.usage.setupBufferState(this.count, this.type.getGlType(), stride, offset, this.index);
}
public void clearBufferState() {
this.usage.clearBufferState(this.index);
}
public enum Usage {
POSITION("Position", (size, type, stride, pointer, index) -> {
GL11.glVertexPointer(size, type, stride, pointer);
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
}, index -> GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY)),
NORMAL("Normal", (size, type, stride, pointer, index) -> {
GL11.glNormalPointer(type, stride, pointer);
GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY);
}, index -> GL11.glDisableClientState(GL11.GL_NORMAL_ARRAY)),
COLOR("Vertex Color", (size, type, stride, pointer, index) -> {
GL11.glColorPointer(size, type, stride, pointer);
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
}, index -> GL11.glDisableClientState(GL11.GL_COLOR_ARRAY)),
UV("UV", (size, type, stride, pointer, index) -> {
GL13.glClientActiveTexture(GL13.GL_TEXTURE0 + index);
GL11.glTexCoordPointer(size, type, stride, pointer);
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
}, index -> {
GL13.glClientActiveTexture(GL13.GL_TEXTURE0 + index);
GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
}),
PADDING("Padding", (size, type, stride, pointer, index) -> {}, index-> {}),
GENERIC("Generic", (size, type, stride, pointer, index) -> {
GL20.glEnableVertexAttribArray(index);
GL20.glVertexAttribPointer(index, size, type, false, stride, pointer);
}, GL20::glDisableVertexAttribArray);
@Getter private final String name;
private final SetupState setupState;
private final IntConsumer clearState;
Usage(String name, SetupState setupState, IntConsumer clearState) {
this.name = name;
this.setupState = setupState;
this.clearState = clearState;
}
private void setupBufferState(int size, int type, int stride, long pointer, int index) {
this.setupState.setupBufferState(size, type, stride, pointer, index);
}
public void clearBufferState(int index) {
this.clearState.accept(index);
}
interface SetupState {
void setupBufferState(int size, int type, int stride, long pointer, int index);
}
}
@Getter
public enum Type {
FLOAT(4, "Float", GL11.GL_FLOAT),
UBYTE(1, "Unsigned Byte", GL11.GL_UNSIGNED_BYTE),
BYTE(1, "Byte", GL11.GL_BYTE),
USHORT(2, "Unsigned Short", GL11.GL_UNSIGNED_SHORT),
SHORT(2, "Short", GL11.GL_SHORT),
UINT(4, "Unsigned Int", GL11.GL_UNSIGNED_INT),
INT(4, "Int", GL11.GL_INT);
private final int size;
private final String name;
private final int glType;
Type(int size, String name, int glType) {
this.size = size;
this.name = name;
this.glType = glType;
}
}
}
@@ -1,9 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd;
import com.gtnewhorizons.angelica.api.QuadView;
import java.nio.ByteBuffer;
public interface IWriteQuads {
void writeQuad(QuadView quad, ByteBuffer buf);
}
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
@@ -1,7 +1,8 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
@@ -1,8 +1,10 @@
package com.gtnewhorizons.angelica.compat.toremove;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
import it.unimi.dsi.fastutil.Hash;
import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
import lombok.Getter;
@@ -58,7 +60,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
}
public static RenderLayer getOutline(ResourceLocation texture, RenderPhase.Cull cull) {
return of("outline", DefaultVertexFormat.POSITION_COLOR_TEXTURE, 7, 256, RenderLayer.MultiPhaseParameters.builder().texture(new RenderPhase.Texture(texture, false, false)).cull(cull).depthTest(ALWAYS_DEPTH_TEST).alpha(ONE_TENTH_ALPHA).texturing(OUTLINE_TEXTURING).fog(NO_FOG).target(OUTLINE_TARGET).build(RenderLayer.OutlineMode.IS_OUTLINE));
return of("outline", DefaultVertexFormat.POSITION_COLOR_TEXTURE, 7, 256, RenderLayer.MultiPhaseParameters.builder().texture(new RenderPhase.Texture(texture, false, false)).cull(cull).depthTest(ALWAYS_DEPTH_TEST).alpha(ONE_TENTH_ALPHA).fog(NO_FOG).target(OUTLINE_TARGET).build(RenderLayer.OutlineMode.IS_OUTLINE));
}
public int mode() {
@@ -145,11 +147,10 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
private final RenderPhase.Target target;
private final RenderPhase.Texturing texturing;
private final RenderPhase.WriteMaskState writeMaskState;
private final RenderPhase.LineWidth lineWidth;
private final OutlineMode outlineMode;
private final ImmutableList<RenderPhase> phases;
private MultiPhaseParameters(RenderPhase.Texture texture, RenderPhase.Transparency transparency, RenderPhase.DiffuseLighting diffuseLighting, RenderPhase.ShadeModel shadeModel, RenderPhase.Alpha alpha, RenderPhase.DepthTest depthTest, RenderPhase.Cull cull, RenderPhase.Lightmap lightmap, RenderPhase.Fog fog, RenderPhase.Layering layering, RenderPhase.Target target, RenderPhase.Texturing texturing, RenderPhase.WriteMaskState writeMaskState, RenderPhase.LineWidth lineWidth, OutlineMode outlineMode) {
private MultiPhaseParameters(RenderPhase.Texture texture, RenderPhase.Transparency transparency, RenderPhase.DiffuseLighting diffuseLighting, RenderPhase.ShadeModel shadeModel, RenderPhase.Alpha alpha, RenderPhase.DepthTest depthTest, RenderPhase.Cull cull, RenderPhase.Lightmap lightmap, RenderPhase.Fog fog, RenderPhase.Layering layering, RenderPhase.Target target, RenderPhase.Texturing texturing, RenderPhase.WriteMaskState writeMaskState, OutlineMode outlineMode) {
this.texture = texture;
this.transparency = transparency;
this.diffuseLighting = diffuseLighting;
@@ -163,9 +164,8 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
this.target = target;
this.texturing = texturing;
this.writeMaskState = writeMaskState;
this.lineWidth = lineWidth;
this.outlineMode = outlineMode;
this.phases = ImmutableList.of(this.texture, this.transparency, this.diffuseLighting, this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering, this.target, this.texturing, this.writeMaskState, this.lineWidth);
this.phases = ImmutableList.of(this.texture, this.transparency, this.diffuseLighting, this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering, this.target, this.texturing, this.writeMaskState);
}
public boolean equals(Object object) {
@@ -205,7 +205,6 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
private RenderPhase.Target target;
private RenderPhase.Texturing texturing;
private RenderPhase.WriteMaskState writeMaskState;
private RenderPhase.LineWidth lineWidth;
private Builder() {
this.texture = RenderPhase.NO_TEXTURE ;
@@ -221,7 +220,6 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
this.target = RenderPhase.MAIN_TARGET;
this.texturing = RenderPhase.DEFAULT_TEXTURING;
this.writeMaskState = RenderPhase.ALL_MASK;
this.lineWidth = RenderPhase.FULL_LINE_WIDTH;
}
public Builder texture(RenderPhase.Texture texture) {
@@ -279,7 +277,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
}
public MultiPhaseParameters build(OutlineMode outlineMode) {
return new MultiPhaseParameters(this.texture, this.transparency, this.diffuseLighting, this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering, this.target, this.texturing, this.writeMaskState, this.lineWidth, outlineMode);
return new MultiPhaseParameters(this.texture, this.transparency, this.diffuseLighting, this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering, this.target, this.texturing, this.writeMaskState, outlineMode);
}
}
}
@@ -64,9 +64,6 @@ public abstract class RenderPhase {
protected static final Texture BLOCK_ATLAS_TEXTURE;
protected static final Texture NO_TEXTURE;
protected static final Texturing DEFAULT_TEXTURING;
protected static final Texturing OUTLINE_TEXTURING;
protected static final Texturing GLINT_TEXTURING;
protected static final Texturing ENTITY_GLINT_TEXTURING;
protected static final Lightmap ENABLE_LIGHTMAP;
protected static final Lightmap DISABLE_LIGHTMAP;
protected static final DiffuseLighting ENABLE_DIFFUSE_LIGHTING;
@@ -80,19 +77,12 @@ public abstract class RenderPhase {
protected static final WriteMaskState COLOR_MASK;
protected static final WriteMaskState DEPTH_MASK;
protected static final Layering NO_LAYERING;
protected static final Layering POLYGON_OFFSET_LAYERING;
protected static final Layering VIEW_OFFSET_Z_LAYERING;
protected static final Fog NO_FOG;
protected static final Fog FOG;
protected static final Fog BLACK_FOG;
protected static final Target MAIN_TARGET;
protected static final Target OUTLINE_TARGET;
protected static final Target TRANSLUCENT_TARGET;
protected static final Target PARTICLES_TARGET;
protected static final Target WEATHER_TARGET;
protected static final Target CLOUDS_TARGET;
protected static final Target ITEM_TARGET;
protected static final LineWidth FULL_LINE_WIDTH;
public RenderPhase(String name, Runnable beginAction, Runnable endAction) {
this.name = name;
@@ -127,20 +117,6 @@ public abstract class RenderPhase {
return this.name;
}
private static void setupGlintTexturing(float scale) {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.pushMatrix();
// RenderSystem.loadIdentity();
// long l = Util.getMeasuringTimeMs() * 8L;
// float g = (float)(l % 110000L) / 110000.0F;
// float h = (float)(l % 30000L) / 30000.0F;
// RenderSystem.translatef(-g, h, 0.0F);
// RenderSystem.rotatef(10.0F, 0.0F, 0.0F, 1.0F);
// RenderSystem.scalef(scale, scale, scale);
// RenderSystem.matrixMode(5888);
}
private static ResourceLocation ATLAS = TextureMap.locationBlocksTexture;
static {
// TODO: Sodium - SpriteAtlasTexture
@@ -149,29 +125,6 @@ public abstract class RenderPhase {
NO_TEXTURE = new Texture();
DEFAULT_TEXTURING = new Texturing("default_texturing", () -> {
}, () -> {
});
OUTLINE_TEXTURING = new Texturing("outline_texturing", () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.setupOutline();
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.teardownOutline();
});
GLINT_TEXTURING = new Texturing("glint_texturing", () -> {
setupGlintTexturing(8.0F);
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.popMatrix();
// RenderSystem.matrixMode(5888);
});
ENTITY_GLINT_TEXTURING = new Texturing("entity_glint_texturing", () -> {
setupGlintTexturing(0.16F);
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.popMatrix();
// RenderSystem.matrixMode(5888);
});
ENABLE_LIGHTMAP = new Lightmap(true);
DISABLE_LIGHTMAP = new Lightmap(false);
@@ -185,26 +138,7 @@ public abstract class RenderPhase {
ALL_MASK = new WriteMaskState(true, true);
COLOR_MASK = new WriteMaskState(true, false);
DEPTH_MASK = new WriteMaskState(false, true);
NO_LAYERING = new Layering("no_layering", () -> {
}, () -> {
});
POLYGON_OFFSET_LAYERING = new Layering("polygon_offset_layering", () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.polygonOffset(-1.0F, -10.0F);
// RenderSystem.enablePolygonOffset();
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.polygonOffset(0.0F, 0.0F);
// RenderSystem.disablePolygonOffset();
});
VIEW_OFFSET_Z_LAYERING = new Layering("view_offset_z_layering", () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.pushMatrix();
// RenderSystem.scalef(0.99975586F, 0.99975586F, 0.99975586F);
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem::popMatrix();
});
NO_LAYERING = new Layering("no_layering", () -> {}, () -> {});
NO_FOG = new Fog("no_fog", () -> {
}, () -> {
});
@@ -246,103 +180,6 @@ public abstract class RenderPhase {
}
});
PARTICLES_TARGET = new Target("particles_target", () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
throw new RuntimeException("Not Implemented Yet");
// MinecraftClient.getInstance().worldRenderer.getParticlesFramebuffer().beginWrite(false);
}
}, () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
}
});
WEATHER_TARGET = new Target("weather_target", () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
throw new RuntimeException("Not Implemented Yet");
// MinecraftClient.getInstance().worldRenderer.getWeatherFramebuffer().beginWrite(false);
}
}, () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
}
});
CLOUDS_TARGET = new Target("clouds_target", () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
throw new RuntimeException("Not Implemented Yet");
// MinecraftClient.getInstance().worldRenderer.getCloudsFramebuffer().beginWrite(false);
}
}, () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
}
});
ITEM_TARGET = new Target("item_entity_target", () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
throw new RuntimeException("Not Implemented Yet");
// MinecraftClient.getInstance().worldRenderer.getEntityFramebuffer().beginWrite(false);
}
}, () -> {
if (Minecraft.isFancyGraphicsEnabled()) {
Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
}
});
FULL_LINE_WIDTH = new LineWidth(OptionalDouble.of(1.0));
}
public static class LineWidth extends RenderPhase {
private final OptionalDouble width;
public LineWidth(OptionalDouble optionalDouble) {
super("line_width", () -> {
if (!Objects.equals(optionalDouble, OptionalDouble.of(1.0))) {
if (optionalDouble.isPresent()) {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.lineWidth((float)optionalDouble.getAsDouble());
} else {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.lineWidth(Math.max(2.5F, (float)MinecraftClient.getInstance().getWindow().getFramebufferWidth() / 1920.0F * 2.5F));
}
}
}, () -> {
if (!Objects.equals(optionalDouble, OptionalDouble.of(1.0))) {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.lineWidth(1.0F);
}
});
this.width = optionalDouble;
}
@Override
public boolean equals(@Nullable Object object) {
if (this == object) {
return true;
} else if (object != null && this.getClass() == object.getClass()) {
return !super.equals(object) ? false : Objects.equals(this.width, ((LineWidth)object).width);
} else {
return false;
}
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), this.width);
}
@Override
public String toString() {
return this.name + '[' + (this.width.isPresent() ? this.width.getAsDouble() : "window_scale") + ']';
}
}
@@ -557,93 +394,6 @@ public abstract class RenderPhase {
}
public static final class PortalTexturing extends Texturing {
private final int layer;
public PortalTexturing(int layer) {
super("portal_texturing", () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.pushMatrix();
// RenderSystem.loadIdentity();
// RenderSystem.translatef(0.5F, 0.5F, 0.0F);
// RenderSystem.scalef(0.5F, 0.5F, 1.0F);
// RenderSystem.translatef(17.0F / (float)layer, (2.0F + (float)layer / 1.5F) * ((float)(Util.getMeasuringTimeMs() % 800000L) / 800000.0F), 0.0F);
// RenderSystem.rotatef(((float)(layer * layer) * 4321.0F + (float)layer * 9.0F) * 2.0F, 0.0F, 0.0F, 1.0F);
// RenderSystem.scalef(4.5F - (float)layer / 4.0F, 4.5F - (float)layer / 4.0F, 1.0F);
// RenderSystem.mulTextureByProjModelView();
// RenderSystem.matrixMode(5888);
// RenderSystem.setupEndPortalTexGen();
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.popMatrix();
// RenderSystem.matrixMode(5888);
// RenderSystem.clearTexGen();
});
this.layer = layer;
}
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
} else if (object != null && this.getClass() == object.getClass()) {
PortalTexturing lv = (PortalTexturing)object;
return this.layer == lv.layer;
} else {
return false;
}
}
@Override
public int hashCode() {
return Integer.hashCode(this.layer);
}
}
public static final class OffsetTexturing extends Texturing {
private final float x;
private final float y;
public OffsetTexturing(float x, float y) {
super("offset_texturing", () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.pushMatrix();
// RenderSystem.loadIdentity();
// RenderSystem.translatef(x, y, 0.0F);
// RenderSystem.matrixMode(5888);
}, () -> {
throw new RuntimeException("Not Implemented Yet");
// RenderSystem.matrixMode(5890);
// RenderSystem.popMatrix();
// RenderSystem.matrixMode(5888);
});
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
} else if (object != null && this.getClass() == object.getClass()) {
OffsetTexturing lv = (OffsetTexturing)object;
return Float.compare(lv.x, this.x) == 0 && Float.compare(lv.y, this.y) == 0;
} else {
return false;
}
}
@Override
public int hashCode() {
return Objects.hash(this.x, this.y);
}
}
public static class Texturing extends RenderPhase {
public Texturing(String string, Runnable runnable, Runnable runnable2) {
super(string, runnable, runnable2);
@@ -1,8 +1,9 @@
package com.gtnewhorizons.angelica.dynamiclights;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.blockpos.IBlockPos;
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
@@ -25,7 +26,6 @@ import net.minecraft.util.MathHelper;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import xonin.backhand.api.core.BackhandUtils;
import xonin.backhand.api.core.IBackhandPlayer;
import java.util.Set;
import java.util.concurrent.locks.ReentrantReadWriteLock;
@@ -195,7 +195,7 @@ public class DynamicLights {
return MathHelper.clamp_double(result, 0, 15);
}
public double getDynamicLightLevel(@NotNull BlockPosImpl pos) {
public double getDynamicLightLevel(@NotNull BlockPos pos) {
return this.getDynamicLightLevel(pos.getX(), pos.getY(), pos.getZ());
}
@@ -229,7 +229,7 @@ public class DynamicLights {
* @param currentLightLevel the current surrounding dynamic light level
* @return the dynamic light level at the specified position
*/
public static double maxDynamicLightLevel(@NotNull BlockPosImpl pos, @NotNull IDynamicLightSource lightSource, double currentLightLevel) {
public static double maxDynamicLightLevel(@NotNull BlockPos pos, @NotNull IDynamicLightSource lightSource, double currentLightLevel) {
return maxDynamicLightLevel(pos.getX(), pos.getY(), pos.getZ(), lightSource, currentLightLevel);
}
@@ -267,7 +267,7 @@ public class DynamicLights {
* @param renderer the renderer
* @param chunkPos the chunk position
*/
public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, @NotNull BlockPosImpl chunkPos) {
public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, @NotNull IBlockPos chunkPos) {
scheduleChunkRebuild(renderer, chunkPos.getX(), chunkPos.getY(), chunkPos.getZ());
}
@@ -292,7 +292,7 @@ public class DynamicLights {
* @param old the set of old chunk coordinates to remove this chunk from it
* @param newPos the set of new chunk coordinates to add this chunk to it
*/
public static void updateTrackedChunks(@NotNull BlockPosImpl chunkPos, @Nullable LongOpenHashSet old, @Nullable LongOpenHashSet newPos) {
public static void updateTrackedChunks(@NotNull IBlockPos chunkPos, @Nullable LongOpenHashSet old, @Nullable LongOpenHashSet newPos) {
if (old != null || newPos != null) {
final long pos = chunkPos.asLong();
if (old != null)
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.glsm;
import com.google.common.collect.ImmutableSet;
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import org.lwjgl.opengl.GL11;
@@ -1,5 +1,7 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VBOManager;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack;
@@ -9,7 +11,6 @@ import com.gtnewhorizons.angelica.glsm.stacks.Color4Stack;
import com.gtnewhorizons.angelica.glsm.stacks.ColorMaskStack;
import com.gtnewhorizons.angelica.glsm.stacks.DepthStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.FogStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.IntegerStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.LightModelStateStack;
import com.gtnewhorizons.angelica.glsm.stacks.LightStateStack;
@@ -1,98 +0,0 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.util.List;
@SuppressWarnings("unused")
public class TessellatorManager {
private static final ThreadLocal<CapturingTessellator> capturingTessellator = ThreadLocal.withInitial(CapturingTessellator::new);
private static final ThreadLocal<Boolean> currentlyCapturing = ThreadLocal.withInitial(() -> Boolean.FALSE);
private static final Thread mainThread = Thread.currentThread();
public static Tessellator get() {
if(currentlyCapturing.get()) {
return capturingTessellator.get();
} else if(isOnMainThread()) {
return Tessellator.instance;
} else {
// TODO: Verify this works correctly and nothing unexpected is grabbing a tessellator off the main thread
// when not capturing
throw new IllegalStateException("Tried to get the Tessellator off the main thread when not capturing!");
}
}
public static boolean isOnMainThread() {
return Thread.currentThread() == mainThread;
}
public static boolean isMainInstance(Object instance) {
return instance == Tessellator.instance || isOnMainThread();
}
public static void startCapturing() {
if(currentlyCapturing.get()) throw new IllegalStateException("Tried to start capturing when already capturing!");
final CapturingTessellator tess = capturingTessellator.get();
if(tess.getQuads().size() > 0) throw new IllegalStateException("Tried to start capturing with existing collected Quads!");
tess.storeTranslation();
currentlyCapturing.set(true);
}
/*
* Stop the CapturingTessellator and return the pooled quads. The quads are valid until clearQuads() is
* called on the CapturingTesselator, which must be done before starting capturing again.
*/
public static List<QuadView> stopCapturingToPooledQuads() {
if(!currentlyCapturing.get()) throw new IllegalStateException("Tried to stop capturing when not capturing!");
currentlyCapturing.set(false);
final CapturingTessellator tess = capturingTessellator.get();
// Be sure we got all the quads
if(tess.isDrawing) tess.draw();
final List<QuadView> quads = tess.getQuads();
tess.discard();
tess.restoreTranslation();
return quads;
}
/*
* Stops the CapturingTessellator, stores the quads in a buffer (based on the VertexFormat provided),
* and clears the quads.
*/
public static ByteBuffer stopCapturingToBuffer(VertexFormat format) {
final ByteBuffer buf = CapturingTessellator.quadsToBuffer(stopCapturingToPooledQuads(), format);
capturingTessellator.get().clearQuads();
return buf;
}
/*
* Stops the CapturingTessellator, stores the quads in a buffer (based on the VertexFormat provided),
* uploads the buffer to a new VertexBuffer, and clears the quads.
*/
public static VertexBuffer stopCapturingToVBO(VertexFormat format) {
return new VertexBuffer(format, GL11.GL_QUADS).upload(stopCapturingToBuffer(format));
}
static {
System.out.println("[TessellatorManager] Initialized on thread " + mainThread.getName());
}
public static void cleanup() {
// Ensure we've cleaned everything up
final CapturingTessellator tessellator = capturingTessellator.get();
currentlyCapturing.set(false);
tessellator.discard();
tessellator.clearQuads();
}
}
@@ -1,45 +0,0 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
public class VBOManager {
// Not thread safe, only expected to be called from the main thread
private static int nextDisplayList = Integer.MIN_VALUE;
private static int getNextDisplayList() {
return nextDisplayList++;
}
private static Int2ObjectMap<VertexBuffer> vertexBuffers = new Int2ObjectOpenHashMap<>();
/*
* Allocate a (range) of "display list IDs" that will refer to a VBO in the arraylist of vertex buffers.
*/
public static int generateDisplayLists(int range) {
if(range < 1) throw new IllegalArgumentException("Range must be at least 1!");
final int id = getNextDisplayList();
for (int i = 1; i < range; i++) {
// Reserve, but don't use, the rest in the range
getNextDisplayList();
}
// Return the first in the range
return id;
}
public static VertexBuffer registerVBO(int displayList, VertexBuffer vertexBuffer) {
if(displayList > 0) throw new IllegalArgumentException("Display list must be negative!");
displayList -= Integer.MIN_VALUE;
vertexBuffers.put(displayList, vertexBuffer);
return vertexBuffer;
}
public static VertexBuffer get(int list) {
list -= Integer.MIN_VALUE;
return vertexBuffers.getOrDefault(list, null);
}
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.AlphaState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.BlendState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.BooleanState;
import org.lwjgl.opengl.GL11;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.Color4;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.ColorMask;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.DepthState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.FogState;
@@ -1,11 +0,0 @@
package com.gtnewhorizons.angelica.glsm.stacks;
public interface IStateStack<T>{
T push();
T pop();
boolean isEmpty();
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.IntegerState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.LightModelState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.LightState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.MaterialState;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.MatrixMode;
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.TextureBinding;
@@ -1,39 +0,0 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import org.joml.Vector3d;
public class Vector3dStack extends Vector3d implements IStateStack<Vector3dStack> {
protected final Vector3d[] stack;
protected int pointer;
public Vector3dStack() {
stack = new Vector3d[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
stack[i] = new Vector3d();
}
}
@Override
public Vector3dStack push() {
if(pointer == stack.length) {
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
}
stack[pointer++].set(this);
return this;
}
@Override
public Vector3dStack pop() {
if(pointer == 0) {
throw new IllegalStateException("Stack underflow");
}
set(stack[--pointer]);
return this;
}
public boolean isEmpty() {
return pointer == 0;
}
}
@@ -1,5 +1,6 @@
package com.gtnewhorizons.angelica.glsm.stacks;
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.states.ViewportState;
@@ -3,9 +3,12 @@ package com.gtnewhorizons.angelica.hudcaching;
import java.util.ArrayList;
import java.util.List;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching.RenderGameOverlayEventAccessor;
import com.gtnewhorizons.angelica.mixins.interfaces.GuiIngameAccessor;
import com.gtnewhorizons.angelica.mixins.interfaces.GuiIngameForgeAccessor;
import com.gtnewhorizons.angelica.mixins.interfaces.RenderGameOverlayEventAccessor;
import com.kentington.thaumichorizons.common.ThaumicHorizons;
import cpw.mods.fml.common.eventhandler.EventPriority;
import net.dries007.holoInventory.client.Renderer;
@@ -15,9 +18,6 @@ import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL30;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
import com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching.GuiIngameAccessor;
import com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching.GuiIngameForgeAccessor;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
@@ -107,9 +107,6 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader {
@Override
public List<String> getMixins(Set<String> loadedCoreMods) {
// TODO: Sodium
// mixins.addAll(getNotFineMixins(loadedCoreMods));
// mixins.addAll(getArchaicMixins(loadedCoreMods));
return Mixins.getEarlyMixins(loadedCoreMods);
}
@@ -122,7 +122,6 @@ public enum Mixins {
,"sodium.MixinRenderBlocks"
,"sodium.MixinRenderGlobal"
,"sodium.MixinWorldClient"
,"sodium.MixinTessellator"
,"sodium.MixinTileEntity"
,"sodium.MixinEffectRenderer"
,"sodium.MixinTileEntityRendererDispatcher"
@@ -157,12 +156,12 @@ public enum Mixins {
IRIS_ACCESSORS(new Builder("Iris Accessors").addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT)
.setPhase(Phase.EARLY).setApplyIf(() -> AngelicaConfig.enableIris).addMixinClasses(
"shaders.accessors.MinecraftAccessor"
,"shaders.accessors.EntityRendererAccessor"
,"shaders.accessors.SimpleTextureAccessor"
,"shaders.accessors.TextureAtlasSpriteAccessor"
,"shaders.accessors.TextureMapAccessor"
,"shaders.accessors.AnimationMetadataSectionAccessor"
"shaders.accessors.MixinMinecraft"
,"shaders.accessors.MixinEntityRenderer"
,"shaders.accessors.MixinSimpleTexture"
,"shaders.accessors.MixinTextureAtlasSprite"
,"shaders.accessors.MixinTextureMap"
,"shaders.accessors.MixinAnimationMetadataSection"
)
),
@@ -175,9 +174,9 @@ public enum Mixins {
HUD_CACHING(new Builder("Renders the HUD elements 20 times per second maximum to improve performance")
.addTargetedMod(TargetedMod.VANILLA).setSide(Side.CLIENT).setPhase(Phase.EARLY)
.setApplyIf(() -> AngelicaConfig.enableHudCaching).addMixinClasses(
"angelica.hudcaching.GuiIngameAccessor",
"angelica.hudcaching.GuiIngameForgeAccessor",
"angelica.hudcaching.RenderGameOverlayEventAccessor",
"angelica.hudcaching.MixinGuiIngame",
"angelica.hudcaching.MixinGuiIngameForge",
"angelica.hudcaching.MixinRenderGameOverlayEvent",
"angelica.hudcaching.MixinEntityRenderer_HUDCaching",
"angelica.hudcaching.MixinFramebuffer_HUDCaching",
"angelica.hudcaching.MixinGuiIngame_HUDCaching",
@@ -1,22 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import net.minecraft.client.renderer.ActiveRenderInfo;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import java.nio.FloatBuffer;
@Mixin(ActiveRenderInfo.class)
public class MixinActiveRenderInfo {
@Shadow private static FloatBuffer modelview;
@Shadow private static FloatBuffer projection;
@Inject(method = "updateRenderInfo", at = @At(value = "TAIL"))
private static void angelica$onUpdateRenderInfo(CallbackInfo ci) {
RenderingState.INSTANCE.setProjectionMatrix(projection);
RenderingState.INSTANCE.setModelViewMatrix(modelview);
}
}
@@ -1,32 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.entity.EntityLivingBase;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(EntityRenderer.class)
public abstract class MixinEntityRenderer {
@Inject(method = "setupCameraTransform", at = @At(value = "TAIL"))
private void angelica$captureCameraMatrix(float partialTicks, int startTime, CallbackInfo ci) {
final Minecraft mc = Minecraft.getMinecraft();
final EntityLivingBase viewEntity = mc.renderViewEntity;
RenderingState.INSTANCE.setCameraPosition(
viewEntity.lastTickPosX + (viewEntity.posX - viewEntity.lastTickPosX) * partialTicks,
viewEntity.lastTickPosY + (viewEntity.posY - viewEntity.lastTickPosY) * partialTicks,
viewEntity.lastTickPosZ + (viewEntity.posZ - viewEntity.lastTickPosZ) * partialTicks
);
}
@ModifyArg(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", ordinal = 0, remap = false), index = 0)
private float captureFov(float fov) {
RenderingState.INSTANCE.setFov(fov);
return fov;
}
}
@@ -1,27 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica;
import cpw.mods.fml.client.FMLClientHandler;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
@Mixin(value = FMLClientHandler.class, remap = false)
public class MixinFMLClientHandler {
/**
* @author mitchej123
* @reason Remove more traces of Optifine
*/
@Overwrite
private void detectOptifine() {
// Do nothing
}
/**
* @author mitchej123
* @reason Remove more traces of Optifine
*/
@Overwrite
public boolean hasOptifine() {
return false;
}
}
@@ -1,20 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica;
import net.minecraft.client.Minecraft;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(Minecraft.class)
public class MixinMinecraft {
@Inject(
method = "runGameLoop",
at = @At(value = "INVOKE", target = "Lcpw/mods/fml/common/FMLCommonHandler;onRenderTickEnd(F)V", shift = At.Shift.AFTER, remap = false)
)
private void angelica$injectLightingFixPostRenderTick(CallbackInfo ci) {
GL11.glEnable(GL11.GL_LIGHTING);
}
}
@@ -1,22 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import net.minecraft.block.BlockFire;
import net.minecraft.util.IIcon;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(BlockFire.class)
public class MixinBlockFire {
@Shadow
private IIcon[] field_149850_M;
@Inject(method = "getFireIcon", at = @At("HEAD"))
private void angelica$markFireAnimationForUpdate(int p_149840_1_, CallbackInfoReturnable<IIcon> cir) {
AnimationsRenderUtils.markBlockTextureForUpdate(field_149850_M[p_149840_1_]);
}
}
@@ -1,26 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
import net.minecraft.util.IIcon;
import net.minecraft.world.ChunkCache;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Unique;
import java.util.HashSet;
@Mixin(ChunkCache.class)
public class MixinChunkCache implements ITexturesCache {
@Unique
private final HashSet<IIcon> renderedIcons = new HashSet<>();
@Override
public HashSet<IIcon> getRenderedTextures() {
return renderedIcons;
}
@Override
public void enableTextureTracking() {
}
}
@@ -1,44 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraftforge.client.IItemRenderer;
import net.minecraftforge.client.MinecraftForgeClient;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(MinecraftForgeClient.class)
public class MixinMinecraftForgeClient {
/**
* @author laetansky We can just mark any item texture that gets rendered for an update
*/
@Inject(method = "getItemRenderer", at = @At("HEAD"), remap = false)
private static void angelica$beforeRenderItem(ItemStack itemStack, IItemRenderer.ItemRenderType type,
CallbackInfoReturnable<IItemRenderer> cir) {
// Don't animate items if a world is not present (e.g. during loading)
if (Minecraft.getMinecraft().theWorld == null) {
return;
}
final Item item = itemStack.getItem();
if (item.requiresMultipleRenderPasses()) {
for (int i = 0; i < item.getRenderPasses(itemStack.getItemDamage()); i++) {
IIcon icon = item.getIcon(itemStack, i);
if (icon instanceof TextureAtlasSprite) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
}
}
} else {
final IIcon icon = itemStack.getIconIndex();
if (icon instanceof TextureAtlasSprite) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
}
}
}
}
@@ -1,43 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.fluids.RenderBlockFluid;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(value = RenderBlockFluid.class, remap = false)
public abstract class MixinRenderBlockFluid {
@Unique
private IBlockAccess currentBlockAccess;
@Inject(method = "renderWorldBlock", at = @At(value = "HEAD"))
private void angelica$saveCurrentBlockAccess(IBlockAccess world, int x, int y, int z, Block block, int modelId,
RenderBlocks renderer, CallbackInfoReturnable<Boolean> cir) {
currentBlockAccess = world;
}
/**
* @author laetansky
* @reason mark texture for update
*/
@Overwrite
private IIcon getIcon(IIcon icon) {
if (icon != null) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, currentBlockAccess);
return icon;
}
return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture))
.getAtlasSprite("missingno");
}
}
@@ -1,93 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFire;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
import java.util.Set;
@Mixin(RenderBlocks.class)
public class MixinRenderBlocks implements ITexturesCache {
@Shadow
public IBlockAccess blockAccess;
@Shadow
public IIcon overrideBlockTexture;
private Set<IIcon> renderedSprites = new ReferenceOpenHashSet<>();
private boolean enableSpriteTracking;
/**
* @author laetansky Here where things get very tricky. We can't just mark blocks textures for update because this
* method gets called only when chunk render cache needs an update (that happens when a state of any block
* in that chunk changes). What we can do though is pass the rendered textures up to the WorldRenderer and
* later use it in RenderGlobal to mark textures for update and before that even sort WorldRenderers and
* apply Occlusion Querry (Basically that means that we will only mark those textures for update that are
* visible (on the viewport) at the moment)
*/
@Inject(method = "*(Lnet/minecraft/block/Block;DDDLnet/minecraft/util/IIcon;)V", at = @At("HEAD"))
public void angelica$beforeRenderFace(Block p_147761_1_, double p_147761_2_, double p_147761_4_,
double p_147761_6_, IIcon icon, CallbackInfo ci) {
if (overrideBlockTexture != null) {
icon = overrideBlockTexture;
}
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
}
@Inject(method = "renderBlockFire", at = @At("HEAD"))
public void angelica$markFireBlockAnimationForUpdate(BlockFire instance, int x, int y, int z,
CallbackInfoReturnable<Boolean> cir) {
if(this.enableSpriteTracking) {
this.renderedSprites.add(instance.getFireIcon(0));
this.renderedSprites.add(instance.getFireIcon(1));
}
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(0), blockAccess);
AnimationsRenderUtils.markBlockTextureForUpdate(instance.getFireIcon(1), blockAccess);
}
@ModifyVariable(method = "renderBlockLiquid", at = @At(value = "INVOKE_ASSIGN", target = "Lnet/minecraft/client/renderer/RenderBlocks;getBlockIconFromSideAndMetadata(Lnet/minecraft/block/Block;II)Lnet/minecraft/util/IIcon;"))
public IIcon angelica$markFluidAnimationForUpdate(IIcon icon) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
return icon;
}
@Inject(method = "drawCrossedSquares", at = @At("HEAD"))
public void angelica$markCrossedSquaresAnimationForUpdate(IIcon icon, double p_147765_2_, double p_147765_4_, double p_147765_6_, float p_147765_8_,
CallbackInfo ci) {
AnimationsRenderUtils.markBlockTextureForUpdate(icon, blockAccess);
if(this.enableSpriteTracking)
this.renderedSprites.add(icon);
}
@Override
public Set<IIcon> getRenderedTextures() {
return renderedSprites;
}
@Override
public void enableTextureTracking() {
enableSpriteTracking = true;
}
}
@@ -1,25 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.util.IIcon;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(RenderItem.class)
public class MixinRenderItem {
/**
* Some mods may call it to render their internally stored icons, so we make sure we mark those for an update
*/
@Inject(method = "renderIcon", at = @At("HEAD"))
private void angelica$beforeRenderIcon(int p_94149_1_, int p_94149_2_, IIcon icon, int p_94149_4_, int p_94149_5_,
CallbackInfo ci) {
if (icon instanceof TextureAtlasSprite) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
}
}
}
@@ -1,57 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.resources.data.AnimationMetadataSection;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.Unique;
import java.util.List;
@Mixin(TextureAtlasSprite.class)
public abstract class MixinTextureAtlasSprite implements IPatchedTextureAtlasSprite {
@Unique
private boolean needsAnimationUpdate = false;
@Shadow
protected int tickCounter;
@Shadow
protected int frameCounter;
@Shadow
private AnimationMetadataSection animationMetadata;
@Shadow
protected List<?> framesTextureData;
@Override
public void markNeedsAnimationUpdate() {
needsAnimationUpdate = true;
}
@Override
public boolean needsAnimationUpdate() {
return needsAnimationUpdate;
}
@Override
public void unmarkNeedsAnimationUpdate() {
needsAnimationUpdate = false;
}
@Override
public void updateAnimationsDryRun() {
// account for weird subclass that doesn't use the stock mechanisms for animation
if (animationMetadata == null || framesTextureData == null) return;
tickCounter++;
if (tickCounter >= animationMetadata.getFrameTimeSingle(frameCounter)) {
int j = this.animationMetadata.getFrameCount() == 0 ? framesTextureData.size()
: this.animationMetadata.getFrameCount();
this.frameCounter = (this.frameCounter + 1) % j;
this.tickCounter = 0;
}
}
}
@@ -1,60 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import com.gtnewhorizons.angelica.utils.AnimationMode;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.AbstractTexture;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.texture.TextureMap;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.Unique;
import java.util.List;
@Mixin(value = TextureMap.class, priority = 999)
@SuppressWarnings("ForLoopReplaceableByForEach")
public abstract class MixinTextureMap extends AbstractTexture {
@Shadow
@Final
private List<TextureAtlasSprite> listAnimatedSprites;
@Unique
private static final Minecraft mc = Minecraft.getMinecraft();
/**
* @author laetansky
* @reason only update animations for textures that are being currently drawn By default minecraft handles any
* animations that present in listAnimatedSprites no matter if you see it or not which can lead to a huge
* performance decrease
*/
@Overwrite
public void updateAnimations() {
final boolean renderAllAnimations = AngelicaMod.animationsMode.is(AnimationMode.ALL);
final boolean renderVisibleAnimations = AngelicaMod.animationsMode.is(AnimationMode.VISIBLE_ONLY);
mc.mcProfiler.startSection("updateAnimations");
GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.getGlTextureId());
// C Style loop should be faster
final int size = listAnimatedSprites.size();
for (int i = 0; i < size; i++) {
final TextureAtlasSprite textureAtlasSprite = listAnimatedSprites.get(i);
final IPatchedTextureAtlasSprite patchedTextureAtlasSprite = ((IPatchedTextureAtlasSprite) textureAtlasSprite);
if (renderAllAnimations || (renderVisibleAnimations && patchedTextureAtlasSprite.needsAnimationUpdate())) {
mc.mcProfiler.startSection(textureAtlasSprite.getIconName());
textureAtlasSprite.updateAnimation();
patchedTextureAtlasSprite.unmarkNeedsAnimationUpdate();
mc.mcProfiler.endSection();
} else {
patchedTextureAtlasSprite.updateAnimationsDryRun();
}
}
mc.mcProfiler.endSection();
}
}
@@ -1,52 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.IPatchedTextureAtlasSprite;
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
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.ModifyArg;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
import java.util.Set;
@Mixin(WorldRenderer.class)
public class MixinWorldRenderer implements ITexturesCache {
@Shadow
public boolean isInFrustum;
@Unique
private Set<IIcon> renderedIcons;
@ModifyArg(method = "updateRenderer", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderBlocks;<init>(Lnet/minecraft/world/IBlockAccess;)V"))
private IBlockAccess angelica$onUpdateRenderer(IBlockAccess chunkCache) {
((ITexturesCache) chunkCache).enableTextureTracking();
renderedIcons = ((ITexturesCache) chunkCache).getRenderedTextures();
return chunkCache;
}
@Inject(method = "getGLCallListForPass", at = @At("HEAD"))
private void angelica$getGLCallListForPass(int pass, CallbackInfoReturnable<Integer> cir) {
if (isInFrustum && pass == 0 && renderedIcons != null) {
for (IIcon icon : renderedIcons) {
((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
}
}
}
@Override
public Set<IIcon> getRenderedTextures() {
return renderedIcons;
}
@Override
public void enableTextureTracking() {
}
}
@@ -1,23 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import cpw.mods.fml.client.SplashProgress;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Accessor;
@SuppressWarnings("deprecation")
@Mixin(SplashProgress.class)
public interface AccessorSplashProgress {
@Accessor(remap = false)
static int getBarBorderColor() {
throw new AssertionError();
}
@Accessor(remap = false)
static int getBarBackgroundColor() {
throw new AssertionError();
}
@Accessor(remap = false)
static int getFontColor() {
throw new AssertionError();
}
}
@@ -1,24 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFence;
import net.minecraft.block.material.Material;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(BlockFence.class)
public abstract class MixinBlockFence extends Block {
private MixinBlockFence(Material materialIn) {
super(materialIn);
}
/**
* Fix a smooth lighting glitch with fences against solid blocks.
*/
@Inject(method = "<init>", at = @At("RETURN"))
private void makeTransparent(String s, Material m, CallbackInfo ci) {
this.canBlockGrass = true;
}
}
@@ -1,21 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import cpw.mods.fml.client.FMLClientHandler;
import cpw.mods.fml.client.GuiModList;
import net.minecraft.client.gui.GuiIngameMenu;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(FMLClientHandler.class)
public abstract class MixinFMLClientHandler {
@Shadow(remap = false) public abstract void showGuiScreen(Object clientGuiElement);
@Inject(method = "showInGameModOptions", at = @At("HEAD"), cancellable = true, remap = false)
private void showModsList(GuiIngameMenu guiIngameMenu, CallbackInfo ci) {
showGuiScreen(new GuiModList(guiIngameMenu));
ci.cancel();
}
}
@@ -1,20 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import cpw.mods.fml.common.ModContainer;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraftforge.client.GuiIngameForge;
import com.gtnewhorizons.angelica.helpers.LoadControllerHelper;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(value=GuiIngameForge.class, remap = false)
public class MixinGuiIngameForge {
@Redirect(method = "renderHUDText", at = @At(value = "FIELD", target = "Lnet/minecraft/world/biome/BiomeGenBase;biomeName:Ljava/lang/String;"))
private String getModNameWithBiome(BiomeGenBase biome) {
ModContainer theMod = LoadControllerHelper.getOwningMod(biome.getClass());
if(theMod == null)
return biome.biomeName;
return biome.biomeName + " [" + theMod.getName() + "]";
}
}
@@ -1,31 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.network.NetHandlerPlayClient;
import net.minecraft.network.play.INetHandlerPlayClient;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
/**
* Makes interdimensional teleportation nearly as fast as same-dimension
* teleportation by removing the "Downloading terrain..." screen. This will cause
* the player to see partially loaded terrain rather than waiting for the whole
* drawScreen distance to load, but that's also the vanilla behaviour for same-dimension
* teleportation. [From ArchaicFix]
*/
@Mixin(value = NetHandlerPlayClient.class, priority = 500)
public abstract class MixinNetHandlerPlayClient implements INetHandlerPlayClient {
@Redirect(method = "handleJoinGame", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Minecraft;displayGuiScreen(Lnet/minecraft/client/gui/GuiScreen;)V"))
private void onGuiDisplayJoin(Minecraft mc, GuiScreen guiScreenIn) {
mc.displayGuiScreen(AngelicaConfig.hideDownloadingTerrainScreen ? null : guiScreenIn);
}
@Redirect(method = "handleRespawn", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Minecraft;displayGuiScreen(Lnet/minecraft/client/gui/GuiScreen;)V"))
private void onGuiDisplayRespawn(Minecraft mc, GuiScreen guiScreenIn) {
mc.displayGuiScreen(AngelicaConfig.hideDownloadingTerrainScreen ? null : guiScreenIn);
}
}
@@ -1,143 +0,0 @@
/*
* Based off SplashProgress from Forge 14.23.5.2860.
*/
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import com.gtnewhorizons.angelica.Tags;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import cpw.mods.fml.client.SplashProgress;
import net.minecraft.client.gui.FontRenderer;
import org.apache.commons.lang3.StringUtils;
import org.lwjgl.opengl.Display;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import java.lang.reflect.Field;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
import static org.lwjgl.opengl.GL11.glDisable;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glPopMatrix;
import static org.lwjgl.opengl.GL11.glPushMatrix;
import static org.lwjgl.opengl.GL11.glScalef;
import static org.lwjgl.opengl.GL11.glTranslatef;
@SuppressWarnings("deprecation")
@Mixin(targets = { "cpw/mods/fml/client/SplashProgress$3" })
public class MixinSplashProgress {
private static final int memoryGoodColor = 0x78CB34;
private static final int memoryWarnColor = 0xE6E84A;
private static final int memoryLowColor = 0xE42F2F;
private static float memoryColorPercent;
private static long memoryColorChangeTime;
private static FontRenderer fontRenderer = null;
@Inject(method = "run", at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glDisable(I)V", ordinal = 1, remap = false, shift = At.Shift.AFTER), remap = false, require = 0)
private void injectDrawMemoryBar(CallbackInfo ci) {
// NOTE: Disable this if you're checking for off thread GL calls via `-Dangelica.assertMainThread=true`
if(fontRenderer == null) {
try {
Field f = SplashProgress.class.getDeclaredField("fontRenderer");
f.setAccessible(true);
fontRenderer = (FontRenderer)f.get(null);
} catch(ReflectiveOperationException e) {
AngelicaTweaker.LOGGER.error(e);
return;
}
}
glPushMatrix();
glTranslatef(320 - Display.getWidth() / 2 + 4, 240 + Display.getHeight() / 2 - textHeight2, 0);
glScalef(2, 2, 1);
glEnable(GL_TEXTURE_2D);
fontRenderer.drawString("Angelica " + Tags.VERSION, 0, 0, 0x000000);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
if(AngelicaConfig.showSplashMemoryBar) {
glPushMatrix();
glTranslatef(320 - (float) barWidth / 2, 20, 0);
drawMemoryBar();
glPopMatrix();
}
}
@Shadow(remap = false)
private void setColor(int color) {}
@Shadow(remap = false)
private void drawBox(int w, int h) {}
@Final
@Shadow(remap = false)
private int barWidth, barHeight, textHeight2;
private void drawMemoryBar() {
final int maxMemory = bytesToMb(Runtime.getRuntime().maxMemory());
final int totalMemory = bytesToMb(Runtime.getRuntime().totalMemory());
final int freeMemory = bytesToMb(Runtime.getRuntime().freeMemory());
final int usedMemory = totalMemory - freeMemory;
final float usedMemoryPercent = usedMemory / (float) maxMemory;
glPushMatrix();
// title - message
setColor(AccessorSplashProgress.getFontColor());
glScalef(2, 2, 1);
glEnable(GL_TEXTURE_2D);
fontRenderer.drawString("Memory Used / Total", 0, 0, 0x000000);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
// border
glPushMatrix();
glTranslatef(0, textHeight2, 0);
setColor(AccessorSplashProgress.getBarBorderColor());
drawBox(barWidth, barHeight);
// interior
setColor(AccessorSplashProgress.getBarBackgroundColor());
glTranslatef(1, 1, 0);
drawBox(barWidth - 2, barHeight - 2);
// slidy part
final long time = System.currentTimeMillis();
if (usedMemoryPercent > memoryColorPercent || (time - memoryColorChangeTime > 1000)) {
memoryColorChangeTime = time;
memoryColorPercent = usedMemoryPercent;
}
final int memoryBarColor;
if (memoryColorPercent < 0.75f) {
memoryBarColor = memoryGoodColor;
} else if (memoryColorPercent < 0.85f) {
memoryBarColor = memoryWarnColor;
} else {
memoryBarColor = memoryLowColor;
}
setColor(memoryLowColor);
glPushMatrix();
glTranslatef((barWidth - 2) * (totalMemory) / (maxMemory) - 2, 0, 0);
drawBox(2, barHeight - 2);
glPopMatrix();
setColor(memoryBarColor);
drawBox((barWidth - 2) * (usedMemory) / (maxMemory), barHeight - 2);
// progress text
final String progress = getMemoryString(usedMemory) + " / " + getMemoryString(maxMemory);
glTranslatef(((float)barWidth - 2) / 2 - fontRenderer.getStringWidth(progress), 2, 0);
setColor(AccessorSplashProgress.getFontColor());
glScalef(2, 2, 1);
glEnable(GL_TEXTURE_2D);
fontRenderer.drawString(progress, 0, 0, 0x000000);
glPopMatrix();
}
private String getMemoryString(int memory)
{
return StringUtils.leftPad(Integer.toString(memory), 4, ' ') + " MB";
}
private static int bytesToMb(long bytes)
{
return (int) (bytes / 1024L / 1024L);
}
}
@@ -1,24 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.archaic;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import net.minecraft.client.renderer.ThreadDownloadImageData;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* Removes a start of tons new threads
* for skins loading
*/
@Mixin(ThreadDownloadImageData.class)
public final class MixinThreadDownloadImageData {
private static final Executor EXECUTOR = Executors.newFixedThreadPool(Math.max(2, Runtime.getRuntime().availableProcessors() / 2), new ThreadFactoryBuilder().setNameFormat("Skin Downloader #%d").setDaemon(true).setPriority(Thread.MIN_PRIORITY).build());
@Redirect(method = "func_152433_a", at = @At(value = "INVOKE", target = "Ljava/lang/Thread;start()V"))
private void onThreadStart(Thread thread) {
EXECUTOR.execute(thread);
}
}
@@ -1,24 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
import com.gtnewhorizons.angelica.mixins.hooks.FluidHooks;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.fluids.BlockFluidBase;
import net.minecraftforge.fluids.RenderBlockFluid;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
import com.llamalad7.mixinextras.sugar.Local;
@Mixin(value = RenderBlockFluid.class, remap = false)
public class MixinRenderBlockFluid {
@Redirect(
method = "renderWorldBlock", at = @At(
value = "INVOKE",
target = "Lnet/minecraftforge/fluids/BlockFluidBase;getFlowDirection(Lnet/minecraft/world/IBlockAccess;III)D"))
double hodgepodge$directFlowDirectionCheck(IBlockAccess world, int x, int y, int z, @Local BlockFluidBase block) {
return FluidHooks.getFlowDirection(world, x, y, z, block);
}
}
@@ -1,21 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.debug;
import com.gtnewhorizons.angelica.glsm.GLDebug;
import net.minecraft.profiler.Profiler;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(Profiler.class)
public class MixinProfiler {
@Inject(method = "startSection(Ljava/lang/String;)V", at = @At("HEAD"))
private void debugStartSection(String name, CallbackInfo ci) {
GLDebug.pushGroup("minecraft:" + name);
}
@Inject(method = "endSection()V", at = @At("HEAD"))
private void debugEndSection(CallbackInfo ci) {
GLDebug.popGroup();
}
}
@@ -1,22 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.debug;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
import cpw.mods.fml.client.SplashProgress;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@Mixin(value = SplashProgress.class, remap = false)
public class MixinSplashProgress {
@WrapOperation(method="Lcpw/mods/fml/client/SplashProgress;start()V", at=@At(value="INVOKE", target="Lcpw/mods/fml/client/SplashProgress;getBool(Ljava/lang/String;Z)Z"))
private static boolean angelica$disableSplashProgress(String name, boolean def, Operation<Boolean> original) {
AngelicaTweaker.LOGGER.info("Forcibly disabling splash progress because LWJGL debug has been set");
// Forcibly disable splash progress until we can figure out why it's not working with our debug callback
if(name.equals("enabled"))
return false;
else
return original.call(name, def);
}
}
@@ -1,25 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.debug;
import com.gtnewhorizons.angelica.glsm.GLDebug;
import net.minecraft.client.renderer.texture.ITextureObject;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.renderer.texture.TextureUtil;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(TextureManager.class)
public class MixinTextureManager {
@Inject(method = "loadTexture", at = @At("RETURN"))
private void onTextureLoad(ResourceLocation resource, ITextureObject texture, CallbackInfoReturnable<Boolean> cir) {
if(texture != null && texture != TextureUtil.missingTexture) {
final int curId = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture.getGlTextureId());
GLDebug.nameObject(GL11.GL_TEXTURE, texture.getGlTextureId(), resource.toString());
GL11.glBindTexture(GL11.GL_TEXTURE_2D, curId);
}
}
}
@@ -1,171 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.dynamiclights;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource;
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
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.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(Entity.class)
public abstract class MixinEntity implements IDynamicLightSource {
@Shadow
public World worldObj;
@Shadow
public double posX;
@Shadow
public double posY;
@Shadow
public double posZ;
@Shadow
public int chunkCoordX;
@Shadow
public int chunkCoordZ;
@Shadow
public abstract float getEyeHeight();
@Shadow
public boolean isDead;
@Unique
protected int angelica$luminance = 0;
@Unique
private int angelica$lastLuminance = 0;
@Unique
private static long angelica$lastUpdate = 0;
@Unique
private double angelica$prevX;
@Unique
private double angelica$prevY;
@Unique
private double angelica$prevZ;
@Unique
private LongOpenHashSet angelica$trackedLitChunkPos = new LongOpenHashSet();
@Override
public double angelica$getDynamicLightX() {
return posX;
}
@Override
public double angelica$getDynamicLightY() {
return posY + getEyeHeight();
}
@Override
public double angelica$getDynamicLightZ() {
return posZ;
}
@Override
public void angelica$resetDynamicLight() {
this.angelica$lastLuminance = 0;
}
@Override
public boolean angelica$shouldUpdateDynamicLight() {
if (DynamicLights.Mode.hasDelay()) {
long currentTime = System.currentTimeMillis();
if (currentTime < angelica$lastUpdate + DynamicLights.Mode.getDelay())
return false;
angelica$lastUpdate = currentTime;
}
return true;
}
@Inject(method = "onEntityUpdate", at = @At("TAIL"))
public void angelica$onUpdate(CallbackInfo ci) {
if (worldObj != null && worldObj.isRemote) {
if (isDead) {
angelica$setDynamicLightEnabled(false);
} else {
angelica$dynamicLightTick();
DynamicLights.updateTracking(this);
}
}
}
@Override
public void angelica$dynamicLightTick() {
this.angelica$luminance = DynamicLights.getLuminanceFromEntity((Entity) (Object) this);
}
@Override
public int angelica$getLuminance() {
return this.angelica$luminance;
}
@Override
public boolean angelica$updateDynamicLight(@NotNull SodiumWorldRenderer renderer) {
if (!this.angelica$shouldUpdateDynamicLight())
return false;
double deltaX = this.posX - this.angelica$prevX;
double deltaY = this.posY - this.angelica$prevY;
double deltaZ = this.posZ - this.angelica$prevZ;
int luminance = this.angelica$getLuminance();
if (Math.abs(deltaX) > 0.1D || Math.abs(deltaY) > 0.1D || Math.abs(deltaZ) > 0.1D || luminance != this.angelica$lastLuminance) {
this.angelica$prevX = this.posX;
this.angelica$prevY = this.posY;
this.angelica$prevZ = this.posZ;
this.angelica$lastLuminance = luminance;
var newPos = new LongOpenHashSet();
if (luminance > 0) {
var chunkPos = new BlockPosImpl(chunkCoordX, MathHelper.floor_double(posY + getEyeHeight()) >> 4, chunkCoordZ);
DynamicLights.scheduleChunkRebuild(renderer, chunkPos);
DynamicLights.updateTrackedChunks(chunkPos, this.angelica$trackedLitChunkPos, newPos);
var directionX = ((MathHelper.floor_double(posX) & 15) >= 8) ? ForgeDirection.EAST : ForgeDirection.WEST;
var directionY = ((MathHelper.floor_double(posY + getEyeHeight()) & 15) >= 8) ? ForgeDirection.UP : ForgeDirection.DOWN;
var directionZ = ((MathHelper.floor_double(posZ) & 15) >= 8) ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
for (int i = 0; i < 7; i++) {
if (i % 4 == 0) {
chunkPos = chunkPos.offset(directionX); // X
} else if (i % 4 == 1) {
chunkPos = chunkPos.offset(directionZ); // XZ
} else if (i % 4 == 2) {
chunkPos = chunkPos.offset(directionX.getOpposite()); // Z
} else {
chunkPos = chunkPos.offset(directionZ.getOpposite()); // origin
chunkPos = chunkPos.offset(directionY); // Y
}
DynamicLights.scheduleChunkRebuild(renderer, chunkPos);
DynamicLights.updateTrackedChunks(chunkPos, this.angelica$trackedLitChunkPos, newPos);
}
}
// Schedules the rebuild of removed chunks.
this.angelica$scheduleTrackedChunksRebuild(renderer);
// Update tracked lit chunks.
this.angelica$trackedLitChunkPos = newPos;
return true;
}
return false;
}
@Override
public void angelica$scheduleTrackedChunksRebuild(@NotNull SodiumWorldRenderer renderer) {
for (long pos : this.angelica$trackedLitChunkPos) {
DynamicLights.scheduleChunkRebuild(renderer, pos);
}
}
}
@@ -1,23 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.dynamiclights;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.EntityRenderer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(EntityRenderer.class)
public class MixinEntityRenderer {
@Shadow
private Minecraft mc;
@Inject(method = "renderWorld", at = @At("HEAD"))
private void updateDynamicLights(float p_78471_1_, long p_78471_2_, CallbackInfo ci){
mc.mcProfiler.endStartSection("angelica_dynamic_lighting");
DynamicLights.get().updateAll(SodiumWorldRenderer.getInstance());
}
}
@@ -1,23 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.dynamiclights;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.client.renderer.ItemRenderer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@Mixin(ItemRenderer.class)
public class MixinItemRenderer {
@WrapOperation(method = "renderItemInFirstPerson", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/multiplayer/WorldClient;getLightBrightnessForSkyBlocks(IIII)I"))
private int angelica$dynamiclights_renderItemInFirstPerson(WorldClient theWorld, int posX, int posY, int posZ, int p_72802_4_, Operation<Integer> original){
int lightmap = original.call(theWorld, posX, posY, posZ, p_72802_4_);
if (DynamicLights.isEnabled()){
lightmap = (int)DynamicLights.get().getLightmapWithDynamicLight(posX, posY, posZ, lightmap);
}
return lightmap;
}
}
@@ -1,39 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.dynamiclights;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource;
import com.llamalad7.mixinextras.injector.ModifyReturnValue;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.world.World;
import net.minecraft.world.WorldSettings;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(World.class)
public abstract class MixinWorld {
@Shadow
protected abstract void initialize(WorldSettings p_72963_1_);
@Shadow
public abstract Block getBlock(int p_147439_1_, int p_147439_2_, int p_147439_3_);
@Inject(method = "onEntityRemoved", at = @At("HEAD"))
private void angelica$removeEntity(Entity entity, CallbackInfo ci){
if (entity instanceof IDynamicLightSource lightSource){
lightSource.angelica$setDynamicLightEnabled(false);
}
}
@ModifyReturnValue(method = "getLightBrightnessForSkyBlocks", at = @At(value = "RETURN"))
private int angelica$dynamiclights_getLightBrightnessForSkyBlocks(int lightmap, int p_72802_1_, int p_72802_2_, int p_72802_3_, int p_72802_4_){
if (DynamicLights.isEnabled()){
return DynamicLights.get().getLightmapWithDynamicLight(p_72802_1_, p_72802_2_, p_72802_3_, lightmap);
}
return lightmap;
}
}
@@ -1,189 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.fontrenderer;
import com.gtnewhorizons.angelica.client.font.BatchingFontRenderer;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.mixins.interfaces.FontRendererAccessor;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.settings.GameSettings;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
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.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
import java.util.Random;
/**
* Fixes the horrible performance of FontRenderer
* @author eigenraven
*/
@Mixin(FontRenderer.class)
public abstract class MixinFontRenderer implements FontRendererAccessor {
@Shadow
private boolean randomStyle;
@Shadow
private boolean boldStyle;
@Shadow
private boolean strikethroughStyle;
@Shadow
private boolean underlineStyle;
@Shadow
private boolean italicStyle;
@Shadow
private int[] colorCode;
@Shadow
private int textColor;
@Shadow(remap = false)
protected abstract void setColor(float r, float g, float b, float a);
@Shadow
private float alpha;
@Shadow
private float red;
/** Actually green */
@Shadow
private float blue;
/** Actually blue */
@Shadow
private float green;
@Shadow
public Random fontRandom;
@Shadow
protected int[] charWidth;
@Shadow
private boolean unicodeFlag;
@Shadow
protected float posX;
@Shadow
protected float posY;
@Shadow
protected abstract float renderCharAtPos(int p_78278_1_, char p_78278_2_, boolean p_78278_3_);
@Shadow(remap = false)
protected abstract void doDraw(float f);
@Shadow
@Final
private static ResourceLocation[] unicodePageLocations;
@Shadow
protected byte[] glyphWidth;
@Shadow
@Final
protected ResourceLocation locationFontTexture;
@Shadow
@Final
private TextureManager renderEngine;
@Shadow
private boolean bidiFlag;
@Shadow
protected abstract String bidiReorder(String p_147647_1_);
@Shadow(remap = false)
protected abstract void bindTexture(ResourceLocation location);
@Unique
public BatchingFontRenderer angelica$batcher;
@Unique
private static final char angelica$FORMATTING_CHAR = 167; // §
@Unique
private static final float angelica$1_over_255 = 1.0f/255.0f; // §
@Inject(method = "<init>", at = @At("TAIL"))
private void angelica$injectBatcher(GameSettings settings, ResourceLocation fontLocation, TextureManager texManager,
boolean unicodeMode, CallbackInfo ci) {
angelica$batcher = new BatchingFontRenderer((FontRenderer) (Object) this, unicodePageLocations, this.charWidth, this.glyphWidth, this.colorCode, this.locationFontTexture, this.renderEngine);
}
@Unique
private static boolean angelica$charInRange(char what, char fromInclusive, char toInclusive) {
return (what >= fromInclusive) && (what <= toInclusive);
}
/**
* Only allow using the batched renderer if we are not in an OpenGL Display List
* Batched font renderer is not compatible with display lists, and won't really
* help performance when display lists are already being used anyway.
*/
@Inject(method = "drawString(Ljava/lang/String;IIIZ)I", at = @At("HEAD"), cancellable = true)
public void angelica$BatchedFontRendererDrawString(String text, int x, int y, int argb, boolean dropShadow, CallbackInfoReturnable<Integer> cir)
{
if (GLStateManager.getListMode() == 0) {
cir.setReturnValue(angelica$drawStringBatched(text, x, y, argb, dropShadow));
}
}
/**
* See above explanation about batched renderer in display lists.
*/
@Inject(method = "renderString", at = @At("HEAD"), cancellable = true)
public void angelica$BatchedFontRendererRenderString(String text, int x, int y, int argb, boolean dropShadow, CallbackInfoReturnable<Integer> cir) {
if (GLStateManager.getListMode() == 0) {
cir.setReturnValue(angelica$drawStringBatched(text, x, y, argb, dropShadow));
}
}
@Override
public int angelica$drawStringBatched(String text, int x, int y, int argb, boolean dropShadow) {
if (text == null)
{
return 0;
}
else
{
if (this.bidiFlag)
{
text = this.bidiReorder(text);
}
if ((argb & 0xfc000000) == 0)
{
argb |= 0xff000000;
}
this.red = (float)(argb >> 16 & 255) / 255.0F;
this.blue = (float)(argb >> 8 & 255) / 255.0F;
this.green = (float)(argb & 255) / 255.0F;
this.alpha = (float)(argb >> 24 & 255) / 255.0F;
GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
this.posX = (float)x;
this.posY = (float)y;
return (int) angelica$batcher.drawString(x, y, argb, dropShadow, unicodeFlag, text, 0, text.length());
}
}
@Override
public BatchingFontRenderer angelica$getBatcher() {
return angelica$batcher;
}
@Override
public void angelica$bindTexture(ResourceLocation location) { this.bindTexture(location); }
}
@@ -1,36 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.fontrenderer;
import com.gtnewhorizons.angelica.mixins.interfaces.FontRendererAccessor;
import net.minecraft.client.gui.FontRenderer;
import net.minecraftforge.client.GuiIngameForge;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(GuiIngameForge.class)
public class MixinGuiIngameForge {
@Shadow(remap = false)
private FontRenderer fontrenderer;
@Inject(
method = "renderHUDText",
at = @At(
value = "INVOKE",
target = "net/minecraftforge/client/event/RenderGameOverlayEvent$Text.<init>(Lnet/minecraftforge/client/event/RenderGameOverlayEvent;Ljava/util/ArrayList;Ljava/util/ArrayList;)V"),
remap = false)
private void angelica$startF3TextBatching(int width, int height, CallbackInfo ci) {
FontRendererAccessor fra = (FontRendererAccessor) (Object) fontrenderer;
fra.angelica$getBatcher().beginBatch();
}
@Inject(
method = "renderHUDText",
at = @At(value = "INVOKE", target = "net/minecraft/profiler/Profiler.endSection()V"))
private void angelica$endF3TextBatching(int width, int height, CallbackInfo ci) {
FontRendererAccessor fra = (FontRendererAccessor) (Object) fontrenderer;
fra.angelica$getBatcher().endBatch();
}
}
@@ -1,18 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Invoker;
import net.minecraft.client.gui.GuiIngame;
@Mixin(GuiIngame.class)
public interface GuiIngameAccessor {
@Invoker
void callRenderVignette(float brightness, int width, int height);
@Invoker
void callRenderPumpkinBlur(int width, int height);
@Invoker("func_130015_b")
void callRenderPortal(float partialTicks, int width, int height);
}
@@ -1,19 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import net.minecraft.client.gui.GuiIngame;
import net.minecraft.client.renderer.EntityRenderer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(value = EntityRenderer.class)
public class MixinEntityRenderer_HUDCaching {
@Redirect(
method = "updateCameraAndRender",
at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/GuiIngame;renderGameOverlay(FZII)V"))
public void angelica$renderCachedHUD(GuiIngame guiIngame, float partialTicks, boolean b, int i, int j) {
HUDCaching.renderCachedHud((EntityRenderer) (Object) this, guiIngame, partialTicks, b, i, j);
}
}
@@ -1,23 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import net.minecraft.client.Minecraft;
import net.minecraft.client.shader.Framebuffer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(Framebuffer.class)
public class MixinFramebuffer_HUDCaching {
@Inject(method = "bindFramebuffer", at = @At("HEAD"), cancellable = true)
public void angelica$bindHUDCachingBuffer(boolean viewport, CallbackInfo ci) {
final Framebuffer framebuffer = (Framebuffer) (Object) this;
if (HUDCaching.renderingCacheOverride && framebuffer == Minecraft.getMinecraft().getFramebuffer()) {
HUDCaching.framebuffer.bindFramebuffer(viewport);
ci.cancel();
}
}
}
@@ -1,61 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import net.minecraft.client.gui.ScaledResolution;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import net.minecraft.client.gui.Gui;
import net.minecraftforge.client.GuiIngameForge;
@Mixin(GuiIngameForge.class)
public class MixinGuiIngameForge_HUDCaching {
@Inject(method = "renderGameOverlay", at = @At("HEAD"))
private void angelica$resetCaptures(CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderVignetteCaptured = false;
HUDCaching.renderHelmetCaptured = false;
HUDCaching.renderPortalCapturedTicks = -1;
HUDCaching.renderCrosshairsCaptured = false;
}
}
@Inject(method = "renderCrosshairs", at = @At("HEAD"), cancellable = true, remap = false)
private void angelica$captureRenderCrosshair(CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderCrosshairsCaptured = true;
HUDCaching.fixGLStateBeforeRenderingCache();
ci.cancel();
}
}
@Inject(method = "renderHelmet", at = @At("HEAD"), cancellable = true, remap = false)
private void angelica$captureRenderHelmet(ScaledResolution res, float partialTicks, boolean hasScreen, int mouseX, int mouseY, CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderHelmetCaptured = true;
ci.cancel();
}
HUDCaching.disableHoloInventory();
}
@Inject(method = "renderPortal", at = @At("HEAD"), cancellable = true, remap = false)
private void angelica$captureRenderPortal(int width, int height, float partialTicks, CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderPortalCapturedTicks = partialTicks;
ci.cancel();
}
}
@Inject(method = "renderBossHealth", at = @At("HEAD"))
private void angelica$bindBossHealthTexture(CallbackInfo ci) {
// boss health texture is bind in renderCrosshairs
// but HUD caching skips rendering crosshairs when rendering into cache
if (HUDCaching.renderingCacheOverride) {
((GuiIngameForgeAccessor) this).callBind(Gui.icons);
}
}
}
@@ -1,61 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiIngame;
@Mixin(GuiIngame.class)
public class MixinGuiIngame_HUDCaching {
@Inject(method = "renderGameOverlay", at = @At("HEAD"))
private void angelica$resetCaptures(CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderVignetteCaptured = false;
HUDCaching.renderHelmetCaptured = false;
HUDCaching.renderPortalCapturedTicks = -1;
// GuiIngame doesn't allow a clean way to capture crosshair
}
}
@Inject(method = "renderVignette", at = @At("HEAD"), cancellable = true)
private void angelica$captureRenderVignette(CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderVignetteCaptured = true;
ci.cancel();
}
}
@Inject(method = "renderPumpkinBlur", at = @At("HEAD"), cancellable = true)
private void angelica$captureRenderPumpkimBlur(CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderHelmetCaptured = true;
ci.cancel();
}
}
@Inject(method = "func_130015_b", at = @At("HEAD"), cancellable = true)
private void angelica$captureRenderPortal(float partialTicks, int width, int height, CallbackInfo ci) {
if (HUDCaching.renderingCacheOverride) {
HUDCaching.renderPortalCapturedTicks = partialTicks;
ci.cancel();
}
}
@WrapOperation(method = "func_96136_a", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/FontRenderer;drawString(Ljava/lang/String;III)I"))
private int angelica$fixScoreboardTextAlpha(FontRenderer fontRenderer, String text, int x, int y, int color, Operation<Integer> op) {
// Vanilla uses 0x20 for the alpha but it looks like 0xFF for some reason
// here we just make it 0xFF so it doesn't cause issues
if (HUDCaching.renderingCacheOverride) {
color |= 0xFF000000;
}
return op.call(fontRenderer, text, x, y, color);
}
}
@@ -1,57 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import com.gtnewhorizons.angelica.mixins.dummy.DummyTessellator;
import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderItem;
import org.lwjgl.opengl.GL11;
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.injection.Slice;
import static org.lwjgl.opengl.GL11.GL_LIGHTING;
@Mixin(RenderItem.class)
public class MixinRenderItem {
@ModifyExpressionValue(
method = "renderItemIntoGUI(Lnet/minecraft/client/gui/FontRenderer;Lnet/minecraft/client/renderer/texture/TextureManager;Lnet/minecraft/item/ItemStack;IIZ)V",
at = @At(value = "FIELD", target = "Lnet/minecraft/client/renderer/Tessellator;instance:Lnet/minecraft/client/renderer/Tessellator;")
)
private Tessellator angelica$neuterTesselator(Tessellator useless) {
return DummyTessellator.instance;
}
@Redirect(
method = "renderItemIntoGUI(Lnet/minecraft/client/gui/FontRenderer;Lnet/minecraft/client/renderer/texture/TextureManager;Lnet/minecraft/item/ItemStack;IIZ)V",
at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glDisable(I)V", remap = false),
slice = @Slice(
from = @At(value = "INVOKE", target = "Lnet/minecraft/item/Item;requiresMultipleRenderPasses()Z"),
to = @At(value = "INVOKE", target = "Lnet/minecraft/item/ItemStack;getItem()Lnet/minecraft/item/Item;", ordinal = 4)
)
)
private void angelica$neuterGlDisable(int cap) {
if (cap == GL_LIGHTING) GL11.glDisable(cap);
}
@Redirect(
method = "renderItemIntoGUI(Lnet/minecraft/client/gui/FontRenderer;Lnet/minecraft/client/renderer/texture/TextureManager;Lnet/minecraft/item/ItemStack;IIZ)V",
at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glEnable(I)V", remap = false),
slice = @Slice(
from = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/Tessellator;startDrawingQuads()V", ordinal = 0),
to = @At(value = "INVOKE", target = "Lnet/minecraft/item/ItemStack;getItem()Lnet/minecraft/item/Item;", ordinal = 4)
)
)
private void angelica$neuterGlEnable(int cap) {}
@Redirect(
method = "renderItemIntoGUI(Lnet/minecraft/client/gui/FontRenderer;Lnet/minecraft/client/renderer/texture/TextureManager;Lnet/minecraft/item/ItemStack;IIZ)V",
at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glColorMask(ZZZZ)V", remap = false),
slice = @Slice(
from = @At(value = "INVOKE", target = "Lnet/minecraft/item/Item;requiresMultipleRenderPasses()Z"),
to = @At(value = "INVOKE", target = "Lnet/minecraft/item/ItemStack;getItem()Lnet/minecraft/item/Item;", ordinal = 4)
)
)
private void angelica$neuterGlColorMask(boolean red, boolean green, boolean blue, boolean alpha) {}
}
@@ -1,22 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraftforge.client.event.RenderGameOverlayEvent;
import net.minecraftforge.event.terraingen.BiomeEvent;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Accessor;
@Mixin(RenderGameOverlayEvent.class)
public interface RenderGameOverlayEventAccessor {
@Accessor(value = "partialTicks", remap = false)
void setPartialTicks(float value);
@Accessor(value = "resolution", remap = false)
void setResolution(ScaledResolution resolution);
@Accessor(value = "mouseX", remap = false)
void setMouseX(int mouseX);
@Accessor(value = "mouseY", remap = false)
void setMouseY(int mouseY);
}
@@ -1,39 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.lighting;
import com.llamalad7.mixinextras.sugar.Share;
import com.llamalad7.mixinextras.sugar.ref.LocalIntRef;
import net.minecraft.world.EnumSkyBlock;
import net.minecraft.world.World;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Constant;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyConstant;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
/**
* This mixin is a backport of a Forge fix https://github.com/MinecraftForge/MinecraftForge/pull/4729
*/
@Mixin(World.class)
public abstract class MixinWorld_FixLightUpdateLag {
@Shadow
public abstract boolean doChunksNearChunkExist(int p_72873_1_, int p_72873_2_, int p_72873_3_, int p_72873_4_);
@ModifyConstant(method = "updateLightByType", constant = @Constant(intValue = 17, ordinal = 0))
public int angelica$modifyRangeCheck1(int cst) {
return 16;
}
@Inject(method = "updateLightByType", at = @At(value = "FIELD", target = "Lnet/minecraft/world/World;theProfiler:Lnet/minecraft/profiler/Profiler;", shift = At.Shift.BEFORE, ordinal = 0))
public void angelica$modifyUpdateRange(EnumSkyBlock p_147463_1_, int x, int y, int z,
CallbackInfoReturnable<Boolean> cir, @Share("updateRange") LocalIntRef updateRange) {
updateRange.set(this.doChunksNearChunkExist(x, y, z, 18) ? 17 : 15);
}
@ModifyConstant(method = "updateLightByType", constant = { @Constant(intValue = 17, ordinal = 1), @Constant(intValue = 17, ordinal = 2) })
public int angelica$modifyRangeCheck2(int cst, @Share("updateRange") LocalIntRef updateRange) {
return updateRange.get();
}
}
@@ -1,38 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.mixins.interfaces.ModeledBlock;
import lombok.Getter;
import lombok.Setter;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import static com.gtnewhorizons.angelica.models.VanillaModels.*;
@Mixin(Block.class)
public abstract class MixinBlock implements ModeledBlock {
@Getter
@Setter
private QuadProvider model = null;
@Inject(method = "registerBlocks", at = @At(value = "TAIL"))
private static void angelica$registerInjectedQP(CallbackInfo ci) {
if (!AngelicaConfig.injectQPRendering)
return;
((ModeledBlock) Blocks.stone).setModel(STONE);
((ModeledBlock) Blocks.glass).setModel(GLASS);
((ModeledBlock) Blocks.crafting_table).setModel(WORKBENCH);
((ModeledBlock) Blocks.leaves).setModel(OLD_LEAF);
((ModeledBlock) Blocks.leaves2).setModel(NEW_LEAF);
((ModeledBlock) Blocks.log).setModel(OLD_LOG);
((ModeledBlock) Blocks.log2).setModel(NEW_LOG);
}
}
@@ -1,20 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.models;
import com.gtnewhorizons.angelica.utils.AssetLoader;
import net.minecraft.block.BlockOldLeaf;
import net.minecraft.client.renderer.texture.IIconRegister;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(BlockOldLeaf.class)
public abstract class MixinBlockOldLeaf {
@Inject(method = "registerBlockIcons", at = @At(value = "TAIL"))
public void angelica$injectTextures(IIconRegister reg, CallbackInfo ci) {
for (String s : AssetLoader.injectTexs) {
reg.registerIcon(s);
}
}
}
@@ -1,49 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.optimizations;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import net.minecraft.client.renderer.entity.RendererLivingEntity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.MathHelper;
import org.lwjgl.opengl.GL11;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
@Mixin(RendererLivingEntity.class)
public abstract class MixinRendererLivingEntity {
@Shadow protected abstract float getDeathMaxRotation(EntityLivingBase entity);
/**
* @author mitchej123
* @reason The vanilla method triggers way too many allocations for no good reason
*/
@Overwrite
protected void rotateCorpse(EntityLivingBase entity, float p_77043_2_, float p_77043_3_, float partialTicks) {
GLStateManager.glRotatef(180.0F - p_77043_3_, 0.0F, 1.0F, 0.0F);
if (entity.deathTime > 0) {
float f3 = ((float)entity.deathTime + partialTicks - 1.0F) / 20.0F * 1.6F;
f3 = MathHelper.sqrt_float(f3);
if (f3 > 1.0F) {
f3 = 1.0F;
}
GL11.glRotatef(f3 * this.getDeathMaxRotation(entity), 0.0F, 0.0F, 1.0F);
}
else if ((entity instanceof EntityLiving entityLiving) && entityLiving.hasCustomNameTag() || (entity instanceof EntityPlayer entityPlayer) && !entityPlayer.getHideCape()) {
final String s = EnumChatFormatting.getTextWithoutFormattingCodes(entity.getCommandSenderName());
if ((s.equals("Dinnerbone") || s.equals("Grumm"))) {
GLStateManager.glTranslatef(0.0F, entity.height + 0.1F, 0.0F);
GLStateManager.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
}
}
}
}
@@ -1,17 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.startup;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import net.minecraft.client.renderer.OpenGlHelper;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(value = OpenGlHelper.class, priority = 100)
public class MixinInitGLStateManager {
@Inject(method = "initializeTextures", at = @At("RETURN"))
private static void angelica$initializeGLStateManager(CallbackInfo ci) {
GLStateManager.preInit();
GLStateManager.init();
}
}
@@ -1,34 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.textures;
import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.resources.data.AnimationMetadataSection;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
@Mixin(TextureAtlasSprite.class)
public abstract class MixinTextureAtlasSprite implements ISpriteExt {
@Shadow
private AnimationMetadataSection animationMetadata;
@Shadow
protected int frameCounter;
@Override
public boolean isAnimation() {
return animationMetadata != null && animationMetadata.getFrameCount() > 1;
}
@Override
public int getFrame() {
return frameCounter;
}
@Override
public void callUpload(int frameIndex) {}
@Override
public AnimationMetadataSection getMetadata() {
return animationMetadata;
}
}
@@ -1,15 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.textures;
import net.minecraft.client.renderer.texture.TextureUtil;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(TextureUtil.class)
public class MixinTextureUtil {
@Redirect(method = "allocateTextureImpl", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/texture/TextureUtil;deleteTexture(I)V"))
private static void angelica$dontDeleteTexture(int textureId) {
// NO-OP - Not sure why it's deleting a texture that was just generated and subsequently being bound...
}
}
@@ -1,71 +0,0 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.textures;
import com.gtnewhorizons.angelica.utils.Mipmaps;
import net.minecraft.client.renderer.texture.TextureUtil;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
@Mixin(TextureUtil.class)
public class MixinTextureUtil_OptimizeMipmap {
/**
* @author SuperCoder79
* @reason Rewrite mipmap color math to use memoized value array instead of using Math.pow directly
*/
@Overwrite
private static int func_147943_a(int one, int two, int three, int four, boolean alpha) {
if (!alpha) {
final int a = Mipmaps.getColorComponent(one, two, three, four, 24);
final int r = Mipmaps.getColorComponent(one, two, three, four, 16);
final int g = Mipmaps.getColorComponent(one, two, three, four, 8);
final int b = Mipmaps.getColorComponent(one, two, three, four, 0);
return a << 24 | r << 16 | g << 8 | b;
} else {
float a = 0.0F;
float r = 0.0F;
float g = 0.0F;
float b = 0.0F;
if (one >> 24 != 0) {
a += Mipmaps.get(one >> 24);
r += Mipmaps.get(one >> 16);
g += Mipmaps.get(one >> 8);
b += Mipmaps.get(one >> 0);
}
if (two >> 24 != 0) {
a += Mipmaps.get(two >> 24);
r += Mipmaps.get(two >> 16);
g += Mipmaps.get(two >> 8);
b += Mipmaps.get(two >> 0);
}
if (three >> 24 != 0) {
a += Mipmaps.get(three >> 24);
r += Mipmaps.get(three >> 16);
g += Mipmaps.get(three >> 8);
b += Mipmaps.get(three >> 0);
}
if (four >> 24 != 0) {
a += Mipmaps.get(four >> 24);
r += Mipmaps.get(four >> 16);
g += Mipmaps.get(four >> 8);
b += Mipmaps.get(four >> 0);
}
a /= 4.0F;
r /= 4.0F;
g /= 4.0F;
b /= 4.0F;
int ia = (int) (Math.pow((double) a, 0.45454545454545453) * 255.0);
final int ir = (int) (Math.pow((double) r, 0.45454545454545453) * 255.0);
final int ig = (int) (Math.pow((double) g, 0.45454545454545453) * 255.0);
final int ib = (int) (Math.pow((double) b, 0.45454545454545453) * 255.0);
if (ia < 96) {
ia = 0;
}
return ia << 24 | ir << 16 | ig << 8 | ib;
}
}
}
Loaded 100 of 404 files, more files were not shown because too many files have changed in this diff. Show more