# HG changeset patch # User coz # Date 1614716118 0 # Tue Mar 02 20:15:18 2021 +0000 # Node ID 8465d9534a77e40b72553b8387ebf0bcb9bd7693 # Parent 5d6a36eba981095e3907123b9e121f0bc97ea50f Testing two instances diff -r 5d6a36eba981 -r 8465d9534a77 bin/Data/Main.compositor --- a/bin/Data/Main.compositor Tue Feb 16 18:43:56 2021 -0300 +++ b/bin/Data/Main.compositor Tue Mar 02 20:15:18 2021 +0000 @@ -29,7 +29,42 @@ } } +compositor_node RenderingNode2 +{ + in 0 renderWindow + + target renderWindow + { + pass render_scene + { + load + { + all clear + clear_colour 0.4 0.1 0.1 1 + } + store + { + colour store_or_resolve + depth dont_care + stencil dont_care + } + overlays on + } + + pass custom colibri_gui2 + { + // Colibri doesn't have load/store semantics. + // It appends itself to the previous pass' + } + } +} + workspace ColibriGuiWorkspace { connect_output RenderingNode 0 } + +workspace ColibriGuiWorkspace2 +{ + connect_output RenderingNode2 0 +} \ No newline at end of file diff -r 5d6a36eba981 -r 8465d9534a77 bin/Data/Materials/ColibriGui/Skins/DarkGloss/Atlas.dds Binary file bin/Data/Materials/ColibriGui/Skins/DarkGloss/Atlas.dds has changed diff -r 5d6a36eba981 -r 8465d9534a77 bin/Data/Materials/ColibriGui/Skins/DarkGloss/Skins.material --- a/bin/Data/Materials/ColibriGui/Skins/DarkGloss/Skins.material Tue Feb 16 18:43:56 2021 -0300 +++ b/bin/Data/Materials/ColibriGui/Skins/DarkGloss/Skins.material Tue Mar 02 20:15:18 2021 +0000 @@ -1,30 +1,30 @@ -hlms Atlas unlit -{ - diffuse_map Atlas.png -} -hlms AtlasTransparent unlit -{ - scene_blend alpha_blend - diffuse_map Atlas.png -} -hlms AtlasDisabled unlit -{ - diffuse 1 1 1 0.2 - scene_blend alpha_blend - diffuse_map Atlas.png -} -hlms AtlasBrighter unlit -{ - diffuse 2 2 2 1 - diffuse_map Atlas.png -} -hlms AtlasBrighterTransparent unlit -{ - diffuse 2 2 2 1 - scene_blend alpha_blend - diffuse_map Atlas.png -} -hlms ProgressBarLayerProgress unlit -{ - diffuse_map ProgressBar_l0.png -} +hlms Atlas unlit +{ + diffuse_map Atlas.dds +} +hlms AtlasTransparent unlit +{ + scene_blend alpha_blend + diffuse_map Atlas.dds +} +hlms AtlasDisabled unlit +{ + diffuse 1 1 1 0.2 + scene_blend alpha_blend + diffuse_map Atlas.dds +} +hlms AtlasBrighter unlit +{ + diffuse 2 2 2 1 + diffuse_map Atlas.dds +} +hlms AtlasBrighterTransparent unlit +{ + diffuse 2 2 2 1 + scene_blend alpha_blend + diffuse_map Atlas.dds +} +hlms ProgressBarLayerProgress unlit +{ + diffuse_map ProgressBar_l0.dds +} diff -r 5d6a36eba981 -r 8465d9534a77 include/ColibriGui/ColibriManager.h --- a/include/ColibriGui/ColibriManager.h Tue Feb 16 18:43:56 2021 -0300 +++ b/include/ColibriGui/ColibriManager.h Tue Mar 02 20:15:18 2021 +0000 @@ -2,7 +2,7 @@ #pragma once #include "ColibriGui/ColibriWidget.h" - +#include "OgreHlmsCommon.h" #include "OgreIdString.h" COLIBRIGUI_ASSUME_NONNULL_BEGIN @@ -167,7 +167,7 @@ UiVertex *m_vertexBufferBase; GlyphVertex *m_textVertexBufferBase; - + Ogre::HlmsCache m_dummyCache; #if COLIBRIGUI_DEBUG_MEDIUM bool m_fillBuffersStarted; bool m_renderingStarted; diff -r 5d6a36eba981 -r 8465d9534a77 include/ColibriGui/Ogre/CompositorPassColibriGuiProvider.h --- a/include/ColibriGui/Ogre/CompositorPassColibriGuiProvider.h Tue Feb 16 18:43:56 2021 -0300 +++ b/include/ColibriGui/Ogre/CompositorPassColibriGuiProvider.h Tue Mar 02 20:15:18 2021 +0000 @@ -1,50 +1,61 @@ - -#pragma once - -#include "ColibriGui/ColibriGuiPrerequisites.h" -#include "OgrePrerequisites.h" -#include "Compositor/Pass/OgreCompositorPassProvider.h" - -namespace Ogre -{ - /** @ingroup Api_Backend - @class CompositorPassColibriGuiProvider - Generates the CompositorPassColibriGui pass needed to render Colibri UI - Also ensures the compositor scripts recognize the pass type "colibri_gui" - i.e. - @code - pass custom colibri_gui - { - } - @endcode - */ - class CompositorPassColibriGuiProvider : public CompositorPassProvider - { - Colibri::ColibriManager *m_colibriManager; - - public: - CompositorPassColibriGuiProvider( Colibri::ColibriManager *colibriManager ); - - /** Called from CompositorTargetDef::addPass when adding a Compositor Pass of type 'custom' - @param passType - @param customId - Arbitrary ID in case there is more than one type of custom pass you want to implement. - Defaults to IdString() - @param rtIndex - @param parentNodeDef - @return - */ - virtual CompositorPassDef* addPassDef( CompositorPassType passType, - IdString customId, - CompositorTargetDef *parentTargetDef, - CompositorNodeDef *parentNodeDef ); - - /** Creates a CompositorPass from a CompositorPassDef for Compositor Pass of type 'custom' - @remarks If you have multiple custom pass types then you will need to use dynamic_cast<>() - on the CompositorPassDef to determine what custom pass it is. - */ - virtual CompositorPass* addPass( const CompositorPassDef *definition, Camera *defaultCamera, - CompositorNode *parentNode, const RenderTargetViewDef *rtvDef, - SceneManager *sceneManager ); - }; -} + +#pragma once + +#include "ColibriGui/ColibriGuiPrerequisites.h" +#include "OgrePrerequisites.h" +#include "Compositor/Pass/OgreCompositorPassProvider.h" + +namespace Ogre +{ + /** @ingroup Api_Backend + @class CompositorPassColibriGuiProvider + Generates the CompositorPassColibriGui pass needed to render Colibri UI + Also ensures the compositor scripts recognize the pass type "colibri_gui" + i.e. + @code + pass custom colibri_gui + { + } + @endcode + */ + class CompositorPassColibriGuiProvider : public CompositorPassProvider + { + Colibri::ColibriManager *m_colibriManager1; + Colibri::ColibriManager *m_colibriManager2; + Ogre::Camera *m_camera1; + Ogre::Camera *m_camera2; + + public: + CompositorPassColibriGuiProvider( Colibri::ColibriManager *colibriManager1); + + CompositorPassColibriGuiProvider( Colibri::ColibriManager *colibriManager1, + Colibri::ColibriManager *colibriManager2, + Ogre::Camera *cam1, + Ogre::Camera *cam2 ); + + /** Called from CompositorTargetDef::addPass when adding a Compositor Pass of type 'custom' + @param passType + @param customId + Arbitrary ID in case there is more than one type of custom pass you want to implement. + Defaults to IdString() + @param rtIndex + @param parentNodeDef + @return + */ + virtual CompositorPassDef* addPassDef( CompositorPassType passType, + IdString customId, + CompositorTargetDef *parentTargetDef, + CompositorNodeDef *parentNodeDef ); + + /** Creates a CompositorPass from a CompositorPassDef for Compositor Pass of type 'custom' + @remarks If you have multiple custom pass types then you will need to use dynamic_cast<>() + on the CompositorPassDef to determine what custom pass it is. + */ + virtual CompositorPass* addPass( const CompositorPassDef *definition, Camera *defaultCamera, + CompositorNode *parentNode, const RenderTargetViewDef *rtvDef, + SceneManager *sceneManager ); + }; + + + +} diff -r 5d6a36eba981 -r 8465d9534a77 include/ColibriGuiGameState.h --- a/include/ColibriGuiGameState.h Tue Feb 16 18:43:56 2021 -0300 +++ b/include/ColibriGuiGameState.h Tue Mar 02 20:15:18 2021 +0000 @@ -15,6 +15,7 @@ ColibriGuiGameState( const Ogre::String &helpDescription ); virtual void createScene01(void); + virtual void createScene02( void ); virtual void destroyScene(); virtual void update( float timeSinceLast ); diff -r 5d6a36eba981 -r 8465d9534a77 src/ColibriGui.cpp --- a/src/ColibriGui.cpp Tue Feb 16 18:43:56 2021 -0300 +++ b/src/ColibriGui.cpp Tue Mar 02 20:15:18 2021 +0000 @@ -61,7 +61,8 @@ namespace Demo { - extern Colibri::ColibriManager *colibriManager; + extern Colibri::ColibriManager *colibriManager1; + extern Colibri::ColibriManager *colibriManager2; class ColibriLogListener : public Colibri::LogListener { virtual void log( const char *text, Colibri::LogSeverity::LogSeverity severity ) @@ -83,13 +84,20 @@ } }; static ColibriLogListener g_colibriLogListener; + static ColibriLogListener g_colibriLogListener2; static ColibriListener g_colibriListener; + static ColibriListener g_colibriListener2; class ColibriGuiGraphicsSystem : public GraphicsSystem { virtual Ogre::CompositorWorkspace* setupCompositor() { Ogre::CompositorManager2 *compositorManager = mRoot->getCompositorManager2(); + // add Workspace to a seperate camera and window + compositorManager->addWorkspace( mSceneManager, mRenderWindow2->getTexture(), mCamera2, + "ColibriGuiWorkspace2", true ); + + return compositorManager->addWorkspace( mSceneManager, mRenderWindow->getTexture(), mCamera, "ColibriGuiWorkspace", true ); } @@ -232,16 +240,17 @@ #endif ShaperSettings shaperSettings[3] = { - ShaperSettings( "en", "Fonts/DejaVuSerif.ttf", HB_SCRIPT_LATIN, true ), + ShaperSettings( "en", "Fonts/AGENCYB.TTF", HB_SCRIPT_LATIN, true ), ShaperSettings( "ar", "Fonts/amiri-0.104/amiri-regular.ttf", HB_SCRIPT_ARABIC, false, Colibri::HorizReadingDir::RTL ), ShaperSettings( "ch", "Fonts/fireflysung-1.3.0/fireflysung.ttf", HB_SCRIPT_HAN, false, Colibri::HorizReadingDir::LTR, true ) }; - colibriManager = new Colibri::ColibriManager( &g_colibriLogListener, - &g_colibriListener ); - Colibri::ShaperManager *shaperManager = colibriManager->getShaperManager(); + colibriManager1 = new Colibri::ColibriManager( &g_colibriLogListener, &g_colibriListener ); + colibriManager2 = new Colibri::ColibriManager( &g_colibriLogListener2, &g_colibriListener2 ); + + Colibri::ShaperManager *shaperManager = colibriManager1->getShaperManager(); for( size_t i=0; isetSwapRTLControls( true ); + + Colibri::ShaperManager *shaperManager2 = colibriManager2->getShaperManager(); - Ogre::CompositorPassColibriGuiProvider *compoProvider = - OGRE_NEW Ogre::CompositorPassColibriGuiProvider( colibriManager ); + for( size_t i = 0; i < sizeof( shaperSettings ) / sizeof( shaperSettings[0] ); ++i ) + { + Colibri::Shaper *shaper; + const Ogre::String fullPath = dataPath + shaperSettings[i].fullpath; + shaper = shaperManager2->addShaper( shaperSettings[i].script, fullPath.c_str(), + shaperSettings[i].locale ); + if( shaperSettings[i].useKerning ) + shaper->addFeatures( Colibri::Shaper::KerningOn ); + } + + shaperManager2->setDefaultShaper( defaultFont + 1u, + shaperSettings[defaultFont].horizReadingDir, + shaperSettings[defaultFont].allowsVerticalLayout ); + + if( defaultFont == 1 ) + colibriManager2->setSwapRTLControls( true ); + + Ogre::CompositorPassColibriGuiProvider *compoProvider = + OGRE_NEW Ogre::CompositorPassColibriGuiProvider( colibriManager1, colibriManager2, + mCamera, mCamera2 ); Ogre::CompositorManager2 *compositorManager = mRoot->getCompositorManager2(); compositorManager->setCompositorPassProvider( compoProvider ); diff -r 5d6a36eba981 -r 8465d9534a77 src/ColibriGui/ColibriManager.cpp --- a/src/ColibriGui/ColibriManager.cpp Tue Feb 16 18:43:56 2021 -0300 +++ b/src/ColibriGui/ColibriManager.cpp Tue Mar 02 20:15:18 2021 +0000 @@ -19,12 +19,13 @@ #include "OgreRoot.h" #include "CommandBuffer/OgreCommandBuffer.h" #include "CommandBuffer/OgreCbDrawCall.h" +#include "OgreHlmsCommon.h" namespace Colibri { static LogListener DefaultLogListener; static ColibriListener DefaultColibriListener; - static const Ogre::HlmsCache c_dummyCache( 0, Ogre::HLMS_MAX, Ogre::HlmsPso() ); + const std::string ColibriManager::c_defaultTextDatablockNames[States::NumStates] = { @@ -73,7 +74,8 @@ m_skinManager( 0 ), m_shaperManager( 0 ), m_vertexBufferBase( 0 ), - m_textVertexBufferBase( 0 ) + m_textVertexBufferBase( 0 ), + m_dummyCache( 0, Ogre::HLMS_MAX, Ogre::HlmsPso()) #if COLIBRIGUI_DEBUG_MEDIUM , m_fillBuffersStarted( false ) , m_renderingStarted( false ) @@ -184,10 +186,14 @@ for( size_t i=0; icreateDatablock( c_defaultTextDatablockNames[i], - c_defaultTextDatablockNames[i], - macroblock, blendblock, - Ogre::HlmsParamVec() ); + // check they dont already exist + m_defaultTextDatablock[i] = hlms->getDatablock( c_defaultTextDatablockNames[i] ); + if( m_defaultTextDatablock[i] == nullptr ) + { + m_defaultTextDatablock[i] = hlms->createDatablock( + c_defaultTextDatablockNames[i], c_defaultTextDatablockNames[i], macroblock, + blendblock, Ogre::HlmsParamVec() ); + } } COLIBRI_ASSERT_HIGH( dynamic_cast( @@ -1485,7 +1491,7 @@ COLIBRI_ASSERT_HIGH( dynamic_cast( hlms ) ); Ogre::HlmsColibri *hlmsColibri = static_cast( hlms ); - apiObjects.lastHlmsCache = &c_dummyCache; + apiObjects.lastHlmsCache = &m_dummyCache; Ogre::HlmsCache passCache = hlms->preparePassHash( 0, false, false, m_sceneManager ); apiObjects.passCache = &passCache; diff -r 5d6a36eba981 -r 8465d9534a77 src/ColibriGui/Ogre/CompositorPassColibriGuiProvider.cpp --- a/src/ColibriGui/Ogre/CompositorPassColibriGuiProvider.cpp Tue Feb 16 18:43:56 2021 -0300 +++ b/src/ColibriGui/Ogre/CompositorPassColibriGuiProvider.cpp Tue Mar 02 20:15:18 2021 +0000 @@ -1,35 +1,66 @@ - -#include "ColibriGui/Ogre/CompositorPassColibriGuiProvider.h" -#include "ColibriGui/Ogre/CompositorPassColibriGuiDef.h" -#include "ColibriGui/Ogre/CompositorPassColibriGui.h" - -namespace Ogre -{ - CompositorPassColibriGuiProvider::CompositorPassColibriGuiProvider( Colibri::ColibriManager *colibriManager ) : - m_colibriManager( colibriManager ) - { - } - //------------------------------------------------------------------------- - CompositorPassDef* CompositorPassColibriGuiProvider::addPassDef( - CompositorPassType passType, IdString customId, - CompositorTargetDef *parentTargetDef, CompositorNodeDef *parentNodeDef ) - { - if( customId == "colibri_gui" ) - return OGRE_NEW CompositorPassColibriGuiDef( parentTargetDef ); - - return 0; - } - //------------------------------------------------------------------------- - CompositorPass* CompositorPassColibriGuiProvider::addPass( const CompositorPassDef *definition, - Camera *defaultCamera, - CompositorNode *parentNode, - const RenderTargetViewDef *rtvDef, - SceneManager *sceneManager ) - { - COLIBRI_ASSERT( dynamic_cast( definition ) ); - const CompositorPassColibriGuiDef *colibriGuiDef = - static_cast( definition ); - return OGRE_NEW CompositorPassColibriGui( colibriGuiDef, sceneManager, rtvDef, - parentNode, m_colibriManager ); - } -} + +#include "ColibriGui/Ogre/CompositorPassColibriGuiProvider.h" +#include "ColibriGui/Ogre/CompositorPassColibriGuiDef.h" +#include "ColibriGui/Ogre/CompositorPassColibriGui.h" +#include "Compositor/OgreCompositorNode.h" + + +namespace Ogre +{ + CompositorPassColibriGuiProvider::CompositorPassColibriGuiProvider( + Colibri::ColibriManager *colibriManager1, Colibri::ColibriManager *colibriManager2, Ogre::Camera* cam1, Ogre::Camera* cam2 ) : + m_colibriManager1( colibriManager1 ), + m_colibriManager2( colibriManager2 ), + m_camera1(cam1), + m_camera2(cam2) + { + } + + CompositorPassColibriGuiProvider::CompositorPassColibriGuiProvider( + Colibri::ColibriManager *colibriManager1 ) : + m_colibriManager1( colibriManager1) + { + } + + //------------------------------------------------------------------------- + CompositorPassDef* CompositorPassColibriGuiProvider::addPassDef( + CompositorPassType passType, IdString customId, + CompositorTargetDef *parentTargetDef, CompositorNodeDef *parentNodeDef ) + { + if( customId == "colibri_gui" ) + return OGRE_NEW CompositorPassColibriGuiDef( parentTargetDef ); + + if( customId == "colibri_gui2" ) + return OGRE_NEW CompositorPassColibriGuiDef( parentTargetDef ); + return 0; + } + //------------------------------------------------------------------------- + CompositorPass* CompositorPassColibriGuiProvider::addPass( const CompositorPassDef *definition, + Camera *defaultCamera, + CompositorNode *parentNode, + const RenderTargetViewDef *rtvDef, + SceneManager *sceneManager ) + { + + + + COLIBRI_ASSERT( dynamic_cast( definition ) ); + const CompositorPassColibriGuiDef *colibriGuiDef = + static_cast( definition ); + /*return OGRE_NEW CompositorPassColibriGui( colibriGuiDef, sceneManager, rtvDef, parentNode, + m_colibriManager1 ); + */ + + + if( parentNode->getName() == "RenderingNode" ) + return OGRE_NEW CompositorPassColibriGui( colibriGuiDef, sceneManager, rtvDef, + parentNode, m_colibriManager1 ); + + if( parentNode->getName() == "RenderingNode2" ) + return OGRE_NEW CompositorPassColibriGui( colibriGuiDef, sceneManager, rtvDef, parentNode, + m_colibriManager2 ); + } + + + +} diff -r 5d6a36eba981 -r 8465d9534a77 src/ColibriGuiGameState.cpp --- a/src/ColibriGuiGameState.cpp Tue Feb 16 18:43:56 2021 -0300 +++ b/src/ColibriGuiGameState.cpp Tue Mar 02 20:15:18 2021 +0000 @@ -42,8 +42,12 @@ namespace Demo { - extern Colibri::ColibriManager *colibriManager; - Colibri::ColibriManager *colibriManager = 0; + extern Colibri::ColibriManager *colibriManager1; + Colibri::ColibriManager *colibriManager1 = 0; + + extern Colibri::ColibriManager *colibriManager2; + Colibri::ColibriManager *colibriManager2 = 0; + Colibri::Window *mainWindow = 0; Colibri::Window *vertWindow = 0; Colibri::Button *button0 = 0; @@ -57,14 +61,27 @@ Colibri::Slider *slider2 = 0; Colibri::Label *sliderLabel = 0; + Colibri::Window *mainWindow2 = 0; + Colibri::Window *vertWindow2 = 0; + Colibri::Button *button2 = 0; + Colibri::Button *button3 = 0; + Colibri::Spinner *spinner2 = 0; + Colibri::Checkbox *checkbox2 = 0; + Colibri::Editbox *editbox2 = 0; + Colibri::Progressbar *progressBar2 = 0; + Colibri::Progressbar *progressBar3 = 0; + Colibri::Slider *slider3 = 0; + Colibri::Slider *slider4 = 0; + Colibri::Label *sliderLabel2 = 0; + Colibri::Window *overlapWindow1 = 0; Colibri::Window *overlapWindow2 = 0; Colibri::Button *orderButtonBack = 0; Colibri::Button *orderButtonFront = 0; Colibri::Window *innerOverlapWindow1 = 0; Colibri::Window *innerOverlapWindow2 = 0; - Colibri::Button* innerOverlapButton1 = 0; - Colibri::Button* innerOverlapButton2 = 0; + Colibri::Button *innerOverlapButton1 = 0; + Colibri::Button *innerOverlapButton2 = 0; Colibri::Button *innerToggleOrder = 0; class DemoWidgetListener : public Colibri::WidgetActionListener @@ -103,25 +120,25 @@ Ogre::Window *window = mGraphicsSystem->getRenderWindow(); - colibriManager->setCanvasSize( Ogre::Vector2( 1920.0f, 1080.0f ), + colibriManager1->setCanvasSize( Ogre::Vector2( 1920.0f, 1080.0f ), Ogre::Vector2( window->getWidth(), window->getHeight() ) ); //colibriManager = new Colibri::ColibriManager(); - colibriManager->setOgre( mGraphicsSystem->getRoot(), + colibriManager1->setOgre( mGraphicsSystem->getRoot(), mGraphicsSystem->getRoot()->getRenderSystem()->getVaoManager(), mGraphicsSystem->getSceneManager() ); - colibriManager->loadSkins( (mGraphicsSystem->getResourcePath() + + colibriManager1->loadSkins( (mGraphicsSystem->getResourcePath() + "Materials/ColibriGui/Skins/DarkGloss/Skins.colibri.json").c_str() ); - mainWindow = colibriManager->createWindow( 0 ); + mainWindow = colibriManager1->createWindow( 0 ); //mainWindow->setVisualsEnabled( false ); - vertWindow = colibriManager->createWindow( 0 ); + vertWindow = colibriManager1->createWindow( 0 ); //Ogre::Hlms *hlms = mGraphicsSystem->getRoot()->getHlmsManager()->getHlms( Ogre::HLMS_UNLIT ); //mainWindow->setDatablock( hlms->getDefaultDatablock() ); mainWindow->setTransform( Ogre::Vector2( 0, 0 ), Ogre::Vector2( 450, 0 ) ); - vertWindow->setTransform( Ogre::Vector2( colibriManager->getCanvasSize().x - 64, 0 ), + vertWindow->setTransform( Ogre::Vector2( colibriManager1->getCanvasSize().x - 64, 0 ), Ogre::Vector2( 64, 450 ) ); //When m_breadthFirst is set to true, it can cause significant performance @@ -130,21 +147,21 @@ mainWindow->m_breadthFirst = true; vertWindow->m_breadthFirst = true; - Colibri::LayoutLine *layout = new Colibri::LayoutLine( colibriManager ); + Colibri::LayoutLine *layout = new Colibri::LayoutLine( colibriManager1 ); //layout->addCell( &Colibri::LayoutSpacer::c_DefaultBlankSpacer ); - button0 = colibriManager->createWidget( mainWindow ); + button0 = colibriManager1->createWidget( mainWindow ); button0->m_minSize = Ogre::Vector2( 350, 64 ); button0->getLabel()->setText( "This is a button" ); button0->sizeToFit(); layout->addCell( button0 ); - checkbox0 = colibriManager->createWidget( mainWindow ); + checkbox0 = colibriManager1->createWidget( mainWindow ); checkbox0->m_minSize = Ogre::Vector2( 350, 64 ); checkbox0->getButton()->getLabel()->setText( "This is a checkbox" ); layout->addCell( checkbox0 ); - checkbox0 = colibriManager->createWidget( mainWindow ); + checkbox0 = colibriManager1->createWidget( mainWindow ); checkbox0->m_minSize = Ogre::Vector2( 350, 64 ); checkbox0->setTriState( true ); checkbox0->getButton()->getLabel()->setText( "This is a tri-state checkbox" ); @@ -152,13 +169,13 @@ // checkbox0->setSize( checkbox0->getSize() + Ogre::Vector2( 0, 32 ) ); layout->addCell( checkbox0 ); - checkbox0 = colibriManager->createWidget( mainWindow ); + checkbox0 = colibriManager1->createWidget( mainWindow ); checkbox0->m_minSize = Ogre::Vector2( 350, 64 ); checkbox0->getButton()->getLabel()->setText( "This checkbox has the tickmark outside" ); checkbox0->setCheckboxMode( Colibri::Checkbox::TickButton ); layout->addCell( checkbox0 ); - spinner0 = colibriManager->createWidget( mainWindow ); + spinner0 = colibriManager1->createWidget( mainWindow ); spinner0->setTopLeft( Ogre::Vector2::ZERO ); spinner0->m_minSize = Ogre::Vector2( 350, 64 ); spinner0->getLabel()->setText( "Options" ); @@ -172,13 +189,13 @@ } layout->addCell( spinner0 ); - spinner0 = colibriManager->createWidget( mainWindow ); + spinner0 = colibriManager1->createWidget( mainWindow ); spinner0->setTopLeft( Ogre::Vector2::ZERO ); spinner0->m_minSize = Ogre::Vector2( 350, 64 ); spinner0->getLabel()->setText( "Numeric Spinner" ); layout->addCell( spinner0 ); - spinner0 = colibriManager->createWidget( mainWindow ); + spinner0 = colibriManager1->createWidget( mainWindow ); spinner0->setTopLeft( Ogre::Vector2::ZERO ); spinner0->m_minSize = Ogre::Vector2( 350, 64 ); spinner0->setFixedWidth( true, 0 ); @@ -186,29 +203,29 @@ spinner0->getLabel()->setText( "This spinner is on the other side" ); layout->addCell( spinner0 ); - editbox0 = colibriManager->createWidget( mainWindow ); + editbox0 = colibriManager1->createWidget( mainWindow ); editbox0->m_minSize = Ogre::Vector2( 350, 64 ); editbox0->setText( "You can edit this text" ); editbox0->m_expand[0] = true; layout->addCell( editbox0 ); - progressBar0 = colibriManager->createWidget( mainWindow ); + progressBar0 = colibriManager1->createWidget( mainWindow ); progressBar0->m_minSize = Ogre::Vector2( 350, 64 ); progressBar0->setProgress( 0.75f ); layout->addCell( progressBar0 ); - progressBar1 = colibriManager->createWidget( mainWindow ); + progressBar1 = colibriManager1->createWidget( mainWindow ); progressBar1->m_minSize = Ogre::Vector2( 350, 64 ); progressBar1->setProgress( 0.75f ); progressBar1->setVertical( true ); progressBar1->getProgressLayer()->setColour( true, Ogre::ColourValue( 0.0f, 0.7f, 0.2f ) ); layout->addCell( progressBar1 ); - slider1 = colibriManager->createWidget( mainWindow ); + slider1 = colibriManager1->createWidget( mainWindow ); slider1->m_minSize = Ogre::Vector2( 350, 32 ); layout->addCell( slider1 ); - sliderLabel = colibriManager->createWidget( mainWindow ); + sliderLabel = colibriManager1->createWidget( mainWindow ); sliderLabel->sizeToFit(); sliderLabel->m_minSize = Ogre::Vector2( 350, 32 ); layout->addCell( sliderLabel ); @@ -228,16 +245,16 @@ } // Do not put slider2 in the layout - slider2 = colibriManager->createWidget( vertWindow ); + slider2 = colibriManager1->createWidget( vertWindow ); slider2->m_minSize = Ogre::Vector2( 32, 320 ); slider2->setSize( slider2->m_minSize ); slider2->setVertical( true ); layout->setAdjustableWindow( mainWindow ); - layout->m_hardMaxSize = colibriManager->getCanvasSize(); + layout->m_hardMaxSize = colibriManager1->getCanvasSize(); - Colibri::LayoutLine *layoutW = new Colibri::LayoutLine( colibriManager ); - layoutW->setCellSize( colibriManager->getCanvasSize() ); + Colibri::LayoutLine *layoutW = new Colibri::LayoutLine( colibriManager1 ); + layoutW->setCellSize( colibriManager1->getCanvasSize() ); layoutW->addCell( &Colibri::LayoutSpacer::c_DefaultBlankSpacer ); layoutW->addCell( layout ); layoutW->layout(); @@ -246,24 +263,24 @@ //Overlapping windows demoActionListener = new DemoWidgetListener(); - Colibri::LayoutLine *layoutOverlapping = new Colibri::LayoutLine( colibriManager ); - overlapWindow1 = colibriManager->createWindow( 0 ); + Colibri::LayoutLine *layoutOverlapping = new Colibri::LayoutLine( colibriManager1 ); + overlapWindow1 = colibriManager1->createWindow( 0 ); overlapWindow1->setTransform(Ogre::Vector2(650, 250), Ogre::Vector2(300, 300)); overlapWindow1->setZOrder(3); - orderButtonBack = colibriManager->createWidget( overlapWindow1 ); + orderButtonBack = colibriManager1->createWidget( overlapWindow1 ); orderButtonBack->m_minSize = Ogre::Vector2( 350, 64 ); orderButtonBack->getLabel()->setText( "Send to back" ); orderButtonBack->sizeToFit(); orderButtonBack->addActionListener(demoActionListener); - orderButtonFront = colibriManager->createWidget( overlapWindow1 ); + orderButtonFront = colibriManager1->createWidget( overlapWindow1 ); orderButtonFront->m_minSize = Ogre::Vector2( 350, 64 ); orderButtonFront->getLabel()->setText( "Bring to front" ); orderButtonFront->sizeToFit(); orderButtonFront->addActionListener(demoActionListener); - overlapWindow2 = colibriManager->createWindow( 0 ); + overlapWindow2 = colibriManager1->createWindow( 0 ); overlapWindow2->setTransform(Ogre::Vector2(750, 450), Ogre::Vector2(300, 300)); overlapWindow2->setZOrder(4); @@ -272,23 +289,23 @@ layoutOverlapping->layout(); { - innerOverlapWindow1 = colibriManager->createWindow( overlapWindow2 ); + innerOverlapWindow1 = colibriManager1->createWindow( overlapWindow2 ); innerOverlapWindow1->setTransform( Ogre::Vector2(10, 10), Ogre::Vector2(100, 100) ); innerOverlapWindow1->setZOrder(1); - innerOverlapWindow2 = colibriManager->createWindow( overlapWindow2 ); + innerOverlapWindow2 = colibriManager1->createWindow( overlapWindow2 ); innerOverlapWindow2->setTransform( Ogre::Vector2(20, 20), Ogre::Vector2(100, 100) ); innerOverlapWindow2->setZOrder(4); - innerOverlapButton1 = colibriManager->createWidget( overlapWindow2 ); + innerOverlapButton1 = colibriManager1->createWidget( overlapWindow2 ); innerOverlapButton1->getLabel()->setText( "First" ); innerOverlapButton1->setTransform( Ogre::Vector2(150, 10), Ogre::Vector2(100, 100) ); innerOverlapButton1->setZOrder(1); - innerOverlapButton2 = colibriManager->createWidget( overlapWindow2 ); + innerOverlapButton2 = colibriManager1->createWidget( overlapWindow2 ); innerOverlapButton2->setTransform( Ogre::Vector2(160, 20), Ogre::Vector2(100, 100) ); innerOverlapButton2->setZOrder(2); innerOverlapButton2->getLabel()->setText( "Second" ); - innerToggleOrder = colibriManager->createWidget( overlapWindow2 ); + innerToggleOrder = colibriManager1->createWidget( overlapWindow2 ); innerToggleOrder->m_minSize = Ogre::Vector2( 350, 64 ); innerToggleOrder->getLabel()->setText( "Switch order" ); innerToggleOrder->setTopLeft( Ogre::Vector2(0, 120) ); @@ -400,17 +417,150 @@ TutorialGameState::createScene01(); } + + void ColibriGuiGameState::createScene02( void ) + { + // do everythign in another window + Ogre::Window *window = mGraphicsSystem->getRenderWindow2(); + + colibriManager2->setCanvasSize( Ogre::Vector2( 1920, 1080.0f ), + Ogre::Vector2( window->getWidth(), window->getHeight() ) ); + + // colibriManager = new Colibri::ColibriManager(); + colibriManager2->setOgre( mGraphicsSystem->getRoot(), + mGraphicsSystem->getRoot()->getRenderSystem()->getVaoManager(), + mGraphicsSystem->getSceneManager() ); + colibriManager2->loadSkins( ( mGraphicsSystem->getResourcePath() + + "Materials/ColibriGui/Skins/DarkGloss/Skins.colibri.json" ) + .c_str() ); + + mainWindow2 = colibriManager2->createWindow( 0 ); + // mainWindow->setVisualsEnabled( false ); + vertWindow2 = colibriManager2->createWindow( 0 ); + + // Ogre::Hlms *hlms = mGraphicsSystem->getRoot()->getHlmsManager()->getHlms( Ogre::HLMS_UNLIT ); + // mainWindow->setDatablock( hlms->getDefaultDatablock() ); + + mainWindow2->setTransform( Ogre::Vector2( 0, 0 ), Ogre::Vector2( 555, 1080.0f ) ); + vertWindow2->setTransform( Ogre::Vector2( colibriManager2->getCanvasSize().x - 64, 0 ), + Ogre::Vector2( 66, 450 ) ); + + // When m_breadthFirst is set to true, it can cause significant performance + // increases for UI-heavy applications. But be sure you understand it i.e. + // it may not render correctly if your widgets have children and they overlap. + mainWindow2->m_breadthFirst = false; + vertWindow2->m_breadthFirst = false; + + Colibri::LayoutLine *layout2 = new Colibri::LayoutLine( colibriManager2 ); + // layout->addCell( &Colibri::LayoutSpacer::c_DefaultBlankSpacer ); + + button2 = colibriManager2->createWidget( mainWindow2 ); + button2->m_minSize = Ogre::Vector2( 350, 64 ); + button2->getLabel()->setText( "This is a button 2" ); + button2->sizeToFit(); + layout2->addCell( button2 ); + + checkbox2 = colibriManager2->createWidget( mainWindow2 ); + checkbox2->m_minSize = Ogre::Vector2( 350, 64 ); + checkbox2->getButton()->getLabel()->setText( "This is a checkbox2" ); + layout2->addCell( checkbox2 ); + + checkbox2 = colibriManager2->createWidget( mainWindow2 ); + checkbox2->m_minSize = Ogre::Vector2( 350, 64 ); + checkbox2->setTriState( true ); + checkbox2->getButton()->getLabel()->setText( "This is a tri-state checkbox 2" ); + // checkbox0->sizeToFit(); + // checkbox0->setSize( checkbox0->getSize() + Ogre::Vector2( 0, 32 ) ); + layout2->addCell( checkbox0 ); + + checkbox2 = colibriManager2->createWidget( mainWindow2 ); + checkbox2->m_minSize = Ogre::Vector2( 350, 64 ); + checkbox2->getButton()->getLabel()->setText( "This checkbox has the tickmark outside 2" ); + checkbox2->setCheckboxMode( Colibri::Checkbox::TickButton ); + layout2->addCell( checkbox0 ); + + spinner2 = colibriManager2->createWidget( mainWindow2 ); + spinner2->setTopLeft( Ogre::Vector2::ZERO ); + spinner2->m_minSize = Ogre::Vector2( 350, 64 ); + spinner2->getLabel()->setText( "Options2" ); + { + std::vector options; + options.push_back( "Test" ); + options.push_back( "Low" ); + options.push_back( "Medium" ); + options.push_back( "High" ); + spinner2->setOptions( options ); + } + layout2->addCell( spinner2 ); + + spinner2 = colibriManager2->createWidget( mainWindow2 ); + spinner2->setTopLeft( Ogre::Vector2::ZERO ); + spinner2->m_minSize = Ogre::Vector2( 350, 64 ); + spinner2->getLabel()->setText( "Numeric Spinner2" ); + layout2->addCell( spinner2 ); + + spinner2 = colibriManager2->createWidget( mainWindow2 ); + spinner2->setTopLeft( Ogre::Vector2::ZERO ); + spinner2->m_minSize = Ogre::Vector2( 350, 64 ); + spinner2->setFixedWidth( true, 0 ); + spinner2->setHorizWidgetDir( Colibri::HorizWidgetDir::AutoRTL ); + spinner2->getLabel()->setText( "This spinner is on the other side" ); + layout2->addCell( spinner2 ); + + editbox2 = colibriManager2->createWidget( mainWindow2 ); + editbox2->m_minSize = Ogre::Vector2( 350, 64 ); + editbox2->setText( "You can edit this text" ); + editbox2->m_expand[0] = true; + layout2->addCell( editbox2 ); + + progressBar2 = colibriManager2->createWidget( mainWindow2 ); + progressBar2->m_minSize = Ogre::Vector2( 350, 64 ); + progressBar2->setProgress( 0.75f ); + layout2->addCell( progressBar2 ); + + progressBar3 = colibriManager2->createWidget( mainWindow2 ); + progressBar3->m_minSize = Ogre::Vector2( 350, 64 ); + progressBar3->setProgress( 0.75f ); + progressBar3->setVertical( true ); + progressBar3->getProgressLayer()->setColour( true, Ogre::ColourValue( 0.0f, 0.7f, 0.2f ) ); + layout2->addCell( progressBar3 ); + + slider3 = colibriManager2->createWidget( mainWindow2 ); + slider3->m_minSize = Ogre::Vector2( 350, 32 ); + layout2->addCell( slider3 ); + + sliderLabel2 = colibriManager2->createWidget( mainWindow2 ); + sliderLabel2->sizeToFit(); + sliderLabel2->m_minSize = Ogre::Vector2( 350, 32 ); + layout2->addCell( sliderLabel2 ); + + { + const Colibri::LayoutCellVec &cells = layout2->getCells(); + Colibri::LayoutCellVec::const_iterator itor = cells.begin(); + Colibri::LayoutCellVec::const_iterator end = cells.end(); + + while( itor != end ) + { + ( *itor )->m_margin = 5.0f; + ( *itor )->m_expand[0] = true; + + ++itor; + } + } + mainWindow2->sizeScrollToFit(); + } + //----------------------------------------------------------------------------------- void ColibriGuiGameState::destroyScene() { - colibriManager->destroyWidget( orderButtonBack ); - colibriManager->destroyWidget( orderButtonFront ); - colibriManager->destroyWindow( mainWindow ); - colibriManager->destroyWindow( vertWindow ); - colibriManager->destroyWindow( overlapWindow1 ); - colibriManager->destroyWindow( overlapWindow2 ); + colibriManager1->destroyWidget( orderButtonBack ); + colibriManager1->destroyWidget( orderButtonFront ); + colibriManager1->destroyWindow( mainWindow ); + colibriManager1->destroyWindow( vertWindow ); + colibriManager1->destroyWindow( overlapWindow1 ); + colibriManager1->destroyWindow( overlapWindow2 ); delete demoActionListener; - delete colibriManager; + delete colibriManager1; } //----------------------------------------------------------------------------------- void ColibriGuiGameState::update( float timeSinceLast ) @@ -425,13 +575,13 @@ tried = true; } - colibriManager->update( timeSinceLast ); - + colibriManager1->update( timeSinceLast ); + colibriManager2->update( timeSinceLast ); const bool isTextInputActive = SDL_IsTextInputActive(); - if( colibriManager->focusedWantsTextInput() && !isTextInputActive ) + if( colibriManager1->focusedWantsTextInput() && !isTextInputActive ) SDL_StartTextInput(); - else if( !colibriManager->focusedWantsTextInput() && isTextInputActive ) + else if( !colibriManager1->focusedWantsTextInput() && isTextInputActive ) SDL_StopTextInput(); if( isTextInputActive ) @@ -439,7 +589,7 @@ static SDL_Rect oldRect = { 0, 0, 0, 0 }; //We tried to update this only inside ColibriGuiGameState::keyPressed //but it didn't work well in Linux with fcitx - Ogre::Vector2 imeOffset = colibriManager->getImeLocation(); + Ogre::Vector2 imeOffset = colibriManager1->getImeLocation(); SDL_Rect rect; rect.x = imeOffset.x; rect.y = imeOffset.y; @@ -479,14 +629,14 @@ if( arg.type == SDL_MOUSEMOTION ) { Ogre::Vector2 mousePos( arg.motion.x / width, arg.motion.y / height ); - colibriManager->setMouseCursorMoved( mousePos * colibriManager->getCanvasSize() ); + colibriManager1->setMouseCursorMoved( mousePos * colibriManager1->getCanvasSize() ); } else if( arg.type == SDL_MOUSEWHEEL ) { Ogre::Vector2 mouseScroll( arg.wheel.x, -arg.wheel.y ); - colibriManager->setScroll( mouseScroll * 50.0f * - colibriManager->getCanvasSize() * - colibriManager->getPixelSize() ); + colibriManager1->setScroll( mouseScroll * 50.0f * + colibriManager1->getCanvasSize() * + colibriManager1->getPixelSize() ); } TutorialGameState::mouseMoved( arg ); @@ -498,51 +648,51 @@ float height = static_cast( mGraphicsSystem->getRenderWindow()->getHeight() ); Ogre::Vector2 mousePos( arg.x / width, arg.y / height ); - colibriManager->setMouseCursorMoved( mousePos * colibriManager->getCanvasSize() ); - colibriManager->setMouseCursorPressed( true, false ); + colibriManager1->setMouseCursorMoved( mousePos * colibriManager1->getCanvasSize() ); + colibriManager1->setMouseCursorPressed( true, false ); } //----------------------------------------------------------------------------------- void ColibriGuiGameState::mouseReleased( const SDL_MouseButtonEvent &arg, Ogre::uint8 id ) { - colibriManager->setMouseCursorReleased(); + colibriManager1->setMouseCursorReleased(); } //----------------------------------------------------------------------------------- void ColibriGuiGameState::textEditing( const SDL_TextEditingEvent &arg ) { - colibriManager->setTextEdit( arg.text, arg.start, arg.length ); + colibriManager1->setTextEdit( arg.text, arg.start, arg.length ); } //----------------------------------------------------------------------------------- void ColibriGuiGameState::textInput( const SDL_TextInputEvent &arg ) { - colibriManager->setTextInput( arg.text ); + colibriManager1->setTextInput( arg.text ); } //----------------------------------------------------------------------------------- void ColibriGuiGameState::keyPressed( const SDL_KeyboardEvent &arg ) { const bool isTextInputActive = SDL_IsTextInputActive(); - const bool isTextMultiline = colibriManager->isTextMultiline(); + const bool isTextMultiline = colibriManager1->isTextMultiline(); if( (arg.keysym.sym == SDLK_w && !isTextInputActive) || arg.keysym.sym == SDLK_UP ) - colibriManager->setKeyDirectionPressed( Colibri::Borders::Top ); + colibriManager1->setKeyDirectionPressed( Colibri::Borders::Top ); else if( (arg.keysym.sym == SDLK_s && !isTextInputActive) || arg.keysym.sym == SDLK_DOWN ) - colibriManager->setKeyDirectionPressed( Colibri::Borders::Bottom ); + colibriManager1->setKeyDirectionPressed( Colibri::Borders::Bottom ); else if( (arg.keysym.sym == SDLK_a && !isTextInputActive) || arg.keysym.sym == SDLK_LEFT ) - colibriManager->setKeyDirectionPressed( Colibri::Borders::Left ); + colibriManager1->setKeyDirectionPressed( Colibri::Borders::Left ); else if( (arg.keysym.sym == SDLK_d && !isTextInputActive) || arg.keysym.sym == SDLK_RIGHT ) - colibriManager->setKeyDirectionPressed( Colibri::Borders::Right ); + colibriManager1->setKeyDirectionPressed( Colibri::Borders::Right ); else if( ((arg.keysym.sym == SDLK_RETURN || arg.keysym.sym == SDLK_KP_ENTER) && !isTextMultiline) || (arg.keysym.sym == SDLK_SPACE && !isTextInputActive) ) { - colibriManager->setKeyboardPrimaryPressed(); + colibriManager1->setKeyboardPrimaryPressed(); } else if( isTextInputActive ) { if( (arg.keysym.sym == SDLK_RETURN || arg.keysym.sym == SDLK_KP_ENTER) && isTextMultiline ) - colibriManager->setTextSpecialKeyPressed( SDLK_RETURN, arg.keysym.mod ); + colibriManager1->setTextSpecialKeyPressed( SDLK_RETURN, arg.keysym.mod ); else { - colibriManager->setTextSpecialKeyPressed( arg.keysym.sym & ~SDLK_SCANCODE_MASK, + colibriManager1->setTextSpecialKeyPressed( arg.keysym.sym & ~SDLK_SCANCODE_MASK, arg.keysym.mod ); } } @@ -557,29 +707,29 @@ } const bool isTextInputActive = SDL_IsTextInputActive(); - const bool isTextMultiline = colibriManager->isTextMultiline(); + const bool isTextMultiline = colibriManager1->isTextMultiline(); if( (arg.keysym.sym == SDLK_w && !isTextInputActive) || arg.keysym.sym == SDLK_UP ) - colibriManager->setKeyDirectionReleased( Colibri::Borders::Top ); + colibriManager1->setKeyDirectionReleased( Colibri::Borders::Top ); else if( (arg.keysym.sym == SDLK_s && !isTextInputActive) || arg.keysym.sym == SDLK_DOWN ) - colibriManager->setKeyDirectionReleased( Colibri::Borders::Bottom ); + colibriManager1->setKeyDirectionReleased( Colibri::Borders::Bottom ); else if( (arg.keysym.sym == SDLK_a && !isTextInputActive) || arg.keysym.sym == SDLK_LEFT ) - colibriManager->setKeyDirectionReleased( Colibri::Borders::Left ); + colibriManager1->setKeyDirectionReleased( Colibri::Borders::Left ); else if( (arg.keysym.sym == SDLK_d && !isTextInputActive) || arg.keysym.sym == SDLK_RIGHT ) - colibriManager->setKeyDirectionReleased( Colibri::Borders::Right ); + colibriManager1->setKeyDirectionReleased( Colibri::Borders::Right ); else if( ((arg.keysym.sym == SDLK_RETURN || arg.keysym.sym == SDLK_KP_ENTER) && !isTextMultiline) || (arg.keysym.sym == SDLK_SPACE && !isTextInputActive) ) { - colibriManager->setKeyboardPrimaryReleased(); + colibriManager1->setKeyboardPrimaryReleased(); } else if( isTextInputActive ) { if( (arg.keysym.sym == SDLK_RETURN || arg.keysym.sym == SDLK_KP_ENTER) && isTextMultiline ) - colibriManager->setTextSpecialKeyReleased( SDLK_RETURN, arg.keysym.mod ); + colibriManager1->setTextSpecialKeyReleased( SDLK_RETURN, arg.keysym.mod ); else { - colibriManager->setTextSpecialKeyReleased( arg.keysym.sym & ~SDLK_SCANCODE_MASK, + colibriManager1->setTextSpecialKeyReleased( arg.keysym.sym & ~SDLK_SCANCODE_MASK, arg.keysym.mod ); } }