mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-02-26 14:58:51 -06:00
Code Issues Packages Projects Releases Wiki Activity

More restructuring work on SceneGraph

Browse Source
This commit is contained in:
Alexander Bock
2015-04-12 14:50:43 +02:00
parent a65e48b0e3
commit ccd58b7224
8 changed files with 693 additions and 1657 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/openspace/scene/scene.h
View File

@@ -34,6 +34,7 @@
#include <openspace/util/camera.h>
#include <openspace/util/updatestructures.h>
#include <openspace/scripting/scriptengine.h>
#include <openspace/scene/scenegraph.h>
#include <ghoul/opengl/programobject.h>
#include <ghoul/misc/dictionary.h>
@@ -95,7 +96,7 @@ public:
*/
SceneGraphNode* sceneGraphNode(const std::string& name) const;
std::vector<SceneGraphNode*> allSceneGraphNodes() const;
std::vector<SceneGraphNode*> allSceneGraphNodes();
/**
* Returns the Lua library that contains all Lua functions available to change the
@@ -115,9 +116,10 @@ private:
std::string _focus;
// actual scenegraph
SceneGraphNode* _root;
std::vector<SceneGraphNode*> _nodes;
std::map<std::string, SceneGraphNode*> _allNodes;
SceneGraph _graph;
//SceneGraphNode* _root;
//std::vector<SceneGraphNode*> _nodes;
//std::map<std::string, SceneGraphNode*> _allNodes;
std::string _sceneGraphToLoad;

28
include/openspace/scene/scenegraph.h
View File

@@ -36,7 +36,7 @@ class SceneGraphNode;
class SceneGraph {
public:
SceneGraph() = default;
SceneGraph();
void clear();
bool loadFromFile(const std::string& sceneDescription);
@@ -46,18 +46,34 @@ public:
bool removeSceneGraphNode(SceneGraphNode* node);
// topological sort
std::vector<SceneGraphNode*> linearList();
const std::vector<SceneGraphNode*>& linearList();
SceneGraphNode* rootNode() const;
SceneGraphNode* sceneGraphNode(const std::string& name) const;
private:
bool nodeIsDependentOnRoot(const std::string& nodeName);
struct SceneGraphNodeInternal {
SceneGraphNode* node;
// From nodes that are dependent on this one
std::vector<SceneGraphNodeInternal*> incomingEdges;
// To nodes that this node depends on
std::vector<SceneGraphNodeInternal*> outgoingEdges;
};
bool nodeIsDependentOnRoot(SceneGraphNodeInternal* node);
bool topologicalSort();
std::vector<SceneGraphNode*> _nodes;
SceneGraphNodeInternal* nodeByName(const std::string& name);
SceneGraphNode* _rootNode;
std::vector<SceneGraphNodeInternal*> _nodes;
std::vector<SceneGraphNode*> _topologicalSortedNodes;
// child -> parent
std::unordered_multimap<std::string, std::string> _forwardEdges;
//std::unordered_multimap<std::string, std::string> _forwardEdges;
// Edges are in reverse order of dependency
// parent -> child
std::unordered_multimap<std::string, std::string> _backwardEdges;
//std::unordered_multimap<std::string, std::string> _backwardEdges;
};
} // namespace openspace

165
include/openspace/scene/scenegraphloader.h
View File

@@ -1,165 +0,0 @@
/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2015 *
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
* software and associated documentation files (the "Software"), to deal in the Software *
* without restriction, including without limitation the rights to use, copy, modify, *
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
* permit persons to whom the Software is furnished to do so, subject to the following *
* conditions: *
* *
* The above copyright notice and this permission notice shall be included in all copies *
* or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#ifndef __SCENEGRAPHLOADER_H__
#define __SCENEGRAPHLOADER_H__
#include <string>
#include <vector>
namespace openspace {
class SceneGraphNode;
class SceneGraphLoader {
public:
static bool load(const std::string& sceneDescription, std::vector<SceneGraphNode*>& nodes);
private:
};
} // namespace openspace
//// std includes
//#include <vector>
//#include <map>
//#include <set>
//#include <mutex>
//
//#include <openspace/util/camera.h>
//#include <openspace/util/updatestructures.h>
//#include <openspace/scripting/scriptengine.h>
//
//#include <ghoul/opengl/programobject.h>
//#include <ghoul/misc/dictionary.h>
//
//namespace openspace {
//
//
//class SceneGraphNode;
//
//// Notifications:
//// SceneGraphFinishedLoading
//class SceneGraph {
//public:
// // constructors & destructor
// SceneGraph();
// ~SceneGraph();
//
// /**
// * Initalizes the SceneGraph by loading modules from the ${SCENEPATH} directory
// */
// bool initialize();
//
// /*
// * Clean up everything
// */
// bool deinitialize();
//
// /*
// * Load the scenegraph from the provided folder
// */
// void scheduleLoadSceneFile(const std::string& sceneDescriptionFilePath);
// void clearSceneGraph();
//
// void loadModule(const std::string& modulePath);
//
// /*
// * Updates all SceneGraphNodes relative positions
// */
// void update(const UpdateData& data);
//
// /*
// * Evaluates if the SceneGraphNodes are visible to the provided camera
// */
// void evaluate(Camera* camera);
//
// /*
// * Render visible SceneGraphNodes using the provided camera
// */
// void render(const RenderData& data);
//
// /*
// * Returns the root SceneGraphNode
// */
// SceneGraphNode* root() const;
//
// /**
// * Return the scenegraph node with the specified name or <code>nullptr</code> if that
// * name does not exist
// */
// SceneGraphNode* sceneGraphNode(const std::string& name) const;
//
// std::vector<SceneGraphNode*> allSceneGraphNodes() const;
//
// /**
// * Returns the Lua library that contains all Lua functions available to change the
// * scene graph. The functions contained are
// * - openspace::luascriptfunctions::property_setValue
// * - openspace::luascriptfunctions::property_getValue
// * \return The Lua library that contains all Lua functions available to change the
// * scene graph
// */
// static scripting::ScriptEngine::LuaLibrary luaLibrary();
//
//private:
// bool loadSceneInternal(const std::string& sceneDescriptionFilePath);
//
// void writePropertyDocumentation(const std::string& filename, const std::string& type);
//
// std::string _focus;
//
// // actual scenegraph
// SceneGraphNode* _root;
// std::vector<SceneGraphNode*> _nodes;
// std::map<std::string, SceneGraphNode*> _allNodes;
//
// std::string _sceneGraphToLoad;
//
// std::mutex _programUpdateLock;
// std::set<ghoul::opengl::ProgramObject*> _programsToUpdate;
// std::vector<ghoul::opengl::ProgramObject*> _programs;
//
// typedef std::map<std::string, ghoul::Dictionary> NodeMap;
// typedef std::multimap<std::string, std::string> DependencyMap;
// typedef std::vector<std::string> LoadedList;
//
// struct LoadMaps {
// NodeMap nodes;
// DependencyMap dependencies;
// LoadedList loadedNodes;
// };
//
// void loadModules(const std::string& directory, const ghoul::Dictionary& dictionary);
// void loadModule(LoadMaps& m,const std::string& modulePath, lua_State* state);
// void loadNodes(const std::string& parentName, LoadMaps& m);
// void loadNode(const ghoul::Dictionary& dictionary);
//};
//
//} // namespace openspace
#endif // __SCENEGRAPHLOADER_H__