Complete review of raymath for API consistency

release/include/raylib.h

@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   raylib v1.9-dev
+*   raylib v1.9mf">.6-dev
 *
 *   A simple and easy-to-use library to learn videogames programming (www.raylib.com)
 *
@@ -103,11 +103,23 @@
 #define KEY_SPACE            32
 #define KEY_ESCAPE          256
 #define KEY_ENTER           257
+#define KEY_TAB             258
 #define KEY_BACKSPACE       259
+#define KEY_INSERT          260
+#define KEY_DELETE          261
 #define KEY_RIGHT           262
 #define KEY_LEFT            263
 #define KEY_DOWN            264
 #define KEY_UP              265
+#define KEY_PAGE_UP         266
+#define KEY_PAGE_DOWN       267
+#define KEY_HOME            268
+#define KEY_END             269
+#define KEY_CAPS_LOCK       280
+#define KEY_SCROLL_LOCK     281
+#define KEY_NUM_LOCK        282
+#define KEY_PRINT_SCREEN    283
+#define KEY_PAUSE           284
 #define KEY_F1              290
 #define KEY_F2              291
 #define KEY_F3              292
@@ -310,6 +322,14 @@ typedef struct Vector3 {
     float z;
 } Vector3;
 
+// Vector4 type
+typedef struct Vector4 {
+    float x;
+    float y;
+    float z;
+    float w;
+} Vector4;
+
 // Matrix type (OpenGL style 4x4 - right handed, column major)
 typedef struct Matrix {
     float m0, m4, m8, m12;
@@ -410,7 +430,7 @@ typedef struct Mesh {
     float *texcoords;       // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
     float *texcoords2;      // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
     float *normals;         // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-    float *tangents;        // Vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
+    float *tangents;        // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
     unsigned char *colors;  // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
     unsigned short *indices;// Vertex indices (in case vertex data comes indexed)
 
@@ -541,7 +561,7 @@ typedef enum {
     LOC_MAP_METALNESS,       // LOC_MAP_SPECULAR
     LOC_MAP_NORMAL,
     LOC_MAP_ROUGHNESS,
-    LOC_MAP_OCCUSION,
+    LOC_MAP_OCCLUSION,
     LOC_MAP_EMISSION,
     LOC_MAP_HEIGHT,
     LOC_MAP_CUBEMAP,
@@ -674,6 +694,7 @@ extern "C" {            // Prevents name mangling of functions
 // Window-related functions
 RLAPI void InitWindow(int width, int height, void *data);         // Initialize window and OpenGL context
 RLAPI void CloseWindow(void);                                     // Close window and unload OpenGL context
+RLAPI bool IsWindowReady(void);                                   // Check if window has been initialized successfully
 RLAPI bool WindowShouldClose(void);                               // Check if KEY_ESCAPE pressed or Close icon pressed
 RLAPI bool IsWindowMinimized(void);                               // Check if window has been minimized (or lost focus)
 RLAPI void ToggleFullscreen(void);                                // Toggle fullscreen mode (only PLATFORM_DESKTOP)
@@ -682,6 +703,7 @@ RLAPI void SetWindowTitle(const char *title);                     // Set title f
 RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
 RLAPI void SetWindowMonitor(int monitor);                         // Set monitor for the current window (fullscreen mode)
 RLAPI void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+RLAPI void SetWindowSize(int width, int height);                  // Set window dimensions
 RLAPI int GetScreenWidth(void);                                   // Get current screen width
 RLAPI int GetScreenHeight(void);                                  // Get current screen height
 
@@ -715,17 +737,11 @@ RLAPI float GetFrameTime(void);                                   // Returns tim
 RLAPI double GetTime(void);                                       // Returns elapsed time in seconds since InitWindow()
 
 // Color-related functions
-RLAPI int GetHexValue(Color color);                               // Returns hexadecimal value for a Color
+RLAPI float *ColorToFloat(Color color);                           // Returns normalized float array for a Color
+RLAPI int ColorToInt(Color color);                                // Returns hexadecimal value for a Color
+RLAPI Vector3 ColorToHSV(Color color);                            // Returns HSV values for a Color
 RLAPI Color GetColor(int hexValue);                               // Returns a Color struct from hexadecimal value
 RLAPI Color Fade(Color color, float alpha);                       // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
-RLAPI float *ColorToFloat(Color color);                           // Converts Color to float array and normalizes
-
-// Math useful functions (available from raymath.h)
-RLAPI float *Vector3ToFloat(Vector3 vec);                         // Returns Vector3 as float array
-RLAPI float *MatrixToFloat(Matrix mat);                           // Returns Matrix as float array
-RLAPI Vector3 Vector3Zero(void);                                  // Vector with components value 0.0f
-RLAPI Vector3 Vector3One(void);                                   // Vector with components value 1.0f
-RLAPI Matrix MatrixIdentity(void);                                // Returns identity matrix
 
 // Misc. functions
 RLAPI void ShowLogo(void);                                        // Activate raylib logo at startup (can be done with flags)
@@ -783,6 +799,7 @@ RLAPI int GetMouseX(void);                                    // Returns mouse p
 RLAPI int GetMouseY(void);                                    // Returns mouse position Y
 RLAPI Vector2 GetMousePosition(void);                         // Returns mouse position XY
 RLAPI void SetMousePosition(Vector2 position);                // Set mouse position XY
+RLAPI void SetMouseScale(float scale);                        // Set mouse scaling
 RLAPI int GetMouseWheelMove(void);                            // Returns mouse wheel movement Y
 
 // Input-related functions: touch
@@ -839,6 +856,7 @@ RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Col
 RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
 RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
 RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
+RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                              // Draw rectangle outline with extended parameters
 RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle
 RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline
 RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
@@ -886,6 +904,7 @@ RLAPI void ImageAlphaPremultiply(Image *image);
 RLAPI void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
 RLAPI void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize and image (bilinear filtering)
 RLAPI void ImageResizeNN(Image *image,int newWidth,int newHeight);                                       // Resize and image (Nearest-Neighbor scaling algorithm)
+RLAPI void ImageMipmaps(Image *image);                                                                   // Generate all mipmap levels for a provided image
 RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
 RLAPI Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
 RLAPI Image ImageTextEx(SpriteFont font, const char *text, float fontSize, int spacing, Color tint);     // Create an image from text (custom sprite font)
@@ -908,7 +927,7 @@ RLAPI Image GenImageGradientH(int width, int height, Color left, Color right);
 RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);      // Generate image: radial gradient
 RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
 RLAPI Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
-RLAPI Image GenImagePerlinNoise(int width, int height, float scale);                                     // Generate image: perlin noise
+RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);           // Generate image: perlin noise
 RLAPI Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm. Bigger tileSize means bigger cells
 
 // Texture2D configuration functions
@@ -932,19 +951,20 @@ RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle dest
 RLAPI SpriteFont GetDefaultFont(void);                                                                   // Get the default SpriteFont
 RLAPI SpriteFont LoadSpriteFont(const char *fileName);                                                   // Load SpriteFont from file into GPU memory (VRAM)
 RLAPI SpriteFont LoadSpriteFontEx(const char *fileName, int fontSize, int charsCount, int *fontChars);   // Load SpriteFont from file with extended parameters
-RLAPI void UnloadSpriteFont(SpriteFont spriteFont);                                                      // Unload SpriteFont from GPU memory (VRAM)
+RLAPI void UnloadSpriteFont(SpriteFont font);                                                            // Unload SpriteFont from GPU memory (VRAM)
 
 // Text drawing functions
 RLAPI void DrawFPS(int posX, int posY);                                                                  // Shows current FPS
 RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);                    // Draw text (using default font)
-RLAPI void DrawTextEx(SpriteFont spriteFont, const char* text, Vector2 position,                         // Draw text using SpriteFont and additional parameters
+RLAPI void DrawTextEx(SpriteFont font, const char* text, Vector2 position,                               // Draw text using SpriteFont and additional parameters
                 float fontSize, int spacing, Color tint);
 
 // Text misc. functions
 RLAPI int MeasureText(const char *text, int fontSize);                                                   // Measure string width for default font
-RLAPI Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, int spacing);       // Measure string size for SpriteFont
+RLAPI Vector2 MeasureTextEx(SpriteFont font, const char *text, float fontSize, int spacing);             // Measure string size for SpriteFont
 RLAPI const char *FormatText(const char *text, ...);                                                     // Formatting of text with variables to 'embed'
 RLAPI const char *SubText(const char *text, int position, int length);                                   // Get a piece of a text string
+RLAPI int GetGlyphIndex(SpriteFont font, int character);                                                 // Returns index position for a unicode character on sprite font
 
 //------------------------------------------------------------------------------------
 // Basic 3d Shapes Drawing Functions (Module: models)
@@ -981,6 +1001,11 @@ RLAPI void UnloadModel(Model model);
 RLAPI Mesh LoadMesh(const char *fileName);                                                              // Load mesh from file
 RLAPI void UnloadMesh(Mesh *mesh);                                                                      // Unload mesh from memory (RAM and/or VRAM)
 
+// Mesh manipulation functions
+RLAPI BoundingBox MeshBoundingBox(Mesh mesh);                                                           // Compute mesh bounding box limits
+RLAPI void MeshTangents(Mesh *mesh);                                                                    // Compute mesh tangents 
+RLAPI void MeshBinormals(Mesh *mesh);                                                                   // Compute mesh binormals
+
 // Mesh generation functions
 RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                 // Generate plane mesh (with subdivisions)
 RLAPI Mesh GenMeshCube(float width, float height, float length);                                        // Generate cuboid mesh
@@ -1010,7 +1035,6 @@ RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRe
                             Vector3 center, float size, Color tint);                                    // Draw a billboard texture defined by sourceRec
 
 // Collision detection functions
-RLAPI BoundingBox CalculateBoundingBox(Mesh mesh);                                                      // Calculate mesh bounding box limits
 RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);       // Detect collision between two spheres
 RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                     // Detect collision between two bounding boxes
 RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere);          // Detect collision between box and sphere
@@ -1029,7 +1053,8 @@ RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);
 
 // Shader loading/unloading functions
 RLAPI char *LoadText(const char *fileName);                               // Load chars array from text file
-RLAPI Shader LoadShader(char *vsFileName, char *fsFileName);              // Load shader from files and bind default locations
+RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);  // Load shader from files and bind default locations
+RLAPI Shader LoadShaderCode(char *vsCode, char *fsCode);                  // Load shader from code strings and bind default locations
 RLAPI void UnloadShader(Shader shader);                                   // Unload shader from GPU memory (VRAM)
 
 RLAPI Shader GetShaderDefault(void);                                      // Get default shader

src/core.c

@@ -432,7 +432,7 @@ static void *GamepadThread(void *arg);                  // Mouse reading thread
 // NOTE: data parameter could be used to pass any kind of required data to the initialization
 void InitWindow(int width, int height, void *data)
 {
-    TraceLog(LOG_INFO, "Initializing raylib (v1.9.5-dev)");
+    TraceLog(LOG_INFO, "Initializing raylib (v1.9.6-dev)");
 
 #if defined(PLATFORM_DESKTOP)
     windowTitle = (char *)data;
@@ -503,7 +503,7 @@ void InitWindow(int width, int height, void *data)
 // NOTE: data parameter could be used to pass any kind of required data to the initialization
 void InitWindow(int width, int height, void *data)
 {
-    TraceLog(LOG_INFO, "Initializing raylib (v1.9.5-dev)");
+    TraceLog(LOG_INFO, "Initializing raylib (v1.9.6-dev)");
 
     screenWidth = width;
     screenHeight = height;
@@ -1025,7 +1025,7 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera)
 
     // Calculate normalized direction vector
     Vector3 direction = Vector3Subtract(farPoint, nearPoint);
-    Vector3Normalize(&direction);
+    direction = Vector3Normalize(direction);
 
     // Apply calculated vectors to ray
     ray.position = camera.position;
@@ -1047,10 +1047,10 @@ Vector2 GetWorldToScreen(Vector3 position, Camera camera)
     Quaternion worldPos = { position.x, position.y, position.z, 1.0f };
 
     // Transform world position to view
-    QuaternionTransform(&worldPos, matView);
+    worldPos = QuaternionTransform(worldPos, matView);
 
     // Transform result to projection (clip space position)
-    QuaternionTransform(&worldPos, matProj);
+    worldPos = QuaternionTransform(worldPos, matProj);
 
     // Calculate normalized device coordinates (inverted y)
     Vector3 ndcPos = { worldPos.x/worldPos.w, -worldPos.y/worldPos.w, worldPos.z/worldPos.w };

src/models.c

@@ -1759,8 +1759,8 @@ void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vec
     |       |
     d-------c
 */
-    Vector3Scale(&right, sizeRatio.x/2);
-    Vector3Scale(&up, sizeRatio.y/2);
+    right = Vector3Scale(right, sizeRatio.x/2);
+    up = Vector3Scale(up, sizeRatio.y/2);
 
     Vector3 p1 = Vector3Add(right, up);
     Vector3 p2 = Vector3Subtract(right, up);
@@ -1897,7 +1897,7 @@ bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadi
     if (distance < sphereRadius) collisionDistance = vector + sqrtf(d);
     else collisionDistance = vector - sqrtf(d);
 
-    Vector3Scale(&offset, collisionDistance);
+    offset = Vector3Scale(offset, collisionDistance);
     Vector3 cPoint = Vector3Add(ray.position, offset);
 
     collisionPoint->x = cPoint.x;
@@ -2022,9 +2022,9 @@ RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3)
         result.distance = t;
         result.hit = true;
         result.normal = Vector3CrossProduct(edge1, edge2);
-        Vector3Normalize(&result.normal);
+        result.normal = Vector3Normalize(result.normal);
         Vector3 rayDir = ray.direction;
-        Vector3Scale(&rayDir, t);
+        rayDir = Vector3Scale(rayDir, t);
         result.position = Vector3Add(ray.position, rayDir);
     }
 
@@ -2045,7 +2045,7 @@ RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight)
         if (t >= 0.0)
         {
             Vector3 rayDir = ray.direction;
-            Vector3Scale(&rayDir, t);
+            rayDir = Vector3Scale(rayDir, t);
             result.hit = true;
             result.distance = t;
             result.normal = (Vector3){ 0.0, 1.0, 0.0 };
@@ -2300,7 +2300,7 @@ static Mesh LoadOBJ(const char *fileName)
                 {
                     // If normals not defined, they are calculated from the 3 vertices [N = (V2 - V1) x (V3 - V1)]
                     Vector3 norm = Vector3CrossProduct(Vector3Subtract(midVertices[vCount[1]-1], midVertices[vCount[0]-1]), Vector3Subtract(midVertices[vCount[2]-1], midVertices[vCount[0]-1]));
-                    Vector3Normalize(&norm);
+                    norm = Vector3Normalize(norm);
 
                     mesh.normals[nCounter] = norm.x;
                     mesh.normals[nCounter + 1] = norm.y;

src/raylib.h

@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   raylib v1.9.5-dev
+*   raylib v1.9.6-dev
 *
 *   A simple and easy-to-use library to learn videogames programming (www.raylib.com)
 *

src/raymath.h

@@ -83,11 +83,16 @@
     #define RAD2DEG (180.0f/PI)
 #endif
 
-// Return float vector
+// Return float vector for Matrix
 #ifndef MatrixToFloat
     #define MatrixToFloat(mat) (MatrixToFloatV(mat).v)
 #endif
 
+// Return float vector for Vector3
+#ifndef Vector3ToFloat
+    #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) 
+#endif
+
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
@@ -147,84 +152,86 @@ RMDEF float Clamp(float value, float min, float max)
 // Vector with components value 0.0f
 RMDEF Vector2 Vector2Zero(void) 
 { 
-    Vector2 tmp = {0.0f, 0.0f};
-    return tmp;
+    Vector2 result = { 0.0f, 0.0f };
+    return result;
 }
 
 // Vector with components value 1.0f
 RMDEF Vector2 Vector2One(void) 
 { 
-    Vector2 tmp = {1.0f, 1.0f};
-    return tmp;
+    Vector2 result = { 1.0f, 1.0f };
+    return result;
 }
 
 // Add two vectors (v1 + v2)
 RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2)
 {
-    Vector2 tmp = { v1.x + v2.x, v1.y + v2.y };
-    return tmp;
+    Vector2 result = { v1.x + v2.x, v1.y + v2.y };
+    return result;
 }
 
 // Subtract two vectors (v1 - v2)
 RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
 {
-    Vector2 tmp = { v1.x - v2.x, v1.y - v2.y };
-    return tmp;
+    Vector2 result = { v1.x - v2.x, v1.y - v2.y };
+    return result;
 }
 
 // Calculate vector length
 RMDEF float Vector2Length(Vector2 v)
 {
-    return sqrtf((v.x*v.x) + (v.y*v.y));
+    float result = sqrtf((v.x*v.x) + (v.y*v.y));
+    return result;
 }
 
 // Calculate two vectors dot product
 RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2)
 {
-    return (v1.x*v2.x + v1.y*v2.y);
+    float result = (v1.x*v2.x + v1.y*v2.y);
+    return result;
 }
 
 // Calculate distance between two vectors
 RMDEF float Vector2Distance(Vector2 v1, Vector2 v2)
 {
-    return sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));
+    float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));
+    return result;
 }
 
 // Calculate angle from two vectors in X-axis
 RMDEF float Vector2Angle(Vector2 v1, Vector2 v2)
 {
-    float angle = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/PI);
-    
-    if (angle < 0) angle += 360.0f;
-
-    return angle;
+    float result = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/PI);
+    if (result < 0) result += 360.0f;
+    return result;
 }
 
 // Scale vector (multiply by value)
-RMDEF kt">void Vector2Scale(Vector2 *v, float scale)
+RMDEF n">Vector2 Vector2Scale(Vector2 v, float scale)
 {
-    v->x *= scale;
-    n">v->y *= scale;
+    Vector2 result = { v.x*scale, v.y*scale };
+    k">return result;
 }
 
 // Negate vector
-RMDEF kt">void Vector2Negate(Vector2 *v)
+RMDEF n">Vector2 Vector2Negate(Vector2 v)
 {
-    v->x = -v->x;
-    n">v->y = -v->y;
+    Vector2 result = { -v.x, -v.y };
+    k">return result;
 }
 
 // Divide vector by a float value
-RMDEF kt">void Vector2Divide(Vector2 *v, float div)
+RMDEF n">Vector2 Vector2Divide(Vector2 v, float div)
 {
-    Vector2 tmp = {v->x/div, vo">->y/div};
-    o">*v = tmp;
+    Vector2 result = { v.x/div, vp">.y/div };
+    k">return result;
 }
 
 // Normalize provided vector
-RMDEF kt">void Vector2Normalize(Vector2 *v)
+RMDEF n">Vector2 Vector2Normalize(Vector2 v)
 {
-    Vector2Divide(v, Vector2Length(*v));
+    Vector2 result = Vector2Divide(v, Vector2Length(v));
+    return result;
 }
 
 //----------------------------------------------------------------------------------
@@ -234,69 +241,56 @@ RMDEF void Vector2Normalize(Vector2 *v)
 // Vector with components value 0.0f
 RMDEF Vector3 Vector3Zero(void) 
 { 
-    Vector3 tmp = { 0.0f, 0.0f, 0.0f };
-    return tmp; 
+    Vector3 result = { 0.0f, 0.0f, 0.0f };
+    return result; 
 }
 
 // Vector with components value 1.0f
 RMDEF Vector3 Vector3One(void) 
 { 
-    Vector3 tmp = { 1.0f, 1.0f, 1.0f };
-    return tmp; 
+    Vector3 result = { 1.0f, 1.0f, 1.0f };
+    return result; 
 }
 
 // Add two vectors
 RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2)
 {
-    Vector3 tmp = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
-    return tmp; 
+    Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
+    return result; 
 }
 
 // Substract two vectors
 RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)
 {
-    Vector3 tmp = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
-    return tmp; 
+    Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
+    return result; 
 }
 
 // Multiply vector by scalar
 RMDEF Vector3 Vector3Multiply(Vector3 v, float scalar)
-{	
-    v.x *= scalar;
-    v.y *= scalar;
-    v.z *= scalar;
-
-    return v;
+{
+    Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar };
+    return result;
 }
 
 // Multiply vector by vector
 RMDEF Vector3 Vector3MultiplyV(Vector3 v1, Vector3 v2)
 {	
-    Vector3 result;
-
-    result.x = v1.x * v2.x;
-    result.y = v1.y * v2.y;
-    result.z = v1.z * v2.z;
-
+    Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z };
     return result;
 }
 
 // Calculate two vectors cross product
 RMDEF Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2)
 {
-    Vector3 result;
-
-    result.x = v1.y*v2.z - v1.z*v2.y;
-    result.y = v1.z*v2.x - v1.x*v2.z;
-    result.z = v1.x*v2.y - v1.y*v2.x;
-
+    Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };
     return result;
 }
 
 // Calculate one vector perpendicular vector
 RMDEF Vector3 Vector3Perpendicular(Vector3 v)
 {
-    Vector3 result;
+    Vector3 result = { 0 };
 
     float min = fabsf(v.x);
     Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
@@ -322,13 +316,15 @@ RMDEF Vector3 Vector3Perpendicular(Vector3 v)
 // Calculate vector length
 RMDEF float Vector3Length(const Vector3 v)
 {
-    return sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    return result;
 }
 
 // Calculate two vectors dot product
 RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2)
 {
-    return (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+    float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+    return result;
 }
 
 // Calculate distance between two vectors
@@ -337,58 +333,60 @@ RMDEF float Vector3Distance(Vector3 v1, Vector3 v2)
     float dx = v2.x - v1.x;
     float dy = v2.y - v1.y;
     float dz = v2.z - v1.z;
-
-    return f">sqrtf(dx*dx + dy*dy + dz*dz);
+    float result = sqrtf(dx*dx + dy*dy + dz*dz);
+    return ">result;
 }
 
 // Scale provided vector
-RMDEF kt">void Vector3Scale(Vector3 *v, float scale)
+RMDEF n">Vector3 Vector3Scale(Vector3 v, float scale)
 {
-    v->x *= scale;
-    v->y *= scale;
-    v->z *= scale;
+    Vector3 result = { v.x*scale, v.y*scale, v.z*scale };
+    return result;
 }
 
 // Negate provided vector (invert direction)
-RMDEF kt">void Vector3Negate(Vector3 *v)
+RMDEF n">Vector3 Vector3Negate(Vector3 v)
 {
-    v->x = -v->x;
-    v->y = -v->y;
-    v->z = -v->z;
+    Vector3 result = { -v.x, -v.y, -v.z };
+    return result;
 }
 
 // Normalize provided vector
-RMDEF kt">void Vector3Normalize(Vector3 *v)
+RMDEF n">Vector3 Vector3Normalize(Vector3 v)
 {
+    Vector3 result = v;
+    
     float length, ilength;
-
-    length = Vector3Length(*v);
-
+    length = Vector3Length(v);
     if (length == 0.0f) length = 1.0f;
-
     ilength = 1.0f/length;
 
-    v->x *= ilength;
-    v->y *= ilength;
-    v->z *= ilength;
+    result.x *= ilength;
+    result.y *= ilength;
+    result.z *= ilength;
+
+    return result;
 }
 
 // Transforms a Vector3 by a given Matrix
-RMDEF kt">void Vector3Transform(Vector3 *v, Matrix mat)
+RMDEF n">Vector3 Vector3Transform(Vector3 v, Matrix mat)
 {
-    float x = v->x;
-    float y = v->y;
-    float z = v->z;
+    Vector3 result = { 0 };
+    float x = v.x;
+    float y = v.y;
+    float z = v.z;
 
-    v->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
-    v->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
-    v->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
+    result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
+    result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
+    result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
+    
+    return result;
 };
 
 // Calculate linear interpolation between two vectors
 RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
 {
-    Vector3 result;
+    Vector3 result = { 0 };
 
     result.x = v1.x + amount*(v2.x - v1.x);
     result.y = v1.y + amount*(v2.y - v1.y);
@@ -398,43 +396,43 @@ RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
 }
 
 // Calculate reflected vector to normal
-RMDEF Vector3 Vector3Reflect(Vector3 vector, Vector3 normal)
+RMDEF Vector3 Vector3Reflect(Vector3 v, Vector3 normal)
 {
     // I is the original vector
     // N is the normal of the incident plane
     // R = I - (2*N*( DotProduct[ I,N] ))
 
-    Vector3 result;
+    Vector3 result = { 0 };
 
-    float dotProduct = Vector3DotProduct(vector, normal);
+    float dotProduct = Vector3DotProduct(v, normal);
 
-    result.x = vector.x - (2.0f*normal.x)*dotProduct;
-    result.y = vector.y - (2.0f*normal.y)*dotProduct;
-    result.z = vector.z - (2.0f*normal.z)*dotProduct;
+    result.x = v.x - (2.0f*normal.x)*dotProduct;
+    result.y = v.y - (2.0f*normal.y)*dotProduct;
+    result.z = v.z - (2.0f*normal.z)*dotProduct;
 
     return result;
 }
 
 // Return min value for each pair of components
-RMDEF Vector3 Vector3Min(Vector3 vec1, Vector3 vec2)
+RMDEF Vector3 Vector3Min(Vector3 v1, Vector3 v2)
 {
-    Vector3 result;
+    Vector3 result = { 0 };
     
-    result.x = fminf(vec1.x, vec2.x);
-    result.y = fminf(vec1.y, vec2.y);
-    result.z = fminf(vec1.z, vec2.z);
+    result.x = fminf(v1.x, v2.x);
+    result.y = fminf(v1.y, v2.y);
+    result.z = fminf(v1.z, v2.z);
     
     return result;
 }
 
 // Return max value for each pair of components
-RMDEF Vector3 Vector3Max(Vector3 vec1, Vector3 vec2)
+RMDEF Vector3 Vector3Max(Vector3 v1, Vector3 v2)
 {
-    Vector3 result;
+    Vector3 result = { 0 };
     
-    result.x = fmaxf(vec1.x, vec2.x);
-    result.y = fmaxf(vec1.y, vec2.y);
-    result.z = fmaxf(vec1.z, vec2.z);
+    result.x = fmaxf(v1.x, v2.x);
+    result.y = fmaxf(v1.y, v2.y);
+    result.z = fmaxf(v1.z, v2.z);
     
     return result;
 }
@@ -456,7 +454,7 @@ RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
     
     float denom = d00*d11 - d01*d01;
     
-    Vector3 result;
+    Vector3 result = { 0 };
     
     result.y = (d11*d20 - d01*d21)/denom;
     result.z = (d00*d21 - d01*d20)/denom;
@@ -466,19 +464,16 @@ RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
 }
 
 // Returns Vector3 as float array
-RMDEF float3 Vector3ToFloat_(Vector3 vec)
+RMDEF float3 Vector3ToFloatV(Vector3 v)
 {
-    float3 buffer;
+    float3 buffer = { 0 };
 
-    buffer.v[0] = vec.x;
-    buffer.v[1] = vec.y;
-    buffer.v[2] = vec.z;
+    buffer.v[0] = v.x;
+    buffer.v[1] = v.y;
+    buffer.v[2] = v.z;
 
     return buffer;
 }
-#ifndef Vector3ToFloat
-#define Vector3ToFloat(vec) (Vector3ToFloat_(vec).v) 
-#endif
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Matrix math
@@ -487,7 +482,7 @@ RMDEF float3 Vector3ToFloat_(Vector3 vec)
 // Compute matrix determinant
 RMDEF float MatrixDeterminant(Matrix mat)
 {
-    float result;
+    float result = { 0 };
 
     // Cache the matrix values (speed optimization)
     float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
@@ -508,44 +503,45 @@ RMDEF float MatrixDeterminant(Matrix mat)
 // Returns the trace of the matrix (sum of the values along the diagonal)
 RMDEF float MatrixTrace(Matrix mat)
 {
-    return (mat.m0 + mat.m5 + mat.m10 + mat.m15);
+    float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15);
+    return result;
 }
 
 // Transposes provided matrix
-RMDEF kt">void MatrixTranspose(Matrix *mat)
-{
-    Matrix temp;
-
-    temp.m0 = mato">->m0;
-    temp.m1 = mato">->m4;
-    temp.m2 = mato">->m8;
-    temp.m3 = mato">->m12;
-    temp.m4 = mato">->m1;
-    temp.m5 = mato">->m5;
-    temp.m6 = mato">->m9;
-    temp.m7 = mato">->m13;
-    temp.m8 = mato">->m2;
-    temp.m9 = mato">->m6;
-    temp.m10 = mato">->m10;
-    temp.m11 = mato">->m14;
-    temp.m12 = mato">->m3;
-    temp.m13 = mato">->m7;
-    temp.m14 = mato">->m11;
-    temp.m15 = mato">->m15;
-
-    o">*mat = temp;
+RMDEF n">Matrix MatrixTranspose(Matrix mat)
+{
+    Matrix result = { 0 };
+
+    result.m0 = matp">.m0;
+    result.m1 = matp">.m4;
+    result.m2 = matp">.m8;
+    result.m3 = matp">.m12;
+    result.m4 = matp">.m1;
+    result.m5 = matp">.m5;
+    result.m6 = matp">.m9;
+    result.m7 = matp">.m13;
+    result.m8 = matp">.m2;
+    result.m9 = matp">.m6;
+    result.m10 = matp">.m10;
+    result.m11 = matp">.m14;
+    result.m12 = matp">.m3;
+    result.m13 = matp">.m7;
+    result.m14 = matp">.m11;
+    result.m15 = matp">.m15;
+
+    k">return result;
 }
 
 // Invert provided matrix
-RMDEF kt">void MatrixInvert(Matrix *mat)
+RMDEF n">Matrix MatrixInvert(Matrix mat)
 {
-    Matrix temp;
+    Matrix result = { 0 };
 
     // Cache the matrix values (speed optimization)
-    float a00 = mato">->m0, a01 = mato">->m1, a02 = mato">->m2, a03 = mato">->m3;
-    float a10 = mato">->m4, a11 = mato">->m5, a12 = mato">->m6, a13 = mato">->m7;
-    float a20 = mato">->m8, a21 = mato">->m9, a22 = mato">->m10, a23 = mato">->m11;
-    float a30 = mato">->m12, a31 = mato">->m13, a32 = mato">->m14, a33 = mato">->m15;
+    float a00 = matp">.m0, a01 = matp">.m1, a02 = matp">.m2, a03 = matp">.m3;
+    float a10 = matp">.m4, a11 = matp">.m5, a12 = matp">.m6, a13 = matp">.m7;
+    float a20 = matp">.m8, a21 = matp">.m9, a22 = matp">.m10, a23 = matp">.m11;
+    float a30 = matp">.m12, a31 = matp">.m13, a32 = matp">.m14, a33 = matp">.m15;
 
     float b00 = a00*a11 - a01*a10;
     float b01 = a00*a12 - a02*a10;
@@ -563,47 +559,51 @@ RMDEF void MatrixInvert(Matrix *mat)
     // Calculate the invert determinant (inlined to avoid double-caching)
     float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
 
-    temp.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet;
-    temp.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet;
-    temp.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet;
-    temp.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet;
-    temp.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet;
-    temp.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet;
-    temp.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet;
-    temp.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet;
-    temp.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet;
-    temp.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet;
-    temp.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet;
-    temp.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet;
-    temp.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet;
-    temp.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet;
-    temp.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
-    temp.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
-
-    o">*mat = temp;
+    result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet;
+    result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet;
+    result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet;
+    result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet;
+    result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet;
+    result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet;
+    result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet;
+    result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet;
+    result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet;
+    result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet;
+    result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet;
+    result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet;
+    result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet;
+    result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet;
+    result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
+    result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
+
+    k">return result;
 }
 
 // Normalize provided matrix
-RMDEF void MatrixNormalize(Matrix *mat)
-{
-    float det = MatrixDeterminant(*mat);
-
-    mat->m0 /= det;
-    mat->m1 /= det;
-    mat->m2 /= det;
-    mat->m3 /= det;
-    mat->m4 /= det;
-    mat->m5 /= det;
-    mat->m6 /= det;
-    mat->m7 /= det;
-    mat->m8 /= det;
-    mat->m9 /= det;
-    mat->m10 /= det;
-    mat->m11 /= det;
-    mat->m12 /= det;
-    mat->m13 /= det;
-    mat->m14 /= det;
-    mat->m15 /= det;
+RMDEF Matrix MatrixNormalize(Matrix mat)
+{
+    Matrix result = { 0 };
+    
+    float det = MatrixDeterminant(mat);
+
+    result.m0 = mat.m0/det;
+    result.m1 = mat.m1/det;
+    result.m2 = mat.m2/det;
+    result.m3 = mat.m3/det;
+    result.m4 = mat.m4/det;
+    result.m5 = mat.m5/det;
+    result.m6 = mat.m6/det;
+    result.m7 = mat.m7/det;
+    result.m8 = mat.m8/det;
+    result.m9 = mat.m9/det;
+    result.m10 = mat.m10/det;
+    result.m11 = mat.m11/det;
+    result.m12 = mat.m12/det;
+    result.m13 = mat.m13/det;
+    result.m14 = mat.m14/det;
+    result.m15 = mat.m15/det;
+    
+    return result;
 }
 
 // Returns identity matrix
@@ -682,7 +682,7 @@ RMDEF Matrix MatrixTranslate(float x, float y, float z)
 // NOTE: Angle should be provided in radians
 RMDEF Matrix MatrixRotate(Vector3 axis, float angle)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     float x = axis.x, y = axis.y, z = axis.z;
 
@@ -786,7 +786,7 @@ RMDEF Matrix MatrixScale(float x, float y, float z)
 // NOTE: When multiplying matrices... the order matters!
 RMDEF Matrix MatrixMultiply(Matrix left, Matrix right)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
     result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
@@ -811,7 +811,7 @@ RMDEF Matrix MatrixMultiply(Matrix left, Matrix right)
 // Returns perspective projection matrix
 RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     float rl = (right - left);
     float tb = (top - bottom);
@@ -846,14 +846,15 @@ RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double f
 {
     double top = near*tan(fovy*0.5); 
     double right = top*aspect;
+    Matrix result = MatrixFrustum(-right, right, -top, top, near, far);
 
-    return f">MatrixFrustum(-right, right, -top, top, near, far);
+    return ">result; 
 }
 
 // Returns orthographic projection matrix
 RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     float rl = (right - left);
     float tb = (top - bottom);
@@ -882,14 +883,14 @@ RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, d
 // Returns camera look-at matrix (view matrix)
 RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     Vector3 z = Vector3Subtract(eye, target);
-    Vector3Normalize(&z);
+    z = Vector3Normalize(z);
     Vector3 x = Vector3CrossProduct(up, z);
-    Vector3Normalize(&x);
+    x = Vector3Normalize(x);
     Vector3 y = Vector3CrossProduct(z, x);
-    Vector3Normalize(&y);
+    y = Vector3Normalize(y);
     
     result.m0 = x.x;
     result.m1 = x.y;
@@ -908,7 +909,7 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
     result.m14 = eye.z;
     result.m15 = 1.0f;
 
-    MatrixInvert(&result);
+    result = MatrixInvert(result);
 
     return result;
 }
@@ -916,7 +917,7 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
 // Returns float array of matrix data
 RMDEF float16 MatrixToFloatV(Matrix mat)
 {
-    float16 buffer;
+    float16 buffer = { 0 };
 
     buffer.v[0] = mat.m0;
     buffer.v[1] = mat.m1;
@@ -945,54 +946,59 @@ RMDEF float16 MatrixToFloatV(Matrix mat)
 // Returns identity quaternion
 RMDEF Quaternion QuaternionIdentity(void)
 {
-    Quaternion q = { 0.0f, 0.0f, 0.0f, 1.0f };
-    return q;
+    Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f };
+    return result;
 }
 
 // Computes the length of a quaternion
-RMDEF float QuaternionLength(Quaternion quat)
+RMDEF float QuaternionLength(Quaternion q)
 {
-    return sqrt(quat.x*quat.x + quat.y*quat.y + quat.z*quat.z + quat.w*quat.w);
+    float result = sqrt(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+    return result;
 }
 
 // Normalize provided quaternion
-RMDEF kt">void QuaternionNormalize(Quaternion *q)
+RMDEF n">Quaternion QuaternionNormalize(Quaternion q)
 {
+    Quaternion result = { 0 };
+    
     float length, ilength;
-
-    length = QuaternionLength(*q);
-
+    length = QuaternionLength(q);
     if (length == 0.0f) length = 1.0f;
-
     ilength = 1.0f/length;
 
-    q->x *= ilength;
-    q->y *= ilength;
-    q->z *= ilength;
-    q->w *= ilength;
+    result.x = q.x*ilength;
+    result.y = q.y*ilength;
+    result.z = q.z*ilength;
+    result.w = q.w*ilength;
+    
+    return result;
 }
 
 // Invert provided quaternion
-RMDEF kt">void QuaternionInvert(Quaternion o">*quat)
+RMDEF n">Quaternion QuaternionInvert(Quaternion q)
 {
-    float length = QuaternionLength(*quat);
+    Quaternion result = q;
+    float length = QuaternionLength(q);
     float lengthSq = length*length;
     
     if (lengthSq != 0.0)
     {
         float i = 1.0f/lengthSq;
         
-        quat->x *= -i;
-        quat->y *= -i;
-        quat->z *= -i;
-        quat->w *= i;
+        result.x *= -i;
+        result.y *= -i;
+        result.z *= -i;
+        result.w *= i;
     }
+    
+    return result;
 }
 
 // Calculate two quaternion multiplication
 RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
 {
-    Quaternion result;
+    Quaternion result = { 0 };
 
     float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w;
     float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w;
@@ -1008,7 +1014,7 @@ RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
 // Calculate linear interpolation between two quaternions
 RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
 {
-    Quaternion result;
+    Quaternion result = { 0 };
 
     result.x = q1.x + amount*(q2.x - q1.x);
     result.y = q1.y + amount*(q2.y - q1.y);
@@ -1022,7 +1028,7 @@ RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
 RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount)
 {
     Quaternion result = QuaternionLerp(q1, q2, amount);
-    QuaternionNormalize(&result);
+    result = QuaternionNormalize(result);
     
     return result;
 }
@@ -1030,7 +1036,7 @@ RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount)
 // Calculates spherical linear interpolation between two quaternions
 RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
 {
-    Quaternion result;
+    Quaternion result = { 0 };
 
     float cosHalfTheta =  q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w;
 
@@ -1066,31 +1072,31 @@ RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
 // Calculate quaternion based on the rotation from one vector to another
 RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
 {
-    Quaternion q = { 0 };
+    Quaternion result = { 0 };
 
     float cos2Theta = Vector3DotProduct(from, to);
     Vector3 cross = Vector3CrossProduct(from, to);
 
-    q.x = cross.x;
-    q.y = cross.y;
-    q.z = cross.y;
-    q.w = 1.0f + cos2Theta;     // NOTE: Added QuaternioIdentity()
+    result.x = cross.x;
+    result.y = cross.y;
+    result.z = cross.y;
+    result.w = 1.0f + cos2Theta;     // NOTE: Added QuaternioIdentity()
     
     // Normalize to essentially nlerp the original and identity to 0.5
-    QuaternionNormalize(&q);    
+    result = QuaternionNormalize(result);    
     
     // Above lines are equivalent to:
     //Quaternion result = QuaternionNlerp(q, QuaternionIdentity(), 0.5f);
     
-	return q;
+	return result;
 }
 
 // Returns a quaternion for a given rotation matrix
-RMDEF Quaternion QuaternionFromMatrix(Matrix matrix)
+RMDEF Quaternion QuaternionFromMatrix(Matrix mat)
 {
-    Quaternion result;
+    Quaternion result = { 0 };
 
-    float trace = MatrixTrace(matrix);
+    float trace = MatrixTrace(mat);
 
     if (trace > 0.0f)
     {
@@ -1098,42 +1104,42 @@ RMDEF Quaternion QuaternionFromMatrix(Matrix matrix)
         float invS = 1.0f/s;
 
         result.w = s*0.25f;
-        result.x = (matrix.m6 - matrix.m9)*invS;
-        result.y = (matrix.m8 - matrix.m2)*invS;
-        result.z = (matrix.m1 - matrix.m4)*invS;
+        result.x = (mat.m6 - mat.m9)*invS;
+        result.y = (mat.m8 - mat.m2)*invS;
+        result.z = (mat.m1 - mat.m4)*invS;
     }
     else
     {
-        float m00 = matrix.m0, m11 = matrix.m5, m22 = matrix.m10;
+        float m00 = mat.m0, m11 = mat.m5, m22 = mat.m10;
 
         if (m00 > m11 && m00 > m22)
         {
             float s = (float)sqrt(1.0f + m00 - m11 - m22)*2.0f;
             float invS = 1.0f/s;
 
-            result.w = (matrix.m6 - matrix.m9)*invS;
+            result.w = (mat.m6 - mat.m9)*invS;
             result.x = s*0.25f;
-            result.y = (matrix.m4 + matrix.m1)*invS;
-            result.z = (matrix.m8 + matrix.m2)*invS;
+            result.y = (mat.m4 + mat.m1)*invS;
+            result.z = (mat.m8 + mat.m2)*invS;
         }
         else if (m11 > m22)
         {
             float s = (float)sqrt(1.0f + m11 - m00 - m22)*2.0f;
             float invS = 1.0f/s;
 
-            result.w = (matrix.m8 - matrix.m2)*invS;
-            result.x = (matrix.m4 + matrix.m1)*invS;
+            result.w = (mat.m8 - mat.m2)*invS;
+            result.x = (mat.m4 + mat.m1)*invS;
             result.y = s*0.25f;
-            result.z = (matrix.m9 + matrix.m6)*invS;
+            result.z = (mat.m9 + mat.m6)*invS;
         }
         else
         {
             float s = (float)sqrt(1.0f + m22 - m00 - m11)*2.0f;
             float invS = 1.0f/s;
 
-            result.w = (matrix.m1 - matrix.m4)*invS;
-            result.x = (matrix.m8 + matrix.m2)*invS;
-            result.y = (matrix.m9 + matrix.m6)*invS;
+            result.w = (mat.m1 - mat.m4)*invS;
+            result.x = (mat.m8 + mat.m2)*invS;
+            result.y = (mat.m9 + mat.m6)*invS;
             result.z = s*0.25f;
         }
     }
@@ -1144,7 +1150,7 @@ RMDEF Quaternion QuaternionFromMatrix(Matrix matrix)
 // Returns a matrix for a given quaternion
 RMDEF Matrix QuaternionToMatrix(Quaternion q)
 {
-    Matrix result;
+    Matrix result = { 0 };
 
     float x = q.x, y = q.y, z = q.z, w = q.w;
 
@@ -1197,7 +1203,7 @@ RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
 
     angle *= 0.5f;
 
-    Vector3Normalize(&axis);
+    axis = Vector3Normalize(axis);
     
     float sinres = sinf(angle);
     float cosres = cosf(angle);
@@ -1207,7 +1213,7 @@ RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
     result.z = axis.z*sinres;
     result.w = cosres;
 
-    QuaternionNormalize(&result);
+    result = QuaternionNormalize(result);
 
     return result;
 }
@@ -1215,7 +1221,7 @@ RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
 // Returns the rotation angle and axis for a given quaternion
 RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle)
 {
-    if (fabs(q.w) > 1.0f) QuaternionNormalize(&q);
+    if (fabs(q.w) > 1.0f) q = QuaternionNormalize(q);
 
     Vector3 resAxis = { 0.0f, 0.0f, 0.0f };
     float resAngle = 0.0f;
@@ -1264,39 +1270,38 @@ RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw)
 // NOTE: Angles are returned in a Vector3 struct in degrees
 RMDEF Vector3 QuaternionToEuler(Quaternion q)
 {
-    Vector3 v = { 0 };
+    Vector3 result = { 0 };
 
 	// roll (x-axis rotation)
 	float x0 = 2.0f*(q.w*q.x + q.y*q.z);
 	float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y);
-	v.x = atan2f(x0, x1)*RAD2DEG;
+	result.x = atan2f(x0, x1)*RAD2DEG;
 
 	// pitch (y-axis rotation)
 	float y0 = 2.0f*(q.w*q.y - q.z*q.x);
 	y0 = y0 > 1.0f ? 1.0f : y0;
 	y0 = y0 < -1.0f ? -1.0f : y0;
-	v.y = asinf(y0)*RAD2DEG;
+	result.y = asinf(y0)*RAD2DEG;
 
 	// yaw (z-axis rotation)
 	float z0 = 2.0f*(q.w*q.z + q.x*q.y);
 	float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z);  
-	v.z = atan2f(z0, z1)*RAD2DEG;
+	result.z = atan2f(z0, z1)*RAD2DEG;
     
-    return v;
+    return result;
 }
 
 // Transform a quaternion given a transformation matrix
-RMDEF kt">void QuaternionTransform(Quaternion *q, Matrix mat)
+RMDEF n">Quaternion QuaternionTransform(Quaternion q, Matrix mat)
 {
-    float x = q->x;
-    float y = q->y;
-    float z = q->z;
-    float w = q->w;
+    Quaternion result = { 0 };
 
-    q->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12*w;
-    q->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13*w;
-    q->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14*w;
-    q->w = mat.m3*x + mat.m7*y + mat.m11*z + mat.m15*w;
+    result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w;
+    result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w;
+    result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w;
+    result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w;
+    
+    return result;
 }
 
 #endif  // RAYMATH_H

src/rlgl.c

@@ -470,7 +470,7 @@ void rlRotatef(float angleDeg, float x, float y, float z)
     Matrix matRotation = MatrixIdentity();
 
     Vector3 axis = (Vector3){ x, y, z };
-    Vector3Normalize(&axis);
+    axis = Vector3Normalize(axis);
     matRotation = MatrixRotate(axis, angleDeg*DEG2RAD);
 
     // NOTE: We transpose matrix with multiplication order
@@ -570,7 +570,7 @@ void rlEnd(void)
         // This way, rlTranslatef(), rlRotatef()... behaviour is the same than OpenGL 1.1
 
         // Apply transformation matrix to all temp vertices
-        for (int i = 0; i < tempBufferCount; i++) Vector3Transform(&tempBuffer[i], *currentMatrix);
+        for (int i = 0; i < tempBufferCount; i++) tempBuffer[i] = Vector3Transform(tempBuffer[i], *currentMatrix);
 
         // Deactivate tempBuffer usage to allow rlVertex3f do its job
         useTempBuffer = false;
@@ -1356,13 +1356,13 @@ Vector3 rlUnproject(Vector3 source, Matrix proj, Matrix view)
 
     // Calculate unproject matrix (multiply view patrix by projection matrix) and invert it
     Matrix matViewProj = MatrixMultiply(view, proj);
-    MatrixInvert(&matViewProj);
+    matViewProj= MatrixInvert(matViewProj);
 
     // Create quaternion from source point
     Quaternion quat = { source.x, source.y, source.z, 1.0f };
 
     // Multiply quat point by unproject matrix
-    QuaternionTransform(&quat, matViewProj);
+    quat = QuaternionTransform(quat, matViewProj);
 
     // Normalized world points in vectors
     result.x = quat.x/quat.w;