DekinDev/Smooth_Double_Doors
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 1 Activity

License and Notice

Browse Source
This commit is contained in:
DekinDev
2026-01-01 13:12:38 +01:00
parent 04f58b17da
commit 31ea4af347
3 changed files with 435 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
src/client/java/com/straice/smoothdoors/client/anim/SddAnimator.java
View File

@@ -7,6 +7,7 @@ import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents;
import net.minecraft.block.*;
import net.minecraft.block.enums.BlockHalf;
import net.minecraft.block.enums.DoorHinge;
import net.minecraft.block.enums.DoubleBlockHalf;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.render.OverlayTexture;
import net.minecraft.client.render.VertexConsumerProvider;
@@ -14,8 +15,8 @@ import net.minecraft.client.render.WorldRenderer;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.util.math.*;
import net.minecraft.util.math.RotationAxis;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.BlockRenderView;
import net.minecraft.world.World;
public final class SddAnimator {
@@ -23,35 +24,46 @@ public final class SddAnimator {
// Duración base (segundos) a speed=1.0x
private static final float BASE_DURATION_S = 0.35f;
private static final float MIN_DURATION_S = 0.05f;
private static final Long2ObjectOpenHashMap<Anim> ANIMS = new Long2ObjectOpenHashMap<>();
private static boolean hooksInit = false;
private static long lastNs = 0L;
private SddAnimator() {}
// === Hook de render (NO mixin a WorldRenderer) ===
/**
* Llamar desde SmoothDoubleDoorsClient.onInitializeClient()
* (evita mixins a WorldRenderer y firmas rotas).
*/
public static void initClientHooks() {
if (hooksInit) return;
hooksInit = true;
WorldRenderEvents.LAST.register(ctx -> {
if (MC.world == null) return;
// Render cada frame
WorldRenderEvents.END.register(ctx -> {
if (MC.world == null || ANIMS.isEmpty()) return;
Vec3d camPos = ctx.camera().getPos();
renderAll(camPos);
float tickDelta = MC.getRenderTickCounter().getTickProgress(true);
renderAll(camPos, tickDelta);
});
}
// === API usada por mixins ===
// === API que usan tus mixins ===
/** Se usa en BlockRenderManagerMixin para ocultar el bloque vanilla mientras animamos. */
/** Se usa en BlockRenderManagerMixin para NO meter el modelo vanilla en el chunk mientras animamos. */
public static boolean shouldHideInChunk(BlockPos pos, BlockState state) {
return ANIMS.containsKey(pos.asLong());
}
/** Se usa en ClientWorldMixin para arrancar/parar animaciones al cambiar OPEN. */
/**
* Se llama desde tu WorldMixin (scheduleBlockRerenderIfNeeded).
* Arranca/actualiza animaciones.
*/
public static void onBlockUpdate(BlockPos pos, BlockState oldState, BlockState newState) {
if (MC.world == null) return;
Kind kind = kindOf(oldState, newState);
if (kind == null) {
ANIMS.remove(pos.asLong());
@@ -64,64 +76,52 @@ public final class SddAnimator {
SddConfig cfg = SddConfigManager.get();
if (!isAnimationEnabled(cfg, kind)) {
ANIMS.remove(pos.asLong());
// por seguridad, limpia este pos y (si es puerta) también su otra mitad
removeWithPairIfDoor(pos, newState);
return;
}
float speed = speedFor(cfg, kind);
if (speed <= 0.001f) speed = 1.0f;
// Renderizamos SIEMPRE el modelo "cerrado" y aplicamos rotación nosotros.
BlockState base = forceClosedModel(newState, kind);
long startNs = System.nanoTime();
Anim anim = new Anim(pos.toImmutable(), base, kind, oldOpen, newOpen, speed);
ANIMS.put(pos.asLong(), anim);
if (kind == Kind.DOOR) {
// IMPORTANTÍSIMO:
// 1) animar SIEMPRE LAS 2 MITADES (upper+lower) para que no quede “puerta vanilla” encima
// 2) si cfg.connectDoors está ON, arrancar también la puerta gemela con el MISMO startNs para que vayan a la vez
startDoorAnimationWithPairs(cfg, pos, oldOpen, newOpen, speed, startNs);
return;
}
// Trapdoor / Fence gate (1 bloque)
BlockState base = forceClosedModel(newState, kind);
putOrReplaceAnim(pos, base, kind, oldOpen, newOpen, speed, startNs);
ensureRerender(pos);
}
// === Render ===
/** Render por frame (se llama desde WorldRenderEvents). */
public static void renderAll(Vec3d camPos) {
if (ANIMS.isEmpty() || MC.world == null) return;
tickByTime();
public static void renderAll(Vec3d camPos, float tickDelta) {
if (MC.world == null || ANIMS.isEmpty()) return;
VertexConsumerProvider.Immediate consumers = MC.getBufferBuilders().getEntityVertexConsumers();
MatrixStack matrices = new MatrixStack();
long nowNs = System.nanoTime();
for (Anim a : ANIMS.values()) {
renderOne(a, camPos, matrices, consumers);
float t = a.progress01(nowNs);
renderOne(a, t, camPos, matrices, consumers);
}
consumers.draw(); // flush
cleanupFinished();
consumers.draw();
cleanupFinished(nowNs);
}
// === Interno ===
private static void tickByTime() {
long now = System.nanoTime();
if (lastNs == 0L) lastNs = now;
float dt = (now - lastNs) / 1_000_000_000.0f;
lastNs = now;
// cap por si hay alt-tab / lag
dt = MathHelper.clamp(dt, 0.0f, 0.10f);
for (Anim a : ANIMS.values()) {
float duration = BASE_DURATION_S / a.speed;
if (duration < 0.05f) duration = 0.05f;
float step = dt / duration;
a.t = MathHelper.clamp(a.t + step, 0.0f, 1.0f);
}
}
private static void cleanupFinished() {
ANIMS.long2ObjectEntrySet().removeIf(e -> e.getValue().t >= 1.0f);
}
private static void renderOne(Anim anim, Vec3d camPos, MatrixStack matrices, VertexConsumerProvider consumers) {
private static void renderOne(Anim anim, float t, Vec3d camPos, MatrixStack matrices, VertexConsumerProvider consumers) {
if (MC.world == null) return;
BlockPos pos = anim.pos;
@@ -129,14 +129,14 @@ public final class SddAnimator {
matrices.push();
// Fijo al bloque (no “pegado” a la cámara): worldPos - camPos
// Fijado al bloque (NO a la cámara): world -> camera-relative
matrices.translate(
pos.getX() - camPos.x,
pos.getY() - camPos.y,
pos.getZ() - camPos.z
);
float eased = easeInOut(anim.t);
float eased = easeInOut(t);
float angleDeg = lerpAngleDeg(anim.fromOpen, anim.toOpen, eased, anim.kind, state);
applyTransform(anim.kind, state, angleDeg, matrices);
@@ -146,6 +146,148 @@ public final class SddAnimator {
matrices.pop();
}
private static void cleanupFinished(long nowNs) {
if (ANIMS.isEmpty() || MC.world == null) return;
// Cuando termina una animación, hay que forzar rerender para que el chunk vuelva a incluir el bloque vanilla final.
ANIMS.long2ObjectEntrySet().removeIf(e -> {
Anim a = e.getValue();
if (!a.isFinished(nowNs)) return false;
ensureRerender(a.pos);
return true;
});
}
private static void putOrReplaceAnim(BlockPos pos, BlockState base, Kind kind,
boolean fromOpen, boolean toOpen,
float speed, long startNs) {
Anim anim = new Anim(pos.toImmutable(), base, kind, fromOpen, toOpen, speed, startNs);
ANIMS.put(pos.asLong(), anim);
}
private static void removeWithPairIfDoor(BlockPos pos, BlockState state) {
ANIMS.remove(pos.asLong());
if (!(state.getBlock() instanceof DoorBlock) || MC.world == null) return;
BlockPos other = otherDoorHalfPos(pos, state);
if (other != null) ANIMS.remove(other.asLong());
}
private static void startDoorAnimationWithPairs(SddConfig cfg, BlockPos anyHalfPos,
boolean fromOpen, boolean toOpen,
float speed, long startNs) {
if (MC.world == null) return;
// Normaliza a LOWER para encontrar gemela de doble puerta de forma estable
BlockPos lowerPos = anyHalfPos;
BlockState anyStateNow = MC.world.getBlockState(anyHalfPos);
if (!(anyStateNow.getBlock() instanceof DoorBlock)) return;
if (anyStateNow.get(DoorBlock.HALF) == DoubleBlockHalf.UPPER) {
lowerPos = anyHalfPos.down();
}
BlockState lowerState = MC.world.getBlockState(lowerPos);
if (!(lowerState.getBlock() instanceof DoorBlock)) {
// fallback: al menos animar la mitad recibida
putOrReplaceAnim(anyHalfPos, forceClosedModel(anyStateNow, Kind.DOOR), Kind.DOOR, fromOpen, toOpen, speed, startNs);
ensureRerender(anyHalfPos);
return;
}
// 1) Esta puerta: lower + upper
startDoorBothHalves(lowerPos, lowerState, fromOpen, toOpen, speed, startNs);
// 2) Doble puerta (gemela), sincronizada
if (cfg.connectDoors) {
BlockPos otherLower = findDoubleDoorOtherLower(lowerPos, lowerState);
if (otherLower != null) {
BlockState otherLowerState = MC.world.getBlockState(otherLower);
// Solo si sigue siendo puerta
if (otherLowerState.getBlock() instanceof DoorBlock) {
startDoorBothHalves(otherLower, otherLowerState, fromOpen, toOpen, speed, startNs);
// Forzamos rerender ya, aunque la gemela cambie un tick después: evita ver la puerta vanilla encima.
ensureRerender(otherLower);
BlockPos otherUpper = otherLower.up();
ensureRerender(otherUpper);
}
}
}
// Forzamos rerender de esta puerta ya
ensureRerender(lowerPos);
ensureRerender(lowerPos.up());
}
private static void startDoorBothHalves(BlockPos lowerPos, BlockState lowerState,
boolean fromOpen, boolean toOpen,
float speed, long startNs) {
if (MC.world == null) return;
// LOWER
BlockState baseLower = forceClosedModel(lowerState, Kind.DOOR);
putOrReplaceAnim(lowerPos, baseLower, Kind.DOOR, fromOpen, toOpen, speed, startNs);
// UPPER (si existe)
BlockPos upperPos = lowerPos.up();
BlockState upperState = MC.world.getBlockState(upperPos);
if (upperState.getBlock() instanceof DoorBlock) {
BlockState baseUpper = forceClosedModel(upperState, Kind.DOOR);
putOrReplaceAnim(upperPos, baseUpper, Kind.DOOR, fromOpen, toOpen, speed, startNs);
}
}
/**
* Encuentra la otra puerta (LOWER) de una doble puerta.
* Regla:
* - misma FACING
* - hinge opuesto
* - vecina en el lado “no bisagra” (donde se juntan)
*/
private static BlockPos findDoubleDoorOtherLower(BlockPos lowerPos, BlockState lowerState) {
if (MC.world == null) return null;
if (!(lowerState.getBlock() instanceof DoorBlock)) return null;
if (lowerState.get(DoorBlock.HALF) != DoubleBlockHalf.LOWER) return null;
Direction facing = lowerState.get(DoorBlock.FACING);
DoorHinge hinge = lowerState.get(DoorBlock.HINGE);
// Si mi bisagra está a la IZQ, mi “lado de unión” es a la DCHA (clockwise), y viceversa.
Direction joinSide = (hinge == DoorHinge.LEFT) ? facing.rotateYClockwise()
: facing.rotateYCounterclockwise();
BlockPos otherLower = lowerPos.offset(joinSide);
BlockState other = MC.world.getBlockState(otherLower);
if (!(other.getBlock() instanceof DoorBlock)) return null;
if (other.get(DoorBlock.HALF) != DoubleBlockHalf.LOWER) return null;
if (other.get(DoorBlock.FACING) != facing) return null;
DoorHinge otherHinge = other.get(DoorBlock.HINGE);
if (otherHinge == hinge) return null; // deben ser opuestas
return otherLower;
}
private static BlockPos otherDoorHalfPos(BlockPos pos, BlockState state) {
if (!(state.getBlock() instanceof DoorBlock)) return null;
return (state.get(DoorBlock.HALF) == DoubleBlockHalf.UPPER) ? pos.down() : pos.up();
}
private static void ensureRerender(BlockPos pos) {
if (MC.world == null) return;
// Esta existe (la estás mixineando). Esto fuerza al motor a reconstruir el chunk.
World w = MC.world;
BlockState s = w.getBlockState(pos);
w.scheduleBlockRerenderIfNeeded(pos, s, s);
}
private static float lerpAngleDeg(boolean fromOpen, boolean toOpen, float t, Kind kind, BlockState state) {
float a = angleFor(kind, state, fromOpen);
float b = angleFor(kind, state, toOpen);
@@ -157,14 +299,24 @@ public final class SddAnimator {
switch (kind) {
case DOOR -> {
Direction facing = state.get(DoorBlock.FACING);
DoorHinge hinge = state.get(DoorBlock.HINGE);
return (hinge == DoorHinge.RIGHT) ? -90.0f : 90.0f;
// Igual que vanilla (en shapes): al abrir, la “dirección efectiva” rota ±90 según hinge.
Direction openDir = (hinge == DoorHinge.LEFT) ? facing.rotateYClockwise()
: facing.rotateYCounterclockwise();
float yawClosed = Direction.getHorizontalDegreesOrThrow(facing);
float yawOpen = Direction.getHorizontalDegreesOrThrow(openDir);
return MathHelper.wrapDegrees(yawOpen - yawClosed); // +90 o -90
}
case TRAPDOOR -> {
BlockHalf half = state.get(TrapdoorBlock.HALF);
return (half == BlockHalf.TOP) ? -90.0f : 90.0f;
// (lo afinamos luego) 90º
return 90.0f;
}
case FENCE_GATE -> {
// (lo afinamos luego) 90º
return 90.0f;
}
}
@@ -181,11 +333,14 @@ public final class SddAnimator {
private static void transformDoor(BlockState state, float angleDeg, MatrixStack matrices) {
Direction facing = state.get(DoorBlock.FACING);
DoorHinge hinge = state.get(DoorBlock.HINGE);
DoorHinge hinge = state.get(DoorBlock.HINGE);
Direction hingeSide = (hinge == DoorHinge.RIGHT) ? facing.rotateYClockwise() : facing.rotateYCounterclockwise();
float pivotX = hingeSide.getOffsetX() == 1 ? 1.0f : (hingeSide.getOffsetX() == -1 ? 0.0f : 0.5f);
float pivotZ = hingeSide.getOffsetZ() == 1 ? 1.0f : (hingeSide.getOffsetZ() == -1 ? 0.0f : 0.5f);
// Bisagra en el borde IZQ/DCHA relativo a facing
Direction hingeSide = (hinge == DoorHinge.LEFT) ? facing.rotateYCounterclockwise()
: facing.rotateYClockwise();
float pivotX = (hingeSide == Direction.EAST) ? 1.0f : (hingeSide == Direction.WEST ? 0.0f : 0.5f);
float pivotZ = (hingeSide == Direction.SOUTH) ? 1.0f : (hingeSide == Direction.NORTH ? 0.0f : 0.5f);
matrices.translate(pivotX, 0.0f, pivotZ);
matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(angleDeg));
@@ -195,8 +350,8 @@ public final class SddAnimator {
private static void transformTrapdoor(BlockState state, float angleDeg, MatrixStack matrices) {
Direction facing = state.get(TrapdoorBlock.FACING);
float pivotX = facing.getOffsetX() == 1 ? 1.0f : (facing.getOffsetX() == -1 ? 0.0f : 0.5f);
float pivotZ = facing.getOffsetZ() == 1 ? 1.0f : (facing.getOffsetZ() == -1 ? 0.0f : 0.5f);
float pivotX = (facing == Direction.EAST) ? 1.0f : (facing == Direction.WEST ? 0.0f : 0.5f);
float pivotZ = (facing == Direction.SOUTH) ? 1.0f : (facing == Direction.NORTH ? 0.0f : 0.5f);
matrices.translate(pivotX, 0.5f, pivotZ);
@@ -262,7 +417,7 @@ public final class SddAnimator {
}
private static float easeInOut(float t) {
return t * t * (3.0f - 2.0f * t);
return t * t * (3.0f - 2.0f * t); // smoothstep
}
public enum Kind { DOOR, TRAPDOOR, FENCE_GATE }
@@ -274,17 +429,34 @@ public final class SddAnimator {
final boolean fromOpen;
final boolean toOpen;
final float speed;
final long startNs;
final long durationNs;
float t; // 0..1
Anim(BlockPos pos, BlockState baseState, Kind kind,
boolean fromOpen, boolean toOpen, float speed, long startNs) {
Anim(BlockPos pos, BlockState baseState, Kind kind, boolean fromOpen, boolean toOpen, float speed) {
this.pos = pos;
this.baseState = baseState;
this.kind = kind;
this.fromOpen = fromOpen;
this.toOpen = toOpen;
this.speed = speed;
this.t = 0.0f;
this.startNs = startNs;
float dur = BASE_DURATION_S / Math.max(0.001f, speed);
if (dur < MIN_DURATION_S) dur = MIN_DURATION_S;
this.durationNs = (long) (dur * 1_000_000_000L);
}
float progress01(long nowNs) {
long dt = nowNs - startNs;
if (dt <= 0) return 0.0f;
if (dt >= durationNs) return 1.0f;
return (float) dt / (float) durationNs;
}
boolean isFinished(long nowNs) {
return nowNs - startNs >= durationNs;
}
}
}