moTexture.h

Ir a la documentación de este archivo.

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

                                 moTexture.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
  Andres Colubri

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

#ifndef __MO_TEXTURE_H__
#define __MO_TEXTURE_H__

#include "moTypes.h"
#include "moText.h"
#include "moParam.h"
#include "moBuckets.h"
#include "moVideoGraph.h"
#include "moGsGraph.h"
#include "moDsGraph.h"
#include "moMathVector3.h"

typedef void moBitmap;
typedef int moBitmapFormat;
typedef void moMemory;


typedef enum  {
        MO_TYPE_TEXTURE, 
        MO_TYPE_TEXTURE_MULTIPLE, 
        MO_TYPE_MOVIE,
        MO_TYPE_VIDEOBUFFER,
        MO_TYPE_TEXTUREMEMORY,
        MO_TYPE_TEXTUREBUFFER,
        MO_TYPE_CIRCULARVIDEOBUFFER 
} moTextureType;

class moFBO;
class moTexture;
class moGLManager;
class moDataManager;
class moFile;
class moFileManager;
class moResourceManager;



class LIBMOLDEO_API moTexture : public moAbstract {
    public:
        moTexture();
        virtual ~moTexture();

        virtual MOboolean Init(moText p_name, MOuint p_moid, moResourceManager* p_res, moTexParam p_param = MODefTex2DParams);
        virtual MOboolean Finish();

        MOboolean BuildEmpty(MOuint p_width, MOuint p_height);
        MOboolean BuildFromBuffer(MOuint p_width, MOuint p_height, const GLvoid* p_buffer, GLenum p_format = GL_RGBA, GLenum p_type = GL_UNSIGNED_BYTE);
        MOboolean BuildFromFile(moText p_filename);

        MOboolean SupportedFile(moText p_filename);

        MOboolean Load( moParam* p_param );
        MOboolean Load( moValue* p_value );

        MOboolean SetBuffer( const GLvoid* p_buffer, GLenum p_format = GL_RGBA, GLenum p_type = GL_UNSIGNED_BYTE);
        MOboolean SetBuffer(MOuint p_width, MOuint p_height, const GLvoid* p_buffer, GLenum p_format = GL_RGBA, GLenum p_type = GL_UNSIGNED_BYTE);

        MOboolean GetBuffer(GLvoid* p_buffer, GLenum p_format = GL_RGBA, GLenum p_type = GL_UNSIGNED_BYTE);

        void SetGLMan(moGLManager* p_gl) { m_gl = p_gl; }
        void SetDataMan(moDataManager* p_dataman) { m_pDataMan = p_dataman; }
        void SetFileMan(moFileManager* p_fileman) { m_pFileMan = p_fileman; }

        void SetFBO(moFBO* p_fbo) { m_fbo = p_fbo; }
        MOuint SetFBOandAttachPoint(moFBO* p_fbo);
        void SetFBOAttachPoint(MOuint p_fbo_attach_point) { m_fbo_attach_point = p_fbo_attach_point; }
        moFBO* GetFBO() const { return m_fbo; }
        MOuint GetFBOAttachPoint() const { return m_fbo_attach_point; }

        moTextureType GetType() const { return m_type; }
        MOuint GetGLId() const { return m_glid; }
        MOuint GetGLId( moMoldeoObject* p_src_mob );
        MOuint GetMOId() const { return m_moid; }
        void SetMOId(MOuint p_moid) { m_moid = p_moid; }
        moText GetName() const { return m_name; }
        void SetName(moText p_name) { m_name = p_name; }

        MOuint GetWidth() const { return m_width; }
        MOuint GetHeight() const { return m_height; }
        MOuint GetDataWidth() const;
        MOuint GetDataHeight() const;
        MOuint GetComponents() const { return m_components; }
        MOlong GetTexelCount() const { return m_width * m_height * m_components; }
        MOlong GetDataTexelCount() const { return GetDataWidth() * GetDataHeight() * m_components; }

        MOfloat GetMaxCoordS() const { return m_max_coord_s; }
        MOfloat GetMaxCoordT() const { return m_max_coord_t; }

        moTexParam GetTexParam() const { return m_param; }
        GLenum GetTexTarget() const { return m_param.target; }
        GLenum GetTexInternalFormat() const { return m_param.internal_format; }
        GLint GetMinFilter() const { return m_param.min_filter; }
        GLint GetMagFilter() const { return m_param.mag_filter; }
        GLint GetWrapS() const { return m_param.wrap_s; }
        GLint GetWrapT() const { return m_param.wrap_t; }

        void FlipBufferVert(MOubyte *pBuffer, MOint p_depth);

        void CopyFromTex(moTexture* p_src_tex, MOboolean p_copy_glid, MOboolean p_copy_moid, MOboolean p_copy_type, MOboolean p_copy_name);
        moTexture &operator = (const moTexture &p_src_tex);

        MOboolean       IsBuildedFromFile() const {
                return m_bBuildedFromFile;
        }

        moText  CreateThumbnail( moText p_bufferformat, int w, int h, moText newfilename = moText("") );

        bool  CalculateLuminanceAndConstrast( int x0 = 0, int y0 = 0, int x1 = 0, int y1 = 0 );

        int  GetLuminance() const { return Luminance; }
        int  GetContrast() const { return Contrast; }
        static MOuint NextPowerOf2(MOuint p_seed);
        MOboolean Refresh();

protected:

    MOboolean       m_bBuildedFromFile;

    moFile*         m_pFile;
    moDataManager*  m_pDataMan;
    moFileManager*  m_pFileMan;
    moGLManager* m_gl;
    moResourceManager*  m_pResourceManager;

    moFBO* m_fbo;
    MOuint m_fbo_attach_point;

    moTextureType m_type;
    MOint m_moid;
    MOuint m_glid;
    moText m_name;

        moTexParam m_param;
        MOuint m_width;
        MOuint m_height;
        MOuint m_bytespp;
        MOint m_components;
        MOfloat m_max_coord_s;
        MOfloat m_max_coord_t;

        void SetParam();
        void CalculateSize(MOuint p_width, MOuint p_height);
        MOboolean Build();

        int Luminance;
        int Contrast;

        moDWord Histogram[256];
        MOubyte* m_pBufferData;
        MOuint m_buffer_width;
        MOuint m_buffer_height;
        MOuint m_buffer_bytespp;
        bool ResetBufferData( bool force_creation = false, int bytes_per_pixel=0 );
};


moDeclareExportedDynamicArray( moTexture*, moTextureArray);




class LIBMOLDEO_API moTextureMemory : public moTexture {
    public:
        moTextureMemory();
        virtual ~moTextureMemory();

        virtual MOboolean Init( moText p_name, MOuint p_moid, moResourceManager* p_res, moTexParam p_param = MODefTex2DParams);

        virtual MOboolean Init( moText p_name, MOuint p_moid, moResourceManager* p_res, moText bufferformat, moBitmap* pImageResult, moTexParam p_param = MODefTex2DParams );

        //virtual MOboolean BuildFromFile( moText p_filename );

        //virtual MOboolean BuildFromFile( moText p_filename, moText p_bufferformat );

        virtual MOboolean BuildFromMemory();
        moBitmap* LoadFromMemory();
        MOubyte* GetBits();
        void Unload( moBitmap* p_bitmap  );

        virtual MOboolean BuildFromBitmap( moBitmap* p_bitmap, moText p_bufferformat = "JPG" );


        virtual MOboolean LoadFromBitmap( moBitmap* p_bitmap );


        virtual MOboolean Finish();

        int  GetReference();

        void  ReleaseReference();

        int GetContrast() { return Contrast; }

        int GetLuminance() { return Luminance; }


        moVector3f  GetColorMatrixCorner( int corner ) { return color_matrix[corner]; }
        moVector3f  GetColorAverage() { return color_average; }

    private:

        //four corners average color
        moVector3f      color_matrix[4];
        moVector3f      color_average;

        MOint       reference_counter;

        MOint       options;

        moMemory    *hmem;
        moBitmapFormat fif;
        MOuint _format;
        //FIBITMAP *m_pImage;

        MOlong m_SizeInMemory;

        moText m_BufferFormat;
        MOboolean   m_bBitmapInMemory;

        MOint   Luminance;

        MOint   Contrast;

        moDWord Histogram[256];

};

#include "moTextureIndex.h"

class moShader;
class moTextureFilter;


class LIBMOLDEO_API moTextureAnimated : public  moTexture
{
    public:
        moTextureAnimated();
        virtual ~moTextureAnimated();

        virtual MOboolean  Init(moText p_name, MOuint p_moid, moResourceManager* p_res, moTexParam p_param = MODefTex2DParams);
        virtual MOboolean  Finish();

    virtual void Play();

    virtual void Stop();

    virtual bool IsPlaying();


        virtual MOint       GetGLId( moTempo *tempo );
        virtual MOint       GetGLId( MOuint p_i );
        virtual MOint       GetGLId( MOfloat p_cycle );

        virtual MOuint      GetFrameCount() { return m_nFrames; }
        virtual void        SetFrameCount( MOuint p_nframes ) { m_nFrames = p_nframes; } //

        virtual MOfloat     GetFramesPerSecond() { return m_fFramesPerSecond; }

        virtual void        SetFramesPerSecond( MOfloat p_fps) { m_fFramesPerSecond = p_fps; }


    enum moPlayMode {
      MO_PLAYMODE_TIMEBASE, 
      MO_PLAYMODE_FRAMEBASE 
    };
    virtual void SetPlayMode( moPlayMode playmode );

    virtual moPlayMode GetPlayMode();

        virtual void        GetFrame( MOuint p_i );

        virtual MOuint      GetActualFrame();

        virtual void        SetInterpolation( MOuint p_FrameJump, MOuint p_InterpolationTime );
        virtual MOboolean   IsInterpolating();
        virtual MOboolean   IsInterpolationActive();
        virtual MOboolean   ActivateInterpolation( MOboolean activate = true );

    protected:

        virtual MOboolean   NeedsInterpolation();
        virtual MOint       Interpolate();

    moPlayMode    m_PlayMode;
    MOboolean     m_bIsPlaying;
    MOboolean     m_bIsPaused;

        MOuint              m_nFrames;
        MOfloat             m_fFramesPerSecond;

        MOuint              m_FrameNext;
        MOuint              m_FramePrevious;
        MOuint              m_Time;
        MOuint              m_ActualFrame;

        //interpolation flags
        MOboolean           m_bInterpolation;
        MOboolean           m_bInterpolating;

        //interpolation filters
        moTextureFilter*    m_pCopyStart;
        moTextureFilter*    m_pCopyEnd;
        moTextureFilter*    m_pInterpolator;

        //interpolation textures
        moTextureArray      m_srcstart,m_dststart;
        moTextureArray      m_srcend,m_dstend;
        moTextureArray      m_srcinterpol,m_dstinterpol;

        //interpolation shaders
        moShader*           m_pShaderCopy;
        moShader*           m_pShaderInterpolate;

        //interpolation parameters
        MOuint              m_FrameJump;/* salto entre el cuadro inicial y final mínimo, para resolver la interpolación*/
        MOuint              m_InterpolationTime;/*intervalo de resolución de la interpolación en milisegundos*/

        //interpolation variables
        MOuint              m_StartTime;
        MOuint              m_FrameStart;/*cuadro inicial de la interpolación*/
        MOuint              m_FrameEnd;/*cuadro final de la interpolación*/
        MOfloat             m_InterpolationPosition;/*valor entre 0 y 1 indicando el nivel de interpolación, 0 corresponde al cuadro inicial, 1 al cuadro final*/

};


class LIBMOLDEO_API moTextureMultiple : public moTextureAnimated
{
    public:

        moTextureMultiple();
        ~moTextureMultiple();

        virtual MOboolean  Init(moText p_name, MOuint p_moid, moResourceManager* p_res, moTexParam p_param = MODefTex2DParams);
        virtual MOboolean  Finish();

        MOboolean SupportedFile(moText p_filename);
        MOboolean Load(moParam* p_param);

        MOboolean Load(moValue* p_value);

        MOboolean Load(moText p_name, moTextureArray &p_textures, MOuint p_id0, MOuint p_id1);

        void SetTextureCount(MOuint p_tex_count);
        MOuint GetTextureCount() { return m_textures_array.Count(); }
        void GetFrame(MOuint p_i);
        void SetFrame(MOuint p_i, moTexture* p_texture);
        void AddFrame(moTexture* p_texture);
        moTexture* GetTexture( MOuint p_i ) { return m_textures_array[p_i]; }

        MOboolean ValidTexture(MOuint p_i);


    protected:
        moTextureArray m_textures_array;

};


class LIBMOLDEO_API moMovie : public moTextureAnimated
{
    public:
        moMovie();
        virtual ~moMovie();

        virtual MOboolean  Init(moText p_name, MOuint p_moid, moResourceManager* p_res, moTexParam p_param = MODefTex2DParams);
        virtual MOboolean  Finish();

    virtual void Play();
    virtual void Pause();
    virtual void Continue();
    virtual void Stop();
    virtual void Seek( long frame, float rate = 1.0 );
    virtual bool IsPlaying();
    virtual bool IsPaused();
    virtual MOulong GetPosition();
    virtual moStreamState State();

    virtual void SetBrightness( float brightness );
    virtual void SetContrast( float contrast );
    virtual void SetSaturation( float saturation );
    virtual void SetHue( float hue );

    virtual void SetVolume( float volume );
    virtual void SetBalance( float balance );

        MOboolean SupportedFile(moText p_filename);
        MOboolean LoadMovieFile(moText p_filename);
        MOboolean Load( moParam* p_param );
        MOboolean Load( moValue* p_value );
        MOboolean Reload( bool force_kill=true );

        void EnableVideo(int);
        bool HasVideo();

        void EnableAudio(int);
        bool HasAudio();

    bool  IsEOS();

    protected:

        void GetFrame( MOuint p_i );

        MOint frameprevious;
        MOint lastframe;
        moText m_pFilename;
        moBucketsPool   m_BucketsPool;

    moVideoGraph*   m_pGraph;

};

#include "moFBO.h"
#include "moGLManager.h"
#include "moTextureFilter.h"

#endif