]>
Dogcows Code - chaz/yoink/blob - src/Moof/Texture.cc
2 /*******************************************************************************
4 Copyright (c) 2009, Charles McGarvey
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
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.
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.
27 *******************************************************************************/
31 #include <boost/bind.hpp>
34 #include <SDL/SDL_image.h>
36 #include "Dispatcher.hh"
37 #include "Mippleton.hh"
46 * The texture implementation just contains all the information about the image
47 * which is worth having in memory. The image data itself is not worth keeping
48 * in memory if the texture has been loaded to GL, but the name of the resource
49 * is retained so that it can be reloaded if necessary. The implementation is a
50 * mippleton so that multiple texture objects can share the same internal
51 * objects and avoid having duplicate textures loaded to GL.
54 class Texture::TextureImpl
: public Mippleton
<TextureImpl
>
58 * Delete the texture (if it is loaded) from GL.
65 glDeleteTextures(1, &object_
);
71 * If the GL context was recreated, we probably need to reload the texture.
72 * This may involve reading it from disk again, but hopefully the OS was
73 * smart enough to cache it if the client has plenty of RAM.
76 void contextRecreated(const Notification
& note
)
83 * This is a helper method used by some of the texture loading code. It
84 * returns the first power of two which is greater than the input value.
87 static int powerOfTwo(int input
)
101 * Construction is initialization.
104 explicit TextureImpl(const std::string
& name
) :
105 Mippleton
<TextureImpl
>(name
),
109 minFilter_(GL_NEAREST
),
110 maxFilter_(GL_NEAREST
),
117 // we want to know when the GL context is recreated
118 Dispatcher::instance().addHandler("video.context_recreated",
119 boost::bind(&TextureImpl::contextRecreated
, this, _1
), this);
126 Dispatcher::instance().removeHandler(this);
131 * Adapted from some public domain code. This stuff is common enough that
132 * it really should be included in SDL_image... We need this because images
133 * loaded with SDL_image aren't exactly GL-ready right out of the box. This
134 * method makes them ready.
137 static SDL_Surface
* prepareImageForGL(SDL_Surface
* surface
)
139 int w
= powerOfTwo(surface
->w
);
140 int h
= powerOfTwo(surface
->h
);
142 // 1. OpenGL images must (generally) have dimensions of a power-of-two.
143 // If this one doesn't, we can at least be more friendly by expanding
144 // the dimensions so that they are, though there will be some empty
145 // space within the range of normal texture coordinates. It's better of
146 // textures are the right size to begin with.
148 SDL_Surface
* image
= SDL_CreateRGBSurface
153 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
171 Uint32 savedFlags
= surface
->flags
&(SDL_SRCALPHA
|SDL_RLEACCELOK
);
172 Uint8 savedAlpha
= surface
->format
->alpha
;
173 if (savedFlags
& SDL_SRCALPHA
)
175 SDL_SetAlpha(surface
, 0, 0);
178 SDL_Rect srcArea
, destArea
;
179 srcArea
.x
= 0; destArea
.x
= 0;
180 srcArea
.y
= 0; destArea
.y
= h
- surface
->h
;
181 srcArea
.w
= surface
->w
;
182 srcArea
.h
= surface
->h
;
183 SDL_BlitSurface(surface
, &srcArea
, image
, &destArea
);
185 if (savedFlags
& SDL_SRCALPHA
)
187 SDL_SetAlpha(surface
, savedFlags
, savedAlpha
);
190 // 2. OpenGL textures make more sense within the coordinate system when
191 // they are "upside down," so let's flip it.
193 Uint8 line
[image
->pitch
];
195 Uint8
*pixels
= static_cast<Uint8
*>(image
->pixels
);
196 Uint16 pitch
= image
->pitch
;
198 int yend
= image
->h
- 1;
200 if (SDL_MUSTLOCK(image
)) SDL_LockSurface(image
);
201 while (ybegin
< yend
)
203 memcpy(line
, pixels
+ pitch
* ybegin
, pitch
);
204 memcpy(pixels
+ pitch
* ybegin
, pixels
+ pitch
* yend
, pitch
);
205 memcpy(pixels
+ pitch
* yend
, line
, pitch
);
209 if (SDL_MUSTLOCK(image
)) SDL_UnlockSurface(image
);
215 * Use SDL_image to load images from file. A surface with the image data is
217 * @return Image data.
220 SDL_Surface
* loadImageData()
222 SDL_Surface
* surface
;
224 surface
= IMG_Load(Texture::getPathToResource(getName()).c_str());
228 throw Texture::Exception("loading failed");
231 SDL_Surface
* temp
= prepareImageForGL(surface
);
232 SDL_FreeSurface(surface
);
236 throw Texture::Exception("image couldn't be prepared for GL");
239 if (temp
->format
->BytesPerPixel
== 3)
243 else if (temp
->format
->BytesPerPixel
== 4)
249 SDL_FreeSurface(temp
);
250 throw Texture::Exception("image is not the required 24 or 32 bpp");
261 * Upload the image to GL so that it will be accessible by a much more
262 * manageable handle and hopefully reside in video memory.
273 SDL_Surface
* imageData
= loadImageData();
275 glGenTextures(1, &object_
);
276 glBindTexture(GL_TEXTURE_2D
, object_
);
293 SDL_FreeSurface(imageData
);
298 * Sets some texture properties such as the filters and external coordinate
304 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, minFilter_
);
305 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, maxFilter_
);
306 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, wrapU_
);
307 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, wrapV_
);
311 unsigned width_
; ///< Horizontal dimension of the image.
312 unsigned height_
; ///< Vertical dimension.
314 GLuint mode_
; ///< Depth of the image, GL_RGB or GL_RGBA.
315 GLuint minFilter_
; ///< Filter.
316 GLuint maxFilter_
; ///< Filter.
317 GLuint wrapU_
; ///< Wrapping behavior horizontally.
318 GLuint wrapV_
; ///< Wrapping behavior vertically.
319 GLuint object_
; ///< GL texture handle.
323 Texture::Texture(const std::string
& name
) :
325 impl_(Texture::TextureImpl::retain(name
), &Texture::TextureImpl::release
)
330 * Bind the GL texture for mapping, etc.
335 glBindTexture(GL_TEXTURE_2D
, getObject());
340 * Get the texture object, for the curious.
343 GLuint
Texture::getObject()
346 return impl_
->object_
;
350 unsigned Texture::getWidth()
353 return impl_
->width_
;
356 unsigned Texture::getHeight()
359 return impl_
->height_
;
363 void Texture::setMinFilter(GLuint filter
)
365 impl_
->minFilter_
= filter
;
368 void Texture::setMaxFilter(GLuint filter
)
370 impl_
->maxFilter_
= filter
;
373 void Texture::setWrapU(GLuint wrap
)
375 impl_
->wrapU_
= wrap
;
378 void Texture::setWrapV(GLuint wrap
)
380 impl_
->wrapV_
= wrap
;
384 void Texture::applyChanges()
387 impl_
->setProperties();
391 std::string
Texture::getPathToResource(const std::string
& name
)
393 // TODO since this is a generic library class, more than PNG should be
395 return Resource::getPathToResource("textures/" + name
+ ".png");
401 /** vim: set ts=4 sw=4 tw=80: *************************************************/
This page took 0.052853 seconds and 4 git commands to generate.