You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
275 lines
10 KiB
275 lines
10 KiB
/*********************************************************************************************
|
|
*
|
|
* 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 - raysan@raysanweb.com)
|
|
*
|
|
* 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 <GL/gl.h> // OpenGL functions
|
|
#include <stdlib.h> // Declares malloc() and free() for memory management
|
|
#include "stb_image.h" // Used to read image data (multiple formats support)
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Defines and Macros
|
|
//----------------------------------------------------------------------------------
|
|
// Nop...
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Types and Structures Definition
|
|
//----------------------------------------------------------------------------------
|
|
typedef unsigned char byte;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Global Variables Definition
|
|
//----------------------------------------------------------------------------------
|
|
// It's lonely here...
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module specific Functions Declaration
|
|
//----------------------------------------------------------------------------------
|
|
// No private (static) functions in this module (.c file)
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Definition
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Load an image into CPU memory (RAM)
|
|
Image LoadImage(const char *fileName)
|
|
{
|
|
Image image;
|
|
|
|
int imgWidth;
|
|
int imgHeight;
|
|
int imgBpp;
|
|
|
|
// NOTE: Using stb_image to load images (Supports: BMP, TGA, PNG, JPG, ...)
|
|
byte *imgData = stbi_load(fileName, &imgWidth, &imgHeight, &imgBpp, 4); // Force loading to 4 components (RGBA)
|
|
|
|
// 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;
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Unload image from CPU memory (RAM)
|
|
void UnloadImage(Image image)
|
|
{
|
|
free(image.pixels);
|
|
}
|
|
|
|
// Load an image as texture into GPU memory
|
|
Texture2D LoadTexture(const char *fileName)
|
|
{
|
|
Texture2D texture;
|
|
|
|
int imgWidth;
|
|
int imgHeight;
|
|
int imgBpp;
|
|
|
|
// NOTE: Using stb_image to load images (Supports: BMP, TGA, PNG, JPG, ...)
|
|
byte *imgData = stbi_load(fileName, &imgWidth, &imgHeight, &imgBpp, 4); // Force loading to 4 components (RGBA)
|
|
|
|
// Convert loaded data to OpenGL texture
|
|
//----------------------------------------
|
|
GLuint id;
|
|
glGenTextures(1, &id); // Generate Pointer to the Texture
|
|
|
|
glBindTexture(GL_TEXTURE_2D, id);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repead on x-axis
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repead on y-axis
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Filter for pixel-perfect drawing, alternative: GL_LINEAR
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Filter for pixel-perfect drawing, alternative: GL_LINEAR
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, imgWidth, imgHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
|
|
|
|
// NOTE: Not using mipmappings (texture for 2D drawing)
|
|
// At this point we have the image converted to texture and uploaded to GPU
|
|
|
|
stbi_image_free(imgData); // Now we can free loaded data from RAM memory
|
|
|
|
texture.glId = id;
|
|
texture.width = imgWidth;
|
|
texture.height = imgHeight;
|
|
|
|
return texture;
|
|
}
|
|
|
|
// Load an image as texture (and convert to POT with mipmaps)
|
|
Texture2D LoadTextureEx(const char *fileName, bool createPOT, bool mipmaps)
|
|
{
|
|
Texture2D texture;
|
|
|
|
// TODO: Load and image and convert to Power-Of-Two
|
|
// NOTE: Conversion could be done just adding extra space to image or by scaling image
|
|
// NOTE: If scaling image, be careful with scaling algorithm (aproximation, bilinear, bicubic...)
|
|
|
|
// TODO: Generate all required mipmap levels from image and convert to testure (not that easy)
|
|
// NOTE: If using OpenGL 1.1, the only option is doing mipmap generation on CPU side (i.e. gluBuild2DMipmaps)
|
|
// NOTE: raylib tries to minimize external dependencies so, we are not using GLU
|
|
// NOTE: Re-implement some function similar to gluBuild2DMipmaps (not that easy...)
|
|
|
|
return texture;
|
|
}
|
|
|
|
// Unload texture from GPU memory
|
|
void UnloadTexture(Texture2D texture)
|
|
{
|
|
glDeleteTextures(1, &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 extended parameters
|
|
void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
|
|
{
|
|
glEnable(GL_TEXTURE_2D); // Enable textures usage
|
|
|
|
glBindTexture(GL_TEXTURE_2D, texture.glId);
|
|
|
|
glPushMatrix();
|
|
// NOTE: Rotation is applied before translation and scaling, even being called in inverse order...
|
|
// NOTE: Rotation point is upper-left corner
|
|
glTranslatef(position.x, position.y, 0);
|
|
glScalef(scale, scale, 1.0f);
|
|
glRotatef(rotation, 0, 0, 1);
|
|
|
|
glBegin(GL_QUADS);
|
|
glColor4ub(tint.r, tint.g, tint.b, tint.a);
|
|
glNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer
|
|
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f); // Bottom-left corner for texture and quad
|
|
glTexCoord2f(1.0f, 0.0f); glVertex2f(texture.width, 0.0f); // Bottom-right corner for texture and quad
|
|
glTexCoord2f(1.0f, 1.0f); glVertex2f(texture.width, texture.height); // Top-right corner for texture and quad
|
|
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, texture.height); // Top-left corner for texture and quad
|
|
glEnd();
|
|
glPopMatrix();
|
|
|
|
glDisable(GL_TEXTURE_2D); // Disable textures usage
|
|
}
|
|
|
|
// Draw a part of a texture (defined by a rectangle)
|
|
void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, float scale, Color tint)
|
|
{
|
|
glEnable(GL_TEXTURE_2D); // Enable textures usage
|
|
|
|
glBindTexture(GL_TEXTURE_2D, texture.glId);
|
|
|
|
glPushMatrix();
|
|
glTranslatef(position.x, position.y, 0);
|
|
glScalef(scale, scale, 1.0f);
|
|
//glRotatef(rotation, 0, 0, 1);
|
|
|
|
glBegin(GL_QUADS);
|
|
glColor4ub(tint.r, tint.g, tint.b, tint.a);
|
|
glNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer
|
|
|
|
// Bottom-left corner for texture and quad
|
|
glTexCoord2f((float)sourceRec.x / texture.width, (float)sourceRec.y / texture.height);
|
|
glVertex2f(0.0f, 0.0f);
|
|
|
|
// Bottom-right corner for texture and quad
|
|
glTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)sourceRec.y / texture.height);
|
|
glVertex2f(sourceRec.width, 0.0f);
|
|
|
|
// Top-right corner for texture and quad
|
|
glTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
|
|
glVertex2f(sourceRec.width, sourceRec.height);
|
|
|
|
// Top-left corner for texture and quad
|
|
glTexCoord2f((float)sourceRec.x / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
|
|
glVertex2f(0.0f, sourceRec.height);
|
|
glEnd();
|
|
glPopMatrix();
|
|
|
|
glDisable(GL_TEXTURE_2D); // Disable textures usage
|
|
}
|
|
|
|
// Creates a bitmap (BMP) file from an array of pixel data
|
|
// NOTE: This function is only used by module [core], not explicitly available to raylib users
|
|
extern void WriteBitmap(const char *fileName, const Color *imgDataPixel, int width, int height)
|
|
{
|
|
int filesize = 54 + 3*width*height;
|
|
|
|
unsigned char bmpFileHeader[14] = {'B','M', 0,0,0,0, 0,0, 0,0, 54,0,0,0}; // Standard BMP file header
|
|
unsigned char bmpInfoHeader[40] = {40,0,0,0, 0,0,0,0, 0,0,0,0, 1,0, 24,0}; // Standard BMP info header
|
|
|
|
bmpFileHeader[2] = (unsigned char)(filesize);
|
|
bmpFileHeader[3] = (unsigned char)(filesize>>8);
|
|
bmpFileHeader[4] = (unsigned char)(filesize>>16);
|
|
bmpFileHeader[5] = (unsigned char)(filesize>>24);
|
|
|
|
bmpInfoHeader[4] = (unsigned char)(width);
|
|
bmpInfoHeader[5] = (unsigned char)(width>>8);
|
|
bmpInfoHeader[6] = (unsigned char)(width>>16);
|
|
bmpInfoHeader[7] = (unsigned char)(width>>24);
|
|
bmpInfoHeader[8] = (unsigned char)(height);
|
|
bmpInfoHeader[9] = (unsigned char)(height>>8);
|
|
bmpInfoHeader[10] = (unsigned char)(height>>16);
|
|
bmpInfoHeader[11] = (unsigned char)(height>>24);
|
|
|
|
FILE *bmpFile = fopen(fileName, "wb"); // Define a pointer to bitmap file and open it in write-binary mode
|
|
|
|
// NOTE: fwrite parameters are: data pointer, size in bytes of each element to be written, number of elements, file-to-write pointer
|
|
fwrite(bmpFileHeader, sizeof(unsigned char), 14, bmpFile); // Write BMP file header data
|
|
fwrite(bmpInfoHeader, sizeof(unsigned char), 40, bmpFile); // Write BMP info header data
|
|
|
|
// Write pixel data to file
|
|
for (int y = 0; y < height ; y++)
|
|
{
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
fputc(imgDataPixel[x + y*width].b, bmpFile);
|
|
fputc(imgDataPixel[x + y*width].g, bmpFile);
|
|
fputc(imgDataPixel[x + y*width].r, bmpFile);
|
|
}
|
|
}
|
|
|
|
fclose(bmpFile); // Close bitmap file
|
|
}
|