mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-03 01:59:35 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/iSWA' of github.com:OpenSpace/OpenSpace-Development into feature/iSWA

Browse Source
This commit is contained in:
Sebastian Piwell
2016-05-03 13:46:18 -04:00
parent 7eae57b02f 2f7d2e294f
commit 810bcbb4e1
14 changed files with 150 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/openspace/rendering/renderengine.h
View File

@@ -180,7 +180,6 @@ private:
std::vector<ghoul::opengl::ProgramObject*> _programs;
std::vector<std::shared_ptr<ScreenSpaceRenderable>> _screenSpaceRenderables;
std::vector<std::shared_ptr<ScreenSpaceRenderable>> _deletedScreenSpaceRenderables;
std::shared_ptr<ghoul::fontrendering::Font> _fontInfo = nullptr;
std::shared_ptr<ghoul::fontrendering::Font> _fontDate = nullptr;

1
include/openspace/rendering/screenspacerenderable.h
View File

@@ -53,6 +53,7 @@ namespace openspace {
*/
class ScreenSpaceRenderable : public properties::PropertyOwner {
public:
static ScreenSpaceRenderable* createFromDictionary(const ghoul::Dictionary& dictionary);
ScreenSpaceRenderable();
~ScreenSpaceRenderable();

9
modules/base/basemodule.cpp
View File

@@ -25,6 +25,7 @@
#include <modules/base/basemodule.h>
#include <openspace/rendering/renderable.h>
#include <openspace/rendering/screenspacerenderable.h>
#include <openspace/util/factorymanager.h>
#include <ghoul/misc/assert.h>
@@ -42,6 +43,8 @@
#include <modules/base/rendering/simplespheregeometry.h>
#include <modules/base/rendering/modelgeometry.h>
#include <modules/base/rendering/multimodelgeometry.h>
#include <modules/base/rendering/screenspaceimage.h>
#include <modules/base/rendering/screenspaceframebuffer.h>
#include <modules/base/ephemeris/staticephemeris.h>
#include <modules/base/ephemeris/dynamicephemeris.h>
@@ -59,6 +62,12 @@ void BaseModule::internalInitialize() {
FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<planetgeometry::PlanetGeometry>>());
FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<modelgeometry::ModelGeometry>>());
auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fScreenSpaceRenderable, "ScreenSpaceRenderable factory was not created");
fScreenSpaceRenderable->registerClass<ScreenSpaceImage>("ScreenSpaceImage");
fScreenSpaceRenderable->registerClass<ScreenSpaceFramebuffer>("ScreenSpaceFramebuffer");
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");

2
modules/base/rendering/screenspaceframebuffer.cpp
View File

@@ -32,7 +32,7 @@
#include <openspace/rendering/framebufferrenderer.h>
namespace openspace {
ScreenSpaceFramebuffer::ScreenSpaceFramebuffer()
ScreenSpaceFramebuffer::ScreenSpaceFramebuffer(const ghoul::Dictionary& dictionary)
:ScreenSpaceRenderable()
,_size("size", "Size", glm::vec4(0), glm::vec4(0), glm::vec4(2000))
,_framebuffer(nullptr)

2
modules/base/rendering/screenspaceframebuffer.h
View File

@@ -38,7 +38,7 @@ namespace openspace {
*/
class ScreenSpaceFramebuffer : public ScreenSpaceRenderable {
public:
ScreenSpaceFramebuffer();
ScreenSpaceFramebuffer(const ghoul::Dictionary& dictionary = ghoul::Dictionary());
~ScreenSpaceFramebuffer();
bool initialize() override;

19
modules/base/rendering/screenspaceimage.cpp
View File

@@ -33,7 +33,6 @@ namespace openspace {
ScreenSpaceImage::ScreenSpaceImage(std::string texturePath)
:ScreenSpaceRenderable()
,_texturePath("texturePath", "Texture path", texturePath)
{
_id = id();
setName("ScreenSpaceImage" + std::to_string(_id));
@@ -45,6 +44,24 @@ ScreenSpaceImage::ScreenSpaceImage(std::string texturePath)
_texturePath.onChange([this](){ loadTexture(); });
}
ScreenSpaceImage::ScreenSpaceImage(const ghoul::Dictionary& dictionary)
:ScreenSpaceRenderable()
,_texturePath("texturePath", "Texture path", "")
{
_id = id();
setName("ScreenSpaceImage" + std::to_string(_id));
std::string texturePath;
dictionary.getValue("TexturePath", texturePath);
_texturePath.set(texturePath);
registerProperties();
addProperty(_texturePath);
OsEng.gui()._screenSpaceProperty.registerProperty(&_texturePath);
_texturePath.onChange([this](){ loadTexture(); });
}
ScreenSpaceImage::~ScreenSpaceImage(){}
bool ScreenSpaceImage::initialize(){

1
modules/base/rendering/screenspaceimage.h
View File

@@ -39,6 +39,7 @@ class ScreenSpaceImage : public ScreenSpaceRenderable {
public:
ScreenSpaceImage(std::string texturePath);
ScreenSpaceImage(const ghoul::Dictionary& dictionary);
~ScreenSpaceImage();
bool initialize() override;

8
modules/iswa/iswamodule.cpp
View File

@@ -25,6 +25,7 @@
#include <modules/iswa/iswamodule.h>
#include <openspace/rendering/renderable.h>
#include <openspace/rendering/screenspacerenderable.h>
#include <openspace/util/factorymanager.h>
#include <ghoul/misc/assert.h>
@@ -32,6 +33,7 @@
#include <modules/iswa/rendering/textureplane.h>
#include <modules/iswa/rendering/dataplane.h>
#include <modules/iswa/rendering/kameleonplane.h>
#include <modules/iswa/rendering/screenspacecygnet.h>
namespace openspace {
@@ -40,11 +42,17 @@ namespace openspace {
{}
void ISWAModule::internalInitialize(){
FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<ScreenSpaceRenderable>>());
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<TexturePlane>("TexturePlane");
fRenderable->registerClass<DataPlane>("DataPlane");
fRenderable->registerClass<KameleonPlane>("KameleonPlane");
auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fScreenSpaceRenderable, "No fScreenSpaceRenderable factory existed");
fScreenSpaceRenderable->registerClass<ScreenSpaceCygnet>("ScreenSpaceCygnet");
}
}

17
modules/iswa/rendering/screenspacecygnet.cpp
View File

@@ -45,6 +45,21 @@ ScreenSpaceCygnet::ScreenSpaceCygnet(int cygnetId)
registerProperties();
}
ScreenSpaceCygnet::ScreenSpaceCygnet(const ghoul::Dictionary& dictionary)
: ScreenSpaceRenderable()
, _updateInterval("updateInterval", "Update Interval", 1.0, 0.0 , 10.0)
{
// hacky, have to first get as float and the cast to int.
float cygnetid;
dictionary.getValue("CygnetId", cygnetid);
_cygnetId = (int)cygnetid;
setName("iSWACygnet" + std::to_string(_cygnetId));
addProperty(_updateInterval);
registerProperties();
}
ScreenSpaceCygnet::~ScreenSpaceCygnet(){}
bool ScreenSpaceCygnet::initialize(){
@@ -60,7 +75,7 @@ bool ScreenSpaceCygnet::initialize(){
}
bool ScreenSpaceCygnet::deinitialize(){
OsEng.gui()._iSWAproperty.unregisterProperties(name());
OsEng.gui()._screenSpaceProperty.unregisterProperties(name());
glDeleteVertexArrays(1, &_quad);
_quad = 0;

3
modules/iswa/rendering/screenspacecygnet.h
View File

@@ -35,6 +35,7 @@ namespace openspace{
class ScreenSpaceCygnet : public ScreenSpaceRenderable {
public:
ScreenSpaceCygnet(int cygnetId);
ScreenSpaceCygnet(const ghoul::Dictionary& dictionary);
~ScreenSpaceCygnet();
void render() override;
@@ -47,7 +48,7 @@ private:
void updateTexture();
void loadTexture();
const int _cygnetId;
int _cygnetId;
properties::FloatProperty _updateInterval;
std::chrono::milliseconds _realTime;

4
modules/iswa/util/iswamanager.cpp
View File

@@ -216,7 +216,9 @@ std::shared_ptr<MetadataFuture> ISWAManager::downloadMetadata(int id){
}
void ISWAManager::createScreenSpace(int id){
OsEng.renderEngine().registerScreenSpaceRenderable(std::make_shared<ScreenSpaceCygnet>(id));
std::string luaTable = "{ Type='ScreenSpaceCygnet', CygnetId = "+std::to_string(id)+"}";
std::string script = "openspace.registerScreenSpaceRenderable(" + luaTable + ");";
OsEng.scriptEngine().queueScript(script);
}
void ISWAManager::createPlane(std::shared_ptr<MetadataFuture> data){

18
src/rendering/renderengine.cpp
View File

@@ -375,12 +375,9 @@ void RenderEngine::postSynchronizationPreDraw() {
program->rebuildFromFile();
}
}
if(!_deletedScreenSpaceRenderables.empty())
_deletedScreenSpaceRenderables.clear();
for (auto screenspacerenderable : _screenSpaceRenderables) {
screenspacerenderable->update();
screenspacerenderable->update();
}
//Allow focus node to update camera (enables camera-following)
//FIX LATER: THIS CAUSES MASTER NODE TO BE ONE FRAME AHEAD OF SLAVES
@@ -646,6 +643,18 @@ scripting::ScriptEngine::LuaLibrary RenderEngine::luaLibrary() {
"",
true
},
{
"registerScreenSpaceRenderable",
&luascriptfunctions::registerScreenSpaceRenderable,
"table",
"Will create a ScreenSpaceRenderable from a lua Table and register it in the RenderEngine"
},
{
"unregisterScreenSpaceRenderable",
&luascriptfunctions::unregisterScreenSpaceRenderable,
"string",
"Given a ScreenSpaceRenderable name this script will remove it from the renderengine"
},
},
};
}
@@ -1148,7 +1157,6 @@ void RenderEngine::unregisterScreenSpaceRenderable(std::shared_ptr<ScreenSpaceRe
if (it != _screenSpaceRenderables.end()) {
s->deinitialize();
_deletedScreenSpaceRenderables.push_back(s);
_screenSpaceRenderables.erase(it);
}
}

44
src/rendering/renderengine_lua.inl
View File

@@ -133,6 +133,50 @@ int fadeOut(lua_State* L) {
return 0;
}
int registerScreenSpaceRenderable(lua_State* L) {
static const std::string _loggerCat = "registerScreenSpaceRenderable";
using ghoul::lua::errorLocation;
int nArguments = lua_gettop(L);
if (nArguments != 1)
return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
ghoul::Dictionary d;
try {
ghoul::lua::luaDictionaryFromState(L, d);
}
catch (const ghoul::lua::LuaFormatException& e) {
LERROR(e.what());
return 0;
}
std::shared_ptr<ScreenSpaceRenderable> s( ScreenSpaceRenderable::createFromDictionary(d) );
OsEng.renderEngine().registerScreenSpaceRenderable(s);
return 1;
}
int unregisterScreenSpaceRenderable(lua_State* L) {
static const std::string _loggerCat = "unregisterScreenSpaceRenderable";
using ghoul::lua::errorLocation;
int nArguments = lua_gettop(L);
if (nArguments != 1)
return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
std::string name = luaL_checkstring(L, -1);
std::shared_ptr<ScreenSpaceRenderable> s = OsEng.renderEngine().screenSpaceRenderable(name);
if (!s) {
LERROR(errorLocation(L) << "Could not find ScreenSpaceRenderable '" << name << "'");
return 0;
}
OsEng.renderEngine().unregisterScreenSpaceRenderable(s);
return 1;
}
} // namespace luascriptfunctions
}// namespace openspace

34
src/rendering/screenspacerenderable.cpp
View File

@@ -23,8 +23,37 @@
****************************************************************************************/
#include <openspace/engine/openspaceengine.h>
#include <openspace/rendering/screenspacerenderable.h>
#include <openspace/util/factorymanager.h>
namespace {
const std::string _loggerCat = "ScreenSpaceRenderable";
const std::string KeyType = "Type";
}
namespace openspace {
ScreenSpaceRenderable* ScreenSpaceRenderable::createFromDictionary(const ghoul::Dictionary& dictionary) {
std::string renderableType;
bool success = dictionary.getValue(KeyType, renderableType);
if (!success) {
LERROR("ScreenSpaceRenderable did not have key '" << KeyType << "'");
return nullptr;
}
ghoul::TemplateFactory<ScreenSpaceRenderable>* factory
= FactoryManager::ref().factory<ScreenSpaceRenderable>();
ScreenSpaceRenderable* result = factory->create(renderableType, dictionary);
if (result == nullptr) {
LERROR("Failed to create a ScreenSpaceRenderable object of type '" << renderableType << "'");
return nullptr;
}
return result;
}
ScreenSpaceRenderable::ScreenSpaceRenderable()
:_enabled("enabled", "Is Enabled", true)
,_useFlatScreen("flatScreen", "Flat Screen", true)
@@ -72,7 +101,10 @@ ScreenSpaceRenderable::ScreenSpaceRenderable()
useEuclideanCoordinates(_useFlatScreen.value());
});
_delete.onChange([this](){OsEng.renderEngine().unregisterScreenSpaceRenderable(name());});
_delete.onChange([this](){
std::string script = "openspace.unregisterScreenSpaceRenderable('" + name() + "');";
OsEng.scriptEngine().queueScript(script);
});
}
ScreenSpaceRenderable::~ScreenSpaceRenderable(){}