Merge remote-tracking branch 'cc9cii/mouse-picking'
Marc Zinnschlag
10 years ago
commit
d48a2759f6
@ -0,0 +1,461 @@
|
||||
#include "mousestate.hpp"
|
||||
|
||||
#include <OgreSceneNode.h>
|
||||
#include <OgreSceneManager.h>
|
||||
#include <OgreEntity.h>
|
||||
#include <OgreMeshManager.h>
|
||||
|
||||
#include <QMouseEvent>
|
||||
#include <QElapsedTimer>
|
||||
#include <QObject>
|
||||
|
||||
#include "../../model/settings/usersettings.hpp"
|
||||
#include "../../model/world/commands.hpp"
|
||||
#include "../../model/world/idtable.hpp"
|
||||
#include "../../model/world/universalid.hpp"
|
||||
#include "../world/physicssystem.hpp"
|
||||
|
||||
#include "elements.hpp"
|
||||
#include "worldspacewidget.hpp"
|
||||
|
||||
namespace CSVRender
|
||||
{
|
||||
// mouse picking
|
||||
// FIXME: need to virtualise mouse buttons
|
||||
//
|
||||
// State machine:
|
||||
//
|
||||
// [default] mousePressEvent->check if the mouse is pointing at an object
|
||||
// if yes, create collision planes then go to [grab]
|
||||
// else check for terrain
|
||||
//
|
||||
// [grab] mouseReleaseEvent->if same button and new obj, go to [edit]
|
||||
// mouseMoveEvent->if same button, go to [drag]
|
||||
// other mouse events or buttons, go back to [default] (i.e. like 'cancel')
|
||||
//
|
||||
// [drag] mouseReleaseEvent->if same button, place the object at the new
|
||||
// location, update the document then go to [edit]
|
||||
// mouseMoveEvent->update position to the user based on ray to the collision
|
||||
// planes and render the object at the new location, but do not update
|
||||
// the document yet
|
||||
//
|
||||
// [edit] TODO, probably fine positional adjustments or rotations; clone/delete?
|
||||
//
|
||||
//
|
||||
// press press (obj)
|
||||
// [default] --------> [grab] <-------------------- [edit]
|
||||
// ^ (obj) | | ------> [drag] -----> ^
|
||||
// | | | move ^ | release |
|
||||
// | | | | | |
|
||||
// | | | +-+ |
|
||||
// | | | move |
|
||||
// +----------------+ +--------------------------+
|
||||
// release release
|
||||
// (same obj) (new obj)
|
||||
//
|
||||
//
|
||||
|
||||
MouseState::MouseState(WorldspaceWidget *parent)
|
||||
: mParent(parent), mPhysics(parent->getPhysics()), mSceneManager(parent->getSceneManager())
|
||||
, mCurrentObj(""), mMouseState(Mouse_Default), mOldPos(0,0), mMouseEventTimer(0), mPlane(0)
|
||||
, mGrabbedSceneNode(""), mOrigObjPos(Ogre::Vector3()), mOrigMousePos(Ogre::Vector3())
|
||||
, mCurrentMousePos(Ogre::Vector3()), mOffset(0.0f)
|
||||
, mColIndexPosX(0), mColIndexPosY(0), mColIndexPosZ(0), mIdTableModel(0)
|
||||
{
|
||||
const CSMWorld::RefCollection& references = mParent->mDocument.getData().getReferences();
|
||||
|
||||
mColIndexPosX = references.findColumnIndex(CSMWorld::Columns::ColumnId_PositionXPos);
|
||||
mColIndexPosY = references.findColumnIndex(CSMWorld::Columns::ColumnId_PositionYPos);
|
||||
mColIndexPosZ = references.findColumnIndex(CSMWorld::Columns::ColumnId_PositionZPos);
|
||||
|
||||
mIdTableModel = static_cast<CSMWorld::IdTable *>(
|
||||
mParent->mDocument.getData().getTableModel(CSMWorld::UniversalId::Type_Reference));
|
||||
|
||||
mMouseEventTimer = new QElapsedTimer();
|
||||
mMouseEventTimer->invalidate();
|
||||
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeRes = planeAxis();
|
||||
mPlane = new Ogre::Plane(planeRes.first, 0);
|
||||
Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().createPlane("mouse",
|
||||
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
*mPlane,
|
||||
300000,300000, // FIXME: use far clip dist?
|
||||
1,1, // segments
|
||||
true, // normals
|
||||
1, // numTexCoordSets
|
||||
1,1, // uTile, vTile
|
||||
planeRes.second // upVector
|
||||
);
|
||||
}
|
||||
|
||||
MouseState::~MouseState ()
|
||||
{
|
||||
delete mMouseEventTimer;
|
||||
delete mPlane;
|
||||
}
|
||||
|
||||
void MouseState::mouseMoveEvent (QMouseEvent *event)
|
||||
{
|
||||
switch(mMouseState)
|
||||
{
|
||||
case Mouse_Grab:
|
||||
{
|
||||
// check if min elapsed time to stop false detection of drag
|
||||
if(!mMouseEventTimer->isValid() || !mMouseEventTimer->hasExpired(100)) // ms
|
||||
break;
|
||||
|
||||
mMouseEventTimer->invalidate();
|
||||
mMouseState = Mouse_Drag;
|
||||
|
||||
/* FALL_THROUGH */
|
||||
}
|
||||
case Mouse_Drag:
|
||||
{
|
||||
if(event->pos() != mOldPos) // TODO: maybe don't update less than a quantum?
|
||||
{
|
||||
mOldPos = event->pos();
|
||||
|
||||
// ray test against the plane to provide feedback to the user the
|
||||
// relative movement of the object on the x-y plane
|
||||
std::pair<bool, Ogre::Vector3> planeResult = mousePositionOnPlane(event->pos(), *mPlane);
|
||||
if(planeResult.first)
|
||||
{
|
||||
if(mGrabbedSceneNode != "")
|
||||
{
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeRes = planeAxis();
|
||||
Ogre::Vector3 pos = mOrigObjPos + planeRes.first*mOffset;
|
||||
mSceneManager->getSceneNode(mGrabbedSceneNode)->setPosition(pos+planeResult.second-mOrigMousePos);
|
||||
mCurrentMousePos = planeResult.second;
|
||||
mPhysics->moveSceneNodes(mGrabbedSceneNode, pos+planeResult.second-mOrigMousePos);
|
||||
updateSceneWidgets();
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Mouse_Edit:
|
||||
case Mouse_Default:
|
||||
{
|
||||
break; // error event, ignore
|
||||
}
|
||||
/* NO_DEFAULT_CASE */
|
||||
}
|
||||
}
|
||||
|
||||
void MouseState::mousePressEvent (QMouseEvent *event)
|
||||
{
|
||||
switch(mMouseState)
|
||||
{
|
||||
case Mouse_Grab:
|
||||
case Mouse_Drag:
|
||||
{
|
||||
break;
|
||||
}
|
||||
case Mouse_Edit:
|
||||
case Mouse_Default:
|
||||
{
|
||||
if(event->buttons() & Qt::RightButton)
|
||||
{
|
||||
std::pair<std::string, Ogre::Vector3> result = objectUnderCursor(event->x(), event->y());
|
||||
if(result.first == "")
|
||||
break;
|
||||
|
||||
mGrabbedSceneNode = result.first;
|
||||
// ray test agaist the plane to get a starting position of the
|
||||
// mouse in relation to the object position
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeRes = planeAxis();
|
||||
mPlane->redefine(planeRes.first, result.second);
|
||||
std::pair<bool, Ogre::Vector3> planeResult = mousePositionOnPlane(event->pos(), *mPlane);
|
||||
if(planeResult.first)
|
||||
{
|
||||
mOrigMousePos = planeResult.second;
|
||||
mCurrentMousePos = planeResult.second;
|
||||
mOffset = 0.0f;
|
||||
}
|
||||
|
||||
mOrigObjPos = mSceneManager->getSceneNode(mGrabbedSceneNode)->getPosition();
|
||||
mMouseEventTimer->start();
|
||||
|
||||
mMouseState = Mouse_Grab;
|
||||
}
|
||||
break;
|
||||
}
|
||||
/* NO_DEFAULT_CASE */
|
||||
}
|
||||
}
|
||||
|
||||
void MouseState::mouseReleaseEvent (QMouseEvent *event)
|
||||
{
|
||||
switch(mMouseState)
|
||||
{
|
||||
case Mouse_Grab:
|
||||
{
|
||||
std::pair<std::string, Ogre::Vector3> result = objectUnderCursor(event->x(), event->y());
|
||||
if(result.first != "")
|
||||
{
|
||||
if(result.first == mCurrentObj)
|
||||
{
|
||||
// unselect object
|
||||
mMouseState = Mouse_Default;
|
||||
mCurrentObj = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
// select object
|
||||
mMouseState = Mouse_Edit;
|
||||
mCurrentObj = result.first;
|
||||
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Mouse_Drag:
|
||||
{
|
||||
// final placement
|
||||
std::pair<bool, Ogre::Vector3> planeResult = mousePositionOnPlane(event->pos(), *mPlane);
|
||||
if(planeResult.first)
|
||||
{
|
||||
if(mGrabbedSceneNode != "")
|
||||
{
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeRes = planeAxis();
|
||||
Ogre::Vector3 pos = mOrigObjPos+planeRes.first*mOffset+planeResult.second-mOrigMousePos;
|
||||
// use the saved scene node name since the physics model has not moved yet
|
||||
std::string referenceId = mPhysics->sceneNodeToRefId(mGrabbedSceneNode);
|
||||
|
||||
mParent->mDocument.getUndoStack().beginMacro (QObject::tr("Move Object"));
|
||||
mParent->mDocument.getUndoStack().push(new CSMWorld::ModifyCommand(*mIdTableModel,
|
||||
mIdTableModel->getModelIndex(referenceId, mColIndexPosX), pos.x));
|
||||
mParent->mDocument.getUndoStack().push(new CSMWorld::ModifyCommand(*mIdTableModel,
|
||||
mIdTableModel->getModelIndex(referenceId, mColIndexPosY), pos.y));
|
||||
mParent->mDocument.getUndoStack().push(new CSMWorld::ModifyCommand(*mIdTableModel,
|
||||
mIdTableModel->getModelIndex(referenceId, mColIndexPosZ), pos.z));
|
||||
mParent->mDocument.getUndoStack().endMacro();
|
||||
|
||||
// FIXME: highlight current object?
|
||||
//mCurrentObj = mGrabbedSceneNode; // FIXME: doesn't work?
|
||||
mCurrentObj = ""; // whether the object is selected
|
||||
|
||||
mMouseState = Mouse_Edit;
|
||||
|
||||
// reset states
|
||||
mCurrentMousePos = Ogre::Vector3(); // mouse pos to use in wheel event
|
||||
mOrigMousePos = Ogre::Vector3(); // starting pos of mouse in world space
|
||||
mOrigObjPos = Ogre::Vector3(); // starting pos of object in world space
|
||||
mGrabbedSceneNode = ""; // id of the object
|
||||
mOffset = 0.0f; // used for z-axis movement
|
||||
mOldPos = QPoint(0, 0); // to calculate relative movement of mouse
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Mouse_Edit:
|
||||
case Mouse_Default:
|
||||
{
|
||||
// probably terrain, check
|
||||
std::pair<std::string, Ogre::Vector3> result = terrainUnderCursor(event->x(), event->y());
|
||||
if(result.first != "")
|
||||
{
|
||||
// FIXME: terrain editing
|
||||
}
|
||||
break;
|
||||
}
|
||||
/* NO_DEFAULT_CASE */
|
||||
}
|
||||
mMouseEventTimer->invalidate();
|
||||
}
|
||||
|
||||
void MouseState::mouseDoubleClickEvent (QMouseEvent *event)
|
||||
{
|
||||
event->ignore();
|
||||
}
|
||||
|
||||
bool MouseState::wheelEvent (QWheelEvent *event)
|
||||
{
|
||||
switch(mMouseState)
|
||||
{
|
||||
case Mouse_Grab:
|
||||
mMouseState = Mouse_Drag;
|
||||
|
||||
/* FALL_THROUGH */
|
||||
case Mouse_Drag:
|
||||
{
|
||||
// move the object along the z axis during Mouse_Drag or Mouse_Grab
|
||||
if (event->delta())
|
||||
{
|
||||
// seems positive is up and negative is down
|
||||
mOffset += (event->delta()/1); // FIXME: arbitrary number, make config option?
|
||||
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeRes = planeAxis();
|
||||
Ogre::Vector3 pos = mOrigObjPos + planeRes.first*mOffset;
|
||||
mSceneManager->getSceneNode(mGrabbedSceneNode)->setPosition(pos+mCurrentMousePos-mOrigMousePos);
|
||||
mPhysics->moveSceneNodes(mGrabbedSceneNode, pos+mCurrentMousePos-mOrigMousePos);
|
||||
updateSceneWidgets();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Mouse_Edit:
|
||||
case Mouse_Default:
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* NO_DEFAULT_CASE */
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void MouseState::cancelDrag()
|
||||
{
|
||||
switch(mMouseState)
|
||||
{
|
||||
case Mouse_Grab:
|
||||
case Mouse_Drag:
|
||||
{
|
||||
// cancel operation & return the object to the original position
|
||||
mSceneManager->getSceneNode(mGrabbedSceneNode)->setPosition(mOrigObjPos);
|
||||
// update all SceneWidgets and their SceneManagers
|
||||
mPhysics->moveSceneNodes(mGrabbedSceneNode, mOrigObjPos);
|
||||
updateSceneWidgets();
|
||||
|
||||
// reset states
|
||||
mMouseState = Mouse_Default;
|
||||
mCurrentMousePos = Ogre::Vector3();
|
||||
mOrigMousePos = Ogre::Vector3();
|
||||
mOrigObjPos = Ogre::Vector3();
|
||||
mGrabbedSceneNode = "";
|
||||
mCurrentObj = "";
|
||||
mOldPos = QPoint(0, 0);
|
||||
mMouseEventTimer->invalidate();
|
||||
mOffset = 0.0f;
|
||||
|
||||
break;
|
||||
}
|
||||
case Mouse_Edit:
|
||||
case Mouse_Default:
|
||||
{
|
||||
break;
|
||||
}
|
||||
/* NO_DEFAULT_CASE */
|
||||
}
|
||||
}
|
||||
|
||||
//plane Z, upvector Y, mOffset z : x-y plane, wheel up/down
|
||||
//plane Y, upvector X, mOffset y : y-z plane, wheel left/right
|
||||
//plane X, upvector Y, mOffset x : x-z plane, wheel closer/further
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> MouseState::planeAxis()
|
||||
{
|
||||
bool screenCoord = true;
|
||||
Ogre::Vector3 dir = getCamera()->getDerivedDirection();
|
||||
|
||||
QString wheelDir = "Closer/Further";
|
||||
if(wheelDir == "Left/Right")
|
||||
{
|
||||
if(screenCoord)
|
||||
return std::make_pair(getCamera()->getDerivedRight(), getCamera()->getDerivedUp());
|
||||
else
|
||||
return std::make_pair(Ogre::Vector3::UNIT_Y, Ogre::Vector3::UNIT_Z);
|
||||
}
|
||||
else if(wheelDir == "Up/Down")
|
||||
{
|
||||
if(screenCoord)
|
||||
return std::make_pair(getCamera()->getDerivedUp(), Ogre::Vector3(-dir.x, -dir.y, -dir.z));
|
||||
else
|
||||
return std::make_pair(Ogre::Vector3::UNIT_Z, Ogre::Vector3::UNIT_X);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(screenCoord)
|
||||
return std::make_pair(Ogre::Vector3(-dir.x, -dir.y, -dir.z), getCamera()->getDerivedRight());
|
||||
else
|
||||
return std::make_pair(Ogre::Vector3::UNIT_X, Ogre::Vector3::UNIT_Y);
|
||||
}
|
||||
}
|
||||
|
||||
std::pair<bool, Ogre::Vector3> MouseState::mousePositionOnPlane(const QPoint &pos, const Ogre::Plane &plane)
|
||||
{
|
||||
// using a really small value seems to mess up with the projections
|
||||
float nearClipDistance = getCamera()->getNearClipDistance(); // save existing
|
||||
getCamera()->setNearClipDistance(10.0f); // arbitrary number
|
||||
Ogre::Ray mouseRay = getCamera()->getCameraToViewportRay(
|
||||
(float) pos.x() / getViewport()->getActualWidth(),
|
||||
(float) pos.y() / getViewport()->getActualHeight());
|
||||
getCamera()->setNearClipDistance(nearClipDistance); // restore
|
||||
std::pair<bool, float> planeResult = mouseRay.intersects(plane);
|
||||
|
||||
if(planeResult.first)
|
||||
return std::make_pair(true, mouseRay.getPoint(planeResult.second));
|
||||
else
|
||||
return std::make_pair(false, Ogre::Vector3()); // should only happen if the plane is too small
|
||||
}
|
||||
|
||||
std::pair<std::string, Ogre::Vector3> MouseState::terrainUnderCursor(const int mouseX, const int mouseY)
|
||||
{
|
||||
if(!getViewport())
|
||||
return std::make_pair("", Ogre::Vector3());
|
||||
|
||||
float x = (float) mouseX / getViewport()->getActualWidth();
|
||||
float y = (float) mouseY / getViewport()->getActualHeight();
|
||||
|
||||
std::pair<std::string, Ogre::Vector3> result = mPhysics->castRay(x, y, mSceneManager, getCamera());
|
||||
if(result.first != "")
|
||||
{
|
||||
// FIXME: is there a better way to distinguish terrain from objects?
|
||||
QString name = QString(result.first.c_str());
|
||||
if(name.contains(QRegExp("^HeightField")))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return std::make_pair("", Ogre::Vector3());
|
||||
}
|
||||
|
||||
std::pair<std::string, Ogre::Vector3> MouseState::objectUnderCursor(const int mouseX, const int mouseY)
|
||||
{
|
||||
if(!getViewport())
|
||||
return std::make_pair("", Ogre::Vector3());
|
||||
|
||||
float x = (float) mouseX / getViewport()->getActualWidth();
|
||||
float y = (float) mouseY / getViewport()->getActualHeight();
|
||||
|
||||
std::pair<std::string, Ogre::Vector3> result = mPhysics->castRay(x, y, mSceneManager, getCamera());
|
||||
if(result.first != "")
|
||||
{
|
||||
// NOTE: anything not terrain is assumed to be an object
|
||||
QString name = QString(result.first.c_str());
|
||||
if(!name.contains(QRegExp("^HeightField")))
|
||||
{
|
||||
uint32_t visibilityMask = getViewport()->getVisibilityMask();
|
||||
bool ignoreObjects = !(visibilityMask & (uint32_t)CSVRender::Element_Reference);
|
||||
|
||||
if(!ignoreObjects && mSceneManager->hasSceneNode(result.first))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return std::make_pair("", Ogre::Vector3());
|
||||
}
|
||||
|
||||
void MouseState::updateSceneWidgets()
|
||||
{
|
||||
std::map<Ogre::SceneManager*, CSVRender::SceneWidget *> sceneWidgets = mPhysics->sceneWidgets();
|
||||
|
||||
std::map<Ogre::SceneManager*, CSVRender::SceneWidget *>::iterator iter = sceneWidgets.begin();
|
||||
for(; iter != sceneWidgets.end(); ++iter)
|
||||
{
|
||||
(*iter).second->updateScene();
|
||||
}
|
||||
}
|
||||
|
||||
Ogre::Camera *MouseState::getCamera()
|
||||
{
|
||||
return mParent->getCamera();
|
||||
}
|
||||
|
||||
Ogre::Viewport *MouseState::getViewport()
|
||||
{
|
||||
return mParent->getCamera()->getViewport();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,90 @@
|
||||
#ifndef OPENCS_VIEW_MOUSESTATE_H
|
||||
#define OPENCS_VIEW_MOUSESTATE_H
|
||||
|
||||
#include <map>
|
||||
#include <QPoint>
|
||||
#include <OgreVector3.h>
|
||||
|
||||
class QElapsedTimer;
|
||||
class QMouseEvent;
|
||||
class QWheelEvent;
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
class Plane;
|
||||
class SceneManager;
|
||||
class Camera;
|
||||
class Viewport;
|
||||
}
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
class PhysicsSystem;
|
||||
}
|
||||
|
||||
namespace CSMWorld
|
||||
{
|
||||
class IdTable;
|
||||
}
|
||||
|
||||
namespace CSVRender
|
||||
{
|
||||
class WorldspaceWidget;
|
||||
|
||||
class MouseState
|
||||
{
|
||||
enum MouseStates
|
||||
{
|
||||
Mouse_Grab,
|
||||
Mouse_Drag,
|
||||
Mouse_Edit,
|
||||
Mouse_Default
|
||||
};
|
||||
MouseStates mMouseState;
|
||||
|
||||
WorldspaceWidget *mParent;
|
||||
CSVWorld::PhysicsSystem *mPhysics; // local copy
|
||||
Ogre::SceneManager *mSceneManager; // local copy
|
||||
|
||||
QPoint mOldPos;
|
||||
std::string mCurrentObj;
|
||||
std::string mGrabbedSceneNode;
|
||||
QElapsedTimer *mMouseEventTimer;
|
||||
Ogre::Plane *mPlane;
|
||||
Ogre::Vector3 mOrigObjPos;
|
||||
Ogre::Vector3 mOrigMousePos;
|
||||
Ogre::Vector3 mCurrentMousePos;
|
||||
float mOffset;
|
||||
|
||||
CSMWorld::IdTable *mIdTableModel;
|
||||
int mColIndexPosX;
|
||||
int mColIndexPosY;
|
||||
int mColIndexPosZ;
|
||||
|
||||
public:
|
||||
|
||||
MouseState(WorldspaceWidget *parent);
|
||||
~MouseState();
|
||||
|
||||
void mouseMoveEvent (QMouseEvent *event);
|
||||
void mousePressEvent (QMouseEvent *event);
|
||||
void mouseReleaseEvent (QMouseEvent *event);
|
||||
void mouseDoubleClickEvent (QMouseEvent *event);
|
||||
bool wheelEvent (QWheelEvent *event);
|
||||
|
||||
void cancelDrag();
|
||||
|
||||
private:
|
||||
|
||||
std::pair<bool, Ogre::Vector3> mousePositionOnPlane(const QPoint &pos, const Ogre::Plane &plane);
|
||||
std::pair<std::string, Ogre::Vector3> terrainUnderCursor(const int mouseX, const int mouseY);
|
||||
std::pair<std::string, Ogre::Vector3> objectUnderCursor(const int mouseX, const int mouseY);
|
||||
std::pair<Ogre::Vector3, Ogre::Vector3> planeAxis();
|
||||
void updateSceneWidgets();
|
||||
|
||||
Ogre::Camera *getCamera(); // friend access
|
||||
Ogre::Viewport *getViewport(); // friend access
|
||||
};
|
||||
}
|
||||
|
||||
#endif // OPENCS_VIEW_MOUSESTATE_H
|
||||
@ -0,0 +1,99 @@
|
||||
#include "physicsmanager.hpp"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../render/worldspacewidget.hpp"
|
||||
#include "physicssystem.hpp"
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
PhysicsManager *PhysicsManager::mPhysicsManagerInstance = 0;
|
||||
|
||||
PhysicsManager::PhysicsManager()
|
||||
{
|
||||
assert(!mPhysicsManagerInstance);
|
||||
mPhysicsManagerInstance = this;
|
||||
}
|
||||
|
||||
PhysicsManager::~PhysicsManager()
|
||||
{
|
||||
std::map<CSMDoc::Document *, CSVWorld::PhysicsSystem *>::iterator iter = mPhysics.begin();
|
||||
for(; iter != mPhysics.end(); ++iter)
|
||||
delete iter->second; // shouldn't be any left but just in case
|
||||
}
|
||||
|
||||
PhysicsManager *PhysicsManager::instance()
|
||||
{
|
||||
assert(mPhysicsManagerInstance);
|
||||
return mPhysicsManagerInstance;
|
||||
}
|
||||
|
||||
// create a physics instance per document, called from CSVDoc::View() to get Document*
|
||||
void PhysicsManager::setupPhysics(CSMDoc::Document *doc)
|
||||
{
|
||||
std::map<CSMDoc::Document *, std::list<CSVRender::SceneWidget *> >::iterator iter = mSceneWidgets.find(doc);
|
||||
if(iter == mSceneWidgets.end())
|
||||
{
|
||||
mSceneWidgets[doc] = std::list<CSVRender::SceneWidget *> (); // zero elements
|
||||
mPhysics[doc] = new PhysicsSystem();
|
||||
}
|
||||
}
|
||||
|
||||
// destroy physics, called from CSVDoc::ViewManager
|
||||
void PhysicsManager::removeDocument(CSMDoc::Document *doc)
|
||||
{
|
||||
std::map<CSMDoc::Document *, CSVWorld::PhysicsSystem *>::iterator iter = mPhysics.find(doc);
|
||||
if(iter != mPhysics.end())
|
||||
{
|
||||
delete iter->second;
|
||||
mPhysics.erase(iter);
|
||||
}
|
||||
|
||||
std::map<CSMDoc::Document *, std::list<CSVRender::SceneWidget *> >::iterator it = mSceneWidgets.find(doc);
|
||||
if(it != mSceneWidgets.end())
|
||||
{
|
||||
mSceneWidgets.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
// called from CSVRender::WorldspaceWidget() to get widgets' association with Document&
|
||||
PhysicsSystem *PhysicsManager::addSceneWidget(CSMDoc::Document &doc, CSVRender::WorldspaceWidget *widget)
|
||||
{
|
||||
CSVRender::SceneWidget *sceneWidget = static_cast<CSVRender::SceneWidget *>(widget);
|
||||
|
||||
std::map<CSMDoc::Document *, std::list<CSVRender::SceneWidget *> >::iterator iter = mSceneWidgets.begin();
|
||||
for(; iter != mSceneWidgets.end(); ++iter)
|
||||
{
|
||||
if((*iter).first == &doc)
|
||||
{
|
||||
(*iter).second.push_back(sceneWidget);
|
||||
return mPhysics[(*iter).first]; // TODO: consider using shared_ptr instead
|
||||
}
|
||||
}
|
||||
|
||||
throw std::runtime_error("No physics system found for the given document.");
|
||||
}
|
||||
|
||||
void PhysicsManager::removeSceneWidget(CSVRender::WorldspaceWidget *widget)
|
||||
{
|
||||
CSVRender::SceneWidget *sceneWidget = static_cast<CSVRender::SceneWidget *>(widget);
|
||||
|
||||
std::map<CSMDoc::Document *, std::list<CSVRender::SceneWidget *> >::iterator iter = mSceneWidgets.begin();
|
||||
for(; iter != mSceneWidgets.end(); ++iter)
|
||||
{
|
||||
std::list<CSVRender::SceneWidget *>::iterator itWidget = (*iter).second.begin();
|
||||
for(; itWidget != (*iter).second.end(); ++itWidget)
|
||||
{
|
||||
if((*itWidget) == sceneWidget)
|
||||
{
|
||||
(*iter).second.erase(itWidget);
|
||||
|
||||
//if((*iter).second.empty()) // last one for the document
|
||||
// NOTE: do not delete physics until the document itself is closed
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,54 @@
|
||||
#ifndef CSV_WORLD_PHYSICSMANAGER_H
|
||||
#define CSV_WORLD_PHYSICSMANAGER_H
|
||||
|
||||
#include <map>
|
||||
#include <list>
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
class SceneManager;
|
||||
}
|
||||
|
||||
namespace CSMDoc
|
||||
{
|
||||
class Document;
|
||||
}
|
||||
|
||||
namespace CSVRender
|
||||
{
|
||||
class WorldspaceWidget;
|
||||
class SceneWidget;
|
||||
}
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
class PhysicsSystem;
|
||||
}
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
class PhysicsManager
|
||||
{
|
||||
static PhysicsManager *mPhysicsManagerInstance;
|
||||
|
||||
std::map<CSMDoc::Document *, std::list<CSVRender::SceneWidget *> > mSceneWidgets;
|
||||
std::map<CSMDoc::Document *, CSVWorld::PhysicsSystem *> mPhysics;
|
||||
|
||||
public:
|
||||
|
||||
PhysicsManager();
|
||||
~PhysicsManager();
|
||||
|
||||
static PhysicsManager *instance();
|
||||
|
||||
void setupPhysics(CSMDoc::Document *);
|
||||
|
||||
PhysicsSystem *addSceneWidget(CSMDoc::Document &doc, CSVRender::WorldspaceWidget *widget);
|
||||
|
||||
void removeSceneWidget(CSVRender::WorldspaceWidget *widget);
|
||||
|
||||
void removeDocument(CSMDoc::Document *doc);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CSV_WORLD_PHYSICSMANAGER_H
|
||||
@ -0,0 +1,325 @@
|
||||
#include "physicssystem.hpp"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include <OgreRay.h>
|
||||
#include <OgreCamera.h>
|
||||
#include <OgreSceneManager.h>
|
||||
|
||||
#include <openengine/bullet/physic.hpp>
|
||||
#include <components/nifbullet/bulletnifloader.hpp>
|
||||
#include "../../model/settings/usersettings.hpp"
|
||||
#include "../render/elements.hpp"
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
PhysicsSystem::PhysicsSystem()
|
||||
{
|
||||
// Create physics. shapeLoader is deleted by the physic engine
|
||||
NifBullet::ManualBulletShapeLoader* shapeLoader = new NifBullet::ManualBulletShapeLoader();
|
||||
mEngine = new OEngine::Physic::PhysicEngine(shapeLoader);
|
||||
}
|
||||
|
||||
PhysicsSystem::~PhysicsSystem()
|
||||
{
|
||||
// FIXME: OEngine does not behave well when multiple instances are created
|
||||
// and deleted, sometimes resulting in crashes. Skip the deletion until the physics
|
||||
// code is moved out of OEngine.
|
||||
//delete mEngine;
|
||||
}
|
||||
|
||||
// looks up the scene manager based on the scene node name (inefficient)
|
||||
// NOTE: referenceId is assumed to be unique per document
|
||||
// NOTE: searching is done here rather than after rayTest, hence slower to load but
|
||||
// faster to find (guessing, not verified w/ perf test)
|
||||
void PhysicsSystem::addObject(const std::string &mesh,
|
||||
const std::string &sceneNodeName, const std::string &referenceId, float scale,
|
||||
const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, bool placeable)
|
||||
{
|
||||
Ogre::SceneManager *sceneManager = findSceneManager(sceneNodeName);
|
||||
if(sceneManager)
|
||||
{
|
||||
// update maps (NOTE: sometimes replaced)
|
||||
mSceneNodeToRefId[sceneNodeName] = referenceId;
|
||||
mSceneNodeToMesh[sceneNodeName] = mesh;
|
||||
mRefIdToSceneNode[referenceId][sceneManager] = sceneNodeName;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "Attempt to add an object without a corresponding SceneManager: "
|
||||
+ referenceId + " : " + sceneNodeName << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
// update physics, only one physics model per referenceId
|
||||
if(mEngine->getRigidBody(referenceId, true) == NULL)
|
||||
{
|
||||
mEngine->createAndAdjustRigidBody(mesh,
|
||||
referenceId, scale, position, rotation,
|
||||
0, // scaledBoxTranslation
|
||||
0, // boxRotation
|
||||
true, // raycasting
|
||||
placeable);
|
||||
}
|
||||
}
|
||||
|
||||
// normal delete (e.g closing a scene subview or ~Object())
|
||||
// the scene node is destroyed so the mappings should be removed
|
||||
//
|
||||
// TODO: should think about using some kind of reference counting within RigidBody
|
||||
void PhysicsSystem::removeObject(const std::string &sceneNodeName)
|
||||
{
|
||||
std::string referenceId = mSceneNodeToRefId[sceneNodeName];
|
||||
|
||||
if(referenceId != "")
|
||||
{
|
||||
mSceneNodeToRefId.erase(sceneNodeName);
|
||||
mSceneNodeToMesh.erase(sceneNodeName);
|
||||
|
||||
// find which SceneManager has this object
|
||||
Ogre::SceneManager *sceneManager = findSceneManager(sceneNodeName);
|
||||
if(!sceneManager)
|
||||
{
|
||||
std::cerr << "Attempt to remove an object without a corresponding SceneManager: "
|
||||
+ sceneNodeName << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
// illustration: erase the object "K" from the object map
|
||||
//
|
||||
// RidigBody SubView Ogre
|
||||
// --------------- -------------- -------------
|
||||
// ReferenceId "A" (SceneManager X SceneNode "J")
|
||||
// (SceneManager Y SceneNode "K") <--- erase
|
||||
// (SceneManager Z SceneNode "L")
|
||||
//
|
||||
// ReferenceId "B" (SceneManager X SceneNode "M")
|
||||
// (SceneManager Y SceneNode "N") <--- notice not deleted
|
||||
// (SceneManager Z SceneNode "O")
|
||||
std::map<std::string, std::map<Ogre::SceneManager *, std::string> >::iterator itRef =
|
||||
mRefIdToSceneNode.begin();
|
||||
for(; itRef != mRefIdToSceneNode.end(); ++itRef)
|
||||
{
|
||||
if((*itRef).second.find(sceneManager) != (*itRef).second.end())
|
||||
{
|
||||
(*itRef).second.erase(sceneManager);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// check whether the physics model should be deleted
|
||||
if(mRefIdToSceneNode.find(referenceId) == mRefIdToSceneNode.end())
|
||||
{
|
||||
mEngine->removeRigidBody(referenceId);
|
||||
mEngine->deleteRigidBody(referenceId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Object::clear() is called when reference data is changed. It clears all
|
||||
// contents of the SceneNode and removes the physics object
|
||||
//
|
||||
// A new physics object will be created and assigned to this sceneNodeName by
|
||||
// Object::update()
|
||||
void PhysicsSystem::removePhysicsObject(const std::string &sceneNodeName)
|
||||
{
|
||||
std::string referenceId = mSceneNodeToRefId[sceneNodeName];
|
||||
|
||||
if(referenceId != "")
|
||||
{
|
||||
mEngine->removeRigidBody(referenceId);
|
||||
mEngine->deleteRigidBody(referenceId);
|
||||
}
|
||||
}
|
||||
|
||||
void PhysicsSystem::replaceObject(const std::string &sceneNodeName, float scale,
|
||||
const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, bool placeable)
|
||||
{
|
||||
std::string referenceId = mSceneNodeToRefId[sceneNodeName];
|
||||
std::string mesh = mSceneNodeToMesh[sceneNodeName];
|
||||
|
||||
if(referenceId != "")
|
||||
{
|
||||
// delete the physics object
|
||||
mEngine->removeRigidBody(referenceId);
|
||||
mEngine->deleteRigidBody(referenceId);
|
||||
|
||||
// create a new physics object
|
||||
mEngine->createAndAdjustRigidBody(mesh, referenceId, scale, position, rotation,
|
||||
0, 0, true, placeable);
|
||||
|
||||
// update other scene managers if they have the referenceId
|
||||
// FIXME: rotation or scale not updated
|
||||
moveSceneNodeImpl(sceneNodeName, referenceId, position);
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: adjustRigidBody() seems to lose objects, work around by deleting and recreating objects
|
||||
void PhysicsSystem::moveObject(const std::string &sceneNodeName,
|
||||
const Ogre::Vector3 &position, const Ogre::Quaternion &rotation)
|
||||
{
|
||||
mEngine->adjustRigidBody(mEngine->getRigidBody(sceneNodeName, true /*raycasting*/),
|
||||
position, rotation);
|
||||
}
|
||||
|
||||
void PhysicsSystem::moveSceneNodeImpl(const std::string sceneNodeName,
|
||||
const std::string referenceId, const Ogre::Vector3 &position)
|
||||
{
|
||||
std::map<Ogre::SceneManager *, CSVRender::SceneWidget *>::const_iterator iter = mSceneWidgets.begin();
|
||||
for(; iter != mSceneWidgets.end(); ++iter)
|
||||
{
|
||||
std::string name = refIdToSceneNode(referenceId, (*iter).first);
|
||||
if(name != sceneNodeName && (*iter).first->hasSceneNode(name))
|
||||
{
|
||||
(*iter).first->getSceneNode(name)->setPosition(position);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PhysicsSystem::moveSceneNodes(const std::string sceneNodeName, const Ogre::Vector3 &position)
|
||||
{
|
||||
moveSceneNodeImpl(sceneNodeName, sceneNodeToRefId(sceneNodeName), position);
|
||||
}
|
||||
|
||||
void PhysicsSystem::addHeightField(Ogre::SceneManager *sceneManager,
|
||||
float* heights, int x, int y, float yoffset, float triSize, float sqrtVerts)
|
||||
{
|
||||
std::string name = "HeightField_"
|
||||
+ QString::number(x).toStdString() + "_" + QString::number(y).toStdString();
|
||||
|
||||
if(mTerrain.find(name) == mTerrain.end())
|
||||
mEngine->addHeightField(heights, x, y, yoffset, triSize, sqrtVerts);
|
||||
|
||||
mTerrain.insert(std::pair<std::string, Ogre::SceneManager *>(name, sceneManager));
|
||||
}
|
||||
|
||||
void PhysicsSystem::removeHeightField(Ogre::SceneManager *sceneManager, int x, int y)
|
||||
{
|
||||
std::string name = "HeightField_"
|
||||
+ QString::number(x).toStdString() + "_" + QString::number(y).toStdString();
|
||||
|
||||
if(mTerrain.count(name) == 1)
|
||||
mEngine->removeHeightField(x, y);
|
||||
|
||||
std::multimap<std::string, Ogre::SceneManager *>::iterator iter = mTerrain.begin();
|
||||
for(; iter != mTerrain.end(); ++iter)
|
||||
{
|
||||
if((*iter).second == sceneManager)
|
||||
{
|
||||
mTerrain.erase(iter);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sceneMgr: to lookup the scene node name from the object's referenceId
|
||||
// camera: primarily used to get the visibility mask for the viewport
|
||||
//
|
||||
// returns the found object's scene node name and its position in the world space
|
||||
//
|
||||
// WARNING: far clip distance is a global setting, if it changes in future
|
||||
// this method will need to be updated
|
||||
std::pair<std::string, Ogre::Vector3> PhysicsSystem::castRay(float mouseX,
|
||||
float mouseY, Ogre::SceneManager *sceneMgr, Ogre::Camera *camera)
|
||||
{
|
||||
// NOTE: there could be more than one camera for the scene manager
|
||||
// TODO: check whether camera belongs to sceneMgr
|
||||
if(!sceneMgr || !camera || !camera->getViewport())
|
||||
return std::make_pair("", Ogre::Vector3(0,0,0)); // FIXME: this should be an exception
|
||||
|
||||
// using a really small value seems to mess up with the projections
|
||||
float nearClipDistance = camera->getNearClipDistance(); // save existing
|
||||
camera->setNearClipDistance(10.0f); // arbitrary number
|
||||
Ogre::Ray ray = camera->getCameraToViewportRay(mouseX, mouseY);
|
||||
camera->setNearClipDistance(nearClipDistance); // restore
|
||||
|
||||
Ogre::Vector3 from = ray.getOrigin();
|
||||
CSMSettings::UserSettings &userSettings = CSMSettings::UserSettings::instance();
|
||||
float farClipDist = userSettings.setting("Scene/far clip distance", QString("300000")).toFloat();
|
||||
Ogre::Vector3 to = ray.getPoint(farClipDist);
|
||||
|
||||
btVector3 _from, _to;
|
||||
_from = btVector3(from.x, from.y, from.z);
|
||||
_to = btVector3(to.x, to.y, to.z);
|
||||
|
||||
uint32_t visibilityMask = camera->getViewport()->getVisibilityMask();
|
||||
bool ignoreHeightMap = !(visibilityMask & (uint32_t)CSVRender::Element_Terrain);
|
||||
bool ignoreObjects = !(visibilityMask & (uint32_t)CSVRender::Element_Reference);
|
||||
|
||||
Ogre::Vector3 norm; // not used
|
||||
std::pair<std::string, float> result =
|
||||
mEngine->rayTest(_from, _to, !ignoreObjects, ignoreHeightMap, &norm);
|
||||
|
||||
// result.first is the object's referenceId
|
||||
if(result.first == "")
|
||||
return std::make_pair("", Ogre::Vector3(0,0,0));
|
||||
else
|
||||
{
|
||||
std::string name = refIdToSceneNode(result.first, sceneMgr);
|
||||
if(name == "")
|
||||
name = result.first;
|
||||
else
|
||||
name = refIdToSceneNode(result.first, sceneMgr);
|
||||
|
||||
return std::make_pair(name, ray.getPoint(farClipDist*result.second));
|
||||
}
|
||||
}
|
||||
|
||||
std::string PhysicsSystem::refIdToSceneNode(std::string referenceId, Ogre::SceneManager *sceneMgr)
|
||||
{
|
||||
return mRefIdToSceneNode[referenceId][sceneMgr];
|
||||
}
|
||||
|
||||
std::string PhysicsSystem::sceneNodeToRefId(std::string sceneNodeName)
|
||||
{
|
||||
return mSceneNodeToRefId[sceneNodeName];
|
||||
}
|
||||
|
||||
void PhysicsSystem::addSceneManager(Ogre::SceneManager *sceneMgr, CSVRender::SceneWidget *sceneWidget)
|
||||
{
|
||||
mSceneWidgets[sceneMgr] = sceneWidget;
|
||||
}
|
||||
|
||||
std::map<Ogre::SceneManager*, CSVRender::SceneWidget *> PhysicsSystem::sceneWidgets()
|
||||
{
|
||||
return mSceneWidgets;
|
||||
}
|
||||
|
||||
void PhysicsSystem::removeSceneManager(Ogre::SceneManager *sceneMgr)
|
||||
{
|
||||
mSceneWidgets.erase(sceneMgr);
|
||||
}
|
||||
|
||||
Ogre::SceneManager *PhysicsSystem::findSceneManager(std::string sceneNodeName)
|
||||
{
|
||||
std::map<Ogre::SceneManager *, CSVRender::SceneWidget *>::const_iterator iter = mSceneWidgets.begin();
|
||||
for(; iter != mSceneWidgets.end(); ++iter)
|
||||
{
|
||||
if((*iter).first->hasSceneNode(sceneNodeName))
|
||||
{
|
||||
return (*iter).first;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void PhysicsSystem::toggleDebugRendering(Ogre::SceneManager *sceneMgr)
|
||||
{
|
||||
// FIXME: should check if sceneMgr is in the list
|
||||
if(!sceneMgr)
|
||||
return;
|
||||
|
||||
mEngine->setSceneManager(sceneMgr);
|
||||
|
||||
CSMSettings::UserSettings &userSettings = CSMSettings::UserSettings::instance();
|
||||
if(!(userSettings.setting("debug/mouse-picking", QString("false")) == "true" ? true : false))
|
||||
{
|
||||
std::cerr << "Turn on mouse-picking debug option to see collision shapes." << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
mEngine->toggleDebugRendering();
|
||||
mEngine->stepSimulation(0.0167); // DebugDrawer::step() not directly accessible
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,94 @@
|
||||
#ifndef CSV_WORLD_PHYSICSSYSTEM_H
|
||||
#define CSV_WORLD_PHYSICSSYSTEM_H
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
class Vector3;
|
||||
class Quaternion;
|
||||
class SceneManager;
|
||||
class Camera;
|
||||
}
|
||||
|
||||
namespace OEngine
|
||||
{
|
||||
namespace Physic
|
||||
{
|
||||
class PhysicEngine;
|
||||
}
|
||||
}
|
||||
|
||||
namespace CSVRender
|
||||
{
|
||||
class SceneWidget;
|
||||
}
|
||||
|
||||
namespace CSVWorld
|
||||
{
|
||||
class PhysicsSystem
|
||||
{
|
||||
std::map<std::string, std::string> mSceneNodeToRefId;
|
||||
std::map<std::string, std::map<Ogre::SceneManager *, std::string> > mRefIdToSceneNode;
|
||||
std::map<std::string, std::string> mSceneNodeToMesh;
|
||||
std::map<Ogre::SceneManager*, CSVRender::SceneWidget *> mSceneWidgets;
|
||||
OEngine::Physic::PhysicEngine* mEngine;
|
||||
std::multimap<std::string, Ogre::SceneManager *> mTerrain;
|
||||
|
||||
public:
|
||||
|
||||
PhysicsSystem();
|
||||
~PhysicsSystem();
|
||||
|
||||
void addSceneManager(Ogre::SceneManager *sceneMgr, CSVRender::SceneWidget * scene);
|
||||
|
||||
void removeSceneManager(Ogre::SceneManager *sceneMgr);
|
||||
|
||||
void addObject(const std::string &mesh,
|
||||
const std::string &sceneNodeName, const std::string &referenceId, float scale,
|
||||
const Ogre::Vector3 &position, const Ogre::Quaternion &rotation,
|
||||
bool placeable=false);
|
||||
|
||||
void removeObject(const std::string &sceneNodeName);
|
||||
void removePhysicsObject(const std::string &sceneNodeName);
|
||||
|
||||
void replaceObject(const std::string &sceneNodeName,
|
||||
float scale, const Ogre::Vector3 &position,
|
||||
const Ogre::Quaternion &rotation, bool placeable=false);
|
||||
|
||||
void moveObject(const std::string &sceneNodeName,
|
||||
const Ogre::Vector3 &position, const Ogre::Quaternion &rotation);
|
||||
|
||||
void moveSceneNodes(const std::string sceneNodeName, const Ogre::Vector3 &position);
|
||||
|
||||
void addHeightField(Ogre::SceneManager *sceneManager,
|
||||
float* heights, int x, int y, float yoffset, float triSize, float sqrtVerts);
|
||||
|
||||
void removeHeightField(Ogre::SceneManager *sceneManager, int x, int y);
|
||||
|
||||
void toggleDebugRendering(Ogre::SceneManager *sceneMgr);
|
||||
|
||||
// return the object's SceneNode name and position for the given SceneManager
|
||||
std::pair<std::string, Ogre::Vector3> castRay(float mouseX,
|
||||
float mouseY, Ogre::SceneManager *sceneMgr, Ogre::Camera *camera);
|
||||
|
||||
std::string sceneNodeToRefId(std::string sceneNodeName);
|
||||
|
||||
// for multi-scene manager per physics engine
|
||||
std::map<Ogre::SceneManager*, CSVRender::SceneWidget *> sceneWidgets();
|
||||
|
||||
private:
|
||||
|
||||
void moveSceneNodeImpl(const std::string sceneNodeName,
|
||||
const std::string referenceId, const Ogre::Vector3 &position);
|
||||
|
||||
void updateSelectionHighlight(std::string sceneNode, const Ogre::Vector3 &position);
|
||||
|
||||
std::string refIdToSceneNode(std::string referenceId, Ogre::SceneManager *sceneMgr);
|
||||
|
||||
Ogre::SceneManager *findSceneManager(std::string sceneNodeName);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CSV_WORLD_PHYSICSSYSTEM_H
|
||||
Loading…
Reference in New Issue