summaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
authorRay <[email protected]>2021-03-14 11:05:51 +0100
committerRay <[email protected]>2021-03-14 11:05:51 +0100
commit01e28263be9869b28acae5cf1128472269626edb (patch)
tree7536aebc3ff6273926fc52c4aa5929dd2b96fba6 /src
parent75038baf716a79606e86d46dad9d527bbb65628a (diff)
downloadraylib-01e28263be9869b28acae5cf1128472269626edb.tar.gz
raylib-01e28263be9869b28acae5cf1128472269626edb.zip
WARNING: VERY BREAKING CHANGE: Renamed some enum values for consistency
Some enums values have been renamed to be more consistent and also provide a more detailed description: - ShaderLocationIndex: LOC_VERTEX_POSITION -> SHADER_SHADER_LOC_VERTEX_POSITION - ShaderUniformDataType: UNIFORM_VEC2 -> SHADER_UNIFORM_VEC2 - MaterialMapType: MAP_ALBEDO -> MATERIAL_MAP_ALBEDO - PixelFormat: UNCOMPRESSED_GRAYSCALE -> PIXELFORMAT_UNCOMPRESSED_GRAYSCALE
Diffstat (limited to 'src')
-rw-r--r--src/core.c4
-rw-r--r--src/models.c70
-rw-r--r--src/raylib.h156
-rw-r--r--src/rlgl.h530
-rw-r--r--src/text.c16
-rw-r--r--src/textures.c378
6 files changed, 578 insertions, 576 deletions
diff --git a/src/core.c b/src/core.c
index 4ee2f631..3519627c 100644
--- a/src/core.c
+++ b/src/core.c
@@ -1356,7 +1356,7 @@ void ClearWindowState(unsigned int flags)
void SetWindowIcon(Image image)
{
#if defined(PLATFORM_DESKTOP)
- if (image.format == UNCOMPRESSED_R8G8B8A8)
+ if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
{
GLFWimage icon[1] = { 0 };
@@ -2258,7 +2258,7 @@ void SetConfigFlags(unsigned int flags)
void TakeScreenshot(const char *fileName)
{
unsigned char *imgData = rlReadScreenPixels(CORE.Window.render.width, CORE.Window.render.height);
- Image image = { imgData, CORE.Window.render.width, CORE.Window.render.height, 1, UNCOMPRESSED_R8G8B8A8 };
+ Image image = { imgData, CORE.Window.render.width, CORE.Window.render.height, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
char path[512] = { 0 };
#if defined(PLATFORM_ANDROID)
diff --git a/src/models.c b/src/models.c
index eba6f4f6..93146b7c 100644
--- a/src/models.c
+++ b/src/models.c
@@ -983,12 +983,12 @@ Material LoadMaterialDefault(void)
material.maps = (MaterialMap *)RL_CALLOC(MAX_MATERIAL_MAPS, sizeof(MaterialMap));
material.shader = GetShaderDefault();
- material.maps[MAP_DIFFUSE].texture = GetTextureDefault(); // White texture (1x1 pixel)
- //material.maps[MAP_NORMAL].texture; // NOTE: By default, not set
- //material.maps[MAP_SPECULAR].texture; // NOTE: By default, not set
+ material.maps[MATERIAL_MAP_DIFFUSE].texture = GetTextureDefault(); // White texture (1x1 pixel)
+ //material.maps[MATERIAL_MAP_NORMAL].texture; // NOTE: By default, not set
+ //material.maps[MATERIAL_MAP_SPECULAR].texture; // NOTE: By default, not set
- material.maps[MAP_DIFFUSE].color = WHITE; // Diffuse color
- material.maps[MAP_SPECULAR].color = WHITE; // Specular color
+ material.maps[MATERIAL_MAP_DIFFUSE].color = WHITE; // Diffuse color
+ material.maps[MATERIAL_MAP_SPECULAR].color = WHITE; // Specular color
return material;
}
@@ -1009,7 +1009,7 @@ void UnloadMaterial(Material material)
RL_FREE(material.params);
}
-// Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...)
+// Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
// NOTE: Previous texture should be manually unloaded
void SetMaterialTexture(Material *material, int mapType, Texture2D texture)
{
@@ -2330,7 +2330,7 @@ void MeshTangents(Mesh *mesh)
RL_FREE(tan2);
// Load a new tangent attributes buffer
- mesh->vboId[LOC_VERTEX_TANGENT] = rlLoadAttribBuffer(mesh->vaoId, LOC_VERTEX_TANGENT, mesh->tangents, mesh->vertexCount*4*sizeof(float), false);
+ mesh->vboId[SHADER_LOC_VERTEX_TANGENT] = rlLoadAttribBuffer(mesh->vaoId, SHADER_LOC_VERTEX_TANGENT, mesh->tangents, mesh->vertexCount*4*sizeof(float), false);
TRACELOG(LOG_INFO, "MESH: Tangents data computed for provided mesh");
}
@@ -2373,7 +2373,7 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota
for (int i = 0; i < model.meshCount; i++)
{
- Color color = model.materials[model.meshMaterial[i]].maps[MAP_DIFFUSE].color;
+ Color color = model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color;
Color colorTint = WHITE;
colorTint.r = (unsigned char)((((float)color.r/255.0)*((float)tint.r/255.0))*255.0f);
@@ -2381,9 +2381,9 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota
colorTint.b = (unsigned char)((((float)color.b/255.0)*((float)tint.b/255.0))*255.0f);
colorTint.a = (unsigned char)((((float)color.a/255.0)*((float)tint.a/255.0))*255.0f);
- model.materials[model.meshMaterial[i]].maps[MAP_DIFFUSE].color = colorTint;
+ model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color = colorTint;
rlDrawMesh(model.meshes[i], model.materials[model.meshMaterial[i]], model.transform);
- model.materials[model.meshMaterial[i]].maps[MAP_DIFFUSE].color = color;
+ model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color = color;
}
}
@@ -2883,28 +2883,28 @@ static Model LoadOBJ(const char *fileName)
for (unsigned int m = 0; m < materialCount; m++)
{
// Init material to default
- // NOTE: Uses default shader, which only supports MAP_DIFFUSE
+ // NOTE: Uses default shader, which only supports MATERIAL_MAP_DIFFUSE
model.materials[m] = LoadMaterialDefault();
- model.materials[m].maps[MAP_DIFFUSE].texture = GetTextureDefault(); // Get default texture, in case no texture is defined
+ model.materials[m].maps[MATERIAL_MAP_DIFFUSE].texture = GetTextureDefault(); // Get default texture, in case no texture is defined
- if (materials[m].diffuse_texname != NULL) model.materials[m].maps[MAP_DIFFUSE].texture = LoadTexture(materials[m].diffuse_texname); //char *diffuse_texname; // map_Kd
- else model.materials[m].maps[MAP_DIFFUSE].texture = GetTextureDefault();
+ if (materials[m].diffuse_texname != NULL) model.materials[m].maps[MATERIAL_MAP_DIFFUSE].texture = LoadTexture(materials[m].diffuse_texname); //char *diffuse_texname; // map_Kd
+ else model.materials[m].maps[MATERIAL_MAP_DIFFUSE].texture = GetTextureDefault();
- model.materials[m].maps[MAP_DIFFUSE].color = (Color){ (unsigned char)(materials[m].diffuse[0]*255.0f), (unsigned char)(materials[m].diffuse[1]*255.0f), (unsigned char)(materials[m].diffuse[2]*255.0f), 255 }; //float diffuse[3];
- model.materials[m].maps[MAP_DIFFUSE].value = 0.0f;
+ model.materials[m].maps[MATERIAL_MAP_DIFFUSE].color = (Color){ (unsigned char)(materials[m].diffuse[0]*255.0f), (unsigned char)(materials[m].diffuse[1]*255.0f), (unsigned char)(materials[m].diffuse[2]*255.0f), 255 }; //float diffuse[3];
+ model.materials[m].maps[MATERIAL_MAP_DIFFUSE].value = 0.0f;
- if (materials[m].specular_texname != NULL) model.materials[m].maps[MAP_SPECULAR].texture = LoadTexture(materials[m].specular_texname); //char *specular_texname; // map_Ks
- model.materials[m].maps[MAP_SPECULAR].color = (Color){ (unsigned char)(materials[m].specular[0]*255.0f), (unsigned char)(materials[m].specular[1]*255.0f), (unsigned char)(materials[m].specular[2]*255.0f), 255 }; //float specular[3];
- model.materials[m].maps[MAP_SPECULAR].value = 0.0f;
+ if (materials[m].specular_texname != NULL) model.materials[m].maps[MATERIAL_MAP_SPECULAR].texture = LoadTexture(materials[m].specular_texname); //char *specular_texname; // map_Ks
+ model.materials[m].maps[MATERIAL_MAP_SPECULAR].color = (Color){ (unsigned char)(materials[m].specular[0]*255.0f), (unsigned char)(materials[m].specular[1]*255.0f), (unsigned char)(materials[m].specular[2]*255.0f), 255 }; //float specular[3];
+ model.materials[m].maps[MATERIAL_MAP_SPECULAR].value = 0.0f;
- if (materials[m].bump_texname != NULL) model.materials[m].maps[MAP_NORMAL].texture = LoadTexture(materials[m].bump_texname); //char *bump_texname; // map_bump, bump
- model.materials[m].maps[MAP_NORMAL].color = WHITE;
- model.materials[m].maps[MAP_NORMAL].value = materials[m].shininess;
+ if (materials[m].bump_texname != NULL) model.materials[m].maps[MATERIAL_MAP_NORMAL].texture = LoadTexture(materials[m].bump_texname); //char *bump_texname; // map_bump, bump
+ model.materials[m].maps[MATERIAL_MAP_NORMAL].color = WHITE;
+ model.materials[m].maps[MATERIAL_MAP_NORMAL].value = materials[m].shininess;
- model.materials[m].maps[MAP_EMISSION].color = (Color){ (unsigned char)(materials[m].emission[0]*255.0f), (unsigned char)(materials[m].emission[1]*255.0f), (unsigned char)(materials[m].emission[2]*255.0f), 255 }; //float emission[3];
+ model.materials[m].maps[MATERIAL_MAP_EMISSION].color = (Color){ (unsigned char)(materials[m].emission[0]*255.0f), (unsigned char)(materials[m].emission[1]*255.0f), (unsigned char)(materials[m].emission[2]*255.0f), 255 }; //float emission[3];
- if (materials[m].displacement_texname != NULL) model.materials[m].maps[MAP_HEIGHT].texture = LoadTexture(materials[m].displacement_texname); //char *displacement_texname; // disp
+ if (materials[m].displacement_texname != NULL) model.materials[m].maps[MATERIAL_MAP_HEIGHT].texture = LoadTexture(materials[m].displacement_texname); //char *displacement_texname; // disp
}
tinyobj_attrib_free(&attrib);
@@ -3605,7 +3605,7 @@ static Image LoadImageFromCgltfImage(cgltf_image *image, const char *texPath, Co
rimage.data = raw;
rimage.width = width;
rimage.height = height;
- rimage.format = UNCOMPRESSED_R8G8B8A8;
+ rimage.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
rimage.mipmaps = 1;
// TODO: Tint shouldn't be applied here!
@@ -3639,7 +3639,7 @@ static Image LoadImageFromCgltfImage(cgltf_image *image, const char *texPath, Co
rimage.data = raw;
rimage.width = width;
rimage.height = height;
- rimage.format = UNCOMPRESSED_R8G8B8A8;
+ rimage.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
rimage.mipmaps = 1;
// TODO: Tint shouldn't be applied here!
@@ -3790,12 +3790,12 @@ static Model LoadGLTF(const char *fileName)
tint.b = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[2] * 255);
tint.a = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[3] * 255);
- model.materials[i].maps[MAP_ALBEDO].color = tint;
+ model.materials[i].maps[MATERIAL_MAP_ALBEDO].color = tint;
if (data->materials[i].pbr_metallic_roughness.base_color_texture.texture)
{
Image albedo = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.base_color_texture.texture->image, texPath, tint);
- model.materials[i].maps[MAP_ALBEDO].texture = LoadTextureFromImage(albedo);
+ model.materials[i].maps[MATERIAL_MAP_ALBEDO].texture = LoadTextureFromImage(albedo);
UnloadImage(albedo);
}
@@ -3804,13 +3804,13 @@ static Model LoadGLTF(const char *fileName)
if (data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture)
{
Image metallicRoughness = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture->image, texPath, tint);
- model.materials[i].maps[MAP_ROUGHNESS].texture = LoadTextureFromImage(metallicRoughness);
+ model.materials[i].maps[MATERIAL_MAP_ROUGHNESS].texture = LoadTextureFromImage(metallicRoughness);
float roughness = data->materials[i].pbr_metallic_roughness.roughness_factor;
- model.materials[i].maps[MAP_ROUGHNESS].value = roughness;
+ model.materials[i].maps[MATERIAL_MAP_ROUGHNESS].value = roughness;
float metallic = data->materials[i].pbr_metallic_roughness.metallic_factor;
- model.materials[i].maps[MAP_METALNESS].value = metallic;
+ model.materials[i].maps[MATERIAL_MAP_METALNESS].value = metallic;
UnloadImage(metallicRoughness);
}
@@ -3818,25 +3818,25 @@ static Model LoadGLTF(const char *fileName)
if (data->materials[i].normal_texture.texture)
{
Image normalImage = LoadImageFromCgltfImage(data->materials[i].normal_texture.texture->image, texPath, tint);
- model.materials[i].maps[MAP_NORMAL].texture = LoadTextureFromImage(normalImage);
+ model.materials[i].maps[MATERIAL_MAP_NORMAL].texture = LoadTextureFromImage(normalImage);
UnloadImage(normalImage);
}
if (data->materials[i].occlusion_texture.texture)
{
Image occulsionImage = LoadImageFromCgltfImage(data->materials[i].occlusion_texture.texture->image, texPath, tint);
- model.materials[i].maps[MAP_OCCLUSION].texture = LoadTextureFromImage(occulsionImage);
+ model.materials[i].maps[MATERIAL_MAP_OCCLUSION].texture = LoadTextureFromImage(occulsionImage);
UnloadImage(occulsionImage);
}
if (data->materials[i].emissive_texture.texture)
{
Image emissiveImage = LoadImageFromCgltfImage(data->materials[i].emissive_texture.texture->image, texPath, tint);
- model.materials[i].maps[MAP_EMISSION].texture = LoadTextureFromImage(emissiveImage);
+ model.materials[i].maps[MATERIAL_MAP_EMISSION].texture = LoadTextureFromImage(emissiveImage);
tint.r = (unsigned char)(data->materials[i].emissive_factor[0]*255);
tint.g = (unsigned char)(data->materials[i].emissive_factor[1]*255);
tint.b = (unsigned char)(data->materials[i].emissive_factor[2]*255);
- model.materials[i].maps[MAP_EMISSION].color = tint;
+ model.materials[i].maps[MATERIAL_MAP_EMISSION].color = tint;
UnloadImage(emissiveImage);
}
}
diff --git a/src/raylib.h b/src/raylib.h
index a6a1ddff..d08ead50 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -153,12 +153,14 @@
// Temporal hacks to avoid breaking old codebases using
// deprecated raylib implementation or definitions
-#define FormatText TextFormat
-#define LoadText LoadFileText
-#define GetExtension GetFileExtension
-#define GetImageData LoadImageColors
-#define FILTER_POINT TEXTURE_FILTER_POINT
-#define FILTER_BILINEAR TEXTURE_FILTER_BILINEAR
+#define FormatText TextFormat
+#define LoadText LoadFileText
+#define GetExtension GetFileExtension
+#define GetImageData LoadImageColors
+#define FILTER_POINT TEXTURE_FILTER_POINT
+#define FILTER_BILINEAR TEXTURE_FILTER_BILINEAR
+#define MAP_DIFFUSE MATERIAL_MAP_DIFFUSE
+#define PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 PIXELFORMAT_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
//----------------------------------------------------------------------------------
// Structures Definition
@@ -701,91 +703,91 @@ typedef enum {
// Shader location points
typedef enum {
- LOC_VERTEX_POSITION = 0,
- LOC_VERTEX_TEXCOORD01,
- LOC_VERTEX_TEXCOORD02,
- LOC_VERTEX_NORMAL,
- LOC_VERTEX_TANGENT,
- LOC_VERTEX_COLOR,
- LOC_MATRIX_MVP,
- LOC_MATRIX_MODEL,
- LOC_MATRIX_VIEW,
- LOC_MATRIX_PROJECTION,
- LOC_VECTOR_VIEW,
- LOC_COLOR_DIFFUSE,
- LOC_COLOR_SPECULAR,
- LOC_COLOR_AMBIENT,
- LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE
- LOC_MAP_METALNESS, // LOC_MAP_SPECULAR
- LOC_MAP_NORMAL,
- LOC_MAP_ROUGHNESS,
- LOC_MAP_OCCLUSION,
- LOC_MAP_EMISSION,
- LOC_MAP_HEIGHT,
- LOC_MAP_CUBEMAP,
- LOC_MAP_IRRADIANCE,
- LOC_MAP_PREFILTER,
- LOC_MAP_BRDF
+ SHADER_LOC_VERTEX_POSITION = 0,
+ SHADER_LOC_VERTEX_TEXCOORD01,
+ SHADER_LOC_VERTEX_TEXCOORD02,
+ SHADER_LOC_VERTEX_NORMAL,
+ SHADER_LOC_VERTEX_TANGENT,
+ SHADER_LOC_VERTEX_COLOR,
+ SHADER_LOC_MATRIX_MVP,
+ SHADER_LOC_MATRIX_MODEL,
+ SHADER_LOC_MATRIX_VIEW,
+ SHADER_LOC_MATRIX_PROJECTION,
+ SHADER_LOC_VECTOR_VIEW,
+ SHADER_LOC_COLOR_DIFFUSE,
+ SHADER_LOC_COLOR_SPECULAR,
+ SHADER_LOC_COLOR_AMBIENT,
+ SHADER_LOC_MAP_ALBEDO, // SHADER_LOC_MAP_DIFFUSE
+ SHADER_LOC_MAP_METALNESS, // SHADER_LOC_MAP_SPECULAR
+ SHADER_LOC_MAP_NORMAL,
+ SHADER_LOC_MAP_ROUGHNESS,
+ SHADER_LOC_MAP_OCCLUSION,
+ SHADER_LOC_MAP_EMISSION,
+ SHADER_LOC_MAP_HEIGHT,
+ SHADER_LOC_MAP_CUBEMAP,
+ SHADER_LOC_MAP_IRRADIANCE,
+ SHADER_LOC_MAP_PREFILTER,
+ SHADER_LOC_MAP_BRDF
} ShaderLocationIndex;
-#define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
-#define LOC_MAP_SPECULAR LOC_MAP_METALNESS
+#define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO
+#define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS
// Shader uniform data types
typedef enum {
- UNIFORM_FLOAT = 0,
- UNIFORM_VEC2,
- UNIFORM_VEC3,
- UNIFORM_VEC4,
- UNIFORM_INT,
- UNIFORM_IVEC2,
- UNIFORM_IVEC3,
- UNIFORM_IVEC4,
- UNIFORM_SAMPLER2D
+ SHADER_UNIFORM_FLOAT = 0,
+ SHADER_UNIFORM_VEC2,
+ SHADER_UNIFORM_VEC3,
+ SHADER_UNIFORM_VEC4,
+ SHADER_UNIFORM_INT,
+ SHADER_UNIFORM_IVEC2,
+ SHADER_UNIFORM_IVEC3,
+ SHADER_UNIFORM_IVEC4,
+ SHADER_UNIFORM_SAMPLER2D
} ShaderUniformDataType;
// Material maps
typedef enum {
- MAP_ALBEDO = 0, // MAP_DIFFUSE
- MAP_METALNESS = 1, // MAP_SPECULAR
- MAP_NORMAL = 2,
- MAP_ROUGHNESS = 3,
- MAP_OCCLUSION,
- MAP_EMISSION,
- MAP_HEIGHT,
- MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_BRDF
+ MATERIAL_MAP_ALBEDO = 0, // MATERIAL_MAP_DIFFUSE
+ MATERIAL_MAP_METALNESS = 1, // MATERIAL_MAP_SPECULAR
+ MATERIAL_MAP_NORMAL = 2,
+ MATERIAL_MAP_ROUGHNESS = 3,
+ MATERIAL_MAP_OCCLUSION,
+ MATERIAL_MAP_EMISSION,
+ MATERIAL_MAP_HEIGHT,
+ MATERIAL_MAP_BRDG,
+ MATERIAL_MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
+ MATERIAL_MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
+ MATERIAL_MAP_PREFILTER // NOTE: Uses GL_TEXTURE_CUBE_MAP
} MaterialMapType;
-#define MAP_DIFFUSE MAP_ALBEDO
-#define MAP_SPECULAR MAP_METALNESS
+#define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO
+#define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS
// Pixel formats
// NOTE: Support depends on OpenGL version and platform
typedef enum {
- UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
- UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
- UNCOMPRESSED_R5G6B5, // 16 bpp
- UNCOMPRESSED_R8G8B8, // 24 bpp
- UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
- UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
- UNCOMPRESSED_R8G8B8A8, // 32 bpp
- UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
- UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
- UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
- COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
- COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
- COMPRESSED_DXT3_RGBA, // 8 bpp
- COMPRESSED_DXT5_RGBA, // 8 bpp
- COMPRESSED_ETC1_RGB, // 4 bpp
- COMPRESSED_ETC2_RGB, // 4 bpp
- COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
- COMPRESSED_PVRT_RGB, // 4 bpp
- COMPRESSED_PVRT_RGBA, // 4 bpp
- COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
- COMPRESSED_ASTC_8x8_RGBA // 2 bpp
+ PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+ PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
+ PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
+ PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
+ PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
+ PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
+ PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
+ PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
} PixelFormat;
// Texture parameters: filter mode
@@ -1360,7 +1362,7 @@ RLAPI bool ExportMesh(Mesh mesh, const char *fileName);
RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file
RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM)
-RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...)
+RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh
// Model animations loading/unloading functions
diff --git a/src/rlgl.h b/src/rlgl.h
index d77608d8..07d8e705 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -364,27 +364,27 @@ typedef enum {
// Texture formats (support depends on OpenGL version)
typedef enum {
- UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
- UNCOMPRESSED_GRAY_ALPHA,
- UNCOMPRESSED_R5G6B5, // 16 bpp
- UNCOMPRESSED_R8G8B8, // 24 bpp
- UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
- UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
- UNCOMPRESSED_R8G8B8A8, // 32 bpp
- UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
- UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
- UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
- COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
- COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
- COMPRESSED_DXT3_RGBA, // 8 bpp
- COMPRESSED_DXT5_RGBA, // 8 bpp
- COMPRESSED_ETC1_RGB, // 4 bpp
- COMPRESSED_ETC2_RGB, // 4 bpp
- COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
- COMPRESSED_PVRT_RGB, // 4 bpp
- COMPRESSED_PVRT_RGBA, // 4 bpp
- COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
- COMPRESSED_ASTC_8x8_RGBA // 2 bpp
+ PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+ PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,
+ PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
+ PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
+ PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
+ PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
+ PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
+ PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
+ PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
+ PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
+ PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
+ PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
} PixelFormat;
// Texture parameters: filter mode
@@ -411,66 +411,66 @@ typedef enum {
// Shader location point type
typedef enum {
- LOC_VERTEX_POSITION = 0,
- LOC_VERTEX_TEXCOORD01,
- LOC_VERTEX_TEXCOORD02,
- LOC_VERTEX_NORMAL,
- LOC_VERTEX_TANGENT,
- LOC_VERTEX_COLOR,
- LOC_MATRIX_MVP,
- LOC_MATRIX_MODEL,
- LOC_MATRIX_VIEW,
- LOC_MATRIX_PROJECTION,
- LOC_VECTOR_VIEW,
- LOC_COLOR_DIFFUSE,
- LOC_COLOR_SPECULAR,
- LOC_COLOR_AMBIENT,
- LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE
- LOC_MAP_METALNESS, // LOC_MAP_SPECULAR
- LOC_MAP_NORMAL,
- LOC_MAP_ROUGHNESS,
- LOC_MAP_OCCLUSION,
- LOC_MAP_EMISSION,
- LOC_MAP_HEIGHT,
- LOC_MAP_CUBEMAP,
- LOC_MAP_IRRADIANCE,
- LOC_MAP_PREFILTER,
- LOC_MAP_BRDF
+ SHADER_LOC_VERTEX_POSITION = 0,
+ SHADER_LOC_VERTEX_TEXCOORD01,
+ SHADER_LOC_VERTEX_TEXCOORD02,
+ SHADER_LOC_VERTEX_NORMAL,
+ SHADER_LOC_VERTEX_TANGENT,
+ SHADER_LOC_VERTEX_COLOR,
+ SHADER_LOC_MATRIX_MVP,
+ SHADER_LOC_MATRIX_MODEL,
+ SHADER_LOC_MATRIX_VIEW,
+ SHADER_LOC_MATRIX_PROJECTION,
+ SHADER_LOC_VECTOR_VIEW,
+ SHADER_LOC_COLOR_DIFFUSE,
+ SHADER_LOC_COLOR_SPECULAR,
+ SHADER_LOC_COLOR_AMBIENT,
+ SHADER_LOC_MAP_ALBEDO, // SHADER_LOC_MAP_DIFFUSE
+ SHADER_LOC_MAP_METALNESS, // SHADER_LOC_MAP_SPECULAR
+ SHADER_LOC_MAP_NORMAL,
+ SHADER_LOC_MAP_ROUGHNESS,
+ SHADER_LOC_MAP_OCCLUSION,
+ SHADER_LOC_MAP_EMISSION,
+ SHADER_LOC_MAP_HEIGHT,
+ SHADER_LOC_MAP_CUBEMAP,
+ SHADER_LOC_MAP_IRRADIANCE,
+ SHADER_LOC_MAP_PREFILTER,
+ SHADER_LOC_MAP_BRDF
} ShaderLocationIndex;
// Shader uniform data types
typedef enum {
- UNIFORM_FLOAT = 0,
- UNIFORM_VEC2,
- UNIFORM_VEC3,
- UNIFORM_VEC4,
- UNIFORM_INT,
- UNIFORM_IVEC2,
- UNIFORM_IVEC3,
- UNIFORM_IVEC4,
- UNIFORM_SAMPLER2D
+ SHADER_UNIFORM_FLOAT = 0,
+ SHADER_UNIFORM_VEC2,
+ SHADER_UNIFORM_VEC3,
+ SHADER_UNIFORM_VEC4,
+ SHADER_UNIFORM_INT,
+ SHADER_UNIFORM_IVEC2,
+ SHADER_UNIFORM_IVEC3,
+ SHADER_UNIFORM_IVEC4,
+ SHADER_UNIFORM_SAMPLER2D
} ShaderUniformDataType;
- #define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
- #define LOC_MAP_SPECULAR LOC_MAP_METALNESS
+ #define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO
+ #define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS
// Material map type
typedef enum {
- MAP_ALBEDO = 0, // MAP_DIFFUSE
- MAP_METALNESS = 1, // MAP_SPECULAR
- MAP_NORMAL = 2,
- MAP_ROUGHNESS = 3,
- MAP_OCCLUSION,
- MAP_EMISSION,
- MAP_HEIGHT,
- MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
- MAP_BRDF
+ MATERIAL_MAP_ALBEDO = 0, // MATERIAL_MAP_DIFFUSE
+ MATERIAL_MAP_METALNESS = 1, // MATERIAL_MAP_SPECULAR
+ MATERIAL_MAP_NORMAL = 2,
+ MATERIAL_MAP_ROUGHNESS = 3,
+ MATERIAL_MAP_OCCLUSION,
+ MATERIAL_MAP_EMISSION,
+ MATERIAL_MAP_HEIGHT,
+ MATERIAL_MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
+ MATERIAL_MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
+ MATERIAL_MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
+ MATERIAL_MAP_BRDG
} MaterialMapType;
- #define MAP_DIFFUSE MAP_ALBEDO
- #define MAP_SPECULAR MAP_METALNESS
+ #define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO
+ #define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS
#endif
#if defined(__cplusplus)
@@ -1762,7 +1762,7 @@ void rlglInit(int width, int height)
//----------------------------------------------------------
// Init default white texture
unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes)
- RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, UNCOMPRESSED_R8G8B8A8, 1);
+ RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
if (RLGL.State.defaultTextureId != 0) TRACELOG(LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId);
else TRACELOG(LOG_WARNING, "TEXTURE: Failed to load default texture");
@@ -1973,38 +1973,38 @@ unsigned int rlLoadTexture(void *data, int width, int height, int format, int mi
// Check texture format support by OpenGL 1.1 (compressed textures not supported)
#if defined(GRAPHICS_API_OPENGL_11)
- if (format >= COMPRESSED_DXT1_RGB)
+ if (format >= PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
TRACELOG(LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats");
return id;
}
#else
- if ((!RLGL.ExtSupported.texCompDXT) && ((format == COMPRESSED_DXT1_RGB) || (format == COMPRESSED_DXT1_RGBA) ||
- (format == COMPRESSED_DXT3_RGBA) || (format == COMPRESSED_DXT5_RGBA)))
+ if ((!RLGL.ExtSupported.texCompDXT) && ((format == PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == PIXELFORMAT_COMPRESSED_DXT1_RGBA) ||
+ (format == PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == PIXELFORMAT_COMPRESSED_DXT5_RGBA)))
{
TRACELOG(LOG_WARNING, "GL: DXT compressed texture format not supported");
return id;
}
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
- if ((!RLGL.ExtSupported.texCompETC1) && (format == COMPRESSED_ETC1_RGB))
+ if ((!RLGL.ExtSupported.texCompETC1) && (format == PIXELFORMAT_COMPRESSED_ETC1_RGB))
{
TRACELOG(LOG_WARNING, "GL: ETC1 compressed texture format not supported");
return id;
}
- if ((!RLGL.ExtSupported.texCompETC2) && ((format == COMPRESSED_ETC2_RGB) || (format == COMPRESSED_ETC2_EAC_RGBA)))
+ if ((!RLGL.ExtSupported.texCompETC2) && ((format == PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA)))
{
TRACELOG(LOG_WARNING, "GL: ETC2 compressed texture format not supported");
return id;
}
- if ((!RLGL.ExtSupported.texCompPVRT) && ((format == COMPRESSED_PVRT_RGB) || (format == COMPRESSED_PVRT_RGBA)))
+ if ((!RLGL.ExtSupported.texCompPVRT) && ((format == PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == PIXELFORMAT_COMPRESSED_PVRT_RGBA)))
{
TRACELOG(LOG_WARNING, "GL: PVRT compressed texture format not supported");
return id;
}
- if ((!RLGL.ExtSupported.texCompASTC) && ((format == COMPRESSED_ASTC_4x4_RGBA) || (format == COMPRESSED_ASTC_8x8_RGBA)))
+ if ((!RLGL.ExtSupported.texCompASTC) && ((format == PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)))
{
TRACELOG(LOG_WARNING, "GL: ASTC compressed texture format not supported");
return id;
@@ -2038,18 +2038,18 @@ unsigned int rlLoadTexture(void *data, int width, int height, int format, int mi
if (glInternalFormat != -1)
{
- if (format < COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset);
+ if (format < PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset);
#if !defined(GRAPHICS_API_OPENGL_11)
else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, (unsigned char *)data + mipOffset);
#endif
#if defined(GRAPHICS_API_OPENGL_33)
- if (format == UNCOMPRESSED_GRAYSCALE)
+ if (format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
{
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
- else if (format == UNCOMPRESSED_GRAY_ALPHA)
+ else if (format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
{
#if defined(GRAPHICS_API_OPENGL_21)
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
@@ -2192,32 +2192,32 @@ unsigned int rlLoadTextureCubemap(void *data, int size, int format)
{
if (data == NULL)
{
- if (format < COMPRESSED_DXT1_RGB)
+ if (format < PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
- if (format == UNCOMPRESSED_R32G32B32)
+ if (format == PIXELFORMAT_UNCOMPRESSED_R32G32B32)
{
// Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB)
if (RLGL.ExtSupported.texFloat32) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL);
else TRACELOG(LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
}
- else if ((format == UNCOMPRESSED_R32) || (format == UNCOMPRESSED_R32G32B32A32)) TRACELOG(LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
+ else if ((format == PIXELFORMAT_UNCOMPRESSED_R32) || (format == PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) TRACELOG(LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL);
}
else TRACELOG(LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format");
}
else
{
- if (format < COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize);
+ if (format < PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize);
else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize);
}
#if defined(GRAPHICS_API_OPENGL_33)
- if (format == UNCOMPRESSED_GRAYSCALE)
+ if (format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
{
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
- else if (format == UNCOMPRESSED_GRAY_ALPHA)
+ else if (format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
{
#if defined(GRAPHICS_API_OPENGL_21)
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
@@ -2258,7 +2258,7 @@ void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int h
unsigned int glInternalFormat, glFormat, glType;
rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
- if ((glInternalFormat != -1) && (format < COMPRESSED_DXT1_RGB))
+ if ((glInternalFormat != -1) && (format < PIXELFORMAT_COMPRESSED_DXT1_RGB))
{
glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, (unsigned char *)data);
}
@@ -2276,43 +2276,43 @@ void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned
{
#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2)
// NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
- case UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
- case UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
- case UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
- case UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
#if !defined(GRAPHICS_API_OPENGL_11)
- case UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
- case UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
- case UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
+ case PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float
#endif
#endif
#if defined(GRAPHICS_API_OPENGL_33)
- case UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
- case UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
- case UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
- case UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
- case UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break;
- case UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break;
- case UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;
#endif
#if !defined(GRAPHICS_API_OPENGL_11)
- case COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break;
- case COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
- case COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
- case COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
- case COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
- case COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
- case COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
- case COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
- case COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
- case COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
- case COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+ case PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break;
+ case PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
+ case PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
+ case PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
+ case PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
+ case PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+ case PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+ case PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
+ case PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
+ case PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+ case PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
#endif
default: TRACELOG(LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break;
}
@@ -2427,7 +2427,7 @@ void rlGenerateMipmaps(Texture2D *texture)
if (texIsPOT)
{
// WARNING: Manual mipmap generation only works for RGBA 32bit textures!
- if (texture->format == UNCOMPRESSED_R8G8B8A8)
+ if (texture->format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
{
// Retrieve texture data from VRAM
void *texData = rlReadTexturePixels(*texture);
@@ -2731,7 +2731,7 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
{
#if defined(GRAPHICS_API_OPENGL_11)
glEnable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, material.maps[MAP_DIFFUSE].texture.id);
+ glBindTexture(GL_TEXTURE_2D, material.maps[MATERIAL_MAP_DIFFUSE].texture.id);
// NOTE: On OpenGL 1.1 we use Vertex Arrays to draw model
glEnableClientState(GL_VERTEX_ARRAY); // Enable vertex array
@@ -2746,7 +2746,7 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
rlPushMatrix();
rlMultMatrixf(MatrixToFloat(transform));
- rlColor4ub(material.maps[MAP_DIFFUSE].color.r, material.maps[MAP_DIFFUSE].color.g, material.maps[MAP_DIFFUSE].color.b, material.maps[MAP_DIFFUSE].color.a);
+ rlColor4ub(material.maps[MATERIAL_MAP_DIFFUSE].color.r, material.maps[MATERIAL_MAP_DIFFUSE].color.g, material.maps[MATERIAL_MAP_DIFFUSE].color.b, material.maps[MATERIAL_MAP_DIFFUSE].color.a);
if (mesh.indices != NULL) glDrawElements(GL_TRIANGLES, mesh.triangleCount*3, GL_UNSIGNED_SHORT, mesh.indices);
else glDrawArrays(GL_TRIANGLES, 0, mesh.vertexCount);
@@ -2768,24 +2768,24 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
// Matrices and other values required by shader
//-----------------------------------------------------
// Calculate and send to shader model matrix (used by PBR shader)
- if (material.shader.locs[LOC_MATRIX_MODEL] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_MODEL], transform);
+ if (material.shader.locs[SHADER_LOC_MATRIX_MODEL] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[SHADER_LOC_MATRIX_MODEL], transform);
// Upload to shader material.colDiffuse
- if (material.shader.locs[LOC_COLOR_DIFFUSE] != -1)
- glUniform4f(material.shader.locs[LOC_COLOR_DIFFUSE], (float)material.maps[MAP_DIFFUSE].color.r/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.g/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.b/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.a/255.0f);
+ if (material.shader.locs[SHADER_LOC_COLOR_DIFFUSE] != -1)
+ glUniform4f(material.shader.locs[SHADER_LOC_COLOR_DIFFUSE], (float)material.maps[MATERIAL_MAP_DIFFUSE].color.r/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.g/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.b/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.a/255.0f);
// Upload to shader material.colSpecular (if available)
- if (material.shader.locs[LOC_COLOR_SPECULAR] != -1)
- glUniform4f(material.shader.locs[LOC_COLOR_SPECULAR], (float)material.maps[MAP_SPECULAR].color.r/255.0f,
- (float)material.maps[MAP_SPECULAR].color.g/255.0f,
- (float)material.maps[MAP_SPECULAR].color.b/255.0f,
- (float)material.maps[MAP_SPECULAR].color.a/255.0f);
+ if (material.shader.locs[SHADER_LOC_COLOR_SPECULAR] != -1)
+ glUniform4f(material.shader.locs[SHADER_LOC_COLOR_SPECULAR], (float)material.maps[MATERIAL_MAP_SPECULAR].color.r/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.g/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.b/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.a/255.0f);
- if (material.shader.locs[LOC_MATRIX_VIEW] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_VIEW], RLGL.State.modelview);
- if (material.shader.locs[LOC_MATRIX_PROJECTION] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_PROJECTION], RLGL.State.projection);
+ if (material.shader.locs[SHADER_LOC_MATRIX_VIEW] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[SHADER_LOC_MATRIX_VIEW], RLGL.State.modelview);
+ if (material.shader.locs[SHADER_LOC_MATRIX_PROJECTION] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[SHADER_LOC_MATRIX_PROJECTION], RLGL.State.projection);
// At this point the modelview matrix just contains the view matrix (camera)
// That's because BeginMode3D() sets it an no model-drawing function modifies it, all use rlPushMatrix() and rlPopMatrix()
@@ -2807,10 +2807,10 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
if (material.maps[i].texture.id > 0)
{
glActiveTexture(GL_TEXTURE0 + i);
- if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, material.maps[i].texture.id);
+ if ((i == MATERIAL_MAP_IRRADIANCE) || (i == MATERIAL_MAP_PREFILTER) || (i == MATERIAL_MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, material.maps[i].texture.id);
else glBindTexture(GL_TEXTURE_2D, material.maps[i].texture.id);
- glUniform1i(material.shader.locs[LOC_MAP_DIFFUSE + i], i);
+ glUniform1i(material.shader.locs[SHADER_LOC_MAP_DIFFUSE + i], i);
}
}
@@ -2820,54 +2820,54 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
{
// Bind mesh VBO data: vertex position (shader-location = 0)
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[0]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_POSITION]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_POSITION]);
// Bind mesh VBO data: vertex texcoords (shader-location = 1)
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[1]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TEXCOORD01]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01]);
// Bind mesh VBO data: vertex normals (shader-location = 2, if available)
- if (material.shader.locs[LOC_VERTEX_NORMAL] != -1)
+ if (material.shader.locs[SHADER_LOC_VERTEX_NORMAL] != -1)
{
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[2]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_NORMAL], 3, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_NORMAL]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_NORMAL], 3, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_NORMAL]);
}
// Bind mesh VBO data: vertex colors (shader-location = 3, if available)
- if (material.shader.locs[LOC_VERTEX_COLOR] != -1)
+ if (material.shader.locs[SHADER_LOC_VERTEX_COLOR] != -1)
{
if (mesh.vboId[3] != 0)
{
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[3]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_COLOR]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_COLOR]);
}
else
{
// Set default value for unused attribute
// NOTE: Required when using default shader and no VAO support
- glVertexAttrib4f(material.shader.locs[LOC_VERTEX_COLOR], 1.0f, 1.0f, 1.0f, 1.0f);
- glDisableVertexAttribArray(material.shader.locs[LOC_VERTEX_COLOR]);
+ glVertexAttrib4f(material.shader.locs[SHADER_LOC_VERTEX_COLOR], 1.0f, 1.0f, 1.0f, 1.0f);
+ glDisableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_COLOR]);
}
}
// Bind mesh VBO data: vertex tangents (shader-location = 4, if available)
- if (material.shader.locs[LOC_VERTEX_TANGENT] != -1)
+ if (material.shader.locs[SHADER_LOC_VERTEX_TANGENT] != -1)
{
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[4]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TANGENT], 4, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TANGENT]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_TANGENT], 4, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_TANGENT]);
}
// Bind mesh VBO data: vertex texcoords2 (shader-location = 5, if available)
- if (material.shader.locs[LOC_VERTEX_TEXCOORD02] != -1)
+ if (material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02] != -1)
{
glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[5]);
- glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TEXCOORD02], 2, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TEXCOORD02]);
+ glVertexAttribPointer(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02], 2, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02]);
}
if (mesh.indices != NULL) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.vboId[6]);
@@ -2889,7 +2889,7 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
Matrix matMVP = MatrixMultiply(RLGL.State.modelview, RLGL.State.projection); // Transform to screen-space coordinates
// Send combined model-view-projection matrix to shader
- glUniformMatrix4fv(material.shader.locs[LOC_MATRIX_MVP], 1, false, MatrixToFloat(matMVP));
+ glUniformMatrix4fv(material.shader.locs[SHADER_LOC_MATRIX_MVP], 1, false, MatrixToFloat(matMVP));
// Draw call!
if (mesh.indices != NULL) glDrawElements(GL_TRIANGLES, mesh.triangleCount*3, GL_UNSIGNED_SHORT, 0); // Indexed vertices draw
@@ -2900,7 +2900,7 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
{
glActiveTexture(GL_TEXTURE0 + i); // Set shader active texture
- if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+ if ((i == MATERIAL_MAP_IRRADIANCE) || (i == MATERIAL_MAP_PREFILTER) || (i == MATERIAL_MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
else glBindTexture(GL_TEXTURE_2D, 0); // Unbind current active texture
}
@@ -2930,18 +2930,18 @@ void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int c
glUseProgram(material.shader.id);
// Upload to shader material.colDiffuse
- if (material.shader.locs[LOC_COLOR_DIFFUSE] != -1)
- glUniform4f(material.shader.locs[LOC_COLOR_DIFFUSE], (float)material.maps[MAP_DIFFUSE].color.r/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.g/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.b/255.0f,
- (float)material.maps[MAP_DIFFUSE].color.a/255.0f);
+ if (material.shader.locs[SHADER_LOC_COLOR_DIFFUSE] != -1)
+ glUniform4f(material.shader.locs[SHADER_LOC_COLOR_DIFFUSE], (float)material.maps[MATERIAL_MAP_DIFFUSE].color.r/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.g/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.b/255.0f,
+ (float)material.maps[MATERIAL_MAP_DIFFUSE].color.a/255.0f);
// Upload to shader material.colSpecular (if available)
- if (material.shader.locs[LOC_COLOR_SPECULAR] != -1)
- glUniform4f(material.shader.locs[LOC_COLOR_SPECULAR], (float)material.maps[MAP_SPECULAR].color.r/255.0f,
- (float)material.maps[MAP_SPECULAR].color.g/255.0f,
- (float)material.maps[MAP_SPECULAR].color.b/255.0f,
- (float)material.maps[MAP_SPECULAR].color.a/255.0f);
+ if (material.shader.locs[SHADER_LOC_COLOR_SPECULAR] != -1)
+ glUniform4f(material.shader.locs[SHADER_LOC_COLOR_SPECULAR], (float)material.maps[MATERIAL_MAP_SPECULAR].color.r/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.g/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.b/255.0f,
+ (float)material.maps[MATERIAL_MAP_SPECULAR].color.a/255.0f);
// Bind active texture maps (if available)
for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
@@ -2949,11 +2949,11 @@ void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int c
if (material.maps[i].texture.id > 0)
{
glActiveTexture(GL_TEXTURE0 + i);
- if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP))
+ if ((i == MATERIAL_MAP_IRRADIANCE) || (i == MATERIAL_MAP_PREFILTER) || (i == MATERIAL_MAP_CUBEMAP))
glBindTexture(GL_TEXTURE_CUBE_MAP, material.maps[i].texture.id);
else glBindTexture(GL_TEXTURE_2D, material.maps[i].texture.id);
- glUniform1i(material.shader.locs[LOC_MAP_DIFFUSE + i], i);
+ glUniform1i(material.shader.locs[SHADER_LOC_MAP_DIFFUSE + i], i);
}
}
@@ -2962,7 +2962,7 @@ void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int c
// At this point the modelview matrix just contains the view matrix (camera)
// For instanced shaders "mvp" is not premultiplied by any instance transform, only RLGL.State.transform
- glUniformMatrix4fv(material.shader.locs[LOC_MATRIX_MVP], 1, false,
+ glUniformMatrix4fv(material.shader.locs[SHADER_LOC_MATRIX_MVP], 1, false,
MatrixToFloat(MatrixMultiply(MatrixMultiply(RLGL.State.transform, RLGL.State.modelview), RLGL.State.projection)));
float16* instanceTransforms = RL_MALLOC(count*sizeof(float16));
@@ -2978,9 +2978,9 @@ void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int c
glBindBuffer(GL_ARRAY_BUFFER, instancesB);
glBufferData(GL_ARRAY_BUFFER, count*sizeof(float16), instanceTransforms, GL_STATIC_DRAW);
- // Instances are put in LOC_MATRIX_MODEL attribute location with space for 4x Vector4, eg:
+ // Instances are put in SHADER_LOC_MATRIX_MODEL attribute location with space for 4x Vector4, eg:
// layout (location = 12) in mat4 instance;
- unsigned int instanceA = material.shader.locs[LOC_MATRIX_MODEL];
+ unsigned int instanceA = material.shader.locs[SHADER_LOC_MATRIX_MODEL];
for (unsigned int i = 0; i < 4; i++)
{
@@ -3002,7 +3002,7 @@ void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int c
for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
{
glActiveTexture(GL_TEXTURE0 + i); // Set shader active texture
- if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+ if ((i == MATERIAL_MAP_IRRADIANCE) || (i == MATERIAL_MAP_PREFILTER) || (i == MATERIAL_MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
else glBindTexture(GL_TEXTURE_2D, 0); // Unbind current active texture
}
@@ -3089,7 +3089,7 @@ void *rlReadTexturePixels(Texture2D texture)
rlGetGlTextureFormats(texture.format, &glInternalFormat, &glFormat, &glType);
unsigned int size = GetPixelDataSize(texture.width, texture.height, texture.format);
- if ((glInternalFormat != -1) && (texture.format < COMPRESSED_DXT1_RGB))
+ if ((glInternalFormat != -1) && (texture.format < PIXELFORMAT_COMPRESSED_DXT1_RGB))
{
pixels = RL_MALLOC(size);
glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels);
@@ -3118,7 +3118,7 @@ void *rlReadTexturePixels(Texture2D texture)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.id, 0);
// We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
- pixels = (unsigned char *)RL_MALLOC(GetPixelDataSize(texture.width, texture.height, UNCOMPRESSED_R8G8B8A8));
+ pixels = (unsigned char *)RL_MALLOC(GetPixelDataSize(texture.width, texture.height, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8));
glReadPixels(0, 0, texture.width, texture.height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -3144,7 +3144,7 @@ Texture2D GetTextureDefault(void)
texture.width = 1;
texture.height = 1;
texture.mipmaps = 1;
- texture.format = UNCOMPRESSED_R8G8B8A8;
+ texture.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
#endif
return texture;
}
@@ -3357,15 +3357,15 @@ void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int unifo
switch (uniformType)
{
- case UNIFORM_FLOAT: glUniform1fv(uniformLoc, count, (float *)value); break;
- case UNIFORM_VEC2: glUniform2fv(uniformLoc, count, (float *)value); break;
- case UNIFORM_VEC3: glUniform3fv(uniformLoc, count, (float *)value); break;
- case UNIFORM_VEC4: glUniform4fv(uniformLoc, count, (float *)value); break;
- case UNIFORM_INT: glUniform1iv(uniformLoc, count, (int *)value); break;
- case UNIFORM_IVEC2: glUniform2iv(uniformLoc, count, (int *)value); break;
- case UNIFORM_IVEC3: glUniform3iv(uniformLoc, count, (int *)value); break;
- case UNIFORM_IVEC4: glUniform4iv(uniformLoc, count, (int *)value); break;
- case UNIFORM_SAMPLER2D: glUniform1iv(uniformLoc, count, (int *)value); break;
+ case SHADER_UNIFORM_FLOAT: glUniform1fv(uniformLoc, count, (float *)value); break;
+ case SHADER_UNIFORM_VEC2: glUniform2fv(uniformLoc, count, (float *)value); break;
+ case SHADER_UNIFORM_VEC3: glUniform3fv(uniformLoc, count, (float *)value); break;
+ case SHADER_UNIFORM_VEC4: glUniform4fv(uniformLoc, count, (float *)value); break;
+ case SHADER_UNIFORM_INT: glUniform1iv(uniformLoc, count, (int *)value); break;
+ case SHADER_UNIFORM_IVEC2: glUniform2iv(uniformLoc, count, (int *)value); break;
+ case SHADER_UNIFORM_IVEC3: glUniform3iv(uniformLoc, count, (int *)value); break;
+ case SHADER_UNIFORM_IVEC4: glUniform4iv(uniformLoc, count, (int *)value); break;
+ case SHADER_UNIFORM_SAMPLER2D: glUniform1iv(uniformLoc, count, (int *)value); break;
default: TRACELOG(LOG_WARNING, "SHADER: [ID %i] Failed to set uniform, data type not recognized", shader.id);
}
@@ -3487,7 +3487,7 @@ TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, in
// Define projection matrix and send it to shader
Matrix fboProjection = MatrixPerspective(90.0*DEG2RAD, 1.0, RL_CULL_DISTANCE_NEAR, RL_CULL_DISTANCE_FAR);
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_PROJECTION], fboProjection);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_PROJECTION], fboProjection);
// Define view matrix for every side of the cubemap
Matrix fboViews[6] = {
@@ -3509,7 +3509,7 @@ TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, in
for (int i = 0; i < 6; i++)
{
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_VIEW], fboViews[i]);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_VIEW], fboViews[i]);
rlFramebufferAttach(fbo, cubemap.id, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_CUBEMAP_POSITIVE_X + i);
rlEnableFramebuffer(fbo);
@@ -3543,7 +3543,7 @@ TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, in
cubemap.width = size;
cubemap.height = size;
cubemap.mipmaps = 1;
- cubemap.format = UNCOMPRESSED_R32G32B32;
+ cubemap.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32;
#endif
return cubemap;
}
@@ -3559,7 +3559,7 @@ TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int s
// STEP 1: Setup framebuffer
//------------------------------------------------------------------------------------------
unsigned int rbo = rlLoadTextureDepth(size, size, true);
- irradiance.id = rlLoadTextureCubemap(NULL, size, UNCOMPRESSED_R32G32B32);
+ irradiance.id = rlLoadTextureCubemap(NULL, size, PIXELFORMAT_UNCOMPRESSED_R32G32B32);
unsigned int fbo = rlLoadFramebuffer(size, size);
rlFramebufferAttach(fbo, rbo, RL_ATTACHMENT_DEPTH, RL_ATTACHMENT_RENDERBUFFER);
@@ -3572,7 +3572,7 @@ TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int s
// Define projection matrix and send it to shader
Matrix fboProjection = MatrixPerspective(90.0*DEG2RAD, 1.0, RL_CULL_DISTANCE_NEAR, RL_CULL_DISTANCE_FAR);
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_PROJECTION], fboProjection);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_PROJECTION], fboProjection);
// Define view matrix for every side of the cubemap
Matrix fboViews[6] = {
@@ -3592,7 +3592,7 @@ TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int s
for (int i = 0; i < 6; i++)
{
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_VIEW], fboViews[i]);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_VIEW], fboViews[i]);
rlFramebufferAttach(fbo, irradiance.id, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_CUBEMAP_POSITIVE_X + i);
rlEnableFramebuffer(fbo);
@@ -3616,7 +3616,7 @@ TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int s
irradiance.width = size;
irradiance.height = size;
irradiance.mipmaps = 1;
- irradiance.format = UNCOMPRESSED_R32G32B32;
+ irradiance.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32;
#endif
return irradiance;
}
@@ -3632,7 +3632,7 @@ TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int si
// STEP 1: Setup framebuffer
//------------------------------------------------------------------------------------------
unsigned int rbo = rlLoadTextureDepth(size, size, true);
- prefilter.id = rlLoadTextureCubemap(NULL, size, UNCOMPRESSED_R32G32B32);
+ prefilter.id = rlLoadTextureCubemap(NULL, size, PIXELFORMAT_UNCOMPRESSED_R32G32B32);
rlTextureParameters(prefilter.id, RL_TEXTURE_MIN_FILTER, RL_TEXTURE_FILTER_MIP_LINEAR);
unsigned int fbo = rlLoadFramebuffer(size, size);
@@ -3649,7 +3649,7 @@ TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int si
// Define projection matrix and send it to shader
Matrix fboProjection = MatrixPerspective(90.0*DEG2RAD, 1.0, RL_CULL_DISTANCE_NEAR, RL_CULL_DISTANCE_FAR);
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_PROJECTION], fboProjection);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_PROJECTION], fboProjection);
// Define view matrix for every side of the cubemap
Matrix fboViews[6] = {
@@ -3688,7 +3688,7 @@ TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int si
for (int i = 0; i < 6; i++)
{
- SetShaderValueMatrix(shader, shader.locs[LOC_MATRIX_VIEW], fboViews[i]);
+ SetShaderValueMatrix(shader, shader.locs[SHADER_LOC_MATRIX_VIEW], fboViews[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, prefilter.id, mip);
//rlFramebufferAttach(fbo, irradiance.id, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_CUBEMAP_POSITIVE_X + i); // TODO: Support mip levels?
@@ -3714,7 +3714,7 @@ TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int si
prefilter.width = size;
prefilter.height = size;
//prefilter.mipmaps = 1 + (int)floor(log(size)/log(2)); // MAX_MIPMAP_LEVELS
- //prefilter.format = UNCOMPRESSED_R32G32B32;
+ //prefilter.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32;
#endif
return prefilter;
}
@@ -3728,7 +3728,7 @@ Texture2D GenTextureBRDF(Shader shader, int size)
// STEP 1: Setup framebuffer
//------------------------------------------------------------------------------------------
unsigned int rbo = rlLoadTextureDepth(size, size, true);
- brdf.id = rlLoadTexture(NULL, size, size, UNCOMPRESSED_R32G32B32, 1);
+ brdf.id = rlLoadTexture(NULL, size, size, PIXELFORMAT_UNCOMPRESSED_R32G32B32, 1);
unsigned int fbo = rlLoadFramebuffer(size, size);
rlFramebufferAttach(fbo, rbo, RL_ATTACHMENT_DEPTH, RL_ATTACHMENT_RENDERBUFFER);
@@ -3762,7 +3762,7 @@ Texture2D GenTextureBRDF(Shader shader, int size)
brdf.width = size;
brdf.height = size;
brdf.mipmaps = 1;
- brdf.format = UNCOMPRESSED_R32G32B32;
+ brdf.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32;
#endif
return brdf;
}
@@ -3809,7 +3809,7 @@ void InitVrSimulator(void)
RLGL.Vr.stereoFboId = rlLoadFramebuffer(RLGL.State.framebufferWidth, RLGL.State.framebufferHeight);
// Load color/depth textures to attach to framebuffer
- RLGL.Vr.stereoTexId = rlLoadTexture(NULL, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight, UNCOMPRESSED_R8G8B8A8, 1);
+ RLGL.Vr.stereoTexId = rlLoadTexture(NULL, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
unsigned int depthId = rlLoadTextureDepth(RLGL.State.framebufferWidth, RLGL.State.framebufferHeight, true);
// Attach color texture and depth renderbuffer/texture to FBO
@@ -3913,15 +3913,15 @@ void SetVrConfiguration(VrDeviceInfo hmd, Shader distortion)
if (RLGL.Vr.config.distortionShader.id > 0)
{
// Update distortion shader with lens and distortion-scale parameters
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "leftLensCenter"), leftLensCenter, UNIFORM_VEC2);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "rightLensCenter"), rightLensCenter, UNIFORM_VEC2);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "leftScreenCenter"), leftScreenCenter, UNIFORM_VEC2);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "rightScreenCenter"), rightScreenCenter, UNIFORM_VEC2);
-
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "scale"), scale, UNIFORM_VEC2);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "scaleIn"), scaleIn, UNIFORM_VEC2);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "hmdWarpParam"), hmd.lensDistortionValues, UNIFORM_VEC4);
- SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "chromaAbParam"), hmd.chromaAbCorrection, UNIFORM_VEC4);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "leftLensCenter"), leftLensCenter, SHADER_UNIFORM_VEC2);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "rightLensCenter"), rightLensCenter, SHADER_UNIFORM_VEC2);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "leftScreenCenter"), leftScreenCenter, SHADER_UNIFORM_VEC2);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "rightScreenCenter"), rightScreenCenter, SHADER_UNIFORM_VEC2);
+
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "scale"), scale, SHADER_UNIFORM_VEC2);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "scaleIn"), scaleIn, SHADER_UNIFORM_VEC2);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "hmdWarpParam"), hmd.lensDistortionValues, SHADER_UNIFORM_VEC4);
+ SetShaderValue(RLGL.Vr.config.distortionShader, GetShaderLocation(RLGL.Vr.config.distortionShader, "chromaAbParam"), hmd.chromaAbCorrection, SHADER_UNIFORM_VEC4);
}
#endif
}
@@ -4217,14 +4217,14 @@ static Shader LoadShaderDefault(void)
TRACELOG(LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", shader.id);
// Set default shader locations: attributes locations
- shader.locs[LOC_VERTEX_POSITION] = glGetAttribLocation(shader.id, "vertexPosition");
- shader.locs[LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader.id, "vertexTexCoord");
- shader.locs[LOC_VERTEX_COLOR] = glGetAttribLocation(shader.id, "vertexColor");
+ shader.locs[SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(shader.id, "vertexPosition");
+ shader.locs[SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader.id, "vertexTexCoord");
+ shader.locs[SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(shader.id, "vertexColor");
// Set default shader locations: uniform locations
- shader.locs[LOC_MATRIX_MVP] = glGetUniformLocation(shader.id, "mvp");
- shader.locs[LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader.id, "colDiffuse");
- shader.locs[LOC_MAP_DIFFUSE] = glGetUniformLocation(shader.id, "texture0");
+ shader.locs[SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(shader.id, "mvp");
+ shader.locs[SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader.id, "colDiffuse");
+ shader.locs[SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(shader.id, "texture0");
// NOTE: We could also use below function but in case DEFAULT_ATTRIB_* points are
// changed for external custom shaders, we just use direct bindings above
@@ -4248,23 +4248,23 @@ static void SetShaderDefaultLocations(Shader *shader)
// vertex texcoord2 location = 5
// Get handles to GLSL input attibute locations
- shader->locs[LOC_VERTEX_POSITION] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_POSITION);
- shader->locs[LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
- shader->locs[LOC_VERTEX_TEXCOORD02] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
- shader->locs[LOC_VERTEX_NORMAL] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
- shader->locs[LOC_VERTEX_TANGENT] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
- shader->locs[LOC_VERTEX_COLOR] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_COLOR);
+ shader->locs[SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_POSITION);
+ shader->locs[SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
+ shader->locs[SHADER_LOC_VERTEX_TEXCOORD02] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
+ shader->locs[SHADER_LOC_VERTEX_NORMAL] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
+ shader->locs[SHADER_LOC_VERTEX_TANGENT] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
+ shader->locs[SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(shader->id, DEFAULT_SHADER_ATTRIB_NAME_COLOR);
// Get handles to GLSL uniform locations (vertex shader)
- shader->locs[LOC_MATRIX_MVP] = glGetUniformLocation(shader->id, "mvp");
- shader->locs[LOC_MATRIX_PROJECTION] = glGetUniformLocation(shader->id, "projection");
- shader->locs[LOC_MATRIX_VIEW] = glGetUniformLocation(shader->id, "view");
+ shader->locs[SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(shader->id, "mvp");
+ shader->locs[SHADER_LOC_MATRIX_PROJECTION] = glGetUniformLocation(shader->id, "projection");
+ shader->locs[SHADER_LOC_MATRIX_VIEW] = glGetUniformLocation(shader->id, "view");
// Get handles to GLSL uniform locations (fragment shader)
- shader->locs[LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader->id, "colDiffuse");
- shader->locs[LOC_MAP_DIFFUSE] = glGetUniformLocation(shader->id, "texture0");
- shader->locs[LOC_MAP_SPECULAR] = glGetUniformLocation(shader->id, "texture1");
- shader->locs[LOC_MAP_NORMAL] = glGetUniformLocation(shader->id, "texture2");
+ shader->locs[SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader->id, "colDiffuse");
+ shader->locs[SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(shader->id, "texture0");
+ shader->locs[SHADER_LOC_MAP_SPECULAR] = glGetUniformLocation(shader->id, "texture1");
+ shader->locs[SHADER_LOC_MAP_NORMAL] = glGetUniformLocation(shader->id, "texture2");
}
// Unload default shader
@@ -4348,22 +4348,22 @@ static RenderBatch LoadRenderBatch(int numBuffers, int bufferElements)
glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]);
glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]);
glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_POSITION]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_POSITION]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
// Vertex texcoord buffer (shader-location = 1)
glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]);
glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]);
glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_TEXCOORD01]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_TEXCOORD01]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
// Vertex color buffer (shader-location = 3)
glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]);
glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]);
glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_COLOR]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_COLOR]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
// Fill index buffer
glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]);
@@ -4477,32 +4477,32 @@ static void DrawRenderBatch(RenderBatch *batch)
// Create modelview-projection matrix and upload to shader
Matrix matMVP = MatrixMultiply(RLGL.State.modelview, RLGL.State.projection);
- glUniformMatrix4fv(RLGL.State.currentShader.locs[LOC_MATRIX_MVP], 1, false, MatrixToFloat(matMVP));
+ glUniformMatrix4fv(RLGL.State.currentShader.locs[SHADER_LOC_MATRIX_MVP], 1, false, MatrixToFloat(matMVP));
if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
else
{
// Bind vertex attrib: position (shader-location = 0)
glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_POSITION]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_POSITION]);
// Bind vertex attrib: texcoord (shader-location = 1)
glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_TEXCOORD01]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_TEXCOORD01]);
// Bind vertex attrib: color (shader-location = 3)
glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]);
- glVertexAttribPointer(RLGL.State.currentShader.locs[LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
- glEnableVertexAttribArray(RLGL.State.currentShader.locs[LOC_VERTEX_COLOR]);
+ glVertexAttribPointer(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
+ glEnableVertexAttribArray(RLGL.State.currentShader.locs[SHADER_LOC_VERTEX_COLOR]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]);
}
// Setup some default shader values
- glUniform4f(RLGL.State.currentShader.locs[LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f);
- glUniform1i(RLGL.State.currentShader.locs[LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0
+ glUniform4f(RLGL.State.currentShader.locs[SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f);
+ glUniform1i(RLGL.State.currentShader.locs[SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0
// Activate additional sampler textures
// Those additional textures will be common for all draw calls of the batch
@@ -4960,27 +4960,27 @@ int GetPixelDataSize(int width, int height, int format)
switch (format)
{
- case UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
- case UNCOMPRESSED_GRAY_ALPHA:
- case UNCOMPRESSED_R5G6B5:
- case UNCOMPRESSED_R5G5B5A1:
- case UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
- case UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
- case UNCOMPRESSED_R8G8B8: bpp = 24; break;
- case UNCOMPRESSED_R32: bpp = 32; break;
- case UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
- case UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
- case COMPRESSED_DXT1_RGB:
- case COMPRESSED_DXT1_RGBA:
- case COMPRESSED_ETC1_RGB:
- case COMPRESSED_ETC2_RGB:
- case COMPRESSED_PVRT_RGB:
- case COMPRESSED_PVRT_RGBA: bpp = 4; break;
- case COMPRESSED_DXT3_RGBA:
- case COMPRESSED_DXT5_RGBA:
- case COMPRESSED_ETC2_EAC_RGBA:
- case COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
- case COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
+ case PIXELFORMAT_COMPRESSED_DXT1_RGB:
+ case PIXELFORMAT_COMPRESSED_DXT1_RGBA:
+ case PIXELFORMAT_COMPRESSED_ETC1_RGB:
+ case PIXELFORMAT_COMPRESSED_ETC2_RGB:
+ case PIXELFORMAT_COMPRESSED_PVRT_RGB:
+ case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+ case PIXELFORMAT_COMPRESSED_DXT3_RGBA:
+ case PIXELFORMAT_COMPRESSED_DXT5_RGBA:
+ case PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
+ case PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
+ case PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
default: break;
}
@@ -4990,8 +4990,8 @@ int GetPixelDataSize(int width, int height, int format)
// if texture is smaller, minimum dataSize is 8 or 16
if ((width < 4) && (height < 4))
{
- if ((format >= COMPRESSED_DXT1_RGB) && (format < COMPRESSED_DXT3_RGBA)) dataSize = 8;
- else if ((format >= COMPRESSED_DXT3_RGBA) && (format < COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
+ if ((format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
+ else if ((format >= PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
}
return dataSize;
diff --git a/src/text.c b/src/text.c
index 204cc4e3..e945b33f 100644
--- a/src/text.c
+++ b/src/text.c
@@ -196,7 +196,7 @@ extern void LoadFontDefault(void)
.data = calloc(128*128, 2), // 2 bytes per pixel (gray + alpha)
.width = 128,
.height = 128,
- .format = UNCOMPRESSED_GRAY_ALPHA,
+ .format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,
.mipmaps = 1
};
@@ -440,7 +440,7 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
.data = pixels,
.width = image.width,
.height = image.height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -598,7 +598,7 @@ CharInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize
chars[i].image.width = chw;
chars[i].image.height = chh;
chars[i].image.mipmaps = 1;
- chars[i].image.format = UNCOMPRESSED_GRAYSCALE;
+ chars[i].image.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
chars[i].offsetY += (int)((float)ascent*scaleFactor);
@@ -609,7 +609,7 @@ CharInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize
.data = calloc(chars[i].advanceX*fontSize, 2),
.width = chars[i].advanceX,
.height = fontSize,
- .format = UNCOMPRESSED_GRAYSCALE,
+ .format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE,
.mipmaps = 1
};
@@ -679,7 +679,7 @@ Image GenImageFontAtlas(const CharInfo *chars, Rectangle **charRecs, int charsCo
atlas.width = imageSize; // Atlas bitmap width
atlas.height = imageSize; // Atlas bitmap height
atlas.data = (unsigned char *)RL_CALLOC(1, atlas.width*atlas.height); // Create a bitmap to store characters (8 bpp)
- atlas.format = UNCOMPRESSED_GRAYSCALE;
+ atlas.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
atlas.mipmaps = 1;
// DEBUG: We can see padding in the generated image setting a gray background...
@@ -783,7 +783,7 @@ Image GenImageFontAtlas(const CharInfo *chars, Rectangle **charRecs, int charsCo
RL_FREE(atlas.data);
atlas.data = dataGrayAlpha;
- atlas.format = UNCOMPRESSED_GRAY_ALPHA;
+ atlas.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
*charRecs = recs;
@@ -1794,14 +1794,14 @@ static Font LoadBMFont(const char *fileName)
Image imFont = LoadImage(imPath);
- if (imFont.format == UNCOMPRESSED_GRAYSCALE)
+ if (imFont.format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
{
// Convert image to GRAYSCALE + ALPHA, using the mask as the alpha channel
Image imFontAlpha = {
.data = calloc(imFont.width*imFont.height, 2),
.width = imFont.width,
.height = imFont.height,
- .format = UNCOMPRESSED_GRAY_ALPHA,
+ .format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,
.mipmaps = 1
};
diff --git a/src/textures.c b/src/textures.c
index 0d78c2a2..1de11d80 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -147,8 +147,8 @@
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
-#ifndef UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD
- #define UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD 50 // Threshold over 255 to set alpha as 0
+#ifndef PIXELFORMAT_UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD
+ #define PIXELFORMAT_UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD 50 // Threshold over 255 to set alpha as 0
#endif
//----------------------------------------------------------------------------------
@@ -276,7 +276,7 @@ Image LoadImageAnim(const char *fileName, int *frames)
image.data = stbi_load_gif_from_memory(fileData, dataSize, delays, &image.width, &image.height, &framesCount, &comp, 4);
image.mipmaps = 1;
- image.format = UNCOMPRESSED_R8G8B8A8;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
RL_FREE(fileData);
RL_FREE(delays); // NOTE: Frames delays are discarded
@@ -337,10 +337,10 @@ Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, i
image.mipmaps = 1;
- if (comp == 1) image.format = UNCOMPRESSED_GRAYSCALE;
- else if (comp == 2) image.format = UNCOMPRESSED_GRAY_ALPHA;
- else if (comp == 3) image.format = UNCOMPRESSED_R8G8B8;
- else if (comp == 4) image.format = UNCOMPRESSED_R8G8B8A8;
+ if (comp == 1) image.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
+ else if (comp == 2) image.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
+ else if (comp == 3) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
+ else if (comp == 4) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
}
#endif
}
@@ -355,9 +355,9 @@ Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, i
image.mipmaps = 1;
- if (comp == 1) image.format = UNCOMPRESSED_R32;
- else if (comp == 3) image.format = UNCOMPRESSED_R32G32B32;
- else if (comp == 4) image.format = UNCOMPRESSED_R32G32B32A32;
+ if (comp == 1) image.format = PIXELFORMAT_UNCOMPRESSED_R32;
+ else if (comp == 3) image.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32;
+ else if (comp == 4) image.format = PIXELFORMAT_UNCOMPRESSED_R32G32B32A32;
else
{
TRACELOG(LOG_WARNING, "IMAGE: HDR file format not supported");
@@ -404,10 +404,10 @@ bool ExportImage(Image image, const char *fileName)
bool allocatedData = false;
unsigned char *imgData = (unsigned char *)image.data;
- if (image.format == UNCOMPRESSED_GRAYSCALE) channels = 1;
- else if (image.format == UNCOMPRESSED_GRAY_ALPHA) channels = 2;
- else if (image.format == UNCOMPRESSED_R8G8B8) channels = 3;
- else if (image.format == UNCOMPRESSED_R8G8B8A8) channels = 4;
+ if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) channels = 1;
+ else if (image.format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) channels = 2;
+ else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8) channels = 3;
+ else if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8) channels = 4;
else
{
// NOTE: Getting Color array as RGBA unsigned char values
@@ -512,7 +512,7 @@ Image GenImageColor(int width, int height, Color color)
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -541,7 +541,7 @@ Image GenImageGradientV(int width, int height, Color top, Color bottom)
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -569,7 +569,7 @@ Image GenImageGradientH(int width, int height, Color left, Color right)
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -606,7 +606,7 @@ Image GenImageGradientRadial(int width, int height, float density, Color inner,
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -631,7 +631,7 @@ Image GenImageChecked(int width, int height, int checksX, int checksY, Color col
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -653,7 +653,7 @@ Image GenImageWhiteNoise(int width, int height, float factor)
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -689,7 +689,7 @@ Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -754,7 +754,7 @@ Image GenImageCellular(int width, int height, int tileSize)
.data = pixels,
.width = width,
.height = height,
- .format = UNCOMPRESSED_R8G8B8A8,
+ .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
@@ -844,7 +844,7 @@ void ImageCrop(Image *image, Rectangle crop)
}
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
@@ -885,7 +885,7 @@ void ImageFormat(Image *image, int newFormat)
if ((newFormat != 0) && (image->format != newFormat))
{
- if ((image->format < COMPRESSED_DXT1_RGB) && (newFormat < COMPRESSED_DXT1_RGB))
+ if ((image->format < PIXELFORMAT_COMPRESSED_DXT1_RGB) && (newFormat < PIXELFORMAT_COMPRESSED_DXT1_RGB))
{
Vector4 *pixels = LoadImageDataNormalized(*image); // Supports 8 to 32 bit per channel
@@ -897,7 +897,7 @@ void ImageFormat(Image *image, int newFormat)
switch (image->format)
{
- case UNCOMPRESSED_GRAYSCALE:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
{
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*sizeof(unsigned char));
@@ -907,7 +907,7 @@ void ImageFormat(Image *image, int newFormat)
}
} break;
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*2*sizeof(unsigned char));
@@ -918,7 +918,7 @@ void ImageFormat(Image *image, int newFormat)
}
} break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
@@ -936,7 +936,7 @@ void ImageFormat(Image *image, int newFormat)
}
} break;
- case UNCOMPRESSED_R8G8B8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8:
{
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*3*sizeof(unsigned char));
@@ -947,7 +947,7 @@ void ImageFormat(Image *image, int newFormat)
((unsigned char *)image->data)[i + 2] = (unsigned char)(pixels[k].z*255.0f);
}
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
@@ -961,13 +961,13 @@ void ImageFormat(Image *image, int newFormat)
r = (unsigned char)(round(pixels[i].x*31.0f));
g = (unsigned char)(round(pixels[i].y*31.0f));
b = (unsigned char)(round(pixels[i].z*31.0f));
- a = (pixels[i].w > ((float)UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;
+ a = (pixels[i].w > ((float)PIXELFORMAT_UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;
((unsigned short *)image->data)[i] = (unsigned short)r << 11 | (unsigned short)g << 6 | (unsigned short)b << 1 | (unsigned short)a;
}
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
@@ -987,7 +987,7 @@ void ImageFormat(Image *image, int newFormat)
}
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*4*sizeof(unsigned char));
@@ -999,7 +999,7 @@ void ImageFormat(Image *image, int newFormat)
((unsigned char *)image->data)[i + 3] = (unsigned char)(pixels[k].w*255.0f);
}
} break;
- case UNCOMPRESSED_R32:
+ case PIXELFORMAT_UNCOMPRESSED_R32:
{
// WARNING: Image is converted to GRAYSCALE eqeuivalent 32bit
@@ -1010,7 +1010,7 @@ void ImageFormat(Image *image, int newFormat)
((float *)image->data)[i] = (float)(pixels[i].x*0.299f + pixels[i].y*0.587f + pixels[i].z*0.114f);
}
} break;
- case UNCOMPRESSED_R32G32B32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32:
{
image->data = (float *)RL_MALLOC(image->width*image->height*3*sizeof(float));
@@ -1021,7 +1021,7 @@ void ImageFormat(Image *image, int newFormat)
((float *)image->data)[i + 2] = pixels[k].z;
}
} break;
- case UNCOMPRESSED_R32G32B32A32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
{
image->data = (float *)RL_MALLOC(image->width*image->height*4*sizeof(float));
@@ -1164,12 +1164,12 @@ void ImageAlphaClear(Image *image, Color color, float threshold)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
switch (image->format)
{
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
unsigned char thresholdValue = (unsigned char)(threshold*255.0f);
for (int i = 1; i < image->width*image->height*2; i += 2)
@@ -1181,7 +1181,7 @@ void ImageAlphaClear(Image *image, Color color, float threshold)
}
}
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
unsigned char thresholdValue = ((threshold < 0.5f)? 0 : 1);
@@ -1198,7 +1198,7 @@ void ImageAlphaClear(Image *image, Color color, float threshold)
}
}
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
unsigned char thresholdValue = (unsigned char)(threshold*15.0f);
@@ -1215,7 +1215,7 @@ void ImageAlphaClear(Image *image, Color color, float threshold)
}
}
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
unsigned char thresholdValue = (unsigned char)(threshold*255.0f);
for (int i = 3; i < image->width*image->height*4; i += 4)
@@ -1229,7 +1229,7 @@ void ImageAlphaClear(Image *image, Color color, float threshold)
}
}
} break;
- case UNCOMPRESSED_R32G32B32A32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
{
for (int i = 3; i < image->width*image->height*4; i += 4)
{
@@ -1256,7 +1256,7 @@ void ImageAlphaMask(Image *image, Image alphaMask)
{
TRACELOG(LOG_WARNING, "IMAGE: Alpha mask must be same size as image");
}
- else if (image->format >= COMPRESSED_DXT1_RGB)
+ else if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
TRACELOG(LOG_WARNING, "IMAGE: Alpha mask can not be applied to compressed data formats");
}
@@ -1264,10 +1264,10 @@ void ImageAlphaMask(Image *image, Image alphaMask)
{
// Force mask to be Grayscale
Image mask = ImageCopy(alphaMask);
- if (mask.format != UNCOMPRESSED_GRAYSCALE) ImageFormat(&mask, UNCOMPRESSED_GRAYSCALE);
+ if (mask.format != PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) ImageFormat(&mask, PIXELFORMAT_UNCOMPRESSED_GRAYSCALE);
// In case image is only grayscale, we just add alpha channel
- if (image->format == UNCOMPRESSED_GRAYSCALE)
+ if (image->format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
{
unsigned char *data = (unsigned char *)RL_MALLOC(image->width*image->height*2);
@@ -1280,12 +1280,12 @@ void ImageAlphaMask(Image *image, Image alphaMask)
RL_FREE(image->data);
image->data = data;
- image->format = UNCOMPRESSED_GRAY_ALPHA;
+ image->format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
}
else
{
// Convert image to RGBA
- if (image->format != UNCOMPRESSED_R8G8B8A8) ImageFormat(image, UNCOMPRESSED_R8G8B8A8);
+ if (image->format != PIXELFORMAT_UNCOMPRESSED_R8G8B8A8) ImageFormat(image, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8);
// Apply alpha mask to alpha channel
for (int i = 0, k = 3; (i < mask.width*mask.height) || (i < image->width*image->height); i++, k += 4)
@@ -1328,7 +1328,7 @@ void ImageAlphaPremultiply(Image *image)
int format = image->format;
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -1343,7 +1343,7 @@ void ImageResize(Image *image, int newWidth, int newHeight)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
bool fastPath = true;
- if ((image->format != UNCOMPRESSED_GRAYSCALE) && (image->format != UNCOMPRESSED_GRAY_ALPHA) && (image->format != UNCOMPRESSED_R8G8B8) && (image->format != UNCOMPRESSED_R8G8B8A8)) fastPath = true;
+ if ((image->format != PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) && (image->format != PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) && (image->format != PIXELFORMAT_UNCOMPRESSED_R8G8B8) && (image->format != PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)) fastPath = true;
if (fastPath)
{
@@ -1352,10 +1352,10 @@ void ImageResize(Image *image, int newWidth, int newHeight)
switch (image->format)
{
- case UNCOMPRESSED_GRAYSCALE: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 1); break;
- case UNCOMPRESSED_GRAY_ALPHA: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 2); break;
- case UNCOMPRESSED_R8G8B8: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 3); break;
- case UNCOMPRESSED_R8G8B8A8: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 4); break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 1); break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 2); break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 3); break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: stbir_resize_uint8((unsigned char *)image->data, image->width, image->height, 0, output, newWidth, newHeight, 0, 4); break;
default: break;
}
@@ -1381,7 +1381,7 @@ void ImageResize(Image *image, int newWidth, int newHeight)
image->data = output;
image->width = newWidth;
image->height = newHeight;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
}
@@ -1419,7 +1419,7 @@ void ImageResizeNN(Image *image,int newWidth,int newHeight)
image->data = output;
image->width = newWidth;
image->height = newHeight;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
@@ -1434,7 +1434,7 @@ void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, i
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else if ((newWidth != image->width) || (newHeight != image->height))
{
Rectangle srcRec = { 0, 0, (float)image->width, (float)image->height };
@@ -1557,7 +1557,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
- if (image->format >= COMPRESSED_DXT1_RGB)
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
TRACELOG(LOG_WARNING, "IMAGE: Compressed data formats can not be dithered");
return;
@@ -1573,15 +1573,15 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
RL_FREE(image->data); // free old image data
- if ((image->format != UNCOMPRESSED_R8G8B8) && (image->format != UNCOMPRESSED_R8G8B8A8))
+ if ((image->format != PIXELFORMAT_UNCOMPRESSED_R8G8B8) && (image->format != PIXELFORMAT_UNCOMPRESSED_R8G8B8A8))
{
TRACELOG(LOG_WARNING, "IMAGE: Format is already 16bpp or lower, dithering could have no effect");
}
// Define new image format, check if desired bpp match internal known format
- if ((rBpp == 5) && (gBpp == 6) && (bBpp == 5) && (aBpp == 0)) image->format = UNCOMPRESSED_R5G6B5;
- else if ((rBpp == 5) && (gBpp == 5) && (bBpp == 5) && (aBpp == 1)) image->format = UNCOMPRESSED_R5G5B5A1;
- else if ((rBpp == 4) && (gBpp == 4) && (bBpp == 4) && (aBpp == 4)) image->format = UNCOMPRESSED_R4G4B4A4;
+ if ((rBpp == 5) && (gBpp == 6) && (bBpp == 5) && (aBpp == 0)) image->format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
+ else if ((rBpp == 5) && (gBpp == 5) && (bBpp == 5) && (aBpp == 1)) image->format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
+ else if ((rBpp == 4) && (gBpp == 4) && (bBpp == 4) && (aBpp == 4)) image->format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
else
{
image->format = 0;
@@ -1668,7 +1668,7 @@ void ImageFlipVertical(Image *image)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
@@ -1692,7 +1692,7 @@ void ImageFlipHorizontal(Image *image)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
@@ -1737,7 +1737,7 @@ void ImageRotateCW(Image *image)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
@@ -1769,7 +1769,7 @@ void ImageRotateCCW(Image *image)
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (image->mipmaps > 1) TRACELOG(LOG_WARNING, "Image manipulation only applied to base mipmap level");
- if (image->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
+ if (image->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image manipulation not supported for compressed formats");
else
{
int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
@@ -1828,7 +1828,7 @@ void ImageColorTint(Image *image, Color color)
RL_FREE(image->data);
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -1855,7 +1855,7 @@ void ImageColorInvert(Image *image)
RL_FREE(image->data);
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -1863,7 +1863,7 @@ void ImageColorInvert(Image *image)
// Modify image color: grayscale
void ImageColorGrayscale(Image *image)
{
- ImageFormat(image, UNCOMPRESSED_GRAYSCALE);
+ ImageFormat(image, PIXELFORMAT_UNCOMPRESSED_GRAYSCALE);
}
// Modify image color: contrast
@@ -1919,7 +1919,7 @@ void ImageColorContrast(Image *image, float contrast)
RL_FREE(image->data);
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -1963,7 +1963,7 @@ void ImageColorBrightness(Image *image, int brightness)
RL_FREE(image->data);
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -1997,7 +1997,7 @@ void ImageColorReplace(Image *image, Color color, Color replace)
RL_FREE(image->data);
image->data = pixels;
- image->format = UNCOMPRESSED_R8G8B8A8;
+ image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
}
@@ -2011,18 +2011,18 @@ Color *LoadImageColors(Image image)
Color *pixels = (Color *)RL_MALLOC(image.width*image.height*sizeof(Color));
- if (image.format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "IMAGE: Pixel data retrieval not supported for compressed image formats");
+ if (image.format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "IMAGE: Pixel data retrieval not supported for compressed image formats");
else
{
- if ((image.format == UNCOMPRESSED_R32) ||
- (image.format == UNCOMPRESSED_R32G32B32) ||
- (image.format == UNCOMPRESSED_R32G32B32A32)) TRACELOG(LOG_WARNING, "IMAGE: Pixel format converted from 32bit to 8bit per channel");
+ if ((image.format == PIXELFORMAT_UNCOMPRESSED_R32) ||
+ (image.format == PIXELFORMAT_UNCOMPRESSED_R32G32B32) ||
+ (image.format == PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) TRACELOG(LOG_WARNING, "IMAGE: Pixel format converted from 32bit to 8bit per channel");
for (int i = 0, k = 0; i < image.width*image.height; i++)
{
switch (image.format)
{
- case UNCOMPRESSED_GRAYSCALE:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
{
pixels[i].r = ((unsigned char *)image.data)[i];
pixels[i].g = ((unsigned char *)image.data)[i];
@@ -2030,7 +2030,7 @@ Color *LoadImageColors(Image image)
pixels[i].a = 255;
} break;
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
pixels[i].r = ((unsigned char *)image.data)[k];
pixels[i].g = ((unsigned char *)image.data)[k];
@@ -2039,7 +2039,7 @@ Color *LoadImageColors(Image image)
k += 2;
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2049,7 +2049,7 @@ Color *LoadImageColors(Image image)
pixels[i].a = (unsigned char)((pixel & 0b0000000000000001)*255);
} break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2059,7 +2059,7 @@ Color *LoadImageColors(Image image)
pixels[i].a = 255;
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2069,7 +2069,7 @@ Color *LoadImageColors(Image image)
pixels[i].a = (unsigned char)((float)(pixel & 0b0000000000001111)*(255/15));
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
pixels[i].r = ((unsigned char *)image.data)[k];
pixels[i].g = ((unsigned char *)image.data)[k + 1];
@@ -2078,7 +2078,7 @@ Color *LoadImageColors(Image image)
k += 4;
} break;
- case UNCOMPRESSED_R8G8B8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8:
{
pixels[i].r = (unsigned char)((unsigned char *)image.data)[k];
pixels[i].g = (unsigned char)((unsigned char *)image.data)[k + 1];
@@ -2087,7 +2087,7 @@ Color *LoadImageColors(Image image)
k += 3;
} break;
- case UNCOMPRESSED_R32:
+ case PIXELFORMAT_UNCOMPRESSED_R32:
{
pixels[i].r = (unsigned char)(((float *)image.data)[k]*255.0f);
pixels[i].g = 0;
@@ -2095,7 +2095,7 @@ Color *LoadImageColors(Image image)
pixels[i].a = 255;
} break;
- case UNCOMPRESSED_R32G32B32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32:
{
pixels[i].r = (unsigned char)(((float *)image.data)[k]*255.0f);
pixels[i].g = (unsigned char)(((float *)image.data)[k + 1]*255.0f);
@@ -2104,7 +2104,7 @@ Color *LoadImageColors(Image image)
k += 3;
} break;
- case UNCOMPRESSED_R32G32B32A32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
{
pixels[i].r = (unsigned char)(((float *)image.data)[k]*255.0f);
pixels[i].g = (unsigned char)(((float *)image.data)[k]*255.0f);
@@ -2194,14 +2194,14 @@ static Vector4 *LoadImageDataNormalized(Image image)
{
Vector4 *pixels = (Vector4 *)RL_MALLOC(image.width*image.height*sizeof(Vector4));
- if (image.format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "IMAGE: Pixel data retrieval not supported for compressed image formats");
+ if (image.format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "IMAGE: Pixel data retrieval not supported for compressed image formats");
else
{
for (int i = 0, k = 0; i < image.width*image.height; i++)
{
switch (image.format)
{
- case UNCOMPRESSED_GRAYSCALE:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
{
pixels[i].x = (float)((unsigned char *)image.data)[i]/255.0f;
pixels[i].y = (float)((unsigned char *)image.data)[i]/255.0f;
@@ -2209,7 +2209,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
pixels[i].w = 1.0f;
} break;
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
pixels[i].x = (float)((unsigned char *)image.data)[k]/255.0f;
pixels[i].y = (float)((unsigned char *)image.data)[k]/255.0f;
@@ -2218,7 +2218,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
k += 2;
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2228,7 +2228,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
pixels[i].w = ((pixel & 0b0000000000000001) == 0)? 0.0f : 1.0f;
} break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2238,7 +2238,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
pixels[i].w = 1.0f;
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
unsigned short pixel = ((unsigned short *)image.data)[i];
@@ -2248,7 +2248,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
pixels[i].w = (float)(pixel & 0b0000000000001111)*(1.0f/15);
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
pixels[i].x = (float)((unsigned char *)image.data)[k]/255.0f;
pixels[i].y = (float)((unsigned char *)image.data)[k + 1]/255.0f;
@@ -2257,7 +2257,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
k += 4;
} break;
- case UNCOMPRESSED_R8G8B8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8:
{
pixels[i].x = (float)((unsigned char *)image.data)[k]/255.0f;
pixels[i].y = (float)((unsigned char *)image.data)[k + 1]/255.0f;
@@ -2266,7 +2266,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
k += 3;
} break;
- case UNCOMPRESSED_R32:
+ case PIXELFORMAT_UNCOMPRESSED_R32:
{
pixels[i].x = ((float *)image.data)[k];
pixels[i].y = 0.0f;
@@ -2274,7 +2274,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
pixels[i].w = 1.0f;
} break;
- case UNCOMPRESSED_R32G32B32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32:
{
pixels[i].x = ((float *)image.data)[k];
pixels[i].y = ((float *)image.data)[k + 1];
@@ -2283,7 +2283,7 @@ static Vector4 *LoadImageDataNormalized(Image image)
k += 3;
} break;
- case UNCOMPRESSED_R32G32B32A32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
{
pixels[i].x = ((float *)image.data)[k];
pixels[i].y = ((float *)image.data)[k + 1];
@@ -2359,7 +2359,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
switch (dst->format)
{
- case UNCOMPRESSED_GRAYSCALE:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
{
// NOTE: Calculate grayscale equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2368,7 +2368,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((unsigned char *)dst->data)[y*dst->width + x] = gray;
} break;
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
// NOTE: Calculate grayscale equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2378,7 +2378,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((unsigned char *)dst->data)[(y*dst->width + x)*2 + 1] = color.a;
} break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
// NOTE: Calculate R5G6B5 equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2390,7 +2390,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((unsigned short *)dst->data)[y*dst->width + x] = (unsigned short)r << 11 | (unsigned short)g << 5 | (unsigned short)b;
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
// NOTE: Calculate R5G5B5A1 equivalent color
Vector4 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f, (float)color.a/255.0f };
@@ -2398,12 +2398,12 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
unsigned char r = (unsigned char)(round(coln.x*31.0f));
unsigned char g = (unsigned char)(round(coln.y*31.0f));
unsigned char b = (unsigned char)(round(coln.z*31.0f));
- unsigned char a = (coln.w > ((float)UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;;
+ unsigned char a = (coln.w > ((float)PIXELFORMAT_UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;;
((unsigned short *)dst->data)[y*dst->width + x] = (unsigned short)r << 11 | (unsigned short)g << 6 | (unsigned short)b << 1 | (unsigned short)a;
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
// NOTE: Calculate R5G5B5A1 equivalent color
Vector4 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f, (float)color.a/255.0f };
@@ -2416,14 +2416,14 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((unsigned short *)dst->data)[y*dst->width + x] = (unsigned short)r << 12 | (unsigned short)g << 8 | (unsigned short)b << 4 | (unsigned short)a;
} break;
- case UNCOMPRESSED_R8G8B8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8:
{
((unsigned char *)dst->data)[(y*dst->width + x)*3] = color.r;
((unsigned char *)dst->data)[(y*dst->width + x)*3 + 1] = color.g;
((unsigned char *)dst->data)[(y*dst->width + x)*3 + 2] = color.b;
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
((unsigned char *)dst->data)[(y*dst->width + x)*4] = color.r;
((unsigned char *)dst->data)[(y*dst->width + x)*4 + 1] = color.g;
@@ -2431,7 +2431,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((unsigned char *)dst->data)[(y*dst->width + x)*4 + 3] = color.a;
} break;
- case UNCOMPRESSED_R32:
+ case PIXELFORMAT_UNCOMPRESSED_R32:
{
// NOTE: Calculate grayscale equivalent color (normalized to 32bit)
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2439,7 +2439,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((float *)dst->data)[y*dst->width + x] = coln.x*0.299f + coln.y*0.587f + coln.z*0.114f;
} break;
- case UNCOMPRESSED_R32G32B32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32:
{
// NOTE: Calculate R32G32B32 equivalent color (normalized to 32bit)
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -2448,7 +2448,7 @@ void ImageDrawPixel(Image *dst, int x, int y, Color color)
((float *)dst->data)[(y*dst->width + x)*3 + 1] = coln.y;
((float *)dst->data)[(y*dst->width + x)*3 + 2] = coln.z;
} break;
- case UNCOMPRESSED_R32G32B32A32:
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
{
// NOTE: Calculate R32G32B32A32 equivalent color (normalized to 32bit)
Vector4 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f, (float)color.a/255.0f };
@@ -2578,7 +2578,7 @@ void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color
(src.data == NULL) || (src.width == 0) || (src.height == 0)) return;
if (dst->mipmaps > 1) TRACELOG(LOG_WARNING, "Image drawing only applied to base mipmap level");
- if (dst->format >= COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image drawing not supported for compressed formats");
+ if (dst->format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) TRACELOG(LOG_WARNING, "Image drawing not supported for compressed formats");
else
{
Image srcMod = { 0 }; // Source copy (in case it was required)
@@ -2638,7 +2638,7 @@ void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color
bool blendRequired = true;
// Fast path: Avoid blend if source has no alpha to blend
- if ((tint.a == 255) && ((srcPtr->format == UNCOMPRESSED_GRAYSCALE) || (srcPtr->format == UNCOMPRESSED_R8G8B8) || (srcPtr->format == UNCOMPRESSED_R5G6B5))) blendRequired = false;
+ if ((tint.a == 255) && ((srcPtr->format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) || (srcPtr->format == PIXELFORMAT_UNCOMPRESSED_R8G8B8) || (srcPtr->format == PIXELFORMAT_UNCOMPRESSED_R5G6B5))) blendRequired = false;
int strideDst = GetPixelDataSize(dst->width, 1, dst->format);
int bytesPerPixelDst = strideDst/(dst->width);
@@ -2838,10 +2838,10 @@ RenderTexture2D LoadRenderTexture(int width, int height)
rlEnableFramebuffer(target.id);
// Create color texture (default to RGBA)
- target.texture.id = rlLoadTexture(NULL, width, height, UNCOMPRESSED_R8G8B8A8, 1);
+ target.texture.id = rlLoadTexture(NULL, width, height, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
target.texture.width = width;
target.texture.height = height;
- target.texture.format = UNCOMPRESSED_R8G8B8A8;
+ target.texture.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
target.texture.mipmaps = 1;
// Create depth renderbuffer/texture
@@ -2910,7 +2910,7 @@ Image GetTextureData(Texture2D texture)
{
Image image = { 0 };
- if (texture.format < COMPRESSED_DXT1_RGB)
+ if (texture.format < PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
image.data = rlReadTexturePixels(texture);
@@ -2925,7 +2925,7 @@ Image GetTextureData(Texture2D texture)
// NOTE: Data retrieved on OpenGL ES 2.0 should be RGBA,
// coming from FBO color buffer attachment, but it seems
// original texture format is retrieved on RPI...
- image.format = UNCOMPRESSED_R8G8B8A8;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
#endif
TRACELOG(LOG_INFO, "TEXTURE: [ID %i] Pixel data retrieved successfully", texture.id);
}
@@ -2944,7 +2944,7 @@ Image GetScreenData(void)
image.width = GetScreenWidth();
image.height = GetScreenHeight();
image.mipmaps = 1;
- image.format = UNCOMPRESSED_R8G8B8A8;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
image.data = rlReadScreenPixels(image.width, image.height);
return image;
@@ -3646,9 +3646,9 @@ Color GetPixelColor(void *srcPtr, int format)
switch (format)
{
- case UNCOMPRESSED_GRAYSCALE: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], 255 }; break;
- case UNCOMPRESSED_GRAY_ALPHA: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1] }; break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], 255 }; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1] }; break;
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
col.r = (unsigned char)((((unsigned short *)srcPtr)[0] >> 11)*255/31);
col.g = (unsigned char)(((((unsigned short *)srcPtr)[0] >> 5) & 0b0000000000111111)*255/63);
@@ -3656,7 +3656,7 @@ Color GetPixelColor(void *srcPtr, int format)
col.a = 255;
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
col.r = (unsigned char)((((unsigned short *)srcPtr)[0] >> 11)*255/31);
col.g = (unsigned char)(((((unsigned short *)srcPtr)[0] >> 6) & 0b0000000000011111)*255/31);
@@ -3664,7 +3664,7 @@ Color GetPixelColor(void *srcPtr, int format)
col.a = (((unsigned short *)srcPtr)[0] & 0b0000000000000001)? 255 : 0;
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
col.r = (unsigned char)((((unsigned short *)srcPtr)[0] >> 12)*255/15);
col.g = (unsigned char)(((((unsigned short *)srcPtr)[0] >> 8) & 0b0000000000001111)*255/15);
@@ -3672,11 +3672,11 @@ Color GetPixelColor(void *srcPtr, int format)
col.a = (unsigned char)((((unsigned short *)srcPtr)[0] & 0b0000000000001111)*255/15);
} break;
- case UNCOMPRESSED_R8G8B8A8: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1], ((unsigned char *)srcPtr)[2], ((unsigned char *)srcPtr)[3] }; break;
- case UNCOMPRESSED_R8G8B8: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1], ((unsigned char *)srcPtr)[2], 255 }; break;
- // TODO: case UNCOMPRESSED_R32: break;
- // TODO: case UNCOMPRESSED_R32G32B32: break;
- // TODO: case UNCOMPRESSED_R32G32B32A32: break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1], ((unsigned char *)srcPtr)[2], ((unsigned char *)srcPtr)[3] }; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: col = (Color){ ((unsigned char *)srcPtr)[0], ((unsigned char *)srcPtr)[1], ((unsigned char *)srcPtr)[2], 255 }; break;
+ // TODO: case PIXELFORMAT_UNCOMPRESSED_R32: break;
+ // TODO: case PIXELFORMAT_UNCOMPRESSED_R32G32B32: break;
+ // TODO: case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: break;
default: break;
}
@@ -3688,7 +3688,7 @@ void SetPixelColor(void *dstPtr, Color color, int format)
{
switch (format)
{
- case UNCOMPRESSED_GRAYSCALE:
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
{
// NOTE: Calculate grayscale equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -3697,7 +3697,7 @@ void SetPixelColor(void *dstPtr, Color color, int format)
((unsigned char *)dstPtr)[0] = gray;
} break;
- case UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
{
// NOTE: Calculate grayscale equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -3707,7 +3707,7 @@ void SetPixelColor(void *dstPtr, Color color, int format)
((unsigned char *)dstPtr)[1] = color.a;
} break;
- case UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
{
// NOTE: Calculate R5G6B5 equivalent color
Vector3 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f };
@@ -3719,7 +3719,7 @@ void SetPixelColor(void *dstPtr, Color color, int format)
((unsigned short *)dstPtr)[0] = (unsigned short)r << 11 | (unsigned short)g << 5 | (unsigned short)b;
} break;
- case UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
{
// NOTE: Calculate R5G5B5A1 equivalent color
Vector4 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f, (float)color.a/255.0f };
@@ -3727,12 +3727,12 @@ void SetPixelColor(void *dstPtr, Color color, int format)
unsigned char r = (unsigned char)(round(coln.x*31.0f));
unsigned char g = (unsigned char)(round(coln.y*31.0f));
unsigned char b = (unsigned char)(round(coln.z*31.0f));
- unsigned char a = (coln.w > ((float)UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;;
+ unsigned char a = (coln.w > ((float)PIXELFORMAT_UNCOMPRESSED_R5G5B5A1_ALPHA_THRESHOLD/255.0f))? 1 : 0;;
((unsigned short *)dstPtr)[0] = (unsigned short)r << 11 | (unsigned short)g << 6 | (unsigned short)b << 1 | (unsigned short)a;
} break;
- case UNCOMPRESSED_R4G4B4A4:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
{
// NOTE: Calculate R5G5B5A1 equivalent color
Vector4 coln = { (float)color.r/255.0f, (float)color.g/255.0f, (float)color.b/255.0f, (float)color.a/255.0f };
@@ -3745,14 +3745,14 @@ void SetPixelColor(void *dstPtr, Color color, int format)
((unsigned short *)dstPtr)[0] = (unsigned short)r << 12 | (unsigned short)g << 8 | (unsigned short)b << 4 | (unsigned short)a;
} break;
- case UNCOMPRESSED_R8G8B8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8:
{
((unsigned char *)dstPtr)[0] = color.r;
((unsigned char *)dstPtr)[1] = color.g;
((unsigned char *)dstPtr)[2] = color.b;
} break;
- case UNCOMPRESSED_R8G8B8A8:
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
{
((unsigned char *)dstPtr)[0] = color.r;
((unsigned char *)dstPtr)[1] = color.g;
@@ -3773,27 +3773,27 @@ int GetPixelDataSize(int width, int height, int format)
switch (format)
{
- case UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
- case UNCOMPRESSED_GRAY_ALPHA:
- case UNCOMPRESSED_R5G6B5:
- case UNCOMPRESSED_R5G5B5A1:
- case UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
- case UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
- case UNCOMPRESSED_R8G8B8: bpp = 24; break;
- case UNCOMPRESSED_R32: bpp = 32; break;
- case UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
- case UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
- case COMPRESSED_DXT1_RGB:
- case COMPRESSED_DXT1_RGBA:
- case COMPRESSED_ETC1_RGB:
- case COMPRESSED_ETC2_RGB:
- case COMPRESSED_PVRT_RGB:
- case COMPRESSED_PVRT_RGBA: bpp = 4; break;
- case COMPRESSED_DXT3_RGBA:
- case COMPRESSED_DXT5_RGBA:
- case COMPRESSED_ETC2_EAC_RGBA:
- case COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
- case COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
+ case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
+ case PIXELFORMAT_COMPRESSED_DXT1_RGB:
+ case PIXELFORMAT_COMPRESSED_DXT1_RGBA:
+ case PIXELFORMAT_COMPRESSED_ETC1_RGB:
+ case PIXELFORMAT_COMPRESSED_ETC2_RGB:
+ case PIXELFORMAT_COMPRESSED_PVRT_RGB:
+ case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+ case PIXELFORMAT_COMPRESSED_DXT3_RGBA:
+ case PIXELFORMAT_COMPRESSED_DXT5_RGBA:
+ case PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
+ case PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
+ case PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
default: break;
}
@@ -3803,8 +3803,8 @@ int GetPixelDataSize(int width, int height, int format)
// if texture is smaller, minimum dataSize is 8 or 16
if ((width < 4) && (height < 4))
{
- if ((format >= COMPRESSED_DXT1_RGB) && (format < COMPRESSED_DXT3_RGBA)) dataSize = 8;
- else if ((format >= COMPRESSED_DXT3_RGBA) && (format < COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
+ if ((format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
+ else if ((format >= PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
}
return dataSize;
@@ -3902,7 +3902,7 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
memcpy(image.data, fileDataPtr, dataSize);
- image.format = UNCOMPRESSED_R5G6B5;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
}
else if (ddsHeader->ddspf.flags == 0x41) // with alpha channel
{
@@ -3923,7 +3923,7 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
((unsigned short *)image.data)[i] += alpha;
}
- image.format = UNCOMPRESSED_R5G5B5A1;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
}
else if (ddsHeader->ddspf.aBitMask == 0xf000) // 4bit alpha
{
@@ -3942,7 +3942,7 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
((unsigned short *)image.data)[i] += alpha;
}
- image.format = UNCOMPRESSED_R4G4B4A4;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
}
}
}
@@ -3953,7 +3953,7 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
memcpy(image.data, fileDataPtr, dataSize);
- image.format = UNCOMPRESSED_R8G8B8;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
}
else if (ddsHeader->ddspf.flags == 0x41 && ddsHeader->ddspf.rgbBitCount == 32) // DDS_RGBA, no compressed
{
@@ -3974,7 +3974,7 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
((unsigned char *)image.data)[i + 2] = blue;
}
- image.format = UNCOMPRESSED_R8G8B8A8;
+ image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
}
else if (((ddsHeader->ddspf.flags == 0x04) || (ddsHeader->ddspf.flags == 0x05)) && (ddsHeader->ddspf.fourCC > 0)) // Compressed
{
@@ -3992,11 +3992,11 @@ static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
{
case FOURCC_DXT1:
{
- if (ddsHeader->ddspf.flags == 0x04) image.format = COMPRESSED_DXT1_RGB;
- else image.format = COMPRESSED_DXT1_RGBA;
+ if (ddsHeader->ddspf.flags == 0x04) image.format = PIXELFORMAT_COMPRESSED_DXT1_RGB;
+ else image.format = PIXELFORMAT_COMPRESSED_DXT1_RGBA;
} break;
- case FOURCC_DXT3: image.format = COMPRESSED_DXT3_RGBA; break;
- case FOURCC_DXT5: image.format = COMPRESSED_DXT5_RGBA; break;
+ case FOURCC_DXT3: image.format = PIXELFORMAT_COMPRESSED_DXT3_RGBA; break;
+ case FOURCC_DXT5: image.format = PIXELFORMAT_COMPRESSED_DXT5_RGBA; break;
default: break;
}
}
@@ -4079,9 +4079,9 @@ static Image LoadPKM(const unsigned char *fileData, unsigned int fileSize)
memcpy(image.data, fileDataPtr, dataSize);
- if (pkmHeader->format == 0) image.format = COMPRESSED_ETC1_RGB;
- else if (pkmHeader->format == 1) image.format = COMPRESSED_ETC2_RGB;
- else if (pkmHeader->format == 3) image.format = COMPRESSED_ETC2_EAC_RGBA;
+ if (pkmHeader->format == 0) image.format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
+ else if (pkmHeader->format == 1) image.format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
+ else if (pkmHeader->format == 3) image.format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
}
}
@@ -4162,9 +4162,9 @@ static Image LoadKTX(const unsigned char *fileData, unsigned int fileSize)
memcpy(image.data, fileDataPtr, dataSize);
- if (ktxHeader->glInternalFormat == 0x8D64) image.format = COMPRESSED_ETC1_RGB;
- else if (ktxHeader->glInternalFormat == 0x9274) image.format = COMPRESSED_ETC2_RGB;
- else if (ktxHeader->glInternalFormat == 0x9278) image.format = COMPRESSED_ETC2_EAC_RGBA;
+ if (ktxHeader->glInternalFormat == 0x8D64) image.format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
+ else if (ktxHeader->glInternalFormat == 0x9274) image.format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
+ else if (ktxHeader->glInternalFormat == 0x9278) image.format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
}
}
@@ -4358,24 +4358,24 @@ static Image LoadPVR(const unsigned char *fileData, unsigned int fileSize)
image.mipmaps = pvrHeader->numMipmaps;
// Check data format
- if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 0)) && (pvrHeader->channelDepth[0] == 8)) image.format = UNCOMPRESSED_GRAYSCALE;
- else if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 'a')) && ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8))) image.format = UNCOMPRESSED_GRAY_ALPHA;
+ if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 0)) && (pvrHeader->channelDepth[0] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
+ else if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 'a')) && ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8))) image.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
else if ((pvrHeader->channels[0] == 'r') && (pvrHeader->channels[1] == 'g') && (pvrHeader->channels[2] == 'b'))
{
if (pvrHeader->channels[3] == 'a')
{
- if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 5) && (pvrHeader->channelDepth[2] == 5) && (pvrHeader->channelDepth[3] == 1)) image.format = UNCOMPRESSED_R5G5B5A1;
- else if ((pvrHeader->channelDepth[0] == 4) && (pvrHeader->channelDepth[1] == 4) && (pvrHeader->channelDepth[2] == 4) && (pvrHeader->channelDepth[3] == 4)) image.format = UNCOMPRESSED_R4G4B4A4;
- else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8) && (pvrHeader->channelDepth[3] == 8)) image.format = UNCOMPRESSED_R8G8B8A8;
+ if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 5) && (pvrHeader->channelDepth[2] == 5) && (pvrHeader->channelDepth[3] == 1)) image.format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
+ else if ((pvrHeader->channelDepth[0] == 4) && (pvrHeader->channelDepth[1] == 4) && (pvrHeader->channelDepth[2] == 4) && (pvrHeader->channelDepth[3] == 4)) image.format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
+ else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8) && (pvrHeader->channelDepth[3] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
}
else if (pvrHeader->channels[3] == 0)
{
- if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 6) && (pvrHeader->channelDepth[2] == 5)) image.format = UNCOMPRESSED_R5G6B5;
- else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8)) image.format = UNCOMPRESSED_R8G8B8;
+ if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 6) && (pvrHeader->channelDepth[2] == 5)) image.format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
+ else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
}
}
- else if (pvrHeader->channels[0] == 2) image.format = COMPRESSED_PVRT_RGB;
- else if (pvrHeader->channels[0] == 3) image.format = COMPRESSED_PVRT_RGBA;
+ else if (pvrHeader->channels[0] == 2) image.format = PIXELFORMAT_COMPRESSED_PVRT_RGB;
+ else if (pvrHeader->channels[0] == 3) image.format = PIXELFORMAT_COMPRESSED_PVRT_RGBA;
fileDataPtr += pvrHeader->metaDataSize; // Skip meta data header
@@ -4383,15 +4383,15 @@ static Image LoadPVR(const unsigned char *fileData, unsigned int fileSize)
int bpp = 0;
switch (image.format)
{
- case UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
- case UNCOMPRESSED_GRAY_ALPHA:
- case UNCOMPRESSED_R5G5B5A1:
- case UNCOMPRESSED_R5G6B5:
- case UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
- case UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
- case UNCOMPRESSED_R8G8B8: bpp = 24; break;
- case COMPRESSED_PVRT_RGB:
- case COMPRESSED_PVRT_RGBA: bpp = 4; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+ case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+ case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+ case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+ case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+ case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+ case PIXELFORMAT_COMPRESSED_PVRT_RGB:
+ case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
default: break;
}
@@ -4470,8 +4470,8 @@ static Image LoadASTC(const unsigned char *fileData, unsigned int fileSize)
memcpy(image.data, fileDataPtr, dataSize);
- if (bpp == 8) image.format = COMPRESSED_ASTC_4x4_RGBA;
- else if (bpp == 2) image.format = COMPRESSED_ASTC_8x8_RGBA;
+ if (bpp == 8) image.format = PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA;
+ else if (bpp == 2) image.format = PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA;
}
else TRACELOG(LOG_WARNING, "IMAGE: ASTC block size configuration not supported");
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-15 19:37:40 +0000