update upstream

geralis.a · geralis.a · commit 4cef79ce03e4 · 2025-07-16T13:40:21.000+03:00
diff --git a/src/raylib/config.h b/src/raylib/config.h
@@ -189,7 +189,7 @@
 //------------------------------------------------------------------------------------
 // Module: rtextures - Configuration Flags
 //------------------------------------------------------------------------------------
-// Selecte desired fileformats to be supported for image data loading
+// Selected desired fileformats to be supported for image data loading
 #define SUPPORT_FILEFORMAT_PNG      1
 //#define SUPPORT_FILEFORMAT_BMP      1
 //#define SUPPORT_FILEFORMAT_TGA      1
diff --git a/src/raylib/external/dr_flac.h b/src/raylib/external/dr_flac.h
diff --git a/src/raylib/external/dr_mp3.h b/src/raylib/external/dr_mp3.h
diff --git a/src/raylib/external/dr_wav.h b/src/raylib/external/dr_wav.h
diff --git a/src/raylib/external/glfw/src/mappings.h b/src/raylib/external/glfw/src/mappings.h
diff --git a/src/raylib/platforms/rcore_desktop_sdl.c b/src/raylib/platforms/rcore_desktop_sdl.c
@@ -424,6 +424,8 @@ void ClosePlatform(void);                                    // Close platform
 
 static KeyboardKey ConvertScancodeToKey(SDL_Scancode sdlScancode);  // Help convert SDL scancodes to raylib key
 
+static int GetCodepointNextSDL(const char *text, int *codepointSize); // Get next codepoint in a byte sequence and bytes processed
+
 //----------------------------------------------------------------------------------
 // Module Functions Declaration
 //----------------------------------------------------------------------------------
@@ -1601,13 +1603,18 @@ void PollInputEvents(void)
             {
                 // NOTE: event.text.text data comes an UTF-8 text sequence but we register codepoints (int)
 
-                int codepointSize = 0;
-
                 // Check if there is space available in the queue
                 if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
                 {
                     // Add character (codepoint) to the queue
-                    CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = GetCodepointNext(event.text.text, &codepointSize);
+                    #if defined(PLATFORM_DESKTOP_SDL3)
+                    unsigned int textLen = strlen(event.text.text);
+                    unsigned int codepoint = (unsigned int)SDL_StepUTF8(&event.text.text, textLen);
+                    #else
+                    int codepointSize = 0;
+                    int codepoint = GetCodepointNextSDL(event.text.text, &codepointSize);
+                    #endif
+                    CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = codepoint;
                     CORE.Input.Keyboard.charPressedQueueCount++;
                 }
             } break;
@@ -2093,4 +2100,42 @@ static KeyboardKey ConvertScancodeToKey(SDL_Scancode sdlScancode)
 
     return KEY_NULL; // No equivalent key in Raylib
 }
-// EOF
+
+// Get next codepoint in a byte sequence and bytes processed
+static int GetCodepointNextSDL(const char *text, int *codepointSize)
+{
+    const char *ptr = text;
+    int codepoint = 0x3f;       // Codepoint (defaults to '?')
+    *codepointSize = 1;
+
+    // Get current codepoint and bytes processed
+    if (0xf0 == (0xf8 & ptr[0]))
+    {
+        // 4 byte UTF-8 codepoint
+        if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
+        codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]);
+        *codepointSize = 4;
+    }
+    else if (0xe0 == (0xf0 & ptr[0]))
+    {
+        // 3 byte UTF-8 codepoint */
+        if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
+        codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]);
+        *codepointSize = 3;
+    }
+    else if (0xc0 == (0xe0 & ptr[0]))
+    {
+        // 2 byte UTF-8 codepoint
+        if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } // 10xxxxxx checks
+        codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]);
+        *codepointSize = 2;
+    }
+    else if (0x00 == (0x80 & ptr[0]))
+    {
+        // 1 byte UTF-8 codepoint
+        codepoint = ptr[0];
+        *codepointSize = 1;
+    }
+
+    return codepoint;
+}
diff --git a/src/raylib/raudio.c b/src/raylib/raudio.c
@@ -81,7 +81,7 @@
     #include "utils.h"          // Required for: fopen() Android mapping
 #endif
 
-#if defined(SUPPORT_MODULE_RAUDIO)
+#if defined(SUPPORT_MODULE_RAUDIO) || defined(RAUDIO_STANDALONE)
 
 #if defined(_WIN32)
 // To avoid conflicting windows.h symbols with raylib, some flags are defined
@@ -1037,6 +1037,8 @@ void UnloadSoundAlias(Sound alias)
 }
 
 // Update sound buffer with new data
+// NOTE 1: data format must match sound.stream.sampleSize
+// NOTE 2: frameCount must not exceed sound.frameCount
 void UpdateSound(Sound sound, const void *data, int frameCount)
 {
     if (sound.stream.buffer != NULL)
@@ -1869,6 +1871,7 @@ void SeekMusicStream(Music music, float position)
 void UpdateMusicStream(Music music)
 {
     if (music.stream.buffer == NULL) return;
+    if (!music.stream.buffer->playing) return;
 
     ma_mutex_lock(&AUDIO.System.lock);
 
diff --git a/src/raylib/raylib.h b/src/raylib/raylib.h
@@ -1424,8 +1424,8 @@ RLAPI bool IsTextureValid(Texture2D texture);
 RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
 RLAPI bool IsRenderTextureValid(RenderTexture2D target);                                                 // Check if a render texture is valid (loaded in GPU)
 RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
-RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
-RLAPI void UpdateTextureRec(Texture2D texture, rlRectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data
+RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data (pixels should be able to fill texture)
+RLAPI void UpdateTextureRec(Texture2D texture, rlRectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data (pixels and rec should fit in texture)
 
 // Texture configuration functions
 RLAPI void GenTextureMipmaps(Texture2D *texture);                                                        // Generate GPU mipmaps for a texture
@@ -1646,7 +1646,7 @@ RLAPI Sound LoadSound(const char *fileName);                          // Load so
 RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
 RLAPI Sound LoadSoundAlias(Sound source);                             // Create a new sound that shares the same sample data as the source sound, does not own the sound data
 RLAPI bool IsSoundValid(Sound sound);                                 // Checks if a sound is valid (data loaded and buffers initialized)
-RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
+RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data (data and frame count should fit in sound)
 RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
 RLAPI void UnloadSound(Sound sound);                                  // Unload sound
 RLAPI void UnloadSoundAlias(Sound alias);                             // Unload a sound alias (does not deallocate sample data)
diff --git a/src/raylib/rcore.c b/src/raylib/rcore.c
@@ -3757,7 +3757,8 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
 // Scan all files and directories recursively from a base path
 static void ScanDirectoryFilesRecursively(const char *basePath, FilePathList *files, const char *filter)
 {
-    static char path[MAX_FILEPATH_LENGTH] = { 0 };
+    // WARNING: Path can not be static or it will be reused between recursive function calls!
+    char path[MAX_FILEPATH_LENGTH] = { 0 };
     memset(path, 0, MAX_FILEPATH_LENGTH);
 
     struct dirent *dp = NULL;
diff --git a/src/raylib/rlgl.h b/src/raylib/rlgl.h
@@ -1885,7 +1885,7 @@ void rlActiveDrawBuffers(int count)
 
     if (count > 0)
     {
-        if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8");
+        if (count > 8) TRACELOG(RL_LOG_WARNING, "GL: Max color buffers limited to 8");
         else
         {
             unsigned int buffers[8] = {
@@ -1902,7 +1902,7 @@ void rlActiveDrawBuffers(int count)
             glDrawBuffers(count, buffers);
         }
     }
-    else TRACELOG(LOG_WARNING, "GL: One color buffer active by default");
+    else TRACELOG(RL_LOG_WARNING, "GL: One color buffer active by default");
 #endif
 }
 
@@ -2219,10 +2219,10 @@ static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint
         default: break;
     }
 
-    TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message);
-    TRACELOG(LOG_WARNING, "    > Type: %s", msgType);
-    TRACELOG(LOG_WARNING, "    > Source = %s", msgSource);
-    TRACELOG(LOG_WARNING, "    > Severity = %s", msgSeverity);
+    TRACELOG(RL_LOG_WARNING, "GL: OpenGL debug message: %s", message);
+    TRACELOG(RL_LOG_WARNING, "    > Type: %s", msgType);
+    TRACELOG(RL_LOG_WARNING, "    > Source = %s", msgSource);
+    TRACELOG(RL_LOG_WARNING, "    > Severity = %s", msgSeverity);
 }
 #endif
 
@@ -4178,6 +4178,9 @@ unsigned int rlCompileShader(const char *shaderCode, int type)
             RL_FREE(log);
         }
 
+        // Unload object allocated by glCreateShader(),
+        // despite failing in the compilation process
+        glDeleteShader(shader);
         shader = 0;
     }
     else
diff --git a/src/raylib/rmodels.c b/src/raylib/rmodels.c
@@ -5577,7 +5577,7 @@ static Model LoadGLTF(const char *fileName)
                         }
                         else TRACELOG(LOG_WARNING, "MODEL: [%s] Normal attribute data format not supported, use vec3 float", fileName);
                     }
-                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_tangent)   // TANGENT, vec3, float
+                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_tangent)   // TANGENT, vec4, float, w is tangent basis sign
                     {
                         cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data;
 
@@ -5593,10 +5593,10 @@ static Model LoadGLTF(const char *fileName)
                             float *tangents = model.meshes[meshIndex].tangents;
                             for (unsigned int k = 0; k < attribute->count; k++)
                             {
-                                Vector3 tt = Vector3Transform((Vector3){ tangents[3*k], tangents[3*k+1], tangents[3*k+2] }, worldMatrix);
-                                tangents[3*k] = tt.x;
-                                tangents[3*k+1] = tt.y;
-                                tangents[3*k+2] = tt.z;
+                                Vector3 tt = Vector3Transform((Vector3){ tangents[4*k], tangents[4*k+1], tangents[4*k+2] }, worldMatrix);
+                                tangents[4*k] = tt.x;
+                                tangents[4*k+1] = tt.y;
+                                tangents[4*k+2] = tt.z;
                             }
                         }
                         else TRACELOG(LOG_WARNING, "MODEL: [%s] Tangent attribute data format not supported, use vec4 float", fileName);
diff --git a/src/raylib/rtextures.c b/src/raylib/rtextures.c
@@ -2217,9 +2217,9 @@ void ImageBlurGaussian(Image *image, int blurSize)
         else if (pixelsCopy1[i].w <= 255.0f)
         {
             float alpha = (float)pixelsCopy1[i].w/255.0f;
-            pixels[i].r = (unsigned char)((float)pixelsCopy1[i].x/alpha);
-            pixels[i].g = (unsigned char)((float)pixelsCopy1[i].y/alpha);
-            pixels[i].b = (unsigned char)((float)pixelsCopy1[i].z/alpha);
+            pixels[i].r = (unsigned char)fminf((float)pixelsCopy1[i].x/alpha, 255.0);
+            pixels[i].g = (unsigned char)fminf((float)pixelsCopy1[i].y/alpha, 255.0);
+            pixels[i].b = (unsigned char)fminf((float)pixelsCopy1[i].z/alpha, 255.0);
             pixels[i].a = (unsigned char) pixelsCopy1[i].w;
         }
     }
@@ -3565,34 +3565,43 @@ void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color co
     int dx = x2 - x1;
     int dy = y2 - y1;
 
-    // Draw the main line between (x1, y1) and (x2, y2)
-    ImageDrawLine(dst, x1, y1, x2, y2, color);
-
     // Determine if the line is more horizontal or vertical
     if ((dx != 0) && (abs(dy/dx) < 1))
     {
         // Line is more horizontal
-        // Calculate half the width of the line
-        int wy = (thick - 1)*(int)sqrtf((float)(dx*dx + dy*dy))/(2*abs(dx));
 
-        // Draw additional lines above and below the main line
-        for (int i = 1; i <= wy; i++)
+        // How many additional lines to draw
+        int wy = thick - 1;
+
+        // Draw the main line and lower half
+        for (int i = 0; i <= ((wy+1)/2); i++)
+        {
+            ImageDrawLine(dst, x1, y1 + i, x2, y2 + i, color);
+        }
+
+        // Draw the upper half
+        for (int i = 1; i <= (wy/2); i++)
         {
-            ImageDrawLine(dst, x1, y1 - i, x2, y2 - i, color); // Draw above the main line
-            ImageDrawLine(dst, x1, y1 + i, x2, y2 + i, color); // Draw below the main line
+            ImageDrawLine(dst, x1, y1 - i, x2, y2 - i, color);
         }
     }
     else if (dy != 0)
     {
         // Line is more vertical or perfectly horizontal
-        // Calculate half the width of the line
-        int wx = (thick - 1)*(int)sqrtf((float)(dx*dx + dy*dy))/(2*abs(dy));
 
-        // Draw additional lines to the left and right of the main line
-        for (int i = 1; i <= wx; i++)
+        // How many additional lines to draw
+        int wx = thick - 1;
+
+        //Draw the main line and right half
+        for (int i = 0; i <= ((wx+1)/2); i++)
+        {
+            ImageDrawLine(dst, x1 + i, y1, x2 + i, y2, color);
+        }
+
+        // Draw the left half
+        for (int i = 1; i <= (wx/2); i++)
         {
-            ImageDrawLine(dst, x1 - i, y1, x2 - i, y2, color); // Draw left of the main line
-            ImageDrawLine(dst, x1 + i, y1, x2 + i, y2, color); // Draw right of the main line
+            ImageDrawLine(dst, x1 - i, y1, x2 - i, y2, color);
         }
     }
 }
@@ -4338,14 +4347,17 @@ void UnloadRenderTexture(RenderTexture2D target)
 }
 
 // Update GPU texture with new data
-// NOTE: pixels data must match texture.format
+// NOTE 1: pixels data must match texture.format
+// NOTE 2: pixels data must contain at least as many pixels as texture
 void UpdateTexture(Texture2D texture, const void *pixels)
 {
     rlUpdateTexture(texture.id, 0, 0, texture.width, texture.height, texture.format, pixels);
 }
 
 // Update GPU texture rectangle with new data
-// NOTE: pixels data must match texture.format
+// NOTE 1: pixels data must match texture.format
+// NOTE 2: pixels data must contain as many pixels as rec contains
+// NOTE 3: rec must fit completely within texture's width and height
 void UpdateTextureRec(Texture2D texture, rlRectangle rec, const void *pixels)
 {
     rlUpdateTexture(texture.id, (int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, texture.format, pixels);
@@ -5397,7 +5409,7 @@ static float HalfToFloat(unsigned short x)
     } uni;
 
     const unsigned int e = (x & 0x7c00) >> 10; // Exponent
-    const unsigned int m = (x & 0x03cc) << 13; // Mantissa
+    const unsigned int m = (x & 0x03ff) << 13; // Mantissa
     uni.fm = (float)m;
     const unsigned int v = uni.ui >> 23; // Evil log2 bit hack to count leading zeros in denormalized format
     uni.ui = (x & 0x8000) << 16 | (e != 0)*((e + 112) << 23 | m) | ((e == 0)&(m != 0))*((v - 37) << 23 | ((m << (150 - v)) & 0x007fe000)); // sign : normalized : denormalized
diff --git a/tools/wrapper/api/raylib.json b/tools/wrapper/api/raylib.json
@@ -8529,7 +8529,7 @@
     },
     {
       "name": "UpdateTexture",
-      "description": "Update GPU texture with new data",
+      "description": "Update GPU texture with new data (pixels should be able to fill texture)",
       "returnType": "void",
       "params": [
         {
@@ -8544,7 +8544,7 @@
     },
     {
       "name": "UpdateTextureRec",
-      "description": "Update GPU texture rectangle with new data",
+      "description": "Update GPU texture rectangle with new data (pixels and rec should fit in texture)",
       "returnType": "void",
       "params": [
         {
@@ -11511,7 +11511,7 @@
     },
     {
       "name": "UpdateSound",
-      "description": "Update sound buffer with new data",
+      "description": "Update sound buffer with new data (data and frame count should fit in sound)",
       "returnType": "void",
       "params": [
         {
diff --git a/tools/wrapper/snippets/raylib_funcs.nim b/tools/wrapper/snippets/raylib_funcs.nim
@@ -212,14 +212,14 @@ proc loadRenderTexture*(width: int32, height: int32): RenderTexture2D =
   if not isRenderTextureValid(result): raiseRaylibError("Failed to load RenderTexture")
 
 proc updateTexture*[T: Pixel](texture: Texture2D, pixels: openArray[T]) =
-  ## Update GPU texture with new data
+  ## Update GPU texture with new data (pixels should be able to fill texture)
   assert texture.format == pixelKind(T), "Incompatible texture format"
   assert getPixelDataSize(texture.width, texture.height, texture.format) == pixels.len*sizeof(T),
       "Mismatch between expected and actual data size"
   updateTextureImpl(texture, cast[pointer](pixels))
 
 proc updateTexture*[T: Pixel](texture: Texture2D, rec: Rectangle, pixels: openArray[T]) =
-  ## Update GPU texture rectangle with new data
+  ## Update GPU texture rectangle with new data (pixels and rec should fit in texture)
   assert texture.format == pixelKind(T), "Incompatible texture format"
   assert getPixelDataSize(rec.width.int32, rec.height.int32, texture.format) == pixels.len*sizeof(T),
       "Mismatch between expected and actual data size"
@@ -336,7 +336,7 @@ proc loadSoundFromWave*(wave: Wave): Sound =
   if not isSoundValid(result): raiseRaylibError("Failed to load Sound from Wave")
 
 proc updateSound*[T](sound: var Sound, data: openArray[T]) =
-  ## Update sound buffer with new data
+  ## Update sound buffer with new data (data and frame count should fit in sound)
   updateSoundImpl(sound, cast[ptr UncheckedArray[T]](data), data.len.int32)
 
 proc loadMusicStream*(fileName: string): Music =
diff --git a/update_bindings.nims b/update_bindings.nims
@@ -5,7 +5,7 @@ const
   PkgDir = thisDir()
   RaylibDir = PkgDir / "raylib"
   RaylibGit = "https://github.com/raysan5/raylib.git"
-  RayLatestCommit = "4bc8d3761c48f4dcf56f126640da8f3567dc516b"
+  RayLatestCommit = "e00c5eb8b1068b1fb3c1c52fc00967749f2a990a"
   DocsDir = PkgDir / "docs"
   ToolsDir = PkgDir / "tools"
   ApiDir = ToolsDir / "wrapper/api"

Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@`
`81`	`81`	`#include "utils.h" // Required for: fopen() Android mapping`
`82`	`82`	`#endif`
`83`	`83`
`84`		`-#if defined(SUPPORT_MODULE_RAUDIO)`
	`84`	`+#if defined(SUPPORT_MODULE_RAUDIO) \|\| defined(RAUDIO_STANDALONE)`
`85`	`85`
`86`	`86`	`#if defined(_WIN32)`
`87`	`87`	`// To avoid conflicting windows.h symbols with raylib, some flags are defined`
`@@ -1037,6 +1037,8 @@ void UnloadSoundAlias(Sound alias)`
`1037`	`1037`	`}`
`1038`	`1038`
`1039`	`1039`	`// Update sound buffer with new data`
	`1040`	`+// NOTE 1: data format must match sound.stream.sampleSize`
	`1041`	`+// NOTE 2: frameCount must not exceed sound.frameCount`
`1040`	`1042`	`void UpdateSound(Sound sound, const void *data, int frameCount)`
`1041`	`1043`	`{`
`1042`	`1044`	`if (sound.stream.buffer != NULL)`
`@@ -1869,6 +1871,7 @@ void SeekMusicStream(Music music, float position)`
`1869`	`1871`	`void UpdateMusicStream(Music music)`
`1870`	`1872`	`{`
`1871`	`1873`	`if (music.stream.buffer == NULL) return;`
	`1874`	`+ if (!music.stream.buffer->playing) return;`
`1872`	`1875`
`1873`	`1876`	`ma_mutex_lock(&AUDIO.System.lock);`
`1874`	`1877`
Original file line number	Diff line number	Diff line change
`@@ -3757,7 +3757,8 @@ static void ScanDirectoryFiles(const char basePath, FilePathList files, const`
`3757`	`3757`	`// Scan all files and directories recursively from a base path`
`3758`	`3758`	`static void ScanDirectoryFilesRecursively(const char basePath, FilePathList files, const char *filter)`
`3759`	`3759`	`{`
`3760`		`- static char path[MAX_FILEPATH_LENGTH] = { 0 };`
	`3760`	`+ // WARNING: Path can not be static or it will be reused between recursive function calls!`
	`3761`	`+ char path[MAX_FILEPATH_LENGTH] = { 0 };`
`3761`	`3762`	`memset(path, 0, MAX_FILEPATH_LENGTH);`
`3762`	`3763`
`3763`	`3764`	`struct dirent *dp = NULL;`
Original file line number	Diff line number	Diff line change
`@@ -1885,7 +1885,7 @@ void rlActiveDrawBuffers(int count)`
`1885`	`1885`
`1886`	`1886`	`if (count > 0)`
`1887`	`1887`	`{`
`1888`		`- if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8");`
	`1888`	`+ if (count > 8) TRACELOG(RL_LOG_WARNING, "GL: Max color buffers limited to 8");`
`1889`	`1889`	`else`
`1890`	`1890`	`{`
`1891`	`1891`	`unsigned int buffers[8] = {`
`@@ -1902,7 +1902,7 @@ void rlActiveDrawBuffers(int count)`
`1902`	`1902`	`glDrawBuffers(count, buffers);`
`1903`	`1903`	`}`
`1904`	`1904`	`}`
`1905`		`- else TRACELOG(LOG_WARNING, "GL: One color buffer active by default");`
	`1905`	`+ else TRACELOG(RL_LOG_WARNING, "GL: One color buffer active by default");`
`1906`	`1906`	`#endif`
`1907`	`1907`	`}`
`1908`	`1908`
`@@ -2219,10 +2219,10 @@ static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint`
`2219`	`2219`	`default: break;`
`2220`	`2220`	`}`
`2221`	`2221`
`2222`		`- TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message);`
`2223`		`- TRACELOG(LOG_WARNING, " > Type: %s", msgType);`
`2224`		`- TRACELOG(LOG_WARNING, " > Source = %s", msgSource);`
`2225`		`- TRACELOG(LOG_WARNING, " > Severity = %s", msgSeverity);`
	`2222`	`+ TRACELOG(RL_LOG_WARNING, "GL: OpenGL debug message: %s", message);`
	`2223`	`+ TRACELOG(RL_LOG_WARNING, " > Type: %s", msgType);`
	`2224`	`+ TRACELOG(RL_LOG_WARNING, " > Source = %s", msgSource);`
	`2225`	`+ TRACELOG(RL_LOG_WARNING, " > Severity = %s", msgSeverity);`
`2226`	`2226`	`}`
`2227`	`2227`	`#endif`
`2228`	`2228`
`@@ -4178,6 +4178,9 @@ unsigned int rlCompileShader(const char *shaderCode, int type)`
`4178`	`4178`	`RL_FREE(log);`
`4179`	`4179`	`}`
`4180`	`4180`
	`4181`	`+ // Unload object allocated by glCreateShader(),`
	`4182`	`+ // despite failing in the compilation process`
	`4183`	`+ glDeleteShader(shader);`
`4181`	`4184`	`shader = 0;`
`4182`	`4185`	`}`
`4183`	`4186`	`else`