506 lines
21 KiB
C++
506 lines
21 KiB
C++
/********************************************************************************
|
|
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
|
|
* Copyright (c) 2010-2016 Daniel Chappuis *
|
|
*********************************************************************************
|
|
* *
|
|
* This software is provided 'as-is', without any express or implied warranty. *
|
|
* In no event will the authors be held liable for any damages arising from the *
|
|
* use of this software. *
|
|
* *
|
|
* Permission is granted to anyone to use this software for any purpose, *
|
|
* including commercial applications, and to alter it and redistribute it *
|
|
* freely, subject to the following restrictions: *
|
|
* *
|
|
* 1. The origin of this software must not be misrepresented; you must not claim *
|
|
* that you wrote the original software. If you use this software in a *
|
|
* product, an acknowledgment in the product documentation would be *
|
|
* appreciated but is not required. *
|
|
* *
|
|
* 2. Altered source versions must be plainly marked as such, and must not be *
|
|
* misrepresented as being the original software. *
|
|
* *
|
|
* 3. This notice may not be removed or altered from any source distribution. *
|
|
* *
|
|
********************************************************************************/
|
|
|
|
// Libraries
|
|
#include "Gui.h"
|
|
#include <GLFW/glfw3.h>
|
|
#include "TestbedApplication.h"
|
|
|
|
using namespace nanogui;
|
|
|
|
//GLFWwindow* Gui::mWindow = NULL;
|
|
double Gui::mScrollX = 0.0;
|
|
double Gui::mScrollY = 0.0;
|
|
double Gui::mTimeSinceLastProfilingDisplay = 0;
|
|
double Gui::mCachedFPS = 0;
|
|
double Gui::mCachedUpdateTime = 0;
|
|
double Gui::mCachedTotalPhysicsUpdateTime = 0;
|
|
double Gui::mCachedPhysicsStepTime = 0;
|
|
|
|
// Constructor
|
|
Gui::Gui(TestbedApplication* app)
|
|
: mApp(app), mSimulationPanel(nullptr), mSettingsPanel(nullptr), mPhysicsPanel(nullptr),
|
|
mRenderingPanel(nullptr), mFPSLabel(nullptr), mFrameTimeLabel(nullptr), mTotalPhysicsTimeLabel(nullptr),
|
|
mPhysicsStepTimeLabel(nullptr)
|
|
{
|
|
|
|
}
|
|
|
|
// Destructor
|
|
Gui::~Gui() {
|
|
|
|
|
|
}
|
|
|
|
/// Initialize the GUI
|
|
void Gui::init() {
|
|
|
|
// Create the Simulation panel
|
|
createSimulationPanel();
|
|
|
|
// Create the Settings panel
|
|
createSettingsPanel();
|
|
|
|
// Create the Profiling panel
|
|
createProfilingPanel();
|
|
|
|
mApp->set_visible(true);
|
|
mApp->perform_layout();
|
|
|
|
mTimeSinceLastProfilingDisplay = glfwGetTime();
|
|
}
|
|
|
|
// Update the GUI
|
|
void Gui::update() {
|
|
|
|
// Update Profiling GUI every seconds
|
|
if ((mApp->mCurrentTime - mTimeSinceLastProfilingDisplay) > TIME_INTERVAL_DISPLAY_PROFILING_INFO) {
|
|
mTimeSinceLastProfilingDisplay = mApp->mCurrentTime;
|
|
mCachedFPS = mApp->mFPS;
|
|
mCachedUpdateTime = mApp->mFrameTime;
|
|
mCachedTotalPhysicsUpdateTime = mApp->mTotalPhysicsTime;
|
|
mCachedPhysicsStepTime = mApp->mPhysicsStepTime;
|
|
}
|
|
|
|
// Framerate (FPS)
|
|
mFPSLabel->set_caption(std::string("FPS : ") + floatToString(mCachedFPS, 0));
|
|
|
|
// Frame time
|
|
mFrameTimeLabel->set_caption(std::string("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + std::string(" ms"));
|
|
|
|
// Total Physics time
|
|
mTotalPhysicsTimeLabel->set_caption(std::string("Total physics time : ") + floatToString(mCachedTotalPhysicsUpdateTime * 1000.0, 1) + std::string(" ms"));
|
|
|
|
// Physics step time
|
|
mPhysicsStepTimeLabel->set_caption(std::string("Physics step time : ") + floatToString(mCachedPhysicsStepTime * 1000.0, 1) + std::string(" ms"));
|
|
}
|
|
|
|
void Gui::createSimulationPanel() {
|
|
|
|
mSimulationPanel = new Window(mApp, "Simulation");
|
|
mSimulationPanel->set_position(Vector2i(15, 15));
|
|
mSimulationPanel->set_layout(new GroupLayout(10, 5, 10 , 20));
|
|
//mSimulationPanel->setId("SimulationPanel");
|
|
mSimulationPanel->set_fixed_width(220);
|
|
|
|
// Scenes/Physics/Rendering buttons
|
|
new Label(mSimulationPanel, "Controls","sans-bold");
|
|
Widget* panelControls = new Widget(mSimulationPanel);
|
|
panelControls->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 0, 5));
|
|
ToolButton* buttonPlay = new ToolButton(panelControls, FA_PLAY);
|
|
buttonPlay->set_flags(Button::NormalButton);
|
|
buttonPlay->set_callback([&] {
|
|
mApp->playSimulation();
|
|
});
|
|
ToolButton* buttonPause = new ToolButton(panelControls, FA_PAUSE);
|
|
buttonPause->set_flags(Button::NormalButton);
|
|
buttonPause->set_callback([&] {
|
|
mApp->pauseSimulation();
|
|
});
|
|
ToolButton* buttonPlayStep = new ToolButton(panelControls, FA_STEP_FORWARD);
|
|
buttonPlayStep->set_flags(Button::NormalButton);
|
|
buttonPlayStep->set_callback([&] {
|
|
mApp->toggleTakeSinglePhysicsStep();
|
|
});
|
|
ToolButton* buttonRestart = new ToolButton(panelControls, FA_REDO);
|
|
buttonRestart->set_flags(Button::NormalButton);
|
|
buttonRestart->set_callback([&] {
|
|
mApp->restartSimulation();
|
|
});
|
|
|
|
// Scenes
|
|
std::vector<Scene*> scenes = mApp->getScenes();
|
|
std::vector<std::string> scenesNames;
|
|
for (uint i=0; i<scenes.size(); i++) {
|
|
scenesNames.push_back(scenes[i]->getName().c_str());
|
|
}
|
|
new Label(mSimulationPanel, "Scene","sans-bold");
|
|
ComboBox* comboBoxScenes = new ComboBox(mSimulationPanel, scenesNames);
|
|
comboBoxScenes->set_fixed_width(150);
|
|
comboBoxScenes->popup()->child_at(0)->set_fixed_height(800);
|
|
comboBoxScenes->set_callback([&, scenes](int index) {
|
|
mApp->switchScene(scenes[index]);
|
|
});
|
|
}
|
|
|
|
void Gui::createSettingsPanel() {
|
|
|
|
mSettingsPanel = new Window(mApp, "Settings");
|
|
mSettingsPanel->set_position(Vector2i(15, 180));
|
|
mSettingsPanel->set_layout(new BoxLayout(Orientation::Vertical, Alignment::Middle, 10, 5));
|
|
//mSettingsPanel->setId("SettingsPanel");
|
|
mSettingsPanel->set_fixed_width(220);
|
|
|
|
// Scenes/Physics/Rendering buttons
|
|
Widget* buttonsPanel = new Widget(mSettingsPanel);
|
|
buttonsPanel->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 5, 5));
|
|
Button* buttonPhysics = new Button(buttonsPanel, "Physics");
|
|
buttonPhysics->set_flags(Button::RadioButton);
|
|
buttonPhysics->set_pushed(true);
|
|
buttonPhysics->set_change_callback([&](bool state) {
|
|
mPhysicsPanel->set_visible(true);
|
|
mRenderingPanel->set_visible(false);
|
|
mApp->perform_layout();
|
|
});
|
|
Button* buttonRendering = new Button(buttonsPanel, "Rendering");
|
|
buttonRendering->set_flags(Button::RadioButton);
|
|
buttonRendering->set_change_callback([&](bool state) {
|
|
mRenderingPanel->set_visible(true);
|
|
mPhysicsPanel->set_visible(false);
|
|
mApp->perform_layout();
|
|
});
|
|
|
|
// ---------- Physics Panel ----------
|
|
mPhysicsPanel = new Widget(mSettingsPanel);
|
|
mPhysicsPanel->set_layout(new BoxLayout(Orientation::Vertical, Alignment::Fill, 0, 5));
|
|
|
|
// Enable/Disable sleeping
|
|
CheckBox* checkboxSleeping = new CheckBox(mPhysicsPanel, "Sleeping enabled");
|
|
checkboxSleeping->set_checked(mApp->mEngineSettings.isSleepingEnabled);
|
|
checkboxSleeping->set_callback([&](bool value) {
|
|
mApp->mEngineSettings.isSleepingEnabled = value;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
});
|
|
|
|
// Enabled/Disable Gravity
|
|
CheckBox* checkboxGravity = new CheckBox(mPhysicsPanel, "Gravity enabled");
|
|
checkboxGravity->set_checked(mApp->mEngineSettings.isGravityEnabled);
|
|
checkboxGravity->set_callback([&](bool value) {
|
|
mApp->mEngineSettings.isGravityEnabled = value;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
});
|
|
|
|
// Timestep
|
|
Widget* panelTimeStep = new Widget(mPhysicsPanel);
|
|
panelTimeStep->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 0, 5));
|
|
Label* labelTimeStep = new Label(panelTimeStep, "Time step","sans-bold");
|
|
labelTimeStep->set_fixed_width(120);
|
|
TextBox* textboxTimeStep = new TextBox(panelTimeStep);
|
|
textboxTimeStep->set_fixed_size(Vector2i(70, 25));
|
|
textboxTimeStep->set_editable(true);
|
|
std::ostringstream out;
|
|
out << std::setprecision(1) << std::fixed << (mApp->mEngineSettings.timeStep * 1000);
|
|
textboxTimeStep->set_value(out.str());
|
|
textboxTimeStep->set_units("ms");
|
|
textboxTimeStep->set_callback([&, textboxTimeStep](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(1) << std::fixed << std::showpoint << value;
|
|
float finalValue = std::stof(out.str());
|
|
|
|
if (finalValue < 1 || finalValue > 1000) return false;
|
|
|
|
mApp->mEngineSettings.timeStep = finalValue / 1000.0f;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxTimeStep->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxTimeStep->set_font_size(16);
|
|
textboxTimeStep->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// Velocity solver iterations
|
|
Widget* panelVelocityIterations = new Widget(mPhysicsPanel);
|
|
panelVelocityIterations->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 0, 5));
|
|
Label* labelVelocityIterations = new Label(panelVelocityIterations, "Velocity solver","sans-bold");
|
|
labelVelocityIterations->set_fixed_width(120);
|
|
TextBox* textboxVelocityIterations = new TextBox(panelVelocityIterations);
|
|
textboxVelocityIterations->set_fixed_size(Vector2i(70, 25));
|
|
textboxVelocityIterations->set_editable(true);
|
|
textboxVelocityIterations->set_value(std::to_string(mApp->mEngineSettings.nbVelocitySolverIterations));
|
|
textboxVelocityIterations->set_units("iter");
|
|
textboxVelocityIterations->set_callback([&, textboxVelocityIterations](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(0) << std::fixed << value;
|
|
|
|
if (value < 1 || value > 1000) return false;
|
|
|
|
mApp->mEngineSettings.nbVelocitySolverIterations = value;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxVelocityIterations->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxVelocityIterations->set_font_size(16);
|
|
textboxVelocityIterations->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// Position solver iterations
|
|
Widget* panelPositionIterations = new Widget(mPhysicsPanel);
|
|
panelPositionIterations->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 0, 5));
|
|
Label* labelPositionIterations = new Label(panelPositionIterations, "Position solver","sans-bold");
|
|
labelPositionIterations->set_fixed_width(120);
|
|
TextBox* textboxPositionIterations = new TextBox(panelPositionIterations);
|
|
textboxPositionIterations->set_fixed_size(Vector2i(70, 25));
|
|
textboxPositionIterations->set_editable(true);
|
|
textboxPositionIterations->set_value(std::to_string(mApp->mEngineSettings.nbPositionSolverIterations));
|
|
textboxPositionIterations->set_units("iter");
|
|
textboxPositionIterations->set_callback([&, textboxPositionIterations](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(0) << std::fixed << value;
|
|
|
|
if (value < 1 || value > 1000) return false;
|
|
|
|
mApp->mEngineSettings.nbPositionSolverIterations = value;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxPositionIterations->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxPositionIterations->set_font_size(16);
|
|
textboxPositionIterations->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// Time before sleep
|
|
Widget* panelTimeSleep = new Widget(mPhysicsPanel);
|
|
panelTimeSleep->set_layout(new BoxLayout(Orientation::Horizontal, Alignment::Middle, 0, 5));
|
|
Label* labelTimeSleep = new Label(panelTimeSleep, "Time before sleep","sans-bold");
|
|
labelTimeSleep->set_fixed_width(120);
|
|
out.str("");
|
|
out << std::setprecision(0) << std::fixed << (mApp->mEngineSettings.timeBeforeSleep * 1000);
|
|
TextBox* textboxTimeSleep = new TextBox(panelTimeSleep);
|
|
textboxTimeSleep->set_fixed_size(Vector2i(70, 25));
|
|
textboxTimeSleep->set_editable(true);
|
|
textboxTimeSleep->set_value(out.str());
|
|
textboxTimeSleep->set_units("ms");
|
|
textboxTimeSleep->set_callback([&, textboxTimeSleep](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(0) << std::fixed << std::showpoint << value;
|
|
float finalValue = std::stof(out.str());
|
|
|
|
if (finalValue < 1 || finalValue > 100000) return false;
|
|
|
|
mApp->mEngineSettings.timeBeforeSleep = finalValue / 1000.0f;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxTimeSleep->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxTimeSleep->set_font_size(16);
|
|
textboxTimeSleep->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// Sleep linear velocity
|
|
Widget* panelSleepLinearVel = new Widget(mPhysicsPanel);
|
|
panelSleepLinearVel->set_layout(new GridLayout(Orientation::Horizontal, 2, Alignment::Middle, 0, 5));
|
|
Label* labelSleepLinearVel = new Label(panelSleepLinearVel, "Sleep linear velocity","sans-bold");
|
|
labelSleepLinearVel->set_fixed_width(120);
|
|
out.str("");
|
|
out << std::setprecision(2) << std::fixed << (mApp->mEngineSettings.sleepLinearVelocity);
|
|
TextBox* textboxSleepLinearVel = new TextBox(panelSleepLinearVel);
|
|
textboxSleepLinearVel->set_fixed_size(Vector2i(70, 25));
|
|
textboxSleepLinearVel->set_editable(true);
|
|
textboxSleepLinearVel->set_value(out.str());
|
|
textboxSleepLinearVel->set_units("m/s");
|
|
textboxSleepLinearVel->set_callback([&, textboxSleepLinearVel](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(2) << std::fixed << std::showpoint << value;
|
|
float finalValue = std::stof(out.str());
|
|
|
|
if (finalValue < 0 || finalValue > 10000) return false;
|
|
|
|
mApp->mEngineSettings.sleepLinearVelocity = finalValue;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxSleepLinearVel->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxSleepLinearVel->set_font_size(16);
|
|
textboxSleepLinearVel->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// Sleep angular velocity
|
|
Widget* panelSleepAngularVel = new Widget(mPhysicsPanel);
|
|
panelSleepAngularVel->set_layout(new GridLayout(Orientation::Horizontal, 2, Alignment::Middle, 0, 5));
|
|
Label* labelSleepAngularVel = new Label(panelSleepAngularVel, "Sleep angular velocity","sans-bold");
|
|
labelSleepAngularVel->set_fixed_width(120);
|
|
out.str("");
|
|
out << std::setprecision(2) << std::fixed << (mApp->mEngineSettings.sleepAngularVelocity);
|
|
TextBox* textboxSleepAngularVel = new TextBox(panelSleepAngularVel);
|
|
textboxSleepAngularVel->set_fixed_size(Vector2i(70, 25));
|
|
textboxSleepAngularVel->set_editable(true);
|
|
textboxSleepAngularVel->set_value(out.str());
|
|
textboxSleepAngularVel->set_units("rad/s");
|
|
textboxSleepAngularVel->set_callback([&, textboxSleepAngularVel](const std::string &str) {
|
|
|
|
try {
|
|
float value = std::stof(str);
|
|
std::ostringstream out;
|
|
out << std::setprecision(2) << std::fixed << std::showpoint << value;
|
|
float finalValue = std::stof(out.str());
|
|
|
|
if (finalValue < 0 || finalValue > 10000) return false;
|
|
|
|
mApp->mEngineSettings.sleepAngularVelocity = finalValue;
|
|
mApp->notifyEngineSetttingsChanged();
|
|
textboxSleepAngularVel->set_value(out.str());
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
textboxSleepAngularVel->set_font_size(16);
|
|
textboxSleepAngularVel->set_alignment(TextBox::Alignment::Right);
|
|
|
|
// ---------- Rendering Panel ----------
|
|
mRenderingPanel = new Widget(mSettingsPanel);
|
|
mRenderingPanel->set_layout(new BoxLayout(Orientation::Vertical, Alignment::Fill, 0, 5));
|
|
|
|
// Display/Hide contact points
|
|
CheckBox* checkboxDebugRendererEnabled = new CheckBox(mRenderingPanel, "Debug rendering");
|
|
checkboxDebugRendererEnabled->set_checked(mApp->mIsDebugRendererEnabled);
|
|
|
|
// Display/Hide contact points
|
|
CheckBox* checkboxContactPoints = new CheckBox(mRenderingPanel, "Contact points");
|
|
checkboxContactPoints->set_checked(mApp->mAreContactPointsDisplayed);
|
|
checkboxContactPoints->set_enabled(false);
|
|
checkboxContactPoints->set_callback([&](bool value) {
|
|
mApp->mAreContactPointsDisplayed = value;
|
|
});
|
|
|
|
// Display/Hide contact normals
|
|
CheckBox* checkboxContactNormals = new CheckBox(mRenderingPanel, "Contact normals");
|
|
checkboxContactNormals->set_checked(mApp->mAreContactNormalsDisplayed);
|
|
checkboxContactNormals->set_enabled(false);
|
|
checkboxContactNormals->set_callback([&](bool value) {
|
|
mApp->mAreContactNormalsDisplayed = value;
|
|
});
|
|
|
|
// Display/Hide the Broad-phase AABBs
|
|
CheckBox* checkboxBroadPhaseAABBs = new CheckBox(mRenderingPanel, "Broad phase AABBs");
|
|
checkboxBroadPhaseAABBs->set_checked(mApp->mAreBroadPhaseAABBsDisplayed);
|
|
checkboxBroadPhaseAABBs->set_enabled(false);
|
|
checkboxBroadPhaseAABBs->set_callback([&](bool value) {
|
|
mApp->mAreBroadPhaseAABBsDisplayed = value;
|
|
});
|
|
|
|
// Display/Hide the colliders AABBs
|
|
CheckBox* checkboxColliderAABBs = new CheckBox(mRenderingPanel, "Colliders AABBs");
|
|
checkboxColliderAABBs->set_checked(mApp->mAreCollidersAABBsDisplayed);
|
|
checkboxColliderAABBs->set_enabled(false);
|
|
checkboxColliderAABBs->set_callback([&](bool value) {
|
|
mApp->mAreCollidersAABBsDisplayed = value;
|
|
});
|
|
|
|
// Display/Hide the collision shapes
|
|
CheckBox* checkboxCollisionShapes = new CheckBox(mRenderingPanel, "Collision shapes");
|
|
checkboxCollisionShapes->set_checked(mApp->mAreCollisionShapesDisplayed);
|
|
checkboxCollisionShapes->set_enabled(false);
|
|
checkboxCollisionShapes->set_callback([&](bool value) {
|
|
mApp->mAreCollisionShapesDisplayed = value;
|
|
});
|
|
|
|
// Enable/Disable wireframe mode
|
|
CheckBox* checkboxWireframe = new CheckBox(mRenderingPanel, "Objects Wireframe");
|
|
checkboxWireframe->set_checked(mApp->mAreObjectsWireframeEnabled);
|
|
checkboxWireframe->set_callback([&](bool value) {
|
|
mApp->mAreObjectsWireframeEnabled = value;
|
|
});
|
|
|
|
// Enabled/Disable VSync
|
|
CheckBox* checkboxVSync = new CheckBox(mRenderingPanel, "V-Sync");
|
|
checkboxVSync->set_checked(mApp->mIsVSyncEnabled);
|
|
checkboxVSync->set_callback([&](bool value) {
|
|
mApp->enableVSync(value);
|
|
});
|
|
|
|
// Enabled/Disable Shadows
|
|
CheckBox* checkboxShadows = new CheckBox(mRenderingPanel, "Shadows");
|
|
checkboxShadows->set_checked(mApp->mIsShadowMappingEnabled);
|
|
checkboxShadows->set_callback([&](bool value) {
|
|
mApp->mIsShadowMappingEnabled = value;
|
|
});
|
|
|
|
checkboxDebugRendererEnabled->set_callback([&, checkboxContactPoints, checkboxContactNormals,
|
|
checkboxBroadPhaseAABBs, checkboxColliderAABBs,
|
|
checkboxCollisionShapes](bool value) {
|
|
mApp->mIsDebugRendererEnabled = value;
|
|
checkboxContactPoints->set_enabled(value);
|
|
checkboxContactNormals->set_enabled(value);
|
|
checkboxBroadPhaseAABBs->set_enabled(value);
|
|
checkboxColliderAABBs->set_enabled(value);
|
|
checkboxCollisionShapes->set_enabled(value);
|
|
});
|
|
|
|
mPhysicsPanel->set_visible(true);
|
|
mRenderingPanel->set_visible(false);
|
|
}
|
|
|
|
void Gui::createProfilingPanel() {
|
|
|
|
Widget* profilingPanel = new Window(mApp, "Profiling");
|
|
profilingPanel->set_position(Vector2i(15, 525));
|
|
profilingPanel->set_layout(new BoxLayout(Orientation::Vertical, Alignment::Fill, 10, 5));
|
|
//profilingPanel->setId("SettingsPanel");
|
|
profilingPanel->set_fixed_width(220);
|
|
|
|
// Framerate (FPS)
|
|
mFPSLabel = new Label(profilingPanel, std::string("FPS : ") + floatToString(mCachedFPS, 0),"sans-bold");
|
|
|
|
// Update time
|
|
mFrameTimeLabel = new Label(profilingPanel, std::string("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + std::string(" ms"),"sans-bold");
|
|
|
|
// Total physics time
|
|
mTotalPhysicsTimeLabel = new Label(profilingPanel, std::string("Total physics time : ") + floatToString(mCachedTotalPhysicsUpdateTime * 1000.0, 1) + std::string(" ms"),"sans-bold");
|
|
|
|
// Physics step time
|
|
mPhysicsStepTimeLabel = new Label(profilingPanel, std::string("Physics step time : ") + floatToString(mCachedPhysicsStepTime * 1000.0, 1) + std::string(" ms"),"sans-bold");
|
|
|
|
profilingPanel->set_visible(true);
|
|
}
|
|
|