/**
* @brief
* Updates the text of the time scale text node
*/
void Application61::UpdateTimeScaleTextNode()
{
// Get the scene
SceneContainer *pSceneContainer = GetScene();
if (pSceneContainer) {
// Get the scene info text container
SceneContainer *pInfoTextContainer = static_cast<SceneContainer*>(pSceneContainer->GetByName("Parent.InfoText"));
if (pInfoTextContainer) {
// Get the time scale text scene node
SceneNode *pInfoTextNode = pInfoTextContainer->GetByName("TimeScale");
if (pInfoTextNode)
pInfoTextNode->SetAttribute("Text", PLT("1/2/0=Decrease/increase/reset timescale (current: ") + Timing::GetInstance()->GetTimeScaleFactor() + ')');
}
}
}
/**
* @brief
* Sets whether or not edit mode is enabled
*/
void EngineApplication::SetEditModeEnabled(bool bEnabled)
{
// State change?
if (m_bEditModeEnabled != bEnabled) {
// Backup the new state
m_bEditModeEnabled = bEnabled;
// Get the root scene
SceneContainer *pRootScene = GetRootScene();
if (pRootScene) {
// Enable/disable standard edit features from the PixelLight scene graph (if the user hasn't changed anything :)
SceneNode *pSceneNode = pRootScene->GetByName("PLEngine::SNEngineInformation0");
if (pSceneNode)
pSceneNode->SetActive(bEnabled);
pSceneNode = pRootScene->GetByName("PLEngine::SNConsole0");
if (pSceneNode)
pSceneNode->SetActive(bEnabled);
}
// Setup log level
Log::GetInstance()->SetLogLevel(static_cast<uint8>(m_bEditModeEnabled ? Log::Debug : Log::Info));
}
}
//[-------------------------------------------------------]
//[ Private virtual PLCore::AbstractFrontend functions ]
//[-------------------------------------------------------]
void Application60::OnUpdate()
{
// One important word at the beginning: DON'T COPYCAT THIS!
// The following is 'just' a simple demonstration how the scene graph 'can' be used. It's
// definitely not good to update your scene nodes in the way you can see within this function.
// Its quite to intricate, inflexible and not performant. Use for example a scene node modifier
// added to your scene node (in this case 'the white light') for this job!
// Call base implementation
EngineApplication::OnUpdate();
// Get the scene container with our 'concrete scene'
SceneContainer *pSceneContainer = GetScene();
if (pSceneContainer) {
// Get the scene node with the name 'Light' (our 'white light')
SceneNode *pLightSceneNode = pSceneContainer->GetByName("Light");
if (pLightSceneNode) {
// This variable is used for the light animation. Its just static you keep the implementation
// for a good sample overview completely within this function.
static float fLightTimer = 0.0f;
// Get a new fancy light position
const Vector3 vPosition(Math::Sin(fLightTimer), Math::Sin(fLightTimer)/2+2, -(Math::Cos(fLightTimer)+5));
// We set the current light position using the RTTI class interface. This is quite comfortable and
// universal because you haven't to care about the concrete class type - just set the variable values.
pLightSceneNode->SetAttribute("Position", Var<Vector3>(vPosition)); // More efficient
// Another way by using strings:
// pLightSceneNode->SetAttribute("Position", vPosition.ToString()); // More generic
// For highly performance critical situations it's recommend to avoid using these RTTI
// functions to set your variables and use the concrete provided class interfaces instead.
// Update the light timer by using the time difference between the last and the current frame
fLightTimer += Timing::GetInstance()->GetTimeDifference();
}
}
}
bool EngineApplication::LoadScene(const String &sFilename)
{
// Get the scene container holding our scene
SceneContainer *pContainer = GetScene();
if (!pContainer)
return false; // Error! (should NEVER happen...)
// Disable the ingame GUI
SceneNode *pGui = pContainer->GetContainer()->GetByName("GUI");
if (pGui)
pGui->SetActive(false);
// Clear the scene, after calling this method the scene is empty
ClearScene();
// Load the scene
bool bResult = pContainer->LoadByFilename(sFilename);
if (bResult) {
// Set a null pointer camera and default scene renderer
m_sDefaultSceneRenderer = "";
m_sSceneRendererVariables = "";
m_sClearColor = "";
m_sStartCamera = "";
m_pFirstFoundCamera = nullptr;
m_bHasLoadScreen = false;
// Get scene surface painter
SurfacePainter *pPainter = GetPainter();
if (pPainter && pPainter->IsInstanceOf("PLScene::SPScene")) {
// Assign the first found camera scene node to your surface listener and look for
// known key/value data scene nodes
SceneQuery *pSceneQuery = pContainer->CreateQuery("PLScene::SQEnumerate");
if (pSceneQuery) {
// Connect event handler
pSceneQuery->SignalSceneNode.Connect(EventHandlerSceneNode);
// Perform the query
pSceneQuery->PerformQuery();
// Destroy the query
pContainer->DestroyQuery(*pSceneQuery);
}
// Set to default scene renderer?
if (!m_sDefaultSceneRenderer.GetLength())
m_sDefaultSceneRenderer = DefaultSceneRenderer;
// Sets all scene renderer pass attribute values to their default value
GetSceneRendererTool().SetDefaultValues();
// Set the used scene renderer
GetSceneRendererTool().SetSceneRenderer(pContainer, m_sDefaultSceneRenderer, DefaultSceneRenderer);
// Set clear color
GetSceneRendererTool().SetPassAttribute("Begin", "ColorClear", m_sClearColor);
// Set scene renderer variables
if (m_sSceneRendererVariables.GetLength())
GetSceneRendererTool().SetValues(m_sSceneRendererVariables);
// Is there a given start camera?
SceneNode *pCamera = nullptr;
if (m_sStartCamera.GetLength()) {
SceneNode *pStartCamera = pContainer->GetByName(m_sStartCamera);
if (pStartCamera && pStartCamera->IsCamera())
pCamera = pStartCamera;
}
// Use the first found camera?
if (!pCamera)
pCamera = m_pFirstFoundCamera;
// Activate the current used camera by default
if (pCamera)
pCamera->SetActive(true);
// Assign this camera to the scene renderer and to the application
SetCamera(reinterpret_cast<SNCamera*>(pCamera));
}
// Emit the scene loading has been finished successfully event
SignalSceneLoadingFinished();
}
// Enable the ingame GUI
if (pGui)
pGui->SetActive(true);
// Done
return bResult;
}