ScreenFPS.cpp

Go to the documentation of this file.

#include "ScreenFPS.h"
#include "MercuryDisplay.h"
#include "MercuryTheme.h"
#include "MercuryInput.h"
#include "MercuryShapes.h"
#include "MercuryLog.h"
#include "MercuryTextureManager.h"
#include "MercurySoundSourceWAV.h"

KeyMappingWithCode( button_a, "0-97" );
KeyMappingWithCode( button_b, "0-98" );
KeyMappingWithCode( button_s, "0-115" );
KeyMappingWithCode( button_d, "0-100" );
KeyMappingWithCode( button_w, "0-119" );
KeyMappingWithCode( button_mouse1, "0-1" );
KeyMappingWithCode( button_mouse2, "0-2" );
KeyMappingWithCode( button_u, "0-117" );
KeyMappingWithCode( button_t, "0-116" );
KeyMappingWithCode( button_space, "0-32" );

REGISTER_SCREEN_CLASS( ScreenFPS );

#define     MC_INPUTMAPPED      1       //convention: MESSAGE CODE
#define     MC_EXPLOSION        2       //convention: MESSAGE CODE

ScreenFPS::~ScreenFPS()
{
    m_pCamera = NULL;
}

void ScreenFPS::Init()
{
    ScreenOutdoors::Init();

    pTweenCommands.resize(4);
    pTweenCommands[0].sAnimationName = "run_lower";
    pTweenCommands[0].fPercent = .5;
    pTweenCommands[1].sAnimationName = "run_upper";
    pTweenCommands[1].fPercent = .25;

    pTweenCommands[2].sAnimationName = "shootright_upper";
    pTweenCommands[2].bLoop = pTweenCommands[2].bRunning = false;
    pTweenCommands[3].sAnimationName = "shootleft_upper";
    pTweenCommands[3].fRate = 2;
    pTweenCommands[3].bLoop = pTweenCommands[3].bRunning = false;

    m_pPlayer.SetName( "jupiter" );
    m_pPlayer.Init();
    m_pPlayer.SetRotX( 90 );
    m_pPlayer.SetScale( MercuryPoint( 0.1f,0.1f,0.1f ) );
    m_pPlayer.Load( GET_MODEL_BY_NAME( "jupiter" ) );
    m_pPlayer.SetAnimationState( pTweenCommands );
    AddPerspObject( &m_pPlayer );

    pBullet.SetName( "BULLET" );
    pBullet.Init();
    pBullet.NotifyClass( this, "rayhit" );
    pBullet.SetDrawOrder( 10000 );
    AddPerspObject( &pBullet, false );

    m_Aimer.SetName( "BULLET Aimer" );
    m_Aimer.Init();
    m_Aimer.NotifyClass( this, "aimhit" );
    m_oldInter = m_interactable = false;
    fClosestAimerObject = 100000;

    m_closestHitObjectDistance = 100000;
    m_runObjectHitCode = false;

    pPhysics.SetName( "PHYSGUN" );
    pPhysics.Init();
    pPhysics.NotifyClass( this, "physhit" );
    pPhysics.SetDrawOrder( 10000 );
    AddPerspObject( &pPhysics, false );
    iPhysicsObject = 0;
    fClosestPhysicsObject = 100000;

    m_pINI.Open( GET_FILE_BY_NAME( "IniFile" ) );

    m_pWorld.Init();
    m_pWorld.LoadFromINI( m_pINI, THEME.GetMetricS( m_name, "WorldName" ) );
    AddPerspObject( &m_pWorld );

    m_fCamera.SetName( "Camera" );
    m_fCamera.Init();
    m_fCamera.SetUp(MercuryPoint(0,0,1));
    m_pCamera = &m_fCamera;
    m_fCamera.Tweening.AddCommand( THEME.GetMetricS( m_name, "CamTween" ), MercuryTweenState::LOCAL, "CamTween" );

    m_fTimeSinceLastShot = 0;
    m_fForwardMovement = 0;

    m_bFPS = true;
    m_sprCrosshairs.SetName( "Crosshairs" );
    m_sprCrosshairs.Init();
    m_sprCrosshairs.LoadImage( "GRAPHIC:targetret2.png" );
    m_sprCrosshairs.SetPosition( MercuryPoint( 320,240, 0 ) );
    m_sprCrosshairs.SetDrawOrder( 10001 );
    m_sprCrosshairs.Tweening.AddCommand( THEME.GetMetricS( m_name, "CrosshairsOnTarget" ), MercuryTweenState::LOCAL, "OnTarget" );
    m_sprCrosshairs.Tweening.AddCommand( THEME.GetMetricS( m_name, "CrosshairsOffTarget" ), MercuryTweenState::LOCAL, "OffTarget" );
    m_sprCrosshairs.Tweening.ExecuteCommand("OffTarget", PStack());
    AddOrthoObject( &m_sprCrosshairs );

    m_sprCrosshairsCenter.SetName( "CrosshairsCenter" );
    m_sprCrosshairsCenter.Init();
    m_sprCrosshairsCenter.LoadImage( "GRAPHIC:targetret.png" );
    m_sprCrosshairsCenter.SetPosition( MercuryPoint( 320,240, 0 ) );
    m_sprCrosshairsCenter.SetDrawOrder( 10000 );
    AddOrthoObject( &m_sprCrosshairsCenter );

    RegisterMessage( MC_INPUTMAPPED, "mappedinput" );
    RegisterMessage( MC_EXPLOSION, "DoExplosion" );
    m_slowDown = false;
    m_fistExplosion = m_donefirst = false;

    Tweening.AddCommand(THEME.GetMetricS( GetName(), "BlastParticle" ) , MercuryTweenState::GLOBAL, "BlastParticle" ) ;

    MercuryObject* instructions = new MercuryObject;
    instructions->Init();
    instructions->SetName("Instructions");
    unsigned int num = THEME.GetMetricI( GetName(), "NumInstructions" );
    unsigned int space = 0;
    for (unsigned int i = 0; i < num; ++i)
    {
        MercuryText* t = new MercuryText;

//      t->SetName(ssprintf("Instruction%d", i));
        t->Init();
        t->SetFont(THEME.GetMetricS( GetName(), "Font" ));
        t->SetSize(THEME.GetMetricI( GetName(), "FontSize" ));
        t->MoveY(space);
        t->SetText(THEME.GetMetricS( GetName(), ssprintf("Instruction%d", i)));
        instructions->AddObject(t, true);
        space += THEME.GetMetricI( GetName(), "InstructionSpace" );
    }
    instructions->Tweening.AddCommand(THEME.GetMetricS( GetName(), instructions->GetName() + "Tween" ));
    AddOrthoObject(instructions, true);
    
    MercurySoundSourceWAV* music = new MercurySoundSourceWAV;
    music->Open("FILE:test.wav");
    music->Play();
}

void ScreenFPS::CalculateMovement(MercuryODEObject* control)
{
    int dx=0;
    int dy=0;
    if ( INPUTMAN->IsButtonDown( button_d ) )
        dy -= 5;
    if ( INPUTMAN->IsButtonDown( button_a ) )
        dy += 5;
    if ( INPUTMAN->IsButtonDown( button_w ) )
        dx += 5;
    if ( INPUTMAN->IsButtonDown( button_s ) )
        dx -= 5;

    float Amplitude = SQRT(float((dx*dx)+(dy*dy)));
    float AngleToGo=ATAN2(float(dx),float(-dy));

    MercuryPoint Target = m_pWorld.GetODEObjectByName( "Control" )->GetPosition();
    MercuryPoint From = Target - pTarget;

    float AngleDiff=ATAN2((From-Target).x,(From-Target).y);
    float RealAngle = AngleToGo - AngleDiff - 1.57f;

    dBodyEnable( control->m_oBody );
    dBodySetAngularVel( control->m_oBody, COS(RealAngle)*Amplitude,SIN(RealAngle)*Amplitude,0); 
    
    //Handle Jumping
    if( INPUTMAN->IsButtonDown( button_space ) )
    {
        dBodyAddForce( control->m_oBody, SIN(RealAngle)*Amplitude*800,-COS(RealAngle)*Amplitude*800,3900 );
    }

    //Now, Update the robot's animations
    PlayRobotAnimations(dx);
}

void ScreenFPS::PlayRobotAnimations(int dx)
{
    if (m_fForwardMovement > 0 )
        m_fForwardMovement = (m_fForwardMovement + float(dx)/50) - 0.025f;
    else
        m_fForwardMovement = (m_fForwardMovement + float(dx)/50) + 0.025f;

    m_fForwardMovement = Clamp( m_fForwardMovement, -1.0f, 1.0f );

    if( m_fForwardMovement < 0.05 && m_fForwardMovement > -0.05f )
        m_fForwardMovement = 0;

    m_pPlayer.GetAllAnimationStates( pTweenCommands );
    pTweenCommands[0].fPercent = m_fForwardMovement;
    pTweenCommands[0].fRate = ABS(m_fForwardMovement)*1.5f;
    pTweenCommands[1].fPercent = m_fForwardMovement/2;
    pTweenCommands[1].fRate = ABS(m_fForwardMovement)*1.5f;

    if( m_fTimeSinceLastShot == 0 )
        pTweenCommands[3].Trigger();

    m_pPlayer.SetAnimationState( pTweenCommands );
}

void ScreenFPS::Update( const float dTime )
{
    if (dTime == 0)
        return;

    if ( m_bFirstUpdate )
    {
        m_bFirstUpdate = false;
        return;
    }

    float adjTime = dTime;
    if (m_slowDown > 0)
    {
        m_slowDown -= dTime;
        adjTime /= 5;
    }

    if ((m_slowDown <= 0) && m_fistExplosion)
    {
        m_donefirst = true;
        m_slowDown = 0;
    }

    //hack to move water
    MercuryODEObjectLoadable* water = (MercuryODEObjectLoadable*)m_pWorld.GetODEObjectByName("Water");
    if (water)
    {
        water->GetGLState().Disable(MGLS_OPAQUE);
        MercuryShape* s = (MercuryShape*)water->m_vMercuryShapes[0];
        if (s)
        {
            MercuryMaterial* mw = s->GetMaterial(0);
            if (mw)
            {
                mw->EditTexture(0)->MoveY( dTime/THEME.GetMetricF( m_name, "WaterPeriodSecY" ));
                mw->EditTexture(0)->MoveX( dTime/THEME.GetMetricF( m_name, "WaterPeriodSecX" ));
            }
        }
    }

    int x, y;
    INPUTMAN->GetCursorPosition(x, y);
    MercuryODEObject* control = m_pWorld.GetODEObjectByName( "Control" );

    CalculateMovement(control);

    //Must happen before aim shot to keep targeting smooth
    CalculateLook(x, y, control);

    ScreenOutdoors::Update( adjTime );

    //Do before Physics Update to stay smooth
    m_Aimer.Disable();
    m_Aimer.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, m_pGun, pLookAt );

    //Must happen after physics update to stay smooth
    TweenCamera(x, y, control);

    m_pPlayer.SetPosition( control->GetPosition( ) );

    pPhysics.Disable();
    //do physics if necessiary
    if ( iPhysicsObject != 0 )
    {
        //Physics!
        MercuryPoint pNewPos = m_pGun + pLookAt.Normalize() * fClosestPhysicsObject;
        fClosestPhysicsObject = fClosestPhysicsObject * 0.95f + 2;
        MercuryPoint pCurrentPos( dBodyGetPosition( (dBodyID)iPhysicsObject ) );
        //dBodySetPosition( (dBodyID)iPhysicsObject, pPos.x, pPos.y, pPos.z );

        MercuryPoint pDir = pNewPos-pCurrentPos;
        pDir *= (0.4f/dTime);
        dBodySetLinearVel( (dBodyID)iPhysicsObject, pDir.x, pDir.y, pDir.z );
        dBodyEnable( (dBodyID)iPhysicsObject );
    }

//      m_sprCrosshairs.SetHide( (m_slowDown > 0 && !m_donefirst) );

    m_fTimeSinceLastShot += dTime;
    pBullet.Disable();
    if( m_fTimeSinceLastShot > .25 && INPUTMAN->IsButtonDown( button_mouse1 ) )
    {
        m_fTimeSinceLastShot = 0;
        pBullet.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, 
            m_pGun, pLookAt );
    }

    //aimer result
    {
        if ( m_interactable )
        {
            if( m_interactable != m_oldInter )
            {
                m_sprCrosshairs.Tweening.StopTweening();
                m_sprCrosshairs.Tweening.ExecuteCommand("OnTarget", PStack());
            }
        }
        else
        {
            if( m_interactable != m_oldInter )
            {
                m_sprCrosshairs.Tweening.StopTweening();
                m_sprCrosshairs.Tweening.ExecuteCommand("OffTarget", PStack());
            }
        }
        m_oldInter = m_interactable;
        MercuryPoint xy = PointToScreenCoord(m_perspProjection.m_matrix, m_fCamera.GetFinalMatrix(), m_aimPos, DISPLAY->GetBasedDimensions());
        xy.z = 0;
        m_sprCrosshairs.SetPosition(xy);
        fClosestAimerObject = 10000;
    }

    if (m_runObjectHitCode)
        ObjectHit(m_closestHitPosition, m_closestHitObject, m_closestHitRay);

    m_pPlayer.SetRotY( -float(x)/300*RADDEG );

    //Tricky: find where the gun is shooting from, for this we can use some basic trigonometry.
    m_pGun = control->GetPosition();
    m_pGun.x += cos( -float(x)/300 + Q_PI/4)*7;
    m_pGun.y += sin( -float(x)/300 + Q_PI/4)*7;
}

void ScreenFPS::CalculateLook(int x, int y, MercuryODEObject* control)
{

    if( ( y - m_iSlidingF ) > 470 )
        m_iSlidingF = y - 470;
    if( ( y - m_iSlidingF ) < -470 )
        m_iSlidingF = y + 470;

    pTarget.x = cos( -float(x)/300 );
    pTarget.y = sin( -float(x)/300 );
    pTarget.z = 0;

    pLookAt = pTarget;

    pLookAt.x *= cos( -float(y-m_iSlidingF)/300 );
    pLookAt.y *= cos( -float(y-m_iSlidingF)/300 );
    pLookAt.z = sin( -float(y-m_iSlidingF)/300 );
}

void ScreenFPS::TweenCamera(int x, int y, MercuryODEObject* control)
{
    if ( !((m_slowDown > 0) && !m_donefirst))
        if( !m_bFPS )
        {
            m_fCamera.Tweening.StopTweening();

            m_fCamera.Tweening.ExecuteCommand( "CamTween", PStack( 
                    PSElement( control->GetX()-COS(-float(x)/300)*30 ),
                    PSElement( control->GetY()-SIN(-float(x)/300)*30 ),
                    PSElement( (control->GetZ())+25)));

            MercuryPoint pos = m_fCamera.GetPosition();

            m_pPlayer.SetHide( false );
            m_fCamera.SetTarget( pLookAt + pos );

            MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
            pNewUp = pNewUp.CrossProduct( pLookAt );
            m_fCamera.SetUp( pNewUp );
            m_fCamera.Prerender();
        } else {
            m_fCamera.SetPosition( control->GetPosition() );
            m_pPlayer.SetHide( true );
            m_fCamera.SetTarget( pLookAt + control->GetPosition() );

            MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
            pNewUp = pNewUp.CrossProduct( pLookAt );
            m_fCamera.SetUp( pNewUp );
        }
}

void ScreenFPS::Message( int Message, PStack & data, const MString &name )
{
    switch ( Message ) 
    {
    case MC_INPUTMAPPED:
        {
            InputMessageStruct c(data);
            if ( c.code == button_u )
            {
                if ( c.type == IET_DOWN )
                {
                    m_bFPS = !m_bFPS;
                }
            } else if ( c.code == button_b && c.type != IET_RELEASE ) {
                m_pWorld.GenAndAddToWorld( m_pINI, "MyBall", "Ball", "MercuryODEObjectLoadable", 1, MercuryPoint(0,0,100));
            } else if ( c.code == button_t && c.type == IET_DOWN ) {
                m_pWorld.GenAndAddToWorld( m_pINI, "MyBall", "coke", "ExplodingCokeCan", 1, MercuryPoint(0,0,100));
            } else if ( c.code == button_mouse2 )
            {
                if ( c.type == IET_DOWN )
                {
                    pPhysics.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, 
                        m_pGun, pLookAt );
                }
                else if( c.type == IET_RELEASE )
                {
                    iPhysicsObject = 0;
                    fClosestPhysicsObject = 100000;
                }
            }
        }
        break;
    case MC_EXPLOSION:
        {
            if (!m_fistExplosion)
            {
                m_slowDown += 2;
//              MercuryODEObject * c = m_pWorld.GetODEObjectByName( "Control" );

                MercuryPoint coke;
                coke.SetX(data.PeekItem(0).GetValueF());
                coke.SetY(data.PeekItem(1).GetValueF());
                coke.SetZ(data.PeekItem(2).GetValueF());
                MercuryPoint a = (coke - m_fCamera.GetPosition()).CrossProduct( MercuryPoint(0,0,1));
                a.NormalizeSelf();
                m_fCamera.Tweening.StopTweening();
                m_fCamera.Tweening.AddCommand( ssprintf( "linear,%f;x,%f;y,%f;z,%f", m_slowDown/5, coke.x-50, coke.y-50, coke.z+50));

    //          m_fCamera.Tweening.AddCommand( ssprintf( "linear,0.4;addx,%f;addy,%f;addz,%f", a.x*300, a.y*300, a.z*-600));
    //          m_fCamera.Tweening.AddCommand( ssprintf( "linear,0.2;movex,%f;y,%f;z,%f;",  
                m_fCamera.SetTarget(coke);
    //          m_fCamera.SetTarget(c->GetPosition() + MercuryPoint( 0,0,15));

                MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
                pNewUp = pNewUp.CrossProduct( pLookAt );
                m_fCamera.SetUp( pNewUp );
                m_pPlayer.SetHide( false );
                m_fistExplosion = true;
            }
        }
        break;
    };

    ScreenOutdoors::Message( Message, data, name );
}

bool ScreenFPS::Command( PStack & ret, const char * command, PStack & args )
{
    if ( strcmp( command, "physhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();
        if( L->m_oBody )
        {
            MercuryPoint pPos = MercuryPoint(  args.PeekItem( 2 ).GetValueF(), 
                args.PeekItem( 3 ).GetValueF(), 
                args.PeekItem( 4 ).GetValueF() ) - m_pGun;
            
            float fDistance = pPos.Magnitude();

            if( fDistance < fClosestPhysicsObject )
            {
                iPhysicsObject = (MVPtr)L->m_oBody;
                fClosestPhysicsObject = fDistance;
            }
        }
        return true;
    }
    else if ( strcmp( command, "rayhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        //Order of args: NameOfObject, (void*)ObjectHandle, fX, fY, fZ, fNX, fNY, fNZ
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();

        MercuryPoint position(MercuryPoint( args.PeekItem( 2 ).GetValueF(), args.PeekItem( 3 ).GetValueF(), args.PeekItem( 4 ).GetValueF() ));
        MercuryPoint ray(MercuryPoint( args.PeekItem( 5 ).GetValueF(), args.PeekItem( 6 ).GetValueF(), args.PeekItem( 7 ).GetValueF() ));
        ray.NormalizeSelf();

        float fDistance = (m_pPlayer.GetPosition()-position).Magnitude();
        if ( fDistance < m_closestHitObjectDistance )
        {
            m_closestHitObjectDistance = fDistance;
            m_runObjectHitCode = true;
            m_closestHitRay = ray;
            m_closestHitPosition = position;
            m_closestHitObject = L->m_oBody;
        }
        return true;
    }
    else if ( strcmp( command, "aimhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();

        MercuryPoint pPos = MercuryPoint(  args.PeekItem( 2 ).GetValueF(), 
            args.PeekItem( 3 ).GetValueF(), 
            args.PeekItem( 4 ).GetValueF() );
            
        float fDistance = (m_pPlayer.GetPosition()-pPos).Magnitude();

        if( fDistance < fClosestAimerObject )
        {
            if (L->m_oBody)
                m_interactable = true;
            else
                m_interactable = false;

            fClosestAimerObject = fDistance;
            m_aimPos = pPos;
        }

        return true;
    }

    return ScreenOutdoors::Command( ret, command, args );
}

void ScreenFPS::ObjectHit(const MercuryPoint& position, dBodyID id, const MercuryPoint& ray)
{
    m_runObjectHitCode = false;
    m_closestHitObjectDistance = 100000;

    if( id )
    {
        dBodyEnable( id );
        dBodyAddForce( id, 70000*ray.x,
                    70000*ray.y,
                    70000*ray.z );
    }
    MercuryPoint p2(ray*0.01);

    MercuryLight* l = (MercuryLight*)Spawn("MercuryLight", "Explosion light");
    l->SetPosition(position-p2);
    l->SetStatic(true);
    l->SetLightType(LT_POINT);
    l->SetAttenuation(.001f,Attenuation::QUADRATIC);
    l->Tweening.AddCommand(THEME.GetMetricS( GetName(), "LightExplosion", "" ));
    DISPLAY->AddLight(l);

    MercuryColor color1, color2, color;
    float fRadius = ((rand()%1000)/100.0f) + 10.0f;
    float scale = THEME.GetMetricF( GetName(), "BlastParticleScale" );
    MercuryParticleField* pfield = (MercuryParticleField*)Spawn( "MercuryParticleField", "BlastParticles", PERSPECTIVE );
    pfield->LoadImage( THEME.GetMetricS( GetName(), "BlastParticleImage" ));
    pfield->Tweening.AddCommand( THEME.GetMetricS( GetName(), "BlastParticleField" ) );
    pfield->GetGLState().Disable(MGLS_OPAQUE);
    color1.FromString( THEME.GetMetricS( GetName(), "BlastParticleBaseColor1" ) );
    color2.FromString( THEME.GetMetricS( GetName(), "BlastParticleBaseColor2" ) );

    for (unsigned int i = 0; i < 25; ++i)
    {
        MercuryObject* particle = pfield->SpawnParticle();
        particle->SetPosition(position);
        particle->SetScale( MercuryPoint(scale, scale, 1) );
        particle->SetRotationMode(RM_BILLBOARD);

        float fLifetime = float( rand()%100 )/100.0f+0.3f;
        MercuryPoint newPos( ((rand()%200)/100.0f)-1.0f, ((rand()%200)/100.0f)-1.0f, ((rand()%200)/100.0f)-1.0f );
        newPos.NormalizeSelf();
        newPos *= fRadius*(rand()%90)/100.0f+0.1f;
        newPos += position;
        float brightness = ((rand()%50)+50)/100.0f;

        int percentColor1 = rand()%100;
        color = (color1*(percentColor1/100.0f));
        color += color2*((100-percentColor1)/100.0f);

        PStack KArgs;
        KArgs.PushItemBack( PSElement( color.GetR()*brightness ) );
        KArgs.PushItemBack( PSElement( color.GetG()*brightness ) );
        KArgs.PushItemBack( PSElement( color.GetB()*brightness ) );
        KArgs.PushItemBack( PSElement( fLifetime ) );
        KArgs.PushItemBack( PSElement( newPos.x ) );
        KArgs.PushItemBack( PSElement( newPos.y ) );
        KArgs.PushItemBack( PSElement( newPos.z ) );
        int rotz = (rand()%1000) - 500;
        KArgs.PushItemBack( PSElement( rotz ) );
        particle->Tweening.ExecuteCommand( "BlastParticle", KArgs );
    }
}

/* 
 * Copyright (c) 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 Mercury Engine 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