loadImage(), move command

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140626 ]
+    * ColorMode enum now global
+    * Entities setAngles now sets all three angles
+    * Added loadPNG to TextureManager
+    * Added loadImage to TextureManager, _detecting_ the file type
+    * Re-Implemented the move command
+
     [ 20140624 ]
     * Some changes to allow compilation with Ubuntu 14.04 / gcc
     * Modified utils/png to allow compilation with different integer sizes

include/Entity.h

     MoveType getMoveType();
     void setMoveType(MoveType m);
     int getObjectId();
-    void setAngle(vec_t yaw);
+    void setAngles(vec3_t a);
     vec_t getPos(unsigned int i);
     vec_t getAngle(unsigned int i);
     int getRoom();

include/TextureManager.h

 class TextureManager {
 public:
 
-    enum ColorMode {
-        GREYSCALE,
-        RGB,
-        RGBA,
-        ARGB,
-        BGR,
-        BGRA
-    };
-
     enum TextureFlag {
         fUseMultiTexture = (1 << 0),
     };
                         ColorMode mode, unsigned int bpp,
                         unsigned int slot);
 
-    /*!
-     * \brief Loads TGA file as texture
-     * \param filename Existing TGA file
-     * \returns ID of new texture or -1 on error
-     */
-    int loadTGA(const char *filename);
-
-    int loadPCX(const char *filename);
+    int loadImage(const char *filename);
 
     /*!
      * \brief Sets an option flag
     void useMultiTexture(float aU, float aV, float bU, float bV);
 
 private:
+    int loadTGA(const char *filename);
+    int loadPCX(const char *filename);
+    int loadPNG(const char *filename);
+
     std::vector<unsigned int> mTextureIds;
     unsigned int mFlags;
 };

include/global.h

 #define DEFAULT_WIDTH 640
 #define DEFAULT_HEIGHT 480
 
-// Visual C++ does not understand __attribute__
-#ifdef _MSC_VER
-#define __attribute__(x)
-#endif
-
-//! \todo Replace NULL usage with nullptr
-#ifndef NULL
-#define NULL nullptr
-#endif
-
-// Globally include OpenGL header
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#else
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
-#include <GL/gl.h>
-#endif
-
-// If available, use our own assert that prints the call stack
-#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
-#ifndef NDEBUG
-[[noreturn]] void assertImplementation(const char *exp, const char *file, int line);
-#define assert(x) (void)((x) || (assertImplementation(#x, __FILE__, __LINE__),0))
-#else
-#define assert(x)
-#endif
-#else
-// Fall back to the default C assert
-#include <cassert>
-#endif
+// Supported pixelmap color formats
+enum ColorMode {
+    GREYSCALE,
+    RGB,
+    RGBA,
+    ARGB,
+    BGR,
+    BGRA
+};
 
 // Colors used where ever needed
 const unsigned char BLACK[]  = {   0,   0,   0, 255 };
 
 KeyboardButton stringToKeyboardButton(const char *key);
 
+// Visual C++ does not understand __attribute__
+#ifdef _MSC_VER
+#define __attribute__(x)
+#endif
+
+//! \todo Replace NULL usage with nullptr
+#ifndef NULL
+#define NULL nullptr
+#endif
+
+// Globally include OpenGL header
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#else
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+#include <GL/gl.h>
+#endif
+
+// If available, use our own assert that prints the call stack
+#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
+#ifndef NDEBUG
+[[noreturn]] void assertImplementation(const char *exp, const char *file, int line);
+#define assert(x) (void)((x) || (assertImplementation(#x, __FILE__, __LINE__),0))
+#else
+#define assert(x)
+#endif
+#else
+// Fall back to the default C assert
+#include <cassert>
+#endif
+
 #endif
 

include/utils/pcx.h

 #ifndef _UTILS_PCX_H_
 #define _UTILS_PCX_H_
 
-#include "TextureManager.h"
-
 /*!
  * \brief Check if a file is a valid PCX image
  * \param filename path of file to read
  * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp);
+int pcxLoad(const char *filename, unsigned char **image,
+        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp);
 
 #endif
 

include/utils/png.h

 #ifndef _UTILS_PNG_H_
 #define _UTILS_PNG_H_
 
-#include "TextureManager.h"
-
 /*!
  * \brief Check if a file is a valid PNG image
  * \param filename path of file to read
  * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp);
+int pngLoad(const char *filename, unsigned char **image,
+        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp);
 
 /*!
  * \brief Create a PNG image file from an RGBA buffer
  * \param bpp bits per pixel (8, 24, 32)
  * \returns 0 on success
  */
-int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height, TextureManager::ColorMode mode, unsigned int bpp);
+int pngSave(const char *filename, unsigned char *image,
+        unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp);
 
 #endif
 

src/Camera.cpp

 
 void Camera::rotate(float angle, float x, float y, float z) {
     Quaternion t, n;
-    vec_t look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
+    float look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
 
     t.set(angle, x, y, z);
     n = mQ * t;

src/Command.cpp

             getConsole().print("  set       - set a parameter");
             getConsole().print("  bind      - bind a keyboard/mouse action");
             getConsole().print("  animate   - [BOOL|n|p] - Animate models");
+            getConsole().print("  move      - [walk|fly|noclip]");
 /*
             getConsole().print("  sshot     - make a screenshot");
-            getConsole().print("  move      - [walk|fly|noclip]");
             getConsole().print("  sound     - INT - Test play sound");
             getConsole().print("  mode      - MODE - Render mode");
             getConsole().print("  light     - BOOL - GL Lights");
                 getRender().clearFlags(Render::fAnimateAllModels);
             getConsole().print(b ? "Animating all models" : "No longer animating all models");
         }
+    } else if (cmd.compare("move") == 0) {
+        if ((!mRunning) || (!getGame().isLoaded())) {
+            getConsole().print("Use move command interactively!");
+            return -999;
+        }
+        std::string temp;
+        command >> temp;
+        if (temp.compare("walk") == 0) {
+            getGame().getLara().setMoveType(Entity::MoveTypeWalk);
+        } else if (temp.compare("fly") == 0) {
+            getGame().getLara().setMoveType(Entity::MoveTypeFly);
+        } else if (temp.compare("noclip") == 0) {
+            getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
+        } else {
+            getConsole().print("Invalid use of move command (%s)!", temp.c_str());
+            return -9;
+        }
+        getConsole().print("%sing", temp.c_str());
+
 /*
     } else if (cmd.compare("mode") == 0) {
         std::string mode;
         }
         getConsole().print("Screenshot stored...");
         delete filename;
-    } else if (cmd.compare("move") == 0) {
-        if (!mRunning) {
-            getConsole().print("Use move command interactively!");
-            return -999;
-        }
-        if (args->size() > 0) {
-            if (getGame().isLoaded()) {
-                char *move = args->at(0);
-                if (strcmp(move, "walk") == 0) {
-                    getGame().getLara().setMoveType(Entity::MoveTypeWalk);
-                    getConsole().print("Lara is walking...");
-                } else if (strcmp(move, "fly") == 0) {
-                    getGame().getLara().setMoveType(Entity::MoveTypeFly);
-                    getConsole().print("Lara is flying...");
-                } else if (strcmp(move, "noclip") == 0) {
-                    getGame().getLara().setMoveType(Entity::MoveTypeNoClipping);
-                    getConsole().print("Lara is noclipping...");
-                } else {
-                    getConsole().print("Invalid use of move command (%s)!", move);
-                    return -9;
-                }
-            } else {
-                getConsole().print("Load a level to change the movement type!");
-                return -10;
-            }
-        } else {
-            getConsole().print("Invalid use of move command!");
-            return -11;
-        }
     } else if (cmd.compare("sound") == 0) {
         if ((!mRunning) || (!getGame().isLoaded())) {
             getConsole().print("Use sound command interactively!");

src/Entity.cpp

     glTranslatef(pos[0], pos[1], pos[2]);
     glRotatef(OR_RAD_TO_DEG(angles[1]), 0, 1, 0);
     glRotatef(OR_RAD_TO_DEG(angles[0]), 1, 0, 0);
-    glRotatef(OR_RAD_TO_DEG(angles[2]), 0, 0, 1);
+    //glRotatef(OR_RAD_TO_DEG(angles[2]), 0, 0, 1);
     getWorld().getSkeletalModel(skeletalModel).display(animationFrame, boneFrame);
     glPopMatrix();
 
     return objectId;
 }
 
-void Entity::setAngle(vec_t yaw) {
-    angles[1] = yaw;
+void Entity::setAngles(vec3_t a) {
+    for (unsigned int i = 0; i < 3; i++)
+        angles[i] = a[i];
 }
 
 vec_t Entity::getPos(unsigned int i) {

src/FontSDL.cpp

     if (mFont)
         TTF_CloseFont(mFont);
 
-    if (mFontInit)
+    if (mFontInit) {
         TTF_Quit();
+        glDeleteTextures(1, &mFontTexture);
+    }
 }
 
 int FontSDL::initialize() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
+    SDL_FreeSurface(surface);
 
     GLuint xMin = s.x;
     GLuint yMin = s.y;
     glTexCoord2f(1.0f, 0.0f);
     glVertex2i(xMax, yMin);
     glEnd();
-
-    SDL_FreeSurface(surface);
 }
 

src/Game.cpp

                 getCamera().command(CAMERA_ROTATE_DOWN);
 
         // Fix Laras rotation
-        getLara().setAngle(getCamera().getRadianYaw());
+        vec3_t angles = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
+        getLara().setAngles(angles);
     }
 }
 
 
         // Overwrite any previous level textures on load
         getTextureManager().loadBufferSlot(image, 256, 256,
-                TextureManager::RGBA, 32, (mTextureStart - 1) + i);
+                RGBA, 32, (mTextureStart - 1) + i);
 
 #ifdef MULTITEXTURE
         gMapTex2Bump[(mTextureStart - 1) + i] = -1;
                     mTombRaider.NumTextures();
 #endif
             getTextureManager().loadBufferSlot(bumpmap, 256, 256,
-                    TextureManager::RGBA, 32,
+                    RGBA, 32,
                     (mTextureStart - 1) + i + mTombRaider.NumTextures());
         }
 

src/StaticMesh.cpp

     } catch (...) {
         unsigned char *image = generateColorTexture(color, 32, 32, 32);
         texture = getTextureManager().loadBufferSlot(image, 32, 32,
-                TextureManager::RGBA, 32, getTextureManager().getTextureCount());
+                RGBA, 32, getTextureManager().getTextureCount());
         delete [] image;
     }
 
     return texture;
 }
+
 #endif
 
 StaticMesh::StaticMesh(TombRaider &tr, unsigned int index) {

src/TextureManager.cpp

 #include "utils/tga.h"
 #include "TextureManager.h"
 
+#ifdef USING_PNG
+#include "utils/png.h"
+#endif
+
 TextureManager::TextureManager() {
     mFlags = 0;
 }
     assert((mode == GREYSCALE) || (mode == RGB)
             || (mode == BGR) || (mode == ARGB)
             || (mode == RGBA) || (mode ==  BGRA));
-
-    switch (mode) {
-        case GREYSCALE:
-            assert(bpp == 8);
-            break;
-
-        case RGB:
-        case BGR:
-            assert(bpp == 24);
-            break;
-
-        case ARGB:
-        case RGBA:
-        case BGRA:
-            assert(bpp == 32);
-            break;
-    }
+    assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
     while (mTextureIds.size() <= slot) {
         unsigned int id;
         mTextureIds.push_back(id);
     }
 
-    unsigned char bytes;
     unsigned int glcMode;
-
     switch (mode) {
         case GREYSCALE:
-            bytes = 1;
             glcMode = GL_LUMINANCE;
             break;
 
+        case BGR:
+            bgr2rgb24(image, width, height);
+            glcMode = GL_RGB;
+            break;
+
         case RGB:
-            bytes = 3;
             glcMode = GL_RGB;
             break;
 
         case ARGB:
             argb2rgba32(image, width, height);
-            bytes = 4;
             glcMode = GL_RGBA;
             break;
 
-        case RGBA:
-            bytes = 4;
+        case BGRA:
+            bgra2rgba32(image, width, height);
             glcMode = GL_RGBA;
             break;
 
-        case BGR:
-            bytes = 3;
-            glcMode = GL_BGR_EXT;
-            break;
-
-        case BGRA:
-            bytes = 4;
-            glcMode = GL_BGRA_EXT;
+        case RGBA:
+            glcMode = GL_RGBA;
             break;
     }
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 
     glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
-    glTexImage2D(GL_TEXTURE_2D, 0, bytes, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
+    glTexImage2D(GL_TEXTURE_2D, 0, bpp / 8, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
 
     //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
     glBindTexture(GL_TEXTURE_2D, mTextureIds.at(n));
 }
 
+int TextureManager::loadImage(const char *filename) {
+    if (stringEndsWith(filename, ".pcx") || stringEndsWith(filename, ".PCX")) {
+        return loadPCX(filename);
+    } else if (stringEndsWith(filename, ".png") || stringEndsWith(filename, ".PNG")) {
+        return loadPNG(filename);
+    } else if (stringEndsWith(filename, ".tga") || stringEndsWith(filename, ".TGA")) {
+        return loadTGA(filename);
+    } else {
+        getConsole().print("No known image file type? (%s)", filename);
+    }
+
+    return -1;
+}
+
 int TextureManager::loadPCX(const char *filename) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
     return id;
 }
 
+int TextureManager::loadPNG(const char *filename) {
+#ifdef USING_PNG
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+
+    if (pngCheck(filename) != 0) {
+        return -1;
+    }
+
+    unsigned char *image;
+    unsigned int w, h, bpp;
+    ColorMode c;
+    int id = -1;
+    int error = pngLoad(filename, &image, &w, &h, &c, &bpp);
+
+    if (error == 0) {
+        unsigned char *image2 = scaleBuffer(image, &w, &h, bpp);
+        if (image2) {
+            delete [] image;
+            image = image2;
+        }
+        id = loadBufferSlot(image, w, h, c, bpp, mTextureIds.size());
+        delete [] image;
+    }
+
+    return id;
+#else
+    getConsole().print("No PNG support available (%s)", filename);
+    return -1;
+#endif
+}
+
 int TextureManager::loadTGA(const char *filename) {
     assert(filename != NULL);
     assert(filename[0] != '\0');

src/WindowSDL.cpp

 
     if (SDL_GL_LoadLibrary(mDriver) < 0) {
         SDL_ClearError();
-        if (SDL_GL_LoadLibrary("libGL.so") < 0) {
-            SDL_ClearError();
-            if (SDL_GL_LoadLibrary("libGL.so.1") < 0) {
-                printf("Could not load OpenGL driver!\n");
-                printf("SDL_GL_LoadLibrary Error: %s\n", SDL_GetError());
-                return -2;
-            }
-        }
+        printf("Could not load OpenGL driver!\n");
+        printf("SDL_GL_LoadLibrary Error: %s\n", SDL_GetError());
+        return -2;
     }
 #endif
 

src/utils/pcx.cpp

     return 0;
 }
 
-int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp) {
+int pcxLoad(const char *filename, unsigned char **image,
+        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
     assert(image != NULL);
         }
     }
 
-    *mode = TextureManager::RGBA;
+    *mode = RGBA;
     *bpp = 32;
 
     delete [] buffer;

src/utils/png.cpp

     return 0;
 }
 
-int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp) {
+int pngLoad(const char *filename, unsigned char **image,
+        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp) {
     png_byte header[8];
 
     assert(filename != NULL);
     fclose(fp);
 
     if (color_type == PNG_COLOR_TYPE_GRAY) {
-        *mode = TextureManager::GREYSCALE;
+        *mode = GREYSCALE;
         *bpp = 8;
     } else if (color_type == PNG_COLOR_TYPE_RGB) {
-        *mode = TextureManager::RGB;
+        *mode = RGB;
         *bpp = 24;
     } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-        *mode = TextureManager::RGBA;
+        *mode = RGBA;
         *bpp = 32;
     } else {
         pngPrint("%s: Unknown libpng color type %d.", filename, color_type);
     return 0;
 }
 
-int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height, TextureManager::ColorMode mode, unsigned int bpp) {
+int pngSave(const char *filename, unsigned char *image,
+        unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
     assert(image != NULL);
     }
 
     int color_type;
-    if ((mode == TextureManager::GREYSCALE) && (bpp == 8)) {
+    if ((mode == GREYSCALE) && (bpp == 8)) {
         color_type = PNG_COLOR_TYPE_GRAY;
-    } else if (((mode == TextureManager::RGB) || (mode == TextureManager::BGR)) && (bpp == 24)) {
-        if (mode == TextureManager::BGR) {
+    } else if (((mode == RGB) || (mode == BGR)) && (bpp == 24)) {
+        if (mode == BGR) {
             bgr2rgb24(image, width, height);
         }
         color_type = PNG_COLOR_TYPE_RGB;
-    } else if (((mode == TextureManager::RGBA) || (mode == TextureManager::BGRA)) && (bpp == 32)) {
-        if (mode == TextureManager::BGRA) {
+    } else if (((mode == RGBA) || (mode == BGRA)) && (bpp == 32)) {
+        if (mode == BGRA) {
             bgra2rgba32(image, width, height);
         }
         color_type = PNG_COLOR_TYPE_RGB_ALPHA;