tex_mgmt.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software 
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

/*!****************************************************************************
 * \file    tex_mgmt.h
 * \author  Raj Sharma, roos@allacrost.org
 * \brief   Header file for texture management code
 *
 * We use texture management so that at runtime, we can load many small
 * images (e.g. tiles) and stick them together into larger textures called
 * "texture sheets". This improves performance, because then we don't have to
 * constantly switch textures while rendering.
 *
 * This file contains several classes:
 *
 * TexSheet: physically represents an OpenGL texture in memory, plus a pointer
 *           to a texture management class which keeps track of which images
 *           are in that texture sheet.
 *
 * TexMemMgr: abstract base class, used by TexSheet. The job of a texture
 *            memory manager is to allocate sub-rectangles within the sheet
 *            so we can stuff images into it.
 *
 * FixedTexMemMgr: texture memory manager for fixed-size images, i.e. 32x32.
 *                 This class can do all its operations in constant (O(1)) time
 *                 because it knows in advance that all textures are the same size
 *
 * FixedImageNode: this represents a single allocation within the fixed-size
 *                 texture memory manager
 *
 * VariableTexMemMgr: this manages memory for any size images. This works fairly
 *                    well in practice, but it generally has a fair amount of wasted
 *                    space, because the images don't always "fit together" perfectly
 *                    on the sheet.
 *
 * VariableImageNode: a single alloaction within the variable-size texture memory
 *                    manager
 *****************************************************************************/ 


#ifndef __TEX_MGMT_HEADER__
#define __TEX_MGMT_HEADER__

#include "defs.h"
#include "utils.h"

// OpenGL includes
#ifdef __APPLE__
  #include <OpenGL/gl.h>
  #include <OpenGL/glu.h>
#else
  #include <GL/gl.h>
  #include <GL/glu.h>
#endif

namespace hoa_video
{

namespace private_video
{



enum TexSheetType
{
  VIDEO_TEXSHEET_INVALID = -1,
  
  VIDEO_TEXSHEET_32x32 = 0,
  VIDEO_TEXSHEET_32x64 = 1,
  VIDEO_TEXSHEET_64x64 = 2,
  VIDEO_TEXSHEET_ANY = 3,
  
  VIDEO_TEXSHEET_TOTAL = 4
};





class TexMemMgr
{
public:
  
  virtual ~TexMemMgr() {}


  virtual bool Insert  (Image *img)=0;
  

  virtual bool Remove  (Image *img)=0;
  

  virtual bool Free    (Image *img)=0;
  

  virtual bool Restore (Image *img)=0;
};





class TexSheet
{
public:

  TexSheet(int32 w, int32 h, GLuint texID_, TexSheetType type_, bool is_static_);
  ~TexSheet();


  bool AddImage
  (
    Image *img,
    ImageLoadInfo & load_info
  );
  

  bool CopyRect(int32 x, int32 y, private_video::ImageLoadInfo & load_info);


  bool CopyScreenRect(int32 x, int32 y, const ScreenRect &screen_rect);
  

  bool RemoveImage (Image *img);
  

  bool FreeImage   (Image *img);
  

  bool RestoreImage (Image *img);
  

  bool Unload();
  

  bool Reload();

  int32 width;
  
  int32 height;

  bool is_static;
  
  TexSheetType type;

  TexMemMgr *tex_mem_manager;

  GLuint tex_ID;
  
  bool loaded;    
};





class FixedImageNode
{
public:

  Image          *image;
  
  FixedImageNode *next;
  
  FixedImageNode *prev;
  
  int32 block_index;
};





class FixedTexMemMgr : public TexMemMgr
{
public:
  FixedTexMemMgr(TexSheet *texSheet, int32 imgW, int32 imgH);
  ~FixedTexMemMgr();
  

  bool Insert  (Image *img);
  

  bool Remove  (Image *img);
  

  bool Free    (Image *img);
  

  bool Restore (Image *img);

private:


  int32 _CalculateBlockIndex(Image *img);
  

  void _DeleteNode(int32 block_index);

  int32 _sheet_width;

  int32 _sheet_height;

  int32 _image_width;

  int32 _image_height;
  
  TexSheet *_tex_sheet;
  

  FixedImageNode *_open_list_head;


  FixedImageNode *_open_list_tail;
  

  FixedImageNode *_blocks;
};




class VariableImageNode
{
public:
  VariableImageNode()
  {
    image = NULL;
    free  = true;
  }

  Image *image;
  
  bool   free;
};





class VariableTexMemMgr : public TexMemMgr
{
public:
  
  VariableTexMemMgr(TexSheet *sheet);
  ~VariableTexMemMgr();


  bool Insert  (Image *img);
  

  bool Remove  (Image *img);
  

  bool Free    (Image *img);
  

  bool Restore (Image *img);

private:


  bool SetBlockProperties
  (
    Image *img, 
    bool change_free, 
    bool change_image, 
    bool free, 
    Image *new_image
  );

  TexSheet *_tex_sheet;
  
  VariableImageNode *_blocks;
    
  int32 _sheet_width;

  int32 _sheet_height;
};



}  // namespace private_video

}  // namespace hoa_video



#endif   // !__TEX_MGMT_HEADER__

---