|| || || || || || || ||

---

PhysicsEngine.h

Go to the documentation of this file.

#ifndef Impala_Application_Videolympics_PhysicsEngine_h
#define Impala_Application_Videolympics_PhysicsEngine_h

#include "OglGui/View.h"

namespace Impala {
namespace Application {
namespace Videolympics {

using namespace OglGui;
class PhysicsPart
{
public:
    PhysicsPart(OGLVIEW3D *view, int identifier)
    {
        mView = view;
        mNr = identifier;
        view3DSys.GetDimensions(mView, &tX, &tY, &tZ, NULL, NULL, NULL);
        mDestroying = false;
        tfX = tfY = tfZ = fX = fY = fZ = 0.0f;
    }
    void
    DoPhysics()
    {
        if (!IsAtTarget()) {
            CalcForces();
            float aX, aY, aZ;
            view3DSys.GetDimensions(mView, &aX, &aY, &aZ, NULL, NULL, NULL);

            aX += fX;
            aY += fY;
            aZ += fZ;
            view3DSys.SetDimensions(mView, aX, aY, aZ, FRETAIN, FRETAIN, FRETAIN);
        }
    }

    void
    CalcForces()
    {
        float sFactor = 0.005f;

        float aX, aY, aZ;
        view3DSys.GetDimensions(mView, &aX, &aY, &aZ, NULL, NULL, NULL);

        tfX = (tX - aX);
        tfY = (tY - aY);
        tfZ = (tZ - aZ);

        //fX = fX * (1.0f - sFactor) + tfX * sFactor * 0.8;
        //fY = fY * (1.0f - sFactor) + tfY * sFactor * 0.8;
        //fZ = fZ * (1.0f - sFactor) + tfZ * sFactor * 0.8;
        fX = (tX - aX) * 0.05;
        fY = (tY - aY) * 0.05;
        fZ = (tZ - aZ) * 0.05;

        fX = Limit(fX, 0.2f);
        fY = Limit(fY, 0.2f);
        fZ = Limit(fZ, 0.2f);
    }

    float
    Limit(float f, float max)
    {
        if (f > max)
            return max;
        if (f < -max)
            return -max;
        return f;
    }

    void
    AddToStack(int stackno)
    {
        int mStackNo = stackno;
    }

    void
    MoveTo(float x, float y, float z)
    {
        tX = x; tY = y; tZ = z;
    }

    void
    MoveRelative(float x, float y, float z)
    {
        tX += x; tY += y; tZ += z;
    }

    // call this when this physics part AND the view on which it operates
    // should be destroyed, logic in VidolviWindow will take care of the
    // actual destruction based on this.
    void
    DoDestroyPart()
    {
        mDestroying = true;
    }

    bool
    IsDestroying()
    {
        return mDestroying;
    }

    bool
    ShouldDestroy()
    {
        if (mDestroying)
            return true;

/*        float aX, aY, aZ;
        view3DSys.GetDimensions(mView, &aX, &aY, &aZ, NULL, NULL, NULL);
        if (IsAtTarget())
        {
            ILOG_DEBUG("VIEW " << mNr << "TARGET REACHED. DESTROYING...");
            return true;
        } */
        return false;
    }


    inline bool
    IsAlmost(float a, float r)
    {
        if (a==r) return true;
        if ( (a>r && a - r < 0.01) || (r>a && r - a < 0.01))
            return true;
        return false;
    }

    bool
    IsAtTarget()
    {
        float aX, aY, aZ;
        view3DSys.GetDimensions(mView, &aX, &aY, &aZ, NULL, NULL, NULL);
        if (IsAlmost(aX,tX) && IsAlmost(aY,tY) && IsAlmost(aZ, tZ))
        {
            return true;
        }
        return false;
    }

private:
    bool mRequestDestroy;
    bool mDestroying;
    float tX, tY, tZ;
    float fX, fY, fZ;
    float tfX, tfY, tfZ;
    OGLVIEW3D *mView;
    int mNr;

    int mStackNo;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(PhysicsPart, Visualization.Application.Videolympics);





class PhysicsEngine
{
public:

    PhysicsEngine()
    {
        mParts = std::vector<PhysicsPart*>();
        mStacks = std::map<int, std::vector<PhysicsPart*>* >();
        mIsFlushing = false;
        mFlushCounter = 0;
        Impala::CmdOptions& options = Impala::CmdOptions::GetInstance();
        mMaxImagesOnRow = options.GetInt("maxImagesOnRow");
        ILOG_DEBUG("Max images on row: " << mMaxImagesOnRow);
    }

    void
    RegisterPart(PhysicsPart *p, int stackno)
    {
        if (mIsFlushing)
        {
            ILOG_DEBUG("RegisterPart: still flushing, ignored.");
            return;
        }

        if (p == NULL) {
            ILOG_ERROR("Trying to register an empty PhysicsPart.");
            return;
        }
        mParts.push_back(p);
        std::vector <PhysicsPart*>* s = GetStack(stackno);
        s->push_back(p);
        MoveStackUp(stackno);
        ILOG_DEBUG("Added shot to stack " << stackno << " now " << s->size() << " shots in stack.");
    }

    void
    UnregisterPart(PhysicsPart *p)
    {
/*        for (int i = 0; i < mParts.size(); i++) {
            if (p == mParts[i])
            {
                mParts.erase(mParts.begin() + i, mParts.begin() + i + 1);
                ILOG_DEBUG("ERASING PPART " << i);
                break;
            }
        } */
    }

    std::vector <PhysicsPart*>*
    GetStack(int stackno)
    {
        if(mStacks.find(stackno) == mStacks.end())
        {
            mStacks[stackno] = new std::vector<PhysicsPart*>();
        }
        return mStacks[stackno];
    }

    void
    MoveStackUp(int stackno)
    {
        if (mIsFlushing)
        {
            ILOG_DEBUG("MoveStackUp: still flushing, ignored.");
            return;
        }

        std::vector <PhysicsPart*>* s = GetStack(stackno);
        ILOG_DEBUG("MoveStackUp: " << stackno << " contains " << s->size() << " shots.");
        for (int i = 0; i < s->size(); i++) {
            PhysicsPart *p = (*s)[i];
            if (p == NULL)
                continue;
            p->MoveRelative(0.0f, 1.0f, 0.0f);
        }

        int mMaxStackSize = mMaxImagesOnRow; // 12
        if (s->size() > mMaxStackSize)
        {
            int toRemove = s->size() - mMaxStackSize;
            ILOG_DEBUG("Removing " << toRemove << " shots...");
            std::vector<PhysicsPart*>::iterator here = s->begin();
            while (toRemove > 0)
            {
                PhysicsPart *p = *here;
                if (p == NULL)
                    continue;
                p->DoDestroyPart();
                here++;
                toRemove--;
            }
            here--;
            s->erase(s->begin(), here);
        }
    }

    void
    FlushStacks()
    {
        if (mIsFlushing)
            return;

        ILOG_DEBUG("Flushing stacks...");
        // clear the stacks:
        std::map<int, std::vector<PhysicsPart*>* >::iterator stackiter = mStacks.begin();
        for (stackiter = mStacks.begin(); stackiter != mStacks.end(); stackiter++)
        {
            int stackno = stackiter->first;
            ILOG_DEBUG("Cleaning stack " << stackno);
            std::vector <PhysicsPart*>* s = GetStack(stackno);
            s->clear();
        }

        // move the parts, and request deletion:
        for (int i = 0; i < mParts.size(); i++) {
            PhysicsPart *p = mParts[i];
            if (p == NULL) {
                ILOG_ERROR("DoPhysics - PhysicsPart " << i << " = NULL.");
                continue;
            }

            if (p->IsDestroying())
                continue;

            p->MoveRelative(0.0f, +10.0f, 0.0f);
        }

        mIsFlushing = true;
        mFlushCounter = 100;
    }

    bool
    IsFlushing()
    {
        return mIsFlushing;
    }

    void
    DoPhysics()
    {
        int before = mParts.size();
        for (int i = 0; i < mParts.size(); i++) {
            PhysicsPart *p = mParts[i];
            if (p == NULL) {
                ILOG_ERROR("DoPhysics - PhysicsPart " << i << " = NULL.");
                continue;
            }

            if (p->IsDestroying())
            {
                mParts.erase(mParts.begin() + i, mParts.begin() + i + 1);
                i--;
                continue;
            }
            p->DoPhysics();
        }
//         if (mParts.size() != before)
//         {
//             ILOG_DEBUG("NR OF PARTS BEFORE: " << before);
//             ILOG_DEBUG("NR OF PARTS AFTER:  " << mParts.size());
//         }

        if (mIsFlushing)
        {
            if (mFlushCounter <= 0)
            {
                ILOG_DEBUG("Flush counter reached zero. Destroying everything in sight.");

                // Everything flushed, destroy all.
                for (int i = 0; i < mParts.size(); i++) {
                    PhysicsPart *p = mParts[i];
                    if (p == NULL) {
                        ILOG_ERROR("DoPhysics - PhysicsPart " << i << " = NULL.");
                        continue;
                    }
        
                    p->DoDestroyPart();
                }

                mParts.clear();

                mIsFlushing = false;
                mFlushCounter = 0;
            }
            mFlushCounter--;
        }
    }

    std::vector<PhysicsPart*> mParts;

    std::map<int, std::vector<PhysicsPart*>* > mStacks;

    bool mIsFlushing;
    int  mFlushCounter;
    int  mMaxImagesOnRow;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(PhysicsEngine, Visualization.Application.Videolympics);



}
}
}

#endif

---