moTextureManager.h

Ir a la documentación de este archivo.

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

                                moTextureManager.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_MANAGER_H
#define __MO_TEXTURE_MANAGER_H

#include "moTexture.h"
#include "moResourceManager.h"
#include <moFileManager.h>

typedef moTextureMemory* moTextureFramePtr;

moDeclareExportedDynamicArray(moTextureFramePtr,moTextureFrames);


enum moTextureBufferFormat {
    MO_TEXTURE_BUFFER_FORMAT_LEVELS = 0,
    MO_TEXTURE_BUFFER_FORMAT_PATTERNS = 1
};

class LIBMOLDEO_API moTextureBuffer : public moAbstract {

    public:
        moTextureBuffer();
        virtual ~moTextureBuffer();

        virtual MOboolean  Init();
        virtual MOboolean  Init( moText p_foldername, moText p_bufferformat, moResourceManager* p_pResourceManager );
        virtual MOboolean  Init( moText p_foldername, moTextureBufferFormat p_bufferformat, int p_pattern_width, int p_pattern_height, moResourceManager* p_pResourceManager );
        virtual MOboolean  Finish();

        virtual int GetFrame( MOuint p_i );

        virtual void ReleaseFrame( MOuint p_i );

        virtual moTextureMemory* GetTexture( MOuint p_i );

        MOboolean UpdateImages( int maxfiles = -1 );

        MOboolean   LoadCompleted();
        int GetImagesProcessed() { return  m_ImagesProcessed; }

        MOboolean LoadImage( moText p_ImageName, moBitmap* pImage, int indeximage );

        moText GetBufferPath() { return m_BufferPath; }
        moText  GetBufferFormat() { return m_BufferFormat; }

        moText GetName() { return m_FolderName; }

        moTextureFrames& GetBufferLevels( int L, int C );
        moTextureFrames& GetBufferPatterns( moTexture* p_ImageReference, int x, int y, int width=0, int height=0 );
        moTextureFrames& GetBufferPatterns( const moTexture& p_ImageReference, int x, int y, int width=0, int height=0 );

        int max_luminance;
        int min_luminance;
        int max_contrast;
        int min_contrast;

        //size of max_luminance
        MObyte*   LevelDiagram;

    private:

        int pattern_width;
        int pattern_height;

        MOint m_ImagesProcessed;
        MOboolean   m_bLoadCompleted;
        MOint m_ActualImage;


        moText  m_FolderName;
        moText  m_BufferPath;
        moText  m_BufferFormat;

        moResourceManager*  m_pResourceManager;

        moTextureFrames     m_Frames;
        moDirectory*    m_pDirectory;

        moTextureFrames**  m_pBufferLevels;
        moTextureFrames*  m_pBufferPatterns;

};

typedef moTextureBuffer* moTextureBufferPtr;

moDeclareExportedDynamicArray(moTextureBufferPtr,moTextureBuffers);



class LIBMOLDEO_API moTextureManager : public moResource
{
    public:

        moTextureManager();

        virtual ~moTextureManager();

        virtual MOboolean Init();

        virtual MOboolean Finish();

        MOint GetTextureMOId(moParam *param, MOboolean p_create_tex);

        MOint GetTextureMOId(moValue *value, MOboolean p_create_tex);


        MOint GetTextureMOId(moText p_name, MOboolean p_create_tex, bool p_refresh=false );

        MOint GetTextureMOId(MOuint p_glid);

        MOint GetTextureBuffer( moText p_foldername, MOboolean p_create_tex = true, moText p_bufferformat = "JPGAVERAGE" );

        moTextureBuffer* GetTextureBuffer( int idx );

        MOint AddTexture(MOuint p_type, moText p_name, moTexParam p_tex_param = MODefTex2DParams);

        MOint AddTexture(moParam* p_param);

        MOint AddTexture(moValue* p_value);

        MOint AddTexture(moText p_name, MOuint p_width, MOuint p_height, moTexParam p_tex_param = MODefTex2DParams);

        MOint AddTexture(moText p_name, MOuint p_width, MOuint p_height, GLvoid* p_buffer, GLenum p_pixel_format = GL_RGBA, GLenum p_pixel_type = GL_UNSIGNED_BYTE, moTexParam p_tex_param = MODefTex2DParams);

        MOint AddTexture(moText p_filename);

        MOint AddTextureBuffer( moText p_foldername, moText p_bufferformat = "JPGAVERAGE" );


        MOboolean DeleteTexture(MOuint p_moid);

        MOuint GetTextureCount() { return m_textures_array.Count(); }

        moTexture* GetTexture(MOuint p_moid) { return m_textures_array[p_moid]; }

        MOint GetType(MOuint p_moid);

        MOuint GetGLId(MOuint p_moid);

        moText GetName(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetName() : moText(""); }

        MOint GetWidth(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetWidth() : MO_UNDEFINED; }

        MOint GetHeight(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetHeight() : MO_UNDEFINED; }

        MOint GetDataWidth(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetDataWidth() : MO_UNDEFINED; }

        MOint GetDataHeight(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetDataHeight() : MO_UNDEFINED; }

        MOint GetComponents(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetComponents() : MO_UNDEFINED; }

        MOlong GetTexelCount(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetTexelCount() : MO_UNDEFINED; }

        MOlong GetDataTexelCount(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetDataTexelCount() : MO_UNDEFINED; }

        MOfloat GetMaxCoordS(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetMaxCoordS() : MO_UNDEFINED; }

        MOfloat GetMaxCoordT(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetMaxCoordT() : MO_UNDEFINED; }

        moTexParam GetTexParam(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetTexParam() : MOUndefinedTex; }

        GLenum GetTexTarget(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetTexTarget() : MO_UNDEFINED; }

        GLenum GetTexInternalFormat(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetTexInternalFormat() : MO_UNDEFINED; }

        GLint GetMinFilter(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetMinFilter() : MO_UNDEFINED; }

        GLint GetMagFilter(MOuint p_moid)  { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetMagFilter() : MO_UNDEFINED; }

        GLint GetWrapS(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetWrapS() : MO_UNDEFINED; }

        GLint GetWrapT(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetWrapT() : MO_UNDEFINED; }

        moFBO* GetFBO(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetFBO() : NULL; }

        MOint GetFBOAttachPoint(MOuint p_moid) { return ValidTexture(p_moid) ? m_textures_array[p_moid]->GetFBOAttachPoint() : MO_UNDEFINED; }

        MOboolean ValidTexture(MOuint p_moid) { return m_textures_array[p_moid] != NULL; }

        MOuint GetTypeForFile(moText p_filename);

    void RefreshAll();

        virtual void Update(moEventList *Events);


        int         m_preview_texture_idx;


    protected:
        moGLManager* m_glmanager;
        moFBManager* m_fbmanager;
        moTextureArray m_textures_array;

        moTextureBuffers    m_textures_buffers;


        moTexture* CreateTexture(MOuint p_type, moText p_name, moTexParam p_param = MODefTex2DParams);
        MOboolean CreateMultipleTex(moTextureMultiple* p_tex_mult, moParam* p_param);
        MOboolean CreateMultipleTex(moTextureMultiple* p_tex_mult, moValue* p_value);
};


#endif