Ogre立方体查询

Ogre立方体查询

ogre还有一个立方体查询。

//---------------------------------------------------------------------------
TutorialApplication::TutorialApplication(void):mRenderer(0),mSelectionBox(0),mSelecting(false)
{
}
//---------------------------------------------------------------------------
TutorialApplication::~TutorialApplication(void)
{
	CEGUI::OgreRenderer::destroySystem();
	if(mSelectionBox)
		delete mSelectionBox;
}

//---------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
    // Create your scene here :)
	setupCEGui();
	// 设置环境光
	mSceneMgr->setAmbientLight(Ogre::ColourValue(0.7,0.7,0.7));
	
	for (int i= 0; i<10;++i)
		for (int j = 0;j < 10; ++j)
		{
			Ogre::Entity* ent = mSceneMgr->createEntity("robot.mesh");
			Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
			node->setPosition(Ogre::Vector3(i*15,0,j*15));
			node->attachObject(ent);
			node->setScale(0.2,0.2,0.2);
		}
	
	mCamera->setPosition(-60,100,-60);
	mCamera->lookAt(60,0,60);
	
	mSelectionBox = new SelectionBox("SelectionBox");
	mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(mSelectionBox);

	CEGUI::WindowManager& wmgr = CEGUI::WindowManager::getSingleton();
 	CEGUI::Window* rootWin = wmgr.createWindow("DefaultWindow", "CEGUIDemo/Sheet");
 	CEGUI::System::getSingleton().getDefaultGUIContext().setRootWindow(rootWin);

	mVolQuery = mSceneMgr->createPlaneBoundedVolumeQuery(Ogre::PlaneBoundedVolumeList());
}

bool TutorialApplication::quit(const CEGUI::EventArgs &e)
{
	mShutDown = true;
	return true;
}

//---------------------------------------------------------------------------
bool TutorialApplication::mouseMoved(const OIS::MouseEvent &arg)
{
	//关联鼠标
	if(CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseMove(arg.state.X.rel, arg.state.Y.rel))
	{
		if(mSelecting)
		{
			CEGUI::MouseCursor* mouse = &CEGUI::System::getSingleton().getDefaultGUIContext().getMouseCursor();
			mStop.x = mouse->getPosition().d_x/(float)arg.state.width;
			mStop.y = mouse->getPosition().d_y/(float)arg.state.height;

			mSelectionBox->setCorners(mStart,mStop);
		}
		


		return true;
	}
	
	return BaseApplication::mouseMoved(arg);
}
//---------------------------------------------------------------------------
bool TutorialApplication::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
	CEGUI::GUIContext& context = CEGUI::System::getSingleton().getDefaultGUIContext();
	if(context.injectMouseButtonDown(convertButton(id)))
	{
		if (id == OIS::MB_Left)
		{
			CEGUI::MouseCursor* mouse = &context.getMouseCursor();
			mStart.x = mouse->getPosition().d_x/(float)arg.state.width;
			mStart.y = mouse->getPosition().d_y/(float)arg.state.height;

			mStop = mStart;

			mSelecting = true;

			mSelectionBox->clear();
			mSelectionBox->setVisible(true);

		}
		else if (id == OIS::MB_Right)
		{
			
		}
		return true;
	}
	

	//关联鼠标	
	return BaseApplication::mousePressed(arg,id);
}
//---------------------------------------------------------------------------
bool TutorialApplication::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
	if (id == OIS::MB_Left)
	{
		performSelection(mStart, mStop);
		mSelecting = false;
		mSelectionBox->setVisible(false);
	}
	
	//关联鼠标
	if(CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonUp(convertButton(id))) return true;
	return BaseApplication::mouseReleased(arg,id);
}

CEGUI::MouseButton TutorialApplication::convertButton(OIS::MouseButtonID buttonID)
{
	//关联鼠标按键
	switch (buttonID)
	{
	case OIS::MB_Left:
		return CEGUI::LeftButton;
		break;

	case OIS::MB_Right:
		return CEGUI::RightButton;
		break;

	case OIS::MB_Middle:
		return CEGUI::MiddleButton;
		break;

	default:
		return CEGUI::LeftButton;
		break;
	}
}

void TutorialApplication::setupCEGui()
{
	Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing CEGUI ***");

	mRenderer = &CEGUI::OgreRenderer::bootstrapSystem();

	//设置资源路径
	CEGUI::ImageManager::setImagesetDefaultResourceGroup("Imagesets");
	CEGUI::Font::setDefaultResourceGroup("Fonts");
	CEGUI::Scheme::setDefaultResourceGroup("Schemes");
	CEGUI::WidgetLookManager::setDefaultResourceGroup("LookNFeel");
	CEGUI::WindowManager::setDefaultResourceGroup("Layouts");


	//设置鼠标图片
	CEGUI::SchemeManager::getSingleton().createFromFile("TaharezLook.scheme");
	CEGUI::FontManager::getSingleton().createFromFile("DejaVuSans-10.font");
	CEGUI::System::getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow");

	CEGUI::GUIContext& context = CEGUI::System::getSingleton().getDefaultGUIContext();

	context.setDefaultFont("DejaVuSans-10");
	context.getMouseCursor().setDefaultImage("TaharezLook/MouseArrow");

	Ogre::LogManager::getSingletonPtr()->logMessage("Finished");
}

void TutorialApplication::destroyScene()
{

}

void TutorialApplication::swap(float& x,float& y)
{
	float temp = x;
	x = y;
	y = temp;
}

void TutorialApplication::performSelection(const Ogre::Vector2& first,const Ogre::Vector2& second)
{
	float left = first.x,right = second.x;
	float top = first.y, bottom = second.y;
	if(left > right)
		swap(left,right);
	if (top > bottom)
		swap(top,bottom);
	if ((right - left)*(bottom - top) < 0.0001)
		return;
	
	Ogre::Ray topLeft = mCamera->getCameraToViewportRay(left,top);
	Ogre::Ray topRight = mCamera->getCameraToViewportRay(right,top);
	Ogre::Ray bottomLeft = mCamera->getCameraToViewportRay(left,bottom);
	Ogre::Ray bottomRight = mCamera->getCameraToViewportRay(right,bottom);

	Ogre::Plane frontPlane, topPlane, leftPlane, bottomPlane, rightPlane;

	frontPlane = Ogre::Plane(
		topLeft.getOrigin(),
		topRight.getOrigin(),
		bottomRight.getOrigin());

	topPlane = Ogre::Plane(
		topLeft.getOrigin(),
		topLeft.getPoint(10),
		topRight.getPoint(10));

	leftPlane = Ogre::Plane(
		topLeft.getOrigin(),
		bottomLeft.getPoint(10),
		topLeft.getPoint(10));

	bottomPlane = Ogre::Plane(
		bottomLeft.getOrigin(),
		bottomRight.getPoint(10),
		bottomLeft.getPoint(10));

	rightPlane = Ogre::Plane(
		topRight.getOrigin(),
		topRight.getPoint(10),
		bottomRight.getPoint(10));

	Ogre::PlaneBoundedVolume vol;

	vol.planes.push_back(frontPlane);
	vol.planes.push_back(topPlane);
	vol.planes.push_back(leftPlane);
	vol.planes.push_back(bottomPlane);
	vol.planes.push_back(rightPlane);

	Ogre::PlaneBoundedVolumeList volList;
	volList.push_back(vol);

	
	mVolQuery->setVolumes(volList);
	Ogre::SceneQueryResult result = mVolQuery->execute();

	deselectObjects();

	Ogre::SceneQueryResultMovableList::iterator it;
	for (it = result.movables.begin(); it != result.movables.end(); ++it)
	{
		std::cout << (*it)->getParentSceneNode()->getPosition() << std::endl;;
		selectObject(*it);
	}
}

void TutorialApplication::deselectObjects()
{
	std::list<Ogre::MovableObject*>::iterator it;

	for (it = mSelected.begin(); it != mSelected.end(); ++it)
		(*it)->getParentSceneNode()->showBoundingBox(false);
}

void TutorialApplication::selectObject(Ogre::MovableObject* obj)
{
	obj->getParentSceneNode()->showBoundingBox(true);
	mSelected.push_back(obj);
}