public ItemModelRenderer(ResourcePackModelBase model, McResourcePack resourcePack) : base(model, resourcePack,
VertexPositionColor.VertexDeclaration)
{
if (model.ParentName != "item/handheld")
{
Offset = new Vector3(0f, -0.5f, 0f);
}
}
public ItemBlockModelRenderer(BlockState block, ResourcePackModelBase model, McResourcePack resourcePack,
ResourceManager resourceManager) : base(model, resourcePack,
VertexPositionNormalTextureColor.VertexDeclaration)
{
_block = block;
_resource = resourceManager;
Offset = new Vector3(0f, -0.5f, 0f);
// Translation = -Vector3.Forward * 8f;
}
public ItemBlockModelRenderer(BlockState block, ResourcePackModelBase model, Texture2D texture) : base(model,
VertexPositionColorTexture.VertexDeclaration)
{
_blockState = block;
_texture = texture;
Scale = new Vector3(8f, 8f, 8f);
// Size = new Vector3(16f, 16f, 16f);
//Offset = new Vector3(0f, -0.5f, 0f);
// Translation = -Vector3.Forward * 8f;
}
public ItemBlockModelRenderer(BlockState block, ResourcePackModelBase model,
ResourceManager resourceManager) : base(model,
VertexPositionColorTexture.VertexDeclaration)
{
_block = block;
_resource = resourceManager;
_animated = _block.Block.Animated;
Offset = new Vector3(0f, -0.5f, 0f);
// Translation = -Vector3.Forward * 8f;
}
public bool TryGetBlockModel(ResourceLocation key, out ResourcePackModelBase model)
{
model = null;
foreach (var resourcePack in ActiveResourcePacks.Reverse())
{
if (resourcePack.BlockModels.TryGetValue(key, out model))
{
return(true);
}
}
return(false);
}
private ResourcePackModelBase ProcessModel(ResourcePackModelBase model, ref Dictionary <string, ResourcePackModelBase> models)
{
string key = $"{model.Namespace}:{model.Name}";
if (!string.IsNullOrWhiteSpace(model.ParentName) && !model.ParentName.Equals(model.Name, StringComparison.InvariantCultureIgnoreCase))
{
string parentKey = model.ParentName;
if (!parentKey.Contains(":"))
{
parentKey = $"{model.Namespace}:{model.ParentName}";
}
ResourcePackModelBase parent;
if (!_models.TryGetValue(parentKey, out parent))
{
if (models.TryGetValue(parentKey, out parent))
{
parent = ProcessModel(parent, ref models);
}
}
if (parent != null)
{
model.Parent = parent;
/*if (model.Elements.Length == 0 && parent.Elements.Length > 0)
* {
* model.Elements = (BlockModelElement[])parent.Elements.Clone();
* }
*
* foreach (var (k, value) in parent.Textures)
* {
* if (!model.Textures.ContainsKey(k))
* {
* model.Textures.Add(k, value);
* }
* }
*
* foreach (var (name, value) in parent.Display)
* {
* model.Display[name] = value;
* }*/
}
}
_models.Add(key, model);
return(model);
}
public bool TryGetBlockModel(ResourceLocation modelName, out ResourcePackModelBase model)
{
if (BlockModels.TryGetValue(modelName, out model))
{
return(true);
}
var m = BlockModels.FirstOrDefault(x => x.Key.ToString().EndsWith(modelName.Path, StringComparison.InvariantCultureIgnoreCase))
.Value;
if (m != null)
{
model = m;
return(true);
}
model = null;
return(false);
}
public static void Init(IRegistryManager registryManager, ResourceManager resources, McResourcePack resourcePack, IProgressReceiver progressReceiver = null)
{
ResourceManager = resources;
ResourcePack = resourcePack;
var otherRaw = ResourceManager.ReadStringResource("Alex.Resources.items3.json");
SecItemEntries = JsonConvert.DeserializeObject <SecondItemEntry[]>(otherRaw);
var raw = ResourceManager.ReadStringResource("Alex.Resources.items2.json");
ItemEntries = JsonConvert.DeserializeObject <ItemEntry[]>(raw);
var ii = resources.Registries.Items.Entries;
var blocks = resources.Registries.Blocks.Entries;
LoadModels();
ConcurrentDictionary <ResourceLocation, Func <Item> > items = new ConcurrentDictionary <ResourceLocation, Func <Item> >();
// for(int i = 0; i < blocks.Count; i++)
int done = 0;
Parallel.ForEach(
blocks, e =>
{
try
{
var entry = e;
progressReceiver?.UpdateProgress(done, blocks.Count, $"Processing block items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
var bs = BlockFactory.GetBlockState(entry.Key);
if (!(bs.Block is Air))
{
item = new ItemBlock(bs);
// Log.Info($"Registered block item: {entry.Key}");
}
else
{
return;
}
var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(
x => x.name.Equals(entry.Key.Substring(10), StringComparison.InvariantCultureIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var key = new ResourceLocation(ns, $"block/{path}");
ResourcePackModelBase model = null;
if (!(ResourcePack.ItemModels.TryGetValue(key, out model)) &&
!(ResourcePack.BlockModels.TryGetValue(key, out model)))
{
foreach (var it in ResourcePack.ItemModels)
{
if (it.Key.Path.Equals(key.Path, StringComparison.InvariantCultureIgnoreCase))
{
model = it.Value;
break;
}
}
}
if (model == null)
{
Log.Debug($"Missing item render definition for block {entry.Key}, using default.");
model = new ResourcePackItem()
{
Display = _defaultDisplayElements
};
}
item.Renderer = new ItemBlockModelRenderer(bs, model, resources);
item.Renderer.Cache(resourcePack);
items.TryAdd(entry.Key, () => { return(item.Clone()); });
}
finally
{
done++;
}
});
for (int i = 0; i < ii.Count; i++)
{
var entry = ii.ElementAt(i);
progressReceiver?.UpdateProgress(i, ii.Count, $"Processing items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
/* if (blocks.ContainsKey(entry.Key) && blockRegistry.TryGet(entry.Key, out var registryEntry))
* {
* item = new ItemBlock(registryEntry.Value);
* }
* else
* {*/
item = new Item();
// }
var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(x =>
x.name.Equals(entry.Key.Substring(10), StringComparison.InvariantCultureIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var key = new ResourceLocation(ns, $"item/{path}");
foreach (var it in ResourcePack.ItemModels)
{
if (it.Key.Path.Equals(key.Path, StringComparison.InvariantCultureIgnoreCase))
{
//Log.Info($"Model found: {entry.Key} = {it.Key}");
ItemModelRenderer renderer;
if (ItemRenderers.TryGetValue(it.Key, out renderer))
{
}
else if (ItemRenderers.TryGetValue(key, out renderer))
{
}
if (renderer != null)
{
//Log.Debug($"Found renderer for {entry.Key}, textures: {it.Value.Textures.Count}");
item.Renderer = renderer;
break;
}
}
}
if (item.Renderer == null)
{
Log.Warn($"Could not find item model renderer for: {key.ToString()}");
}
items.TryAdd(key, () => { return(item.Clone()); });
}
Items = new ReadOnlyDictionary <ResourceLocation, Func <Item> >(items);
}
public static void Init(IRegistryManager registryManager, ResourceManager resources, IProgressReceiver progressReceiver = null)
{
ResourceManager = resources;
// ResourcePack = resourcePack;
var otherRaw = ResourceManager.ReadStringResource("Alex.Resources.items3.json");
SecItemEntries = JsonConvert.DeserializeObject <SecondItemEntry[]>(otherRaw);
var raw = ResourceManager.ReadStringResource("Alex.Resources.items2.json");
ItemEntries = JsonConvert.DeserializeObject <ItemEntry[]>(raw);
var ii = resources.Registries.Items.Entries;
var blocks = resources.Registries.Blocks.Entries;
// LoadModels();
ConcurrentDictionary <ResourceLocation, Func <Item> > items = new ConcurrentDictionary <ResourceLocation, Func <Item> >();
// for(int i = 0; i < blocks.Count; i++)
// List<ResourceLocation> addedCurrently = n
int done = 0;
Parallel.ForEach(
blocks, e =>
{
try
{
var entry = e;
progressReceiver?.UpdateProgress(done, blocks.Count, $"Processing block items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
var bs = BlockFactory.GetBlockState(entry.Key);
if (!(bs.Block is Air) && bs != null)
{
item = new ItemBlock(bs);
// Log.Info($"Registered block item: {entry.Key}");
}
else
{
return;
}
/*var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
*
* if (minetItem != null)
* {
* if (Enum.TryParse<ItemType>(minetItem.ItemType.ToString(), out ItemType t))
* {
* item.ItemType = t;
* }
*
* SetItemMaterial(item, minetItem.ItemMaterial);
* // item.Material = minetItem.ItemMaterial;
*
* item.Meta = minetItem.Metadata;
* item.Id = minetItem.Id;
* }*/
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(
x => x.name.Equals(entry.Key.Substring(10), StringComparison.OrdinalIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var resourceLocation = new ResourceLocation(ns, $"block/{path}");
ResourcePackModelBase model = null;
if (!ResourceManager.TryGetBlockModel(resourceLocation, out model))
{
/*foreach (var it in ResourcePack.ItemModels)
* {
* if (it.Key.Path.Equals(key.Path, StringComparison.OrdinalIgnoreCase))
* {
* model = it.Value;
*
* break;
* }
* }*/
}
if (model == null)
{
Log.Debug($"Missing item render definition for block {entry.Key}, using default.");
// model = new ResourcePackItem() {Display = _defaultDisplayElements};
}
else
{
item.Renderer = new ItemBlockModelRenderer(bs, model, bs.Block.Animated ? resources.Atlas.GetAtlas(0) : resources.Atlas.GetStillAtlas());
item.Renderer.Cache(resources);
if (!items.TryAdd(entry.Key, () => { return(item.Clone()); }))
{
// items[entry.Key] = () => { return item.Clone(); };
}
}
}
finally
{
done++;
}
});
int i = 0;
Parallel.ForEach(
ii, (entry) =>
{
// var entry = ii.ElementAt(i);
progressReceiver?.UpdateProgress(i++, ii.Count, $"Processing items...", entry.Key);
var resourceLocation = new ResourceLocation(entry.Key);
resourceLocation = new ResourceLocation(resourceLocation.Namespace, $"item/{resourceLocation.Path}");
if (items.ContainsKey(resourceLocation))
{
return;
}
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
/* if (blocks.ContainsKey(entry.Key) && blockRegistry.TryGet(entry.Key, out var registryEntry))
* {
* item = new ItemBlock(registryEntry.Value);
* }
* else
* {*/
item = new Item();
// }
var minetItem = MiNET.Items.ItemFactory.GetItem(resourceLocation.Path);
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(
x => x.name.Equals(resourceLocation.Path, StringComparison.OrdinalIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
ItemModelRenderer renderer;
if (!ItemRenderers.TryGetValue(resourceLocation, out renderer))
{
if (ResourceManager.TryGetItemModel(resourceLocation, out var model))
{
renderer = new ItemModelRenderer(model);
renderer.Cache(ResourceManager);
ItemRenderers.TryAdd(resourceLocation, renderer);
}
if (renderer == null)
{
var r = ItemRenderers.FirstOrDefault(
x => x.Key.Path.Equals(resourceLocation.Path, StringComparison.OrdinalIgnoreCase));
if (r.Value != null)
{
renderer = r.Value;
}
}
// if (ResourcePack.ItemModels.TryGetValue(resourceLocation, out var itemModel)) { }
}
if (renderer != null)
{
item.Renderer = renderer;
}
if (item.Renderer == null)
{
Log.Warn($"Could not find item model renderer for: {resourceLocation}");
}
if (!items.TryAdd(resourceLocation, () => { return(item.Clone()); }))
{
//var oldItem = items[resourceLocation];
// items[resourceLocation] = () => { return item.Clone(); };
}
});
Items = new ReadOnlyDictionary <ResourceLocation, Func <Item> >(items);
}
public ItemModelRenderer(ResourcePackModelBase model) : base(model,
VertexPositionColor.VertexDeclaration)
{
}
private ResourcePackModelBase ProcessModel(ResourceLocation resourceLocation, ResourcePackModelBase model, ref Dictionary <ResourceLocation, ResourcePackModelBase> models)
{
if (_models.TryGetValue(resourceLocation, out var existingModel))
{
return(existingModel);
}
if (!string.IsNullOrWhiteSpace(model.ParentName) && !model.ParentName.Equals(resourceLocation.Path, StringComparison.InvariantCultureIgnoreCase))
{
ResourceLocation parentKey = new ResourceLocation(model.ParentName);
ResourcePackModelBase parent;
if (!_models.TryGetValue(parentKey, out parent))
{
if (models.TryGetValue(parentKey, out parent))
{
parent = ProcessModel(parentKey, parent, ref models);
}
}
if (parent != null)
{
model.Parent = parent;
}
}
_models.Add(resourceLocation, model);
return(model);
}
private ItemBlockModelRenderer(bool animated, ResourcePackModelBase model, ResourceManager resourceManager) : base(model, VertexPositionColorTexture.VertexDeclaration)
{
_animated = animated;
_resource = resourceManager;
Offset = new Vector3(0f, -0.5f, 0f);
}
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);
}
}
}
}
}
public BlockStateModelWrapper(BlockStateModel model, ResourcePackModelBase blockModel)
{
BlockStateModel = model;
BlockModel = blockModel;
}
