416 lines
15 KiB
Java
416 lines
15 KiB
Java
package net.minecraft.client.renderer;
|
|
|
|
import com.mojang.blaze3d.buffers.BufferType;
|
|
import com.mojang.blaze3d.buffers.BufferUsage;
|
|
import com.mojang.blaze3d.buffers.GpuBuffer;
|
|
import com.mojang.blaze3d.pipeline.RenderPipeline;
|
|
import com.mojang.blaze3d.pipeline.RenderTarget;
|
|
import com.mojang.blaze3d.platform.NativeImage;
|
|
import com.mojang.blaze3d.systems.CommandEncoder;
|
|
import com.mojang.blaze3d.systems.RenderPass;
|
|
import com.mojang.blaze3d.systems.RenderSystem;
|
|
import com.mojang.blaze3d.textures.GpuTexture;
|
|
import com.mojang.blaze3d.vertex.BufferBuilder;
|
|
import com.mojang.blaze3d.vertex.MeshData;
|
|
import com.mojang.blaze3d.vertex.Tesselator;
|
|
import com.mojang.blaze3d.vertex.VertexFormat;
|
|
import com.mojang.logging.LogUtils;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.Optional;
|
|
import java.util.OptionalDouble;
|
|
import java.util.OptionalInt;
|
|
import net.fabricmc.api.EnvType;
|
|
import net.fabricmc.api.Environment;
|
|
import net.minecraft.client.CloudStatus;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.resources.ResourceLocation;
|
|
import net.minecraft.server.packs.resources.ResourceManager;
|
|
import net.minecraft.server.packs.resources.SimplePreparableReloadListener;
|
|
import net.minecraft.util.ARGB;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.util.profiling.ProfilerFiller;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.slf4j.Logger;
|
|
|
|
@Environment(EnvType.CLIENT)
|
|
public class CloudRenderer extends SimplePreparableReloadListener<Optional<CloudRenderer.TextureData>> implements AutoCloseable {
|
|
private static final Logger LOGGER = LogUtils.getLogger();
|
|
private static final ResourceLocation TEXTURE_LOCATION = ResourceLocation.withDefaultNamespace("textures/environment/clouds.png");
|
|
private static final float CELL_SIZE_IN_BLOCKS = 12.0F;
|
|
private static final float HEIGHT_IN_BLOCKS = 4.0F;
|
|
private static final float BLOCKS_PER_SECOND = 0.6F;
|
|
private static final long EMPTY_CELL = 0L;
|
|
private static final int COLOR_OFFSET = 4;
|
|
private static final int NORTH_OFFSET = 3;
|
|
private static final int EAST_OFFSET = 2;
|
|
private static final int SOUTH_OFFSET = 1;
|
|
private static final int WEST_OFFSET = 0;
|
|
private boolean needsRebuild = true;
|
|
private int prevCellX = Integer.MIN_VALUE;
|
|
private int prevCellZ = Integer.MIN_VALUE;
|
|
private CloudRenderer.RelativeCameraPos prevRelativeCameraPos = CloudRenderer.RelativeCameraPos.INSIDE_CLOUDS;
|
|
@Nullable
|
|
private CloudStatus prevType;
|
|
@Nullable
|
|
private CloudRenderer.TextureData texture;
|
|
@Nullable
|
|
private GpuBuffer vertexBuffer = null;
|
|
private int indexCount = 0;
|
|
private final RenderSystem.AutoStorageIndexBuffer indices = RenderSystem.getSequentialBuffer(VertexFormat.Mode.QUADS);
|
|
|
|
protected Optional<CloudRenderer.TextureData> prepare(ResourceManager resourceManager, ProfilerFiller profilerFiller) {
|
|
try {
|
|
InputStream inputStream = resourceManager.open(TEXTURE_LOCATION);
|
|
|
|
Optional var20;
|
|
try (NativeImage nativeImage = NativeImage.read(inputStream)) {
|
|
int i = nativeImage.getWidth();
|
|
int j = nativeImage.getHeight();
|
|
long[] ls = new long[i * j];
|
|
|
|
for (int k = 0; k < j; k++) {
|
|
for (int l = 0; l < i; l++) {
|
|
int m = nativeImage.getPixel(l, k);
|
|
if (isCellEmpty(m)) {
|
|
ls[l + k * i] = 0L;
|
|
} else {
|
|
boolean bl = isCellEmpty(nativeImage.getPixel(l, Math.floorMod(k - 1, j)));
|
|
boolean bl2 = isCellEmpty(nativeImage.getPixel(Math.floorMod(l + 1, j), k));
|
|
boolean bl3 = isCellEmpty(nativeImage.getPixel(l, Math.floorMod(k + 1, j)));
|
|
boolean bl4 = isCellEmpty(nativeImage.getPixel(Math.floorMod(l - 1, j), k));
|
|
ls[l + k * i] = packCellData(m, bl, bl2, bl3, bl4);
|
|
}
|
|
}
|
|
}
|
|
|
|
var20 = Optional.of(new CloudRenderer.TextureData(ls, i, j));
|
|
} catch (Throwable var18) {
|
|
if (inputStream != null) {
|
|
try {
|
|
inputStream.close();
|
|
} catch (Throwable var15) {
|
|
var18.addSuppressed(var15);
|
|
}
|
|
}
|
|
|
|
throw var18;
|
|
}
|
|
|
|
if (inputStream != null) {
|
|
inputStream.close();
|
|
}
|
|
|
|
return var20;
|
|
} catch (IOException var19) {
|
|
LOGGER.error("Failed to load cloud texture", (Throwable)var19);
|
|
return Optional.empty();
|
|
}
|
|
}
|
|
|
|
protected void apply(Optional<CloudRenderer.TextureData> optional, ResourceManager resourceManager, ProfilerFiller profilerFiller) {
|
|
this.texture = (CloudRenderer.TextureData)optional.orElse(null);
|
|
this.needsRebuild = true;
|
|
}
|
|
|
|
private static boolean isCellEmpty(int color) {
|
|
return ARGB.alpha(color) < 10;
|
|
}
|
|
|
|
private static long packCellData(int color, boolean northEmpty, boolean eastEmpty, boolean southEmpty, boolean westEmpty) {
|
|
return (long)color << 4 | (northEmpty ? 1 : 0) << 3 | (eastEmpty ? 1 : 0) << 2 | (southEmpty ? 1 : 0) << 1 | (westEmpty ? 1 : 0) << 0;
|
|
}
|
|
|
|
private static int getColor(long cellData) {
|
|
return (int)(cellData >> 4 & 4294967295L);
|
|
}
|
|
|
|
private static boolean isNorthEmpty(long cellData) {
|
|
return (cellData >> 3 & 1L) != 0L;
|
|
}
|
|
|
|
private static boolean isEastEmpty(long cellData) {
|
|
return (cellData >> 2 & 1L) != 0L;
|
|
}
|
|
|
|
private static boolean isSouthEmpty(long cellData) {
|
|
return (cellData >> 1 & 1L) != 0L;
|
|
}
|
|
|
|
private static boolean isWestEmpty(long cellData) {
|
|
return (cellData >> 0 & 1L) != 0L;
|
|
}
|
|
|
|
public void render(int cloudColor, CloudStatus cloudStatus, float height, Vec3 cameraPosition, float ticks) {
|
|
if (this.texture != null) {
|
|
float f = (float)(height - cameraPosition.y);
|
|
float g = f + 4.0F;
|
|
CloudRenderer.RelativeCameraPos relativeCameraPos;
|
|
if (g < 0.0F) {
|
|
relativeCameraPos = CloudRenderer.RelativeCameraPos.ABOVE_CLOUDS;
|
|
} else if (f > 0.0F) {
|
|
relativeCameraPos = CloudRenderer.RelativeCameraPos.BELOW_CLOUDS;
|
|
} else {
|
|
relativeCameraPos = CloudRenderer.RelativeCameraPos.INSIDE_CLOUDS;
|
|
}
|
|
|
|
double d = cameraPosition.x + ticks * 0.030000001F;
|
|
double e = cameraPosition.z + 3.96F;
|
|
double h = this.texture.width * 12.0;
|
|
double i = this.texture.height * 12.0;
|
|
d -= Mth.floor(d / h) * h;
|
|
e -= Mth.floor(e / i) * i;
|
|
int j = Mth.floor(d / 12.0);
|
|
int k = Mth.floor(e / 12.0);
|
|
float l = (float)(d - j * 12.0F);
|
|
float m = (float)(e - k * 12.0F);
|
|
boolean bl = cloudStatus == CloudStatus.FANCY;
|
|
RenderPipeline renderPipeline = bl ? RenderPipelines.CLOUDS : RenderPipelines.FLAT_CLOUDS;
|
|
if (this.needsRebuild || j != this.prevCellX || k != this.prevCellZ || relativeCameraPos != this.prevRelativeCameraPos || cloudStatus != this.prevType) {
|
|
this.needsRebuild = false;
|
|
this.prevCellX = j;
|
|
this.prevCellZ = k;
|
|
this.prevRelativeCameraPos = relativeCameraPos;
|
|
this.prevType = cloudStatus;
|
|
|
|
try (MeshData meshData = this.buildMesh(Tesselator.getInstance(), j, k, cloudStatus, relativeCameraPos, renderPipeline)) {
|
|
if (meshData == null) {
|
|
this.indexCount = 0;
|
|
} else {
|
|
if (this.vertexBuffer != null && this.vertexBuffer.size >= meshData.vertexBuffer().remaining()) {
|
|
CommandEncoder commandEncoder = RenderSystem.getDevice().createCommandEncoder();
|
|
commandEncoder.writeToBuffer(this.vertexBuffer, meshData.vertexBuffer(), 0);
|
|
} else {
|
|
if (this.vertexBuffer != null) {
|
|
this.vertexBuffer.close();
|
|
}
|
|
|
|
this.vertexBuffer = RenderSystem.getDevice()
|
|
.createBuffer(() -> "Cloud vertex buffer", BufferType.VERTICES, BufferUsage.DYNAMIC_WRITE, meshData.vertexBuffer());
|
|
}
|
|
|
|
this.indexCount = meshData.drawState().indexCount();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.indexCount != 0) {
|
|
RenderSystem.setShaderColor(ARGB.redFloat(cloudColor), ARGB.greenFloat(cloudColor), ARGB.blueFloat(cloudColor), 1.0F);
|
|
if (bl) {
|
|
this.draw(RenderPipelines.CLOUDS_DEPTH_ONLY, l, f, m);
|
|
}
|
|
|
|
this.draw(renderPipeline, l, f, m);
|
|
RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void draw(RenderPipeline pipeline, float x, float y, float z) {
|
|
RenderSystem.setModelOffset(-x, y, -z);
|
|
RenderTarget renderTarget = Minecraft.getInstance().getMainRenderTarget();
|
|
RenderTarget renderTarget2 = Minecraft.getInstance().levelRenderer.getCloudsTarget();
|
|
GpuTexture gpuTexture;
|
|
GpuTexture gpuTexture2;
|
|
if (renderTarget2 != null) {
|
|
gpuTexture = renderTarget2.getColorTexture();
|
|
gpuTexture2 = renderTarget2.getDepthTexture();
|
|
} else {
|
|
gpuTexture = renderTarget.getColorTexture();
|
|
gpuTexture2 = renderTarget.getDepthTexture();
|
|
}
|
|
|
|
GpuBuffer gpuBuffer = this.indices.getBuffer(this.indexCount);
|
|
|
|
try (RenderPass renderPass = RenderSystem.getDevice()
|
|
.createCommandEncoder()
|
|
.createRenderPass(gpuTexture, OptionalInt.empty(), gpuTexture2, OptionalDouble.empty())) {
|
|
renderPass.setPipeline(pipeline);
|
|
renderPass.setIndexBuffer(gpuBuffer, this.indices.type());
|
|
renderPass.setVertexBuffer(0, this.vertexBuffer);
|
|
renderPass.drawIndexed(0, this.indexCount);
|
|
}
|
|
|
|
RenderSystem.resetModelOffset();
|
|
}
|
|
|
|
@Nullable
|
|
private MeshData buildMesh(
|
|
Tesselator tesselator, int cellX, int cellY, CloudStatus cloudStatus, CloudRenderer.RelativeCameraPos relativeCameraPos, RenderPipeline pipeline
|
|
) {
|
|
float f = 0.8F;
|
|
int i = ARGB.colorFromFloat(0.8F, 1.0F, 1.0F, 1.0F);
|
|
int j = ARGB.colorFromFloat(0.8F, 0.9F, 0.9F, 0.9F);
|
|
int k = ARGB.colorFromFloat(0.8F, 0.7F, 0.7F, 0.7F);
|
|
int l = ARGB.colorFromFloat(0.8F, 0.8F, 0.8F, 0.8F);
|
|
BufferBuilder bufferBuilder = tesselator.begin(pipeline.getVertexFormatMode(), pipeline.getVertexFormat());
|
|
this.buildMesh(relativeCameraPos, bufferBuilder, cellX, cellY, k, i, j, l, cloudStatus == CloudStatus.FANCY);
|
|
return bufferBuilder.build();
|
|
}
|
|
|
|
private void buildMesh(
|
|
CloudRenderer.RelativeCameraPos relativeCameraPos,
|
|
BufferBuilder bufferBuilder,
|
|
int cellX,
|
|
int cellZ,
|
|
int bottomColor,
|
|
int topColor,
|
|
int sideColor,
|
|
int frontColor,
|
|
boolean fancyClouds
|
|
) {
|
|
if (this.texture != null) {
|
|
int i = 32;
|
|
long[] ls = this.texture.cells;
|
|
int j = this.texture.width;
|
|
int k = this.texture.height;
|
|
|
|
for (int l = -32; l <= 32; l++) {
|
|
for (int m = -32; m <= 32; m++) {
|
|
int n = Math.floorMod(cellX + m, j);
|
|
int o = Math.floorMod(cellZ + l, k);
|
|
long p = ls[n + o * j];
|
|
if (p != 0L) {
|
|
int q = getColor(p);
|
|
if (fancyClouds) {
|
|
this.buildExtrudedCell(
|
|
relativeCameraPos,
|
|
bufferBuilder,
|
|
ARGB.multiply(bottomColor, q),
|
|
ARGB.multiply(topColor, q),
|
|
ARGB.multiply(sideColor, q),
|
|
ARGB.multiply(frontColor, q),
|
|
m,
|
|
l,
|
|
p
|
|
);
|
|
} else {
|
|
this.buildFlatCell(bufferBuilder, ARGB.multiply(topColor, q), m, l);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void buildFlatCell(BufferBuilder bufferBuilder, int color, int x, int y) {
|
|
float f = x * 12.0F;
|
|
float g = f + 12.0F;
|
|
float h = y * 12.0F;
|
|
float i = h + 12.0F;
|
|
bufferBuilder.addVertex(f, 0.0F, h).setColor(color);
|
|
bufferBuilder.addVertex(f, 0.0F, i).setColor(color);
|
|
bufferBuilder.addVertex(g, 0.0F, i).setColor(color);
|
|
bufferBuilder.addVertex(g, 0.0F, h).setColor(color);
|
|
}
|
|
|
|
private void buildExtrudedCell(
|
|
CloudRenderer.RelativeCameraPos relativeCameraPos,
|
|
BufferBuilder bufferBuilder,
|
|
int bottomColor,
|
|
int topColor,
|
|
int sideColor,
|
|
int frontColor,
|
|
int x,
|
|
int y,
|
|
long cellData
|
|
) {
|
|
float f = x * 12.0F;
|
|
float g = f + 12.0F;
|
|
float h = 0.0F;
|
|
float i = 4.0F;
|
|
float j = y * 12.0F;
|
|
float k = j + 12.0F;
|
|
if (relativeCameraPos != CloudRenderer.RelativeCameraPos.BELOW_CLOUDS) {
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(topColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(topColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(topColor);
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(topColor);
|
|
}
|
|
|
|
if (relativeCameraPos != CloudRenderer.RelativeCameraPos.ABOVE_CLOUDS) {
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(bottomColor);
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(bottomColor);
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(bottomColor);
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(bottomColor);
|
|
}
|
|
|
|
if (isNorthEmpty(cellData) && y > 0) {
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(frontColor);
|
|
}
|
|
|
|
if (isSouthEmpty(cellData) && y < 0) {
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(frontColor);
|
|
}
|
|
|
|
if (isWestEmpty(cellData) && x > 0) {
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(sideColor);
|
|
}
|
|
|
|
if (isEastEmpty(cellData) && x < 0) {
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(sideColor);
|
|
}
|
|
|
|
boolean bl = Math.abs(x) <= 1 && Math.abs(y) <= 1;
|
|
if (bl) {
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(topColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(topColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(topColor);
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(topColor);
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(bottomColor);
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(bottomColor);
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(bottomColor);
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(bottomColor);
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(frontColor);
|
|
bufferBuilder.addVertex(f, 0.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 4.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 4.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(f, 0.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 0.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 4.0F, k).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 4.0F, j).setColor(sideColor);
|
|
bufferBuilder.addVertex(g, 0.0F, j).setColor(sideColor);
|
|
}
|
|
}
|
|
|
|
public void markForRebuild() {
|
|
this.needsRebuild = true;
|
|
}
|
|
|
|
public void close() {
|
|
if (this.vertexBuffer != null) {
|
|
this.vertexBuffer.close();
|
|
}
|
|
}
|
|
|
|
@Environment(EnvType.CLIENT)
|
|
static enum RelativeCameraPos {
|
|
ABOVE_CLOUDS,
|
|
INSIDE_CLOUDS,
|
|
BELOW_CLOUDS;
|
|
}
|
|
|
|
@Environment(EnvType.CLIENT)
|
|
public record TextureData(long[] cells, int width, int height) {
|
|
}
|
|
}
|