C++ NameValuePairList类代码示例

	RenderWindow* Win32GLSupport::newWindow(const String &name, unsigned int width, 
		unsigned int height, bool fullScreen, const NameValuePairList *miscParams)
	{		
		Win32Window* window = OGRE_NEW Win32Window(*this);
		NameValuePairList newParams;
	
		if (miscParams != NULL)
		{	
			newParams = *miscParams;
			miscParams = &newParams;

			NameValuePairList::const_iterator monitorIndexIt = miscParams->find("monitorIndex");			
			HMONITOR hMonitor = NULL;
			int monitorIndex = -1;
		
			// If monitor index found, try to assign the monitor handle based on it.
			if (monitorIndexIt != miscParams->end())
			{				
				if (mMonitorInfoList.empty())		
					EnumDisplayMonitors(NULL, NULL, sCreateMonitorsInfoEnumProc, (LPARAM)&mMonitorInfoList);			

				monitorIndex = StringConverter::parseInt(monitorIndexIt->second);
				if (monitorIndex < (int)mMonitorInfoList.size())
				{						
					hMonitor = mMonitorInfoList[monitorIndex].hMonitor;					
				}
			}
			// If we didn't specified the monitor index, or if it didn't find it
			if (hMonitor == NULL)
			{
				POINT windowAnchorPoint;
		
				NameValuePairList::const_iterator opt;
				int left = -1;
				int top  = -1;

				if ((opt = newParams.find("left")) != newParams.end())
					left = StringConverter::parseInt(opt->second);

				if ((opt = newParams.find("top")) != newParams.end())
					top = StringConverter::parseInt(opt->second);

				// Fill in anchor point.
				windowAnchorPoint.x = left;
				windowAnchorPoint.y = top;


				// Get the nearest monitor to this window.
				hMonitor = MonitorFromPoint(windowAnchorPoint, MONITOR_DEFAULTTOPRIMARY);				
			}

			newParams["monitorHandle"] = StringConverter::toString((size_t)hMonitor);																
		}

		window->create(name, width, height, fullScreen, miscParams);

		if(!mInitialWindow)
			mInitialWindow = window;
		return window;
	}

void OgreRenderer::createWindow(const std::string &title, const WindowSettings& settings)
{
    assert(mRoot);
    mRoot->initialise(false);

    // create a hidden 1x1 background window to keep resources when recreating the secondary (real) window
    NameValuePairList params_;
    params_.insert(std::make_pair("title", title));
    params_.insert(std::make_pair("FSAA", "0"));
    params_.insert(std::make_pair("vsync", "false"));
    params_.insert(std::make_pair("hidden", "true"));
    Ogre::RenderWindow* hiddenWindow = mRoot->createRenderWindow("InactiveHidden", 1, 1, false, &params_);
    hiddenWindow->setActive(false);

    NameValuePairList params;
    params.insert(std::make_pair("title", title));
    params.insert(std::make_pair("FSAA", settings.fsaa));
    params.insert(std::make_pair("vsync", settings.vsync ? "true" : "false"));


    mWindow = mRoot->createRenderWindow(title, settings.window_x, settings.window_y, settings.fullscreen, &params);

    // create the semi-transparent black background texture used by the GUI.
    // has to be created in code with TU_DYNAMIC_WRITE_ONLY param
    // so that it can be modified at runtime.
    Ogre::TextureManager::getSingleton().createManual(
                    "transparent.png",
                    Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
                    Ogre::TEX_TYPE_2D,
                    1, 1,
                    0,
                    Ogre::PF_A8R8G8B8,
                    Ogre::TU_WRITE_ONLY);
}

void OgreRenderer::createWindow(const std::string &title, const WindowSettings& settings)
{
    assert(mRoot);
    mRoot->initialise(false);

    NameValuePairList params;
    params.insert(std::make_pair("title", title));
    params.insert(std::make_pair("FSAA", settings.fsaa));
    params.insert(std::make_pair("vsync", settings.vsync ? "true" : "false"));

    int pos_x = SDL_WINDOWPOS_CENTERED_DISPLAY(settings.screen),
        pos_y = SDL_WINDOWPOS_CENTERED_DISPLAY(settings.screen);

    if(settings.fullscreen)
    {
        pos_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(settings.screen);
        pos_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(settings.screen);
    }


    // Create an application window with the following settings:
    mSDLWindow = SDL_CreateWindow(
      "OpenMW",          // window title
      pos_x,             // initial x position
      pos_y,             // initial y position
      settings.window_x, // width, in pixels
      settings.window_y, // height, in pixels
      SDL_WINDOW_SHOWN
        | (settings.fullscreen ? SDL_WINDOW_FULLSCREEN : 0) | SDL_WINDOW_RESIZABLE
    );

    SFO::SDLWindowHelper helper(mSDLWindow, settings.window_x, settings.window_y, title, settings.fullscreen, params);
    if (settings.icon != "")
        helper.setWindowIcon(settings.icon);
    mWindow = helper.getWindow();


    // create the semi-transparent black background texture used by the GUI.
    // has to be created in code with TU_DYNAMIC_WRITE_ONLY param
    // so that it can be modified at runtime.
    Ogre::TextureManager::getSingleton().createManual(
                    "transparent.png",
                    Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
                    Ogre::TEX_TYPE_2D,
                    1, 1,
                    0,
                    Ogre::PF_A8R8G8B8,
                    Ogre::TU_WRITE_ONLY);

    mScene = mRoot->createSceneManager(ST_GENERIC);

    mFader = new Fader(mScene);

    mCamera = mScene->createCamera("cam");

    // Create one viewport, entire window
    mView = mWindow->addViewport(mCamera);
    // Alter the camera aspect ratio to match the viewport
    mCamera->setAspectRatio(Real(mView->getActualWidth()) / Real(mView->getActualHeight()));
}

 //-----------------------------------------------------------------------
 void StringInterface::setParameterList(const NameValuePairList& paramList)
 {
     NameValuePairList::const_iterator i, iend;
     iend = paramList.end();
     for (i = paramList.begin(); i != iend; ++i)
     {
         setParameter(i->first, i->second);
     }
 }

	void init_render_sys()
	{
		m_root = new Ogre::Root();
		m_root->setRenderSystem(m_root->getRenderSystemByName("OpenGL Rendering Subsystem"));
		m_root->initialise(false);
		m_frm = new wxFrame(0,-1,wxT(""));
		NameValuePairList a;
		a.insert(std::pair<String,String>("externalWindowHandle",StringConverter::toString( (size_t) m_frm->GetHandle() )));
		RenderSystem *sys = m_root->getRenderSystem();
		RenderWindow *m_ren = sys->_createRenderWindow(String("OgreRenderWindow_00"),1,1,false,&a);
		MaterialManager::getSingleton().initialise();
		m_frm->Show(false);
	}

void BaseApplication::run()
{
    // Construct Ogre::Root
    // We handle our stuff manually, so don't want to use any of the files
    mRoot = new Root(
        /* plugins.cfg file*/	"",
        /* config file */ 		"",
        /* log file */ 			""
    );

    PathManager::init ();

    // Set render system
    //!todo do not hardcode render system

#ifdef _DEBUG
    mRoot->loadPlugin(PathManager::ogre_plugin_dir + "/RenderSystem_GL");
    RenderSystem* rs = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
#else
    mRoot->loadPlugin(PathManager::ogre_plugin_dir + "/RenderSystem_Direct3D9");
    RenderSystem* rs = mRoot->getRenderSystemByName("Direct3D9 Rendering Subsystem");
#endif
    mRoot->setRenderSystem(rs);

    // Fire up Ogre::Root
    mRoot->initialise(false);

    // Create a hidden background window to keep resources
    NameValuePairList params;
    params.insert(std::make_pair("hidden", "true"));
    RenderWindow *wnd = mRoot->createRenderWindow("InactiveHidden", 1, 1, false, &params);
    wnd->setActive(false);

    Ogre::ResourceGroupManager::getSingleton ().addResourceLocation ("./", "FileSystem");
    Ogre::ResourceGroupManager::getSingleton ().initialiseAllResourceGroups ();

    // Create input system
    //mInputManager = new InputManager();

    // Create the application window
    mWindow = new Window();
    mWindow->mListener = static_cast<WindowEventListener*>(this);
    //mWindow->mInputManager = mInputManager;
    mWindow->mWidth = 800;
    mWindow->mHeight = 600;
    mWindow->mFullscreen = false;
    mWindow->create();

    createScene();
    mRoot->addFrameListener(this);
}

void OgreRenderer::recreateWindow(const std::string &title, const WindowSettings &settings)
{
    Ogre::ColourValue viewportBG = mView->getBackgroundColour();

    mRoot->destroyRenderTarget(mWindow);
    NameValuePairList params;
    params.insert(std::make_pair("title", title));
    params.insert(std::make_pair("FSAA", settings.fsaa));
    params.insert(std::make_pair("vsync", settings.vsync ? "true" : "false"));

    mWindow = mRoot->createRenderWindow(title, settings.window_x, settings.window_y, settings.fullscreen, &params);

    // Create one viewport, entire window
    mView = mWindow->addViewport(mCamera);
    mView->setBackgroundColour(viewportBG);

    adjustViewport();
}

void wxOgrePanel::createOgreRenderWindow()
{
	int width;
	int height;
	RenderSystem *sys = OgreInitializer::root()->getRenderSystem();
	NameValuePairList a;

	a.insert(std::pair<String,String>("externalWindowHandle",StringConverter::toString( (size_t) this->GetHandle() )));
	GetSize(&width, &height);
	m_unique_name = StringConverter::toString((size_t) GetId());
	m_RenderWindow = sys->_createRenderWindow(String("OgreRenderWindow")+m_unique_name,width,height,false,&a);
	m_Root = OgreInitializer::root();
	createSceneManager();
	createCamera();
	m_ViewPort = m_RenderWindow->addViewport(m_Camera); 
	m_ViewPort->setBackgroundColour(Ogre::ColourValue(1.0f, ((GetId()*23)&0xFF)/255.0f, 0.0f, 1.0f));
	update();
}

    void CommandMapper::buildCommandMap(KeyAndMouseCommandMap& cmdMap,
        const NameValuePairList& values)
    {
        for (NameValuePairList::const_iterator it = values.begin(); it != values.end(); it++)
        {
            // Split the path at the ',' character
            StringVector keys = Ogre::StringUtil::split(it->second, ",");

            for (size_t i = 0; i < keys.size(); i++)
            {
                int keycode = getKeyCode(keys[i]);
                cmdMap[keycode] = CeGuiString(it->first);
                LOG_MESSAGE(Logger::UI,
                    Ogre::String("Key ") + keys[i] + " ("
                    + StringConverter::toString(keycode)
                    + ") is assigned to command " + it->first);
            }
        }
    }

void Window::create()
{
	if (mWidth == 0 || mHeight == 0)
	{
		// use highest resolution (last in supported resolutions)
		std::pair<size_t, size_t> res = mSupportedFullscreenResolutions.back();
		mWidth = res.first; mHeight = res.second;
	}
	
	NameValuePairList settings;
	settings.insert(std::make_pair("title", mWindowTitle));
	settings.insert(std::make_pair("FSAA", StringConverter::toString(mFSAA)));
	settings.insert(std::make_pair("vsync", mVSync ? "true" : "false"));

	mRenderWindow = Root::getSingleton().createRenderWindow(mWindowTitle, mWidth, mHeight, mFullscreen, &settings);
	WindowEventUtilities::addWindowEventListener(mRenderWindow, mListener);
	
	size_t windowID; mRenderWindow->getCustomAttribute("WINDOW", &windowID);
	//mInputManager->create(windowID);
}

void BaseApplication::run()
{	
	// Construct Ogre::Root
	// We handle our stuff manually, so don't want to use any of the files
	mRoot = new Root(
		/* plugins.cfg file*/	"",
		/* config file */ 		"", 
		/* log file */ 			""
	);
	
	// Set render system
    mRoot->loadPlugin(OGRE_PLUGIN_DIR_REL + std::string("/RenderSystem_GL"));
	RenderSystem* rs = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
	mRoot->setRenderSystem(rs);
	
	// Fire up Ogre::Root
	mRoot->initialise(false);

	// Create the application window
	NameValuePairList settings;
	settings.insert(std::make_pair("title", "OGRE Application"));
	settings.insert(std::make_pair("FSAA", "0"));
    settings.insert(std::make_pair("vsync", "false"));

	mWindow = Root::getSingleton().createRenderWindow("OGRE Application", 800, 600, false, &settings);
	WindowEventUtilities::addWindowEventListener(mWindow, this);
	
	size_t windowID;
	mWindow->getCustomAttribute("WINDOW", &windowID);

	// Create input system
	OIS::ParamList pl;
	std::ostringstream windowHndStr;
	windowHndStr << windowID;
	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
    #ifdef OIS_LINUX_PLATFORM
	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")));
    #endif
	mOIS = OIS::InputManager::createInputSystem( pl );
	// Create devices
	if (mOIS->getNumberOfDevices(OIS::OISKeyboard) > 0)
	{
		mOISKeyboard = static_cast<OIS::Keyboard*>(mOIS->createInputObject(OIS::OISKeyboard, true));
		mOISKeyboard->setEventCallback(this);
	}
	if (mOIS->getNumberOfDevices(OIS::OISMouse) > 0)
	{
		mOISMouse = static_cast<OIS::Mouse*>(mOIS->createInputObject(OIS::OISMouse, true));
		mOISMouse->setEventCallback(this);
	}
		
	// Start the rendering loop
	createScene();
	mRoot->addFrameListener(this);
	mRoot->startRendering();
	
	// Shutdown
	if (mOISMouse)
		mOIS->destroyInputObject(mOISMouse);
	if (mOISKeyboard)
		mOIS->destroyInputObject(mOISKeyboard);
	mOIS->destroyInputSystem(mOIS);
	mRoot->removeFrameListener(this);
	delete mRoot;
}