RenderTarget.cpp

//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//

// Headers
#include <SFML/Graphics/RenderTarget.hpp>
#include <SFML/Graphics/Drawable.hpp>
#include <SFML/Graphics/GraphicsContext.hpp>
#include <iostream>
 
 
namespace sf
{
RenderTarget::RenderTarget() :
myCurrentView   (&myDefaultView),
myPreserveStates(false),
myIsDrawing     (false)
{
 
}
 

RenderTarget::~RenderTarget()
{
    // Nothing to do
}
 

void RenderTarget::Clear(const Color& FillColor)
{
    if (Activate(true))
    {
        // Clear the frame buffer
        GLCheck(glClearColor(FillColor.r / 255.f, FillColor.g / 255.f, FillColor.b / 255.f, FillColor.a / 255.f));
        GLCheck(glClear(GL_COLOR_BUFFER_BIT));
 
        Activate(false);
    }
}
 

void RenderTarget::Draw(const Drawable& Object)
{
    // Check whether we are called from the outside or from a previous call to Draw
    if (!myIsDrawing)
    {
        myIsDrawing = true;
 
        // Set our target as the current target for rendering
        if (Activate(true))
        {
            // Save the current render states and set the SFML ones
            if (myPreserveStates)
            {
                GLCheck(glPushAttrib(GL_COLOR_BUFFER_BIT | GL_CURRENT_BIT   | GL_ENABLE_BIT  |
                                     GL_TEXTURE_BIT      | GL_TRANSFORM_BIT | GL_VIEWPORT_BIT));
                GLCheck(glMatrixMode(GL_MODELVIEW));  GLCheck(glPushMatrix());
                GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glPushMatrix());
                SetRenderStates();
            }
 
            // Set the window viewport and transform matrices
            GLCheck(glViewport(0, 0, GetWidth(), GetHeight()));
            GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glLoadMatrixf(myCurrentView->GetMatrix().Get4x4Elements()));
            GLCheck(glMatrixMode(GL_MODELVIEW));  GLCheck(glLoadIdentity());
 
            // Let the object draw itself
            Object.Draw(*this);
 
            // Restore render states
            if (myPreserveStates)
            {
                GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glPopMatrix());
                GLCheck(glMatrixMode(GL_MODELVIEW));  GLCheck(glPopMatrix());
                GLCheck(glPopAttrib());
            }
 
            // Deactivate rendering on this target
            Activate(false);
        }
 
        myIsDrawing = false;
    }
    else
    {
        // We are already called from a previous Draw : we don't need to set the states again, just draw the object
        Object.Draw(*this);
    }
}
 

void RenderTarget::SetView(const View& NewView)
{
    myCurrentView = &NewView;
}
 

const View& RenderTarget::GetView() const
{
    return *myCurrentView;
}
 

View& RenderTarget::GetDefaultView()
{
    return myDefaultView;
}
 

void RenderTarget::PreserveOpenGLStates(bool Preserve)
{
    myPreserveStates = Preserve;
}
 

void RenderTarget::Initialize()
{
    // Set the default rendering states
    SetRenderStates();
 
    // Setup the default view
    myDefaultView.SetFromRect(FloatRect(0, 0, static_cast<float>(GetWidth()), static_cast<float>(GetHeight())));
    SetView(myDefaultView);
}
 

void RenderTarget::SetRenderStates()
{
    GLCheck(glDisable(GL_ALPHA_TEST));
    GLCheck(glDisable(GL_DEPTH_TEST));
    GLCheck(glDisable(GL_LIGHTING)); 
}
 
} // namespace sf