From 6ffc8cb7990fb4ff40f205cb53bec797b10e48a2 Mon Sep 17 00:00:00 2001
From: Ahmad Fatoum <ahmad@a3f.at>
Date: Thu, 22 Feb 2018 02:05:00 +0100
Subject: raymath.h: Use C99 inline semantics

RAYMATH_EXTERN_INLINE was renamed to RAYMATH_HEADER_ONLY, which user code
may define if they want to use it as header-only library. If multiple
files in the same project define RAYMATH_HEADER_ONLY, they might each
have duplicate out-of-line definitions of the same functions.

By default, raymath.h exposes inline definitions, which instructs the
compiler _not_ to generate out-of-line definitons, if out-of-line
definitions are required, those of the file defined with
RAYLIB_IMPLEMENTATION are used instead. There may be only one such file.

In C++ mode, the compiler will select only one out-of-line definition
automatically, so no need to define a RAYLIB_IMPLEMENTATION.

Unfortunately, we have to remove raymath function declaration from
raylib.h as those declarations would lead to duplicate out-of-line
definitions which would yield linker errors. This problem didn't
exist with GNU89 or C++, because there multiple defintions are ok,
but in C99 they aren't.
---
 examples/models/models_skybox.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'examples/models/models_skybox.c')

diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index 46297e41..9f0d8c17 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -62,7 +62,7 @@ int main()
 
             Begin3dMode(camera);
 
-                DrawModel(skybox, Vector3Zero(), 1.0f, WHITE);
+                DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
                 
                 DrawGrid(10, 1.0f);
 
-- 
cgit v1.2.3


From a5881fb9ccaf60ea0ff4f6afd7f3925e24330cac Mon Sep 17 00:00:00 2001
From: Ahmad Fatoum <ahmad@a3f.at>
Date: Sat, 24 Feb 2018 15:38:54 +0100
Subject: Revert "raymath.h: Use C99 inline semantics"

This reverts commit 6ffc8cb7990fb4ff40f205cb53bec797b10e48a2.
and commit e4d7bbec1ef08279495ac41f5f8c4be359c58cf0.
which I pushed by mistake...
---
 examples/models/models_skybox.c |   2 +-
 src/core.c                      |   7 +-
 src/raylib.h                    |   7 ++
 src/raymath.h                   | 189 ++++++++++++++++++++++++++++------------
 4 files changed, 145 insertions(+), 60 deletions(-)

(limited to 'examples/models/models_skybox.c')

diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index 9f0d8c17..46297e41 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -62,7 +62,7 @@ int main()
 
             Begin3dMode(camera);
 
-                DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
+                DrawModel(skybox, Vector3Zero(), 1.0f, WHITE);
                 
                 DrawGrid(10, 1.0f);
 
diff --git a/src/core.c b/src/core.c
index 0382aacd..137c0b61 100644
--- a/src/core.c
+++ b/src/core.c
@@ -98,12 +98,13 @@
     #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
 #endif
 
-#define RAYMATH_IMPLEMENTATION  // Define external out-of-line implementation of raymath here
-#include "raymath.h"            // Required for: Vector3 and Matrix functions
-
 #include "rlgl.h"           // raylib OpenGL abstraction layer to OpenGL 1.1, 3.3+ or ES2
 #include "utils.h"          // Required for: fopen() Android mapping
 
+#define RAYMATH_IMPLEMENTATION  // Use raymath as a header-only library (includes implementation)
+#define RAYMATH_EXTERN_INLINE   // Compile raymath functions as static inline (remember, it's a compiler hint)
+#include "raymath.h"            // Required for: Vector3 and Matrix functions
+
 #if defined(SUPPORT_GESTURES_SYSTEM)
     #define GESTURES_IMPLEMENTATION
     #include "gestures.h"       // Gestures detection functionality
diff --git a/src/raylib.h b/src/raylib.h
index 66598b27..41755dc3 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -742,6 +742,13 @@ RLAPI Vector3 ColorToHSV(Color color);                            // Returns HSV
 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
 
+// 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)
 RLAPI void SetConfigFlags(unsigned char flags);                   // Setup window configuration flags (view FLAGS)
diff --git a/src/raymath.h b/src/raymath.h
index a781ec80..c29c6b95 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -9,9 +9,8 @@
 *       If not defined, the library is in header only mode and can be included in other headers
 *       or source files without problems. But only ONE file should hold the implementation.
 *
-*   #define RAYMATH_HEADER_ONLY
-*       Define static inline functions code, so #include header suffices for use.
-*       This may use up lots of memory.
+*   #define RAYMATH_EXTERN_INLINE
+*       Inlines all functions code, so it runs faster. This requires lots of memory on system.
 *   
 *   #define RAYMATH_STANDALONE
 *       Avoid raylib.h header inclusion in this file. 
@@ -42,8 +41,8 @@
 #ifndef RAYMATH_H
 #define RAYMATH_H
 
-//#define RAYMATH_STANDALONE      // NOTE: To use raymath as standalone lib, just uncomment this line
-//#define RAYMATH_HEADER_ONLY     // NOTE: To compile functions as static inline, uncomment this line
+//#define RAYMATH_STANDALONE        // NOTE: To use raymath as standalone lib, just uncomment this line
+//#define RAYMATH_EXTERN_INLINE     // NOTE: To compile functions as static inline, uncomment this line
 
 #ifndef RAYMATH_STANDALONE
     #include "raylib.h"             // Required for structs: Vector3, Matrix
@@ -52,22 +51,15 @@
 #ifdef __cplusplus
     #define RMEXTERN extern "C"     // Functions visible from other files (no name mangling of functions in C++)
 #else
-    #define RMEXTERN                // Functions visible from other files
+    #define RMEXTERN extern         // Functions visible from other files
 #endif
 
-#if defined RAYMATH_IMPLEMENTATION && defined RAYMATH_HEADER_ONLY
-    #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_HEADER_ONLY is contradictory"
-#endif
-
-#ifdef RAYMATH_IMPLEMENTATION
-    #define RMDEF extern inline // Provide external definition
-#elif defined RAYMATH_HEADER_ONLY
-    #define RMDEF static inline // Functions may be inlined, no external out-of-line definition
+#if defined(RAYMATH_EXTERN_INLINE)
+    #define RMDEF RMEXTERN inline   // Functions are embeded inline (compiler generated code)
 #else
-    #define RMDEF inline        // Functions may be inlined or external definition used
+    #define RMDEF RMEXTERN
 #endif
 
-
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -110,14 +102,6 @@
     } Matrix;
 #endif
 
-// Helper types to be used instead of array return types for *ToFloat functions
-typedef struct Float3 {
-    float f[3];
-} Float3;
-typedef struct Float16 {
-    float f[16];
-} Float16;
-
 // Quaternion type
 typedef struct Quaternion {
     float x;
@@ -126,6 +110,105 @@ typedef struct Quaternion {
     float w;
 } Quaternion;
 
+#ifndef RAYMATH_EXTERN_INLINE
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - math utils
+//------------------------------------------------------------------------------------
+RMDEF float Clamp(float value, float min, float max);           // Clamp float value
+
+//------------------------------------------------------------------------------------
+// Functions Declaration to work with Vector2
+//------------------------------------------------------------------------------------
+RMDEF Vector2 Vector2Zero(void);                                // Vector with components value 0.0f
+RMDEF Vector2 Vector2One(void);                                 // Vector with components value 1.0f
+RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2);               // Add two vectors (v1 + v2)
+RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);          // Subtract two vectors (v1 - v2)
+RMDEF float Vector2Length(Vector2 v);                           // Calculate vector length
+RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2);          // Calculate two vectors dot product
+RMDEF float Vector2Distance(Vector2 v1, Vector2 v2);            // Calculate distance between two vectors
+RMDEF float Vector2Angle(Vector2 v1, Vector2 v2);               // Calculate angle between two vectors in X-axis
+RMDEF void Vector2Scale(Vector2 *v, float scale);               // Scale vector (multiply by value)
+RMDEF void Vector2Negate(Vector2 *v);                           // Negate vector
+RMDEF void Vector2Divide(Vector2 *v, float div);                // Divide vector by a float value
+RMDEF void Vector2Normalize(Vector2 *v);                        // Normalize provided vector
+
+//------------------------------------------------------------------------------------
+// Functions Declaration to work with Vector3
+//------------------------------------------------------------------------------------
+RMDEF Vector3 Vector3Zero(void);                                 // Vector with components value 0.0f
+RMDEF Vector3 Vector3One(void);                                  // Vector with components value 1.0f
+RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2);                // Add two vectors
+RMDEF Vector3 Vector3Multiply(Vector3 v, float scalar);          // Multiply vector by scalar
+RMDEF Vector3 Vector3MultiplyV(Vector3 v1, Vector3 v2);          // Multiply vector by vector
+RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);           // Substract two vectors
+RMDEF Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);       // Calculate two vectors cross product
+RMDEF Vector3 Vector3Perpendicular(Vector3 v);                   // Calculate one vector perpendicular vector
+RMDEF float Vector3Length(const Vector3 v);                      // Calculate vector length
+RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2);           // Calculate two vectors dot product
+RMDEF float Vector3Distance(Vector3 v1, Vector3 v2);             // Calculate distance between two points
+RMDEF void Vector3Scale(Vector3 *v, float scale);                // Scale provided vector
+RMDEF void Vector3Negate(Vector3 *v);                            // Negate provided vector (invert direction)
+RMDEF void Vector3Normalize(Vector3 *v);                         // Normalize provided vector
+RMDEF void Vector3Transform(Vector3 *v, Matrix mat);             // Transforms a Vector3 by a given Matrix
+RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount); // Calculate linear interpolation between two vectors
+RMDEF Vector3 Vector3Reflect(Vector3 vector, Vector3 normal);    // Calculate reflected vector to normal
+RMDEF Vector3 Vector3Min(Vector3 vec1, Vector3 vec2);            // Return min value for each pair of components
+RMDEF Vector3 Vector3Max(Vector3 vec1, Vector3 vec2);            // Return max value for each pair of components
+RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c); // Barycenter coords for p in triangle abc
+RMDEF float *Vector3ToFloat(Vector3 vec);                        // Returns Vector3 as float array
+
+//------------------------------------------------------------------------------------
+// Functions Declaration to work with Matrix
+//------------------------------------------------------------------------------------
+RMDEF float MatrixDeterminant(Matrix mat);                      // Compute matrix determinant
+RMDEF float MatrixTrace(Matrix mat);                            // Returns the trace of the matrix (sum of the values along the diagonal)
+RMDEF void MatrixTranspose(Matrix *mat);                        // Transposes provided matrix
+RMDEF void MatrixInvert(Matrix *mat);                           // Invert provided matrix
+RMDEF void MatrixNormalize(Matrix *mat);                        // Normalize provided matrix
+RMDEF Matrix MatrixIdentity(void);                              // Returns identity matrix
+RMDEF Matrix MatrixAdd(Matrix left, Matrix right);              // Add two matrices
+RMDEF Matrix MatrixSubstract(Matrix left, Matrix right);        // Substract two matrices (left - right)
+RMDEF Matrix MatrixTranslate(float x, float y, float z);        // Returns translation matrix
+RMDEF Matrix MatrixRotate(Vector3 axis, float angle);           // Returns rotation matrix for an angle around an specified axis (angle in radians)
+RMDEF Matrix MatrixRotateX(float angle);                        // Returns x-rotation matrix (angle in radians)
+RMDEF Matrix MatrixRotateY(float angle);                        // Returns y-rotation matrix (angle in radians)
+RMDEF Matrix MatrixRotateZ(float angle);                        // Returns z-rotation matrix (angle in radians)
+RMDEF Matrix MatrixScale(float x, float y, float z);            // Returns scaling matrix
+RMDEF Matrix MatrixMultiply(Matrix left, Matrix right);         // Returns two matrix multiplication
+RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far);  // Returns perspective projection matrix
+RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far);                        // Returns perspective projection matrix
+RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);    // Returns orthographic projection matrix
+RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up);  // Returns camera look-at matrix (view matrix)
+RMDEF float *MatrixToFloat(Matrix mat);                         // Returns float array of Matrix data
+
+//------------------------------------------------------------------------------------
+// Functions Declaration to work with Quaternions
+//------------------------------------------------------------------------------------
+RMDEF Quaternion QuaternionIdentity(void);                      // Returns identity quaternion
+RMDEF float QuaternionLength(Quaternion quat);                  // Compute the length of a quaternion
+RMDEF void QuaternionNormalize(Quaternion *q);                  // Normalize provided quaternion
+RMDEF void QuaternionInvert(Quaternion *quat);                  // Invert provided quaternion
+RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);    // Calculate two quaternion multiplication
+RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);    // Calculate linear interpolation between two quaternions
+RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);   // Calculate slerp-optimized interpolation between two quaternions
+RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);   // Calculates spherical linear interpolation between two quaternions
+RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);      // Calculate quaternion based on the rotation from one vector to another
+RMDEF Quaternion QuaternionFromMatrix(Matrix matrix);                 // Returns a quaternion for a given rotation matrix
+RMDEF Matrix QuaternionToMatrix(Quaternion q);                        // Returns a matrix for a given quaternion
+RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);  // Returns rotation quaternion for an angle and axis
+RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle);  // Returns the rotation angle and axis for a given quaternion
+RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw);           // Returns he quaternion equivalent to Euler angles
+RMDEF Vector3 QuaternionToEuler(Quaternion q);                  // Return the Euler angles equivalent to quaternion (roll, pitch, yaw)
+RMDEF void QuaternionTransform(Quaternion *q, Matrix mat);      // Transform a quaternion given a transformation matrix
+
+#endif  // notdef RAYMATH_EXTERN_INLINE
+
+#endif  // RAYMATH_H
+//////////////////////////////////////////////////////////////////// end of header file
+
+#if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE)
+
 #include <math.h>       // Required for: sinf(), cosf(), tan(), fabs()
 
 //----------------------------------------------------------------------------------
@@ -465,19 +548,16 @@ RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
 }
 
 // Returns Vector3 as float array
-RMDEF Float3 Vector3ToFloat_(Vector3 vec)
+RMDEF float *Vector3ToFloat(Vector3 vec)
 {
-    Float3 buffer;
+    static float buffer[3];
 
-    buffer.f[0] = vec.x;
-    buffer.f[1] = vec.y;
-    buffer.f[2] = vec.z;
+    buffer[0] = vec.x;
+    buffer[1] = vec.y;
+    buffer[2] = vec.z;
 
     return buffer;
 }
-#ifndef Vector3ToFloat
-#define Vector3ToFloat(vec) (Vector3ToFloat_(vec).f) 
-#endif
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Matrix math
@@ -913,32 +993,29 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
 }
 
 // Returns float array of matrix data
-RMDEF Float16 MatrixToFloat_(Matrix mat)
-{
-    Float16 buffer;
-
-    buffer.f[0] = mat.m0;
-    buffer.f[1] = mat.m1;
-    buffer.f[2] = mat.m2;
-    buffer.f[3] = mat.m3;
-    buffer.f[4] = mat.m4;
-    buffer.f[5] = mat.m5;
-    buffer.f[6] = mat.m6;
-    buffer.f[7] = mat.m7;
-    buffer.f[8] = mat.m8;
-    buffer.f[9] = mat.m9;
-    buffer.f[10] = mat.m10;
-    buffer.f[11] = mat.m11;
-    buffer.f[12] = mat.m12;
-    buffer.f[13] = mat.m13;
-    buffer.f[14] = mat.m14;
-    buffer.f[15] = mat.m15;
+RMDEF float *MatrixToFloat(Matrix mat)
+{
+    static float buffer[16];
+
+    buffer[0] = mat.m0;
+    buffer[1] = mat.m1;
+    buffer[2] = mat.m2;
+    buffer[3] = mat.m3;
+    buffer[4] = mat.m4;
+    buffer[5] = mat.m5;
+    buffer[6] = mat.m6;
+    buffer[7] = mat.m7;
+    buffer[8] = mat.m8;
+    buffer[9] = mat.m9;
+    buffer[10] = mat.m10;
+    buffer[11] = mat.m11;
+    buffer[12] = mat.m12;
+    buffer[13] = mat.m13;
+    buffer[14] = mat.m14;
+    buffer[15] = mat.m15;
 
     return buffer;
 }
-#ifndef MatrixToFloat
-#define MatrixToFloat(mat) (MatrixToFloat_(mat).f)
-#endif
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Quaternion math
@@ -1301,4 +1378,4 @@ RMDEF void QuaternionTransform(Quaternion *q, Matrix mat)
     q->w = mat.m3*x + mat.m7*y + mat.m11*z + mat.m15*w;
 }
 
-#endif  // RAYMATH_H
+#endif  // RAYMATH_IMPLEMENTATION
-- 
cgit v1.2.3


From f52d2de582643719814987f7335668b611a4edbd Mon Sep 17 00:00:00 2001
From: Ahmad Fatoum <ahmad@a3f.at>
Date: Thu, 22 Feb 2018 02:05:00 +0100
Subject: raymath.h: Use C99 inline semantics

RAYMATH_EXTERN_INLINE was renamed to RAYMATH_HEADER_ONLY, which user code
may define if they want to use it as header-only library. If multiple
files in the same project define RAYMATH_HEADER_ONLY, they might each
have duplicate out-of-line definitions of the same functions.

By default, raymath.h exposes inline definitions, which instructs the
compiler _not_ to generate out-of-line definitons, if out-of-line
definitions are required, those of the file defined with
RAYLIB_IMPLEMENTATION are used instead. There may be only one such file.

In C++ mode, the compiler will select only one out-of-line definition
automatically, so no need to define a RAYLIB_IMPLEMENTATION.

Unfortunately, we have to remove raymath function declaration from
raylib.h as those declarations would lead to duplicate out-of-line
definitions which would yield linker errors. This problem didn't
exist with GNU89 or C++, because there multiple defintions are ok,
but in C99 they aren't.
---
 examples/models/models_skybox.c |   2 +-
 src/core.c                      |   7 +-
 src/raylib.h                    |  21 ------
 src/raymath.h                   | 139 ++++++++--------------------------------
 4 files changed, 29 insertions(+), 140 deletions(-)

(limited to 'examples/models/models_skybox.c')

diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index 46297e41..9f0d8c17 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -62,7 +62,7 @@ int main()
 
             Begin3dMode(camera);
 
-                DrawModel(skybox, Vector3Zero(), 1.0f, WHITE);
+                DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
                 
                 DrawGrid(10, 1.0f);
 
diff --git a/src/core.c b/src/core.c
index 137c0b61..0382aacd 100644
--- a/src/core.c
+++ b/src/core.c
@@ -98,13 +98,12 @@
     #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
 #endif
 
+#define RAYMATH_IMPLEMENTATION  // Define external out-of-line implementation of raymath here
+#include "raymath.h"            // Required for: Vector3 and Matrix functions
+
 #include "rlgl.h"           // raylib OpenGL abstraction layer to OpenGL 1.1, 3.3+ or ES2
 #include "utils.h"          // Required for: fopen() Android mapping
 
-#define RAYMATH_IMPLEMENTATION  // Use raymath as a header-only library (includes implementation)
-#define RAYMATH_EXTERN_INLINE   // Compile raymath functions as static inline (remember, it's a compiler hint)
-#include "raymath.h"            // Required for: Vector3 and Matrix functions
-
 #if defined(SUPPORT_GESTURES_SYSTEM)
     #define GESTURES_IMPLEMENTATION
     #include "gestures.h"       // Gestures detection functionality
diff --git a/src/raylib.h b/src/raylib.h
index a740e234..66598b27 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -338,14 +338,6 @@ typedef struct Matrix {
     float m3, m7, m11, m15;
 } Matrix;
 
-typedef struct Float3 {
-    float f[3];
-} Float3;
-
-typedef struct Float16 {
-    float f[16];
-} Float16;
-
 // Color type, RGBA (32bit)
 typedef struct Color {
     unsigned char r;
@@ -750,19 +742,6 @@ RLAPI Vector3 ColorToHSV(Color color);                            // Returns HSV
 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
 
-// Math useful functions (available from raymath.h)
-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
-#ifndef Vector3ToFloat
-#define Vector3ToFloat(vec) (Vector3ToFloat_(vec).f)              // Returns Vector3 as float array
-RLAPI Float3 Vector3ToFloat_(Vector3 vec);                        // don't use, use above
-#endif
-#ifndef MatrixToFloat
-#define MatrixToFloat(mat) (MatrixToFloat_(mat).f)                // Returns Matrix as float array
-RLAPI Float16 MatrixToFloat_(Matrix mat);                         // don't use, use above
-#endif
-
 // Misc. functions
 RLAPI void ShowLogo(void);                                        // Activate raylib logo at startup (can be done with flags)
 RLAPI void SetConfigFlags(unsigned char flags);                   // Setup window configuration flags (view FLAGS)
diff --git a/src/raymath.h b/src/raymath.h
index 0eb010f1..a781ec80 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -9,8 +9,9 @@
 *       If not defined, the library is in header only mode and can be included in other headers
 *       or source files without problems. But only ONE file should hold the implementation.
 *
-*   #define RAYMATH_EXTERN_INLINE
-*       Inlines all functions code, so it runs faster. This requires lots of memory on system.
+*   #define RAYMATH_HEADER_ONLY
+*       Define static inline functions code, so #include header suffices for use.
+*       This may use up lots of memory.
 *   
 *   #define RAYMATH_STANDALONE
 *       Avoid raylib.h header inclusion in this file. 
@@ -41,8 +42,8 @@
 #ifndef RAYMATH_H
 #define RAYMATH_H
 
-//#define RAYMATH_STANDALONE        // NOTE: To use raymath as standalone lib, just uncomment this line
-//#define RAYMATH_EXTERN_INLINE     // NOTE: To compile functions as static inline, uncomment this line
+//#define RAYMATH_STANDALONE      // NOTE: To use raymath as standalone lib, just uncomment this line
+//#define RAYMATH_HEADER_ONLY     // NOTE: To compile functions as static inline, uncomment this line
 
 #ifndef RAYMATH_STANDALONE
     #include "raylib.h"             // Required for structs: Vector3, Matrix
@@ -51,15 +52,22 @@
 #ifdef __cplusplus
     #define RMEXTERN extern "C"     // Functions visible from other files (no name mangling of functions in C++)
 #else
-    #define RMEXTERN extern         // Functions visible from other files
+    #define RMEXTERN                // Functions visible from other files
 #endif
 
-#if defined(RAYMATH_EXTERN_INLINE)
-    #define RMDEF RMEXTERN inline   // Functions are embeded inline (compiler generated code)
+#if defined RAYMATH_IMPLEMENTATION && defined RAYMATH_HEADER_ONLY
+    #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_HEADER_ONLY is contradictory"
+#endif
+
+#ifdef RAYMATH_IMPLEMENTATION
+    #define RMDEF extern inline // Provide external definition
+#elif defined RAYMATH_HEADER_ONLY
+    #define RMDEF static inline // Functions may be inlined, no external out-of-line definition
 #else
-    #define RMDEF RMEXTERN
+    #define RMDEF inline        // Functions may be inlined or external definition used
 #endif
 
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -100,14 +108,16 @@
         float m2, m6, m10, m14;
         float m3, m7, m11, m15;
     } Matrix;
-    typedef struct Float3 {
-        float f[3];
-    } Float3;
-    typedef struct Float16 {
-        float f[16];
-    } Float16;
 #endif
 
+// Helper types to be used instead of array return types for *ToFloat functions
+typedef struct Float3 {
+    float f[3];
+} Float3;
+typedef struct Float16 {
+    float f[16];
+} Float16;
+
 // Quaternion type
 typedef struct Quaternion {
     float x;
@@ -116,105 +126,6 @@ typedef struct Quaternion {
     float w;
 } Quaternion;
 
-#ifndef RAYMATH_EXTERN_INLINE
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - math utils
-//------------------------------------------------------------------------------------
-RMDEF float Clamp(float value, float min, float max);           // Clamp float value
-
-//------------------------------------------------------------------------------------
-// Functions Declaration to work with Vector2
-//------------------------------------------------------------------------------------
-RMDEF Vector2 Vector2Zero(void);                                // Vector with components value 0.0f
-RMDEF Vector2 Vector2One(void);                                 // Vector with components value 1.0f
-RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2);               // Add two vectors (v1 + v2)
-RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);          // Subtract two vectors (v1 - v2)
-RMDEF float Vector2Length(Vector2 v);                           // Calculate vector length
-RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2);          // Calculate two vectors dot product
-RMDEF float Vector2Distance(Vector2 v1, Vector2 v2);            // Calculate distance between two vectors
-RMDEF float Vector2Angle(Vector2 v1, Vector2 v2);               // Calculate angle between two vectors in X-axis
-RMDEF void Vector2Scale(Vector2 *v, float scale);               // Scale vector (multiply by value)
-RMDEF void Vector2Negate(Vector2 *v);                           // Negate vector
-RMDEF void Vector2Divide(Vector2 *v, float div);                // Divide vector by a float value
-RMDEF void Vector2Normalize(Vector2 *v);                        // Normalize provided vector
-
-//------------------------------------------------------------------------------------
-// Functions Declaration to work with Vector3
-//------------------------------------------------------------------------------------
-RMDEF Vector3 Vector3Zero(void);                                 // Vector with components value 0.0f
-RMDEF Vector3 Vector3One(void);                                  // Vector with components value 1.0f
-RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2);                // Add two vectors
-RMDEF Vector3 Vector3Multiply(Vector3 v, float scalar);          // Multiply vector by scalar
-RMDEF Vector3 Vector3MultiplyV(Vector3 v1, Vector3 v2);          // Multiply vector by vector
-RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);           // Substract two vectors
-RMDEF Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);       // Calculate two vectors cross product
-RMDEF Vector3 Vector3Perpendicular(Vector3 v);                   // Calculate one vector perpendicular vector
-RMDEF float Vector3Length(const Vector3 v);                      // Calculate vector length
-RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2);           // Calculate two vectors dot product
-RMDEF float Vector3Distance(Vector3 v1, Vector3 v2);             // Calculate distance between two points
-RMDEF void Vector3Scale(Vector3 *v, float scale);                // Scale provided vector
-RMDEF void Vector3Negate(Vector3 *v);                            // Negate provided vector (invert direction)
-RMDEF void Vector3Normalize(Vector3 *v);                         // Normalize provided vector
-RMDEF void Vector3Transform(Vector3 *v, Matrix mat);             // Transforms a Vector3 by a given Matrix
-RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount); // Calculate linear interpolation between two vectors
-RMDEF Vector3 Vector3Reflect(Vector3 vector, Vector3 normal);    // Calculate reflected vector to normal
-RMDEF Vector3 Vector3Min(Vector3 vec1, Vector3 vec2);            // Return min value for each pair of components
-RMDEF Vector3 Vector3Max(Vector3 vec1, Vector3 vec2);            // Return max value for each pair of components
-RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c); // Barycenter coords for p in triangle abc
-RMDEF Float3 Vector3ToFloat_(Vector3 vec);                       // Returns Vector3 as float array
-
-//------------------------------------------------------------------------------------
-// Functions Declaration to work with Matrix
-//------------------------------------------------------------------------------------
-RMDEF float MatrixDeterminant(Matrix mat);                      // Compute matrix determinant
-RMDEF float MatrixTrace(Matrix mat);                            // Returns the trace of the matrix (sum of the values along the diagonal)
-RMDEF void MatrixTranspose(Matrix *mat);                        // Transposes provided matrix
-RMDEF void MatrixInvert(Matrix *mat);                           // Invert provided matrix
-RMDEF void MatrixNormalize(Matrix *mat);                        // Normalize provided matrix
-RMDEF Matrix MatrixIdentity(void);                              // Returns identity matrix
-RMDEF Matrix MatrixAdd(Matrix left, Matrix right);              // Add two matrices
-RMDEF Matrix MatrixSubstract(Matrix left, Matrix right);        // Substract two matrices (left - right)
-RMDEF Matrix MatrixTranslate(float x, float y, float z);        // Returns translation matrix
-RMDEF Matrix MatrixRotate(Vector3 axis, float angle);           // Returns rotation matrix for an angle around an specified axis (angle in radians)
-RMDEF Matrix MatrixRotateX(float angle);                        // Returns x-rotation matrix (angle in radians)
-RMDEF Matrix MatrixRotateY(float angle);                        // Returns y-rotation matrix (angle in radians)
-RMDEF Matrix MatrixRotateZ(float angle);                        // Returns z-rotation matrix (angle in radians)
-RMDEF Matrix MatrixScale(float x, float y, float z);            // Returns scaling matrix
-RMDEF Matrix MatrixMultiply(Matrix left, Matrix right);         // Returns two matrix multiplication
-RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far);  // Returns perspective projection matrix
-RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far);                        // Returns perspective projection matrix
-RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);    // Returns orthographic projection matrix
-RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up);  // Returns camera look-at matrix (view matrix)
-RMDEF Float16 MatrixToFloat_(Matrix mat);                       // Returns float array of Matrix data
-
-//------------------------------------------------------------------------------------
-// Functions Declaration to work with Quaternions
-//------------------------------------------------------------------------------------
-RMDEF Quaternion QuaternionIdentity(void);                      // Returns identity quaternion
-RMDEF float QuaternionLength(Quaternion quat);                  // Compute the length of a quaternion
-RMDEF void QuaternionNormalize(Quaternion *q);                  // Normalize provided quaternion
-RMDEF void QuaternionInvert(Quaternion *quat);                  // Invert provided quaternion
-RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);    // Calculate two quaternion multiplication
-RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);    // Calculate linear interpolation between two quaternions
-RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);   // Calculate slerp-optimized interpolation between two quaternions
-RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);   // Calculates spherical linear interpolation between two quaternions
-RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);      // Calculate quaternion based on the rotation from one vector to another
-RMDEF Quaternion QuaternionFromMatrix(Matrix matrix);                 // Returns a quaternion for a given rotation matrix
-RMDEF Matrix QuaternionToMatrix(Quaternion q);                        // Returns a matrix for a given quaternion
-RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);  // Returns rotation quaternion for an angle and axis
-RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle);  // Returns the rotation angle and axis for a given quaternion
-RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw);           // Returns he quaternion equivalent to Euler angles
-RMDEF Vector3 QuaternionToEuler(Quaternion q);                  // Return the Euler angles equivalent to quaternion (roll, pitch, yaw)
-RMDEF void QuaternionTransform(Quaternion *q, Matrix mat);      // Transform a quaternion given a transformation matrix
-
-#endif  // notdef RAYMATH_EXTERN_INLINE
-
-#endif  // RAYMATH_H
-//////////////////////////////////////////////////////////////////// end of header file
-
-#if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE)
-
 #include <math.h>       // Required for: sinf(), cosf(), tan(), fabs()
 
 //----------------------------------------------------------------------------------
@@ -1390,4 +1301,4 @@ RMDEF void QuaternionTransform(Quaternion *q, Matrix mat)
     q->w = mat.m3*x + mat.m7*y + mat.m11*z + mat.m15*w;
 }
 
-#endif  // RAYMATH_IMPLEMENTATION
+#endif  // RAYMATH_H
-- 
cgit v1.2.3


From 4cc12ef2b32f66f160e4e401e5cd76d1740eaf61 Mon Sep 17 00:00:00 2001
From: Ray San <raysan5@gmail.com>
Date: Wed, 11 Apr 2018 10:13:00 +0200
Subject: Review camera definition on examples

---
 examples/core/core_3d_camera_first_person.c      |  7 ++++-
 examples/core/core_world_screen.c                |  7 ++++-
 examples/models/models_billboard.c               |  8 ++++-
 examples/models/models_box_collisions.c          |  2 +-
 examples/models/models_cubicmap.c                |  2 +-
 examples/models/models_geometric_shapes.c        |  7 ++++-
 examples/models/models_heightmap.c               |  2 +-
 examples/models/models_material_pbr.c            |  2 +-
 examples/models/models_mesh_generation.c         |  2 +-
 examples/models/models_obj_loading.c             |  7 ++++-
 examples/models/models_orthographic_projection.c | 37 +++++++-----------------
 examples/models/models_skybox.c                  |  2 +-
 examples/models/models_yaw_pitch_roll.c          |  1 +
 examples/shaders/shaders_custom_uniform.c        |  7 ++++-
 examples/shaders/shaders_model_shader.c          |  7 ++++-
 examples/shaders/shaders_postprocessing.c        |  2 +-
 src/raylib.h                                     | 14 ++++-----
 17 files changed, 69 insertions(+), 47 deletions(-)

(limited to 'examples/models/models_skybox.c')

diff --git a/examples/core/core_3d_camera_first_person.c b/examples/core/core_3d_camera_first_person.c
index 3998af81..775e6c57 100644
--- a/examples/core/core_3d_camera_first_person.c
+++ b/examples/core/core_3d_camera_first_person.c
@@ -23,7 +23,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
     
     // Define the camera to look into our 3d world (position, target, up vector)
-    Camera camera = {{ 4.0f, 2.0f, 4.0f }, { 0.0f, 1.8f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 60.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 4.0f, 2.0f, 4.0f };
+    camera.target = (Vector3){ 0.0f, 1.8f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 60.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     // Generates some random columns
     float heights[MAX_COLUMNS];
diff --git a/examples/core/core_world_screen.c b/examples/core/core_world_screen.c
index f8c53c70..78ca6eb4 100644
--- a/examples/core/core_world_screen.c
+++ b/examples/core/core_world_screen.c
@@ -21,7 +21,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 10.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 10.0f, 10.0f, 10.0f };
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
     
diff --git a/examples/models/models_billboard.c b/examples/models/models_billboard.c
index bca9faf8..3b3efc47 100644
--- a/examples/models/models_billboard.c
+++ b/examples/models/models_billboard.c
@@ -21,7 +21,13 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 5.0f, 4.0f, 5.0f }, { 0.0f, 2.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 5.0f, 4.0f, 5.0f };
+    camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
+    
 
     Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
     Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
diff --git a/examples/models/models_box_collisions.c b/examples/models/models_box_collisions.c
index 69cec418..eb72c54c 100644
--- a/examples/models/models_box_collisions.c
+++ b/examples/models/models_box_collisions.c
@@ -21,7 +21,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
     
     Vector3 playerPosition = { 0.0f, 1.0f, 2.0f };
     Vector3 playerSize = { 1.0f, 2.0f, 1.0f };
diff --git a/examples/models/models_cubicmap.c b/examples/models/models_cubicmap.c
index d8be9329..47b88748 100644
--- a/examples/models/models_cubicmap.c
+++ b/examples/models/models_cubicmap.c
@@ -21,7 +21,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 16.0f, 14.0f, 16.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 16.0f, 14.0f, 16.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
     Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
     Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
diff --git a/examples/models/models_geometric_shapes.c b/examples/models/models_geometric_shapes.c
index a13a1f3b..7a1e7e48 100644
--- a/examples/models/models_geometric_shapes.c
+++ b/examples/models/models_geometric_shapes.c
@@ -21,7 +21,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
diff --git a/examples/models/models_heightmap.c b/examples/models/models_heightmap.c
index e476d1b7..55474185 100644
--- a/examples/models/models_heightmap.c
+++ b/examples/models/models_heightmap.c
@@ -21,7 +21,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
 
     // Define our custom camera to look into our 3d world
-    Camera camera = {{ 18.0f, 16.0f, 18.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 18.0f, 16.0f, 18.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
     Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
     Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
diff --git a/examples/models/models_material_pbr.c b/examples/models/models_material_pbr.c
index d98d7eac..4ad2c9e7 100644
--- a/examples/models/models_material_pbr.c
+++ b/examples/models/models_material_pbr.c
@@ -34,7 +34,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - pbr material");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 0.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 0.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
     // Load model and PBR material
     Model model = LoadModel("resources/pbr/trooper.obj");
diff --git a/examples/models/models_mesh_generation.c b/examples/models/models_mesh_generation.c
index 72222156..d9c28ac2 100644
--- a/examples/models/models_mesh_generation.c
+++ b/examples/models/models_mesh_generation.c
@@ -41,7 +41,7 @@ int main()
     for (int i = 0; i < NUM_MODELS; i++) models[i].material.maps[MAP_DIFFUSE].texture = texture;
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 5.0f, 5.0f, 5.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 5.0f, 5.0f, 5.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
     // Model drawing position
     Vector3 position = { 0.0f, 0.0f, 0.0f };
diff --git a/examples/models/models_obj_loading.c b/examples/models/models_obj_loading.c
index 70f92168..4f89130f 100644
--- a/examples/models/models_obj_loading.c
+++ b/examples/models/models_obj_loading.c
@@ -21,7 +21,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 3.0f, 3.0f, 3.0f };
+    camera.target = (Vector3){ 0.0f, 1.5f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     Model dwarf = LoadModel("resources/model/dwarf.obj");                   // Load OBJ model
     Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png");   // Load model texture
diff --git a/examples/models/models_orthographic_projection.c b/examples/models/models_orthographic_projection.c
index 2c2a89d1..cb5ea053 100644
--- a/examples/models/models_orthographic_projection.c
+++ b/examples/models/models_orthographic_projection.c
@@ -4,17 +4,17 @@
 *
 *   This program is heavily based on the geometric objects example
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
+*   This example has been created using raylib 1.9.7 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2018 Max Danielsson & Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
-#define FOVY_PERSPECTIVE 45.0f
-#define WIDTH_ORTHOGRAPHIC 10.0f
+#define FOVY_PERSPECTIVE    45.0f
+#define WIDTH_ORTHOGRAPHIC  10.0f
 
 int main()
 {
@@ -36,15 +36,9 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        // TODO: Update your variables here
-        //----------------------------------------------------------------------------------
-        //
-
-        // Input
-        //----------------------------------------------------------------------------------
-        if(IsKeyPressed(KEY_SPACE)) 
+        if (IsKeyPressed(KEY_SPACE)) 
         {
-            if(camera.type == CAMERA_PERSPECTIVE) 
+            if (camera.type == CAMERA_PERSPECTIVE) 
             {
                 camera.fovy = WIDTH_ORTHOGRAPHIC;
                 camera.type = CAMERA_ORTHOGRAPHIC;
@@ -55,12 +49,10 @@ int main()
                 camera.type = CAMERA_PERSPECTIVE;
             }
         }
-
+        //----------------------------------------------------------------------------------
 
         // Draw
         //----------------------------------------------------------------------------------
-
-
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
@@ -85,19 +77,12 @@ int main()
 
             End3dMode();
 
-            DrawFPS(10, 10);
+            DrawText("Press Spacebar to switch camera type", 10, GetScreenHeight() - 30, 20, DARKGRAY);
 
-            DrawText("Press Spacebar to switch camera type", 10, 40, 24, BLACK);
-
-            if(camera.type == CAMERA_ORTHOGRAPHIC)
-            {
-                DrawText("Orthographic", 10, 65, 24, BLACK);
-            }
-            else if(camera.type == CAMERA_PERSPECTIVE)
-            {
-                DrawText("Perspective", 10, 65, 24, BLACK);
-            }
+            if (camera.type == CAMERA_ORTHOGRAPHIC) DrawText("ORTHOGRAPHIC", 10, 40, 20, BLACK);
+            else if (camera.type == CAMERA_PERSPECTIVE) DrawText("PERSPECTIVE", 10, 40, 20, BLACK);
 
+            DrawFPS(10, 10);
 
         EndDrawing();
         //----------------------------------------------------------------------------------
diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index 9f0d8c17..700824d3 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -21,7 +21,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 1.0f, 1.0f, 1.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 1.0f, 1.0f, 1.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
     // Load skybox model   
     Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
diff --git a/examples/models/models_yaw_pitch_roll.c b/examples/models/models_yaw_pitch_roll.c
index 4fdbd4d7..c559e67b 100644
--- a/examples/models/models_yaw_pitch_roll.c
+++ b/examples/models/models_yaw_pitch_roll.c
@@ -48,6 +48,7 @@ int main()
     camera.target = (Vector3){ 0.0f, 12.0f, 0.0f };     // Camera looking at point
     camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
     camera.fovy = 30.0f;                                // Camera field-of-view Y
+    camera.type = CAMERA_PERSPECTIVE;                   // Camera type
 
     float pitch = 0.0f;
     float roll = 0.0f;
diff --git a/examples/shaders/shaders_custom_uniform.c b/examples/shaders/shaders_custom_uniform.c
index a0f6fd22..4e160455 100644
--- a/examples/shaders/shaders_custom_uniform.c
+++ b/examples/shaders/shaders_custom_uniform.c
@@ -30,7 +30,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 3.0f, 3.0f, 3.0f };
+    camera.target = (Vector3){ 0.0f, 1.5f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     Model dwarf = LoadModel("resources/model/dwarf.obj");                   // Load OBJ model
     Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png");   // Load model texture (diffuse map)
diff --git a/examples/shaders/shaders_model_shader.c b/examples/shaders/shaders_model_shader.c
index f1a349c6..51acc836 100644
--- a/examples/shaders/shaders_model_shader.c
+++ b/examples/shaders/shaders_model_shader.c
@@ -30,7 +30,12 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 3.0f, 3.0f, 3.0f };
+    camera.target = (Vector3){ 0.0f, 1.5f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
 
     Model dwarf = LoadModel("resources/model/dwarf.obj");                   // Load OBJ model
     Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png");   // Load model texture
diff --git a/examples/shaders/shaders_postprocessing.c b/examples/shaders/shaders_postprocessing.c
index b8b5f6ae..5eeda896 100644
--- a/examples/shaders/shaders_postprocessing.c
+++ b/examples/shaders/shaders_postprocessing.c
@@ -70,7 +70,7 @@ int main()
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader");
 
     // Define the camera to look into our 3d world
-    Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+    Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
     
     Model dwarf = LoadModel("resources/model/dwarf.obj");                   // Load OBJ model
     Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png");   // Load model texture (diffuse map)
diff --git a/src/raylib.h b/src/raylib.h
index fd4b9b21..9c50ecf7 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -396,19 +396,13 @@ typedef struct SpriteFont {
     CharInfo *chars;        // Characters info data
 } SpriteFont;
 
-// Camera projection modes
-typedef enum {
-    CAMERA_PERSPECTIVE = 0,
-    CAMERA_ORTHOGRAPHIC
-} CameraType;
-
 // Camera type, defines a camera position/orientation in 3d space
 typedef struct Camera {
     Vector3 position;       // Camera position
     Vector3 target;         // Camera target it looks-at
     Vector3 up;             // Camera up vector (rotation over its axis)
     float fovy;             // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
-    CameraType type;        // Camera type, controlling projection type, either CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC.
+    int type;               // Camera type, defines projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
 } Camera;
 
 // Camera2D type, defines a 2d camera
@@ -673,6 +667,12 @@ typedef enum {
     CAMERA_THIRD_PERSON
 } CameraMode;
 
+// Camera projection modes
+typedef enum {
+    CAMERA_PERSPECTIVE = 0,
+    CAMERA_ORTHOGRAPHIC
+} CameraType;
+
 // Head Mounted Display devices
 typedef enum {
     HMD_DEFAULT_DEVICE = 0,
-- 
cgit v1.2.3