SurfaceParams.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Physics/SurfaceParams.h>
#include <PVLE/Util/TracedException.h>

namespace Physics {

void SurfaceParams::mergeInto(const SurfaceParams & s1, const SurfaceParams & s2) {
    mode = 0;

    // approx
    // Rule used : If one is approx, then merge is approx
    if ((s1.mode & APPROX1_1) || (s2.mode & APPROX1_1)) mode |= APPROX1_1;
    if ((s1.mode & APPROX1_2) || (s2.mode & APPROX1_2)) mode |= APPROX1_2;

    // mu & mu2
    // Rule used : a*b - constant "PHY_INFINITY" is considered as mathematical infinity
    // Other ideas : (a+b)/2 - constant "PHY_INFINITY" is considered as mathematical infinity
    mu = (s1.mu == PHY_INFINITY || s2.mu == PHY_INFINITY) ? PHY_INFINITY : (s1.mu * s2.mu);
    //mu = (s1.mu == PHY_INFINITY || s2.mu == PHY_INFINITY) ? PHY_INFINITY : (s1.mu + s2.mu) / static_cast<dReal>(2);
    if ((s1.mode & MU2) || (s2.mode & MU2)) {
        mode |= MU2;
        if (s1.mu2 == PHY_INFINITY || s2.mu2 == PHY_INFINITY) mu2 = PHY_INFINITY;
        else mu2 = ((s1.mode & MU2 ? s1.mu2 : s2.mu2) * (s2.mode & MU2 ? s2.mu2 : s1.mu2));
        //else mu2 = ((s1.mode & MU2 ? s1.mu2 : s2.mu2) + (s2.mode & MU2 ? s2.mu2 : s1.mu2)) / static_cast<dReal>(2);
    }

    // bounce & bounce_vel
    // Rule used : Bounce param is (a+b)/2, bounce_vel is min(a,b)
    // Other ideas : bounce_vel is max(a,b) for faster/less precise simulation, or (a+b)/2 for intermediate
    if ((s1.mode & BOUNCE) || (s2.mode & BOUNCE)) {
        mode |= BOUNCE;
        bounce = ((s1.mode & BOUNCE ? s1.bounce : s2.bounce) + (s2.mode & BOUNCE ? s2.bounce : s1.bounce)) / static_cast<dReal>(2);
        bounce_vel = osg::minimum((s1.mode & BOUNCE ? s1.bounce_vel : s2.bounce_vel), (s2.mode & BOUNCE ? s2.bounce_vel : s1.bounce_vel));
    }

    // CFM
    // Rule used : 10^((log(a)+log(b)) /2)  - log median (ex : 1e-4 and 1e-2 => 1e-3)
    if ((s1.mode & SOFT_CFM) || (s2.mode & SOFT_CFM)) {
        mode |= SOFT_CFM;
        soft_cfm = powf(10, (log10f(s1.mode & SOFT_CFM ? s1.soft_cfm : s2.soft_cfm) + log10f(s2.mode & SOFT_CFM ? s2.soft_cfm : s1.soft_cfm)) /2.f);
    }
    // ERP
    // Rule used : (a+b)/2
    if ((s1.mode & SOFT_ERP) || (s2.mode & SOFT_ERP)) {
        mode |= SOFT_ERP;
        soft_erp = ((s1.mode & SOFT_ERP ? s1.soft_erp : s2.soft_erp) + (s2.mode & SOFT_ERP ? s2.soft_erp : s1.soft_erp)) / static_cast<dReal>(2);
    }

    // FDir1
    // Nothing to be done here, fdir1 is in Contact

    // Slip
    // Rule used : (a+b)/2
    if ((s1.mode & SLIP1) || (s2.mode & SLIP1)) {
        mode |= SLIP1;
        slip1 = ((s1.mode & SLIP1 ? s1.slip1 : s2.slip1) + (s2.mode & SLIP1 ? s2.slip1 : s1.slip1)) / static_cast<dReal>(2);
    }
    if ((s1.mode & SLIP2) || (s2.mode & SLIP2)) {
        mode |= SLIP2;
        slip2 = ((s1.mode & SLIP2 ? s1.slip2 : s2.slip2) + (s2.mode & SLIP2 ? s2.slip2 : s1.slip2)) / static_cast<dReal>(2);
    }

    // Motion
    // Rule used : ?
    if ((s1.mode & MOTION1) || (s2.mode & MOTION1)) { THROW_TRACED_EXCEPTION("Not implemented"); }
    if ((s1.mode & MOTION2) || (s2.mode & MOTION2)) { THROW_TRACED_EXCEPTION("Not implemented"); }
}

}   // namespace Physics

---