C++ RenderWindow::getHeight方法代码示例

	OgreWindow::OgreWindow(OgreModule& module, UiWindow& window, Ogre::RenderWindow& context)
		: RenderWindow(context.getWidth(), context.getHeight(), context.getName(), 0)
		, mModule(module)
		, mWindow(window)
		, mContext(context)
	{
		Ogre::WindowEventUtilities::addWindowEventListener(&mContext, this);

		mContext.getCustomAttribute("WINDOW", &mHandle);
	}

void ApplicationContextAndroid::_fireInputEventAndroid(AInputEvent* event, int wheel) {
    Event evt = {0};

    static TouchFingerEvent lastTouch = {0};

    if(wheel) {
        evt.type = MOUSEWHEEL;
        evt.wheel.y = wheel;
        _fireInputEvent(evt, 0);
        lastTouch.fingerId = -1; // prevent move-jump after pinch is over
        return;
    }

    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
        int32_t action = AMOTION_EVENT_ACTION_MASK & AMotionEvent_getAction(event);

        switch (action) {
        case AMOTION_EVENT_ACTION_DOWN:
            evt.type = FINGERDOWN;
            break;
        case AMOTION_EVENT_ACTION_UP:
            evt.type = FINGERUP;
            break;
        case AMOTION_EVENT_ACTION_MOVE:
            evt.type = FINGERMOTION;
            break;
        default:
            return;
        }

        Ogre::RenderWindow* win = getRenderWindow();

        evt.tfinger.fingerId = AMotionEvent_getPointerId(event, 0);
        evt.tfinger.x = AMotionEvent_getRawX(event, 0) / win->getWidth();
        evt.tfinger.y = AMotionEvent_getRawY(event, 0) / win->getHeight();

        if(evt.type == FINGERMOTION) {
            if(evt.tfinger.fingerId != lastTouch.fingerId)
                return; // wrong finger

            evt.tfinger.dx = evt.tfinger.x - lastTouch.x;
            evt.tfinger.dy = evt.tfinger.y - lastTouch.y;
        }

        lastTouch = evt.tfinger;
    } else {
        if(AKeyEvent_getKeyCode(event) != AKEYCODE_BACK)
            return;

        evt.type = AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN ? KEYDOWN : KEYUP;
        evt.key.keysym.sym = SDLK_ESCAPE;
    }

    _fireInputEvent(evt, 0);
}

VIEW_API void windowAttributes(size_t& handle, u32& width, u32& height)
{
	Ogre::Root* root = Ogre::Root::getSingletonPtr();
	
	if (! root)
		throw std::logic_error
			("View::windowAttributes: Ogre hasn't been initialized yet.");
	
	Ogre::RenderWindow* win = root->getAutoCreatedWindow();

	win->getCustomAttribute("WINDOW", &handle);
	height = win->getHeight();
	width = win->getWidth();
}

//----------------------------------------------------------------------------//
OIS::MultiTouchState& AndroidMultiTouch::getMultiTouchState (int i)
{
    while (i >= mStates.size())
    {
        Ogre::RenderWindow* pRenderWnd =
            static_cast<Ogre::RenderWindow*> (Ogre::Root::getSingleton().getRenderTarget ("OgreWindow"));
        if (pRenderWnd)
        {
            OIS::MultiTouchState state;
            state.width = pRenderWnd->getWidth();
            state.height = pRenderWnd->getHeight();
            mStates.push_back (state);
        }
    }
    return mStates[i];
}

//---------------------------------------------------------------------------------------------
void TEditorMapLogic::HandleFromGraphicEngine_Key( nsGraphicEngine::TKeyEvent* pKeyGE )
{
  bool fast = bool( pKeyGE->modifier & OIS::Keyboard::Shift );
  mPtrControlCamera->SetFast( fast );

  switch( pKeyGE->key )
  {
    case OIS::KC_W:
      mPtrControlCamera->SetMoveForward( pKeyGE->pressed );
      break;
    case OIS::KC_S:
      mPtrControlCamera->SetMoveBackward( pKeyGE->pressed );
      break;
    case OIS::KC_A:
      mPtrControlCamera->SetMoveLeft( pKeyGE->pressed );
      break;
    case OIS::KC_D:
      mPtrControlCamera->SetMoveRight( pKeyGE->pressed );
      break;
    case OIS::KC_Q:
      mPtrControlCamera->SetMoveDown( pKeyGE->pressed );
      break;
    case OIS::KC_E:
      mPtrControlCamera->SetMoveUp( pKeyGE->pressed );
      break;
    case OIS::KC_ESCAPE:
      Exit();
      break;
    case OIS::KC_RETURN:// experimental
    {
      if( OIS::Keyboard::Alt & pKeyGE->modifier )
      {
        Ogre::RenderWindow* pRW = mComp.pGraphicEngine->GetGE()->GetWindow();
        int width = pRW->getWidth();
        int height = pRW->getHeight();
        bool isFullScreen = pRW->isFullScreen();
        pRW->setFullscreen( !isFullScreen, width, height );
      }
    }
    break;
  }
}

void EC_SelectionBox::SetBoundingBox(QRect &view)
{
    if (world_.expired())
        return;
    OgreWorldPtr world = world_.lock();
    Renderer* renderer = world->GetRenderer();
    Ogre::RenderWindow *renderWindow = renderer->GetCurrentRenderWindow();
    float w= (float)renderWindow->getWidth();
    float h= (float)renderWindow->getHeight();
    float left = (float)(view.left()) / w, right = (float)(view.right()) / w;
    float top = (float)(view.top()) / h, bottom = (float)(view.bottom()) / h;
    
    if(left > right) { float tmp; tmp = left; left = right; right = tmp; }
    if(top > bottom) { float tmp; tmp = top; top = bottom; bottom = tmp; }
    // don't do selection box if too small
    if((right - left) * (bottom-top) < 0.0001) return;
    
    // correct coordinates for overlay
    left = left * 2 - 1;
    right = right * 2 - 1;
    top = 1 - top * 2;
    bottom = 1 - bottom * 2;
 
    selectionBox_->clear();
    selectionBox_->begin("BlueTransparent",Ogre::RenderOperation::OT_TRIANGLE_STRIP);
    selectionBox_->position(left, bottom, -1);
    selectionBox_->position(right, bottom, -1);
    selectionBox_->position(left, top, -1);
    selectionBox_->position(right, top, -1);
    selectionBox_->end();
    selectionBox_->begin("",Ogre::RenderOperation::OT_LINE_STRIP);
    selectionBox_->position(left, top, -1);
    selectionBox_->position(right, top, -1);
    selectionBox_->position(right, bottom, -1);
    selectionBox_->position(left, bottom, -1);
    selectionBox_->position(left, top, -1);
    selectionBox_->end();
    
    selectionBox_->setBoundingBox(Ogre::AxisAlignedBox::BOX_INFINITE);
}

    /**
     * This is the most basic "triangle" example, done as a Scene in Ogre.
     */
    Ogre::SceneManager* createTriangleScene() {
        Ogre::SceneManager* scene = mRoot->createSceneManager(Ogre::ST_GENERIC);

        // Configure camera (~ view & projection transforms, i.e. gluLookAt + glOrtho)
        Ogre::Camera* camera = scene->createCamera("MainCamera"); // We can use an arbitrary name here
        camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
        camera->setOrthoWindow(2, 2);              // ~ glOrtho(-1, 1, -1, 1)
        camera->setAspectRatio((float) mWindow->getWidth() / mWindow->getHeight());
        camera->setNearClipDistance(0.5);
        camera->setPosition(Ogre::Vector3(0,0,1)); // Move camera away from (0, 0, 0), otherwise the triangle at z=0 will be clipped

        // Now add some geometry to the scene
        Ogre::ManualObject* triangle = scene->createManualObject("Triangle");

        // ~ glBegin, glVertex, glEnd
        // "BaseWhiteNoLighting" is a built-in name for a basic non-lit material
        triangle->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST);
        triangle->position(0, 0.5, 0);            // ~ glVertex.
                                                  // Contrary to OpenGL we *first* must create the vertex
        triangle->colour(Ogre::ColourValue::Red); // .. and then provide its attributes such as color (~ glColor)
        triangle->position(-0.5, -0.5, 0);
        triangle->colour(Ogre::ColourValue::Green);
        triangle->position(0.5, -0.5, 0);
        triangle->colour(Ogre::ColourValue::Blue);
        triangle->end();

        // Add the created triangle object to the scene graph
        // For this we create a SceneNode object, which will combine information about
        // the object's geometry with its modeling transform
        // (see frameRenderingQueued to understand how to rotate the triangle by changing this transform)
        scene->getRootSceneNode()->createChildSceneNode("Triangle")->attachObject(triangle);

        // Exercise 1: Create new object, add vertices, attach the object to a new SceneNode
        // ...

        return scene;
    }

bool OISManager::init()
{
	OIS::ParamList pl;
	size_t windowHnd = 0;
	std::ostringstream windowHndStr;
	Ogre::RenderWindow* rw = OgreManager::getInstance().getRenderWindow();
	rw->getCustomAttribute("WINDOW", &windowHnd);
	windowHndStr << windowHnd;
	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));

	_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 ));
	const OIS::MouseState &ms = _mouse->getMouseState();
	ms.width = static_cast<int>(rw->getWidth());
	ms.height = static_cast<int>(rw->getHeight());

	_keyboard->setEventCallback(this);
	_mouse->setEventCallback(this);

	_L = ScriptManager::getInstance().getLuaVM();
	return true;
}