mathlib_extra.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2020 UFO: Alien Invasion.

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 2
of the License, or (at your option) any later version.

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "mathlib_extra.h"
#include <math.h>

double FpCurveUp (double fpVal, double mEffect)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));

    fpVal = ((2.0 - mEffect) * fpVal) / ((1.0 - mEffect) + fpVal);

    return fpVal;
}

double FpCurveDn (double fpVal, double mEffect)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));

    fpVal = 1.0 - fpVal;
    fpVal = ((2.0 - mEffect) * fpVal) / ((1.0 - mEffect) + fpVal);
    fpVal = 1.0 - fpVal;

    return fpVal;
}

double FpCurveUpRs (double fpVal, double mEffect)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));

    fpVal = (((2.0 - mEffect) * fpVal) / ((1.0 - mEffect) + fpVal)) + fpVal;
    fpVal *= 0.50;

    return fpVal;
}

double FpCurveDnRs (double fpVal, double mEffect)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));

    fpVal = 1.0 - fpVal;
    fpVal = (((2.0 - mEffect) * fpVal) / ((1.0 - mEffect) + fpVal)) + fpVal;
    fpVal *= 0.50;
    fpVal = 1.0 - fpVal;

    return fpVal;
}

double FpCurve1D_u_in (double fpVal, double mEffect, double cntPnt)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));
    cntPnt = std::min(DENORM_INV, std::max(DENORM, cntPnt));

    if (fpVal > cntPnt) {
        double fpVal_mod = (fpVal - cntPnt) / (1.0 - cntPnt);

        fpVal_mod = FpCurveDn(fpVal_mod, mEffect);
        fpVal_mod *= 1.0 - cntPnt;
        fpVal_mod += cntPnt;
        return fpVal_mod;
    }
    if (fpVal < cntPnt) {
        double fpVal_mod = (cntPnt - fpVal) / cntPnt;

        fpVal_mod = FpCurveDn(fpVal_mod, mEffect);
        fpVal_mod *= cntPnt;
        fpVal_mod = cntPnt - fpVal_mod;
        return fpVal_mod;
    }
    /* fpVal = cntPnt, so no change */
    return fpVal;
}

double FpCurve1D_u_out (double fpVal, double mEffect, double cntPnt)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));
    cntPnt = std::min(DENORM_INV, std::max(DENORM, cntPnt));

    if (fpVal > cntPnt) {
        double fpVal_mod = (fpVal - cntPnt) / (1.0 - cntPnt);

        fpVal_mod = FpCurveUp(fpVal_mod, mEffect);
        fpVal_mod *= 1.0 - cntPnt;
        fpVal_mod += cntPnt;
        return fpVal_mod;
    }
    if (fpVal < cntPnt) {
        double fpVal_mod = (cntPnt - fpVal) / cntPnt;

        fpVal_mod = FpCurveUp(fpVal_mod, mEffect);
        fpVal_mod *= cntPnt;
        fpVal_mod = cntPnt - fpVal_mod;
        return fpVal_mod;
    }
    /* fpVal = cntPnt, so no change */
    return fpVal;
}

double FpCurve1D_s_out (double fpVal, double mEffect)
{
    /* If there isn't any "curve" to skew fpVal with (flat, straight line), we can stop right here (no change). */
    if (mEffect == 0.0)
        return fpVal;

    /* Safe values only please, to avoid breaking things */
    fpVal = std::min(DENORM_INV, std::max(DENORM, fpVal));
    mEffect = std::min(DENORM_INV, std::max(DENORM, mEffect));

    fpVal = ((2.0 - mEffect) * fpVal) / ((1.0 - mEffect) + fabs(fpVal));

    return fpVal;
}

float FpUcurve_f(const float inpVal, const float hard)
{
    return (float) ( inpVal >= 0.f ? (inpVal * (hard+inpVal) / (1.f + (hard*inpVal) + (inpVal*inpVal))) :
                    (inpVal * (hard-inpVal) / (1.f - (hard*inpVal) + (inpVal*inpVal))) );
}

double FpUcurve_d(const double inpVal, const double hard)
{
    return (double) ( inpVal >= 0.0 ? (inpVal * (hard+inpVal) / (1.0 + (hard*inpVal) + (inpVal*inpVal))) :
                    (inpVal * (hard-inpVal) / (1.0 - (hard*inpVal) + (inpVal*inpVal))) );
}

float FpUcurveSc_f(const float inpVal, const float hard, const float scale)
{
    return (float) ( inpVal >= 0.f ? (inpVal * (hard+inpVal) / (scale + (hard*inpVal) + (inpVal*inpVal))) :
                    (inpVal * (hard-inpVal) / (scale - (hard*inpVal) + (inpVal*inpVal))) );
}

double FpUcurveSc_d(const double inpVal, const double hard, const double scale)
{
    return (double) ( inpVal >= 0.0 ? (inpVal * (hard+inpVal) / (scale + (hard*inpVal) + (inpVal*inpVal))) :
                    (inpVal * (hard-inpVal) / (scale - (hard*inpVal) + (inpVal*inpVal))) );
}