自学教程：C++ windowResized函数代码示例

FrameListenerBase::FrameListenerBase(Ogre::RenderWindow* rw, Ogre::Camera* camera) :	m_Window(rw),	m_Camera(camera){	// Initialize OIS(Object-oriented Input System)	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr;	m_Window->getCustomAttribute("WINDOW", &windowHnd);	windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));	m_InputManager = OIS::InputManager::createInputSystem(pl);	// Buffered input	m_Keyboard = static_cast<OIS::Keyboard*>(m_InputManager->createInputObject(OIS::OISKeyboard, true));	m_Mouse = static_cast<OIS::Mouse*>(m_InputManager->createInputObject(OIS::OISMouse, true));	m_Keyboard->setEventCallback(this);	m_Mouse->setEventCallback(this);	// Set initial mouse clipping state	windowResized(m_Window);	// Register as a WindowEventListener	Ogre::WindowEventUtilities::addWindowEventListener(m_Window, this);}

void TutorialApplication::createFrameListener(void){    Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");    OIS::ParamList pl;    size_t windowHnd = 0;    std::ostringstream windowHndStr;    mWindow->getCustomAttribute("WINDOW", &windowHnd);    windowHndStr << windowHnd;    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));    mInputManager = OIS::InputManager::createInputSystem( pl );    mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));    mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true ));    mMouse->setEventCallback(this);    mKeyboard->setEventCallback(this);    //Set initial mouse clipping size    windowResized(mWindow);    //Register as a Window listener    Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);    mRoot->addFrameListener(this);}

void OISManager::initialize() {	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr;	Client::getInstance().getOgreManager().getWindow()->getCustomAttribute("WINDOW", &windowHnd);	windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));    pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string("false")));    pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string("false")));    pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));    pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));	inputManager = OIS::InputManager::createInputSystem( pl );	keyboard = static_cast<OIS::Keyboard*>(inputManager->createInputObject( OIS::OISKeyboard, true ));	mouse = static_cast<OIS::Mouse*>(inputManager->createInputObject( OIS::OISMouse, true ));	mouse->setEventCallback(this);	keyboard->setEventCallback(this);		// unsigned int width, height, depth; //    int left, top; //    Client::getInstance().getOgreManager().getWindow()->getMetrics(width, height, depth, left, top);	windowResized(		Client::getInstance().getOgreManager().getWindow());    Ogre::WindowEventUtilities::addWindowEventListener(    	Client::getInstance().getOgreManager().getWindow(), this);         DEBUG("!!!!!!!!!!! OIS INITIATE DONE !!!!!!!!!!!");}

void 	TutorialApplication::initInput(){	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr;	mWindow->getCustomAttribute("WINDOW", &windowHnd);	windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));	pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));    pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));	mInputManager = OIS::InputManager::createInputSystem( pl );	mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));	mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true ));	mMouse->setEventCallback(this);mKeyboard->setEventCallback(this);	//Set initial mouse clipping size	windowResized(mWindow);}

void GameCore::initializeEventListeners(){    //compiled from ogre framework    OIS::ParamList pl;    size_t windowHnd = 0;    std::ostringstream windowHndStr;    renderWindow->getCustomAttribute("WINDOW", &windowHnd);    windowHndStr << windowHnd;    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));    pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));    inputManager = OIS::InputManager::createInputSystem( pl );    keyboard = static_cast<OIS::Keyboard*>(inputManager->createInputObject( OISKeyboard, true ));    mouse = static_cast<OIS::Mouse*>(inputManager->createInputObject( OISMouse, true ));    mouse->setEventCallback(this);    keyboard->setEventCallback(this);    windowResized(renderWindow);    Ogre::WindowEventUtilities::addWindowEventListener(renderWindow, this);}

void ApplicationContext::pollEvents(){#if OGRE_BITES_HAVE_SDL    if(!mSDLWindow)    {        // SDL events not initialized        return;    }    SDL_Event event;    while (SDL_PollEvent(&event))    {        switch (event.type)        {        case SDL_QUIT:            mRoot->queueEndRendering();            break;        case SDL_WINDOWEVENT:            if(event.window.event == SDL_WINDOWEVENT_RESIZED) {                mWindow->resize(event.window.data1, event.window.data2);                windowResized(mWindow);            }            break;        default:            _fireInputEvent(event);            break;        }    }#endif}

GameFrameListener::GameFrameListener( Ogre::RenderWindow* win ):    m_Window( win ),    m_InputManager( 0 ),    m_Keyboard( 0 ){    OIS::ParamList pl;    size_t windowHnd = 0;    std::ostringstream windowHndStr;    win->getCustomAttribute( "WINDOW", &windowHnd );    windowHndStr << windowHnd;    pl.insert( std::make_pair( std::string( "WINDOW" ), windowHndStr.str() ) );#if defined __WIN32__    pl.insert( std::make_pair( std::string( "w32_mouse" ), std::string( "DISCL_FOREGROUND" ) ) );    pl.insert( std::make_pair( std::string( "w32_mouse" ), std::string( "DISCL_NONEXCLUSIVE" ) ) );#else    pl.insert( std::make_pair( std::string( "x11_mouse_grab" ), std::string( "false" ) ) );    pl.insert( std::make_pair( std::string( "x11_mouse_hide" ), std::string( "false" ) ) );#endif    m_InputManager = OIS::InputManager::createInputSystem( pl );    m_Keyboard = static_cast< OIS::Keyboard* >( m_InputManager->createInputObject( OIS::OISKeyboard, true ) );    m_Keyboard->setEventCallback( this );    m_Mouse = static_cast< OIS::Mouse* >( m_InputManager->createInputObject( OIS::OISMouse, true ) );    m_Mouse->setEventCallback( this );    windowResized( m_Window );    //Register as a Window listener    Ogre::WindowEventUtilities::addWindowEventListener( m_Window, this );}

void Game::InitializeOIS(bool useBufferedInput){	//Set up logger	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	//Initialize OIS	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr; 	mWindow->getCustomAttribute("WINDOW", &windowHnd);		windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str())); pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));   pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));    pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));	mInputManager = OIS::InputManager::createInputSystem( pl );	mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, useBufferedInput ));	mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, useBufferedInput ));	mKeyboard->setEventCallback(InputNotifier::GetInstance());	mMouse->setEventCallback(InputNotifier::GetInstance());	//Set initial mouse clipping size	windowResized(mWindow);}

	bool Input::Start(Ogre::RenderWindow * win, bool exclusive)	{		window = win;		OIS::ParamList pl;		size_t windowHnd=0;		std::ostringstream windowHndStr;		window->getCustomAttribute("WINDOW", &windowHnd);		windowHndStr << windowHnd;		pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));		if(!exclusive)		{			pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));			pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));		}		manager = OIS::InputManager::createInputSystem(pl);		keyboard = static_cast<OIS::Keyboard*>(manager->createInputObject(OIS::OISKeyboard, true));		mouse = static_cast<OIS::Mouse*>(manager->createInputObject(OIS::OISMouse, true));		keyboard->setBuffered(true);		mouse->setBuffered(true);		keyboard->setEventCallback(this);		mouse->setEventCallback(this);		Ogre::WindowEventUtilities::addWindowEventListener(window, this);		windowResized(window);		running = true;		return true;	}

void Client::InitializeWindow() {	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr;	mWindow->getCustomAttribute("WINDOW", &windowHnd);	windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));#ifdef DEBUG	pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string("false")));	pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));#endif	mInputManager = OIS::InputManager::createInputSystem( pl );	mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));	mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true ));	// Register for callback	mKeyboard->setEventCallback(this);	mMouse->setEventCallback(this);	//mMouse->setBuffered(true);	// Set initial mouse clipping size	windowResized(mWindow);	// Register as a Window listener	Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);	// Register as Frame Listener	mOgreRoot->addFrameListener(this);}

// Add this class as a frame listener to react on different input.void InputHandler::createFrameListener(void) {    Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");    OIS::ParamList pl;    size_t windowHnd = 0;    std::ostringstream windowHndStr;    mWindow->getCustomAttribute("WINDOW", &windowHnd);    windowHndStr << windowHnd;    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));    mInputManager = OIS::InputManager::createInputSystem( pl );    mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));    mKeyboard->setEventCallback(this);	mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true ));	mMouse->setEventCallback(this);    //Set initial mouse clipping size    windowResized(mWindow);    //Register as a Window listener    Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);	const OIS::MouseState &mouseState = mMouse->getMouseState(); // mMouse is type of OIS::Mouse*	mouseState.width = mWindow->getWidth(); // your rendering area width	mouseState.height = mWindow->getHeight(); // your rendering area height}

void Game::setResolution(sf::Vector2u size){	if (fullscreen)		window.create(sf::VideoMode(size.x, size.y), title, sf::Style::Close | sf::Style::Titlebar | sf::Style::Fullscreen);	else		window.create(sf::VideoMode(size.x, size.y), title, sf::Style::Close | sf::Style::Titlebar);	windowResized(size);}

//-------------------------------------------------------------------------------------void BaseApplication::createFrameListener(void){    Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");    OIS::ParamList pl;    size_t windowHnd = 0;    std::ostringstream windowHndStr;    mWindow->getCustomAttribute("WINDOW", &windowHnd);    windowHndStr << windowHnd;    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));    mInputManager = OIS::InputManager::createInputSystem( pl );    mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));    mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true ));    mMouse->setEventCallback(this);    mKeyboard->setEventCallback(this);    //Set initial mouse clipping size    windowResized(mWindow);    //Register as a Window listener    Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);    OgreBites::InputContext input;    input.mAccelerometer = NULL;    input.mKeyboard = mKeyboard;    input.mMouse = mMouse;    input.mMultiTouch = NULL;        mTrayMgr = new OgreBites::SdkTrayManager(Ogre::String("InterfaceName"), mWindow, input, this);    mTrayMgr->showFrameStats(OgreBites::TL_BOTTOMLEFT);    mTrayMgr->showLogo(OgreBites::TL_BOTTOMRIGHT);    mTrayMgr->hideCursor();    // create a params panel for displaying sample details    Ogre::StringVector items;    items.push_back("cam.pX");    items.push_back("cam.pY");    items.push_back("cam.pZ");    items.push_back("");    items.push_back("cam.oW");    items.push_back("cam.oX");    items.push_back("cam.oY");    items.push_back("cam.oZ");    items.push_back("");    items.push_back("Filtering");    items.push_back("Poly Mode");    mDetailsPanel = mTrayMgr->createParamsPanel(OgreBites::TL_NONE, "DetailsPanel", 200, items);    mDetailsPanel->setParamValue(9, "Bilinear");    mDetailsPanel->setParamValue(10, "Solid");    mDetailsPanel->hide();    mRoot->addFrameListener(this);}

void ApplicationContextAndroid::pollEvents(){    for(WindowList::iterator it = mWindows.begin(); it != mWindows.end(); ++it)    {        Ogre::RenderWindow* win = it->render;        win->windowMovedOrResized();        windowResized(win);    }}

	void Gui::setActiveViewport(Ogre::ushort _num)	{		if (_num == mActiveViewport) return;		MYGUI_ASSERT(mWindow, "Gui is not initialised.");		MYGUI_ASSERT(mWindow->getNumViewports() >= _num, "index out of range");		mActiveViewport = _num;		// рассылка обновлений		windowResized(mWindow);	}

void SDL_Event_Handler::windowEvent(const SDL_Event *event) {  switch (event->window.event) {    case SDL_WINDOWEVENT_SHOWN:      //windowShown(event);      break;    case SDL_WINDOWEVENT_HIDDEN:      //windowHidden(event);      break;    case SDL_WINDOWEVENT_EXPOSED:      //windowExposed(event);      break;    case SDL_WINDOWEVENT_MOVED:      //windowMoved(event);      break;    case SDL_WINDOWEVENT_RESIZED:      windowResized(event);      break;    case SDL_WINDOWEVENT_SIZE_CHANGED:      break;  // will trigger above event too    case SDL_WINDOWEVENT_MINIMIZED:      //windowMinimized(event);      break;    case SDL_WINDOWEVENT_MAXIMIZED:      //windowMaximized(event);      break;    case SDL_WINDOWEVENT_RESTORED:      //windowRestored(event);      break;    case SDL_WINDOWEVENT_ENTER:      //windowEntered(event);      break;    case SDL_WINDOWEVENT_LEAVE:      //windowLeave(event);      break;    case SDL_WINDOWEVENT_FOCUS_GAINED:      windowFocusGain(event);      break;    case SDL_WINDOWEVENT_FOCUS_LOST:      windowFocusLost(event);      break;    case SDL_WINDOWEVENT_CLOSE:      //windowClose(event);      break;#if SDL_VERSION_ATLEAST(2, 0, 5)    case SDL_WINDOWEVENT_TAKE_FOCUS:      //windowTakeFocus(event);      break;    case SDL_WINDOWEVENT_HIT_TEST:      //windowHitTest(event);      break;#endif    default:      //unkownEvent(event);      break;  }}

//--------------------------------------------------------------void testApp::setup() {	 	for(int i=0; i<strlen(sz); i++) sz[i] += 20;		// setup fluid stuff	fluidSolver.setup(100, 100);    fluidSolver.enableRGB(true).setFadeSpeed(0.002).setDeltaT(0.5).setVisc(0.00015).setColorDiffusion(0);	fluidDrawer.setup(&fluidSolver);		fluidCellsX			= 150;		drawFluid			= true;	drawParticles		= true;		ofSetFrameRate(60);	ofBackground(0, 0, 0);	ofSetVerticalSync(false);	#ifdef USE_TUIO	tuioClient.start(3333);#endif	#ifdef USE_GUI 	gui.addSlider("fluidCellsX", fluidCellsX, 20, 400);	gui.addButton("resizeFluid", resizeFluid);    gui.addSlider("colorMult", colorMult, 0, 100);    gui.addSlider("velocityMult", velocityMult, 0, 100);	gui.addSlider("fs.viscocity", fluidSolver.viscocity, 0.0, 0.01);	gui.addSlider("fs.colorDiffusion", fluidSolver.colorDiffusion, 0.0, 0.0003); 	gui.addSlider("fs.fadeSpeed", fluidSolver.fadeSpeed, 0.0, 0.1); 	gui.addSlider("fs.solverIterations", fluidSolver.solverIterations, 1, 50); 	gui.addSlider("fs.deltaT", fluidSolver.deltaT, 0.1, 5);//	gui.addComboBox("fd.drawMode", (int&)fluidDrawer.drawMode, msa::fluid::getDrawModeTitles());	gui.addToggle("fs.doRGB", fluidSolver.doRGB);	gui.addToggle("fs.doVorticityConfinement", fluidSolver.doVorticityConfinement); 	gui.addToggle("drawFluid", drawFluid); 	gui.addToggle("drawParticles", drawParticles); 	gui.addToggle("fs.wrapX", fluidSolver.wrap_x);	gui.addToggle("fs.wrapY", fluidSolver.wrap_y);	gui.currentPage().setXMLName("ofxMSAFluidSettings.xml");    gui.loadFromXML();	gui.setDefaultKeys(true);	gui.setAutoSave(true);    gui.show();#endif		windowResized(ofGetWidth(), ofGetHeight());		// force this at start (cos I don't think it is called)	pMouse = msa::getWindowCenter();	resizeFluid			= true;		ofEnableAlphaBlending();	ofSetBackgroundAuto(false);}

void BaseApplication::createFrameListener(void){    mMouse->setEventCallback(this);    mKeyboard->setEventCallback(this);    //Set initial mouse clipping size    windowResized(mWindow);    //Register as a Window listener    Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);    mRoot->addFrameListener(this);}

//--------------------------------------------------------------void fluid001::setup() {	 	ofSetLogLevel(OF_LOG_VERBOSE);		for(int i=0; i<strlen(sz); i++) {		sz[i] = sz[i] + 20;	}	printf("%s/n", sz);		// setup fluid stuff	fluidSolver.setup(100, 100);    fluidSolver.enableRGB(true).setFadeSpeed(0.002).setDeltaT(0.5).setVisc(0.00015).setColorDiffusion(0);	fluidDrawer.setup(&fluidSolver);		fluidCellsX			= 150;		drawFluid			= true;	drawParticles		= true;	renderUsingVA		= true;			ofBackground(0, 0, 0);	ofSetVerticalSync(false);//	ofSetFrameRate(60);	#ifdef USE_TUIO	tuioClient.start(3333);#endif	#ifdef USE_GUI 	gui.addSlider("fluidCellsX", fluidCellsX, 20, 400);	gui.addButton("resizeFluid", resizeFluid);	gui.addSlider("fs.viscocity", fluidSolver.viscocity, 0.0, 1, 0.5); 	gui.addSlider("fs.colorDiffusion", fluidSolver.colorDiffusion, 0.0, 0.0003, 0.5); 	gui.addSlider("fs.fadeSpeed", fluidSolver.fadeSpeed, 0.0, 0.1, 0.5); 	gui.addSlider("fs.solverIterations", fluidSolver.solverIterations, 1, 50); 	gui.addSlider("fs.deltaT", fluidSolver.deltaT, 0.1, 5);	gui.addSlider("fd.drawMode", fluidDrawer.drawMode, 0, FLUID_DRAW_MODE_COUNT-1); 	gui.addToggle("fs.doRGB", fluidSolver.doRGB); 	gui.addToggle("fs.doVorticityConfinement", fluidSolver.doVorticityConfinement); 	gui.addToggle("drawFluid", drawFluid); 	gui.addToggle("drawParticles", drawParticles); 	gui.addToggle("renderUsingVA", renderUsingVA); 	gui.addToggle("fs.wrapX", fluidSolver.wrap_x); 	gui.addToggle("fs.wrapY", fluidSolver.wrap_y);	gui.addSlider("velocityMult", velocityMult, 0.0, 1);	gui.setAutoSave(true);	gui.loadFromXML();	#endif		windowResized(ofGetWidth(), ofGetHeight());		// force this at start (cos I don't think it is called)	resizeFluid			= true;}

//--------------------------------------------------------------void ofApp::setup(){	showInfo = false;	dropped = 0;	changed = false;	clearFbos = false;	lastMouseMoved = 0;	exporting = 0;		applicationRunning = false; 	ofSetVerticalSync(true);	ofBackground(0);	ofSetBackgroundAuto(false);		// shaderLoader handles this for us//	shader.setGeometryInputType(GL_LINES);//	shader.setGeometryOutputType(GL_QUADS);//	shader.setGeometryOutputCount(4);	shaderLoader.setup(&shader, "shaders/osci");		vector<RtAudio::DeviceInfo> devices = listRtSoundDevices();	ofSetFrameRate(60);		root = new mui::Root();		globals.loadFromFile();	globals.player.loadSound( "konichiwa.wav" );	globals.player.setLoop(true);	globals.player.stop(); 		configView = new ConfigView();	configView->fromGlobals();	if( globals.autoDetect ){		configView->autoDetect();	}	root->add( configView );		osciView = new OsciView();	osciView->visible = false;	root->add( osciView );		left.loop = false;	right.loop = false;		if( globals.autoDetect ){		startApplication();	}	windowResized(ofGetWidth(), ofGetHeight());}

    void setActiveViewport(unsigned short _num)    {        mActiveViewport = _num;        if (mWindow != nullptr)        {            Ogre::WindowEventUtilities::removeWindowEventListener(mWindow, this);            Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);            // рассылка обновлений            windowResized(mWindow);        }    }

bool		Application::init(const std::string &host, int port){  _plugins = "plugins.cfg";  _ressources = "resources.cfg";  Factory::init();  Factory::Client::init();  if (!(_root = new Ogre::Root(_plugins)))    throw graphicException("fail init root");  this->loadResources();  if (!(_root->restoreConfig() || _root->showConfigDialog()))    return false;  if (!(_window = _root->initialise(true, "Hexatyla")))    throw graphicException("can't initialise window renderer");  if (!_fontmanager)    _fontmanager = new Ogre::FontManager();  if (!(_overlaySystem = new Ogre::OverlaySystem()))    throw graphicException("Failed to instanciate OverlaySystem");  Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);  Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();  this->initInput();  this->initScene();  windowResized(_window);  this->initOverlaySceneManager();  bool		pb = false;  Kernel::Manager::getInstance()->init();  try {    Network::Manager::Client::getInstance()->init(host, port);  }  catch (Network::Exception *e) {    Logger::getInstance()->log(e->what(), Logger::FATAL);    delete (e);    pb = true;  }  if (pb == false) {    this->_thNetwork->start(&start_network_manager, Network::Manager::Client::getInstance());  }  return true;}

//callbackextern void __android_handle_cmd(struct android_app* app, int32_t cmd) {	switch(cmd){		case APP_CMD_INIT_WINDOW: 			setIsAndroidValidDevice(true);			if(initAndroid) 				initAndroid(app->userData);		break;		case APP_CMD_TERM_WINDOW: 			if(termAndroid) 				termAndroid(app->userData);		break;		case APP_CMD_PAUSE: 			setIsAndroidValidDevice(false);			if(pauseAndroid) 				pauseAndroid(app->userData);		break;		case APP_CMD_WINDOW_RESIZED:			if(windowResized){ 				int32_t width = ANativeWindow_getWidth(getAndroidApp()->window);				int32_t height = ANativeWindow_getHeight(getAndroidApp()->window);				windowResized(app->userData,(int)width,(int)height);			}		break;		case APP_CMD_RESUME: 			if(resumeAndroid) 				resumeAndroid(app->userData);		break;  		case APP_CMD_CONFIG_CHANGED:			if(configChange) 				configChange(app->userData);        break;		case APP_CMD_SAVE_STATE:						if(saveStateAndroid) 				saveStateAndroid(app->userData);        break;		case APP_CMD_GAINED_FOCUS: 			setEnableAccelerometer((1000L/60)*1000);			if(getFocusAndroid) 				getFocusAndroid(app->userData);		break;  		case APP_CMD_LOST_FOCUS: 			setDisableAccelerometer();			if(lostFocusAndroid) 				lostFocusAndroid(app->userData);		break;		default:break;	}	}

bool BareOgre::go(void) {  mLog = new Ogre::LogManager;  mLog->createLog("Ogre.log");#ifdef _DEBUG  mResourcesCfg = "resources_d.cfg";  mPluginsCfg = "plugins_d.cfg";#else  mResourcesCfg = "resources.cfg";  mPluginsCfg = "plugins.cfg";#endif  mRoot = new Ogre::Root(mPluginsCfg);  // Load resource paths from resources config file.  setupResources();  // Configure dialog.  if (!( mRoot->restoreConfig() || mRoot->showConfigDialog() )) {    return false;  }  // Create RenderWindow.  mWindow = mRoot->initialise(true, "BareOgre Render Window");  // Set default mipmap level.  Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);  // Initialize all resource groups.  Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();  // Create scene.  createScene();  // Initialize input. (OIS)  initInput();  // Set initial mouse clipping size.  windowResized(mWindow);  // Register as a Window listener.  Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);  // Render loop.  mRoot->addFrameListener(this);  mRoot->startRendering();  return true;}

    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 BaseApplication::createFrameListener(void){	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");	OIS::ParamList pl;	size_t windowHnd = 0;	std::ostringstream windowHndStr; 	mWindow->getCustomAttribute("WINDOW", &windowHnd);	windowHndStr << windowHnd;	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str())); 	mInputManager = OIS::InputManager::createInputSystem( pl ); 	mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true ));	mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true )); 	mMouse->setEventCallback(this);	mKeyboard->setEventCallback(this); 	//Set initial mouse clipping size	windowResized(mWindow); 	//Register as a Window listener	Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this); 	mInputContext.mKeyboard = mKeyboard;    mInputContext.mMouse = mMouse;    mTrayMgr = new OgreBites::SdkTrayManager("InterfaceName", mWindow, mInputContext, this);	mTrayMgr->showFrameStats(OgreBites::TL_BOTTOMLEFT);	mTrayMgr->showLogo(OgreBites::TL_BOTTOMRIGHT);	//mTrayMgr->hideCursor(); 	// create a params panel for displaying sample details	Ogre::StringVector items;	items.push_back("ID : ");	items.push_back("HP :");	items.push_back("STATE :");	items.push_back("KILLS : ");	items.push_back("DEATHS : ");	items.push_back("POWERUP : "); 	mDetailsPanel = mTrayMgr->createParamsPanel(OgreBites::TL_NONE, "DetailsPanel", 200, items);	mDetailsPanel->hide(); 	mRoot->addFrameListener(this);}

//-------------------------------------------------------------------------------------void BaseApplication::createFrameListener(void){    size_t windowHnd = 0;    std::stringstream windowHndStr;    mWindow->getCustomAttribute("WINDOW", &windowHnd);    windowHndStr << windowHnd;	    //Set initial mouse clipping size    windowResized(mWindow);    //Register as a Window listener    WindowEventUtilities::addWindowEventListener(mWindow, this);	OgreBites::InputContext input;	//input.mMouse = mMouse;    mTrayMgr = new OgreBites::SdkTrayManager("InterfaceName", mWindow, input, this);    mTrayMgr->showFrameStats(OgreBites::TL_BOTTOMLEFT);    mTrayMgr->showLogo(OgreBites::TL_BOTTOMRIGHT);    mTrayMgr->hideCursor();    // create a params panel for displaying sample details    StringVector items;    items.push_back("cam.pX");    items.push_back("cam.pY");    items.push_back("cam.pZ");    items.push_back("");    items.push_back("cam.oW");    items.push_back("cam.oX");    items.push_back("cam.oY");    items.push_back("cam.oZ");    items.push_back("");    items.push_back("Filtering");    items.push_back("Poly Mode");    mDetailsPanel = mTrayMgr->createParamsPanel(OgreBites::TL_NONE, "DetailsPanel", 200, items);    mDetailsPanel->setParamValue(9, "Bilinear");    mDetailsPanel->setParamValue(10, "Solid");    mDetailsPanel->hide();    mRoot->addFrameListener(this);}

void application::create_frame_listener(){    Ogre::LogManager::getSingletonPtr() -> logMessage("Initializing OIS");    OIS::ParamList pl;    size_t wndhnd = 0;    std::ostringstream wndhndstr;    wnd->getCustomAttribute ("WINDOW", &wndhnd);    wndhndstr << wndhnd;    pl.insert (std::make_pair (std::string {"WINDOW"}, wndhndstr.str()));    input = OIS::InputManager::createInputSystem(pl);    kbd   = static_cast<OIS::Keyboard*> (input->createInputObject (OIS::OISKeyboard, true));    mouse = static_cast<OIS::Mouse*>    (input->createInputObject (OIS::OISMouse,    true));    mouse -> setEventCallback(this);    kbd   -> setEventCallback(this);    windowResized(wnd);    Ogre::WindowEventUtilities::addWindowEventListener (wnd, this);    OgreBites::InputContext inctx;    inctx.mMouse    = mouse;    inctx.mKeyboard = kbd;    tray_mgr = new OgreBites::SdkTrayManager ("InterfaceName", wnd, inctx, this);    tray_mgr->showFrameStats(OgreBites::TL_BOTTOMLEFT);    tray_mgr->showLogo(OgreBites::TL_BOTTOMRIGHT);    tray_mgr->hideCursor();    Ogre::StringVector items;    items.push_back("cam.pX");    items.push_back("cam.pY");    items.push_back("cam.pZ");    items.push_back("");    items.push_back("cam.oW");    items.push_back("cam.oX");    items.push_back("cam.oY");    items.push_back("cam.oZ");    items.push_back("");    items.push_back("Filtering");    items.push_back("Poly Mode");    root->addFrameListener(this);}

void ApplicationContextSDL::pollEvents(){    if(mWindows.empty())    {        // SDL events not initialized        return;    }    SDL_Event event;    while (SDL_PollEvent(&event))    {        switch (event.type)        {        case SDL_QUIT:            mRoot->queueEndRendering();            break;        case SDL_WINDOWEVENT:            if(event.window.event != SDL_WINDOWEVENT_RESIZED)                continue;            for(WindowList::iterator it = mWindows.begin(); it != mWindows.end(); ++it)            {                if(event.window.windowID != SDL_GetWindowID(it->native))                    continue;                Ogre::RenderWindow* win = it->render;                win->windowMovedOrResized();                windowResized(win);            }            break;        default:            _fireInputEvent(convert(event), event.window.windowID);            break;        }    }#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE    // hacky workaround for black window on OSX    for(const auto& win : mWindows)    {        SDL_SetWindowSize(win.native, win.render->getWidth(), win.render->getHeight());        win.render->windowMovedOrResized();    }#endif}

//-------------------------------------------------------------------------------------------------//void OSXCarbonWindow::swapBuffers( bool waitForVSync ){	if(!mIsFullScreen)	{		if(mAGLContext != aglGetCurrentContext())			aglSetCurrentContext(mAGLContext);					aglSwapBuffers(mAGLContext);	}	else		swapCGLBuffers();			if(mHasResized)	{		windowResized();		mHasResized = false;	}}