MercuryDisplay.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryDisplay.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"
#include "MercuryINI.h"
#include "MercuryMath.h"
#include "MercuryTexture.h"
#include "BMPWriter.h"

#if !defined(_EE)
#if !defined(USE_FRAMEBUFFER)
#include "MercuryOGL.h"
#endif
#include "MercuryDisplaySoftwareC.h"
#else
#include "MercuryDisplayEE.h"
#endif


#include "MercuryInput.h"

#if defined (WIN32)
#include "Win32Window.h"
#if defined( USE_D3D )
#include "MercuryDisplay_D3D.h"
#endif
#else
#if !defined(_EE)
#if !defined(USE_FRAMEBUFFER)
#include "MercuryWindowSDL.h"
#else
#include "MercuryWindowFB.h"
#endif
#else
#include "MercuryWindowEE.h"
#endif
#endif

#if defined(_MSC_VER) && (_MSC_VER > 1100)
    #pragma warning (disable : 4786) //char truncation dealing with MStrings
#endif

MercuryMatrixStack WorldStack;
//MercuryMatrixStack ViewStack;
MercuryMatrixStack TextureStack;

KeyMappingWithCode( print_scr, "0-316" );

REGISTER_STATEMENT_TO_MESSAGE( quit, quit, DISPLAY->CloseNextCycle(); )
REGISTER_STATEMENT_TO_COMMAND( quit, DISPLAY->CloseNextCycle(); )

REGISTER_STATEMENT_TO_MESSAGE( screenshot, mappedinput,
                              InputMessageStruct c(args);
                            if (c.code == print_scr && c.type == IET_RELEASE )
                                DISPLAY->TakeScreenShot();
)

MercuryDisplay::MercuryDisplay()
:m_renderObjects(200)
{
    m_framesDrawn = 0;
    m_verticesDrawn = 0;
    m_bCloseNextCycle = 0;
    m_maxTextures = 1;
    m_maxLights = 0;
    m_initalized = false;
    m_maxDrawBuffers = m_maxVertexAttributes = m_maxTextureCoordinates =
    m_maxShaderVertUniformComponents = m_maxShaderFragUniformComponents =
    m_shaderLanngVersion = 0;
    m_maxAnisotropy = 0;

    m_based_width = PREFSMAN->GetValueI( "Rendering", "BasedWidth", InitialDisplayProperties::InitialBasedWidth, true );
    m_based_height = PREFSMAN->GetValueI( "Rendering", "BasedHeight", InitialDisplayProperties::InitialBasedHeight, true );
    
    m_window = NULL;

    m_disableTextures = false;
    m_useMaterialColors = true;
}

MercuryDisplay::~MercuryDisplay()
{
    SAFE_DELETE(m_window);
    m_globalState.pop_back(); //prevents crash
}

void* MercuryDisplay::ThreadCallback(void* display)
{
    ((MercuryDisplay*)display)->ThreadLoop();
    return NULL;
}

void MercuryDisplay::CreateThread()
{
#if !defined( NO_THREADS )
    m_thread.Create(MercuryDisplay::ThreadCallback, this);
#endif
}

void MercuryDisplay::ThreadLoop()
{
    if ( !DISPLAY->Init(
        PREFSMAN->GetValueS( "Window", "Name", "Mercury Engine", true ).c_str(),
        PREFSMAN->GetValueI( "Window", "Width", 640, true ),
        PREFSMAN->GetValueI( "Window", "Height", 480, true ),
        PREFSMAN->GetValueI( "Window", "BPP", 32, true ),
        PREFSMAN->GetValueB( "Window", "Fullscreen", false, true )
        ) )
    {
        LOG.Warn("Failed to initalize display.");
        ASSERT(!"Failed to initalize display.");
    }

    while(true)
    {
    }
}

bool MercuryDisplay::Init(const MString& name, unsigned int width, unsigned int height, unsigned short bpp, bool fullscreen)
{
    m_initalized = true;
    m_view.Identity();

#if defined (WIN32)
    AttachWindow(new Win32Window);
#else

#if !defined(_EE)
#if !defined(USE_FRAMEBUFFER)
    AttachWindow(new MercuryWindowSDL);
#else
    AttachWindow(new MercuryWindowFB);
#endif
#else
    AttachWindow(new MercuryWindowEE);
#endif

#endif
    if ( !MakeWindow(name, width, height, bpp, fullscreen) )
    {
        LOG.Warn("Failed to make window.");
        return false;
    }

    MercuryGLState gls;
    gls.Enable(MGLS_ALL);
    m_globalState.push_front(gls);
    m_currentState = gls;
    gls.Disable(MGLS_ALL);
    SetStates(gls);

    return true;
}

bool MercuryDisplay::Update(const float dTime)
{
    double age = m_timer.Age();

    if (m_window != NULL)
        if (!m_window->Update(dTime))
            return false;

    if ( m_window->HasFocus() != m_bLastHadFocus )
    {
        m_bLastHadFocus = m_window->HasFocus();
        MESSAGEMAN->BroadcastMessage( "changefocus", PStack( PSElement( m_bLastHadFocus ) ) );
    }

    if (age >= 0.5)
    {
        m_timer.Touch();
        PStack stats;
        stats.PushItemBack( PSElement ((float)(m_verticesDrawn/age)) ); //VPS
        stats.PushItemBack( PSElement ((float)(m_verticesDrawn/(float)m_framesDrawn)) ); //VPF
        stats.PushItemBack( PSElement ((float)(m_framesDrawn/age)) ); //FPS

        //Post this message and deal with it later
        MESSAGEMAN->PostSystemMessage( "RenderStats", stats, 0 );

        m_framesDrawn = 0;
        m_verticesDrawn = 0;
    }

    return !m_bCloseNextCycle;
}

void MercuryDisplay::Resize(int width, int height)
{
    if (height <= 0)
        height = 1;

    if (width <= 0)
        width = 1;

    m_window->SetDemensions(width, height);

    Viewport(0, 0, width, height);

    //Don't do anything if we are minimizing.
    if ( !m_window->IsMinimized() )
    {
        if ((width > 1) && (height > 1))
        {
            DisplayDimensions dimensions = GetDimensions();
            MESSAGEMAN->BroadcastMessage( "DisplayResized", PStack( PSElement( dimensions.height ), PSElement( dimensions.width) ) );
        }
    }
}

void MercuryDisplay::SetProjection(const Projection& projection)
{
    m_projection = projection;
    ResetFrustumClippingPlanes();
    SendProjectionMatrixData();
}

bool MercuryDisplay::AttachWindow(MercuryWindow* window)
{
    SAFE_DELETE(m_window);
    m_window = window;

    return true;
}

bool MercuryDisplay::MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
    RendererInfo();
    Resize(m_window->GetWidth(), m_window->GetHeight());

    return true;
}

DisplayDimensions MercuryDisplay::GetDimensions() const
{
    DisplayDimensions dimensions;
    dimensions.width = (float)m_window->GetWidth();
    dimensions.height = (float)m_window->GetHeight();
    return dimensions;
}

DisplayDimensions MercuryDisplay::GetBasedDimensions() const
{
    DisplayDimensions dimensions;
    dimensions.width = (float)m_based_width;
    dimensions.height = (float)m_based_height;
    return dimensions;
}

void MercuryDisplay::LookAt( float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ )
{
    MercuryPoint eye(eyeX,eyeY,eyeZ);
    MercuryPoint center(centerX,centerY,centerZ);
    MercuryPoint up(upX,upY,upZ);

    LookAt(eye, center, up);
}

MercuryPoint MercuryDisplay::GetLastCameraPosition( )
{
    return m_pLastCameraPos;
}

void MercuryDisplay::LookAt(const MercuryPoint& eye, const MercuryPoint& center,
                    const MercuryPoint& up)
{
    LookAtInternals lai = CalculateLookAtMatrix(eye, center, up, m_view);
    m_pLastCameraPos = eye;
    SetupClippingPlanes( eye, lai.m_direction, lai.m_up, lai.m_x );
}

LookAtInternals CalculateLookAtMatrix(const MercuryPoint& eye, const MercuryPoint& center,
                    const MercuryPoint& up, MercuryMatrix& m)
{
    MercuryPoint viewDirection = (center-eye).Normalize(); //direction vector

    MercuryPoint viewX = viewDirection.CrossProduct( up.Normalize() ); //x axis
    viewX.NormalizeSelf();

    MercuryPoint viewUp = viewX.CrossProduct( viewDirection ); //real up
    viewUp.NormalizeSelf();

    m.Identity();

    //row major
    m[0][0] = viewX.GetX();
    m[0][1] = viewX.GetY();
    m[0][2] = viewX.GetZ();

    m[1][0] = viewUp.GetX();
    m[1][1] = viewUp.GetY();
    m[1][2] = viewUp.GetZ();

    m[2][0] = -viewDirection.GetX();
    m[2][1] = -viewDirection.GetY();
    m[2][2] = -viewDirection.GetZ();

    m.Translate( -eye.GetX(), -eye.GetY(), -eye.GetZ() );

    return LookAtInternals(viewDirection, viewX, viewUp);
}

void MercuryDisplay::SetupClippingPlanes(const MercuryPoint& position, MercuryPoint F, MercuryPoint u, MercuryPoint s )
{
    u.NormalizeSelf();
    F.NormalizeSelf();
    s.NormalizeSelf();
    //Set up the view planes.
    //NEAR
    m_nViewPlanes[0] = MercuryPoint(0,0,0)-F;   //SPECIAL: The eye does not lie on this plane
    //FAR
    m_nViewPlanes[1] = F;   //SPECIAL: The eye does not lie on this plane either.

    MercuryMatrix mNormalRot;

    //Sanity check code for RotateAngAxis
/*  MercuryPoint pRight;
    MercuryPoint pOut;
    pRight = MercuryPoint( 0,0,1 );
    mNormalRot.RotateAngAxis( 45, 1,0,0 );
    VectorRotate( pRight, mNormalRot, pOut );*/
    
    mNormalRot.RotateAngAxis( -m_projection.m_frustumInfo.m_fov/2, s.x, s.y, s.z );
    VectorRotate( MercuryPoint()-u, mNormalRot, m_nViewPlanes[2] );

    mNormalRot.Identity();
    mNormalRot.RotateAngAxis( m_projection.m_frustumInfo.m_fov/2, s.x, s.y, s.z  );
    VectorRotate( u, mNormalRot, m_nViewPlanes[3] );

    mNormalRot.Identity();
    mNormalRot.RotateAngAxis( m_projection.m_frustumInfo.m_fov/2 * m_projection.m_frustumInfo.m_aspect, u.x, u.y, u.z );
    VectorRotate( MercuryPoint()-s, mNormalRot, m_nViewPlanes[4] );

    mNormalRot.Identity();
    mNormalRot.RotateAngAxis( -m_projection.m_frustumInfo.m_fov/2 * m_projection.m_frustumInfo.m_aspect, u.x, u.y, u.z );
    VectorRotate( s, mNormalRot, m_nViewPlanes[5] );

    m_pNearPoint = F * m_projection.m_frustumInfo.m_znear + position;
    m_pFarPoint = F * m_projection.m_frustumInfo.m_zfar + position;
}

void MercuryDisplay::LookAt(const MQuaternion& q, const MercuryPoint& eye)
{
    MercuryMatrix& view = m_view;
//  view.Identity();
    q.toMatrix4(view);

    view.Translate( -eye.GetX(), -eye.GetY(), -eye.GetZ() );
    m_pLastCameraPos = eye;
    SetupClippingPlanes( eye, MercuryPoint(0,0,0)-MercuryPoint(view[2]), view[1], view[0] );
}

void MercuryDisplay::ResetFrustumClippingPlanes()
{
    m_pLastCameraPos = MercuryPoint(0,0,0);
    SetupClippingPlanes( MercuryPoint(0,0,0), MercuryPoint( 0,0,-1 ), MercuryPoint( 0,1, 0 ), MercuryPoint(1,0,0 ) );
}

bool MercuryDisplay::IsVisible( const MercuryPoint & pCenter, float fRadius, const MercuryMatrix& world )
{
    if ( fRadius < 0 )
        return true;

    const float * f = world.Ptr();
    MercuryPoint pAdjustedCenter(f[3], f[7], f[11]);

    if ( (DotProduct(m_nViewPlanes[0],(pAdjustedCenter-m_pNearPoint))) > fRadius )
        return false;
    if ( (DotProduct(m_nViewPlanes[1],(pAdjustedCenter-m_pFarPoint))) > fRadius )
        return false;
    if ( (DotProduct(m_nViewPlanes[2],(pAdjustedCenter-m_pLastCameraPos))) > fRadius )
        return false;
    if ( (DotProduct(m_nViewPlanes[3],(pAdjustedCenter-m_pLastCameraPos))) > fRadius )
        return false;
    if ( (DotProduct(m_nViewPlanes[4],(pAdjustedCenter-m_pLastCameraPos))) > fRadius )
        return false;
    if ( (DotProduct(m_nViewPlanes[5],(pAdjustedCenter-m_pLastCameraPos))) > fRadius )
        return false;

    return true;
}

void MercuryDisplay::AddLight(MercuryLight* light)
{
    ASSERT(light->IsInitalized());
    m_lights.push_back(light);
}

void MercuryDisplay::RemoveLight(MercuryLight* light)
{
    for( unsigned int i = 0; i < m_lights.size(); ++i)
        if (m_lights[i] == light)
        {
            m_lights.remove(i);
            return;
        }
}

void MercuryDisplay::TakeScreenShot()
{
    RawImageData image;
    DISPLAY->ReadFrameBuffer(image);
    int ssn = PREFSMAN->GetValueI("Data", "ScreenShotNum", 0, true);
    //XXX: put screenshots in a folder
    WriteBMP(ssprintf("screenshot%d.bmp", ssn), image);
    PREFSMAN->SetValue("Data", "ScreenShotNum", ssprintf("%d", ++ssn));
    SAFE_DELETE(image.data);
    LOG.Log("screen shot");
}

MercuryDisplay* MakeDisplayDriver()
{
    MString sDisplayDriver = PREFSMAN->GetValueS( "Options", "DisplayDriver", "OGL", true );
#if !defined(_EE) && !defined(USE_FRAMEBUFFER)
    if ( sDisplayDriver == "OGL" )
        return new MercuryOGL();
#if defined( WIN32 )
#if defined( USE_D3D )
    if ( sDisplayDriver == "D3D" )
        return new MercuryDisplay_D3D();
#endif
#endif
#elif defined(_EE)
    return new MercuryDisplayEE();
#endif
    if ( sDisplayDriver == "SWC" )
        return new MercuryDisplaySoftwareC();

    LOG.Warn( "Cannot make display driver.  Pick OGL." );
    mercury_crash( "Cannot make display driver.  Pick OGL." );
    return NULL;        //Not like we'll get here
}

void MercuryDisplay::AddTranslucentObject(MercuryObject* obj)
{
    //sort furthest to nearest
    const MercuryMatrix& m = obj->GetFinalMatrix();
    TranslucentPair p;
    MercuryPoint gp(m[0][3], m[1][3], m[2][3]);
    p.dist = -(gp - GetLastCameraPosition()).Magnitude();
    p.obj = obj;
    m_translucentObjects.push_back(p);

    TSortDrawOrder(m_translucentObjects);
}

MercuryPoint PointToScreenCoord(const MercuryMatrix& proj, const MercuryMatrix& view, const MercuryPoint& p, const DisplayDimensions& bd)
{
    float ip[4];
    float a[4];
    MercuryMatrix mFinal;
    MercuryPoint tmp;

    mFinal = proj * view;

    ip[0] = p.x;
    ip[1] = p.y;
    ip[2] = p.z;
    ip[3] = 1;

    VectorMultiply4f( mFinal.Ptr(), ip, a );

    //Divide-by-perspective step
    tmp.x = a[0]/a[3];
    tmp.y = a[1]/a[3];
    tmp.z = a[2]/fabs(a[3]);

    //we don't want real window coordinates, we only want the
    //coordinates for the base resolution we are in
/*
    tmp.x *= (m_VPwidth - m_VPx)/2.0f;
    tmp.x += (m_VPwidth)/2.0f;
    tmp.y *= (m_VPy - m_VPheight)/2.0f;
    tmp.y += (m_VPheight)/2.0f;
*/

    tmp.x *= (bd.width)/2.0f;
    tmp.x += (bd.width)/2.0f;
    tmp.y *= (-bd.height)/2.0f;
    tmp.y += (bd.height)/2.0f;

    return tmp;
}

void MercuryDisplay::Viewport(int x, int y, int width, int height)
{
    m_VPx = x;
    m_VPy = y;
    m_VPwidth = width;
    m_VPheight = height;
}

void MercuryDisplay::FindLights(const MercuryMatrix& world, float radius)
{
    m_foundLights.clear();

    if ( radius < 0 )
        return;

    const float * f = world.Ptr();
    MercuryPoint objectPosition(f[3], f[7], f[11]);

    for (unsigned int i = 0; i < m_lights.size(); ++i)
    {
        float x = (objectPosition - m_lights[i]->GetPosition()).Magnitude();
        float y = m_lights[i]->GetRadius() + radius;

        if (m_lights[i]->GetLightType() == LT_DIRECTIONAL)
            m_foundLights.push_back(m_lights[i]);
        else if ( x < y )
            m_foundLights.push_back(m_lights[i]);
    }
//  printf("picked:%d %d\n", m_foundLights.size(), m_lights.size());
}

int MercuryDisplay::Next3Lights(const MercuryLight* light[3], unsigned int& count)
{
    unsigned int i;
    if (m_currentState.GetState(MGLS_LIGHTING))
    {
        for (i = 0; i < 3; ++i)
                light[i] = NULL;
        for (i = 0; (i < 3) && (count+i < m_foundLights.size()); ++i)
                light[i] = m_foundLights[count+i];
        count += i;
        return m_foundLights.size() - count;
    }
    return 0;
}

MercuryGLState MercuryDisplay::SetStates(MercuryGLState states)
{
    MercuryGLState newstate = m_globalState.back()&states;
    MercuryGLState changedStates = m_currentState^newstate;
    m_currentState = newstate;
    return changedStates;
}

void MercuryDisplay::SetView(const MercuryPoint& position, const MercuryMatrix& m, const LookAtInternals& lai)
{
    m_view = m;
    m_pLastCameraPos = position;
    SetupClippingPlanes(position, lai.m_direction, lai.m_up, lai.m_x);
}

void MercuryDisplay::EnqueueObject(const RenderPacket& rp)
{
    m_renderObjects.push_back(rp);
}

Projection Perspective( float fov, float aspect, float znear, float zfar )
{
    Projection p;
    p.m_frustumInfo.m_fov = fov;
    p.m_frustumInfo.m_aspect = aspect;
    p.m_frustumInfo.m_znear = znear;
    p.m_frustumInfo.m_zfar = zfar;

    float xmin, xmax, ymin, ymax;

    ymax = znear * TAN(fov * Q_PI / 360.0);
    ymin = -ymax;
    xmin = ymin * aspect;
    xmax = ymax * aspect;

    p.m_matrix = Frustum(xmin, xmax, ymin, ymax, znear, zfar);
    return p;
}

Projection Ortho(float left, float right, float bottom, float top, float zNear, float zFar)
{
    Projection p;
    MercuryMatrix& PERSP = p.m_matrix;

    //row major
    PERSP[0][0] = 2/(right-left);
    PERSP[0][3] = -(right+left)/(right-left);
    PERSP[1][1] = 2/(top-bottom);
    PERSP[1][3] = -(top+bottom)/(top-bottom);
    PERSP[2][2] = -2/(zFar-zNear);
    PERSP[2][3] = (zFar + zNear)/(zFar-zNear);
    PERSP[3][3] = 1;

    return p;
}

MercuryMatrix Frustum(float left, float right, float bottom, float top, float zNear, float zFar)
{
    //http://pyopengl.sourceforge.net/documentation/manual/glFrustum.3G.html

    MercuryMatrix frustum;

    float near2 = 2*zNear;
    float rml = right-left;
    float tmb = top - bottom;
    float fmn = zFar - zNear;

    float A = (right+left)/rml;
    float B = (top+bottom)/tmb;
    float C = -(zFar+zNear)/fmn;
    float D = -(near2*zFar)/fmn;

    frustum.Zero();

    //row major
    frustum[0][0] = near2/rml;
    frustum[0][2] = A;
    frustum[1][1] = near2/tmb;
    frustum[1][2] = B;
    frustum[2][2] = C;
    frustum[2][3] = D;
    frustum[3][2] = -1;

    return frustum;
}

MercuryDisplay * GetDisplay()
{
    return DISPLAY;
}

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