3888de7ab4
Added code to the file which have the functionality to get skin boxes and duplicated the functionality for skin offsets. The code causes the game to crash when switching to third person. The error occurs with the skin offsets returning as an empty class object.
662 lines
22 KiB
C++
662 lines
22 KiB
C++
#include "stdafx.h"
|
|
#include "PlayerRenderer.h"
|
|
#include "SkullTileRenderer.h"
|
|
#include "HumanoidMobRenderer.h"
|
|
#include "HumanoidModel.h"
|
|
#include "ModelPart.h"
|
|
#include "LocalPlayer.h"
|
|
#include "MultiPlayerLocalPlayer.h"
|
|
#include "entityRenderDispatcher.h"
|
|
#include "..\Minecraft.World\net.minecraft.world.entity.h"
|
|
#include "..\Minecraft.World\net.minecraft.world.entity.player.h"
|
|
#include "..\Minecraft.World\net.minecraft.world.item.h"
|
|
#include "..\Minecraft.World\net.minecraft.world.level.tile.h"
|
|
#include "..\Minecraft.World\net.minecraft.h"
|
|
#include "..\Minecraft.World\StringHelpers.h"
|
|
|
|
static unsigned int nametagColorForIndex(int index)
|
|
{
|
|
static const unsigned int s_firstColors[] = {
|
|
0xff000000, // WHITE (represents the "white" player, but using black as the colour)
|
|
0xff33cc33, // GREEN
|
|
0xffcc3333, // RED
|
|
0xff3333cc, // BLUE
|
|
0xffcc33cc, // PINK
|
|
0xffcc6633, // ORANGE
|
|
0xffcccc33, // YELLOW
|
|
0xff33dccc // TURQUOISE
|
|
};
|
|
#ifndef __PSVITA__
|
|
if (index >= 0 && index < 8) // Use original colors for the first 8 players
|
|
return s_firstColors[index];
|
|
if (index >= 8 && index < MINECRAFT_NET_MAX_PLAYERS)
|
|
{
|
|
float h = (float)((index * 137) % 360) / 60.f;
|
|
int i = (int)h;
|
|
float f = h - i;
|
|
float q = 1.f - f;
|
|
float t = 1.f - (1.f - f);
|
|
float r = 0.f, g = 0.f, b = 0.f;
|
|
switch (i % 6)
|
|
{
|
|
case 0: r = 1.f; g = t; b = 0.f; break;
|
|
case 1: r = q; g = 1.f; b = 0.f; break;
|
|
case 2: r = 0.f; g = 1.f; b = t; break;
|
|
case 3: r = 0.f; g = q; b = 1.f; break;
|
|
case 4: r = t; g = 0.f; b = 1.f; break;
|
|
default: r = 1.f; g = 0.f; b = q; break;
|
|
}
|
|
int ri = (int)(r * 255.f) & 0xff, gi = (int)(g * 255.f) & 0xff, bi = (int)(b * 255.f) & 0xff;
|
|
return 0xff000000u | (ri << 16) | (gi << 8) | bi;
|
|
}
|
|
#endif
|
|
return 0xFF000000; //Fallback if exceeds 256 somehow
|
|
}
|
|
|
|
ResourceLocation PlayerRenderer::DEFAULT_LOCATION = ResourceLocation(TN_MOB_CHAR);
|
|
|
|
PlayerRenderer::PlayerRenderer() : LivingEntityRenderer( new HumanoidModel(0), 0.5f, true, true )
|
|
{
|
|
humanoidModel = static_cast<HumanoidModel *>(model);
|
|
humanoidModelClassic = static_cast<HumanoidModel *>(modelClassic);
|
|
humanoidModelSlim = static_cast<HumanoidModel *>(modelSlim);
|
|
|
|
armorParts1 = new HumanoidModel(1.0f, true);
|
|
armorParts2 = new HumanoidModel(0.5f, true);
|
|
}
|
|
|
|
unsigned int PlayerRenderer::getNametagColour(int index)
|
|
{
|
|
if( index >= 0 && index < MINECRAFT_NET_MAX_PLAYERS)
|
|
return nametagColorForIndex(index);
|
|
return 0xFF000000;
|
|
}
|
|
|
|
int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, float a)
|
|
{
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
|
|
|
|
// 4J-PB - need to disable rendering armour for some special skins (Daleks)
|
|
unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask();
|
|
if(uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DontRenderArmour))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
|
|
if (itemInstance != nullptr)
|
|
{
|
|
Item *item = itemInstance->getItem();
|
|
if (dynamic_cast<ArmorItem *>(item))
|
|
{
|
|
ArmorItem *armorItem = dynamic_cast<ArmorItem *>(item);
|
|
bindTexture(HumanoidMobRenderer::getArmorLocation(armorItem, layer));
|
|
|
|
HumanoidModel *armor = layer == 2 ? armorParts2 : armorParts1;
|
|
|
|
armor->head->visible = layer == 0;
|
|
armor->hair->visible = layer == 0;
|
|
armor->body->visible = layer == 1 || layer == 2;
|
|
armor->arm0->visible = layer == 1;
|
|
armor->arm1->visible = layer == 1;
|
|
armor->leg0->visible = layer == 2 || layer == 3;
|
|
armor->leg1->visible = layer == 2 || layer == 3;
|
|
|
|
setArmor(armor);
|
|
if (armor != nullptr) armor->attackTime = model->attackTime;
|
|
if (armor != nullptr) armor->riding = model->riding;
|
|
if (armor != nullptr) armor->young = model->young;
|
|
|
|
float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : player->getBrightness(a);
|
|
if (armorItem->getMaterial() == ArmorItem::ArmorMaterial::CLOTH)
|
|
{
|
|
int color = armorItem->getColor(itemInstance);
|
|
float red = static_cast<float>((color >> 16) & 0xFF) / 0xFF;
|
|
float green = static_cast<float>((color >> 8) & 0xFF) / 0xFF;
|
|
float blue = static_cast<float>(color & 0xFF) / 0xFF;
|
|
glColor3f(brightness * red, brightness * green, brightness * blue);
|
|
|
|
if (itemInstance->isEnchanted()) return 0x1f;
|
|
return 0x10;
|
|
}
|
|
else
|
|
{
|
|
glColor3f(brightness, brightness, brightness);
|
|
}
|
|
|
|
if (itemInstance->isEnchanted()) return 0xf;
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
return -1;
|
|
|
|
}
|
|
|
|
void PlayerRenderer::prepareSecondPassArmor(shared_ptr<LivingEntity> _player, int layer, float a)
|
|
{
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
|
|
shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
|
|
if (itemInstance != nullptr)
|
|
{
|
|
Item *item = itemInstance->getItem();
|
|
if (dynamic_cast<ArmorItem *>(item))
|
|
{
|
|
ArmorItem *armorItem = dynamic_cast<ArmorItem *>(item);
|
|
bindTexture(HumanoidMobRenderer::getArmorLocation(static_cast<ArmorItem *>(item), layer, true));
|
|
|
|
float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : player->getBrightness(a);
|
|
glColor3f(brightness, brightness, brightness);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
|
|
{
|
|
if (_mob == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
|
|
HumanoidModel *resModel;
|
|
|
|
if(mob == nullptr) return;
|
|
if(mob->hasInvisiblePrivilege()) return;
|
|
|
|
if (humanoidModelClassic != nullptr && (mob->getCustomSkin() == 18 || mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_ClassicModel))) resModel = humanoidModelClassic;
|
|
else if (humanoidModelSlim != nullptr && ((mob->getCustomSkin() >= 8 && mob->getCustomSkin() <= 17) || mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_SlimModel))) resModel = humanoidModelSlim;
|
|
else resModel = humanoidModel;
|
|
|
|
shared_ptr<ItemInstance> item = mob->inventory->getSelected();
|
|
|
|
armorParts1->holdingRightHand = armorParts2->holdingRightHand = resModel->holdingRightHand = item != nullptr ? 1 : 0;
|
|
|
|
if (item != nullptr)
|
|
{
|
|
if (mob->getUseItemDuration() > 0)
|
|
{
|
|
UseAnim anim = item->getUseAnimation();
|
|
if (anim == UseAnim_block)
|
|
{
|
|
armorParts1->holdingRightHand = armorParts2->holdingRightHand = resModel->holdingRightHand = 3;
|
|
}
|
|
else if (anim == UseAnim_bow)
|
|
{
|
|
armorParts1->bowAndArrow = armorParts2->bowAndArrow = resModel->bowAndArrow = true;
|
|
}
|
|
}
|
|
}
|
|
// 4J added, for 3rd person view of eating
|
|
if( item != nullptr && mob->getUseItemDuration() > 0 && item->getUseAnimation() == UseAnim_eat )
|
|
{
|
|
// These factors are largely lifted from ItemInHandRenderer to try and keep the 3rd person eating animation as similar as possible
|
|
float t = (mob->getUseItemDuration() - a + 1);
|
|
float swing = 1 - (t / item->getUseDuration());
|
|
|
|
armorParts1->eating = armorParts2->eating = resModel->eating = true;
|
|
armorParts1->eating_t = armorParts2->eating_t = resModel->eating_t = t;
|
|
armorParts1->eating_swing = armorParts2->eating_swing = resModel->eating_swing = swing;
|
|
}
|
|
else
|
|
{
|
|
armorParts1->eating = armorParts2->eating = resModel->eating = false;
|
|
}
|
|
|
|
armorParts1->sneaking = armorParts2->sneaking = resModel->sneaking = mob->isSneaking();
|
|
double yp = y - mob->heightOffset;
|
|
if (mob->isSneaking() && !mob->instanceof(eTYPE_LOCALPLAYER))
|
|
{
|
|
yp -= 2 / 16.0f;
|
|
}
|
|
|
|
// Check if an idle animation is needed
|
|
if(mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_HasIdle))
|
|
{
|
|
if(mob->isIdle())
|
|
{
|
|
resModel->idle=true;
|
|
armorParts1->idle=true;
|
|
armorParts2->idle=true;
|
|
}
|
|
else
|
|
{
|
|
resModel->idle=false;
|
|
armorParts1->idle=false;
|
|
armorParts2->idle=false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
resModel->idle=false;
|
|
armorParts1->idle=false;
|
|
armorParts2->idle=false;
|
|
}
|
|
|
|
// 4J-PB - any additional parts to turn on for this player (skin dependent)
|
|
vector<ModelPart *> *pAdditionalModelParts=mob->GetAdditionalModelParts();
|
|
//turn them on
|
|
if(pAdditionalModelParts!=nullptr)
|
|
{
|
|
for(ModelPart *pModelPart : *pAdditionalModelParts)
|
|
{
|
|
pModelPart->visible=true;
|
|
}
|
|
}
|
|
|
|
LivingEntityRenderer::render(mob, x, yp, z, rot, a);
|
|
|
|
// turn them off again
|
|
if(pAdditionalModelParts && pAdditionalModelParts->size()!=0)
|
|
{
|
|
for(ModelPart *pModelPart : *pAdditionalModelParts)
|
|
{
|
|
pModelPart->visible=false;
|
|
}
|
|
}
|
|
|
|
vector<SKIN_OFFSET*>* modelOffsets = Minecraft::GetInstance()->player->GetModelOffsets();
|
|
if (modelOffsets)
|
|
{
|
|
std::unordered_set<SKIN_OFFSET*> modelOffsetSet(modelOffsets->begin(), modelOffsets->end());
|
|
for( auto& offset : modelOffsetSet )
|
|
{
|
|
switch (offset->ePart)
|
|
{
|
|
case eBodyOffset_Head:
|
|
if (offset->fD == L'Y')
|
|
resModel->head->y += offset->fO;
|
|
break;
|
|
case eBodyOffset_Body:
|
|
if (offset->fD == L'Y')
|
|
resModel->body->y += offset->fO;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
armorParts1->bowAndArrow = armorParts2->bowAndArrow = resModel->bowAndArrow = false;
|
|
armorParts1->sneaking = armorParts2->sneaking = resModel->sneaking = false;
|
|
armorParts1->holdingRightHand = armorParts2->holdingRightHand = resModel->holdingRightHand = 0;
|
|
}
|
|
|
|
void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
|
|
{
|
|
float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : _mob->getBrightness(a);
|
|
glColor3f(brightness, brightness, brightness);
|
|
|
|
LivingEntityRenderer::additionalRendering(_mob,a);
|
|
LivingEntityRenderer::renderArrows(_mob, a);
|
|
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
|
|
HumanoidModel *resModel;
|
|
|
|
if (mob != nullptr && humanoidModelClassic != nullptr && (mob->getCustomSkin() == 18 || mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_ClassicModel))) resModel = humanoidModelClassic;
|
|
else if (mob != nullptr && humanoidModelSlim != nullptr && ((mob->getCustomSkin() >= 8 && mob->getCustomSkin() <= 17) || mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_SlimModel))) resModel = humanoidModelSlim;
|
|
else resModel = humanoidModel;
|
|
|
|
shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
|
|
if (headGear != nullptr)
|
|
{
|
|
// don't render the pumpkin for the skins
|
|
unsigned int uiAnimOverrideBitmask = mob->getSkinAnimOverrideBitmask( mob->getCustomSkin());
|
|
|
|
if((uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DontRenderArmour))==0)
|
|
{
|
|
glPushMatrix();
|
|
resModel->head->translateTo(1 / 16.0f);
|
|
|
|
if(headGear->getItem()->id < 256)
|
|
{
|
|
if (TileRenderer::canRender(Tile::tiles[headGear->id]->getRenderShape()))
|
|
{
|
|
float s = 10 / 16.0f;
|
|
glTranslatef(-0 / 16.0f, -4 / 16.0f, 0 / 16.0f);
|
|
glRotatef(90, 0, 1, 0);
|
|
glScalef(s, -s, s);
|
|
}
|
|
|
|
entityRenderDispatcher->itemInHandRenderer->renderItem(mob, headGear, 0);
|
|
}
|
|
else if (headGear->getItem()->id == Item::skull_Id)
|
|
{
|
|
float s = 17 / 16.0f;
|
|
glScalef(s, -s, -s);
|
|
|
|
wstring extra = L"";
|
|
if (headGear->hasTag() && headGear->getTag()->contains(L"SkullOwner"))
|
|
{
|
|
extra = headGear->getTag()->getString(L"SkullOwner");
|
|
}
|
|
SkullTileRenderer::instance->renderSkull(-0.5f, 0, -0.5f, Facing::UP, 180, headGear->getAuxValue(), extra);
|
|
}
|
|
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
// need to add a custom texture for deadmau5
|
|
if (mob != nullptr && app.isXuidDeadmau5( mob->getXuid() ) && bindTexture(mob->customTextureUrl, L"" ))
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
float yr = (mob->yRotO + (mob->yRot - mob->yRotO) * a) - (mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a);
|
|
float xr = mob->xRotO + (mob->xRot - mob->xRotO) * a;
|
|
glPushMatrix();
|
|
glRotatef(yr, 0, 1, 0);
|
|
glRotatef(xr, 1, 0, 0);
|
|
glTranslatef((6 / 16.0f) * (i * 2 - 1), 0, 0);
|
|
glTranslatef(0, -6 / 16.0f, 0);
|
|
glRotatef(-xr, 1, 0, 0);
|
|
glRotatef(-yr, 0, 1, 0);
|
|
|
|
float s = 8 / 6.0f;
|
|
glScalef(s, s, s);
|
|
resModel->renderEars(1 / 16.0f,true);
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
// 4J: removed
|
|
/*boolean loaded = mob->getCloakTexture()->isLoaded();
|
|
boolean b1 = !mob->isInvisible();
|
|
boolean b2 = !mob->isCapeHidden();*/
|
|
if (bindTexture(mob->customTextureUrl2, L"") && !mob->isInvisible())
|
|
{
|
|
glPushMatrix();
|
|
glTranslatef(0, 0, 2 / 16.0f);
|
|
|
|
double xd = (mob->xCloakO + (mob->xCloak - mob->xCloakO) * a) - (mob->xo + (mob->x - mob->xo) * a);
|
|
double yd = (mob->yCloakO + (mob->yCloak - mob->yCloakO) * a) - (mob->yo + (mob->y - mob->yo) * a);
|
|
double zd = (mob->zCloakO + (mob->zCloak - mob->zCloakO) * a) - (mob->zo + (mob->z - mob->zo) * a);
|
|
|
|
float yr = mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a;
|
|
|
|
double xa = Mth::sin(yr * PI / 180);
|
|
double za = -Mth::cos(yr * PI / 180);
|
|
|
|
float flap = static_cast<float>(yd) * 10;
|
|
if (flap < -6) flap = -6;
|
|
if (flap > 32) flap = 32;
|
|
float lean = static_cast<float>(xd * xa + zd * za) * 100;
|
|
float lean2 = static_cast<float>(xd * za - zd * xa) * 100;
|
|
if (lean < 0) lean = 0;
|
|
|
|
float pow = mob->oBob + (mob->bob - mob->oBob) * a;
|
|
|
|
flap += sin((mob->walkDistO + (mob->walkDist - mob->walkDistO) * a) * 6) * 32 * pow;
|
|
if (mob->isSneaking())
|
|
{
|
|
flap += 25;
|
|
}
|
|
|
|
// 4J Stu - Fix for sprint-flying causing the cape to rotate up by 180 degrees or more
|
|
float xRot = 6.0f + lean / 2 + flap;
|
|
if(xRot > 64.0f) xRot = 64.0f;
|
|
|
|
glRotatef(xRot, 1, 0, 0);
|
|
glRotatef(lean2 / 2, 0, 0, 1);
|
|
glRotatef(-lean2 / 2, 0, 1, 0);
|
|
glRotatef(180, 0, 1, 0);
|
|
humanoidModel->renderCloak(1 / 16.0f,true);
|
|
glPopMatrix();
|
|
}
|
|
|
|
shared_ptr<ItemInstance> item = mob->inventory->getSelected();
|
|
|
|
if (item != nullptr)
|
|
{
|
|
glPushMatrix();
|
|
resModel->arm0->translateTo(1 / 16.0f);
|
|
glTranslatef(-1 / 16.0f, 7 / 16.0f, 1 / 16.0f);
|
|
|
|
if (mob->fishing != nullptr)
|
|
{
|
|
item = std::make_shared<ItemInstance>(Item::stick);
|
|
}
|
|
|
|
UseAnim anim = UseAnim_none;//null;
|
|
if (mob->getUseItemDuration() > 0)
|
|
{
|
|
anim = item->getUseAnimation();
|
|
}
|
|
|
|
if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape()))
|
|
{
|
|
float s = 8 / 16.0f;
|
|
glTranslatef(-0 / 16.0f, 3 / 16.0f, -5 / 16.0f);
|
|
s *= 0.75f;
|
|
glRotatef(20, 1, 0, 0);
|
|
glRotatef(45, 0, 1, 0);
|
|
glScalef(-s, -s, s);
|
|
}
|
|
else if (item->id == Item::bow->id)
|
|
{
|
|
float s = 10 / 16.0f;
|
|
glTranslatef(0 / 16.0f, 2 / 16.0f, 5 / 16.0f);
|
|
glRotatef(-20, 0, 1, 0);
|
|
glScalef(s, -s, s);
|
|
glRotatef(-100, 1, 0, 0);
|
|
glRotatef(45, 0, 1, 0);
|
|
}
|
|
else if (Item::items[item->id]->isHandEquipped())
|
|
{
|
|
float s = 10 / 16.0f;
|
|
if (Item::items[item->id]->isMirroredArt())
|
|
{
|
|
glRotatef(180, 0, 0, 1);
|
|
glTranslatef(0, -2 / 16.0f, 0);
|
|
}
|
|
if (mob->getUseItemDuration() > 0)
|
|
{
|
|
if (anim == UseAnim_block)
|
|
{
|
|
glTranslatef(0.05f, 0, -0.1f);
|
|
glRotatef(-50, 0, 1, 0);
|
|
glRotatef(-10, 1, 0, 0);
|
|
glRotatef(-60, 0, 0, 1);
|
|
}
|
|
}
|
|
glTranslatef(0, 3 / 16.0f, 0);
|
|
glScalef(s, -s, s);
|
|
glRotatef(-100, 1, 0, 0);
|
|
glRotatef(45, 0, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
float s = 6 / 16.0f;
|
|
glTranslatef(+4 / 16.0f, +3 / 16.0f, -3 / 16.0f);
|
|
glScalef(s, s, s);
|
|
glRotatef(60, 0, 0, 1);
|
|
glRotatef(-90, 1, 0, 0);
|
|
glRotatef(20, 0, 0, 1);
|
|
}
|
|
|
|
if (item->getItem()->hasMultipleSpriteLayers())
|
|
{
|
|
for (int layer = 0; layer <= 1; layer++)
|
|
{
|
|
int col = item->getItem()->getColor(item,layer);
|
|
float red = ((col >> 16) & 0xff) / 255.0f;
|
|
float g = ((col >> 8) & 0xff) / 255.0f;
|
|
float b = ((col) & 0xff) / 255.0f;
|
|
|
|
glColor4f(red, g, b, 1);
|
|
this->entityRenderDispatcher->itemInHandRenderer->renderItem(mob, item, layer, false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int col = item->getItem()->getColor(item, 0);
|
|
float red = ((col >> 16) & 0xff) / 255.0f;
|
|
float g = ((col >> 8) & 0xff) / 255.0f;
|
|
float b = ((col) & 0xff) / 255.0f;
|
|
|
|
glColor4f(red, g, b, 1);
|
|
this->entityRenderDispatcher->itemInHandRenderer->renderItem(mob, item, 0);
|
|
}
|
|
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
void PlayerRenderer::renderNameTags(shared_ptr<LivingEntity> player, double x, double y, double z, wstring msg, float scale, double dist)
|
|
{
|
|
#if 0
|
|
if (dist < 10 * 10)
|
|
{
|
|
Scoreboard *scoreboard = player->getScoreboard();
|
|
Objective *objective = scoreboard->getDisplayObjective(Scoreboard::DISPLAY_SLOT_BELOW_NAME);
|
|
|
|
if (objective != nullptr)
|
|
{
|
|
Score *score = scoreboard->getPlayerScore(player->getAName(), objective);
|
|
|
|
if (player->isSleeping())
|
|
{
|
|
renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y - 1.5f, z, 64);
|
|
}
|
|
else
|
|
{
|
|
renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y, z, 64);
|
|
}
|
|
|
|
y += getFont()->lineHeight * 1.15f * scale;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
LivingEntityRenderer::renderNameTags(player, x, y, z, msg, scale, dist);
|
|
}
|
|
|
|
void PlayerRenderer::scale(shared_ptr<LivingEntity> player, float a)
|
|
{
|
|
float s = 15 / 16.0f;
|
|
glScalef(s, s, s);
|
|
}
|
|
|
|
void PlayerRenderer::renderHand()
|
|
{
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
|
|
HumanoidModel *resModel;
|
|
|
|
if (player != nullptr && humanoidModelClassic != nullptr && (player->getCustomSkin() == 18 || player->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_ClassicModel))) resModel = humanoidModelClassic;
|
|
else if (player != nullptr && humanoidModelSlim != nullptr && ((player->getCustomSkin() >= 8 && player->getCustomSkin() <= 17) || player->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_SlimModel))) resModel = humanoidModelSlim;
|
|
else resModel = humanoidModel;
|
|
|
|
float brightness = 1;
|
|
glColor3f(brightness, brightness, brightness);
|
|
|
|
resModel->m_uiAnimOverrideBitmask = player->getAnimOverrideBitmask();
|
|
armorParts1->eating = armorParts2->eating = resModel->eating = resModel->idle = false;
|
|
resModel->attackTime = 0;
|
|
resModel->setupAnim(0, 0, 0, 0, 0, 1 / 16.0f, Minecraft::GetInstance()->player);
|
|
// 4J-PB - does this skin have its arm0 disabled? (Dalek, etc)
|
|
if((resModel->m_uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DisableRenderArm0))==0)
|
|
resModel->arm0->render(1 / 16.0f,true);
|
|
// Does this skin have its sleeve0 disabled?
|
|
if((resModel->m_uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DisableRenderSleeve0))==0&&resModel->sleeve0!=nullptr)
|
|
resModel->sleeve0->render(1 / 16.0f,true);
|
|
|
|
//Render custom skin boxes on viewmodel - Botch
|
|
vector<ModelPart*>* additionalModelParts = Minecraft::GetInstance()->player->GetAdditionalModelParts();
|
|
if (!additionalModelParts) return; //If there are no custom boxes, return. This fixes bug where the game will crash if you select a skin with no additional boxes.
|
|
std::unordered_set<ModelPart*> additionalModelPartSet(additionalModelParts->begin(), additionalModelParts->end());
|
|
vector<ModelPart*> armchildren = resModel->arm0->children;
|
|
for (const auto& x : armchildren) {
|
|
if (x && additionalModelPartSet.find(x) != additionalModelPartSet.end()) //This is to verify box is still actually on current skin - Botch
|
|
{
|
|
glPushMatrix();
|
|
//We need to transform to match offset of arm - Botch
|
|
glTranslatef(-5 * 0.0625f, 2 * 0.0625f, 0);
|
|
glRotatef(0.1 * (180.0f / PI), 0, 0, 1);
|
|
x->visible = true;
|
|
x->render(1.0f / 16.0f, true);
|
|
x->visible = false;
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
//Render custom skin boxes on viewmodel for sleeve0
|
|
if (resModel->sleeve0!=nullptr)
|
|
{
|
|
vector<ModelPart*> sleevechildren = resModel->sleeve0->children;
|
|
for (const auto& x : sleevechildren) {
|
|
if (x && additionalModelPartSet.find(x) != additionalModelPartSet.end()) //This is to verify box is still actually on current skin
|
|
{
|
|
glPushMatrix();
|
|
//We need to transform to match offset of arm/sleeve
|
|
glTranslatef(-5 * 0.0625f, 2 * 0.0625f, 0);
|
|
glRotatef(0.1 * (180.0f / PI), 0, 0, 1);
|
|
x->visible = true;
|
|
x->render(1.0f / 16.0f, true);
|
|
x->visible = false;
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlayerRenderer::setupPosition(shared_ptr<LivingEntity> _mob, double x, double y, double z)
|
|
{
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
|
|
|
|
if (mob->isAlive() && mob->isSleeping())
|
|
{
|
|
LivingEntityRenderer::setupPosition(mob, x + mob->bedOffsetX, y + mob->bedOffsetY, z + mob->bedOffsetZ);
|
|
|
|
}
|
|
else
|
|
{
|
|
if(mob->isRiding() && (mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_SmallModel))!=0)
|
|
{
|
|
y += 0.5f;
|
|
}
|
|
LivingEntityRenderer::setupPosition(mob, x, y, z);
|
|
}
|
|
}
|
|
|
|
void PlayerRenderer::setupRotations(shared_ptr<LivingEntity> _mob, float bob, float bodyRot, float a)
|
|
{
|
|
// 4J - dynamic cast required because we aren't using templates/generics in our version
|
|
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
|
|
|
|
if (mob->isAlive() && mob->isSleeping())
|
|
{
|
|
glRotatef(mob->getSleepRotation(), 0, 1, 0);
|
|
glRotatef(getFlipDegrees(mob), 0, 0, 1);
|
|
glRotatef(270, 0, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
LivingEntityRenderer::setupRotations(mob, bob, bodyRot, a);
|
|
}
|
|
}
|
|
|
|
// 4J Added override to stop rendering shadow if player is invisible
|
|
void PlayerRenderer::renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
|
|
{
|
|
if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
|
|
{
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
|
|
if(player != nullptr && player->hasInvisiblePrivilege()) return;
|
|
}
|
|
EntityRenderer::renderShadow(e,x,y,z,pow,a);
|
|
}
|
|
|
|
// 4J Added override
|
|
void PlayerRenderer::bindTexture(shared_ptr<Entity> entity)
|
|
{
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
|
|
bindTexture(player->customTextureUrl, player->getTexture());
|
|
}
|
|
|
|
ResourceLocation *PlayerRenderer::getTextureLocation(shared_ptr<Entity> entity)
|
|
{
|
|
shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
|
|
return new ResourceLocation(static_cast<_TEXTURE_NAME>(player->getTexture()));
|
|
} |