MercuryObjectCommands.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryObjectCommands.h"
#include "MercuryObject.h"
#include "MercuryUtil.h"
#include "MercuryMath.h"
#include "MercuryLog.h"

using namespace std;

//ObjectFunctions Registering system
AutoCommandRegisterer CommandRegisterer;

map< MString, vector< MercuryTween * > > MercuryTweenState::m_GlobalTweens;

MercuryTweenFunction AutoCommandRegisterer::GetFunction( const MString &name )
{
    if ((sMapFunctions == NULL) || (sMapFunctions->find( name ) == sMapFunctions->end() ))
        return NULL;

    return (*sMapFunctions)[name];
}

int AutoCommandRegisterer::RegisterFunction( MercuryTweenFunction fnct, const MString & name )
{
    if ( sMapFunctions == NULL )
        sMapFunctions = new map< MString, MercuryTweenFunction >;

    (*sMapFunctions)[name] = fnct;

    sNumFunctions++;

    return sNumFunctions;
}

MercuryTweenType AutoCommandRegisterer::GetTweenType( const MString &name )
{
    if ((sMapTweens == NULL) || (sMapTweens->find( name ) == sMapTweens->end() ))
        return NULL;

    return (*sMapTweens)[name];
}

int AutoCommandRegisterer::RegisterTweenType( MercuryTweenType fnct, const MString & name )
{
    if ( sMapTweens == NULL )
        sMapTweens = new map< MString, MercuryTweenType >;

    (*sMapTweens)[name] = fnct;

    sNumFunctions++;

    return sNumFunctions;
}

//Object Functions ( Actual Command, Name of Command, Forceful Typecast )
#define STD_COMMAND( x, y, z ) \
static void CMD##x( const float fPercent, const float fLastPercent, MercuryObject * pObject, MercuryTweenOperation * pOperation ) \
{ \
    float newloc; \
    if  ( pOperation->Parameters.PeekItem().GetType() == PSElement::PARAMETER ) {\
        newloc = pObject->Tweening.m_pCurrentTween->pKArgs.PeekItem( pOperation->Parameters.PeekItem().GetValueI() ).GetValueF(); \
    } else \
        newloc = pOperation->Parameters.PeekItem().GetValueF(); \
    float oldloc = pObject->Get##x(); \
    float diffloc = newloc-oldloc; \
    float totalmove = diffloc/(1-fLastPercent); \
    float fToMove = totalmove * ( fPercent - fLastPercent ); \
    pObject->Set##x( (z)( fToMove + oldloc ) ); \
} \
 \
static int FunctionNumberCMD##x = CommandRegisterer.RegisterFunction( CMD##x, y );

#define STD_FLOAT_COMMAND( x, y ) STD_COMMAND( x, y, float )

STD_FLOAT_COMMAND( X, "x" )
STD_FLOAT_COMMAND( Y, "y" )
STD_FLOAT_COMMAND( Z, "z" )
STD_FLOAT_COMMAND( RotX, "rotationx" )
STD_FLOAT_COMMAND( RotY, "rotationy" )
STD_FLOAT_COMMAND( RotZ, "rotationz" )
STD_FLOAT_COMMAND( ScaleX, "scalex" )
STD_FLOAT_COMMAND( ScaleY, "scaley" )
STD_FLOAT_COMMAND( ScaleZ, "scalez" )
STD_COMMAND( DrawOrder, "draworder", int )  //FIXME

//For object-specific commands, we have to register a special type of handler

static void ExecuteObjectCommand( const float fPercent, const float fLastPercent, MercuryObject * pObject, MercuryTweenOperation * pOperation ) 
{
    if ( fPercent == 1 )
    {
        PStack ret;
        pObject->Command( ret, pOperation->Command, pOperation->Parameters );
    }
}

static int FunctionNumberExecCommand = CommandRegisterer.RegisterFunction( ExecuteObjectCommand, "cmd" );

//Alpha is not an object-specific command and cannot be grouped as an STD_COMMAND, so we have to explicitly work on it
#define ADD_COLOR_COMMAND( x, y ) \
static void ADDCCMD##x( const float fPercent, const float fLastPercent, MercuryObject * pObject, MercuryTweenOperation * pOperation ) \
{ \
    MercuryColor newloc; \
    if ( pOperation->Parameters.PeekItem(0).GetType() == PSElement::PARAMETER ) \
        newloc.SetR( pObject->Tweening.m_pCurrentTween->pKArgs.PeekItem( pOperation->Parameters.PeekItem(0).GetValueI() ).GetValueF() ); \
    else \
        newloc.SetR( pOperation->Parameters.PeekItem(0).GetValueF() ); \
    if ( pOperation->Parameters.PeekItem(1).GetType() == PSElement::PARAMETER ) \
        newloc.SetG( pObject->Tweening.m_pCurrentTween->pKArgs.PeekItem( pOperation->Parameters.PeekItem(1).GetValueI() ).GetValueF() ); \
    else \
        newloc.SetG( pOperation->Parameters.PeekItem(1).GetValueF() ); \
    if ( pOperation->Parameters.PeekItem(2).GetType() == PSElement::PARAMETER ) \
        newloc.SetB( pObject->Tweening.m_pCurrentTween->pKArgs.PeekItem( pOperation->Parameters.PeekItem(2).GetValueI() ).GetValueF() ); \
    else \
        newloc.SetB( pOperation->Parameters.PeekItem(2).GetValueF() ); \
    if ( pOperation->Parameters.PeekItem(3).GetType() == PSElement::PARAMETER ) \
        newloc.SetA( pObject->Tweening.m_pCurrentTween->pKArgs.PeekItem( pOperation->Parameters.PeekItem(3).GetValueI() ).GetValueF() ); \
    else \
        newloc.SetA( pOperation->Parameters.PeekItem(3).GetValueF() ); \
 \
    MercuryColor oldloc = pObject->Get##x(); \
    MercuryColor diffloc = newloc-oldloc; \
    MercuryColor totalmove = diffloc*(1/(1-fLastPercent)); \
    MercuryColor fToMove = totalmove * ( fPercent - fLastPercent ); \
 \
    pObject->Set##x( fToMove + oldloc ); \
} \
 \
static int FunctionADDCCMD##x = CommandRegisterer.RegisterFunction( ADDCCMD##x, y );

ADD_COLOR_COMMAND( Diffuse, "diffuse" )
ADD_COLOR_COMMAND( Ambient, "ambient" )
ADD_COLOR_COMMAND( Emissive, "emissive" )
ADD_COLOR_COMMAND( Specular, "specular" )

#define ADD_COMMAND( x, y ) \
static void ADDCMD##x( const float fPercent, const float fLastPercent, MercuryObject * pObject, MercuryTweenOperation * pOperation ) \
{ \
    float diffloc = pOperation->Parameters.PeekItem().GetValueF(); \
    float oldloc = pObject->Get##x(); \
    float totalmove = diffloc*(fPercent-fLastPercent); \
    float fToMove = totalmove; \
    pObject->Set##x( fToMove + oldloc ); \
} \
 \
static int FunctionNumberADDCMD##x = CommandRegisterer.RegisterFunction( ADDCMD##x, y );

ADD_COMMAND( X, "addx" )
ADD_COMMAND( Y, "addy" )
ADD_COMMAND( Z, "addz" )
ADD_COMMAND( RotX, "addrotationx" )
ADD_COMMAND( RotY, "addrotationy" )
ADD_COMMAND( RotZ, "addrotationz" )

static void CommandHide( const float fPercent, const float fLastPercent, MercuryObject * pObject, MercuryTweenOperation * pOperation ) 
{ 
    bool hideON = (pOperation->Parameters.PeekItem().GetValueF() > 0.5f ); 
    if ( fPercent > 0.5f )
        pObject->SetHide( hideON ); 
} 
static int FunctionHideNumber = CommandRegisterer.RegisterFunction( CommandHide, "hide" );

//Register Linear and sleep
static float TweenLinear( const float fPercent, PStack & pArgs )
{
    return fPercent;
}

static float TweenSleep( const float fPercent, PStack & pArgs )
{
    if ( fPercent == 1 )
        return 1;
    else
        return 0;
}

static float TweenQuadratic( const float fPercent, PStack & pArgs )
{
    return powf(fPercent,pArgs.PeekItem().GetValueF());
}

static int FunctionNumberCMDlinear = CommandRegisterer.RegisterTweenType( TweenLinear, "linear" );
static int FunctionNumberCMDsleep = CommandRegisterer.RegisterTweenType( TweenSleep, "sleep" );
static int FunctionNumberCMDquadratic = CommandRegisterer.RegisterTweenType( TweenQuadratic, "quadratic" );

//The rest of the manager.


MercuryTween::MercuryTween() :
    fStart(0), fEnd(0) 
{
    //No code
    bDeleteChildren = true;
    iEndBase = -1;
}

MercuryTween::MercuryTween( const MercuryTween & rhs )
{
    for( unsigned i = 0; i < rhs.Operations.size(); i++ )
        Operations.push_back( new MercuryTweenOperation( *rhs.Operations[i] ) );
    fStart = rhs.fStart;
    fEnd = rhs.fEnd;
    pTT = rhs.pTT;
    pTArgs = rhs.pTArgs;
    pKArgs = rhs.pKArgs;
    bAutoDelete = rhs.bAutoDelete;
    bDeleteChildren = rhs.bDeleteChildren;
    iEndBase = rhs.iEndBase;
}

MercuryTween & MercuryTween::operator = ( const MercuryTween & rhs )
{
    for( unsigned i = 0; i < rhs.Operations.size(); i++ )
        Operations.push_back( new MercuryTweenOperation( *rhs.Operations[i] ) );
    fStart = rhs.fStart;
    fEnd = rhs.fEnd;
    pTT = rhs.pTT;
    pTArgs = rhs.pTArgs;
    pKArgs = rhs.pKArgs;
    bAutoDelete = rhs.bAutoDelete;
    bDeleteChildren = rhs.bDeleteChildren;
    iEndBase = rhs.iEndBase;
    return *this;
}

MercuryTween::~MercuryTween()
{
    if ( bDeleteChildren )
        for( unsigned i = 0; i < Operations.size(); i++ )
            SAFE_DELETE( Operations[i] );
}

void MercuryTween::Operate( const float fPercent, const float fLastPercent, MercuryObject * pObject )
{
    for ( unsigned i = 0; i < Operations.size(); i++ )
        Operations[i]->Function( fPercent, fLastPercent, pObject, Operations[i] );
}

MercuryTweenState::MercuryTweenState( )
    :m_fCurTime(0), m_bPauseTweening(false), m_bCloned( false )
{
        //No code
    m_fRunningEnd = 0;
    m_pCurrentTween = NULL;
}

MercuryTweenState::MercuryTweenState( const MercuryTweenState & rhs ) :
    m_fCurTime(rhs.m_fCurTime), 
    m_bPauseTweening(rhs.m_bPauseTweening),
    m_fRunningEnd(rhs.m_fRunningEnd), m_LocalTweens(rhs.m_LocalTweens),
    m_bCloned( true )
{
    MDequeIterator< MercuryTween *> i;
    for( i = m_qTweens.begin(); i != m_qTweens.end(); ++i )
        m_qTweens.push_back( new MercuryTween( *i.Data() ) );
    m_pCurrentTween = NULL;
}

MercuryTweenState & MercuryTweenState::operator = ( const MercuryTweenState & rhs )
{
    m_bCloned = true;
    m_bPauseTweening = rhs.m_bPauseTweening;
    m_fCurTime = rhs.m_fCurTime;
    m_fRunningEnd = rhs.m_fRunningEnd;
    m_LocalTweens = rhs.m_LocalTweens;
    MDequeIterator< MercuryTween *> i;
    for( i = rhs.m_qTweens.begin(); i != rhs.m_qTweens.end(); ++i )
        m_qTweens.push_back( new MercuryTween( *i.Data() ) );
    m_pCurrentTween = NULL;
    return *this;
}

MercuryTweenState::~MercuryTweenState()
{
    StopTweening();
    if( !m_bCloned )
    {
        map< MString, vector< MercuryTween * > >::iterator g = m_LocalTweens.begin();
        for( ; g != m_LocalTweens.end(); g++ )
        {
            for ( unsigned i = 0; i < (g->second).size(); i++ )
                SAFE_DELETE( (g->second)[i] );
        }
    }
}

void MercuryTweenState::AttachToObject( MercuryObject * object )
{
    m_pObject = object;
}

void MercuryTweenState::Update( float fDeltaTime )
{
    if ( !m_bPauseTweening ) 
        m_fCurTime += fDeltaTime;
    
    InternalUpdate( fDeltaTime );
}

void MercuryTweenState::FinishTweening()
{
    InternalUpdate( 0, true );
}

void MercuryTweenState::StopTweening()
{
    m_pCurrentTween = NULL;
    
    while ( !m_qTweens.empty() )
    {
        if ( m_qTweens.front()->bAutoDelete )
            SAFE_DELETE( m_qTweens.front() );
        m_qTweens.pop_front();
    }
}

void MercuryTweenState::InternalUpdate( float fDeltaTime, bool bFinish )
{
    while ( !m_qTweens.empty() )
    {
        if ( !m_pCurrentTween && (m_qTweens.front()->fStart <= m_fCurTime) )
            m_pCurrentTween = m_qTweens.front();
        
        if ( bFinish )
            if ( m_pCurrentTween->fEnd > m_fCurTime )
            {
                //If we move the time forward the next block of code should
                //complete and remove the current tween. The loop should
                // continue until all tweens have been completed and removed.
                fDeltaTime += ( m_pCurrentTween->fEnd - m_fCurTime );
                m_fCurTime = m_pCurrentTween->fEnd;
            }

        if ( m_pCurrentTween->fEnd <= m_fCurTime )
        {
            float curPercent = 1;
            float lastPercent = CalculateRemainingPercent( fDeltaTime );
    
            lastPercent = Clamp( lastPercent, 0.0f, 1.0f);
            m_pCurrentTween->Operate( curPercent, lastPercent, m_pObject );
            
            //remove tween from queue only when done
            m_qTweens.pop_front();
            if ( m_pCurrentTween->bAutoDelete )
                SAFE_DELETE( m_pCurrentTween );
            m_pCurrentTween = NULL;
        } else {
            float curPercent = CalculateCurrentPercent( fDeltaTime );
            float lastPercent = CalculateRemainingPercent( fDeltaTime );
                
            //Clamp high for bouncing.
            lastPercent = Clamp( lastPercent, 0.0f, 1000.0f );
            m_pCurrentTween->Operate( m_pCurrentTween->pTT(curPercent,m_pCurrentTween->pTArgs), 
                                    m_pCurrentTween->pTT(lastPercent,m_pCurrentTween->pTArgs), m_pObject );
            break;
        }
    }
}

float MercuryTweenState::CalculateRemainingPercent( float fDeltaTime )
{
    float percent, fDeltaTweenTime;
    percent = 0;
    fDeltaTweenTime = m_pCurrentTween->fEnd - m_pCurrentTween->fStart;
    if (fDeltaTweenTime > 0)
        percent = ( m_fCurTime - fDeltaTime - m_pCurrentTween->fStart ) / fDeltaTweenTime ;
    return percent;
}

float MercuryTweenState::CalculateCurrentPercent( float fDeltaTime )
{
    float percent, fDeltaTweenTime;
    percent = 0;
    fDeltaTweenTime = m_pCurrentTween->fEnd - m_pCurrentTween->fStart;
    if (fDeltaTweenTime > 0)
        percent = ( m_fCurTime - m_pCurrentTween->fStart ) / fDeltaTweenTime ;
    return percent;
}

void MercuryTweenState::ExecuteCommand( const MString & sName, const PStack & pKArgs )
{
    vector< MercuryTween * > * AllTweens = NULL;
    if ( m_LocalTweens.find( sName ) == m_LocalTweens.end() )
    {
        if ( m_GlobalTweens.find( sName ) == m_GlobalTweens.end() )
            AllTweens = NULL;
        else
            AllTweens = &m_GlobalTweens[sName];
    } else
        AllTweens = &m_LocalTweens[sName];

    if ( AllTweens == NULL )
        return;

    vector< MercuryTween * >::iterator g = AllTweens->begin();
    for ( ; g != AllTweens->end(); g++ )
    {
        MercuryTween * Copied = new MercuryTween;
        //(*Copied) = (*(*g));
        if ( (*g)->iEndBase >= 0 )
            Copied->fEnd = pKArgs.PeekItem( (*g)->iEndBase ).GetValueF();
        else
            Copied->fEnd = (*g)->fEnd;
        Copied->fStart = 0;
        Copied->pTT = (*g)->pTT;
        Copied->pTArgs = (*g)->pTArgs;
        Copied->Operations = (*g)->Operations;
        Copied->pKArgs = pKArgs;
        Copied->bAutoDelete = true;
        Copied->bDeleteChildren = false;
        AddCommand( Copied );
    }
}

void MercuryTweenState::AddCommand( MercuryTween * ToPush, float fFuture, SPACE iWhichPlace, MString sTweenName )
{
    if ( m_qTweens.size() > 0 )
    {
        ToPush->fStart += m_fRunningEnd;
        ToPush->fEnd += m_fRunningEnd;
    } else if ( fFuture >= 0 )
    {
        ToPush->fStart += m_fCurTime;
        ToPush->fEnd += ToPush->fStart;  //Relitive to when the start ends, I think.
    }
    
    switch ( iWhichPlace )
    {
    case CURRENT:
        ToPush->bAutoDelete = true;
        m_qTweens.push_back( ToPush );
        break;
    case LOCAL:
        ToPush->bAutoDelete = false;
        m_LocalTweens[sTweenName].push_back( ToPush );
        break;
    case GLOBAL:
        ToPush->bAutoDelete = false;
        m_GlobalTweens[sTweenName].push_back( ToPush );
        break;
    default:
        LOG.Warn( "Requested AddCommand to non-existant tween 'place'.  This tween will leak." );
        break;
    };
    
    m_fRunningEnd = ToPush->fEnd;
    
    //If we have just added the first tween and it is immediate,
    //run an update so the tween is initalized. This fixes the
    //problem of objects being in the wrong place for the very
    //first frame of an animation.
    if ( (m_qTweens.size() == 1) && (fFuture <= 0.0f) )
        InternalUpdate( 0 );
}


//HEAVILY OPTIMIZED!
//
//Noted slow downs: There does not exist a atof() that takes on a length
//parameter.  We have to copy the string into a new string in order to send
//it in.

void MercuryTweenState::AddCommand( const MString & command, SPACE iWhichPlace, MString sTweenName )
{
    const char *sCmd = command.c_str();
    const char *sEnd = sCmd + command.length();
    const char *sNext = 0;
    const char *sCur = sCmd;
    const char *sNextComma = 0;
    char    *   sTmp;
    unsigned int            iTmp;
    bool        bHasNextPart;
    MString     sBaseCmd;
    MercuryTween * cs = new MercuryTween;
    cs->fEnd = -1;

    //First if we are writing to a cache buffer, we have to clear it out.
    switch ( iWhichPlace )
    {
    case LOCAL:
        for ( iTmp = 0; iTmp < m_LocalTweens[sTweenName].size(); ++iTmp )
            SAFE_DELETE( m_LocalTweens[sTweenName][iTmp] );
        m_LocalTweens[sTweenName].clear();
        break;
    case GLOBAL:
        for ( iTmp = 0; iTmp < m_GlobalTweens[sTweenName].size(); ++iTmp )
            SAFE_DELETE( m_GlobalTweens[sTweenName][iTmp] );
        m_GlobalTweens[sTweenName].clear();
        break;
    default:
        break;
    }

    //Make sure we aren't past the end, and we aren't at/beyond the real end.
    while ( sCur < sEnd && sCur[0] != '\0' )
    {
        //Find next ; in string.  If it's past the end of the string, say it's at the end
        sNext = strchr( sCur, ';' );
        if ( !sNext )
            sNext = sEnd;

        //Find the next comma.  If it's beyond the end of the string, say it's at the end
        //and set a flag
        sNextComma = strchr( sCur, ',' );
        if ( sNextComma > sNext || !sNextComma )
        {
            bHasNextPart = false;
            sNextComma = sNext;
        } else
            bHasNextPart = true;

        //Clear out the base command, and stick in the other info.
        sBaseCmd.assign( sCur, sNextComma - sCur );

        //Say we're currently after the previous command's comma
        //IE:    sBaseCmd,[here],...
        sCur = sNextComma+1;

        //Check to see if we have functions or tween types
        MercuryTweenFunction fnct = CommandRegisterer.GetFunction( sBaseCmd );
        MercuryTweenType typ = CommandRegisterer.GetTweenType( sBaseCmd );

        //(Remaining = Current -> sNext - sCur)

        //SPECIAL: If we start without knowing what kind of tween type to use
        // we MUST set one, otherwise our tween may be thrown out, or we may 
        // try tweening from an unknown state.  So, we set up a dummy tween.
        if ( typ == NULL && cs->fEnd < 0 )
        {
            cs->fEnd = 0;
            cs->pTT = CommandRegisterer.GetTweenType( "sleep" );
            cs->fStart = 0;
        }

        if ( typ != NULL )
        {
            //We have a tween type

            //Check to see if cs contains a tween
            if ( cs->fEnd >= 0 )
            {
                //If so add it to this.
                AddCommand( cs, 0, iWhichPlace, sTweenName );
                cs = new MercuryTween;
            }

            //Set the tween type
            cs->pTT = typ;

            //If we have no more parts, don't bother processing for fEnd
            if ( !bHasNextPart )
            {
                cs->fEnd = 0;
                cs->pTArgs.Clear();
            } else {
                //Otherwise process for end
                sNextComma = strchr( sCur, ',' );
                if ( sNextComma > sNext || !sNextComma )
                    sNextComma = sNext;

                iTmp = sNextComma - sCur;
                sTmp = (char*)malloc( sNextComma - sCur + 1 );
                strncpy( sTmp, sCur, iTmp );
                sTmp[iTmp] = '\0';
                cs->fEnd = float(atof( sTmp ));
                if ( sTmp[0] == '%' )
                    cs->iEndBase = atoi( sTmp+1 );
                free( sTmp );
                sCur = sNextComma+1;

                //Add on any additional arguments.  This is "safe"
                cs->pTArgs = PStack( sCur, sNext - sCur );

                if( sCur < sNext )
                    sCur = sNext + 1;
            }
        } else if ( fnct != NULL ) {
            MercuryTweenOperation * k = new MercuryTweenOperation;
            k->Function = fnct;

            //Dump on any additional parameters.
            k->Parameters = PStack( sCur, sNext - sCur );

            //If we have farther to go, move up to right after the next ;
            if ( sCur <= sNext )
                sCur = sNext + 1;
            cs->Operations.push_back(k);
        } else {
            fnct = CommandRegisterer.GetFunction( "cmd" );
            if ( fnct == NULL )
                LOG.Warn( "The object commands function \"cmd\" has not been registered!  Your compile may be bad" );
            else
            {
                MercuryTweenOperation *k = new MercuryTweenOperation;
                k->Function = fnct;
                k->Command = sBaseCmd;
                k->Parameters = PStack( sCur, sNext - sCur );
                if ( sCur <= sNext )
                    sCur = sNext + 1;
                cs->Operations.push_back(k);
            }
        }
    }
    if ( cs->fEnd < 0 )
        cs->fEnd = 0;
    if ( ( cs->Operations.size() > 0 ) || (cs->fEnd > 0) )
        AddCommand( cs, 0, iWhichPlace, sTweenName );
    else
        SAFE_DELETE( cs );
}

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the <ORGANIZATION> nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by