More work on magic glows to try and get them looking right

src/main/java/com/minelittlepony/client/render/LevitatingItemRenderer.java

@@ -8,6 +8,7 @@ import com.minelittlepony.client.util.render.RenderLayerUtil;
 
 import org.jetbrains.annotations.Nullable;
 
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.render.*;
 import net.minecraft.client.render.item.ItemRenderer;
 import net.minecraft.client.render.model.json.ModelTransformationMode;
@@ -18,17 +19,18 @@ import net.minecraft.item.*;
 import net.minecraft.registry.Registries;
 import net.minecraft.screen.PlayerScreenHandler;
 import net.minecraft.util.UseAction;
+import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.RotationAxis;
 import net.minecraft.world.World;
 
 public class LevitatingItemRenderer {
-    private VertexConsumerProvider getProvider(Pony pony, VertexConsumerProvider renderContext) {
+    private VertexConsumerProvider getProvider(Pony pony, VertexConsumerProvider provider) {
         final int color = pony.metadata().glowColor();
         return layer -> {
             if (layer.getVertexFormat() != VertexFormats.POSITION_COLOR_TEXTURE_OVERLAY_LIGHT_NORMAL) {
-                return renderContext.getBuffer(layer);
+                return provider.getBuffer(layer);
             }
-            return renderContext.getBuffer(MagicGlow.getColoured(RenderLayerUtil.getTexture(layer).orElse(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE), color));
+            return provider.getBuffer(MagicGlow.getColoured(RenderLayerUtil.getTexture(layer).orElse(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE), color));
         };
     }
 
@@ -62,12 +64,20 @@ public class LevitatingItemRenderer {
                             stack.set(DataComponentTypes.ENCHANTMENT_GLINT_OVERRIDE, false);
                         }
 
-                        matrix.scale(1.1F, 1.1F, 1.1F);
+                        float tickDelta = MinecraftClient.getInstance().getTickDelta() + entity.age;
-                        matrix.translate(0.015F, 0.01F, 0.01F);
+
+
+                        float driftStrength = 0.002F;
+                        float xDrift = MathHelper.sin(tickDelta / 20F) * driftStrength;
+                        float zDrift = MathHelper.cos((tickDelta + 20) / 20F) * driftStrength;
+
+                        float scale = 1.1F + (MathHelper.sin(tickDelta / 20F) + 1) * driftStrength;
+                        matrix.scale(scale, scale, scale);
+                        matrix.translate(0.015F + xDrift, 0.01F, 0.01F + zDrift);
 
                         itemRenderer.renderItem(entity, stack, mode, left, matrix, interceptedContext, world, lightUv, OverlayTexture.DEFAULT_UV, posLong);
-                        matrix.scale(1.1F, 1.1F, 1.1F);
+                        matrix.scale(scale, scale, scale);
-                        matrix.translate(-0.03F, -0.02F, -0.02F);
+                        matrix.translate(-0.03F - xDrift, -0.02F, -0.02F - zDrift);
                         itemRenderer.renderItem(entity, stack, mode, left, matrix, interceptedContext, world, lightUv, OverlayTexture.DEFAULT_UV, posLong);
                     }
 

src/main/java/com/minelittlepony/client/render/MagicGlow.java

@@ -30,6 +30,7 @@ public abstract class MagicGlow extends RenderPhase {
             .transparency(LIGHTNING_TRANSPARENCY)
             .lightmap(DISABLE_LIGHTMAP)
             .cull(DISABLE_CULLING)
+            .layering(VIEW_OFFSET_Z_LAYERING)
             .build(false));
     });
 
@@ -42,6 +43,7 @@ public abstract class MagicGlow extends RenderPhase {
                 .transparency(LIGHTNING_TRANSPARENCY)
                 .lightmap(DISABLE_LIGHTMAP)
                 .cull(DISABLE_CULLING)
+                .layering(VIEW_OFFSET_Z_LAYERING)
                 .build(true));
     });
 

src/main/java/com/minelittlepony/client/render/OffsetVertexConsumer.java

@@ -0,0 +1,98 @@
+package com.minelittlepony.client.render;
+
+import net.minecraft.client.render.VertexConsumer;
+
+import org.joml.Vector3f;
+
+// TODO: This works but it only outsets the faces making them look disjointed. We need to scale the vertices relative to the quad center as well.
+public class OffsetVertexConsumer implements VertexConsumer {
+
+    private final VertexConsumer delegate;
+
+    private double x, y, z;
+    private int r, g, b, a;
+    private float textureU, textureV;
+    private int overlayU, overlayV;
+    private int lightU, lightV;
+    private float normalX, normalY, normalZ;
+
+    private final Vector3f normalVector = new Vector3f();
+
+    private final float offsetDistance;
+
+    public OffsetVertexConsumer(VertexConsumer delegate, float offsetDistance) {
+        this.delegate = delegate;
+        this.offsetDistance = offsetDistance;
+    }
+
+    @Override
+    public VertexConsumer vertex(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+
+    @Override
+    public VertexConsumer color(int red, int green, int blue, int alpha) {
+        r = red;
+        g = green;
+        b = blue;
+        a = alpha;
+        return this;
+    }
+
+    @Override
+    public VertexConsumer texture(float u, float v) {
+        textureU = u;
+        textureV = v;
+        return this;
+    }
+
+    @Override
+    public VertexConsumer overlay(int u, int v) {
+        overlayU = u;
+        overlayV = v;
+        return this;
+    }
+
+    @Override
+    public VertexConsumer light(int u, int v) {
+        lightU = u;
+        lightV = v;
+        return this;
+    }
+
+    @Override
+    public VertexConsumer normal(float x, float y, float z) {
+        normalX = x;
+        normalY = y;
+        normalZ = z;
+        return this;
+    }
+
+    @Override
+    public void next() {
+        normalVector.set(normalX, normalY, normalZ).normalize(offsetDistance);
+        delegate.vertex(
+                (normalVector.x + (float)x),
+                (normalVector.y + (float)y),
+                (normalVector.z + (float)z),
+                r / 255F, g / 255F, b / 255F, a / 255F,
+                textureU, textureV,
+                overlayU | overlayV << 16,
+                lightU | lightV << 16,
+                normalX, normalY, normalZ
+        );
+    }
+
+    @Override
+    public void fixedColor(int red, int green, int blue, int alpha) {
+        delegate.fixedColor(red, green, blue, alpha);
+    }
+
+    @Override
+    public void unfixColor() {
+        delegate.unfixColor();
+    }
+}