Initial SplashScreen

Editor/CMakeLists.txt

@@ -4,9 +4,11 @@ add_subdirectory(locale)
 atdna(atdna_Space.cpp Space.hpp)
 
 set(SPACE_HEADERS
+    SplashScreen/SplashScreen.hpp
     ResourceOutliner/ResourceOutliner.hpp)
 
 set(SPACE_SOURCES
+    SplashScreen/SplashScreen.cpp
     ResourceOutliner/ResourceOutliner.cpp)
 
 add_executable(rude WIN32

Editor/Space.hpp

@@ -44,8 +44,8 @@ protected:
     virtual bool usesToolbar() const {return false;}
     virtual void buildToolbar(Specter::ViewResources& res, Specter::Toolbar& tb) {}
     virtual Specter::View* buildContent(Specter::ViewResources& res)=0;
-public:
     Specter::Space* buildSpace(Specter::ViewResources& res);
+public:
 };
 
 class SplitSpace : public Space

Editor/SplashScreen/SplashScreen.cpp

@@ -0,0 +1,341 @@
+#include "SplashScreen.hpp"
+
+namespace RUDE
+{
+
+#define SPLASH_WIDTH 555
+#define SPLASH_HEIGHT 300
+
+#define WIRE_START 0
+#define WIRE_FRAMES 60
+#define SOLID_START 40
+#define SOLID_FRAMES 40
+#define TEXT_START 80
+#define TEXT_FRAMES 40
+
+#define TEXT_MARGIN 10
+
+void SplashScreen::setLineVerts(int width, int height, float pf, float t)
+{
+    std::pair<int,int> margin = m_cornersOutline[0]->queryGlyphDimensions(0);
+    float t1 = Zeus::Math::clamp(0.f, t * 2.f, 1.f);
+    float t2 = Zeus::Math::clamp(0.f, t * 2.f - 1.f, 1.f);
+
+    float lineLeft = 0;
+    float lineRight = pf*2;
+    float lineTop = height-margin.second;
+    float lineBottom = margin.second;
+    m_verts.lineVerts[0].m_pos.assign(lineLeft, lineTop, 0);
+    m_verts.lineVerts[1].m_pos = Zeus::CVector3f::lerp({lineLeft, lineTop, 0}, {lineLeft, lineBottom, 0}, t1);
+    m_verts.lineVerts[2].m_pos.assign(lineRight, lineTop, 0);
+    m_verts.lineVerts[3].m_pos = Zeus::CVector3f::lerp({lineRight, lineTop, 0}, {lineRight, lineBottom, 0}, t1);
+    m_verts.lineVerts[4].m_pos = m_verts.lineVerts[3].m_pos;
+
+    lineLeft = margin.first;
+    lineRight = width-margin.first;
+    lineTop = height;
+    lineBottom = height-pf*2;
+    m_verts.lineVerts[5].m_pos.assign(lineLeft, lineTop, 0);
+    m_verts.lineVerts[6].m_pos = m_verts.lineVerts[5].m_pos;
+    m_verts.lineVerts[7].m_pos.assign(lineLeft, lineBottom, 0);
+    m_verts.lineVerts[8].m_pos = Zeus::CVector3f::lerp({lineLeft, lineTop, 0}, {lineRight, lineTop, 0}, t1);
+    m_verts.lineVerts[9].m_pos = Zeus::CVector3f::lerp({lineLeft, lineBottom, 0}, {lineRight, lineBottom, 0}, t1);
+    m_verts.lineVerts[10].m_pos = m_verts.lineVerts[9].m_pos;
+
+    lineLeft = width-pf*2;
+    lineRight = width;
+    lineTop = height-margin.second;
+    lineBottom = margin.second;
+    m_verts.lineVerts[11].m_pos.assign(lineLeft, lineTop, 0);
+    m_verts.lineVerts[12].m_pos = m_verts.lineVerts[11].m_pos;
+    m_verts.lineVerts[13].m_pos = Zeus::CVector3f::lerp({lineLeft, lineTop, 0}, {lineLeft, lineBottom, 0}, t2);
+    m_verts.lineVerts[14].m_pos.assign(lineRight, lineTop, 0);
+    m_verts.lineVerts[15].m_pos = Zeus::CVector3f::lerp({lineRight, lineTop, 0}, {lineRight, lineBottom, 0}, t2);
+    m_verts.lineVerts[16].m_pos = m_verts.lineVerts[15].m_pos;
+
+    lineLeft = margin.first;
+    lineRight = width-margin.first;
+    lineTop = pf*2;
+    lineBottom = 0;
+    m_verts.lineVerts[17].m_pos.assign(lineLeft, lineTop, 0);
+    m_verts.lineVerts[18].m_pos = m_verts.lineVerts[17].m_pos;
+    m_verts.lineVerts[19].m_pos.assign(lineLeft, lineBottom, 0);
+    m_verts.lineVerts[20].m_pos = Zeus::CVector3f::lerp({lineLeft, lineTop, 0}, {lineRight, lineTop, 0}, t2);
+    m_verts.lineVerts[21].m_pos = Zeus::CVector3f::lerp({lineLeft, lineBottom, 0}, {lineRight, lineBottom, 0}, t2);
+}
+
+void SplashScreen::setLineColors(float t)
+{
+    float t1 = Zeus::Math::clamp(0.f, t * 2.f, 1.f);
+    float t2 = Zeus::Math::clamp(0.f, t * 2.f - 1.f, 1.f);
+    float t3 = Zeus::Math::clamp(0.f, t * 2.f - 2.f, 1.f);
+
+    Zeus::CColor c1 = Zeus::CColor::lerp(m_splash1, m_splash2, t1);
+    Zeus::CColor c2 = Zeus::CColor::lerp(m_splash1, m_splash2, t2);
+    Zeus::CColor c3 = Zeus::CColor::lerp(m_splash1, m_splash2, t3);
+
+    m_cornersOutline[0]->colorGlyphs(c1);
+    if (t < 0.5)
+    {
+        m_cornersOutline[1]->colorGlyphs(Zeus::CColor::skClear);
+        m_cornersOutline[2]->colorGlyphs(Zeus::CColor::skClear);
+        m_cornersOutline[3]->colorGlyphs(Zeus::CColor::skClear);
+    }
+    else if (t < 1.0)
+    {
+        m_cornersOutline[1]->colorGlyphs(c2);
+        m_cornersOutline[3]->colorGlyphs(c2);
+    }
+    else
+    {
+        m_cornersOutline[1]->colorGlyphs(c2);
+        m_cornersOutline[2]->colorGlyphs(c3);
+        m_cornersOutline[3]->colorGlyphs(c2);
+    }
+
+    m_verts.lineVerts[0].m_color = c1;
+    m_verts.lineVerts[1].m_color = c2;
+    m_verts.lineVerts[2].m_color = m_verts.lineVerts[0].m_color;
+    m_verts.lineVerts[3].m_color = m_verts.lineVerts[1].m_color;
+    m_verts.lineVerts[4].m_color = m_verts.lineVerts[3].m_color;
+
+    m_verts.lineVerts[5].m_color = c1;
+    m_verts.lineVerts[6].m_color = m_verts.lineVerts[5].m_color;
+    m_verts.lineVerts[7].m_color = m_verts.lineVerts[6].m_color;
+    m_verts.lineVerts[8].m_color = c2;
+    m_verts.lineVerts[9].m_color = m_verts.lineVerts[8].m_color;
+    m_verts.lineVerts[10].m_color = m_verts.lineVerts[9].m_color;
+
+    m_verts.lineVerts[11].m_color = c2;
+    m_verts.lineVerts[12].m_color = m_verts.lineVerts[11].m_color;
+    m_verts.lineVerts[13].m_color = c3;
+    m_verts.lineVerts[14].m_color = m_verts.lineVerts[12].m_color;
+    m_verts.lineVerts[15].m_color = m_verts.lineVerts[13].m_color;
+    m_verts.lineVerts[16].m_color = m_verts.lineVerts[15].m_color;
+
+    m_verts.lineVerts[17].m_color = c2;
+    m_verts.lineVerts[18].m_color = m_verts.lineVerts[17].m_color;
+    m_verts.lineVerts[19].m_color = m_verts.lineVerts[18].m_color;
+    m_verts.lineVerts[20].m_color = c3;
+    m_verts.lineVerts[21].m_color = m_verts.lineVerts[20].m_color;
+}
+
+void SplashScreen::setFillVerts(int width, int height, float pf)
+{
+    std::pair<int,int> margin = m_cornersFilled[0]->queryGlyphDimensions(0);
+
+    float fillLeft = pf;
+    float fillRight = width-pf;
+    float fillTop = height-margin.second;
+    float fillBottom = margin.second;
+    m_verts.fillVerts[0].m_pos.assign(fillLeft, fillTop, 0);
+    m_verts.fillVerts[1].m_pos.assign(fillLeft, fillBottom, 0);
+    m_verts.fillVerts[2].m_pos.assign(fillRight, fillTop, 0);
+    m_verts.fillVerts[3].m_pos.assign(fillRight, fillBottom, 0);
+    m_verts.fillVerts[4].m_pos = m_verts.fillVerts[3].m_pos;
+
+    fillLeft = margin.first;
+    fillRight = width-margin.first;
+    fillTop = height-pf;
+    fillBottom = height-margin.second;
+    m_verts.fillVerts[5].m_pos.assign(fillLeft, fillTop, 0);
+    m_verts.fillVerts[6].m_pos = m_verts.fillVerts[5].m_pos;
+    m_verts.fillVerts[7].m_pos.assign(fillLeft, fillBottom, 0);
+    m_verts.fillVerts[8].m_pos.assign(fillRight, fillTop, 0);
+    m_verts.fillVerts[9].m_pos.assign(fillRight, fillBottom, 0);
+    m_verts.fillVerts[10].m_pos = m_verts.fillVerts[9].m_pos;
+
+    fillLeft = margin.first;
+    fillRight = width-margin.first;
+    fillTop = margin.second;
+    fillBottom = pf;
+    m_verts.fillVerts[11].m_pos.assign(fillLeft, fillTop, 0);
+    m_verts.fillVerts[12].m_pos = m_verts.fillVerts[11].m_pos;
+    m_verts.fillVerts[13].m_pos.assign(fillLeft, fillBottom, 0);
+    m_verts.fillVerts[14].m_pos.assign(fillRight, fillTop, 0);
+    m_verts.fillVerts[15].m_pos.assign(fillRight, fillBottom, 0);
+}
+
+void SplashScreen::setFillColors(float t)
+{
+    t = Zeus::Math::clamp(0.f, t, 1.f);
+    Zeus::CColor color = Zeus::CColor::lerp(m_splashBgClear, m_splashBg, t);
+
+    for (int i=0 ; i<16 ; ++i)
+        m_verts.fillVerts[i].m_color = color;
+    for (int i=0 ; i<4 ; ++i)
+        m_cornersFilled[i]->colorGlyphs(color);
+}
+
+SplashScreen::SplashScreen(ViewManager& vm, Specter::ViewResources& res)
+: View(res, vm.rootView()), m_vm(vm),
+  m_splashBg(res.themeData().splashBackground()),
+  m_splashBgClear(m_splashBg),
+  m_splash1(res.themeData().splash1()),
+  m_splash2(res.themeData().splash2()),
+  m_textColor(res.themeData().uiText()),
+  m_textColorClear(m_textColor)
+{
+    m_splashBgClear[3] = 0.0;
+    m_textColorClear[3] = 0.0;
+    m_viewBlockBuf = res.m_factory->newDynamicBuffer(boo::BufferUse::Uniform, sizeof(ViewBlock), 1);
+    m_vertsBuf = res.m_factory->newDynamicBuffer(boo::BufferUse::Vertex, sizeof(SolidShaderVert), 38);
+
+    if (!res.m_viewRes.m_solidVtxFmt)
+    {
+        boo::VertexElementDescriptor vdescs[] =
+        {
+            {m_vertsBuf, nullptr, boo::VertexSemantic::Position4},
+            {m_vertsBuf, nullptr, boo::VertexSemantic::Color}
+        };
+        m_vertsVtxFmt = res.m_factory->newVertexFormat(2, vdescs);
+        boo::IGraphicsBuffer* bufs[] = {m_viewBlockBuf};
+        m_vertsShaderBinding = res.m_factory->newShaderDataBinding(res.m_viewRes.m_solidShader,
+                                                                   m_vertsVtxFmt, m_vertsBuf, nullptr,
+                                                                   nullptr, 1, bufs, 0, nullptr);
+    }
+    else
+    {
+        boo::IGraphicsBuffer* bufs[] = {m_viewBlockBuf};
+        m_vertsShaderBinding = res.m_factory->newShaderDataBinding(res.m_viewRes.m_solidShader,
+                                                                   res.m_viewRes.m_solidVtxFmt,
+                                                                   m_vertsBuf, nullptr,
+                                                                   nullptr, 1, bufs, 0, nullptr);
+    }
+    commitResources(res);
+
+    for (int i=0 ; i<4 ; ++i)
+    {
+        m_cornersOutline[i].reset(new Specter::TextView(res, *this, res.m_curveFont, 1));
+        m_cornersFilled[i].reset(new Specter::TextView(res, *this, res.m_curveFont, 1));
+    }
+    m_cornersOutline[0]->typesetGlyphs(L"\xF4F0");
+    m_cornersFilled[0]->typesetGlyphs(L"\xF4F1", res.themeData().splashBackground());
+    m_cornersOutline[1]->typesetGlyphs(L"\xF4F2");
+    m_cornersFilled[1]->typesetGlyphs(L"\xF4F3", res.themeData().splashBackground());
+    m_cornersOutline[2]->typesetGlyphs(L"\xF4F4");
+    m_cornersFilled[2]->typesetGlyphs(L"\xF4F5", res.themeData().splashBackground());
+    m_cornersOutline[3]->typesetGlyphs(L"\xF4F6");
+    m_cornersFilled[3]->typesetGlyphs(L"\xF4F7", res.themeData().splashBackground());
+
+    float pf = res.pixelFactor();
+    setLineVerts(SPLASH_WIDTH * pf, SPLASH_HEIGHT * pf, pf, 0.0);
+    setFillVerts(SPLASH_WIDTH * pf, SPLASH_HEIGHT * pf, pf);
+    setLineColors(0.0);
+    setFillColors(0.0);
+
+    m_vertsBuf->load(&m_verts, sizeof(m_verts));
+}
+
+static float CubicEase(float t)
+{
+    t *= 2.f;
+    if (t < 1) return 1.f/2.f*t*t*t;
+    t -= 2.f;
+    return 1.f/2.f*(t*t*t + 2.f);
+}
+
+void SplashScreen::think()
+{
+    Specter::ViewResources& res = rootView().viewRes();
+    float pf = res.pixelFactor();
+
+    if (!m_title && res.m_titleFont)
+    {
+        m_title.reset(new Specter::TextView(res, *this, res.m_titleFont));
+        Zeus::CColor clearColor = res.themeData().uiText();
+        clearColor[3] = 0.0;
+        m_title->typesetGlyphs("RUDE", clearColor);
+        updateSize();
+    }
+
+    bool loadVerts = false;
+    if (m_frame > WIRE_START)
+    {
+        float wt = (m_frame-WIRE_START) / float(WIRE_FRAMES);
+        wt = Zeus::Math::clamp(0.f, wt, 2.f);
+        setLineVerts(SPLASH_WIDTH * pf, SPLASH_HEIGHT * pf, pf, CubicEase(wt));
+        setLineColors(wt);
+        loadVerts = true;
+    }
+    if (m_frame > SOLID_START)
+    {
+        float ft = (m_frame-SOLID_START) / float(SOLID_FRAMES);
+        ft = Zeus::Math::clamp(0.f, ft, 2.f);
+        setFillColors(ft);
+        loadVerts = true;
+    }
+    if (m_title && m_frame > TEXT_START)
+    {
+        if (!m_textStartFrame)
+            m_textStartFrame = m_frame;
+        float tt = (m_frame-m_textStartFrame) / float(TEXT_FRAMES);
+        tt = Zeus::Math::clamp(0.f, tt, 1.f);
+        Zeus::CColor clearColor = res.themeData().uiText();
+        clearColor[3] = 0.0;
+        Zeus::CColor color = Zeus::CColor::lerp(clearColor, res.themeData().uiText(), tt);
+        m_title->colorGlyphs(color);
+    }
+
+    if (loadVerts)
+        m_vertsBuf->load(&m_verts, sizeof(m_verts));
+
+    ++m_frame;
+}
+
+void SplashScreen::resized(const boo::SWindowRect& root, const boo::SWindowRect& sub)
+{
+    float pf = rootView().viewRes().pixelFactor();
+
+    boo::SWindowRect centerRect = sub;
+    centerRect.location[0] = root.size[0] / 2 - (SPLASH_WIDTH * pf / 2.0);
+    centerRect.location[1] = root.size[1] / 2 - (SPLASH_HEIGHT * pf / 2.0);
+    View::resized(root, centerRect);
+    m_viewBlock.setViewRect(root, centerRect);
+    m_viewBlockBuf->load(&m_viewBlock, sizeof(m_viewBlock));
+
+    boo::SWindowRect textRect = centerRect;
+    textRect.location[0] += TEXT_MARGIN * pf;
+    textRect.location[1] += (SPLASH_HEIGHT - 36) * pf;
+    if (m_title)
+        m_title->resized(root, textRect);
+
+    boo::SWindowRect cornerRect = centerRect;
+    cornerRect.size[0] = cornerRect.size[1] = 8 * pf;
+    cornerRect.location[1] = centerRect.location[1] + (SPLASH_HEIGHT - 8) * pf;
+    m_cornersOutline[0]->resized(root, cornerRect);
+    m_cornersFilled[0]->resized(root, cornerRect);
+    cornerRect.location[0] = centerRect.location[0] + (SPLASH_WIDTH - 8) * pf;
+    m_cornersOutline[1]->resized(root, cornerRect);
+    m_cornersFilled[1]->resized(root, cornerRect);
+    cornerRect.location[1] = centerRect.location[1];
+    m_cornersOutline[2]->resized(root, cornerRect);
+    m_cornersFilled[2]->resized(root, cornerRect);
+    cornerRect.location[0] = centerRect.location[0];
+    m_cornersOutline[3]->resized(root, cornerRect);
+    m_cornersFilled[3]->resized(root, cornerRect);
+}
+
+void SplashScreen::draw(boo::IGraphicsCommandQueue* gfxQ)
+{
+    gfxQ->setShaderDataBinding(m_vertsShaderBinding);
+    gfxQ->setDrawPrimitive(boo::Primitive::TriStrips);
+    if (m_frame > WIRE_START)
+        gfxQ->draw(0, 22);
+    if (m_frame > SOLID_START)
+        gfxQ->draw(22, 16);
+    if (m_title && m_textStartFrame && m_frame > m_textStartFrame)
+        m_title->draw(gfxQ);
+
+    m_cornersFilled[0]->draw(gfxQ);
+    m_cornersFilled[1]->draw(gfxQ);
+    m_cornersFilled[2]->draw(gfxQ);
+    m_cornersFilled[3]->draw(gfxQ);
+
+    m_cornersOutline[0]->draw(gfxQ);
+    m_cornersOutline[1]->draw(gfxQ);
+    m_cornersOutline[2]->draw(gfxQ);
+    m_cornersOutline[3]->draw(gfxQ);
+}
+
+}

Editor/SplashScreen/SplashScreen.hpp

@@ -0,0 +1,58 @@
+#ifndef RUDE_SPLASH_SCREEN_HPP
+#define RUDE_SPLASH_SCREEN_HPP
+
+#include <Specter/View.hpp>
+#include <Specter/MultiLineTextView.hpp>
+#include "ViewManager.hpp"
+
+namespace RUDE
+{
+class SplashScreen : public Specter::View
+{
+    ViewManager& m_vm;
+    unsigned m_frame = 0;
+    unsigned m_textStartFrame = 0;
+
+    Zeus::CColor m_splashBg;
+    Zeus::CColor m_splashBgClear;
+    Zeus::CColor m_splash1;
+    Zeus::CColor m_splash2;
+    Zeus::CColor m_textColor;
+    Zeus::CColor m_textColorClear;
+
+    ViewBlock m_viewBlock;
+    boo::IGraphicsBufferD* m_viewBlockBuf;
+    struct
+    {
+        SolidShaderVert lineVerts[22];
+        SolidShaderVert fillVerts[16];
+    } m_verts;
+
+    void setLineVerts(int width, int height, float pf, float t);
+    void setLineColors(float t);
+    void setFillVerts(int width, int height, float pf);
+    void setFillColors(float t);
+
+    boo::IGraphicsBufferD* m_vertsBuf;
+    boo::IVertexFormat* m_vertsVtxFmt; /* OpenGL only */
+    boo::IShaderDataBinding* m_vertsShaderBinding;
+
+    std::string m_titleStr;
+    std::unique_ptr<Specter::TextView> m_title;
+    std::string m_messageStr;
+    std::unique_ptr<Specter::MultiLineTextView> m_message;
+
+    std::unique_ptr<Specter::TextView> m_cornersOutline[4];
+    std::unique_ptr<Specter::TextView> m_cornersFilled[4];
+public:
+    SplashScreen(ViewManager& vm, Specter::ViewResources& res);
+    void think();
+
+    void resized(const boo::SWindowRect& root, const boo::SWindowRect& sub);
+    void draw(boo::IGraphicsCommandQueue* gfxQ);
+};
+
+}
+
+
+#endif // RUDE_SPLASH_SCREEN_HPP

Editor/ViewManager.cpp

@@ -1,6 +1,7 @@
 #include "ViewManager.hpp"
 #include "Specter/Control.hpp"
 #include "Specter/Space.hpp"
+#include "SplashScreen/SplashScreen.hpp"
 
 using YAMLNode = Athena::io::YAMLNode;
 
@@ -20,6 +21,19 @@ Specter::View* ViewManager::BuildSpaceViews(RUDE::Space* space)
 void ViewManager::SetupRootView()
 {
     m_rootView.reset(new Specter::RootView(*this, m_viewResources, m_mainWindow.get()));
+    m_rootView->setBackground(Zeus::CColor::skBlack);
+    m_rootView->updateSize();
+}
+
+void ViewManager::SetupSplashView()
+{
+    m_splash.reset(new SplashScreen(*this, m_viewResources));
+    m_rootView->setContentView(m_splash.get());
+    m_rootView->updateSize();
+}
+
+void ViewManager::SetupEditorView()
+{
     m_rootView->setBackground(Zeus::CColor::skGrey);
     m_rootView->setContentView(m_split.buildContent(m_viewResources));
     m_split.m_splitView->setContentView(0, BuildSpaceViews(&m_space1));
@@ -27,19 +41,32 @@ void ViewManager::SetupRootView()
     m_rootView->updateSize();
 }
 
+ViewManager::ViewManager(HECL::Runtime::FileStoreManager& fileMgr, HECL::CVarManager& cvarMgr)
+: m_cvarManager(cvarMgr), m_fontCache(fileMgr),
+  m_setTo1(*this), m_setTo2(*this),
+  m_split(*this),
+  m_space1(*this, "Hello, World!\n\n", "Hello Button", &m_setTo1),
+  m_space2(*this, "こんにちは世界！\n\n", "こんにちはボタン", &m_setTo2)
+{}
+
+ViewManager::~ViewManager() {}
+
 void ViewManager::init(boo::IApplication* app)
 {
     m_mainWindow = std::unique_ptr<boo::IWindow>(app->newWindow(_S("RUDE")));
     m_mainWindow->showWindow();
     m_mainWindow->setWaitCursor(true);
 
-    float pixelFactor = 2.0;
+    float pixelFactor = 1.0;
     m_cvPixelFactor = m_cvarManager.newCVar("ed_pixelfactor", "User-selected UI Scale",
                                     pixelFactor, HECL::CVar::EFlags::Editor | HECL::CVar::EFlags::Archive);
 
     boo::IGraphicsDataFactory* gf = m_mainWindow->getMainContextDataFactory();
     m_viewResources.init(gf, &m_fontCache, Specter::ThemeData(), pixelFactor);
+    m_viewResources.prepFontCacheAsync(m_mainWindow.get());
     SetupRootView();
+    SetupSplashView();
+    m_showSplash = true;
 
     m_mainWindow->setWaitCursor(false);
 }
@@ -64,6 +91,8 @@ bool ViewManager::proc()
     }
 #endif
     m_rootView->dispatchEvents();
+    if (m_showSplash)
+        m_splash->think();
     m_rootView->draw(gfxQ);
     gfxQ->execute();
     m_mainWindow->waitForRetrace();

Editor/ViewManager.hpp

@@ -6,6 +6,7 @@
 
 namespace RUDE
 {
+class SplashScreen;
 
 class ViewManager : Specter::IViewManager
 {
@@ -14,6 +15,7 @@ class ViewManager : Specter::IViewManager
     Specter::ViewResources m_viewResources;
     std::unique_ptr<boo::IWindow> m_mainWindow;
     std::unique_ptr<Specter::RootView> m_rootView;
+    std::unique_ptr<SplashScreen> m_splash;
 
     HECL::CVar* m_cvPixelFactor;
 
@@ -22,6 +24,10 @@ class ViewManager : Specter::IViewManager
 
     Specter::View* BuildSpaceViews(RUDE::Space* space);
     void SetupRootView();
+    void SetupSplashView();
+    void SetupEditorView();
+
+    bool m_showSplash = false;
 public:
     struct SetTo1 : Specter::IButtonBinding
     {
@@ -59,13 +65,8 @@ public:
     TestSpace m_space1;
     TestSpace m_space2;
 
-    ViewManager(HECL::Runtime::FileStoreManager& fileMgr, HECL::CVarManager& cvarMgr)
+    ViewManager(HECL::Runtime::FileStoreManager& fileMgr, HECL::CVarManager& cvarMgr);
-    : m_cvarManager(cvarMgr), m_fontCache(fileMgr),
+    ~ViewManager();
-      m_setTo1(*this), m_setTo2(*this),
-      m_split(*this),
-      m_space1(*this, "Hello, World!\n\n", "Hello Button", &m_setTo1),
-      m_space2(*this, "こんにちは世界！\n\n", "こんにちはボタン", &m_setTo2)
-    {}
 
     Specter::RootView& rootView() const {return *m_rootView;}
     void RequestPixelFactor(float pf)

libSpecter

@@ -1 +1 @@
-Subproject commit 409855bc1b8085beb0a739efdf31ee53a7a8d305
+Subproject commit d495a1b104274916927da1ade3f53b6b706dcd7d