/**
* @brief init the object
* @author kito berg-taylor
*/
void OgreWidget::init()
{
// create the main ogre object
mOgreRoot = new Ogre::Root;
mOgreRoot->loadPlugin("RenderSystem_GL");
Ogre::String rName("OpenGL Rendering Subsystem");
Ogre::RenderSystemList rList = mOgreRoot->getAvailableRenderers();
Ogre::RenderSystemList::iterator it = rList.begin();
Ogre::RenderSystem *rSys = 0;
while(it != rList.end())
{
rSys = * (it++);
Ogre::String strx=rSys->getName();
if(strx == rName)
{
mOgreRoot->setRenderSystem(rSys);
break;
}
}
QString dimensions = QString( "%1x%2" )
.arg(this->width())
.arg(this->height());
rSys->setConfigOption( "Video Mode", dimensions.toStdString() );
// initialize without creating window
mOgreRoot->getRenderSystem()->setConfigOption( "Full Screen", "No" );
mOgreRoot->saveConfig();
mOgreRoot->initialise(false); // don't create a window
}
OgreRTTexture::OgreRTTexture(Ogre::TexturePtr _texture) :
mViewport(nullptr),
mSaveViewport(nullptr),
mTexture(_texture)
{
mProjectMatrix = Ogre::Matrix4::IDENTITY;
Ogre::Root* root = Ogre::Root::getSingletonPtr();
if (root != nullptr)
{
Ogre::RenderSystem* system = root->getRenderSystem();
if (system != nullptr)
{
size_t width = mTexture->getWidth();
size_t height = mTexture->getHeight();
mRenderTargetInfo.maximumDepth = system->getMaximumDepthInputValue();
mRenderTargetInfo.hOffset = system->getHorizontalTexelOffset() / float(width);
mRenderTargetInfo.vOffset = system->getVerticalTexelOffset() / float(height);
mRenderTargetInfo.aspectCoef = float(height) / float(width);
mRenderTargetInfo.pixScaleX = 1.0f / float(width);
mRenderTargetInfo.pixScaleY = 1.0f / float(height);
}
if (mTexture->getBuffer()->getRenderTarget()->requiresTextureFlipping())
{
mProjectMatrix[1][0] = -mProjectMatrix[1][0];
mProjectMatrix[1][1] = -mProjectMatrix[1][1];
mProjectMatrix[1][2] = -mProjectMatrix[1][2];
mProjectMatrix[1][3] = -mProjectMatrix[1][3];
}
}
}
void wxOgre::createOgreRenderWindow()
{
// Grab the current render system from Ogre
Ogre::RenderSystem* renderSystem =
Ogre::Root::getSingleton().getRenderSystem();
// Create a new parameters list according to compiled OS
Ogre::NameValuePairList params;
getWindowParams(¶ms);
// Get wx control window size
int width;
int height;
GetClientSize(&width, &height);
std::string name(GetName().mb_str(wxConvUTF8));
// Create the render window (give the name of wxWidget window to Ogre)
mRenderWindow =
renderSystem->createRenderWindow(name, width, height, false, ¶ms);
// Set the viewport up with camera
// NOTE: You can only create a camera after you have made the first camera
// we are going to need to be passed a camera for the second one
if (mCamera)
{
mViewport = mRenderWindow->addViewport(mCamera);
mViewport->setBackgroundColour(Ogre::ColourValue(1.0f, 0.0f, 0.0f,
1.0f));
}
}
void OgreWidget::init(std::string const& plugins_file, std::string const& ogre_cfg_file, std::string const& ogre_log)
{
// create the main ogre object
_mOgreRoot = new Ogre::Root(plugins_file, ogre_cfg_file, ogre_log);
// setup a renderer
Ogre::RenderSystemList::const_iterator renderers = _mOgreRoot->getAvailableRenderers().begin();
while(renderers != _mOgreRoot->getAvailableRenderers().end())
{
Ogre::String rName = (*renderers)->getName();
if (rName == "OpenGL Rendering Subsystem")
break;
renderers++;
}
Ogre::RenderSystem *renderSystem = *renderers;
_mOgreRoot->setRenderSystem(renderSystem);
QString dimensions = QString("%1x%2")
.arg(this->width())
.arg(this->height());
renderSystem->setConfigOption("Video Mode", dimensions.toStdString());
// initialize without creating window
_mOgreRoot->getRenderSystem()->setConfigOption("Full Screen", "No");
_mOgreRoot->saveConfig();
_mOgreRoot->initialise(false); // don't create a window
}
void ApplicationContext::reconfigure(const Ogre::String &renderer, Ogre::NameValuePairList &options)
{
mNextRenderer = renderer;
Ogre::RenderSystem* rs = mRoot->getRenderSystemByName(renderer);
// set all given render system options
for (Ogre::NameValuePairList::iterator it = options.begin(); it != options.end(); it++)
{
rs->setConfigOption(it->first, it->second);
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
// Change the viewport orientation on the fly if requested
if(it->first == "Orientation")
{
if (it->second == "Landscape Left")
mWindow->getViewport(0)->setOrientationMode(Ogre::OR_LANDSCAPELEFT, true);
else if (it->second == "Landscape Right")
mWindow->getViewport(0)->setOrientationMode(Ogre::OR_LANDSCAPERIGHT, true);
else if (it->second == "Portrait")
mWindow->getViewport(0)->setOrientationMode(Ogre::OR_PORTRAIT, true);
}
#endif
}
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
// Need to save the config on iOS to make sure that changes are kept on disk
mRoot->saveConfig();
#endif
mRoot->queueEndRendering(); // break from render loop
}
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();
}
}
void CDynamicLineDrawer::FillHardwareBuffers()
{
int Size = int(Points.size());
PrepareHardwareBuffers(Size);
if (!Size) {
mBox.setExtents( Ogre::Vector3::ZERO, Ogre::Vector3::ZERO );
Dirty = false;
return;
}
Ogre::Vector3 AABMin = Points[0];
Ogre::Vector3 AABMax = Points[0];
Ogre::HardwareVertexBufferSharedPtr VBuf =
mRenderOp.vertexData->vertexBufferBinding->getBuffer(0);
Ogre::HardwareVertexBufferSharedPtr CBuf =
mRenderOp.vertexData->vertexBufferBinding->getBuffer(1);
// get rendersystem to pack colours
Ogre::RenderSystem* RS = Ogre::Root::getSingleton().getRenderSystem();
Ogre::Real* VPrPos = static_cast<Ogre::Real*>(VBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
Ogre::RGBA* CPrPos = static_cast<Ogre::RGBA*>(CBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
for(int i = 0; i < Size; i++)
{
*VPrPos++ = Points[i].x;
*VPrPos++ = Points[i].y;
*VPrPos++ = Points[i].z;
Ogre::RGBA color;
RS->convertColourValue(Colours[i], &color);
*CPrPos++ = color;
//*CPrPos++ = unsigned int(Colours[i].g);
//*CPrPos++ = unsigned int(Colours[i].b);
if(Points[i].x < AABMin.x)
AABMin.x = Points[i].x;
if(Points[i].y < AABMin.y)
AABMin.y = Points[i].y;
if(Points[i].z < AABMin.z)
AABMin.z = Points[i].z;
if(Points[i].x > AABMax.x)
AABMax.x = Points[i].x;
if(Points[i].y > AABMax.y)
AABMax.y = Points[i].y;
if(Points[i].z > AABMax.z)
AABMax.z = Points[i].z;
}
VBuf->unlock();
CBuf->unlock();
mBox.setExtents(AABMin, AABMax);
Dirty = false;
}
void OgreMinimalSetup::debugRenderList(const Ogre::RenderSystemList& rsl)
{
assert(rsl.size() && "RenderSystemList size is 0");
cout << "RenderSystemList size is " << rsl.size() << endl;
Ogre::RenderSystem* rs = rsl[0];
assert(rs && "First RenderSystem is NULL");
cout << "First RenderSystem name is '" << rs->getName() << "'" << endl;
}
virtual void registerHlms(void)
{
GraphicsSystem::registerHlms();
Ogre::ConfigFile cf;
cf.load(mResourcePath + "resources2.cfg");
Ogre::String dataFolder = cf.getSetting("DoNotUseAsResource", "Hlms", "");
if (dataFolder.empty())
dataFolder = "./";
else if (*(dataFolder.end() - 1) != '/')
dataFolder += "/";
Ogre::RenderSystem *renderSystem = mpRoot->getRenderSystem();
Ogre::String shaderSyntax = "GLSL";
if (renderSystem->getName() == "Direct3D11 Rendering Subsystem")
shaderSyntax = "HLSL";
Ogre::Archive *archiveLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/" + shaderSyntax,
"FileSystem", true);
Ogre::Archive *archiveLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/Any",
"FileSystem", true);
Ogre::Archive *archivePbsLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/Any",
"FileSystem", true);
Ogre::Archive *pbsLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/" + shaderSyntax,
"FileSystem", true);
Ogre::ArchiveVec library;
library.push_back(archiveLibrary);
library.push_back(archiveLibraryAny);
library.push_back(archivePbsLibraryAny);
library.push_back(pbsLibrary);
Ogre::Archive *archiveTerra = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Terra/" + shaderSyntax,
"FileSystem", true);
Ogre::HlmsTerra *hlmsTerra = OGRE_NEW Ogre::HlmsTerra(archiveTerra, &library);
Ogre::HlmsManager *hlmsManager = mpRoot->getHlmsManager();
hlmsManager->registerHlms(hlmsTerra);
//Add Terra's piece files that customize the PBS implementation.
//These pieces are coded so that they will be activated when
//we set the HlmsPbsTerraShadows listener and there's an active Terra
//(see Tutorial_TerrainGameState::createScene01)
Ogre::Hlms *hlmsPbs = hlmsManager->getHlms(Ogre::HLMS_PBS);
Ogre::Archive *archivePbs = hlmsPbs->getDataFolder();
Ogre::ArchiveVec libraryPbs = hlmsPbs->getPiecesLibraryAsArchiveVec();
libraryPbs.push_back(Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Terra/" + shaderSyntax + "/PbsTerraShadows",
"FileSystem", true));
hlmsPbs->reloadFrom(archivePbs, &libraryPbs);
}
void rtt::clear(unsigned buffers, const colour &c, float d, unsigned s)
{
assert(_viewport);
Ogre::RenderSystem *rs = Ogre::Root::getSingleton().getRenderSystem();
rs->_setViewport(_viewport);
rs->clearFrameBuffer(buffers, c, d, s);
}
void RenderedCompassImpl::_setCompass(Compass* compass)
{
Ogre::MaterialPtr originalMaterial = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName(mMaterialName));
if (originalMaterial) {
originalMaterial->load();
mCompassMaterial = originalMaterial->clone(OgreInfo::createUniqueResourceName(originalMaterial->getName()));
if (Ogre::Technique* tech = mCompassMaterial->getBestTechnique()) {
Ogre::Pass* pass = nullptr;
if (tech->getNumPasses() && (pass = tech->getPass(0))) {
mCompassMaterialMapTUS = pass->getTextureUnitState("Background");
if (mCompassMaterialMapTUS) {
//Make sure that the compass material is using the map texture for the base rendering
mCompassMaterialMapTUS->setTexture(mMap->getTexture());
mTexture = Ogre::TextureManager::getSingleton().createManual("RenderedCompass", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 128, 128, 1, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET);
mRenderTexture = mTexture->getBuffer()->getRenderTarget();
mRenderTexture->removeAllViewports();
mRenderTexture->setAutoUpdated(false);
mRenderTexture->setActive(true);
mCamera = mSceneManager->createCamera("RenderedCompassCamera");
mViewport = mRenderTexture->addViewport(mCamera);
mViewport->setOverlaysEnabled(false);
mViewport->setShadowsEnabled(false);
mViewport->setSkiesEnabled(false);
mViewport->setClearEveryFrame(true);
mViewport->setBackgroundColour(Ogre::ColourValue::ZERO);
mMapRectangle = OGRE_NEW Ogre::Rectangle2D(true);
auto mapMaterialPtr = Ogre::MaterialManager::getSingleton().getByName(mCompassMaterial->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (mapMaterialPtr) {
mMapRectangle->setMaterial(mapMaterialPtr);
}
//We need to maximise the rendered texture to cover the whole screen
Ogre::RenderSystem* rs = Ogre::Root::getSingleton().getRenderSystem();
Ogre::Real hOffset = rs->getHorizontalTexelOffset() / (0.5 * mViewport->getActualWidth());
Ogre::Real vOffset = rs->getVerticalTexelOffset() / (0.5 * mViewport->getActualHeight());
mMapRectangle->setCorners(-1 + hOffset, 1 - vOffset, 1 + hOffset, -1 - vOffset);
//Since a Rectangle2D instance is a moveable object it won't be rendered unless it's in the frustrum. If we set the axis aligned box to be "infinite" it will always be rendered.
Ogre::AxisAlignedBox aabInf;
aabInf.setInfinite();
mMapRectangle->setBoundingBox(aabInf);
//We can't attach something to the root node, so we'll attach it to a newly created node. We won't keep a reference to this node since it will be destroyed along with the scene manager when we ourselves are destroyed.
mSceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(mMapRectangle);
//Return early since everything is good.
return;
}
}
}
}
S_LOG_WARNING("Could not load material '" << mMaterialName << "' for the compass.");
}
void FrameGraphRenderable::fillHardwareBuffers()
{
Ogre::HardwareVertexBufferSharedPtr vbuf = mRenderOp.vertexData->vertexBufferBinding->getBuffer(0);
Ogre::Real *vertices = static_cast<Ogre::Real*>(vbuf->lock(Ogre::HardwareBuffer::HBL_NORMAL));
Ogre::HardwareVertexBufferSharedPtr vcbuf = mRenderOp.vertexData->vertexBufferBinding->getBuffer(1);
Ogre::RGBA* pColours = static_cast<Ogre::RGBA*>(vcbuf->lock(Ogre::HardwareBuffer::HBL_NORMAL));
Ogre::RenderSystem* rs = Ogre::Root::getSingleton().getRenderSystem();
uint16_t index = 0;
for (uint16_t i = 0; i < mNumFrames; i++) {
float x = i * mLineSpace - 1.0f;
// OgreTime line
vertices[index + 0] = x;
vertices[index + 1] = -1;
vertices[index + 2] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(1.0f, 0.0f, 0.0f), pColours++); // Color
vertices[index + 3] = x;
vertices[index + 4] = -1;
vertices[index + 5] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(1.0f, 0.0f, 0.0f), pColours++); // Color
// BulletTime line
vertices[index + 6] = x;
vertices[index + 7] = -1;
vertices[index + 8] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(0.0f, 1.0f, 0.0f), pColours++); // Color
vertices[index + 9] = x;
vertices[index + 10] = -1;
vertices[index + 11] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(0.0f, 1.0f, 0.0f), pColours++); // Color
// WorldTime line
vertices[index + 12] = x;
vertices[index + 13] = -1;
vertices[index + 14] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(0.0f, 0.0f, 1.0f), pColours++); // Color
vertices[index + 15] = x;
vertices[index + 16] = -1;
vertices[index + 17] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(0.0f, 0.0f, 1.0f), pColours++); // Color
// UnknownTime line
vertices[index + 18] = x;
vertices[index + 19] = -1;
vertices[index + 20] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(1.0f, 1.0f, 1.0f), pColours++); // Color
vertices[index + 21] = x;
vertices[index + 22] = -1;
vertices[index + 23] = 0; // Vertex
rs->convertColourValue(Ogre::ColourValue(1.0f, 1.0f, 1.0f), pColours++); // Color
index += ValuesPerGraphLine;
}
vcbuf->unlock();
vbuf->unlock();
mBox.setInfinite();
}
void OgreRTTexture::end()
{
Ogre::RenderSystem* system = Ogre::Root::getSingleton().getRenderSystem();
system->_setViewport(mSaveViewport);
#if OGRE_VERSION >= MYGUI_DEFINE_VERSION(1, 7, 0) && OGRE_NO_VIEWPORT_ORIENTATIONMODE == 0
Ogre::OrientationMode orient = mSaveViewport->getOrientationMode();
system->_setProjectionMatrix(Ogre::Matrix4::IDENTITY * Ogre::Quaternion(Ogre::Degree(orient * 90.f), Ogre::Vector3::UNIT_Z));
#else
system->_setProjectionMatrix(Ogre::Matrix4::IDENTITY);
#endif
}
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);
}
}
/** The Ogre renderQueueStarted implementation
*
* The more used parameter is the queueGroupId. 90 is for the
* object to be highlighted, 91 is its outline.
*
* \param queueGroupId The queue group identifier (90 and 91 are treated)
* \param invocation Unused Ogre provided parameter
* \param repeatThisInvocation Unused Ogre provided parameter
*
*/
void RainbruRPG::Core::HighlightQueueListener::
renderQueueEnded(Ogre::uint8 queueGroupId, const Ogre::String& invocation,
bool& repeatThisInvocation)
{
if (( queueGroupId == 90 ) || ( queueGroupId == 91 )){
Ogre::RenderSystem * rendersys = Ogre::Root::getSingleton()
.getRenderSystem();
rendersys->setStencilCheckEnabled(false);
rendersys->setStencilBufferParams();
}
}
void GameMain::CreateRenderer()
{
m_pkRoot = new Ogre::Root();
mD3D9Plugin = new Ogre::D3D9Plugin();
m_pkRoot->installPlugin(mD3D9Plugin);
mOctreePlugin = new Ogre::OctreePlugin();
m_pkRoot->installPlugin(mOctreePlugin);
mBSPPlugin = new BspSceneManagerPlugin();
m_pkRoot->installPlugin(mBSPPlugin);
mCgPlugin = new CgPlugin();
m_pkRoot->installPlugin(mCgPlugin);
mParticleFXPlugin = new ParticleFXPlugin();
m_pkRoot->installPlugin(mParticleFXPlugin);
// Initialize window
Ogre::RenderSystem *selectedRenderSystem = m_pkRoot->getRenderSystemByName("Direct3D9 Rendering Subsystem");
m_pkRoot->setRenderSystem(selectedRenderSystem);
selectedRenderSystem->setConfigOption("Full Screen", "No");
selectedRenderSystem->setConfigOption("VSync","Yes");
char value[128];
sprintf(value, "%d x %d @ %d-bit colour", Chapter::ms_nWidth, Chapter::ms_nHeight, 32);
selectedRenderSystem->setConfigOption("Video Mode", value);
m_pkWindow = m_pkRoot->initialise(false, "Test Bullet");
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
m_pkWindow = m_pkRoot->createRenderWindow("Test Bullet", Chapter::ms_nWidth, Chapter::ms_nHeight, !Chapter::ms_bWindowed, &parms);
Chapter::ms_hWnd = m_hWnd;
Chapter::m_pkRoot = m_pkRoot;
Chapter::m_pkWindow = m_pkWindow;
m_pkRoot->addFrameListener( this );
m_pkWindow->setActive(true);
m_pkWindow->update();
// Add media path
Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
m_fCurrentTime = GetTickCount();
}
bool OgreApplication::initStart(void)
{
mPluginsCfg = "../configs/plugins.cfg";
mResourcesCfg = "../configs/resources.cfg";
Ogre::LogManager * lm = new Ogre::LogManager();
lm->createLog("OgreLogfile.log", true, false, false);
// construct Ogre::Root
mRoot = new Ogre::Root(mPluginsCfg, "", "");
Ogre::ConfigFile cf;
cf.load(mResourcesCfg);
// Go through all sections & settings in the file
Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::String secName, typeName, archName;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
Ogre::ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
archName = i->second;
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../assets/", "FileSystem");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../assets/particles", "FileSystem");
// Do not add this to the application
Ogre::RenderSystem *rs = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
mRoot->setRenderSystem(rs);
rs->setConfigOption("Full Screen", "No");
rs->setConfigOption("Video Mode", "800 x 600 @ 32-bit colour");
rs->setStencilCheckEnabled(true);
mRoot->initialise(false);
running = true;
return true;
}
void OgreWidget::init( std::string plugins_file, std::string ogre_cfg_file, std::string ogre_log )
{
mOgreRoot = new Ogre::Root( plugins_file, ogre_cfg_file, ogre_log );
Ogre::RenderSystemList renderers = mOgreRoot->getAvailableRenderers();
assert( !renderers.empty() );
Ogre::RenderSystem *renderSystem = chooseRenderer(& renderers );
assert( renderSystem );
mOgreRoot->setRenderSystem( renderSystem );
QString dimensions = QString( "%1x%2" ).arg(this->width()).arg(this->height());
renderSystem->setConfigOption( "Video Mode", dimensions.toStdString() );
mOgreRoot->getRenderSystem()->setConfigOption( "Full Screen", "No" );
mOgreRoot->saveConfig();
mOgreRoot->initialise(false);
initResourses();
}
//-------------------------------------------------------------------------------------
bool THIS::configure(void)
{
cout << "<TRACE><LOG><SceneManager><configure> Start" << endl;
// Show the configuration dialog and initialise the system
// You can skip this and use root.restoreConfig() to load configuration
// settings if you were sure there are valid ones saved in ogre.cfg
//mRoot->showConfigDialog();
//{
// If returned true, user clicked OK so initialise
// Here we choose to let the system create a default rendering window by passing 'true'
// mWindow = mRoot->initialise(true, "TutorialApplication Render Window");
//return true;
//}
//else
//{
// return false;
//}
// setup a renderer
Ogre::RenderSystemList::const_iterator renderers = mRoot->getAvailableRenderers().begin();
while(renderers != mRoot->getAvailableRenderers().end())
{
Ogre::String rName = (*renderers)->getName();
if (rName == "OpenGL Rendering Subsystem")
break;
renderers++;
}
Ogre::RenderSystem *renderSystem = *renderers;
mRoot->setRenderSystem( renderSystem );
QString dimensions = QString( "%1x%2" )
.arg(this->width())
.arg(this->height());
renderSystem->setConfigOption( "Video Mode", dimensions.toStdString() );
// initialize without creating window
mRoot->getRenderSystem()->setConfigOption( "Full Screen", "No" );
mRoot->saveConfig();
cout << "<TRACE><LOG><SceneManager><configure> initialize" << endl;
mRoot->initialise(false); // don't create a window
}
void GameSettings::update()
{
Root* root = Ogre::Root::getSingletonPtr();
Ogre::RenderSystem* renderer = root->getRenderSystem();
#if OGRE_VERSION_MINOR == 7 || OGRE_VERSION_MINOR == 8
const RenderSystemList& renderers = root->getAvailableRenderers();
#else
const RenderSystemList renderers = *root->getAvailableRenderers();
#endif
createElements(mVideoRenderer, renderers.size());
for (unsigned int i = 0; i < renderers.size(); ++i)
{
Ogre::RenderSystem* cur = renderers[i];
ListboxItem* item = mVideoRenderer->getListboxItemFromIndex(i);
item->setText(cur->getName());
if (cur == renderer)
{
mVideoRenderer->setItemSelectState(item, true);
}
}
ConfigOptionMap config = renderer->getConfigOptions();
setOption(config, "Full Screen", mVideoFullscreen);
std::vector<RadioButton*> videoColorDepth;
videoColorDepth.push_back(mVideoColorDepth32);
videoColorDepth.push_back(mVideoColorDepth16);
setOption(config, "Colour Depth", videoColorDepth);
std::vector<RadioButton*> videoAntiAliasing;
videoAntiAliasing.push_back(mVideoFsaa0);
videoAntiAliasing.push_back(mVideoFsaa2);
videoAntiAliasing.push_back(mVideoFsaa4);
videoAntiAliasing.push_back(mVideoFsaa8);
setOption(config, "FSAA", videoAntiAliasing);
std::vector<RadioButton*> videoRttMode;
videoRttMode.push_back(mVideoRttModeFBO);
videoRttMode.push_back(mVideoRttModePBuffer);
videoRttMode.push_back(mVideoRttModeCopy);
setOption(config, "RTT Preferred Mode", videoRttMode);
setOption(config, "Video Mode", mVideoResolution);
}
/**
* Setup application configuration options
*/
bool Robot::Application::configure()
{
// Always load the GL render system
this->mRoot->loadPlugin("./RenderSystem_GL");
// Get the GL Render system and set it on the root
Ogre::RenderSystem* RS = this->mRoot->getAvailableRenderers()[0];
this->mRoot->setRenderSystem(RS);
// Dont use full-screen
RS->setConfigOption("Full Screen", "no");
// Setup the root window
this->mWindow = this->mRoot->initialise(true, "CG - Project 4");
return true;
}
//------------------------------------------------------------------------------
void wxOgreRenderSystem::SelectOgreRenderSystem(const Ogre::String& render)
{
Ogre::RenderSystemList renderList;
Ogre::RenderSystemList::iterator it;
renderList = m_root->getAvailableRenderers();
// check through all available renderers, if there is one the
// string is "render"
for (it = renderList.begin(); it != renderList.end(); ++it) {
Ogre::RenderSystem* renderSys = *it;
if (std::string (renderSys->getName()) == render) {
m_root->setRenderSystem(renderSys);
break;
}
}
}
void RenderSystem::detectGlVersion()
{
if ( force_gl_version_ )
{
gl_version_ = force_gl_version_;
}
else
{
Ogre::RenderSystem *renderSys = ogre_root_->getRenderSystem();
renderSys->createRenderSystemCapabilities();
const Ogre::RenderSystemCapabilities* caps = renderSys->getCapabilities();
int major = caps->getDriverVersion().major;
int minor = caps->getDriverVersion().minor;
gl_version_ = major * 100 + minor*10;
}
switch ( gl_version_ )
{
case 200:
glsl_version_ = 110;
break;
case 210:
glsl_version_ = 120;
break;
case 300:
glsl_version_ = 130;
break;
case 310:
glsl_version_ = 140;
break;
case 320:
glsl_version_ = 150;
break;
default:
if ( gl_version_ > 320 )
{
glsl_version_ = gl_version_;
}
else
{
glsl_version_ = 0;
}
break;
}
ROS_INFO_STREAM( "OpenGl version: " << (float)gl_version_ / 100.0 << " (GLSL " << (float)glsl_version_ / 100.0 << ")." );
}
void OgreRTTexture::begin()
{
Ogre::RenderTexture* rtt = mTexture->getBuffer()->getRenderTarget();
if (mViewport == nullptr)
{
mViewport = rtt->addViewport(nullptr);
mViewport->setClearEveryFrame(false);
mViewport->setOverlaysEnabled(false);
}
Ogre::RenderSystem* system = Ogre::Root::getSingleton().getRenderSystem();
system->_setProjectionMatrix(mProjectMatrix);
mSaveViewport = system->_getViewport();
system->_setViewport(mViewport);
system->clearFrameBuffer(Ogre::FBT_COLOUR, Ogre::ColourValue::ZERO);
}
/** Sets up the application - returns false if the user chooses to abandon configuration. */
bool OgreApp::setup(void){
String cfgPath = mResourcePath + resource_cfg_file;
mRoot = new Root();
#if( CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID )
Ogre::GLES2Plugin* plugin = new Ogre::GLES2Plugin();
#else
Ogre::GLPlugin* plugin = new Ogre::GLPlugin();
//Ogre::GLES2Plugin* plugin = new Ogre::GLES2Plugin();
#endif
mRoot->installPlugin(plugin);
Ogre::RenderSystem* rs = mRoot->getRenderSystemByName( "OpenGL Rendering Subsystem" );
assert( rs );
// CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCSize frameSize = CCDirector::sharedDirector()->getWinSize();
char buff[256]; memset( buff, 0x00, sizeof(buff) );
sprintf( buff, "%dx%d", (int)frameSize.width, (int)frameSize.height );
// sprintf( buff, "%dx%d", 200, 200 );
rs->setConfigOption( "Video Mode", buff );
rs->setConfigOption( "Full Screen", "No" );
mRoot->setRenderSystem( rs );
mWindow = mRoot->initialise(true);
setupResources();
chooseSceneManager();
createCamera();
createViewports();
// Set default mipmap level (NB some APIs ignore this)
TextureManager::getSingleton().setDefaultNumMipmaps(5);
// Create any resource listeners (for loading screens)
createResourceListener();
// Load resources
#if( CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID )
//android 不需要?
loadResources();
#endif
return true;
}
/** The Ogre renderQueueStarted implementation
*
* The more used parameter is the queueGroupId. 90 is for the
* object to be highlighted, 91 is its outline.
*
* \param queueGroupId The queue group identifier (90 and 91 are treated)
* \param invocation Unused Ogre provided parameter
* \param skipThisInvocation Unused Ogre provided parameter
*
*/
void RainbruRPG::Core::HighlightQueueListener::
renderQueueStarted(Ogre::uint8 queueGroupId, const Ogre::String& invocation,
bool& skipThisInvocation)
{
//RenderQueue containing the object to be highlighted
if (queueGroupId == 90){
Ogre::RenderSystem * rendersys = Ogre::Root::getSingleton()
.getRenderSystem();
rendersys->clearFrameBuffer(Ogre::FBT_STENCIL);
rendersys->setStencilCheckEnabled(true);
rendersys->setStencilBufferParams(Ogre::CMPF_ALWAYS_PASS,1,0xFFFFFFFF,
Ogre::SOP_KEEP,Ogre::SOP_KEEP,
Ogre::SOP_REPLACE,false);
}
//RenderQueue containing the outline
if (queueGroupId == 91){
Ogre::RenderSystem * rendersys = Ogre::Root::getSingleton()
.getRenderSystem();
rendersys->setStencilCheckEnabled(true);
rendersys->setStencilBufferParams(Ogre::CMPF_NOT_EQUAL,1,0xFFFFFFFF,
Ogre::SOP_KEEP,Ogre::SOP_KEEP,
Ogre::SOP_KEEP,false);
}
}
void LayerManager::_windowResized(const FloatSize& _size)
{
// новый размер
mViewSize = _size;
mPixScaleX = 1.0 / _size.width;
mPixScaleY = 1.0 / _size.height;
mAspectCoef = _size.height / _size.width;
Ogre::RenderSystem * render = Ogre::Root::getSingleton().getRenderSystem();
mHOffset = render->getHorizontalTexelOffset() / _size.width;
mVOffset = render->getVerticalTexelOffset() / _size.height;
// обновить всех
mUpdate = true;
}
void RenderSystem::setupRenderSystem()
{
Ogre::RenderSystem *renderSys;
const Ogre::RenderSystemList *rsList;
// Get the list of available renderers.
#if OGRE_VERSION_MAJOR == 1 && OGRE_VERSION_MINOR == 6
rsList = ogre_root_->getAvailableRenderers();
#else
rsList = &(ogre_root_->getAvailableRenderers());
#endif
// Look for the OpenGL one, which we require.
renderSys = NULL;
for( unsigned int i = 0; i < rsList->size(); i++ )
{
renderSys = rsList->at( i );
if( renderSys->getName().compare("OpenGL Rendering Subsystem")== 0 )
{
break;
}
}
if( renderSys == NULL )
{
throw std::runtime_error( "Could not find the opengl rendering subsystem!\n" );
}
// We operate in windowed mode
renderSys->setConfigOption("Full Screen","No");
/// We used to allow the user to set the RTT mode to PBuffer, FBO, or Copy.
/// Copy is slow, and there doesn't seem to be a good reason to use it
/// PBuffer limits the size of the renderable area of the RTT to the
/// size of the first window created.
/// FBO seem to be the only good option
// renderSys->setConfigOption("RTT Preferred Mode", "FBO");
// Set the Full Screen Anti-Aliasing factor.
renderSys->setConfigOption("FSAA", "2");
ogre_root_->setRenderSystem(renderSys);
}
void doRender(IVertexBuffer* _buffer, ITexture* _texture, size_t _count)
{
if (getManualRender())
{
begin();
setManualRender(false);
}
// ADDED
if (!mVertexProgramNoTexture)
initShaders();
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 OgreImGui::renderQueueEnded(Ogre::uint8 queueGroupId, const Ogre::String& invocation,bool& repeatThisInvocation)
{
if ((queueGroupId != Ogre::RENDER_QUEUE_OVERLAY) || (invocation == "SHADOWS"))
{
return;
}
Ogre::RenderSystem* renderSys = Ogre::Root::getSingletonPtr()->getRenderSystem();
Ogre::Viewport* vp = renderSys->_getViewport();
if ((vp == nullptr) || (!vp->getTarget()->isPrimary()) || mFrameEnded)
{
return;
}
mFrameEnded = true;
ImGui::Render();
this->updateVertexData();
ImGuiIO& io = ImGui::GetIO();
// Construct projection matrix, taking texel offset corrections in account (important for DirectX9)
// See also:
// - OGRE-API specific hint: http://www.ogre3d.org/forums/viewtopic.php?f=5&p=536881#p536881
// - IMGUI Dx9 demo solution: https://github.com/ocornut/imgui/blob/master/examples/directx9_example/imgui_impl_dx9.cpp#L127-L138
const float texelOffsetX = renderSys->getHorizontalTexelOffset();
const float texelOffsetY = renderSys->getVerticalTexelOffset();
const float L = texelOffsetX;
const float R = io.DisplaySize.x + texelOffsetX;
const float T = texelOffsetY;
const float B = io.DisplaySize.y + texelOffsetY;
Ogre::Matrix4 projMatrix( 2.0f/(R-L), 0.0f, 0.0f, (L+R)/(L-R),
0.0f, -2.0f/(B-T), 0.0f, (T+B)/(B-T),
0.0f, 0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
mPass->getVertexProgramParameters()->setNamedConstant("ProjectionMatrix", projMatrix);
for(std::list<ImGUIRenderable*>::iterator it = mRenderables.begin(); it!=mRenderables.end(); ++it)
{
mSceneMgr->_injectRenderWithPass(mPass, (*it), false, false, nullptr);
}
}