delete deprecated classes
This commit is contained in:
austin
parent
329559bfd7
commit
222a3ebe9f
@ -1800,6 +1800,7 @@ Safe executor service creation in non final static contexts
|
|||||||
Fix reloading client world repeatedly
|
Fix reloading client world repeatedly
|
||||||
AI manager thread safeing
|
AI manager thread safeing
|
||||||
AI manager better error handling
|
AI manager better error handling
|
||||||
|
Delete deprecated classes
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -1,706 +0,0 @@
|
|||||||
package electrosphere.client.terrain.cells;
|
|
||||||
|
|
||||||
import java.util.HashMap;
|
|
||||||
import java.util.HashSet;
|
|
||||||
import java.util.List;
|
|
||||||
import java.util.Map;
|
|
||||||
import java.util.Set;
|
|
||||||
|
|
||||||
import org.joml.Vector3d;
|
|
||||||
import org.joml.Vector3i;
|
|
||||||
|
|
||||||
import electrosphere.client.terrain.cache.ChunkData;
|
|
||||||
import electrosphere.client.terrain.cells.DrawCell.DrawCellFace;
|
|
||||||
import electrosphere.client.terrain.manager.ClientTerrainManager;
|
|
||||||
import electrosphere.collision.PhysicsEntityUtils;
|
|
||||||
import electrosphere.engine.Globals;
|
|
||||||
import electrosphere.entity.EntityUtils;
|
|
||||||
import electrosphere.net.parser.net.message.TerrainMessage;
|
|
||||||
import electrosphere.renderer.shader.VisualShader;
|
|
||||||
import electrosphere.server.physics.terrain.manager.ServerTerrainChunk;
|
|
||||||
|
|
||||||
@Deprecated
|
|
||||||
/**
|
|
||||||
* Manages the graphical entities for the terrain chunks
|
|
||||||
*
|
|
||||||
*
|
|
||||||
*
|
|
||||||
Notes for integrating with transvoxel algo:
|
|
||||||
Different problems to tackle
|
|
||||||
|
|
||||||
For all chunks within minimum radius, check if they can be updated and update accordingly <--- we do this currently
|
|
||||||
|
|
||||||
|
|
||||||
For all chunks between minimum radius and first LOD radius, check if we can make a LOD chunk
|
|
||||||
If we can, make a lod chunk or see if it can be updated
|
|
||||||
This check will be:
|
|
||||||
For every position, check if all four positions required for LOD chunk are within lod radius
|
|
||||||
if yes, make lod chunk
|
|
||||||
|
|
||||||
If we cannot, create a fullres chunk
|
|
||||||
This check will be:
|
|
||||||
For every position, check if all four positions required for LOD chunk are within lod radius
|
|
||||||
if yes, make lod chunk
|
|
||||||
if they are outside the far bound, create lod chunk
|
|
||||||
if they are within the near bound, create a fullres chunk
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
*/
|
|
||||||
public class DrawCellManager {
|
|
||||||
|
|
||||||
|
|
||||||
//the center of this cell manager's array in cell space
|
|
||||||
int cellX;
|
|
||||||
int cellY;
|
|
||||||
int cellZ;
|
|
||||||
|
|
||||||
//all currently displaying mini cells
|
|
||||||
Set<DrawCell> cells = new HashSet<DrawCell>();
|
|
||||||
Map<String,DrawCell> keyCellMap = new HashMap<String,DrawCell>();
|
|
||||||
|
|
||||||
//status of all position keys
|
|
||||||
Set<String> hasNotRequested = new HashSet<String>();
|
|
||||||
Set<String> requested = new HashSet<String>();
|
|
||||||
Set<String> drawable = new HashSet<String>();
|
|
||||||
Set<String> undrawable = new HashSet<String>();
|
|
||||||
Set<String> updateable = new HashSet<String>();
|
|
||||||
|
|
||||||
//LOD level of all position keys
|
|
||||||
Map<String,Integer> positionLODLevel = new HashMap<String,Integer>();
|
|
||||||
|
|
||||||
//voxel atlas
|
|
||||||
VoxelTextureAtlas atlas;
|
|
||||||
|
|
||||||
//shader program for drawable cells
|
|
||||||
VisualShader program;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
//the real-space radius for which we will construct draw cells inside of
|
|
||||||
//ie, we check if the draw cell's entity would be inside this radius. If it would, create the draw cell, otherwise don't
|
|
||||||
double drawFullModelRadius = 70;
|
|
||||||
|
|
||||||
//the radius we'll draw LODed chunks for
|
|
||||||
double drawLODRadius = drawFullModelRadius + ServerTerrainChunk.CHUNK_DIMENSION * (2*2 + 4*4 + 8*8 + 16*16);
|
|
||||||
|
|
||||||
|
|
||||||
//the number of possible LOD levels
|
|
||||||
//1,2,4,8,16
|
|
||||||
static final int NUMBER_OF_LOD_LEVELS = 5;
|
|
||||||
|
|
||||||
//the table of lod leve -> radius at which we will look for chunks within this log
|
|
||||||
double[] lodLevelRadiusTable = new double[5];
|
|
||||||
|
|
||||||
//the radius for which physics meshes are created when draw cells are created
|
|
||||||
int physicsRadius = 3;
|
|
||||||
|
|
||||||
//ready to start updating?
|
|
||||||
boolean update = false;
|
|
||||||
|
|
||||||
//controls whether we try to generate the drawable entities
|
|
||||||
//we want this to be false when in server-only mode
|
|
||||||
boolean generateDrawables = false;
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* DrawCellManager constructor
|
|
||||||
* @param commonWorldData The common world data
|
|
||||||
* @param clientTerrainManager The client terrain manager
|
|
||||||
* @param discreteX The initial discrete position X coordinate
|
|
||||||
* @param discreteY The initial discrete position Y coordinate
|
|
||||||
*/
|
|
||||||
public DrawCellManager(ClientTerrainManager clientTerrainManager, int discreteX, int discreteY, int discreteZ){
|
|
||||||
cellX = discreteX;
|
|
||||||
cellY = discreteY;
|
|
||||||
cellZ = discreteZ;
|
|
||||||
|
|
||||||
program = Globals.terrainShaderProgram;
|
|
||||||
|
|
||||||
//the first lod level is set by user
|
|
||||||
lodLevelRadiusTable[0] = drawFullModelRadius;
|
|
||||||
//generate LOD radius table
|
|
||||||
for(int i = 1; i < NUMBER_OF_LOD_LEVELS; i++){
|
|
||||||
double sizeOfSingleModel = Math.pow(2,i) * ServerTerrainChunk.CHUNK_DIMENSION;
|
|
||||||
//size of the radius for this lod level should be three times the size of a model + the previous radius
|
|
||||||
//this guarantees we get at least one adapter chunk, one proper chunk, and also that the radius accounts for the previous lod level chunks
|
|
||||||
lodLevelRadiusTable[i] = lodLevelRadiusTable[i-1] + sizeOfSingleModel * 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
physicsRadius = Globals.userSettings.getGameplayPhysicsCellRadius();
|
|
||||||
|
|
||||||
invalidateAllCells();
|
|
||||||
|
|
||||||
update = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Private constructor
|
|
||||||
*/
|
|
||||||
DrawCellManager(){
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Sets the player's current position in cell-space
|
|
||||||
* @param cellPos The cell's position
|
|
||||||
*/
|
|
||||||
public void setPlayerCell(Vector3i cellPos){
|
|
||||||
cellX = cellPos.x;
|
|
||||||
cellY = cellPos.y;
|
|
||||||
cellZ = cellPos.z;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Update function that is called if a cell has not been requested
|
|
||||||
*/
|
|
||||||
void updateUnrequestedCell(){
|
|
||||||
if(hasNotRequested.size() > 0){
|
|
||||||
String targetKey = hasNotRequested.iterator().next();
|
|
||||||
hasNotRequested.remove(targetKey);
|
|
||||||
Vector3i worldPos = getVectorFromKey(targetKey);
|
|
||||||
|
|
||||||
//
|
|
||||||
//Because of the way marching cubes works, we need to request the adjacent chunks so we know how to properly blend between one chunk and the next
|
|
||||||
//The following loop-hell does this
|
|
||||||
//
|
|
||||||
for(int i = 0; i < 2; i++){
|
|
||||||
for(int j = 0; j < 2; j++){
|
|
||||||
for(int k = 0; k < 2; k++){
|
|
||||||
Vector3i posToCheck = new Vector3i(worldPos).add(i,j,k);
|
|
||||||
String requestKey = getCellKey(posToCheck.x,posToCheck.y,posToCheck.z);
|
|
||||||
if(
|
|
||||||
posToCheck.x >= 0 &&
|
|
||||||
posToCheck.x < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
posToCheck.y >= 0 &&
|
|
||||||
posToCheck.y < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
posToCheck.z >= 0 &&
|
|
||||||
posToCheck.z < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
!Globals.clientTerrainManager.containsChunkDataAtWorldPoint(posToCheck.x, posToCheck.y, posToCheck.z, ChunkData.NO_STRIDE)
|
|
||||||
){
|
|
||||||
if(!requested.contains(requestKey)){
|
|
||||||
//client should request chunk data from server for each chunk necessary to create the model
|
|
||||||
Globals.clientConnection.queueOutgoingMessage(TerrainMessage.constructRequestChunkDataMessage(
|
|
||||||
posToCheck.x,
|
|
||||||
posToCheck.y,
|
|
||||||
posToCheck.z
|
|
||||||
));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
undrawable.add(targetKey);
|
|
||||||
requested.add(targetKey);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Makes one of the undrawable cells drawable
|
|
||||||
*/
|
|
||||||
void makeCellDrawable(){
|
|
||||||
if(undrawable.size() > 0){
|
|
||||||
String targetKey = undrawable.iterator().next();
|
|
||||||
Vector3i worldPos = getVectorFromKey(targetKey);
|
|
||||||
|
|
||||||
//
|
|
||||||
//Checks if all chunk data necessary to generate a mesh is present
|
|
||||||
boolean containsNecessaryChunks = true;
|
|
||||||
for(int i = 0; i < 2; i++){
|
|
||||||
for(int j = 0; j < 2; j++){
|
|
||||||
for(int k = 0; k < 2; k++){
|
|
||||||
Vector3i posToCheck = new Vector3i(worldPos).add(i,j,k);
|
|
||||||
if(worldPos.x >= 0 &&
|
|
||||||
posToCheck.x < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
posToCheck.y >= 0 &&
|
|
||||||
posToCheck.y < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
posToCheck.z >= 0 &&
|
|
||||||
posToCheck.z < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
!containsChunkDataAtWorldPoint(posToCheck.x,posToCheck.y,posToCheck.z)
|
|
||||||
){
|
|
||||||
containsNecessaryChunks = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//
|
|
||||||
//if contains data for all chunks necessary to generate visuals
|
|
||||||
if(containsNecessaryChunks){
|
|
||||||
|
|
||||||
//update the status of the terrain key
|
|
||||||
undrawable.remove(targetKey);
|
|
||||||
drawable.add(targetKey);
|
|
||||||
|
|
||||||
//build the cell
|
|
||||||
DrawCell cell = DrawCell.generateTerrainCell(
|
|
||||||
worldPos,
|
|
||||||
0
|
|
||||||
);
|
|
||||||
cells.add(cell);
|
|
||||||
keyCellMap.put(targetKey,cell);
|
|
||||||
List<DrawCellFace> higherLODFace = null;
|
|
||||||
keyCellMap.get(targetKey).generateDrawableEntity(atlas,0,higherLODFace);
|
|
||||||
|
|
||||||
// //evaluate for foliage
|
|
||||||
// Globals.clientFoliageManager.evaluateChunk(worldPos);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Updates a cell that can be updated
|
|
||||||
*/
|
|
||||||
void updateCellModel(){
|
|
||||||
if(updateable.size() > 0){
|
|
||||||
String targetKey = updateable.iterator().next();
|
|
||||||
updateable.remove(targetKey);
|
|
||||||
Vector3i worldPos = getVectorFromKey(targetKey);
|
|
||||||
if(
|
|
||||||
worldPos.x >= 0 &&
|
|
||||||
worldPos.x < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
worldPos.y >= 0 &&
|
|
||||||
worldPos.y < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
worldPos.z >= 0 &&
|
|
||||||
worldPos.z < Globals.clientWorldData.getWorldDiscreteSize()
|
|
||||||
){
|
|
||||||
keyCellMap.get(targetKey).destroy();
|
|
||||||
List<DrawCellFace> higherLODFace = null;
|
|
||||||
keyCellMap.get(targetKey).generateDrawableEntity(atlas,0,higherLODFace);
|
|
||||||
}
|
|
||||||
drawable.add(targetKey);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if the manager contains a cell position that hasn't had its chunk data requested from the server yet
|
|
||||||
* @return true if there is an unrequested cell, false otherwise
|
|
||||||
*/
|
|
||||||
public boolean containsUnrequestedCell(){
|
|
||||||
return hasNotRequested.size() > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if the manager contains a cell who hasn't been made drawable yet
|
|
||||||
* @return true if there is an undrawable cell, false otherwise
|
|
||||||
*/
|
|
||||||
public boolean containsUndrawableCell(){
|
|
||||||
return undrawable.size() > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if the manager contains a cell who needs to be updated
|
|
||||||
* @return true if there is an updateable cell, false otherwise
|
|
||||||
*/
|
|
||||||
public boolean containsUpdateableCell(){
|
|
||||||
return updateable.size() > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Transforms a real coordinate into a cell-space coordinate
|
|
||||||
* @param input the real coordinate
|
|
||||||
* @return the cell coordinate
|
|
||||||
*/
|
|
||||||
public int transformRealSpaceToCellSpace(double input){
|
|
||||||
return (int)(input / ServerTerrainChunk.CHUNK_DIMENSION);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Clears the valid set and adds all keys to invalid set
|
|
||||||
*/
|
|
||||||
public void invalidateAllCells(){
|
|
||||||
drawable.clear();
|
|
||||||
hasNotRequested.clear();
|
|
||||||
clearOutOfBoundsCells();
|
|
||||||
queueNewCells();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Calculates whether the position of the player has changed and if so, invalidates and cleans up cells accordingly
|
|
||||||
*/
|
|
||||||
private void calculateDeltas(){
|
|
||||||
//check if any not requested cells no longer need to be requested
|
|
||||||
clearOutOfBoundsCells();
|
|
||||||
//check if any cells should be added
|
|
||||||
queueNewCells();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Clears all cells outside of draw radius
|
|
||||||
*/
|
|
||||||
private void clearOutOfBoundsCells(){
|
|
||||||
Set<DrawCell> cellsToRemove = new HashSet<DrawCell>();
|
|
||||||
for(DrawCell cell : cells){
|
|
||||||
Vector3d realPos = cell.getRealPos();
|
|
||||||
if(Globals.playerEntity != null && EntityUtils.getPosition(Globals.playerEntity).distance(realPos) > drawFullModelRadius){
|
|
||||||
cellsToRemove.add(cell);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for(DrawCell cell : cellsToRemove){
|
|
||||||
cells.remove(cell);
|
|
||||||
String key = getCellKey(cell.worldPos.x, cell.worldPos.y, cell.worldPos.z);
|
|
||||||
hasNotRequested.remove(key);
|
|
||||||
drawable.remove(key);
|
|
||||||
undrawable.remove(key);
|
|
||||||
updateable.remove(key);
|
|
||||||
keyCellMap.remove(key);
|
|
||||||
requested.remove(key);
|
|
||||||
cell.destroy();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Queues new cells that are in bounds but not currently accounted for
|
|
||||||
*/
|
|
||||||
private void queueNewCells(){
|
|
||||||
if(Globals.playerEntity != null && Globals.clientWorldData != null){
|
|
||||||
Vector3d playerPos = EntityUtils.getPosition(Globals.playerEntity);
|
|
||||||
for(int x = -(int)drawFullModelRadius; x < drawFullModelRadius; x = x + ChunkData.CHUNK_DATA_SIZE){
|
|
||||||
for(int y = -(int)drawFullModelRadius; y < drawFullModelRadius; y = y + ChunkData.CHUNK_DATA_SIZE){
|
|
||||||
for(int z = -(int)drawFullModelRadius; z < drawFullModelRadius; z = z + ChunkData.CHUNK_DATA_SIZE){
|
|
||||||
Vector3d newPos = new Vector3d(playerPos.x + x, playerPos.y + y, playerPos.z + z);
|
|
||||||
Vector3i worldPos = new Vector3i(
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(newPos.x),
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(newPos.y),
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(newPos.z)
|
|
||||||
);
|
|
||||||
Vector3d chunkRealSpace = new Vector3d(
|
|
||||||
Globals.clientWorldData.convertChunkToRealSpace(worldPos.x),
|
|
||||||
Globals.clientWorldData.convertChunkToRealSpace(worldPos.y),
|
|
||||||
Globals.clientWorldData.convertChunkToRealSpace(worldPos.z)
|
|
||||||
);
|
|
||||||
if(
|
|
||||||
playerPos.distance(chunkRealSpace) < drawFullModelRadius &&
|
|
||||||
worldPos.x >= 0 &&
|
|
||||||
worldPos.x < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
worldPos.y >= 0 &&
|
|
||||||
worldPos.y < Globals.clientWorldData.getWorldDiscreteSize() &&
|
|
||||||
worldPos.z >= 0 &&
|
|
||||||
worldPos.z < Globals.clientWorldData.getWorldDiscreteSize()
|
|
||||||
){
|
|
||||||
String key = getCellKey(
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(chunkRealSpace.x),
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(chunkRealSpace.y),
|
|
||||||
Globals.clientWorldData.convertRealToChunkSpace(chunkRealSpace.z)
|
|
||||||
);
|
|
||||||
if(!keyCellMap.containsKey(key) && !hasNotRequested.contains(key) && !undrawable.contains(key) && !drawable.contains(key) &&
|
|
||||||
!requested.contains(key)){
|
|
||||||
hasNotRequested.add(key);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Updates cells that need updating in this manager
|
|
||||||
*/
|
|
||||||
public void update(){
|
|
||||||
calculateDeltas();
|
|
||||||
if(containsUnrequestedCell() && !containsUndrawableCell()){
|
|
||||||
updateUnrequestedCell();
|
|
||||||
} else if(containsUndrawableCell()){
|
|
||||||
makeCellDrawable();
|
|
||||||
} else if(containsUpdateableCell()){
|
|
||||||
updateCellModel();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Controls whether the client generates drawable chunks or just physics chunks (ie if running a headless client)
|
|
||||||
* @param generate true to generate graphics, false otherwise
|
|
||||||
*/
|
|
||||||
public void setGenerateDrawables(boolean generate){
|
|
||||||
this.generateDrawables = generate;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if the terrain cache has a chunk at a given world point
|
|
||||||
* @param worldX the x coordinate
|
|
||||||
* @param worldY the y coordinate
|
|
||||||
* @param worldZ the z coordinate
|
|
||||||
* @return true if the chunk data exists, false otherwise
|
|
||||||
*/
|
|
||||||
boolean containsChunkDataAtWorldPoint(int worldX, int worldY, int worldZ){
|
|
||||||
if(Globals.clientTerrainManager != null){
|
|
||||||
return Globals.clientTerrainManager.containsChunkDataAtWorldPoint(worldX,worldY,worldZ,ChunkData.NO_STRIDE);
|
|
||||||
}
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Gets the chunk data at a given point
|
|
||||||
* @param worldX The world position x component of the cell
|
|
||||||
* @param worldY The world position y component of the cell
|
|
||||||
* @param worldZ The world position z component of the cell
|
|
||||||
* @return The chunk data at the specified points
|
|
||||||
*/
|
|
||||||
ChunkData getChunkDataAtPoint(int worldX, int worldY, int worldZ){
|
|
||||||
return Globals.clientTerrainManager.getChunkDataAtWorldPoint(worldX,worldY,worldZ,ChunkData.NO_STRIDE);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Gets a unique key for the cell
|
|
||||||
* @param worldX The world position x component of the cell
|
|
||||||
* @param worldY The world position y component of the cell
|
|
||||||
* @param worldZ The world position z component of the cell
|
|
||||||
* @return The key
|
|
||||||
*/
|
|
||||||
private String getCellKey(int worldX, int worldY, int worldZ){
|
|
||||||
return worldX + "_" + worldY + "_" + worldZ;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Parses a vector3i from the cell key
|
|
||||||
* @param key The cell key
|
|
||||||
* @return The vector3i containing the components of the cell key
|
|
||||||
*/
|
|
||||||
private Vector3i getVectorFromKey(String key){
|
|
||||||
String[] keyComponents = key.split("_");
|
|
||||||
return new Vector3i(Integer.parseInt(keyComponents[0]),Integer.parseInt(keyComponents[1]),Integer.parseInt(keyComponents[2]));
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Marks a data cell as updateable (can be regenerated with a new model because the underlying data has changed)
|
|
||||||
* @param chunkX The chunk x coordinate
|
|
||||||
* @param chunkY The chunk y coordinate
|
|
||||||
* @param chunkZ The chunk z coordinate
|
|
||||||
*/
|
|
||||||
public void markUpdateable(int chunkX, int chunkY, int chunkZ){
|
|
||||||
updateable.add(getCellKey(chunkX, chunkY, chunkZ));
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Evicts all chunks
|
|
||||||
*/
|
|
||||||
public void evictAll(){
|
|
||||||
//destroy models
|
|
||||||
for(String key : drawable){
|
|
||||||
keyCellMap.get(key).destroy();
|
|
||||||
}
|
|
||||||
keyCellMap.clear();
|
|
||||||
hasNotRequested.clear();
|
|
||||||
requested.clear();
|
|
||||||
drawable.clear();
|
|
||||||
undrawable.clear();
|
|
||||||
updateable.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Gets the radius within which full-detail models are drawn
|
|
||||||
* @return the radius
|
|
||||||
*/
|
|
||||||
public double getDrawFullModelRadius(){
|
|
||||||
return drawFullModelRadius;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Initializes the voxel texture atlas
|
|
||||||
*/
|
|
||||||
public void attachTextureAtlas(VoxelTextureAtlas voxelTextureAtlas){
|
|
||||||
atlas = voxelTextureAtlas;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if the draw cell at the given world position has generated physics
|
|
||||||
* @param worldPos The world position
|
|
||||||
* @return true if has generated physics, false otherwise
|
|
||||||
*/
|
|
||||||
public boolean generatedPhysics(Vector3i worldPos){
|
|
||||||
String key = this.getCellKey(worldPos.x, worldPos.y, worldPos.z);
|
|
||||||
if(!keyCellMap.containsKey(key)){
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
DrawCell cell = this.keyCellMap.get(key);
|
|
||||||
return cell.modelEntity != null && PhysicsEntityUtils.getDBody(cell.modelEntity) != null;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
transvoxel algorithm spacing management
|
|
||||||
|
|
||||||
want to specify a radius and have it be a circle so we're not wasting resolution on far off corners
|
|
||||||
To benefit from the LOD, should have a series of for loops
|
|
||||||
First loop iterates over (-largest radius) -> (largest radius) at an interval of the width of the lowest level of detail chunk
|
|
||||||
We check all 8 corners of the chunk to see if they all fall within the largest lod concentric circle
|
|
||||||
There are a few cases to consider
|
|
||||||
- All fall outside the largest LOD radius (ignore)
|
|
||||||
- All but one fall outside thel argest LOD radius (ignore)
|
|
||||||
- All fall within the largest LOD circle (make LOD chunk)
|
|
||||||
- One is within the next LOD radius, others are within the current LOD radius (ignore for this pass)
|
|
||||||
- All are within a lower LOD radius (ignore)
|
|
||||||
|
|
||||||
Once we're done with the largest LOD radius, we go to a higher resolution radius and iterate for smaller bounds
|
|
||||||
|
|
||||||
In a middle LOD level, if all corners are outside, but the lower resolution didn't
|
|
||||||
already pick it up, still need to generate a chunk at the current resolution
|
|
||||||
|
|
||||||
Detection of this case is tricky
|
|
||||||
We could snap the currently considered position to the nearest low-resolution chunk and then bounds check that low resolution chunk for every
|
|
||||||
higher resolution position we're considering
|
|
||||||
This is probably a bad idea
|
|
||||||
|
|
||||||
We could recurse every time a chunk doesn't work for the current level of detail, then evaluate it for a higher level of detail at this closer value
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
//the number of corners to consider for a valid chunk
|
|
||||||
static final int NUM_CORNERS_TO_CONSIDER = 8;
|
|
||||||
|
|
||||||
//offsets to get from current position to the actual corner to consider
|
|
||||||
int[] cornerOffsetsX = new int[]{0,1,0,1,0,1,0,1,};
|
|
||||||
int[] cornerOffsetsY = new int[]{0,0,0,0,1,1,1,1,};
|
|
||||||
int[] cornerOffsetsZ = new int[]{0,0,1,1,0,0,1,1,};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Recursive function that does chunk validity checking
|
|
||||||
* @param playerChunkPos
|
|
||||||
* @param minPoint
|
|
||||||
* @param maxPoint
|
|
||||||
* @param currentLOD
|
|
||||||
*/
|
|
||||||
public void assesChunkPositionsAtLOD(
|
|
||||||
Vector3i playerChunkPos,
|
|
||||||
Vector3i minPoint,
|
|
||||||
Vector3i maxPoint,
|
|
||||||
int currentLOD
|
|
||||||
){
|
|
||||||
Vector3i currentChunkPositionConsidered = new Vector3i(playerChunkPos); // The chunk position we're currently considering
|
|
||||||
double currentRadius = lodLevelRadiusTable[currentLOD];
|
|
||||||
double nextRadius = 0;
|
|
||||||
int increment = 1;
|
|
||||||
if(currentLOD > 0){
|
|
||||||
//only works when the LOD is greater than 0. When it's 0, there is no lower bound on chunk positions to generate
|
|
||||||
nextRadius = lodLevelRadiusTable[currentLOD-1];
|
|
||||||
increment = (int)Math.pow(2,currentLOD);
|
|
||||||
}
|
|
||||||
|
|
||||||
//iterate
|
|
||||||
for(int x = minPoint.x; x < maxPoint.x; x = x + increment){
|
|
||||||
for(int y = minPoint.y; y < maxPoint.x; y = y + increment){
|
|
||||||
for(int z = minPoint.z; z < maxPoint.x; z = z + increment){
|
|
||||||
//we have 8 corners to consider
|
|
||||||
//need to identify which case the current position is
|
|
||||||
int positionCase = 0;
|
|
||||||
for(int j = 0; j < NUM_CORNERS_TO_CONSIDER; j++){
|
|
||||||
currentChunkPositionConsidered.set(
|
|
||||||
x + cornerOffsetsX[j] * increment,
|
|
||||||
y + cornerOffsetsY[j] * increment,
|
|
||||||
z + cornerOffsetsZ[j] * increment
|
|
||||||
);
|
|
||||||
//figure out the case of this corner
|
|
||||||
double distance = currentChunkPositionConsidered.distance(playerChunkPos);
|
|
||||||
if(distance > currentRadius){
|
|
||||||
positionCase = 1;
|
|
||||||
break;
|
|
||||||
} else if(distance <= nextRadius){
|
|
||||||
positionCase = 2;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
switch(positionCase){
|
|
||||||
case 0: {
|
|
||||||
//fully within current band, generate chunk
|
|
||||||
} break;
|
|
||||||
case 1: {
|
|
||||||
//partially outside bound, ignore
|
|
||||||
} break;
|
|
||||||
case 2: {
|
|
||||||
//partially inside higher resolution bound, recurse
|
|
||||||
assesChunkPositionsAtLOD(
|
|
||||||
playerChunkPos,
|
|
||||||
new Vector3i(x,y,z),
|
|
||||||
new Vector3i(x+increment,y+increment,z+increment),
|
|
||||||
currentLOD
|
|
||||||
);
|
|
||||||
} break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Assess all LOD chunk levels
|
|
||||||
*/
|
|
||||||
public void assesLODChunks(){
|
|
||||||
|
|
||||||
//pre-existing values
|
|
||||||
Vector3d playerPosition = EntityUtils.getPosition(Globals.playerEntity);
|
|
||||||
Vector3i playerChunkPosition = Globals.clientWorldData.convertRealToWorldSpace(playerPosition);
|
|
||||||
|
|
||||||
//variables used while iterating across chunk positions
|
|
||||||
double currentRadius = 0; //the current radius is in units of chunks, even though it's a double (it's discrete, not real)
|
|
||||||
double nextRadius = 0; //the next radius is in units of chunks, even though it's a double (it's discrete, not real)
|
|
||||||
int increment = 1; //the increment is in units of chunks, not real
|
|
||||||
//the offsets from the player's position to
|
|
||||||
//the nearest possible spot we could place a chunk of the current LOD at (in units of chunks)
|
|
||||||
Vector3i lowerOffsets = new Vector3i(0,0,0);
|
|
||||||
Vector3i currentChunkPositionConsidered = new Vector3i(playerChunkPosition); // The chunk position we're currently considering
|
|
||||||
|
|
||||||
//actual logic to search for valid chunks
|
|
||||||
for(int i = NUMBER_OF_LOD_LEVELS - 1; i >= 0; i--){
|
|
||||||
currentRadius = lodLevelRadiusTable[i];
|
|
||||||
nextRadius = 0;
|
|
||||||
increment = 1;
|
|
||||||
if(i > 0){
|
|
||||||
//only works when the LOD is greater than 0. When it's 0, there is no lower bound on chunk positions to generate
|
|
||||||
nextRadius = lodLevelRadiusTable[i-1];
|
|
||||||
increment = (int)Math.pow(2,i);
|
|
||||||
}
|
|
||||||
//calculate offsets to get from player's current chunk position to the lower resolution grid for the current LOD
|
|
||||||
lowerOffsets.x = playerChunkPosition.x % ((int)increment);
|
|
||||||
lowerOffsets.y = playerChunkPosition.y % ((int)increment);
|
|
||||||
lowerOffsets.z = playerChunkPosition.z % ((int)increment);
|
|
||||||
|
|
||||||
//iterate
|
|
||||||
for(int x = -(int)currentRadius - lowerOffsets.x; x < currentRadius; x = x + increment){
|
|
||||||
for(int y = -(int)currentRadius - lowerOffsets.y; y < currentRadius; y = y + increment){
|
|
||||||
for(int z = -(int)currentRadius - lowerOffsets.z; z < currentRadius; z = z + increment){
|
|
||||||
//we have 8 corners to consider
|
|
||||||
//need to identify which case the current position is
|
|
||||||
int positionCase = 0;
|
|
||||||
for(int j = 0; j < NUM_CORNERS_TO_CONSIDER; j++){
|
|
||||||
currentChunkPositionConsidered.set(
|
|
||||||
x + cornerOffsetsX[j] * increment,
|
|
||||||
y + cornerOffsetsY[j] * increment,
|
|
||||||
z + cornerOffsetsZ[j] * increment
|
|
||||||
);
|
|
||||||
//figure out the case of this corner
|
|
||||||
double distance = currentChunkPositionConsidered.distance(playerChunkPosition);
|
|
||||||
if(distance > currentRadius){
|
|
||||||
positionCase = 1;
|
|
||||||
break;
|
|
||||||
} else if(distance <= nextRadius){
|
|
||||||
positionCase = 2;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
switch(positionCase){
|
|
||||||
case 0: {
|
|
||||||
//fully within current band, generate chunk
|
|
||||||
} break;
|
|
||||||
case 1: {
|
|
||||||
//partially outside bound, ignore
|
|
||||||
} break;
|
|
||||||
case 2: {
|
|
||||||
//partially inside higher resolution bound, recurse
|
|
||||||
} break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
@ -1,245 +0,0 @@
|
|||||||
package electrosphere.renderer.meshgen;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Utilities for generating and managing skyboxes
|
|
||||||
*/
|
|
||||||
public class SkyboxMeshgen {
|
|
||||||
|
|
||||||
|
|
||||||
// public static Model createSkyboxModel(Material optionalMaterial){
|
|
||||||
// Model skyboxModel = new Model();
|
|
||||||
// skyboxModel.meshes = new ArrayList<Mesh>();
|
|
||||||
|
|
||||||
// skyboxModel.modelMatrix = new Matrix4d();
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// // boolean apply_lighting = false;
|
|
||||||
// // boolean has_bones = false;
|
|
||||||
|
|
||||||
// Mesh skyboxmesh = new Mesh("skybox"){
|
|
||||||
// @Override
|
|
||||||
// public void complexDraw(RenderPipelineState renderPipelineState){
|
|
||||||
// if(renderPipelineState.getUseMeshShader()){
|
|
||||||
// GL11.glDepthFunc(GL_LEQUAL);
|
|
||||||
// glUseProgram(shader.getShaderId());
|
|
||||||
// }
|
|
||||||
|
|
||||||
// if(renderPipelineState.getUseMaterial()){
|
|
||||||
// if(this.getMaterial() == null){
|
|
||||||
// Globals.materialDefault.apply_material(0,1);
|
|
||||||
// Iterator<Vector3f> colorIterator = Globals.skyboxColors.iterator();
|
|
||||||
// int counter = 0;
|
|
||||||
// float[] temp = new float[3];
|
|
||||||
// while(colorIterator.hasNext()){
|
|
||||||
// Vector3f colorCurrent = colorIterator.next();
|
|
||||||
// temp[0] = colorCurrent.x / 255.0f;
|
|
||||||
// temp[1] = colorCurrent.y / 255.0f;
|
|
||||||
// temp[2] = colorCurrent.z / 255.0f;
|
|
||||||
// // System.out.println("colors[" + counter + "] " + temp[0] + " " + temp[1] + " " + temp[2]);
|
|
||||||
// glUniform3fv(glGetUniformLocation(shader.getShaderId(), "colors[" + counter + "]"), temp);
|
|
||||||
// counter++;
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
// glBindVertexArray(vertexArrayObject);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// if(renderPipelineState.getBufferStandardUniforms()){
|
|
||||||
// //buffer model/view/proj matrices
|
|
||||||
// glUniformMatrix4fv(shader.shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16]));
|
|
||||||
// glUniformMatrix4fv(shader.shaderVertexViewLoc, false, new Matrix4f(Globals.viewMatrix).scale(100).get(new float[16]));
|
|
||||||
// glUniformMatrix4fv(shader.shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16]));
|
|
||||||
// glUniform3fv(shader.shaderVertexViewPosLoc, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
|
|
||||||
// }
|
|
||||||
|
|
||||||
// GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
|
|
||||||
// glBindVertexArray(0);
|
|
||||||
|
|
||||||
// if(renderPipelineState.getUseMeshShader()){
|
|
||||||
// GL11.glDepthFunc(GL_LESS);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// };
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// //
|
|
||||||
// // VAO
|
|
||||||
// //
|
|
||||||
// skyboxmesh.generateVAO();
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// float[] vertexcoords = {
|
|
||||||
// 100.0f, 100.0f, 100.0f,
|
|
||||||
// 100.0f, 100.0f,-100.0f,
|
|
||||||
// 100.0f,-100.0f, 100.0f,
|
|
||||||
// 100.0f,-100.0f,-100.0f,
|
|
||||||
// -100.0f, 100.0f, 100.0f,
|
|
||||||
// -100.0f, 100.0f,-100.0f,
|
|
||||||
// -100.0f,-100.0f, 100.0f,
|
|
||||||
// -100.0f,-100.0f,-100.0f,
|
|
||||||
|
|
||||||
// };
|
|
||||||
|
|
||||||
// //
|
|
||||||
// //Buffer data to GPU
|
|
||||||
// //
|
|
||||||
|
|
||||||
// try {
|
|
||||||
// skyboxmesh.vertexCount = vertexcoords.length / 3;
|
|
||||||
// FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount * 3);
|
|
||||||
// float[] temp = new float[3];
|
|
||||||
// for (int i = 0; i < skyboxmesh.vertexCount; i++) {
|
|
||||||
// temp[0] = vertexcoords[i * 3 + 0];
|
|
||||||
// temp[1] = vertexcoords[i * 3 + 1];
|
|
||||||
// temp[2] = vertexcoords[i * 3 + 2];
|
|
||||||
// VertexArrayBufferData.put(temp);
|
|
||||||
// }
|
|
||||||
// VertexArrayBufferData.flip();
|
|
||||||
// skyboxmesh.buffer_vertices(VertexArrayBufferData, 3);
|
|
||||||
// } catch (NullPointerException ex){
|
|
||||||
// ex.printStackTrace();
|
|
||||||
// }
|
|
||||||
|
|
||||||
// int[] facedata = {
|
|
||||||
// 0,1,4,
|
|
||||||
// 1,4,5,
|
|
||||||
// 1,3,5,
|
|
||||||
// 3,5,7,
|
|
||||||
// 4,5,7,
|
|
||||||
// 4,6,7,
|
|
||||||
|
|
||||||
// 0,2,4,
|
|
||||||
// 2,4,6,
|
|
||||||
// 0,1,2,
|
|
||||||
// 1,2,3,
|
|
||||||
|
|
||||||
// 2,3,6,
|
|
||||||
// 3,6,7,
|
|
||||||
|
|
||||||
// };
|
|
||||||
|
|
||||||
// //
|
|
||||||
// // FACES
|
|
||||||
// //
|
|
||||||
// skyboxmesh.faceCount = facedata.length / 3;
|
|
||||||
// skyboxmesh.elementCount = facedata.length;
|
|
||||||
// IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(skyboxmesh.elementCount);
|
|
||||||
// for(int i = 0; i < skyboxmesh.faceCount; i++){
|
|
||||||
// int[] temp = new int[3];
|
|
||||||
// temp[0] = facedata[i * 3 + 0];
|
|
||||||
// temp[1] = facedata[i * 3 + 1];
|
|
||||||
// temp[2] = facedata[i * 3 + 2];
|
|
||||||
// elementArrayBufferData.put(temp);
|
|
||||||
// }
|
|
||||||
// elementArrayBufferData.flip();
|
|
||||||
// skyboxmesh.buffer_faces(elementArrayBufferData);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// if(optionalMaterial != null){
|
|
||||||
// //
|
|
||||||
// // NORMALS
|
|
||||||
// //
|
|
||||||
// try {
|
|
||||||
// skyboxmesh.normalCount = vertexcoords.length / 3;
|
|
||||||
// FloatBuffer NormalArrayBufferData;
|
|
||||||
// if(skyboxmesh.normalCount > 0){
|
|
||||||
// NormalArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.normalCount * 3);
|
|
||||||
// float[] temp = new float[3];
|
|
||||||
// for (int i = 0; i < skyboxmesh.normalCount; i++) {
|
|
||||||
// temp[0] = vertexcoords[i * 3 + 0];
|
|
||||||
// temp[1] = vertexcoords[i * 3 + 1];
|
|
||||||
// temp[2] = vertexcoords[i * 3 + 2];
|
|
||||||
// NormalArrayBufferData.put(temp);
|
|
||||||
// }
|
|
||||||
// NormalArrayBufferData.flip();
|
|
||||||
// skyboxmesh.buffer_normals(NormalArrayBufferData, 3);
|
|
||||||
// }
|
|
||||||
// } catch (NullPointerException ex){
|
|
||||||
// ex.printStackTrace();
|
|
||||||
// }
|
|
||||||
// //
|
|
||||||
// // TEXTURE COORDINATES
|
|
||||||
// //
|
|
||||||
// /*try {
|
|
||||||
// skyboxmesh.textureCoordCount = mesh.mTextureCoords(0).capacity();
|
|
||||||
// FloatBuffer TextureArrayBufferData;
|
|
||||||
// if(skyboxmesh.textureCoordCount > 0){
|
|
||||||
// TextureArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.textureCoordCount * 2);
|
|
||||||
// float[] temp = new float[2];
|
|
||||||
// for (int i = 0; i < skyboxmesh.textureCoordCount; i++) {
|
|
||||||
// AIVector3D normal = texturecoords.get(i);
|
|
||||||
// temp[0] = normal.x();
|
|
||||||
// temp[1] = normal.y();
|
|
||||||
// // temp[2] = normal.z();
|
|
||||||
// TextureArrayBufferData.put(temp);
|
|
||||||
// }
|
|
||||||
// TextureArrayBufferData.flip();
|
|
||||||
// skyboxmesh.buffer_texture_coords(TextureArrayBufferData);
|
|
||||||
// }
|
|
||||||
// } catch (NullPointerException ex){
|
|
||||||
// ex.printStackTrace();
|
|
||||||
// }
|
|
||||||
|
|
||||||
// skyboxmesh.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting);
|
|
||||||
|
|
||||||
// skybox_model.materials.add(optionalMaterial);
|
|
||||||
// */
|
|
||||||
// } else {
|
|
||||||
// skyboxmesh.shader = ShaderProgram.loadSpecificShader("/Shaders/skybox/VertexShaderNoTexture.vs", "/Shaders/skybox/FragmentShaderNoTexture.fs");
|
|
||||||
// try {
|
|
||||||
// FloatBuffer ColorArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount);
|
|
||||||
// for (int i = 0; i < skyboxmesh.vertexCount; i++) {
|
|
||||||
// ColorArrayBufferData.put(i);
|
|
||||||
// }
|
|
||||||
// ColorArrayBufferData.flip();
|
|
||||||
// int idBuffer = glGenBuffers();
|
|
||||||
// glBindBuffer(GL_ARRAY_BUFFER, idBuffer);
|
|
||||||
// GL15.glBufferData(GL_ARRAY_BUFFER, ColorArrayBufferData, GL_STATIC_DRAW);
|
|
||||||
// glVertexAttribPointer(1, 1, GL11.GL_FLOAT, false, 0, 0);
|
|
||||||
// glEnableVertexAttribArray(1);
|
|
||||||
// } catch (NullPointerException ex){
|
|
||||||
// ex.printStackTrace();
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// skyboxmesh.setHasBones(false);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// glBindVertexArray(0);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// skyboxmesh.setParent(skyboxModel);
|
|
||||||
|
|
||||||
|
|
||||||
// skyboxModel.meshes.add(skyboxmesh);
|
|
||||||
|
|
||||||
|
|
||||||
// return skyboxModel;
|
|
||||||
// }
|
|
||||||
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue
Block a user