public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
var v = serializer.Deserialize <BlockStateModel[]>(reader);
return(v);
}
else
{
var v = new BlockStateModel[] { serializer.Deserialize <BlockStateModel>(reader) };
return(v);
}
}
protected void GetVertices(IBlockAccess world, ChunkData chunkBuilder, BlockCoordinates blockCoordinates,
Vector3 position, Block baseBlock,
BlockStateModel[] models)
{
{
var biome = world == null?BiomeUtils.GetBiomeById(0) : world.GetBiome(position);
if (UseRandomizer)
{
BlockStateModel selectedModel = null;
var rnd = MathF.Abs(NoiseGenerator.GetValue(position.X * position.Y, position.Z * position.X)) * WeightSum;
for (var index = 0; index < models.Length; index++)
{
var model = models[index];
rnd -= model.Weight;
if (rnd < 0)
{
selectedModel = model;
break;
}
}
CalculateModel(
world, blockCoordinates, chunkBuilder, position, baseBlock, selectedModel, biome);
}
else
{
for (var bsModelIndex = 0; bsModelIndex < models.Length; bsModelIndex++)
{
var bsModel = models[bsModelIndex];
if (bsModel.Model == null)
{
continue;
}
CalculateModel(
world, blockCoordinates, chunkBuilder, position, baseBlock, bsModel,
biome);
}
}
}
}
protected string ResolveTexture(BlockStateModel var, string texture)
{
string textureName = "no_texture";
if (!var.Model.Textures.TryGetValue(texture.Replace("#", ""), out textureName))
{
textureName = texture;
}
if (textureName.StartsWith("#"))
{
if (!var.Model.Textures.TryGetValue(textureName.Replace("#", ""), out textureName))
{
textureName = "no_texture";
}
}
return(textureName);
}
/*private BlockCoordinates[] GetCornerOffsetsForFace(BlockFace face)
* {
* //0 = TopLeft, 1 = TopRight
* //2 = BottomLeft, 3 = BottomRight
* BlockCoordinates[] corners = new BlockCoordinates[4];
*
* switch (face)
* {
* case BlockFace.Down:
* case BlockFace.Up:
* corners[0] = new BlockCoordinates(-1, 0, 1);
* corners[1] = new BlockCoordinates(1, 0, 1);
* break;
* }
* }
*/
private void CalculateModel(IBlockAccess world,
Vector3 position,
Block baseBlock,
BlockStateModel bsModel,
IList <BlockShaderVertex> verts,
List <int> indexResult,
List <int> animatedIndexResult,
int biomeId,
Biome biome)
{
var model = bsModel.Model;
var baseColor = baseBlock.BlockMaterial.TintColor;
/*if (biomeId != -1)
* {
* var mapColor = baseBlock.BlockMaterial.GetMaterialMapColor();
* if (mapColor == MapColor.GRASS)
* {
* baseColor = Resources.ResourcePack.GetGrassColor(
* biome.Temperature, biome.Downfall, (int) position.Y);
* }
* else if (mapColor == MapColor.FOLIAGE)
* {
* baseColor = Resources.ResourcePack.GetFoliageColor(
* biome.Temperature, biome.Downfall, (int) position.Y);
* }
* }*/
for (var index = 0; index < model.Elements.Length; index++)
{
var element = model.Elements[index];
element.To *= Scale;
element.From *= Scale;
foreach (var face in element.Faces)
{
var facing = face.Key;
//var originalFacing = facing;
var cullFace = face.Value.CullFace;
if (cullFace == null)
{
cullFace = facing;
}
//var originalCullFace = cullFace;
if (bsModel.X > 0f)
{
var offset = -bsModel.X / 90;
cullFace = RotateDirection(cullFace.Value, offset, FACE_ROTATION_X, INVALID_FACE_ROTATION_X);
facing = RotateDirection(facing, offset, FACE_ROTATION_X, INVALID_FACE_ROTATION_X);
}
if (bsModel.Y > 0f)
{
var offset = -bsModel.Y / 90;
cullFace = RotateDirection(cullFace.Value, offset, FACE_ROTATION, INVALID_FACE_ROTATION);
facing = RotateDirection(facing, offset, FACE_ROTATION, INVALID_FACE_ROTATION);
}
if (!ShouldRenderFace(world, cullFace.Value, position, baseBlock))
{
continue;
}
var textureRotation = face.Value.Rotation;
string texture = face.Value.Texture;
if (bsModel.Uvlock)
{
if (element.Faces.TryGetValue(facing, out var newRotation) && newRotation.Texture != texture)
{
texture = newRotation.Texture;
}
else
{
if (bsModel.X > 0)
{
//textureRotation = bsModel.X;
}
if ((face.Key == BlockFace.Up || face.Key == BlockFace.Down) && bsModel.Y > 0)
{
//textureRotation = bsModel.Y;
}
}
}
var uv = face.Value.UV;
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
if (uv == null)
{
switch (face.Key)
{
case BlockFace.North:
case BlockFace.South:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.West:
case BlockFace.East:
x1 = element.From.Z;
x2 = element.To.Z;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.Down:
case BlockFace.Up:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Z;
y2 = 16f - element.From.Z;
break;
}
}
else
{
x1 = uv.X1;
x2 = uv.X2;
y1 = uv.Y1;
y2 = uv.Y2;
}
var faceColor = baseColor;
if (face.Value.TintIndex.HasValue && face.Value.TintIndex == 0)
{
switch (baseBlock.BlockMaterial.TintType)
{
case TintType.Default:
faceColor = Color.White;
break;
case TintType.Color:
faceColor = baseBlock.BlockMaterial.TintColor;
break;
case TintType.Grass:
faceColor = Resources.ResourcePack.GetGrassColor(
biome.Temperature, biome.Downfall, (int)position.Y);
break;
case TintType.Foliage:
faceColor = Resources.ResourcePack.GetFoliageColor(
biome.Temperature, biome.Downfall, (int)position.Y);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var facePosition = position + cullFace.Value.GetVector3();
var uvMap = GetTextureUVMap(
Resources, texture, x1, x2, y1, y2, textureRotation,
AdjustColor(faceColor, facing, element.Shade));
var vertices = GetFaceVertices(face.Key, element.From, element.To,
uvMap,
out int[] indexes);
float minX = float.MaxValue, minY = float.MaxValue, minZ = float.MaxValue;
float maxX = float.MinValue, maxY = float.MinValue, maxZ = float.MinValue;
for (int i = 0; i < vertices.Length; i++)
{
var v = vertices[i];
//v.Position += (v.Normal * scale);
v.Position = FixRotation(v.Position, element, bsModel.X, bsModel.Y);
v.Position /= 16f;
if (v.Position.X < minX)
{
minX = v.Position.X;
}
else if (v.Position.X > maxX)
{
maxX = v.Position.X;
}
if (v.Position.Y < minY)
{
minY = v.Position.Y;
}
else if (v.Position.Y > maxY)
{
maxY = v.Position.Y;
}
if (v.Position.Z < minZ)
{
minZ = v.Position.Z;
}
else if (v.Position.Z > maxZ)
{
maxZ = v.Position.Z;
}
vertices[i] = v;
}
FixElementScale(
element, vertices, minX, maxX, minY, maxY, minZ, maxZ, ref minX, ref maxX, ref minY, ref maxY, ref minZ,
ref maxZ);
var initialIndex = verts.Count;
byte vertexBlockLight = 0, vertexSkyLight = 0;
if (!SmoothLighting)
{
GetLight(
world, facePosition, out vertexBlockLight, out vertexSkyLight,
baseBlock.Transparent || !baseBlock.Solid);
}
Vector3 lightOffset = cullFace.Value.GetVector3();
for (var idx = 0; idx < vertices.Length; idx++)
{
var vertex = vertices[idx];
vertex.Position = position + vertex.Position;
if (SmoothLighting)
{
GetLight(world, vertex.Position + lightOffset, out vertexBlockLight, out vertexSkyLight, true);
}
//if (blockLight > 0)
{
vertex.BlockLight = vertexBlockLight;
vertex.SkyLight = vertexSkyLight;
}
verts.Add(vertex);
}
for (var idx = 0; idx < indexes.Length; idx++)
{
var idxx = indexes[idx];
if (uvMap.IsAnimated)
{
animatedIndexResult.Add(initialIndex + idxx);
}
else
{
indexResult.Add(initialIndex + idxx);
}
}
}
}
}
private void ProcessModel(BlockStateModel stateModel, ResourcePackLib.Json.Models.ResourcePackModelBase model, out Vector3 min, out Vector3 max)
{
float facesMinX = float.MaxValue, facesMinY = float.MaxValue, facesMinZ = float.MaxValue;
float facesMaxX = float.MinValue, facesMaxY = float.MinValue, facesMaxZ = float.MinValue;
List <BoundingBox> boxes = new List <BoundingBox>();
for (var index = 0; index < model.Elements.Length; index++)
{
var element = model.Elements[index];
element.To *= (Scale);
element.From *= (Scale);
foreach (var face in element.Faces)
{
var verts = GetFaceVertices(face.Key, element.From, element.To, new UVMap(), out _);
float minX = float.MaxValue, minY = float.MaxValue, minZ = float.MaxValue;
float maxX = float.MinValue, maxY = float.MinValue, maxZ = float.MinValue;
for (int i = 0; i < verts.Length; i++)
{
var v = verts[i];
//v.Position += (v.Normal * scale);
v.Position = FixRotation(v.Position, element, stateModel.X, stateModel.Y);
v.Position /= 16f;
if (v.Position.X < minX)
{
minX = v.Position.X;
}
else if (v.Position.X > maxX)
{
maxX = v.Position.X;
}
if (v.Position.Y < minY)
{
minY = v.Position.Y;
}
else if (v.Position.Y > maxY)
{
maxY = v.Position.Y;
}
if (v.Position.Z < minZ)
{
minZ = v.Position.Z;
}
else if (v.Position.Z > maxZ)
{
maxZ = v.Position.Z;
}
verts[i] = v;
}
FixElementScale(
element, verts, minX, maxX, minY, maxY, minZ, maxZ, ref facesMinX, ref facesMaxX, ref facesMinY,
ref facesMaxY, ref facesMinZ, ref facesMaxZ);
if (minX < facesMinX)
{
facesMinX = minX;
}
else if (maxX > facesMaxX)
{
facesMaxX = maxX;
}
if (minY < facesMinY)
{
facesMinY = minY;
}
else if (maxY > facesMaxY)
{
facesMaxY = maxY;
}
if (minZ < facesMinZ)
{
facesMinZ = minZ;
}
else if (maxZ > facesMaxZ)
{
facesMaxZ = maxZ;
}
}
var from = FixRotation(element.From, element, stateModel.X, stateModel.Y);
var to = FixRotation(element.To, element, stateModel.X, stateModel.Y);
boxes.Add(new BoundingBox(Vector3.Min(from, to) / 16f, Vector3.Max(from, to) / 16f));
}
min = new Vector3(facesMinX, facesMinY, facesMinZ);
max = new Vector3(facesMaxX, facesMaxY, facesMaxZ);
Boxes = Boxes.Concat(boxes.ToArray()).ToArray();
}
public async Task BlockStateSave(BlockStateModel model)
{
await base.SaveEntity <BlockStateEntity, BlockStateModel>(model);
}
private void ProcessBlockStateModel(McResourcePack resourcePack, Dictionary <ResourceLocation, ImageEntry> textures, BlockStateModel bsModel)
{
var model = bsModel.Model;
foreach (var texture in model.Textures)
{
var text = texture.Value;
if (text[0] == '#')
{
var substr = text.Substring(1);
if (model.Textures.TryGetValue(substr, out var p))
{
text = p;
}
else
{
var parent = model.Parent;
while (parent != null)
{
if (parent.Textures.TryGetValue(substr, out string parentName))
{
text = parentName;
break;
}
parent = parent.Parent;
}
}
}
var key = new ResourceLocation(text);
var alreadyLoaded = textures.ContainsKey(key);
if (!alreadyLoaded && resourcePack.TryGetBitmap(key, out var bmp))
{
TextureMeta meta = null;
resourcePack.TryGetTextureMeta(key, out meta);
textures.TryAdd(key, new ImageEntry(bmp, meta));
}
else if (!alreadyLoaded)
{
if (texture.Value[0] != '#' || text[0] != '#')
{
Log.Warn(
$"Could not get bitmap {texture.Value} or {text} (Key: {texture.Key} Model: {bsModel.ModelName})");
}
}
}
}
private Dictionary <string, FaceCache> ProcessModel(BlockStateModel raw, out Vector3 min, out Vector3 max)
{
float facesMinX = float.MaxValue, facesMinY = float.MaxValue, facesMinZ = float.MaxValue;
float facesMaxX = float.MinValue, facesMaxY = float.MinValue, facesMaxZ = float.MinValue;
Dictionary <string, FaceCache> faceCaches = new Dictionary <string, FaceCache>();
var model = raw.Model;
for (var index = 0; index < model.Elements.Length; index++)
{
var element = model.Elements[index];
element.To *= Scale;
element.From *= Scale;
FaceCache cache = new FaceCache();
foreach (var face in element.Faces)
{
var uv = face.Value.UV;
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
if (uv == null)
{
switch (face.Key)
{
case BlockFace.North:
case BlockFace.South:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.West:
case BlockFace.East:
x1 = element.From.Z;
x2 = element.To.Z;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.Down:
case BlockFace.Up:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Z;
y2 = 16f - element.From.Z;
break;
}
}
else
{
x1 = uv.X1;
x2 = uv.X2;
y1 = uv.Y1;
y2 = uv.Y2;
}
var verts = GetFaceVertices(face.Key, element.From, element.To,
GetTextureUVMap(Resources, ResolveTexture(raw, face.Value.Texture), x1, x2, y1, y2, face.Value.Rotation),
out int[] indexes);
float minX = float.MaxValue, minY = float.MaxValue, minZ = float.MaxValue;
float maxX = float.MinValue, maxY = float.MinValue, maxZ = float.MinValue;
for (int i = 0; i < verts.Length; i++)
{
var v = verts[i];
if (element.Rotation.Axis != Axis.Undefined)
{
var r = element.Rotation;
var angle = (float)(r.Angle * (Math.PI / 180f));
//angle = r.Axis == Axis.Z ? angle : -angle;
//angle = r.Axis == Axis.Y ? -angle : angle;
var origin = r.Origin;
var c = MathF.Cos(angle);
var s = MathF.Sin(angle);
switch (r.Axis)
{
case Axis.Y:
{
var x = v.Position.X - origin.X;
var z = v.Position.Z - origin.Z;
v.Position.X = origin.X + (x * c - z * s);
v.Position.Z = origin.Z + (z * c + x * s);
}
break;
case Axis.X:
{
var x = v.Position.Z - origin.Z;
var z = v.Position.Y - origin.Y;
v.Position.Z = origin.Z + (x * c - z * s);
v.Position.Y = origin.Y + (z * c + x * s);
}
break;
case Axis.Z:
{
var x = v.Position.X - origin.X;
var z = v.Position.Y - origin.Y;
v.Position.X = origin.X + (x * c - z * s);
v.Position.Y = origin.Y + (z * c + x * s);
}
break;
}
}
if (raw.X > 0)
{
var rotX = (float)(raw.X * (Math.PI / 180f));
var c = MathF.Cos(rotX);
var s = MathF.Sin(rotX);
var z = v.Position.Z - 8f;
var y = v.Position.Y - 8f;
v.Position.Z = 8f + (z * c - y * s);
v.Position.Y = 8f + (y * c + z * s);
}
if (raw.Y > 0)
{
var rotX = (float)(raw.Y * (Math.PI / 180f));
var c = MathF.Cos(rotX);
var s = MathF.Sin(rotX);
var z = v.Position.X - 8f;
var y = v.Position.Z - 8f;
v.Position.X = 8f + (z * c - y * s);
v.Position.Z = 8f + (y * c + z * s);
}
v.Position /= 16f;
if (v.Position.X < minX)
{
minX = v.Position.X;
}
else if (v.Position.X > maxX)
{
maxX = v.Position.X;
}
if (v.Position.Y < minY)
{
minY = v.Position.Y;
}
else if (v.Position.Y > maxY)
{
maxY = v.Position.Y;
}
if (v.Position.Z < minZ)
{
minZ = v.Position.Z;
}
else if (v.Position.Z > maxZ)
{
maxZ = v.Position.Z;
}
verts[i] = v;
}
if (element.Rotation.Axis != Axis.Undefined && element.Rotation.Rescale)
{
var diffX = maxX - minX;
var diffY = maxY - minY;
var diffZ = maxZ - minZ;
for (var i = 0; i < verts.Length; i++)
{
var v = verts[i];
v.Position.X = (v.Position.X - minX) / diffX;
v.Position.Y = (v.Position.Y - minY) / diffY;
v.Position.Z = (v.Position.Z - minZ) / diffZ;
verts[i] = v;
if (v.Position.X < facesMinX)
{
facesMinX = v.Position.X;
}
else if (v.Position.X > facesMaxX)
{
facesMaxX = v.Position.X;
}
if (v.Position.Y < facesMinY)
{
facesMinY = v.Position.Y;
}
else if (v.Position.Y > facesMaxY)
{
facesMaxY = v.Position.Y;
}
if (v.Position.Z < facesMinZ)
{
facesMinZ = v.Position.Z;
}
else if (v.Position.Z > facesMaxZ)
{
facesMaxZ = v.Position.Z;
}
}
}
if (minX < facesMinX)
{
facesMinX = minX;
}
else if (maxX > facesMaxX)
{
facesMaxX = maxX;
}
if (minY < facesMinY)
{
facesMinY = minY;
}
else if (maxY > facesMaxY)
{
facesMaxY = maxY;
}
if (minZ < facesMinZ)
{
facesMinZ = minZ;
}
else if (maxZ > facesMaxZ)
{
facesMaxZ = maxZ;
}
cache.Set(face.Key, new FaceData(verts, indexes, face.Value.Rotation, null));
}
faceCaches.Add(index.ToString(), cache);
}
min = new Vector3(facesMinX, facesMinY, facesMinZ);
max = new Vector3(facesMaxX, facesMaxY, facesMaxZ);
return(faceCaches);
}
private void CalculateModel(IBlockAccess world,
BlockCoordinates blockCoordinates,
ChunkData chunkBuilder,
Vector3 position,
Block baseBlock,
BlockStateModel blockStateModel,
ResourcePackModelBase model,
Biome biome)
{
//bsModel.Y = Math.Abs(180 - bsModel.Y);
//if (Resources.BlockModelRegistry.TryGet(blockStateModel.ModelName, out var registryEntry))
{
//var model = registryEntry.Value;
var baseColor = baseBlock.BlockMaterial.TintColor;
for (var index = 0; index < model.Elements.Length; index++)
{
var element = model.Elements[index];
element.To *= Scale;
element.From *= Scale;
foreach (var face in element.Faces)
{
var facing = face.Key;
var cullFace = face.Value.CullFace ?? face.Key;
if (blockStateModel.X > 0f)
{
var offset = blockStateModel.X / 90;
cullFace = RotateDirection(cullFace, offset, FACE_ROTATION_X, INVALID_FACE_ROTATION_X);
facing = RotateDirection(facing, offset, FACE_ROTATION_X, INVALID_FACE_ROTATION_X);
}
if (blockStateModel.Y > 0f)
{
var offset = blockStateModel.Y / 90;
cullFace = RotateDirection(cullFace, offset, FACE_ROTATION, INVALID_FACE_ROTATION);
facing = RotateDirection(facing, offset, FACE_ROTATION, INVALID_FACE_ROTATION);
}
if (!ShouldRenderFace(world, facing, position, baseBlock))
{
continue;
}
var positionOffset = baseBlock.GetOffset(NoiseGenerator, position);
var uv = face.Value.UV;
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
if (uv == null)
{
switch (face.Key)
{
case BlockFace.North:
case BlockFace.South:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.West:
case BlockFace.East:
x1 = element.From.Z;
x2 = element.To.Z;
y1 = 16f - element.To.Y;
y2 = 16f - element.From.Y;
break;
case BlockFace.Down:
case BlockFace.Up:
x1 = element.From.X;
x2 = element.To.X;
y1 = 16f - element.To.Z;
y2 = 16f - element.From.Z;
break;
}
}
else
{
x1 = uv.X1;
x2 = uv.X2;
y1 = uv.Y1;
y2 = uv.Y2;
}
var faceColor = baseColor;
bool hasTint = (face.Value.TintIndex.HasValue && face.Value.TintIndex == 0);
if (hasTint)
{
switch (baseBlock.BlockMaterial.TintType)
{
case TintType.Default:
faceColor = Color.White;
break;
case TintType.Color:
faceColor = baseBlock.BlockMaterial.TintColor;
break;
case TintType.Grass:
if (SmoothLighting)
{
var bx = (int)position.X;
var y = (int)position.Y;
var bz = (int)position.Z;
faceColor = CombineColors(
GetGrassBiomeColor(world, bx, y, bz),
GetGrassBiomeColor(world, bx - 1, y, bz),
GetGrassBiomeColor(world, bx, y, bz - 1),
GetGrassBiomeColor(world, bx + 1, y, bz),
GetGrassBiomeColor(world, bx, y, bz + 1),
GetGrassBiomeColor(world, bx + 1, y, bz - 1));
}
else
{
faceColor = Resources.ResourcePack.GetGrassColor(
biome.Temperature, biome.Downfall, (int)position.Y);
}
break;
case TintType.Foliage:
if (face.Value.TintIndex.HasValue && face.Value.TintIndex == 0)
{
faceColor = Resources.ResourcePack.GetFoliageColor(
biome.Temperature, biome.Downfall, (int)position.Y);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
faceColor = AdjustColor(faceColor, facing, element.Shade);
var uvMap = GetTextureUVMap(
Resources, ResolveTexture(model, face.Value.Texture), x1, x2, y1, y2, face.Value.Rotation, faceColor);
var vertices = GetFaceVertices(face.Key, element.From, element.To, uvMap);
vertices = ProcessVertices(vertices, blockStateModel, element, uvMap, facing, face.Value);
RenderStage targetState = RenderStage.OpaqueFullCube;
if (baseBlock.BlockMaterial.IsLiquid)
{
targetState = RenderStage.Liquid;
}
else if (uvMap.IsAnimated)
{
targetState = RenderStage.Animated;
}
else if (baseBlock.Transparent)
{
if (baseBlock.BlockMaterial.IsOpaque)
{
if (!Block.FancyGraphics && baseBlock.IsFullCube)
{
targetState = RenderStage.OpaqueFullCube;
}
else
{
targetState = RenderStage.Transparent;
}
}
else
{
targetState = RenderStage.Translucent;
}
}
else if (!baseBlock.IsFullCube)
{
targetState = RenderStage.Opaque;
}
for (int i = 0; i < vertices.Length; i++)
{
var vertex = vertices[i];
BlockModel.GetLight(
world, vertex.Position + position + vertex.Face.GetVector3(), out var blockLight,
out var skyLight, true);
chunkBuilder.AddVertex(
blockCoordinates, vertex.Position + position + positionOffset, vertex.TexCoords,
vertex.Color, blockLight, skyLight, targetState);
}
}
}
}
}
private BlockShaderVertex[] ProcessVertices(BlockShaderVertex[] vertices,
BlockStateModel bsModel,
ModelElement element,
BlockTextureData?uvMap,
BlockFace blockFace,
ModelElementFace face)
{
for (int i = 0; i < vertices.Length; i++)
{
var v = vertices[i];
v.Position /= 16f;
v.Position = FixRotation(v.Position, element);
if (bsModel.X > 0)
{
var rotX = bsModel.X * (MathHelper.Pi / 180f);
var c = MathF.Cos(rotX);
var s = MathF.Sin(rotX);
var z = v.Position.Z - 0.5f;
var y = v.Position.Y - 0.5f;
v.Position.Z = 0.5f + (z * c - y * s);
v.Position.Y = 0.5f + (y * c + z * s);
}
if (bsModel.Y > 0)
{
var rotY = bsModel.Y * (MathHelper.Pi / 180f);
var c = MathF.Cos(rotY);
var s = MathF.Sin(rotY);
var x = v.Position.X - 0.5f;
var z = v.Position.Z - 0.5f;
v.Position.X = 0.5f + (x * c - z * s);
v.Position.Z = 0.5f + (z * c + x * s);
}
if (uvMap.HasValue)
{
var tw = uvMap.Value.TextureInfo.Width;
var th = uvMap.Value.TextureInfo.Height;
var rot = face.Rotation;
if (rot > 0)
{
var rotY = rot * (MathHelper.Pi / 180f);
var c = MathF.Cos(rotY);
var s = MathF.Sin(rotY);
var x = v.TexCoords.X - 8f * tw;
var y = v.TexCoords.Y - 8f * th;
v.TexCoords.X = 8f * tw + (x * c - y * s);
v.TexCoords.Y = 8f * th + (y * c + x * s);
}
if (bsModel.Uvlock)
{
if (bsModel.Y > 0 && (blockFace == BlockFace.Up || blockFace == BlockFace.Down))
{
var rotY = bsModel.Y * (MathHelper.Pi / 180f);
var c = MathF.Cos(rotY);
var s = MathF.Sin(rotY);
var x = v.TexCoords.X - 8f * tw;
var y = v.TexCoords.Y - 8f * th;
v.TexCoords.X = 8f * tw + (x * c - y * s);
v.TexCoords.Y = 8f * th + (y * c + x * s);
}
if (bsModel.X > 0 && (blockFace != BlockFace.Up && blockFace != BlockFace.Down))
{
var rotX = bsModel.X * (MathHelper.Pi / 180f);
var c = MathF.Cos(rotX);
var s = MathF.Sin(rotX);
var x = v.TexCoords.X - 8f * tw;
var y = v.TexCoords.Y - 8f * th;
v.TexCoords.X = 8f * tw + (x * c - y * s);
v.TexCoords.Y = 8f * th + (y * c + x * s);
}
}
v.TexCoords += uvMap.Value.TextureInfo.Position;
v.TexCoords *= (Vector2.One / uvMap.Value.TextureInfo.AtlasSize);
}
v.Face = blockFace;
vertices[i] = v;
}
return(vertices);
}
public BlockStateModelWrapper(BlockStateModel model, ResourcePackModelBase blockModel)
{
BlockStateModel = model;
BlockModel = blockModel;
}
private BoundingBox[] GenerateBoundingBoxes(BlockStateModel stateModel, ResourcePackLib.Json.Models.ResourcePackModelBase model, out Vector3 min, out Vector3 max)
{
float facesMinX = float.MaxValue, facesMinY = float.MaxValue, facesMinZ = float.MaxValue;
float facesMaxX = float.MinValue, facesMaxY = float.MinValue, facesMaxZ = float.MinValue;
List <BoundingBox> boxes = new List <BoundingBox>();
for (var index = 0; index < model.Elements.Length; index++)
{
var eMinX = float.MaxValue;
var eMinY = float.MaxValue;
var eMinZ = float.MaxValue;
var eMaxX = float.MinValue;
var eMaxY = float.MinValue;
var eMaxZ = float.MinValue;
var element = model.Elements[index];
element.To *= Scale;
element.From *= Scale;
foreach (var face in element.Faces)
{
var facing = face.Key;
if (stateModel.X > 0f)
{
var offset = stateModel.X / 90;
facing = RotateDirection(facing, offset, FACE_ROTATION_X, INVALID_FACE_ROTATION_X);
}
if (stateModel.Y > 0f)
{
var offset = stateModel.Y / 90;
facing = RotateDirection(facing, offset, FACE_ROTATION, INVALID_FACE_ROTATION);
}
var verts = GetFaceVertices(face.Key, element.From, element.To, new BlockTextureData());
verts = ProcessVertices(verts, stateModel, element, null, facing, face.Value);
float minX = float.MaxValue, minY = float.MaxValue, minZ = float.MaxValue;
float maxX = float.MinValue, maxY = float.MinValue, maxZ = float.MinValue;
for (int i = 0; i < verts.Length; i++)
{
var v = verts[i];
if (v.Position.X < minX)
{
minX = v.Position.X;
}
else if (v.Position.X > maxX)
{
maxX = v.Position.X;
}
if (v.Position.Y < minY)
{
minY = v.Position.Y;
}
else if (v.Position.Y > maxY)
{
maxY = v.Position.Y;
}
if (v.Position.Z < minZ)
{
minZ = v.Position.Z;
}
else if (v.Position.Z > maxZ)
{
maxZ = v.Position.Z;
}
//
if (v.Position.X < eMinX)
{
eMinX = v.Position.X;
}
else if (v.Position.X > eMaxX)
{
eMaxX = v.Position.X;
}
if (v.Position.Y < eMinY)
{
eMinY = v.Position.Y;
}
else if (v.Position.Y > eMaxY)
{
eMaxY = v.Position.Y;
}
if (v.Position.Z < eMinZ)
{
eMinZ = v.Position.Z;
}
else if (v.Position.Z > eMaxZ)
{
eMaxZ = v.Position.Z;
}
verts[i] = v;
}
if (minX < facesMinX)
{
facesMinX = minX;
}
else if (maxX > facesMaxX)
{
facesMaxX = maxX;
}
if (minY < facesMinY)
{
facesMinY = minY;
}
else if (maxY > facesMaxY)
{
facesMaxY = maxY;
}
if (minZ < facesMinZ)
{
facesMinZ = minZ;
}
else if (maxZ > facesMaxZ)
{
facesMaxZ = maxZ;
}
}
boxes.Add(new BoundingBox(new Vector3(eMinX, eMinY, eMinZ), new Vector3(eMaxX, eMaxY, eMaxZ)));
}
min = new Vector3(facesMinX, facesMinY, facesMinZ);
max = new Vector3(facesMaxX, facesMaxY, facesMaxZ);
return(boxes.ToArray());
}
public async Task BlockStateSave(BlockStateModel model)
{
await this.sharedRepository.BlockStateSave(model);
}
public override void GetVertices(IBlockAccess world,
ChunkData chunkBuilder,
BlockCoordinates blockCoordinates,
Vector3 position,
BlockState baseBlock)
{
var biome = world == null?BiomeUtils.GetBiomeById(0) : world.GetBiome(position);
if (baseBlock.ModelData == null)
{
return;
}
if (baseBlock.VariantMapper.IsMultiPart)
{
foreach (var model in baseBlock.ModelData)
{
if (Resources.BlockModelRegistry.TryGet(model.ModelName, out var registryEntry))
{
CalculateModel(
world, blockCoordinates, chunkBuilder, position, baseBlock.Block, model,
registryEntry.Value, biome);
}
}
return;
}
// if (UseRandomizer)
{
BlockStateModel selectedModel = null;
if (baseBlock.ModelData.Count > 1)
{
var weightSum = baseBlock.ModelData.Sum(x => x.Weight);
var rnd = ((baseBlock.ModelData.Count == 1) ? 1f : MathF.Abs(
NoiseGenerator.GetValue(position.X * position.Y, position.Z * position.X))) * weightSum;
//for (var index = 0; index < Models.Length; index++)
foreach (var model in baseBlock.ModelData)
{
// var model = Models[index];
rnd -= model.Weight;
if (rnd < 0)
{
selectedModel = model;
break;
}
}
}
else
{
selectedModel = baseBlock.ModelData.FirstOrDefault();
}
if (selectedModel == null)
{
return;
}
if (Resources.BlockModelRegistry.TryGet(selectedModel.ModelName, out var registryEntry))
{
CalculateModel(
world, blockCoordinates, chunkBuilder, position, baseBlock.Block, selectedModel,
registryEntry.Value, biome);
}
// CalculateModel(world, blockCoordinates, chunkBuilder, position, baseBlock, selectedModel.BlockStateModel, selectedModel.BlockModel, biome);
}
//else
//{
//for (var bsModelIndex = 0; bsModelIndex < Models.Length; bsModelIndex++)
//{
//var bsModel = Models[bsModelIndex];
// if (string.IsNullOrWhiteSpace(bsModel.ModelName)) continue;
//}
//}
}
private IEnumerable <BlockStateModelWrapper> GetAppliedModels(BlockState baseBlock)
{
if (baseBlock.ModelData == null)
{
yield break;
}
if (baseBlock.VariantMapper.IsMultiPart)
{
foreach (var model in baseBlock.ModelData)
{
if (Resources.BlockModelRegistry.TryGet(model.ModelName, out var registryEntry))
{
yield return(new BlockStateModelWrapper(model, registryEntry.Value));
}
}
yield break;
}
// if (UseRandomizer)
{
BlockStateModel selectedModel = null;
if (baseBlock.ModelData.Count > 1)
{
var weightSum = baseBlock.ModelData.Sum(x => x.Weight);
var rnd = weightSum;
//for (var index = 0; index < Models.Length; index++)
foreach (var model in baseBlock.ModelData)
{
// var model = Models[index];
rnd -= model.Weight;
if (rnd < 0)
{
selectedModel = model;
break;
}
}
}
else
{
selectedModel = baseBlock.ModelData.FirstOrDefault();
}
if (selectedModel == null)
{
yield break;
}
if (Resources.BlockModelRegistry.TryGet(selectedModel.ModelName, out var registryEntry))
{
yield return(new BlockStateModelWrapper(selectedModel, registryEntry.Value));
}
// CalculateModel(world, blockCoordinates, chunkBuilder, position, baseBlock, selectedModel.BlockStateModel, selectedModel.BlockModel, biome);
}
}
