Dogcows Code - chaz/yoink/blob - src/Moof/Texture.cc

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #include <cstring>              // memcpy
  30
  31 #include <boost/bind.hpp>
  32
  33 #include <SDL/SDL.h>
  34 #include <SDL/SDL_image.h>
  35
  36 #include "Dispatcher.hh"
  37 #include "Log.hh"
  38 #include "Mippleton.hh"
  39 #include "OpenGL.hh"
  40 #include "Texture.hh"
  41
  42
  43 namespace Mf {
  44
  45
  46 /**
  47  * The texture implementation just contains all the information about the image
  48  * which is worth having in memory.  The image data itself is not worth keeping
  49  * in memory if the texture has been loaded to GL, but the name of the resource
  50  * is retained so that it can be reloaded if necessary.  The implementation is a
  51  * mippleton so that multiple texture objects can share the same internal
  52  * objects and avoid having duplicate textures loaded to GL.
  53  */
  54
  55 class Texture::Impl : public Mippleton<Impl>
  56 {
  57
  58         /**
  59          * Delete the texture (if it is loaded) from GL.
  60          */
  61
  62         void unloadFromGL()
  63         {
  64                 if (object_)
  65                 {
  66                         if (object_ == globalObject_)
  67                         {
  68                                 globalObject_ = 0;
  69                         }
  70
  71                         glDeleteTextures(1, &object_);
  72                         object_ = 0;
  73                 }
  74         }
  75
  76         /**
  77          * If the GL context was recreated, we need to reload the texture.  This may
  78          * involve reading it from disk again, but hopefully the OS was smart enough
  79          * to cache it if the client has plenty of RAM.
  80          */
  81
  82         void contextRecreated(const Notification* note)
  83         {
  84                 object_ = globalObject_ = 0;
  85                 uploadToGL();
  86         }
  87
  88         /**
  89          * This is a helper method used by some of the texture loading code.  It
  90          * returns the first power of two which is greater than the input value.
  91          */
  92
  93         static int powerOfTwo(int input)
  94         {
  95                 int value = 1;
  96
  97                 while (value < input)
  98                 {
  99                         value <<= 1;
 100                 }
 101                 return value;
 102         }
 103
 104
 105         static void flipSurface(SDL_Surface* image)
 106         {
 107                 unsigned char*  pixels = (Uint8*)(image->pixels);
 108
 109                 unsigned                pitch = image->pitch;
 110                 unsigned char   line[pitch];
 111
 112                 int             yBegin = 0;
 113                 int             yEnd = image->h - 1;
 114
 115                 if (SDL_MUSTLOCK(image)) SDL_LockSurface(image);
 116                 while (yBegin < yEnd)
 117                 {
 118                         memcpy(line,                    pixels + pitch * yBegin, pitch);
 119                         memcpy(pixels + pitch * yBegin, pixels + pitch * yEnd,   pitch);
 120                         memcpy(pixels + pitch * yEnd,   line,                    pitch);
 121                         yBegin++;
 122                         yEnd--;
 123                 }
 124                 if (SDL_MUSTLOCK(image)) SDL_UnlockSurface(image);
 125         }
 126
 127 public:
 128
 129         /**
 130          * Construction is initialization.
 131          */
 132
 133         explicit Impl(const std::string& name) :
 134                 Mippleton<Impl>(name),
 135                 surface_(0),
 136                 width_(0),
 137                 height_(0),
 138                 mode_(0),
 139                 minFilter_(GL_NEAREST),
 140                 magFilter_(GL_NEAREST),
 141                 wrapS_(GL_CLAMP),
 142                 wrapT_(GL_CLAMP),
 143                 object_(0)
 144         {
 145                 loadFromFile();
 146
 147                 // we want to know when the GL context is recreated
 148                 Dispatcher::getInstance().addHandler("video.context_recreated",
 149                                 boost::bind(&Impl::contextRecreated, this, _1), this);
 150         }
 151
 152         ~Impl()
 153         {
 154                 if (surface_)
 155                 {
 156                         SDL_FreeSurface(surface_);
 157                 }
 158
 159                 unloadFromGL();
 160
 161                 Dispatcher::getInstance().removeHandler(this);
 162         }
 163
 164
 165         /**
 166          * Adapted from some public domain code.  This stuff is common enough that
 167          * it really should be included in SDL_image...  We need this because images
 168          * loaded with SDL_image aren't exactly GL-ready right out of the box.  This
 169          * method makes them ready.
 170          */
 171
 172         static SDL_Surface* prepareImageForGL(SDL_Surface* surface)
 173         {
 174                 int w = powerOfTwo(surface->w);
 175                 int h = powerOfTwo(surface->h);
 176
 177                 // 2. OpenGL textures make more sense within the coordinate system when
 178                 // they are "upside down," so let's flip it.
 179
 180                 flipSurface(surface);
 181
 182                 // 1. OpenGL images must (generally) have dimensions of a power-of-two.
 183                 // If this one doesn't, we can at least be more friendly by expanding
 184                 // the dimensions so that they are, though there will be some empty
 185                 // space within the range of normal texture coordinates.  It's better if
 186                 // textures are the right size to begin with.
 187
 188                 SDL_Surface* image = SDL_CreateRGBSurface
 189                 (
 190                         SDL_SWSURFACE,
 191                         w, h,
 192                         32,
 193 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
 194                         0x000000FF,
 195                         0x0000FF00,
 196                         0x00FF0000,
 197                         0xFF000000
 198 #else
 199                         0xFF000000,
 200                         0x00FF0000,
 201                         0x0000FF00,
 202                         0x000000FF
 203 #endif
 204                 );
 205
 206                 if (!image)
 207                 {
 208                         return 0;
 209                 }
 210
 211                 Uint32 savedFlags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
 212                 Uint8  savedAlpha = surface->format->alpha;
 213                 if (savedFlags & SDL_SRCALPHA)
 214                 {
 215                         SDL_SetAlpha(surface, 0, 0);
 216                 }
 217
 218                 SDL_Rect srcArea, destArea;
 219                 srcArea.x = 0; destArea.x = 0;
 220                 srcArea.y = 0; destArea.y = h - surface->h;
 221                 srcArea.w = surface->w;
 222                 srcArea.h = surface->h;
 223                 SDL_BlitSurface(surface, &srcArea, image, &destArea);
 224
 225                 if (savedFlags & SDL_SRCALPHA)
 226                 {
 227                         SDL_SetAlpha(surface, savedFlags, savedAlpha);
 228                 }
 229
 230                 return image;
 231         }
 232
 233         /**
 234          * Use SDL_image to load images from file.  A surface with the image data is
 235          * returned.
 236          * @return Image data.
 237          */
 238
 239         void loadFromFile()
 240         {
 241                 SDL_Surface* surface;
 242
 243                 surface = IMG_Load(Texture::getPath(getName()).c_str());
 244
 245                 if (!surface)
 246                 {
 247                         logWarning("texture not found: %s", getName().c_str());
 248                         throw Exception(Exception::FILE_NOT_FOUND);
 249                 }
 250
 251                 SDL_Surface* temp = prepareImageForGL(surface);
 252                 SDL_FreeSurface(surface);
 253
 254                 if (!temp)
 255                 {
 256                         throw Exception(Exception::OPENGL_ERROR);
 257                 }
 258
 259                 if (temp->format->BytesPerPixel == 3)
 260                 {
 261                         mode_ = GL_RGB;
 262                 }
 263                 else if (temp->format->BytesPerPixel == 4)
 264                 {
 265                         mode_ = GL_RGBA;
 266                 }
 267                 else
 268                 {
 269                         SDL_FreeSurface(temp);
 270                         throw Exception(Exception::BAD_IMAGE_FORMAT);
 271                 }
 272
 273                 width_ = temp->w;
 274                 height_ = temp->h;
 275
 276                 surface_ = temp;
 277         }
 278
 279
 280         /**
 281          * Upload the image to GL so that it will be accessible by a much more
 282          * manageable handle and hopefully reside in video memory.
 283          */
 284
 285         void uploadToGL()
 286         {
 287                 if (object_)
 288                 {
 289                         // already loaded
 290                         return;
 291                 }
 292
 293                 if (!surface_) loadFromFile();
 294
 295                 glGenTextures(1, &object_);
 296                 glBindTexture(GL_TEXTURE_2D, object_);
 297
 298                 glTexImage2D
 299                 (
 300                         GL_TEXTURE_2D,
 301                         0,
 302                         mode_,
 303                         surface_->w,
 304                         surface_->h,
 305                         0,
 306                         mode_,
 307                         GL_UNSIGNED_BYTE,
 308                         surface_->pixels
 309                 );
 310
 311                 setProperties();
 312
 313                 SDL_FreeSurface(surface_);
 314                 surface_ = 0;
 315         }
 316
 317
 318         /**
 319          * Sets some texture properties such as the filters and external coordinate
 320          * behavior.
 321          */
 322
 323         void setProperties()
 324         {
 325                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter_);
 326                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter_);
 327                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS_);
 328                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT_);
 329         }
 330
 331         inline void setMinFilter(GLuint filter)
 332         {
 333                 bind();
 334                 minFilter_ = filter;
 335                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter_);
 336         }
 337
 338         inline void setMagFilter(GLuint filter)
 339         {
 340                 bind();
 341                 magFilter_ = filter;
 342                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter_);
 343         }
 344
 345         inline void setWrapS(GLuint wrap)
 346         {
 347                 bind();
 348                 wrapS_ = wrap;
 349                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS_);
 350         }
 351
 352         inline void setWrapT(GLuint wrap)
 353         {
 354                 bind();
 355                 wrapT_ = wrap;
 356                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT_);
 357         }
 358
 359
 360         inline void bind()
 361         {
 362                 if (object_ == 0)
 363                 {
 364                         uploadToGL();
 365                 }
 366                 if (object_ != globalObject_)
 367                 {
 368                         glBindTexture(GL_TEXTURE_2D, object_);
 369                         globalObject_ = object_;
 370                 }
 371         }
 372
 373
 374         SDL_Surface*    surface_;
 375         unsigned                width_;                 ///< Horizontal dimension of the image.
 376         unsigned                height_;                ///< Vertical dimension.
 377
 378         GLuint                  mode_;                  ///< Depth of the image, GL_RGB or GL_RGBA.
 379         GLuint                  minFilter_;             ///< Minifcation filter.
 380         GLuint                  magFilter_;             ///< Magnification filter.
 381         GLuint                  wrapS_;                 ///< Wrapping behavior horizontally.
 382         GLuint                  wrapT_;                 ///< Wrapping behavior vertically.
 383
 384         GLuint                  object_;                ///< GL texture handle.
 385         static GLuint   globalObject_;  ///< Global GL texture handle.
 386 };
 387
 388 GLuint Texture::Impl::globalObject_ = 0;
 389
 390
 391 Texture::Texture(const std::string& name) :
 392         // pass through
 393         impl_(Texture::Impl::getInstance(name)) {}
 394
 395
 396 /**
 397  * Bind the GL texture for mapping, etc.
 398  */
 399
 400 void Texture::bind() const
 401 {
 402         // pass through
 403         impl_->bind();
 404 }
 405
 406
 407 /**
 408  * Get the texture object, for the curious.
 409  */
 410
 411 GLuint Texture::getObject() const
 412 {
 413         // pass through
 414         return impl_->object_;
 415 }
 416
 417
 418 void Texture::resetBind()
 419 {
 420         glBindTexture(GL_TEXTURE_2D, 0);
 421         Impl::globalObject_ = 0;
 422 }
 423
 424
 425 unsigned Texture::getWidth() const
 426 {
 427         // pass through
 428         return impl_->width_;
 429 }
 430
 431 unsigned Texture::getHeight() const
 432 {
 433         // pass through
 434         return impl_->height_;
 435 }
 436
 437
 438 void Texture::setMinFilter(GLuint filter)
 439 {
 440         // pass through
 441         impl_->setMinFilter(filter);
 442 }
 443
 444 void Texture::setMagFilter(GLuint filter)
 445 {
 446         // pass through
 447         impl_->setMagFilter(filter);
 448 }
 449
 450 void Texture::setWrapS(GLuint wrap)
 451 {
 452         // pass through
 453         impl_->setWrapS(wrap);
 454 }
 455
 456 void Texture::setWrapT(GLuint wrap)
 457 {
 458         // pass through
 459         impl_->setWrapT(wrap);
 460 }
 461
 462
 463 std::string Texture::getPath(const std::string& name)
 464 {
 465         std::string path = Resource::getPath("textures/" + name + ".png");
 466         return path;
 467 }
 468
 469
 470 } // namespace Mf
 471
 472 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 473