moRenderManager.h

Ir a la documentación de este archivo.

/*******************************************************************************

                                moRenderManager.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                          *
  *   This code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa


*******************************************************************************/

#ifndef __MO_RENDERMANAGER_H__
#define __MO_RENDERMANAGER_H__

#include <moTextureManager.h>
#include <moGUIManager.h>
#include <moBuckets.h>

class moEffect;
class moBucketPool;

#define MO_RENDER_RESOLUTION 0
#define MO_SCREEN_RESOLUTION 1

#define MO_RENDER_TO_TEXTURE_FBSCREEN 0
#define MO_RENDER_TO_TEXTURE_FBOBJECT 1

enum moRenderManagerMode {

  RENDERMANAGER_MODE_NORMAL=0,
  RENDERMANAGER_MODE_FRAMEBUFFER=1,
  RENDERMANAGER_MODE_VDPAU=2

};

enum moRenderOutputMode {

    MO_RENDER_OUTPUT_MODE_NORMAL, 
    MO_RENDER_OUTPUT_MODE_ADVANCED 

};

class LIBMOLDEO_API moResolution {

  public:

        int Width() const { return width; }
        int Height() const { return height; }
        float Aspect() const { return aspect; }

        int width;
        int height;
        float aspect;


};


class LIBMOLDEO_API moRenderClip {

    public:

        moVector2f points[4];


};

moDeclareExportedDynamicArray( moRenderClip*, moRenderClips);


class LIBMOLDEO_API moDisplay : public moAbstract {

  public:

    moDisplay();
    moDisplay( int w, int h);
    moDisplay( float w, float h);
    moDisplay( const moDisplay& p_src );
    virtual ~moDisplay();
    moDisplay& operator= ( const moDisplay& p_src );

    const moResolution& Resolution() const {
      return m_DisplayResolution;
    }

    float HeightToProportion( float p_height ) const {
      return p_height/Proportion();
    }

    float Proportion() const {
      return m_DisplayResolution.Aspect();
    }

  private:

    moResolution    m_DisplayResolution;

};

moDeclareExportedDynamicArray( moDisplay*, moDisplays);


class LIBMOLDEO_API moRenderOutputConfiguration {

  public:

        moRenderOutputMode m_OutputMode;

        moResolution    m_RenderResolution;

        moResolution    m_OutputResolution;


        moRenderClips  Clips;

        moDisplays Displays;

};




class LIBMOLDEO_API moRenderManager : public moResource
{
    public:
        moRenderManager();
        virtual ~moRenderManager();

        bool Lock();
        bool Unlock();

        virtual MOboolean Init( moRenderManagerMode p_render_to_texture_mode,
                  MOint p_screen_width, MOint p_screen_height,
                  MOint p_render_width, MOint p_render_height);
        virtual MOboolean Finish();

        void SetView( int p_width, int p_height );
        void SetInterfaceView( int p_width, int p_height );

        MOboolean IsRenderToFBOEnabled();
        MOboolean RenderResEqualScreenRes();

        void SetRenderToTexMode( moRenderManagerMode p_render_to_texture_mode);
        MOint GetRenderToTexMode() { return m_render_to_texture_mode; }

        void BeginUpdate();
        void BeginUpdateDevice();
        void EndUpdateDevice();
        void EndUpdate();

        void BeginUpdateObject();
        void EndUpdateObject();

        void BeginDraw();
        void BeginDrawEffect();
        void EndDrawEffect();
        void EndDraw();

        void DrawRenderTexure(MOint p_resolution) { DrawTexture(p_resolution, 0); }
        void DrawTexture(MOint p_resolution, MOint p_tex_num);
        void DrawTexture(MOint p_width, MOint p_height, MOint p_tex_num);
        void SaveScreen();

        bool Screenshot( moText pathname, moText& screenshot_result, const moText& image_format="PNG", const moText& file_pattern="image_{DATETIME}_{####}.png" );

    bool PreviewShot( bool shot_start = false);

        void CopyRenderToTexture(MOint p_tex_num);
        MOint RenderTexGLId(MOint p_tex_num);

        MOint ScreenWidth() const;
        MOint ScreenHeight() const;

        MOint InterfaceWidth() const;
        MOint InterfaceHeight() const;

        float ScreenProportion() const;


        MOint RenderWidth() const;
        MOint RenderHeight() const;

        float RenderProportion() const;


        MOboolean MultiTextureSupported() const;
        MOboolean FramebufferObjectSupported() const;
        MOboolean ShadersSupported() const;

    MOboolean IsTextureNonPowerOf2Disabled() const;

        void    SetOutputConfiguration( moRenderOutputConfiguration p_output_configuration );

        moRenderOutputConfiguration& GetOutputConfiguration();

        moBucketsPool*  GetFramesPool() {
                return m_pFramesPool;
        }

    int   CreateLayer( moEffect* p_scene_effect );
    void   RenderLayer( int layer_id );
    int    Render( moObject3D* p_pObj, moCamera3D* p_pCamera );


    protected:

    moTimerAbsolute m_PreviewShotTimer;
    int             m_PreviewShotIteration;
        moLock                  m_RenderLock;

        MOboolean               m_saved_screen;

        moTextureManager*       m_pTextureManager;
        moGLManager*            m_pGLManager;
        moFBManager*            m_pFBManager;
        moShaderManager*            m_pSHManager;

        moDecoderManager*   m_pDecoderManager;

        moRenderOutputConfiguration m_OutputConfiguration;

        moBucketsPool*           m_pFramesPool;

        moRenderManagerMode m_render_to_texture_mode;

        MOint m_screen_width, m_screen_height;
    MOint m_render_width, m_render_height;
    MOint m_interface_width, m_interface_height;

    MOint m_render_tex_moid[6];
        MOuint m_render_attach_points[4];
        MOuint m_fbo_idx;

        MOboolean ValidSourceTexNum(MOint p_tex_num) const { return (0 <= p_tex_num) && (p_tex_num < 4); }
        MOboolean ValidDestTexNum(MOint p_tex_num) const { return (0 < p_tex_num) && (p_tex_num < 4); }
};


#endif