mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/LCEMP-Server.git
synced 2026-05-22 06:06:47 +00:00
780 lines
38 KiB
C++
780 lines
38 KiB
C++
|
|
#include "stdafx.h"
|
|
|
|
#include "../../Minecraft.World/Dimension.h"
|
|
#include "../../Minecraft.World/ChunkSource.h"
|
|
#include "../../Minecraft.Client/Windows64/4JLibs/inc/4J_Input.h"
|
|
#include "../../Minecraft.Client/Windows64/4JLibs/inc/4J_Storage.h"
|
|
#include "../../Minecraft.Client/TexturePackRepository.h"
|
|
#include "../../Minecraft.Client/LevelRenderer.h"
|
|
#include "../../Minecraft.Client/Textures.h"
|
|
#include "../../Minecraft.Client/Font.h"
|
|
#include "../../Minecraft.Client/Gui.h"
|
|
#include "../../Minecraft.Client/ScreenSizeCalculator.h"
|
|
#include "../../Minecraft.Client/Timer.h"
|
|
#include "../../Minecraft.Client/HumanoidModel.h"
|
|
#include "../../Minecraft.Client/ParticleEngine.h"
|
|
#include "../../Minecraft.Client/Tesselator.h"
|
|
#include "../../Minecraft.Client/ItemInHandRenderer.h"
|
|
#include "../../Minecraft.Client/EntityRenderDispatcher.h"
|
|
#include "../../Minecraft.Client/TileEntityRenderDispatcher.h"
|
|
#include "../../Minecraft.Client/GuiParticles.h"
|
|
#include "../../Minecraft.Client/TitleScreen.h"
|
|
#include "../../Minecraft.Client/AchievementPopup.h"
|
|
#include "../../Minecraft.Client/Input.h"
|
|
#include "../../Minecraft.Client/TextureManager.h"
|
|
#include "../../Minecraft.Client/TileRenderer.h"
|
|
#include "../../Minecraft.Client/Chunk.h"
|
|
class EnderDragon;
|
|
#include "../../Minecraft.Client/EnderDragonRenderer.h"
|
|
#include "../../Minecraft.Client/GameRenderer.h"
|
|
#include "../../Minecraft.Client/GameMode.h"
|
|
#include "../../Minecraft.Client/KeyMapping.h"
|
|
#include "../../Minecraft.Client/ArchiveFile.h"
|
|
#include "../../Minecraft.Client/BufferedImage.h"
|
|
#include "../../Minecraft.Client/Lighting.h"
|
|
#include "../../Minecraft.Client/Model.h"
|
|
#include "../../Minecraft.Client/OffsettedRenderList.h"
|
|
#include "../../Minecraft.Client/Common/Audio/SoundEngine.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIController.h"
|
|
#include "../../Minecraft.Client/Windows64/Windows64_UIController.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIControl_Progress.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIControl_Label.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIControl_Button.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIScene_FullscreenProgress.h"
|
|
#include "../../Minecraft.Client/Common/UI/IUIScene_PauseMenu.h"
|
|
#include "../../Minecraft.Client/Common/UI/IUIScene_CreativeMenu.h"
|
|
#include "../../Minecraft.Client/Common/UI/IUIScene_TradingMenu.h"
|
|
#include "../../Minecraft.Client/Common/UI/IUIScene_CraftingMenu.h"
|
|
#include "../../Minecraft.Client/Common/UI/UIFontData.h"
|
|
#include "../../Minecraft.Client/Particle.h"
|
|
#include "../../Minecraft.Client/CritParticle.h"
|
|
#include "../../Minecraft.Client/TakeAnimationParticle.h"
|
|
#include "../../Minecraft.Client/Screen.h"
|
|
#include "../../Minecraft.Client/GuiComponent.h"
|
|
|
|
C_4JInput InputManager;
|
|
wchar_t g_Win64UsernameW[17] = L"Server";
|
|
char g_Win64Username[17] = "Server";
|
|
HWND g_hWnd = NULL;
|
|
|
|
bool TileRenderer::fancy = false;
|
|
EntityRenderDispatcher *EntityRenderDispatcher::instance = NULL;
|
|
TileEntityRenderDispatcher *TileEntityRenderDispatcher::instance = NULL;
|
|
int Chunk::updates = 0;
|
|
LevelRenderer *Chunk::levelRenderer = NULL;
|
|
shared_ptr<EnderDragon> EnderDragonRenderer::bossInstance;
|
|
int EnderDragonRenderer::currentModel = 0;
|
|
|
|
double EntityRenderDispatcher::xOff = 0;
|
|
double EntityRenderDispatcher::yOff = 0;
|
|
double EntityRenderDispatcher::zOff = 0;
|
|
|
|
double TileEntityRenderDispatcher::xOff = 0;
|
|
double TileEntityRenderDispatcher::yOff = 0;
|
|
double TileEntityRenderDispatcher::zOff = 0;
|
|
|
|
bool Textures::MIPMAP = false;
|
|
C4JRender::eTextureFormat Textures::TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGyBzAw;
|
|
|
|
float Gui::currentGuiBlendFactor = 1.0f;
|
|
float Gui::currentGuiScaleFactor = 1.0f;
|
|
|
|
const int LevelRenderer::MAX_LEVEL_RENDER_SIZE[3] = { 356, 42, 18 };
|
|
const int LevelRenderer::DIMENSION_OFFSETS[3] = { 0, (356 * 356 * 16), (356 * 356 * 16) + (42 * 42 * 16) };
|
|
|
|
int ItemInHandRenderer::list = 0;
|
|
int ItemInHandRenderer::listGlint = 0;
|
|
|
|
TexturePack *TexturePackRepository::DEFAULT_TEXTURE_PACK = NULL;
|
|
|
|
FloatBuffer *Lighting::lb = NULL;
|
|
|
|
void C_4JInput::Tick() {}
|
|
unsigned int C_4JInput::GetGameJoypadMaps(unsigned char, unsigned char) { return 0; }
|
|
unsigned char C_4JInput::GetJoypadMapVal(int) { return 0; }
|
|
void C_4JInput::SetJoypadMapVal(int, unsigned char) {}
|
|
unsigned int C_4JInput::GetValue(int, unsigned char, bool) { return 0; }
|
|
bool C_4JInput::ButtonPressed(int, unsigned char) { return false; }
|
|
bool C_4JInput::ButtonReleased(int, unsigned char) { return false; }
|
|
bool C_4JInput::ButtonDown(int, unsigned char) { return false; }
|
|
bool C_4JInput::IsPadConnected(int) { return false; }
|
|
float C_4JInput::GetJoypadStick_LX(int, bool) { return 0.0f; }
|
|
float C_4JInput::GetJoypadStick_LY(int, bool) { return 0.0f; }
|
|
float C_4JInput::GetJoypadStick_RX(int, bool) { return 0.0f; }
|
|
float C_4JInput::GetJoypadStick_RY(int, bool) { return 0.0f; }
|
|
float C_4JInput::GetIdleSeconds(int) { return 0.0f; }
|
|
void C_4JInput::SetJoypadStickAxisMap(int, unsigned int, unsigned int) {}
|
|
void C_4JInput::SetJoypadStickTriggerMap(int, unsigned int, unsigned int) {}
|
|
void C_4JInput::SetDebugSequence(const char *, int (*)(LPVOID), LPVOID) {}
|
|
void C_4JInput::SetMenuDisplayed(int, bool) {}
|
|
|
|
void glTranslatef(float, float, float) {}
|
|
void glRotatef(float, float, float, float) {}
|
|
void glScalef(float, float, float) {}
|
|
void glPushMatrix() {}
|
|
void glPopMatrix() {}
|
|
void glEnable(int) {}
|
|
void glDisable(int) {}
|
|
void glDepthFunc(int) {}
|
|
void glMatrixMode(int) {}
|
|
void glLoadIdentity() {}
|
|
void glBindTexture(int, int) {}
|
|
void glShadeModel(int) {}
|
|
void glLineWidth(float) {}
|
|
void glClear(int) {}
|
|
void glViewport(int, int, int, int) {}
|
|
void glAlphaFunc(int, float) {}
|
|
void glOrtho(float, float, float, float, float, float) {}
|
|
void glClearColor(float, float, float, float) {}
|
|
void glBlendFunc(int, int) {}
|
|
void glDeleteTextures(int) {}
|
|
void glDeleteTextures(IntBuffer *) {}
|
|
void glDepthMask(bool) {}
|
|
void glColor4f(float, float, float, float) {}
|
|
void glColor3f(float, float, float) {}
|
|
void glNormal3f(float, float, float) {}
|
|
void glNewList(int, int) {}
|
|
void glEndList(int) {}
|
|
void glCallList(int) {}
|
|
void glCallLists(IntBuffer *) {}
|
|
void glDrawArrays(int, int, int) {}
|
|
void glTexCoordPointer(int, int, int, int) {}
|
|
void glTexCoordPointer(int, int, FloatBuffer *) {}
|
|
void glNormalPointer(int, int, int) {}
|
|
void glNormalPointer(int, ByteBuffer *) {}
|
|
void glEnableClientState(int) {}
|
|
void glDisableClientState(int) {}
|
|
void glColorPointer(int, bool, int, ByteBuffer *) {}
|
|
void glColorPointer(int, int, int, int) {}
|
|
void glVertexPointer(int, int, int, int) {}
|
|
void glVertexPointer(int, int, FloatBuffer *) {}
|
|
void glMultMatrixf(float *) {}
|
|
void glTexParameteri(int, int, int) {}
|
|
int glGenTextures() { return 0; }
|
|
int glGenLists(int) { return 0; }
|
|
void glTexImage2D(int, int, int, int, int, int, int, int, ByteBuffer *) {}
|
|
void glColorMask(bool, bool, bool, bool) {}
|
|
void glGenQueriesARB(IntBuffer *) {}
|
|
void glBeginQueryARB(int, int) {}
|
|
void glEndQueryARB(int) {}
|
|
void glGetQueryObjectuARB(int, int, IntBuffer *) {}
|
|
void glPolygonOffset(float, float) {}
|
|
void glScaled(double, double, double) {}
|
|
void gluPerspective(float, float, float, float) {}
|
|
void glFogi(int, int) {}
|
|
void glFogf(int, float) {}
|
|
void glFog(int, FloatBuffer *) {}
|
|
void glColorMaterial(int, int) {}
|
|
void glMultiTexCoord2f(int, float, float) {}
|
|
void glClientActiveTexture(int) {}
|
|
void glActiveTexture(int) {}
|
|
|
|
void Display::update() {}
|
|
void Display::swapBuffers() {}
|
|
|
|
Textures::Textures(TexturePackRepository *, Options *) {}
|
|
int Textures::loadTexture(int) { return 0; }
|
|
void Textures::tick(bool, bool) {}
|
|
void Textures::reloadAll() {}
|
|
void Textures::stitch() {}
|
|
void Textures::bind(int) {}
|
|
int Textures::getTexture(BufferedImage *, C4JRender::eTextureFormat, bool) { return 0; }
|
|
void Textures::replaceTextureDirect(intArray, int, int, int) {}
|
|
void Textures::releaseTexture(int) {}
|
|
intArray Textures::loadTexturePixels(TEXTURE_NAME, const wstring &) { return intArray(); }
|
|
void Textures::bindTexture(const wstring &) {}
|
|
void Textures::bindTexture(int) {}
|
|
void Textures::clearLastBoundId() {}
|
|
void Textures::loadTexture(BufferedImage *, int) {}
|
|
void Textures::loadTexture(BufferedImage *, int, bool, bool) {}
|
|
void Textures::replaceTexture(intArray, int, int, int) {}
|
|
void Textures::replaceTextureDirect(shortArray, int, int, int) {}
|
|
int Textures::loadHttpTexture(const wstring &, const wstring &) { return 0; }
|
|
int Textures::loadHttpTexture(const wstring &, int) { return 0; }
|
|
bool Textures::hasHttpTexture(const wstring &) { return false; }
|
|
HttpTexture *Textures::addHttpTexture(const wstring &, HttpTextureProcessor *) { return NULL; }
|
|
void Textures::removeHttpTexture(const wstring &) {}
|
|
int Textures::loadMemTexture(const wstring &, const wstring &) { return 0; }
|
|
int Textures::loadMemTexture(const wstring &, int) { return 0; }
|
|
MemTexture *Textures::addMemTexture(const wstring &, MemTextureProcessor *) { return NULL; }
|
|
void Textures::removeMemTexture(const wstring &) {}
|
|
Icon *Textures::getMissingIcon(int) { return NULL; }
|
|
BufferedImage *Textures::readImage(TEXTURE_NAME, const wstring &) { return NULL; }
|
|
bool Textures::IsTUImage(TEXTURE_NAME, const wstring &) { return false; }
|
|
bool Textures::IsOriginalImage(TEXTURE_NAME, const wstring &) { return false; }
|
|
|
|
Font::Font(Options *, const wstring &, Textures *, bool, TEXTURE_NAME, int, int, int, int, unsigned short *) {}
|
|
#ifndef _XBOX
|
|
Font::~Font() {}
|
|
#endif
|
|
void Font::drawShadow(const wstring &, int, int, int) {}
|
|
void Font::drawShadowWordWrap(const wstring &, int, int, int, int, int) {}
|
|
void Font::draw(const wstring &, int, int, int) {}
|
|
void Font::renderFakeCB(IntBuffer *) {}
|
|
|
|
Gui::Gui(Minecraft *) {}
|
|
void Gui::render(float, bool, int, int) {}
|
|
void Gui::tick() {}
|
|
void Gui::clearMessages(int) {}
|
|
void Gui::addMessage(const wstring &, int, bool) {}
|
|
void Gui::setNowPlaying(const wstring &) {}
|
|
void Gui::displayClientMessage(int, int) {}
|
|
float Gui::getOpacity(int, DWORD) { return 0.0f; }
|
|
|
|
ScreenSizeCalculator::ScreenSizeCalculator(Options *, int, int, int) {}
|
|
int ScreenSizeCalculator::getWidth() { return 800; }
|
|
int ScreenSizeCalculator::getHeight() { return 600; }
|
|
|
|
Timer::Timer(float) {}
|
|
void Timer::advanceTime() {}
|
|
void Timer::advanceTimeQuickly() {}
|
|
void Timer::skipTime() {}
|
|
|
|
LevelRenderer::LevelRenderer(Minecraft *, Textures *) {}
|
|
void LevelRenderer::setLevel(int, MultiPlayerLevel *) {}
|
|
void LevelRenderer::allChanged() {}
|
|
void LevelRenderer::allChanged(int) {}
|
|
void LevelRenderer::tick() {}
|
|
void LevelRenderer::clear() {}
|
|
int LevelRenderer::render(shared_ptr<Mob>, int, double, bool) { return 0; }
|
|
void LevelRenderer::renderEntities(Vec3 *, Culler *, float) {}
|
|
void LevelRenderer::renderSky(float) {}
|
|
void LevelRenderer::renderClouds(float) {}
|
|
bool LevelRenderer::updateDirtyChunks() { return false; }
|
|
void LevelRenderer::renderHit(shared_ptr<Player>, HitResult *, int, shared_ptr<ItemInstance>, float) {}
|
|
void LevelRenderer::renderDestroyAnimation(Tesselator *, shared_ptr<Player>, float) {}
|
|
void LevelRenderer::renderHitOutline(shared_ptr<Player>, HitResult *, int, shared_ptr<ItemInstance>, float) {}
|
|
wstring LevelRenderer::gatherStats1() { return L""; }
|
|
wstring LevelRenderer::gatherStats2() { return L""; }
|
|
void LevelRenderer::setDirty(int, int, int, int, int, int, Level *) {}
|
|
void LevelRenderer::tileChanged(int, int, int) {}
|
|
void LevelRenderer::tileLightChanged(int, int, int) {}
|
|
void LevelRenderer::setTilesDirty(int, int, int, int, int, int, Level *) {}
|
|
void LevelRenderer::cull(Culler *, float) {}
|
|
void LevelRenderer::playStreamingMusic(const wstring &, int, int, int) {}
|
|
void LevelRenderer::playSound(int, double, double, double, float, float, float) {}
|
|
void LevelRenderer::playSound(shared_ptr<Entity>, int, double, double, double, float, float, float) {}
|
|
void LevelRenderer::addParticle(ePARTICLE_TYPE, double, double, double, double, double, double) {}
|
|
shared_ptr<Particle> LevelRenderer::addParticleInternal(ePARTICLE_TYPE, double, double, double, double, double, double) { return nullptr; }
|
|
void LevelRenderer::entityAdded(shared_ptr<Entity>) {}
|
|
void LevelRenderer::entityRemoved(shared_ptr<Entity>) {}
|
|
void LevelRenderer::skyColorChanged() {}
|
|
void LevelRenderer::levelEvent(shared_ptr<Player>, int, int, int, int, int) {}
|
|
void LevelRenderer::destroyTileProgress(int, int, int, int, int) {}
|
|
void LevelRenderer::registerTextures(IconRegister *) {}
|
|
void LevelRenderer::render(AABB *) {}
|
|
int LevelRenderer::activePlayers() { return 0; }
|
|
void LevelRenderer::renderSameAsLast(int, double) {}
|
|
void LevelRenderer::renderHaloRing(float) {}
|
|
bool LevelRenderer::isInCloud(double, double, double, float) { return false; }
|
|
void LevelRenderer::renderAdvancedClouds(float) {}
|
|
void LevelRenderer::AddDLCSkinsToMemTextures() {}
|
|
void LevelRenderer::fullyFlagRenderableTileEntitiesToBeRemoved() {}
|
|
|
|
int LevelRenderer::getDimensionIndexFromId(int id) { return (3 - id) % 3; }
|
|
|
|
int LevelRenderer::getGlobalIndexForChunk(int x, int y, int z, Level *level) {
|
|
return getGlobalIndexForChunk(x, y, z, level->dimension->id);
|
|
}
|
|
int LevelRenderer::getGlobalIndexForChunk(int x, int y, int z, int dimensionId) {
|
|
int dimIdx = getDimensionIndexFromId(dimensionId);
|
|
int xx = (x / CHUNK_XZSIZE) + (MAX_LEVEL_RENDER_SIZE[dimIdx] / 2);
|
|
int yy = y / CHUNK_SIZE;
|
|
int zz = (z / CHUNK_XZSIZE) + (MAX_LEVEL_RENDER_SIZE[dimIdx] / 2);
|
|
if ((xx < 0) || (xx >= MAX_LEVEL_RENDER_SIZE[dimIdx])) return -1;
|
|
if ((zz < 0) || (zz >= MAX_LEVEL_RENDER_SIZE[dimIdx])) return -1;
|
|
if ((yy < 0) || (yy >= CHUNK_Y_COUNT)) return -1;
|
|
int offset = DIMENSION_OFFSETS[dimIdx];
|
|
offset += (zz * MAX_LEVEL_RENDER_SIZE[dimIdx] + xx) * CHUNK_Y_COUNT;
|
|
offset += yy;
|
|
return offset;
|
|
}
|
|
bool LevelRenderer::isGlobalIndexInSameDimension(int idx, Level *level) {
|
|
int dim = getDimensionIndexFromId(level->dimension->id);
|
|
int idxDim = 0;
|
|
if (idx >= DIMENSION_OFFSETS[2]) idxDim = 2;
|
|
else if (idx >= DIMENSION_OFFSETS[1]) idxDim = 1;
|
|
return (dim == idxDim);
|
|
}
|
|
int LevelRenderer::getGlobalChunkCount() {
|
|
return (MAX_LEVEL_RENDER_SIZE[0] * MAX_LEVEL_RENDER_SIZE[0] * CHUNK_Y_COUNT) +
|
|
(MAX_LEVEL_RENDER_SIZE[1] * MAX_LEVEL_RENDER_SIZE[1] * CHUNK_Y_COUNT) +
|
|
(MAX_LEVEL_RENDER_SIZE[2] * MAX_LEVEL_RENDER_SIZE[2] * CHUNK_Y_COUNT);
|
|
}
|
|
int LevelRenderer::getGlobalChunkCountForOverworld() {
|
|
return (MAX_LEVEL_RENDER_SIZE[0] * MAX_LEVEL_RENDER_SIZE[0] * CHUNK_Y_COUNT);
|
|
}
|
|
bool LevelRenderer::getGlobalChunkFlag(int, int, int, Level *, unsigned char, unsigned char) { return false; }
|
|
void LevelRenderer::setGlobalChunkFlag(int, int, int, Level *, unsigned char, unsigned char) {}
|
|
void LevelRenderer::setGlobalChunkFlag(int, unsigned char, unsigned char) {}
|
|
void LevelRenderer::clearGlobalChunkFlag(int, int, int, Level *, unsigned char, unsigned char) {}
|
|
|
|
LevelRenderer::DestroyedTileManager::DestroyedTileManager() {}
|
|
LevelRenderer::DestroyedTileManager::~DestroyedTileManager() {}
|
|
void LevelRenderer::DestroyedTileManager::destroyingTileAt(Level *, int, int, int) {}
|
|
void LevelRenderer::DestroyedTileManager::updatedChunkAt(Level *, int, int, int, int) {}
|
|
void LevelRenderer::DestroyedTileManager::addAABBs(Level *, AABB *, AABBList *) {}
|
|
void LevelRenderer::DestroyedTileManager::tick() {}
|
|
|
|
ParticleEngine::ParticleEngine(Level *, Textures *) {}
|
|
ParticleEngine::~ParticleEngine() {}
|
|
void ParticleEngine::add(shared_ptr<Particle>) {}
|
|
void ParticleEngine::tick() {}
|
|
void ParticleEngine::render(shared_ptr<Entity>, float) {}
|
|
void ParticleEngine::renderLit(shared_ptr<Entity>, float) {}
|
|
void ParticleEngine::setLevel(Level *) {}
|
|
void ParticleEngine::destroy(int, int, int, int, int) {}
|
|
void ParticleEngine::crack(int, int, int, int) {}
|
|
wstring ParticleEngine::countParticles() { return L"0"; }
|
|
|
|
void GameRenderer::tick(bool) {}
|
|
void GameRenderer::pick(float) {}
|
|
void GameRenderer::render(float, bool) {}
|
|
void GameRenderer::AddForDelete(SparseLightStorage *) {}
|
|
void GameRenderer::AddForDelete(CompressedTileStorage *) {}
|
|
void GameRenderer::AddForDelete(SparseDataStorage *) {}
|
|
void GameRenderer::FinishedReassigning() {}
|
|
|
|
Tesselator *Tesselator::getInstance()
|
|
{
|
|
static char buffer[4096] = {};
|
|
return reinterpret_cast<Tesselator *>(buffer);
|
|
}
|
|
void Tesselator::CreateNewThreadStorage(int) {}
|
|
void Tesselator::end() {}
|
|
void Tesselator::begin() {}
|
|
void Tesselator::begin(int) {}
|
|
void Tesselator::useCompactVertices(bool) {}
|
|
bool Tesselator::getCompactVertices() { return false; }
|
|
void Tesselator::useProjectedTexture(bool) {}
|
|
void Tesselator::tex(float, float) {}
|
|
void Tesselator::tex2(int) {}
|
|
void Tesselator::color(float, float, float) {}
|
|
void Tesselator::color(float, float, float, float) {}
|
|
void Tesselator::color(int, int, int) {}
|
|
void Tesselator::color(int, int, int, int) {}
|
|
void Tesselator::color(byte, byte, byte) {}
|
|
void Tesselator::vertexUV(float, float, float, float, float) {}
|
|
void Tesselator::vertex(float, float, float) {}
|
|
void Tesselator::color(int) {}
|
|
void Tesselator::color(int, int) {}
|
|
void Tesselator::noColor() {}
|
|
void Tesselator::normal(float, float, float) {}
|
|
void Tesselator::offset(float, float, float) {}
|
|
void Tesselator::addOffset(float, float, float) {}
|
|
bool Tesselator::setMipmapEnable(bool) { return false; }
|
|
bool Tesselator::hasMaxVertices() { return false; }
|
|
|
|
HumanoidModel::HumanoidModel() {}
|
|
HumanoidModel::HumanoidModel(float) {}
|
|
HumanoidModel::HumanoidModel(float, float, int, int) {}
|
|
|
|
ItemInHandRenderer::ItemInHandRenderer(Minecraft *, bool) {}
|
|
void ItemInHandRenderer::itemPlaced() {}
|
|
void ItemInHandRenderer::itemUsed() {}
|
|
void ItemInHandRenderer::render(float) {}
|
|
void ItemInHandRenderer::tick() {}
|
|
|
|
void EntityRenderDispatcher::staticCtor() {}
|
|
EntityRenderer *EntityRenderDispatcher::getRenderer(eINSTANCEOF) { return NULL; }
|
|
EntityRenderer *EntityRenderDispatcher::getRenderer(shared_ptr<Entity>) { return NULL; }
|
|
void EntityRenderDispatcher::prepare(Level *, Textures *, Font *, shared_ptr<Mob>, Options *, float) {}
|
|
void EntityRenderDispatcher::render(shared_ptr<Entity>, float) {}
|
|
void EntityRenderDispatcher::render(shared_ptr<Entity>, double, double, double, float, float, bool, bool) {}
|
|
void EntityRenderDispatcher::setLevel(Level *) {}
|
|
double EntityRenderDispatcher::distanceToSqr(double, double, double) { return 0; }
|
|
Font *EntityRenderDispatcher::getFont() { return NULL; }
|
|
void EntityRenderDispatcher::registerTerrainTextures(IconRegister *) {}
|
|
|
|
void TileEntityRenderDispatcher::staticCtor() {}
|
|
TileEntityRenderer *TileEntityRenderDispatcher::getRenderer(eINSTANCEOF) { return NULL; }
|
|
bool TileEntityRenderDispatcher::hasRenderer(shared_ptr<TileEntity>) { return false; }
|
|
TileEntityRenderer *TileEntityRenderDispatcher::getRenderer(shared_ptr<TileEntity>) { return NULL; }
|
|
void TileEntityRenderDispatcher::prepare(Level *, Textures *, Font *, shared_ptr<Mob>, float) {}
|
|
void TileEntityRenderDispatcher::render(shared_ptr<TileEntity>, float, bool) {}
|
|
void TileEntityRenderDispatcher::render(shared_ptr<TileEntity>, double, double, double, float, bool, float, bool) {}
|
|
void TileEntityRenderDispatcher::setLevel(Level *) {}
|
|
double TileEntityRenderDispatcher::distanceToSqr(double, double, double) { return 0; }
|
|
Font *TileEntityRenderDispatcher::getFont() { return NULL; }
|
|
|
|
GuiParticles::GuiParticles(Minecraft *) {}
|
|
void GuiParticles::tick() {}
|
|
void GuiParticles::render(float) {}
|
|
|
|
TitleScreen::TitleScreen() {}
|
|
|
|
AchievementPopup::AchievementPopup(Minecraft *) {}
|
|
void AchievementPopup::render() {}
|
|
|
|
Input::Input() : xa(0), ya(0), wasJumping(false), jumping(false), sneaking(false), sprinting(false) {}
|
|
void Input::tick(LocalPlayer *) {}
|
|
|
|
void TextureManager::createInstance() {}
|
|
TextureManager *TextureManager::getInstance() { return NULL; }
|
|
|
|
void Lighting::turnOff() {}
|
|
void Lighting::turnOn() {}
|
|
void Lighting::turnOnGui() {}
|
|
|
|
TexturePackRepository::TexturePackRepository(File, Minecraft *) {}
|
|
void TexturePackRepository::addDebugPacks() {}
|
|
TexturePack *TexturePackRepository::getSelected() { return NULL; }
|
|
bool TexturePackRepository::selectTexturePackById(DWORD) { return false; }
|
|
TexturePack *TexturePackRepository::addTexturePackFromDLC(DLCPack *, DWORD) { return NULL; }
|
|
void TexturePackRepository::updateUI() {}
|
|
bool TexturePackRepository::needsUIUpdate() { return false; }
|
|
unsigned int TexturePackRepository::getTexturePackCount() { return 0; }
|
|
TexturePack *TexturePackRepository::getTexturePackByIndex(unsigned int) { return NULL; }
|
|
unsigned int TexturePackRepository::getTexturePackIndex(unsigned int) { return 0; }
|
|
TexturePack *TexturePackRepository::getTexturePackById(DWORD) { return NULL; }
|
|
void TexturePackRepository::clearInvalidTexturePacks() {}
|
|
void TexturePackRepository::updateList() {}
|
|
vector<TexturePack *> *TexturePackRepository::getAll() { return NULL; }
|
|
bool TexturePackRepository::selectSkin(TexturePack *) { return false; }
|
|
|
|
ArchiveFile::ArchiveFile(File) {}
|
|
ArchiveFile::~ArchiveFile() {}
|
|
bool ArchiveFile::hasFile(const wstring &) { return false; }
|
|
int ArchiveFile::getFileSize(const wstring &) { return 0; }
|
|
byteArray ArchiveFile::getFile(const wstring &) { return byteArray(); }
|
|
vector<wstring> *ArchiveFile::getFileList() { return NULL; }
|
|
|
|
KeyMapping::KeyMapping(const wstring &, int) {}
|
|
|
|
GameMode::GameMode(Minecraft *mc) : minecraft(mc), instaBuild(false) {}
|
|
void GameMode::initLevel(Level *) {}
|
|
bool GameMode::destroyBlock(int, int, int, int) { return false; }
|
|
void GameMode::render(float) {}
|
|
void GameMode::initPlayer(shared_ptr<Player>) {}
|
|
void GameMode::tick() {}
|
|
void GameMode::adjustPlayer(shared_ptr<Player>) {}
|
|
bool GameMode::useItem(shared_ptr<Player>, Level *, shared_ptr<ItemInstance>, bool) { return false; }
|
|
shared_ptr<Player> GameMode::createPlayer(Level *) { return nullptr; }
|
|
bool GameMode::interact(shared_ptr<Player>, shared_ptr<Entity>) { return false; }
|
|
void GameMode::attack(shared_ptr<Player>, shared_ptr<Entity>) {}
|
|
shared_ptr<ItemInstance> GameMode::handleInventoryMouseClick(int, int, int, bool, shared_ptr<Player>) { return nullptr; }
|
|
void GameMode::handleCloseInventory(int, shared_ptr<Player>) {}
|
|
void GameMode::handleInventoryButtonClick(int, int) {}
|
|
bool GameMode::isCutScene() { return false; }
|
|
void GameMode::releaseUsingItem(shared_ptr<Player>) {}
|
|
bool GameMode::hasExperience() { return false; }
|
|
bool GameMode::hasMissTime() { return false; }
|
|
bool GameMode::hasInfiniteItems() { return false; }
|
|
bool GameMode::hasFarPickRange() { return false; }
|
|
void GameMode::handleCreativeModeItemAdd(shared_ptr<ItemInstance>, int) {}
|
|
void GameMode::handleCreativeModeItemDrop(shared_ptr<ItemInstance>) {}
|
|
bool GameMode::handleCraftItem(int, shared_ptr<Player>) { return false; }
|
|
void GameMode::handleDebugOptions(unsigned int, shared_ptr<Player>) {}
|
|
|
|
BufferedImage::BufferedImage(int, int, int) { memset(data, 0, sizeof(data)); width = 0; height = 0; }
|
|
BufferedImage::BufferedImage(const wstring &, bool, bool, const wstring &) { memset(data, 0, sizeof(data)); width = 0; height = 0; }
|
|
BufferedImage::BufferedImage(DLCPack *, const wstring &, bool) { memset(data, 0, sizeof(data)); width = 0; height = 0; }
|
|
BufferedImage::BufferedImage(BYTE *, DWORD) { memset(data, 0, sizeof(data)); width = 0; height = 0; }
|
|
BufferedImage::~BufferedImage() {}
|
|
int BufferedImage::getWidth() { return width; }
|
|
int BufferedImage::getHeight() { return height; }
|
|
void BufferedImage::getRGB(int, int, int, int, intArray, int, int, int) {}
|
|
int *BufferedImage::getData() { return NULL; }
|
|
int *BufferedImage::getData(int) { return NULL; }
|
|
Graphics *BufferedImage::getGraphics() { return NULL; }
|
|
int BufferedImage::getTransparency() { return 0; }
|
|
BufferedImage *BufferedImage::getSubimage(int, int, int, int) { return NULL; }
|
|
void BufferedImage::preMultiplyAlpha() {}
|
|
|
|
void Windows64_UpdateGamma(unsigned short) {}
|
|
|
|
__int64 UIController::iggyAllocCount = 0;
|
|
CRITICAL_SECTION UIController::ms_reloadSkinCS;
|
|
bool UIController::ms_bReloadSkinCSInitialised = false;
|
|
DWORD UIController::m_dwTrialTimerLimitSecs = 0;
|
|
|
|
UIController::UIController()
|
|
{
|
|
m_uiDebugConsole = NULL;
|
|
m_uiDebugMarketingGuide = NULL;
|
|
memset(&m_navigationLock, 0, sizeof(m_navigationLock));
|
|
memset(m_actionRepeatTimer, 0, sizeof(m_actionRepeatTimer));
|
|
m_fScreenWidth = 0;
|
|
m_fScreenHeight = 0;
|
|
m_bScreenWidthSetup = false;
|
|
m_tileOriginX = 0;
|
|
m_tileOriginY = 0;
|
|
m_mcBitmapFont = NULL;
|
|
m_mcTTFFont = NULL;
|
|
m_moj7 = NULL;
|
|
m_moj11 = NULL;
|
|
gdraw_funcs = NULL;
|
|
iggy_explorer = NULL;
|
|
iggy_perfmon = NULL;
|
|
m_iggyPerfmonEnabled = false;
|
|
memset(m_bMenuDisplayed, 0, sizeof(m_bMenuDisplayed));
|
|
memset(m_bMenuToBeClosed, 0, sizeof(m_bMenuToBeClosed));
|
|
memset(m_iCountDown, 0, sizeof(m_iCountDown));
|
|
memset(m_bCloseAllScenes, 0, sizeof(m_bCloseAllScenes));
|
|
m_iPressStartQuadrantsMask = 0;
|
|
m_bCustomRenderPosition = false;
|
|
m_winUserIndex = 0;
|
|
m_bSystemUIShowing = false;
|
|
m_reloadSkinThread = NULL;
|
|
m_navigateToHomeOnReload = false;
|
|
m_accumulatedTicks = 0;
|
|
memset(&m_customRenderingClearRect, 0, sizeof(m_customRenderingClearRect));
|
|
memset(&m_registeredCallbackScenesCS, 0, sizeof(m_registeredCallbackScenesCS));
|
|
for (int i = 0; i < eUIGroup_COUNT; i++) m_groups[i] = NULL;
|
|
memset(&m_Allocatorlock, 0, sizeof(m_Allocatorlock));
|
|
m_defaultBuffer = NULL;
|
|
m_tempBuffer = NULL;
|
|
}
|
|
|
|
void UIController::tick() {}
|
|
void UIController::StartReloadSkinThread() {}
|
|
bool UIController::IsReloadingSkin() { return false; }
|
|
bool UIController::IsExpectingOrReloadingSkin() { return false; }
|
|
void UIController::CleanUpSkinReload() {}
|
|
bool UIController::NavigateToScene(int, EUIScene, void *, EUILayer, EUIGroup) { return false; }
|
|
bool UIController::NavigateBack(int, bool, EUIScene, EUILayer) { return false; }
|
|
void UIController::NavigateToHomeMenu() {}
|
|
UIScene *UIController::GetTopScene(int, EUILayer, EUIGroup) { return NULL; }
|
|
void UIController::CloseUIScenes(int, bool) {}
|
|
void UIController::CloseAllPlayersScenes() {}
|
|
bool UIController::IsPauseMenuDisplayed(int) { return false; }
|
|
bool UIController::IsContainerMenuDisplayed(int) { return false; }
|
|
bool UIController::IsIgnorePlayerJoinMenuDisplayed(int) { return false; }
|
|
bool UIController::IsIgnoreAutosaveMenuDisplayed(int) { return false; }
|
|
void UIController::SetIgnoreAutosaveMenuDisplayed(int, bool) {}
|
|
bool UIController::IsSceneInStack(int, EUIScene) { return false; }
|
|
void UIController::CheckMenuDisplayed() {}
|
|
void UIController::AnimateKeyPress(int, int, bool, bool, bool) {}
|
|
void UIController::OverrideSFX(int, int, bool) {}
|
|
void UIController::SetTooltipText(unsigned int, unsigned int, int) {}
|
|
void UIController::SetEnableTooltips(unsigned int, BOOL) {}
|
|
void UIController::ShowTooltip(unsigned int, unsigned int, bool) {}
|
|
void UIController::SetTooltips(unsigned int, int, int, int, int, int, int, int, int, int, bool) {}
|
|
void UIController::EnableTooltip(unsigned int, unsigned int, bool) {}
|
|
void UIController::RefreshTooltips(unsigned int) {}
|
|
void UIController::PlayUISFX(ESoundEffect) {}
|
|
void UIController::DisplayGamertag(unsigned int, bool) {}
|
|
void UIController::SetSelectedItem(unsigned int, const wstring &) {}
|
|
void UIController::UpdateSelectedItemPos(unsigned int) {}
|
|
void UIController::HandleDLCMountingComplete() {}
|
|
void UIController::HandleDLCInstalled(int) {}
|
|
void UIController::HandleTMSDLCFileRetrieved(int) {}
|
|
void UIController::HandleTMSBanFileRetrieved(int) {}
|
|
void UIController::HandleInventoryUpdated(int) {}
|
|
void UIController::HandleGameTick() {}
|
|
void UIController::SetTutorial(int, Tutorial *) {}
|
|
void UIController::SetTutorialDescription(int, TutorialPopupInfo *) {}
|
|
void UIController::RemoveInteractSceneReference(int, UIScene *) {}
|
|
void UIController::SetTutorialVisible(int, bool) {}
|
|
bool UIController::IsTutorialVisible(int) { return false; }
|
|
void UIController::UpdatePlayerBasePositions() {}
|
|
void UIController::SetEmptyQuadrantLogo(int) {}
|
|
void UIController::HideAllGameUIElements() {}
|
|
void UIController::ShowOtherPlayersBaseScene(unsigned int, bool) {}
|
|
void UIController::ShowTrialTimer(bool) {}
|
|
void UIController::SetTrialTimerLimitSecs(unsigned int) {}
|
|
void UIController::UpdateTrialTimer(unsigned int) {}
|
|
void UIController::ReduceTrialTimerValue() {}
|
|
void UIController::ShowAutosaveCountdownTimer(bool) {}
|
|
void UIController::UpdateAutosaveCountdownTimer(unsigned int) {}
|
|
void UIController::ShowSavingMessage(unsigned int, C4JStorage::ESavingMessage) {}
|
|
void UIController::ShowPlayerDisplayname(bool) {}
|
|
bool UIController::PressStartPlaying(unsigned int) { return false; }
|
|
void UIController::ShowPressStart(unsigned int) {}
|
|
void UIController::HidePressStart() {}
|
|
void UIController::ClearPressStart() {}
|
|
void UIController::SetWinUserIndex(unsigned int) {}
|
|
unsigned int UIController::GetWinUserIndex() { return 0; }
|
|
bool UIController::GetMenuDisplayed(int) { return false; }
|
|
void UIController::SetMenuDisplayed(int, bool) {}
|
|
void UIController::SetupFont() {}
|
|
void UIController::ReloadSkin() {}
|
|
byteArray UIController::getMovieData(const wstring &) { return byteArray(); }
|
|
void UIController::getRenderDimensions(C4JRender::eViewportType, S32 &, S32 &) {}
|
|
void UIController::setupRenderPosition(C4JRender::eViewportType) {}
|
|
void UIController::setupRenderPosition(S32, S32) {}
|
|
void UIController::SetSysUIShowing(bool) {}
|
|
void UIController::SetSystemUIShowing(LPVOID, bool) {}
|
|
void UIController::setupCustomDrawGameState() {}
|
|
void UIController::endCustomDrawGameState() {}
|
|
void UIController::setupCustomDrawMatrices(UIScene *, CustomDrawData *) {}
|
|
void UIController::setupCustomDrawGameStateAndMatrices(UIScene *, CustomDrawData *) {}
|
|
void UIController::endCustomDrawMatrices() {}
|
|
void UIController::endCustomDrawGameStateAndMatrices() {}
|
|
void UIController::registerSubstitutionTexture(const wstring &, PBYTE, DWORD) {}
|
|
void UIController::unregisterSubstitutionTexture(const wstring &, bool) {}
|
|
size_t UIController::RegisterForCallbackId(UIScene *) { return 0; }
|
|
void UIController::UnregisterCallbackId(size_t) {}
|
|
UIScene *UIController::GetSceneFromCallbackId(size_t) { return NULL; }
|
|
void UIController::EnterCallbackIdCriticalSection() {}
|
|
void UIController::LeaveCallbackIdCriticalSection() {}
|
|
#ifndef __PS3__
|
|
C4JStorage::EMessageResult UIController::RequestMessageBox(UINT, UINT, UINT *, UINT, DWORD, int (*)(LPVOID, int, const C4JStorage::EMessageResult), LPVOID, C4JStringTable *, WCHAR *, DWORD, bool) { return (C4JStorage::EMessageResult)0; }
|
|
#endif
|
|
C4JStorage::EMessageResult UIController::RequestUGCMessageBox(UINT, UINT, int, int (*)(LPVOID, int, const C4JStorage::EMessageResult), LPVOID) { return (C4JStorage::EMessageResult)0; }
|
|
C4JStorage::EMessageResult UIController::RequestContentRestrictedMessageBox(UINT, UINT, int, int (*)(LPVOID, int, const C4JStorage::EMessageResult), LPVOID) { return (C4JStorage::EMessageResult)0; }
|
|
void UIController::ShowUIDebugConsole(bool) {}
|
|
void UIController::ShowUIDebugMarketingGuide(bool) {}
|
|
void UIController::logDebugString(const string &) {}
|
|
UIScene *UIController::FindScene(EUIScene) { return NULL; }
|
|
void UIController::setFontCachingCalculationBuffer(int) {}
|
|
|
|
void UIController::preInit(S32, S32) {}
|
|
void UIController::postInit() {}
|
|
void UIController::renderScenes() {}
|
|
|
|
void ConsoleUIController::init(ID3D11Device *, ID3D11DeviceContext *, ID3D11RenderTargetView *, ID3D11DepthStencilView *, S32, S32) {}
|
|
void ConsoleUIController::render() {}
|
|
void ConsoleUIController::beginIggyCustomDraw4J(IggyCustomDrawCallbackRegion *, CustomDrawData *) {}
|
|
CustomDrawData *ConsoleUIController::setupCustomDraw(UIScene *, IggyCustomDrawCallbackRegion *) { return NULL; }
|
|
CustomDrawData *ConsoleUIController::calculateCustomDraw(IggyCustomDrawCallbackRegion *) { return NULL; }
|
|
void ConsoleUIController::endCustomDraw(IggyCustomDrawCallbackRegion *) {}
|
|
void ConsoleUIController::setTileOrigin(S32, S32) {}
|
|
GDrawTexture *ConsoleUIController::getSubstitutionTexture(int) { return NULL; }
|
|
void ConsoleUIController::destroySubstitutionTexture(void *, GDrawTexture *) {}
|
|
void ConsoleUIController::shutdown() {}
|
|
|
|
ConsoleUIController ui;
|
|
|
|
TileRenderer::TileRenderer() : setColor(true) {}
|
|
TileRenderer::TileRenderer(LevelSource *) : setColor(true) {}
|
|
TileRenderer::~TileRenderer() {}
|
|
|
|
Chunk::Chunk() {}
|
|
Chunk::~Chunk() {}
|
|
|
|
GuiComponent::GuiComponent() : blitOffset(0) {}
|
|
void GuiComponent::hLine(int, int, int, int) {}
|
|
void GuiComponent::vLine(int, int, int, int) {}
|
|
void GuiComponent::fill(int, int, int, int, int) {}
|
|
void GuiComponent::fillGradient(int, int, int, int, int, int) {}
|
|
void GuiComponent::drawCenteredString(Font *, const wstring &, int, int, int) {}
|
|
void GuiComponent::drawString(Font *, const wstring &, int, int, int) {}
|
|
void GuiComponent::blit(int, int, int, int, int, int) {}
|
|
|
|
Screen::Screen() {}
|
|
void Screen::render(int, int, float) {}
|
|
void Screen::keyPressed(wchar_t, int) {}
|
|
void Screen::mouseClicked(int, int, int) {}
|
|
void Screen::mouseReleased(int, int, int) {}
|
|
void Screen::buttonClicked(Button *) {}
|
|
void Screen::init(Minecraft *, int, int) {}
|
|
void Screen::setSize(int, int) {}
|
|
void Screen::init() {}
|
|
void Screen::updateEvents() {}
|
|
void Screen::mouseEvent() {}
|
|
void Screen::keyboardEvent() {}
|
|
void Screen::tick() {}
|
|
void Screen::removed() {}
|
|
void Screen::renderBackground() {}
|
|
void Screen::renderBackground(int) {}
|
|
void Screen::renderDirtBackground(int) {}
|
|
bool Screen::isPauseScreen() { return false; }
|
|
void Screen::confirmResult(bool, int) {}
|
|
void Screen::tabPressed() {}
|
|
wstring Screen::getClipboard() { return L""; }
|
|
void Screen::setClipboard(const wstring &) {}
|
|
|
|
Model::Model() : attackTime(0), riding(false), young(false), texWidth(64), texHeight(32), yHeadOffs(0), zHeadOffs(0) {}
|
|
OffsettedRenderList::OffsettedRenderList() : x(0), y(0), z(0), xOff(0), yOff(0), zOff(0), lists(NULL), inited(false), rendered(false) {}
|
|
|
|
void HumanoidModel::render(shared_ptr<Entity>, float, float, float, float, float, float, bool) {}
|
|
void HumanoidModel::setupAnim(float, float, float, float, float, float, unsigned int) {}
|
|
ModelPart *HumanoidModel::AddOrRetrievePart(SKIN_BOX *) { return NULL; }
|
|
|
|
void TitleScreen::tick() {}
|
|
void TitleScreen::keyPressed(wchar_t, int) {}
|
|
void TitleScreen::init() {}
|
|
void TitleScreen::buttonClicked(Button *) {}
|
|
void TitleScreen::render(int, int, float) {}
|
|
|
|
SoundEngine::SoundEngine() {}
|
|
void SoundEngine::SetStreamingSounds(int, int, int, int, int, int, int) {}
|
|
void SoundEngine::destroy() {}
|
|
void SoundEngine::play(int, float, float, float, float, float) {}
|
|
void SoundEngine::playStreaming(const wstring &, float, float, float, float, float, bool) {}
|
|
void SoundEngine::playUI(int, float, float) {}
|
|
void SoundEngine::playMusicTick() {}
|
|
void SoundEngine::updateMusicVolume(float) {}
|
|
void SoundEngine::updateSystemMusicPlaying(bool) {}
|
|
void SoundEngine::updateSoundEffectVolume(float) {}
|
|
void SoundEngine::init(Options *) {}
|
|
void SoundEngine::tick(shared_ptr<Mob> *, float) {}
|
|
void SoundEngine::add(const wstring &, File *) {}
|
|
void SoundEngine::addMusic(const wstring &, File *) {}
|
|
void SoundEngine::addStreaming(const wstring &, File *) {}
|
|
char *SoundEngine::ConvertSoundPathToName(const wstring &, bool) { return NULL; }
|
|
|
|
bool ConsoleSoundEngine::GetIsPlayingStreamingCDMusic() { return false; }
|
|
bool ConsoleSoundEngine::GetIsPlayingStreamingGameMusic() { return false; }
|
|
void ConsoleSoundEngine::SetIsPlayingStreamingCDMusic(bool) {}
|
|
void ConsoleSoundEngine::SetIsPlayingStreamingGameMusic(bool) {}
|
|
bool ConsoleSoundEngine::GetIsPlayingEndMusic() { return false; }
|
|
bool ConsoleSoundEngine::GetIsPlayingNetherMusic() { return false; }
|
|
void ConsoleSoundEngine::SetIsPlayingEndMusic(bool) {}
|
|
void ConsoleSoundEngine::SetIsPlayingNetherMusic(bool) {}
|
|
|
|
void LevelRenderer::staticCtor() {}
|
|
void IUIScene_CreativeMenu::staticCtor() {}
|
|
vector< shared_ptr<ItemInstance> > IUIScene_CreativeMenu::categoryGroups[IUIScene_CreativeMenu::eCreativeInventoryGroupsCount];
|
|
IUIScene_CreativeMenu::TabSpec **IUIScene_CreativeMenu::specs = NULL;
|
|
|
|
unsigned short SFontData::Codepoints[SFontData::FONTSIZE] = {};
|
|
SFontData SFontData::Mojangles_7 = {};
|
|
SFontData SFontData::Mojangles_11 = {};
|
|
|
|
int IUIScene_PauseMenu::SaveWorldThreadProc(void *) { return 0; }
|
|
int IUIScene_PauseMenu::ExitWorldThreadProc(void *) { return 0; }
|
|
void IUIScene_PauseMenu::_ExitWorld(LPVOID) {}
|
|
shared_ptr<Merchant> IUIScene_TradingMenu::getMerchant() { return shared_ptr<Merchant>(); }
|
|
bool IUIScene_CraftingMenu::isItemSelected(int) { return false; }
|
|
|
|
void UIScene_FullscreenProgress::SetWasCancelled(bool) {}
|
|
|
|
double Particle::xOff = 0;
|
|
double Particle::yOff = 0;
|
|
double Particle::zOff = 0;
|
|
|
|
void Particle::_init(Level *level, double x, double y, double z) {}
|
|
Particle::Particle(Level *level, double x, double y, double z) : Entity(level) {}
|
|
Particle::Particle(Level *level, double x, double y, double z, double xa, double ya, double za) : Entity(level) {}
|
|
shared_ptr<Particle> Particle::setPower(float) { return shared_ptr<Particle>(); }
|
|
shared_ptr<Particle> Particle::scale(float) { return shared_ptr<Particle>(); }
|
|
void Particle::setColor(float, float, float) {}
|
|
void Particle::setAlpha(float) {}
|
|
float Particle::getRedCol() { return 0; }
|
|
float Particle::getGreenCol() { return 0; }
|
|
float Particle::getBlueCol() { return 0; }
|
|
float Particle::getAlpha() { return 0; }
|
|
bool Particle::makeStepSound() { return false; }
|
|
void Particle::defineSynchedData() {}
|
|
void Particle::tick() {}
|
|
void Particle::render(Tesselator *, float, float, float, float, float, float) {}
|
|
int Particle::getParticleTexture() { return 0; }
|
|
void Particle::addAdditonalSaveData(CompoundTag *) {}
|
|
void Particle::readAdditionalSaveData(CompoundTag *) {}
|
|
void Particle::setTex(Textures *, Icon *) {}
|
|
void Particle::setMiscTex(int) {}
|
|
void Particle::setNextMiscAnimTex() {}
|
|
bool Particle::isAttackable() { return false; }
|
|
wstring Particle::toString() { return L""; }
|
|
|
|
void CritParticle::_init(Level *, shared_ptr<Entity>, ePARTICLE_TYPE) {}
|
|
CritParticle::CritParticle(Level *level, shared_ptr<Entity> entity) : Particle(level, 0, 0, 0, 0, 0, 0), life(0), lifeTime(0), particleName(eParticleType_crit) {}
|
|
CritParticle::CritParticle(Level *level, shared_ptr<Entity> entity, ePARTICLE_TYPE type) : Particle(level, 0, 0, 0, 0, 0, 0), life(0), lifeTime(0), particleName(type) {}
|
|
void CritParticle::CritParticlePostConstructor() {}
|
|
void CritParticle::render(Tesselator *, float, float, float, float, float, float) {}
|
|
void CritParticle::tick() {}
|
|
int CritParticle::getParticleTexture() { return 0; }
|
|
|
|
TakeAnimationParticle::TakeAnimationParticle(Level *level, shared_ptr<Entity> item, shared_ptr<Entity> target, float yOffs) : Particle(level, 0, 0, 0, 0, 0, 0), life(0), lifeTime(0), yOffs(yOffs) {}
|
|
TakeAnimationParticle::~TakeAnimationParticle() {}
|
|
void TakeAnimationParticle::render(Tesselator *, float, float, float, float, float, float) {}
|
|
void TakeAnimationParticle::tick() {}
|
|
int TakeAnimationParticle::getParticleTexture() { return 0; }
|
|
|
|
/*#ifdef _WIN32
|
|
void C4JStorage::SetMaxSaves(int) {}
|
|
C4JStorage::ESaveGameState C4JStorage::GetSaveState() { return C4JStorage::ESaveGame_Idle; }
|
|
#endif*/ |