ScreenHelloWorld.cpp

Go to the documentation of this file.

#include "global.h"
#include "ScreenHelloWorld.h"
#include "MercuryTheme.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"
#include "MercuryDisplay.h"
#include "MercuryInput.h"

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

KeyMappingWithCode( button_a, "0-97" );

KeyMappingWithCode( button_b, "0-98" );
KeyMappingWithCode( button_c, "0-99" );
KeyMappingWithCode( button_d, "0-100" );

#include "MercuryObjectFactory.h"
REGISTER_SCREEN_CLASS( ScreenHelloWorld )

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

    m_held = false;

    m_sprHello.SetName( "HelloSprite" );
    m_sprHello.Init();
    m_sprHello.LoadImage( THEME.GetMetricS( GetName(), "HelloImage" ) );
    m_sprHello.Tweening.AddCommand(THEME.GetMetricS( GetName(), m_sprHello.GetName()+"OnCommand" ) );
    m_sprHello.SetRotX(180);
    m_sprHello.SetScale( MercuryPoint(0.3, 0.3, 1) );
    AddPerspObject( &m_sprHello );
    m_timeElasped = 0;

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

    m_camera.Init();
    AddObject(&m_camera);

    LOG.Info( THEME.GetMetricS( GetName(), "InfoComment" ) );

    //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);

    unsigned int numImg = THEME.GetMetricI( GetName(), "NumberImages" );
    m_imagePaths.resize( numImg );
    for (unsigned int i = 0; i < numImg; ++i)
        m_imagePaths[i] = THEME.GetMetricS( GetName(), ssprintf("Image%d",i) );

    m_delay = THEME.GetMetricF( GetName(), "ShellDelay" );
    m_maxPoints = THEME.GetMetricI( GetName(), "MaxPointsInShell" );
    m_minPoints = THEME.GetMetricI( GetName(), "MinPointsInShell" );

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

void ScreenHelloWorld::Update( const float dTime )
{
    m_timeElasped += dTime;
    if (m_timeElasped >= m_delay)
    {
        m_timeElasped = 0;
        float fCenterX = float( rand()%640 );
        float fCenterY = float( rand()%480 );

        float fRadius = float( rand()%100 )+100.0f;
        
        bool    bMulticolor = false;

        if ( ( rand() % 3 ) == 0 )
            bMulticolor = true;

        int iParticles = (rand()%(m_maxPoints-m_minPoints))+m_minPoints;
        
        float ColorR = float(rand()%100)/100.0f;
        float ColorB = float(rand()%100)/100.0f;
        float ColorG = float(rand()%100)/100.0f;

        int ModType = rand()%m_imagePaths.size();
        float RandScale = (50 + (rand()%100))/150.0f;

        MercuryParticleField* seed = (MercuryParticleField*)Spawn( "MercuryParticleField", "Firework", ORTHOGRAPHIC );
        seed->Tweening.AddCommand( THEME.GetMetricS( GetName(), "Firework" ) );

        seed->LoadImage( m_imagePaths[ModType] );

        for ( int i = 0; i < iParticles; i++ )
        {
            float fLifetime = float( rand()%100 )/100.0f+0.3f;
            MercuryObject* c = seed->SpawnParticle();

            c->SetScale( MercuryPoint(RandScale, RandScale, 1.0) );         
            
            c->SetZ(0);
            c->SetY( fCenterY );
            c->SetX( fCenterX );

            if ( bMulticolor )
            {
                ColorR = float(rand()%100)/100.0f;
                ColorG = float(rand()%100)/100.0f;
                ColorB = float(rand()%100)/100.0f;
            }

            float fAngle = float(rand()%200)/200.0f*6.283f;
            float fActRadius = powf((float(rand()%200)/200.0f),0.25);
            float fNewX = fActRadius*fRadius * COS( fAngle )+fCenterX;
            float fNewY = fActRadius*fRadius * SIN( fAngle )+fCenterY;

//          BENCHMARK.Start( "TWEENING" );
            PStack KArgs;
            KArgs.PushItemBack( PSElement( ColorR ) );
            KArgs.PushItemBack( PSElement( ColorG ) );
            KArgs.PushItemBack( PSElement( ColorB ) );
            KArgs.PushItemBack( PSElement( fLifetime ) );
            KArgs.PushItemBack( PSElement( fNewX ) );
            KArgs.PushItemBack( PSElement( fNewY ) );
            int rotz = (rand()%1000) - 500;
            KArgs.PushItemBack( PSElement( rotz ) );
            c->Tweening.ExecuteCommand( "GenericParticle", KArgs );
//          BENCHMARK.End( "TWEENING" );
        }
    }

    if (m_held)
    {
        int x,y;
        INPUTMAN->GetCursorPosition( x, y );
//      m_camera.Pitch(-(m_y - y)/3.0f);
//      m_camera.Yaw(-(m_x - x)/3.0f);
        m_x = x;
        m_y = y;
    }

//  if (m_camera.GetAxisRecalc())
    {
        if (INPUTMAN->IsButtonDown(button_b))
            m_camera.MoveX(-.1f);

        if (INPUTMAN->IsButtonDown(button_c))
            m_camera.MoveX(.1f);
    }

    MercuryScreen::Update( dTime );
}

void ScreenHelloWorld::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_INPUTMAPPED:
        {
            InputMessageStruct c(data);
            if ( c.code == button_a )
            {
                if ( c.type == IET_DOWN )
                {
                    m_held = true;
                    INPUTMAN->GetCursorPosition( m_x, m_y );
                }
                if ( c.type == IET_RELEASE )
                {
                    m_held = false;
                }
            }
            if ( c.code == button_d )
            {
//              if ( c.type == IET_DOWN )
//                  m_camera.SetAxisRecalc(!m_camera.GetAxisRecalc());
            }
        }
    }
}

/* 
 * 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