/// <inheritdoc />
public ChestBlockEntity(Block block, World level, PooledTexture2D texture) : base(level, block)
{
Width = 16;
Height = 16;
ModelRenderer = new EntityModelRenderer(new ChestEntityModel(), texture);
}
/// <inheritdoc />
public SkullBlockEntity(World level, Block block, PooledTexture2D texture) : base(level, block)
{
ModelRenderer = new EntityModelRenderer(new SkullBlockEntityModel(), texture);
Width = 8;
Height = 8;
}
internal void UpdateSkin(PooledTexture2D skinTexture)
{
if (skinTexture == null)
{
skinTexture = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, Alex.PlayerTexture);
}
//if (skinSlim)
{
var gotModel = ModelFactory.TryGetModel(GeometryName,
out EntityModel m);
ValidModel = gotModel;
if (gotModel || ModelFactory.TryGetModel("geometry.humanoid.customSlim", out m))
{
if (!gotModel)
{
}
_model = m;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
//UpdateModelParts();
}
}
/*else
* {
* if (ModelFactory.TryGetModel("geometry.humanoid.custom",
* out EntityModel m))
* {
* _model = m;
* ModelRenderer = new EntityModelRenderer(_model, skinTexture);
* UpdateModelParts();
* }
* }*/
}
private void Set(EntityModelRenderer renderer, string bone, bool value)
{
if (renderer.GetBone(bone, out var boneValue))
{
boneValue.Rendered = value;
}
}
internal void UpdateSkin(PooledTexture2D skinTexture)
{
//if (skinSlim)
{
var gotModel = ModelFactory.TryGetModel(GeometryName,
out EntityModel m);
ValidModel = gotModel;
if (gotModel || ModelFactory.TryGetModel("geometry.humanoid.customSlim", out m))
{
if (!gotModel)
{
}
_model = m;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
UpdateModelParts();
}
}
/*else
* {
* if (ModelFactory.TryGetModel("geometry.humanoid.custom",
* out EntityModel m))
* {
* _model = m;
* ModelRenderer = new EntityModelRenderer(_model, skinTexture);
* UpdateModelParts();
* }
* }*/
}
internal void UpdateSkin(PooledTexture2D skinTexture)
{
if (skinTexture != null && ModelRenderer != null)
{
ModelRenderer.Texture = skinTexture;
return;
}
string geometry = "geometry.humanoid.customSlim";
if (skinTexture == null)
{
string skinVariant = "entity/alex";
var uuid = UUID.GetBytes();
if ((uuid[3] ^ uuid[7] ^ uuid[11] ^ uuid[15]) % 2 == 0)
{
skinVariant = "entity/steve";
geometry = "geometry.humanoid.custom";
}
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(skinVariant, out var rawTexture))
{
skinTexture = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, rawTexture);
//skinBitmap = rawTexture;
}
else
{
skinTexture = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, Alex.PlayerTexture);
}
}
//if (skinSlim)
{
//var gotModel = ModelFactory.TryGetModel(GeometryName,
// out EntityModel m);
//ValidModel = gotModel;
if (ModelFactory.TryGetModel(geometry, out var m))
{
_model = m;
ValidModel = true;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
//UpdateModelParts();
}
}
/*else
* {
* if (ModelFactory.TryGetModel("geometry.humanoid.custom",
* out EntityModel m))
* {
* _model = m;
* ModelRenderer = new EntityModelRenderer(_model, skinTexture);
* UpdateModelParts();
* }
* }*/
}
public void ApplyTo(EntityModelRenderer renderer)
{
Set(renderer, "cape", CapeEnabled);
Set(renderer, "jacket", JacketEnabled);
Set(renderer, "leftSleeve", LeftSleeveEnabled);
Set(renderer, "rightSleeve", RightSleeveEnabled);
Set(renderer, "leftPants", LeftPantsEnabled);
Set(renderer, "rightPants", RightPantsEnabled);
Set(renderer, "hat", HatEnabled);
}
public static bool ModelByType(EntityType type, out EntityModelRenderer renderer, out EntityData data)
{
if (_typeToId.TryGetValue(type, out long id))
{
return(ModelByNetworkId(id, out renderer, out data));
}
renderer = null;
data = null;
return(false);
}
/// <inheritdoc />
public ChestBlockEntity(Block block, World level, PooledTexture2D texture) : base(level, block)
{
Width = 16;
Height = 16;
ModelRenderer = new EntityModelRenderer(new ChestModel(), texture);
if (ModelRenderer.GetBone("head", out var head))
{
HeadBone = head;
}
}
public static bool ModelByNetworkId(long networkId, out EntityModelRenderer renderer, out EntityData data)
{
if (_idToData.TryGetValue(networkId, out data))
{
renderer = TryGetRendererer(data, null);
if (renderer != null)
{
return(true);
}
else
{
Log.Warn($"No renderer found for {data.Name}");
}
}
renderer = null;
return(false);
}
public static bool ModelByNetworkId(long networkId, out EntityModelRenderer renderer, out EntityData data)
{
if (_idToData.TryGetValue(networkId, out data))
{
renderer = TryGetRendererer(data, null);
if (renderer != null)
{
return(true);
}
else
{
// if (data.OriginalName.Equals("armor_stand"))
//Log.Warn($"No entity model renderer found for {data.Name} - {data.OriginalName}");
}
}
renderer = null;
return(false);
}
private void SetVertices()
{
var def = _entityDefinitions[_index];
EntityModelRenderer renderer = null;
//if (def.Value != null)
//{
// renderer = EntityFactory.GetEntityRenderer(def.Key, null);
//}
if (def.Value != null && def.Value.Geometry != null && def.Value.Geometry.ContainsKey("default") &&
def.Value.Textures != null)
{
EntityModel model;
if (ModelFactory.TryGetModel(def.Value.Geometry["default"],
out model) && model != null)
{
var textures = def.Value.Textures;
string texture;
if (!textures.TryGetValue("default", out texture))
{
texture = textures.FirstOrDefault().Value;
}
if (Alex.Resources.BedrockResourcePack.Textures.TryGetValue(texture,
out var bmp))
{
PooledTexture2D t = TextureUtils.BitmapToTexture2D(Alex.GraphicsDevice, bmp.Value);
renderer = new EntityModelRenderer(model, t);
renderer.Scale = 1f / 16f;
}
}
}
_currentRenderer = renderer;
}
internal void UpdateSkin(Texture2D skinTexture, bool skinSlim)
{
if (skinSlim)
{
if (ModelFactory.TryGetModel("geometry.humanoid.customSlim",
out EntityModel m))
{
_model = m;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
UpdateModelParts();
}
}
else
{
if (ModelFactory.TryGetModel("geometry.humanoid.custom",
out EntityModel m))
{
_model = m;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
UpdateModelParts();
}
}
}
public void SpawnMob(long entityId, Guid uuid, EntityType type, PlayerLocation position, Microsoft.Xna.Framework.Vector3 velocity)
{
Entity entity = null;
if (EntityFactory.ModelByType(type, out var renderer, out EntityData knownData))
{
//if (Enum.TryParse(knownData.Name, out type))
//{
// entity = type.Create(null);
//}
entity = type.Create(null);
if (entity == null)
{
entity = new Entity((int)type, null, BaseClient);
}
//if (knownData.Height)
{
entity.Height = knownData.Height;
}
//if (knownData.Width.HasValue)
entity.Width = knownData.Width;
if (string.IsNullOrWhiteSpace(entity.NameTag) && !string.IsNullOrWhiteSpace(knownData.Name))
{
entity.NameTag = knownData.Name;
}
}
if (entity == null)
{
Log.Warn($"Could not create entity of type: {(int) type}:{type.ToString()}");
return;
}
if (renderer == null)
{
var def = AlexInstance.Resources.BedrockResourcePack.EntityDefinitions.FirstOrDefault(x =>
x.Value.Filename.Replace("_", "").Equals(type.ToString().ToLowerInvariant()));
if (!string.IsNullOrWhiteSpace(def.Key))
{
EntityModel model;
if (ModelFactory.TryGetModel(def.Value.Geometry["default"],
out model) && model != null)
{
var textures = def.Value.Textures;
string texture;
if (!textures.TryGetValue("default", out texture))
{
texture = textures.FirstOrDefault().Value;
}
if (AlexInstance.Resources.BedrockResourcePack.Textures.TryGetValue(texture,
out Bitmap bmp))
{
Texture2D t = TextureUtils.BitmapToTexture2D(AlexInstance.GraphicsDevice, bmp);
renderer = new EntityModelRenderer(model, t);
}
}
}
}
if (renderer == null)
{
Log.Debug($"Missing renderer for entity: {type.ToString()} ({(int) type})");
return;
}
if (renderer.Texture == null)
{
Log.Debug($"Missing texture for entity: {type.ToString()} ({(int) type})");
return;
}
entity.ModelRenderer = renderer;
entity.KnownPosition = position;
entity.Velocity = velocity;
entity.EntityId = entityId;
entity.UUID = new UUID(uuid.ToByteArray());
BaseClient.WorldProvider.SpawnEntity(entityId, entity);
}
/// <inheritdoc />
public EnderChestBlockEntity(Block block, World level) : base(block, level)
{
ModelRenderer = new EntityModelRenderer(new ChestEntityModel(), BlockEntityFactory.EnderChestTexture);
}
public World(IServiceProvider serviceProvider, GraphicsDevice graphics, AlexOptions options,
NetworkProvider networkProvider)
{
Graphics = graphics;
Options = options;
PhysicsEngine = new PhysicsManager(this);
ChunkManager = new ChunkManager(serviceProvider, graphics, this);
EntityManager = new EntityManager(graphics, this, networkProvider);
Ticker = new TickManager();
PlayerList = new PlayerList();
ChunkManager.Start();
// var alex = serviceProvider.GetRequiredService<Alex>();
var settings = serviceProvider.GetRequiredService <IOptionsProvider>();
var profileService = serviceProvider.GetRequiredService <IPlayerProfileService>();
var resources = serviceProvider.GetRequiredService <ResourceManager>();
EventDispatcher = serviceProvider.GetRequiredService <IEventDispatcher>();
string username = string.Empty;
PooledTexture2D texture;
if (Alex.PlayerTexture != null)
{
texture = TextureUtils.BitmapToTexture2D(graphics, Alex.PlayerTexture);
}
else
{
resources.ResourcePack.TryGetBitmap("entity/alex", out var rawTexture);
texture = TextureUtils.BitmapToTexture2D(graphics, rawTexture);
}
Skin skin = profileService?.CurrentProfile?.Skin;
if (skin == null)
{
skin = new Skin()
{
Texture = texture,
Slim = true
};
}
if (!string.IsNullOrWhiteSpace(profileService?.CurrentProfile?.Username))
{
username = profileService.CurrentProfile.Username;
}
Player = new Player(graphics, serviceProvider.GetRequiredService <Alex>().InputManager, username, this, skin, networkProvider, PlayerIndex.One);
Camera = new EntityCamera(Player);
if (Alex.PlayerModel != null)
{
EntityModelRenderer modelRenderer = new EntityModelRenderer(Alex.PlayerModel, texture);
if (modelRenderer.Valid)
{
Player.ModelRenderer = modelRenderer;
}
}
Player.KnownPosition = new PlayerLocation(GetSpawnPoint());
Camera.MoveTo(Player.KnownPosition, Vector3.Zero);
Options.FieldOfVision.ValueChanged += FieldOfVisionOnValueChanged;
Camera.FOV = Options.FieldOfVision.Value;
PhysicsEngine.AddTickable(Player);
/*if (networkProvider is BedrockClient)
* {
* Player.SetInventory(new BedrockInventory(46));
* }
* else
* {
* Player.SetInventory(new Utils.Inventory(46));
* }*/
// Player.Inventory.IsPeInventory = true;
/*if (ItemFactory.TryGetItem("minecraft:diamond_sword", out var sword))
* {
* Player.Inventory[Player.Inventory.SelectedSlot] = sword;
* Player.Inventory.MainHand = sword;
* }
* else
* {
* Log.Warn($"Could not get diamond sword!");
* }*/
EventDispatcher.RegisterEvents(this);
var guiManager = serviceProvider.GetRequiredService <GuiManager>();
InventoryManager = new InventoryManager(guiManager);
SkyRenderer = new SkyBox(serviceProvider, graphics, this);
//SkyLightCalculations = new SkyLightCalculations();
UseDepthMap = options.VideoOptions.Depthmap;
options.VideoOptions.Depthmap.Bind((old, newValue) => { UseDepthMap = newValue; });
options.VideoOptions.RenderDistance.Bind(
(old, newValue) =>
{
Camera.SetRenderDistance(newValue);
});
Camera.SetRenderDistance(options.VideoOptions.RenderDistance);
//ServerType = (networkProvider is BedrockClient) ? ServerType.Bedrock : ServerType.Java;
}
public void LoadSkin(Skin skin)
{
//PooledTexture2D skinTexture = null;
Image <Rgba32> skinBitmap = null;
if (!skin.TryGetBitmap(out skinBitmap))
{
Log.Warn($"No custom skin data for player {Name}");
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap("entity/alex", out var rawTexture))
{
skinBitmap = rawTexture;
//skinTexture = TextureUtils.BitmapToTexture2D(AlexInstance.GraphicsDevice, rawTexture);
}
}
EntityModel model = null;
if (!skin.IsPersonaSkin)
{
if (!string.IsNullOrWhiteSpace(skin.GeometryData) && skin.GeometryData != "null")
{
try
{
if (string.IsNullOrWhiteSpace(skin.ResourcePatch) || skin.ResourcePatch == "null")
{
Log.Warn($"Resourcepatch null for player {Name}");
}
else
{
var resourcePatch = JsonConvert.DeserializeObject <SkinResourcePatch>(
skin.ResourcePatch, GeometrySerializationSettings);
GeometryModel geometryModel = null;
// Dictionary<string, EntityModel> models = new Dictionary<string, EntityModel>();
if (!GeometryModel.TryParse(skin.GeometryData, resourcePatch, out geometryModel))
{
Log.Warn($"Failed to parse geometry for player {Name}");
}
/*try
* {
* geometryModel = MCJsonConvert.DeserializeObject<GeometryModel>(skin.GeometryData);
* }
* catch (Exception ex)
* {
* Log.Warn($"Failed to parse geometry for player {Name}: {ex.ToString()}");
* }*/
if (geometryModel == null || geometryModel.Geometry.Count == 0)
{
Log.Warn($"!! Model count was 0 for player {Name} !!");
//EntityModel.GetEntries(r.Skin.GeometryData, models);
}
else
{
if (resourcePatch?.Geometry != null)
{
model = geometryModel.FindGeometry(resourcePatch.Geometry.Default);
if (model == null)
{
Log.Warn(
$"Invalid geometry: {resourcePatch.Geometry.Default} for player {Name}");
}
else
{
var modelTextureSize = model.Description != null ?
new Point((int)model.Description.TextureWidth, (int)model.Description.TextureHeight) :
new Point((int)model.Texturewidth, (int)model.Textureheight);
var textureSize = new Point(skinBitmap.Width, skinBitmap.Height);
if (modelTextureSize != textureSize)
{
int newHeight = modelTextureSize.Y > textureSize.Y ? textureSize.Y : modelTextureSize.Y;
int newWidth = modelTextureSize.X > textureSize.X ? textureSize.X: modelTextureSize.X;
var bitmap = skinBitmap;
// bitmap.Mutate<Rgba32>(xx => xx.Resize(newWidth, newHeight));
Image <Rgba32> skinTexture = new Image <Rgba32>(modelTextureSize.X, modelTextureSize.Y);
skinTexture.Mutate <Rgba32>(
c =>
{
c.DrawImage(bitmap, new SixLabors.ImageSharp.Point(0, 0), 1f);
});
skinBitmap = skinTexture;
}
}
}
else
{
Log.Warn($"Resourcepatch geometry was null for player {Name}");
}
}
/*foreach (var mm in models.ToArray())
* {
* if (ProcessEntityModel(models, mm.Value, false))
* {
* models.Remove(mm.Key);
* }
* }
*
* foreach (var mm in models.ToArray())
* {
* if (ProcessEntityModel(models, mm.Value, true))
* {
* models.Remove(mm.Key);
* }
* }*/
}
}
catch (Exception ex)
{
string name = "N/A";
/*if (r.Skin.SkinResourcePatch != null)
* {
* name = r.Skin.SkinResourcePatch.Geometry.Default;
* }*/
Log.Warn(ex, $"Could not create geometry ({name}): {ex.ToString()} for player {Name}");
// File.WriteAllBytes(Path.Combine("/home/kenny/.config/Alex/skinDebug/failed", $"failed-{Environment.TickCount}.json"), Encoding.UTF8.GetBytes(skin.GeometryData));
}
}
else
{
Log.Warn($"Geometry data null for player {Name}");
}
}
if (model == null)
{
model = skin.Slim ? (EntityModel) new Models.HumanoidCustomslimModel() : (EntityModel) new Models.HumanoidCustomGeometryHumanoidModel();
}
if (model != null && ValidateModel(model, Name))
{
var modelRenderer = new EntityModelRenderer(model, TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, skinBitmap));
if (modelRenderer.Valid)
{
ModelRenderer = modelRenderer;
}
else
{
modelRenderer.Dispose();
Log.Warn($"Invalid model: for player {Name} (Disposing)");
}
}
else
{
Log.Warn($"Invalid model for player {Name}");
}
}
public World(IServiceProvider serviceProvider, GraphicsDevice graphics, AlexOptions options,
NetworkProvider networkProvider)
{
Graphics = graphics;
Options = options;
PhysicsEngine = new PhysicsManager(this);
ChunkManager = new ChunkManager(serviceProvider, graphics, this);
EntityManager = new EntityManager(graphics, this, networkProvider);
Ticker = new TickManager();
PlayerList = new PlayerList();
Ticker.RegisterTicked(this);
Ticker.RegisterTicked(EntityManager);
//Ticker.RegisterTicked(PhysicsEngine);
Ticker.RegisterTicked(ChunkManager);
ChunkManager.Start();
var profileService = serviceProvider.GetRequiredService <IPlayerProfileService>();
var resources = serviceProvider.GetRequiredService <ResourceManager>();
EventDispatcher = serviceProvider.GetRequiredService <IEventDispatcher>();
string username = string.Empty;
PooledTexture2D texture;
if (Alex.PlayerTexture != null)
{
texture = TextureUtils.BitmapToTexture2D(graphics, Alex.PlayerTexture);
}
else
{
resources.ResourcePack.TryGetBitmap("entity/alex", out var rawTexture);
texture = TextureUtils.BitmapToTexture2D(graphics, rawTexture);
}
Skin skin = profileService?.CurrentProfile?.Skin;
if (skin == null)
{
skin = new Skin()
{
Texture = texture,
Slim = true
};
}
if (!string.IsNullOrWhiteSpace(profileService?.CurrentProfile?.Username))
{
username = profileService.CurrentProfile.Username;
}
Player = new Player(graphics, serviceProvider.GetRequiredService <Alex>().InputManager, username, this, skin, networkProvider, PlayerIndex.One);
Camera = new EntityCamera(Player);
if (Alex.PlayerModel != null)
{
EntityModelRenderer modelRenderer = new EntityModelRenderer(Alex.PlayerModel, texture);
if (modelRenderer.Valid)
{
Player.ModelRenderer = modelRenderer;
}
}
Player.KnownPosition = new PlayerLocation(GetSpawnPoint());
Options.FieldOfVision.ValueChanged += FieldOfVisionOnValueChanged;
Camera.FOV = Options.FieldOfVision.Value;
PhysicsEngine.AddTickable(Player);
EventDispatcher.RegisterEvents(this);
var guiManager = serviceProvider.GetRequiredService <GuiManager>();
InventoryManager = new InventoryManager(guiManager);
SkyRenderer = new SkyBox(serviceProvider, graphics, this);
options.VideoOptions.RenderDistance.Bind(
(old, newValue) =>
{
Camera.SetRenderDistance(newValue);
});
Camera.SetRenderDistance(options.VideoOptions.RenderDistance);
}
private void LoadSkin(Skin skin)
{
try
{
if (skin == null)
{
return;
}
EntityModel model = null;
if (!skin.IsPersonaSkin)
{
if (!string.IsNullOrWhiteSpace(skin.GeometryData) && !skin.GeometryData.Equals(
"null", StringComparison.InvariantCultureIgnoreCase))
{
try
{
if (string.IsNullOrWhiteSpace(skin.ResourcePatch) || skin.ResourcePatch == "null")
{
Log.Debug($"Resourcepatch null for player {Name}");
}
else
{
var resourcePatch = JsonConvert.DeserializeObject <SkinResourcePatch>(
skin.ResourcePatch, GeometrySerializationSettings);
Dictionary <string, EntityModel> models = new Dictionary <string, EntityModel>();
BedrockResourcePack.LoadEntityModel(skin.GeometryData, models);
var processedModels = BedrockResourcePack.ProcessEntityModels(models);
if (processedModels == null || processedModels.Count == 0)
{
Log.Warn($"!! Model count was 0 for player {NameTag} !!");
if (!Directory.Exists("failed"))
{
Directory.CreateDirectory("failed");
}
File.WriteAllText(
Path.Combine(
"failed",
$"{Environment.TickCount64}-{resourcePatch.Geometry.Default}.json"),
skin.GeometryData);
}
else
{
if (resourcePatch?.Geometry != null)
{
if (!processedModels.TryGetValue(resourcePatch.Geometry.Default, out model))
{
Log.Debug(
$"Invalid geometry: {resourcePatch.Geometry.Default} for player {Name}");
}
else
{
}
}
else
{
Log.Debug($"Resourcepatch geometry was null for player {Name}");
}
}
}
}
catch (Exception ex)
{
string name = "N/A";
Log.Debug(ex, $"Could not create geometry ({name}): {ex.ToString()} for player {Name}");
}
}
else
{
//Log.Debug($"Geometry data null for player {Name}");
}
}
if (model == null)
{
ModelFactory.TryGetModel(
skin.Slim ? "geometry.humanoid.custom" : "geometry.humanoid.customSlim", out model);
/*model = skin.Slim ? (EntityModel) new Models.HumanoidCustomslimModel() :
* (EntityModel) new HumanoidModel();*/// new Models.HumanoidCustomGeometryHumanoidModel();
}
if (model != null && ValidateModel(model, Name))
{
Image <Rgba32> skinBitmap = null;
if (!skin.TryGetBitmap(model, out skinBitmap))
{
Log.Warn($"No custom skin data for player {Name}");
if (Alex.Instance.Resources.TryGetBitmap("entity/alex", out var rawTexture))
{
skinBitmap = rawTexture;
}
}
//if (!Directory.Exists("skins"))
// Directory.CreateDirectory("skins");
//var path = Path.Combine("skins", $"{model.Description.Identifier}-{Environment.TickCount64}");
//File.WriteAllText($"{path}.json", skin.GeometryData);
//skinBitmap.SaveAsPng($"{path}.png");
var modelTextureSize = new Point(
(int)model.Description.TextureWidth, (int)model.Description.TextureHeight);
var textureSize = new Point(skinBitmap.Width, skinBitmap.Height);
if (modelTextureSize != textureSize)
{
if (modelTextureSize.Y > textureSize.Y)
{
skinBitmap = SkinUtils.ConvertSkin(skinBitmap, modelTextureSize.X, modelTextureSize.Y);
}
/*var bitmap = skinBitmap;
* bitmap.Mutate<Rgba32>(xx =>
* {
* xx.Resize(modelTextureSize.X, modelTextureSize.Y);
* // xx.Flip(FlipMode.Horizontal);
* });
*
* skinBitmap = bitmap;*/
}
GeometryName = model.Description.Identifier;
var modelRenderer = new EntityModelRenderer(
model, TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, skinBitmap));
if (modelRenderer.Valid)
{
ModelRenderer = modelRenderer;
}
else
{
modelRenderer.Dispose();
Log.Debug($"Invalid model: for player {Name} (Disposing)");
}
}
else
{
Log.Debug($"Invalid model for player {Name}");
}
}
catch (Exception ex)
{
Log.Warn(ex, $"Error while handling player skin.");
}
}
internal void UpdateSkin(PooledTexture2D skinTexture)
{
if (skinTexture != null && ModelRenderer != null)
{
ModelRenderer.Texture = skinTexture;
return;
}
string geometry = "geometry.humanoid.customSlim";
if (skinTexture == null)
{
string skinVariant = "entity/alex";
skinTexture = _alex;
var uuid = UUID.GetBytes();
bool isSteve = (uuid[3] ^ uuid[7] ^ uuid[11] ^ uuid[15]) % 2 == 0;
if (isSteve)
{
skinVariant = "entity/steve";
geometry = "geometry.humanoid.custom";
skinTexture = _steve;
}
if (skinTexture == null)
{
if (Alex.Instance.Resources.TryGetBitmap(skinVariant, out var rawTexture))
{
skinTexture = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, rawTexture);
if (isSteve)
{
_steve = skinTexture;
}
else
{
_alex = skinTexture;
}
//skinBitmap = rawTexture;
}
}
if (skinTexture == null)
{
skinTexture = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, Alex.PlayerTexture);
}
}
if (ModelFactory.TryGetModel(geometry, out var m))
{
_model = m;
ValidModel = true;
ModelRenderer = new EntityModelRenderer(_model, skinTexture);
_texture = skinTexture;
//UpdateModelParts();
}
}
/// <inheritdoc />
protected override void BlockChanged(Block oldBlock, Block newBlock)
{
if (newBlock is Skull s)
{
switch (s.SkullType)
{
case SkullType.Player:
break;
case SkullType.Skeleton:
if (_skeleton == null)
{
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(
"minecraft:entity/skeleton/skeleton", out var bmp))
{
_skeleton = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, bmp);
}
}
if (_skeleton != null)
{
ModelRenderer = new EntityModelRenderer(new SkullBlockEntityModel(), _skeleton);
//ModelRenderer.Texture = _skeleton;
}
break;
case SkullType.WitherSkeleton:
if (_witherSkeleton == null)
{
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(
"minecraft:entity/skeleton/wither_skeleton", out var bmp))
{
_witherSkeleton = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, bmp);
}
}
if (_witherSkeleton != null)
{
ModelRenderer = new EntityModelRenderer(new SkullBlockEntityModel(), _witherSkeleton);
}
break;
case SkullType.Zombie:
if (_zombie == null)
{
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(
"minecraft:entity/zombie/zombie", out var bmp))
{
_zombie = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, bmp);
}
}
if (_zombie != null)
{
ModelRenderer = new EntityModelRenderer(new SkullBlockEntityModel(), _zombie);
}
break;
case SkullType.Creeper:
if (_creeper == null)
{
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(
"minecraft:entity/creeper/creeper", out var bmp))
{
_creeper = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, bmp);
}
}
if (_creeper != null)
{
ModelRenderer = new EntityModelRenderer(new SkullBlockEntityModel(), _creeper);
}
break;
case SkullType.Dragon:
if (_dragon == null)
{
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap(
"minecraft:entity/enderdragon/dragon", out var bmp))
{
_dragon = TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, bmp);
}
}
if (_dragon != null)
{
if (ModelFactory.TryGetModel("geometry.dragon_head", out var dragonHead))
{
ModelRenderer = new EntityModelRenderer(dragonHead, _dragon);
}
//ModelRenderer.Texture = _dragon;
}
break;
}
}
if (newBlock is WallSkull)
{
if (newBlock.BlockState.TryGetValue("facing", out var facing))
{
if (Enum.TryParse <BlockFace>(facing, true, out var face))
{
Offset = (face.Opposite().GetVector3() * 0.5f);
}
}
}
else if (newBlock is Skull)
{
if (newBlock.BlockState.TryGetValue("rotation", out var r))
{
if (byte.TryParse(r, out var rot))
{
Rotation = rot;
}
}
}
}
public void LoadSkin(Skin skin)
{
Image <Rgba32> skinBitmap = null;
if (!skin.TryGetBitmap(out skinBitmap))
{
Log.Warn($"No custom skin data for player {Name}");
if (Alex.Instance.Resources.ResourcePack.TryGetBitmap("entity/alex", out var rawTexture))
{
skinBitmap = rawTexture;
}
}
EntityModel model = null;
if (!skin.IsPersonaSkin)
{
if (!string.IsNullOrWhiteSpace(skin.GeometryData) && skin.GeometryData != "null")
{
try
{
if (string.IsNullOrWhiteSpace(skin.ResourcePatch) || skin.ResourcePatch == "null")
{
Log.Debug($"Resourcepatch null for player {Name}");
}
else
{
var resourcePatch = JsonConvert.DeserializeObject <SkinResourcePatch>(
skin.ResourcePatch, GeometrySerializationSettings);
GeometryModel geometryModel = null;
if (!GeometryModel.TryParse(skin.GeometryData, resourcePatch, out geometryModel))
{
Log.Debug($"Failed to parse geometry for player {Name}");
}
if (geometryModel == null || geometryModel.Geometry.Count == 0)
{
//Log.Warn($"!! Model count was 0 for player {Name} !!");
}
else
{
if (resourcePatch?.Geometry != null)
{
model = geometryModel.FindGeometry(resourcePatch.Geometry.Default);
if (model == null)
{
Log.Debug(
$"Invalid geometry: {resourcePatch.Geometry.Default} for player {Name}");
}
else
{
var modelTextureSize = new Point((int)model.Description.TextureWidth, (int)model.Description.TextureHeight);
var textureSize = new Point(skinBitmap.Width, skinBitmap.Height);
if (modelTextureSize != textureSize)
{
int newHeight = modelTextureSize.Y > textureSize.Y ? textureSize.Y : modelTextureSize.Y;
int newWidth = modelTextureSize.X > textureSize.X ? textureSize.X: modelTextureSize.X;
var bitmap = skinBitmap;
bitmap.Mutate <Rgba32>(xx =>
{
xx.Resize(modelTextureSize.X, modelTextureSize.Y);
xx.Flip(FlipMode.Horizontal);
});
skinBitmap = bitmap;
}
}
}
else
{
Log.Debug($"Resourcepatch geometry was null for player {Name}");
}
}
}
}
catch (Exception ex)
{
string name = "N/A";
Log.Debug(ex, $"Could not create geometry ({name}): {ex.ToString()} for player {Name}");
}
}
else
{
Log.Debug($"Geometry data null for player {Name}");
}
}
if (model == null)
{
model = skin.Slim ? (EntityModel) new Models.HumanoidCustomslimModel() :
(EntityModel) new HumanoidModel(); // new Models.HumanoidCustomGeometryHumanoidModel();
}
if (model != null && ValidateModel(model, Name))
{
var modelRenderer = new EntityModelRenderer(model, TextureUtils.BitmapToTexture2D(Alex.Instance.GraphicsDevice, skinBitmap));
if (modelRenderer.Valid)
{
ModelRenderer = modelRenderer;
}
else
{
modelRenderer.Dispose();
Log.Debug($"Invalid model: for player {Name} (Disposing)");
}
}
else
{
Log.Debug($"Invalid model for player {Name}");
}
}
