Merge pull request #1 from raysan5/master

Update to latest master

.gitignore

@@ -33,6 +33,7 @@ Thumbs.db
 [Bb]in
 [Dd]ebug/
 [Dd]ebug.win32/
+[Dd]ebug.DLL/
 *.sbr
 *.sdf
 obj/

.travis.yml

@@ -120,7 +120,6 @@ script:
       -DBUILD_EXAMPLES=ON -DBUILD_GAMES=ON
       -DUSE_EXTERNAL_GLFW=$USE_EXTERNAL_GLFW
       -DUSE_WAYLAND=$WAYLAND
-      -DUSE_OPENAL_BACKEND=$OPENAL
       -DINCLUDE_EVERYTHING=ON
       ..
   - $RUNNER make VERBOSE=1

CONTRIBUTING.md

@@ -7,7 +7,7 @@ Use your best judgement, and feel free to propose changes to this document in a
 
 ### raylib philosophy
 
- - raylib is a tool to LEARN videogames programming, every single function in raylib should be a tutorial on itself.
+ - raylib is a tool to enjoy videogames programming, every single function in raylib should be a tutorial on itself.
  - raylib is SIMPLE and EASY-TO-USE, I tried to keep it compact with a small set of functions, if a function is too complex or is not clearly useful, better not to include it.
  - raylib is open source and free; educators and institutions can use this tool to TEACH videogames programming completely by free.
  - raylib is collaborative; contribution of tutorials / code-examples / bugs-solving / code-comments are highly appreciated.
@@ -59,15 +59,23 @@ To open new issue for raylib (bug, enhancement, discussion...), just try to foll
 
 Some people ported raylib to other languages in form of bindings or wrappers to the library, here is a list with the ones I'm aware of:
 
- - [raylib C/C++ version (default)](https://github.com/raysan5/raylib)
+ - [raylib](https://github.com/raysan5/raylib) : raylib **C/C++** version (default)
- - [raylib Lua binding](https://github.com/raysan5/raylib-lua)
+ - [raylib-lua](https://github.com/raysan5/raylib-lua) : raylib **Lua** binding
- - [raylib Go binding](https://github.com/gen2brain/raylib-go)
+ - [raylib-go](https://github.com/gen2brain/raylib-go) : raylib **Go** binding
- - [raylib Nim binding](https://gitlab.com/define-private-public/raylib-Nim)
+ - [raylib-Nim](https://gitlab.com/define-private-public/raylib-Nim) : raylib **Nim** binding
- - [raylib Crystal binding](https://gitlab.com/Zatherz/cray) 
+ - [cray](https://gitlab.com/Zatherz/cray) - raylib **Crystal** binding
- - [raylib Perl wrapper](https://metacpan.org/pod/Graphics::Raylib) 
+ - [Graphics::Raylib](https://metacpan.org/pod/Graphics::Raylib) : raylib **Perl** wrapper
- - raylib Pascal binding with custom IDE (closed-source)
+ - [raylib-pascal](https://github.com/drezgames/raylib-pascal) - raylib **Pascal** binding
- - [raylib flat-assembler Usage example](http://forum.raylib.com/index.php?p=/discussion/comment/425/#Comment_425)
+ - [Raylib-cs](https://github.com/ChrisDill/Raylib-cs) : raylib **C#** binding
- - [raylib COBOL Usage example](https://github.com/Martinfx/Cobol/tree/master/OpenCobol/Games/raylib)
+ - [RaylibSharp](https://github.com/TheLumaio/RaylibSharp) : raylib **C#** binding
+ - [raylib-ruby-ffi](https://github.com/D3nX/raylib-ruby-ffi) : raylib **Ruby** binding
+ - [raylib-rs](https://github.com/deltaphc/raylib-rs) : raylib **Rust** binding
+ - [raylib-rust](https://github.com/dtcristo/raylib-rust) : raylib **Rust** binding
+ - [raylib-py](https://github.com/overdev/raylib-py) : raylib **Python** binding
+ - [raylib-haskell](https://github.com/DevJac/raylib-haskell) : raylib **Haskell** binding
+ - [raylib-java]() : raylib **Java** binding
+ - *[raylib flat-assembler Usage example](http://forum.raylib.com/index.php?p=/discussion/comment/425/#Comment_425)*
+ - *[raylib COBOL Usage example](https://github.com/Martinfx/Cobol/tree/master/OpenCobol/Games/raylib)*
  
 Usually, raylib bindings follow the convention: `raylib-{language}`
 
@@ -79,7 +87,7 @@ provide the icon/logo for that new language binding.
 If you have any doubt, don't hesitate to [contact me](mailto:ray@raylib.com)!.
 You can write me a direct mail but you can also contact me on the following networks:
 
- - [raylib forum](http://forum.raylib.com/) - A good place for discussions or to ask for help.
+ - [raylib reddit](https://www.reddit.com/r/raylib/) - A good place for discussions or to ask for help.
  - [raylib Discord](https://discord.gg/VkzNHUE) - A direct communication channel for project discussions.
  - [raylib twitter](https://twitter.com/raysan5) - My personal twitter account, I usually post about raylib, you can send me PMs.
  - [raylib web](http://www.raylib.com/) - On top-right corner there is a bunch of networks where you can find me.

HELPME.md

@@ -18,7 +18,7 @@ with a small [donation](http://www.raylib.com/helpme.html) or contributing with
 raylib philosophy
 ------------------
 
-   * raylib is a tool to LEARN videogames programming, every single function in raylib should be a tutorial on itself.
+   * raylib is a tool to enjoy videogames programming, every single function in raylib should be a tutorial on itself.
    * raylib is SIMPLE and EASY-TO-USE, I tried to keep it compact with a small set of functions, if a function is too complex or has not a clear usefulness, better not to include it.
    * raylib is open source and free; educators and institutions can use this tool to TEACH videogames programming completely by free. 
    * raylib is collaborative; contribution of tutorials / code-examples / bugs-solving / code-comments are highly appreciated.

LICENSE.md

@@ -7,7 +7,7 @@ source code
 raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, 
 BSD-like license that allows static linking with closed source software:
 	
-Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
+Copyright (c) 2013-2019 Ramon Santamaria (@raysan5)
 
 This software is provided "as-is", without any express or implied warranty. In no event 
 will the authors be held liable for any damages arising from the use of this software.
@@ -41,9 +41,9 @@ The following fonts [provided with raylib](https://github.com/raysan5/raylib/tre
 2d art
 ------
 
-[scarfy spritesheet](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/scarfy.png) and [fudesumi image](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/fudesumi.png) have been created by [Eiden Marsal](https://www.artstation.com/artist/marshall_z) and licensed as [Creative Commons Attribution-NonCommercial 3.0](https://creativecommons.org/licenses/by-nc/3.0/legalcode)
+[scarfy spritesheet](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/scarfy.png) and [fudesumi image](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/fudesumi.png) have been created by [Eiden Marsal](https://www.artstation.com/artist/marshall_z) and are licensed as [Creative Commons Attribution-NonCommercial 3.0](https://creativecommons.org/licenses/by-nc/3.0/legalcode)
 
 3d models
 ---------
 
-[medieval city 3d models and textures](https://github.com/raysan5/raylib/tree/master/examples/models/resources/medieval) have been created by Alberto Cano and licensed as [Creative Commons Attribution-NonCommercial 4.0](https://creativecommons.org/licenses/by-nc/4.0/legalcode)
+[medieval city 3d models and textures](https://github.com/raysan5/raylib/tree/master/examples/models/resources/medieval) have been created by Alberto Cano and are licensed as [Creative Commons Attribution-NonCommercial 4.0](https://creativecommons.org/licenses/by-nc/4.0/legalcode)

README.md

@@ -1,12 +1,12 @@
 <img align="left" src="https://github.com/raysan5/raylib/blob/master/logo/raylib_256x256.png" width=256>
 
-**raylib is a simple and easy-to-use library to learn videogames programming.**
+**raylib is a simple and easy-to-use library to enjoy videogames programming.**
 
 raylib is highly inspired by Borland BGI graphics lib and by XNA framework.
 
 raylib could be useful for prototyping, tools development, graphic applications, embedded systems and education.
 
-NOTE for ADVENTURERS: raylib is a programming library to learn videogames programming; 
+NOTE for ADVENTURERS: raylib is a programming library to enjoy videogames programming; 
 no fancy interface, no visual helpers, no auto-debugging... just coding in the most 
 pure spartan-programmers way. Are you ready to learn? Jump to [code examples!](http://www.raylib.com/examples.html)
 
@@ -22,7 +22,7 @@ features
   - Multiple platforms supported: **Windows, Linux, MacOS, Android... and many more!**
   - Written in plain C code (C99) in PascalCase/camelCase notation
   - Hardware accelerated with OpenGL (**1.1, 2.1, 3.3 or ES 2.0**)
-  - **Unique OpenGL abstraction layer** (usable as standalone module): [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.c)
+  - **Unique OpenGL abstraction layer** (usable as standalone module): [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.h)
   - Multiple Fonts formats supported (XNA fonts, AngelCode fonts, TTF)
   - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
   - **Full 3d support** for 3d Shapes, Models, Billboards, Heightmaps and more! 
@@ -31,7 +31,7 @@ features
   - **Powerful math module** for Vector, Matrix and Quaternion operations: [raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h)
   - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
   - **VR stereo rendering** support with configurable HMD device parameters
-  - Bindings to **Lua** ([raylib-lua](https://github.com/raysan5/raylib-lua)), **Go** ([raylib-go](https://github.com/gen2brain/raylib-go)) and more!
+  - Bindings to **Lua** ([raylib-lua](https://github.com/raysan5/raylib-lua)), **Go** ([raylib-go](https://github.com/gen2brain/raylib-go)) and [more](https://github.com/raysan5/raylib/blob/master/CONTRIBUTING.md#raylib-bindings)!
 
 raylib uses on its [core](https://github.com/raysan5/raylib/blob/master/src/core.c) module the outstanding [GLFW3](http://www.glfw.org/) library, embedded inside raylib in the form of [rglfw](https://github.com/raysan5/raylib/blob/master/src/rglfw.c) module, avoiding that way external dependencies.
 

examples/models/models_yaw_pitch_roll.c

@@ -5,8 +5,7 @@
 *   This example has been created using raylib 1.8 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Example based on Berni work on Raspberry Pi:
+*   Example based on Berni work on Raspberry Pi.
-*   http://forum.raylib.com/index.php?p=/discussion/124/line-versus-triangle-drawing-order
 *
 *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
 *

examples/others/iqm_loader/riqm.h

@@ -64,29 +64,32 @@ typedef struct Pose {
 } Pose;
 
 typedef struct Animation {
-    int jointCount;
+    int jointCount;         // Number of joints (bones)
-    Joint *joints;      // NOTE: Joints in anims do not have names
+    Joint *joints;          // Joints array
+                            // NOTE: Joints in anims do not have names
 
-    int frameCount;
+    int frameCount;         // Number of animation frames
-    float framerate;
+    float framerate;        // Frame change speed
 
-    Pose **framepose;
+    Pose **framepose;       // Poses array by frame (and one pose by joint)
 } Animation;
 
 // Animated Model type
 typedef struct AnimatedModel {
-    int meshCount;
+    Matrix transform;       // Local transform matrix
-    Mesh *mesh;
     
-    int materialCount;
+    int meshCount;          // Number of meshes
-    int *meshMaterialId;
+    Mesh *meshes;           // Meshes array
-    Material *materials;
 
-    int jointCount;
+    int materialCount;      // Number of materials
-    Joint *joints;
+    Material *materials;    // Materials array
     
-    Pose *basepose;
+    int *meshMaterialId;    // Mesh materials ids
-    Matrix transform;
+
+    // Animation required data
+    int jointCount;         // Number of joints (and keyposes)
+    Joint *joints;          // Mesh joints (bones)
+    Pose *basepose;         // Mesh base-poses by joint
 } AnimatedModel;
 
 //----------------------------------------------------------------------------------
@@ -233,7 +236,7 @@ AnimatedModel LoadAnimatedModel(const char *filename)
 {
     AnimatedModel out = LoadIQM(filename);
 
-    for (int i = 0; i < out.meshCount; i++) rlLoadMesh(&out.mesh[i], false);
+    for (int i = 0; i < out.meshCount; i++) rlLoadMesh(&out.meshes[i], false);
 
     out.transform = MatrixIdentity();
     out.meshMaterialId = malloc(sizeof(int)*out.meshCount);
@@ -258,7 +261,7 @@ AnimatedModel AnimatedModelAddTexture(AnimatedModel model, const char *filename)
     return model;
 }
 
-// Set the material for a mesh
+// Set the material for a meshes
 AnimatedModel SetMeshMaterial(AnimatedModel model, int meshid, int textureid)
 {
     if (meshid > model.meshCount)
@@ -466,9 +469,9 @@ void UnloadAnimatedModel(AnimatedModel model)
     free(model.joints);
     free(model.basepose);
 
-    for (int i = 0; i < model.meshCount; i++) rlUnloadMesh(&model.mesh[i]);
+    for (int i = 0; i < model.meshCount; i++) rlUnloadMesh(&model.meshes[i]);
 
-    free(model.mesh);
+    free(model.meshes);
 }
 
 // Unload animation
@@ -515,9 +518,9 @@ void AnimateModel(AnimatedModel model, Animation anim, int frame)
         int wcounter = 0;
         int weightId = 0;
 
-        for (int i = 0; i < model.mesh[m].vertexCount; i++)
+        for (int i = 0; i < model.meshes[m].vertexCount; i++)
         {
-            weightId = model.mesh[m].weightId[wcounter];
+            weightId = model.meshes[m].weightId[wcounter];
             baset = model.basepose[weightId].translation;
             baser = model.basepose[weightId].rotation;
             bases = model.basepose[weightId].scale;
@@ -526,23 +529,23 @@ void AnimateModel(AnimatedModel model, Animation anim, int frame)
             outs = anim.framepose[frame][weightId].scale;
 
             // vertices
-            // NOTE: We use mesh.baseVertices (default position) to calculate mesh.vertices (animated position)
+            // NOTE: We use meshes.baseVertices (default position) to calculate meshes.vertices (animated position)
-            outv = (Vector3){ model.mesh[m].baseVertices[vcounter], model.mesh[m].baseVertices[vcounter + 1], model.mesh[m].baseVertices[vcounter + 2] };
+            outv = (Vector3){ model.meshes[m].baseVertices[vcounter], model.meshes[m].baseVertices[vcounter + 1], model.meshes[m].baseVertices[vcounter + 2] };
             outv = Vector3MultiplyV(outv, outs);
             outv = Vector3Subtract(outv, baset);
             outv = Vector3RotateByQuaternion(outv, QuaternionMultiply(outr, QuaternionInvert(baser)));
             outv = Vector3Add(outv, outt);
-            model.mesh[m].vertices[vcounter] = outv.x;
+            model.meshes[m].vertices[vcounter] = outv.x;
-            model.mesh[m].vertices[vcounter + 1] = outv.y;
+            model.meshes[m].vertices[vcounter + 1] = outv.y;
-            model.mesh[m].vertices[vcounter + 2] = outv.z;
+            model.meshes[m].vertices[vcounter + 2] = outv.z;
 
             // normals
-            // NOTE: We use mesh.baseNormals (default normal) to calculate mesh.normals (animated normals)
+            // NOTE: We use meshes.baseNormals (default normal) to calculate meshes.normals (animated normals)
-            outn = (Vector3){ model.mesh[m].baseNormals[vcounter], model.mesh[m].baseNormals[vcounter + 1], model.mesh[m].baseNormals[vcounter + 2] };
+            outn = (Vector3){ model.meshes[m].baseNormals[vcounter], model.meshes[m].baseNormals[vcounter + 1], model.meshes[m].baseNormals[vcounter + 2] };
             outn = Vector3RotateByQuaternion(outn, QuaternionMultiply(outr, QuaternionInvert(baser)));
-            model.mesh[m].normals[vcounter] = outn.x;
+            model.meshes[m].normals[vcounter] = outn.x;
-            model.mesh[m].normals[vcounter + 1] = outn.y;
+            model.meshes[m].normals[vcounter + 1] = outn.y;
-            model.mesh[m].normals[vcounter + 2] = outn.z;
+            model.meshes[m].normals[vcounter + 2] = outn.z;
             vcounter += 3;
             wcounter += 4;
         }
@@ -563,7 +566,7 @@ void DrawAnimatedModelEx(AnimatedModel model, Vector3 position, Vector3 rotation
 {
     if (model.materialCount == 0)
     {
-        TraceLog(LOG_WARNING,"No materials set, can't draw animated mesh\n");
+        TraceLog(LOG_WARNING,"No materials set, can't draw animated meshes\n");
         return;
     }
 
@@ -576,9 +579,9 @@ void DrawAnimatedModelEx(AnimatedModel model, Vector3 position, Vector3 rotation
 
     for (int i = 0; i < model.meshCount; i++)
     {
-        rlUpdateMesh(model.mesh[i], 0, model.mesh[i].vertexCount);      // Update vertex position
+        rlUpdateMesh(model.meshes[i], 0, model.meshes[i].vertexCount);      // Update vertex position
-        rlUpdateMesh(model.mesh[i], 2, model.mesh[i].vertexCount);      // Update vertex normals
+        rlUpdateMesh(model.meshes[i], 2, model.meshes[i].vertexCount);      // Update vertex normals
-        rlDrawMesh(model.mesh[i], model.materials[model.meshMaterialId[i]], model.transform);   // Draw mesh
+        rlDrawMesh(model.meshes[i], model.materials[model.meshMaterialId[i]], model.transform);   // Draw meshes
     }
 }
 
@@ -632,7 +635,7 @@ static AnimatedModel LoadIQM(const char *filename)
     fread(imesh, sizeof(IQMMesh)*iqm.num_meshes, 1, iqmFile);
 
     model.meshCount = iqm.num_meshes;
-    model.mesh = malloc(sizeof(Mesh)*iqm.num_meshes);
+    model.meshes = malloc(sizeof(Mesh)*iqm.num_meshes);
     
     char name[MESH_NAME_LENGTH];
 
@@ -640,21 +643,21 @@ static AnimatedModel LoadIQM(const char *filename)
     {
         fseek(iqmFile,iqm.ofs_text+imesh[i].name,SEEK_SET);
         fread(name, sizeof(char)*MESH_NAME_LENGTH, 1, iqmFile);         // Mesh name not used...
-        model.mesh[i].vertexCount = imesh[i].num_vertexes;
+        model.meshes[i].vertexCount = imesh[i].num_vertexes;
         
-        model.mesh[i].baseVertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);     // Default IQM base position
+        model.meshes[i].baseVertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);     // Default IQM base position
-        model.mesh[i].baseNormals = malloc(sizeof(float)*imesh[i].num_vertexes*3);      // Default IQM base normal
+        model.meshes[i].baseNormals = malloc(sizeof(float)*imesh[i].num_vertexes*3);      // Default IQM base normal
         
-        model.mesh[i].texcoords = malloc(sizeof(float)*imesh[i].num_vertexes*2);
+        model.meshes[i].texcoords = malloc(sizeof(float)*imesh[i].num_vertexes*2);
-        model.mesh[i].weightId = malloc(sizeof(int)*imesh[i].num_vertexes*4);
+        model.meshes[i].weightId = malloc(sizeof(int)*imesh[i].num_vertexes*4);
-        model.mesh[i].weightBias = malloc(sizeof(float)*imesh[i].num_vertexes*4);
+        model.meshes[i].weightBias = malloc(sizeof(float)*imesh[i].num_vertexes*4);
         
-        model.mesh[i].triangleCount = imesh[i].num_triangles;
+        model.meshes[i].triangleCount = imesh[i].num_triangles;
-        model.mesh[i].indices = malloc(sizeof(unsigned short)*imesh[i].num_triangles*3);
+        model.meshes[i].indices = malloc(sizeof(unsigned short)*imesh[i].num_triangles*3);
         
-        // What we actually process for rendering, should be updated transforming mesh.vertices and mesh.normals
+        // What we actually process for rendering, should be updated transforming meshes.vertices and meshes.normals
-        model.mesh[i].vertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);     
+        model.meshes[i].vertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);     
-        model.mesh[i].normals = malloc(sizeof(float)*imesh[i].num_vertexes*3);
+        model.meshes[i].normals = malloc(sizeof(float)*imesh[i].num_vertexes*3);
     }
 
     // tris
@@ -669,9 +672,9 @@ static AnimatedModel LoadIQM(const char *filename)
         for (int i = imesh[m].first_triangle; i < imesh[m].first_triangle+imesh[m].num_triangles; i++)
         {
             // IQM triangles are stored counter clockwise, but raylib sets opengl to clockwise drawing, so we swap them around
-            model.mesh[m].indices[tcounter+2] = tri[i].vertex[0] - imesh[m].first_vertex;
+            model.meshes[m].indices[tcounter+2] = tri[i].vertex[0] - imesh[m].first_vertex;
-            model.mesh[m].indices[tcounter+1] = tri[i].vertex[1] - imesh[m].first_vertex;
+            model.meshes[m].indices[tcounter+1] = tri[i].vertex[1] - imesh[m].first_vertex;
-            model.mesh[m].indices[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex;
+            model.meshes[m].indices[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex;
             tcounter += 3;
         }
     }
@@ -696,8 +699,8 @@ static AnimatedModel LoadIQM(const char *filename)
                     int vcounter = 0;
                     for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++)
                     {
-                        model.mesh[m].vertices[vcounter] = vertex[i];
+                        model.meshes[m].vertices[vcounter] = vertex[i];
-                        model.mesh[m].baseVertices[vcounter] = vertex[i];
+                        model.meshes[m].baseVertices[vcounter] = vertex[i];
                         vcounter++;
                     }
                 }
@@ -713,8 +716,8 @@ static AnimatedModel LoadIQM(const char *filename)
                     int vcounter = 0;
                     for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++)
                     {
-                        model.mesh[m].normals[vcounter] = normal[i];
+                        model.meshes[m].normals[vcounter] = normal[i];
-                        model.mesh[m].baseNormals[vcounter] = normal[i];
+                        model.meshes[m].baseNormals[vcounter] = normal[i];
                         vcounter++;
                     }
                 }
@@ -730,7 +733,7 @@ static AnimatedModel LoadIQM(const char *filename)
                     int vcounter = 0;
                     for (int i = imesh[m].first_vertex*2; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*2; i++)
                     {
-                        model.mesh[m].texcoords[vcounter] = text[i];
+                        model.meshes[m].texcoords[vcounter] = text[i];
                         vcounter++;
                     }
                 }
@@ -746,7 +749,7 @@ static AnimatedModel LoadIQM(const char *filename)
                     int vcounter = 0;
                     for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++)
                     {
-                        model.mesh[m].weightId[vcounter] = blendi[i];
+                        model.meshes[m].weightId[vcounter] = blendi[i];
                         vcounter++;
                     }
                 }
@@ -762,7 +765,7 @@ static AnimatedModel LoadIQM(const char *filename)
                     int vcounter = 0;
                     for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++)
                     {
-                        model.mesh[m].weightBias[vcounter] = blendw[i]/255.0f;
+                        model.meshes[m].weightBias[vcounter] = blendw[i]/255.0f;
                         vcounter++;
                     }
                 }

examples/physac/physics_demo.c

@@ -17,6 +17,7 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
+#define PHYSAC_NO_THREADS
 #include "physac.h"
 
 int main()
@@ -54,6 +55,8 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         // Delay initialization of variables due to physics reset async
+        RunPhysicsStep();
+
         if (needsReset)
         {
             floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
@@ -61,6 +64,8 @@ int main()
 
             circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
             circle->enabled = false;
+
+            needsReset = false;
         }
 
         // Reset physics input
@@ -134,4 +139,3 @@ int main()
 
     return 0;
 }
-

examples/physac/physics_friction.c

@@ -17,6 +17,7 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
+#define PHYSAC_NO_THREADS
 #include "physac.h"
 
 int main()
@@ -71,6 +72,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        RunPhysicsStep();
+
         if (IsKeyPressed('R'))    // Reset physics input
         {
             // Reset dynamic physics bodies position, velocity and rotation
@@ -141,4 +144,3 @@ int main()
 
     return 0;
 }
-

examples/physac/physics_movement.c

@@ -17,6 +17,7 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
+#define PHYSAC_NO_THREADS
 #include "physac.h"
 
 #define VELOCITY    0.5f
@@ -64,6 +65,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        RunPhysicsStep();
+
         if (IsKeyPressed('R'))    // Reset physics input
         {
             // Reset movement physics body position, velocity and rotation
@@ -127,4 +130,3 @@ int main()
 
     return 0;
 }
-

examples/physac/physics_restitution.c

@@ -17,6 +17,7 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
+#define PHYSAC_NO_THREADS
 #include "physac.h"
 
 int main()
@@ -50,6 +51,9 @@ int main()
     circleC->restitution = 1;
     
     SetTargetFPS(60);
+
+    // Restitution demo needs a very tiny physics time step for a proper simulation
+    SetPhysicsTimeStep(1.0/60.0/100 * 1000);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -57,6 +61,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        RunPhysicsStep();
+
         if (IsKeyPressed('R'))    // Reset physics input
         {
             // Reset circles physics bodies position and velocity
@@ -120,4 +126,3 @@ int main()
 
     return 0;
 }
-

examples/physac/physics_shatter.c

@@ -17,6 +17,7 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
+#define PHYSAC_NO_THREADS
 #include "physac.h"
 
 int main()
@@ -48,12 +49,15 @@ int main()
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
+        RunPhysicsStep();
+
         //----------------------------------------------------------------------------------
         // Delay initialization of variables due to physics reset asynchronous
         if (needsReset)
         {
             // Create random polygon physics body to shatter
             CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
+            needsReset = false;
         }
 
         if (IsKeyPressed('R'))    // Reset physics input
@@ -118,4 +122,3 @@ int main()
 
     return 0;
 }
-

examples/text/text_font_sdf.c

@@ -29,19 +29,18 @@ int main()
     fontDefault.baseSize = 16;
     fontDefault.charsCount = 95;
     // Parameters > font size: 16, no chars array provided (0), chars count: 95 (autogenerate chars array)
-    fontDefault.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, 0, 95, false);
+    fontDefault.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, 0, 95, FONT_DEFAULT);
     // Parameters > chars count: 95, font size: 16, chars padding in image: 4 px, pack method: 0 (default)
     Image atlas = GenImageFontAtlas(fontDefault.chars, 95, 16, 4, 0);
     fontDefault.texture = LoadTextureFromImage(atlas);
     UnloadImage(atlas);
     
     // SDF font generation from TTF font
-    // NOTE: SDF chars data is generated with LoadFontData(), it's just a bool option
     Font fontSDF = { 0 };
     fontSDF.baseSize = 16;
     fontSDF.charsCount = 95;
     // Parameters > font size: 16, no chars array provided (0), chars count: 0 (defaults to 95)
-    fontSDF.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, 0, 0, true);
+    fontSDF.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, 0, 0, FONT_SDF);
     // Parameters > chars count: 95, font size: 16, chars padding in image: 0 px, pack method: 1 (Skyline algorythm)
     atlas = GenImageFontAtlas(fontSDF.chars, 95, 16, 0, 1);
     fontSDF.texture = LoadTextureFromImage(atlas);

examples/textures/textures_image_npatch.c

@@ -0,0 +1,108 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - N-patch drawing
+*
+*   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
+*
+*   This example has been created using raylib 2.0 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - N-patch drawing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D nPatchTexture = LoadTexture("resources/ninepatch_button.png");
+    Vector2 mousePosition;
+    Vector2 origin = {0.0f, 0.0f};
+
+    // The location and size of the n-patches.
+    Rectangle dstRec1 = {480.0f, 160.0f, 32.0f, 32.0f};
+    Rectangle dstRec2 = {160.0f, 160.0f, 32.0f, 32.0f};
+    Rectangle dstRecH = {160.0f, 93.0f, 32.0f, 32.0f};   // this rec's height is ignored
+    Rectangle dstRecV = {92.0f, 160.0f, 32.0f, 32.0f};   // this rec's width is ignored
+
+    // A 9-patch (NPT_9PATCH) changes its sizes in both axis
+    NPatchInfo ninePatchInfo1 = {(Rectangle){0.0f, 0.0f, 64.0f, 64.0f}, 12, 40, 12, 12, NPT_9PATCH };
+    NPatchInfo ninePatchInfo2 = {(Rectangle){0.0f, 128.0f, 64.0f, 64.0f}, 16, 16, 16, 16, NPT_9PATCH };
+    // A horizontal 3-patch (NPT_3PATCH_HORIZONTAL) changes its sizes along the x axis only
+    NPatchInfo h3PatchInfo = {(Rectangle){0.0f,  64.0f, 64.0f, 64.0f}, 8, 8, 8, 8, NPT_3PATCH_HORIZONTAL };
+    // A vertical 3-patch (NPT_3PATCH_VERTICAL) changes its sizes along the y axis only
+    NPatchInfo v3PatchInfo = {(Rectangle){0.0f, 192.0f, 64.0f, 64.0f}, 6, 6, 6, 6, NPT_3PATCH_VERTICAL };
+    
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        mousePosition = GetMousePosition();
+        // resize the n-patches based on mouse position.
+        dstRec1.width = mousePosition.x - dstRec1.x;
+        dstRec1.height = mousePosition.y - dstRec1.y;
+        dstRec2.width = mousePosition.x - dstRec2.x;
+        dstRec2.height = mousePosition.y - dstRec2.y;
+        dstRecH.width = mousePosition.x - dstRecH.x;
+        dstRecV.height = mousePosition.y - dstRecV.y;
+
+        // set a minimum width and/or height
+        if (dstRec1.width < 1.0f) dstRec1.width = 1.0f;
+        if (dstRec1.width > 300.0f) dstRec1.width = 300.0f;
+        if (dstRec1.height < 1.0f) dstRec1.height = 1.0f;
+        if (dstRec2.width < 1.0f) dstRec2.width = 1.0f;
+        if (dstRec2.width > 300.0f) dstRec2.width = 300.0f;
+        if (dstRec2.height < 1.0f) dstRec2.height = 1.0f;
+        if (dstRecH.width < 1.0f) dstRecH.width = 1.0f;
+        if (dstRecV.height < 1.0f) dstRecV.height = 1.0f;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // Draw the n-patches
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo2, dstRec2, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo1, dstRec1, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, h3PatchInfo, dstRecH, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, v3PatchInfo, dstRecV, origin, 0.0f, WHITE);
+            
+            // Draw the source texture
+            DrawRectangleLines( 5, 88, 74, 266, BLUE);
+            DrawTexture(nPatchTexture, 10, 93, WHITE);
+            DrawText("TEXTURE", 15, 360, 10, DARKGRAY);
+
+            DrawRectangle( 10, 10, 250, 73, Fade(SKYBLUE, 0.5));
+            DrawRectangleLines( 10, 10, 250, 73, BLUE);
+
+            DrawText("9-Patch and 3-Patch example", 20, 20, 10, BLACK);
+            DrawText("  Move the mouse to stretch or", 40, 40, 10, DARKGRAY);
+            DrawText("  shrink the n-patches.", 40, 60, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(nPatchTexture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_image_processing.c

@@ -59,7 +59,7 @@ int main()
 
     Rectangle selectRecs[NUM_PROCESSES];
     
-    for (int i = 0; i < NUM_PROCESSES; i++) selectRecs[i] = (Rectangle){ 40, 50 + 32*i, 150, 30 };
+    for (int i = 0; i < NUM_PROCESSES; i++) selectRecs[i] = (Rectangle){ 40.0f, (float)(50 + 32*i), 150.0f, 30.0f };
     
     SetTargetFPS(60);
     //---------------------------------------------------------------------------------------
@@ -122,8 +122,8 @@ int main()
             for (int i = 0; i < NUM_PROCESSES; i++)
             {
                 DrawRectangleRec(selectRecs[i], (i == currentProcess) ? SKYBLUE : LIGHTGRAY);
-                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, (i == currentProcess) ? BLUE : GRAY);
+                DrawRectangleLines((int)selectRecs[i].x, (int) selectRecs[i].y, (int) selectRecs[i].width, (int) selectRecs[i].height, (i == currentProcess) ? BLUE : GRAY);
-                DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)/2, selectRecs[i].y + 11, 10, (i == currentProcess) ? DARKBLUE : DARKGRAY);
+                DrawText( processText[i], (int)( selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)/2), (int) selectRecs[i].y + 11, 10, (i == currentProcess) ? DARKBLUE : DARKGRAY);
             }
 
             DrawTexture(texture, screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, WHITE);

examples/textures/textures_image_text.c

@@ -26,12 +26,12 @@ int main()
     Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
 
     // Draw over image using custom font
-    ImageDrawTextEx(&parrots, (Vector2){ 20, 20 }, font, "[Parrots font drawing]", font.baseSize, 0, WHITE);
+    ImageDrawTextEx(&parrots, (Vector2){ 20.0f, 20.0f }, font, "[Parrots font drawing]", (float)font.baseSize, 0.0f, RED);
 
     Texture2D texture = LoadTextureFromImage(parrots);  // Image converted to texture, uploaded to GPU memory (VRAM)
     UnloadImage(parrots);   // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
     
-    Vector2 position = { screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 20 };
+    Vector2 position = { (float)(screenWidth/2 - texture.width/2), (float)(screenHeight/2 - texture.height/2 - 20) };
     
     bool showFont = false;
 
@@ -60,7 +60,7 @@ int main()
                 
                 // Draw text directly using sprite font
                 DrawTextEx(font, "[Parrots font drawing]", (Vector2){ position.x + 20, 
-                           position.y + 20 + 280 }, font.baseSize, 0, WHITE);
+                           position.y + 20 + 280 }, (float)font.baseSize, 0.0f, WHITE);
             }
             else DrawTexture(font.texture, screenWidth/2 - font.texture.width/2, 50, BLACK);
             

examples/textures/textures_particles_blending.c

@@ -42,7 +42,7 @@ int main()
         mouseTail[i].color = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 };
         mouseTail[i].alpha = 1.0f;
         mouseTail[i].size = (float)GetRandomValue(1, 30)/20.0f;
-        mouseTail[i].rotation = GetRandomValue(0, 360);
+        mouseTail[i].rotation = (float)GetRandomValue(0, 360);
         mouseTail[i].active = false;
     }
     
@@ -107,9 +107,9 @@ int main()
                 // Draw active particles
                 for (int i = 0; i < MAX_PARTICLES; i++)
                 {
-                    if (mouseTail[i].active) DrawTexturePro(smoke, (Rectangle){ 0, 0, smoke.width, smoke.height }, 
+                    if (mouseTail[i].active) DrawTexturePro(smoke, (Rectangle){ 0.0f, 0.0f, (float)smoke.width, (float)smoke.height }, 
                                                            (Rectangle){ mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size },
-                                                           (Vector2){ smoke.width*mouseTail[i].size/2, smoke.height*mouseTail[i].size/2 }, mouseTail[i].rotation,
+                                                           (Vector2){ (float)(smoke.width*mouseTail[i].size/2.0f), (float)(smoke.height*mouseTail[i].size/2.0f) }, mouseTail[i].rotation,
                                                            Fade(mouseTail[i].color, mouseTail[i].alpha));
                 }
             

examples/textures/textures_srcrec_dstrec.c

@@ -27,13 +27,13 @@ int main()
     int frameHeight = scarfy.height;
     
     // NOTE: Source rectangle (part of the texture to use for drawing)
-    Rectangle sourceRec = { 0, 0, frameWidth, frameHeight };
+    Rectangle sourceRec = { 0.0f, 0.0f, (float)frameWidth, (float)frameHeight };
 
     // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
-    Rectangle destRec = { screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2 };
+    Rectangle destRec = { (float)screenWidth/2, (float)screenHeight/2, (float)frameWidth*2, (float)frameHeight*2 };
 
     // NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size
-    Vector2 origin = { frameWidth, frameHeight };
+    Vector2 origin = { (float)frameWidth, (float)frameHeight };
     
     int rotation = 0;
     
@@ -59,10 +59,10 @@ int main()
             // destRec defines the rectangle where our texture part will fit (scaling it to fit)
             // origin defines the point of the texture used as reference for rotation and scaling
             // rotation defines the texture rotation (using origin as rotation point)
-            DrawTexturePro(scarfy, sourceRec, destRec, origin, rotation, WHITE);
+            DrawTexturePro(scarfy, sourceRec, destRec, origin, (float)rotation, WHITE);
 
-            DrawLine(destRec.x, 0, destRec.x, screenHeight, GRAY);
+            DrawLine((int) destRec.x, 0, (int) destRec.x, screenHeight, GRAY);
-            DrawLine(0, destRec.y, screenWidth, destRec.y, GRAY);
+            DrawLine(0, (int)destRec.y, screenWidth, (int)destRec.y, GRAY);
             
             DrawText("(c) Scarfy sprite by Eiden Marsal", screenWidth - 200, screenHeight - 20, 10, GRAY);
 

games/just_do/screens/screen_level06.c

@@ -132,7 +132,7 @@ void DrawLevel06Screen(void)
         DrawRectangleRec(movingRecs[i], GRAY);
     }
     
-    if (!done & (mouseOverNum >= 0)) DrawRectangleLines(movingRecs[mouseOverNum].x - 5, movingRecs[mouseOverNum].y - 5, movingRecs[mouseOverNum].width + 10, movingRecs[mouseOverNum].height + 10, Fade(LIGHTGRAY, 0.8f));
+    if (!done && (mouseOverNum >= 0)) DrawRectangleLines(movingRecs[mouseOverNum].x - 5, movingRecs[mouseOverNum].y - 5, movingRecs[mouseOverNum].width + 10, movingRecs[mouseOverNum].height + 10, Fade(LIGHTGRAY, 0.8f));
         
     if (levelFinished)
     {

games/just_do/screens/screen_logo.c

@@ -37,7 +37,7 @@ static int framesCounter;
 static int finishScreen;
 
 const char msgLogoA[64] = "A simple and easy-to-use library";
-const char msgLogoB[64] = "to learn videogames programming";
+const char msgLogoB[64] = "to enjoy videogames programming";
 
 int logoPositionX;
 int logoPositionY;

games/koala_seasons/screens/screen_gameplay.c

@@ -954,7 +954,7 @@ void UpdateGameplayScreen(void)
                     playerActive = false;
                     killer = 5;
                 }
-                else if (CheckCollisionRecs(bee, player) && (state == FINALFORM) && (state != KICK))
+                else if (CheckCollisionRecs(bee, player) && (state == FINALFORM))
                 {
                     isHitBee = true;
                     beeVelocity = 8;

games/koala_seasons/screens/screen_logo.c

@@ -37,7 +37,7 @@ static int framesCounter;
 static int finishScreen;
 
 const char msgLogoA[64] = "A simple and easy-to-use library";
-const char msgLogoB[64] = "to learn videogames programming";
+const char msgLogoB[64] = "to enjoy videogames programming";
 
 int logoPositionX;
 int logoPositionY;

games/snake.c

@@ -203,7 +203,7 @@ void UpdateGame(void)
                 if ((snake[0].position.x == snake[i].position.x) && (snake[0].position.y == snake[i].position.y)) gameOver = true;
             }
 
-            // TODO: review logic: fruit.position calculation
+            // fruit.position calculation
             if (!fruit.active)
             {
                 fruit.active = true;
@@ -213,15 +213,15 @@ void UpdateGame(void)
                 {
                     while ((fruit.position.x == snake[i].position.x) && (fruit.position.y == snake[i].position.y))
                     {
-                           fruit.position = (Vector2){ GetRandomValue(0, (screenWidth/SQUARE_SIZE) - 1)*SQUARE_SIZE, GetRandomValue(0, (screenHeight/SQUARE_SIZE) - 1)*SQUARE_SIZE };
+                        fruit.position = (Vector2){ GetRandomValue(0, (screenWidth/SQUARE_SIZE) - 1)*SQUARE_SIZE + offset.x/2, GetRandomValue(0, (screenHeight/SQUARE_SIZE) - 1)*SQUARE_SIZE + offset.y/2 };
                         i = 0;
                     }
                 }
             }
 
             // collision
-            if (CheckCollisionRecs((Rectangle){(int)snake[0].position.x, (int)snake[0].position.y, (int)snake[0].size.x, (int)snake[0].size.y},
+            if ((snake[0].position.x < (fruit.position.x + fruit.size.x) && (snake[0].position.x + snake[0].size.x) > fruit.position.x) &&
-                                   (Rectangle){(int)fruit.position.x, (int)fruit.position.y, (int)fruit.size.x, (int)fruit.size.y}))
+                (snake[0].position.y < (fruit.position.y + fruit.size.y) && (snake[0].position.y + snake[0].size.y) > fruit.position.y))
             {
                 snake[counterTail].position = snakePosition[counterTail - 1];
                 counterTail += 1;

games/transmission/screens/screen_ending.c

@@ -111,9 +111,11 @@ void InitEndingScreen(void)
             // WARNING: It fails if the last sentence word has a '.' after space
             char *title = StringReplace(headline, messageWords[i].text, codingWords[messageWords[i].id]);
            
+            if (title != NULL)
+            {
                 strcpy(headline, title);     // Base headline updated
-            
+                free(title);
-            if (title != NULL) free(title);
+            }
         }
     }