Decoupled Systems and Scenes. Every EngineState now owns a separate instance of a SystemScene and all the Systems are shared and initialized once

Moved Systems initialization from EngineState to Engine
Added scene arrays in every System, methods for creating, getting and destroying SystemScenes
Added a way to reorder RenderPasses in the same RenderSystem instance. RenderScene now owns a list of RenderPass orders
Added initialization flags to every RenderPass
Added more error codes and error strings
Fixed a bug of GUI Docking windows being left enabled after exiting EditorState, thus rendering over the whole screen in PlayState
Fixed a bug in PhysicsScene of heap corruption during the scene destruction

.gitignore

@@ -37,3 +37,7 @@ Praxis3D/x64/Debug/CodeAnalysisResultManifest.txt
 Builds/x64/Debug/Praxis3D.exe
 Builds/x64/Debug/Praxis3D.exe
 Praxis3D/Data/Sounds/
+compileData.scor
+compileData.scor.gbl
+compileData.scor.incl
+compileData.scor.t0000

Praxis3D/Data/Maps/componentTest.pmap

@@ -57,7 +57,26 @@
 			{
 				"LuaComponent":
 				{
-					"Filename": "GUI_test.lua"
+					"Filename": "GUI_test.lua",
+					"Variables":
+					[
+						{
+							"Name": "cameraSpeed",
+							"Value": "10.0f"
+						},
+						{
+							"Name": "cameraSpeedMultiplier",
+							"Value": "10.0f"
+						},
+						{
+							"Name": "stringTest",
+							"Value": "test1"
+						},
+						{
+							"Name": "boolTest",
+							"Value": "false"
+						}
+					]
 				}
 			}
 		},
@@ -201,6 +220,24 @@
 				}
 			}
 		},
+		{
+			"ID": "44",
+			"Name": "Cube3",
+			"Parent": "0",
+			"Prefab": "cube1.prefab",
+			"World":
+			{
+				"ObjectMaterialComponent":
+				{
+					"Type": "Wood"
+				},
+				"SpatialComponent":
+				{
+					"LocalPosition": "8.0f, 3.0f, 0.0f",
+					"LocalRotation": "0.0f, 45.0f, 0.0f"
+				}
+			}
+		},
 		{
 			"ID": "4",
 			"Name": "Sphere 1",
@@ -468,10 +505,7 @@
 		{
 			"Scene":
 			{
-				"ObjectPoolSize": "50"
-			},
-			"System":
-			{
+				"ObjectPoolSize": "50",
 				"RenderPasses":
 				[
 					{
@@ -499,6 +533,9 @@
 						"Type": "GUIRenderPass"
 					}
 				]
+			},
+			"System":
+			{
 			}
 		},
 		"Script":

Praxis3D/Data/Maps/mainMenu.pmap

@@ -75,10 +75,7 @@
 		{
 			"Scene":
 			{
-				"ObjectPoolSize": "50"
-			},
-			"System":
-			{
+				"ObjectPoolSize": "50",
 				"RenderPasses":
 				[
 					{
@@ -100,6 +97,9 @@
 						"Type": "GUIRenderPass"
 					}
 				]
+			},
+			"System":
+			{
 			}
 		},
 		"Script":

Praxis3D/Data/Shaders/finalPass.frag

@@ -95,5 +95,5 @@ void main(void)
 	//fragmentColor = gammaCorrection(fragmentColor, gamma);
 	
 	// Write the color to the framebuffer
-	outputColor = vec4(fragmentColor, 1.0);	
+	outputColor = vec4(fragmentColor, 1.0);
 }

Praxis3D/Data/error-strings-eng.data

@@ -1,47 +1,49 @@
 {
 	"Error Codes":
 	{
-		"Undefined"												: "Undefined",
-		"Success"													: "Succeed",
-		"Failure"													: "Failed",
-		"Initialize_success"							: "Has been initialized",
-		"Initialize_failure"							: "Failed to initialized",
-		"File_not_found"									: "File missing",
-		"Filename_empty"									: "Filename is empty",
-		"Audio_no_drivers"								: "System has no sound devices",
-		"Audio_system_init_failed"				: "Audio system has failed to initialize",
-		"Destroy_obj_not_found"						: "Destruction: object not found",
-		"Glew_failed"											: "OpenGL Extension Wrangler Library has failed to initialize",
-		"Ifstream_failed"									: "Unable to read input file stream",
-		"Clock_QueryFrequency"						: "Unable to query the clock frequency",
-		"Framebuffer_failed"							: "Framebuffer has failed to load",
-		"Geometrybuffer_failed"						: "Geometry buffer has failed to load",
-		"Editor_path_outside_current_dir"	: "Selected file path is outside of current working directory",
-		"GL_context_missing"							: "Failed to get GL context handle",
-		"Window_handle_missing"						: "Failed to get window handle",
-		"AssimpScene_failed"							: "Assimp scene has failed to load",
-		"ObjectPool_full"									: "Object pool overflow",
-		"Collision_invalid"								: "Invalid collision type",
-		"Collision_missing"								: "Collision shape missing",
-		"Kinematic_has_mass"							: "Kinematic object has a mass greater than zero",
-		"Property_missing_size"						: "Missing 'Size' property",
-		"Property_missing_radius"					: "Missing 'Radius' property",
-		"Property_missing_type"						: "Missing 'Type' property",
-		"Property_no_filename"						: "No filename specified",
-		"Shader_attach_failed"						: "Attaching shaders to GPU program has failed",
-		"Shader_compile_failed"						: "Shader compilation from source code has failed to load",
-		"Shader_creation_failed"					: "Shader handle creation has failed",
-		"Shader_link_failed"							: "Shader linking has failed",
-		"Shader_loading_failed"						: "Shader has failed to load",
-		"GameObjects_missing"							: "GameObjects missing from the map file",
-		"Texture_not_found"								: "Texture was not found",
-		"Texture_empty"										: "Texture data was not found",
-		"Invalid_num_vid_displays"				: "Invalid number of video displays",
-		"SDL_video_init_failed"						: "SDL Video has failed to initialize",
-		"SDL_vsync_failed"								: "Failed to change vertical synchronization mode",
-		"Window_creation_failed"					: "Unable to create a window",
-		"Invalid_object_id"								: "Invalid game object ID",
-		"Duplicate_object_id"							: "Duplicate game object ID"
+		"Undefined"													: "Undefined",
+		"Success"														: "Succeed",
+		"Failure"														: "Failed",
+		"Initialize_success"								: "Has been initialized",
+		"Initialize_failure"								: "Failed to initialized",
+		"File_not_found"										: "File missing",
+		"Filename_empty"										: "Filename is empty",
+		"Audio_no_drivers"									: "System has no sound devices",
+		"Audio_system_init_failed"					: "Audio system has failed to initialize",
+		"Destroy_obj_not_found"							: "Destruction: object not found",
+		"Glew_failed"												: "OpenGL Extension Wrangler Library has failed to initialize",
+		"Ifstream_failed"										: "Unable to read input file stream",
+		"Clock_QueryFrequency"							: "Unable to query the clock frequency",
+		"Framebuffer_failed"								: "Framebuffer has failed to load",
+		"Geometrybuffer_failed"							: "Geometry buffer has failed to load",
+		"Editor_path_outside_current_dir"		: "Selected file path is outside of current working directory",
+		"GL_context_missing"								: "Failed to get GL context handle",
+		"Universal_scene_extend_null"				: "Invalid scene was passed while trying to extend the Universal Scene",
+		"Universal_scene_extend_duplicate"	: "Duplicate scene was passed while trying to extend the Universal Scene",
+		"Window_handle_missing"							: "Failed to get window handle",
+		"AssimpScene_failed"								: "Assimp scene has failed to load",
+		"ObjectPool_full"										: "Object pool overflow",
+		"Collision_invalid"									: "Invalid collision type",
+		"Collision_missing"									: "Collision shape missing",
+		"Kinematic_has_mass"								: "Kinematic object has a mass greater than zero",
+		"Property_missing_size"							: "Missing 'Size' property",
+		"Property_missing_radius"						: "Missing 'Radius' property",
+		"Property_missing_type"							: "Missing 'Type' property",
+		"Property_no_filename"							: "No filename specified",
+		"Shader_attach_failed"							: "Attaching shaders to GPU program has failed",
+		"Shader_compile_failed"							: "Shader compilation from source code has failed to load",
+		"Shader_creation_failed"						: "Shader handle creation has failed",
+		"Shader_link_failed"								: "Shader linking has failed",
+		"Shader_loading_failed"							: "Shader has failed to load",
+		"GameObjects_missing"								: "GameObjects missing from the map file",
+		"Texture_not_found"									: "Texture was not found",
+		"Texture_empty"											: "Texture data was not found",
+		"Invalid_num_vid_displays"					: "Invalid number of video displays",
+		"SDL_video_init_failed"							: "SDL Video has failed to initialize",
+		"SDL_vsync_failed"									: "Failed to change vertical synchronization mode",
+		"Window_creation_failed"						: "Unable to create a window",
+		"Invalid_object_id"									: "Invalid game object ID",
+		"Duplicate_object_id"								: "Duplicate game object ID"
 	},
 	"Error Sources":
 	{
@@ -101,6 +103,7 @@
 		"Source_SkyPass"									: "Sky Rendering Pass",
 		"Source_SoundComponent"						: "Sound Component",
 		"Source_SoundListenerComponent"		: "Sound Listener Component",
+		"Source_UniversalScene"						: "Universal Scene",
 		"Source_TextureLoader"						: "Texture Loader",
 		"Source_Window"										: "Window System",
 		"Source_World"										: "World",

Praxis3D/Praxis3D.vcxproj

@@ -207,7 +207,6 @@
     <ClCompile Include="Source\Universal.cpp" />
     <ClCompile Include="Source\Window.cpp" />
     <ClCompile Include="Source\WindowLocator.cpp" />
-    <ClCompile Include="Source\WorldEditState.cpp" />
     <ClCompile Include="Source\WorldScene.cpp" />
     <ClCompile Include="Source\WorldTask.cpp" />
   </ItemGroup>
@@ -369,7 +368,6 @@
     <ClInclude Include="Source\Window.h" />
     <ClInclude Include="Source\WindowLocator.h" />
     <ClInclude Include="Source\WorldEditObject.h" />
-    <ClInclude Include="Source\WorldEditState.h" />
     <ClInclude Include="Source\WorldScene.h" />
     <ClInclude Include="Source\WorldSystem.h" />
     <ClInclude Include="Source\WorldTask.h" />

Praxis3D/Praxis3D.vcxproj.filters

@@ -324,9 +324,6 @@
     <ClCompile Include="Source\PlayState.cpp">
       <Filter>Engine States\Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\WorldEditState.cpp">
-      <Filter>Engine States\Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\RendererBackend.cpp">
       <Filter>Renderer\Source Files</Filter>
     </ClCompile>
@@ -632,9 +629,6 @@
     <ClInclude Include="Source\PlayState.h">
       <Filter>Engine States\Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Source\WorldEditState.h">
-      <Filter>Engine States\Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Source\WorldEditObject.h">
       <Filter>Scripting\Objects\Header Files</Filter>
     </ClInclude>

Praxis3D/Source/AtmScatteringPass.h

@@ -114,7 +114,10 @@ public:
 
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_AtmScatteringPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_AtmScatteringPass);
 

Praxis3D/Source/AudioScene.cpp

@@ -548,7 +548,7 @@ void AudioScene::exportComponents(const EntityID p_entityID, AudioComponentsCons
 SystemObject *AudioScene::createComponent(const EntityID &p_entityID, const SoundComponent::SoundComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene*>(m_sceneLoader->getSystemScene(Systems::World));
@@ -616,7 +616,7 @@ SystemObject *AudioScene::createComponent(const EntityID &p_entityID, const Soun
 SystemObject *AudioScene::createComponent(const EntityID &p_entityID, const SoundListenerComponent::SoundListenerComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene*>(m_sceneLoader->getSystemScene(Systems::World));

Praxis3D/Source/AudioSystem.h

@@ -9,10 +9,17 @@ class AudioSystem : public SystemBase
 public:
 	AudioSystem()
 	{
-		m_audioScene = nullptr;
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			m_audioScenes[i] = nullptr;
+
 		m_systemName = GetString(Systems::Audio);
 	}
-	~AudioSystem() { }
+	~AudioSystem()
+	{
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			if(m_audioScenes[i] != nullptr)
+				delete m_audioScenes[i];
+	}
 
 	ErrorCode init()
 	{
@@ -41,26 +48,34 @@ public:
 
 	Systems::TypeID getSystemType() { return Systems::Audio; }
 
-	SystemScene *createScene(SceneLoader *p_sceneLoader)
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 	{
-		if(m_audioScene == nullptr)
+		if(m_audioScenes[p_engineState] == nullptr)
 		{
 			// Create new scene
-			m_audioScene = new AudioScene(this, p_sceneLoader);
-			ErrorCode sceneError = m_audioScene->init();
+			m_audioScenes[p_engineState] = new AudioScene(this, p_sceneLoader);
+			ErrorCode sceneError = m_audioScenes[p_engineState]->init();
 
 			// Check if it initialized correctly (cannot continue without the scene)
 			if(sceneError != ErrorCode::Success)
 			{
 				ErrHandlerLoc::get().log(sceneError, ErrorSource::Source_AudioScene);
+				delete m_audioScenes[p_engineState];
+				m_audioScenes[p_engineState] = nullptr;
 			}
 		}
 
-		return m_audioScene;
+		return m_audioScenes[p_engineState];
 	}
 
-	SystemScene *getScene() { return m_audioScene; }
+	SystemScene *getScene(EngineStateType p_engineState) { return m_audioScenes[p_engineState]; }
+
+	void deleteScene(EngineStateType p_engineState)
+	{
+		if(m_audioScenes[p_engineState] != nullptr)
+			delete m_audioScenes[p_engineState];
+	}
 
 protected:
-	AudioScene *m_audioScene;
+	AudioScene *m_audioScenes[EngineStateType::EngineStateType_NumOfTypes];
 };

Praxis3D/Source/BloomCompositePass.h

@@ -38,6 +38,9 @@ public:
 		else
 			returnError = shaderError;
 		
+		if(returnError == ErrorCode::Success)
+			setInitialized(true);
+
 		return returnError;
 	}
 

Praxis3D/Source/BloomPass.h

@@ -47,6 +47,7 @@ public:
 		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_BloomPass);
 			returnError = ErrorCode::Success;
+			setInitialized(true);
 		}
 		else
 		{

Praxis3D/Source/BlurPass.h

@@ -52,7 +52,10 @@ public:
 		
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_BlurPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_BlurPass);
 

Praxis3D/Source/CommonDefinitions.h

@@ -13,9 +13,11 @@ constexpr EntityID NULL_ENTITY_ID = std::numeric_limits<EntityID>::max();
 
 enum EngineStateType : unsigned int
 {
-	EngineStateType_MainMenu = 0,
+	EngineStateType_Default = 0,
+	EngineStateType_MainMenu = EngineStateType_Default,
 	EngineStateType_Play,
-	EngineStateType_Editor
+	EngineStateType_Editor,
+	EngineStateType_NumOfTypes
 };
 
 enum BindCommandType : unsigned int
@@ -54,6 +56,7 @@ enum RenderPassType : unsigned int
 	RenderPassType_GUI,
 	RenderPassType_NumOfTypes
 };
+typedef std::vector<RenderPassType> RenderingPasses;
 
 enum BufferType : unsigned int
 {

Praxis3D/Source/EditorState.cpp

@@ -7,7 +7,7 @@
 #include "RendererSystem.h"
 #include "WorldSystem.h"
 
-EditorState::EditorState() : EngineState()
+EditorState::EditorState(Engine &p_engine) : EngineState(p_engine, EngineStateType::EngineStateType_Editor)
 {
 }
 

Praxis3D/Source/EditorState.h

@@ -8,7 +8,7 @@
 class EditorState : public EngineState
 {
 public:
-	EditorState();
+	EditorState(Engine &p_engine);
 	~EditorState();
 
 	ErrorCode init(TaskManager *p_taskManager);
@@ -18,8 +18,6 @@ public:
 
 	void deactivate();
 
-	const EngineStateType getEngineStateType() final { return EngineStateType::EngineStateType_Editor; }
-
 private:
 	EditorWindowSettings m_editorWindowSettings;
 };

Praxis3D/Source/EditorWindow.cpp

@@ -27,6 +27,12 @@
 #include <imgui_tex_inspect.h>
 #include <imgui/imgui_stdlib.h>
 
+EditorWindow::~EditorWindow()
+{
+    // Tell the renderer to draw the scene to the screen
+    m_systemScene->getSceneLoader()->getChangeController()->sendData(m_systemScene->getSceneLoader()->getSystemScene(Systems::Graphics), DataType::DataType_RenderToTexture, (void *)false);
+}
+
 ErrorCode EditorWindow::init()
 {
     return ErrorCode::Success;
@@ -34,6 +40,9 @@ ErrorCode EditorWindow::init()
 
 void EditorWindow::update(const float p_deltaTime)
 {
+    // Set the docking area over the whole screen
+    ImGui::DockSpaceOverViewport(ImGui::GetMainViewport());
+
     // Clear the texture inspector functor sequence from the last frame
     m_textureInspectorSequence.swapBuffer();
     m_textureInspectorSequence.getFront().clear();
@@ -156,7 +165,7 @@ void EditorWindow::update(const float p_deltaTime)
                     m_fileBrowserDialog.m_definedFilename = m_systemScene->getSceneLoader()->getSceneFilename();
                     m_fileBrowserDialog.m_filter = ".pmap,.*";
                     m_fileBrowserDialog.m_title = "Open scene";
-                    m_fileBrowserDialog.m_name = "##OpenSceneFileDialog";
+                    m_fileBrowserDialog.m_name = "OpenSceneFileDialog";
                     m_fileBrowserDialog.m_rootPath = Config::filepathVar().map_path;
 
                     // Tell the GUI scene to open the file browser
@@ -178,7 +187,7 @@ void EditorWindow::update(const float p_deltaTime)
                     m_fileBrowserDialog.m_flags = FileBrowserDialog::FileBrowserDialogFlags::FileBrowserDialogFlags_ConfirmOverwrite;
                     m_fileBrowserDialog.m_filter = ".pmap,.*";
                     m_fileBrowserDialog.m_title = "Save scene";
-                    m_fileBrowserDialog.m_name = "##SaveSceneFileDialog";
+                    m_fileBrowserDialog.m_name = "SaveSceneFileDialog";
                     m_fileBrowserDialog.m_rootPath = Config::filepathVar().map_path;
                     
                     // Tell the GUI scene to open the file browser
@@ -863,7 +872,7 @@ void EditorWindow::update(const float p_deltaTime)
                                         // Define file browser variables
                                         m_fileBrowserDialog.m_filter = ".lua,.*";
                                         m_fileBrowserDialog.m_title = "Open LUA script file";
-                                        m_fileBrowserDialog.m_name = "##OpenLuaScriptFileDialog";
+                                        m_fileBrowserDialog.m_name = "OpenLuaScriptFileDialog";
                                         m_fileBrowserDialog.m_rootPath = Config::filepathVar().script_path;
 
                                         // Tell the GUI scene to open the file browser
@@ -1399,6 +1408,14 @@ void EditorWindow::update(const float p_deltaTime)
     }
 }
 
+void EditorWindow::activate()
+{
+}
+
+void EditorWindow::deactivate()
+{
+}
+
 void EditorWindow::setup(EditorWindowSettings &p_editorWindowSettings)
 {
     ImGuiTexInspect::ImplOpenGL3_Init();

Praxis3D/Source/EditorWindow.h

@@ -3,6 +3,7 @@
 #include "ComponentConstructorInfo.h"
 #include "ErrorHandlerLocator.h"
 #include "GUIHandler.h"
+#include "GUIHandlerLocator.h"
 #include "LightComponent.h"
 #include "Loaders.h"
 #include "InheritanceObjects.h"
@@ -37,7 +38,7 @@ public:
 		for(unsigned int i = 0; i < ObjectMaterialType::NumberOfMaterialTypes; i++)
 			m_physicalMaterialProperties.push_back(GetString(static_cast<ObjectMaterialType>(i)));
 	}
-	~EditorWindow() { }
+	~EditorWindow();
 
 	ErrorCode init();
 
@@ -47,68 +48,9 @@ public:
 
 	void update(const float p_deltaTime);
 
-	ErrorCode importObject(const PropertySet &p_properties) final override
-	{
-		ErrorCode importError = ErrorCode::Failure;
-
-		// Check if PropertySet isn't empty and the component hasn't been loaded already
-		if(p_properties)// && !isLoadedToMemory())
-		{
-			if(p_properties.getPropertyID() == Properties::Sequence)
-			{
-				importError = ErrorCode::Success;
-				/*			auto const &luaFilenameProperty = p_properties.getPropertyByID(Properties::Filename);
-
-							if(luaFilenameProperty)
-							{
-								std::string luaFilename = luaFilenameProperty.getString();
-								if(!luaFilename.empty())
-								{
-									luaFilename = Config::filepathVar().script_path + luaFilename;
-									if(Filesystem::exists(luaFilename))
-									{
-										m_luaScript.setScriptFilename(luaFilename);
-
-										importError = ErrorCode::Success;
-										ErrHandlerLoc().get().log(ErrorType::Info, ErrorSource::Source_LuaComponent, m_name + " - Script loaded");
-									}
-									else
-									{
-										importError = ErrorCode::File_not_found;
-										ErrHandlerLoc().get().log(ErrorType::Warning, ErrorSource::Source_LuaComponent, m_name + " - File \'" + luaFilename + "\' not found");
-									}
-								}
-								else
-								{
-									importError = ErrorCode::Property_no_filename;
-									ErrHandlerLoc().get().log(ErrorType::Warning, ErrorSource::Source_LuaComponent, m_name + " - Property \'" + GetString(Properties::Filename) + "\' is empty");
-								}
-							}
-							else
-							{
-								importError = ErrorCode::Property_no_filename;
-								ErrHandlerLoc().get().log(ErrorType::Warning, ErrorSource::Source_LuaComponent, m_name + " - Missing \'" + GetString(Properties::Filename) + "\' property");
-							}*/
-			}
-
-			if(importError == ErrorCode::Success)
-			{
-				//setLoadedToMemory(true);
-				//setLoadedToVideoMemory(true);
-				setActive(true);
-			}
-		}
-
-		return importError;
-	}
+	void activate();
 
-	PropertySet exportObject() final override
-	{
-		// Create the root Camera property set
-		PropertySet propertySet(Properties::Camera);
-
-		return propertySet;
-	}
+	void deactivate();
 
 	// System type is GUI
 	BitMask getSystemType() final override { return Systems::GUI; }

Praxis3D/Source/Engine.cpp

@@ -21,7 +21,7 @@ int Engine::m_instances = 0;
 
 #define ENUMTOSTRING(ENUM) #ENUM
 
-Engine::Engine()
+Engine::Engine() : m_mainMenuState(*this), m_playstate(*this), m_editorState(*this)
 {
 	m_instances++;
 	m_initialized = false;
@@ -61,13 +61,18 @@ ErrorCode Engine::init()
 	if(servicesError != ErrorCode::Success)
 		return servicesError;
 
+	// Initialize all engine systems
+	auto systemsError = initSystems();
+	if(systemsError != ErrorCode::Success)
+		return systemsError;
+
 	//  ___________________________________
 	// |								   |
 	// |	ENGINE STATE INITIALIZATION	   |
 	// |___________________________________|
 	// Set and initialize the current engine state
 	setCurrentStateType();
-	if(!m_currentState->isInitialized())
+	if(m_currentState == nullptr || !m_currentState->isInitialized())
 		return ErrorCode::Failure;
 
 	// If this point is reached, all initializations passed, mark the engine as initialized
@@ -284,7 +289,7 @@ ErrorCode Engine::initServices()
 	m_GUIHandler = new GUIHandler();
 	ErrorCode guiError = m_GUIHandler->init();
 
-	// Check if gui handler was initialized successfully
+	// Check if the GUI handler was initialized successfully
 	// If so, register it in GUI Handler locator and Window system
 	// and enable GUI in Window system
 	if(guiError == ErrorCode::Success)
@@ -299,6 +304,85 @@ ErrorCode Engine::initServices()
 	return returnError;
 }
 
+ErrorCode Engine::initSystems()
+{
+	ErrorCode returnError = ErrorCode::Success;
+
+	//  __________________________________
+	// |								  |
+	// |   AUDIO SYSTEM INITIALIZATION	  |
+	// |__________________________________|
+	// Create audio system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::Audio] = new AudioSystem();
+	if(m_systems[Systems::Audio]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::Audio];
+		m_systems[Systems::Audio] = &g_nullSystemBase;
+	}
+
+	//  __________________________________
+	// |								  |
+	// |  RENDERER SYSTEM INITIALIZATION  |
+	// |__________________________________|
+	// Create graphics system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::Graphics] = new RendererSystem();
+	if(m_systems[Systems::Graphics]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::Graphics];
+		m_systems[Systems::Graphics] = &g_nullSystemBase;
+	}
+
+	//  ___________________________________
+	// |								   |
+	// |	 GUI SYSTEM INITIALIZATION	   |
+	// |___________________________________|
+	// Create GUI system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::GUI] = new GUISystem();
+	if(m_systems[Systems::GUI]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::GUI];
+		m_systems[Systems::GUI] = &g_nullSystemBase;
+	}
+
+	//  ___________________________________
+	// |								   |
+	// |   PHYSICS SYSTEM INITIALIZATION   |
+	// |___________________________________|
+	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::Physics] = new PhysicsSystem();
+	if(m_systems[Systems::Physics]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::Physics];
+		m_systems[Systems::Physics] = &g_nullSystemBase;
+	}
+
+	//  ___________________________________
+	// |								   |
+	// |  SCRIPTING SYSTEM INITIALIZATION  |
+	// |___________________________________|
+	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::Script] = new ScriptSystem();
+	if(m_systems[Systems::Script]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::Script];
+		m_systems[Systems::Script] = &g_nullSystemBase;
+	}
+
+	//  ___________________________________
+	// |								   |
+	// |	WORLD SYSTEM INITIALIZATION	   |
+	// |___________________________________|
+	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
+	m_systems[Systems::World] = new WorldSystem();
+	if(m_systems[Systems::World]->init() != ErrorCode::Success)
+	{
+		delete m_systems[Systems::World];
+		m_systems[Systems::World] = &g_nullSystemBase;
+	}
+
+	return returnError;
+}
+
 void Engine::shutdown()
 {
 	// Shutdown engine states

Praxis3D/Source/Engine.h

@@ -14,6 +14,7 @@
 // Class containing a complete one instance of the engine.
 class Engine
 {
+	friend class EngineState;
 public:
 	Engine();
 	~Engine();
@@ -25,6 +26,9 @@ public:
 	void run();
 
 private:
+	// Get all engine systems. Return a pointer to an array the size of Systems::NumberOfSystems
+	SystemBase **getSystems() { return m_systems; }
+
 	// Sets which engine state is currently active
 	void setCurrentStateType()
 	{
@@ -59,7 +63,8 @@ private:
 			if(stateInitError != ErrorCode::Success)
 			{
 				m_currentState = previousState;
-				m_currentStateType = m_currentState->getEngineStateType();
+				if(m_currentState != nullptr)
+					m_currentStateType = m_currentState->getEngineStateType();
 				ErrHandlerLoc::get().log(stateInitError, ErrorSource::Source_Engine);
 			}
 		}
@@ -78,6 +83,9 @@ private:
 	// Creates and initializes all the services and their locators
 	ErrorCode initServices();
 
+	// Creates and initializes all the engine systems
+	ErrorCode initSystems();
+
 	// Shuts all the systems, etc. down, called before returning from run()
 	void shutdown();
 
@@ -90,6 +98,9 @@ private:
 	PlayState m_playstate;
 	EditorState m_editorState;
 
+	// All engine systems
+	SystemBase *m_systems[Systems::NumberOfSystems];
+	
 	// Various required services
 	ErrorHandler *m_errorHandler;
 	GUIHandler *m_GUIHandler;

Praxis3D/Source/EngineState.cpp

@@ -1,5 +1,6 @@
 
 #include "AudioSystem.h"
+#include "Engine.h"
 #include "EngineState.h"
 #include "GUISystem.h"
 #include "PhysicsSystem.h"
@@ -7,7 +8,7 @@
 #include "ScriptSystem.h"
 #include "WorldSystem.h"
 
-EngineState::EngineState() : m_initialized(false)
+EngineState::EngineState(Engine &p_engine, EngineStateType p_engineState) : m_engine(p_engine), m_engineStateType(p_engineState), m_initialized(false)
 {
 	m_sceneChangeController = new ChangeController();
 	m_objectChangeController = new ChangeController();
@@ -15,8 +16,8 @@ EngineState::EngineState() : m_initialized(false)
 	m_scheduler = nullptr;
 	m_changeCtrlScene = nullptr;
 
-	for(int i = 0; i < Systems::NumberOfSystems; i++)
-		m_systems[i] = nullptr;
+	//for(int i = 0; i < Systems::NumberOfSystems; i++)
+	//	m_systems[i] = nullptr;
 }
 
 EngineState::~EngineState()
@@ -35,33 +36,41 @@ ErrorCode EngineState::init(TaskManager *p_taskManager)
 	if(m_initialized)
 		shutdown();
 
-	// Initialize all engine systems
-	returnError = initSystems();
-	if(returnError == ErrorCode::Success)
-	{
-		// Create new scene change controller
-		m_changeCtrlScene = new UniversalScene(m_sceneChangeController, m_objectChangeController);
+	// Get all engine systems
+	auto systems = m_engine.getSystems();
 
-		// Create new scheduler for updating (executing) scenes
-		m_scheduler = new TaskScheduler(p_taskManager);
+	// Create new scene change controller
+	m_changeCtrlScene = new UniversalScene(m_sceneChangeController, m_objectChangeController);
 
-		// Use the created scene change controller in our scene loader
-		m_sceneLoader.registerChangeController(m_changeCtrlScene);
+	// Create new scheduler for updating (executing) scenes
+	m_scheduler = new TaskScheduler(p_taskManager);
 
-		// Create new scenes from each system to be used by this play state
-		// Register systems with change controller and scenes with scene loader
-		for(int i = 0; i < Systems::NumberOfSystems; i++)
-		{
-			m_sceneLoader.registerSystemScene(m_systems[i]->createScene(&m_sceneLoader));
-			m_changeCtrlScene->extend(m_systems[i]);
-		}
+	// Use the created scene change controller in our scene loader
+	m_sceneLoader.registerChangeController(m_changeCtrlScene);
+
+	// Create new scenes from each system to be used by this play state
+	// Register systems with change controller and scenes with scene loader
+	for(int i = 0; i < Systems::NumberOfSystems; i++)
+	{
+		// Create new system scene
+		auto newScene = systems[i]->createScene(&m_sceneLoader, m_engineStateType);
+
+		m_sceneLoader.registerSystemScene(newScene);
+		auto extendError = m_changeCtrlScene->extend(newScene);
+		if(extendError != ErrorCode::Success)
+			returnError = extendError;
+	}
 
+	if(returnError == ErrorCode::Success)
+	{
 		// Register change control scene with the scheduler
 		m_scheduler->setScene(m_changeCtrlScene);
 
 		// Register task manager with object and scene change controllers
-		m_objectChangeController->setTaskManager(p_taskManager);
-		m_sceneChangeController->setTaskManager(p_taskManager);
+		returnError = m_objectChangeController->setTaskManager(p_taskManager);
+
+		if(returnError == ErrorCode::Success)
+			returnError = m_sceneChangeController->setTaskManager(p_taskManager);
 	}
 
 	return returnError;
@@ -99,90 +108,15 @@ void EngineState::shutdown()
 		if(m_objectChangeController != nullptr)
 			delete m_objectChangeController;
 
-		// Delete all created systems
+		// Get all engine systems
+		auto systems = m_engine.getSystems();
+
+		// Delete all system scenes that belong to this engine state
 		for(int i = 0; i < Systems::NumberOfSystems; i++)
-			if(m_systems[i]->getSystemType() != Systems::Null)
-				delete m_systems[i];
+		{
+			systems[i]->deleteScene(m_engineStateType);
+		}
 
 		m_initialized = false;
 	}
-}
-
-ErrorCode EngineState::initSystems()
-{
-	ErrorCode returnError = ErrorCode::Success;
-
-	//  __________________________________
-	// |								  |
-	// |   AUDIO SYSTEM INITIALIZATION	  |
-	// |__________________________________|
-	// Create audio system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Audio] = new AudioSystem();
-	if(m_systems[Systems::Audio]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Audio];
-		m_systems[Systems::Audio] = &g_nullSystemBase;
-	}
-
-	//  __________________________________
-	// |								  |
-	// |  RENDERER SYSTEM INITIALIZATION  |
-	// |__________________________________|
-	// Create graphics system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Graphics] = new RendererSystem();
-	if(m_systems[Systems::Graphics]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Graphics];
-		m_systems[Systems::Graphics] = &g_nullSystemBase;
-	}
-
-	//  ___________________________________
-	// |								   |
-	// |	 GUI SYSTEM INITIALIZATION	   |
-	// |___________________________________|
-	// Create GUI system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::GUI] = new GUISystem();
-	if(m_systems[Systems::GUI]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::GUI];
-		m_systems[Systems::GUI] = &g_nullSystemBase;
-	}
-
-	//  ___________________________________
-	// |								   |
-	// |   PHYSICS SYSTEM INITIALIZATION   |
-	// |___________________________________|
-	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Physics] = new PhysicsSystem();
-	if(m_systems[Systems::Physics]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Physics];
-		m_systems[Systems::Physics] = &g_nullSystemBase;
-	}
-
-	//  ___________________________________
-	// |								   |
-	// |  SCRIPTING SYSTEM INITIALIZATION  |
-	// |___________________________________|
-	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Script] = new ScriptSystem();
-	if(m_systems[Systems::Script]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Script];
-		m_systems[Systems::Script] = &g_nullSystemBase;
-	}
-
-	//  ___________________________________
-	// |								   |
-	// |	WORLD SYSTEM INITIALIZATION	   |
-	// |___________________________________|
-	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::World] = new WorldSystem();
-	if(m_systems[Systems::World]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::World];
-		m_systems[Systems::World] = &g_nullSystemBase;
-	}
-
-	return returnError;
 }

Praxis3D/Source/EngineState.h

@@ -13,7 +13,7 @@ class SystemBase;
 class EngineState
 {
 public:
-	EngineState();
+	EngineState(Engine &p_engine, EngineStateType p_engineState);
 	virtual ~EngineState();
 
 	virtual ErrorCode init(TaskManager *p_taskManager);
@@ -26,20 +26,18 @@ public:
 
 	virtual void shutdown();
 
-	virtual const EngineStateType getEngineStateType() = 0;
+	const inline EngineStateType getEngineStateType() { return m_engineStateType; }
 
 	const inline bool isInitialized() const { return m_initialized; }
 
 protected:
-	// Creates and initializes all the engine systems
-	ErrorCode initSystems();
-
 	bool m_initialized;
+	EngineStateType m_engineStateType;
 
-	// All engine systems
-	SystemBase *m_systems[Systems::NumberOfSystems];
+	// Reference to engine, used for getting systems
+	Engine &m_engine;
 
-	// System scenes register
+	// System scenes loader and register
 	SceneLoader m_sceneLoader;
 
 	// Multi-threading task scheduler

Praxis3D/Source/ErrorCodes.h

@@ -56,6 +56,8 @@ DECLARE_ENUM(ErrorType, ERROR_TYPES)
 	/* GUI errors */ \
 	Code(Editor_path_outside_current_dir,) \
 	Code(GL_context_missing,) \
+	Code(Universal_scene_extend_null,) \
+	Code(Universal_scene_extend_duplicate,) \
 	Code(Window_handle_missing,) \
 	/* Model loader errors */ \
 	Code(AssimpScene_failed,) \
@@ -152,6 +154,7 @@ DECLARE_ENUM(ErrorCode, ERROR_CODES)
     Code(Source_SoundComponent,) \
     Code(Source_SoundListenerComponent,) \
     Code(Source_TextureLoader,) \
+    Code(Source_UniversalScene,) \
     Code(Source_Window,) \
     Code(Source_World,) \
     Code(Source_WorldScene,) \

Praxis3D/Source/ErrorHandler.cpp

@@ -38,6 +38,8 @@ ErrorHandler::ErrorHandler()
 	AssignErrorType(Geometrybuffer_failed, FatalError);
 	AssignErrorType(Editor_path_outside_current_dir, Warning);
 	AssignErrorType(GL_context_missing, Error);
+	AssignErrorType(Universal_scene_extend_null, Error);
+	AssignErrorType(Universal_scene_extend_duplicate, Error);
 	AssignErrorType(Window_handle_missing, Error);
 	AssignErrorType(AssimpScene_failed, Error);
 	AssignErrorType(ObjectPool_full, Warning); 

Praxis3D/Source/FinalPass.h

@@ -36,7 +36,10 @@ public:
 		
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_FinalPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_FinalPass);
 

Praxis3D/Source/GUIHandler.h

@@ -29,6 +29,12 @@ public:
 	// Get an atomic flag that marks when the GUI frame is ready to be rendered
 	inline std::atomic_flag &getFrameReadyFlag()  { return m_frameReady; }
 
+	// Enable docking windows
+	void enableDocking() { }
+
+	// Disable docking windows
+	void disableDocking() { }
+
 protected:
 	virtual ErrorCode init() { return ErrorCode::Success; }
 
@@ -87,6 +93,16 @@ public:
 		ImGui_ImplSDL2_ProcessEvent(&p_SDLEvent);
 	}
 
+	void enableDocking()
+	{
+		m_io->ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+	}
+
+	void disableDocking()
+	{
+		m_io->ConfigFlags &= ~(ImGuiConfigFlags_DockingEnable);
+	}
+
 protected:
 	ErrorCode init()
 	{
@@ -95,7 +111,7 @@ protected:
 		// Setup Dear ImGui context
 		IMGUI_CHECKVERSION();
 		ImGui::CreateContext();
-		m_io = &ImGui::GetIO(); //(void)m_io;
+		m_io = &ImGui::GetIO();
 
 		// Enable docking if it is set in the config
 		if(Config::GUIVar().gui_docking_enabled)
@@ -144,10 +160,6 @@ protected:
 
 		// Begin new GUI frame (prepares frame to receive new GUI calls)
 		ImGui::NewFrame();
-
-		// If docking is enabled, set the whole main viewport as a docking area
-		if(Config::GUIVar().gui_docking_enabled)
-			ImGui::DockSpaceOverViewport(ImGui::GetMainViewport());
 	}
 
 	void render();

Praxis3D/Source/GUIHandlerLocator.h

@@ -7,6 +7,7 @@
 // an empty (null) service if it hasn't been initialized. Uses dependency injection pattern.
 class GUIHandlerLocator
 {
+	friend class EditorWindow;
 	friend class Engine;
 	friend class GUIPass;
 	friend class GUIScene;

Praxis3D/Source/GUIPass.h

@@ -22,7 +22,10 @@ public:
 
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_GUIPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_GUIPass);
 

Praxis3D/Source/GUIScene.cpp

@@ -65,6 +65,18 @@ void GUIScene::exportSetup(PropertySet &p_propertySet)
 	objectPoolSizePropertySet.addProperty(Properties::GUISequenceComponent, (int)worldScene->getPoolSize<GUISequenceComponent>());
 }
 
+void GUIScene::activate()
+{
+	if(m_editorWindow != nullptr)
+		m_editorWindow->activate();
+}
+
+void GUIScene::deactivate()
+{
+	if(m_editorWindow != nullptr)
+		m_editorWindow->deactivate();
+}
+
 void GUIScene::update(const float p_deltaTime)
 {
 	if(Config::GUIVar().gui_render)
@@ -220,7 +232,7 @@ void GUIScene::exportComponents(const EntityID p_entityID, GUIComponentsConstruc
 SystemObject *GUIScene::createComponent(const EntityID p_entityID, const GUISequenceComponent::GUISequenceComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {	
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene *>(m_sceneLoader->getSystemScene(Systems::World));
@@ -295,6 +307,8 @@ void GUIScene::receiveData(const DataType p_dataType, void *p_data, const bool p
 			}
 			else // If the editor window does exist, just send the settings to it
 				m_editorWindow->setup(*editorWindowSettings);
+
+			GUIHandlerLocator::get().enableDocking();
 		}
 		else // If the editor should be disabled
 		{

Praxis3D/Source/GUIScene.h

@@ -92,6 +92,10 @@ public:
 
 	void exportSetup(PropertySet &p_propertySet);
 
+	void activate();
+
+	void deactivate();
+
 	void update(const float p_deltaTime);
 
 	ErrorCode preload();

Praxis3D/Source/GUISystem.h

@@ -9,11 +9,17 @@ class GUISystem : public SystemBase
 public:
 	GUISystem()
 	{
-		m_GUIScene = nullptr;
-		//m_guiHandler = nullptr;
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			m_GUIScenes[i] = nullptr;
+
 		m_systemName = GetString(Systems::GUI);
 	}
-	~GUISystem() { }
+	~GUISystem()
+	{
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			if(m_GUIScenes[i] != nullptr)
+				delete m_GUIScenes[i];
+	}
 
 	ErrorCode init()
 	{
@@ -39,13 +45,13 @@ public:
 
 	Systems::TypeID getSystemType() { return Systems::GUI; }
 
-	SystemScene *createScene(SceneLoader *p_sceneLoader)
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 	{
-		if (m_GUIScene == nullptr)
+		if(m_GUIScenes[p_engineState] == nullptr)
 		{
 			// Create new scene
-			m_GUIScene = new GUIScene(this, p_sceneLoader);
-			ErrorCode sceneError = m_GUIScene->init();
+			m_GUIScenes[p_engineState] = new GUIScene(this, p_sceneLoader);
+			ErrorCode sceneError = m_GUIScenes[p_engineState]->init();
 
 			// Check if it initialized correctly (cannot continue without the scene)
 			if (sceneError != ErrorCode::Success)
@@ -59,19 +65,17 @@ public:
 			}
 		}
 
-		return m_GUIScene;
+		return m_GUIScenes[p_engineState];
 	}
 
-	SystemScene* getScene() { return m_GUIScene; }
-
-	// Set the GUI Handler, so it can be used to draw GUI to the framebuffer at the end of the frame
-	//inline void setGUIHanlder(GUIHandler *p_guiHandler) { m_guiHandler = p_guiHandler; }
+	SystemScene* getScene(EngineStateType p_engineState) { return m_GUIScenes[p_engineState]; }
 
-	// Get the GUI Handler; returns nullptr if the GUI Handler is not set
-	//inline GUIHandler *getGUIHanlder() { return m_guiHandler; }
+	void deleteScene(EngineStateType p_engineState)
+	{
+		if(m_GUIScenes[p_engineState] != nullptr)
+			delete m_GUIScenes[p_engineState];
+	}
 
 protected:
-	GUIScene* m_GUIScene;
-
-	//GUIHandler *m_guiHandler;
+	GUIScene *m_GUIScenes[EngineStateType::EngineStateType_NumOfTypes];
 };

Praxis3D/Source/GeometryPass.h

@@ -33,6 +33,8 @@ public:
 
 			// Log a successful initialization
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_GeometryPass);
+
+			setInitialized(true);
 		}
 		else
 		{

Praxis3D/Source/HdrMappingPass.h

@@ -58,7 +58,10 @@ public:
 		
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_HdrMappingPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_HdrMappingPass);
 

Praxis3D/Source/LenseFlareCompositePass.h

@@ -22,7 +22,7 @@ public:
 		ErrorCode shaderError = ErrorCode::Success;
 
 		m_name = "Lense Flare Composite Rendering Pass";
-		
+
 		// Set buffer values
 		m_diffuseAndOutputBuffers.resize(2);
 		m_diffuseAndOutputBuffers[0] = m_renderer.m_backend.getGeometryBuffer()->getBufferLocation(GBufferTextureType::GBufferDiffuse);
@@ -44,18 +44,21 @@ public:
 			m_renderer.queueForLoading(*m_lenseFlareShader);	// Queue the shader to be loaded to GPU
 		else
 			returnError = shaderError;
-		
+
 		// Create textures for lens flare effect and load them to memory
 		m_lensFlareDirt.loadToMemory();
 		m_lenseFlareStarburst.loadToMemory();
-		
+
 		// Queue lens flare textures for loading to GPU
 		m_renderer.queueForLoading(m_lensFlareDirt);
 		m_renderer.queueForLoading(m_lenseFlareStarburst);
 
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_LensFlareCompositePass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_LensFlareCompositePass);
 

Praxis3D/Source/LenseFlarePass.h

@@ -42,7 +42,7 @@ public:
 		ErrorCode shaderError;
 
 		m_name = "Lense Flare Rendering Pass";
-		
+
 		// Set buffer values
 		m_diffuseAndOutputBuffers.resize(2);
 		m_diffuseAndOutputBuffers[0] = m_renderer.m_backend.getGeometryBuffer()->getBufferLocation(GBufferTextureType::GBufferDiffuse);
@@ -64,26 +64,29 @@ public:
 			m_renderer.queueForLoading(*m_lenseFlareShader);	// Queue the shader to be loaded to GPU
 		else
 			returnError = shaderError;
-		
+
 		// Set lens flare parameters buffer shader binding index
 		m_lensFlareParamBuffer.m_bindingIndex = UniformBufferBinding_LensFlareParam;
 
 		// Set lens flare parameters buffer size and data
 		m_lensFlareParamBuffer.m_size = sizeof(LensFlareParameters);
-		m_lensFlareParamBuffer.m_data = (void*)(&m_lensFlareParam);
+		m_lensFlareParamBuffer.m_data = (void *)(&m_lensFlareParam);
 
 		// Queue lens flare parameters buffer to be created
 		m_renderer.queueForLoading(m_lensFlareParamBuffer);
 
 		// Create textures for lens flare effect and load them to memory
 		m_lensFlareGhostGradient.loadToMemory();
-		
+
 		// Queue lens flare textures for loading to GPU
 		m_renderer.queueForLoading(m_lensFlareGhostGradient);
-		
+
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_LensFlarePass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_LensFlarePass);
 

Praxis3D/Source/LightingPass.h

@@ -30,7 +30,7 @@ public:
 		m_spotLightBuffer.m_size = sizeof(SpotLightDataSet) * m_maxNumSpotLights;
 		m_pointLights.reserve(m_maxNumPointLights);
 		m_spotLights.reserve(m_maxNumSpotLights);
-		
+
 		// Set buffer values
 		m_emissiveAndOutputBuffers.resize(2);
 		m_emissiveAndOutputBuffers[0] = m_renderer.m_backend.getGeometryBuffer()->getBufferLocation(GBufferTextureType::GBufferEmissive);
@@ -56,10 +56,13 @@ public:
 		// Queue light buffers to be created
 		m_renderer.queueForLoading(m_pointLightBuffer);
 		m_renderer.queueForLoading(m_spotLightBuffer);
-		
+
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_LightingPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_LightingPass);
 

Praxis3D/Source/LuminancePass.h

@@ -71,6 +71,8 @@ public:
 			m_renderer.queueForLoading(m_histogramBuffer);
 			m_renderer.queueForLoading(m_luminanceAverageTexture);
 
+			setInitialized(true);
+
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_LuminancePass);
 		}
 		else

Praxis3D/Source/MainMenuState.cpp

@@ -8,7 +8,7 @@
 #include "RendererSystem.h"
 #include "WorldSystem.h"
 
-MainMenuState::MainMenuState() : EngineState()
+MainMenuState::MainMenuState(Engine &p_engine) : EngineState(p_engine, EngineStateType::EngineStateType_MainMenu)
 {
 }
 

Praxis3D/Source/MainMenuState.h

@@ -8,13 +8,11 @@
 class MainMenuState : public EngineState
 {
 public:
-	MainMenuState();
+	MainMenuState(Engine &p_engine);
 	~MainMenuState();
 
 	ErrorCode init(TaskManager *p_taskManager);
 	void update(Engine &p_engine);
 
-	const EngineStateType getEngineStateType() final { return EngineStateType::EngineStateType_MainMenu; }
-
 private:
 };

Praxis3D/Source/NullSystemObjects.cpp

@@ -4,12 +4,12 @@ NullSystemScene NullSystemBase::m_nullSystemScene(nullptr);
 NullSystemTask NullSystemScene::m_nullSystemTask(nullptr);
 NullSystemObject NullSystemScene::m_nullSystemObject;
 
-SystemScene *NullSystemBase::createScene(SceneLoader *p_sceneLoader)
+SystemScene *NullSystemBase::createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 {
 	return &m_nullSystemScene;
 }
 
-SystemScene *NullSystemBase::getScene()
+SystemScene *NullSystemBase::getScene(EngineStateType p_engineState)
 {
 	return &m_nullSystemScene;
 }

Praxis3D/Source/NullSystemObjects.h

@@ -15,14 +15,14 @@ public:
 
 	ErrorCode setup(const PropertySet &p_properties) { return ErrorCode::Success; }
 
-	//ErrorCode destroyScene(SystemScene *p_systemScene) { return ErrorCode::Success; }
-
 	std::string getName() { return ""; }
 	Systems::TypeID getSystemType() { return Systems::Null; }
 
-	SystemScene *createScene(SceneLoader *p_sceneLoader);
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState);
+
+	SystemScene *getScene(EngineStateType p_engineState);
 
-	SystemScene *getScene();
+	void deleteScene(EngineStateType p_engineState) { }
 
 	void loadInBackground() { }
 

Praxis3D/Source/PhysicsScene.cpp

@@ -19,20 +19,20 @@ PhysicsScene::PhysicsScene(SystemBase *p_system, SceneLoader *p_sceneLoader) : S
 
 PhysicsScene::~PhysicsScene()
 {
-	//remove the rigidbodies from the dynamics world and delete them
+	// Remove the rigidbodies from the dynamics world and delete them
 	for(int i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
 	{
 		btCollisionObject *obj = m_dynamicsWorld->getCollisionObjectArray()[i];
 		btRigidBody *body = btRigidBody::upcast(obj);
-		if(body && body->getMotionState())
+		if(body)
 		{
-			delete body->getMotionState();
+			delete static_cast<EntityID *>(body->getUserPointer());
 		}
 		m_dynamicsWorld->removeCollisionObject(obj);
 		delete obj;
 	}
 
-	//delete collision shapes
+	// Delete collision shapes
 	for(int i = 0; i < m_collisionShapes.size(); i++)
 	{
 		btCollisionShape *shape = m_collisionShapes[i];
@@ -40,27 +40,27 @@ PhysicsScene::~PhysicsScene()
 		delete shape;
 	}
 
-	//delete dynamics world
+	// Delete dynamics world
 	if(m_dynamicsWorld != nullptr)
 		delete m_dynamicsWorld;
 
-	//delete solver
+	// Delete solver
 	if(m_collisionSolver != nullptr)
 		delete m_collisionSolver;
 
-	//delete broadphase
+	// Delete broadphase
 	if(m_collisionBroadphase != nullptr)
 		delete m_collisionBroadphase;
 
-	//delete dispatcher
+	// Delete dispatcher
 	if(m_collisionDispatcher != nullptr)
 		delete m_collisionDispatcher;
 
-	//delete collision configuration
+	// Delete collision configuration
 	if(m_collisionConfiguration != nullptr)
 		delete m_collisionConfiguration;
 
-	//next line is optional: it will be cleared by the destructor when the array goes out of scope
+	// Next line is optional: it will be cleared by the destructor when the array goes out of scope
 	m_collisionShapes.clear();
 }
 
@@ -374,7 +374,7 @@ void PhysicsScene::exportComponents(const EntityID p_entityID, PhysicsComponents
 SystemObject *PhysicsScene::createComponent(const EntityID &p_entityID, const RigidBodyComponent::RigidBodyComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene*>(m_sceneLoader->getSystemScene(Systems::World));

Praxis3D/Source/PhysicsSystem.h

@@ -9,10 +9,17 @@ class PhysicsSystem : public SystemBase
 public:
 	PhysicsSystem()
 	{
-		m_physicsScene = nullptr;
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			m_physicsScenes[i] = nullptr;
+
 		m_systemName = GetString(Systems::Physics);
 	}
-	~PhysicsSystem() { }
+	~PhysicsSystem()
+	{
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			if(m_physicsScenes[i] != nullptr)
+				delete m_physicsScenes[i];
+	}
 
 	ErrorCode init()
 	{
@@ -40,13 +47,13 @@ public:
 
 	Systems::TypeID getSystemType() { return Systems::Physics; }
 
-	SystemScene *createScene(SceneLoader *p_sceneLoader)
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 	{
-		if(m_physicsScene == nullptr)
+		if(m_physicsScenes[p_engineState] == nullptr)
 		{
 			// Create new scene
-			m_physicsScene = new PhysicsScene(this, p_sceneLoader);
-			ErrorCode sceneError = m_physicsScene->init();
+			m_physicsScenes[p_engineState] = new PhysicsScene(this, p_sceneLoader);
+			ErrorCode sceneError = m_physicsScenes[p_engineState]->init();
 
 			// Check if it initialized correctly (cannot continue without the scene)
 			if(sceneError != ErrorCode::Success)
@@ -55,11 +62,17 @@ public:
 			}
 		}
 
-		return m_physicsScene;
+		return m_physicsScenes[p_engineState];
 	}
 
-	SystemScene *getScene() { return m_physicsScene; }
+	SystemScene *getScene(EngineStateType p_engineState) { return m_physicsScenes[p_engineState]; }
+
+	void deleteScene(EngineStateType p_engineState)
+	{
+		if(m_physicsScenes[p_engineState] != nullptr)
+			delete m_physicsScenes[p_engineState];
+	}
 
 protected:
-	PhysicsScene *m_physicsScene;
+	PhysicsScene *m_physicsScenes[EngineStateType::EngineStateType_NumOfTypes];
 };

Praxis3D/Source/PlayState.cpp

@@ -8,7 +8,7 @@
 #include "RendererSystem.h"
 #include "WorldSystem.h"
 
-PlayState::PlayState() : EngineState()
+PlayState::PlayState(Engine &p_engine) : EngineState(p_engine, EngineStateType::EngineStateType_Play)
 {
 }
 

Praxis3D/Source/PlayState.h

@@ -8,13 +8,11 @@
 class PlayState : public EngineState
 {
 public:
-	PlayState();
+	PlayState(Engine &p_engine);
 	~PlayState();
 
 	ErrorCode init(TaskManager *p_taskManager);
 	void update(Engine &p_engine);
 
-	const EngineStateType getEngineStateType() final { return EngineStateType::EngineStateType_Play; }
-
 private:
 };

Praxis3D/Source/PostProcessPass.h

@@ -30,7 +30,7 @@ public:
 		ErrorCode shaderError;
 
 		m_name = "Post Process Rendering Pass";
-		
+
 		// Set buffer values
 		m_diffuseAndOutputBuffers.resize(2);
 		m_diffuseAndOutputBuffers[0] = m_renderer.m_backend.getGeometryBuffer()->getBufferLocation(GBufferTextureType::GBufferDiffuse);
@@ -52,28 +52,31 @@ public:
 			m_renderer.queueForLoading(*m_postProcessShader);	// Queue the shader to be loaded to GPU
 		else
 			returnError = shaderError;
-		
+
 		// Set lens flare parameters buffer shader binding index
 		m_lensFlareParamBuffer.m_bindingIndex = UniformBufferBinding_LensFlareParam;
 
 		// Set lens flare parameters buffer size and data
 		m_lensFlareParamBuffer.m_size = sizeof(LensFlareParameters);
-		m_lensFlareParamBuffer.m_data = (void*)(&m_lensFlareParam);
+		m_lensFlareParamBuffer.m_data = (void *)(&m_lensFlareParam);
 
 		// Queue lens flare parameters buffer to be created
 		m_renderer.queueForLoading(m_lensFlareParamBuffer);
 
 		// Create textures for lens flare effect and load them to memory
 		m_lensFlareGhostGradient.loadToMemory();
-		
+
 		// Queue lens flare textures for loading to GPU
 		m_renderer.queueForLoading(m_lensFlareGhostGradient);
 
 		//Loaders::texture2D().load(m_materialNames.m_materials[matType][i].m_filename, static_cast<MaterialType>(matType), false)
-		
+
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_PostProcessPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_PostProcessPass);
 

Praxis3D/Source/ReflectionPass.h

@@ -31,10 +31,13 @@ public:
 			// Queue the shaders to be loaded to GPU
 			m_renderer.queueForLoading(*m_shaderReflectionPass);
 		}
-		
+
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_ReflectionPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_ReflectionPass);
 

Praxis3D/Source/RenderPassBase.h

@@ -83,7 +83,7 @@ struct RenderPassData
 class RenderPass
 {
 public:
-	RenderPass(RendererFrontend &p_renderer, RenderPassType p_renderPassType) : m_renderer(p_renderer), m_renderPassType(p_renderPassType), m_ID(0) { }
+	RenderPass(RendererFrontend &p_renderer, RenderPassType p_renderPassType) : m_renderer(p_renderer), m_renderPassType(p_renderPassType), m_ID(0), m_initialized(false) { }
 	virtual ~RenderPass() { }
 
 	virtual ErrorCode init() = 0;
@@ -97,9 +97,13 @@ public:
 	inline const std::string &getName() const { return m_name; }
 	inline unsigned int getID() const { return m_ID; }
 	RenderPassType getRenderPassType() const { return m_renderPassType; }
+	inline bool isInitialized() const { return m_initialized; }
 
 protected:
+	inline void setInitialized(const bool p_initialized) { m_initialized = p_initialized; }
+
 	unsigned int m_ID;
+	bool m_initialized;
 	RenderPassType m_renderPassType;
 	std::string m_name;
 

Praxis3D/Source/RendererFrontend.cpp

@@ -25,7 +25,7 @@ RendererFrontend::RendererFrontend() : m_renderPassData(nullptr)
 
 	m_renderingPassesSet = false;
 	for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
-		m_initializedRenderingPasses[i] = nullptr;
+		m_allRenderPasses[i] = nullptr;
 
 	/*/ Set up the order of the rendering passes
 	m_renderingPassesTypes.push_back(RenderPassType::RenderPassType_Geometry);
@@ -110,8 +110,8 @@ RendererFrontend::~RendererFrontend()
 	for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
 	{
 		// Check if has been created
-		if(m_initializedRenderingPasses[i] != nullptr)
-			delete m_initializedRenderingPasses[i];
+		if(m_allRenderPasses[i] != nullptr)
+			delete m_allRenderPasses[i];
 	}
 
 	delete m_renderPassData;
@@ -174,70 +174,140 @@ void RendererFrontend::setRenderingPasses(const RenderingPasses &p_renderingPass
 	m_renderingPassesSet = true;
 
 	// Make sure the entries of the rendering passes are set to nullptr
-	for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
-	{
-		if(m_initializedRenderingPasses[i] != nullptr)
-			delete m_initializedRenderingPasses[i];
+	//for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
+	//{
+	//	if(m_initializedRenderingPasses[i] != nullptr)
+	//		delete m_initializedRenderingPasses[i];
 
-		m_initializedRenderingPasses[i] = nullptr;
-	}
+	//	m_initializedRenderingPasses[i] = nullptr;
+	//}
+
+	m_activeRenderPasses.clear();
 
 	bool guiRenderPassSet = false;
 
 	// Create rendering passes
+	//for(decltype(p_renderingPasses.size()) i = 0, size = p_renderingPasses.size(); i < size; i++)
+	//{
+	//	switch(p_renderingPasses[i])
+	//	{
+	//	case RenderPassType_Geometry:
+	//		if(m_initializedRenderingPasses[RenderPassType_Geometry] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Geometry] = new GeometryPass(*this);
+	//		break;
+	//	case RenderPassType_Lighting:
+	//		if(m_initializedRenderingPasses[RenderPassType_Lighting] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Lighting] = new LightingPass(*this);
+	//		break;
+	//	case RenderPassType_AtmScattering:
+	//		if(m_initializedRenderingPasses[RenderPassType_AtmScattering] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_AtmScattering] = new AtmScatteringPass(*this);
+	//		break;
+	//	case RenderPassType_HdrMapping:
+	//		if(m_initializedRenderingPasses[RenderPassType_HdrMapping] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_HdrMapping] = new HdrMappingPass(*this);
+	//		break;
+	//	case RenderPassType_Blur:
+	//		if(m_initializedRenderingPasses[RenderPassType_Blur] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Blur] = new BlurPass(*this);
+	//		break;
+	//	case RenderPassType_Bloom:
+	//		if(m_initializedRenderingPasses[RenderPassType_Bloom] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Bloom] = new BloomPass(*this);
+	//		break;
+	//	case RenderPassType_BloomComposite:
+	//		if(m_initializedRenderingPasses[RenderPassType_BloomComposite] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_BloomComposite] = new BloomCompositePass(*this);
+	//		break;
+	//	case RenderPassType_LenseFlare:
+	//		if(m_initializedRenderingPasses[RenderPassType_LenseFlare] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_LenseFlare] = new LenseFlarePass(*this);
+	//		break;
+	//	case RenderPassType_LenseFlareComposite:
+	//		if(m_initializedRenderingPasses[RenderPassType_LenseFlareComposite] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_LenseFlareComposite] = new LenseFlareCompositePass(*this);
+	//		break;
+	//	case RenderPassType_Luminance:
+	//		if(m_initializedRenderingPasses[RenderPassType_Luminance] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Luminance] = new LuminancePass(*this);
+	//		break;
+	//	case RenderPassType_Final:
+	//		if(m_initializedRenderingPasses[RenderPassType_Final] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_Final] = new FinalPass(*this);
+	//		break;
+	//	case RenderPassType_GUI:
+	//		if(m_initializedRenderingPasses[RenderPassType_GUI] == nullptr)
+	//			m_initializedRenderingPasses[RenderPassType_GUI] = new GUIPass(*this);
+	//		guiRenderPassSet = true;
+	//		break;
+	//	}
+	//}
+
 	for(decltype(p_renderingPasses.size()) i = 0, size = p_renderingPasses.size(); i < size; i++)
 	{
 		switch(p_renderingPasses[i])
 		{
-		case RenderPassType_Geometry:
-			if(m_initializedRenderingPasses[RenderPassType_Geometry] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Geometry] = new GeometryPass(*this);
-			break;
-		case RenderPassType_Lighting:
-			if(m_initializedRenderingPasses[RenderPassType_Lighting] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Lighting] = new LightingPass(*this);
-			break;
-		case RenderPassType_AtmScattering:
-			if(m_initializedRenderingPasses[RenderPassType_AtmScattering] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_AtmScattering] = new AtmScatteringPass(*this);
-			break;
-		case RenderPassType_HdrMapping:
-			if(m_initializedRenderingPasses[RenderPassType_HdrMapping] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_HdrMapping] = new HdrMappingPass(*this);
-			break;
-		case RenderPassType_Blur:
-			if(m_initializedRenderingPasses[RenderPassType_Blur] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Blur] = new BlurPass(*this);
-			break;
-		case RenderPassType_Bloom:
-			if(m_initializedRenderingPasses[RenderPassType_Bloom] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Bloom] = new BloomPass(*this);
-			break;
-		case RenderPassType_BloomComposite:
-			if(m_initializedRenderingPasses[RenderPassType_BloomComposite] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_BloomComposite] = new BloomCompositePass(*this);
-			break;
-		case RenderPassType_LenseFlare:
-			if(m_initializedRenderingPasses[RenderPassType_LenseFlare] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_LenseFlare] = new LenseFlarePass(*this);
-			break;
-		case RenderPassType_LenseFlareComposite:
-			if(m_initializedRenderingPasses[RenderPassType_LenseFlareComposite] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_LenseFlareComposite] = new LenseFlareCompositePass(*this);
-			break;
-		case RenderPassType_Luminance:
-			if(m_initializedRenderingPasses[RenderPassType_Luminance] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Luminance] = new LuminancePass(*this);
-			break;
-		case RenderPassType_Final:
-			if(m_initializedRenderingPasses[RenderPassType_Final] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_Final] = new FinalPass(*this);
-			break;
-		case RenderPassType_GUI:
-			if(m_initializedRenderingPasses[RenderPassType_GUI] == nullptr)
-				m_initializedRenderingPasses[RenderPassType_GUI] = new GUIPass(*this);
-			guiRenderPassSet = true;
-			break;
+			case RenderPassType_Geometry:
+				if(m_allRenderPasses[RenderPassType_Geometry] == nullptr)
+					m_allRenderPasses[RenderPassType_Geometry] = new GeometryPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Geometry]);
+				break;
+			case RenderPassType_Lighting:
+				if(m_allRenderPasses[RenderPassType_Lighting] == nullptr)
+					m_allRenderPasses[RenderPassType_Lighting] = new LightingPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Lighting]);
+				break;
+			case RenderPassType_AtmScattering:
+				if(m_allRenderPasses[RenderPassType_AtmScattering] == nullptr)
+					m_allRenderPasses[RenderPassType_AtmScattering] = new AtmScatteringPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_AtmScattering]);
+				break;
+			case RenderPassType_HdrMapping:
+				if(m_allRenderPasses[RenderPassType_HdrMapping] == nullptr)
+					m_allRenderPasses[RenderPassType_HdrMapping] = new HdrMappingPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_HdrMapping]);
+				break;
+			case RenderPassType_Blur:
+				if(m_allRenderPasses[RenderPassType_Blur] == nullptr)
+					m_allRenderPasses[RenderPassType_Blur] = new BlurPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Blur]);
+				break;
+			case RenderPassType_Bloom:
+				if(m_allRenderPasses[RenderPassType_Bloom] == nullptr)
+					m_allRenderPasses[RenderPassType_Bloom] = new BloomPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Bloom]);
+				break;
+			case RenderPassType_BloomComposite:
+				if(m_allRenderPasses[RenderPassType_BloomComposite] == nullptr)
+					m_allRenderPasses[RenderPassType_BloomComposite] = new BloomCompositePass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_BloomComposite]);
+				break;
+			case RenderPassType_LenseFlare:
+				if(m_allRenderPasses[RenderPassType_LenseFlare] == nullptr)
+					m_allRenderPasses[RenderPassType_LenseFlare] = new LenseFlarePass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_LenseFlare]);
+				break;
+			case RenderPassType_LenseFlareComposite:
+				if(m_allRenderPasses[RenderPassType_LenseFlareComposite] == nullptr)
+					m_allRenderPasses[RenderPassType_LenseFlareComposite] = new LenseFlareCompositePass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_LenseFlareComposite]);
+				break;
+			case RenderPassType_Luminance:
+				if(m_allRenderPasses[RenderPassType_Luminance] == nullptr)
+					m_allRenderPasses[RenderPassType_Luminance] = new LuminancePass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Luminance]);
+				break;
+			case RenderPassType_Final:
+				if(m_allRenderPasses[RenderPassType_Final] == nullptr)
+					m_allRenderPasses[RenderPassType_Final] = new FinalPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_Final]);
+				break;
+			case RenderPassType_GUI:
+				if(m_allRenderPasses[RenderPassType_GUI] == nullptr)
+					m_allRenderPasses[RenderPassType_GUI] = new GUIPass(*this);
+				m_activeRenderPasses.push_back(m_allRenderPasses[RenderPassType_GUI]);
+				guiRenderPassSet = true;
+				break;
 		}
 	}
 
@@ -248,32 +318,48 @@ void RendererFrontend::setRenderingPasses(const RenderingPasses &p_renderingPass
 		if(m_guiRenderWasEnabled)
 			Config::m_GUIVar.gui_render = true;
 
-	// Initialize rendering passes
-	for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
+	for(decltype(m_activeRenderPasses.size()) size = m_activeRenderPasses.size(), i = 0; i < size; i++)
 	{
-		// Check if has been created
-		if(m_initializedRenderingPasses[i] != nullptr)
+		if(!m_activeRenderPasses[i]->isInitialized())
 		{
 			// Initialize the rendering pass and check if it was successful
-			if(m_initializedRenderingPasses[i]->init() != ErrorCode::Success)
+			if(m_activeRenderPasses[i]->init() != ErrorCode::Success)
 			{
 				// Log an error and delete the rendering pass
-				ErrHandlerLoc::get().log(ErrorType::Error, ErrorSource::Source_Renderer, m_initializedRenderingPasses[i]->getName() + " failed to load.");
-				delete m_initializedRenderingPasses[i];
-				m_initializedRenderingPasses[i] = nullptr;
+				ErrHandlerLoc::get().log(ErrorType::Error, ErrorSource::Source_Renderer, m_activeRenderPasses[i]->getName() + " failed to load.");
+				m_activeRenderPasses.erase(m_activeRenderPasses.begin() + i);
+				i--;
 			}
 		}
 	}
 
-	// Reserve the required space for rendering passes array
-	m_renderingPasses.reserve(p_renderingPasses.size());
-
-	// Add required rendering passes to the main array
-	for(decltype(p_renderingPasses.size()) i = 0, size = p_renderingPasses.size(); i < size; i++)
-	{
-		if(m_initializedRenderingPasses[p_renderingPasses[i]] != nullptr)
-			m_renderingPasses.push_back(m_initializedRenderingPasses[p_renderingPasses[i]]);
-	}
+	// Initialize rendering passes
+	//for(unsigned int i = 0; i < RenderPassType::RenderPassType_NumOfTypes; i++)
+	//{
+	//	// Check if has been created
+	//	if(m_initializedRenderingPasses[i] != nullptr)
+	//	{
+	//		// Initialize the rendering pass and check if it was successful
+	//		if(m_initializedRenderingPasses[i]->init() != ErrorCode::Success)
+	//		{
+	//			// Log an error and delete the rendering pass
+	//			ErrHandlerLoc::get().log(ErrorType::Error, ErrorSource::Source_Renderer, m_initializedRenderingPasses[i]->getName() + " failed to load.");
+	//			delete m_initializedRenderingPasses[i];
+	//			m_initializedRenderingPasses[i] = nullptr;
+	//		}
+	//	}
+	//}
+
+	//// Reserve the required space for rendering passes array
+	//m_renderingPasses.clear();
+	//m_renderingPasses.reserve(p_renderingPasses.size());
+
+	//// Add required rendering passes to the main array
+	//for(decltype(p_renderingPasses.size()) i = 0, size = p_renderingPasses.size(); i < size; i++)
+	//{
+	//	if(m_initializedRenderingPasses[p_renderingPasses[i]] != nullptr)
+	//		m_renderingPasses.push_back(m_initializedRenderingPasses[p_renderingPasses[i]]);
+	//}
 
 	//passLoadCommandsToBackend();
 	glViewport(0, 0, m_frameData.m_screenSize.x, m_frameData.m_screenSize.y);
@@ -283,7 +369,7 @@ const RenderingPasses RendererFrontend::getRenderingPasses()
 {
 	RenderingPasses renderPasses;
 
-	for(const auto renderPass : m_renderingPasses)
+	for(const auto renderPass : m_activeRenderPasses)
 	{
 		if(renderPass != nullptr)
 		{
@@ -430,17 +516,13 @@ void RendererFrontend::renderFrame(SceneObjects &p_sceneObjects, const float p_d
 	glDepthFunc(Config::rendererVar().depth_test_func);
 	//glDisable(GL_CULL_FACE);
 
-	for(decltype(m_renderingPasses.size()) i = 0, size = m_renderingPasses.size(); i < size; i++)
+	for(decltype(m_activeRenderPasses.size()) i = 0, size = m_activeRenderPasses.size(); i < size; i++)
 	{
-		m_renderingPasses[i]->update(*m_renderPassData, p_sceneObjects, p_deltaTime);
+		m_activeRenderPasses[i]->update(*m_renderPassData, p_sceneObjects, p_deltaTime);
 	}
 }
 
 unsigned int RendererFrontend::getFramebufferTextureHandle(GBufferTextureType p_bufferType) const
 {
-	//std::cout << "frontend  :" << m_renderPassData->getColorOutputMap() << std::endl;
-
-	//return m_renderPassData->getColorOutputMap();
-
 	return m_backend.getFramebufferTextureHandle(p_bufferType); 
 }

Praxis3D/Source/RendererFrontend.h

@@ -5,8 +5,6 @@
 #include "RendererBackend.h"
 #include "RendererScene.h"
 
-typedef std::vector<RenderPassType> RenderingPasses;
-
 class RenderPass;
 struct RenderPassData;
 
@@ -340,9 +338,10 @@ protected:
 	glm::mat4 m_viewProjMatrix;
 	
 	// An array of all active rendering passes
-	std::vector<RenderPass*> m_renderingPasses;
+	std::vector<RenderPass*> m_activeRenderPasses;
+	RenderPass* m_allRenderPasses[RenderPassType::RenderPassType_NumOfTypes];
 
 	//RenderingPasses m_renderingPassesTypes;
-	RenderPass *m_initializedRenderingPasses[RenderPassType::RenderPassType_NumOfTypes];
+	//RenderPass *m_initializedRenderingPasses[RenderPassType::RenderPassType_NumOfTypes];
 	//bool m_renderPassBeingUsed[RenderPassType::RenderPassType_NumOfTypes];
 };

Praxis3D/Source/RendererScene.cpp

@@ -10,8 +10,8 @@
 RendererScene::RendererScene(RendererSystem *p_system, SceneLoader *p_sceneLoader) : SystemScene(p_system, p_sceneLoader, Properties::PropertyID::Renderer)
 {
 	m_renderTask = new RenderTask(this, p_system->getRenderer());
-	//m_camera = nullptr;
-	//m_skybox = nullptr;
+	m_renderToTexture = false; 
+	m_renderToTextureResolution = glm::ivec2(Config::graphicsVar().current_resolution_x, Config::graphicsVar().current_resolution_y);
 }
 
 RendererScene::~RendererScene()
@@ -55,6 +55,44 @@ ErrorCode RendererScene::setup(const PropertySet &p_properties)
 	worldScene->reserve<GraphicsLoadToMemoryComponent>(modelComponentPoolSize + shaderComponentPoolSize);
 	worldScene->reserve<GraphicsLoadToVideoMemoryComponent>(modelComponentPoolSize + shaderComponentPoolSize);
 
+	// Load the rendering passes
+	auto &renderPassesProperty = p_properties.getPropertySetByID(Properties::RenderPasses);
+	if(renderPassesProperty)
+	{
+		// Iterate over the property array
+		for(decltype(renderPassesProperty.getNumPropertySets()) objIndex = 0, objSize = renderPassesProperty.getNumPropertySets(); objIndex < objSize; objIndex++)
+		{
+			auto &typeProperty = renderPassesProperty.getPropertySetUnsafe(objIndex).getPropertyByID(Properties::Type);
+			if(typeProperty)
+			{
+				switch(typeProperty.getID())
+				{
+					case Properties::AtmScatteringRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_AtmScattering);
+						break;
+					case Properties::BloomRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_Bloom);
+						break;
+					case Properties::GeometryRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_Geometry);
+						break;
+					case Properties::GUIRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_GUI);
+						break;
+					case Properties::LightingRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_Lighting);
+						break;
+					case Properties::LuminanceRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_Luminance);
+						break;
+					case Properties::FinalRenderPass:
+						m_renderingPasses.push_back(RenderPassType::RenderPassType_Final);
+						break;
+				}
+			}
+		}
+	}
+
 	return ErrorCode::Success;
 }
 
@@ -71,6 +109,23 @@ void RendererScene::exportSetup(PropertySet &p_propertySet)
 	objectPoolSizePropertySet.addProperty(Properties::ShaderComponent, (int)worldScene->getPoolSize<ShaderComponent>());
 }
 
+void RendererScene::activate()
+{
+	auto rendererSystem = static_cast<RendererSystem *>(m_system);
+
+	// Set rendering passes
+	rendererSystem->setRenderingPasses(m_renderingPasses);
+
+	// Set whether render the scene to texture or the whole screen
+	rendererSystem->getRenderer().setRenderFinalToTexture(m_renderToTexture);
+
+	// Set render-to-texture resolution, if enabled
+	if(m_renderToTexture)
+	{
+		rendererSystem->getRenderer().setRenderToTextureResolution(m_renderToTextureResolution);
+	}
+}
+
 ErrorCode RendererScene::preload()
 {
 	// Get the entity registry 
@@ -415,7 +470,7 @@ void RendererScene::exportComponents(const EntityID p_entityID, GraphicsComponen
 SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const CameraComponent::CameraComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene*>(m_sceneLoader->getSystemScene(Systems::World));
@@ -445,7 +500,7 @@ SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const C
 SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const LightComponent::LightComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {	
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Proceed only if the light type is not null
 	if(p_constructionInfo.m_lightComponentType != LightComponent::LightComponentType::LightComponentType_null)
@@ -518,7 +573,7 @@ SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const L
 SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const ModelComponent::ModelComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Make sure there are models present
 	if(!p_constructionInfo.m_modelsProperties.m_modelNames.empty())
@@ -563,7 +618,7 @@ SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const M
 SystemObject *RendererScene::createComponent(const EntityID &p_entityID, const ShaderComponent::ShaderComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {	
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Check if any of the shader nodes are present
 	if(!p_constructionInfo.m_vetexShaderFilename.empty() && !p_constructionInfo.m_fragmentShaderFilename.empty())
@@ -644,13 +699,15 @@ void RendererScene::receiveData(const DataType p_dataType, void *p_data, const b
 		break;
 
 	case DataType_RenderToTexture:
-		m_renderTask->m_renderer.setRenderFinalToTexture(static_cast<bool>(p_data));
+		m_renderToTexture = static_cast<bool>(p_data);
+		m_renderTask->m_renderer.setRenderFinalToTexture(m_renderToTexture);
 		break;
 
 	case DataType_RenderToTextureResolution:
 		{
 			auto renderToTextureResolution = static_cast<glm::ivec2 *>(p_data);
-			m_renderTask->m_renderer.setRenderToTextureResolution(*renderToTextureResolution);
+			m_renderToTextureResolution = *renderToTextureResolution;
+			m_renderTask->m_renderer.setRenderToTextureResolution(m_renderToTextureResolution);
 
 			// Delete the received data if it has been marked for deletion (ownership transfered upon receiving)
 			if(p_deleteAfterReceiving)

Praxis3D/Source/RendererScene.h

@@ -112,6 +112,8 @@ public:
 
 	void exportSetup(PropertySet &p_propertySet);
 
+	void activate();
+
 	// Preloads all the resources in the scene (as opposed to loading them while rendering, in background threads)
 	ErrorCode preload();
 
@@ -224,4 +226,11 @@ private:
 
 	// Task responsible for initiating rendering each frame
 	RenderTask *m_renderTask;
+
+	// Contains a list of rendering passes that gets set in the renderer system
+	RenderingPasses m_renderingPasses;
+
+	// Render-to-texture data
+	bool m_renderToTexture;
+	glm::ivec2 m_renderToTextureResolution;
 };

Praxis3D/Source/RendererSystem.cpp

@@ -5,13 +5,17 @@
 
 RendererSystem::RendererSystem()
 {
-	m_rendererScene = nullptr;
+	for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+		m_rendererScenes[i] = nullptr;
+
 	m_systemName = GetString(Systems::Graphics);
 }
 
 RendererSystem::~RendererSystem()
 {
-
+	for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+		if(m_rendererScenes[i] != nullptr)
+			delete m_rendererScenes[i];
 }
 
 ErrorCode RendererSystem::init()
@@ -31,48 +35,48 @@ ErrorCode RendererSystem::init()
 }
 ErrorCode RendererSystem::setup(const PropertySet &p_properties)
 {
-	RenderingPasses renderingPasses;
-
-	// Load the rendering passes
-	auto &renderPassesProperty = p_properties.getPropertySetByID(Properties::RenderPasses);
-	if(renderPassesProperty)
-	{
-		// Iterate over the property array
-		for(decltype(renderPassesProperty.getNumPropertySets()) objIndex = 0, objSize = renderPassesProperty.getNumPropertySets(); objIndex < objSize; objIndex++)
-		{
-			auto &typeProperty = renderPassesProperty.getPropertySetUnsafe(objIndex).getPropertyByID(Properties::Type);
-			if(typeProperty)
-			{
-				switch(typeProperty.getID())
-				{
-				case Properties::AtmScatteringRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_AtmScattering);
-					break;
-				case Properties::BloomRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_Bloom);
-					break;
-				case Properties::GeometryRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_Geometry);
-					break;
-				case Properties::GUIRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_GUI);
-					break;
-				case Properties::LightingRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_Lighting);
-					break;
-				case Properties::LuminanceRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_Luminance);
-					break;
-				case Properties::FinalRenderPass:
-					renderingPasses.push_back(RenderPassType::RenderPassType_Final);
-					break;
-				}
-			}
-		}
-	}
-
-	// Pass the loaded rendering passes to the renderer
-	m_renderer.setRenderingPasses(renderingPasses);
+	//RenderingPasses renderingPasses;
+
+	//// Load the rendering passes
+	//auto &renderPassesProperty = p_properties.getPropertySetByID(Properties::RenderPasses);
+	//if(renderPassesProperty)
+	//{
+	//	// Iterate over the property array
+	//	for(decltype(renderPassesProperty.getNumPropertySets()) objIndex = 0, objSize = renderPassesProperty.getNumPropertySets(); objIndex < objSize; objIndex++)
+	//	{
+	//		auto &typeProperty = renderPassesProperty.getPropertySetUnsafe(objIndex).getPropertyByID(Properties::Type);
+	//		if(typeProperty)
+	//		{
+	//			switch(typeProperty.getID())
+	//			{
+	//			case Properties::AtmScatteringRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_AtmScattering);
+	//				break;
+	//			case Properties::BloomRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_Bloom);
+	//				break;
+	//			case Properties::GeometryRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_Geometry);
+	//				break;
+	//			case Properties::GUIRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_GUI);
+	//				break;
+	//			case Properties::LightingRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_Lighting);
+	//				break;
+	//			case Properties::LuminanceRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_Luminance);
+	//				break;
+	//			case Properties::FinalRenderPass:
+	//				renderingPasses.push_back(RenderPassType::RenderPassType_Final);
+	//				break;
+	//			}
+	//		}
+	//	}
+	//}
+
+	//// Pass the loaded rendering passes to the renderer
+	//m_renderer.setRenderingPasses(renderingPasses);
 
 	return ErrorCode::Success;
 }
@@ -122,25 +126,27 @@ void RendererSystem::exportSetup(PropertySet &p_propertySet)
 
 ErrorCode RendererSystem::preload()
 {
-	if(m_rendererScene != nullptr)
-		return m_rendererScene->preload();
-	else
+	std::cout << "PRELOAD CALLED" << std::endl;
+	//if(m_rendererScene != nullptr)
+	//	return m_rendererScene->preload();
+	//else
 		return ErrorCode::Failure;
 }
 
 void RendererSystem::loadInBackground()
 {
-	if(m_rendererScene != nullptr)
-		return m_rendererScene->loadInBackground();
+	std::cout << "LOAD IN BACKGROUND CALLED" << std::endl;
+	//if(m_rendererScene != nullptr)
+	//	return m_rendererScene->loadInBackground();
 }
 
-SystemScene *RendererSystem::createScene(SceneLoader *p_sceneLoader)
+SystemScene *RendererSystem::createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 {
-	if(m_rendererScene == nullptr)
+	if(m_rendererScenes[p_engineState] == nullptr)
 	{
 		// Create new scene
-		m_rendererScene = new RendererScene(this, p_sceneLoader);
-		ErrorCode sceneError = m_rendererScene->init();
+		m_rendererScenes[p_engineState] = new RendererScene(this, p_sceneLoader);
+		ErrorCode sceneError = m_rendererScenes[p_engineState]->init();
 
 		// Check if it initialized correctly (cannot continue without the scene)
 		if(sceneError != ErrorCode::Success)
@@ -154,10 +160,16 @@ SystemScene *RendererSystem::createScene(SceneLoader *p_sceneLoader)
 		}
 	}
 
-	return m_rendererScene;
+	return m_rendererScenes[p_engineState];
+}
+
+SystemScene *RendererSystem::getScene(EngineStateType p_engineState)
+{
+	return m_rendererScenes[p_engineState];
 }
 
-SystemScene *RendererSystem::getScene()
+void RendererSystem::deleteScene(EngineStateType p_engineState)
 {
-	return m_rendererScene;
+	if(m_rendererScenes[p_engineState] != nullptr)
+		delete m_rendererScenes[p_engineState];
 }

Praxis3D/Source/RendererSystem.h

@@ -13,7 +13,7 @@ public:
 	RendererSystem();
 	~RendererSystem();
 
-	virtual ErrorCode init();
+	ErrorCode init();
 
 	ErrorCode setup(const PropertySet &p_properties);
 
@@ -21,19 +21,26 @@ public:
 
 	//virtual ErrorCode destroyScene(SystemScene *p_systemScene);
 
-	virtual ErrorCode preload();
+	ErrorCode preload();
 	void loadInBackground();
 
 	Systems::TypeID getSystemType() { return Systems::Graphics; }
 
-	virtual SystemScene *createScene(SceneLoader *p_sceneLoader);
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState);
 
-	virtual SystemScene *getScene();
+	SystemScene *getScene(EngineStateType p_engineState);
+
+	void deleteScene(EngineStateType p_engineState);
 
 	RendererFrontend &getRenderer() { return m_renderer; }
 
+	void setRenderingPasses(const RenderingPasses &p_renderingPasses)
+	{
+		m_renderer.setRenderingPasses(p_renderingPasses);
+	}
+
 protected:
 	RendererFrontend m_renderer;
-	RendererScene *m_rendererScene;
+	RendererScene *m_rendererScenes[EngineStateType::EngineStateType_NumOfTypes];
 };
 

Praxis3D/Source/RigidBodyComponent.h

@@ -50,7 +50,6 @@ public:
 	}
 	~RigidBodyComponent()
 	{
-		delete static_cast<EntityID*>(m_rigidBody->getUserPointer());
 	}
 	ErrorCode init() final override
 	{

Praxis3D/Source/SceneLoader.cpp

@@ -12,7 +12,7 @@ SceneLoader::SceneLoader()
 	m_loadInBackground = false;
 
 	for(int i = 0; i < Systems::NumberOfSystems; i++)
-		m_systemScenes[i] = g_nullSystemBase.createScene(this);
+		m_systemScenes[i] = g_nullSystemBase.createScene(this, EngineStateType::EngineStateType_Default);
 }
 
 SceneLoader::~SceneLoader()

Praxis3D/Source/ScriptScene.cpp

@@ -161,7 +161,7 @@ void ScriptScene::exportComponents(const EntityID p_entityID, ScriptComponentsCo
 SystemObject *ScriptScene::createComponent(const EntityID &p_entityID, const LuaComponent::LuaComponentConstructionInfo &p_constructionInfo, const bool p_startLoading)
 {	
 	// If valid type was not specified, or object creation failed, return a null object instead
-	SystemObject *returnObject = g_nullSystemBase.getScene()->getNullObject();
+	SystemObject *returnObject = g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 
 	// Get the world scene required for attaching components to the entity
 	WorldScene *worldScene = static_cast<WorldScene*>(m_sceneLoader->getSystemScene(Systems::World));

Praxis3D/Source/ScriptScene.h

@@ -99,7 +99,7 @@ public:
 		if(m_scriptingTask != nullptr)
 			return m_scriptingTask;
 
-		return g_nullSystemBase.getScene()->getSystemTask();
+		return g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getSystemTask();
 	}
 	Systems::TypeID getSystemType() { return Systems::Script; }
 

Praxis3D/Source/ScriptSystem.cpp

@@ -6,13 +6,17 @@
 
 ScriptSystem::ScriptSystem()
 {
-	m_scriptingScene = nullptr;
+	for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+		m_scriptingScenes[i] = nullptr;
+
 	m_systemName = GetString(Systems::Script);
 }
 
 ScriptSystem::~ScriptSystem()
 {
-
+	for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+		if(m_scriptingScenes[i] != nullptr)
+			delete m_scriptingScenes[i];
 }
 
 ErrorCode ScriptSystem::init()
@@ -41,13 +45,13 @@ void ScriptSystem::loadInBackground()
 {
 }
 
-SystemScene *ScriptSystem::createScene(SceneLoader *p_sceneLoader)
+SystemScene *ScriptSystem::createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 {
-	if(m_scriptingScene == nullptr)
+	if(m_scriptingScenes[p_engineState] == nullptr)
 	{
 		// Create new scene
-		m_scriptingScene = new ScriptScene(this, p_sceneLoader);
-		ErrorCode sceneError = m_scriptingScene->init();
+		m_scriptingScenes[p_engineState] = new ScriptScene(this, p_sceneLoader);
+		ErrorCode sceneError = m_scriptingScenes[p_engineState]->init();
 
 		// Check if it initialized correctly (cannot continue without the scene)
 		if(sceneError != ErrorCode::Success)
@@ -56,10 +60,16 @@ SystemScene *ScriptSystem::createScene(SceneLoader *p_sceneLoader)
 		}
 	}
 
-	return m_scriptingScene;
+	return m_scriptingScenes[p_engineState];
+}
+
+SystemScene *ScriptSystem::getScene(EngineStateType p_engineState)
+{
+	return m_scriptingScenes[p_engineState];
 }
 
-SystemScene *ScriptSystem::getScene()
+void ScriptSystem::deleteScene(EngineStateType p_engineState)
 {
-	return m_scriptingScene;
+	if(m_scriptingScenes[p_engineState] != nullptr)
+		delete m_scriptingScenes[p_engineState];
 }

Praxis3D/Source/ScriptSystem.h

@@ -8,23 +8,23 @@ class ScriptSystem : public SystemBase
 {
 public:
 	ScriptSystem();
-	virtual ~ScriptSystem();
+	~ScriptSystem();
 
-	virtual ErrorCode init();
+	ErrorCode init();
 
 	ErrorCode setup(const PropertySet &p_properties);
 
-	//virtual ErrorCode preload();
-
 	void loadInBackground();
 
 	Systems::TypeID getSystemType() { return Systems::Script; }
 
-	virtual SystemScene *createScene(SceneLoader *p_sceneLoader);
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState);
+
+	SystemScene *getScene(EngineStateType p_engineState);
 
-	virtual SystemScene *getScene();
+	void deleteScene(EngineStateType p_engineState);
 	
 protected:
-	ScriptScene *m_scriptingScene;
+	ScriptScene *m_scriptingScenes[EngineStateType::EngineStateType_NumOfTypes];
 };
 

Praxis3D/Source/SkyPass.h

@@ -34,10 +34,13 @@ public:
 			m_renderer.queueForLoading(*m_skyPassShader);	// Queue the shader to be loaded to GPU
 		else
 			returnError = shaderError;
-		
+
 		// Check for errors and log either a successful or a failed initialization
 		if(returnError == ErrorCode::Success)
+		{
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_success, ErrorSource::Source_SkyPass);
+			setInitialized(true);
+		}
 		else
 			ErrHandlerLoc::get().log(ErrorCode::Initialize_failure, ErrorSource::Source_SkyPass);
 

Praxis3D/Source/System.cpp

@@ -28,5 +28,5 @@ std::vector<SystemObject*> SystemScene::createComponents(const EntityID p_entity
 
 SystemObject *SystemScene::getNullObject()
 {
-	return g_nullSystemBase.getScene()->getNullObject();
+	return g_nullSystemBase.getScene(EngineStateType::EngineStateType_Default)->getNullObject();
 }

Praxis3D/Source/System.h

@@ -42,11 +42,13 @@ public:
 	virtual Systems::TypeID getSystemType() = 0;
 	virtual std::string getName() { return m_systemName; }
 
-	// Passes scene loader as argument so that scenes could have access to other system scenes 
-	// that are register with this scene loader
-	virtual SystemScene *createScene(SceneLoader *p_sceneLoader) = 0;
+	// Passes scene loader as argument so that scenes could have access to other system scenes that are register with this scene loader
+	// Also takes in an engine state type, as a way to identify created scenes, since scenes can only be created for each engine state
+	virtual SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState) = 0;
 
-	virtual SystemScene *getScene() = 0;
+	virtual SystemScene *getScene(EngineStateType p_engineState) = 0;
+
+	virtual void deleteScene(EngineStateType p_engineState) = 0;
 
 	virtual void loadInBackground() = 0;
 	

Praxis3D/Source/Universal.cpp

@@ -60,7 +60,7 @@ SystemScene *UniversalScene::extend(SystemBase *p_system)
 	}
 
 	// Get the new scene
-	SystemScene *newScene = p_system->getScene();
+	SystemScene *newScene = nullptr;// p_system->getScene();
 
 	// TODO ASSERT ERROR
 	_ASSERT(newScene != nullptr);
@@ -82,6 +82,34 @@ SystemScene *UniversalScene::extend(SystemBase *p_system)
 
 	return newScene;
 }
+ErrorCode UniversalScene::extend(SystemScene *p_scene)
+{
+	ErrorCode returnError = ErrorCode::Success;
+
+	if(p_scene != nullptr)
+	{
+		// Get the system type
+		BitMask systemType = p_scene->getSystemType();
+
+		// Check for duplicates
+		if(m_systemScenes.find(systemType) == m_systemScenes.end())
+		{
+			// Add the new scene to the list
+			m_systemScenes[systemType] = p_scene;
+
+			// Register the new scene to receive all changes
+			m_sceneChangeController->registerSubject(p_scene, p_scene->getDesiredSystemChanges(), this);
+		}
+		else
+		{
+			returnError = ErrorCode::Universal_scene_extend_duplicate;
+		}
+	}
+	else
+		returnError = ErrorCode::Universal_scene_extend_null;
+
+	return returnError;
+}
 ErrorCode UniversalScene::unextend(SystemScene *p_scene)
 {
 	ErrorCode returnError = ErrorCode::Failure;

Praxis3D/Source/Universal.h

@@ -17,6 +17,7 @@ public:
 	~UniversalScene();
 
 	SystemScene *extend(SystemBase *p_system);
+	ErrorCode extend(SystemScene *p_scene);
 	ErrorCode unextend(SystemScene *p_scene);
 
 	UniversalObject *createObject(std::string p_name = "");

Praxis3D/Source/WorldEditState.cpp

@@ -1,94 +0,0 @@
-
-#include "ClockLocator.h"
-#include "PropertySet.h"
-#include "ScriptSystem.h"
-#include "RendererSystem.h"
-#include "WorldEditState.h"
-
-WorldEditState::WorldEditState()
-{
-	m_sceneChangeController = new ChangeController();
-	m_objectChangeController = new ChangeController();
-}
-
-WorldEditState::~WorldEditState()
-{
-	delete m_scheduler;
-	delete m_changeCtrlScene;
-	delete m_sceneChangeController;
-	delete m_objectChangeController;
-
-	for(int i = 0; i < Systems::NumberOfSystems; i++)
-		if(m_systems[i]->getSystemType() != Systems::Null)
-			delete m_systems[i];
-}
-
-ErrorCode WorldEditState::init(TaskManager *p_taskManager)
-{
-	ErrorCode returnError = ErrorCode::Success;
-
-	m_changeCtrlScene = new UniversalScene(m_sceneChangeController, m_objectChangeController);
-
-	m_scheduler = new TaskScheduler(p_taskManager);
-
-	m_sceneLoader.registerChangeController(m_changeCtrlScene);
-
-	//  __________________________________
-	// |								  |
-	// |  RENDERER SYSTEM INITIALIZATION  |
-	// |__________________________________|
-	// Create graphics system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Graphics] = new RendererSystem();
-	if(m_systems[Systems::Graphics]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Graphics];
-		m_systems[Systems::Graphics] = &g_nullSystemBase;
-	}
-
-	//  ___________________________________
-	// |								   |
-	// |   SCRIPT SYSTEM INITIALIZATION    |
-	// |___________________________________|
-	// Create scripting system and check if it was successful (if not, assign a null system in it's place)
-	m_systems[Systems::Script] = new ScriptSystem();
-	if(m_systems[Systems::Script]->init() != ErrorCode::Success)
-	{
-		delete m_systems[Systems::Script];
-		m_systems[Systems::Script] = &g_nullSystemBase;
-	}
-
-	// Register systems with change controller and scenes with scene loader
-	for(int i = 0; i < Systems::NumberOfSystems; i++)
-	{
-		m_changeCtrlScene->extend(m_systems[i]);
-		m_sceneLoader.registerSystemScene(m_systems[i]->createScene(&m_sceneLoader));
-	}
-
-	// Register change control scene with the scheduler
-	m_scheduler->setScene(m_changeCtrlScene);
-
-	// Register task manager with object and scene change controllers
-	m_objectChangeController->setTaskManager(p_taskManager);
-	m_sceneChangeController->setTaskManager(p_taskManager);
-
-	// Load the default map, and log an error if it wasn't successful
-	ErrorCode sceneLoaderError = m_sceneLoader.loadFromFile(Config::gameplayVar().default_map);
-	if(sceneLoaderError != ErrorCode::Success)
-		ErrHandlerLoc::get().log(sceneLoaderError, ErrorSource::Source_SceneLoader);
-
-	return returnError;
-}
-
-void WorldEditState::update(Engine &p_engine)
-{
-	m_scheduler->execute(ClockLocator::get().getDeltaSecondsF());
-
-	m_objectChangeController->distributeChanges();
-	m_sceneChangeController->distributeChanges();
-}
-
-void WorldEditState::shutdown()
-{
-	m_sceneChangeController->resetTaskManager();
-	m_objectChangeController->resetTaskManager();
-}

Praxis3D/Source/WorldEditState.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "SceneLoader.h"
-#include "EngineState.h"
-#include "TaskManager.h"
-#include "TaskScheduler.h"
-
-class WorldEditState : public EngineState
-{
-public:
-	WorldEditState();
-	~WorldEditState();
-
-	ErrorCode init(TaskManager *p_taskManager);
-	void update(Engine &p_engine);
-
-	void shutdown();
-
-private:
-	SystemBase *m_systems[Systems::NumberOfSystems];
-	SceneLoader m_sceneLoader;
-
-	TaskScheduler *m_scheduler;
-	UniversalScene *m_changeCtrlScene;
-
-	ChangeController *m_sceneChangeController;
-	ChangeController *m_objectChangeController;
-};

Praxis3D/Source/WorldScene.h

@@ -162,7 +162,7 @@ public:
 
 	// Get the internal pool size of a given component
 	template <class T_Component>
-	unsigned int getPoolSize()
+	size_t getPoolSize()
 	{
 		return m_entityRegistry.storage<T_Component>().size();
 	}

Praxis3D/Source/WorldSystem.h

@@ -7,11 +7,18 @@ class WorldSystem : public SystemBase
 {
 public:
 	WorldSystem() 
-	{ 
-		m_worldScene = nullptr;
+	{
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			m_worldScenes[i] = nullptr;
+
 		m_systemName = GetString(Systems::World);
 	}
-	~WorldSystem() { }
+	~WorldSystem() 
+	{
+		for(unsigned int i = 0; i < EngineStateType::EngineStateType_NumOfTypes; i++)
+			if(m_worldScenes[i] != nullptr)
+				delete m_worldScenes[i];
+	}
 
 	ErrorCode init()
 	{
@@ -39,13 +46,13 @@ public:
 
 	Systems::TypeID getSystemType() { return Systems::World; }
 
-	SystemScene *createScene(SceneLoader *p_sceneLoader)
+	SystemScene *createScene(SceneLoader *p_sceneLoader, EngineStateType p_engineState)
 	{
-		if(m_worldScene == nullptr)
+		if(m_worldScenes[p_engineState] == nullptr)
 		{
 			// Create new scene
-			m_worldScene = new WorldScene(this, p_sceneLoader);
-			ErrorCode sceneError = m_worldScene->init();
+			m_worldScenes[p_engineState] = new WorldScene(this, p_sceneLoader);
+			ErrorCode sceneError = m_worldScenes[p_engineState]->init();
 
 			// Check if it initialized correctly (cannot continue without the scene)
 			if(sceneError != ErrorCode::Success)
@@ -59,11 +66,17 @@ public:
 			}
 		}
 
-		return m_worldScene;
+		return m_worldScenes[p_engineState];
 	}
 
-	SystemScene *getScene() { return m_worldScene; }
+	SystemScene *getScene(EngineStateType p_engineState) { return m_worldScenes[p_engineState]; }
+
+	void deleteScene(EngineStateType p_engineState)
+	{
+		if(m_worldScenes[p_engineState] != nullptr)
+			delete m_worldScenes[p_engineState];
+	}
 
 protected:
-	WorldScene *m_worldScene;
+	WorldScene *m_worldScenes[EngineStateType::EngineStateType_NumOfTypes];
 };

Praxis3D/imgui.ini

@@ -4,7 +4,7 @@ Size=400,400
 Collapsed=0
 
 [Window][Dear ImGui Demo]
-Pos=66,369
+Pos=465,156
 Size=507,676
 Collapsed=0
 
@@ -90,20 +90,20 @@ Collapsed=0
 DockId=0x00000001,0
 
 [Window][##RightWindow]
-Pos=1499,69
-Size=421,1011
+Pos=1535,69
+Size=385,1011
 Collapsed=0
 DockId=0x00000008,0
 
 [Window][##BottomWindow]
 Pos=0,868
-Size=1497,212
+Size=1533,212
 Collapsed=0
 DockId=0x00000006,0
 
 [Window][##CenterWindow]
 Pos=303,69
-Size=1194,797
+Size=1230,797
 Collapsed=0
 DockId=0x00000004,0
 
@@ -473,12 +473,12 @@ Column 0  Sort=0v
 
 [Docking][Data]
 DockSpace         ID=0x8B93E3BD Window=0xA787BDB4 Pos=0,69 Size=1920,1011 Split=X
-  DockNode        ID=0x00000007 Parent=0x8B93E3BD SizeRef=1497,1011 Split=Y
+  DockNode        ID=0x00000007 Parent=0x8B93E3BD SizeRef=1533,1011 Split=Y
     DockNode      ID=0x00000005 Parent=0x00000007 SizeRef=1920,725 Split=X
       DockNode    ID=0x00000001 Parent=0x00000005 SizeRef=301,1011 Selected=0xB1B21E90
-      DockNode    ID=0x00000003 Parent=0x00000005 SizeRef=1194,1011 Split=X
+      DockNode    ID=0x00000003 Parent=0x00000005 SizeRef=1230,1011 Split=X
         DockNode  ID=0x00000002 Parent=0x00000003 SizeRef=332,1042 Selected=0xD00C9CD4
         DockNode  ID=0x00000004 Parent=0x00000003 SizeRef=1586,1042 CentralNode=1 Selected=0xFB1B6F35
     DockNode      ID=0x00000006 Parent=0x00000007 SizeRef=1920,212 Selected=0x51C0BD29
-  DockNode        ID=0x00000008 Parent=0x8B93E3BD SizeRef=421,1011 Selected=0x96D2BCA2
+  DockNode        ID=0x00000008 Parent=0x8B93E3BD SizeRef=385,1011 Selected=0x96D2BCA2