mirror of
https://github.com/TES3MP/openmw-tes3mp.git
synced 2025-01-16 10:49:57 +00:00
290 lines
12 KiB
C++
290 lines
12 KiB
C++
#include "physicssystem.hpp"
|
|
|
|
#include <iostream> // FIXME: debug only
|
|
|
|
#include <OgreRay.h>
|
|
#include <OgreCamera.h>
|
|
#include <OgreSceneManager.h>
|
|
#include <OgreManualObject.h> // FIXME: debug cursor position
|
|
#include <OgreEntity.h> // FIXME: visual highlight, clone
|
|
#include <OgreMaterialManager.h> // FIXME: visual highlight, material
|
|
#include <OgreHardwarePixelBuffer.h> // FIXME: visual highlight, texture
|
|
|
|
#include <openengine/bullet/physic.hpp>
|
|
#include <components/nifbullet/bulletnifloader.hpp>
|
|
#include "../../model/settings/usersettings.hpp"
|
|
#include "../render/elements.hpp"
|
|
|
|
namespace
|
|
{
|
|
void showHitPoint(Ogre::SceneManager *sceneMgr, std::string name, Ogre::Vector3 point)
|
|
{
|
|
sceneMgr->destroyManualObject("manual" + name);
|
|
Ogre::ManualObject* manual = sceneMgr->createManualObject("manual" + name);
|
|
manual->begin("BaseWhite", Ogre::RenderOperation::OT_LINE_LIST);
|
|
manual-> position(point.x, point.y, point.z-100);
|
|
manual-> position(point.x, point.y, point.z+100);
|
|
manual-> position(point.x, point.y-100, point.z);
|
|
manual-> position(point.x, point.y+100, point.z);
|
|
manual-> position(point.x-100, point.y, point.z);
|
|
manual-> position(point.x+100, point.y, point.z);
|
|
manual->end();
|
|
sceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(manual);
|
|
}
|
|
|
|
void removeHitPoint(Ogre::SceneManager *sceneMgr, std::string name)
|
|
{
|
|
sceneMgr->destroyManualObject("manual" + name);
|
|
}
|
|
}
|
|
|
|
namespace CSVWorld
|
|
{
|
|
PhysicsSystem *PhysicsSystem::mPhysicsSystemInstance = 0;
|
|
|
|
PhysicsSystem::PhysicsSystem(Ogre::SceneManager *sceneMgr) : mSceneMgr(sceneMgr)
|
|
{
|
|
assert(!mPhysicsSystemInstance);
|
|
mPhysicsSystemInstance = this;
|
|
|
|
// Create physics. shapeLoader is deleted by the physic engine
|
|
NifBullet::ManualBulletShapeLoader* shapeLoader = new NifBullet::ManualBulletShapeLoader();
|
|
mEngine = new OEngine::Physic::PhysicEngine(shapeLoader);
|
|
}
|
|
|
|
PhysicsSystem::~PhysicsSystem()
|
|
{
|
|
std::map<std::string, std::vector<std::string> >::iterator iter = mSelectedEntities.begin();
|
|
for(;iter != mSelectedEntities.end(); ++iter)
|
|
{
|
|
removeHitPoint(mSceneMgr, iter->first);
|
|
Ogre::SceneNode *scene = mSceneMgr->getSceneNode(iter->first);
|
|
scene->removeAndDestroyAllChildren();
|
|
mSceneMgr->destroySceneNode(iter->first);
|
|
}
|
|
|
|
delete mEngine;
|
|
}
|
|
|
|
PhysicsSystem *PhysicsSystem::instance()
|
|
{
|
|
assert(mPhysicsSystemInstance);
|
|
return mPhysicsSystemInstance;
|
|
}
|
|
|
|
void PhysicsSystem::addObject(const std::string &mesh,
|
|
const std::string &name,
|
|
const std::string &referenceId,
|
|
float scale,
|
|
const Ogre::Vector3 &position,
|
|
const Ogre::Quaternion &rotation,
|
|
bool placeable)
|
|
{
|
|
mRefToSceneNode[referenceId] = name;
|
|
|
|
mEngine->createAndAdjustRigidBody(mesh, referenceId, scale, position, rotation,
|
|
0, // scaledBoxTranslation
|
|
0, // boxRotation
|
|
true, // raycasting
|
|
placeable);
|
|
}
|
|
|
|
void PhysicsSystem::setSceneManager(Ogre::SceneManager *sceneMgr)
|
|
{
|
|
mSceneMgr = sceneMgr;
|
|
|
|
mEngine->setSceneManager(sceneMgr); // needed for toggleDebugRendering()
|
|
|
|
// material for visual cue on selected objects
|
|
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().getByName("DynamicTrans");
|
|
if(texture.isNull())
|
|
{
|
|
texture = Ogre::TextureManager::getSingleton().createManual(
|
|
"DynamicTrans", // name
|
|
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
|
Ogre::TEX_TYPE_2D, // type
|
|
8, 8, // width & height
|
|
0, // number of mipmaps
|
|
Ogre::PF_BYTE_BGRA, // pixel format
|
|
Ogre::TU_DEFAULT); // usage; should be TU_DYNAMIC_WRITE_ONLY_DISCARDABLE for
|
|
// textures updated very often (e.g. each frame)
|
|
|
|
Ogre::HardwarePixelBufferSharedPtr pixelBuffer = texture->getBuffer();
|
|
pixelBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL);
|
|
const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
|
|
|
|
uint8_t* pDest = static_cast<uint8_t*>(pixelBox.data);
|
|
|
|
// Fill in some pixel data. This will give a semi-transparent colour,
|
|
// but this is of course dependent on the chosen pixel format.
|
|
for (size_t j = 0; j < 8; j++)
|
|
{
|
|
for(size_t i = 0; i < 8; i++)
|
|
{
|
|
*pDest++ = 255; // B
|
|
*pDest++ = 255; // G
|
|
*pDest++ = 127; // R
|
|
*pDest++ = 63; // A
|
|
}
|
|
|
|
pDest += pixelBox.getRowSkip() * Ogre::PixelUtil::getNumElemBytes(pixelBox.format);
|
|
}
|
|
pixelBuffer->unlock();
|
|
}
|
|
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(
|
|
"TransMaterial");
|
|
if(material.isNull())
|
|
{
|
|
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(
|
|
"TransMaterial",
|
|
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true );
|
|
Ogre::Pass *pass = material->getTechnique( 0 )->getPass( 0 );
|
|
pass->setLightingEnabled( false );
|
|
pass->setDepthWriteEnabled( false );
|
|
pass->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
|
|
|
|
Ogre::TextureUnitState *tex = pass->createTextureUnitState("CustomState", 0);
|
|
tex->setTextureName("DynamicTrans");
|
|
tex->setTextureFiltering( Ogre::TFO_ANISOTROPIC );
|
|
material->load();
|
|
}
|
|
}
|
|
|
|
void PhysicsSystem::removeObject(const std::string& name)
|
|
{
|
|
mEngine->removeRigidBody(name);
|
|
mEngine->deleteRigidBody(name);
|
|
}
|
|
|
|
void PhysicsSystem::addHeightField(float* heights, int x, int y, float yoffset,
|
|
float triSize, float sqrtVerts)
|
|
{
|
|
mEngine->addHeightField(heights, x, y, yoffset, triSize, sqrtVerts);
|
|
}
|
|
|
|
void PhysicsSystem::removeHeightField(int x, int y)
|
|
{
|
|
mEngine->removeHeightField(x, y);
|
|
}
|
|
|
|
void PhysicsSystem::toggleDebugRendering()
|
|
{
|
|
CSMSettings::UserSettings &userSettings = CSMSettings::UserSettings::instance();
|
|
bool debug = userSettings.setting ("debug/mouse-picking", QString("false")) == "true" ? true : false;
|
|
if(!mSceneMgr || !debug)
|
|
return; // FIXME: add a warning message
|
|
|
|
mEngine->toggleDebugRendering();
|
|
mEngine->stepSimulation(0.0167); // DebugDrawer::step() not directly accessible
|
|
}
|
|
|
|
// FIXME: this method needs a cleanup/refactoring
|
|
std::pair<std::string, Ogre::Vector3> PhysicsSystem::castRay(float mouseX, float mouseY,
|
|
Ogre::Vector3* normal, std::string* hit, Ogre::Camera *camera)
|
|
{
|
|
CSMSettings::UserSettings &userSettings = CSMSettings::UserSettings::instance();
|
|
bool debug = userSettings.setting ("debug/mouse-picking", QString("false")) == "true" ? true : false;
|
|
if(!mSceneMgr || !camera || !camera->getViewport())
|
|
return std::make_pair("", Ogre::Vector3(0,0,0)); // FIXME: add a warning message
|
|
|
|
// using a really small value seems to mess up with the projections
|
|
float nearClipDistance = camera->getNearClipDistance();
|
|
camera->setNearClipDistance(10.0f); // arbitrary number
|
|
Ogre::Ray ray = camera->getCameraToViewportRay(mouseX, mouseY);
|
|
camera->setNearClipDistance(nearClipDistance);
|
|
|
|
Ogre::Vector3 from = ray.getOrigin();
|
|
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;
|
|
std::pair<std::string, float> result =
|
|
mEngine->rayTest(_from, _to, !ignoreObjects, ignoreHeightMap, &norm);
|
|
|
|
if(result.first == "")
|
|
return std::make_pair("", Ogre::Vector3(0,0,0));
|
|
|
|
std::string sceneNode = mRefToSceneNode[result.first];
|
|
if(!ignoreObjects && mSceneMgr->hasSceneNode(sceneNode))
|
|
{
|
|
//TODO: Try http://www.ogre3d.org/tikiwiki/Create+outline+around+a+character
|
|
Ogre::SceneNode *scene = mSceneMgr->getSceneNode(sceneNode);
|
|
std::map<std::string, std::vector<std::string> >::iterator iter =
|
|
mSelectedEntities.find(sceneNode);
|
|
if(debug && iter != mSelectedEntities.end()) // currently selected
|
|
{
|
|
std::vector<std::string> clonedEntities = mSelectedEntities[sceneNode];
|
|
while(!clonedEntities.empty())
|
|
{
|
|
if(mSceneMgr->hasEntity(clonedEntities.back()))
|
|
{
|
|
scene->detachObject(clonedEntities.back());
|
|
mSceneMgr->destroyEntity(clonedEntities.back());
|
|
}
|
|
clonedEntities.pop_back();
|
|
}
|
|
mSelectedEntities.erase(iter);
|
|
|
|
bool debugCursor = userSettings.setting (
|
|
"debug/mouse-position", QString("false")) == "true" ? true : false;
|
|
if(debugCursor) // FIXME: show cursor position for debugging
|
|
removeHitPoint(mSceneMgr, sceneNode);
|
|
}
|
|
else if(debug)
|
|
{
|
|
std::vector<std::string> clonedEntities;
|
|
Ogre::SceneNode::ObjectIterator iter = scene->getAttachedObjectIterator();
|
|
iter.begin();
|
|
while(iter.hasMoreElements())
|
|
{
|
|
Ogre::MovableObject * element = iter.getNext();
|
|
if(!element)
|
|
break;
|
|
|
|
if(element->getMovableType() != "Entity")
|
|
continue;
|
|
|
|
Ogre::Entity * entity = dynamic_cast<Ogre::Entity *>(element);
|
|
if(mSceneMgr->hasEntity(entity->getName()+"cover"))
|
|
{
|
|
// FIXME: this shouldn't really happen... but does :(
|
|
scene->detachObject(entity->getName()+"cover");
|
|
mSceneMgr->destroyEntity(entity->getName()+"cover");
|
|
}
|
|
Ogre::Entity * clone = entity->clone(entity->getName()+"cover");
|
|
|
|
Ogre::MaterialPtr mat =
|
|
Ogre::MaterialManager::getSingleton().getByName("TransMaterial");
|
|
if(!mat.isNull())
|
|
{
|
|
clone->setMaterial(mat);
|
|
scene->attachObject(clone);
|
|
clonedEntities.push_back(entity->getName()+"cover");
|
|
}
|
|
|
|
}
|
|
mSelectedEntities[sceneNode] = clonedEntities;
|
|
|
|
bool debugCursor = userSettings.setting (
|
|
"debug/mouse-position", QString("false")) == "true" ? true : false;
|
|
if(debugCursor) // FIXME: show cursor position for debugging
|
|
showHitPoint(mSceneMgr, sceneNode, ray.getPoint(farClipDist*result.second));
|
|
}
|
|
|
|
return std::make_pair(result.first, ray.getPoint(farClipDist*result.second));
|
|
}
|
|
else
|
|
{
|
|
// terrain
|
|
return std::make_pair(result.first, ray.getPoint(farClipDist*result.second));
|
|
}
|
|
}
|
|
}
|