ScreenTitle.cpp

Go to the documentation of this file.

#include "global.h"
#include "ScreenTitle.h"
#include "MercuryScreenManager.h"
#include "MercuryLoadableModel.h"
#include "MercuryInput.h"
#include "MercuryLog.h"
#include "MercuryTheme.h"
#include "MercuryDisplay.h"
#include "MercuryLoadableModel.h"

#if defined(_EE)
#include "MercuryDisplayEE.h"
#endif
#include "MercuryTheme.h"

KeyMappingWithCode( button_a, "0-97" );
KeyMappingWithCode( button_b, "0-98" );
KeyMappingWithCode( button_c, "0-99" );
KeyMappingWithCode( button_t, "0-116" );
KeyMappingWithCode( button_u, "0-117" );

#include "MercuryObjectFactory.h"
REGISTER_SCREEN_CLASS( ScreenHgTitle )

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

ScreenHgTitle::~ScreenHgTitle()
{
    DISPLAY->RemoveLight(&m_light);
    SAFE_DELETE(m_mercury);
}

void ScreenHgTitle::Init()
{
    MercuryScreen::Init();  

    m_mercury = new MercuryLoadableModel;
    m_mercury->SetName( "Mercury" );
    m_mercury->Init();
    m_mercury->Load(GET_MODEL_BY_NAME( "Mercury" ));
    m_mercury->Tweening.AddCommand( THEME.GetMetricS( m_name, "MercuryTween" ) );
    AddPerspObject(m_mercury);

    //The deleting of explosion will happen in metrics or when the screen is destroyed.
    MercuryModel* m_mercuryExplode = new MercuryLoadableModel;
    m_mercuryExplode->SetName( "MercuryExplode" );
    m_mercuryExplode->Init();
    m_mercuryExplode->Load(GET_MODEL_BY_NAME( "Mercury" ));
    m_mercuryExplode->Tweening.AddCommand( THEME.GetMetricS( m_name, "MercuryExplodeTween" ) );
    AddPerspObject(m_mercuryExplode, true);

/*  MercurySprite* background = new MercurySprite;
    m_pBackground = background;
    background->SetName(m_name + " background");
    background->LoadImage( THEME.GetMetricS( m_name, "background" ));
    background->SetProjectionType(ORTHOGRAPHIC);
    background->MoveX(320);
    background->MoveY(240);*/
    //The ScreenObject will delete this when destructing

    m_logo.SetName("MercuryEngine");
    m_logo.Init();
    m_logo.LoadImage( THEME.GetMetricS( m_name, m_logo.GetName()+"Image") );
//  m_logo.SetProjectionType(ORTHOGRAPHIC);
    m_logo.Tweening.AddCommand( THEME.GetMetricS( m_name, m_logo.GetName()+"OnCommand") );
    AddOrthoObject(&m_logo);

    m_iDirection = 0;
    fTotalTime = 0;

    //Setup a light
    m_light.Init();
    m_light.SetY(100);
    m_light.SetX(-100);
    m_light.SetZ(110);
    m_light.SetAttenuation(0.001f, Attenuation::LINEAR);
//  m_light.SetStatic(true);
    DISPLAY->AddLight(&m_light);

//  m_pCamera = new MercuryCamera;
//  m_pCamera->Init();
//  AddObject(m_pCamera);

    this->RegisterMessage( MC_INPUTMAPPED, "mappedinput" );
}

void ScreenHgTitle::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_INPUTMAPPED:
        {
            InputMessageStruct c(data);
            if ( c.code == button_c )
            {
                if ( c.type == IET_DOWN )
                {
                    m_logo.Tweening.StopTweening();
                    m_logo.Tweening.AddCommand( "hide,0;linear,2;rotationz,0;diffuse,1,1,1,1");
                }
                if ( c.type == IET_RELEASE )
                {
                    m_logo.Tweening.StopTweening();
                    m_logo.Tweening.AddCommand( "hide,0;linear,2;rotationz,360;diffuse,1,1,1,1");
                }
                if ( m_mercury->GetName() == GET_MODEL_BY_NAME( "jupiter" )  )
                {
                    if ( c.type == IET_DOWN )
                        ((MercuryLoadableModel*)m_mercury)->GetAnimationState( 3 ).Trigger();
                    else
                        ((MercuryLoadableModel*)m_mercury)->GetAnimationState( 2 ).Trigger();
                }
            }
            if ( c.code == button_t )
            {
                if ( c.type == IET_RELEASE )
                {
                    RemoveObject(m_mercury);
                    SAFE_DELETE(m_mercury);
                    m_mercury = new MercuryLoadableModel;
                    m_mercury->SetName( "Jupiter" );
                    m_mercury->Init();
                    m_mercury->Load( GET_MODEL_BY_NAME( "jupiter" ) );
                    m_mercury->Tweening.StopTweening();

                    MVector< MercuryLoadableModel::LoadableModelAnimationInfo > pTweenCommands;

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

                    pTweenCommands[2].sAnimationName = "shootright_upper";
                    pTweenCommands[2].bLoop = pTweenCommands[2].bRunning = false;
                    pTweenCommands[3].sAnimationName = "shootleft_upper";
                    pTweenCommands[3].bLoop = pTweenCommands[3].bRunning = false;
                    ((MercuryLoadableModel*)m_mercury)->SetAnimationState( pTweenCommands );

                    this->AddPerspObject(m_mercury);
                    m_mercury->SetDrawOrder(-1);
                    m_mercury->SetZ(-400);
                    m_mercury->MoveY(-20);
                }
            }
            if ( c.code == button_u )
            {
                if ( c.type == IET_RELEASE )
                {
                    m_logo.LoadImage( THEME.GetMetricS( GetName(), "DownloadImage" ) );

                    m_mercury->GetMaterial(0)->EditTexture(0)->Tweening.AddCommand( THEME.GetMetricS(m_name, "MercuryTextureTween"));
                }
            }
        }
        break;
    };
}

void ScreenHgTitle::Update( const float dTime )
{
    fTotalTime += dTime;
    if ( fTotalTime > THEME.GetMetricF( GetName(), "RestrainInput" ) )
    {
        int x,y;
        INPUTMAN->GetCursorPosition( x, y );
        m_mercury->SetRotX( float(y)/3.0f );
        m_mercury->SetRotY( float(x)/3.0f );
    }
    if ( INPUTMAN->IsButtonDown( button_a ) )
    {
        m_mercury->MoveX( -20*dTime );
    }
    if ( INPUTMAN->IsButtonDown( button_b ) )
    {
        m_mercury->MoveX( 20*dTime );
    }

    MercuryScreen::Update( dTime );
}

/* 
 * Copyright (c) 2005-2006, Joshua Allen
 * 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