src/BilliardPhysics.cpp

Go to the documentation of this file.

#ifndef DOLOG
//#define DOLOG
#undef  DOLOG
#endif


#include <algorithm>
#include <iomanip>
#include <sstream>
#include <stdexcept>

#include "BilliardPhysics.h"
#include "Object.h"
#include "TableBorder.h"
#include "Collision.h"
#include "defines.h"


BilliardPhysics::BilliardPhysics()
    : mObjects(),
        mBorders(),
        mCollisions(),
        mTime(0.0f),
        mLoadFile(),
        mInFile(),
        mSaveFile(),
        mOutFile()
{
    mBorders[0] = new TableBorder("left",   TABLE_MIN.z(), true,    Vec3f(0, 0, 1));
    mBorders[1] = new TableBorder("top",    TABLE_MAX.x(), false,   Vec3f(-1, 0, 0));
    mBorders[2] = new TableBorder("right",  TABLE_MAX.z(), true,    Vec3f(0, 0, -1));
    mBorders[3] = new TableBorder("bottom", TABLE_MIN.x(), false,   Vec3f(1, 0, 0));
    LOG("");
    LOG("physics init");
    LOG("------------");
    LOG("constants:");
    LOG("EPSILON        = " << std::setprecision(8) << EPSILON);
    LOG("PHYS_EPS       = " << std::setprecision(8) << PHYS_EPS);
    LOG("MUE_SLIDING    = " << std::setprecision(8) << MUE_SLIDING);
    LOG("MUE_ROLLING    = " << std::setprecision(8) << MUE_ROLLING);
    LOG("MUE_BALLS      = " << std::setprecision(8) << MUE_BALLS);
    LOG("COLLISION_LOSS = " << std::setprecision(8) << COLLISION_LOSS);
    LOG("T_IMPULSE      = " << std::setprecision(8) << T_IMPULSE);
    LOG("GRAVITY        = " << std::setprecision(8) << GRAVITY);
    LOG("CONTACT_RADIUS = " << std::setprecision(8) << CONTACT_RADIUS);
    LOG("BALL_MASS      = " << std::setprecision(8) << BALL_MASS);
    LOG("FRAME_LENGTH   = " << std::setprecision(8) << FRAME_LENGTH);
    LOG("");
}

BilliardPhysics::~BilliardPhysics()
{
    for (int i=0; i<4; i++)
        delete mBorders[i];
    for (unsigned int i =0; i<mCollisions.size(); i++)
        delete mCollisions[i];
}

void BilliardPhysics::remove(Object * obj)
{/*{{{*/
    for (std::vector<Object*>::iterator it=mObjects.begin(); it != mObjects.end(); ++it)
    {
        if ((*it) == obj)
        {
            mObjects.erase(it);
            break;
        }
    }
}/*}}}*/


void BilliardPhysics::step()
{/*{{{*/
    LOG("physics step()");
    // load frame
    if (mLoadFile != "")
    {
        LOG("Loading frame...");
        std::stringstream s;
        mInFile.read(reinterpret_cast<char *>(&mTime), sizeof(float));
        unsigned int tmp;
        mInFile.read(reinterpret_cast<char *>(&tmp), sizeof(unsigned int));
        if (tmp != mObjects.size())
        {
            s << "Unexpected number of objects (" << tmp << ") in file \"" << mLoadFile << "\" ";
            s << "should be: " << mObjects.size();
            throw std::logic_error(s.str());
        }
        for (unsigned int i=0; i<mObjects.size(); i++)
        {
            mObjects[i]->readDump(mInFile);
        }
        return;
    }

    createCollisionList();
    dumpCollisions();   // FIXME DEBUG

    // collide all objects
    int nrcollisions = 0;
    std::vector<Collision *>    sameTime;
    while (mCollisions.size() > 0)
    {
        assert(mCollisions.at(0));
        LLOG("collecting");
        // collect collisions that happen at the same time
        sameTime.clear();
        sameTime.push_back(mCollisions[0]);
        unsigned int j = 1;
        while (j < mCollisions.size() && mCollisions[j]->time < sameTime[0]->time + EPSILON)
        {
            assert(mCollisions.at(j));
            sameTime.push_back(mCollisions[j]);
            j++;
        }

        LLOG("colliding");
        // collide all this objects
        for (unsigned int i = 0; i<sameTime.size(); i++)
        {
            assert(sameTime.at(i));
            sameTime[i]->collide();
            nrcollisions++;
        }

        LLOG("updating");
        // list is sorted -> we can update time of all objects and safely recalculate collisions
        for (unsigned int i=0; i<mObjects.size(); i++)
        {
            mObjects[i]->updateProperties(sameTime[0]->time);
        }
        updateCollisionList(sameTime);
    }
    LOG("processed " << nrcollisions << " collisions");

    LOG("update properties of " << mObjects.size() << " objects");
    // update properties of all objects for the next frame
    for (unsigned int i=0; i<mObjects.size(); i++)
    {
        mObjects[i]->updateProperties(mTime + FRAME_LENGTH);
#ifndef DOLOG
        LOG(mObjects[i]->name() << " : pos = " << mObjects[i]->position()
                << "  v = " << mObjects[i]->velocity() << "  w = " << mObjects[i]->angularVelocity());
#endif
    }
    mTime += FRAME_LENGTH;

    // dump frame
    if (mSaveFile != "")
    {
        LOG("Dumping frame...");
        mOutFile.write(reinterpret_cast<char *>(&mTime), sizeof(float));
        unsigned int tmp = mObjects.size();
        mOutFile.write(reinterpret_cast<char *>(&tmp), sizeof(unsigned int));
        for (unsigned int i=0; i<mObjects.size(); i++)
        {
            mObjects[i]->writeDump(mOutFile);
        }
        mOutFile.flush();
    }
}/*}}}*/


void BilliardPhysics::createCollisionList()
{/*{{{*/
    for (unsigned int i =0; i<mCollisions.size(); i++)
        delete mCollisions[i];
    mCollisions.clear();
    for (unsigned int i=0; i<mObjects.size(); i++)
    {
        // test for collisions between all balls
        for (unsigned int j=i+1; j<mObjects.size(); j++)
        {
            float time = mTime;
            if (willCollide(time, mObjects[i], mObjects[j]))
                mCollisions.push_back(new BallCollision(time, mObjects[i], mObjects[j]));
        }
        // test for collisions between balls and borders
        for (int j=0; j<4; j++)
        {
            float time = mTime;
            if (willHitBorder(time, mObjects[i], mBorders[j]))
                mCollisions.push_back(new BorderCollision(time, mObjects[i], mBorders[j]));
        }
    }
    std::sort(mCollisions.begin(), mCollisions.end(), Collision::compare);
}/*}}}*/


bool BilliardPhysics::willCollide(float & time, const Object * o1, const Object * o2) const
{/*{{{*/
    assert(o1);
    assert(o2);
    LLOG("testing possible collision of " << o1->name() << " vs " << o2->name() << "  time: " << std::setprecision(6) << time);
    if (!o1->applyPhysics() || !o2->applyPhysics())
        return false;
    assert(time >= -0.0f);
    assert(o1->time() <= time + EPSILON);
    assert(o2->time() <= time + EPSILON);
    assert(fabs(o1->time() - o2->time()) < EPSILON);

//    return false; // FIXME DEBUG

    // range check
    if (o1 == o2 || time < mTime || mTime + FRAME_LENGTH <= time)
        return false;
    // not moving balls
//    if (o1->velocity().length() < PHYS_EPS && o2->velocity().length() < PHYS_EPS)
//        return false;

    // simple formula for monotonic motion, since formula for accelerated motion yelds to
    // 4-th degree equation
    Vec3f dv = o1->velocity() - o2->velocity();
    Vec3f dp = o1->position() - o2->position();
    LLOG("dv : " << dv << " |dv| : " << dv.length() << "  dp : " << dp << " |dp| : " << dp.length());
    LLOG("v1 = " << o1->velocity() << " v2 = " << o2->velocity());
    if (dp.length() < BALL_RADIUS*2 - EPSILON)
    {
        // avoid numerical problems
        time = o1->time() + EPSILON;
        return true;
    }
    float a = dv.dot(dv);
    float b = 2*dp.dot(dv);
    float c = dp.dot(dp) - 4*BALL_RADIUS*BALL_RADIUS;
    float D = b*b - 4*a*c;
//    LOG("a : " << a << " b : " << b << " c : " << c << "  D : " << D);
    if (D < 0.0f)
        return false;
    D = sqrtf(D);
    float t1;
    float t2;
    if (fabs(a) > EPSILON)
    {
        t1 = (- b + D)*0.5f/a;
        t2 = (- b - D)*0.5f/a;
    }
    else
    {
        if (fabs(b) < EPSILON)
            return false;
        t1 = -c / b;
        t2 = -c / b;
    }
    t1 += o1->time();
    t2 += o2->time();

    LLOG("(" << mTime << " .. " << mTime + FRAME_LENGTH << ") time : " << time << "  t1 : " << t1 << " t2 : " << t2);
    // bounds check
    float t = t1;
    t1 = t1 < t2 ? t1 : t2;
    t2 = t < t2 ? t2 : t;
    LLOG("(" << mTime << " .. " << mTime + FRAME_LENGTH << ") time : " << time << "  t1 : " << t1 << " t2 : " << t2);
    if (time <= t1 && t1 <= mTime + FRAME_LENGTH)
    {
        time = t1 + EPSILON;
        return true;
    }
    if (time <= t2 && t2 <= mTime + FRAME_LENGTH)
    {
        time = t2 + EPSILON;
        return true;
    }
    return false;
}/*}}}*/


bool BilliardPhysics::willHitBorder(float & time, const Object * obj, const TableBorder * border) const
{/*{{{*/
    assert(obj);
    assert(border);
    LLOG("testing possible collision of " << obj->name() << " vs " << border->name() << " border  time: " << std::setprecision(6) << time);
    assert(time >= -0.0f);
    assert(obj->time() <= time + EPSILON);

//    return false;   // FIXME DEBUG

    if (time < mTime || mTime + FRAME_LENGTH <= time)
        return false;
    for (int i=0; i<4; i++)
        if (obj == mBorders[i])
            return false;

    // since borders are axis aligned, we only need to consider one dimension
    // assume monotonic motion FIXME calculate using friction force
    float t = INFINITY;
    if (border->xAligned())
    {
        // left or right
        if (fabs(obj->velocity().z()) > PHYS_EPS)
        {
            t = border->dist() - obj->position().z();
            LLOG("t = " << t);
            if (t * obj->velocity().z() > 0.0f && fabs(t) < BALL_RADIUS - EPSILON)
            {
                t = time - obj->time();
            }
            else
            {
                t = t < 0.0f ? t + BALL_RADIUS : t - BALL_RADIUS;
                t /= obj->velocity().z();
            }
        }
    }
    else
    {
        // top or bottom
        if (fabs(obj->velocity().x()) > PHYS_EPS)
        {
            t = border->dist() - obj->position().x();
            LLOG("t = " << t);
            if (t * obj->velocity().x() > 0.0f && fabs(t) < BALL_RADIUS - EPSILON)
            {
                t = time - obj->time();
            }
            else
            {
                t = t < 0.0f ? t + BALL_RADIUS : t - BALL_RADIUS;
                t /= obj->velocity().x();
            }
        }
    }
    t += obj->time();
    LLOG("(" << mTime << " .. " << mTime + FRAME_LENGTH << ") time : " << time << "  t : " << t);

    // range check
    if (time - EPSILON < t && t <= mTime + FRAME_LENGTH)
    {
        time = t + EPSILON;
        return true;
    }
    return false;
}/*}}}*/


void BilliardPhysics::updateCollisionList(const std::vector<Collision *> & clsns)
{/*{{{*/
    assert(clsns.size() > 0);
#ifdef DOLOG
    LLOG("collisions to update with:");
    for (unsigned int j = 0; j < clsns.size(); j++)
    {
        assert(clsns[j]);
        assert(clsns[j]->first);
        assert(clsns[j]->second);
        LLOG("clsn " << j << "  " << clsns[j]->dump());
    }
    LLOG(" # # # ");
    dumpCollisions();
#endif

    // delete invalid collisions
    std::vector<Collision *>    toFree(clsns);
    for (unsigned int i = 0; i < mCollisions.size(); )
    {
        bool notDeleted = true;
        for (unsigned int j = 0; j < clsns.size(); j++)
        {
            if (mCollisions[i]->isAffected(clsns[j]))
            {
                // remove
                toFree.push_back(mCollisions[i]);
                mCollisions[i] = mCollisions[mCollisions.size()-1];
                mCollisions.pop_back();
                notDeleted = false;
                break;
            }
        }
        if (notDeleted)
            i++;
    }

    LLOG("removed invalid collisions");
    dumpCollisions();   // FIXME DEBUG

    // add new collisions
    for (unsigned int i = 0; i < mObjects.size(); i++)
    {
        for (unsigned int j = 0; j < clsns.size(); j++)
        {
            LLOG("current (" << j << " / " << clsns.size() << ") collision: " << clsns.at(j)->dump());
            // collisions between balls
            float time = clsns[j]->time;
            Collision * cs[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
            if (willCollide(time, clsns[j]->first, mObjects[i])
                    && clsns[j]->second != mObjects[i]
                    && clsns[j]->time < time)
                cs[5] = new BallCollision(time, clsns[j]->first, mObjects[i]);

            time = clsns[j]->time;
            if (willCollide(time, clsns[j]->second, mObjects[i])
                    && clsns[j]->first != mObjects[i]
                    && clsns[j]->time < time)
                cs[4] = new BallCollision(time, clsns[j]->second, mObjects[i]);

            // test for collisions between balls and borders
            for (int k=0; k<4; k++)
            {
                time = clsns[j]->time;
                if (willHitBorder(time, mObjects[i], mBorders[k])
                        && (clsns[j]->first != mObjects[i] || clsns[j]->second != mBorders[k])
                        && clsns[j]->time < time)
                    cs[k] = new BorderCollision(time, mObjects[i], mBorders[k]);
            }

            // avoid readding of old collisions
            for (int l=0; l<6; l++)
            {
//                for (unsigned int k = 0; k < clsns.size(); k++)
//                {
//                    if (cs[l] && ((clsns[k]->first == cs[l]->first && clsns[k]->second == cs[l]->second)
//                                    || (clsns[k]->first == cs[l]->second && clsns[k]->second == cs[l]->first)))
//                    {
//                        delete cs[l];
//                        cs[l] = NULL;
//                    }
//                }
                if (cs[l])
                    mCollisions.push_back(cs[l]);
            }
        }
    }
    LLOG("unsorted");
    dumpCollisions();   // FIXME DEBUG
    // remove duplicates
    std::sort(mCollisions.begin(), mCollisions.end(), Collision::ucompare);
    LLOG("sorted by duplicates");
    dumpCollisions();   // FIXME DEBUG
    // free duplicated collisions
    Collision * last = NULL;
    for (unsigned int i = 0; i < mCollisions.size(); i++)
    {
        if (last && Collision::predicate(last, mCollisions[i]))
        {
            delete mCollisions[i];
            mCollisions[i] = NULL;
            continue;
        }
        else
        {
            last = mCollisions[i];
        }
        for (unsigned int j = 0; j < clsns.size(); j++)
        {
            if (Collision::predicate(clsns[j], mCollisions[i]))
            {
                delete mCollisions[i];
                mCollisions[i] = NULL;
            }
        }
    }
    mCollisions.erase(std::unique(mCollisions.begin(), mCollisions.end(), Collision::predicate), mCollisions.end());
    LLOG("deleted");
    dumpCollisions();   // FIXME DEBUG

    // sort by time
    std::sort(mCollisions.begin(), mCollisions.end(), Collision::compare);
    LLOG("sorted by time");
    dumpCollisions();   // FIXME DEBUG
    if (mCollisions.size() > 0 && !mCollisions[0])
    {
        std::vector<Collision *>::iterator endnull = mCollisions.begin();
        while (mCollisions.size() > 0 && endnull != mCollisions.end() && !*endnull)
            ++endnull;
        mCollisions.erase(mCollisions.begin(), endnull);
    }
    LLOG("no nulls");
    dumpCollisions();   // FIXME DEBUG

    // free memory
    LLOG("free memory");
    for (unsigned int j = 0; j < toFree.size(); j++)
    {
        LLOG(j << " / " << toFree.size() << "  " << toFree[j] << "  " << toFree[j]->dump());
    }
    std::sort(toFree.begin(), toFree.end());
    std::vector<Collision *>::iterator endit = std::unique(toFree.begin(), toFree.end());
    for (std::vector<Collision *>::iterator it = toFree.begin(); it != endit; ++it)
        delete *it;

    LLOG("added new collisions");
    dumpCollisions();   // FIXME DEBUG
    LLOG("\n");
}/*}}}*/

void BilliardPhysics::dumpCollisions() const
{/*{{{*/
#ifdef DOLOG
    LOG("dumping " << mCollisions.size() << " collisions:");
    for (unsigned int i = 0; i < mCollisions.size(); i++)
    {
        if (!mCollisions[i])
        {
            LOG(std::setw(3) << i << " : NULL");
        }
        else
        {
            LOG(std::setw(3) << i << " : " << mCollisions[i]->dump());
        }
    }
    LOG("\n");
#endif
}/*}}}*/


void BilliardPhysics::dumpToFile(const std::string & file)
{/*{{{*/
    if (mOutFile)
        mOutFile.close();
    mOutFile.clear();
    if (file == "")
        return;
    mOutFile.open(file.c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
    if (!mOutFile)
    {
        mSaveFile = "";
        throw std::logic_error("Can not open file \"" + file + "\" for physics");
    }
    mSaveFile = file;

    int magic = 0x31796870;
    mOutFile.write(reinterpret_cast<const char *>(&magic), sizeof(int));

    mOutFile.write(reinterpret_cast<const char *>(&BALL_RADIUS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&PHYS_EPS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&MUE_SLIDING), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&MUE_ROLLING), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&MUE_BALLS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&COLLISION_LOSS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&T_IMPULSE), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&GRAVITY), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&CONTACT_RADIUS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&BALL_MASS), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&SPREAD_POW), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&SPREAD_MAX_V), sizeof(float));
    mOutFile.write(reinterpret_cast<const char *>(&FRAME_LENGTH), sizeof(float));

    mOutFile.clear();
    mOutFile.flush();
}/*}}}*/


void BilliardPhysics::loadFromFile(const std::string & file)
{/*{{{*/
    if (mInFile)
        mInFile.close();
    mInFile.clear();
    if (file == "")
        return;
    mInFile.open(file.c_str(), std::ios::in | std::ios::binary);
    if (!mInFile)
    {
        mLoadFile = "";
        return;
    }

    // test type etc
    int magic = 0x31796870;
    float tmpf;
    std::stringstream strs;
    mInFile.read(reinterpret_cast<char *>(&magic), sizeof(int));
    if (magic != 0x31796870)
    {
        strs << "Unknown physics file format \"" << magic << "\", file: \"" << file << "\"";
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - BALL_RADIUS) > EPSILON)
    {
        strs << "BALL_RADIUS constant differ from built in, expected: " << std::setprecision(8) << BALL_RADIUS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - PHYS_EPS) > EPSILON)
    {
        strs << "PHYS_EPS constant differ from built in, expected: " << std::setprecision(8) << PHYS_EPS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - MUE_SLIDING) > EPSILON)
    {
        strs << "MUE_SLIDING constant differ from built in, expected: " << std::setprecision(8) << MUE_SLIDING;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - MUE_ROLLING) > EPSILON)
    {
        strs << "MUE_ROLLING constant differ from built in, expected: " << std::setprecision(8) << MUE_ROLLING;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - MUE_BALLS) > EPSILON)
    {
        strs << "MUE_BALLS constant differ from built in, expected: " << std::setprecision(8) << MUE_BALLS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - COLLISION_LOSS) > EPSILON)
    {
        strs << "COLLISION_LOSS constant differ from built in, expected: " << std::setprecision(8) << COLLISION_LOSS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - T_IMPULSE) > EPSILON)
    {
        strs << "T_IMPULSE constant differ from built in, expected: " << std::setprecision(8) << T_IMPULSE;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - GRAVITY) > EPSILON)
    {
        strs << "GRAVITY constant differ from built in, expected: " << std::setprecision(8) << GRAVITY;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - CONTACT_RADIUS) > EPSILON)
    {
        strs << "CONTACT_RADIUS constant differ from built in, expected: " << std::setprecision(8) << CONTACT_RADIUS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - BALL_MASS) > EPSILON)
    {
        strs << "BALL_MASS constant differ from built in, expected: " << std::setprecision(8) << BALL_MASS;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - SPREAD_POW) > EPSILON)
    {
        strs << "SPREAD_POW constant differ from built in, expected: " << std::setprecision(8) << SPREAD_POW;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - SPREAD_MAX_V) > EPSILON)
    {
        strs << "SPREAD_MAX_V constant differ from built in, expected: " << std::setprecision(8) << SPREAD_MAX_V;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mInFile.read(reinterpret_cast<char *>(&tmpf), sizeof(float));
    mInFile.clear();
    if (fabs(tmpf - FRAME_LENGTH) > EPSILON)
    {
        strs << "FRAME_LENGTH constant differ from built in, expected: " << std::setprecision(8) << FRAME_LENGTH;
        strs << " got: " << std::setprecision(8) << tmpf;
        throw std::logic_error(strs.str());
    }

    mLoadFile = file;
}/*}}}*/

---