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

Separate rendering into its own module

Browse Source
This commit is contained in:
johni0702
2016-06-14 17:01:32 +02:00
parent 65cfdd13ec
commit 25582b6a51
68 changed files with 1822 additions and 2635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,48 +0,0 @@
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);
}
}

231
src/main/java/eu/crushedpixel/replaymod/mixin/MixinEntityRenderer.java
View File

@@ -2,251 +2,34 @@ package eu.crushedpixel.replaymod.mixin;
import com.replaymod.replay.camera.CameraEntity;
import eu.crushedpixel.replaymod.renderer.SpectatorRenderer;
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.entity.EntityPlayerSP;
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.Shadow;
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 {
public abstract class MixinEntityRenderer {
@Shadow
public Minecraft mc;
private EntityRendererHandler handler;
private SpectatorRenderer spectatorRenderer = new SpectatorRenderer();
@Override
public void setHandler(EntityRendererHandler handler) {
this.handler = handler;
}
@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] && entity instanceof CameraEntity) {
((CameraEntity) entity).roll = 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 = entity instanceof CameraEntity ? ((CameraEntity) entity).roll : 0;
}
}
@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;
if (entity instanceof CameraEntity) {
((CameraEntity) entity).roll = orgRoll;
}
}
}
@Inject(method = "renderHand", at = @At("HEAD"), cancellable = true)
@Inject(method = "renderHand", at = @At("HEAD"))
private void renderSpectatorHand(float partialTicks, int renderPass, CallbackInfo ci) {
// TODO
// if (handler != null) {
// if (handler.data instanceof CubicOpenGlFrameCapturer.Data) {
// ci.cancel();
// return; // No spectator hands during 360° view, we wouldn't even know where to put it
// }
// Entity currentEntity = Minecraft.getMinecraft().getRenderViewEntity();
// if (!ReplayHandler.isCameraView() && currentEntity instanceof EntityPlayer) {
// renderPass = handler.data == StereoscopicOpenGlFrameCapturer.Data.LEFT_EYE ? 1 : 0;
// spectatorRenderer.renderSpectatorHand((EntityPlayer) currentEntity, partialTicks, renderPass);
// }
// } else if (ReplayHandler.isInReplay() && !ReplayHandler.isCameraView()) {
// Entity currentEntity = Minecraft.getMinecraft().getRenderViewEntity();
// if (!ReplayHandler.isCameraView() && currentEntity instanceof EntityPlayer) {
// 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);
// TODO Check that this gets cancelled in 360 and doesn't misbehave in SP/MP
Entity currentEntity = Minecraft.getMinecraft().getRenderViewEntity();
if (currentEntity instanceof EntityPlayer && !(currentEntity instanceof EntityPlayerSP)) {
spectatorRenderer.renderSpectatorHand((EntityPlayer) currentEntity, partialTicks, renderPass);
}
}
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);
}
}
/*
* Misc
*/
@Inject(method = "orientCamera", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GlStateManager;translate(FFF)V", shift = At.Shift.AFTER, ordinal = 3))
private void setupCameraRoll(float partialTicks, CallbackInfo ci) {
if (mc.getRenderViewEntity() instanceof CameraEntity) {

22
src/main/java/eu/crushedpixel/replaymod/mixin/MixinRender.java
View File

@@ -1,22 +0,0 @@
package eu.crushedpixel.replaymod.mixin;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.entity.Entity;
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(Render.class)
public abstract class MixinRender {
@Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
private void areAllNamesHidden(Entity entity, CallbackInfoReturnable<Boolean> ci) {
EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).getHandler();
if (handler != null && handler.getOptions().isHideNameTags()) {
ci.setReturnValue(false);
ci.cancel();
}
}
}

18
src/main/java/eu/crushedpixel/replaymod/mixin/MixinRenderManager.java
View File

@@ -1,8 +1,5 @@
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.gui.FontRenderer;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.settings.GameSettings;
@@ -14,27 +11,12 @@ 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 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);
}
}
@Inject(method = "cacheActiveRenderInfo", at = @At("RETURN"))
public void fixHeadRotationForAnimals(World world, FontRenderer font, Entity view, Entity target, GameSettings settings, float partialRenderTick, CallbackInfo ci) {
if (view instanceof EntityAnimal && !((EntityAnimal) view).isPlayerSleeping()) {

38
src/main/java/eu/crushedpixel/replaymod/mixin/MixinRendererLivingEntity.java
View File

@@ -1,38 +0,0 @@
package eu.crushedpixel.replaymod.mixin;
import eu.crushedpixel.replaymod.video.EntityRendererHandler;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.entity.RendererLivingEntity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
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.CallbackInfoReturnable;
@Mixin(RendererLivingEntity.class)
public abstract class MixinRendererLivingEntity {
@Inject(method = "canRenderName", at = @At("HEAD"), cancellable = true)
private void areAllNamesHidden(EntityLivingBase entity, CallbackInfoReturnable<Boolean> ci) {
EntityRendererHandler handler = ((EntityRendererHandler.IEntityRenderer) Minecraft.getMinecraft().entityRenderer).getHandler();
if (handler != null && handler.getOptions().isHideNameTags()) {
ci.setReturnValue(false); //this calls the cancel method
}
// TODO
// if(ReplayHandler.isInReplay() && entity.isInvisible()
// && ReplaySettings.ReplayOptions.renderInvisible.getValue() == Boolean.FALSE) {
// ci.setReturnValue(false);
// }
}
@Redirect(method = "renderModel", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/EntityLivingBase;isInvisibleToPlayer(Lnet/minecraft/entity/player/EntityPlayer;)Z"))
private boolean shouldInvisibleNotBeRendered(EntityLivingBase entity, EntityPlayer thePlayer) {
// TODO
// if(ReplaySettings.ReplayOptions.renderInvisible.getValue() == Boolean.TRUE|| !ReplayHandler.isInReplay()) {
// return entity.isInvisibleToPlayer(thePlayer);
// }
return true; //the original method inverts the return value
}
}