Leonardo
4e249e943a
LevelPos are useful and the small stutter in the buffer builder is probably caused by the creation of ChunkPos
560 lines
16 KiB
Java
560 lines
16 KiB
Java
/*
|
|
* This file is part of the LOD Mod, licensed under the GNU GPL v3 License.
|
|
*
|
|
* Copyright (C) 2020 James Seibel
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, version 3.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
package com.seibel.lod.builders;
|
|
|
|
import java.awt.Color;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
|
|
import com.seibel.lod.enums.DistanceGenerationMode;
|
|
import com.seibel.lod.enums.LodDetail;
|
|
import com.seibel.lod.handlers.LodConfig;
|
|
import com.seibel.lod.objects.DataPoint;
|
|
import com.seibel.lod.objects.LodDimension;
|
|
import com.seibel.lod.objects.LodWorld;
|
|
import com.seibel.lod.objects.LevelPos.LevelPos;
|
|
import com.seibel.lod.util.ColorUtil;
|
|
import com.seibel.lod.util.LodThreadFactory;
|
|
import com.seibel.lod.util.LodUtil;
|
|
|
|
import net.minecraft.block.AbstractPlantBlock;
|
|
import net.minecraft.block.BlockState;
|
|
import net.minecraft.block.Blocks;
|
|
import net.minecraft.block.BushBlock;
|
|
import net.minecraft.block.GrassBlock;
|
|
import net.minecraft.block.IGrowable;
|
|
import net.minecraft.block.LeavesBlock;
|
|
import net.minecraft.block.material.MaterialColor;
|
|
import net.minecraft.world.DimensionType;
|
|
import net.minecraft.world.IWorld;
|
|
import net.minecraft.world.biome.Biome;
|
|
import net.minecraft.world.chunk.ChunkSection;
|
|
import net.minecraft.world.chunk.IChunk;
|
|
import net.minecraft.world.gen.Heightmap;
|
|
|
|
/**
|
|
* This object is in charge of creating Lod related objects. (specifically: Lod
|
|
* World, Dimension, and Region objects)
|
|
*
|
|
* @author Leonardo Amato
|
|
* @author James Seibel
|
|
* @version 8-29-2021
|
|
*/
|
|
public class LodBuilder
|
|
{
|
|
private ExecutorService lodGenThreadPool = Executors.newSingleThreadExecutor(new LodThreadFactory(this.getClass().getSimpleName()));
|
|
|
|
public static final int CHUNK_DATA_WIDTH = LodUtil.CHUNK_WIDTH;
|
|
public static final int CHUNK_SECTION_HEIGHT = CHUNK_DATA_WIDTH;
|
|
public static final Heightmap.Type DEFAULT_HEIGHTMAP = Heightmap.Type.WORLD_SURFACE_WG;
|
|
|
|
/**
|
|
* If no blocks are found in the area in determineBottomPointForArea return this
|
|
*/
|
|
public static final short DEFAULT_DEPTH = -1;
|
|
/**
|
|
* If no blocks are found in the area in determineHeightPointForArea return this
|
|
*/
|
|
public static final short DEFAULT_HEIGHT = -1;
|
|
|
|
/**
|
|
* How wide LodDimensions should be in regions
|
|
*/
|
|
public int defaultDimensionWidthInRegions = 5;
|
|
|
|
public LodBuilder()
|
|
{
|
|
|
|
}
|
|
|
|
public void generateLodNodeAsync(IChunk chunk, LodWorld lodWorld, IWorld world)
|
|
{
|
|
generateLodNodeAsync(chunk, lodWorld, world, DistanceGenerationMode.SERVER);
|
|
}
|
|
|
|
|
|
public void generateLodNodeAsync(IChunk chunk, LodWorld lodWorld, IWorld world, DistanceGenerationMode generationMode)
|
|
{
|
|
if (lodWorld == null || !lodWorld.getIsWorldLoaded())
|
|
return;
|
|
|
|
// don't try to create an LOD object
|
|
// if for some reason we aren't
|
|
// given a valid chunk object
|
|
if (chunk == null)
|
|
return;
|
|
|
|
Thread thread = new Thread(() ->
|
|
{
|
|
try
|
|
{
|
|
DimensionType dim = world.dimensionType();
|
|
|
|
|
|
LodDimension lodDim;
|
|
|
|
if (lodWorld.getLodDimension(dim) == null)
|
|
{
|
|
lodDim = new LodDimension(dim, lodWorld, defaultDimensionWidthInRegions);
|
|
lodWorld.addLodDimension(lodDim);
|
|
} else
|
|
{
|
|
lodDim = lodWorld.getLodDimension(dim);
|
|
}
|
|
|
|
generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(generationMode), LodConfig.CLIENT.maxGenerationDetail.get());
|
|
} catch (IllegalArgumentException | NullPointerException e)
|
|
{
|
|
System.out.println("Chunk pos " + chunk.getPos());
|
|
e.printStackTrace();
|
|
// if the world changes while LODs are being generated
|
|
// they will throw errors as they try to access things that no longer
|
|
// exist.
|
|
}
|
|
});
|
|
lodGenThreadPool.execute(thread);
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Creates a LodChunk for a chunk in the given world.
|
|
*
|
|
* @throws IllegalArgumentException thrown if either the chunk or world is null.
|
|
*/
|
|
public void generateLodNodeFromChunk(LodDimension lodDim, IChunk chunk, LodDetail detailLevel) throws IllegalArgumentException
|
|
{
|
|
generateLodNodeFromChunk(lodDim, chunk, new LodBuilderConfig(), detailLevel);
|
|
}
|
|
|
|
/**
|
|
* Creates a LodChunk for a chunk in the given world.
|
|
*
|
|
* @throws IllegalArgumentException thrown if either the chunk or world is null.
|
|
*/
|
|
public void generateLodNodeFromChunk(LodDimension lodDim, IChunk chunk, LodBuilderConfig config, LodDetail detail)
|
|
throws IllegalArgumentException
|
|
{
|
|
|
|
if (chunk == null)
|
|
throw new IllegalArgumentException("generateLodFromChunk given a null chunk");
|
|
|
|
boolean check = false;
|
|
|
|
int startX;
|
|
int startZ;
|
|
int endX;
|
|
int endZ;
|
|
short[] color;
|
|
short height;
|
|
short depth;
|
|
LevelPos levelPos = new LevelPos((byte) 0, 0, 0);
|
|
short[] data;
|
|
try
|
|
{
|
|
for (int i = 0; i < detail.dataPointLengthCount * detail.dataPointLengthCount; i++)
|
|
{
|
|
startX = detail.startX[i];
|
|
startZ = detail.startZ[i];
|
|
endX = detail.endX[i];
|
|
endZ = detail.endZ[i];
|
|
|
|
color = generateLodColorForArea(chunk, config, startX, startZ, endX, endZ);
|
|
|
|
if (!config.useHeightmap)
|
|
{
|
|
height = determineHeightPointForArea(chunk.getSections(), startX, startZ, endX, endZ);
|
|
depth = determineBottomPointForArea(chunk.getSections(), startX, startZ, endX, endZ);
|
|
} else
|
|
{
|
|
height = determineHeightPoint(chunk.getOrCreateHeightmapUnprimed(LodUtil.DEFAULT_HEIGHTMAP), startX,
|
|
startZ, endX, endZ);
|
|
depth = 0;
|
|
}
|
|
levelPos.changeParameters((byte) 0,
|
|
chunk.getPos().x * 16 + startX,
|
|
chunk.getPos().z * 16 + startZ);
|
|
levelPos.convert(detail.detailLevel);
|
|
boolean isServer = config.distanceGenerationMode == DistanceGenerationMode.SERVER;
|
|
data = DataPoint.createDataPoint(height, depth, color[0], color[1], color[2]);
|
|
lodDim.addData(levelPos,
|
|
data,
|
|
false,
|
|
isServer);
|
|
}
|
|
//levelPos.changeParameters(LodUtil.CHUNK_DETAIL_LEVEL, chunk.getPos().x, chunk.getPos().z);
|
|
|
|
lodDim.updateData(new LevelPos(LodUtil.CHUNK_DETAIL_LEVEL, chunk.getPos().x, chunk.getPos().z));
|
|
} catch (Exception e)
|
|
{
|
|
//e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
|
|
// =====================//
|
|
// constructor helpers //
|
|
// =====================//
|
|
|
|
/**
|
|
* Find the lowest valid point from the bottom.
|
|
*/
|
|
private short determineBottomPointForArea(ChunkSection[] chunkSections, int startX, int startZ, int endX, int endZ)
|
|
{
|
|
int numberOfBlocksRequired = ((endX - startX) * (endZ - startZ) / 2);
|
|
|
|
// search from the bottom up
|
|
for (int section = 0; section < CHUNK_DATA_WIDTH; section++)
|
|
{
|
|
for (int y = 0; y < CHUNK_SECTION_HEIGHT; y++)
|
|
{
|
|
int numberOfBlocksFound = 0;
|
|
|
|
for (int x = startX; x < endX; x++)
|
|
{
|
|
for (int z = startZ; z < endZ; z++)
|
|
{
|
|
if (isLayerValidLodPoint(chunkSections, section, y, x, z))
|
|
{
|
|
numberOfBlocksFound++;
|
|
|
|
if (numberOfBlocksFound >= numberOfBlocksRequired)
|
|
{
|
|
// we found
|
|
// enough blocks in this
|
|
// layer to count as an
|
|
// LOD point
|
|
return (short) (y + (section * CHUNK_SECTION_HEIGHT));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// we never found a valid LOD point
|
|
return DEFAULT_DEPTH;
|
|
}
|
|
|
|
|
|
/**
|
|
* Find the lowest valid point from the bottom.
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
private short determineBottomPoint(Heightmap heightmap)
|
|
{
|
|
// the heightmap only shows how high the blocks go, it
|
|
// doesn't have any info about how low they go
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Find the highest valid point from the Top
|
|
*/
|
|
private short determineHeightPointForArea(ChunkSection[] chunkSections, int startX, int startZ, int endX, int endZ)
|
|
{
|
|
int numberOfBlocksRequired = ((endX - startX) * (endZ - startZ) / 2);
|
|
// search from the top down
|
|
for (int section = chunkSections.length - 1; section >= 0; section--)
|
|
{
|
|
for (int y = CHUNK_DATA_WIDTH - 1; y >= 0; y--)
|
|
{
|
|
int numberOfBlocksFound = 0;
|
|
|
|
for (int x = startX; x < endX; x++)
|
|
{
|
|
for (int z = startZ; z < endZ; z++)
|
|
{
|
|
if (isLayerValidLodPoint(chunkSections, section, y, x, z))
|
|
{
|
|
numberOfBlocksFound++;
|
|
|
|
if (numberOfBlocksFound >= numberOfBlocksRequired)
|
|
{
|
|
// we found
|
|
// enough blocks in this
|
|
// layer to count as an
|
|
// LOD point
|
|
return (short) (y + 1 + (section * CHUNK_SECTION_HEIGHT));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// we never found a valid LOD point
|
|
return DEFAULT_HEIGHT;
|
|
}
|
|
|
|
|
|
/**
|
|
* Find the highest point from the Top
|
|
*/
|
|
private short determineHeightPoint(Heightmap heightmap, int startX, int startZ, int endX, int endZ)
|
|
{
|
|
short highest = 0;
|
|
for (int x = startX; x < endX; x++)
|
|
{
|
|
for (int z = startZ; z < endZ; z++)
|
|
{
|
|
short newHeight = (short) heightmap.getFirstAvailable(x, z);
|
|
if (newHeight > highest)
|
|
highest = newHeight;
|
|
}
|
|
}
|
|
|
|
return highest;
|
|
}
|
|
|
|
/**
|
|
* Generate the color for the given chunk using biome water color, foliage
|
|
* color, and grass color.
|
|
*
|
|
* @param config_useSolidBlocksInColorGen <br>
|
|
* If true we look down from the top of
|
|
* the <br>
|
|
* chunk until we find a non-invisible
|
|
* block, and then use <br>
|
|
* its color. If false we generate the
|
|
* color immediately for <br>
|
|
* each x and z.
|
|
* @param config_useBiomeColors <br>
|
|
* If true use biome foliage, water, and
|
|
* grass colors, <br>
|
|
* otherwise only use the block's
|
|
* material color
|
|
*/
|
|
private short[] generateLodColorForArea(IChunk chunk, LodBuilderConfig config, int startX, int startZ, int endX,
|
|
int endZ)
|
|
{
|
|
ChunkSection[] chunkSections = chunk.getSections();
|
|
|
|
int numbOfBlocks = 0;
|
|
int red = 0;
|
|
int green = 0;
|
|
int blue = 0;
|
|
|
|
for (int x = startX; x < endX; x++)
|
|
{
|
|
for (int z = startZ; z < endZ; z++)
|
|
{
|
|
boolean foundBlock = false;
|
|
|
|
// go top down
|
|
for (int i = chunkSections.length - 1; !foundBlock && i >= 0; i--)
|
|
{
|
|
if (!foundBlock && (chunkSections[i] != null || !config.useSolidBlocksInColorGen))
|
|
{
|
|
for (int y = CHUNK_SECTION_HEIGHT - 1; !foundBlock && y >= 0; y--)
|
|
{
|
|
int colorInt = 0;
|
|
BlockState blockState = null;
|
|
|
|
if (chunkSections[i] != null)
|
|
{
|
|
blockState = chunkSections[i].getBlockState(x, y, z);
|
|
colorInt = blockState.materialColor.col;
|
|
}
|
|
|
|
if (colorInt == 0 && config.useSolidBlocksInColorGen)
|
|
{
|
|
// skip air or invisible blocks
|
|
continue;
|
|
}
|
|
|
|
if (config.useBiomeColors)
|
|
{
|
|
// I have no idea why I need to bit shift to the right, but
|
|
// if I don't the biomes don't show up correctly.
|
|
Biome biome = chunk.getBiomes().getNoiseBiome(x >> 2, y + 1 * chunkSections.length >> 2,
|
|
z >> 2);
|
|
colorInt = getColorForBiome(x, z, biome);
|
|
} else
|
|
{
|
|
|
|
// the bit shift is equivalent to dividing by 4
|
|
Biome biome = chunk.getBiomes().getNoiseBiome(x >> 2, y + i * chunkSections.length >> 2,
|
|
z >> 2);
|
|
colorInt = getColorForBlock(x, z, blockState, biome);
|
|
}
|
|
|
|
red += ColorUtil.getRed(colorInt);
|
|
green += ColorUtil.getGreen(colorInt);
|
|
blue += ColorUtil.getBlue(colorInt);
|
|
|
|
numbOfBlocks++;
|
|
|
|
// we found a valid block, skip to the
|
|
// next x and z
|
|
foundBlock = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (numbOfBlocks == 0)
|
|
numbOfBlocks = 1;
|
|
|
|
red /= numbOfBlocks;
|
|
green /= numbOfBlocks;
|
|
blue /= numbOfBlocks;
|
|
|
|
return new short[]{(short) red, (short) green, (short) blue};
|
|
}
|
|
|
|
/**
|
|
* Returns a color int for the given block.
|
|
*/
|
|
private int getColorForBlock(int x, int z, BlockState blockState, Biome biome)
|
|
{
|
|
int colorInt = 0;
|
|
|
|
// block special cases
|
|
if (blockState == Blocks.AIR.defaultBlockState() || blockState == Blocks.CAVE_AIR.defaultBlockState())
|
|
{
|
|
Color tmp = LodUtil.intToColor(biome.getGrassColor(x, z));
|
|
tmp = tmp.darker();
|
|
colorInt = LodUtil.colorToInt(tmp);
|
|
}
|
|
else if (blockState == Blocks.STONE.defaultBlockState())
|
|
{
|
|
colorInt = LodUtil.STONE_COLOR_INT;
|
|
}
|
|
else if (blockState == Blocks.MYCELIUM.defaultBlockState())
|
|
{
|
|
colorInt = LodUtil.MYCELIUM_COLOR_INT;
|
|
}
|
|
|
|
// plant life
|
|
else if (blockState.getBlock() instanceof LeavesBlock || blockState.getBlock() == Blocks.VINE)
|
|
{
|
|
Color leafColor = LodUtil.intToColor(biome.getFoliageColor()).darker();
|
|
leafColor = leafColor.darker();
|
|
colorInt = LodUtil.colorToInt(leafColor);
|
|
} else if ((blockState.getBlock() instanceof GrassBlock || blockState.getBlock() instanceof AbstractPlantBlock
|
|
|| blockState.getBlock() instanceof BushBlock || blockState.getBlock() instanceof IGrowable)
|
|
&& !(blockState.getBlock() == Blocks.BROWN_MUSHROOM || blockState.getBlock() == Blocks.RED_MUSHROOM))
|
|
{
|
|
Color plantColor = LodUtil.intToColor(biome.getGrassColor(x, z));
|
|
plantColor = plantColor.darker();
|
|
colorInt = LodUtil.colorToInt(plantColor);
|
|
}
|
|
|
|
// water
|
|
else if (blockState.getBlock() == Blocks.WATER)
|
|
{
|
|
colorInt = biome.getWaterColor();
|
|
}
|
|
|
|
// everything else
|
|
else
|
|
{
|
|
colorInt = blockState.materialColor.col;
|
|
}
|
|
|
|
return colorInt;
|
|
}
|
|
|
|
/**
|
|
* Returns a color int for the given biome.
|
|
*/
|
|
private int getColorForBiome(int x, int z, Biome biome)
|
|
{
|
|
int colorInt = 0;
|
|
|
|
switch (biome.getBiomeCategory())
|
|
{
|
|
|
|
case NETHER:
|
|
colorInt = Blocks.BEDROCK.defaultBlockState().materialColor.col;
|
|
break;
|
|
|
|
case THEEND:
|
|
colorInt = Blocks.END_STONE.defaultBlockState().materialColor.col;
|
|
break;
|
|
|
|
case BEACH:
|
|
case DESERT:
|
|
colorInt = Blocks.SAND.defaultBlockState().materialColor.col;
|
|
break;
|
|
|
|
case EXTREME_HILLS:
|
|
colorInt = Blocks.STONE.defaultMaterialColor().col;
|
|
break;
|
|
|
|
case MUSHROOM:
|
|
colorInt = MaterialColor.COLOR_LIGHT_GRAY.col;
|
|
break;
|
|
|
|
case ICY:
|
|
colorInt = Blocks.SNOW.defaultMaterialColor().col;
|
|
break;
|
|
|
|
case MESA:
|
|
colorInt = Blocks.RED_SAND.defaultMaterialColor().col;
|
|
break;
|
|
|
|
case OCEAN:
|
|
case RIVER:
|
|
colorInt = biome.getWaterColor();
|
|
break;
|
|
|
|
case NONE:
|
|
case FOREST:
|
|
case TAIGA:
|
|
case JUNGLE:
|
|
case PLAINS:
|
|
case SAVANNA:
|
|
case SWAMP:
|
|
default:
|
|
Color tmp = LodUtil.intToColor(biome.getGrassColor(x, z));
|
|
tmp = tmp.darker();
|
|
colorInt = LodUtil.colorToInt(tmp);
|
|
break;
|
|
|
|
}
|
|
|
|
return colorInt;
|
|
}
|
|
|
|
/**
|
|
* Is the layer between the given X, Z, and dataIndex values a valid LOD point?
|
|
*/
|
|
private boolean isLayerValidLodPoint(ChunkSection[] chunkSections, int sectionIndex, int y, int x, int z)
|
|
{
|
|
if (chunkSections[sectionIndex] == null)
|
|
{
|
|
// this section doesn't have any blocks,
|
|
// it is not a valid section
|
|
return false;
|
|
} else
|
|
{
|
|
if (chunkSections[sectionIndex].getBlockState(x, y, z) != null
|
|
&& chunkSections[sectionIndex].getBlockState(x, y, z).getBlock() != Blocks.AIR
|
|
&& chunkSections[sectionIndex].getBlockState(x, y, z).getBlock() != Blocks.CAVE_AIR)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|