path: root/src/textures.c

/*********************************************************************************************
*
*   raylib.textures
*
*   Basic functions to load and draw Textures (2d)
*    
*   Uses external lib:
*       stb_image - Multiple formats image loading (JPEG, PNG, BMP, TGA, PSD, GIF, PIC)
*
*   Copyright (c) 2013 Ramon Santamaria (Ray San - [email protected])
*    
*   This software is provided "as-is", without any express or implied warranty. In no event 
*   will the authors be held liable for any damages arising from the use of this software.
*
*   Permission is granted to anyone to use this software for any purpose, including commercial 
*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
*
*     1. The origin of this software must not be misrepresented; you must not claim that you 
*     wrote the original software. If you use this software in a product, an acknowledgment 
*     in the product documentation would be appreciated but is not required.
*
*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
*     as being the original software.
*
*     3. This notice may not be removed or altered from any source distribution.
*
**********************************************************************************************/

#include "raylib.h"

#include <stdlib.h>          // Declares malloc() and free() for memory management
#include <string.h>          // Required for strcmp(), strrchr(), strncmp()
#include "stb_image.h"       // Used to read image data (multiple formats support)
#include "utils.h"           // rRES data decompression utility function

#include "rlgl.h"            // raylib OpenGL abstraction layer to OpenGL 1.1, 3.3+ or ES2

//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
// Nop...

//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
typedef unsigned char byte;

typedef struct {
    unsigned char *data;
    int width;
    int height;
    int mipmaps;
    int format;
} ImageDDS;

//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
// It's lonely here...

//----------------------------------------------------------------------------------
// Other Modules Functions Declaration (required by text)
//----------------------------------------------------------------------------------
//...

//----------------------------------------------------------------------------------
// Module specific Functions Declaration
//----------------------------------------------------------------------------------
static const char *GetExtension(const char *fileName);
static ImageDDS LoadDDS(const char *fileName);

//----------------------------------------------------------------------------------
// Module Functions Definition
//----------------------------------------------------------------------------------

// Load an image into CPU memory (RAM)
Image LoadImage(const char *fileName)
{
    Image image;
    
    if ((strcmp(GetExtension(fileName),"png") == 0) ||
        (strcmp(GetExtension(fileName),"bmp") == 0) ||
        (strcmp(GetExtension(fileName),"tga") == 0) ||
        (strcmp(GetExtension(fileName),"jpg") == 0) ||
        (strcmp(GetExtension(fileName),"gif") == 0) ||
        (strcmp(GetExtension(fileName),"psd") == 0) ||
        (strcmp(GetExtension(fileName),"pic") == 0))
    {       
        int imgWidth;
        int imgHeight;
        int imgBpp;
        
        // NOTE: Using stb_image to load images (Supports: BMP, TGA, PNG, JPG, ...)
        // Force loading to 4 components (RGBA)
        byte *imgData = stbi_load(fileName, &imgWidth, &imgHeight, &imgBpp, 4);    
        
        // Convert array to pixel array for working convenience
        image.pixels = (Color *)malloc(imgWidth * imgHeight * sizeof(Color));
        
        int pix = 0;
        
        for (int i = 0; i < (imgWidth * imgHeight * 4); i += 4)
        {
            image.pixels[pix].r = imgData[i];
            image.pixels[pix].g = imgData[i+1];
            image.pixels[pix].b = imgData[i+2];
            image.pixels[pix].a = imgData[i+3];
            pix++;
        }
        
        stbi_image_free(imgData);
        
        image.width = imgWidth;
        image.height = imgHeight;
        
        TraceLog(INFO, "[%s] Image loaded successfully", fileName);
    }
    else TraceLog(WARNING, "[%s] Image extension not recognized, it can't be loaded", fileName);
    
    // ALTERNATIVE: We can load pixel data directly into Color struct pixels array, 
    // to do that struct data alignment should be the right one (4 byte); it is.
    //image.pixels = stbi_load(fileName, &imgWidth, &imgHeight, &imgBpp, 4);

    return image;
}

// Load an image from rRES file (raylib Resource)
Image LoadImageFromRES(const char *rresName, int resId)
{
    // NOTE: rresName could be directly a char array with all the data!!! ---> TODO!
    Image image;
    bool found = false;

    char id[4];             // rRES file identifier
    unsigned char version;  // rRES file version and subversion
    char useless;           // rRES header reserved data
    short numRes;
    
    ResInfoHeader infoHeader;
    
    FILE *rresFile = fopen(rresName, "rb");

    if (!rresFile) TraceLog(WARNING, "[%s] Could not open raylib resource file", rresName);
    else
    {
        // Read rres file (basic file check - id)
        fread(&id[0], sizeof(char), 1, rresFile);
        fread(&id[1], sizeof(char), 1, rresFile);
        fread(&id[2], sizeof(char), 1, rresFile);
        fread(&id[3], sizeof(char), 1, rresFile);
        fread(&version, sizeof(char), 1, rresFile);
        fread(&useless, sizeof(char), 1, rresFile);
        
        if ((id[0] != 'r') && (id[1] != 'R') && (id[2] != 'E') &&(id[3] != 'S'))
        {
            TraceLog(WARNING, "[%s] This is not a valid raylib resource file", rresName);
        }
        else
        {
            // Read number of resources embedded
            fread(&numRes, sizeof(short), 1, rresFile);
            
            for (int i = 0; i < numRes; i++)
            {
                fread(&infoHeader, sizeof(ResInfoHeader), 1, rresFile);
                
                if (infoHeader.id == resId)
                {
                    found = true;
                    
                    // Check data is of valid IMAGE type
                    if (infoHeader.type == 0)   // IMAGE data type
                    {
                        // TODO: Check data compression type
                        
                        // NOTE: We suppose compression type 2 (DEFLATE - default)
                        short imgWidth, imgHeight;
                        char colorFormat, mipmaps;
                    
                        fread(&imgWidth, sizeof(short), 1, rresFile);   // Image width
                        fread(&imgHeight, sizeof(short), 1, rresFile);  // Image height
                        fread(&colorFormat, 1, 1, rresFile);            // Image data color format (default: RGBA 32 bit)
                        fread(&mipmaps, 1, 1, rresFile);                // Mipmap images included (default: 0)
                
                        image.width = (int)imgWidth;
                        image.height = (int)imgHeight;
                        
                        unsigned char *data = malloc(infoHeader.size);

                        fread(data, infoHeader.size, 1, rresFile);
                        
                        unsigned char *imgData = DecompressData(data, infoHeader.size, infoHeader.srcSize);
                        
                        image.pixels = (Color *)malloc(sizeof(Color)*imgWidth*imgHeight);
                        
                        int pix = 0;
                        
                        for (int i = 0; i < (imgWidth*imgHeight*4); i += 4)
                        {
                            image.pixels[pix].r = imgData[i];
                            image.pixels[pix].g = imgData[i+1];
                            image.pixels[pix].b = imgData[i+2];
                            image.pixels[pix].a = imgData[i+3];
                            pix++;
                        }
                        
                        free(imgData);
                     
                        free(data);
                        
                        TraceLog(INFO, "[%s] Image loaded successfully from resource, size: %ix%i", rresName, image.width, image.height);
                    }
                    else
                    {
                        TraceLog(WARNING, "[%s] Required resource do not seem to be a valid IMAGE resource", rresName);
                    }
                }
                else
                {
                    // Depending on type, skip the right amount of parameters
                    switch (infoHeader.type)
                    {
                        case 0: fseek(rresFile, 6, SEEK_CUR); break;   // IMAGE: Jump 6 bytes of parameters
                        case 1: fseek(rresFile, 6, SEEK_CUR); break;   // SOUND: Jump 6 bytes of parameters
                        case 2: fseek(rresFile, 5, SEEK_CUR); break;   // MODEL: Jump 5 bytes of parameters (TODO: Review)
                        case 3: break;   // TEXT: No parameters
                        case 4: break;   // RAW: No parameters
                        default: break;
                    }
                    
                    // Jump DATA to read next infoHeader
                    fseek(rresFile, infoHeader.size, SEEK_CUR);
                }
            }
        }
        
        fclose(rresFile);
    }
    
    if (!found) TraceLog(WARNING, "[%s] Required resource id [%i] could not be found in the raylib resource file", rresName, resId);
    
    return image;
}

// Load an image as texture into GPU memory
Texture2D LoadTexture(const char *fileName)
{
    Texture2D texture;

    if (strcmp(GetExtension(fileName),"dds") == 0)
    {
#ifdef USE_OPENGL_11 
        TraceLog(WARNING, "[%s] DDS file loading requires OpenGL 3.2+ or ES 2.0", fileName);
#else
        ImageDDS image = LoadDDS(fileName);
        
        texture.glId = rlglLoadCompressedTexture(image.data, image.width, image.height, image.mipmaps, image.format);

        texture.width = image.width;
        texture.height = image.height;
        
        if (texture.glId == 0) TraceLog(WARNING, "Compressed texture could not be loaded");
        else TraceLog(INFO, "Compressed texture loaded succesfully");
#endif
    }
    else
    {
        Image image = LoadImage(fileName);
        
        if (image.pixels != NULL)
        {
            texture = CreateTexture(image);
            UnloadImage(image);
        }
    }
    
    return texture;
}

// Load an image as texture from rRES file (raylib Resource)
Texture2D LoadTextureFromRES(const char *rresName, int resId)
{
    Texture2D texture;

    Image image = LoadImageFromRES(rresName, resId);
    texture = CreateTexture(image);
    
    return texture;
}

// Unload image from CPU memory (RAM)
void UnloadImage(Image image)
{
    free(image.pixels);
}

// Unload texture from GPU memory
void UnloadTexture(Texture2D texture)
{
    rlDeleteTextures(texture.glId);
}

// Draw a Texture2D
void DrawTexture(Texture2D texture, int posX, int posY, Color tint)
{
    DrawTextureEx(texture, (Vector2){ (float)posX, (float)posY }, 0, 1.0f, tint);
}

// Draw a Texture2D with position defined as Vector2
void DrawTextureV(Texture2D texture, Vector2 position, Color tint)
{
    DrawTextureEx(texture, position, 0, 1.0f, tint);
}

// Draw a Texture2D with extended parameters
void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
{
    rlEnableTexture(texture.glId);
    
    // NOTE: Rotation is applied before translation and scaling, even being called in inverse order...
    // NOTE: Rotation point is upper-left corner    
    rlPushMatrix();
        //rlTranslatef(position.x, position.y, 0.0);
        rlRotatef(rotation, 0, 0, 1);
        rlScalef(scale, scale, 1.0f);
    
        rlBegin(RL_QUADS);
            rlColor4ub(tint.r, tint.g, tint.b, tint.a);
            rlNormal3f(0.0f, 0.0f, 1.0f);                               // Normal vector pointing towards viewer
            
            rlTexCoord2f(0.0f, 0.0f);
            rlVertex2f(position.x, position.y);                         // Bottom-left corner for texture and quad
            
            rlTexCoord2f(0.0f, 1.0f); 
            rlVertex2f(position.x, position.y + texture.height);        // Bottom-right corner for texture and quad
            
            rlTexCoord2f(1.0f, 1.0f); 
            rlVertex2f(position.x + texture.width, position.y + texture.height);  // Top-right corner for texture and quad
            
            rlTexCoord2f(1.0f, 0.0f); 
            rlVertex2f(position.x + texture.width, position.y);         // Top-left corner for texture and quad
        rlEnd();
    rlPopMatrix();
    
    rlDisableTexture();
}

// Draw a part of a texture (defined by a rectangle)
void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint)
{
    rlEnableTexture(texture.glId);
    
    rlBegin(RL_QUADS);
        rlColor4ub(tint.r, tint.g, tint.b, tint.a);
        rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
        
        // Bottom-left corner for texture and quad
        rlTexCoord2f((float)sourceRec.x / texture.width, (float)sourceRec.y / texture.height); 
        rlVertex2f(position.x, position.y);
        
        // Bottom-right corner for texture and quad
        rlTexCoord2f((float)sourceRec.x / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
        rlVertex2f(position.x, position.y + sourceRec.height);
        
        // Top-right corner for texture and quad
        rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height); 
        rlVertex2f(position.x + sourceRec.width, position.y + sourceRec.height);
        
        // Top-left corner for texture and quad 
        rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)sourceRec.y / texture.height);
        rlVertex2f(position.x + sourceRec.width, position.y);
    rlEnd();
    
    rlDisableTexture();
}

// Draw a part of a texture (defined by a rectangle) with 'pro' parameters
// TODO: Test this function...
void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint)
{
    rlEnableTexture(texture.glId);
    
    // NOTE: First we translate texture to origin to apply rotation and translation from there
    rlPushMatrix();
        rlTranslatef(-origin.x, -origin.y, 0);  
        rlRotatef(rotation, 0, 0, 1);
        rlTranslatef(destRec.x + origin.x, destRec.y + origin.y, 0);
            
        rlBegin(RL_QUADS);
            rlColor4ub(tint.r, tint.g, tint.b, tint.a);
            rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
            
            // Bottom-left corner for texture and quad
            rlTexCoord2f((float)sourceRec.x / texture.width, (float)sourceRec.y / texture.height); 
            rlVertex2f(0.0f, 0.0f);
            
            // Bottom-right corner for texture and quad
            rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)sourceRec.y / texture.height);
            rlVertex2f(destRec.width, 0.0f);
            
            // Top-right corner for texture and quad
            rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height); 
            rlVertex2f(destRec.width, destRec.height);
            
            // Top-left corner for texture and quad
            rlTexCoord2f((float)sourceRec.x / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
            rlVertex2f(0.0f, destRec.height);
        rlEnd();
    rlPopMatrix();
    
    rlDisableTexture();
}

Texture2D CreateTexture(Image image)
{
    Texture2D texture;
    
    unsigned char *img = malloc(image.width * image.height * 4);
    
    int j = 0;
    
    for (int i = 0; i < image.width * image.height * 4; i += 4)
    {
        img[i] = image.pixels[j].r;
        img[i+1] = image.pixels[j].g;
        img[i+2] = image.pixels[j].b;
        img[i+3] = image.pixels[j].a;
        
        j++;
    }

    texture.glId = rlglLoadTexture(image.width, image.height, img);

    texture.width = image.width;
    texture.height = image.height;
    
    TraceLog(INFO, "Texture created succesfully");
    
    free(img);
    
    return texture;
}

// Get the extension for a filename
static const char *GetExtension(const char *fileName) 
{
    const char *dot = strrchr(fileName, '.');
    if(!dot || dot == fileName) return "";
    return (dot + 1);
}

// Loading DDS image compressed data 
ImageDDS LoadDDS(const char *fileName)
{   
    // TODO: Review and expand DDS file loading to support uncompressed formats and new formats

    // DDS Pixel Format
    typedef struct {
        unsigned int size;
        unsigned int flags;
        unsigned int fourCC;
        unsigned int rgbBitCount;
        unsigned int rBitMask;
        unsigned int gBitMask;
        unsigned int bitMask;
        unsigned int aBitMask;
    } ddsPixelFormat;
    
    // DDS Header (124 bytes)
    typedef struct {
        unsigned int size;
        unsigned int flags;
        unsigned int height;
        unsigned int width;
        unsigned int pitchOrLinearSize;
        unsigned int depth;
        unsigned int mipMapCount;
        unsigned int reserved1[11];
        ddsPixelFormat ddspf;
        unsigned int caps;
        unsigned int caps2;
        unsigned int caps3;
        unsigned int caps4;
        unsigned int reserved2;
    } ddsHeader;
    
    ImageDDS image;
    ddsHeader header;

    FILE *ddsFile = fopen(fileName, "rb");
    
    if (ddsFile == NULL)
    {
        TraceLog(WARNING, "DDS File could not be opened");
    }
    else
    {
        // Verify the type of file
        char filecode[4];
        
        fread(filecode, 1, 4, ddsFile);
        
        if (strncmp(filecode, "DDS ", 4) != 0) 
        { 
            TraceLog(WARNING, "DDS File does not seem to be valid");
            fclose(ddsFile);
        }
        else
        {       
            // Get the surface descriptor
            fread(&header, sizeof(ddsHeader), 1, ddsFile);

            int height = header.height;
            int width = header.width;
            int linearSize = header.pitchOrLinearSize;
            int mipMapCount = header.mipMapCount;
            int fourCC = header.ddspf.fourCC;
            
            TraceLog(DEBUG, "[%s] DDS file header size: %i", fileName, sizeof(ddsHeader));
            
            TraceLog(DEBUG, "[%s] DDS file pixel format size: %i", fileName, header.ddspf.size);
            TraceLog(DEBUG, "[%s] DDS file pixel format flags: 0x%x", fileName, header.ddspf.flags);
            TraceLog(DEBUG, "[%s] DDS file format: 0x%x", fileName, fourCC);
            
            int bufsize;
            
            // Calculate data size, including all mipmaps 
            bufsize = mipMapCount > 1 ? linearSize * 2 : linearSize; 
            
            image.data = (unsigned char*)malloc(bufsize * sizeof(unsigned char)); 
            
            fread(image.data, 1, bufsize, ddsFile); 
            
            // Close file pointer
            fclose(ddsFile);

            //int components = (fourCC == FOURCC_DXT1) ? 3 : 4; // Not required
            
            image.width = width;
            image.height = height;
            image.mipmaps = mipMapCount;
            image.format = fourCC;
        }
    }
    
    return image;
}