DIvan2000/ReplayModCinematic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace CustomEntityHandler with mixin magic

Browse Source
This commit is contained in:
johni0702
2015-08-04 22:36:04 +02:00
parent 00fd746eb7
commit 4efdc0ebd0
24 changed files with 523 additions and 897 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
src/main/java/eu/crushedpixel/replaymod/coremod/EntityRendererCT.java
View File

@@ -1,128 +0,0 @@
package eu.crushedpixel.replaymod.coremod;
import net.minecraft.launchwrapper.IClassTransformer;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.*;
import static org.objectweb.asm.Opcodes.*;
/**
* Transforms the EntityRenderer class:
* - Adds a new field 'CustomEntityRenderer hook'
* - Moves code of 'loadShader' into 'loadShader$Original'
* - Creates 'loadShader' method (see {@link #createLoadShader(ClassNode, MethodNode)} ()}
*
* Transforms the CustomEntityRenderer class:
* - Method 'original_loadShader' calls 'loadShader$Original'
*/
public class EntityRendererCT implements IClassTransformer {
private static final String HOOK = "eu.crushedpixel.replaymod.video.entity.CustomEntityRenderer";
private static final String HOOK_JVM = HOOK.replace('.', '/');
private static final String HOOK_TYPE = "L" + HOOK_JVM + ";";
private static final String ENTITY_RENDERER = "net.minecraft.client.renderer.EntityRenderer";
private static final String ENTITY_RENDERER_JVM = ENTITY_RENDERER.replace('.', '/');
private static final String ENTITY_RENDERER_TYPE = "L" + ENTITY_RENDERER_JVM + ";";
@Override
public byte[] transform(String name, String transformedName, byte[] bytes) {
if (ENTITY_RENDERER.equals(transformedName)) {
if (name.equals(transformedName)) {
return transformEntityRenderer(bytes, "loadShader", "(Lnet/minecraft/util/ResourceLocation;)V");
} else {
return transformEntityRenderer(bytes, "a", "(Loa;)V");
}
} else if (HOOK.equals(transformedName)) {
return transformHook(bytes);
}
return bytes;
}
private byte[] transformHook(byte[] bytes) {
ClassReader classReader = new ClassReader(bytes);
ClassNode classNode = new ClassNode();
classReader.accept(classNode, 0);
// Find method
for (MethodNode m : classNode.methods) {
if ("original_loadShader".equals(m.name)) {
m.instructions.clear();
InsnList iter = m.instructions;
iter.add(new VarInsnNode(ALOAD, 0)); // this
iter.add(new FieldInsnNode(GETFIELD, classNode.name, "proxied", ENTITY_RENDERER_TYPE));
iter.add(new VarInsnNode(ALOAD, 1)); // resourceLocation
iter.add(new MethodInsnNode(INVOKEVIRTUAL, ENTITY_RENDERER_JVM, "loadShader$Original", m.desc, false));
iter.add(new InsnNode(RETURN));
}
}
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
classNode.accept(classWriter);
return classWriter.toByteArray();
}
private byte[] transformEntityRenderer(byte[] bytes, String name_loadShader, String desc_loadShader) {
ClassReader classReader = new ClassReader(bytes);
ClassNode classNode = new ClassNode();
classReader.accept(classNode, 0);
// Add field
classNode.visitField(ACC_PUBLIC, "hook", HOOK_TYPE, null, null);
// Find method
MethodNode setupTerrain = null;
for (MethodNode m : classNode.methods) {
if (name_loadShader.equals(m.name) && desc_loadShader.equals(m.desc)) {
setupTerrain = m;
}
}
if (setupTerrain == null) {
throw new NoSuchMethodError("loadShader");
}
// Generate new method
classNode.methods.add(createLoadShader(classNode, setupTerrain));
// Rename original method
setupTerrain.name = "loadShader$Original";
setupTerrain.access = ACC_PUBLIC;
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
classNode.accept(classWriter);
return classWriter.toByteArray();
}
/**
* public void loadShader(ResourceLocation resourceLocation) {
* if (this.hook == null) {
* loadShader$Original(resourceLocation);
* return;
* }
* hook.loadShader(resourceLocation);
* }
*/
private MethodNode createLoadShader(ClassNode classNode, MethodNode org) {
MethodNode method = new MethodNode(org.access, org.name, org.desc, org.signature, new String[0]);
InsnList list = method.instructions;
list.add(new VarInsnNode(ALOAD, 0));
list.add(new FieldInsnNode(GETFIELD, classNode.name, "hook", HOOK_TYPE));
LabelNode labelNotNull = new LabelNode();
list.add(new JumpInsnNode(IFNONNULL, labelNotNull));
list.add(new VarInsnNode(ALOAD, 0)); // this
list.add(new VarInsnNode(ALOAD, 1)); // resourceLocation
list.add(new MethodInsnNode(INVOKEVIRTUAL, classNode.name, "loadShader$Original", org.desc, false));
list.add(new InsnNode(RETURN));
list.add(labelNotNull);
list.add(new FrameNode(F_SAME, 0, null, 0, null));
list.add(new VarInsnNode(ALOAD, 0)); // this
list.add(new FieldInsnNode(GETFIELD, classNode.name, "hook", HOOK_TYPE));
list.add(new VarInsnNode(ALOAD, 1)); // resourceLocation
list.add(new MethodInsnNode(INVOKEVIRTUAL, HOOK_JVM, "loadShader", org.desc, false));
list.add(new InsnNode(RETURN));
return method;
}
}

33
src/main/java/eu/crushedpixel/replaymod/coremod/LoadingPlugin.java
View File

@@ -1,19 +1,48 @@
package eu.crushedpixel.replaymod.coremod;
import net.minecraftforge.fml.relauncher.CoreModManager;
import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
import org.apache.logging.log4j.LogManager;
import org.spongepowered.asm.launch.MixinBootstrap;
import org.spongepowered.asm.mixin.MixinEnvironment;
import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.CodeSource;
import java.util.Map;
public class LoadingPlugin implements IFMLLoadingPlugin {
public LoadingPlugin() {
MixinBootstrap.init();
MixinEnvironment.getDefaultEnvironment().addConfiguration("mixins.replaymod.json");
CodeSource codeSource = getClass().getProtectionDomain().getCodeSource();
if (codeSource != null) {
URL location = codeSource.getLocation();
try {
File file = new File(location.toURI());
if (file.isFile()) {
// This forces forge to reexamine the jar file for FML mods
// Should eventually be handled by Mixin itself, maybe?
CoreModManager.getLoadedCoremods().remove(file.getName());
}
} catch (URISyntaxException e) {
e.printStackTrace();
}
} else {
LogManager.getLogger().warn("No CodeSource, if this is not a development environment we might run into problems!");
LogManager.getLogger().warn(getClass().getProtectionDomain());
}
}
@Override
public String[] getASMTransformerClass() {
return new String[]{
CameraRollCT.class.getName(),
ForceChunkLoadingCT.class.getName(),
EntityRendererCT.class.getName(),
NoNameTagCT.class.getName(),
RenderManagerCT.class.getName(),
SoundManagerCT.class.getName(),
EnchantmentTimerCT.class.getName()
};

81
src/main/java/eu/crushedpixel/replaymod/coremod/RenderManagerCT.java
View File

@@ -1,81 +0,0 @@
package eu.crushedpixel.replaymod.coremod;
import net.minecraft.launchwrapper.IClassTransformer;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.*;
import java.util.ListIterator;
import static org.objectweb.asm.Opcodes.*;
/**
* Transforms the RenderManager class:
* - Adds a new field 'CubicEntityRenderer hook'
* - Injects CubicEntityRenderer.beforeEntityRender(dx, dy, dz) call at beginning of 'doRenderEntity'
*/
public class RenderManagerCT implements IClassTransformer {
private static final String HOOK = "eu.crushedpixel.replaymod.video.entity.CubicEntityRenderer";
private static final String HOOK_JVM = HOOK.replace('.', '/');
private static final String HOOK_TYPE = "L" + HOOK_JVM + ";";
private static final String RENDER_MANAGER = "net.minecraft.client.renderer.entity.RenderManager";
@Override
public byte[] transform(String name, String transformedName, byte[] bytes) {
if (RENDER_MANAGER.equals(transformedName)) {
if (name.equals(transformedName)) {
return transformRenderManager(bytes, "doRenderEntity", "(Lnet/minecraft/entity/Entity;DDDFFZ)Z");
} else {
return transformRenderManager(bytes, "a", "(Lwv;DDDFFZ)Z");
}
}
return bytes;
}
private byte[] transformRenderManager(byte[] bytes, String name_doRenderEntity, String desc_doRenderEntity) {
ClassReader classReader = new ClassReader(bytes);
ClassNode classNode = new ClassNode();
classReader.accept(classNode, 0);
// Add field
classNode.visitField(ACC_PUBLIC, "hook", HOOK_TYPE, null, null);
// Find method
MethodNode doRenderEntity = null;
for (MethodNode m : classNode.methods) {
if (name_doRenderEntity.equals(m.name) && desc_doRenderEntity.equals(m.desc)) {
doRenderEntity = m;
}
}
if (doRenderEntity == null) {
throw new NoSuchMethodError("doRenderEntity");
}
injectDoRenderEntity(classNode, doRenderEntity);
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
classNode.accept(classWriter);
return classWriter.toByteArray();
}
private MethodNode injectDoRenderEntity(ClassNode classNode, MethodNode method) {
ListIterator<AbstractInsnNode> list = method.instructions.iterator();
list.add(new VarInsnNode(ALOAD, 0));
list.add(new FieldInsnNode(GETFIELD, classNode.name, "hook", HOOK_TYPE));
LabelNode labelNull = new LabelNode();
list.add(new JumpInsnNode(IFNULL, labelNull));
list.add(new VarInsnNode(ALOAD, 0)); // this
list.add(new FieldInsnNode(GETFIELD, classNode.name, "hook", HOOK_TYPE));
list.add(new VarInsnNode(DLOAD, 2)); // x
list.add(new VarInsnNode(DLOAD, 4)); // y
list.add(new VarInsnNode(DLOAD, 6)); // z
list.add(new MethodInsnNode(INVOKEVIRTUAL, HOOK_JVM, "beforeEntityRender", "(DDD)V", false));
list.add(labelNull);
list.add(new FrameNode(F_SAME, 0, null, 0, null));
return method;
}
}

48
src/main/java/eu/crushedpixel/replaymod/mixin/MixinEffectRenderer.java Normal file
View File

@@ -0,0 +1,48 @@
package eu.crushedpixel.replaymod.mixin;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import eu.crushedpixel.replaymod.video.capturer.CubicOpenGlFrameCapturer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.particle.EffectRenderer;
import net.minecraft.client.particle.EntityFX;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.entity.Entity;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Redirect;
@Mixin(EffectRenderer.class)
public class MixinEffectRenderer {
@Redirect(method = "renderParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;func_180434_a(Lnet/minecraft/client/renderer/WorldRenderer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
private void renderNormalParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
@Redirect(method = "renderLitParticles", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/particle/EntityFX;func_180434_a(Lnet/minecraft/client/renderer/WorldRenderer;Lnet/minecraft/entity/Entity;FFFFFF)V"))
private void renderLitParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
private void renderParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).getHandler();
if (handler != null && handler.data instanceof CubicOpenGlFrameCapturer.Data) {
// Align all particles towards the camera
double dx = fx.prevPosX + (fx.posX - fx.prevPosX) * partialTicks - view.posX;
double dy = fx.prevPosY + (fx.posY - fx.prevPosY) * partialTicks - view.posY;
double dz = fx.prevPosZ + (fx.posZ - fx.prevPosZ) * partialTicks - view.posZ;
double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
double yaw = -Math.atan2(dx, dz);
rotX = (float) Math.cos(yaw);
rotZ = (float) Math.sin(yaw);
rotXZ = (float) Math.cos(pitch);
rotYZ = (float) (-rotZ * Math.sin(pitch));
rotXY = (float) (rotX * Math.sin(pitch));
}
fx.func_180434_a(worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
}

237
src/main/java/eu/crushedpixel/replaymod/mixin/MixinEntityRenderer.java Normal file
View File

@@ -0,0 +1,237 @@
package eu.crushedpixel.replaymod.mixin;
import eu.crushedpixel.replaymod.renderer.SpectatorRenderer;
import eu.crushedpixel.replaymod.replay.ReplayHandler;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import eu.crushedpixel.replaymod.video.capturer.CubicOpenGlFrameCapturer;
import eu.crushedpixel.replaymod.video.capturer.StereoscopicOpenGlFrameCapturer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.RenderGlobal;
import net.minecraft.client.renderer.culling.Frustum;
import net.minecraft.client.settings.GameSettings;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.MovingObjectPosition;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.Project;
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.Redirect;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(EntityRenderer.class)
public abstract class MixinEntityRenderer implements EntityRendererHandler.IEntityRenderer, EntityRendererHandler.GluPerspective {
private EntityRendererHandler handler;
private SpectatorRenderer spectatorRenderer;
@Override
public void setHandler(EntityRendererHandler handler) {
this.handler = handler;
if (spectatorRenderer != null) {
spectatorRenderer.cleanup();
spectatorRenderer = null;
}
if (handler != null) {
spectatorRenderer = new SpectatorRenderer();
}
}
@Override
public EntityRendererHandler getHandler() {
return handler;
}
@Inject(method = "setupFog", at = @At("HEAD"), cancellable = true)
private void onSetupFog(int fogDistanceFlag, float partialTicks, CallbackInfo ci) {
if (handler == null) return;
if (!handler.getOptions().isDefaultSky()) {
ci.cancel();
}
}
@Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/culling/Frustum;setPosition(DDD)V"))
public void createNoCullingFrustum(Frustum frustum, double x, double y, double z) {
if (handler != null) {
frustum.clippingHelper = new EntityRendererHandler.NoCullingClippingHelper();
}
frustum.setPosition(x, y, z);
}
@Inject(method = "orientCamera", at = @At("HEAD"))
private void resetRotationIfNeeded(float partialTicks, CallbackInfo ci) {
if (handler != null) {
Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
RenderOptions options = handler.getOptions();
if (options.getIgnoreCameraRotation()[0]) {
entity.prevRotationYaw = entity.rotationYaw = 0;
}
if (options.getIgnoreCameraRotation()[1]) {
entity.prevRotationPitch = entity.rotationPitch = 0;
}
if (options.getIgnoreCameraRotation()[2]) {
ReplayHandler.setCameraTilt(0);
}
}
}
private float orgYaw;
private float orgPitch;
private float orgPrevYaw;
private float orgPrevPitch;
private float orgRoll;
@Inject(method = "setupCameraTransform", at = @At("HEAD"))
private void beforeSetupCameraTransform(float partialTicks, int renderPass, CallbackInfo ci) {
if (handler != null) {
Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
orgYaw = entity.rotationYaw;
orgPitch = entity.rotationPitch;
orgPrevYaw = entity.prevRotationYaw;
orgPrevPitch = entity.prevRotationPitch;
orgRoll = ReplayHandler.getCameraTilt();
}
}
@Inject(method = "setupCameraTransform", at = @At("RETURN"))
private void afterSetupCameraTransform(float partialTicks, int renderPass, CallbackInfo ci) {
if (handler != null) {
Entity entity = Minecraft.getMinecraft().getRenderViewEntity();
entity.rotationYaw = orgYaw;
entity.rotationPitch = orgPitch;
entity.prevRotationYaw = orgPrevYaw;
entity.prevRotationPitch = orgPrevPitch;
ReplayHandler.setCameraTilt(orgRoll);
}
}
@Inject(method = "renderHand", at = @At("HEAD"), cancellable = true)
private void renderSpectatorHand(float partialTicks, int renderPass, CallbackInfo ci) {
if (handler != null) {
if (handler.data instanceof CubicOpenGlFrameCapturer.Data) {
return; // No spectator hands during 360° view, we wouldn't even know where to put it
}
Entity currentEntity = ReplayHandler.getCurrentEntity();
if (!ReplayHandler.isCamera() && currentEntity instanceof EntityPlayer) {
renderPass = handler.data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE ? 1 : 0;
spectatorRenderer.renderSpectatorHand((EntityPlayer) currentEntity, partialTicks, renderPass);
}
}
}
@Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;drawSelectionBox(Lnet/minecraft/entity/player/EntityPlayer;Lnet/minecraft/util/MovingObjectPosition;IF)V"))
private void drawSelectionBox(RenderGlobal instance, EntityPlayer player, MovingObjectPosition mop, int alwaysZero, float partialTicks) {
if (handler == null) {
instance.drawSelectionBox(player, mop, alwaysZero, partialTicks);
}
}
private int orgRenderDistanceChunks;
@Inject(method = "renderWorldPass", at = @At(value = "JUMP", ordinal = 0))
private void beforeRenderSky(CallbackInfo ci) {
if (handler != null && !handler.getOptions().isDefaultSky()) {
GameSettings settings = Minecraft.getMinecraft().gameSettings;
orgRenderDistanceChunks = settings.renderDistanceChunks;
settings.renderDistanceChunks = 5; // Set render distance to 5 so we're always rendering sky when chroma keying
}
}
@Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderGlobal;renderSky(FI)V"))
private void renderSky(RenderGlobal instance, float partialTicks, int renderPass) {
if (handler != null && !handler.getOptions().isDefaultSky()) {
Minecraft.getMinecraft().gameSettings.renderDistanceChunks = orgRenderDistanceChunks;
int c = handler.getOptions().getSkyColor();
GlStateManager.clearColor((c >> 16 & 0xff) / (float) 0xff, (c >> 8 & 0xff) / (float) 0xff, (c & 0xff) / (float) 0xff, 1);
GlStateManager.clear(GL11.GL_COLOR_BUFFER_BIT);
} else {
instance.renderSky(partialTicks, renderPass);
}
}
/*
* Cubic Renderer
*/
@Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;loadIdentity()V", shift = At.Shift.AFTER, ordinal = 0))
private void setupStereoscopicProjection(float partialTicks, int renderPass, CallbackInfo ci) {
if (getHandler() != null) {
if (getHandler().data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE) {
GlStateManager.translate(0.07, 0, 0);
} else if (getHandler().data == StereoscopicOpenGlFrameCapturer.Data.RIGHT_EYE) {
GlStateManager.translate(-0.07, 0, 0);
}
}
}
@Inject(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;loadIdentity()V", shift = At.Shift.AFTER, ordinal = 1))
private void setupStereoscopicModelView(float partialTicks, int renderPass, CallbackInfo ci) {
if (getHandler() != null) {
if (getHandler().data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE) {
GlStateManager.translate(0.1, 0, 0);
} else if (getHandler().data == StereoscopicOpenGlFrameCapturer.Data.RIGHT_EYE) {
GlStateManager.translate(-0.1, 0, 0);
}
}
}
/*
* Cubic Renderer
*/
@Redirect(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
private void gluPerspective$0(float fovY, float aspect, float zNear, float zFar) {
gluPerspective(fovY, aspect, zNear, zFar);
}
@Redirect(method = "renderWorldPass", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
private void gluPerspective$1(float fovY, float aspect, float zNear, float zFar) {
gluPerspective(fovY, aspect, zNear, zFar);
}
@Redirect(method = "renderCloudsCheck", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", remap = false))
private void gluPerspective$2(float fovY, float aspect, float zNear, float zFar) {
gluPerspective(fovY, aspect, zNear, zFar);
}
@Override
public void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
if (getHandler() != null && getHandler().data instanceof CubicOpenGlFrameCapturer.Data) {
fovY = 90;
aspect = 1;
}
Project.gluPerspective(fovY, aspect, zNear, zFar);
}
@Inject(method = "orientCamera", at = @At("HEAD"))
private void setupCubicFrameRotation(float partialTicks, CallbackInfo ci) {
if (getHandler() != null && getHandler().data instanceof CubicOpenGlFrameCapturer.Data) {
switch ((CubicOpenGlFrameCapturer.Data) getHandler().data) {
case FRONT:
GlStateManager.rotate(0, 0.0F, 1.0F, 0.0F);
break;
case RIGHT:
GlStateManager.rotate(90, 0.0F, 1.0F, 0.0F);
break;
case BACK:
GlStateManager.rotate(180, 0.0F, 1.0F, 0.0F);
break;
case LEFT:
GlStateManager.rotate(-90, 0.0F, 1.0F, 0.0F);
break;
case BOTTOM:
GlStateManager.rotate(90, 1.0F, 0.0F, 0.0F);
break;
case TOP:
GlStateManager.rotate(-90, 1.0F, 0.0F, 0.0F);
break;
}
// Minecraft goes back a little so we have to invert that
GlStateManager.translate(0.0F, 0.0F, 0.1F);
}
}
}

32
src/main/java/eu/crushedpixel/replaymod/mixin/MixinRenderManager.java Normal file
View File

@@ -0,0 +1,32 @@
package eu.crushedpixel.replaymod.mixin;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import eu.crushedpixel.replaymod.video.capturer.CubicOpenGlFrameCapturer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
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(RenderManager.class)
public class MixinRenderManager {
@Shadow
private float playerViewX;
@Shadow
private float playerViewY;
@Inject(method = "doRenderEntity", at = @At("HEAD"))
private void reorientForCubicRendering(Entity entity, double dx, double dy, double dz, float iDoNotKnow, float partialTicks, boolean iDoNotCare, CallbackInfoReturnable ci) {
EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).getHandler();
if (handler != null && handler.data instanceof CubicOpenGlFrameCapturer.Data) {
double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
double yaw = -Math.atan2(dx, dz);
playerViewX = (float) Math.toDegrees(pitch);
playerViewY = (float) Math.toDegrees(yaw);
}
}
}

8
src/main/java/eu/crushedpixel/replaymod/renderer/SpectatorRenderer.java
View File

@@ -2,6 +2,7 @@ package eu.crushedpixel.replaymod.renderer;
import eu.crushedpixel.replaymod.replay.ReplayHandler;
import eu.crushedpixel.replaymod.utils.SkinProvider;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
@@ -25,7 +26,6 @@ import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.Project;
public class SpectatorRenderer {
@@ -43,10 +43,6 @@ public class SpectatorRenderer {
return (EntityPlayer)current;
}
protected void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
Project.gluPerspective(fovY, aspect, zNear, zFar);
}
public void renderSpectatorHand(EntityPlayer entityPlayer, float partialTicks, int renderPass) {
if(entityPlayer.isInvisible()) return;
@@ -65,7 +61,7 @@ public class SpectatorRenderer {
GlStateManager.translate((float)(-(renderPass * 2 - 1)) * f1, 0.0F, 0.0F);
}
gluPerspective(mc.entityRenderer.getFOVModifier(partialTicks, false),
((EntityRendererHandler.GluPerspective) mc.entityRenderer).gluPerspective(mc.entityRenderer.getFOVModifier(partialTicks, false),
(float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, mc.entityRenderer.farPlaneDistance * 2.0F);
GlStateManager.matrixMode(GL11.GL_MODELVIEW);

89
src/main/java/eu/crushedpixel/replaymod/video/EntityRendererHandler.java Normal file
View File

@@ -0,0 +1,89 @@
package eu.crushedpixel.replaymod.video;
import eu.crushedpixel.replaymod.coremod.asm_Hooks;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.capturer.CaptureData;
import eu.crushedpixel.replaymod.video.capturer.WorldRenderer;
import lombok.Getter;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.culling.ClippingHelper;
import org.lwjgl.util.ReadableDimension;
import java.io.IOException;
import static net.minecraft.client.renderer.GlStateManager.*;
public class EntityRendererHandler implements WorldRenderer {
public final Minecraft mc = Minecraft.getMinecraft();
@Getter
protected final RenderOptions options;
public CaptureData data;
public EntityRendererHandler(RenderOptions options) {
this.options = options;
if (options.isHideNameTags()) {
asm_Hooks.DO_NOT_RENDER_NAME_TAGS = true;
}
((IEntityRenderer) mc.entityRenderer).setHandler(this);
}
public void withDisplaySize(int displayWidth, int displayHeight, Runnable runnable) {
final int prevWidth = mc.displayWidth;
final int prevHeight = mc.displayHeight;
mc.displayWidth = displayWidth;
mc.displayHeight = displayHeight;
runnable.run();
mc.displayWidth = prevWidth;
mc.displayHeight = prevHeight;
}
@Override
public void renderWorld(ReadableDimension displaySize, final float partialTicks, CaptureData data) {
this.data = data;
withDisplaySize(displaySize.getWidth(), displaySize.getHeight(), new Runnable() {
@Override
public void run() {
renderWorld(partialTicks, 0);
}
});
}
public void renderWorld(float partialTicks, long finishTimeNano) {
mc.entityRenderer.updateLightmap(partialTicks);
enableDepth();
enableAlpha();
alphaFunc(516, 0.5F);
mc.entityRenderer.renderWorldPass(2, partialTicks, finishTimeNano);
}
@Override
public void close() throws IOException {
((IEntityRenderer) mc.entityRenderer).setHandler(null);
asm_Hooks.DO_NOT_RENDER_NAME_TAGS = false;
}
public static final class NoCullingClippingHelper extends ClippingHelper {
@Override
public boolean isBoxInFrustum(double p_78553_1_, double p_78553_3_, double p_78553_5_, double p_78553_7_, double p_78553_9_, double p_78553_11_) {
return true;
}
}
public interface GluPerspective {
void gluPerspective(float fovY, float aspect, float zNear, float zFar);
}
public interface IEntityRenderer {
void setHandler(EntityRendererHandler handler);
EntityRendererHandler getHandler();
}
}

2
src/main/java/eu/crushedpixel/replaymod/video/capturer/CubicOpenGlFrameCapturer.java
View File

@@ -8,7 +8,7 @@ public class CubicOpenGlFrameCapturer extends OpenGlFrameCapturer<CubicOpenGlFra
}
private final int frameSize;
public CubicOpenGlFrameCapturer(WorldRenderer<Data> worldRenderer, RenderInfo renderInfo, int frameSize) {
public CubicOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo, int frameSize) {
super(worldRenderer, renderInfo);
this.frameSize = frameSize;
}

3
src/main/java/eu/crushedpixel/replaymod/video/capturer/CubicPboOpenGlFrameCapturer.java
View File

@@ -7,8 +7,7 @@ public class CubicPboOpenGlFrameCapturer extends
MultiFramePboOpenGlFrameCapturer<CubicOpenGlFrame, CubicOpenGlFrameCapturer.Data> {
private final int frameSize;
public CubicPboOpenGlFrameCapturer(WorldRenderer<CubicOpenGlFrameCapturer.Data> worldRenderer,
RenderInfo renderInfo, int frameSize) {
public CubicPboOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo, int frameSize) {
super(worldRenderer, renderInfo, CubicOpenGlFrameCapturer.Data.class, frameSize * frameSize);
this.frameSize = frameSize;
}

3
src/main/java/eu/crushedpixel/replaymod/video/capturer/MultiFramePboOpenGlFrameCapturer.java
View File

@@ -15,7 +15,7 @@ public abstract class MultiFramePboOpenGlFrameCapturer<F extends Frame, D extend
private final D[] data;
private PixelBufferObject pbo, otherPBO;
public MultiFramePboOpenGlFrameCapturer(WorldRenderer<D> worldRenderer, RenderInfo renderInfo, Class<D> type, int framePixels) {
public MultiFramePboOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo, Class<D> type, int framePixels) {
super(worldRenderer, renderInfo);
data = type.getEnumConstants();
@@ -97,6 +97,7 @@ public abstract class MultiFramePboOpenGlFrameCapturer<F extends Frame, D extend
@Override
public void close() throws IOException {
super.close();
pbo.delete();
otherPBO.delete();
}

4
src/main/java/eu/crushedpixel/replaymod/video/capturer/OpenGlFrameCapturer.java
View File

@@ -19,12 +19,12 @@ import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
public abstract class OpenGlFrameCapturer<F extends Frame, D extends CaptureData> implements FrameCapturer<F> {
protected final WorldRenderer<D> worldRenderer;
protected final WorldRenderer worldRenderer;
protected final RenderInfo renderInfo;
protected int framesDone;
private Framebuffer frameBuffer;
public OpenGlFrameCapturer(WorldRenderer<D> worldRenderer, RenderInfo renderInfo) {
public OpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo) {
this.worldRenderer = worldRenderer;
this.renderInfo = renderInfo;
}

2
src/main/java/eu/crushedpixel/replaymod/video/capturer/SimpleOpenGlFrameCapturer.java
View File

@@ -4,7 +4,7 @@ import eu.crushedpixel.replaymod.video.frame.OpenGlFrame;
public class SimpleOpenGlFrameCapturer extends OpenGlFrameCapturer<OpenGlFrame, CaptureData> {
public SimpleOpenGlFrameCapturer(WorldRenderer<CaptureData> worldRenderer, RenderInfo renderInfo) {
public SimpleOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo) {
super(worldRenderer, renderInfo);
}

3
src/main/java/eu/crushedpixel/replaymod/video/capturer/SimplePboOpenGlFrameCapturer.java
View File

@@ -14,7 +14,7 @@ public class SimplePboOpenGlFrameCapturer extends OpenGlFrameCapturer<OpenGlFram
private final int bufferSize;
private PixelBufferObject pbo, otherPBO;
public SimplePboOpenGlFrameCapturer(WorldRenderer<CaptureData> worldRenderer, RenderInfo renderInfo) {
public SimplePboOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo) {
super(worldRenderer, renderInfo);
ReadableDimension size = renderInfo.getFrameSize();
@@ -81,6 +81,7 @@ public class SimplePboOpenGlFrameCapturer extends OpenGlFrameCapturer<OpenGlFram
@Override
public void close() throws IOException {
super.close();
pbo.delete();
otherPBO.delete();
}

2
src/main/java/eu/crushedpixel/replaymod/video/capturer/StereoscopicOpenGlFrameCapturer.java
View File

@@ -9,7 +9,7 @@ public class StereoscopicOpenGlFrameCapturer
LEFT_EYE, RIGHT_EYE
}
public StereoscopicOpenGlFrameCapturer(WorldRenderer<Data> worldRenderer, RenderInfo renderInfo) {
public StereoscopicOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo) {
super(worldRenderer, renderInfo);
}

3
src/main/java/eu/crushedpixel/replaymod/video/capturer/StereoscopicPboOpenGlFrameCapturer.java
View File

@@ -6,8 +6,7 @@ import eu.crushedpixel.replaymod.video.frame.StereoscopicOpenGlFrame;
public class StereoscopicPboOpenGlFrameCapturer
extends MultiFramePboOpenGlFrameCapturer<StereoscopicOpenGlFrame, StereoscopicOpenGlFrameCapturer.Data> {
public StereoscopicPboOpenGlFrameCapturer(WorldRenderer<StereoscopicOpenGlFrameCapturer.Data> worldRenderer,
RenderInfo renderInfo) {
public StereoscopicPboOpenGlFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo) {
super(worldRenderer, renderInfo, StereoscopicOpenGlFrameCapturer.Data.class,
renderInfo.getFrameSize().getWidth() / 2 * renderInfo.getFrameSize().getHeight());
}

4
src/main/java/eu/crushedpixel/replaymod/video/capturer/WorldRenderer.java
View File

@@ -4,6 +4,6 @@ import org.lwjgl.util.ReadableDimension;
import java.io.Closeable;
public interface WorldRenderer<D extends CaptureData> extends Closeable {
void renderWorld(ReadableDimension displaySize, float partialTicks, D data);
public interface WorldRenderer extends Closeable {
void renderWorld(ReadableDimension displaySize, float partialTicks, CaptureData data);
}

117
src/main/java/eu/crushedpixel/replaymod/video/entity/CubicEntityRenderer.java
View File

@@ -1,117 +0,0 @@
package eu.crushedpixel.replaymod.video.entity;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.capturer.CubicOpenGlFrameCapturer;
import net.minecraft.client.particle.EntityFX;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
import net.minecraft.util.ResourceLocation;
import java.io.IOException;
import java.lang.reflect.Field;
public class CubicEntityRenderer extends CustomEntityRenderer<CubicOpenGlFrameCapturer.Data> {
public CubicEntityRenderer(RenderOptions options) {
super(options);
try {
Field hookField = RenderManager.class.getField("hook");
hookField.set(mc.getRenderManager(), this);
} catch (NoSuchFieldException e) {
throw new Error(e);
} catch (IllegalAccessException e) {
throw new Error(e);
}
}
@Override
public void close() throws IOException{
super.close();
try {
Field hookField = RenderManager.class.getField("hook");
hookField.set(mc.getRenderManager(), null);
} catch (NoSuchFieldException e) {
throw new Error(e);
} catch (IllegalAccessException e) {
throw new Error(e);
}
}
@Override
protected void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
super.gluPerspective(90, 1, zNear, zFar);
}
@Override
public void loadShader(ResourceLocation resourceLocation) {
if (proxied.theShaderGroup != null) {
proxied.theShaderGroup.deleteShaderGroup();
proxied.theShaderGroup = null;
}
proxied.useShader = false;
}
@Override
protected void orientCamera(float partialTicks) {
// Rotate
switch (data) {
case FRONT:
GlStateManager.rotate(0, 0.0F, 1.0F, 0.0F);
break;
case RIGHT:
GlStateManager.rotate(90, 0.0F, 1.0F, 0.0F);
break;
case BACK:
GlStateManager.rotate(180, 0.0F, 1.0F, 0.0F);
break;
case LEFT:
GlStateManager.rotate(-90, 0.0F, 1.0F, 0.0F);
break;
case BOTTOM:
GlStateManager.rotate(90, 1.0F, 0.0F, 0.0F);
break;
case TOP:
GlStateManager.rotate(-90, 1.0F, 0.0F, 0.0F);
break;
}
// Minecraft goes back a little so we have to invert that
GlStateManager.translate(0.0F, 0.0F, 0.1F);
super.orientCamera(partialTicks);
}
@Override
protected void renderSpectatorHand(float partialTicks, int renderPass) {
// No spectator hands during 360° view
}
@Override
protected void renderParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks, float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
// Align all particles towards the camera
double dx = fx.prevPosX + (fx.posX - fx.prevPosX) * partialTicks - view.posX;
double dy = fx.prevPosY + (fx.posY - fx.prevPosY) * partialTicks - view.posY;
double dz = fx.prevPosZ + (fx.posZ - fx.prevPosZ) * partialTicks - view.posZ;
double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
double yaw = -Math.atan2(dx, dz);
rotX = (float) Math.cos(yaw);
rotZ = (float) Math.sin(yaw);
rotXZ = (float) Math.cos(pitch);
rotYZ = (float) (-rotZ * Math.sin(pitch));
rotXY = (float) (rotX * Math.sin(pitch));
super.renderParticle(fx, worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
@SuppressWarnings("unused") // Called by ASM
public void beforeEntityRender(double dx, double dy, double dz) {
double pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz));
double yaw = -Math.atan2(dx, dz);
mc.getRenderManager().playerViewX = (float) Math.toDegrees(pitch);
mc.getRenderManager().playerViewY = (float) Math.toDegrees(yaw);
}
}

465
src/main/java/eu/crushedpixel/replaymod/video/entity/CustomEntityRenderer.java
View File

@@ -1,465 +0,0 @@
package eu.crushedpixel.replaymod.video.entity;
import eu.crushedpixel.replaymod.coremod.asm_Hooks;
import eu.crushedpixel.replaymod.renderer.SpectatorRenderer;
import eu.crushedpixel.replaymod.replay.ReplayHandler;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.capturer.CaptureData;
import net.minecraft.client.Minecraft;
import net.minecraft.client.particle.EffectRenderer;
import net.minecraft.client.particle.EntityFX;
import net.minecraft.client.renderer.*;
import net.minecraft.client.renderer.culling.ClippingHelperImpl;
import net.minecraft.client.renderer.culling.ICamera;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.EnumWorldBlockLayer;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.util.ReadableDimension;
import org.lwjgl.util.glu.Project;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.List;
import static net.minecraft.client.renderer.GlStateManager.*;
import static org.lwjgl.opengl.GL11.*;
public class CustomEntityRenderer<D extends CaptureData> implements eu.crushedpixel.replaymod.video.capturer.WorldRenderer<D> {
public final Minecraft mc = Minecraft.getMinecraft();
public final EntityRenderer proxied = mc.entityRenderer;
protected final SpectatorRenderer spectatorRenderer = new SpectatorRenderer(){
@Override
protected void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
CustomEntityRenderer.this.gluPerspective(fovY, aspect, zNear, zFar);
}
};
public GluPerspectiveHook gluPerspectiveHook;
public LoadShaderHook loadShaderHook;
protected int frameCount;
protected D data;
protected final RenderOptions options;
public CustomEntityRenderer(RenderOptions options) {
this.options = options;
// Install entity renderer hooks
try {
Field hookField = EntityRenderer.class.getField("hook");
hookField.set(proxied, this);
} catch (NoSuchFieldException e) {
throw new Error(e);
} catch (IllegalAccessException e) {
throw new Error(e);
}
if (options.isHideNameTags()) {
asm_Hooks.DO_NOT_RENDER_NAME_TAGS = true;
}
}
@SuppressWarnings("unused") // Method called by ASM hook
public void loadShader(ResourceLocation resourceLocation) {
if (loadShaderHook != null) {
loadShaderHook.loadShader(resourceLocation);
} else {
original_loadShader(resourceLocation);
}
}
@SuppressWarnings("unused")
protected final void original_loadShader(ResourceLocation resourceLocation) {
// Method body generated by ASM
}
protected void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
if (gluPerspectiveHook == null) {
Project.gluPerspective(fovY, aspect, zNear, zFar);
} else {
gluPerspectiveHook.gluPerspective(fovY, aspect, zNear, zFar);
}
}
public void withDisplaySize(int displayWidth, int displayHeight, Runnable runnable) {
final int prevWidth = mc.displayWidth;
final int prevHeight = mc.displayHeight;
mc.displayWidth = displayWidth;
mc.displayHeight = displayHeight;
runnable.run();
mc.displayWidth = prevWidth;
mc.displayHeight = prevHeight;
}
public void renderWorld(float partialTicks, long finishTimeNano) {
proxied.updateLightmap(partialTicks);
enableDepth();
enableAlpha();
alphaFunc(516, 0.5F);
renderWorldPass(partialTicks, finishTimeNano, 2);
}
protected void renderWorldPass(float partialTicks, long finishTimeNano, int renderPass) {
RenderGlobal renderglobal = mc.renderGlobal;
Entity entity = mc.getRenderViewEntity();
enableCull();
viewport(0, 0, mc.displayWidth, mc.displayHeight);
proxied.updateFogColor(partialTicks);
clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setupCameraTransform(partialTicks);
ActiveRenderInfo.updateRenderInfo(mc.thePlayer, mc.gameSettings.thirdPersonView == 2);
ClippingHelperImpl.getInstance();
ICamera camera = new NoCullingCamera();
if (this.mc.gameSettings.renderDistanceChunks >= 4 || !options.isDefaultSky() ) {
setupFog(-1, partialTicks);
matrixMode(GL_PROJECTION);
loadIdentity();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) mc.displayWidth / mc.displayHeight, 0.05F, proxied.farPlaneDistance * 2.0F);
matrixMode(GL_MODELVIEW);
if (options.isDefaultSky()) {
renderglobal.renderSky(partialTicks, renderPass);
} else {
int c = options.getSkyColor();
clearColor((c >> 16 & 0xff) / (float) 0xff, (c >> 8 & 0xff) / (float) 0xff, (c & 0xff) / (float) 0xff, 1);
clear(GL_COLOR_BUFFER_BIT);
}
matrixMode(GL_PROJECTION);
loadIdentity();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) mc.displayWidth / mc.displayHeight, 0.05F, proxied.farPlaneDistance * MathHelper.SQRT_2);
matrixMode(GL_MODELVIEW);
}
setupFog(0, partialTicks);
shadeModel(GL_SMOOTH);
if (entity.posY + entity.getEyeHeight() < 128) {
renderCloudsCheck(renderglobal, partialTicks, renderPass);
}
setupFog(0, partialTicks);
mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
RenderHelper.disableStandardItemLighting();
renderglobal.setupTerrain(entity, partialTicks, camera, frameCount++, mc.thePlayer.isSpectator());
renderglobal.updateChunks(finishTimeNano);
matrixMode(GL_MODELVIEW);
pushMatrix();
disableAlpha();
renderglobal.renderBlockLayer(EnumWorldBlockLayer.SOLID, partialTicks, renderPass, entity);
enableAlpha();
renderglobal.renderBlockLayer(EnumWorldBlockLayer.CUTOUT_MIPPED, partialTicks, renderPass, entity);
mc.getTextureManager().getTexture(TextureMap.locationBlocksTexture).setBlurMipmap(false, false);
renderglobal.renderBlockLayer(EnumWorldBlockLayer.CUTOUT, partialTicks, renderPass, entity);
mc.getTextureManager().getTexture(TextureMap.locationBlocksTexture).restoreLastBlurMipmap();
shadeModel(GL_FLAT);
alphaFunc(516, 0.1F);
matrixMode(GL_MODELVIEW);
popMatrix();
pushMatrix();
RenderHelper.enableStandardItemLighting();
net.minecraftforge.client.ForgeHooksClient.setRenderPass(0);
renderglobal.renderEntities(entity, camera, partialTicks);
net.minecraftforge.client.ForgeHooksClient.setRenderPass(0);
RenderHelper.disableStandardItemLighting();
proxied.disableLightmap();
matrixMode(GL_MODELVIEW);
popMatrix();
enableBlend();
tryBlendFuncSeparate(770, 1, 1, 0);
renderglobal.drawBlockDamageTexture(Tessellator.getInstance(), Tessellator.getInstance().getWorldRenderer(), entity, partialTicks);
disableBlend();
renderParticles(entity, partialTicks);
depthMask(false);
enableCull();
proxied.renderRainSnow(partialTicks);
depthMask(true);
renderglobal.renderWorldBorder(entity, partialTicks);
disableBlend();
enableCull();
tryBlendFuncSeparate(770, 771, 1, 0);
alphaFunc(516, 0.1F);
setupFog(0, partialTicks);
enableBlend();
depthMask(false);
mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
shadeModel(GL_SMOOTH);
if (mc.gameSettings.fancyGraphics) {
enableBlend();
tryBlendFuncSeparate(770, 771, 1, 0);
renderglobal.renderBlockLayer(EnumWorldBlockLayer.TRANSLUCENT, partialTicks, renderPass, entity);
disableBlend();
} else {
renderglobal.renderBlockLayer(EnumWorldBlockLayer.TRANSLUCENT, partialTicks, renderPass, entity);
}
RenderHelper.enableStandardItemLighting();
net.minecraftforge.client.ForgeHooksClient.setRenderPass(1);
renderglobal.renderEntities(entity, camera, partialTicks);
net.minecraftforge.client.ForgeHooksClient.setRenderPass(-1);
RenderHelper.disableStandardItemLighting();
shadeModel(GL_FLAT);
depthMask(true);
enableCull();
disableBlend();
disableFog();
if (entity.posY + entity.getEyeHeight() >= 128) {
renderCloudsCheck(renderglobal, partialTicks, renderPass);
}
net.minecraftforge.client.ForgeHooksClient.dispatchRenderLast(renderglobal, partialTicks);
renderSpectatorHand(partialTicks, renderPass);
}
protected void renderParticles(Entity entity, float partialTicks) {
proxied.enableLightmap();
renderLitParticles(entity, partialTicks);
RenderHelper.disableStandardItemLighting();
setupFog(0, partialTicks);
renderNormalParticles(entity, partialTicks);
proxied.disableLightmap();
}
protected void renderLitParticles(Entity entity, float partialTicks) {
EffectRenderer effectRenderer = mc.effectRenderer;
Tessellator tessellator = Tessellator.getInstance();
WorldRenderer worldrenderer = tessellator.getWorldRenderer();
double yaw = Math.toRadians(entity.rotationYaw);
double pitch = Math.toRadians(entity.rotationPitch);
float rotX = (float) Math.cos(yaw);
float rotZ = (float) Math.sin(yaw);
float rotXZ = (float) Math.cos(pitch);
float rotYZ = (float) (-rotZ * Math.sin(pitch));
float rotXY = (float) (rotX * Math.sin(pitch));
for (int i = 0; i < 2; i++) {
@SuppressWarnings("unchecked")
List<EntityFX> list = (List<EntityFX>) effectRenderer.fxLayers[3][i];
for (EntityFX fx : list) {
worldrenderer.setBrightness(fx.getBrightnessForRender(partialTicks));
renderParticle(fx, worldrenderer, entity, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
}
}
protected void renderNormalParticles(Entity entity, float partialTicks) {
EffectRenderer effectRenderer = mc.effectRenderer;
TextureManager textureManager = mc.getTextureManager();
Tessellator tessellator = Tessellator.getInstance();
WorldRenderer worldRenderer = tessellator.getWorldRenderer();
double yaw = Math.toRadians(entity.rotationYaw);
double pitch = Math.toRadians(entity.rotationPitch);
float rotX = (float) Math.cos(yaw);
float rotZ = (float) Math.sin(yaw);
float rotXZ = (float) Math.cos(pitch);
float rotYZ = (float) (-rotZ * Math.sin(pitch));
float rotXY = (float) (rotX * Math.sin(pitch));
EntityFX.interpPosX = entity.posX;
EntityFX.interpPosY = entity.posY;
EntityFX.interpPosZ = entity.posZ;
enableBlend();
blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
alphaFunc(GL_GREATER, 0.003921569F);
for (int texture = 0; texture < 3; texture++) {
for (int depthMask = 0; depthMask < 2; depthMask++) {
if (effectRenderer.fxLayers[texture][depthMask].isEmpty()) {
continue;
}
if (depthMask == 0) {
GlStateManager.depthMask(false);
} else {
GlStateManager.depthMask(true);
}
if (texture == 1) {
textureManager.bindTexture(TextureMap.locationBlocksTexture);
} else {
textureManager.bindTexture(EffectRenderer.particleTextures);
}
color(1, 1, 1, 1);
worldRenderer.startDrawingQuads();
@SuppressWarnings("unchecked")
List<EntityFX> list = (List<EntityFX>) effectRenderer.fxLayers[texture][depthMask];
for (final EntityFX fx : list) {
worldRenderer.setBrightness(fx.getBrightnessForRender(partialTicks));
renderParticle(fx, worldRenderer, entity, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
tessellator.draw();
}
}
depthMask(true);
disableBlend();
alphaFunc(516, 0.1F);
}
protected void renderParticle(EntityFX fx, WorldRenderer worldRenderer, Entity view, float partialTicks,
float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY) {
fx.func_180434_a(worldRenderer, view, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
}
protected void renderSpectatorHand(float partialTicks, int renderPass) {
Entity currentEntity = ReplayHandler.getCurrentEntity();
if(!ReplayHandler.isCamera() && currentEntity instanceof EntityPlayer) {
spectatorRenderer.renderSpectatorHand((EntityPlayer) currentEntity, partialTicks, renderPass);
}
}
protected void setupCameraTransform(float partialTicks) {
Entity entity = mc.getRenderViewEntity();
float orgYaw = entity.rotationYaw;
float orgPitch = entity.rotationPitch;
float orgPrevYaw = entity.prevRotationYaw;
float orgPrevPitch = entity.prevRotationPitch;
float orgRoll = ReplayHandler.getCameraTilt();
proxied.farPlaneDistance = (float)(this.mc.gameSettings.renderDistanceChunks * 16);
matrixMode(GL_PROJECTION);
loadIdentity();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, proxied.farPlaneDistance * MathHelper.SQRT_2);
matrixMode(GL_MODELVIEW);
loadIdentity();
orientCamera(partialTicks);
entity.rotationYaw = orgYaw;
entity.rotationPitch = orgPitch;
entity.prevRotationYaw = orgPrevYaw;
entity.prevRotationPitch = orgPrevPitch;
ReplayHandler.setCameraTilt(orgRoll);
}
protected void setupFog(int fogDistanceFlag, float partialTicks) {
if (options.isDefaultSky()) {
proxied.setupFog(fogDistanceFlag, partialTicks);
}
}
protected void orientCamera(float partialTicks) {
Entity entity = mc.getRenderViewEntity();
if (options.getIgnoreCameraRotation()[0]) {
entity.prevRotationYaw = entity.rotationYaw = 0;
}
if (options.getIgnoreCameraRotation()[1]) {
entity.prevRotationPitch = entity.rotationPitch = 0;
}
if (options.getIgnoreCameraRotation()[2]) {
ReplayHandler.setCameraTilt(0);
}
proxied.orientCamera(partialTicks);
}
protected void renderCloudsCheck(RenderGlobal renderglobal, float partialTicks, int renderPass) {
if (this.mc.gameSettings.shouldRenderClouds()) {
matrixMode(GL_PROJECTION);
loadIdentity();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, proxied.farPlaneDistance * 4.0F);
matrixMode(GL_MODELVIEW);
pushMatrix();
setupFog(0, partialTicks);
renderglobal.renderClouds(partialTicks, renderPass);
disableFog();
popMatrix();
matrixMode(GL_PROJECTION);
loadIdentity();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float)this.mc.displayWidth / (float)this.mc.displayHeight, 0.05F, proxied.farPlaneDistance * MathHelper.SQRT_2);
matrixMode(GL_MODELVIEW);
}
}
@Override
public void close() throws IOException {
try {
Field hookField = EntityRenderer.class.getField("hook");
hookField.set(proxied, null);
} catch (NoSuchFieldException e) {
throw new Error(e);
} catch (IllegalAccessException e) {
throw new Error(e);
}
asm_Hooks.DO_NOT_RENDER_NAME_TAGS = false;
spectatorRenderer.cleanup();
}
@Override
public void renderWorld(ReadableDimension displaySize, final float partialTicks, D data) {
this.data = data;
withDisplaySize(displaySize.getWidth(), displaySize.getHeight(), new Runnable() {
@Override
public void run() {
renderWorld(partialTicks, 0);
if (OpenGlHelper.shadersSupported) {
if (proxied.theShaderGroup != null && proxied.useShader) {
matrixMode(GL_TEXTURE);
pushMatrix();
loadIdentity();
proxied.theShaderGroup.loadShaderGroup(partialTicks);
popMatrix();
}
}
}
});
}
public static final class NoCullingCamera implements ICamera {
@Override
public boolean isBoundingBoxInFrustum(AxisAlignedBB p_78546_1_) {
return true;
}
@Override
public void setPosition(double p_78547_1_, double p_78547_3_, double p_78547_5_) {
}
}
public interface GluPerspectiveHook {
void gluPerspective(float fovY, float aspect, float zNear, float zFar);
}
public interface LoadShaderHook {
void loadShader(ResourceLocation resourceLocation);
}
}

54
src/main/java/eu/crushedpixel/replaymod/video/entity/StereoscopicEntityRenderer.java
View File

@@ -1,54 +0,0 @@
package eu.crushedpixel.replaymod.video.entity;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.capturer.StereoscopicOpenGlFrameCapturer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import static net.minecraft.client.renderer.GlStateManager.loadIdentity;
import static net.minecraft.client.renderer.GlStateManager.matrixMode;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
public class StereoscopicEntityRenderer extends CustomEntityRenderer<StereoscopicOpenGlFrameCapturer.Data> {
public StereoscopicEntityRenderer(RenderOptions options) {
super(options);
}
@Override
public void loadShader(ResourceLocation resourceLocation) {
if (proxied.theShaderGroup != null) {
proxied.theShaderGroup.deleteShaderGroup();
proxied.theShaderGroup = null;
}
proxied.useShader = false;
}
protected void translateStereoscopic() {
GlStateManager.translate(data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE ? 0.07 : -0.07, 0, 0);
}
@Override
protected void setupCameraTransform(float partialTicks) {
proxied.farPlaneDistance = (float)(this.mc.gameSettings.renderDistanceChunks * 16);
matrixMode(GL_PROJECTION);
loadIdentity();
translateStereoscopic();
gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, proxied.farPlaneDistance * MathHelper.SQRT_2);
matrixMode(GL_MODELVIEW);
loadIdentity();
translateStereoscopic();
orientCamera(partialTicks);
}
@Override
protected void renderSpectatorHand(float partialTicks, int renderPass) {
super.renderSpectatorHand(partialTicks, data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE ? 1 : 0);
}
}

20
src/main/java/eu/crushedpixel/replaymod/video/rendering/Pipelines.java
View File

@@ -2,10 +2,8 @@ package eu.crushedpixel.replaymod.video.rendering;
import eu.crushedpixel.replaymod.opengl.PixelBufferObject;
import eu.crushedpixel.replaymod.settings.RenderOptions;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import eu.crushedpixel.replaymod.video.capturer.*;
import eu.crushedpixel.replaymod.video.entity.CubicEntityRenderer;
import eu.crushedpixel.replaymod.video.entity.CustomEntityRenderer;
import eu.crushedpixel.replaymod.video.entity.StereoscopicEntityRenderer;
import eu.crushedpixel.replaymod.video.frame.CubicOpenGlFrame;
import eu.crushedpixel.replaymod.video.frame.OpenGlFrame;
import eu.crushedpixel.replaymod.video.frame.RGBFrame;
@@ -40,9 +38,9 @@ public class Pipelines {
RenderOptions options = renderInfo.getRenderOptions();
FrameCapturer<OpenGlFrame> capturer;
if (PixelBufferObject.SUPPORTED) {
capturer = new SimplePboOpenGlFrameCapturer(new CustomEntityRenderer<CaptureData>(options), renderInfo);
capturer = new SimplePboOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo);
} else {
capturer = new SimpleOpenGlFrameCapturer(new CustomEntityRenderer<CaptureData>(options), renderInfo);
capturer = new SimpleOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo);
}
return new Pipeline<OpenGlFrame, RGBFrame>(capturer, new OpenGlToRGBProcessor(), consumer);
}
@@ -51,9 +49,9 @@ public class Pipelines {
RenderOptions options = renderInfo.getRenderOptions();
FrameCapturer<StereoscopicOpenGlFrame> capturer;
if (PixelBufferObject.SUPPORTED) {
capturer = new StereoscopicPboOpenGlFrameCapturer(new StereoscopicEntityRenderer(options), renderInfo);
capturer = new StereoscopicPboOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo);
} else {
capturer = new StereoscopicOpenGlFrameCapturer(new StereoscopicEntityRenderer(options), renderInfo);
capturer = new StereoscopicOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo);
}
return new Pipeline<StereoscopicOpenGlFrame, RGBFrame>(capturer, new StereoscopicToRGBProcessor(), consumer);
}
@@ -62,9 +60,9 @@ public class Pipelines {
RenderOptions options = renderInfo.getRenderOptions();
FrameCapturer<CubicOpenGlFrame> capturer;
if (PixelBufferObject.SUPPORTED) {
capturer = new CubicPboOpenGlFrameCapturer(new CubicEntityRenderer(options), renderInfo, options.getWidth() / 4);
capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo, options.getWidth() / 4);
} else {
capturer = new CubicOpenGlFrameCapturer(new CubicEntityRenderer(options), renderInfo, options.getWidth() / 4);
capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo, options.getWidth() / 4);
}
return new Pipeline<CubicOpenGlFrame, RGBFrame>(capturer, new CubicToRGBProcessor(), consumer);
}
@@ -73,9 +71,9 @@ public class Pipelines {
RenderOptions options = renderInfo.getRenderOptions();
FrameCapturer<CubicOpenGlFrame> capturer;
if (PixelBufferObject.SUPPORTED) {
capturer = new CubicPboOpenGlFrameCapturer(new CubicEntityRenderer(options), renderInfo, options.getWidth() / 4);
capturer = new CubicPboOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo, options.getWidth() / 4);
} else {
capturer = new CubicOpenGlFrameCapturer(new CubicEntityRenderer(options), renderInfo, options.getWidth() / 4);
capturer = new CubicOpenGlFrameCapturer(new EntityRendererHandler(options), renderInfo, options.getWidth() / 4);
}
return new Pipeline<CubicOpenGlFrame, RGBFrame>(capturer, new EquirectangularToRGBProcessor(options.getWidth() / 4), consumer);
}