HiBSP

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#pragma once
#include "OGRE\Ogre.h"
#include "OIS\OIS.h"

enum CameraStyle
{
	CS_FREELOOK,
	CS_ORBIT,
	CS_MANAUAL
};

class cCameraManager
{
private:
	Ogre::Camera *mCamera;
	CameraStyle mStyle;
	Ogre::SceneNode *mTarget;
	bool mOrbiting;
	bool mZooming;
	Ogre::Real mTopSpeed;
	Ogre::Vector3 mVelocity;
	bool mGoingForward;
	bool mGoingBack;
	bool mGoingLeft;
	bool mGoingRight;
	bool mGoingUp;
	bool mGoingDown;
	bool mFastMove;

public:
	cCameraManager(Ogre::Camera *cam);

	void setCamera(Ogre::Camera *cam);
	Ogre::Camera *getCamera();

	void manualStop();

	void setStyle(CameraStyle style);
	CameraStyle getStyle();

	void setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist);

	void setTarget(Ogre::SceneNode *target);
	Ogre::SceneNode *getTarget();

	void setTopSpeed(Ogre::Real topSpeed);
	Ogre::Real getTopSpeed();

	bool frameRenderingQueued(const Ogre::FrameEvent& evt);

	// Processes key press for free-look style movement.
	void injectKeyDown(const OIS::KeyEvent &evt);
	void injectKeyUp(const OIS::KeyEvent &evt);

	// Processes mouse movement differently for each style.
	void injectMouseMove(const OIS::MouseEvent &evt);

	// Processes mouse presses. Only applies for orbit style.
	// Left button is for orbiting, and right button is for zooming.
	void injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
	void injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
};

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "Graphics.h"

cCameraManager::cCameraManager(Ogre::Camera *cam)
	:mCamera(0),
	mStyle(CameraStyle::CS_FREELOOK),
	mTarget(0),
	mOrbiting(false),
	mZooming(false),
	mTopSpeed(150),
	mVelocity(Ogre::Vector3::ZERO),
	mGoingForward(false),
	mGoingBack(false),
	mGoingLeft(false),
	mGoingRight(false),
	mGoingUp(false),
	mGoingDown(false),
	mFastMove(false)
{
	setCamera(cam);
	setStyle(CS_FREELOOK);
}

void cCameraManager::setCamera(Ogre::Camera *cam)
{
	mCamera = cam;
}

Ogre::Camera *cCameraManager::getCamera()
{
	return mCamera;
}

void cCameraManager::setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist)
{
	mCamera->setPosition(mTarget->_getDerivedPosition());
	mCamera->setOrientation(mTarget->_getDerivedOrientation());
	mCamera->yaw(yaw);
	mCamera->pitch(pitch);
	mCamera->moveRelative(Ogre::Vector3(0, 0, dist));
}

void cCameraManager::setTarget(Ogre::SceneNode *target)
{
	if(target != mTarget)
	{
		mTarget = target;
		if(target)
		{
			setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
			mCamera->setAutoTracking(true, mTarget);
		}
		else
			mCamera->setAutoTracking(false);
	}
}
	
Ogre::SceneNode *cCameraManager::getTarget()
{
	return mTarget;
}

void cCameraManager::manualStop()
{
	if(mStyle == CS_FREELOOK)
	{
		mVelocity = Ogre::Vector3::ZERO;
		mGoingForward = false;
		mGoingBack = false;
		mGoingLeft = false;
		mGoingRight = false;
		mGoingUp = false;
		mGoingDown = false;
	}
}

void cCameraManager::setStyle(CameraStyle style)
{
	if(mStyle != CS_ORBIT && style == CS_ORBIT)
	{
		setTarget(mTarget ? mTarget : mCamera->getSceneManager()->getRootSceneNode());
		mCamera->setFixedYawAxis(true);
		manualStop();
		setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
	}
	else if(mStyle != CS_FREELOOK && style == CS_FREELOOK)
	{
		mCamera->setAutoTracking(false);
		mCamera->setFixedYawAxis(true);
	}
	else if(mStyle != CS_MANAUAL && style == CS_MANAUAL)
	{
		mCamera->setAutoTracking(false);
		manualStop();
	}
}

CameraStyle cCameraManager::getStyle()
{
	return mStyle;
}

void cCameraManager::setTopSpeed(Ogre::Real topSpeed)
{
	mTopSpeed = topSpeed;
}

Ogre::Real cCameraManager::getTopSpeed()
{
	return mTopSpeed;
}

bool cCameraManager::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
	if (mStyle == CS_FREELOOK)
	{
		// build our acceleration vector based on keyboard input composite
		Ogre::Vector3 accel = Ogre::Vector3::ZERO;
		if (mGoingForward) accel += mCamera->getDirection();
		if (mGoingBack) accel -= mCamera->getDirection();
		if (mGoingRight) accel += mCamera->getRight();
		if (mGoingLeft) accel -= mCamera->getRight();
		if (mGoingUp) accel += mCamera->getUp();
		if (mGoingDown) accel -= mCamera->getUp();

		// if accelerating, try to reach top speed in a certain time
		Ogre::Real topSpeed = mFastMove ? mTopSpeed * 20 : mTopSpeed;
		if (accel.squaredLength() != 0)
		{
			accel.normalise();
			mVelocity += accel * topSpeed * evt.timeSinceLastFrame * 10;
		}
		// if not accelerating, try to stop in a certain time
		else mVelocity -= mVelocity * evt.timeSinceLastFrame * 10;

		Ogre::Real tooSmall = std::numeric_limits<Ogre::Real>::epsilon();

		// keep camera velocity below top speed and above epsilon
		if (mVelocity.squaredLength() > topSpeed * topSpeed)
		{
			mVelocity.normalise();
			mVelocity *= topSpeed;
		}
		else if (mVelocity.squaredLength() < tooSmall * tooSmall)
			mVelocity = Ogre::Vector3::ZERO;

		if (mVelocity != Ogre::Vector3::ZERO) mCamera->move(mVelocity * evt.timeSinceLastFrame);
	}

	return true;
}

void cCameraManager::injectKeyDown(const OIS::KeyEvent &evt)
{
	if(mStyle != CS_FREELOOK)
		return;
	if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = true;
	else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = true;
	else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = true;
	else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = true;
	else if (evt.key == OIS::KC_PGUP) mGoingUp = true;
	else if (evt.key == OIS::KC_PGDOWN) mGoingDown = true;
	else if (evt.key == OIS::KC_LSHIFT) mFastMove = true;
}

void cCameraManager::injectKeyUp(const OIS::KeyEvent &evt)
{
	if(mStyle != CS_FREELOOK)
		return;
	if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = false;
	else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = false;
	else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = false;
	else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = false;
	else if (evt.key == OIS::KC_PGUP) mGoingUp = false;
	else if (evt.key == OIS::KC_PGDOWN) mGoingDown = false;
	else if (evt.key == OIS::KC_LSHIFT) mFastMove = false;
}

void cCameraManager::injectMouseMove(const OIS::MouseEvent &evt)
{
	if (mStyle == CS_ORBIT)
	{
		Ogre::Real dist = (mCamera->getPosition() - mTarget->_getDerivedPosition()).length();

		if (mOrbiting)   // yaw around the target, and pitch locally
		{
			mCamera->setPosition(mTarget->_getDerivedPosition());

			mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.25f));
			mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.25f));

			mCamera->moveRelative(Ogre::Vector3(0, 0, dist));

			// don‘t let the camera go over the top or around the bottom of the target
		}
		else if (mZooming)  // move the camera toward or away from the target
		{
			// the further the camera is, the faster it moves
			mCamera->moveRelative(Ogre::Vector3(0, 0, evt.state.Y.rel * 0.004f * dist));
		}
		else if (evt.state.Z.rel != 0)  // move the camera toward or away from the target
		{
			// the further the camera is, the faster it moves
			mCamera->moveRelative(Ogre::Vector3(0, 0, -evt.state.Z.rel * 0.0008f * dist));
		}
	}
	else if (mStyle == CS_FREELOOK)
	{
		mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.15f));
		mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.15f));
	}
}

void cCameraManager::injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
{
	if (mStyle == CS_ORBIT)
	{
		if (id == OIS::MB_Left) mOrbiting = true;
		else if (id == OIS::MB_Right) mZooming = true;
	}
}

void cCameraManager::injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
{
	if (mStyle == CS_ORBIT)
	{
		if (id == OIS::MB_Left) mOrbiting = false;
		else if (id == OIS::MB_Right) mZooming = false;
	}
}

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#pragma once
#include "Graphics.h"
#include "OGRE\Ogre.h"
#include "OIS\OIS.h"
#include "MyGUI.h"
#include "MyGUI_OgrePlatform.h"

class cAppFrameListener : public Ogre::FrameListener, public OIS::KeyListener, public OIS::MouseListener
{
private:
	cCameraManager		*mCameraMgr;
    OIS::InputManager   *mInputMgr;
    OIS::Keyboard       *mKeyboard;
    OIS::Mouse          *mMouse;

public:
	cAppFrameListener(Ogre::RenderWindow *win, cCameraManager *camMgr);

    bool frameStarted(const Ogre::FrameEvent &evt);
    bool frameRenderingQueued(const Ogre::FrameEvent &evt);
    bool frameEnded(const Ogre::FrameEvent &evt);

	bool keyPressed(const OIS::KeyEvent &arg);
    bool keyReleased(const OIS::KeyEvent &arg);
 
    bool mouseMoved(const OIS::MouseEvent &arg);
    bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
};

class cApplication
{
protected:
    MyGUI::Gui          *mGUI;
    MyGUI::OgrePlatform *mPlatform;
 
    Ogre::Root          *mRoot;
    Ogre::RenderWindow  *mWindow;
    Ogre::SceneManager  *mSceneMgr;
	Ogre::Camera		*mCamera;
	cCameraManager		*mCameraMgr;

public:
    virtual void setupResources();
	virtual void setupView();
	virtual void loadResources();
    virtual void createScene() {}

    bool setup();
    void go();
};

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "System.h"

cAppFrameListener::cAppFrameListener(Ogre::RenderWindow *win, cCameraManager *camMgr)
{
	mCameraMgr = camMgr;
    OIS::ParamList parameters;
    unsigned int windowHandle = 0;
    std::ostringstream windowHandleString;
    win->getCustomAttribute("WINDOW", &windowHandle);
    windowHandleString << windowHandle;
    parameters.insert(std::make_pair("WINDOW", windowHandleString.str()));
	parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_FOREGROUND")));
	parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_NONEXCLUSIVE")));
    mInputMgr = OIS::InputManager::createInputSystem(parameters);
    mKeyboard = static_cast<OIS::Keyboard*>(mInputMgr->createInputObject(OIS::OISKeyboard, true));
    mKeyboard->setEventCallback(this);
    mMouse = static_cast<OIS::Mouse*>(mInputMgr->createInputObject(OIS::OISMouse, true));
    const OIS::MouseState &mouseState = mMouse->getMouseState();
    mouseState.width = win->getWidth();
    mouseState.height = win->getHeight();
    mMouse->setEventCallback(this);
}
 
bool cAppFrameListener::frameStarted(const Ogre::FrameEvent &evt)
{
    mKeyboard->capture();
    mMouse->capture();
    return true;
}
 
bool cAppFrameListener::frameRenderingQueued(const Ogre::FrameEvent &evt)
{
	mCameraMgr->frameRenderingQueued(evt);
    return true;
}
 
bool cAppFrameListener::frameEnded(const Ogre::FrameEvent &evt)
{
    return true;
}

bool cAppFrameListener::keyPressed(const OIS::KeyEvent &arg)
{
	if(arg.key == OIS::KC_ESCAPE)
		exit(0);
    MyGUI::InputManager::getInstance().injectKeyPress(
        MyGUI::KeyCode::Enum(arg.key), arg.text);
	mCameraMgr->injectKeyDown(arg);
    // ...
    return true;
}
 
bool cAppFrameListener::keyReleased(const OIS::KeyEvent &arg)
{
    MyGUI::InputManager::getInstance().injectKeyRelease(MyGUI::KeyCode::Enum(arg.key));
	mCameraMgr->injectKeyUp(arg);
    // ...
    return true;
}
 
bool cAppFrameListener::mouseMoved( const OIS::MouseEvent &arg )
{
    MyGUI::InputManager::getInstance().injectMouseMove(
        arg.state.X.abs, arg.state.Y.abs, arg.state.Z.abs);
	mCameraMgr->injectMouseMove(arg);
    // ...
    return true;
}
 
bool cAppFrameListener::mousePressed( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
    MyGUI::InputManager::getInstance().injectMousePress(
        arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
	mCameraMgr->injectMouseDown(arg, id);
    // ...
    return true;
}
 
bool cAppFrameListener::mouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
    MyGUI::InputManager::getInstance().injectMouseRelease(
        arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
	mCameraMgr->injectMouseUp(arg, id);
    // ...
    return true;
}

void cApplication::setupResources()
{
    Ogre::ConfigFile cf;
#if OGRE_DEBUG_MODE
    cf.load("resources_d.cfg");
#else
    cf.load("resources.cfg");
#endif
    Ogre::ConfigFile::SectionIterator secIter = cf.getSectionIterator();
    Ogre::String secName, typeName, archName;
    while(secIter.hasMoreElements())
    {
        secName = secIter.peekNextKey();
        Ogre::ConfigFile::SettingsMultiMap *settings = secIter.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);
        }
    }
}

void cApplication::setupView()
{
	// Create camera
    mCamera = mSceneMgr->createCamera("Camera");
    mCamera->setPosition(Ogre::Vector3(0, 0, 50));
    mCamera->lookAt(Ogre::Vector3(0, 0, -300));
    mCamera->setNearClipDistance(5);
	mCameraMgr = new cCameraManager(mCamera);
    // Create viewports
    Ogre::Viewport *vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
    mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth())/Ogre::Real(vp->getActualHeight()));
}

void cApplication::loadResources()
{
	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
}

bool cApplication::setup()
{
#ifndef OGRE_STATIC_LIB
#if OGRE_DEBUG_MODE
    mRoot = OGRE_NEW Ogre::Root("plugins_d.cfg");
#else
    mRoot = OGRE_NEW Ogre::Root("plugins.cfg");
#endif
#endif
    setupResources();
    if(!mRoot->showConfigDialog())
        return false;
    mWindow = mRoot->initialise(true);
	ShowCursor(false);
    // Choose scene manager
    mSceneMgr = mRoot->createSceneManager("BspSceneManager");
	setupView();
    // Load resources
    loadResources();
    // Create scene
    createScene();
    // Create frame listener
	mRoot->addFrameListener(new cAppFrameListener(mWindow, mCameraMgr));
    return true;
}
 
void cApplication::go()
{
    if(!setup())
        return;
    mRoot->startRendering();
}

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "System.h"
 
class cMyApplication : public cApplication
{
private:
	Ogre::String mArchive, mMap;

public:
	void setupResources()
	{
		cApplication::setupResources();
    Ogre::ConfigFile cf;
#if OGRE_DEBUG_MODE
    cf.load("quakemap_d.cfg");
#else
    cf.load("quakemap.cfg");
#endif
		mArchive = cf.getSetting("Archive");
		mMap = cf.getSetting("Map");
		Ogre::ResourceGroupManager::getSingleton().addResourceLocation(mArchive, "Zip",
			Ogre::ResourceGroupManager::getSingleton().getWorldResourceGroupName(), true);
	}

	void setupView()
	{
		cApplication::setupView();
		mCamera->setNearClipDistance(4);
		mCamera->setFarClipDistance(1000);
		Ogre::ViewPoint vp = mSceneMgr->getSuggestedViewpoint(true);
		mCamera->setFixedYawAxis(true, Ogre::Vector3::UNIT_Z);
		mCamera->pitch(Ogre::Degree(90));
		mCamera->setPosition(vp.position);
		mCamera->rotate(vp.orientation);
	}

	void loadResources()
	{
		cApplication::loadResources();
		Ogre::ResourceGroupManager &rgm = Ogre::ResourceGroupManager::getSingleton();
		rgm.linkWorldGeometryToResourceGroup(rgm.getWorldResourceGroupName(), mMap, mSceneMgr);
		rgm.loadResourceGroup(rgm.getWorldResourceGroupName(), false);
	}

    void createScene()
    {
        // MyGUI
        mPlatform = new MyGUI::OgrePlatform();
        mPlatform->initialise(mWindow, mSceneMgr);
        mGUI = new MyGUI::Gui();
        mGUI->initialise();
        /*MyGUI::ButtonPtr button = mGUI->createWidget<MyGUI::Button>
            ("Button", 10, 10, 300, 26, MyGUI::Align::Default, "Main");
        button->setCaption("exit");
        button->eventMouseButtonClick += MyGUI::newDelegate(this, &cMyApplication::notifyExitClick);
        */mSceneMgr->setAmbientLight(Ogre::ColourValue::White);
        //Ogre::Entity *ent = mSceneMgr->createEntity("Sinbad", "Sinbad.mesh");
        //mSceneMgr->getRootSceneNode()->attachObject(ent);
    }

    void notifyExitClick(MyGUI::WidgetPtr sender)
    {
        exit(0);
    }
};
 
int main()
{
    cMyApplication App;
    App.go();
    return 0;
}