Stochastic Simulation and Lagrangian Dynamics: Setting Ogre3D as Graphic Environment

The last days I have been working on getting a Graphics Environment for my Toy Physics Engine.
Last December and January I had already fiddled around with excellent engines Ogre (www.ogre3d.org) and Bullet (http://bulletphysics.org/wordpress/), trying to put them to work together.I have a post from february where some simulations on youtube can be seen and some preliminary introductions are made.

However, now I am starting to understand things, and whenever I have the drive to test them always encounter the problem on how visualize them.

So, I came across with Blender (www.blender.org), another fantastic tool, and got surprised to find their Google Summer of Code mentorship for 2010 (http://wiki.blender.org/index.php/Dev:Ref/GSoC/2010/Info).
I have applied for it. Deadline was 9th April, which meant preparing everything in a hurry and some embarrasing trouble with their wiki page (I have already apologised in their bf-commiters mailing list...ooops).
Here is my proposal for such an important event: (http://wiki.blender.org/index.php/User:Ndujar).
Hopefully they find it interesting and contact me to complete it!

In the meantime, I have prepared a short and basic Ogre framework to begin doing some tests.
It is composed of a few files and classes integrating Ogre.

I generated it basically copying, cutting and pasting from the very good tutorials available at the Ogre web page (http://www.ogre3d.org/wiki/index.php/Ogre_Tutorials).

It goes as follows:

The first step is to intall and cofigure Ogre in your computer. This is the best tutorial I found: http://ubuntuforums.org/archive/index.php/t-1148570.html.

Then, using whatever IDE of your taste (I am on EasyEclipse), just get the following files to compile.

The core of the application is the BaseApp object, from which I will later extend further as needed. It is basically in charge of doing everything Ogre requires to be done to put things up in a rendering window.
BaseApp.h:

BaseApp.cpp:

#include "BaseApp.h"

using namespace Ogre;
using namespace std;

///This code is adapted from the Ogre tutorials webpage for my own purposes
 ///http://www.ogre3d.org/wiki/index.php/Basic_Tutorial_6#Creating_the_RenderSystem

///Main function, calling all the private settings to make the application run in proper order:
 ///The basic Ogre life cycle looks like this:

///   1. Create the Root object.
 ///   2. Define the resources that Ogre will use.
 ///   3. Choose and set up the RenderSystem (that is, DirectX, OpenGL, etc).
 ///   4. Create the RenderWindow (the window which Ogre resides in).
 ///   5. Initialize the resources that you are going to use.
 ///   6. Create a scene using those resources.
 ///   7. Set up any third party libraries and plugins.
 ///   8. Create any number of frame listeners.
 ///   9. Start the render loop.
    void BaseApp::go()
    {
        createRoot();
        defineResources();
        loadResources();
        setupRenderSystem();
        createRenderWindow();
        initializeResourceGroups();
        setupScene();
        createFrameListener();
        createPhysicsFrameListener();
        startRenderLoop();
    }

///Destructor releases the FrameListener and the Root object from memory
    BaseApp::~BaseApp()
    {
        delete mListener;
        delete mRoot;
    }

///-createRoot sets the Ogre Root object from where all others derive.
    ///The Root object is the core of the Ogre library,
    ///and must be created before you can do almost anything with the engine.
    void BaseApp::createRoot()
    {
        mRoot = new Root();
    }

///-defineResources sets all the Ogre engine requirements by iterating the configuration file.
    ///The next thing we have to do is define the resources that the application uses.
    ///This includes the textures, models, scripts, and so on.
    ///Everything is set up in the resources.cfg file.
    void BaseApp::defineResources()
    // Method which will define the source of resources (other than current folder)
    {
        // Load resource paths from config file
        ConfigFile cf;
        mResourcePath = "";
        cf.load(mResourcePath + "resources.cfg");

// Go through all sections & settings in the file
        ConfigFile::SectionIterator seci = cf.getSectionIterator();

String secName, typeName, archName;
        while (seci.hasMoreElements())
        {
            secName = seci.peekNextKey();
            ConfigFile::SettingsMultiMap *settings = seci.getNext();
            ConfigFile::SettingsMultiMap::iterator i;
            for (i = settings->begin(); i != settings->end(); ++i)
            {
                typeName = i->first;
                archName = i->second;
                ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
            }
        }
    }

///-loadResources intializes the application ResourceGroupManager.
    ///The function defineResources adds all of the resources from the config file,
    ///but it only tells Ogre where they are.
    ///Before you can use any of them you have to either initialize the group that you want to use,
    ///or you must initialize them all.
    void BaseApp::loadResources()
    {
       // Initialise, parse scripts etc
       ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

}

///-setupRenderSystem checks wether the config file Ogre.cfg has already set things up and calls the
 /// Ogre render system setup dialog in case it isn't.
    ///In the first part of the if statement, we attempt to restore the config file.
    ///If that function returns false it means that the file does not exist so we should show the config dialog,
    ///which is the second portion of that if statement.
    ///If that also returns false it means the user canceled out of config dialog
    ///(meaning they want to exit the program).
    void BaseApp::setupRenderSystem()
    {
        if (!mRoot->restoreConfig() && !mRoot->showConfigDialog())
            throw Exception(52, "User canceled the config dialog!", "BaseApp::setupRenderSystem()");
    }

///-createRenderWindow sets the Ogre root window where everything is going to be displayed
    ///Now that we have chosen the RenderSystem, we need a window to render Ogre in.
    ///There are actually a lot of options for how to do this, but we will really only need this to
    ///keep thing simple.
    void BaseApp::createRenderWindow()
    {
        mRoot->initialise(true, "Physics World");
    }

///The only thing left to do is to initialize the resources we are about to use.
    ///In a very large game or application, we may have hundreds or even thousands of
    ///resources that our game uses - everything from meshes to textures to scripts.
    ///At any given time though, we probably will only be using a small subset of these resources.
    ///To keep down memory requirements, we can load only the resources that our application is using.
    ///We do this by dividing the resources into sections and only initializing them as we go.
    void BaseApp::initializeResourceGroups()
    {
        TextureManager::getSingleton().setDefaultNumMipmaps(5);
        ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
    }

///There are at least three things that must be done before you start adding things to a scene:
    ///creating the SceneManager, creating the Camera, and creating the Viewport.
    ///I have added some lights and entities to give it some flesh.
    ///Entities are instances of PhysicsEntity, which is the class where all physics properties
    ///will be implemented
    void BaseApp::setupScene()
    {
        mgr = mRoot->createSceneManager(ST_GENERIC, "Default SceneManager");
        Viewport *vp;
        PhysicsEntity *PhysEnt(0);
        Light *light;

mgr->setAmbientLight( ColourValue( 0, 0, 0 ) );
        mgr->setShadowTechnique( SHADOWTYPE_TEXTURE_MODULATIVE );

mCamera = mgr->createCamera("PlayerCam");
        mCamera->setPosition(Vector3(300,300,200));
        mCamera->lookAt(Vector3(0,0,0));
        mCamera->setNearClipDistance(5);

vp = mRoot->getAutoCreatedWindow()->addViewport(mCamera);
        vp->setBackgroundColour(ColourValue(0,0,0));
        mCamera->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));

light = mgr->createLight("Light1");
        light->setType(Light::LT_POINT);
        light->setPosition(0, 15, 25);
        light->setDiffuseColour(.25, .25, 0);
        light->setSpecularColour(.25, .25, 0);

light = mgr->createLight("Light3");
        light->setType(Light::LT_DIRECTIONAL);
        light->setPosition(10,10,10);
        light->setCastShadows(true);
        light->setDiffuseColour(.25, .25, 0);
        light->setSpecularColour(.25, .25, 0);
        light->setDirection(Vector3( 0, -1, 1 ));

PhysEnt=new PhysicsEntity(mgr,PhysicsEntity::cube);
        PhysEnt->Geometry->scale(10,10,10);
        PhysicsEntities.push_back(*PhysEnt);
        PhysEnt=new PhysicsEntity(mgr,PhysicsEntity::plane);
        PhysEnt->Geometry->scale(1000,1000,1000);
        PhysicsEntities.push_back(*PhysEnt);
    }

///Every frame you must call the capture method on all Keyboard, Mouse, and Joystick objects you use.
    ///Our BaseFrameListener class manages all this for us.
    void BaseApp::createFrameListener()
    {
     mListener= new BaseFrameListener(mRoot->getAutoCreatedWindow(),mCamera);
        mRoot->addFrameListener(mListener);

}

///Every frame you must also update all physics entities
    ///Our PhysicsFramelistener class manages all this for us.
    void BaseApp::createPhysicsFrameListener()
    {
     PhListener= new PhysicsFrameListener(PhysicsEntities);
        mRoot->addFrameListener(PhListener);
    }
    ///This will render the application until a FrameListener returns false.
    void BaseApp::startRenderLoop()
    {
        mRoot->startRendering();
    }

The BaseFrameListener is another very important piece of code that allows one to control the rendering flow.
In order to manage whatever happens on every rendering step, Ogre provides the FrameListener object.
With the installed package comes an ExampleFrameListener.h file, which overrides the basic Ogre FrameListener and allows for a fairly good control over the inputting devices such as keyboard and mouse.I have slightly customised it for my purposes.
It has been a bit tricky however, and has made my computer crash a few times.
Anyway, here it is, domesticated at last!

BaseFrameListener.h:

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

You may use this sample code for anything you like, it is not covered by the
LGPL like the rest of the engine.
-----------------------------------------------------------------------------
*/
/*
-----------------------------------------------------------------------------
Filename:    ExampleFrameListener.h->Adapted into BaseFrameListener
Description: Defines an example frame listener which responds to frame events.
This frame listener just moves a specified camera around based on
keyboard and mouse movements.
Mouse:    Freelook
W or Up:  Forward
S or Down:Backward
A:        Step left
D:        Step right
PgUp:     Move upwards
PgDown:   Move downwards
F:        Toggle frame rate stats on/off
R:        Render mode
T:        Cycle texture filtering
                       Bilinear, Trilinear, Anisotropic(8)
P:        Toggle on/off display of camera position / orientation
Imp Pant: Saves an incremental Screenshot
-----------------------------------------------------------------------------
*/
#ifndef BASEFRAMELISTENER_H_
#define BASEFRAMELISTENER_H_

#include "Ogre.h"
#include "OgreStringConverter.h"
#include "OgreException.h"

//Use this define to signify OIS will be used as a DLL
//(so that dll import/export macros are in effect)
#define OIS_DYNAMIC_LIB
#include <OIS/OIS.h>

using namespace Ogre;

class BaseFrameListener: public FrameListener, public WindowEventListener
{
protected:
 Camera* mCamera;

Vector3 mTranslateVector;
 Real mCurrentSpeed;
 RenderWindow* mWindow;
 bool mStatsOn;

std::string mDebugText;

unsigned int mNumScreenShots;
 float mMoveScale;
 float mSpeedLimit;
 Degree mRotScale;
 // just to stop toggles flipping too fast
 Real mTimeUntilNextToggle ;
 Radian mRotX, mRotY;
 TextureFilterOptions mFiltering;
 int mAniso;

int mSceneDetailIndex ;
 Real mMoveSpeed;
 Degree mRotateSpeed;
 Overlay* mDebugOverlay;

//OIS Input devices
 OIS::InputManager* mInputManager;
 OIS::Keyboard* mKeyboard;
 OIS::Mouse*    mMouse;

virtual void updateStats(void)
 {
  static String currFps = "Current FPS: ";
  static String avgFps = "Average FPS: ";
  static String bestFps = "Best FPS: ";
  static String worstFps = "Worst FPS: ";
  static String tris = "Triangle Count: ";
  static String batches = "Batch Count: ";

// update stats when necessary
  try {
   OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
   OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
   OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
   OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");

const RenderTarget::FrameStats& stats = mWindow->getStatistics();
   guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
   guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));
   guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
    +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
   guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
    +" "+StringConverter::toString(stats.worstFrameTime)+" ms");

OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
   guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));

OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
   guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));

OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
   guiDbg->setCaption(mDebugText);
  }
  catch(...) { /* ignore */ }
 }

public:
 // Constructor takes a RenderWindow because it uses that to determine input context
 BaseFrameListener(RenderWindow* win, Camera* cam, bool bufferedKeys = false, bool bufferedMouse = false) :
  mCamera(cam),
  mTranslateVector(Vector3::ZERO),
  mCurrentSpeed(0),
  mWindow(win),
  mStatsOn(true),
  mNumScreenShots(0),
  mMoveScale(0.0f),
  mRotScale(0.0f),
  mTimeUntilNextToggle(0),
  mFiltering(TFO_BILINEAR),
  mAniso(1),
  mSceneDetailIndex(0),
  mMoveSpeed(100),
  mRotateSpeed(36),
  mDebugOverlay(0),
  mInputManager(0),
  mKeyboard(0),
  mMouse(0)
 {
  mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");

LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
  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()));

mInputManager = OIS::InputManager::createInputSystem( pl );

//Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse)
  mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, bufferedKeys ));
  mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, bufferedMouse ));

//Set initial mouse clipping size
  windowResized(mWindow);

showDebugOverlay(true);

//Register as a Window listener
  WindowEventUtilities::addWindowEventListener(mWindow, this);
 }

//Adjust mouse clipping area
 virtual void windowResized(RenderWindow* rw)
 {
  unsigned int width, height, depth;
  int left, top;
  rw->getMetrics(width, height, depth, left, top);

const OIS::MouseState &ms = mMouse->getMouseState();
  ms.width = width;
  ms.height = height;
 }

//Unattach OIS before window shutdown (very important under Linux)
 virtual void windowClosed(RenderWindow* rw)
 {
  //Only close for window that created OIS (the main window in these demos)
  if( rw == mWindow )
  {
   if( mInputManager )
   {
    mInputManager->destroyInputObject( mMouse );
    mInputManager->destroyInputObject( mKeyboard );

OIS::InputManager::destroyInputSystem(mInputManager);
    mInputManager = 0;
   }
  }
 }

virtual ~BaseFrameListener()
 {
  //Remove ourself as a Window listener
  WindowEventUtilities::removeWindowEventListener(mWindow, this);
  windowClosed(mWindow);
 }

virtual bool processUnbufferedKeyInput(const FrameEvent& evt)
 {

if(mKeyboard->isKeyDown(OIS::KC_A))
   mTranslateVector.x = -mMoveScale; // Move camera left

if(mKeyboard->isKeyDown(OIS::KC_D))
   mTranslateVector.x = mMoveScale; // Move camera RIGHT

if(mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W) )
   mTranslateVector.z = -mMoveScale; // Move camera forward

if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S) )
   mTranslateVector.z = mMoveScale; // Move camera backward

if(mKeyboard->isKeyDown(OIS::KC_PGUP))
   mTranslateVector.y = mMoveScale; // Move camera up

if(mKeyboard->isKeyDown(OIS::KC_PGDOWN))
   mTranslateVector.y = -mMoveScale; // Move camera down

if(mKeyboard->isKeyDown(OIS::KC_RIGHT))
   mCamera->yaw(-mRotScale);

if(mKeyboard->isKeyDown(OIS::KC_LEFT))
   mCamera->yaw(mRotScale);

if( mKeyboard->isKeyDown(OIS::KC_ESCAPE) || mKeyboard->isKeyDown(OIS::KC_Q) )
   return false;

if( mKeyboard->isKeyDown(OIS::KC_F) && mTimeUntilNextToggle <= 0 )
  {
   mStatsOn = !mStatsOn;
   showDebugOverlay(mStatsOn);
   mTimeUntilNextToggle = 1;
  }

if( mKeyboard->isKeyDown(OIS::KC_T) && mTimeUntilNextToggle <= 0 )
  {
   switch(mFiltering)
   {
   case TFO_BILINEAR:
    mFiltering = TFO_TRILINEAR;
    mAniso = 1;
    break;
   case TFO_TRILINEAR:
    mFiltering = TFO_ANISOTROPIC;
    mAniso = 8;
    break;
   case TFO_ANISOTROPIC:
    mFiltering = TFO_BILINEAR;
    mAniso = 1;
    break;
   default: break;
   }
   MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
   MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);

showDebugOverlay(mStatsOn);
   mTimeUntilNextToggle = 1;
  }

if(mKeyboard->isKeyDown(OIS::KC_SYSRQ) && mTimeUntilNextToggle <= 0)
  {
   std::ostringstream ss;
   ss << "screenshot_" << ++mNumScreenShots << ".png";
   mWindow->writeContentsToFile(ss.str());
   mTimeUntilNextToggle = 0.5;
   mDebugText = "Saved: " + ss.str();
  }

if(mKeyboard->isKeyDown(OIS::KC_R) && mTimeUntilNextToggle <=0)
  {
   mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
   switch(mSceneDetailIndex) {
    case 0 : mCamera->setPolygonMode(PM_SOLID); break;
    case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;
    case 2 : mCamera->setPolygonMode(PM_POINTS); break;
   }
   mTimeUntilNextToggle = 0.5;
  }

static bool displayCameraDetails = false;
  if(mKeyboard->isKeyDown(OIS::KC_P) && mTimeUntilNextToggle <= 0)
  {
   displayCameraDetails = !displayCameraDetails;
   mTimeUntilNextToggle = 0.5;
   if (!displayCameraDetails)
    mDebugText = "";
  }

// Print camera details
  if(displayCameraDetails)
   mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
       " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());

// Return true to continue rendering
  return true;
 }

virtual bool processUnbufferedMouseInput(const FrameEvent& evt)
 {
  // Rotation factors, may not be used if the second mouse button is pressed
  // 2nd mouse button - slide, otherwise rotate
  const OIS::MouseState &ms = mMouse->getMouseState();
  if( ms.buttonDown( OIS::MB_Right ) )
  {
   mTranslateVector.x += ms.X.rel * 0.13;
   mTranslateVector.y -= ms.Y.rel * 0.13;
  }
  else
  {
   mRotX = Degree(-ms.X.rel * 0.13);
   mRotY = Degree(-ms.Y.rel * 0.13);
  }

return true;
 }

virtual void moveCamera()
 {
  // Make all the changes to the camera
  // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW
  //(e.g. airplane)
  mCamera->yaw(mRotX);
  mCamera->pitch(mRotY);
  mCamera->moveRelative(mTranslateVector);
 }

virtual void showDebugOverlay(bool show)
 {
  if (mDebugOverlay)
  {
   if (show)
    mDebugOverlay->show();
   else
    mDebugOverlay->hide();
  }
 }

// Override frameRenderingQueued event to process that (don't care about frameEnded)
 bool frameRenderingQueued(const FrameEvent& evt)
 {

if(mWindow->isClosed()) return false;

mSpeedLimit = mMoveScale * evt.timeSinceLastFrame;

//Need to capture/update each device
  mKeyboard->capture();
  mMouse->capture();

Ogre::Vector3 lastMotion = mTranslateVector;

//Check if one of the devices is not buffered
  if(!mKeyboard->buffered()|| !mMouse->buffered() )
  {
   // one of the input modes is immediate, so setup what is needed for immediate movement
   if (mTimeUntilNextToggle >= 0)
    mTimeUntilNextToggle -= evt.timeSinceLastFrame;

// Move about 100 units per second
   mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
   // Take about 10 seconds for full rotation
   mRotScale = mRotateSpeed * evt.timeSinceLastFrame;

mRotX = 0;
   mRotY = 0;
   mTranslateVector = Ogre::Vector3::ZERO;

}

//Check to see which device is not buffered, and handle it
  if( !mKeyboard->buffered() )
   if( processUnbufferedKeyInput(evt) == false )
    return false;
  if( !mMouse->buffered() )
   if( processUnbufferedMouseInput(evt) == false )
    return false;

// ramp up / ramp down speed
     if (mTranslateVector == Ogre::Vector3::ZERO)
  {
   // decay (one third speed)
   mCurrentSpeed -= evt.timeSinceLastFrame * 0.3;
   mTranslateVector = lastMotion;
  }
  else
  {
   // ramp up
   mCurrentSpeed += evt.timeSinceLastFrame;

}
  // Limit motion speed
  if (mCurrentSpeed > 1.0)
   mCurrentSpeed = 1.0;
  if (mCurrentSpeed < 0.0)
   mCurrentSpeed = 0.0;

mTranslateVector *= mCurrentSpeed;

if(!mKeyboard->buffered() || !mMouse->buffered())
   moveCamera();

return true;
 }

bool frameEnded(const FrameEvent& evt)
 {
  updateStats();
  return true;
 }
};

#endif /*BASEFRAMELISTENER_H_*/

Once the beast is under control, the rest is a piece of cake...hehehe...
You can make as many instances of a FrameListener as you need in an Ogre application.
I have chosen to create a separate framelistener for managing whatever goes under the physics, to keep things up neat and tidy.
It is the PhysicsFrameListener class:

PhysicsFrameListener.h:

/*
#ifndef PHYSICSFRAMELISTENER_H_
#define PHYSICSFRAMELISTENER_H_

#include "PhysicsEntity.h"
#include <iostream>
#include <math.h>
#include <vector>
#include <time.h>
#include <ctime>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <Ogre.h>

using namespace Ogre;
///This class is in charge to manage the physics before every
///render step on the Ogre window.
class PhysicsFrameListener : public FrameListener
{
public:
    ///The Ents vector contains the entities with physical properties attached to them
    ///In this example, no physics are used yet. Just an X-axis displacement is applied
    ///to perceive motion.
    PhysicsFrameListener(std::vector<PhysicsEntity> Ents):
     Entities(Ents)
    {
    }

///frameStarted is an overriden event from the Ogre FrameListener.
    ///Note that positions are updated before sending the information
    ///to the root object in the go loop.
    bool frameStarted(const FrameEvent& evt)
    {
     UpdatePositions();
     return true;
    }

///Update positions is in charge to reallocate the entities to their future locations
    void UpdatePositions()
    {
//     PhysicsEntity::EntityType TypeEnt;

for (unsigned int i=0; i<Entities.size(); i++)
     {
      if (Entities[i].GeomType==PhysicsEntity::cube)
       Entities[i].Geometry->translate(0.1,0,0,Ogre::Node::TS_WORLD);
     }
    }
private:
    std::vector<PhysicsEntity> Entities;
};

#endif /*PHYSICSFRAMELISTENER_H_*/

The elementary brick on which everything else will be constructed is likely to be called PhysicsEntity.
So I have defined my PhysicsEntity Class.
In this code is still at its very bones, just presenting a couple of functions to make things visible.
Hopefully in the near future some more flesh will get added on it!

PhysicsEntity.h:

PhysicsEntity.cpp:

/*
#include "PhysicsEntity.h"

PhysicsEntity::PhysicsEntity(SceneManager *SceneMgr,EntityType ShapeType)
{
 Geometry = SceneMgr->getRootSceneNode()->createChildSceneNode();
 Geometry->setPosition(0,5,0);
 GeomType=ShapeType;
 switch (GeomType)
 {
 case cube:
        Geometry->attachObject(createCubeMesh("Cube","myMaterial"));
  break;
 case plane:
        Geometry->attachObject(createPlane("Plane","myMaterial"));
  break;
 };
}
PhysicsEntity::~PhysicsEntity()
{

}
ManualObject* PhysicsEntity::createCubeMesh(Ogre::String name, Ogre::String matName)
{
 ManualObject* cube = new ManualObject(name);
 cube->begin(matName);

cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(1,0);
 cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(0,1);
 cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(1,1);
 cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(0,0);
 cube->position(0.5,0.5,1.0);cube->normal(0.666667,0.333333,0.666667);cube->textureCoord(1,0);
 cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(0,1);
 cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(1,1);
 cube->position(-0.5,0.5,1.0);cube->normal(-0.408248,0.816497,0.408248);cube->textureCoord(0,0);
 cube->position(-0.5,0.5,0.0);cube->normal(-0.666667,0.333333,-0.666667);cube->textureCoord(0,1);
 cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(1,1);
 cube->position(-0.5,-0.5,1.0);cube->normal(-0.666667,-0.333333,0.666667);cube->textureCoord(1,0);
 cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(0,1);
 cube->position(0.5,0.5,0.0);cube->normal(0.408248,0.816497,-0.408248);cube->textureCoord(1,1);
 cube->position(0.5,-0.5,1.0);cube->normal(0.408248,-0.816497,0.408248);cube->textureCoord(0,0);
 cube->position(0.5,-0.5,0.0);cube->normal(0.666667,-0.333333,-0.666667);cube->textureCoord(1,0);
 cube->position(-0.5,-0.5,0.0);cube->normal(-0.408248,-0.816497,-0.408248);cube->textureCoord(0,0);
 cube->position(-0.5,0.5,1.0);cube->normal(-0.408248,0.816497,0.408248);cube->textureCoord(1,0);
 cube->position(0.5,0.5,0.0);cube->normal(0.408248,0.816497,-0.408248);cube->textureCoord(0,1);
 cube->position(-0.5,0.5,0.0);cube->normal(-0.666667,0.333333,-0.666667);cube->textureCoord(1,1);
 cube->position(0.5,0.5,1.0);cube->normal(0.666667,0.333333,0.666667);cube->textureCoord(0,0);
 cube->triangle(0,1,2);      cube->triangle(3,1,0);
 cube->triangle(4,5,6);      cube->triangle(4,7,5);
 cube->triangle(8,9,10);      cube->triangle(10,7,8);
 cube->triangle(4,11,12);   cube->triangle(4,13,11);
 cube->triangle(14,8,12);   cube->triangle(14,15,8);
 cube->triangle(16,17,18);   cube->triangle(16,19,17);
 cube->end();

return cube;
}
ManualObject* PhysicsEntity::createPlane(Ogre::String name, Ogre::String matName)
{
 ManualObject* plane = new ManualObject(name);
 plane->begin(matName);

plane->position(-0.5,0,-0.5);plane->normal(0.408248,-0.816497,0.408248);plane->textureCoord(1,0);
 plane->position(-0.5,0.0,0.5);plane->normal(-0.408248,-0.816497,-0.408248);plane->textureCoord(0,1);
 plane->position(0.5,0.0,0.5);plane->normal(0.666667,-0.333333,-0.666667);plane->textureCoord(1,1);
 plane->position(0.5,0.0,-0.5);plane->normal(-0.666667,-0.333333,0.666667);plane->textureCoord(0,0);
 plane->triangle(0,1,2);      plane->triangle(0,2,3);
 plane->end();

return plane;
}

Last, but not least, is the main.cpp file, where everything gets blended:

main.cpp:

And this is it. Now...Let's get busy!

Stochastic Simulation and Lagrangian Dynamics

domingo, 11 de abril de 2010

Setting Ogre3D as Graphic Environment

No hay comentarios:

Publicar un comentario

Statcounter

Where are we visited from?