/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */ /*========================================================================== * * Project : MTK, Freyja, OpenRaider * Author : Terry 'Mongoose' Hendrix II * Website : http://www.westga.edu/~stu7440 * Email : stu7440@westga.edu * Object : Texture * Comments: This is the Texture class. * * See file COPYING for license details. * * *-- History ---------------------------------------------------------- * * 2003.06.30, * Mongoose - API update, SDL_TTF support moved here, misc features * SDL_TTF support based on Sam Lantinga's public domain * SDL_TTF demo functions and algorithms * * 2001.05.29: * Mongoose - Removed legacy code and done clean up * * 2001.02.19: * Mongoose - Moved from GooseEgg to mtk * * 2000.04.29: * Mongoose - Created from old PPM/PCX codebases I have done before ==========================================================================*/ #include #include #include #include #ifdef DEBUG_MEMEORY # include "memeory_test.h" #endif #ifdef USING_MTK_TGA # include "mtk_tga.h" #endif #ifdef USING_MTK_PNG # include "mtk_png.h" #endif #ifdef HAVE_SDL_TTF # include #endif #include #include #include "Texture.h" //Texture *gTextureManager = 0x0; gl_font_t *gFontTest = 0x0; //////////////////////////////////////////////////////////// // Constructors //////////////////////////////////////////////////////////// Texture::Texture() { mTextureIds = NULL; mFlags = 0; mTextureId = -1; mTextureId2 = -1; mTextureCount = 0; mTextureLimit = 0; //gTextureManager = this; initSDL_TTF(); } Texture::~Texture() { if (gFontTest) { glDeleteLists(gFontTest->drawListBase, gFontTest->count); delete gFontTest; } reset(); } //////////////////////////////////////////////////////////// // Public Accessors //////////////////////////////////////////////////////////// unsigned char *Texture::generateColorTexture(unsigned char rgba[4], unsigned int width, unsigned int height) { unsigned char *image; unsigned int i, size; image = new unsigned char[height*width*4]; for (i = 0, size = width*height; i < size; ++i) { /* RBGA */ image[i*4] = rgba[0]; image[i*4+1] = rgba[1]; image[i*4+2] = rgba[2]; image[i*4+3] = rgba[3]; } return image; } void glEnterMode2d(unsigned int width, unsigned int height) { glPushAttrib(GL_ENABLE_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); /* This allows alpha blending of 2D textures with the scene */ glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0, (GLdouble)width, (GLdouble)height, 0.0, 0.0, 1.0); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } void glExitMode2d() { glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glPopAttrib(); glMatrixMode(GL_MODELVIEW); } void bufferedPrintf(char *string, unsigned int len, char *s, ...) { va_list args; if (s && s[0]) { va_start(args, s); vsnprintf(string, len-1, s, args); string[len-1] = 0; va_end(args); } } void glPrint2d(float x, float y, float scale, char *string) { gl_font_t *font = gFontTest; if (!font) { static int errors = 0; if (errors < 10) printf("ERROR: glPrintf2d failed, %i\n", ++errors); return; } glPushMatrix(); glBindTexture(GL_TEXTURE_2D, font->textureId); glTranslatef(x, y, 0); glScalef(scale, scale, 1); /* FIXME: * Add utf-8 dencoding of char* string * * Also this string must be preprocessed to have glyph offsets * instead of ASCII text in it and support counts over 256 */ glListBase(font->drawListBase - font->utf8Offset); glCallLists(strlen(string), GL_BYTE, string); glPopMatrix(); } void glPrint3d(float x, float y, float z, float pitch, float yaw, float roll, float scale, char *string) { gl_font_t *font = gFontTest; if (!font) { static int errors = 0; if (errors < 10) printf("ERROR: glPrintf3d failed, %i\n", ++errors); return; } glPushMatrix(); glBindTexture(GL_TEXTURE_2D, font->textureId); glTranslatef(x, y, z); glRotatef(roll, 1, 0, 0); glRotatef(yaw, 0, 1, 0); glRotatef(pitch, 0, 0, 1); glScalef(scale, scale, scale); /* FIXME: * Add utf-8 dencoding of char* string * * Also this string must be preprocessed to have glyph offsets * instead of ASCII text in it and support counts over 256 */ glListBase(font->drawListBase - font->utf8Offset); glCallLists(strlen(string), GL_BYTE, string); glPopMatrix(); } int Texture::loadFontTTF(char *filename, unsigned int utf8Offset, unsigned int count) { ttf_texture_t *texture; unsigned char rgb[3] = {0xff, 0xff, 0xff}; if (!filename || !filename[0]) { printf("fontTest> Passed bad filename\n"); return -1; } texture = generateFontTexture(filename, 24, 256, rgb, //0x303f, 0x3093-0x303f, // hiragana //32, 126 - 32, // english utf8Offset, count, false); if (texture) { #ifdef DUMP_TTF_TGA FILE *f = fopen("/tmp/font.tga", "wb"); if (f) { mtk_image__tga_save(f, texture->texture, 256, 256, 4); fclose(f); } else { perror("/tmp/ttf_font.tga"); } #endif gFontTest = generateFont(texture); /* FIXME: Until UTF8 decoder is working, we map from ASCII when rendering */ gFontTest->utf8Offset = 32; // hack to use ASCII strings to test unicode delete [] texture->texture; delete [] texture->glyphs; delete texture; } else { return -2; } return 0; } gl_font_t *Texture::generateFont(ttf_texture_t *texture) { #ifdef HAVE_SDL_TTF const float spacing = 4.0; unsigned int i; float u, v, u2, v2; int h; gl_font_t *font; if (!texture) return NULL; printf("@ Generating gl font from texture...\n"); font = new gl_font_t; font->utf8Offset = texture->utf8Offset; font->count = texture->count; font->textureId = loadBuffer(texture->texture, texture->width, texture->width, RGBA, 32); glColor3f(1.0, 1.0, 1.0); font->drawListBase = glGenLists(texture->count); glBindTexture(GL_TEXTURE_2D, font->textureId); for (i = 0; i < texture->count; i++) { /* Generate texture coordinates for this TTF glyph */ u = (float)texture->glyphs[i].x / (float)texture->width; v = (float)texture->glyphs[i].y / (float)texture->width; u2 = (((float)texture->glyphs[i].x + (float)texture->glyphs[i].w) / (float)texture->width); v2 = (((float)texture->glyphs[i].y + (float)texture->glyphs[i].h) / (float)texture->width); #ifdef DEBUG_TTF_OFFSET if (i+texture->utf8Offset == 'y' || i+texture->utf8Offset == 'x') { printf("%c: %i %i %i\n", i+texture->utf8Offset, texture->fontDescent, texture->glyphs[i].miny, texture->glyphs[i].maxy); } #endif if (texture->glyphs[i].h < texture->fontHeight) { h = texture->fontHeight - texture->glyphs[i].h; } else { h = 0; } h += -texture->fontHeight/2-(texture->fontDescent + texture->glyphs[i].miny); /* Make a list for this TTF glyph, one nonuniform Quad per glyph */ glNewList(font->drawListBase + i, GL_COMPILE); glBegin(GL_QUADS); glTexCoord2f(u2, v); /* Top, right */ glVertex3i(texture->glyphs[i].w, h, 0); glTexCoord2f(u, v); /* Top, left */ glVertex3i(0, h, 0); glTexCoord2f(u, v2); /* Bottom, left */ glVertex3i(0, h+texture->glyphs[i].h, 0); glTexCoord2f(u2, v2); /* Bottom, right */ glVertex3i(texture->glyphs[i].w, h+texture->glyphs[i].h, 0); glEnd(); /* Move To The Left Of The Character */ glTranslated(texture->glyphs[i].w + spacing, 0, 0); glEndList(); } return font; #else return NULL; #endif } ttf_texture_t *Texture::generateFontTexture(char *filename, int pointSize, unsigned int textureWidth, unsigned char color[3], unsigned int utf8Offset, unsigned int count, char verbose) { #ifdef HAVE_SDL_TTF unsigned int i; int xx = 0, yy = 0, hh = 0, k, h, w, offset; unsigned char b; unsigned char *image; SDL_Surface* glyph; SDL_Color sdlColor; TTF_Font *font; ttf_texture_t *texture; FILE *f; sdlColor.r = color[0]; sdlColor.g = color[1]; sdlColor.b = color[2]; if (!mFlags & fUseSDL_TTF) { printf("SDL_TTF couldn't be used... exiting\n"); return NULL; } if (pointSize < 8) { pointSize = 8; } /* Work around for TTF_OpenFont for file not found segfault */ f = fopen(filename, "rb"); if (!f) { printf("generateFontTexture> Couldn't load '%s'\n", filename); perror(filename); return NULL; } fclose(f); // Open the font file at the requested point size font = TTF_OpenFont(filename, pointSize); if (font == NULL) { fprintf(stderr, "generateFontTexture> Couldn't load %d pt font from %s: %s\n", pointSize, filename, SDL_GetError()); return NULL; } // TTF_STYLE_NORMAL, TTF_STYLE_BOLD, TTF_STYLE_ITALIC, TTF_STYLE_UNDERLINE int renderStyle = TTF_STYLE_NORMAL; TTF_SetFontStyle(font, renderStyle); /* Allocate a new TTF font texture */ printf("@ Creating font texture from '%s'...\n", filename); texture = new ttf_texture_t; texture->width = textureWidth; texture->utf8Offset = utf8Offset; texture->count = count; texture->glyphs = new ttf_glyph_t[count]; texture->texture = new unsigned char[textureWidth*textureWidth*4]; memset(texture->texture, 0, textureWidth*textureWidth*4); texture->fontHeight = TTF_FontHeight(font); texture->fontAscent = TTF_FontAscent(font); texture->fontDescent = TTF_FontDescent(font); texture->fontSpacing = TTF_FontLineSkip(font); for (i = 0; i < count; ++i) { glyph = TTF_RenderGlyph_Blended(font, i + utf8Offset, sdlColor); if (glyph) { image = (unsigned char*)glyph->pixels; TTF_GlyphMetrics(font, i + utf8Offset, &texture->glyphs[i].minx, &texture->glyphs[i].maxx, &texture->glyphs[i].miny, &texture->glyphs[i].maxy, &texture->glyphs[i].advance); texture->glyphs[i].w = glyph->w; texture->glyphs[i].h = glyph->h; if (xx + texture->glyphs[i].w > ((int)textureWidth - 1)) { yy += hh; hh = 2; xx = 2; texture->glyphs[i].x = 0; texture->glyphs[i].y = yy; } else { (texture->glyphs[i].h > hh) ? hh = texture->glyphs[i].h: 0; texture->glyphs[i].x = xx; texture->glyphs[i].y = yy; } xx += glyph->w; if (verbose) { printf("0x%x : %ix%i @ %i, %i\n", i + utf8Offset, texture->glyphs[i].w, texture->glyphs[i].h, texture->glyphs[i].x, texture->glyphs[i].y); } /* Blit @ xx, yy - in pixels */ for (k = 0; k < glyph->w*glyph->h; ++k) { w = texture->glyphs[i].x + k%glyph->w; h = texture->glyphs[i].y + k/glyph->w; offset = (w + h*textureWidth); if (verbose) { printf("Offset: %i; Pixel: %i,%i; Data: 0x%08x\n", offset, w, h, *((unsigned int *)&image[k*4])); } /* 32-bit ARGB to RGBA */ b = image[k*4+3]; texture->texture[offset*4] = image[k*4] = image[k*4+1]; texture->texture[offset*4+1] = image[k*4+1] = image[k*4+2]; texture->texture[offset*4+2] = image[k*4+2] = image[k*4+3]; texture->texture[offset*4+3] = image[k*4+3] = b; } } } TTF_CloseFont(font); return texture; #else printf("SDL_TTF not enabled in this build.\n"); return NULL; #endif } //////////////////////////////////////////////////////////// // Public Mutators //////////////////////////////////////////////////////////// int Texture::loadColorTexture(unsigned char rgba[4], unsigned int width, unsigned int height) { unsigned char *image; int id = -1; image = generateColorTexture(rgba, width, height); id = loadBuffer(image, width, height, RGBA, 32); delete [] image; return id; } void Texture::initSDL_TTF() { #ifdef HAVE_SDL_TTF // Initialize the TTF library if (TTF_Init() < 0) { fprintf(stderr, "initSDL_TTF> TTF_Init() failed!\n"); fprintf(stderr, "initSDL_TTF> Error is [%s].\n", SDL_GetError()); } else { mFlags |= fUseSDL_TTF; printf("@ Started SDL_TTF subsystem...\n"); atexit(TTF_Quit); } #endif } void Texture::setFlag(TextureFlag flag) { mFlags |= flag; } void Texture::clearFlag(TextureFlag flag) { mFlags |= flag; mFlags ^= flag; } void Texture::reset() { if (mTextureIds) { glDeleteTextures(mTextureLimit, mTextureIds); delete [] mTextureIds; } mTextureIds = 0x0; mTextureCount = 0; mTextureLimit = 0; } void Texture::disableMultiTexture() { mFlags ^= fUseMultiTexture; mTextureId = -1; mTextureId2 = -1; glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); } void Texture::useMultiTexture(float aU, float aV, float bU, float bV) { if (!(mFlags & fUseMultiTexture)) return; glMultiTexCoord2fARB(GL_TEXTURE0_ARB, aU, aV); glMultiTexCoord2fARB(GL_TEXTURE1_ARB, bU, bV); } void Texture::useMultiTexture(float u, float v) { if (!(mFlags & fUseMultiTexture)) return; glMultiTexCoord2fARB(GL_TEXTURE0_ARB, u, v); glMultiTexCoord2fARB(GL_TEXTURE1_ARB, u, v); } void Texture::bindMultiTexture(int texture0, int texture1) { if (//(int)a == mTextureId && (int)b == mTextureId2 || !mTextureIds || texture0 < 0 || texture0 > (int)mTextureCount || texture1 < 0 || texture1 > (int)mTextureCount) { return; } mFlags |= fUseMultiTexture; mTextureId = texture0; mTextureId2 = texture1; glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, mTextureIds[texture0]); glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, mTextureIds[texture1]); } void Texture::setMaxTextureCount(unsigned int n) { mTextureLimit = n; mTextureIds = new unsigned int[n]; glGenTextures(n, mTextureIds); } int Texture::getTextureCount() { return (mTextureCount-1); } int Texture::loadBuffer(unsigned char *image, unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp) { int id; id = loadBufferSlot(image, width, height, mode, bpp, mTextureCount++); if (id < 0) { return id; } return ++id; } void convertARGB32bppToRGBA32bpp(unsigned char *image, unsigned int w, unsigned int h) { unsigned int i, size = w*h; unsigned char swap; for (i = 0; i < size; ++i) { /* 32-bit ARGB to RGBA */ swap = image[i*4+3]; image[i*4] = image[i*4+1]; image[i*4+1] = image[i*4+2]; image[i*4+2] = image[i*4+3]; image[i*4+3] = swap; } } int Texture::loadBufferSlot(unsigned char *image, unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp, unsigned int slot) { unsigned char bytes; unsigned int glcMode; if (!mTextureIds || slot >= mTextureLimit) { printf("Texture::Load> ERROR Not initalizied or out of free slots\n"); return -1000; } if (!width || !height || !image) { printf("Texture::Load> ERROR Assertion 'image is valid' failed\n"); return -1; } switch (mode) { case GREYSCALE: if (bpp != 8) { printf("Texture::Load> ERROR Unsupported GREYSCALE, %i bpp\n", bpp); return -2; } bytes = 1; glcMode = GL_LUMINANCE; break; case RGB: if (bpp != 24) { printf("Texture::Load> ERROR Unsupported RGBA, %i bpp\n", bpp); return -2; } bytes = 3; glcMode = GL_RGB; break; case ARGB: if (bpp == 32) { convertARGB32bppToRGBA32bpp(image, width, height); } case RGBA: if (bpp != 32) { printf("Texture::Load> ERROR Unsupported RGBA/ARGB, %i bpp\n", bpp); return -2; } bytes = 4; glcMode = GL_RGBA; break; default: printf("Texture::Load> ERROR Unknown color mode %i\n", mode); return -2; } glClearColor(0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBindTexture(GL_TEXTURE_2D, mTextureIds[slot]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); if (mFlags & fUseMipmaps) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); gluBuild2DMipmaps(GL_TEXTURE_2D, bytes, width, height, glcMode, GL_UNSIGNED_BYTE, image); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, glcMode, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image); } //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); return slot; } void Texture::bindTextureId(unsigned int n) { if ((int)n == mTextureId || !mTextureIds || n > mTextureCount) { return; } mTextureId = n; glEnable(GL_TEXTURE_2D); //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, mTextureIds[n]); } void Texture::glScreenShot(char *base, unsigned int width, unsigned int height) { #ifdef USING_MTK_PNG FILE *f; int sz = width*height; unsigned char *image = new unsigned char[sz*3]; char filename[1024]; static int count = 0; bool done = false; if (!image) { printf("glScreenShot> ERROR: Couldn't allocate image!\n"); return; } while (!done) { snprintf(filename, 1024, "%s-%03i.png", base, count++); f = fopen(filename, "rb"); if (f) fclose(f); else done = true; } f = fopen(filename, "wb"); if (!f) { printf("glScreenShot> ERROR: Couldn't write screenshot.\n"); perror("glScreenShot> ERROR: "); return; } // Capture frame buffer glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, image); mtk_image__png_save(f, image, width, height, 3); fclose(f); delete [] image; printf("glScreenShot> Took screenshot '%s'.\n", filename); #else FILE *f; int sz = width*height; unsigned char *image = new unsigned char[sz*3]; unsigned char *swap_row = new unsigned char[width*3]; char filename[1024]; static int count = 0; bool done = false; int i, j, size; unsigned char comment_lenght; unsigned char colormap_type; unsigned char image_type; unsigned short colormap_index; unsigned short colormap_lenght; unsigned char colormap_bbp; unsigned short origin_x; unsigned short origin_y; unsigned short swidth; unsigned short sheight; char comment[32] = "Mongoose TGA 0.0.1\0"; unsigned char tmp, bpp, desc_flags; if (!image || !width || !height) { if (image) { delete [] image; } printf("glScreenShot> ERROR: Couldn't allocate image!\n"); return; } // Don't overwrite files while (!done) { snprintf(filename, 1024, "%s-%04i.tga", base, count++); f = fopen(filename, "rb"); if (f) fclose(f); else done = true; } f = fopen(filename, "wb"); if (!f) { printf("glScreenShot> ERROR: Couldn't write screenshot.\n"); perror("glScreenShot> ERROR: "); return; } // Capture frame buffer glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, image); // Flip vertical for (i = 0, j = (int)height-1; i < (int)height/2; ++i, --j) { memcpy(swap_row, &image[i*width*3], width*3); memcpy(&image[i*width*3], &image[j*width*3], width*3); memcpy(&image[j*width*3], swap_row, width*3); } delete [] swap_row; comment_lenght = strlen(comment); colormap_type = 0; image_type = 2; colormap_index = 0; colormap_lenght = 0; colormap_bbp = 0; origin_x = origin_y = 0; swidth = width; sheight = height; bpp = 24; desc_flags = 32; // Write TGA header fwrite(&comment_lenght, 1, 1, f); fwrite(&colormap_type, 1, 1, f); fwrite(&image_type, 1, 1, f); fwrite(&colormap_index, 2, 1, f); fwrite(&colormap_lenght, 2, 1, f); fwrite(&colormap_bbp, 1, 1, f); fwrite(&origin_x, 2, 1, f); fwrite(&origin_y, 2, 1, f); fwrite(&swidth, 2, 1, f); fwrite(&sheight, 2, 1, f); fwrite(&bpp, 1, 1, f); fwrite(&desc_flags, 1, 1, f); // Write comment fwrite(&comment, 1, comment_lenght, f); size = width * height * 3; for (i = 0; i < size; i += 3) { tmp = image[i]; image[i] = image[i + 2]; image[i + 2] = tmp; } // Write image data if (fwrite(image, size, 1, f) < 1) { perror("glScreenShot> Disk write failed.\n"); fclose(f); return; } fclose(f); delete [] image; printf("Took screenshot '%s'.\n", filename); #endif } int Texture::loadPNG(char *filename) { #ifdef USING_MTK_PNG FILE *f; unsigned char *image = NULL; unsigned char *image2 = NULL; unsigned int w, h; char type; int id = -1; f = fopen(filename, "rb"); if (!f) { perror("Couldn't load file"); } else if (!mtk_image__png_check(f)) { mtk_image__png_load(f, &image, &w, &h, &type); type += 2; image2 = scaleBuffer(image, w, h, (type == 4) ? 4 : 3); if (image2) { image = image2; w = h = 256; } if (image) { id = loadBuffer(image, w, h, (type == 4) ? RGBA : RGB, (type == 4) ? 32 : 24); printf("%c", (id == -1) ? 'x' : 'o'); fflush(stdout); delete [] image; } if (f) { fclose(f); } } if (id == -1) { printf("Texture::loadPNG> ERROR: Failed to load '%s'\n", filename); } return id; #else printf("ERROR: MTK PNG support not enabled in this build\n"); return -1; #endif } int Texture::loadTGA(char *filename) { #ifdef USING_MTK_TGA FILE *f; unsigned char *image = NULL; unsigned char *image2 = NULL; unsigned int w, h; char type; int id = -1; f = fopen(filename, "rb"); if (!f) { perror("Couldn't load file"); } else if (!mtk_image__tga_check(f)) { mtk_image__tga_load(f, &image, &w, &h, &type); type += 2; image2 = scaleBuffer(image, w, h, (type == 4) ? 4 : 3); if (image2) { image = image2; w = h = 256; } if (image) { id = loadBuffer(image, w, h, (type == 4) ? RGBA : RGB, (type == 4) ? 32 : 24); printf("%c", (id == -1) ? 'x' : 'o'); fflush(stdout); delete [] image; } fclose(f); } if (id == -1) { printf("Texture::loadTGA> ERROR: Failed to load '%s'\n", filename); } return id; #else printf("ERROR: MTK TGA support not enabled in this build\n"); return -1; #endif } //////////////////////////////////////////////////////////// // Private Accessors //////////////////////////////////////////////////////////// int Texture::nextPower(int seed) { int i; for(i = 1; i < seed; i *= 2) ; return i; } /* This code based off on gluScaleImage() */ unsigned char *Texture::scaleBuffer(unsigned char *image, int width, int height, int components) { int i, j, k; float* tempin; float* tempout; float sx, sy; // int components = 3; unsigned char *timage; int original_height = height; int original_width = width; if (!image || !width || !height) { return NULL; } height = nextPower(height); width = nextPower(width); if (height > 256) height = 256; if (width > 256) width = 256; // Check to see if scaling is needed if (height == original_height && width == original_width) return NULL; //printf("%i\n", components); timage = new unsigned char[height * width * components]; tempin = new float[original_width * original_height * components * sizeof(float)]; tempout = new float[width * height * components * sizeof(float)]; if (!tempout || !tempin) { if (tempout) delete [] tempout; if (tempin) delete [] tempin; printf("Oh shit out of memory!\n"); return NULL; } // Copy user data to float format. for (i = 0; i < original_height * original_width * components; ++i) { tempin[i] = (float)image[i]; } // Determine which filter to use by checking ratios. if (width > 1) { sx = (float)(original_width - 1) / (float)(width - 1); } else { sx = (float)(original_width - 1); } if (height > 1) { sy = (float)(original_height - 1) / (float) (height - 1); } else { sy = (float)(original_height - 1); } if (sx < 1.0 && sy < 1.0) { /* Magnify both width and height: use weighted sample of 4 pixels */ int i0, i1, j0, j1; float alpha, beta; float* src00; float* src01; float* src10; float* src11; float s1, s2; float* dst; for(i = 0; i < height; ++i) { i0 = (int)(i * sy); i1 = i0 + 1; if (i1 >= original_height) { i1 = original_height - 1; } alpha = i * sy - i0; for (j = 0; j < width; ++j) { j0 = (int) (j * sx); j1 = j0 + 1; if (j1 >= original_width) { j1 = original_width - 1; } beta = j * sx - j0; /* Compute weighted average of pixels in rect (i0,j0)-(i1,j1) */ src00 = tempin + (i0 * original_width + j0) * components; src01 = tempin + (i0 * original_width + j1) * components; src10 = tempin + (i1 * original_width + j0) * components; src11 = tempin + (i1 * original_width + j1) * components; dst = tempout + (i * width + j) * components; for (k = 0; k < components; ++k) { s1 = *src00++ * (1.0 - beta) + *src01++ * beta; s2 = *src10++ * (1.0 - beta) + *src11++ * beta; *dst++ = s1 * (1.0 - alpha) + s2 * alpha; } } } } else { /* Shrink width and/or height: use an unweighted box filter */ int i0, i1; int j0, j1; int ii, jj; float sum; float* dst; for (i = 0; i < height; ++i) { i0 = (int) (i * sy); i1 = i0 + 1; if (i1 >= original_height) { i1 = original_height - 1; } for (j = 0; j < width; ++j) { j0 = (int) (j * sx); j1 = j0 + 1; if (j1 >= original_width) { j1 = original_width - 1; } dst = tempout + (i * width + j) * components; /* Compute average of pixels in the rectangle (i0,j0)-(i1,j1) */ for (k = 0; k < components; ++k) { sum = 0.0; for (ii = i0; ii <= i1; ++ii) { for (jj = j0; jj <= j1; ++jj) { sum += *(tempin + (ii * original_width + jj) * components + k); } } sum /= ( j1 - j0 + 1 ) * ( i1 - i0 + 1 ); *dst++ = sum; } } } } // Copy to our results. for( i = 0; i < height * width * components; ++i) { timage[i] = (unsigned char)tempout[i]; } // Delete our temp buffers. delete[] tempin; delete[] tempout; delete[] image; return timage; } //////////////////////////////////////////////////////////// // Private Mutators ////////////////////////////////////////////////////////////