teamnwah
/
openmw-tes3coop
forked from mirror/openmw-tes3mp
2
0
Fork 1
Code Issues Pull Requests 1 Releases Wiki Activity

Added shader based MyGUI render manager to allow using Ogre's next generation render systems.

Browse Source
actorid
scrawl 11 years ago
parent ec7a8f1add
commit 4daaa4030d
6 changed files with 625 additions and 4 deletions
Show Stats Download Patch File Download Diff File

3
files/CMakeLists.txt
Unescape Escape View File

@ -44,6 +44,9 @@ set(MATERIAL_FILES
watersim_common.h
watersim.mat
watersim.shaderset
mygui.mat
mygui.shader
mygui.shaderset
)
copy_all_files(${CMAKE_CURRENT_SOURCE_DIR}/water "${OpenMW_BINARY_DIR}/resources/water/" "${WATER_FILES}")

25
files/materials/mygui.mat
Unescape Escape View File

@ -0,0 +1,25 @@
material MyGUI/NoTexture
{
pass
{
vertex_program mygui_vertex
fragment_program mygui_fragment
shader_properties
{
has_texture false
}
}
}
material MyGUI/OneTexture
{
pass
{
vertex_program mygui_vertex
fragment_program mygui_fragment
shader_properties
{
has_texture true
}
}
}

45
files/materials/mygui.shader
Unescape Escape View File

@ -0,0 +1,45 @@
#include "core.h"
#define TEXTURE @shPropertyBool(has_texture)
#ifdef SH_VERTEX_SHADER
SH_BEGIN_PROGRAM
#if TEXTURE
shVertexInput(float2, uv0)
shOutput(float2, UV)
#endif
shColourInput(float4)
shOutput(float4, colourPassthrough)
SH_START_PROGRAM
{
shOutputPosition = float4(shInputPosition.xyz, 1.f);
#if TEXTURE
UV.xy = uv0;
#endif
colourPassthrough = colour;
}
#else
SH_BEGIN_PROGRAM
#if TEXTURE
shSampler2D(diffuseMap)
shInput(float2, UV)
#endif
shInput(float4, colourPassthrough)
SH_START_PROGRAM
{
#if TEXTURE
shOutputColour(0) = shSample(diffuseMap, UV.xy) * colourPassthrough;
#else
shOutputColour(0) = colourPassthrough;
#endif
}
#endif

15
files/materials/mygui.shaderset
Unescape Escape View File

@ -0,0 +1,15 @@
shader_set mygui_vertex
{
source mygui.shader
type vertex
profiles_cg vs_2_0 vp40 arbvp1
profiles_hlsl vs_3_0 vs_2_0
}
shader_set mygui_fragment
{
source mygui.shader
type fragment
profiles_cg ps_3_0 ps_2_x ps_2_0 fp40 arbfp1
profiles_hlsl ps_3_0 ps_2_0
}

537
libs/openengine/gui/manager.cpp
Unescape Escape View File

@ -2,11 +2,18 @@
#include <MyGUI_Gui.h>
#include <MyGUI_OgrePlatform.h>
#include <MyGUI_Timer.h>
#include <cassert>
#include <extern/shiny/Main/Factory.hpp>
#include <extern/shiny/Platforms/Ogre/OgreMaterial.hpp>
using namespace OEngine::GUI;
namespace MyGUI
{
/*
* As of MyGUI 3.2.0, MyGUI::OgreDataManager::isDataExist is unnecessarily complex
* this override fixes the resulting performance issue.
@ -20,6 +27,532 @@ public:
}
};
/*
* As of MyGUI 3.2.0, rendering with shaders is not supported.
* We definitely need this though to run in GL3 core / DX11 at all.
* To make matters worse, subclassing OgreRenderManager doesn't seem to be possible here. :/
*/
class ShaderBasedRenderManager : public RenderManager,
public IRenderTarget,
public Ogre::WindowEventListener,
public Ogre::RenderQueueListener,
public Ogre::RenderSystem::Listener
{
// флаг для обновления всех и вся
bool mUpdate;
IntSize mViewSize;
Ogre::SceneManager* mSceneManager;
VertexColourType mVertexFormat;
// окно, на которое мы подписываемся для изменения размеров
Ogre::RenderWindow* mWindow;
// вьюпорт, с которым работает система
unsigned short mActiveViewport;
Ogre::RenderSystem* mRenderSystem;
Ogre::TextureUnitState::UVWAddressingMode mTextureAddressMode;
Ogre::LayerBlendModeEx mColorBlendMode, mAlphaBlendMode;
RenderTargetInfo mInfo;
typedef std::map<std::string, ITexture*> MapTexture;
MapTexture mTextures;
bool mIsInitialise;
bool mManualRender;
size_t mCountBatch;
// ADDED
Ogre::GpuProgram* mVertexProgramNoTexture;
Ogre::GpuProgram* mVertexProgramOneTexture;
Ogre::GpuProgram* mFragmentProgramNoTexture;
Ogre::GpuProgram* mFragmentProgramOneTexture;
public:
ShaderBasedRenderManager& getInstance()
{
return *getInstancePtr();
}
ShaderBasedRenderManager* getInstancePtr()
{
return static_cast<ShaderBasedRenderManager*>(RenderManager::getInstancePtr());
}
ShaderBasedRenderManager() :
mUpdate(false),
mSceneManager(nullptr),
mWindow(nullptr),
mActiveViewport(0),
mRenderSystem(nullptr),
mIsInitialise(false),
mManualRender(false),
mCountBatch(0)
{
}
void initialise(Ogre::RenderWindow* _window, Ogre::SceneManager* _scene)
{
MYGUI_PLATFORM_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mColorBlendMode.blendType = Ogre::LBT_COLOUR;
mColorBlendMode.source1 = Ogre::LBS_TEXTURE;
mColorBlendMode.source2 = Ogre::LBS_DIFFUSE;
mColorBlendMode.operation = Ogre::LBX_MODULATE;
mAlphaBlendMode.blendType = Ogre::LBT_ALPHA;
mAlphaBlendMode.source1 = Ogre::LBS_TEXTURE;
mAlphaBlendMode.source2 = Ogre::LBS_DIFFUSE;
mAlphaBlendMode.operation = Ogre::LBX_MODULATE;
mTextureAddressMode.u = Ogre::TextureUnitState::TAM_CLAMP;
mTextureAddressMode.v = Ogre::TextureUnitState::TAM_CLAMP;
mTextureAddressMode.w = Ogre::TextureUnitState::TAM_CLAMP;
mSceneManager = nullptr;
mWindow = nullptr;
mUpdate = false;
mRenderSystem = nullptr;
mActiveViewport = 0;
Ogre::Root* root = Ogre::Root::getSingletonPtr();
if (root != nullptr)
setRenderSystem(root->getRenderSystem());
setRenderWindow(_window);
setSceneManager(_scene);
// ADDED
sh::MaterialInstance* mat = sh::Factory::getInstance().getMaterialInstance("MyGUI/NoTexture");
sh::Factory::getInstance()._ensureMaterial("MyGUI/NoTexture", "Default");
mVertexProgramNoTexture = static_cast<sh::OgreMaterial*>(mat->getMaterial())->getOgreTechniqueForConfiguration("Default")->getPass(0)
->getVertexProgram()->_getBindingDelegate();
mat = sh::Factory::getInstance().getMaterialInstance("MyGUI/OneTexture");
sh::Factory::getInstance()._ensureMaterial("MyGUI/OneTexture", "Default");
mVertexProgramOneTexture = static_cast<sh::OgreMaterial*>(mat->getMaterial())->getOgreTechniqueForConfiguration("Default")->getPass(0)
->getVertexProgram()->_getBindingDelegate();
mat = sh::Factory::getInstance().getMaterialInstance("MyGUI/NoTexture");
sh::Factory::getInstance()._ensureMaterial("MyGUI/NoTexture", "Default");
mFragmentProgramNoTexture = static_cast<sh::OgreMaterial*>(mat->getMaterial())->getOgreTechniqueForConfiguration("Default")->getPass(0)
->getFragmentProgram()->_getBindingDelegate();
mat = sh::Factory::getInstance().getMaterialInstance("MyGUI/OneTexture");
sh::Factory::getInstance()._ensureMaterial("MyGUI/OneTexture", "Default");
mFragmentProgramOneTexture = static_cast<sh::OgreMaterial*>(mat->getMaterial())->getOgreTechniqueForConfiguration("Default")->getPass(0)
->getFragmentProgram()->_getBindingDelegate();
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
void shutdown()
{
MYGUI_PLATFORM_ASSERT(mIsInitialise, getClassTypeName() << " is not initialised");
MYGUI_PLATFORM_LOG(Info, "* Shutdown: " << getClassTypeName());
destroyAllResources();
setSceneManager(nullptr);
setRenderWindow(nullptr);
setRenderSystem(nullptr);
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully shutdown");
mIsInitialise = false;
}
void setRenderSystem(Ogre::RenderSystem* _render)
{
// отписываемся
if (mRenderSystem != nullptr)
{
mRenderSystem->removeListener(this);
mRenderSystem = nullptr;
}
mRenderSystem = _render;
// подписываемся на рендер евент
if (mRenderSystem != nullptr)
{
mRenderSystem->addListener(this);
// формат цвета в вершинах
Ogre::VertexElementType vertex_type = mRenderSystem->getColourVertexElementType();
if (vertex_type == Ogre::VET_COLOUR_ARGB)
mVertexFormat = VertexColourType::ColourARGB;
else if (vertex_type == Ogre::VET_COLOUR_ABGR)
mVertexFormat = VertexColourType::ColourABGR;
updateRenderInfo();
}
}
Ogre::RenderSystem* getRenderSystem()
{
return mRenderSystem;
}
void setRenderWindow(Ogre::RenderWindow* _window)
{
// отписываемся
if (mWindow != nullptr)
{
Ogre::WindowEventUtilities::removeWindowEventListener(mWindow, this);
mWindow = nullptr;
}
mWindow = _window;
if (mWindow != nullptr)
{
Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
windowResized(mWindow);
}
}
void setSceneManager(Ogre::SceneManager* _scene)
{
if (nullptr != mSceneManager)
{
mSceneManager->removeRenderQueueListener(this);
mSceneManager = nullptr;
}
mSceneManager = _scene;
if (nullptr != mSceneManager)
{
mSceneManager->addRenderQueueListener(this);
}
}
void setActiveViewport(unsigned short _num)
{
mActiveViewport = _num;
if (mWindow != nullptr)
{
Ogre::WindowEventUtilities::removeWindowEventListener(mWindow, this);
Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
// рассылка обновлений
windowResized(mWindow);
}
}
void renderQueueStarted(Ogre::uint8 queueGroupId, const Ogre::String& invocation, bool& skipThisInvocation)
{
Gui* gui = Gui::getInstancePtr();
if (gui == nullptr)
return;
if (Ogre::RENDER_QUEUE_OVERLAY != queueGroupId)
return;
Ogre::Viewport* viewport = mSceneManager->getCurrentViewport();
if (nullptr == viewport
|| !viewport->getOverlaysEnabled())
return;
if (mWindow->getNumViewports() <= mActiveViewport
|| viewport != mWindow->getViewport(mActiveViewport))
return;
mCountBatch = 0;
static Timer timer;
static unsigned long last_time = timer.getMilliseconds();
unsigned long now_time = timer.getMilliseconds();
unsigned long time = now_time - last_time;
onFrameEvent((float)((double)(time) / (double)1000));
last_time = now_time;
//begin();
setManualRender(true);
onRenderToTarget(this, mUpdate);
//end();
// сбрасываем флаг
mUpdate = false;
}
void renderQueueEnded(Ogre::uint8 queueGroupId, const Ogre::String& invocation, bool& repeatThisInvocation)
{
}
void eventOccurred(const Ogre::String& eventName, const Ogre::NameValuePairList* parameters)
{
if (eventName == "DeviceLost")
{
}
else if (eventName == "DeviceRestored")
{
// обновить всех
mUpdate = true;
}
}
IVertexBuffer* createVertexBuffer()
{
return new OgreVertexBuffer();
}
void destroyVertexBuffer(IVertexBuffer* _buffer)
{
delete _buffer;
}
// для оповещений об изменении окна рендера
void windowResized(Ogre::RenderWindow* _window)
{
if (_window->getNumViewports() > mActiveViewport)
{
Ogre::Viewport* port = _window->getViewport(mActiveViewport);
#if OGRE_VERSION >= MYGUI_DEFINE_VERSION(1, 7, 0) && OGRE_NO_VIEWPORT_ORIENTATIONMODE == 0
Ogre::OrientationMode orient = port->getOrientationMode();
if (orient == Ogre::OR_DEGREE_90 || orient == Ogre::OR_DEGREE_270)
mViewSize.set(port->getActualHeight(), port->getActualWidth());
else
mViewSize.set(port->getActualWidth(), port->getActualHeight());
#else
mViewSize.set(port->getActualWidth(), port->getActualHeight());
#endif
// обновить всех
mUpdate = true;
updateRenderInfo();
onResizeView(mViewSize);
}
}
void updateRenderInfo()
{
if (mRenderSystem != nullptr)
{
mInfo.maximumDepth = mRenderSystem->getMaximumDepthInputValue();
mInfo.hOffset = mRenderSystem->getHorizontalTexelOffset() / float(mViewSize.width);
mInfo.vOffset = mRenderSystem->getVerticalTexelOffset() / float(mViewSize.height);
mInfo.aspectCoef = float(mViewSize.height) / float(mViewSize.width);
mInfo.pixScaleX = 1.0f / float(mViewSize.width);
mInfo.pixScaleY = 1.0f / float(mViewSize.height);
}
}
void doRender(IVertexBuffer* _buffer, ITexture* _texture, size_t _count)
{
if (getManualRender())
{
begin();
setManualRender(false);
}
// ADDED
if (_texture)
{
Ogre::Root::getSingleton().getRenderSystem()->bindGpuProgram(mVertexProgramOneTexture);
Ogre::Root::getSingleton().getRenderSystem()->bindGpuProgram(mFragmentProgramOneTexture);
}
else
{
Ogre::Root::getSingleton().getRenderSystem()->bindGpuProgram(mVertexProgramNoTexture);
Ogre::Root::getSingleton().getRenderSystem()->bindGpuProgram(mFragmentProgramNoTexture);
}
if (_texture)
{
OgreTexture* texture = static_cast<OgreTexture*>(_texture);
Ogre::TexturePtr texture_ptr = texture->getOgreTexture();
if (!texture_ptr.isNull())
{
mRenderSystem->_setTexture(0, true, texture_ptr);
mRenderSystem->_setTextureUnitFiltering(0, Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
}
}
OgreVertexBuffer* buffer = static_cast<OgreVertexBuffer*>(_buffer);
Ogre::RenderOperation* operation = buffer->getRenderOperation();
operation->vertexData->vertexCount = _count;
mRenderSystem->_render(*operation);
++ mCountBatch;
}
void begin()
{
// set-up matrices
mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY);
mRenderSystem->_setViewMatrix(Ogre::Matrix4::IDENTITY);
#if OGRE_VERSION >= MYGUI_DEFINE_VERSION(1, 7, 0) && OGRE_NO_VIEWPORT_ORIENTATIONMODE == 0
Ogre::OrientationMode orient = mWindow->getViewport(mActiveViewport)->getOrientationMode();
mRenderSystem->_setProjectionMatrix(Ogre::Matrix4::IDENTITY * Ogre::Quaternion(Ogre::Degree(orient * 90.f), Ogre::Vector3::UNIT_Z));
#else
mRenderSystem->_setProjectionMatrix(Ogre::Matrix4::IDENTITY);
#endif
// initialise render settings
mRenderSystem->setLightingEnabled(false);
mRenderSystem->_setDepthBufferParams(false, false);
mRenderSystem->_setDepthBias(0, 0);
mRenderSystem->_setCullingMode(Ogre::CULL_NONE);
mRenderSystem->_setFog(Ogre::FOG_NONE);
mRenderSystem->_setColourBufferWriteEnabled(true, true, true, true);
mRenderSystem->unbindGpuProgram(Ogre::GPT_FRAGMENT_PROGRAM);
mRenderSystem->unbindGpuProgram(Ogre::GPT_VERTEX_PROGRAM);
mRenderSystem->setShadingType(Ogre::SO_GOURAUD);
// initialise texture settings
mRenderSystem->_setTextureCoordCalculation(0, Ogre::TEXCALC_NONE);
mRenderSystem->_setTextureCoordSet(0, 0);
mRenderSystem->_setTextureUnitFiltering(0, Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
mRenderSystem->_setTextureAddressingMode(0, mTextureAddressMode);
mRenderSystem->_setTextureMatrix(0, Ogre::Matrix4::IDENTITY);
#if OGRE_VERSION < MYGUI_DEFINE_VERSION(1, 6, 0)
mRenderSystem->_setAlphaRejectSettings(Ogre::CMPF_ALWAYS_PASS, 0);
#else
mRenderSystem->_setAlphaRejectSettings(Ogre::CMPF_ALWAYS_PASS, 0, false);
#endif
mRenderSystem->_setTextureBlendMode(0, mColorBlendMode);
mRenderSystem->_setTextureBlendMode(0, mAlphaBlendMode);
mRenderSystem->_disableTextureUnitsFrom(1);
// enable alpha blending
mRenderSystem->_setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
// always use wireframe
// TODO: add option to enable wireframe mode in platform
mRenderSystem->_setPolygonMode(Ogre::PM_SOLID);
}
void end()
{
}
ITexture* createTexture(const std::string& _name)
{
MapTexture::const_iterator item = mTextures.find(_name);
MYGUI_PLATFORM_ASSERT(item == mTextures.end(), "Texture '" << _name << "' already exist");
OgreTexture* texture = new OgreTexture(_name, OgreDataManager::getInstance().getGroup());
mTextures[_name] = texture;
return texture;
}
void destroyTexture(ITexture* _texture)
{
if (_texture == nullptr) return;
MapTexture::iterator item = mTextures.find(_texture->getName());
MYGUI_PLATFORM_ASSERT(item != mTextures.end(), "Texture '" << _texture->getName() << "' not found");
mTextures.erase(item);
delete _texture;
}
ITexture* getTexture(const std::string& _name)
{
MapTexture::const_iterator item = mTextures.find(_name);
if (item == mTextures.end())
{
Ogre::TexturePtr texture = (Ogre::TexturePtr)Ogre::TextureManager::getSingleton().getByName(_name);
if (!texture.isNull())
{
ITexture* result = createTexture(_name);
static_cast<OgreTexture*>(result)->setOgreTexture(texture);
return result;
}
return nullptr;
}
return item->second;
}
bool isFormatSupported(PixelFormat _format, TextureUsage _usage)
{
return Ogre::TextureManager::getSingleton().isFormatSupported(
Ogre::TEX_TYPE_2D,
OgreTexture::convertFormat(_format),
OgreTexture::convertUsage(_usage));
}
void destroyAllResources()
{
for (MapTexture::const_iterator item = mTextures.begin(); item != mTextures.end(); ++item)
{
delete item->second;
}
mTextures.clear();
}
#if MYGUI_DEBUG_MODE == 1
bool checkTexture(ITexture* _texture)
{
for (MapTexture::const_iterator item = mTextures.begin(); item != mTextures.end(); ++item)
{
if (item->second == _texture)
return true;
}
return false;
}
#endif
const IntSize& getViewSize() const
{
return mViewSize;
}
VertexColourType getVertexFormat()
{
return mVertexFormat;
}
const RenderTargetInfo& getInfo()
{
return mInfo;
}
size_t getActiveViewport()
{
return mActiveViewport;
}
Ogre::RenderWindow* getRenderWindow()
{
return mWindow;
}
bool getManualRender()
{
return mManualRender;
}
void setManualRender(bool _value)
{
mManualRender = _value;
}
size_t getBatchCount() const
{
return mCountBatch;
}
};
}
void MyGUIManager::setup(Ogre::RenderWindow *wnd, Ogre::SceneManager *mgr, bool logging, const std::string& logDir)
{
assert(wnd);
@ -41,8 +574,8 @@ void MyGUIManager::setup(Ogre::RenderWindow *wnd, Ogre::SceneManager *mgr, bool
// Set up OGRE platform (bypassing OgrePlatform). We might make this more generic later.
mLogManager = new LogManager();
mRenderManager = new OgreRenderManager();
mDataManager = new FixedOgreDataManager();
mRenderManager = new MyGUI::ShaderBasedRenderManager();
mDataManager = new MyGUI::FixedOgreDataManager();
LogManager::getInstance().setSTDOutputEnabled(logging);

4
libs/openengine/gui/manager.hpp
Unescape Escape View File

@ -8,7 +8,7 @@ namespace MyGUI
class Gui;
class LogManager;
class OgreDataManager;
class OgreRenderManager;
class ShaderBasedRenderManager;
}
namespace Ogre
@ -25,7 +25,7 @@ namespace GUI
MyGUI::Gui *mGui;
MyGUI::LogManager* mLogManager;
MyGUI::OgreDataManager* mDataManager;
MyGUI::OgreRenderManager* mRenderManager;
MyGUI::ShaderBasedRenderManager* mRenderManager;
Ogre::SceneManager* mSceneMgr;

Write Preview
Loading…
Cancel
Save