ODE DYNAMICS ENGINE QUICK OVERVIEW

Posted: April 15th, 2010 | Author: Rabindranath Andujar Moreno | Filed under: Variado | Comments Off After seeing my own simulator running there is a whole lot of things that I wish it had.
All this stuff is more or less complicated to achieve, but from my previous research I have found some Open Source engines from which I can learn a lot.

The best documented one so far is ODE (www.ode.org), and also the one I intend to merge with Blender.
So, I present a very quick and thorough overview on how this works, in order to have some scope.

The first thing to disentangle is how it gets working. For that, just looking at the user's manual one gets the following algorithm:

1.-Create a Dynamics world

• This basically means to make an instance of the dxWorld struct.

2.-Create the bodies

• Attach the bodies to the world (this means adding data to the dxBody* array of the dynamics world).
• Set their properties (position and orientation of point of reference, its linear and angular velocities, the mass of the bodies and some other stuff of the like).

3.-Create the joints

• Attach the joints to the world (by adding data to the dxJoints* array of the dynamics world)
• Set their properties (depending of the selected type of joint, one has to provide different details).

4.-Manage collisions

• Create a new collision world (just by making an instance to the dxSpace struct).
• Create a joint group where collisions will be stored temporarily for every frame step.

5.-Loop

• Apply forces to bodies.
• Adjust joint parameters.
• Call collision detection.
• Create a contact joint for every detected collision point and add it to the collision joint group.
• Take a simulation step.
• Clear the collision joint group.

6.-Destroy the dynamics and the collision worlds (wow, that sounds evil...hehehe).

All of this seems fairly easy to do but then one has to get to know where and how things have been implemented. This is when things become a bit harder.
I am sure the file structure and the class definitions make perfect sense for the programmers of this engine.
Fortunately, they have been careful enough so as to comment everything in an understandable way, for which I feel deeply grateful.
After some digging, I have managed to restructure the ode/src folder into the following topics:

• Accessories
• Memory management
• Math
• Matrix handling
• External applications
• Collision
• Core
• Joints
• Primitives
• Solver

Which means one can tackle the engine in an ordered manner and find things when needed.

From a theoretical point of view, this engine presents the following features:

• A Lagrange multiplier velocity based model from Trinkle and Stewart
• A friction model from Baraff
• A Danzig LCP solver

---

First Ogre+Verlet+Gauss-Seidel simulation

Posted: April 13th, 2010 | Author: Rabindranath Andujar Moreno | Filed under: Variado | Comments Off Once the Ogre3D engine is ready to draw what we numerically compute, it was about time to start having some fun.

I found this excellent article from Thomas Jakobsen: http://www.teknikus.dk/tj/gdc2001.htm where a very neat and simple engine is implemented (thanks Mr. Jakobsen).

It is very well explained so adapting it to my little lab was not very hard.
Here I proudly present my very first simulation!



I am perfectly conscious that it lacks of a lot of things...namely collision detection, a proper stable, precise integrator, an optimized implementation...and a long etcetera...but it's just a baby!

Here is a zip file with the code (an extension from what I presented in the last post):


http://www.mnbvlabs.com/Thesis/VerletRelaxation.zip

---

Setting Ogre3D as Graphic Environment

Posted: April 11th, 2010 | Author: Rabindranath Andujar Moreno | Filed under: Variado | Comments Off 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:
#include <Ogre.h>#include "BaseFrameListener.h"#include "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>using namespace Ogre;class BaseApp{public: void go(); ~BaseApp();private: Root *mRoot; BaseFrameListener *mListener; PhysicsFrameListener *PhListener; Ogre::String mResourcePath; SceneManager *mgr; RenderWindow *win; Camera *mCamera; std::vector<PhysicsEntity> PhysicsEntities; void createRoot(); void defineResources(); void loadResources(); void setupRenderSystem(); void createRenderWindow(); void initializeResourceGroups(); void setupScene(); void setupInputSystem(); void setupCEGUI(); void createFrameListener(); void createPhysicsFrameListener(); void startRenderLoop();};
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/Copyright (c) 2000-2006 Torus Knot Software LtdAlso see acknowledgements in Readme.htmlYou may use this sample code for anything you like, it is not covered by theLGPL like the rest of the engine.-----------------------------------------------------------------------------*//*-----------------------------------------------------------------------------Filename: ExampleFrameListener.h->Adapted into BaseFrameListenerDescription: Defines an example frame listener which responds to frame events.This frame listener just moves a specified camera around based onkeyboard and mouse movements.Mouse: FreelookW or Up: ForwardS or Down:BackwardA: Step leftD: Step rightPgUp: Move upwardsPgDown: Move downwardsF: Toggle frame rate stats on/offR: Render modeT: Cycle texture filtering Bilinear, Trilinear, Anisotropic(8)P: Toggle on/off display of camera position / orientationImp 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:
/*#ifndef PHYSICSENTITY_H_#define PHYSICSENTITY_H_#include <Ogre.h>using namespace Ogre;class PhysicsEntity{public: enum EntityType { cube, plane }; PhysicsEntity(SceneManager *SceneMgr,EntityType ShapeType); ~PhysicsEntity(); double mass; Vector3 position; Vector3 velocity; Vector3 acceleration; SceneNode *Geometry; EntityType GeomType;private: ManualObject* createCubeMesh(Ogre::String, Ogre::String); ManualObject* createPlane(Ogre::String, Ogre::String);};#endif /*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:
/*#include "BaseApp.h"///This is the top module for running any Ogre based application///Is just simple an concise.///Call the go method of the BaseApp class and everything just goesint main(int argc, char **argv){ // Create application object BaseApp app; //Just in case, catch any errors try { //Call the go method, where all the private settings //for running an Ogre app are called app.go(); } catch(Exception& e) { printf( "An exception has occurred: %s\n", e.getFullDescription().c_str()); } return 0;}

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

---

CODE NAME: Brachistochrona

Posted: March 31st, 2010 | Author: Rabindranath Andujar Moreno | Filed under: Variado | Comments Off Today I'm going to reveal a classified archive. Or so it seems...

Physicians have been keeping this knowledge from us simple mortals for centuries...hehehe...
While trying to understand the essentials on variational mechanics, I have come into this article: http://jazz.openfun.org/wiki/Brachistochrone.
The problem of the brachistochrone dates back to Newton (17th century) and appears mentioned frequently as one of the problems that can be solved be means of this refined technique.

In fact, this problem appears to be the actual trigger for the modern physics (or better stated, its solution), and reveals a completely counterintuitive phenomenon:

The quickest path is not the straight line

Amazingly, the solution for a bead on a wire going in the least time from point A to point B:


Is the cycloid represented in the picture.

As standard human, one always tends to think that the shortest path would be the quickest one. It is wrong.
Analogously, when it comes to minimize the action (see previous posts on the subject), it is very hard to imagine that the stationary points would not come at flattening the curve for the action.
This is what makes so hard to understand the variational principles that rule over Lagrangian, Eulerian and Hamiltonian mechanics.

If one only had been told...

I have made a spreadsheet with openoffice (www.openoffice.org) where this can be numerically perceived also.

The spreadsheet is here.

I have made it with the help of a paper by Jozef Hanc: The original Euler's calculus-of-variations method: Key to Lagrangian mechanics for beginners.
I found it extremely appropriate for my case, and also absolutely clarifying. Thanks mr Hanc

---

INTERNATIONAL SEED TRAINING: ESPAÑA, PORTUGAL, MÉXICO

Posted: March 31st, 2010 | Author: R.O.D. | Filed under: Investigación, Noticias | Tags: 3DMAX, Blender, Clases grass, clases grasshopper, clases Rhino, cursos 3d barcelona, cursos grasshopper, cursos rhinoceros, diseño generativo, estudio SEED, geometría avanzada, Grasshopper Portugal, Grupo KRFR, parametric architecture, programación orientada a objetos, Rhinoceros portugal, universidad de minho, VRAY, workshop portugal, workshop rhinoscript | No Comments »

Gracias a la red y el equipo que se esta formando dentro de grupo KRFR y por la línea de investigación que SEED | KRFR esta proponiendo, estamos trabajando sobre formación especializada tanto teórica como técnica en programación, diseño paramétrico, creación de algoritmos, vinculación entre softwares, sostenibilidad para constructores, arquitectos y diseñadores en 3 países: España, México y Portugal.
Las expectativas son que la red crezca hacia otros países así como fortalecer las redes ya existentes y que están naciendo.

En los tres países en donde actualmente esta SEED, los objetivos de investigación y desarrollo son los mismos, así como el tipo de formación, lógicamente con diferente formador.
En cada uno de estos países SEED | KRFR esta tratando con diferentes Universidades para impulsar nuestra línea de investigación, uno de los temas principales de esta investigación es el trabajo online para desarrollar software y compartir información relevante sobre los temas sostenibilidad ligados con la programación orientada a objetos. Por el momento, las plataformas que usamos es Rhinoceros, Grasshopper, Blender, Python, Rhinoscript, Ogre. Posteriormente iremos avanzando en otras plataformas. Si quieres unirte a la red, porfavor contáctanos: seed@krfr.org

SEED en España
Rabindranath Andujar (Arquitecto programador especializado en física)
Garito (Programador)
Soe Farah Iracheta (Arquitecta especializada en sostenibilidad)
David Antón (Arquitecto Biodigital)
JAN (Programador empresario)
R.O.D. (Arquitecto – Diseñador especializado en sostenibilidad)

WEB SEED España

SEED en Portugal:

Adriano Faria (Arquitecto)
Amilcar Ferreira (Arquitecto)
Miguel Ribeiro (Arquitecto-Matemático)

WEB SEED Potugal

.

.

SEED en México
Silvia Carbajal (Técnica en Diseño Gráfico)
Adrian Velázco (Diseñador Industrial)
Carlos Ruz (Estudiante de Arquitectura)
Coco Gutierrez (Arquitecta)
Fabian Marcelo (Arquitecto especializando en sostenibilidad)
Daniel Zamorano (Arquitecto)

WEB SEED México

La foto de SEED México, fue tomada durante el Taller DPOPS en Buscando la Aurora.

---