tour/minetest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge c3f7e9b1b2 into c4d624083d

Browse Source
This commit is contained in:
sfan5 2025-01-02 15:31:48 +01:00 committed by GitHub
commit 50bf48ef44
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
21 changed files with 163 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
irr/include/EDebugSceneTypes.h
View File

@ -34,7 +34,7 @@ enum E_DEBUG_SCENE_TYPE
EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS,
//! Show all debug infos
EDS_FULL = 0xffffffff
EDS_FULL = 0xffff
};
} // end namespace scene

8
irr/include/ISceneManager.h
View File

@ -387,6 +387,14 @@ public:
pass currently is active they can render the correct part of their geometry. */
virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const = 0;
/**
* Sets debug data flags that will be set on every rendered scene node.
* Refer to `E_DEBUG_SCENE_TYPE`.
* @param setBits bit mask of types to enable
* @param unsetBits bit mask of types to disable
*/
virtual void setGlobalDebugData(u16 setBits, u16 unsetBits) = 0;
//! Creates a new scene manager.
/** This can be used to easily draw and/or store two
independent scenes at the same time. The mesh cache will be

12
irr/include/ISceneNode.h
View File

@ -403,14 +403,14 @@ public:
their geometry because it is their only reason for existence,
for example the OctreeSceneNode.
\param state The culling state to be used. Check E_CULLING_TYPE for possible values.*/
void setAutomaticCulling(u32 state)
void setAutomaticCulling(u16 state)
{
AutomaticCullingState = state;
}
//! Gets the automatic culling state.
/** \return The automatic culling state. */
u32 getAutomaticCulling() const
u16 getAutomaticCulling() const
{
return AutomaticCullingState;
}
@ -419,7 +419,7 @@ public:
/** A bitwise OR of the types from @ref irr::scene::E_DEBUG_SCENE_TYPE.
Please note that not all scene nodes support all debug data types.
\param state The debug data visibility state to be used. */
virtual void setDebugDataVisible(u32 state)
virtual void setDebugDataVisible(u16 state)
{
DebugDataVisible = state;
}
@ -427,7 +427,7 @@ public:
//! Returns if debug data like bounding boxes are drawn.
/** \return A bitwise OR of the debug data values from
@ref irr::scene::E_DEBUG_SCENE_TYPE that are currently visible. */
u32 isDebugDataVisible() const
u16 isDebugDataVisible() const
{
return DebugDataVisible;
}
@ -581,10 +581,10 @@ protected:
s32 ID;
//! Automatic culling state
u32 AutomaticCullingState;
u16 AutomaticCullingState;
//! Flag if debug data should be drawn, such as Bounding Boxes.
u32 DebugDataVisible;
u16 DebugDataVisible;
//! Is the node visible?
bool IsVisible;

6
irr/src/CAnimatedMeshSceneNode.cpp
View File

@ -276,9 +276,6 @@ void CAnimatedMeshSceneNode::render()
debug_mat.ZBuffer = video::ECFN_DISABLED;
driver->setMaterial(debug_mat);
if (DebugDataVisible & scene::EDS_BBOX)
driver->draw3DBox(Box, video::SColor(255, 255, 255, 255));
// show bounding box
if (DebugDataVisible & scene::EDS_BBOX_BUFFERS) {
for (u32 g = 0; g < m->getMeshBufferCount(); ++g) {
@ -290,6 +287,9 @@ void CAnimatedMeshSceneNode::render()
}
}
if (DebugDataVisible & scene::EDS_BBOX)
driver->draw3DBox(Box, video::SColor(255, 255, 255, 255));
// show skeleton
if (DebugDataVisible & scene::EDS_SKELETON) {
if (Mesh->getMeshType() == EAMT_SKINNED) {

8
irr/src/CMeshSceneNode.cpp
View File

@ -110,11 +110,9 @@ void CMeshSceneNode::render()
if (DebugDataVisible && PassCount == 1) {
video::SMaterial m;
m.AntiAliasing = 0;
m.ZBuffer = video::ECFN_DISABLED;
driver->setMaterial(m);
if (DebugDataVisible & scene::EDS_BBOX) {
driver->draw3DBox(Box, video::SColor(255, 255, 255, 255));
}
if (DebugDataVisible & scene::EDS_BBOX_BUFFERS) {
for (u32 g = 0; g < Mesh->getMeshBufferCount(); ++g) {
driver->draw3DBox(
@ -123,6 +121,10 @@ void CMeshSceneNode::render()
}
}
if (DebugDataVisible & scene::EDS_BBOX) {
driver->draw3DBox(Box, video::SColor(255, 255, 255, 255));
}
if (DebugDataVisible & scene::EDS_NORMALS) {
// draw normals
const f32 debugNormalLength = 1.f;

23
irr/src/CNullDriver.cpp
View File

@ -619,20 +619,17 @@ void CNullDriver::draw3DBox(const core::aabbox3d<f32> &box, SColor color)
core::vector3df edges[8];
box.getEdges(edges);
// TODO: optimize into one big drawIndexPrimitive call.
video::S3DVertex v[8];
for (u32 i = 0; i < 8; i++) {
v[i].Pos = edges[i];
v[i].Color = color;
}
draw3DLine(edges[5], edges[1], color);
draw3DLine(edges[1], edges[3], color);
draw3DLine(edges[3], edges[7], color);
draw3DLine(edges[7], edges[5], color);
draw3DLine(edges[0], edges[2], color);
draw3DLine(edges[2], edges[6], color);
draw3DLine(edges[6], edges[4], color);
draw3DLine(edges[4], edges[0], color);
draw3DLine(edges[1], edges[0], color);
draw3DLine(edges[3], edges[2], color);
draw3DLine(edges[7], edges[6], color);
draw3DLine(edges[5], edges[4], color);
const static u16 box_indices[24] = {
5, 1, 1, 3, 3, 7, 7, 5, 0, 2, 2, 6, 6, 4, 4, 0, 1, 0, 3, 2, 7, 6, 5, 4
};
drawVertexPrimitiveList(v, 8, box_indices, 12, EVT_STANDARD, scene::EPT_LINES);
}
//! draws an 2d image

6
irr/src/COpenGLCoreTexture.h
View File

@ -137,6 +137,9 @@ public:
Images.clear();
}
if (!name.empty())
Driver->irrGlObjectLabel(GL_TEXTURE, TextureName, name.c_str());
Driver->getCacheHandler()->getTextureCache().set(0, prevTexture);
TEST_GL_ERROR(Driver);
@ -247,6 +250,9 @@ public:
break;
}
if (!name.empty())
Driver->irrGlObjectLabel(GL_TEXTURE, TextureName, name.c_str());
Driver->getCacheHandler()->getTextureCache().set(0, prevTexture);
if (TEST_GL_ERROR(Driver)) {
char msg[256];

60
irr/src/COpenGLDriver.cpp
View File

@ -2462,66 +2462,6 @@ void COpenGLDriver::setFog(SColor c, E_FOG_TYPE fogType, f32 start,
glFogfv(GL_FOG_COLOR, data);
}
//! Draws a 3d box.
void COpenGLDriver::draw3DBox(const core::aabbox3d<f32> &box, SColor color)
{
core::vector3df edges[8];
box.getEdges(edges);
setRenderStates3DMode();
video::S3DVertex v[24];
for (u32 i = 0; i < 24; i++)
v[i].Color = color;
v[0].Pos = edges[5];
v[1].Pos = edges[1];
v[2].Pos = edges[1];
v[3].Pos = edges[3];
v[4].Pos = edges[3];
v[5].Pos = edges[7];
v[6].Pos = edges[7];
v[7].Pos = edges[5];
v[8].Pos = edges[0];
v[9].Pos = edges[2];
v[10].Pos = edges[2];
v[11].Pos = edges[6];
v[12].Pos = edges[6];
v[13].Pos = edges[4];
v[14].Pos = edges[4];
v[15].Pos = edges[0];
v[16].Pos = edges[1];
v[17].Pos = edges[0];
v[18].Pos = edges[3];
v[19].Pos = edges[2];
v[20].Pos = edges[7];
v[21].Pos = edges[6];
v[22].Pos = edges[5];
v[23].Pos = edges[4];
if (!FeatureAvailable[IRR_ARB_vertex_array_bgra] && !FeatureAvailable[IRR_EXT_vertex_array_bgra])
getColorBuffer(v, 24, EVT_STANDARD);
CacheHandler->setClientState(true, false, true, false);
glVertexPointer(3, GL_FLOAT, sizeof(S3DVertex), &(static_cast<const S3DVertex *>(v))[0].Pos);
#ifdef GL_BGRA
const GLint colorSize = (FeatureAvailable[IRR_ARB_vertex_array_bgra] || FeatureAvailable[IRR_EXT_vertex_array_bgra]) ? GL_BGRA : 4;
#else
const GLint colorSize = 4;
#endif
if (FeatureAvailable[IRR_ARB_vertex_array_bgra] || FeatureAvailable[IRR_EXT_vertex_array_bgra])
glColorPointer(colorSize, GL_UNSIGNED_BYTE, sizeof(S3DVertex), &(static_cast<const S3DVertex *>(v))[0].Color);
else {
_IRR_DEBUG_BREAK_IF(ColorBuffer.size() == 0);
glColorPointer(colorSize, GL_UNSIGNED_BYTE, 0, &ColorBuffer[0]);
}
glDrawArrays(GL_LINES, 0, 24);
}
//! Draws a 3d line.
void COpenGLDriver::draw3DLine(const core::vector3df &start,
const core::vector3df &end, SColor color)

3
irr/src/COpenGLDriver.h
View File

@ -170,9 +170,6 @@ public:
const core::position2d<s32> &end,
SColor color = SColor(255, 255, 255, 255)) override;
//! Draws a 3d box
void draw3DBox(const core::aabbox3d<f32> &box, SColor color = SColor(255, 255, 255, 255)) override;
//! Draws a 3d line.
virtual void draw3DLine(const core::vector3df &start,
const core::vector3df &end,

4
irr/src/COpenGLExtensionHandler.h
View File

@ -1065,6 +1065,10 @@ public:
void irrGlCompressedTexSubImage2D(GLenum target, GLint level,
GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLenum format, GLsizei imageSize, const void *data);
inline void irrGlObjectLabel(GLenum identifier, GLuint name, const char *label)
{
// unimplemented
}
// shader programming
void extGlGenPrograms(GLsizei n, GLuint *programs);

18
irr/src/CSceneManager.cpp
View File

@ -490,13 +490,19 @@ void CSceneManager::drawAll()
// let all nodes register themselves
OnRegisterSceneNode();
const auto &render_node = [this] (ISceneNode *node) {
u32 flags = node->isDebugDataVisible();
node->setDebugDataVisible((flags & ~DebugDataMask) | DebugDataBits);
node->render();
};
// render camera scenes
{
CurrentRenderPass = ESNRP_CAMERA;
Driver->getOverrideMaterial().Enabled = ((Driver->getOverrideMaterial().EnablePasses & CurrentRenderPass) != 0);
for (auto *node : CameraList)
node->render();
render_node(node);
CameraList.clear();
}
@ -507,7 +513,7 @@ void CSceneManager::drawAll()
Driver->getOverrideMaterial().Enabled = ((Driver->getOverrideMaterial().EnablePasses & CurrentRenderPass) != 0);
for (auto *node : SkyBoxList)
node->render();
render_node(node);
SkyBoxList.clear();
}
@ -520,7 +526,7 @@ void CSceneManager::drawAll()
std::sort(SolidNodeList.begin(), SolidNodeList.end());
for (auto &it : SolidNodeList)
it.Node->render();
render_node(it.Node);
SolidNodeList.clear();
}
@ -533,7 +539,7 @@ void CSceneManager::drawAll()
std::sort(TransparentNodeList.begin(), TransparentNodeList.end());
for (auto &it : TransparentNodeList)
it.Node->render();
render_node(it.Node);
TransparentNodeList.clear();
}
@ -546,7 +552,7 @@ void CSceneManager::drawAll()
std::sort(TransparentEffectNodeList.begin(), TransparentEffectNodeList.end());
for (auto &it : TransparentEffectNodeList)
it.Node->render();
render_node(it.Node);
TransparentEffectNodeList.clear();
}
@ -557,7 +563,7 @@ void CSceneManager::drawAll()
Driver->getOverrideMaterial().Enabled = ((Driver->getOverrideMaterial().EnablePasses & CurrentRenderPass) != 0);
for (auto *node : GuiNodeList)
node->render();
render_node(node);
GuiNodeList.clear();
}

8
irr/src/CSceneManager.h
View File

@ -179,6 +179,11 @@ public:
//! Set current render time.
void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) override { CurrentRenderPass = nextPass; }
void setGlobalDebugData(u16 setBits, u16 unsetBits) override {
DebugDataMask = unsetBits;
DebugDataBits = setBits;
}
//! returns if node is culled
bool isCulled(const ISceneNode *node) const override;
@ -268,6 +273,9 @@ private:
//! Mesh cache
IMeshCache *MeshCache;
//! Global debug render state
u16 DebugDataMask = 0, DebugDataBits = 0;
E_SCENE_NODE_RENDER_PASS CurrentRenderPass;
};

23
irr/src/OpenGL/Driver.cpp
View File

@ -164,13 +164,6 @@ COpenGL3DriverBase::COpenGL3DriverBase(const SIrrlichtCreationParameters &params
ExposedData = ContextManager->getContext();
ContextManager->activateContext(ExposedData, false);
GL.LoadAllProcedures(ContextManager);
if (EnableErrorTest && GL.IsExtensionPresent("GL_KHR_debug")) {
GL.Enable(GL_DEBUG_OUTPUT);
GL.DebugMessageCallback(debugCb, this);
} else if (EnableErrorTest) {
os::Printer::log("GL debug extension not available");
}
initQuadsIndices();
TEST_GL_ERROR(this);
}
@ -248,6 +241,20 @@ bool COpenGL3DriverBase::genericDriverInit(const core::dimension2d<u32> &screenS
initFeatures();
printTextureFormats();
if (EnableErrorTest) {
if (KHRDebugSupported) {
GL.Enable(GL_DEBUG_OUTPUT);
GL.DebugMessageCallback(debugCb, this);
} else {
os::Printer::log("GL debug extension not available");
}
} else {
// don't do debug things if they are not wanted (even if supported)
KHRDebugSupported = false;
}
initQuadsIndices();
// reset cache handler
delete CacheHandler;
CacheHandler = new COpenGL3CacheHandler(this);
@ -1615,7 +1622,7 @@ s32 COpenGL3DriverBase::addHighLevelShaderMaterial(
s32 nr = -1;
COpenGL3MaterialRenderer *r = new COpenGL3MaterialRenderer(
this, nr, vertexShaderProgram,
pixelShaderProgram,
pixelShaderProgram, shaderName,
callback, baseMaterial, userData);
r->drop();

13
irr/src/OpenGL/ExtensionHandler.h
View File

@ -161,10 +161,23 @@ public:
GL.BlendEquation(mode);
}
inline void irrGlObjectLabel(GLenum identifier, GLuint name, const char *label)
{
if (KHRDebugSupported) {
u32 len = strlen(label);
// Since our texture strings can get quite long we also truncate
// to a hardcoded limit of 82
len = std::min(len, std::min(MaxLabelLength, 82U));
GL.ObjectLabel(identifier, name, len, label);
}
}
bool LODBiasSupported = false;
bool AnisotropicFilterSupported = false;
bool BlendMinMaxSupported = false;
bool TextureMultisampleSupported = false;
bool KHRDebugSupported = false;
u32 MaxLabelLength = 0;
};
}

7
irr/src/OpenGL/MaterialRenderer.cpp
View File

@ -24,6 +24,7 @@ COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase *driver,
s32 &outMaterialTypeNr,
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram,
const c8 *debugName,
IShaderConstantSetCallBack *callback,
E_MATERIAL_TYPE baseMaterial,
s32 userData) :
@ -45,7 +46,7 @@ COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase *driver,
if (CallBack)
CallBack->grab();
init(outMaterialTypeNr, vertexShaderProgram, pixelShaderProgram);
init(outMaterialTypeNr, vertexShaderProgram, pixelShaderProgram, debugName);
}
COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase *driver,
@ -98,6 +99,7 @@ GLuint COpenGL3MaterialRenderer::getProgram() const
void COpenGL3MaterialRenderer::init(s32 &outMaterialTypeNr,
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram,
const c8 *debugName,
bool addMaterial)
{
outMaterialTypeNr = -1;
@ -121,6 +123,9 @@ void COpenGL3MaterialRenderer::init(s32 &outMaterialTypeNr,
if (!linkProgram())
return;
if (debugName)
Driver->irrGlObjectLabel(GL_PROGRAM, Program, debugName);
if (addMaterial)
outMaterialTypeNr = Driver->addMaterialRenderer(this);
}

5
irr/src/OpenGL/MaterialRenderer.h
View File

@ -28,6 +28,7 @@ public:
s32 &outMaterialTypeNr,
const c8 *vertexShaderProgram = 0,
const c8 *pixelShaderProgram = 0,
const c8 *debugName = nullptr,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = EMT_SOLID,
s32 userData = 0);
@ -66,7 +67,9 @@ protected:
E_MATERIAL_TYPE baseMaterial = EMT_SOLID,
s32 userData = 0);
void init(s32 &outMaterialTypeNr, const c8 *vertexShaderProgram, const c8 *pixelShaderProgram, bool addMaterial = true);
void init(s32 &outMaterialTypeNr, const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram, const c8 *debugName = nullptr,
bool addMaterial = true);
bool createShader(GLenum shaderType, const char *shader);
bool linkProgram();

4
irr/src/OpenGL/Renderer2D.cpp
View File

@ -23,8 +23,8 @@ COpenGL3Renderer2D::COpenGL3Renderer2D(const c8 *vertexShaderProgram, const c8 *
WithTexture(withTexture)
{
int Temp = 0;
init(Temp, vertexShaderProgram, pixelShaderProgram, false);
init(Temp, vertexShaderProgram, pixelShaderProgram,
withTexture ? "2DTexture" : "2DNoTexture", false);
COpenGL3CacheHandler *cacheHandler = Driver->getCacheHandler();

3
irr/src/OpenGL3/Driver.cpp
View File

@ -72,6 +72,9 @@ void COpenGL3Driver::initFeatures()
LODBiasSupported = true;
BlendMinMaxSupported = true;
TextureMultisampleSupported = true;
KHRDebugSupported = isVersionAtLeast(4, 6) || queryExtension("GL_KHR_debug");
if (KHRDebugSupported)
MaxLabelLength = GetInteger(GL.MAX_LABEL_LENGTH);
// COGLESCoreExtensionHandler::Feature
static_assert(MATERIAL_MAX_TEXTURES <= 16, "Only up to 16 textures are guaranteed");

3
irr/src/OpenGLES2/Driver.cpp
View File

@ -124,6 +124,9 @@ void COpenGLES2Driver::initFeatures()
AnisotropicFilterSupported = queryExtension("GL_EXT_texture_filter_anisotropic");
BlendMinMaxSupported = (Version.Major >= 3) || FeatureAvailable[IRR_GL_EXT_blend_minmax];
TextureMultisampleSupported = isVersionAtLeast(3, 1);
KHRDebugSupported = queryExtension("GL_KHR_debug");
if (KHRDebugSupported)
MaxLabelLength = GetInteger(GL.MAX_LABEL_LENGTH);
// COGLESCoreExtensionHandler::Feature
static_assert(MATERIAL_MAX_TEXTURES <= 8, "Only up to 8 textures are guaranteed");

70
src/client/content_cao.cpp
View File

@ -656,25 +656,32 @@ void GenericCAO::addToScene(ITextureSource *tsrc, scene::ISceneManager *smgr)
}
} else if (m_prop.visual == "upright_sprite") {
grabMatrixNode();
scene::SMesh *mesh = new scene::SMesh();
double dx = BS * m_prop.visual_size.X / 2;
double dy = BS * m_prop.visual_size.Y / 2;
auto mesh = make_irr<scene::SMesh>();
f32 dx = BS * m_prop.visual_size.X / 2;
f32 dy = BS * m_prop.visual_size.Y / 2;
video::SColor c(0xFFFFFFFF);
{ // Front
scene::IMeshBuffer *buf = new scene::SMeshBuffer();
video::S3DVertex vertices[4] = {
video::S3DVertex(-dx, -dy, 0, 0,0,1, c, 1,1),
video::S3DVertex( dx, -dy, 0, 0,0,1, c, 0,1),
video::S3DVertex( dx, dy, 0, 0,0,1, c, 0,0),
video::S3DVertex(-dx, dy, 0, 0,0,1, c, 1,0),
};
if (m_is_player) {
// Move minimal Y position to 0 (feet position)
for (video::S3DVertex &vertex : vertices)
vertex.Pos.Y += dy;
video::S3DVertex vertices[4] = {
video::S3DVertex(-dx, -dy, 0, 0,0,1, c, 1,1),
video::S3DVertex( dx, -dy, 0, 0,0,1, c, 0,1),
video::S3DVertex( dx, dy, 0, 0,0,1, c, 0,0),
video::S3DVertex(-dx, dy, 0, 0,0,1, c, 1,0),
};
if (m_is_player) {
// Move minimal Y position to 0 (feet position)
for (auto &vertex : vertices)
vertex.Pos.Y += dy;
}
const u16 indices[] = {0,1,2,2,3,0};
for (int face : {0, 1}) {
auto buf = make_irr<scene::SMeshBuffer>();
// Front (0) or Back (1)
if (face == 1) {
for (auto &v : vertices)
v.Normal *= -1;
for (int i : {0, 2})
std::swap(vertices[i].Pos, vertices[i+1].Pos);
}
u16 indices[] = {0,1,2,2,3,0};
buf->append(vertices, 4, indices, 6);
// Set material
@ -682,36 +689,13 @@ void GenericCAO::addToScene(ITextureSource *tsrc, scene::ISceneManager *smgr)
buf->getMaterial().ColorParam = c;
// Add to mesh
mesh->addMeshBuffer(buf);
buf->drop();
buf->recalculateBoundingBox();
mesh->addMeshBuffer(buf.get());
}
{ // Back
scene::IMeshBuffer *buf = new scene::SMeshBuffer();
video::S3DVertex vertices[4] = {
video::S3DVertex( dx,-dy, 0, 0,0,-1, c, 1,1),
video::S3DVertex(-dx,-dy, 0, 0,0,-1, c, 0,1),
video::S3DVertex(-dx, dy, 0, 0,0,-1, c, 0,0),
video::S3DVertex( dx, dy, 0, 0,0,-1, c, 1,0),
};
if (m_is_player) {
// Move minimal Y position to 0 (feet position)
for (video::S3DVertex &vertex : vertices)
vertex.Pos.Y += dy;
}
u16 indices[] = {0,1,2,2,3,0};
buf->append(vertices, 4, indices, 6);
// Set material
setMaterial(buf->getMaterial());
buf->getMaterial().ColorParam = c;
// Add to mesh
mesh->addMeshBuffer(buf);
buf->drop();
}
m_meshnode = m_smgr->addMeshSceneNode(mesh, m_matrixnode);
mesh->recalculateBoundingBox();
m_meshnode = m_smgr->addMeshSceneNode(mesh.get(), m_matrixnode);
m_meshnode->grab();
mesh->drop();
} else if (m_prop.visual == "cube") {
grabMatrixNode();
scene::IMesh *mesh = createCubeMesh(v3f(BS,BS,BS));

54
src/client/game.cpp
View File

@ -427,6 +427,8 @@ public:
const static float object_hit_delay = 0.2;
const static u16 bbox_debug_flag = scene::EDS_BBOX_ALL;
/* The reason the following structs are not anonymous structs within the
* class is that they are not used by the majority of member functions and
* many functions that do require objects of thse types do not modify them
@ -635,6 +637,8 @@ protected:
private:
struct Flags {
bool disable_camera_update = false;
/// 0 = no debug text active, see toggleDebug() for the rest
int debug_state = 0;
};
void pauseAnimation();
@ -1663,6 +1667,7 @@ void Game::updateDebugState()
hud->disableBlockBounds();
if (!has_debug) {
draw_control->show_wireframe = false;
smgr->setGlobalDebugData(0, bbox_debug_flag);
m_flags.disable_camera_update = false;
m_game_formspec.disableDebugView();
}
@ -2222,46 +2227,41 @@ void Game::toggleDebug()
LocalPlayer *player = client->getEnv().getLocalPlayer();
bool has_debug = client->checkPrivilege("debug");
bool has_basic_debug = has_debug || (player->hud_flags & HUD_FLAG_BASIC_DEBUG);
// Initial: No debug info
// 1x toggle: Debug text
// 2x toggle: Debug text with profiler graph
// 3x toggle: Debug text and wireframe (needs "debug" priv)
// Next toggle: Back to initial
// 4x toggle: Debug text and bbox (needs "debug" priv)
//
// The debug text can be in 2 modes: minimal and basic.
// * Minimal: Only technical client info that not gameplay-relevant
// * Basic: Info that might give gameplay advantage, e.g. pos, angle
// Basic mode is used when player has the debug HUD flag set,
// otherwise the Minimal mode is used.
if (!m_game_ui->m_flags.show_minimal_debug) {
m_game_ui->m_flags.show_minimal_debug = true;
if (has_basic_debug)
m_game_ui->m_flags.show_basic_debug = true;
m_game_ui->m_flags.show_profiler_graph = false;
draw_control->show_wireframe = false;
auto &state = m_flags.debug_state;
state = (state + 1) % 5;
if (state >= 3 && !has_debug)
state = 0;
m_game_ui->m_flags.show_minimal_debug = state > 0;
m_game_ui->m_flags.show_basic_debug = state > 0 && has_basic_debug;
m_game_ui->m_flags.show_profiler_graph = state == 2;
draw_control->show_wireframe = state == 3;
smgr->setGlobalDebugData(state == 4 ? bbox_debug_flag : 0,
state == 4 ? 0 : bbox_debug_flag);
if (state == 1)
m_game_ui->showTranslatedStatusText("Debug info shown");
} else if (!m_game_ui->m_flags.show_profiler_graph && !draw_control->show_wireframe) {
if (has_basic_debug)
m_game_ui->m_flags.show_basic_debug = true;
m_game_ui->m_flags.show_profiler_graph = true;
else if (state == 2)
m_game_ui->showTranslatedStatusText("Profiler graph shown");
} else if (!draw_control->show_wireframe && client->checkPrivilege("debug")) {
if (has_basic_debug)
m_game_ui->m_flags.show_basic_debug = true;
m_game_ui->m_flags.show_profiler_graph = false;
draw_control->show_wireframe = true;
else if (state == 3)
m_game_ui->showTranslatedStatusText("Wireframe shown");
} else {
m_game_ui->m_flags.show_minimal_debug = false;
m_game_ui->m_flags.show_basic_debug = false;
m_game_ui->m_flags.show_profiler_graph = false;
draw_control->show_wireframe = false;
if (has_debug) {
m_game_ui->showTranslatedStatusText("Debug info, profiler graph, and wireframe hidden");
} else {
m_game_ui->showTranslatedStatusText("Debug info and profiler graph hidden");
}
}
else if (state == 4)
m_game_ui->showTranslatedStatusText("Bounding boxes shown");
else
m_game_ui->showTranslatedStatusText("All debug info hidden");
}