/** * @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; }