//[-------------------------------------------------------]
//[ Protected virtual PLScene::SceneApplication functions ]
//[-------------------------------------------------------]
void EngineApplication::OnCreateRootScene()
{
// Get the scene context
SceneContext *pSceneContext = GetSceneContext();
if (pSceneContext) {
// First, create the scene root container which holds the scene container with our 'concrete' scene within it
SceneContainer *pRootContainer = pSceneContext->GetRoot() ? static_cast<SceneContainer*>(pSceneContext->GetRoot()->Create("PLScene::SceneContainer", "RootScene")) : nullptr;
if (pRootContainer) {
// Protect this important container!
pRootContainer->SetProtected(true);
// Create a scene container with our 'concrete scene'
SceneNode *pSceneContainerNode = pRootContainer->Create("PLScene::SceneContainer", "Scene");
if (pSceneContainerNode && pSceneContainerNode->IsInstanceOf("PLScene::SceneContainer")) {
SceneContainer *pSceneContainer = static_cast<SceneContainer*>(pSceneContainerNode);
// Protect this important container!
pSceneContainer->SetProtected(true);
// Connect event handler
if (pSceneContainerNode->IsInstanceOf("PLScene::SceneContainer"))
static_cast<SceneContainer*>(pSceneContainerNode)->SignalLoadProgress.Connect(EventHandlerLoadProgress);
// Create the 'concrete scene'
OnCreateScene(*pSceneContainer);
}
// Create scene node for engine information
SceneNode *pSceneNode = pRootContainer->Create("PLEngine::SNEngineInformation");
if (pSceneNode)
pSceneNode->SetActive(m_bEditModeEnabled);
// Create console scene node - using the console command 'timescale <value>' we
// can change the scene time (slowdown or accelerate)
pSceneNode = pRootContainer->Create("PLEngine::SNConsole");
if (pSceneNode && pSceneNode->GetClass()->IsDerivedFrom("PLEngine::SNConsoleBase")) {
SNConsoleBase *pConsole = static_cast<SNConsoleBase*>(pSceneNode);
// Register default commands
pConsole->RegisterCommand(0, "quit", "", "", Functor<void, ConsoleCommand &>(&EngineApplication::ConsoleCommandQuit, this));
pConsole->RegisterCommand(0, "exit", "", "", Functor<void, ConsoleCommand &>(&EngineApplication::ConsoleCommandQuit, this));
pConsole->RegisterCommand(0, "bye", "", "", Functor<void, ConsoleCommand &>(&EngineApplication::ConsoleCommandQuit, this));
pConsole->RegisterCommand(0, "logout", "", "", Functor<void, ConsoleCommand &>(&EngineApplication::ConsoleCommandQuit, this));
// Set active state
pConsole->SetActive(m_bEditModeEnabled);
}
}
// Set the root scene
SetRootScene(pRootContainer);
}
}
/**
* @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));
}
}
/**
* @brief
* Called when a scene node was found
*/
void EngineApplication::OnSceneNode(SceneQuery &cQuery, SceneNode &cSceneNode)
{
// Is this a camera?
if (cSceneNode.IsCamera()) {
if (!m_pFirstFoundCamera)
m_pFirstFoundCamera = &cSceneNode;
// Deactivate all camera's by default
cSceneNode.SetActive(false);
// Key/value data scene node?
} else if (cSceneNode.IsInstanceOf("PLScene::SNKeyValue")) {
const SNKeyValue &cKeyValue = static_cast<const SNKeyValue&>(cSceneNode);
// SceneRenderer
if (cKeyValue.Key.GetString() == "SceneRenderer") {
// Use the first found key
if (!m_sDefaultSceneRenderer.GetLength())
m_sDefaultSceneRenderer = cKeyValue.Value.GetString();
// SceneRendererVariables
} else if (cKeyValue.Key.GetString() == "SceneRendererVariables") {
// Use the first found key
if (!m_sSceneRendererVariables.GetLength())
m_sSceneRendererVariables = cKeyValue.Value.GetString();
// ClearColor
} else if (cKeyValue.Key.GetString() == "ClearColor") {
// Use the first found key
if (!m_sClearColor.GetLength())
m_sClearColor = cKeyValue.Value.GetString();
// StartCamera
} else if (cKeyValue.Key.GetString() == "StartCamera") {
// Use the first found key
if (!m_sStartCamera.GetLength())
m_sStartCamera = cKeyValue.Value.GetString();
}
// Load screen scene node?
} else if (cSceneNode.IsInstanceOf("PLEngine::SNLoadScreenBase")) {
m_bHasLoadScreen = true;
}
}
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;
}
/**
* @brief
* Called when a control event has occurred
*/
void Application65::OnControl(Control &cControl)
{
// Is it a button and was it just hit?
if (cControl.GetType() == ControlButton && reinterpret_cast<Button&>(cControl).IsHit()) {
// Check whether the escape key was pressed
if (cControl.GetName() == "KeyboardEscape") {
// Shut down the application
Exit(0);
// Show/hide the help text
} else if (cControl.GetName() == "KeyboardF1") {
// Get the info text scene node
SceneNode *pSceneNode = GetRootScene() ? GetRootScene()->GetByName("InfoText") : nullptr;
if (pSceneNode) {
// Toggle the active state of the scene node
pSceneNode->SetActive(!pSceneNode->IsActive());
}
// Toggle post processing
} else if (cControl.GetName() == "KeyboardSpace") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Loop through all available post process scene node modifiers
uint32 nIndex = 0;
SceneNodeModifier *pModifier = pCamera->GetModifier("PLCompositing::SNMPostProcess", nIndex);
while (pModifier) {
// Toggle the active state of the post process scene node modifier
pModifier->SetActive(!pModifier->IsActive());
// Next modifier, please
pModifier = pCamera->GetModifier("PLCompositing::SNMPostProcess", ++nIndex);
}
}
// Next post process effect
} else if (cControl.GetName() == "KeyboardPageUp") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Increase the current selected modifier index
m_nCurrentSelectedModifier++;
if (m_nCurrentSelectedModifier >= m_lstModifierClasses.GetNumOfElements())
m_nCurrentSelectedModifier = 0;
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier(m_lstModifierClasses[m_nCurrentSelectedModifier]->GetClassName());
}
// Previous post process effect
} else if (cControl.GetName() == "KeyboardPageDown") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Decrease the current selected modifier index
if (m_nCurrentSelectedModifier)
m_nCurrentSelectedModifier--;
else
m_nCurrentSelectedModifier = m_lstModifierClasses.GetNumOfElements()-1;
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier(m_lstModifierClasses[m_nCurrentSelectedModifier]->GetClassName());
}
// Custom post process effect: "Rainbow"
} else if (cControl.GetName() == "Keyboard1") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCrazyBars", "ColorScaleY=\"0.002\"");
}
// Custom post process effect: "Cartoon"
} else if (cControl.GetName() == "Keyboard2") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
}
// Custom post process effect: "Animated cartoon"
} else if (cControl.GetName() == "Keyboard3") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
}
// Custom post process effect: "Animated old cartoon"
} else if (cControl.GetName() == "Keyboard4") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
}
// Custom post process effect: "Scratch"
} else if (cControl.GetName() == "Keyboard5") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
}
// Custom post process effect: "Animated old scratch"
} else if (cControl.GetName() == "Keyboard6") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
}
// Custom post process effect: "Edge glow"
} else if (cControl.GetName() == "Keyboard7") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "Filename=\"Data/PostProcesses/EdgeGlow.pp\"");
}
}
}
}
