private void GetTextures(McResourcePack resourcePack,
Dictionary <ResourceLocation, Image <Rgba32>[]> seperateFrames,
Dictionary <ResourceLocation, Image <Rgba32> > regularTextures, IProgressReceiver progressReceiver)
{
progressReceiver.UpdateProgress(0, "Processing blockstate textures...");
int blockstatesProcessed = 0;
int totalStates = resourcePack.BlockStates.Count;
foreach (var state in resourcePack.BlockStates)
{
progressReceiver.UpdateProgress((int)(100D * ((double)blockstatesProcessed / (double)totalStates)), null, state.Key);
var blockState = BlockFactory.GetBlockState(state.Key);
if (blockState.Name == "Unknown")
{
Log.Warn($"Missing blockstate: {state.Key}");
blockstatesProcessed++;
continue;
}
foreach (var variant in state.Value.Variants)
{
foreach (var entry in BlockState.ParseData(variant.Key))
{
blockState = blockState.WithProperty(entry.Key, entry.Value);
}
foreach (var va in variant.Value)
{
var model = va.Model;
foreach (var texture in model.Textures)
//foreach(var element in model.Elements)
//foreach(var face in element.Faces)
{
// var text = face.Value.Texture; //ResourcePackBlockModel.ResolveTexture(model, texture.Value);
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 == null)
{
break;
}
if (parent.Textures.TryGetValue(substr, out string parentName))
{
text = parentName;
break;
}
parent = parent.Parent;
}
}
}
if (resourcePack.TryGetBitmap(text, out var bmp))
{
if (blockState.Block.Animated && !seperateFrames.ContainsKey(text))
{
var frameSize = GetTextureDimensions(resourcePack, text);
seperateFrames.Add(text, GetFrames(bmp, (int)frameSize.X, (int)frameSize.Y));
}
else if (!blockState.Block.Animated &&
regularTextures.All(x => x.Key != text))
{
regularTextures.Add(text, bmp);
}
}
else
{
/// if (!texture.Value)
// Log.Warn($"Could not get bitmap {texture.Value} or {text} (Key: {texture.Key} Model: {model.Name})");
}
}
}
}
blockstatesProcessed++;
// state.
}
if (resourcePack.TryGetBitmap("block/water_flow", out var flow))
{
var frameSize = GetTextureDimensions(resourcePack, "block/water_flow");
seperateFrames.TryAdd("block/water_flow", GetFrames(flow, (int)frameSize.X, (int)frameSize.Y));
}
if (resourcePack.TryGetBitmap("block/water_still", out var still))
{
var frameSize = GetTextureDimensions(resourcePack, "block/water_still");
seperateFrames.TryAdd("block/water_still", GetFrames(still, (int)frameSize.X, (int)frameSize.Y));
}
}
private static int LoadModels(IRegistryManager registryManager,
ResourceManager resources,
bool replace,
bool reportMissing,
IProgressReceiver progressReceiver)
{
Stopwatch sw = Stopwatch.StartNew();
var raw = ResourceManager.ReadStringResource("Alex.Resources.blockmap.json");
var mapping = JsonConvert.DeserializeObject <BlockMap>(raw);
var blockRegistry = registryManager.GetRegistry <Block>();
//var blockStateRegistry = registryManager.GetRegistry<BlockState>();
var data = BlockData.FromJson(ResourceManager.ReadStringResource("Alex.Resources.NewBlocks.json"));
int total = data.Count;
int done = 0;
int importCounter = 0;
void LoadEntry(KeyValuePair <string, BlockData> entry)
{
done++;
if (!resources.TryGetBlockState(entry.Key, out var blockStateResource))
{
if (reportMissing)
{
Log.Warn($"Could not find blockstate with key: {entry.Key}");
}
return;
}
//double percentage = 100D * ((double) done / (double) total);blockstate variants
progressReceiver.UpdateProgress(done, total, $"Importing block models...", entry.Key);
var location = new ResourceLocation(entry.Key);
var variantMap = new BlockStateVariantMapper();
var defaultState = new BlockState {
Name = entry.Key, VariantMapper = variantMap
};
defaultState = defaultState.WithLocation(location).Value;
if (entry.Value.Properties != null)
{
foreach (var property in entry.Value.Properties)
{
defaultState = (BlockState)defaultState.WithPropertyNoResolve(property.Key, property.Value.FirstOrDefault(), false);
}
}
defaultState.ModelData = ResolveVariant(blockStateResource, defaultState);
variantMap.Model = ResolveModel(resources, blockStateResource, out bool isMultipartModel);
variantMap.IsMultiPart = isMultipartModel;
if (variantMap.Model == null)
{
Log.Warn($"No model found for {entry.Key}[{variantMap.ToString()}]");
}
foreach (var s in entry.Value.States)
{
if (!replace && RegisteredBlockStates.TryGetValue(s.ID, out BlockState st))
{
Log.Warn($"Duplicate blockstate id (Existing: {st.Name}[{st.ToString()}]) ");
continue;
}
BlockState variantState = (BlockState)(defaultState).CloneSilent();
variantState.ID = s.ID;
variantState.Name = entry.Key;
if (s.Properties != null)
{
foreach (var property in s.Properties)
{
//if (property.Key.ToLower() == "waterlogged")continue;
variantState = (Blocks.State.BlockState)variantState.WithPropertyNoResolve(property.Key, property.Value, false);
}
}
IRegistryEntry <Block> registryEntry;
if (!blockRegistry.TryGet(location, out registryEntry))
{
registryEntry = new UnknownBlock();
registryEntry = registryEntry.WithLocation(location); // = entry.Key;
}
else
{
registryEntry = registryEntry.WithLocation(location);
}
var block = registryEntry.Value;
if (string.IsNullOrWhiteSpace(block.DisplayName))
{
block.DisplayName = entry.Key;
}
variantState.ModelData = ResolveVariant(blockStateResource, variantState);
variantState.Block = block.Value;
block.BlockState = variantState;
// if (variantState.IsMultiPart) multipartBased++;
variantState.Default = s.Default;
if (variantMap.TryAdd(variantState))
{
if (!RegisteredBlockStates.TryAdd(variantState.ID, variantState))
{
if (replace)
{
RegisteredBlockStates[variantState.ID] = variantState;
importCounter++;
}
else
{
Log.Warn($"Failed to add blockstate (variant), key already exists! ({variantState.ID} - {variantState.Name})");
}
}
else
{
importCounter++;
}
}
else
{
Log.Warn($"Could not add variant to variant map: {variantState.Name}[{variantState.ToString()}]");
}
}
if (!BlockStateByName.TryAdd(location, variantMap))
{
if (replace)
{
BlockStateByName[location] = variantMap;
}
else
{
Log.Warn($"Failed to add blockstate, key already exists! ({defaultState.Name})");
}
}
}
if (resources.Asynchronous)
{
Parallel.ForEach(data, LoadEntry);
}
else
{
foreach (var entry in data)
{
LoadEntry(entry);
}
}
var blockStateTime = sw.Elapsed;
var mappings = mapping.GroupBy(x => x.Value.BedrockIdentifier).ToArray();
int counter = 1;
sw.Restart();
Parallel.ForEach(
mappings, (m) =>
{
progressReceiver?.UpdateProgress(counter, mapping.Count, "Mapping blockstates...", m.Key);
var mapper = new BlockStateVariantMapper();
bool first = true;
foreach (var state in m)
{
var match = _blockMappingRegex.Match(state.Key);
var keyMatch = match.Groups["key"];
var dataMatch = match.Groups["data"];
if (!keyMatch.Success)
{
Log.Warn($"Entry without key!");
continue;
}
BlockState pcVariant = GetBlockState(keyMatch.Value);
if (pcVariant != null)
{
pcVariant = pcVariant.Clone();
if (dataMatch.Success)
{
var properties = BlockState.ParseData(dataMatch.Value);
var p = properties.ToArray();
for (var i = 0; i < p.Length; i++)
{
var prop = p[i];
if (i == p.Length - 1)
{
pcVariant = pcVariant.WithProperty(prop.Key, prop.Value);
}
else
{
pcVariant = pcVariant.WithPropertyNoResolve(prop.Key, prop.Value, false);
}
}
}
}
if (pcVariant == null)
{
Log.Warn($"Map failed: {match.Groups["key"].Value} -> {state.Value.BedrockIdentifier}");
continue;
}
pcVariant = pcVariant.CloneSilent();
PeBlockState bedrockState = new PeBlockState(pcVariant);
bedrockState.Name = state.Value.BedrockIdentifier;
bedrockState.VariantMapper = mapper;
//bedrockState.AppliedModels = pcVariant.AppliedModels;
// bedrockState.IsMultiPart = pcVariant.IsMultiPart;
// bedrockState.MultiPartHelper = pcVariant.MultiPartHelper;
// bedrockState.ResolveModel = pcVariant.ResolveModel;
//bedrockState.Model = pcVariant.Model;
bedrockState.Block = pcVariant.Block;
bedrockState.ID = (uint)Interlocked.Increment(ref counter);
bedrockState.Default = first;
first = false;
if (state.Value.BedrockStates != null && state.Value.BedrockStates.Count > 0)
{
foreach (var bs in state.Value.BedrockStates)
{
bedrockState.Values[bs.Key] = bs.Value.ToString();
}
}
if (!mapper.TryAdd(bedrockState.WithLocation(bedrockState.Name).Value))
{
Log.Warn($"Failed to add bedrockstate: {state.Value.BedrockIdentifier}");
}
}
BedrockStates[m.Key] = mapper;
});
//Log.Info($"Loaded {multipartBased} multi-part blockstates!");
Log.Info($"Loaded {BedrockStates.Count} mappings in {sw.ElapsedMilliseconds}ms...");
return(importCounter);
}
