Globals.h

Go to the documentation of this file.

/************************************************************************
* Verve                                                                 *
* Copyright (C) 2004-2006                                               *
* Tyler Streeter  tylerstreeter@gmail.com                               *
* All rights reserved.                                                  *
* Web: http://verve-agents.sourceforge.net                              *
*                                                                       *
* This library is free software; you can redistribute it and/or         *
* modify it under the terms of EITHER:                                  *
*   (1) The GNU Lesser General Public License as published by the Free  *
*       Software Foundation; either version 2.1 of the License, or (at  *
*       your option) any later version. The text of the GNU Lesser      *
*       General Public License is included with this library in the     *
*       file license-LGPL.txt.                                          *
*   (2) The BSD-style license that is included with this library in     *
*       the file license-BSD.txt.                                       *
*                                                                       *
* This library 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 files    *
* license-LGPL.txt and license-BSD.txt for more details.                *
************************************************************************/

#ifndef VERVE_GLOBALS_H
#define VERVE_GLOBALS_H

#include "Defines.h"

class TiXmlNode;

namespace verve
{
        namespace globals
        {
                inline real abs(real value)
                {
#ifdef VERVE_USE_DOUBLE
                        return ::fabs(value);
#else
                        return ::fabsf(value);
#endif
                }

                inline real sqrt(real value)
                {
#ifdef VERVE_USE_DOUBLE
                        return ::sqrt(value);
#else
                        return ::sqrtf(value);
#endif
                }

                inline real exp(real exponent)
                {
#ifdef VERVE_USE_DOUBLE
                        return ::exp(exponent);
#else
                        return ::expf(exponent);
#endif
                }

                inline real pow(real base, real exponent)
                {
#ifdef VERVE_USE_DOUBLE
                        return ::pow(base, exponent);
#else
                        return ::powf(base, exponent);
#endif
                }

                inline int roundToInt(real value)
                {
                        int nearestInt = (int)value;
                        real fraction = value - (real)nearestInt;
                        if (value < 0)
                        {
                                if (fraction <= (real)-0.5)
                                {
                                        --nearestInt;
                                }
                        }
                        else
                        {
                                if (fraction >= (real)0.5)
                                {
                                        ++nearestInt;
                                }
                        }

                        return nearestInt;
                }

                inline real checkParamValid(real value, real rangeMin, 
                        real rangeMax, const std::string& callingFunction)
                {
                        const real initialValue = value;
                        bool invalid = false;

                        if (value < rangeMin)
                        {
                                value = rangeMin;
                                invalid = true;
                        }
                        else if (value > rangeMax)
                        {
                                value = rangeMax;
                                invalid = true;
                        }

                        if (invalid)
                        {
                                VERVE_LOGGER("warning") << callingFunction << ": " 
                                        << "Actual value " << initialValue << " should be " 
                                        << "within [" << rangeMin << ", " << rangeMax << "].  " 
                                        << "The value will be clamped." << std::endl;
                        }

                        return value;
                }

                inline real calcDecayConstant(real decayPercent, real decayTime, 
                        real dt)
                {
                        // 'decayPercent' values greater than 1 are bad because they 
                        // would present the pow function with a negative base.
                        assert(decayPercent <= 1);

                        // A 'decayPercent' value of 1 means that we are decaying the 
                        // value to 0 in one step, so we just return a constant of 0.  
                        // A 'decayTime' value of 0 gives us a divide by zero error 
                        // later; since a 'decayTime' of 0 actually means we are 
                        // decaying the value instantly, we just return a constant of 0.
                        if (1 == decayPercent || 0 == decayTime)
                        {
                                return 0;
                        }

                        return globals::pow(1 - decayPercent, dt / decayTime);
                }

                inline real calcDecayConstant(real timeConstant, real dt)
                {
                        return calcDecayConstant(1 - VERVE_E, -timeConstant, dt);
                }

                // Note: this decay method avoids using the pow function, but it 
                // is too unstable when decayRate is 0 or >= 1
                //inline real calcDecayConstant2(real decayRate, real dt)
                //{
                //      return (1 - dt/(1-decayRate));
                //}

                inline bool randomBool()
                {
                        if (rand() % 2 == 0)
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                inline int randomIntUniform(int min, int max)
                {
                        return int((max - min + 1) * rand() / (RAND_MAX + 1.0)) + min;
                }

                inline real randomRealUniform(real min, real max)
                {
                        return (real)rand() / RAND_MAX * (max - min) + min;
                }

                inline real randomRealGauss(real variance)
                {
                        static int iset = 0;
                        static real gset;
                        real fac, rsq, v1, v2;

                        if (0 == iset)
                        {
                                do
                                {
                                        static const real invDenominator = 
                                                1 / (RAND_MAX + (real)1.0);
                                        v1 = (real)2.0 * (rand() * invDenominator) - (real)1.0;
                                        v2 = (real)2.0 * (rand() * invDenominator) - (real)1.0;
                                        rsq = v1 * v1 + v2 * v2;
                                }
                                while (rsq >= 1.0 || rsq == 0.0);

                                fac = globals::sqrt((real)-2.0 * log(rsq) / rsq);
                                gset = v1 * fac;
                                iset = 1;
                                return v2 * fac * variance;
                        }
                        else
                        {
                                iset = 0;
                                return gset * variance;
                        }
                }

                inline real scaleZeroToOne(real value, real rangeMin, 
                        real rangeMax)
                {
                        assert(rangeMax >= rangeMin);

                        if (rangeMax == rangeMin)
                        {
                                return 0;
                        }

                        if (value >= rangeMax)
                        {
                                return 1;
                        }

                        if (value <= rangeMin)
                        {
                                return 0;
                        }

                        // Calculate the range, which will always be positive.
                        real range = rangeMax - rangeMin;

                        // Shift the value to be correctly positioned within the new 
                        // range.
                        value -= rangeMin;

                        // Normalize the value to be between 0 and 1.
                        value = value / range;

                        return value;
                }

                inline real scaleNegOneToOne(real value, real rangeMin, 
                        real rangeMax)
                {
                        if (rangeMax == rangeMin)
                        {
                                return 0;
                        }

                        value = scaleZeroToOne(value, rangeMin, rangeMax);

                        // Map the normalized value to [-1, 1].
                        value = (2 * value) - 1;

                        return value;
                }

                real VERVE_CALL getAttributeReal(const TiXmlNode* nodePtr, 
                        const std::string& name);

                int VERVE_CALL getAttributeInt(const TiXmlNode* nodePtr, 
                        const std::string& name);

                bool VERVE_CALL getAttributeBool(const TiXmlNode* nodePtr, 
                        const std::string& name);

                std::string VERVE_CALL getAttributeString(const TiXmlNode* nodePtr, 
                        const std::string& name);
        }
}

#endif

---