This page is related to a deprecated version of NxOgre, called BloodyMess. Some code from here may be adopted to newer versions with sufficient care and knowledge.   

 
Disclaimer: This is not an official NxOgre tutorial. However, it has been revised and edited by the creator of NxOgre and BloodyMess, betajaen.

 Help: For any problems you encounter while working on these tutorials, as well as for detailed questions and propositions, please visit the NxOgre OgreAddons-Forum.

Introduction

In the previous tutorials, we've just met Shapes that are rather simple and natively implemented in BloodyMess: Cubes, Spheres, Planes. Boring, right? Now we will lift it up and have a look at how to bring more complex physical shapes into our applications. Therefore, we have to make our first contacts with the NxOgre helper tool Flour as well as with the ResourceSystem of BloodyMess. But I can assure you: It's really simple (just as everything here)!

So what are we going to build this time? Well, I decided for some nice stairs and a barrel falling down on it. Nice, isn't it?

Falling...

...hitting the stairs...

...and sleeping.

You can find the complete code for this tutorial here.

The initial code

Create a C++ (BloodyMessTutorial5.cpp) file in your -IDE. We will create the necessary code to make Ogre run using the ExampleApplication and ExampleFrameListener classes provided by the Ogre Samples.

 
Please add the following code to that file, it should compile and run with no errors.

#include "ExampleApplication.h"
 
#include <NxOgre.h>
#include <NxOgreOGRE3D.h>
 
class BloodyMessTutorial7Listener : public ExampleFrameListener
{ 
public:
    BloodyMessTutorial7Listener(RenderWindow *win, Camera *cam) 
        : ExampleFrameListener(win, cam)
    {
        mTimeController = NxOgre::TimeController::getSingleton();
    }
 
    bool frameStarted(const FrameEvent& evt)
    {
        mTimeController->advance(evt.timeSinceLastFrame);
        return ExampleFrameListener::frameStarted(evt);
    }
 
protected:
    NxOgre::TimeController* mTimeController;
};
 
class BloodyMessTutorial7 : public ExampleApplication
{
protected:
    NxOgre::World*            mWorld;
    NxOgre::Scene*            mScene;
    NxOgre::TimeController*        mTimeController;
    OGRE3DRenderSystem*        mRenderSystem;
 
    void createScene()
    {
        // Set ambient light
        mSceneMgr->setAmbientLight(ColourValue(0.5f, 0.5f, 0.5f));
 
        // Create a light
        Light* l = mSceneMgr->createLight("MainLight");
        l->setPosition(20, 80, 50);
 
        // Position the camera
        mCamera->setPosition(0, 20, 80);
        mCamera->lookAt(0, 20, 0);
 
        // Create the world
        mWorld = NxOgre::World::createWorld();
 
        // Create scene description
        NxOgre::SceneDescription sceneDesc;
        sceneDesc.mGravity = NxOgre::Vec3(0, -9.8f, 0);
        sceneDesc.mName = "DemoScene";
 
        // Create scene
        mScene = mWorld->createScene(sceneDesc);
 
        // Set some physical scene values
        mScene->getMaterial(0)->setStaticFriction(0.5);
        mScene->getMaterial(0)->setDynamicFriction(0.5);
        mScene->getMaterial(0)->setRestitution(0.1);
 
        // Create render system
        mRenderSystem = new OGRE3DRenderSystem(mScene);
 
        //Create time controller
        mTimeController = NxOgre::TimeController::getSingleton();
 
        // Create floor plane (BloodyMess)
        mScene->createSceneGeometry(new NxOgre::PlaneGeometry(0, NxOgre::Vec3(0, 1, 0)), NxOgre::Matrix44(NxOgre::Matrix44::IDENTITY));
 
        // Create floor plane (Ogre)
        MovablePlane *plane = new MovablePlane("Plane");
        plane->d = 0;
        plane->normal = Vector3::UNIT_Y;
        Ogre::MeshManager::getSingleton().createPlane("PlaneMesh", 
            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
            *plane, 120, 120, 1, 1, true, 1, 3, 3, Vector3::UNIT_Z);
        Entity *planeEnt = mSceneMgr->createEntity("PlaneEntity", "PlaneMesh");
        planeEnt->setMaterialName("PlaneMat");
 
        Ogre::SceneNode* mPlaneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
        mPlaneNode->attachObject(planeEnt);
    }
 
    // Create a new frame listener
    void createFrameListener()
    {
        mFrameListener = new BloodyMessTutorial7Listener(mWindow, mCamera);
        mRoot->addFrameListener(mFrameListener);
    }
};
 
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
    INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
#else
    int main(int argc, char **argv)
#endif
    {
        // Create application object
        BloodyMessTutorial7 app;
 
        try {
            app.go();
        } catch(Exception& e) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
            MessageBoxA(NULL, e.getFullDescription().c_str(),
                "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
            std::cerr << "An exception has occurred: " << e.getFullDescription();
#endif
        }
 
        return 0;
    }
 
#ifdef __cplusplus
}
#endif

Convex and TriangleMeshes

So what are Convex and TriangleMeshes? With a TriangleMesh you can perfectly represent the physical shape of an OGRE mesh. The OGRE mesh and the TriangleMesh generated by Flour are totally equal in terms of shape, but in an file format that BloodyMess can deal with (and even PhysX can). The pitfall of TriangleMeshes are that they don't collide with others of their kind. No physics engine can do that with a good performance so far (maybe in ten years as betajaen told me...). And this is where Convexes enter the game: Convexes are the compromise between totally exact physical representation and performance. Convexes are limited to 256 vertices and represent some kind of a hull around the object used for collision detection. So it's not totally accurate, but good enough and fast.

Get it started

Flour? And where are milk and eggs...

Well, there is no milk or eggs involved, just Flour. It doesn't need more. Flour is a little tool for converting OGRE meshes into NxOgre formats for special meshes, skeletons and heightfields. In this tutorial we will solemnly work with convex and triangle meshes, skeletons and heightfields are covered in other tutorial parts.

Generate a .nxs file with Flour

First of all, we need to generate a file with the physical mesh data of our OGRE mesh to feed our application with. So we put an OGRE mesh in the same folder where our Flour.exe lies in (and don't let it be a simple cube, because this would really make no sense at all).

Note: Of course, your OGRE mesh can also be in another directory, but then you have to adjust the paths you tell Flour!

Now start Flour via the command line, by choosing Windows → Run → cmd and change the directory via the cd command till you are in the folder where your Flour.exe lies.

Note: On Microsoft Vista, you can just press Shift and left click on the folder Flour.exe lies in and choose Open Command Window Here to automatically open the command line, already set to this folder.

Now we have to tell Flour what to do using the following syntax:

flour convert in:infile, into:type, out:outfile

In my case, I had an OGRE mesh named Stairs.mesh and wanted to convert it into a triangle mesh. So my conversion looked like this:

flour convert in:Stairs.mesh, into:triangle, out:Stairs.nxs

 
If Flour spills out OK, you should have your backed mesh file which can now be used with BloodyMess.

I did the same procedure described with a second OGRE mesh, but converted it into a convex mesh:

flour convert in:Barrel.mesh, into:convex, out:Barrel.nxs

Open an archive with the ResourceSystem

BloodyMess brings along its own ResourceSystem to handle all kind of archives: Folders, zip-archives and even URLs. Before we can use any of the files created in the previous steps, we have to tell the ResourceSystem where to watch for these files. This is done via the function openArchive() that needs two parameters:

• an alias for the archive location that can later be used as a placeholder for the path
• a string representing an UniformResourceIdentifier that consists of a protocoll, followed by a : and the path to the archive, either absolut or relative

NxOgre::ResourceSystem::getSingleton()->openArchive("media", "file:media");

NxOgre::ResourceSystem::getSingleton()->openArchive("media", "file:D:/Projects/BloodyMess Tutorials/bin/release/media");

 
Note: If you want to use backslashes as your separator in the path, make sure you escape them with another backslash!

Load a mesh with the ResourceSystem

Now that BloodyMess knows our archive directory, we can finally load our mesh into our application.

NxOgre::Mesh* convexMesh = NxOgre::MeshManager::getSingleton()->load("media:Barrel.nxs");
NxOgre::Mesh* triangleMesh = NxOgre::MeshManager::getSingleton()->load("media:Stairs.nxs");

 
As you can see, we use our alias created while opening the archive to specify the location of our mesh files (Barrel.nxs and Stairs.nxs).

Now that we have our meshes loaded, we can use them for creating a Convex and a TriangleGeometry.

NxOgre::Convex* convex = new NxOgre::Convex(convexMesh);
NxOgre::TriangleGeometry* triangleGeometry = new NxOgre::TriangleGeometry(triangleMesh);

Make'em show up

The last step is to actually bring the stuff loaded into our scene, because so far you shouldn't see anything of them. So we are going to create a OGRE3DBody using our Convex and some SceneGeometry using our TriangleGeometry which we manually have to visualize with OGRE.

OGRE3DBody* convexBody = mRenderSystem->createBody(convex, NxOgre::Vec3(0, 30, 0), "Barrel.mesh");
convexBody->setGlobalOrientation(NxOgre::Matrix33(NxOgre::Real4(0, 45, 0, 45)));
 
mScene->createSceneGeometry(triangleGeometry, NxOgre::Matrix44(NxOgre::Vec3(0, 5, 0)));
 
Ogre::Entity* triangleEntity = mSceneMgr->createEntity("triangleEntity", "Stairs.mesh");
Ogre::SceneNode* triangleNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
triangleNode->attachObject(triangleEntity);
triangleNode->setPosition(Vector3(0, 5, 0));

 
The first two lines create our OGRE3DBody with the Convex as its shape and rotate it. The third line creates our SceneGeometry (first parameter is our TriangleGeometry and the second is a translation to move it up 5 units).

As the last step we create an Ogre::Entity and an Ogre::Scenenode to visualize our SceneGeometry.

Conclusion

After this tutorial, you should now be able to explore the great world of the complex physical shapes as well as spawning some SceneGeometry all over the place. Have fun!

Official Wiki and Website - Forum - Ogre Portal for NxOgre

Betajaen's Guide to creating a Bloody mess

---

Code snippets^{bloody mess}
General - Particles - Mesh Cooking - Cloths

Spacegaier's Tutorials^{bloody mess}
Setting up BloodyMess - First steps - Visual Debugger - Volumes & Triggers - Kinematics - Raycasting? - Resources and Meshes

Terrain / Heightfields? - Joints? - Cloth?