Marc Zinnschlag
14 years ago
commit
3012822ea1
@ -0,0 +1,16 @@
|
||||
#ifndef GAME_MWMECHANICS_MOVEMENT_H
|
||||
#define GAME_MWMECHANICS_MOVEMENT_H
|
||||
|
||||
namespace MWMechanics
|
||||
{
|
||||
/// Desired movement for an actor
|
||||
struct Movement
|
||||
{
|
||||
signed char mLeftRight; // 1: wants to move left, -1: wants to move right
|
||||
signed char mForwardBackward; // 1:wants to move forward, -1: wants to move backward
|
||||
|
||||
Movement() : mLeftRight (0), mForwardBackward (0) {}
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,31 @@
|
||||
#ifndef GAME_MWWORLD_CELLFUNCTORS_H
|
||||
#define GAME_MWWORLD_CELLFUNCTORS_H
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#include "refdata.hpp"
|
||||
|
||||
namespace ESM
|
||||
{
|
||||
class CellRef;
|
||||
}
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
/// List all (Ogre-)handles.
|
||||
struct ListHandles
|
||||
{
|
||||
std::vector<std::string> mHandles;
|
||||
|
||||
bool operator() (ESM::CellRef& ref, RefData& data)
|
||||
{
|
||||
std::string handle = data.getHandle();
|
||||
if (!handle.empty())
|
||||
mHandles.push_back (handle);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,33 @@
|
||||
|
||||
#include "doingphysics.hpp"
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
int DoingPhysics::sCounter = 0;
|
||||
int DoingPhysics::sSuppress = 0;
|
||||
|
||||
DoingPhysics::DoingPhysics()
|
||||
{
|
||||
++sCounter;
|
||||
}
|
||||
|
||||
DoingPhysics::~DoingPhysics()
|
||||
{
|
||||
--sCounter;
|
||||
}
|
||||
|
||||
bool DoingPhysics::isDoingPhysics()
|
||||
{
|
||||
return sCounter>0 || sSuppress>0;
|
||||
}
|
||||
|
||||
SuppressDoingPhysics::SuppressDoingPhysics()
|
||||
{
|
||||
++DoingPhysics::sSuppress;
|
||||
}
|
||||
|
||||
SuppressDoingPhysics::~SuppressDoingPhysics()
|
||||
{
|
||||
--DoingPhysics::sSuppress;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,46 @@
|
||||
#ifndef GAME_MWWORLD_DOINGPHYSICS_H
|
||||
#define GAME_MWWORLD_DOINGPHYSICS_H
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
class SuppressDoingPhysics;
|
||||
|
||||
/// Scope guard for blocking physics updates during physics simulation.
|
||||
class DoingPhysics
|
||||
{
|
||||
static int sCounter;
|
||||
static int sSuppress;
|
||||
|
||||
private:
|
||||
|
||||
DoingPhysics (const DoingPhysics&);
|
||||
DoingPhysics& operator= (const DoingPhysics&);
|
||||
|
||||
public:
|
||||
|
||||
DoingPhysics();
|
||||
|
||||
~DoingPhysics();
|
||||
|
||||
static bool isDoingPhysics();
|
||||
|
||||
friend class SuppressDoingPhysics;
|
||||
};
|
||||
|
||||
/// Scope guard for temporarily lifting the block issues by DoingPhysics
|
||||
class SuppressDoingPhysics
|
||||
{
|
||||
private:
|
||||
|
||||
SuppressDoingPhysics (const SuppressDoingPhysics&);
|
||||
SuppressDoingPhysics& operator= (const SuppressDoingPhysics&);
|
||||
|
||||
public:
|
||||
|
||||
SuppressDoingPhysics();
|
||||
|
||||
~SuppressDoingPhysics();
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,76 @@
|
||||
# - Try to find the Bullet physics engine
|
||||
#
|
||||
# This module defines the following variables
|
||||
#
|
||||
# BULLET_FOUND - Was bullet found
|
||||
# BULLET_INCLUDE_DIRS - the Bullet include directories
|
||||
# BULLET_LIBRARIES - Link to this, by default it includes
|
||||
# all bullet components (Dynamics,
|
||||
# Collision, LinearMath, & SoftBody)
|
||||
#
|
||||
# This module accepts the following variables
|
||||
#
|
||||
# BULLET_ROOT - Can be set to bullet install path or Windows build path
|
||||
#
|
||||
|
||||
# Copyright (c) 2009, Philip Lowman <philip at yhbt.com>
|
||||
#
|
||||
# Redistribution AND use is allowed according to the terms of the New
|
||||
# BSD license.
|
||||
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
|
||||
|
||||
macro(_FIND_BULLET_LIBRARY _var)
|
||||
find_library(${_var}
|
||||
NAMES
|
||||
${ARGN}
|
||||
PATHS
|
||||
${BULLET_ROOT}
|
||||
${BULLET_ROOT}/out/release8/libs
|
||||
${BULLET_ROOT}/out/debug8/libs
|
||||
PATH_SUFFIXES lib
|
||||
)
|
||||
mark_as_advanced(${_var})
|
||||
endmacro()
|
||||
|
||||
macro(_BULLET_APPEND_LIBRARIES _list _release)
|
||||
set(_debug ${_release}_DEBUG)
|
||||
if(${_debug})
|
||||
set(${_list} ${${_list}} optimized ${${_release}} debug ${${_debug}})
|
||||
else()
|
||||
set(${_list} ${${_list}} ${${_release}})
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
find_path(BULLET_INCLUDE_DIR NAMES btBulletCollisionCommon.h
|
||||
PATHS
|
||||
${BULLET_ROOT}/include
|
||||
${BULLET_ROOT}/src
|
||||
PATH_SUFFIXES bullet
|
||||
)
|
||||
|
||||
# Find the libraries
|
||||
|
||||
_FIND_BULLET_LIBRARY(BULLET_DYNAMICS_LIBRARY BulletDynamics)
|
||||
_FIND_BULLET_LIBRARY(BULLET_DYNAMICS_LIBRARY_DEBUG BulletDynamics_d)
|
||||
_FIND_BULLET_LIBRARY(BULLET_COLLISION_LIBRARY BulletCollision)
|
||||
_FIND_BULLET_LIBRARY(BULLET_COLLISION_LIBRARY_DEBUG BulletCollision_d)
|
||||
_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY LinearMath BulletMath)
|
||||
_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY_DEBUG LinearMath_d BulletMath_d)
|
||||
_FIND_BULLET_LIBRARY(BULLET_SOFTBODY_LIBRARY BulletSoftBody)
|
||||
_FIND_BULLET_LIBRARY(BULLET_SOFTBODY_LIBRARY_DEBUG BulletSoftBody_d)
|
||||
|
||||
|
||||
# handle the QUIETLY and REQUIRED arguments and set BULLET_FOUND to TRUE if
|
||||
# all listed variables are TRUE
|
||||
include(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Bullet DEFAULT_MSG
|
||||
BULLET_DYNAMICS_LIBRARY BULLET_COLLISION_LIBRARY BULLET_MATH_LIBRARY
|
||||
BULLET_SOFTBODY_LIBRARY BULLET_INCLUDE_DIR)
|
||||
|
||||
set(BULLET_INCLUDE_DIRS ${BULLET_INCLUDE_DIR})
|
||||
if(BULLET_FOUND)
|
||||
_BULLET_APPEND_LIBRARIES(BULLET_LIBRARIES BULLET_DYNAMICS_LIBRARY)
|
||||
_BULLET_APPEND_LIBRARIES(BULLET_LIBRARIES BULLET_COLLISION_LIBRARY)
|
||||
_BULLET_APPEND_LIBRARIES(BULLET_LIBRARIES BULLET_MATH_LIBRARY)
|
||||
_BULLET_APPEND_LIBRARIES(BULLET_LIBRARIES BULLET_SOFTBODY_LIBRARY)
|
||||
endif()
|
||||
@ -0,0 +1,289 @@
|
||||
/*
|
||||
OpenMW - The completely unofficial reimplementation of Morrowind
|
||||
Copyright (C) 2008-2010 Nicolay Korslund
|
||||
Email: < korslund@gmail.com >
|
||||
WWW: http://openmw.sourceforge.net/
|
||||
|
||||
This file (ogre_nif_loader.cpp) is part of the OpenMW package.
|
||||
|
||||
OpenMW is distributed as free software: you can redistribute it
|
||||
and/or modify it under the terms of the GNU General Public License
|
||||
version 3, as published by the Free Software Foundation.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
version 3 along with this program. If not, see
|
||||
http://www.gnu.org/licenses/ .
|
||||
|
||||
*/
|
||||
|
||||
#include "bullet_nif_loader.hpp"
|
||||
#include <Ogre.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <libs/mangle/vfs/servers/ogre_vfs.hpp>
|
||||
#include "../nif/nif_file.hpp"
|
||||
#include "../nif/node.hpp"
|
||||
#include "../nif/data.hpp"
|
||||
#include "../nif/property.hpp"
|
||||
#include "../nif/controller.hpp"
|
||||
#include "../nif/extra.hpp"
|
||||
#include <libs/platform/strings.h>
|
||||
|
||||
#include <vector>
|
||||
#include <list>
|
||||
// For warning messages
|
||||
#include <iostream>
|
||||
|
||||
// float infinity
|
||||
#include <limits>
|
||||
|
||||
typedef unsigned char ubyte;
|
||||
|
||||
using namespace std;
|
||||
using namespace Ogre;
|
||||
using namespace Nif;
|
||||
using namespace Mangle::VFS;
|
||||
|
||||
|
||||
|
||||
//====================================================================================================
|
||||
Ogre::Matrix3 ManualBulletShapeLoader::getMatrix(Nif::Transformation* tr)
|
||||
{
|
||||
Ogre::Matrix3 rot(tr->rotation.v[0].array[0],tr->rotation.v[0].array[1],tr->rotation.v[0].array[2],
|
||||
tr->rotation.v[1].array[0],tr->rotation.v[1].array[1],tr->rotation.v[1].array[2],
|
||||
tr->rotation.v[2].array[0],tr->rotation.v[2].array[1],tr->rotation.v[2].array[2]);
|
||||
return rot;
|
||||
}
|
||||
Ogre::Vector3 ManualBulletShapeLoader::getVector(Nif::Transformation* tr)
|
||||
{
|
||||
Ogre::Vector3 vect3(tr->pos.array[0],tr->pos.array[1],tr->pos.array[2]);
|
||||
return vect3;
|
||||
}
|
||||
|
||||
btQuaternion ManualBulletShapeLoader::getbtQuat(Ogre::Matrix3 m)
|
||||
{
|
||||
Ogre::Quaternion oquat(m);
|
||||
btQuaternion quat;
|
||||
quat.setW(oquat.w);
|
||||
quat.setX(oquat.x);
|
||||
quat.setY(oquat.y);
|
||||
quat.setZ(oquat.z);
|
||||
return quat;
|
||||
}
|
||||
|
||||
btVector3 ManualBulletShapeLoader::getbtVector(Nif::Vector v)
|
||||
{
|
||||
btVector3 a(v.array[0],v.array[1],v.array[2]);
|
||||
return a;
|
||||
}
|
||||
|
||||
void ManualBulletShapeLoader::loadResource(Ogre::Resource *resource)
|
||||
{
|
||||
cShape = static_cast<BulletShape *>(resource);
|
||||
resourceName = cShape->getName();
|
||||
cShape->collide = false;
|
||||
|
||||
currentShape = new btCompoundShape();
|
||||
cShape->Shape = currentShape;
|
||||
|
||||
if (!vfs) vfs = new OgreVFS(resourceGroup);
|
||||
|
||||
if (!vfs->isFile(resourceName))
|
||||
{
|
||||
warn("File not found.");
|
||||
return;
|
||||
}
|
||||
|
||||
// Load the NIF. TODO: Wrap this in a try-catch block once we're out
|
||||
// of the early stages of development. Right now we WANT to catch
|
||||
// every error as early and intrusively as possible, as it's most
|
||||
// likely a sign of incomplete code rather than faulty input.
|
||||
Nif::NIFFile nif(vfs->open(resourceName), resourceName);
|
||||
|
||||
if (nif.numRecords() < 1)
|
||||
{
|
||||
warn("Found no records in NIF.");
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// The first record is assumed to be the root node
|
||||
Nif::Record *r = nif.getRecord(0);
|
||||
assert(r != NULL);
|
||||
|
||||
Nif::Node *node = dynamic_cast<Nif::Node*>(r);
|
||||
|
||||
if (node == NULL)
|
||||
{
|
||||
warn("First record in file was not a node, but a " +
|
||||
r->recName.toString() + ". Skipping file.");
|
||||
return;
|
||||
}
|
||||
|
||||
//do a first pass
|
||||
handleNode(node,0,Ogre::Matrix3::IDENTITY,Ogre::Vector3::ZERO,1,false,false);
|
||||
|
||||
//if collide = false, then it does a second pass which create a shape for raycasting.
|
||||
if(cShape->collide == false)
|
||||
{
|
||||
handleNode(node,0,Ogre::Matrix3::IDENTITY,Ogre::Vector3::ZERO,1,false,true);
|
||||
}
|
||||
}
|
||||
|
||||
void ManualBulletShapeLoader::handleNode(Nif::Node *node, int flags,
|
||||
Ogre::Matrix3 parentRot,Ogre::Vector3 parentPos,float parentScale,bool isCollisionNode,bool raycastingOnly)
|
||||
{
|
||||
// Accumulate the flags from all the child nodes. This works for all
|
||||
// the flags we currently use, at least.
|
||||
flags |= node->flags;
|
||||
|
||||
// Check for extra data
|
||||
Nif::Extra *e = node;
|
||||
while (!e->extra.empty())
|
||||
{
|
||||
// Get the next extra data in the list
|
||||
e = e->extra.getPtr();
|
||||
assert(e != NULL);
|
||||
|
||||
if (e->recType == Nif::RC_NiStringExtraData)
|
||||
{
|
||||
// String markers may contain important information
|
||||
// affecting the entire subtree of this node
|
||||
Nif::NiStringExtraData *sd = (Nif::NiStringExtraData*)e;
|
||||
|
||||
if (sd->string == "NCO" && !raycastingOnly)
|
||||
{
|
||||
// No collision. Use an internal flag setting to mark this.
|
||||
// We ignor this node!
|
||||
flags |= 0x800;
|
||||
return;
|
||||
}
|
||||
else if (sd->string == "MRK" && !raycastingOnly)
|
||||
// Marker objects. These are only visible in the
|
||||
// editor. Until and unless we add an editor component to
|
||||
// the engine, just skip this entire node.
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
//transfo of parents node + curent node
|
||||
Ogre::Matrix3 finalRot;
|
||||
Ogre::Vector3 finalPos;
|
||||
float finalScale;
|
||||
|
||||
Nif::Transformation &final = *((Nif::Transformation*)node->trafo);
|
||||
Ogre::Vector3 nodePos = getVector(&final);
|
||||
Ogre::Matrix3 nodeRot = getMatrix(&final);
|
||||
|
||||
finalPos = nodePos + parentPos;
|
||||
finalRot = parentRot*nodeRot;
|
||||
finalScale = final.scale*parentScale;
|
||||
|
||||
|
||||
// For NiNodes, loop through children
|
||||
if (node->recType == Nif::RC_NiNode)
|
||||
{
|
||||
Nif::NodeList &list = ((Nif::NiNode*)node)->children;
|
||||
int n = list.length();
|
||||
for (int i=0; i<n; i++)
|
||||
{
|
||||
if (list.has(i))
|
||||
{
|
||||
handleNode(&list[i], flags,finalRot,finalPos,finalScale,isCollisionNode,raycastingOnly);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (node->recType == Nif::RC_NiTriShape && isCollisionNode)
|
||||
{
|
||||
cShape->collide = true;
|
||||
handleNiTriShape(dynamic_cast<Nif::NiTriShape*>(node), flags,finalRot,finalPos,finalScale,raycastingOnly);
|
||||
}
|
||||
else if(node->recType == Nif::RC_RootCollisionNode)
|
||||
{
|
||||
Nif::NodeList &list = ((Nif::NiNode*)node)->children;
|
||||
int n = list.length();
|
||||
for (int i=0; i<n; i++)
|
||||
{
|
||||
if (list.has(i))
|
||||
handleNode(&list[i], flags,finalRot,finalPos,finalScale,true,raycastingOnly);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ManualBulletShapeLoader::handleNiTriShape(Nif::NiTriShape *shape, int flags,Ogre::Matrix3 parentRot,Ogre::Vector3 parentPos,float parentScale,
|
||||
bool raycastingOnly)
|
||||
{
|
||||
assert(shape != NULL);
|
||||
btCollisionShape* NodeShape;
|
||||
|
||||
// Interpret flags
|
||||
bool hidden = (flags & 0x01) != 0; // Not displayed
|
||||
bool collide = (flags & 0x02) != 0; // Use mesh for collision
|
||||
bool bbcollide = (flags & 0x04) != 0; // Use bounding box for collision
|
||||
|
||||
// If the object was marked "NCO" earlier, it shouldn't collide with
|
||||
// anything. So don't do anything.
|
||||
if (flags & 0x800 && !raycastingOnly)
|
||||
{
|
||||
collide = false;
|
||||
bbcollide = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!collide && !bbcollide && hidden && !raycastingOnly)
|
||||
// This mesh apparently isn't being used for anything, so don't
|
||||
// bother setting it up.
|
||||
return;
|
||||
|
||||
btTransform tr;
|
||||
tr.setRotation(getbtQuat(parentRot));
|
||||
tr.setOrigin(btVector3(parentPos.x,parentPos.y,parentPos.z));
|
||||
|
||||
// Bounding box collision isn't implemented, always use mesh for now.
|
||||
/*if (bbcollide)
|
||||
{
|
||||
return;
|
||||
std::cout << "bbcolide?";
|
||||
//TODO: check whether it's half box or not (is there a /2?)
|
||||
NodeShape = new btBoxShape(btVector3(shape->boundXYZ->array[0]/2.,shape->boundXYZ->array[1]/2.,shape->boundXYZ->array[2]/2.));
|
||||
std::cout << "bbcolide12121212121";
|
||||
currentShape->addChildShape(tr,NodeShape);
|
||||
std::cout << "aaaaaaaaaaaaa";
|
||||
return;
|
||||
collide = true;
|
||||
bbcollide = false;
|
||||
}*/
|
||||
|
||||
/* Do in-place transformation.the only needed transfo is the scale. (maybe not in fact)
|
||||
*/
|
||||
btTriangleMesh *mTriMesh = new btTriangleMesh();
|
||||
|
||||
Nif::NiTriShapeData *data = shape->data.getPtr();
|
||||
|
||||
float* vertices = (float*)data->vertices.ptr;
|
||||
unsigned short* triangles = (unsigned short*)data->triangles.ptr;
|
||||
|
||||
for(unsigned int i=0; i < data->triangles.length; i = i+3)
|
||||
{
|
||||
btVector3 b1(vertices[triangles[i+0]*3]*parentScale,vertices[triangles[i+0]*3+1]*parentScale,vertices[triangles[i+0]*3+2]*parentScale);
|
||||
btVector3 b2(vertices[triangles[i+1]*3]*parentScale,vertices[triangles[i+1]*3+1]*parentScale,vertices[triangles[i+1]*3+2]*parentScale);
|
||||
btVector3 b3(vertices[triangles[i+2]*3]*parentScale,vertices[triangles[i+2]*3+1]*parentScale,vertices[triangles[i+2]*3+2]*parentScale);
|
||||
mTriMesh->addTriangle(b1,b2,b3);
|
||||
}
|
||||
NodeShape = new btBvhTriangleMeshShape(mTriMesh,true);
|
||||
currentShape->addChildShape(tr,NodeShape);
|
||||
}
|
||||
|
||||
void ManualBulletShapeLoader::load(const std::string &name,const std::string &group)
|
||||
{
|
||||
// Check if the resource already exists
|
||||
Ogre::ResourcePtr ptr = BulletShapeManager::getSingleton().getByName(name, group);
|
||||
if (!ptr.isNull())
|
||||
return;
|
||||
BulletShapeManager::getSingleton().create(name,group,true,this);
|
||||
}
|
||||
@ -0,0 +1,124 @@
|
||||
/*
|
||||
OpenMW - The completely unofficial reimplementation of Morrowind
|
||||
Copyright (C) 2008-2010 Nicolay Korslund
|
||||
Email: < korslund@gmail.com >
|
||||
WWW: http://openmw.sourceforge.net/
|
||||
|
||||
This file (ogre_nif_loader.h) is part of the OpenMW package.
|
||||
|
||||
OpenMW is distributed as free software: you can redistribute it
|
||||
and/or modify it under the terms of the GNU General Public License
|
||||
version 3, as published by the Free Software Foundation.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
version 3 along with this program. If not, see
|
||||
http://www.gnu.org/licenses/ .
|
||||
|
||||
*/
|
||||
|
||||
#ifndef _BULLET_NIF_LOADER_H_
|
||||
#define _BULLET_NIF_LOADER_H_
|
||||
|
||||
#include <OgreMesh.h>
|
||||
#include <assert.h>
|
||||
#include <string>
|
||||
#include <BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h>
|
||||
#include <BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h>
|
||||
#include <btBulletDynamicsCommon.h>
|
||||
#include <btBulletCollisionCommon.h>
|
||||
#include "openengine/bullet/BulletShapeLoader.h"
|
||||
|
||||
#include <vector>
|
||||
#include <list>
|
||||
// For warning messages
|
||||
#include <iostream>
|
||||
|
||||
// float infinity
|
||||
#include <limits>
|
||||
|
||||
namespace Nif
|
||||
{
|
||||
class Node;
|
||||
class Transformation;
|
||||
class NiTriShape;
|
||||
class Vector;
|
||||
class Matrix;
|
||||
}
|
||||
|
||||
namespace Mangle
|
||||
{
|
||||
namespace VFS
|
||||
{
|
||||
class OgreVFS;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*Load bulletShape from NIF files.
|
||||
*/
|
||||
class ManualBulletShapeLoader : public BulletShapeLoader
|
||||
{
|
||||
public:
|
||||
|
||||
ManualBulletShapeLoader():resourceGroup("General"){vfs = 0;}
|
||||
virtual ~ManualBulletShapeLoader() {}
|
||||
|
||||
void warn(std::string msg)
|
||||
{
|
||||
std::cerr << "NIFLoader: Warn:" << msg << "\n";
|
||||
}
|
||||
|
||||
void fail(std::string msg)
|
||||
{
|
||||
std::cerr << "NIFLoader: Fail: "<< msg << std::endl;
|
||||
assert(1);
|
||||
}
|
||||
|
||||
/**
|
||||
*This function should not be called manualy. Use load instead. (this is called by the BulletShapeManager when you use load).
|
||||
*/
|
||||
void loadResource(Ogre::Resource *resource);
|
||||
|
||||
/**
|
||||
*This function load a new bulletShape from a NIF file into the BulletShapeManager.
|
||||
*When the file is loaded, you can then use BulletShapeManager::getByName() to retrive the bulletShape.
|
||||
*Warning: this function will just crash if the resourceGroup doesn't exist!
|
||||
*/
|
||||
void load(const std::string &name,const std::string &group);
|
||||
|
||||
private:
|
||||
Ogre::Matrix3 getMatrix(Nif::Transformation* tr);
|
||||
|
||||
Ogre::Vector3 getVector(Nif::Transformation* tr);
|
||||
|
||||
btQuaternion getbtQuat(Ogre::Matrix3 m);
|
||||
|
||||
btVector3 getbtVector(Nif::Vector v);
|
||||
|
||||
/**
|
||||
*Parse a node.
|
||||
*/
|
||||
void handleNode(Nif::Node *node, int flags,
|
||||
Ogre::Matrix3 parentRot,Ogre::Vector3 parentPos,float parentScale,bool isCollisionNode,bool raycastingOnly);
|
||||
|
||||
/**
|
||||
*convert a NiTriShape to a bullet trishape.
|
||||
*/
|
||||
void handleNiTriShape(Nif::NiTriShape *shape, int flags,Ogre::Matrix3 parentRot,Ogre::Vector3 parentPos,float parentScales,bool raycastingOnly);
|
||||
|
||||
Mangle::VFS::OgreVFS *vfs;
|
||||
|
||||
std::string resourceName;
|
||||
std::string resourceGroup;
|
||||
|
||||
BulletShape* cShape;//current shape
|
||||
btCompoundShape* currentShape;//the shape curently under construction
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,209 @@
|
||||
#include "bullet_nif_loader.hpp"
|
||||
#include "..\nifogre\ogre_nif_loader.hpp"
|
||||
#include "..\bsa\bsa_archive.hpp"
|
||||
#include "..\nifogre\ogre_nif_loader.hpp"
|
||||
#include <Ogre.h>
|
||||
#include <OIS.h>
|
||||
#include <btBulletDynamicsCommon.h>
|
||||
#include <btBulletCollisionCommon.h>
|
||||
#include "BtOgrePG.h"
|
||||
#include "BtOgreGP.h"
|
||||
#include "BtOgreExtras.h"
|
||||
|
||||
const char* mesh = "meshes\\x\\ex_hlaalu_b_24.nif";
|
||||
|
||||
class MyMotionState : public btMotionState {
|
||||
public:
|
||||
MyMotionState(const btTransform &initialpos, Ogre::SceneNode *node) {
|
||||
mVisibleobj = node;
|
||||
mPos1 = initialpos;
|
||||
node->setPosition(initialpos.getOrigin().x(),initialpos.getOrigin().y(),initialpos.getOrigin().z());
|
||||
}
|
||||
|
||||
virtual ~MyMotionState() {
|
||||
}
|
||||
|
||||
void setNode(Ogre::SceneNode *node) {
|
||||
mVisibleobj = node;
|
||||
}
|
||||
|
||||
virtual void getWorldTransform(btTransform &worldTrans) const {
|
||||
worldTrans = mPos1;
|
||||
}
|
||||
|
||||
virtual void setWorldTransform(const btTransform &worldTrans) {
|
||||
if(NULL == mVisibleobj) return; // silently return before we set a node
|
||||
btQuaternion rot = worldTrans.getRotation();
|
||||
mVisibleobj->setOrientation(rot.w(), rot.x(), rot.y(), rot.z());
|
||||
btVector3 pos = worldTrans.getOrigin();
|
||||
mVisibleobj->setPosition(pos.x(), pos.y(), pos.z());
|
||||
}
|
||||
|
||||
protected:
|
||||
Ogre::SceneNode *mVisibleobj;
|
||||
btTransform mPos1;
|
||||
};
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
try
|
||||
{
|
||||
//Ogre stuff
|
||||
|
||||
Ogre::Root* pRoot = new Ogre::Root();
|
||||
pRoot->showConfigDialog();
|
||||
|
||||
BulletShapeManager* manag = new BulletShapeManager();
|
||||
|
||||
Ogre::RenderWindow* win = pRoot->initialise(true,"test");
|
||||
Ogre::SceneManager* scmg = pRoot->createSceneManager(Ogre::ST_GENERIC,"MonGestionnaireDeScene");
|
||||
Ogre::Camera* pCamera = scmg->createCamera("test");
|
||||
Ogre::Viewport* pViewport = win->addViewport(pCamera);
|
||||
pCamera->setPosition(-50,0,0);
|
||||
pCamera->setFarClipDistance(10000);
|
||||
pCamera->setNearClipDistance(1.);
|
||||
pCamera->lookAt(0,0,0);
|
||||
//Ogre::ResourceGroupManager::getSingleton().addResourceLocation("C++/OgreSK/media/models","FileSystem","General");
|
||||
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("","FileSystem","General");
|
||||
/*Ogre::ResourceGroupManager::getSingleton().addResourceLocation("C++/OgreSK/media/materials/scripts","FileSystem","General");
|
||||
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("C++/OgreSK/media/materials/textures","FileSystem","General");
|
||||
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("C++/OgreSK/media/materials/programs","FileSystem","General");*/
|
||||
|
||||
|
||||
//OIS stuff
|
||||
OIS::ParamList pl;
|
||||
size_t windowHnd = 0;
|
||||
std::ostringstream windowHndStr;
|
||||
win->getCustomAttribute("WINDOW", &windowHnd);
|
||||
windowHndStr << windowHnd;
|
||||
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
|
||||
OIS::InputManager *pInputManager = OIS::InputManager::createInputSystem( pl );
|
||||
OIS::Mouse *pMouse = static_cast<OIS::Mouse*>(pInputManager->createInputObject(OIS::OISMouse, false));
|
||||
OIS::Keyboard* pKeyboard = static_cast<OIS::Keyboard*>(pInputManager->createInputObject(OIS::OISKeyboard, false));
|
||||
unsigned int width, height, depth;
|
||||
int top, left;
|
||||
win->getMetrics(width, height, depth, left, top);
|
||||
const OIS::MouseState &ms = pMouse->getMouseState();
|
||||
ms.width = width;
|
||||
ms.height = height;
|
||||
|
||||
|
||||
//Ressources stuff
|
||||
addBSA("Morrowind.bsa");
|
||||
//Ogre::ResourceGroupManager::getSingleton().createResourceGroup("general");
|
||||
|
||||
Ogre::ResourcePtr ptr = BulletShapeManager::getSingleton().getByName(mesh,"General");
|
||||
ManualBulletShapeLoader* ShapeLoader = new ManualBulletShapeLoader();
|
||||
|
||||
ShapeLoader->load(mesh,"General");
|
||||
//BulletShapeManager::getSingleton().unload(mesh);
|
||||
//ShapeLoader->load(mesh,"General");
|
||||
|
||||
NIFLoader::load(mesh);
|
||||
|
||||
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
|
||||
//BulletShapeManager::getSingleton().
|
||||
BulletShapePtr shape = BulletShapeManager::getSingleton().getByName(mesh,"General");
|
||||
BulletShapeManager::getSingleton().load(mesh,"General");
|
||||
BulletShapeManager::getSingleton().unload(mesh);
|
||||
BulletShapeManager::getSingleton().load(mesh,"General");
|
||||
BulletShapeManager::getSingleton().load(mesh,"General");
|
||||
//shape->load();
|
||||
//shape->unload();
|
||||
//shape->load();
|
||||
|
||||
//Bullet init
|
||||
btBroadphaseInterface* broadphase = new btDbvtBroadphase();
|
||||
|
||||
// Set up the collision configuration and dispatcher
|
||||
btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
|
||||
btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);
|
||||
|
||||
// The actual physics solver
|
||||
btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;
|
||||
|
||||
// The world.
|
||||
btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,collisionConfiguration);
|
||||
dynamicsWorld->setGravity(btVector3(0,-10,0));
|
||||
|
||||
|
||||
|
||||
//le sol?
|
||||
Ogre::SceneNode *node = scmg->getRootSceneNode()->createChildSceneNode("node");
|
||||
Ogre::Entity *ent = scmg->createEntity("Mesh1",mesh);
|
||||
node->attachObject(ent);
|
||||
MyMotionState* mst = new MyMotionState(btTransform::getIdentity(),node);
|
||||
|
||||
btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0,mst,shape->Shape,btVector3(0,0,0));
|
||||
btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI);
|
||||
dynamicsWorld->addRigidBody(groundRigidBody);
|
||||
|
||||
//une balle:
|
||||
Ogre::SceneNode *node2 = scmg->getRootSceneNode()->createChildSceneNode("node2");
|
||||
Ogre::Entity *ent2 = scmg->createEntity("Mesh2","ogrehead.mesh");
|
||||
node2->attachObject(ent2);
|
||||
node2->setPosition(0,500,0);
|
||||
btTransform iT;
|
||||
iT.setIdentity();
|
||||
iT.setOrigin(btVector3(0,5000,0));
|
||||
MyMotionState* mst2 = new MyMotionState(btTransform::getIdentity(),node2);
|
||||
|
||||
btSphereShape* sphereshape = new btSphereShape(10);
|
||||
btRigidBody::btRigidBodyConstructionInfo sphereCI(10,mst2,sphereshape,btVector3(0,0,0));
|
||||
btRigidBody* sphere = new btRigidBody(sphereCI);
|
||||
dynamicsWorld->addRigidBody(sphere);
|
||||
|
||||
|
||||
//btOgre!
|
||||
BtOgre::DebugDrawer* mDebugDrawer = new BtOgre::DebugDrawer(scmg->getRootSceneNode(), dynamicsWorld);
|
||||
dynamicsWorld->setDebugDrawer(mDebugDrawer);
|
||||
|
||||
Ogre::Timer timer;
|
||||
timer.reset();
|
||||
bool cont = true;
|
||||
while(cont)
|
||||
{
|
||||
if(timer.getMilliseconds()>30)
|
||||
{
|
||||
pMouse->capture();
|
||||
pKeyboard->capture();
|
||||
|
||||
Ogre::Vector3 a(0,0,0);
|
||||
|
||||
if(pKeyboard->isKeyDown(OIS::KC_UP))
|
||||
{
|
||||
a = a + Ogre::Vector3(0,0,-20);
|
||||
}
|
||||
if(pKeyboard->isKeyDown(OIS::KC_DOWN))
|
||||
{
|
||||
a = a + Ogre::Vector3(0,0,20);
|
||||
}
|
||||
if(pKeyboard->isKeyDown(OIS::KC_ESCAPE))
|
||||
{
|
||||
cont = false;
|
||||
}
|
||||
OIS::MouseState MS = pMouse->getMouseState();
|
||||
pCamera->yaw(-Ogre::Degree(MS.X.rel));
|
||||
pCamera->pitch(-Ogre::Degree(MS.Y.rel));
|
||||
pCamera->moveRelative(a);
|
||||
|
||||
pRoot->renderOneFrame();
|
||||
mDebugDrawer->step();
|
||||
timer.reset();
|
||||
dynamicsWorld->stepSimulation(0.03);
|
||||
}
|
||||
}
|
||||
std::cout << "cool";
|
||||
delete manag;
|
||||
delete pRoot;
|
||||
char a;
|
||||
std::cin >> a;
|
||||
}
|
||||
catch(Ogre::Exception& e)
|
||||
{
|
||||
std::cout << e.getFullDescription();
|
||||
char a;
|
||||
std::cin >> a;
|
||||
}
|
||||
}
|
||||
@ -1 +1 @@
|
||||
Subproject commit c60a48b397b2077e9a81fdbf3fe31c83276f6ffa
|
||||
Subproject commit 25b3cf935967beb5011419b6d3911fca05863743
|
||||
Loading…
Reference in New Issue