celisej567/mcpe
1
0
Fork 0
mirror of https://github.com/celisej567/mcpe.git synced 2026-01-04 14:09:47 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into cmake

Browse Source
This commit is contained in:
Er2
2023-12-06 19:49:36 +03:00
parent 149cd3127b 777bd6a3e2
commit 7b5f2b61f9
72 changed files with 2111 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
source/client/CMakeLists.txt
View File

@@ -3,11 +3,21 @@ add_library(reminecraftpe-client STATIC
app/AppPlatform.cpp app/AppPlatform.hpp
app/Minecraft.cpp app/Minecraft.hpp
app/NinecraftApp.cpp app/NinecraftApp.hpp
model/ChickenModel.cpp model/ChickenModel.hpp
model/CowModel.cpp model/CowModel.hpp
model/CreeperModel.cpp model/CreeperModel.hpp
model/Cube.cpp model/Cube.hpp
model/HumanoidModel.cpp model/HumanoidModel.hpp
model/Model.cpp model/Model.hpp
model/ModelPart.cpp model/ModelPart.hpp
model/PigModel.cpp model/PigModel.hpp
model/PolygonQuad.cpp model/PolygonQuad.hpp
model/QuadrupedModel.cpp model/QuadrupedModel.hpp
model/SheepFurModel.cpp model/SheepFurModel.hpp
model/SheepModel.cpp model/SheepModel.hpp
model/SkeletonModel.cpp model/SkeletonModel.hpp
model/SpiderModel.cpp model/SpiderModel.hpp
model/ZombieModel.cpp model/ZombieModel.hpp
network/ClientSideNetworkHandler.cpp network/ClientSideNetworkHandler.hpp
options/Options.cpp options/Options.hpp
player/LocalPlayer.cpp player/LocalPlayer.hpp
@@ -58,6 +68,9 @@ add_library(reminecraftpe-client STATIC
renderer/TileRenderer.cpp renderer/TileRenderer.hpp
renderer/WaterSideTexture.cpp
renderer/WaterTexture.cpp
renderer/entity/ChickenRenderer.cpp renderer/entity/ChickenRenderer.hpp
renderer/entity/CowRenderer.cpp renderer/entity/CowRenderer.hpp
renderer/entity/CreeperRenderer.cpp renderer/entity/CreeperRenderer.hpp
renderer/entity/EntityRenderDispatcher.cpp renderer/entity/EntityRenderDispatcher.hpp
renderer/entity/EntityRenderer.cpp renderer/entity/EntityRenderer.hpp
renderer/entity/FallingTileRenderer.cpp renderer/entity/FallingTileRenderer.hpp
@@ -65,8 +78,14 @@ add_library(reminecraftpe-client STATIC
renderer/entity/ItemRenderer.cpp renderer/entity/ItemRenderer.hpp
renderer/entity/ItemSpriteRenderer.cpp renderer/entity/ItemSpriteRenderer.hpp
renderer/entity/MobRenderer.cpp renderer/entity/MobRenderer.hpp
renderer/entity/PigRenderer.cpp renderer/entity/PigRenderer.hpp
renderer/entity/SheepFurRenderer.cpp renderer/entity/SheepFurRenderer.hpp
renderer/entity/SheepRenderer.cpp renderer/entity/SheepRenderer.hpp
renderer/entity/SkeletonRenderer.cpp renderer/entity/SkeletonRenderer.hpp
renderer/entity/SpiderRenderer.cpp renderer/entity/SpiderRenderer.hpp
renderer/entity/TntRenderer.cpp renderer/entity/TntRenderer.hpp
renderer/entity/TripodCameraRenderer.cpp renderer/entity/TripodCameraRenderer.hpp
renderer/entity/ZombieRenderer.cpp renderer/entity/ZombieRenderer.hpp
sound/SoundData.cpp sound/SoundData.hpp
sound/SoundEngine.cpp sound/SoundEngine.hpp
sound/SoundRepository.cpp sound/SoundRepository.hpp

109
source/client/model/ChickenModel.cpp Normal file
View File

@@ -0,0 +1,109 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "ChickenModel.hpp"
#include "common/Mth.hpp"
ChickenModel::ChickenModel() :
Model(64, 32),
m_head(0, 0),
m_unknown(0, 0),
m_body(0, 9),
m_leg1(26, 0),
m_leg2(26, 0),
m_wing1(24, 13),
m_wing2(24, 13),
m_beak(14, 0),
m_wattle(14, 4) // Yes, it's called a wattle. Look it up.
{
m_head.setModel(this);
m_beak.setModel(this);
m_wattle.setModel(this);
m_body.setModel(this);
m_leg1.setModel(this);
m_leg2.setModel(this);
m_wing1.setModel(this);
m_wing2.setModel(this);
m_head.addBox(-2, -6, -2, 4, 6, 3);
m_head.setPos(0, 15, -4);
m_beak.addBox(-2, -4, -4, 4, 2, 2, 0);
m_beak.setPos(0, 15, -4);
m_wattle.addBox(-1, -2, -3, 2, 2, 2, 0);
m_wattle.setPos(0, 15, -4);
m_body.addBox(-3, -4, -3, 6, 8, 6, 0);
m_body.setPos(0, 16, 0);
m_leg1.addBox(-1, 0, -3, 3, 5, 3);
m_leg1.setPos(-2, 19, 1);
m_leg2.addBox(-1, 0, -3, 3, 5, 3);
m_leg2.setPos(1, 19, 1);
m_wing1.addBox(0, 0, -3, 1, 4, 6);
m_wing1.setPos(-4, 13, 0);
m_wing2.addBox(-1, 0, -3, 1, 4, 6);
m_wing2.setPos(4, 13, 0);
}
ChickenModel::~ChickenModel()
{
}
void ChickenModel::render(float a, float b, float c, float d, float e, float f)
{
setupAnim(a, b, c, d, e, f);
if (m_bIsBaby)
{
glPushMatrix();
glTranslatef(0.0f, f * 5.0f, f * 2.0f);
m_head.render(f);
m_beak.render(f);
m_wattle.render(f);
glPopMatrix();
glPushMatrix();
glScalef(0.5f, 0.5f, 0.5f);
glTranslatef(0.0f, f * 24.0f, 0.0f);
m_body.render(f);
m_leg1.render(f);
m_leg2.render(f);
m_wing1.render(f);
m_wing2.render(f);
glPopMatrix();
}
else
{
m_head.render(f);
m_beak.render(f);
m_wattle.render(f);
m_body.render(f);
m_leg1.render(f);
m_leg2.render(f);
m_wing1.render(f);
m_wing2.render(f);
}
}
void ChickenModel::setupAnim(float a, float b, float c, float d, float e, float f)
{
// TODO: Why do I need to invert the rotation again?
float rotX = e / (-180.0f / 3.1416f);
m_head.m_rotX = -rotX;
m_beak.m_rotX = -rotX;
m_wattle.m_rotX = -rotX;
float rotY = d / (180.0f / 3.1416f);
m_head.m_rotY = rotY;
m_beak.m_rotY = rotY;
m_wattle.m_rotY = rotY;
m_body.m_rotX = 90.0f / (180.0f / 3.1416f);
m_wing1.m_rotZ = c;
m_wing2.m_rotZ = -c;
float footAng = (Mth::cos(a * 0.6662f) * 1.4f) * b;
m_leg1.m_rotX = footAng;
m_leg2.m_rotX = -footAng;
}

30
source/client/model/ChickenModel.hpp Normal file
View File

@@ -0,0 +1,30 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "Model.hpp"
class ChickenModel : public Model
{
public:
ChickenModel();
~ChickenModel();
void render(float, float, float, float, float, float) override;
void setupAnim(float, float, float, float, float, float) override;
private:
ModelPart m_head;
ModelPart m_unknown;
ModelPart m_body;
ModelPart m_leg1;
ModelPart m_leg2;
ModelPart m_wing1;
ModelPart m_wing2;
ModelPart m_beak;
ModelPart m_wattle;
};

47
source/client/model/CowModel.cpp Normal file
View File

@@ -0,0 +1,47 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "CowModel.hpp"
CowModel::CowModel() :
QuadrupedModel(12, 0.0f)
{
m_head = ModelPart(0, 0);
m_head.setModel(this);
// head
m_head.addBox(-4, -4, -6, 8, 8, 6);
m_head.setPos(0, 4, -8);
// horns
m_head.texOffs(22, 0);
m_head.addBox(-5, -5, -4, 1, 3, 1);
m_head.texOffs(22, 0);
m_head.addBox(4, -5, -4, 1, 3, 1);
m_body = ModelPart(18, 4);
m_body.setModel(this);
// torso
m_body.addBox(-6, -10, -7, 12, 18, 10);
m_body.setPos(0, 5, 2);
// udders
m_body.texOffs(52, 0);
m_body.addBox(-2, 2, -8, 4, 6, 1);
m_leg1.m_posX -= 1.0f;
m_leg2.m_posX += 1.0f;
m_leg3.m_posX -= 1.0f;
m_leg4.m_posX += 1.0f;
field_290 += 2.0f;
}
CowModel::~CowModel()
{
}

17
source/client/model/CowModel.hpp Normal file
View File

@@ -0,0 +1,17 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "QuadrupedModel.hpp"
class CowModel : public QuadrupedModel
{
public:
CowModel();
~CowModel();
};

67
source/client/model/CreeperModel.cpp Normal file
View File

@@ -0,0 +1,67 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "CreeperModel.hpp"
#include "common/Mth.hpp"
CreeperModel::CreeperModel() :
Model(64, 32),
m_head(0, 0),
m_body(16, 16),
m_leg1(0, 16),
m_leg2(0, 16),
m_leg3(0, 16),
m_leg4(0, 16)
{
m_head.setModel(this);
m_body.setModel(this);
m_leg1.setModel(this);
m_leg2.setModel(this);
m_leg3.setModel(this);
m_leg4.setModel(this);
m_head.addBox(-4, -8, -4, 8, 8, 8);
m_head.setPos(0, 4, 0);
m_body.addBox(-4, 0, -2, 8, 12, 4);
m_body.setPos(0, 4, 0);
m_leg1.addBox(-2, 0, -2, 4, 6, 4);
m_leg1.setPos(-2, 16, 4);
m_leg2.addBox(-2, 0, -2, 4, 6, 4);
m_leg2.setPos(2, 16, 4);
m_leg3.addBox(-2, 0, -2, 4, 6, 4);
m_leg3.setPos(-2, 16, -4);
m_leg4.addBox(-2, 0, -2, 4, 6, 4);
m_leg4.setPos(2, 16, -4);
}
CreeperModel::~CreeperModel()
{
}
void CreeperModel::render(float a, float b, float c, float d, float e, float f)
{
setupAnim(a, b, c, d, e, f);
m_head.render(f);
m_body.render(f);
m_leg1.render(f);
m_leg2.render(f);
m_leg3.render(f);
m_leg4.render(f);
}
void CreeperModel::setupAnim(float a, float b, float c, float d, float e, float f)
{
m_head.m_rotY = d / (180.0f / 3.1416f);
m_head.m_rotX = e / (180.0f / 3.1416f);
float footAng = (Mth::cos(a * 0.6662f) * 1.4f) * b;
m_leg1.m_rotX = footAng;
m_leg4.m_rotX = footAng;
m_leg2.m_rotX = -footAng;
m_leg3.m_rotX = -footAng;
}

27
source/client/model/CreeperModel.hpp Normal file
View File

@@ -0,0 +1,27 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "Model.hpp"
class CreeperModel : public Model
{
public:
CreeperModel();
~CreeperModel();
void render(float, float, float, float, float, float) override;
void setupAnim(float, float, float, float, float, float) override;
private:
ModelPart m_head;
ModelPart m_body;
ModelPart m_leg1;
ModelPart m_leg2;
ModelPart m_leg3;
ModelPart m_leg4;
};

173
source/client/model/Cube.cpp
View File

@@ -9,29 +9,23 @@
#include "Cube.hpp"
#include "renderer/GL/GL.hpp"
const float Cube::c = 180.0f / float(M_PI);
#define MUL_DEG_TO_RAD (180.0f / float(M_PI))
Cube::Cube(int a, int b)
{
m_posX = m_posY = m_posZ = 0.0f;
m_rotX = m_rotY = m_rotZ = 0.0f;
field_18 = false;
field_19 = true;
field_1A = false;
m_bCompiled = false;
field_2C0 = 0;
m_buffer = 0;
m_brightness = 1.0f;
field_2B4 = a;
field_2B8 = b;
}
void Cube::addBox(float x, float y, float z, int d, int e, int f, float g)
Cube::Cube(ModelPart* a2, int a3, int a4, float x, float y, float z, int d, int e, int f, float g)
{
float x1 = x, y1 = y, z1 = z;
float x2 = x + float(d), y2 = y + float(e), z2 = z + float(f);
field_29C = x1;
field_2A0 = y1;
field_2A4 = z1;
field_2A8 = x2;
field_2AC = y2;
field_2B0 = z2;
if (a2->field_18)
std::swap(x1, x2);
x1 -= g;
y1 -= g;
z1 -= g;
@@ -39,9 +33,6 @@ void Cube::addBox(float x, float y, float z, int d, int e, int f, float g)
y2 += g;
z2 += g;
if (field_18)
std::swap(x1, x2);
m_verts[0] = VertexPT(x1, y1, z1, 0.0f, 0.0f);
m_verts[1] = VertexPT(x2, y1, z1, 0.0f, 8.0f);
m_verts[2] = VertexPT(x2, y2, z1, 8.0f, 8.0f);
@@ -50,153 +41,33 @@ void Cube::addBox(float x, float y, float z, int d, int e, int f, float g)
m_verts[5] = VertexPT(x2, y1, z2, 0.0f, 8.0f);
m_verts[6] = VertexPT(x2, y2, z2, 8.0f, 8.0f);
m_verts[7] = VertexPT(x1, y2, z2, 8.0f, 0.0f);
int m = field_2B4, n = field_2B8;
int m = a3, n = a4;
m_faces[0] = PolygonQuad(&m_verts[5], &m_verts[1], &m_verts[2], &m_verts[6], m + f + d, n + f, m + f + d + f, n + f + e); // x2 face
m_faces[1] = PolygonQuad(&m_verts[0], &m_verts[4], &m_verts[7], &m_verts[3], m, n + f, m + f, n + f + e); // x1 face
m_faces[2] = PolygonQuad(&m_verts[5], &m_verts[4], &m_verts[0], &m_verts[1], m + f, n, m + f + d, n + f); // up face
m_faces[3] = PolygonQuad(&m_verts[2], &m_verts[3], &m_verts[7], &m_verts[6], m + f + d, n, m + f + d + d, n + f); // down face
m_faces[3] = PolygonQuad(&m_verts[7], &m_verts[6], &m_verts[2], &m_verts[3], m + f + d, n, m + f + d + d, n + f); // down face*
m_faces[4] = PolygonQuad(&m_verts[1], &m_verts[0], &m_verts[3], &m_verts[2], m + f, n + f, m + f + d, n + f + e); // z1 face
m_faces[5] = PolygonQuad(&m_verts[4], &m_verts[5], &m_verts[6], &m_verts[7], m + f + d + f, n + f, m + f + d + f + d, n + f + e); // z2 face
#ifdef ENH_ENTITY_SHADING
m_faces[0].setColor(0.6f, 0.6f, 0.6f);
m_faces[1].setColor(0.6f, 0.6f, 0.6f);
m_faces[4].setColor(0.8f, 0.8f, 0.8f);
m_faces[5].setColor(0.8f, 0.8f, 0.8f);
m_faces[3].setColor(0.5f, 0.5f, 0.5f);
#endif
// *N.B. The original game specifies the vertex ordering as 2, 3, 7, 6, but that renders the back side of the cow upside down.
// This might not be proper form for the face, but we're disabling culling anyway so who cares.
if (field_18)
if (a2->field_18)
{
for (int i = 0; i < 6; i++)
m_faces[i].mirror();
}
}
void Cube::compile(float scale)
void Cube::compile(Tesselator& t, float scale)
{
if (m_bCompiled)
xglDeleteBuffers(1, &m_buffer);
xglGenBuffers(1, &m_buffer);
Tesselator& t = Tesselator::instance;
t.begin();
for (int i = 0; i < 6; i++)
m_faces[i].render(t, scale);
t.end(m_buffer);
m_bCompiled = true;
}
void Cube::draw()
void Cube::setId(const std::string& s)
{
#ifdef ENH_ENTITY_SHADING
drawArrayVTC(m_buffer, 36, sizeof(Tesselator::Vertex));
#else
drawArrayVT(m_buffer, 36, sizeof(Tesselator::Vertex));
#endif
}
void Cube::drawSlow(float scale)
{
Tesselator& t = Tesselator::instance;
t.begin();
for (int i = 0; i < 6; i++)
m_faces[i].render(t, scale);
t.draw();
}
void Cube::render(float scale)
{
if (field_1A)
return;
if (!field_19)
return;
if (!m_bCompiled)
compile(scale);
if (!hasDefaultRot())
{
glPushMatrix();
translateRotTo(scale);
draw();
glPopMatrix();
}
else if (!hasDefaultPos())
{
translatePosTo(scale);
draw();
translatePosTo(-scale);
}
else
{
draw();
}
}
void Cube::translatePosTo(float scale)
{
glTranslatef(m_posX * scale, m_posY * scale, m_posZ * scale);
}
void Cube::translateRotTo(float scale)
{
glTranslatef(m_posX * scale, m_posY * scale, m_posZ * scale);
if (m_rotZ != 0) glRotatef(m_rotZ * c, 0, 0, 1);
if (m_rotY != 0) glRotatef(m_rotY * c, 0, 1, 0);
if (m_rotX != 0) glRotatef(m_rotX * c, 1, 0, 0);
}
void Cube::translateTo(float scale)
{
if (field_1A)
return;
if (!field_19)
return;
if (!hasDefaultRot())
translateRotTo(scale);
else if (!hasDefaultPos())
translatePosTo(scale);
}
void Cube::setBrightness(float b)
{
if (m_brightness != b)
m_bCompiled = false;
m_brightness = b;
#ifdef ENH_ENTITY_SHADING
m_faces[0].setColor(0.6f * b, 0.6f * b, 0.6f * b);
m_faces[1].setColor(0.6f * b, 0.6f * b, 0.6f * b);
m_faces[2].setColor(1.0f * b, 1.0f * b, 1.0f * b);
m_faces[3].setColor(0.5f * b, 0.5f * b, 0.5f * b);
m_faces[4].setColor(0.8f * b, 0.8f * b, 0.8f * b);
m_faces[5].setColor(0.8f * b, 0.8f * b, 0.8f * b);
#endif
}
void Cube::setPos(float x, float y, float z)
{
m_posX = x;
m_posY = y;
m_posZ = z;
}
void Cube::setTexOffs(int a, int b)
{
field_2B4 = a;
field_2B8 = b;
m_id = s;
}

47
source/client/model/Cube.hpp
View File

@@ -9,48 +9,27 @@
#pragma once
#include "PolygonQuad.hpp"
#include "ModelPart.hpp"
class ModelPart;
class Cube
{
public:
Cube(int, int);
Cube(ModelPart*, int, int, float, float, float, int, int, int, float);
void addBox(float a, float b, float c, int d, int e, int f, float g = 0);
// @TODO: void addTexBox(float a, float b, float c, int d, int e, int f, int g); -- No xrefs
void compile(float scale);
void draw();
void drawSlow(float scale);
void render(float scale);
void setPos(float x, float y, float z);
void setTexOffs(int a, int b);
void translateTo(float scale);
void setBrightness(float brightness);
private:
bool hasDefaultPos() { return m_posX == 0 && m_posY == 0 && m_posZ == 0; }
bool hasDefaultRot() { return m_rotX == 0 && m_rotY == 0 && m_rotZ == 0; }
void translatePosTo(float scale);
void translateRotTo(float scale);
void compile(Tesselator& t, float scale);
void setId(const std::string& s);
public:
float m_posX;
float m_posY;
float m_posZ;
float m_rotX;
float m_rotY;
float m_rotZ;
bool field_18;
bool field_19;
bool field_1A;
VertexPT m_verts[8];
PolygonQuad m_faces[6];
int field_2B4;
int field_2B8;
bool m_bCompiled;
int field_2C0;
GLuint m_buffer;
float m_brightness;
static const float c;
std::string m_id;
float field_29C;
float field_2A0;
float field_2A4;
float field_2A8;
float field_2AC;
float field_2B0;
};

166
source/client/model/HumanoidModel.cpp
View File

@@ -10,52 +10,47 @@
#include "client/app/Minecraft.hpp"
HumanoidModel::HumanoidModel(float a, float b):
Model(64, 32),
m_head(0, 0),
m_body(16, 16),
m_armL(40, 16),
m_armR(40, 16),
m_legL(0, 16),
m_legR(0, 16)
m_arm1(40, 16),
m_arm2(40, 16),
m_leg1(0, 16),
m_leg2(0, 16)
{
field_10BC = false;
field_10BD = false;
field_10BE = false;
field_234 = 0;
m_head.setModel(this);
m_body.setModel(this);
m_arm1.setModel(this);
m_arm2.setModel(this);
m_leg1.setModel(this);
m_leg2.setModel(this);
m_head.addBox(-4, -8, -4, 8, 8, 8, a);
m_head.setPos(0, b, 0);
m_body.addBox(-4, 0, -2, 8, 12, 4);
m_body.setPos(0, b, 0);
m_armL.addBox(-3, -2, -2, 4, 12, 4, a);
m_armL.setPos(-5, b + 2, 0);
m_armR.field_18 = true;
m_armR.addBox(-1, -2, -2, 4, 12, 4, a);
m_armR.setPos(5, b + 2, 0);
m_legL.addBox(-2, 0, -2, 4, 12, 4, a);
m_legL.setPos(-2, b + 12, 0);
m_legR.field_18 = true;
m_legR.addBox(-2, 0, -2, 4, 12, 4, a);
m_legR.setPos(2, b + 12, 0);
}
void HumanoidModel::_logGraphics()
{
Matrix m;
if (Minecraft::customDebugId == 1)
{
// @NOTE: I think most of this function was ifdef'd/commented out
m.fetchGL(GL_MODELVIEW_MATRIX);
}
m_arm1.addBox(-3, -2, -2, 4, 12, 4, a);
m_arm1.setPos(-5, b + 2, 0);
m_arm2.field_18 = true;
m_arm2.addBox(-1, -2, -2, 4, 12, 4, a);
m_arm2.setPos(5, b + 2, 0);
m_leg1.addBox(-2, 0, -2, 4, 12, 4, a);
m_leg1.setPos(-2, b + 12, 0);
m_leg2.field_18 = true;
m_leg2.addBox(-2, 0, -2, 4, 12, 4, a);
m_leg2.setPos(2, b + 12, 0);
}
void HumanoidModel::onGraphicsReset()
{
m_head.m_bCompiled = false;
m_body.m_bCompiled = false;
m_armL.m_bCompiled = false;
m_armR.m_bCompiled = false;
m_legL.m_bCompiled = false;
m_legR.m_bCompiled = false;
m_arm1.m_bCompiled = false;
m_arm2.m_bCompiled = false;
m_leg1.m_bCompiled = false;
m_leg2.m_bCompiled = false;
}
void HumanoidModel::render(float a, float b, float c, float d, float e, float f)
@@ -63,11 +58,10 @@ void HumanoidModel::render(float a, float b, float c, float d, float e, float f)
setupAnim(a, b, c, d, e, f);
m_head.render(f);
m_body.render(f);
m_armL.render(f);
m_armR.render(f);
m_legL.render(f);
m_legR.render(f);
_logGraphics();
m_arm1.render(f);
m_arm2.render(f);
m_leg1.render(f);
m_leg2.render(f);
}
void HumanoidModel::setupAnim(float a2, float a3, float a4, float a5, float a6, float a7)
@@ -80,84 +74,84 @@ void HumanoidModel::setupAnim(float a2, float a3, float a4, float a5, float a6,
if (m_head.m_rotX > 1.0f)
m_head.m_rotX = 1.0f;
float v12 = (a2 * 0.6662f) + 3.1416f;
m_armL.m_rotX = (Mth::cos(v12) * 2.0f * a3) * 0.5f;
m_armR.m_rotX = Mth::cos(a2 * 0.6662f) * 2.0f * a3 * 0.5f; // @HUH: multiplying by 2 and also by 1/2
m_armL.m_rotZ = 0.0f;
m_armR.m_rotZ = 0.0f;
m_legL.m_rotX = (Mth::cos(a2 * 0.6662f) * 1.4f) * a3;
m_legR.m_rotX = (Mth::cos(v12) * 1.4f) * a3;
m_legL.m_rotY = 0.0f;
m_legR.m_rotY = 0.0f;
m_arm1.m_rotX = (Mth::cos(v12) * 2.0f * a3) * 0.5f;
m_arm2.m_rotX = Mth::cos(a2 * 0.6662f) * 2.0f * a3 * 0.5f; // @HUH: multiplying by 2 and also by 1/2
m_arm1.m_rotZ = 0.0f;
m_arm2.m_rotZ = 0.0f;
m_leg1.m_rotX = (Mth::cos(a2 * 0.6662f) * 1.4f) * a3;
m_leg2.m_rotX = (Mth::cos(v12) * 1.4f) * a3;
m_leg1.m_rotY = 0.0f;
m_leg2.m_rotY = 0.0f;
if (field_8)
{
float v15 = (3.1416f * -0.5f) * 0.4f;
m_armL.m_rotX += v15;
m_armR.m_rotX += v15;
m_arm1.m_rotX += v15;
m_arm2.m_rotX += v15;
float v16 = (3.1416f * -0.5f) * 0.8f;
m_legL.m_rotX = v16;
m_legR.m_rotX = v16;
m_legL.m_rotY = (3.1416f * 0.5f) * 0.2f;
m_legR.m_rotY = (3.1416f * -0.5f) * 0.2f;
m_leg1.m_rotX = v16;
m_leg2.m_rotX = v16;
m_leg1.m_rotY = (3.1416f * 0.5f) * 0.2f;
m_leg2.m_rotY = (3.1416f * -0.5f) * 0.2f;
}
if (field_10BC)
m_armR.m_rotX = ((3.1416f * 0.5f) * -0.2f) + (m_armR.m_rotX * 0.5f);
if (field_10BD)
m_armL.m_rotX = ((3.1416f * 0.5f) * -0.2f) + (m_armL.m_rotX * 0.5f);
if (field_234)
m_arm2.m_rotX = ((3.1416f * 0.5f) * -0.2f) + (m_arm2.m_rotX * 0.5f);
if (field_235)
m_arm1.m_rotX = ((3.1416f * 0.5f) * -0.2f) + (m_arm1.m_rotX * 0.5f);
m_armL.m_rotY = 0.0f;
m_armR.m_rotY = 0.0f;
m_arm1.m_rotY = 0.0f;
m_arm2.m_rotY = 0.0f;
if (field_4 > -9990.0f)
{
m_body.m_rotY = Mth::sin(Mth::sqrt(field_4) * 3.1416f * 2.0f) * 0.2f;
m_armL.m_posZ = 5.0f * Mth::sin(m_body.m_rotY);
m_armL.m_posX = -5.0f * Mth::cos(m_body.m_rotY);
m_armR.m_posZ = -5.0f * Mth::sin(m_body.m_rotY);
m_armR.m_posX = 5.0f * Mth::cos(m_body.m_rotY);
m_armL.m_rotY = m_armL.m_rotY + m_body.m_rotY;
m_armR.m_rotY = m_armR.m_rotY + m_body.m_rotY;
m_arm1.m_posZ = 5.0f * Mth::sin(m_body.m_rotY);
m_arm1.m_posX = -5.0f * Mth::cos(m_body.m_rotY);
m_arm2.m_posZ = -5.0f * Mth::sin(m_body.m_rotY);
m_arm2.m_posX = 5.0f * Mth::cos(m_body.m_rotY);
m_arm1.m_rotY = m_arm1.m_rotY + m_body.m_rotY;
m_arm2.m_rotY = m_arm2.m_rotY + m_body.m_rotY;
float o = 1.0f - field_4;
m_armR.m_rotX += m_body.m_rotY;
m_armL.m_rotX -= -((m_head.m_rotX - 0.7f) * Mth::sin(3.1416f * field_4)) * 0.75f + Mth::sin((1.0f - o * o * o * o) * 3.1416f) * 1.2f;
m_armL.m_rotY += m_body.m_rotY * 2.0f;
m_armL.m_rotZ = Mth::sin(field_4 * 3.1416f) * -0.4f;
m_arm2.m_rotX += m_body.m_rotY;
m_arm1.m_rotX -= -((m_head.m_rotX - 0.7f) * Mth::sin(3.1416f * field_4)) * 0.75f + Mth::sin((1.0f - o * o * o * o) * 3.1416f) * 1.2f;
m_arm1.m_rotY += m_body.m_rotY * 2.0f;
m_arm1.m_rotZ = Mth::sin(field_4 * 3.1416f) * -0.4f;
}
if (field_10BE) // sneaking?
if (m_bSneaking)
{
m_body.m_rotX = 0.5f;
m_armL.m_rotX += 0.4f;
m_armR.m_rotX += 0.4f;
m_legL.m_posZ = 4.0f;
m_legR.m_posZ = 4.0f;
m_legL.m_posY = 9.0f;
m_legR.m_posY = 9.0f;
m_arm1.m_rotX += 0.4f;
m_arm2.m_rotX += 0.4f;
m_leg1.m_posZ = 4.0f;
m_leg2.m_posZ = 4.0f;
m_leg1.m_posY = 9.0f;
m_leg2.m_posY = 9.0f;
m_head.m_posY = 1.0f;
}
else
{
m_body.m_rotX = 0.0f;
m_legL.m_posZ = 0.0f;
m_leg1.m_posZ = 0.0f;
m_head.m_posY = 0.0f;
m_legR.m_posZ = 0.0f;
m_legL.m_posY = 12.0f;
m_legR.m_posY = 12.0f;
m_leg2.m_posZ = 0.0f;
m_leg1.m_posY = 12.0f;
m_leg2.m_posY = 12.0f;
}
m_armL.m_rotZ += Mth::cos(a4 * 0.09f) * 0.05f + 0.05f;
m_armR.m_rotZ -= Mth::cos(a4 * 0.09f) * 0.05f + 0.05f;
m_armL.m_rotX += Mth::sin(a4 * 0.067f) * 0.05f;
m_armR.m_rotX += Mth::sin(a4 * 0.067f) * -0.05f;
m_arm1.m_rotZ += Mth::cos(a4 * 0.09f) * 0.05f + 0.05f;
m_arm2.m_rotZ -= Mth::cos(a4 * 0.09f) * 0.05f + 0.05f;
m_arm1.m_rotX += Mth::sin(a4 * 0.067f) * 0.05f;
m_arm2.m_rotX += Mth::sin(a4 * 0.067f) * -0.05f;
}
void HumanoidModel::setBrightness(float f)
{
m_armL.setBrightness(f);
m_armR.setBrightness(f);
m_legL.setBrightness(f);
m_legR.setBrightness(f);
m_arm1.setBrightness(f);
m_arm2.setBrightness(f);
m_leg1.setBrightness(f);
m_leg2.setBrightness(f);
m_body.setBrightness(f);
m_head.setBrightness(f);
}

12
source/client/model/HumanoidModel.hpp
View File

@@ -14,7 +14,6 @@ class HumanoidModel : public Model
{
public:
HumanoidModel(float a, float b);
void _logGraphics();
// @TODO - No xrefs: void render(HumanoidModel* a, float f);
void onGraphicsReset() override;
@@ -23,10 +22,11 @@ public:
void setBrightness(float) override;
public:
// @TODO: swap armL and armR.. Steve punches with the right hand.
Cube m_head, m_body, m_armL, m_armR, m_legL, m_legR;
bool field_10BC;
bool field_10BD;
bool field_10BE;
bool field_20 = false;
ModelPart m_head, m_body, m_arm1, m_arm2, m_leg1, m_leg2;
bool field_234;
bool field_235;
bool m_bSneaking;
bool field_237;
};

9
source/client/model/Model.cpp
View File

@@ -8,10 +8,17 @@
#include "Model.hpp"
Model::Model()
Model::Model(int width, int height)
{
field_4 = 0.0f;
field_8 = false;
m_bIsBaby = true; // @HUH: Why is this true?
m_textureWidth = width;
m_textureHeight = height;
}
Model::~Model()
{
}
void Model::onGraphicsReset()

8
source/client/model/Model.hpp
View File

@@ -11,11 +11,13 @@
#include "Cube.hpp"
class Mob;
class ModelPart;
class Model
{
public:
Model();
Model(int width, int height);
virtual ~Model();
virtual void onGraphicsReset();
virtual void prepareMobModel(Mob*, float, float, float);
virtual void render(float, float, float, float, float, float);
@@ -25,4 +27,8 @@ public:
public:
float field_4;
bool field_8;
int m_textureWidth;
int m_textureHeight;
std::vector<ModelPart*> m_parts;
bool m_bIsBaby;
};

271
source/client/model/ModelPart.cpp Normal file
View File

@@ -0,0 +1,271 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "ModelPart.hpp"
#include "renderer/GL/GL.hpp"
#define MUL_DEG_TO_RAD (180.0f / float(M_PI)) // formerly known as Cube::c
ModelPart::ModelPart(int a, int b)
{
m_pModel = nullptr;
field_40 = a;
field_44 = b;
_init();
}
ModelPart::ModelPart(const std::string& baseId)
{
m_pModel = nullptr;
field_34 = baseId;
field_40 = 0;
field_44 = 0;
_init();
}
ModelPart::~ModelPart()
{
clear();
}
void ModelPart::_init()
{
m_posX = m_posY = m_posZ = 0;
m_rotX = m_rotY = m_rotZ = 0;
m_buffer = 0;
m_textureWidth = 64.0f;
m_textureHeight = 32.0f;
field_4C = 0;
field_18 = false;
field_48 = true;
field_49 = false;
m_bCompiled = false;
}
void ModelPart::addChild(ModelPart* pPart)
{
m_pChildren.push_back(pPart);
}
void ModelPart::addBox(float a, float b, float c, int d, int e, int f, float g)
{
Cube* pCube = new Cube(this, field_40, field_44, a, b, c, d, e, f, g);
m_pCubes.push_back(pCube);
}
void ModelPart::addBox(const std::string& id, float a, float b, float c, int d, int e, int f, float g)
{
Cube* pCube = new Cube(this, field_40, field_44, a, b, c, d, e, f, g);
pCube->setId(field_34 + "." + id);
m_pCubes.push_back(pCube);
}
void ModelPart::clear()
{
for (size_t i = 0; i < m_pCubes.size(); i++)
delete m_pCubes[i];
// N.B. does not clear children
m_pCubes.clear();
}
void ModelPart::compile(float scale)
{
Tesselator& t = Tesselator::instance;
xglGenBuffers(1, &m_buffer);
t.begin();
t.color(255, 255, 255, 255);
// @HUH: Recompiling every cube six times??
#ifdef ORIGINAL_CODE
for (int i = 0; i < 6; i++)
{
#endif
for (size_t i = 0; i < m_pCubes.size(); i++)
{
m_pCubes[i]->compile(t, scale);
}
#ifdef ORIGINAL_CODE
}
#endif
t.end(m_buffer);
m_bCompiled = true;
}
void ModelPart::draw()
{
drawArrayVT(this->m_buffer, 36 * m_pCubes.size(), sizeof(Tesselator::Vertex));
}
void ModelPart::drawSlow(float scale)
{
Tesselator& t = Tesselator::instance;
t.begin();
for (size_t i = 0; i < m_pCubes.size(); i++)
{
for (int f = 0; f < 6; f++)
m_pCubes[i]->m_faces[f].render(t, scale);
}
t.draw();
}
void ModelPart::mimic(ModelPart* pPart)
{
m_posX = pPart->m_posX;
m_posY = pPart->m_posY;
m_posZ = pPart->m_posZ;
m_rotX = pPart->m_rotX;
m_rotY = pPart->m_rotY;
m_rotZ = pPart->m_rotZ;
}
void ModelPart::translatePosTo(float scale)
{
glTranslatef(m_posX * scale, m_posY * scale, m_posZ * scale);
}
void ModelPart::translateRotTo(float scale)
{
glTranslatef(m_posX * scale, m_posY * scale, m_posZ * scale);
if (m_rotZ != 0) glRotatef(m_rotZ * MUL_DEG_TO_RAD, 0, 0, 1);
if (m_rotY != 0) glRotatef(m_rotY * MUL_DEG_TO_RAD, 0, 1, 0);
if (m_rotX != 0) glRotatef(m_rotX * MUL_DEG_TO_RAD, 1, 0, 0);
}
void ModelPart::render(float scale)
{
if (field_49)
return;
if (!field_48)
return;
if (!m_bCompiled)
compile(scale);
if (!hasDefaultRot())
{
glPushMatrix();
translateRotTo(scale);
draw();
glPopMatrix();
}
else if (!hasDefaultPos())
{
translatePosTo(scale);
draw();
translatePosTo(-scale);
}
else
{
draw();
}
}
void ModelPart::renderHorrible(float scale)
{
if (field_49)
return;
if (!field_48)
return;
if (!m_bCompiled)
compile(scale);
if (!hasDefaultRot())
{
glPushMatrix();
translateRotTo(scale);
drawSlow(scale);
glPopMatrix();
}
else if (!hasDefaultPos())
{
translatePosTo(scale);
drawSlow(scale);
translatePosTo(-scale);
}
else
{
drawSlow(scale);
}
}
void ModelPart::renderRollable(float scale)
{
if (field_49)
return;
if (!field_48)
return;
if (!m_bCompiled)
compile(scale);
glPushMatrix();
translatePosTo(scale);
translateRotTo(scale);
draw();
glPopMatrix();
}
void ModelPart::setModel(Model* pModel)
{
m_pModel = pModel;
pModel->m_parts.push_back(this);
setTexSize(pModel->m_textureWidth, pModel->m_textureHeight);
}
void ModelPart::setPos(float x, float y, float z)
{
m_posX = x;
m_posY = y;
m_posZ = z;
}
void ModelPart::setTexSize(int width, int height)
{
m_textureWidth = float(width);
m_textureHeight = float(height);
}
void ModelPart::texOffs(int a, int b)
{
field_40 = a;
field_44 = b;
}
void ModelPart::translateTo(float scale)
{
if (field_49)
return;
if (!field_48)
return;
if (!hasDefaultRot())
translateRotTo(scale);
else if (!hasDefaultPos())
translatePosTo(scale);
}
void ModelPart::setBrightness(float brightness)
{
//no op
}

71
source/client/model/ModelPart.hpp Normal file
View File

@@ -0,0 +1,71 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include <vector>
#include "Cube.hpp"
#include "Model.hpp"
class Cube;
class Model;
class ModelPart
{
public:
ModelPart(int, int);
ModelPart(const std::string&);
~ModelPart();
void addChild(ModelPart*);
void addBox(float a, float b, float c, int d, int e, int f, float g = 0);
void addBox(const std::string& id, float a, float b, float c, int d, int e, int f, float g = 0);
void clear();
void compile(float scale);
void draw();
void drawSlow(float scale);
void mimic(ModelPart* pPart);
void render(float scale);
void renderHorrible(float scale);
void renderRollable(float scale);
void setModel(Model* pModel);
void setPos(float x, float y, float z);
void setTexSize(int, int);
void texOffs(int a, int b);
void translateTo(float scale);
void setBrightness(float brightness);
private:
void _init();
bool hasDefaultPos() { return m_posX == 0 && m_posY == 0 && m_posZ == 0; }
bool hasDefaultRot() { return m_rotX == 0 && m_rotY == 0 && m_rotZ == 0; }
void translatePosTo(float scale);
void translateRotTo(float scale);
public:
float m_posX;
float m_posY;
float m_posZ;
float m_rotX;
float m_rotY;
float m_rotZ;
bool field_18;
std::vector<Cube*> m_pCubes;
std::vector<ModelPart*> m_pChildren;
std::string field_34;
float m_textureWidth;
float m_textureHeight;
int field_40;
int field_44;
bool field_48;
bool field_49;
bool m_bCompiled;
int field_4C;
GLuint m_buffer;
Model* m_pModel;
};

20
source/client/model/PigModel.cpp Normal file
View File

@@ -0,0 +1,20 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "PigModel.hpp"
PigModel::PigModel(float f) :
QuadrupedModel(6, f)
{
m_head.texOffs(16, 16);
m_head.addBox(-2, 0, -9, 4, 3, 1, f);
field_28C = 4.0f;
}
PigModel::~PigModel()
{
}

17
source/client/model/PigModel.hpp Normal file
View File

@@ -0,0 +1,17 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "QuadrupedModel.hpp"
class PigModel : public QuadrupedModel
{
public:
PigModel(float);
~PigModel();
};

92
source/client/model/QuadrupedModel.cpp Normal file
View File

@@ -0,0 +1,92 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "QuadrupedModel.hpp"
#include "common/Mth.hpp"
QuadrupedModel::QuadrupedModel(int i, float f) :
Model(64, 32),
m_head(0, 0),
m_unknown(0, 0),
m_body(28, 8),
m_leg1(0, 16),
m_leg2(0, 16),
m_leg3(0, 16),
m_leg4(0, 16)
{
field_28C = 8.0f;
field_290 = 4.0f;
m_head.setModel(this);
m_body.setModel(this);
m_leg1.setModel(this);
m_leg2.setModel(this);
m_leg3.setModel(this);
m_leg4.setModel(this);
m_head.addBox(-4, -4, -8, 8, 8, 8, f);
m_head.setPos(0, 18 - float(i), -6);
m_body.addBox(-5, -10, -7, 10, 16, 8, f);
m_body.setPos(0, 17 - float(i), 2);
m_leg1.addBox(-2, 0, -2, 4, i, 4, f);
m_leg1.setPos(-3, 24 - float(i), 7);
m_leg2.addBox(-2, 0, -2, 4, i, 4, f);
m_leg2.setPos(3, 24 - float(i), 7);
m_leg3.addBox(-2, 0, -2, 4, i, 4, f);
m_leg3.setPos(-3, 24 - float(i), -5);
m_leg4.addBox(-2, 0, -2, 4, i, 4, f);
m_leg4.setPos(3, 24 - float(i), -5);
}
QuadrupedModel::~QuadrupedModel()
{
}
// NOTE: Model::render now takes an Entity pointer... It's unused, though...
void QuadrupedModel::render(float a, float b, float c, float d, float e, float f)
{
setupAnim(a, b, c, d, e, f);
if (m_bIsBaby)
{
glPushMatrix();
glTranslatef(0.0f, f * field_28C, f * field_290);
m_head.render(f);
glPopMatrix();
glPushMatrix();
glScalef(0.5f, 0.5f, 0.5f);
glTranslatef(0.0f, f * 24.0f, 0.0f);
m_body.render(f);
m_leg1.render(f);
m_leg2.render(f);
m_leg3.render(f);
m_leg4.render(f);
glPopMatrix();
}
else
{
m_head.render(f);
m_body.render(f);
m_leg1.render(f);
m_leg2.render(f);
m_leg3.render(f);
m_leg4.render(f);
}
}
void QuadrupedModel::setupAnim(float a2, float a3, float a4, float a5, float a6, float a7)
{
m_head.m_rotX = a6 / (float)(180.0f / 3.1416f);
m_head.m_rotY = a5 / (float)(180.0f / 3.1416f);
m_body.m_rotX = 90.0f / (float)(180.0f / 3.1416f);
float footAng = (Mth::cos(a2 * 0.6662f) * 1.4f) * a3;
m_leg1.m_rotX = footAng;
m_leg4.m_rotX = footAng;
m_leg2.m_rotX = -footAng;
m_leg3.m_rotX = -footAng;
}

32
source/client/model/QuadrupedModel.hpp Normal file
View File

@@ -0,0 +1,32 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "Model.hpp"
class QuadrupedModel : public Model
{
public:
QuadrupedModel(int, float);
~QuadrupedModel();
void render(float, float, float, float, float, float) override;
void setupAnim(float, float, float, float, float, float) override;
protected:
friend class PigModel;
ModelPart m_head;
ModelPart m_unknown;
ModelPart m_body;
ModelPart m_leg1;
ModelPart m_leg2;
ModelPart m_leg3;
ModelPart m_leg4;
float field_28C;
float field_290;
};

0
source/client/model/SheepFurModel.cpp Normal file
View File

0
source/client/model/SheepFurModel.hpp Normal file
View File

0
source/client/model/SheepModel.cpp Normal file
View File

0
source/client/model/SheepModel.hpp Normal file
View File

0
source/client/model/SkeletonModel.cpp Normal file
View File

0
source/client/model/SkeletonModel.hpp Normal file
View File

0
source/client/model/SpiderModel.cpp Normal file
View File

0
source/client/model/SpiderModel.hpp Normal file
View File

0
source/client/model/ZombieModel.cpp Normal file
View File

0
source/client/model/ZombieModel.hpp Normal file
View File

22
source/client/renderer/entity/ChickenRenderer.cpp Normal file
View File

@@ -0,0 +1,22 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "ChickenRenderer.hpp"
ChickenRenderer::ChickenRenderer(Model* pModel, float f) : MobRenderer(pModel, f)
{
}
ChickenRenderer::~ChickenRenderer()
{
}
float ChickenRenderer::getBob(Mob*, float)
{
// TODO
return 0.0f;
}

18
source/client/renderer/entity/ChickenRenderer.hpp Normal file
View File

@@ -0,0 +1,18 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "MobRenderer.hpp"
class ChickenRenderer : public MobRenderer
{
public:
ChickenRenderer(Model*, float);
~ChickenRenderer();
float getBob(Mob*, float);
};

16
source/client/renderer/entity/CowRenderer.cpp Normal file
View File

@@ -0,0 +1,16 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "CowRenderer.hpp"
CowRenderer::CowRenderer(Model* pModel, float f) : MobRenderer(pModel, f)
{
}
CowRenderer::~CowRenderer()
{
}

17
source/client/renderer/entity/CowRenderer.hpp Normal file
View File

@@ -0,0 +1,17 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "MobRenderer.hpp"
class CowRenderer : public MobRenderer
{
public:
CowRenderer(Model*, float);
~CowRenderer();
};

27
source/client/renderer/entity/CreeperRenderer.cpp Normal file
View File

@@ -0,0 +1,27 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "CreeperRenderer.hpp"
CreeperRenderer::CreeperRenderer(Model* pModel, float f) : MobRenderer(pModel, f)
{
}
CreeperRenderer::~CreeperRenderer()
{
}
int CreeperRenderer::getOverlayColor(Mob* pMob, float a, float b)
{
// TODO
return 0;
}
void CreeperRenderer::scale(Mob* pMob, float f)
{
// TODO
}

20
source/client/renderer/entity/CreeperRenderer.hpp Normal file
View File

@@ -0,0 +1,20 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "MobRenderer.hpp"
class CreeperRenderer : public MobRenderer
{
public:
CreeperRenderer(Model*, float);
~CreeperRenderer();
int getOverlayColor(Mob*, float, float) override;
void scale(Mob*, float) override;
};

55
source/client/renderer/entity/EntityRenderDispatcher.cpp
View File

@@ -10,11 +10,20 @@
#include "client/app/Minecraft.hpp"
#include "../ItemInHandRenderer.hpp"
#include "client/model/PigModel.hpp"
#include "client/model/CowModel.hpp"
#include "client/model/ChickenModel.hpp"
#include "client/model/CreeperModel.hpp"
EntityRenderDispatcher* EntityRenderDispatcher::instance;
float EntityRenderDispatcher::xOff, EntityRenderDispatcher::yOff, EntityRenderDispatcher::zOff;
EntityRenderDispatcher::EntityRenderDispatcher() :
m_HumanoidMobRenderer(new HumanoidModel(0.0f, 0.0f), 0.0f)
m_HumanoidMobRenderer(new HumanoidModel(0.0f, 0.0f), 0.0f),
m_PigRenderer(new PigModel(0.0f), 0.0f),
m_CowRenderer(new CowModel, 0.0f),
m_ChickenRenderer(new ChickenModel, 0.0f),
m_CreeperRenderer(new CreeperModel, 0.5f)
{
m_pItemInHandRenderer = nullptr;
m_pTextures = nullptr;
@@ -27,14 +36,16 @@ EntityRenderDispatcher::EntityRenderDispatcher() :
m_pFont = nullptr;
m_HumanoidMobRenderer.init(this);
m_PigRenderer.init(this);
m_CowRenderer.init(this);
m_ChickenRenderer.init(this);
m_CreeperRenderer.init(this);
// TODO
m_TntRenderer.init(this);
m_CameraRenderer.init(this);
#ifndef ORIGINAL_CODE
// @BUG: Not initializing the item renderer would cause crashes if item7
// entities exist, because it references the dispatcher
m_ItemRenderer.init(this);
#endif
#ifdef ENH_ALLOW_SAND_GRAVITY
m_FallingTileRenderer.init(this);
@@ -63,18 +74,27 @@ EntityRenderDispatcher* EntityRenderDispatcher::getInstance()
return instance;
}
EntityRenderer* EntityRenderDispatcher::getRenderer(Entity* pEnt)
EntityRenderer* EntityRenderDispatcher::getRenderer(int renderType)
{
switch (pEnt->m_renderType)
switch (renderType)
{
case RENDER_TNT:
return &m_TntRenderer;
case RENDER_HUMANOID:
return &m_HumanoidMobRenderer;
case RENDER_ITEM:
return &m_ItemRenderer;
case RENDER_CAMERA:
return &m_CameraRenderer;
case RENDER_HUMANOID:
return &m_HumanoidMobRenderer;
case RENDER_CHICKEN:
return &m_ChickenRenderer;
case RENDER_COW:
return &m_CowRenderer;
case RENDER_PIG:
return &m_PigRenderer;
case RENDER_CREEPER:
return &m_CreeperRenderer;
// TODO
#ifdef ENH_ALLOW_SAND_GRAVITY
case RENDER_FALLING_TILE:
return &m_FallingTileRenderer;
@@ -84,6 +104,15 @@ EntityRenderer* EntityRenderDispatcher::getRenderer(Entity* pEnt)
return nullptr;
}
EntityRenderer* EntityRenderDispatcher::getRenderer(Entity* pEnt)
{
int renderType = pEnt->m_renderType;
if (renderType == RENDER_DYNAMIC)
renderType = pEnt->queryEntityRenderer();
return getRenderer(renderType);
}
void EntityRenderDispatcher::onGraphicsReset()
{
m_HumanoidMobRenderer.onGraphicsReset();
@@ -122,10 +151,10 @@ void EntityRenderDispatcher::render(Entity* entity, float a, float b, float c, f
if (pRenderer)
{
#ifndef ORIGINAL_CODE
if (pRenderer == &m_HumanoidRenderer)
m_HumanoidRenderer.m_pHumanoidModel->field_10BE = entity->isSneaking();
if (pRenderer == &m_HumanoidMobRenderer)
m_HumanoidMobRenderer.m_pHumanoidModel->m_bSneaking = entity->isSneaking();
else
m_HumanoidRenderer.m_pHumanoidModel->field_10BE = false;
m_HumanoidMobRenderer.m_pHumanoidModel->m_bSneaking = false;
#endif
pRenderer->render(entity, a, b, c, d, e);

15
source/client/renderer/entity/EntityRenderDispatcher.hpp
View File

@@ -14,6 +14,10 @@
#include "TntRenderer.hpp"
#include "ItemRenderer.hpp"
#include "FallingTileRenderer.hpp"
#include "PigRenderer.hpp"
#include "CowRenderer.hpp"
#include "ChickenRenderer.hpp"
#include "CreeperRenderer.hpp"
class Minecraft;
class Font;
@@ -29,6 +33,7 @@ public:
float distanceToSqr(float x, float y, float z);
Font* getFont();
EntityRenderer* getRenderer(Entity* pEnt);
EntityRenderer* getRenderer(int renderType);
void onGraphicsReset();
void prepare(Level*, Textures*, Font*, Mob*, Options*, float);
void render(Entity*, float);
@@ -41,8 +46,18 @@ public:
public:
ItemInHandRenderer* m_pItemInHandRenderer;
HumanoidMobRenderer m_HumanoidMobRenderer;
PigRenderer m_PigRenderer;
CowRenderer m_CowRenderer;
ChickenRenderer m_ChickenRenderer;
TntRenderer m_TntRenderer;
//padding??
ItemRenderer m_ItemRenderer;
CreeperRenderer m_CreeperRenderer;
//SpiderRenderer m_SpiderRenderer;
//SkeletonRenderer m_SkeletonRenderer;
//ZombieRenderer m_ZombieRenderer;
//SheepRenderer m_SheepRenderer;
//SheepFurRenderer m_SheepFurRenderer;
TripodCameraRenderer m_CameraRenderer;
Textures* m_pTextures;
Level* m_pLevel;

4
source/client/renderer/entity/HumanoidMobRenderer.cpp
View File

@@ -30,7 +30,7 @@ void HumanoidMobRenderer::additionalRendering(Mob* mob, float f)
ItemInstance inst(itemID, 1, 0);
glPushMatrix();
m_pHumanoidModel->m_armL.translateTo(0.0625f);
m_pHumanoidModel->m_arm1.translateTo(0.0625f);
glTranslatef(-0.0625f, 0.4375f, 0.0625f);
if (itemID <= C_MAX_TILES && TileRenderer::canRender(Tile::tiles[itemID]->getRenderShape()))
{
@@ -69,5 +69,5 @@ void HumanoidMobRenderer::renderHand()
m_pHumanoidModel->field_4 = 0;
m_pHumanoidModel->setBrightness(m_pDispatcher->m_pMinecraft->m_pMobPersp->getBrightness(1.0f));
m_pHumanoidModel->setupAnim(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0625f);
m_pHumanoidModel->m_armL.render(0.0625f);
m_pHumanoidModel->m_arm1.render(0.0625f);
}

6
source/client/renderer/entity/MobRenderer.cpp
View File

@@ -83,9 +83,13 @@ void MobRenderer::render(Entity* entity, float x, float y, float z, float unused
glDisable(GL_CULL_FACE);
m_pModel->field_4 = getAttackAnim(pMob, f);
m_pModel->field_8 = false;
m_pModel->m_bIsBaby = pMob->isBaby();
if (m_pArmorModel)
{
m_pArmorModel->field_8 = m_pModel->field_8;
m_pArmorModel->m_bIsBaby = m_pModel->m_bIsBaby;
}
float aYaw = pMob->field_5C + (pMob->m_yaw - pMob->field_5C) * f;
float aPitch = pMob->field_60 + (pMob->m_pitch - pMob->field_60) * f;
@@ -104,7 +108,7 @@ void MobRenderer::render(Entity* entity, float x, float y, float z, float unused
x1 = 1.0f;
float x2 = pMob->field_130 - pMob->field_12C * (1.0f - f);
bindTexture("mob/char.png");
bindTexture(pMob->getTexture());
glEnable(GL_ALPHA_TEST);
m_pModel->setBrightness(entity->getBrightness(1.0f));

16
source/client/renderer/entity/PigRenderer.cpp Normal file
View File

@@ -0,0 +1,16 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "PigRenderer.hpp"
PigRenderer::PigRenderer(Model* pModel, float f) : MobRenderer(pModel, f)
{
}
PigRenderer::~PigRenderer()
{
}

17
source/client/renderer/entity/PigRenderer.hpp Normal file
View File

@@ -0,0 +1,17 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "MobRenderer.hpp"
class PigRenderer : public MobRenderer
{
public:
PigRenderer(Model*, float);
~PigRenderer();
};

0
source/client/renderer/entity/SheepFurRenderer.cpp Normal file
View File

0
source/client/renderer/entity/SheepFurRenderer.hpp Normal file
View File

0
source/client/renderer/entity/SheepRenderer.cpp Normal file
View File

0
source/client/renderer/entity/SheepRenderer.hpp Normal file
View File

0
source/client/renderer/entity/SkeletonRenderer.cpp Normal file
View File

0
source/client/renderer/entity/SkeletonRenderer.hpp Normal file
View File

0
source/client/renderer/entity/SpiderRenderer.cpp Normal file
View File

0
source/client/renderer/entity/SpiderRenderer.hpp Normal file
View File

16
source/client/renderer/entity/TripodCameraRenderer.cpp
View File

@@ -11,10 +11,10 @@
TripodCameraRenderer::TripodCameraRenderer() :
m_tile(),
m_cube(0, 0)
m_modelPart(0, 0)
{
m_cube.addBox(-4.0f, -4.0f, -6.0f, 8, 8, 10);
m_cube.m_posY = 11.0f;
m_modelPart.addBox(-4.0f, -4.0f, -6.0f, 8, 8, 10);
m_modelPart.m_posY = 11.0f;
field_4 = 0.5f;
}
@@ -30,8 +30,8 @@ void TripodCameraRenderer::render(Entity* entity, float x, float y, float z, flo
{
glPushMatrix();
glTranslatef(x, y, z);
m_cube.m_rotX = 0.017453f * (180.0f + 0.5f * entity->m_pitch);
m_cube.m_rotY = -0.017453f * entity->m_yaw;
m_modelPart.m_rotX = 0.017453f * (180.0f + 0.5f * entity->m_pitch);
m_modelPart.m_rotY = -0.017453f * entity->m_yaw;
Tesselator& t = Tesselator::instance;
t.color(1.0f, 1.0f, 1.0f);
@@ -45,8 +45,8 @@ void TripodCameraRenderer::render(Entity* entity, float x, float y, float z, flo
t.draw();
bindTexture("item/camera.png");
m_cube.setBrightness(brightness);
m_cube.render(0.0625f);
m_modelPart.setBrightness(brightness);
m_modelPart.render(0.0625f);
Entity* pHREntity = m_pDispatcher->m_pMinecraft->m_hitResult.m_pEnt;
@@ -64,7 +64,7 @@ void TripodCameraRenderer::render(Entity* entity, float x, float y, float z, flo
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// @TODO FIX: With ENH_ENTITY_SHADING on, the cube is fully opaque.
glColor4f(0.5f, 0.5f, 0.5f, 0.5f);
m_cube.render(0.0625f);
m_modelPart.renderHorrible(0.0625f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_BLEND);
glEnable(GL_TEXTURE_2D);

2
source/client/renderer/entity/TripodCameraRenderer.hpp
View File

@@ -32,6 +32,6 @@ public:
public:
TileRenderer m_renderer;
TripodTile m_tile;
Cube m_cube;
ModelPart m_modelPart;
};

0
source/client/renderer/entity/ZombieRenderer.cpp Normal file
View File

0
source/client/renderer/entity/ZombieRenderer.hpp Normal file
View File

2
source/world/CMakeLists.txt
View File

@@ -3,7 +3,7 @@ add_library(reminecraftpe-world STATIC
entity/FallingTile.cpp entity/FallingTile.hpp
entity/ItemEntity.cpp entity/ItemEntity.hpp
entity/Mob.cpp entity/Mob.hpp
entity/Pig.cpp entity/Pig.hpp
#entity/Pig.cpp entity/Pig.hpp
entity/Player.cpp entity/Player.hpp
entity/PrimedTnt.cpp entity/PrimedTnt.hpp
entity/TripodCamera.cpp entity/TripodCamera.hpp

7
source/world/entity/Entity.cpp
View File

@@ -1068,6 +1068,13 @@ void Entity::lavaHurt()
}
}
int Entity::queryEntityRenderer()
{
// If field_C8 is equal to RENDER_DYNAMIC, EntityRenderDispatcher
// calls here. Used for sheared sheep.
return 0;
}
int Entity::hashCode()
{
return m_EntityID;

11
source/world/entity/Entity.hpp
View File

@@ -23,10 +23,20 @@ class Model;
enum eEntityRenderType
{
RENDER_NONE,
RENDER_DYNAMIC,
RENDER_TNT,
RENDER_HUMANOID,
RENDER_ITEM,
RENDER_CAMERA,
RENDER_CHICKEN,
RENDER_COW,
RENDER_PIG,
RENDER_SHEEP,
RENDER_SHEEP_FUR,
RENDER_ZOMBIE,
RENDER_SKELETON,
RENDER_SPIDER,
RENDER_CREEPER,
// custom
RENDER_FALLING_TILE = 50,
@@ -140,6 +150,7 @@ public:
virtual void markHurt();
virtual void burn(int);
virtual void lavaHurt();
virtual int queryEntityRenderer();
virtual bool isLocalPlayer();

7
source/world/entity/Mob.cpp
View File

@@ -57,7 +57,7 @@ Mob::Mob(Level* pLevel) : Entity(pLevel)
field_B84 = 0;
m_pEntLookedAt = nullptr;
m_texture = "/mob/char.png";
m_texture = "/mob/pig.png";
m_class = "";
field_34 = 1;
@@ -744,6 +744,11 @@ int Mob::getMaxSpawnClusterSize()
return 4;
}
bool Mob::isBaby()
{
return false;
}
void Mob::actuallyHurt(int damage)
{
#ifdef TEST_SURVIVAL_MODE

1
source/world/entity/Mob.hpp
View File

@@ -62,6 +62,7 @@ public:
virtual Vec3 getLookAngle(float f);
virtual Vec3 getViewVector(float f);
virtual int getMaxSpawnClusterSize();
virtual bool isBaby();
virtual void actuallyHurt(int damage);
virtual bool removeWhenFarAway();
virtual int getDeathLoot();

2
source/world/item/CameraItem.cpp
View File

@@ -23,6 +23,6 @@ ItemInstance* CameraItem::use(ItemInstance* inst, Level* level, Player* player)
return inst;
#endif
level->addEntity(new Pig(level, player->m_pos.x, player->m_pos.y, player->m_pos.z)); //(new TripodCamera(level, player, player->m_pos.x, player->m_pos.y, player->m_pos.z));
level->addEntity(new TripodCamera(level, player, player->m_pos.x, player->m_pos.y, player->m_pos.z)); //(new TripodCamera(level, player, player->m_pos.x, player->m_pos.y, player->m_pos.z));
return inst;
}

103
source/world/level/path/BinaryHeap.cpp Normal file
View File

@@ -0,0 +1,103 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include <climits>
#include "BinaryHeap.hpp"
#include "common/Mth.hpp"
void BinaryHeap::insert(Node* pNode)
{
if (m_count == m_capacity)
{
m_capacity *= 2;
Node** newItems = new Node * [m_capacity];
for (int i = 0; i < m_count; i++)
{
newItems[i] = m_items[i];
}
SAFE_DELETE_ARRAY(m_items);
m_items = newItems;
}
m_items[m_count] = pNode;
pNode->field_0 = m_count;
m_count++;
inlined0(m_count - 1);
}
void BinaryHeap::inlined0(int num)
{
Node* var2 = m_items[num];
int var4;
for (float var3 = var2->field_C; num > 0; num = var4) {
var4 = (num - 1) >> 1;
Node* var5 = m_items[var4];
if (var3 >= var5->field_C) {
break;
}
m_items[num] = var5;
var5->field_0 = num;
}
m_items[num] = var2;
var2->field_0 = num;
}
void BinaryHeap::downHeap(int num)
{
Node* var2 = m_items[num];
float var3 = var2->field_C;
while (true) {
int var4 = 1 + (num << 1);
int var5 = var4 + 1;
if (var4 >= m_count) {
break;
}
Node* var6 = m_items[var4];
float var7 = var6->field_C;
Node* var8;
float var9;
if (var5 >= m_count) {
var8 = nullptr;
var9 = INFINITY;
}
else {
var8 = m_items[var5];
var9 = var8->field_C;
}
if (var7 < var9) {
if (var7 >= var3) {
break;
}
m_items[num] = var6;
var6->field_0 = num;
num = var4;
}
else {
if (var9 >= var3) {
break;
}
m_items[num] = var8;
var8->field_0 = num;
num = var5;
}
}
m_items[num] = var2;
var2->field_0 = num;
}

66
source/world/level/path/BinaryHeap.hpp Normal file
View File

@@ -0,0 +1,66 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "Node.hpp"
class BinaryHeap
{
public:
BinaryHeap()
{
m_count = 0;
m_capacity = 1024;
m_items = new Node*[m_capacity];
}
~BinaryHeap()
{
if (m_items)
delete[] m_items;
}
void insert(Node* pNode);
void inlined0(int i);
void downHeap(int i);
Node* removeTop() {
Node* pNode = m_items[0];
m_items[0] = m_items[--m_count];
m_items[m_count] = 0;
if (m_count > 0)
downHeap(0);
pNode->field_0 = -1;
return pNode;
}
void clear() {
m_count = 0;
}
int size() const {
return m_count;
}
void setDistance(Node* pNode, float distance) {
float oldDistance = pNode->field_C;
pNode->field_C = distance;
if (oldDistance >= distance)
downHeap(pNode->field_0);
else
inlined0(pNode->field_0);
}
private:
Node** m_items;
int m_count;
int m_capacity;
};

17
source/world/level/path/Node.cpp Normal file
View File

@@ -0,0 +1,17 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "Node.hpp"
#include "common/Mth.hpp"
float Node::distanceTo(Node* node)
{
float dx = node->m_x - m_x;
float dy = node->m_y - m_y;
float dz = node->m_z - m_z;
return Mth::sqrt(dx * dx + dy * dy + dz * dz);
}

60
source/world/level/path/Node.hpp Normal file
View File

@@ -0,0 +1,60 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
struct Node
{
int field_0;
float field_4;
float field_8;
float field_C;
Node* field_10;
short m_x;
short m_y;
short m_z;
bool field_1A;
int m_hash;
Node()
{
init();
}
void setPos(int x, int y, int z)
{
m_x = short(x);
m_y = short(y);
m_z = short(z);
}
void setHash(int index)
{
m_hash = index;
}
void init()
{
field_0 = -1;
field_4 = 0.0f;
field_8 = 0.0f;
field_C = 0.0f;
field_10 = nullptr;
m_x = 0;
m_y = 0;
m_z = 0;
field_1A = false;
m_hash = 0;
}
bool equals(Node* node)
{
return m_hash == node->m_hash && m_x == node->m_x && m_y == node->m_y && m_z == node->m_z;
}
float distanceTo(Node* node);
};

36
source/world/level/path/Path.cpp Normal file
View File

@@ -0,0 +1,36 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "Path.hpp"
Path::Path()
{
m_numNodes = 0;
m_pNodes = nullptr;
field_8 = 0;
}
Path::~Path()
{
clear();
}
void Path::setNodes(Node** pNodes, int nodeCount)
{
clear();
m_numNodes = nodeCount;
m_pNodes = pNodes;
for (int i = 0; i < nodeCount; i++)
{
// TODO: We are using the pNodes array for storage but duplicating the pNodes?
// This might cause a memory leak?
Node* oldNode = pNodes[i];
m_pNodes[i] = new Node;
*m_pNodes[i] = *oldNode;
}
}

39
source/world/level/path/Path.hpp Normal file
View File

@@ -0,0 +1,39 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include "Node.hpp"
class Path
{
public:
Path();
~Path();
void setNodes(Node** pNodes, int nodeCount);
void clear()
{
if (m_pNodes)
{
for (int i = 0; i < m_numNodes; i++)
delete m_pNodes[i];
delete[] m_pNodes;
}
m_pNodes = nullptr;
m_numNodes = 0;
field_8 = 0;
}
private:
int m_numNodes;
Node** m_pNodes;
int field_8;
};

320
source/world/level/path/PathFinder.cpp Normal file
View File

@@ -0,0 +1,320 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#include "PathFinder.hpp"
#include "world/level/Level.hpp"
#include "world/tile/DoorTile.hpp"
#include "world/entity/Entity.hpp"
static int dword_1CD868;
static int dword_1CD86C;
static int dword_1CD870;
constexpr int MakeNodeHash(int x, int y, int z)
{
// NOTE: Same as in Java Edition Beta 1.3_01
return (y & 0xFF) |
((x & 0x7FFF) << 8) |
((z & 0x7FFF) << 24) |
(x < 0 ? 0x80000000 : 0) |
(z < 0 ? 0x8000 : 0);
}
PathFinder::PathFinder()
{
m_pLevel = nullptr;
}
PathFinder::~PathFinder()
{
// NOTE: In v0.2.0, this is it. We're going to do more:
for (size_t i = 0; i < m_nodeSpillover.size(); i++)
delete m_nodeSpillover[i];
m_nodeSpillover.clear();
}
int PathFinder::isFree(Entity* pEntity, int x, int y, int z, const Node* node)
{
for (int x1 = x; x1 < x + node->m_x; x1++)
{
for (int y1 = y; y1 < y + node->m_y; y1++)
{
for (int z1 = z; z1 < z + node->m_z; z1++)
{
TileID id = m_pLevel->getTile(x1, y1, z1);
if (id < 0)
continue;
if (id == Tile::door_iron->m_ID || id == Tile::door_wood->m_ID)
{
if (!DoorTile::isOpen(m_pLevel->getData(x1, y1, z1)))
return 0;
continue;
}
Material* pMtl = Tile::tiles[id]->m_pMaterial;
if (pMtl->blocksMotion())
return 0;
if (pMtl == Material::water)
return -1;
if (pMtl == Material::lava)
return -2;
}
}
}
return 1; // Totally free!
}
Node* PathFinder::getNode(Entity* pEntity, int x, int y, int z, const Node* node, int a)
{
Node* pNode = nullptr;
if (isFree(pEntity, x, y, z, node) == 1)
pNode = getNode(x, y, z);
if (a > 0 && !pNode && isFree(pEntity, x, y + a, z, node) == 1)
{
y += a;
pNode = getNode(x, y, z);
}
if (!pNode || y < 0)
return nullptr;
int limit = y - 4;
while (true)
{
int is_free = isFree(pEntity, x, --y, z, node);
if (is_free != 1)
{
if (is_free == -2)
pNode = nullptr;
break;
}
if (y == limit)
{
pNode = nullptr;
break;
}
if (!y)
break;
pNode = getNode(x, y, z);
}
return pNode;
}
Node* PathFinder::getNode(int x, int y, int z)
{
NodeMap::iterator iter = m_nodeMap.find(MakeNodeHash(x, y, z));
if (iter != m_nodeMap.end())
return iter->second;
Node* pNode = new_Node(x, y, z);
dword_1CD868++;
m_nodeMap.insert_or_assign(MakeNodeHash(x, y, z), pNode);
return pNode;
}
int PathFinder::getNeighbors(Entity* pEntity, Node* node1, const Node* node2, Node* node3, float maxDist)
{
int nr = 0;
bool isf = isFree(pEntity, node1->m_x, node1->m_y, node1->m_z, node2) == 1;
Node* n1 = getNode(pEntity, node1->m_x, node1->m_y, node1->m_z + 1, node2, isf);
Node* n2 = getNode(pEntity, node1->m_x - 1, node1->m_y, node1->m_z, node2, isf);
Node* n3 = getNode(pEntity, node1->m_x + 1, node1->m_y, node1->m_z, node2, isf);
Node* n4 = getNode(pEntity, node1->m_x, node1->m_y, node1->m_z - 1, node2, isf);
if (n1 && !n1->field_1A && n1->distanceTo(node3) < maxDist) field_10038[nr++] = n1;
if (n2 && !n2->field_1A && n2->distanceTo(node3) < maxDist) field_10038[nr++] = n2;
if (n3 && !n3->field_1A && n3->distanceTo(node3) < maxDist) field_10038[nr++] = n3;
if (n4 && !n4->field_1A && n4->distanceTo(node3) < maxDist) field_10038[nr++] = n4;
return nr;
}
bool PathFinder::inlined_0(Path& path, Node* nodeEnd)
{
if (dword_1CD870 < dword_1CD868)
dword_1CD870 = dword_1CD868;
int number = 1;
Node* temp = nodeEnd;
while (temp->field_10)
{
temp = temp->field_10;
number++;
}
Node** pathNodes = new Node*[number];
int index = number - 1;
pathNodes[index--] = nodeEnd;
while (nodeEnd->field_10)
{
pathNodes[index--] = nodeEnd->field_10;
nodeEnd = nodeEnd->field_10;
}
path.setNodes(pathNodes, number);
return true;
}
bool PathFinder::findPath(Path& path, Entity* pEntity, Node* nodeStart, Node* nodeEnd, const Node* node3, float fp)
{
dword_1CD868 = 0;
nodeStart->field_4 = 0;
nodeStart->field_C = nodeStart->field_8 = nodeStart->distanceTo(nodeEnd);
m_binaryHeap.clear();
m_binaryHeap.insert(nodeStart);
Node* nodep = nodeStart;
while (true)
{
if (!m_binaryHeap.size())
break;
Node* pNode = m_binaryHeap.removeTop();
if (pNode->equals(nodeEnd))
return inlined_0(path, nodeEnd);
if (nodep->distanceTo(nodeEnd) > pNode->distanceTo(nodeEnd))
nodep = pNode;
pNode->field_1A = true;
int numNeighbors = getNeighbors(pEntity, pNode, node3, nodeEnd, fp);
for (int i = 0; i < numNeighbors; i++)
{
Node* otherNode = field_10038[i];
if (!otherNode->field_1A)
{
float dist = pNode->field_4 + pNode->distanceTo(otherNode);
if (otherNode->field_0 < 0 || otherNode->field_4 > dist)
{
otherNode->field_10 = pNode;
otherNode->field_4 = dist;
otherNode->field_8 = otherNode->distanceTo(nodeEnd);
if (otherNode->field_0 < 0)
{
otherNode->field_C = otherNode->field_4 + otherNode->field_8;
m_binaryHeap.insert(otherNode);
}
else
{
// Update distance
m_binaryHeap.setDistance(otherNode, otherNode->field_4 + otherNode->field_8);
}
}
}
}
}
if (nodep != nodeStart)
return inlined_0(path, nodeEnd);
return false; // no path found
}
bool PathFinder::findPath(Path& path, Entity* pEntity, float x, float y, float z, float d)
{
// uh?
m_nodeMap.clear();
m_nodeCount = 0;
// not treating spillover btw? or what
int x1 = Mth::floor(pEntity->m_hitbox.min.x);
int y1 = Mth::floor(pEntity->m_hitbox.min.y);
int z1 = Mth::floor(pEntity->m_hitbox.min.z);
Node* node1 = getNode(x1, y1, z1);
int x2 = Mth::floor(x - 0.5f * pEntity->field_88);
int y2 = Mth::floor(y);
int z2 = Mth::floor(z - 0.5f * pEntity->field_88);
Node* node2 = nullptr;
if (!m_pLevel->getTile(x2, y2 - 1, z2))
{
for (int x3 = x2; x3 <= Mth::floor(x + 0.5f * pEntity->field_88); x3++)
{
for (int z3 = z2; z3 <= Mth::floor(y + 0.5f * pEntity->field_88); z3++)
{
if (m_pLevel->getTile(x3, y2 - 1, z3))
{
node2 = getNode(x3, y2, z3);
break; // breaking out of the z3 loop only. Intended to break out of x3 too?
}
}
}
}
if (!node2)
node2 = getNode(x2, y2, z2);
int x4 = Mth::floor(pEntity->field_88 + 1.0f);
int y4 = Mth::floor(pEntity->field_8C + 1.0f);
int z4 = Mth::floor(pEntity->field_88 + 1.0f);
Node node3;
node3.setPos(x4, y4, z4);
node3.setHash(MakeNodeHash(x4, y4, z4));
bool foundPath = findPath(path, pEntity, node1, node2, &node3, d);
if (m_nodeCount > 2048)
{
// huh.
for (size_t i = 0; i < m_nodeSpillover.size(); i++)
delete m_nodeSpillover[i];
m_nodeSpillover.clear();
}
return foundPath;
}
Node* PathFinder::new_Node(int x, int y, int z)
{
int nodeID = m_nodeCount++;
Node* pNode;
if (m_nodeCount < MAX_NODE_COUNT)
{
// Allocate from node reserve
pNode = &m_nodeReserve[nodeID];
pNode->init();
pNode->setPos(x, y, z);
pNode->setHash(MakeNodeHash(x, y, z));
}
else
{
pNode = new Node;
pNode->setPos(x, y, z);
pNode->setHash(MakeNodeHash(x, y, z));
m_nodeSpillover.push_back(pNode);
}
return pNode;
}

48
source/world/level/path/PathFinder.hpp Normal file
View File

@@ -0,0 +1,48 @@
/********************************************************************
Minecraft: Pocket Edition - Decompilation Project
Copyright (C) 2023 iProgramInCpp
The following code is licensed under the BSD 1 clause license.
SPDX-License-Identifier: BSD-1-Clause
********************************************************************/
#pragma once
#include <vector>
#include <map>
#include "Path.hpp"
#include "BinaryHeap.hpp"
class Level;
class Entity;
#define MAX_NODE_COUNT (2048)
#define FIELD_10038_SIZE (32)
typedef std::map <int, Node*> NodeMap;
class PathFinder
{
public:
PathFinder();
~PathFinder();
int isFree(Entity*, int x, int y, int z, const Node* node);
Node* getNode(Entity*, int x, int y, int z, const Node* node, int a);
Node* getNode(int x, int y, int z);
int getNeighbors(Entity*, Node*, const Node*, Node*, float);
bool findPath(Path&, Entity*, Node*, Node*, const Node*, float);
bool findPath(Path&, Entity*, float, float, float, float);
private:
Node* new_Node(int x, int y, int z);
bool inlined_0(Path& path, Node* node2);
private:
Level* m_pLevel;
BinaryHeap m_binaryHeap;
NodeMap m_nodeMap;
Node m_nodeReserve[MAX_NODE_COUNT];
std::vector<Node*> m_nodeSpillover;
int m_nodeCount;
Node* field_10038[FIELD_10038_SIZE];
};

4
source/world/tile/DoorTile.hpp
View File

@@ -39,11 +39,11 @@ public:
#pragma GCC diagnostic pop
// @NOTE: These are inlined.
inline bool isOpen(int data)
inline static bool isOpen(int data)
{
return (data & 4) != 0;
}
inline bool isTop(int data)
inline static bool isTop(int data)
{
return (data & 8) != 0;
}