MercuryScreen.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryScreen.h"
#include "MercuryModel.h"
#include "MercuryScreenManager.h"
#include "MercuryDisplay.h"
#include "MercuryLog.h"
#include "MercuryTheme.h"
#include "MercuryTextureManager.h"
#include "MercuryObjectFactory.h"

#define     MC_DISPLAYRESIZED       1       //convention: MESSAGE CODE  

std::map< MString, NewScreenFunction >  * ToMakeScreens = NULL;

void RegisterMercuryScreen( const MString& sClassName, NewScreenFunction pfn )
{
    if ( ToMakeScreens == NULL )
        ToMakeScreens = new std::map< MString, NewScreenFunction >;
    (*ToMakeScreens)[sClassName] = pfn;
}

MercuryScreen::MercuryScreen() : MercuryObject()
{
    m_pBackground = NULL;
    m_pCamera = NULL;
}

MercuryScreen::MercuryScreen( const MercuryScreen & in ) : MercuryObject()
{
    m_pBackground = NULL;
    m_pCamera = NULL;
}

MercuryScreen::MercuryScreen( const MString &name ) : MercuryObject( name )
{
    m_pBackground = NULL;
    m_pCamera = NULL;
}

MercuryScreen::~MercuryScreen()
{
    SAFE_DELETE(m_pBackground);
    SAFE_DELETE(m_pCamera);
}

void MercuryScreen::Init()
{
    m_useLighting = THEME.GetMetricB( GetName(), "UseLighting", true );
    MercuryObject::Init();
    //No idea why this isn't always set.  I think it should always be set.
    SetDiffuse( MercuryColor(1,1,1,1 ) );
    CreateProjections();
    m_PerspObjects.Init();
    m_OrthoObjects.Init();
    m_PerspObjects.SetDrawOrder(0);
    m_OrthoObjects.SetDrawOrder(1);

    //XXX why can't I disable depth write
    m_OrthoObjects.GetGLState().Disable(MGLS_LIGHTING | MGLS_DEPTHTEST );//| MGLS_DEPTHWRITE);
    AddObject(&m_PerspObjects);
    AddObject(&m_OrthoObjects);
    RegisterMessage( MC_DISPLAYRESIZED, "DisplayResized" );
}

void MercuryScreen::CreateProjections()
{
    DisplayDimensions d = DISPLAY->GetBasedDimensions();
    m_perspProjection = Perspective(45.0f,(float)(DISPLAY->GetWindow()->GetWidth())/(float)(DISPLAY->GetWindow()->GetHeight()),1.0f,1500.0f);
    m_orthoProjection = Ortho(0.0f, float(d.width), float(d.height), 0.0f, 0.0f, -1.0f);
}

void MercuryScreen::Message( int Message, PStack & data, const MString & name )
{
    MercuryObject::Message(Message, data, name);
    switch ( Message ) 
    {
    case MC_DISPLAYRESIZED:
        CreateProjections();
        break;
    };
}

void MercuryScreen::Update(const float dTime)
{
    ASSERT_M(m_initalized,"Object '" + GetName() + "'not initialized.");

    if ((m_state == UNLOADED) || (dTime == 0))
        return;

    if ( m_bMarkedForDestroy )
    {
        ((MercuryObject*)m_parentObject)->RemoveObject( this );
        return;
    }

    Tweening.Update( dTime );
    WorldStack.Push();
    Prerender();

    UpdatePerspectiveObjects(dTime);
    UpdateOrthoObjects(dTime);

    WorldStack.Pop();
}

void MercuryScreen::Render()
{
    RenderPerspectiveObjects();
    RenderOrthoObjects();
}

void MercuryScreen::RenderPerspectiveObjects()
{
    DISPLAY->SetProjection(m_perspProjection);

    if (m_pCamera != NULL)
        m_pCamera->Render();

    if (m_pBackground != NULL)
        m_pBackground->Render();

    if (m_useLighting)
        DISPLAY->EnableGLState(MGLS_LIGHTING);
    else
        DISPLAY->DisableGLState(MGLS_LIGHTING);

    m_PerspObjects.Render();
    DISPLAY->RenderTranslucentObject();
}

void MercuryScreen::RenderOrthoObjects()
{
    DISPLAY->SetProjection(m_orthoProjection);
    DISPLAY->GetView().Identity();

    m_OrthoObjects.Render();
    DISPLAY->RenderTranslucentObject();
}


void MercuryScreen::UpdatePerspectiveObjects(float dTime)
{
    DISPLAY->SetProjection(m_perspProjection); //needed for culling

    if (m_pCamera != NULL)
        m_pCamera->Update(dTime);

    if (m_pBackground != NULL)
        m_pBackground->Update(dTime);

//  Draw(); //sets camera and background

    if (m_useLighting)
        DISPLAY->EnableGLState(MGLS_LIGHTING);
    else
        DISPLAY->DisableGLState(MGLS_LIGHTING);

    m_PerspObjects.Update(dTime);
}

void MercuryScreen::UpdateOrthoObjects(float dTime)
{
    //needed for culling
    DISPLAY->SetProjection(m_orthoProjection);
    DISPLAY->GetView().Identity();

    m_OrthoObjects.Update(dTime);
}

//void MercuryScreen::AddObject(MercuryObject* object, bool bParentDelete = false);
bool MercuryScreen::RemoveObject(MercuryObject* object, bool bAllowDelete)
{
    MDequeIterator<ParentHoldPair> i;

    if ( m_PerspObjects.RemoveObject(object, bAllowDelete) )
        return true;
    if ( m_OrthoObjects.RemoveObject(object, bAllowDelete) )
        return true;
    return false;
}

void MercuryScreen::AddPerspObject(MercuryObject* object, bool bParentDelete)
{
    m_PerspObjects.AddObject(object, bParentDelete);
}

void MercuryScreen::AddOrthoObject(MercuryObject* object, bool bParentDelete)
{
    m_OrthoObjects.AddObject(object, bParentDelete);
}

MercuryObject * MercuryScreen::Spawn( const MString & sClass, const MString & sName, PROJECTIONTYPE projection )
{
    MercuryObject * pObject = MercuryObjectFactory::GetInstance().GenerateObject( sClass, sName );
    if ( pObject == NULL )
        return false;

    pObject->Init();
    
    if (projection == PERSPECTIVE)
        AddPerspObject(pObject, true);
    else
        AddOrthoObject(pObject, true);

    return pObject;
}

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