graphics.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GRAPHICS_GRAPHICS_H
#define GRAPHICS_GRAPHICS_H

#include "src/common/atomic.h"

#include <vector>
#include <list>

#include "glm/mat4x4.hpp"

#include "src/common/types.h"
#include "src/common/scopedptr.h"
#include "src/common/singleton.h"
#include "src/common/mutex.h"
#include "src/common/ustring.h"

#include "src/graphics/types.h"
#include "src/graphics/windowman.h"

#include "src/graphics/aurora/animationthread.h"

#include "src/events/notifyable.h"

namespace Graphics {

namespace Aurora {
    class Model;
}

class FPSCounter;
class Cursor;
class Renderable;

class GraphicsManager : public Common::Singleton<GraphicsManager>, public Events::Notifyable {
public:
    enum ScalingType {
        kScalingNone = 0,
        kScalingWindowSize
    };

    GraphicsManager();
    ~GraphicsManager();

    void init();
    void deinit();

    bool ready() const;

    bool needManualDeS3TC() const;
    bool supportMultipleTextures() const;
    size_t getMultipleTextureCount() const;

    bool isGL3() const;

    bool isRendererExperimental() const { return _rendererExperimental; }

    bool setFSAA(int level);

    int getCurrentFSAA() const;

    uint32 getFPS() const;

    void setCullFace(bool enabled, GLenum mode = GL_BACK);

    void setGUIScale(ScalingType scaling);
    void setGUISize(int guiWidth, int guiHeight);

    void setPerspective(float viewAngle, float clipNear, float clipFar);
    void setOrthogonal(float clipNear, float clipFar);

    void setCursor(Cursor *cursor = 0);

    void takeScreenshot();

    bool project(float x, float y, float z, float &sX, float &sY, float &sZ);

    bool unproject(float x, float y,
                   float &x1, float &y1, float &z1,
                   float &x2, float &y2, float &z2) const;

    Renderable *getObjectAt(float x, float y);

    void recalculateObjectDistances();

    void lockFrame();
    void unlockFrame();

    uint32 createRenderableID();

    void abandon(TextureID *ids, uint32 count);
    void abandon(ListID ids, uint32 count);


    void renderScene();

    // Block of functions below may or may not be modified in the future.
    const glm::mat4 &getProjectionMatrix() const;
    glm::mat4 &getProjectionMatrix();
    const glm::mat4 &getProjectionInverseMatrix() const;

    const glm::mat4 &getModelviewMatrix() const;
    glm::mat4 &getModelviewMatrix();
    const glm::mat4 &getModelviewInverseMatrix() const;

    void pauseAnimations();
    void resumeAnimations();

    void registerAnimatedModel(Aurora::Model *model);
    void unregisterAnimatedModel(Aurora::Model *model);

private:
    enum ProjectType {
        kProjectTypePerspective,
        kProjectTypeOrthogonal
    };

    bool _ready; 

    bool _debugGL; 

    bool _rendererExperimental; 

    // Extensions
    bool   _needManualDeS3TC;        
    bool   _supportMultipleTextures; 
    size_t _multipleTextureCount;    

    WindowManager::RenderType _renderType;

    int _fsaa;    

    bool   _cullFaceEnabled;
    GLenum _cullFaceMode;

    ProjectType _projectType;

    float _viewAngle;
    float _clipNear;
    float _clipFar;

    ScalingType _scalingType;
    int _guiHeight;
    int _guiWidth;

    Common::ScopedPtr<FPSCounter> _fpsCounter; 

    uint32 _lastSampled; 

    glm::mat4 _perspective;    
    glm::mat4 _perspectiveInv; 
    glm::mat4 _ortho;          
    glm::mat4 _orthoInv;       
    glm::mat4 _projection;     
    glm::mat4 _projectionInv;  
    glm::mat4 _modelview;      
    glm::mat4 _modelviewInv;   

    boost::atomic<uint32> _frameLock;
    boost::atomic<bool>   _frameEndSignal;

    Cursor     *_cursor;       

    bool _takeScreenshot; 

    uint32 _renderableID;             
    Common::Mutex _renderableIDMutex; 

    bool _hasAbandoned; 

    std::vector<TextureID> _abandonTextures; 
    std::list<ListID>      _abandonLists;    

    Common::Mutex _abandonMutex; 

    Aurora::AnimationThread _animationThread;

    void setupScene();

    bool setupSDLGL();
    void checkGLExtensions();

    void perspective(float fovy, float aspect, float zNear, float zFar);
    void ortho(float left, float right, float bottom, float top, float zNear, float zFar);

    void rebuildGLContainers();
    void destroyGLContainers();

    void destroyContext();
    void rebuildContext();

    void cleanupAbandoned();

    Renderable *getGUIObjectAt(float x, float y) const;
    Renderable *getWorldObjectAt(float x, float y) const;

    void buildNewTextures();

    void beginScene();
    bool playVideo();
    bool renderWorld();
    bool renderGUIFront();
    bool renderGUIBack();
    bool renderGUIConsole();
    bool renderGUI(ScalingType scalingType, QueueType guiQueue, bool disableDepthMask);
    bool renderCursor();

    bool renderWorldShader();
    bool renderGUIFrontShader();
    bool renderGUIBackShader();
    bool renderGUIConsoleShader();
    bool renderGUIShader(ScalingType scalingType, QueueType guiQueue, bool disableDepthMask);
    bool renderCursorShader();

    void endScene();

    void notifyResized(int oldWidth, int oldHeight, int newWidth, int newHeight);
};

} // End of namespace Graphics

#define GfxMan Graphics::GraphicsManager::instance()

#endif // GRAPHICS_GRAPHICS_H