MercuryWindowSDL.cpp

Go to the documentation of this file.

#include "MercuryWindowSDL.h"
#include "MercuryLog.h"
#include "MercuryDisplay.h"
#include "GL/glx.h"
#include <SDL/SDL.h>
    
MercuryWindowSDL::MercuryWindowSDL()
:MercuryWindow(0,0,false)
{
    LOG.Log("Video render: SDL");

    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        LOG.Warn(MString("SDL initialization failed: ") + SDL_GetError());
        throw;
    }
    
    m_info = SDL_GetVideoInfo( );
    
    if ( !m_info )
    {
        LOG.Warn(MString("Video query failed: ") + SDL_GetError());
        throw;
    }
}

MercuryWindowSDL::~MercuryWindowSDL()
{
    DestroyWindowAndRender();
}

bool MercuryWindowSDL::MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
    SetTitle(title);
    m_width = width;
    m_height  = height;
    m_bits = bits;

    if( m_RT == RT_OGL )
    {
        m_flags  = SDL_OPENGL;          /* Enable OpenGL in SDL */
        m_flags |= SDL_GL_DOUBLEBUFFER; /* Enable double buffering */
        m_flags |= SDL_HWPALETTE;       /* Store the palette in hardware */
        m_flags |= SDL_RESIZABLE;       /* Enable window resizing */       
    
        if (fullscreenflag)
            m_flags |= SDL_FULLSCREEN;

        if ( m_info->hw_available )
        {
            m_flags |= SDL_HWSURFACE;
            LOG.Log("Using hardware surface");
        }
        else
        {
            m_flags |= SDL_SWSURFACE;
            LOG.Log("Using software surface");
        }
    
        if ( m_info->blit_hw )
        {
            m_flags |= SDL_HWACCEL;
        }
        else
        {
            LOG.Log("No hardware acceleration");
        }

        SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); 
        MakeOGL();
        return true;
    }
    if( m_RT == RT_SW )
    {
        m_flags  = SDL_SWSURFACE;
        if( fullscreenflag )
            m_flags |= SDL_FULLSCREEN;
        m_BackBuffer = new unsigned char[m_width*m_height*m_bits/8];
        m_surface = SDL_SetVideoMode( m_width, m_height, m_bits, m_flags );
        if( !m_surface )
        {
            LOG.Warn( MString("SDL Set Video Mode FAILED: ") + SDL_GetError() );
            return false;
        }
        return true;
    }
    return false;
}

void MercuryWindowSDL::DestroyWindow()
{
}

bool MercuryWindowSDL::MakeOGL()
{
    m_surface = SDL_SetVideoMode( m_width, m_height, m_bits, m_flags );

    if ( !m_surface )
    {
        LOG.Log(MString("Video mode set failed: ") +  SDL_GetError());
        return false;
    }
    return true;
}

void MercuryWindowSDL::SwapBuffersInternal() 
{
    if( m_RT == RT_OGL )
    {
        //glXWaitGL();
        SDL_GL_SwapBuffers( );
        //glXWaitX();
        //glXSwapBuffers(m_surface, true);
    }
    if( m_RT == RT_SW )
    {
        SDL_UpdateRect( m_surface,0,0,m_width,m_height);    
    }
}

bool MercuryWindowSDL::Update(const float dTime)
{
    if (SDL_PollEvent(&m_event))
    {
        switch(m_event.type)
        {
            case SDL_ACTIVEEVENT:
                if ( m_event.active.state & SDL_APPACTIVE )
                    if ( m_event.active.gain )
                        m_minimized = false;
                    else
                        m_minimized = true;
                break;
            case SDL_VIDEORESIZE:
                DISPLAY->Resize((int)m_event.resize.w, (int)m_event.resize.h);
                SDL_SetVideoMode( m_width, m_height, m_bits, m_flags );
                break;
            case SDL_QUIT:
                return false;
        }
    }
    return true;
}

bool MercuryWindowSDL::HasFocus()
{
    int state = SDL_GetAppState();

    if (state & SDL_APPINPUTFOCUS)
        return true;

    return false;
}

void MercuryWindowSDL::DestroyWindowAndRender()
{
    SDL_Quit( );
}

bool MercuryWindowSDL::RestoreDevice()
{
    return true;
}

bool MercuryWindowSDL::MakeRenderCurrent()
{
    return true;
}

unsigned char * MercuryWindowSDL::GetBackDirectBuffer()
{
    return (unsigned char*)m_surface->pixels;
}

bool MercuryWindowSDL::MakeRender(const char* title, int width, int height, int bits, bool fullscreenflag, RendererType rt )
{
    m_RT = rt;
    return MakeWindow(title, width, height,bits, fullscreenflag);
}

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