Compare commits

...
Author SHA1 Message Date
Darren Eberly 8c90f79c17 Add reserved keywords and replace GLSLPreParser with regex (#683)
* Add reserved keywords and replace GLSLPreParser with regex

* Add a newline to the version directive in patched shader output

* Only process reserved keywords on GLSL < 400

* Better reserved keyword handling
2024-10-28 16:21:05 -07:00
kurrycat e4e657846d implement Iris HandRenderer (#681) 2024-10-28 16:20:00 -07:00
Darren Eberly 2dace708b4 Get frame start time properly for Iris (#682) 2024-10-28 11:12:57 -07:00
7 changed files with 229 additions and 132 deletions

No files matched your search

@@ -143,6 +143,7 @@ public enum Mixins {
,"shaders.MixinGuiIngameForge"
,"shaders.MixinFramebuffer"
,"shaders.MixinItem"
,"shaders.MixinItemRenderer"
,"shaders.MixinLocale"
,"shaders.MixinOpenGlHelper"
,"shaders.MixinRender"
@@ -2,157 +2,181 @@ package net.coderbot.iris.pipeline;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.mojang.InteractionHand;
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.irisshaders.iris.api.v0.IrisApi;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderGlobal;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.Project;
import org.joml.Matrix4f;
import java.util.Map;
public class HandRenderer {
public static final HandRenderer INSTANCE = new HandRenderer();
public static final HandRenderer INSTANCE = new HandRenderer();
private boolean ACTIVE;
private boolean renderingSolid;
public static final float DEPTH = 0.125F;
private boolean ACTIVE;
private boolean renderingSolid;
public static final float DEPTH = 0.125F;
private void setupGlState(RenderGlobal gameRenderer, Camera camera, MatrixStack poseStack, float tickDelta) {
// final MatrixStack.Entry pose = poseStack.peek();
private void setupGlState(RenderGlobal gameRenderer, Camera camera, float tickDelta) {
Minecraft mc = Minecraft.getMinecraft();
// We need to scale the matrix by 0.125 so the hand doesn't clip through blocks.
// Matrix4f scaleMatrix = new Matrix4f().scale(1F, 1F, DEPTH);
// TODO: ProjectionMatrix
// scaleMatrix.multiply(gameRenderer.getProjectionMatrix(camera, tickDelta, false));
// scaleMatrix.mul(projectionMatrix);
// RenderSystem.matrixMode(5889);
// RenderSystem.loadIdentity();
// RenderSystem.multMatrix(arg);
// RenderSystem.matrixMode(5888);
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();
// We need to scale the matrix by 0.125 so the hand doesn't clip through blocks.
GL11.glScalef(1.0F, 1.0F, DEPTH);
// pose.getModel().identity();
// pose.getNormal().identity();
// TODO: Anaglyph
/*if (this.mc.gameSettings.anaglyph) {
GL11.glTranslatef((float) (-(anaglyphChannel * 2 - 1)) * 0.07F, 0.0F, 0.0F);
}*/
// gameRenderer.invokeBobHurt(poseStack, tickDelta);
//
// if (Minecraft.getMinecraft().gameSettings.viewBobbing) {
//// gameRenderer.invokeBobView(poseStack, tickDelta);
// }
}
if (mc.entityRenderer.cameraZoom != 1.0D) {
GL11.glTranslatef((float) mc.entityRenderer.cameraYaw, (float) (-mc.entityRenderer.cameraPitch), 0.0F);
GL11.glScaled(mc.entityRenderer.cameraZoom, mc.entityRenderer.cameraZoom, 1.0D);
}
private boolean canRender(Camera camera, RenderGlobal gameRenderer) {
return (camera.isThirdPerson() || !(camera.getEntity() instanceof EntityPlayer) || Minecraft.getMinecraft().gameSettings.hideGUI || (camera.getEntity() instanceof EntityLiving && ((EntityLiving)camera.getEntity()).isPlayerSleeping()));
Project.gluPerspective(mc.entityRenderer.getFOVModifier(tickDelta, false), (float) mc.displayWidth / (float) mc.displayHeight, 0.05F, mc.entityRenderer.farPlaneDistance * 2.0F);
// return !(!gameRenderer.getRenderHand()
// || camera.isThirdPerson()
// || !(camera.getEntity() instanceof EntityPlayer)
// || gameRenderer.getPanoramicMode()
// || Minecraft.getMinecraft().gameSettings.hideGUI
// || (camera.getEntity() instanceof EntityLiving && ((EntityLiving)camera.getEntity()).isPlayerSleeping())
// // TODO: SPECTATOR
// /*|| Minecraft.getMinecraft().gameMode.getPlayerMode() == GameType.SPECTATOR*/);
}
public boolean isHandTranslucent(InteractionHand hand) {
if (mc.playerController.enableEverythingIsScrewedUpMode()) {
GL11.glScalef(1.0F, 2 / 3f, 1.0F);
}
GL11.glMatrixMode(GL11.GL_MODELVIEW);
GL11.glLoadIdentity();
// TODO: Anaglyph
/*if (mc.gameSettings.anaglyph) {
GL11.glTranslatef((float) (anaglyphChannel * 2 - 1) * 0.1F, 0.0F, 0.0F);
}*/
mc.entityRenderer.hurtCameraEffect(tickDelta);
if (mc.gameSettings.viewBobbing) {
mc.entityRenderer.setupViewBobbing(tickDelta);
}
}
private boolean canRender(Camera camera, RenderGlobal gameRenderer) {
Minecraft mc = Minecraft.getMinecraft();
return mc.entityRenderer.debugViewDirection <= 0 &&
mc.gameSettings.thirdPersonView == 0 &&
!camera.getEntity().isPlayerSleeping() &&
!mc.gameSettings.hideGUI &&
// TODO: SPECTATOR
// mc.playerController.currentGameType
!mc.playerController.enableEverythingIsScrewedUpMode();
}
public boolean isHandTranslucent(InteractionHand hand) {
// TODO: Offhand
// Item item = Minecraft.getMinecraft().thePlayer.getItemBySlot(hand == InteractionHand.OFF_HAND ? EquipmentSlot.OFFHAND : EquipmentSlot.MAINHAND).getItem();
ItemStack heldItem = Minecraft.getMinecraft().thePlayer.getHeldItem();
if (heldItem == null) {
return false;
}
Item item = heldItem.getItem();
if (item instanceof ItemBlock itemBlock) {
// TODO: RenderType
// return ItemBlockRenderTypes.getChunkRenderType(itemBlock.getBlock().defaultBlockState()) == RenderType.translucent();
return false;
}
}
Item item = heldItem.getItem();
return false;
}
if (item instanceof ItemBlock itemBlock) {
Map<Block, RenderLayer> blockTypeIds = BlockRenderingSettings.INSTANCE.getBlockTypeIds();
return blockTypeIds != null && blockTypeIds.get(itemBlock.field_150939_a) == RenderLayer.translucent();
}
public boolean isAnyHandTranslucent() {
return isHandTranslucent(InteractionHand.MAIN_HAND) || isHandTranslucent(InteractionHand.OFF_HAND);
}
return false;
}
public void renderSolid(MatrixStack poseStack, float tickDelta, Camera camera, RenderGlobal gameRenderer, WorldRenderingPipeline pipeline) {
if (!canRender(camera, gameRenderer) || !IrisApi.getInstance().isShaderPackInUse()) {
return;
}
public boolean isAnyHandTranslucent() {
return isHandTranslucent(InteractionHand.MAIN_HAND) || isHandTranslucent(InteractionHand.OFF_HAND);
}
ACTIVE = true;
public void renderSolid(float tickDelta, Camera camera, RenderGlobal gameRenderer, WorldRenderingPipeline pipeline) {
if (!canRender(camera, gameRenderer) || !IrisApi.getInstance().isShaderPackInUse()) {
return;
}
Minecraft mc = Minecraft.getMinecraft();
pipeline.setPhase(WorldRenderingPhase.HAND_SOLID);
ACTIVE = true;
// poseStack.push();
pipeline.setPhase(WorldRenderingPhase.HAND_SOLID);
Minecraft.getMinecraft().mcProfiler.startSection("iris_hand");
GL11.glPushMatrix();
GL11.glDepthMask(true); // actually write to the depth buffer, it's normally disabled at this point
// TODO: Iris
// setupGlState(gameRenderer, camera, poseStack, tickDelta);
mc.mcProfiler.startSection("iris_hand");
renderingSolid = true;
// TODO: Hand
// Minecraft.getMinecraft().getItemInHandRenderer().renderHandsWithItems(tickDelta, poseStack, bufferSource, Minecraft.getMinecraft().thePlayer, Minecraft.getMinecraft().getEntityRenderDispatcher().getPackedLightCoords(camera.getEntity(), tickDelta));
setupGlState(gameRenderer, camera, tickDelta);
Minecraft.getMinecraft().mcProfiler.endSection();
renderingSolid = true;
mc.entityRenderer.enableLightmap(tickDelta);
mc.entityRenderer.itemRenderer.renderItemInFirstPerson(tickDelta);
mc.entityRenderer.disableLightmap(tickDelta);
// TODO: ProjectionMatrix
// gameRenderer.resetProjectionMatrix(CapturedRenderingState.INSTANCE.getGbufferProjection());
GL11.glDepthMask(false);
GL11.glPopMatrix();
// poseStack.pop();
mc.mcProfiler.endSection();
// bufferSource.endBatch();
resetProjectionMatrix();
renderingSolid = false;
renderingSolid = false;
pipeline.setPhase(WorldRenderingPhase.NONE);
pipeline.setPhase(WorldRenderingPhase.NONE);
ACTIVE = false;
}
ACTIVE = false;
}
public void renderTranslucent(MatrixStack poseStack, float tickDelta, Camera camera, RenderGlobal gameRenderer, WorldRenderingPipeline pipeline) {
if (!canRender(camera, gameRenderer) || !isAnyHandTranslucent() || !IrisApi.getInstance().isShaderPackInUse()) {
return;
}
// TODO: RenderType
public void renderTranslucent(float tickDelta, Camera camera, RenderGlobal gameRenderer, WorldRenderingPipeline pipeline) {
if (!canRender(camera, gameRenderer) || !isAnyHandTranslucent() || !IrisApi.getInstance().isShaderPackInUse()) {
return;
}
Minecraft mc = Minecraft.getMinecraft();
ACTIVE = true;
ACTIVE = true;
pipeline.setPhase(WorldRenderingPhase.HAND_TRANSLUCENT);
pipeline.setPhase(WorldRenderingPhase.HAND_TRANSLUCENT);
poseStack.push();
GL11.glPushMatrix();
Minecraft.getMinecraft().mcProfiler.startSection("iris_hand_translucent");
mc.mcProfiler.startSection("iris_hand_translucent");
setupGlState(gameRenderer, camera, poseStack, tickDelta);
setupGlState(gameRenderer, camera, tickDelta);
// TODO: Hand
// Minecraft.getMinecraft().getItemInHandRenderer().renderHandsWithItems(tickDelta, poseStack, bufferSource, Minecraft.getMinecraft().thePlayer, Minecraft.getMinecraft().getEntityRenderDispatcher().getPackedLightCoords(camera.getEntity(), tickDelta));
mc.entityRenderer.enableLightmap(tickDelta);
mc.entityRenderer.itemRenderer.renderItemInFirstPerson(tickDelta);
mc.entityRenderer.disableLightmap(tickDelta);
poseStack.pop();
GL11.glPopMatrix();
Minecraft.getMinecraft().mcProfiler.endSection();
resetProjectionMatrix();
// TODO: ProjectionMatrix
// gameRenderer.resetProjectionMatrix(CapturedRenderingState.INSTANCE.getGbufferProjection());
Minecraft.getMinecraft().mcProfiler.endSection();
// bufferSource.endBatch();
pipeline.setPhase(WorldRenderingPhase.NONE);
pipeline.setPhase(WorldRenderingPhase.NONE);
ACTIVE = false;
}
ACTIVE = false;
}
private void resetProjectionMatrix() {
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();
GL11.glMultMatrix(RenderingState.INSTANCE.getProjectionBuffer());
GL11.glMatrixMode(GL11.GL_MODELVIEW);
}
public boolean isActive() {
return ACTIVE;
}
public boolean isRenderingSolid() {
return renderingSolid;
}
public boolean isActive() {
return ACTIVE;
}
public boolean isRenderingSolid() {
return renderingSolid;
}
}
@@ -6,7 +6,6 @@ import net.coderbot.iris.Iris;
import net.coderbot.iris.gl.shader.ShaderType;
import net.coderbot.iris.pipeline.transform.parameter.Parameters;
import net.coderbot.iris.pipeline.transform.parameter.AttributeParameters;
import org.antlr.v4.runtime.BufferedTokenStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
@@ -14,20 +13,34 @@ import org.antlr.v4.runtime.tree.TerminalNode;
import org.taumc.glsl.Util;
import org.taumc.glsl.grammar.GLSLLexer;
import org.taumc.glsl.grammar.GLSLParser;
import org.taumc.glsl.grammar.GLSLPreParser;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ShaderTransformer {
static String tab = "";
private static final Pattern versionPattern = Pattern.compile("#version\\s+(\\d+)(?:\\s+(\\w+))?");
private static final int CACHE_SIZE = 100;
private static final Object2ObjectLinkedOpenHashMap<TransformKey, Map<PatchShaderType, String>> shaderTransformationCache = new Object2ObjectLinkedOpenHashMap<>();
private static final boolean useCache = true;
private static final List<String> fullReservedWords = new ArrayList<>();
private static final Map<Integer, List<String>> versionedReservedWords = new HashMap<>();;
static {
fullReservedWords.add("texture");
versionedReservedWords.put(400, Arrays.asList("sample"));
}
private static final class TransformKey<P extends Parameters> {
private final Patch patchType;
private final EnumMap<PatchShaderType, String> inputs;
@@ -117,34 +130,50 @@ public class ShaderTransformer {
if (inputs.get(type) == null) {
continue;
}
GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(inputs.get(type)));
GLSLPreParser preParser = new GLSLPreParser(new BufferedTokenStream(lexer));
GLSLParser parser = new GLSLParser(new CommonTokenStream(lexer));
parser.setBuildParseTree(true);
var pre = preParser.translation_unit();
var translationUnit = parser.translation_unit();
var preparsed = pre.compiler_directive();
String profile = "";
String versionString = "0";
GLSLPreParser.Compiler_directiveContext version = null;
for (var entry: preparsed) {
if (entry.version_directive() != null) {
version = entry;
if (entry.version_directive().number() != null) {
versionString = entry.version_directive().number().getText();
}
if (entry.version_directive().profile() != null) {
profile = entry.version_directive().profile().getText();
}
}
String input = inputs.get(type);
Matcher matcher = versionPattern.matcher(input);
if (!matcher.find()) {
throw new IllegalArgumentException("No #version directive found in source code!");
}
pre.children.remove(version);
String versionString = matcher.group(1);
if (versionString == null) {
continue;
}
String profileString = "#version " + versionString + " " + profile;
String profile = "";
int versionInt = Integer.parseInt(versionString);
if (versionInt >= 150) {
profile = matcher.group(2);
if (profile == null) {
profile = "core";
}
}
String profileString = "#version " + versionString + " " + profile + "\n";
// This handles some reserved keywords which cause the AST parser to fail
// but aren't necessarily invalid for GLSL versions prior to 400. This simple
// renames the matching strings and prefixes them with iris_renamed_
for (String reservedWord : fullReservedWords) {
String newName = "iris_renamed_" + reservedWord;
input = input.replaceAll("\\b" + reservedWord + "\\b", newName);
}
for (int version : versionedReservedWords.keySet()) {
if (versionInt < version) {
for (String reservedWord : versionedReservedWords.get(version)) {
String newName = "iris_renamed_" + reservedWord;
input = input.replaceAll("\\b" + reservedWord + "\\b", newName);
}
}
}
GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(input));
GLSLParser parser = new GLSLParser(new CommonTokenStream(lexer));
parser.setBuildParseTree(true);
var translationUnit = parser.translation_unit();
switch(patchType) {
case SODIUM_TERRAIN:
@@ -161,7 +190,7 @@ public class ShaderTransformer {
}
CompatibilityTransformer.transformEach(translationUnit, parameters);
types.put(type, translationUnit);
prepatched.put(type, getFormattedShader((ParseTree) pre, profileString));
prepatched.put(type, profileString);
}
CompatibilityTransformer.transformGrouped(types, parameters);
for (var entry : types.entrySet()) {
@@ -1,6 +1,13 @@
public net.minecraft.block.Block func_149641_N()Ljava/lang/String; # getTextureName
public net.minecraft.client.renderer.EntityRenderer func_78476_b(FI)V # void renderHand(float, int)
public net.minecraft.client.renderer.EntityRenderer func_78481_a(FZ)F # float getFOVModifier(float, boolean)
public net.minecraft.client.renderer.EntityRenderer func_78482_e(F)V # void hurtCameraEffect(float)
public net.minecraft.client.renderer.EntityRenderer func_78475_f(F)V # void setupViewBobbing(float)
public net.minecraft.client.renderer.EntityRenderer field_78503_V # cameraZoom
public net.minecraft.client.renderer.EntityRenderer field_78502_W # cameraYaw
public net.minecraft.client.renderer.EntityRenderer field_78509_X # cameraPitch
public net.minecraft.client.renderer.EntityRenderer field_78530_s # farPlaneDistance
public net.minecraft.client.renderer.RenderGlobal field_72765_l # worldRenderers
@@ -12,8 +12,10 @@ import net.coderbot.iris.pipeline.WorldRenderingPhase;
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
import net.coderbot.iris.uniforms.CapturedRenderingState;
import net.coderbot.iris.uniforms.SystemTimeUniforms;
import net.irisshaders.iris.api.v0.IrisApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.renderer.ItemRenderer;
import net.minecraft.client.renderer.RenderGlobal;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.resources.IResourceManagerReloadListener;
@@ -35,7 +37,7 @@ public abstract class MixinEntityRenderer implements IResourceManagerReloadListe
private void iris$beginRender(float partialTicks, long startTime, CallbackInfo ci, @Share("pipeline") LocalRef<WorldRenderingPipeline> pipeline) {
CapturedRenderingState.INSTANCE.setTickDelta(partialTicks);
SystemTimeUniforms.COUNTER.beginFrame();
SystemTimeUniforms.TIMER.beginFrame(startTime);
SystemTimeUniforms.TIMER.beginFrame(System.nanoTime());
Program.unbind();
@@ -44,18 +46,25 @@ public abstract class MixinEntityRenderer implements IResourceManagerReloadListe
pipeline.get().beginLevelRendering();
}
@Inject(method = "renderWorld(FJ)V", at = @At(value = "RETURN", shift = At.Shift.BEFORE))
@Inject(method = "renderWorld(FJ)V", at = @At(value = "INVOKE", target = "Lnet/minecraftforge/client/ForgeHooksClient;dispatchRenderLast(Lnet/minecraft/client/renderer/RenderGlobal;F)V"))
private void iris$endLevelRender(float partialTicks, long limitTime, CallbackInfo callback, @Share("pipeline") LocalRef<WorldRenderingPipeline> pipeline) {
// TODO: Iris
final Camera camera = new Camera(mc.renderViewEntity, partialTicks);
HandRenderer.INSTANCE.renderTranslucent(null /*poseStack*/, partialTicks, camera, mc.renderGlobal, pipeline.get());
HandRenderer.INSTANCE.renderTranslucent(partialTicks, camera, mc.renderGlobal, pipeline.get());
Minecraft.getMinecraft().mcProfiler.endStartSection("iris_final");
pipeline.get().finalizeLevelRendering();
pipeline.set(null);
Program.unbind();
}
@Inject(at = @At(value= "INVOKE", target="Lnet/minecraft/client/renderer/RenderGlobal;clipRenderersByFrustum(Lnet/minecraft/client/renderer/culling/ICamera;F)V", shift=At.Shift.AFTER), method = "renderWorld(FJ)V")
@WrapOperation(method = "renderHand", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/ItemRenderer;renderItemInFirstPerson(F)V"))
private void iris$disableVanillaRenderHand(ItemRenderer instance, float partialTicks, Operation<Void> original) {
if (!IrisApi.getInstance().isShaderPackInUse()) {
original.call(instance, partialTicks);
}
}
@Inject(at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;clipRenderersByFrustum(Lnet/minecraft/client/renderer/culling/ICamera;F)V", shift = At.Shift.AFTER), method = "renderWorld(FJ)V")
private void iris$beginEntities(float partialTicks, long startTime, CallbackInfo ci, @Share("pipeline") LocalRef<WorldRenderingPipeline> pipeline) {
final Camera camera = new Camera(mc.renderViewEntity, partialTicks);
pipeline.get().renderShadows((EntityRenderer) (Object) this, camera);
@@ -0,0 +1,26 @@
package com.gtnewhorizons.angelica.mixins.early.shaders;
import com.gtnewhorizons.angelica.compat.mojang.InteractionHand;
import net.coderbot.iris.pipeline.HandRenderer;
import net.irisshaders.iris.api.v0.IrisApi;
import net.minecraft.client.renderer.ItemRenderer;
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(ItemRenderer.class)
public class MixinItemRenderer {
@Inject(method = "renderItemInFirstPerson", at = @At("HEAD"), cancellable = true)
private void iris$skipTranslucentHands(float partialTicks, CallbackInfo ci) {
if (IrisApi.getInstance().isShaderPackInUse()) {
// TODO: Offhand
boolean isHandTranslucent = HandRenderer.INSTANCE.isHandTranslucent(InteractionHand.MAIN_HAND);
if (HandRenderer.INSTANCE.isRenderingSolid() && isHandTranslucent) {
ci.cancel();
} else if (!HandRenderer.INSTANCE.isRenderingSolid() && !isHandTranslucent) {
ci.cancel();
}
}
}
}
@@ -154,13 +154,14 @@ public class MixinRenderGlobal implements IRenderGlobalExt {
if(pass == 0) {
pipeline.setPhase(WorldRenderingPhase.TERRAIN_CUTOUT);
} else if(pass == 1) {
pipeline.setPhase(WorldRenderingPhase.TERRAIN_TRANSLUCENT);
final Camera camera = new Camera(mc.renderViewEntity, (float) partialTicks);
// iris$beginTranslucents
pipeline.beginHand();
HandRenderer.INSTANCE.renderSolid(null /*poseStack*/, (float) partialTicks, camera, mc.renderGlobal, pipeline);
HandRenderer.INSTANCE.renderSolid((float) partialTicks, camera, mc.renderGlobal, pipeline);
mc.mcProfiler.endStartSection("iris_pre_translucent");
pipeline.setPhase(WorldRenderingPhase.TERRAIN_TRANSLUCENT);
pipeline.beginTranslucents();
this.renderEngine.bindTexture(TextureMap.locationBlocksTexture);
}