---

sglTexture2D.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglTexture2D.hpp
 *  Created: 11 March 2000
 *  Summary: container for 2D image data used for texturing
 *****************************************************************************/

#ifndef __SGL_TEXTURE_2D_HPP
#define __SGL_TEXTURE_2D_HPP

#include <sgl.h>
#include <vector>
#include <sglObject.hpp>
#include <sglVector.hpp>
#include <sglTexture.hpp>

//============================================================================

class SGL_DLL_API sglTexture2D : public sglTexture
{
public:
   sglTexture2D();
   virtual ~sglTexture2D();

   //   format = format of each texel in the image
   //   type   = data type of texel data
   //   num_s  = width of the image
   //   num_t  = height of the image
   //   border = true if the image has a one pixel border
   // Both num_s and num_t should have the form 2^m +2b, where m is a
   //   non-negative integer (which can be different for s and t) and
   //   b is zero or one (depending on border).  If num_s or num_t
   //   (minus the border) are not powers of two, or if the image is
   //   too large, the image will be automatically resized.
   // Returns false if the parameters are out of range.
   // Note: this will not free the memory from the previous image.
   // Note: this will clear the mipmap levels if not automatic.
   bool setImage(void *image, ExternalFormatEnum format, TypeEnum type,
                 unsigned int num_s, unsigned int num_t,
                 bool border = false);
   void getImage(void *&image, ExternalFormatEnum &format, TypeEnum &type,
                 unsigned int &num_s, unsigned int &num_t,
                 bool &border) const;

   bool setMipmapLevels(const vector<void *> &images);

   //   sub_image = the new texels
   //   level     = mipmap level of image
   //   offset_x  = texel offset in the original image
   //   offset_y  = texel offset in the original image
   //   width     = width of the replacement image
   //   height    = height of the replacement image
   // Returns false if the parameters are out of range.
   // Note: sub-textures once loaded are forgotten and will not
   //   be restored if the base image parameters are changed.
   bool subloadImage(void *sub_image,
                     GLint level,
                     GLint offset_x, GLint offset_y,
                     GLint width, GLint height);

   virtual bool replaceImage(void *new_image, GLint level = 0);

   inline void getSize(unsigned int &width, unsigned int &height) const
      {
         width  = m_width; height = m_height;
      }

   virtual unsigned int getIdealInternalSize() const;
   virtual unsigned int getLikelyInternalSize() const;

   void setWrapMode(WrapEnum s_repeat_flag, WrapEnum t_repeat_flag);
   void getWrapMode(WrapEnum &s_repeat_flag, WrapEnum &t_repeat_flag) const;

   virtual bool checkProxy();

   virtual void bind();

   // The replacement texels are taken from the framebuffer.
   //   level     = mipmap level of image
   //   offset_x  = texel offset in the original image
   //   offset_y  = texel offset in the original image
   //   win_x     = origin of the replacement image in the frame buffer
   //   win_y     = origin of the replacement image in the frame buffer
   //   width     = width of the replacement image
   //   height    = height of the replacement image
   // Returns false if the parameters are out of range.
   // Note: sub-textures once loaded are forgotten and will not
   //   be restored if the base image parameters are changed.
   // Must be called by a thread with a current rendering context.
   bool copyTexSubImage(GLint level,
                        GLint offset_x, GLint offset_y,
                        GLint win_x, GLint win_y,
                        GLint width, GLint height);

   virtual bool buildMipmaps(vector<void*> &mipmaps);

   static bool resizeImage(sglTexture::ExternalFormatEnum format,
                           sglTexture::TypeEnum type,
                           unsigned int old_s, unsigned int old_t,
                           bool border,
                           unsigned int new_s, unsigned int new_t,
                           void *old_image, void *&new_image);

   static bool halveImage(sglTexture::ExternalFormatEnum format,
                          sglTexture::TypeEnum type,
                          unsigned int &num_s, unsigned int &num_t,
                          bool border,
                          void *old_image, void *&new_image);

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglTexture2D(const sglTexture2D&);               // NOT IMPLEMENTED
   sglTexture2D& operator=(const sglTexture2D &);   // NOT IMPLEMENTED

   // helper function for get*InternalSize
   unsigned int getNumTexels() const;

   // used internally for sub tex loading
   struct SubloadImageStruct
   {
      SubloadImageStruct(void* sub_image,
                         GLint level,
                         GLint offset_x, GLint offset_y,
                         GLint width, GLint height)
            : m_sub_image(sub_image), m_level(level),
              m_offset_x(offset_x), m_offset_y(offset_y),
              m_width(width), m_height(height) {};

      void *m_sub_image;
      GLint m_level;
      GLint m_offset_x, m_offset_y;
      GLint m_width, m_height;
   };

private:
   unsigned int m_width, m_height;
   GLint m_repeat_flag[2];
   GLint m_pow_s, m_pow_t;

   vector <SubloadImageStruct*> m_subload_list;
};

#endif

---