Merge branch 'master' of github.com:raysan5/raylib into fork/master

1 files changed, 407 insertions, 232 deletions

diff --git a/src/Makefile b/src/Makefile
index 06b67a04..7837b614 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -2,18 +2,19 @@
 #
 #  raylib makefile
 #
-#  Platforms supported: 
-#    PLATFORM_DESKTOP:  Windows (win32/Win64)
-#    PLATFORM_DESKTOP:  Linux
-#    PLATFORM_DESKTOP:  OSX (Mac)
-#    PLATFORM_ANDROID:  Android (ARM or ARM64)
+#  Platforms supported:
+#    PLATFORM_DESKTOP:  Windows (Win32, Win64)
+#    PLATFORM_DESKTOP:  Linux (32 and 64 bit)
+#    PLATFORM_DESKTOP:  OSX/macOS
+#    PLATFORM_DESKTOP:  FreeBSD
+#    PLATFORM_ANDROID:  Android (ARM, ARM64)
 #    PLATFORM_RPI:      Raspberry Pi (Raspbian)
 #    PLATFORM_WEB:      HTML5 (Chrome, Firefox)
 #
 #  Many thanks to Milan Nikolic (@gen2brain) for implementing Android platform pipeline.
 #  Many thanks to Emanuele Petriglia for his contribution on GNU/Linux pipeline.
 #
-#  Copyright (c) 2014-2017 Ramon Santamaria (@raysan5)
+#  Copyright (c) 2014-2018 Ramon Santamaria (@raysan5)
 #
 #  This software is provided "as-is", without any express or implied warranty.
 #  In no event will the authors be held liable for any damages arising from
@@ -35,61 +36,124 @@
 #
 #******************************************************************************
 
-# Please read the wiki to know how to compile raylib, because there are
-# different methods.
+# Please read the wiki to know how to compile raylib, because there are different methods.
+# https://github.com/raysan5/raylib/wiki
 
 .PHONY: all clean install uninstall
 
-# define raylib platform to compile for
-# possible platforms: PLATFORM_DESKTOP PLATFORM_ANDROID PLATFORM_RPI PLATFORM_WEB
-PLATFORM ?= PLATFORM_DESKTOP
+# Define required raylib variables
+RAYLIB_VERSION     = 1.9.4
+RAYLIB_API_VERSION = 1
 
-# define raylib default path, required to look for emsdk and android-toolchain
-RAYLIB_PATH ?= C:/raylib
+# See below for alternatives.
+RAYLIB_PATH        = ..
 
-# define YES if you want shared/dynamic version of library instead of static (default)
-SHARED_RAYLIB ?= NO
+# Define default options
 
-# use OpenAL Soft as shared library (.so / .dll)
-# NOTE: If defined NO, static OpenAL Soft library should be provided
-SHARED_OPENAL ?= NO
+# One of PLATFORM_DESKTOP, PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+PLATFORM             ?= PLATFORM_DESKTOP
 
-# on PLATFORM_WEB force OpenAL Soft shared library
+# Library type used for raylib: STATIC (.a) or SHARED (.so/.dll)
+RAYLIB_LIBTYPE       ?= STATIC
+
+# Build mode for library: DEBUG or RELEASE
+RAYLIB_BUILD_MODE    ?= RELEASE
+
+# Included raylib audio module on compilation
+# NOTE: Some programs like tools could not require audio support
+INCLUDE_AUDIO_MODULE ?= TRUE
+
+# Use OpenAL Soft backend for audio
+USE_OPENAL_BACKEND   ?= FALSE
+
+# OpenAL Soft audio backend forced on HTML5 and OSX (see below)
 ifeq ($(PLATFORM),PLATFORM_WEB)
-    SHARED_OPENAL = YES
+    USE_OPENAL_BACKEND = TRUE
 endif
-ifeq ($(PLATFORM),PLATFORM_ANDROID)
-    SHARED_OPENAL = YES
+
+# Use external GLFW library instead of rglfw module
+# TODO: Review usage of examples on Linux.
+USE_EXTERNAL_GLFW    ?= FALSE
+
+# Use Wayland display server protocol on Linux desktop
+# by default it uses X11 windowing system
+USE_WAYLAND_DISPLAY  ?= FALSE
+
+# See below for more GRAPHICS options.
+
+# See below for RAYLIB_RELEASE_PATH.
+
+# See install target for *_INSTALL_PATH locations.
+
+# Use cross-compiler for PLATFORM_RPI
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    USE_RPI_CROSS_COMPILER ?= FALSE
+    ifeq ($(USE_RPI_CROSS_COMPILER),TRUE)
+        RPI_TOOLCHAIN ?= C:/SysGCC/Raspberry
+        RPI_TOOLCHAIN_SYSROOT ?= $(RPI_TOOLCHAIN)/arm-linux-gnueabihf/sysroot
+    endif
 endif
 
-# determine if the file has root access (only for installing raylib)
+# Determine if the file has root access (only for installing raylib)
 # "whoami" prints the name of the user that calls him (so, if it is the root
 # user, "whoami" prints "root").
 ROOT = $(shell whoami)
 
-# determine PLATFORM_OS in case PLATFORM_DESKTOP selected
+# Determine PLATFORM_OS in case PLATFORM_DESKTOP selected
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
     # No uname.exe on MinGW!, but OS=Windows_NT on Windows!
     # ifeq ($(UNAME),Msys) -> Windows
     ifeq ($(OS),Windows_NT)
         PLATFORM_OS=WINDOWS
     else
-        UNAMEOS:=$(shell uname)
+        UNAMEOS=$(shell uname)
         ifeq ($(UNAMEOS),Linux)
             PLATFORM_OS=LINUX
-        else
+        endif
+        ifeq ($(UNAMEOS),FreeBSD)
+            PLATFORM_OS=FREEBSD
+        endif
         ifeq ($(UNAMEOS),Darwin)
             PLATFORM_OS=OSX
         endif
-        endif
     endif
 endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    UNAMEOS=$(shell uname)
+    ifeq ($(UNAMEOS),Linux)
+        PLATFORM_OS=LINUX
+    endif
+endif
+
+# RAYLIB_PATH adjustment for different platforms.
+# If using GNU make, we can get the full path to the top of the tree. Windows? BSD?
+# Required for ldconfig or other tools that do not perform path expansion.
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),LINUX)
+        RAYLIB_PREFIX ?= ..
+        RAYLIB_PATH    = $(realpath $(RAYLIB_PREFIX))
+    endif
+endif
+# Default path for raylib on Raspberry Pi, if installed in different path, update it!
+# TODO: update install: target in src/Makefile for RPI, consider relation to LINUX.
+# WARNING: The following is copied from examples/Makefile and is here only for reference.
+# Consequences of enabling this are UNKNOWN. Please test and report.
+#ifeq ($(PLATFORM),PLATFORM_RPI)
+#    RAYLIB_PATH       ?= /home/pi/raylib
+#endif
+
+# Force OpenAL Soft audio backend for OSX platform
+# NOTE 1: mini_al library does not support CoreAudio yet
+# NOTE 2: Required OpenAL libraries should be available on OSX
+ifeq ($(PLATFORM_OS),OSX)
+    USE_OPENAL_BACKEND = TRUE
+endif
 
 ifeq ($(PLATFORM),PLATFORM_WEB)
     # Emscripten required variables
-    EMSDK_PATH = $(RAYLIB_PATH)/emsdk
-    EMSCRIPTEN_VERSION = 1.37.9
-    CLANG_VERSION=e1.37.9_64bit
+    EMSDK_PATH = C:/emsdk
+    EMSCRIPTEN_VERSION = 1.37.28
+    CLANG_VERSION=e1.37.28_64bit
     PYTHON_VERSION=2.7.5.3_64bit
     NODE_VERSION=4.1.1_64bit
     export PATH=$(EMSDK_PATH);$(EMSDK_PATH)\clang\$(CLANG_VERSION);$(EMSDK_PATH)\node\$(NODE_VERSION)\bin;$(EMSDK_PATH)\python\$(PYTHON_VERSION);$(EMSDK_PATH)\emscripten\$(EMSCRIPTEN_VERSION);C:\raylib\MinGW\bin:$$(PATH)
@@ -97,97 +161,117 @@ ifeq ($(PLATFORM),PLATFORM_WEB)
 endif
 
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
-    # Android NDK path
-    # NOTE: Required for standalone toolchain generation
-    ANDROID_NDK = $(ANDROID_NDK_HOME)
-    
-    # Android standalone toolchain path
-    # NOTE: This path is also used if toolchain generation
-    #ANDROID_TOOLCHAIN = $(CURDIR)/toolchain
-    ANDROID_TOOLCHAIN = $(RAYLIB_PATH)/android-toolchain
+    # Android required path variables
+    ANDROID_NDK = C:/android-ndk
+    ANDROID_TOOLCHAIN = C:/android_toolchain_arm_api16
 
     # Android architecture: ARM or ARM64
     ANDROID_ARCH ?= ARM
-
-    # Android compiler: gcc or clang 
-    # NOTE: Define YES to use clang instead of gcc
-    ANDROID_LLVM ?= NO
 endif
 
+# RAYLIB_RELEASE_PATH points to provided binaries or your immediate build of raylib.
+# It is further modified below by PLATFORM below.
+RAYLIB_RELEASE_PATH  ?= $(RAYLIB_PATH)/release/libs
+
+# Define output directory for compiled library
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),WINDOWS)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/win32/mingw32
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/linux
+    endif
+    ifeq ($(PLATFORM_OS),OSX)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/osx
+    endif
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/freebsd
+    endif
+endif
 ifeq ($(PLATFORM),PLATFORM_RPI)
-    # RPI cross-compiler
-    CROSS_COMPILE ?= NO
+    RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/rpi
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/html5
+endif
+ifeq ($(PLATFORM),PLATFORM_ANDROID)
+    ifeq ($(ANDROID_ARCH),ARM)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/android/armeabi-v7a
+    endif
+    ifeq ($(ANDROID_ARCH),ARM64)
+        RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/android/arm64-v8a
+    endif
 endif
 
-# define raylib graphics api depending on selected platform
+# Define raylib graphics api depending on selected platform
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
-    # by default use OpenGL 3.3 on desktop platforms
+    # By default use OpenGL 3.3 on desktop platforms
     GRAPHICS ?= GRAPHICS_API_OPENGL_33
     #GRAPHICS = GRAPHICS_API_OPENGL_11  # Uncomment to use OpenGL 1.1
     #GRAPHICS = GRAPHICS_API_OPENGL_21  # Uncomment to use OpenGL 2.1
 endif
 ifeq ($(PLATFORM),PLATFORM_RPI)
-    # on RPI OpenGL ES 2.0 must be used
+    # On RPI OpenGL ES 2.0 must be used
     GRAPHICS = GRAPHICS_API_OPENGL_ES2
 endif
 ifeq ($(PLATFORM),PLATFORM_WEB)
-    # on HTML5 OpenGL ES 2.0 is used, emscripten translates it to WebGL 1.0
+    # On HTML5 OpenGL ES 2.0 is used, emscripten translates it to WebGL 1.0
     GRAPHICS = GRAPHICS_API_OPENGL_ES2
 endif
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
-    # by default use OpenGL ES 2.0 on Android
+    # By default use OpenGL ES 2.0 on Android
     GRAPHICS = GRAPHICS_API_OPENGL_ES2
 endif
 
-# NOTE: makefiles targets require tab indentation
-# NOTE: define compiler: gcc for C program, define as g++ for C++
-
-# default gcc compiler
+# Define default C compiler: gcc
+# NOTE: define g++ compiler if using C++
 CC = gcc
 
-
-# For OS X
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
     ifeq ($(PLATFORM_OS),OSX)
-		CC = clang
-	endif
-endif
-
-# Android toolchain compiler
-ifeq ($(PLATFORM),PLATFORM_ANDROID)
-    ifeq ($(ANDROID_ARCH),ARM)
-        ifeq ($(ANDROID_LLVM),YES)
-            CC = $(ANDROID_TOOLCHAIN)/bin/arm-linux-androideabi-clang
-        else
-            CC = $(ANDROID_TOOLCHAIN)/bin/arm-linux-androideabi-gcc
-        endif
+        # OSX default compiler
+        CC = clang
+        GLFW_CFLAGS = -x objective-c
     endif
-    ifeq ($(ANDROID_ARCH),ARM64)
-        ifeq ($(ANDROID_LLVM),YES)
-            CC = $(ANDROID_TOOLCHAIN)/bin/aarch64-linux-android-clang
-        else
-            CC = $(ANDROID_TOOLCHAIN)/bin/aarch64-linux-android-gcc
-        endif
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        # FreeBSD default compiler
+        CC = clang
     endif
 endif
-
-# RPI cross-compiler
 ifeq ($(PLATFORM),PLATFORM_RPI)
-    ifeq ($(CROSS_COMPILE),YES)
-    	# rpi compiler
-        CC = armv6j-hardfloat-linux-gnueabi-gcc
+    ifeq ($(USE_RPI_CROSS_COMPILER),TRUE)
+        # Define RPI cross-compiler
+        #CC = armv6j-hardfloat-linux-gnueabi-gcc
+        CC = $(RPI_TOOLCHAIN)/bin/arm-linux-gnueabihf-gcc
     endif
 endif
-
-# HTML5 emscripten compiler
 ifeq ($(PLATFORM),PLATFORM_WEB)
+    # HTML5 emscripten compiler
     CC = emcc
 endif
+ifeq ($(PLATFORM),PLATFORM_ANDROID)
+    # Android toolchain (must be provided for desired architecture and compiler)
+    # NOTE: gcc compiler is being deprecated in Android NDK r16
+    ifeq ($(ANDROID_ARCH),ARM)
+        CC = $(ANDROID_TOOLCHAIN)/bin/arm-linux-androideabi-gcc
+    endif
+    ifeq ($(ANDROID_ARCH),ARM64)
+        CC = $(ANDROID_TOOLCHAIN)/bin/aarch64-linux-android-gcc
+    endif
+endif
 
-# default archiver program to pack libraries
+# Default archiver program to pack libraries
 AR = ar
 
-# Android archiver
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    ifeq ($(USE_RPI_CROSS_COMPILER),TRUE)
+        # Define RPI cross-archiver
+        #CC = armv6j-hardfloat-linux-gnueabi-gcc
+        AR = $(RPI_TOOLCHAIN)/bin/arm-linux-gnueabihf-ar
+    endif
+endif
+
+# Android archiver (also depends on desired architecture)
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
     ifeq ($(ANDROID_ARCH),ARM)
         AR = $(ANDROID_TOOLCHAIN)/bin/arm-linux-androideabi-ar
@@ -197,116 +281,153 @@ ifeq ($(PLATFORM),PLATFORM_ANDROID)
     endif
 endif
 
-# define compiler flags:
-#  -O1                  defines optimization level
-#  -Og                  enable debugging
-#  -Wall                turns on most, but not all, compiler warnings
-#  -std=c99             defines C language mode (standard C from 1999 revision)
-#  -std=gnu99           defines C language mode (GNU C from 1999 revision)
-#  -fgnu89-inline       declaring inline functions support (GCC optimized)
-#  -Wno-missing-braces  ignore invalid warning (GCC bug 53119)
-#  -D_DEFAULT_SOURCE    use with -std=c99
-CFLAGS += -O1 -Wall -std=c99 -D_DEFAULT_SOURCE -fgnu89-inline -Wno-missing-braces
-
+# Define compiler flags:
+#  -O1                   defines optimization level
+#  -g                    enable debugging
+#  -s                    strip unnecessary data from build
+#  -Wall                 turns on most, but not all, compiler warnings
+#  -std=c99              defines C language mode (standard C from 1999 revision)
+#  -std=gnu99            defines C language mode (GNU C from 1999 revision)
+#  -Wno-missing-braces   ignore invalid warning (GCC bug 53119)
+#  -D_DEFAULT_SOURCE     use with -std=c99 on Linux and PLATFORM_WEB, required for timespec
+#  -Werror=pointer-arith catch unportable code that does direct arithmetic on void pointers
+#  -fno-strict-aliasing  jar_xm.h does shady stuff (breaks strict aliasing)
+CFLAGS += -O1 -Wall -std=c99 -D_DEFAULT_SOURCE -Wno-missing-braces -Werror=pointer-arith -fno-strict-aliasing
+
+ifeq ($(RAYLIB_BUILD_MODE), DEBUG)
+    CFLAGS += -g
+    #CC      = clang
+endif
+
+# Additional flags for compiler (if desired)
+#  -Wextra                  enables some extra warning flags that are not enabled by -Wall
+#  -Wmissing-prototypes     warn if a global function is defined without a previous prototype declaration
+#  -Wstrict-prototypes      warn if a function is declared or defined without specifying the argument types
+#  -Werror=implicit-function-declaration   catch function calls without prior declaration
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    CFLAGS += -Werror=implicit-function-declaration
+endif
 ifeq ($(PLATFORM),PLATFORM_WEB)
-    CFLAGS += -s USE_GLFW=3 -s ASSERTIONS=1 --profiling --preload-file resources
     # -O2                        # if used, also set --memory-init-file 0
     # --memory-init-file 0       # to avoid an external memory initialization code file (.mem)
     # -s ALLOW_MEMORY_GROWTH=1   # to allow memory resizing
     # -s TOTAL_MEMORY=16777216   # to specify heap memory size (default = 16MB)
     # -s USE_PTHREADS=1          # multithreading support
+    CFLAGS += -s USE_GLFW=3 -s ASSERTIONS=1 --profiling
 endif
-
-#CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes
-
-# if shared library required, make sure code is compiled as position independent
-ifeq ($(SHARED_RAYLIB),YES)
-    CFLAGS += -fPIC
-    SHAREDFLAG = BUILDING_DLL
-else
-    SHAREDFLAG = BUILDING_STATIC
+ifeq ($(PLATFORM),PLATFORM_ANDROID)
+    # Compiler flags for arquitecture
+    CFLAGS += -march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16
+    # Compilation functions attributes options
+    CFLAGS += -ffunction-sections -funwind-tables -fstack-protector-strong -fPIC
+    # Compiler options for the linker
+    # -Werror=format-security
+    CFLAGS += -Wa,--noexecstack -Wformat -no-canonical-prefixes
+    # Preprocessor macro definitions
+    CFLAGS += -DANDROID -DPLATFORM_ANDROID -D__ANDROID_API__=16
 endif
 
-# if static OpenAL Soft required, define the corresponding flags
-ifeq ($(SHARED_OPENAL),NO)
-    SHAREDLIBS += -lopenal32 -lwinmm
-    SHAREDOPENALFLAG = AL_LIBTYPE_STATIC
-else
-    SHAREDLIBS += -lopenal32dll
-    SHAREDOPENALFLAG = SHARED_OPENAL
+# Define required compilation flags for raylib SHARED lib
+ifeq ($(RAYLIB_LIBTYPE),SHARED)
+    # make sure code is compiled as position independent
+    # BE CAREFUL: It seems that for gcc -fpic is not the same as -fPIC
+    # MinGW32 just doesn't need -fPIC, it shows warnings
+    CFLAGS += -fPIC -DBUILD_LIBTYPE_SHARED
 endif
 
-#CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes
+# Use OpenAL Soft backend instead of mini_al
+ifeq ($(USE_OPENAL_BACKEND),TRUE)
+    CFLAGS += -DUSE_OPENAL_BACKEND
+endif
 
-# external required libraries (stb and others)
-INCLUDES = -I. -Iexternal
+# Use Wayland display on Linux desktop
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS), LINUX)
+        ifeq ($(USE_WAYLAND_DISPLAY),TRUE)
+            CFLAGS += -D_GLFW_WAYLAND
+        endif
+    endif
+endif
 
-# OpenAL Soft library
-INCLUDES += -Iexternal/openal_soft/include
+# Define include paths for required headers
+# NOTE: Several external required libraries (stb and others)
+INCLUDE_PATHS = -I. -Iexternal -Iexternal/glfw/include
 
-# define any directories containing required header files
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
-    # GLFW3 library
-    INCLUDES += -Iexternal/glfw3/include
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        INCLUDE_PATHS += -I/usr/local/include
+        LDFLAGS += -L. -Lsrc -L/usr/local/lib -L$(RAYLIB_RELEASE_PATH)
+    endif
+    ifeq ($(USE_EXTERNAL_GLFW),TRUE)
+        # Check the version name. If GLFW3 was built manually, it may have produced
+        # a static library known as libglfw3.a. In that case, the name should be -lglfw3
+        LDFLAGS += -lglfw
+    endif
 endif
+
+# Define additional directories containing required header files
 ifeq ($(PLATFORM),PLATFORM_RPI)
-    # RPI requried libraries
-    INCLUDES += -I/opt/vc/include
-    INCLUDES += -I/opt/vc/include/interface/vmcs_host/linux
-    INCLUDES += -I/opt/vc/include/interface/vcos/pthreads
-endif
-ifeq ($(PLATFORM),PLATFORM_WEB)
-    # GLFW3 library
-    INCLUDES += -Iexternal/glfw3/include
+    # RPI required libraries
+    INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include
+    INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include/interface/vmcs_host/linux
+    INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include/interface/vcos/pthreads
+    INCLUDE_PATHS += -I$(RPI_TOOLCHAIN_SYSROOT)/opt/vc/include/interface/vcos/pthreads
 endif
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
     # Android required libraries
-    INCLUDES += -I$(ANDROID_TOOLCHAIN)/sysroot/usr/include
+    INCLUDE_PATHS += -I$(ANDROID_TOOLCHAIN)/sysroot/usr/include
     # Include android_native_app_glue.h
-    INCLUDES += -Iexternal/android/native_app_glue
-    #INCLUDES += -I$(ANDROID_NDK)/sources/android/native_app_glue
+    INCLUDE_PATHS += -Iexternal/android/native_app_glue
+    #INCLUDE_PATHS += -I$(ANDROID_NDK)/sources/android/native_app_glue
 endif
 
-# define output directory for compiled library
+# Define linker options
+ifeq ($(PLATFORM),PLATFORM_ANDROID)
+    LDFLAGS = -Wl,-soname,libraylib.$(API_VERSION).so -Wl,--exclude-libs,libatomic.a
+    LDFLAGS += -Wl,--build-id -Wl,--no-undefined -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now -Wl,--warn-shared-textrel -Wl,--fatal-warnings
+    # Force linking of library module to define symbol
+    LDFLAGS += -u ANativeActivity_onCreate
+    # Library paths containing required libs
+    LDFLAGS += -L. -Lsrc -L$(RAYLIB_RELEASE_PATH)
+
+    LDLIBS = -llog -landroid -lEGL -lGLESv2 -lOpenSLES -latomic -lc -lm
+endif
+
+# Define all object files required with a wildcard
+# The wildcard takes all files that finish with ".c",
+# and replaces extentions with ".o", that are the object files
+# NOTE: Some objects depend on the PLATFORM to be added or not!
+# OBJS = $(patsubst %.c, %.o, $(wildcard *.c))
+
+# Define object required on compilation
+OBJS = core.o \
+       rlgl.o \
+       shapes.o \
+       textures.o \
+       text.o \
+       models.o \
+       utils.o
+
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
-    ifeq ($(PLATFORM_OS),WINDOWS)
-        OUTPUT_PATH = ../release/win32/mingw32
-    endif
-    ifeq ($(PLATFORM_OS),LINUX)
-        OUTPUT_PATH = ../release/linux
+    ifeq ($(USE_EXTERNAL_GLFW),FALSE)
+        OBJS += rglfw.o
     endif
-    ifeq ($(PLATFORM_OS),OSX)
-        OUTPUT_PATH = ../release/osx
-    endif
-endif
-ifeq ($(PLATFORM),PLATFORM_RPI)
-    OUTPUT_PATH = ../release/rpi
 endif
-ifeq ($(PLATFORM),PLATFORM_WEB)
-    OUTPUT_PATH = ../release/html5
-endif
-ifeq ($(PLATFORM),PLATFORM_ANDROID)
-    ifeq ($(ANDROID_ARCH),ARM)
-        OUTPUT_PATH = ../release/android/armeabi-v7a
-    endif
-    ifeq ($(ANDROID_ARCH),ARM64)
-        OUTPUT_PATH = ../release/android/arm64-v8a
+
+ifeq ($(INCLUDE_AUDIO_MODULE),TRUE)
+    OBJS += audio.o
+    OBJS += stb_vorbis.o
+    ifeq ($(USE_OPENAL_BACKEND),FALSE)
+        OBJS += mini_al.o
     endif
 endif
 
-# define all object files required with a wildcard
-# The wildcard takes all files that finish with ".c", then it replaces the
-# extentions with ".o", that are the object files.
-OBJS = $(patsubst %.c, %.o, $(wildcard *.c))
-OBJS += external/stb_vorbis.o
-
-# typing 'make' will invoke the default target entry called 'all',
-# in this case, the 'default' target entry is raylib
+# Default target entry
 all: raylib
 
-# generate standalone Android toolchain
+# Generate standalone Android toolchain
 # NOTE: Android toolchain could already be provided
-toolchain:
+generate_android_toolchain:
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
     ifeq ($(ANDROID_ARCH),ARM)
 		$(ANDROID_NDK)/build/tools/make-standalone-toolchain.sh --platform=android-9 --toolchain=arm-linux-androideabi-4.9 --use-llvm --install-dir=$(ANDROID_TOOLCHAIN)
@@ -316,133 +437,187 @@ ifeq ($(PLATFORM),PLATFORM_ANDROID)
     endif
 endif
 
-# compile raylib library
+# Compile raylib library
 raylib: $(OBJS)
 ifeq ($(PLATFORM),PLATFORM_WEB)
-    # compile raylib for web.
-	emcc -O1 $(OBJS) -o $(OUTPUT_PATH)/libraylib.bc
-	@echo "libraylib.bc generated (web version)!"
+    # Compile raylib for web.
+	emcc -O1 $(OBJS) -o $(RAYLIB_RELEASE_PATH)/libraylib.bc
+	@echo "raylib library generated (libraylib.bc)!"
 else
-    ifeq ($(SHARED_RAYLIB),YES)
-        # NOTE: If using OpenAL Soft as static library, all its dependencies must be also linked in the shared library
+    ifeq ($(RAYLIB_LIBTYPE),SHARED)
         ifeq ($(PLATFORM_OS),WINDOWS)
-			$(CC) -shared -o $(OUTPUT_PATH)/raylib.dll $(OBJS) $(SHAREDLIBS) -Lexternal/glfw3/lib/win32 -Lexternal/openal_soft/lib/win32 -lglfw3 -lgdi32 -Wl,--out-implib,$(OUTPUT_PATH)/libraylibdll.a
+			$(CC) -shared -o $(RAYLIB_RELEASE_PATH)/raylib.dll $(OBJS) -L$(RAYLIB_RELEASE_PATH) -static-libgcc -lopengl32 -lgdi32 -Wl,--out-implib,$(RAYLIB_RELEASE_PATH)/libraylibdll.a
 			@echo "raylib dynamic library (raylib.dll) and import library (libraylibdll.a) generated!"
         endif
         ifeq ($(PLATFORM_OS),LINUX)
-            # compile raylib to shared library version for GNU/Linux.
-            # WARNING: you should type "make clean" before doing this target
-			$(CC) -shared -o $(OUTPUT_PATH)/libraylib.so $(OBJS) -lglfw -lGL -lopenal -lm -lpthread -ldl
-			@echo "raylib shared library generated (libraylib.so)!"
+			# Compile raylib shared library version $(RAYLIB_VERSION).
+			# WARNING: you should type "make clean" before doing this target
+			$(CC) -shared -o $(RAYLIB_RELEASE_PATH)/libraylib.so.$(RAYLIB_VERSION) $(OBJS) -shared -Wl,-soname,libraylib.so.$(RAYLIB_API_VERSION) -lGL -lc -lm -lpthread -ldl -lrt
+			@echo "raylib shared library generated (libraylib.so.$(RAYLIB_VERSION)) in $(RAYLIB_RELEASE_PATH)!"
+			cd $(RAYLIB_RELEASE_PATH) && ln -fsv libraylib.so.$(RAYLIB_VERSION) libraylib.so.$(RAYLIB_API_VERSION)
+			cd $(RAYLIB_RELEASE_PATH) && ln -fsv libraylib.so.$(RAYLIB_API_VERSION) libraylib.so
         endif
         ifeq ($(PLATFORM_OS),OSX)
-			$(CC) -dynamiclib -o $(OUTPUT_PATH)/libraylib.dylib $(OBJS) -L/usr/local/Cellar/glfw/3.2.1/lib -lglfw -framework OpenGL -framework OpenAL -framework Cocoa
-			install_name_tool -id "libraylib.dylib" $(OUTPUT_PATH)/libraylib.dylib
-			@echo "raylib shared library generated (libraylib.dylib)!"
+			$(CC) -dynamiclib -o $(RAYLIB_RELEASE_PATH)/libraylib.$(RAYLIB_VERSION).dylib $(OBJS) -compatibility_version $(RAYLIB_API_VERSION) -current_version $(RAYLIB_VERSION) -framework OpenGL -framework OpenAL -framework IOKit -framework CoreVideo -framework Cocoa
+			install_name_tool -id "libraylib.$(VERSION).dylib" $(RAYLIB_RELEASE_PATH)/libraylib.$(RAYLIB_VERSION).dylib
+			@echo "raylib shared library generated (libraylib.$(RAYLIB_VERSION).dylib)!"
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).dylib libraylib.$(RAYLIB_API_VERSION).dylib
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).dylib libraylib.dylib
+        endif
+        ifeq ($(PLATFORM_OS),FREEBSD)
+			# WARNING: you should type "gmake clean" before doing this target
+			$(CC) -shared -o $(RAYLIB_RELEASE_PATH)/libraylib.$(RAYLIB_VERSION).so $(OBJS) -Wl,-soname,libraylib.$(RAYLIB_API_VERSION).so -lGL -lpthread
+			@echo "raylib shared library generated (libraylib.$(RAYLIB_VERSION).so)!"
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).so libraylib.$(RAYLIB_API_VERSION).so
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).so libraylib.so
         endif
         ifeq ($(PLATFORM),PLATFORM_ANDROID)
-			$(CC) -shared -o $(OUTPUT_PATH)/libraylib.so $(OBJS)
-			@echo "raylib shared library generated (libraylib.so)!"
+			$(CC) -shared -o $(RAYLIB_RELEASE_PATH)/libraylib.$(RAYLIB_VERSION).so $(OBJS) $(LDFLAGS) $(LDLIBS)
+			@echo "raylib shared library generated (libraylib.$(RAYLIB_VERSION).so)!"
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).so libraylib.$(RAYLIB_API_VERSION).so
+			cd $(RAYLIB_RELEASE_PATH) && ln -fs libraylib.$(RAYLIB_VERSION).so libraylib.so
         endif
     else
-        # compile raylib static library.
-		$(AR) rcs $(OUTPUT_PATH)/libraylib.a $(OBJS)
-		@echo "raylib static library generated (libraylib.a)!"
-        ifeq ($(SHARED_OPENAL),NO)
-			@echo "expected OpenAL Soft static library linking"
-        else
-			@echo "expected OpenAL Soft shared library linking"
-        endif
+		# Compile raylib static library version $(RAYLIB_VERSION)
+		# WARNING: You should type "make clean" before doing this target.
+		$(AR) rcs $(RAYLIB_RELEASE_PATH)/libraylib.a $(OBJS)
+		@echo "raylib static library generated (libraylib.a) in $(RAYLIB_RELEASE_PATH)!"
     endif
 endif
 
-# compile all modules with their prerequisites
+# Compile all modules with their prerequisites
 
-# compile core module
+# Compile core module
 core.o : core.c raylib.h rlgl.h utils.h raymath.h gestures.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
+
+# Compile rglfw module
+rglfw.o : rglfw.c
+	$(CC) $(GLFW_CFLAGS) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile rlgl module
+# Compile rlgl module
 rlgl.o : rlgl.c rlgl.h raymath.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(GRAPHICS)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile shapes module
+# Compile shapes module
 shapes.o : shapes.c raylib.h rlgl.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile textures module
+# Compile textures module
 textures.o : textures.c rlgl.h utils.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile text module
+# Compile text module
 text.o : text.c raylib.h utils.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile models module
+# Compile models module
 models.o : models.c raylib.h rlgl.h raymath.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM) -D$(GRAPHICS)
 
-# compile audio module
+# Compile audio module
 audio.o : audio.c raylib.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(SHAREDFLAG) -D$(SHAREDOPENALFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM)
 
-# compile stb_vorbis library
-external/stb_vorbis.o: external/stb_vorbis.c external/stb_vorbis.h
-	$(CC) -c -o $@ $< -O1 $(CFLAGS) $(INCLUDES) -D$(PLATFORM)
+# Compile mini_al audio library
+mini_al.o : external/mini_al.c external/mini_al.h
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM)
 
-# compile utils module
+# Compile stb_vorbis library
+stb_vorbis.o: external/stb_vorbis.c external/stb_vorbis.h
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM)
+
+# Compile utils module
 utils.o : utils.c utils.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(SHAREDFLAG)
+	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS) -D$(PLATFORM)
+
+# Install generated and needed files to desired directories.
+# On GNU/Linux and BSDs, there are some standard directories that contain extra
+# libraries and header files. These directories (often /usr/local/lib and
+# /usr/local/include) are for libraries that are installed manually
+# (without a package manager). We'll use /usr/local/lib/raysan5 and /usr/local/include/raysan5
+# for our -L and -I specification to simplify management of the raylib source package.
+# Customize these locations if you like but don't forget to pass them to make
+# for compilation and enable runtime linking with -rpath, LD_LIBRARY_PATH, or ldconfig.
+# Hint: add -L$(RAYLIB_INSTALL_PATH) -I$(RAYLIB_H_INSTALL_PATH) to your own makefiles.
+# See below and ../examples/Makefile for more information.
+# TODO: Add other platforms. Remove sudo requirement, i.e. add USER mode.
+
+# RAYLIB_INSTALL_PATH should be the desired full path to libraylib. No relative paths.
+DESTDIR ?= /usr/local
+RAYLIB_INSTALL_PATH ?= $(DESTDIR)/lib
+# RAYLIB_H_INSTALL_PATH locates the installed raylib header and associated source files.
+RAYLIB_H_INSTALL_PATH ?= $(DESTDIR)/include
 
-# It installs generated and needed files to compile projects using raylib.
-# The installation works manually.
-# TODO: add other platforms.
 install :
 ifeq ($(ROOT),root)
     ifeq ($(PLATFORM_OS),LINUX)
-        # On GNU/Linux there are some standard directories that contain
-        # libraries and header files. These directory (/usr/local/lib and
-        # /usr/local/include/) are for libraries that are installed
-        # manually (without a package manager).
-        ifeq ($(SHARED_RAYLIB),YES)
-			cp --update $(OUTPUT_PATH)/libraylib.so /usr/local/lib/libraylib.so
-        else
-			cp --update raylib.h /usr/local/include/raylib.h
-			cp --update $(OUTPUT_PATH)/libraylib.a /usr/local/lib/libraylib.a
-        endif
-		@echo "raylib dev files installed/updated!"
+		# Attention! You are root, writing files to $(RAYLIB_INSTALL_PATH)
+		# and $(RAYLIB_H_INSTALL_PATH). Consult this Makefile for more information.
+		# Prepare the environment as needed.
+		mkdir --parents --verbose $(RAYLIB_INSTALL_PATH)
+		mkdir --parents --verbose $(RAYLIB_H_INSTALL_PATH)
+                ifeq ($(RAYLIB_LIBTYPE),SHARED)
+			# Installing raylib to $(RAYLIB_INSTALL_PATH).
+			cp --update --verbose $(RAYLIB_RELEASE_PATH)/libraylib.so.$(RAYLIB_VERSION) $(RAYLIB_INSTALL_PATH)/libraylib.so.$(RAYLIB_VERSION)
+			cd $(RAYLIB_INSTALL_PATH); ln -fsv libraylib.so.$(RAYLIB_VERSION) libraylib.so.$(RAYLIB_API_VERSION)
+			cd $(RAYLIB_INSTALL_PATH); ln -fsv libraylib.so.$(RAYLIB_API_VERSION) libraylib.so
+                        # Uncomment to update the runtime linker cache with RAYLIB_INSTALL_PATH.
+                        # Not necessary if later embedding RPATH in your executable. See examples/Makefile.
+			ldconfig $(RAYLIB_INSTALL_PATH)
+                else
+			# Installing raylib to $(RAYLIB_INSTALL_PATH).
+			cp --update --verbose $(RAYLIB_RELEASE_PATH)/libraylib.a $(RAYLIB_INSTALL_PATH)/libraylib.a
+                endif
+		# Copying raylib development files to $(RAYLIB_H_INSTALL_PATH).
+		cp --update raylib.h $(RAYLIB_H_INSTALL_PATH)/raylib.h
+		cp --update raymath.h $(RAYLIB_H_INSTALL_PATH)/raymath.h
+		cp --update rlgl.h $(RAYLIB_H_INSTALL_PATH)/rlgl.h
+		cp --update rlgl.c $(RAYLIB_H_INSTALL_PATH)/rlgl.c
+		cp --update physac.h $(RAYLIB_H_INSTALL_PATH)/physac.h
+		@echo "raylib development files installed/updated!"
     else
-		@echo "This function works only on GNU/Linux systems"
+		@echo "This function currently works on GNU/Linux systems. Add yours today (^;"
     endif
 else
-	@echo "Error: no root permissions"
+	@echo "Error: Root permissions needed for installation. Try sudo make install"
 endif
 
-# it removes raylib dev files installed on the system.
+# Remove raylib dev files installed on the system
 # TODO: see 'install' target.
 uninstall :
 ifeq ($(ROOT),root)
+		# WARNING: You are root, about to delete items from $(RAYLIB_INSTALL_PATH).
+		# and $(RAYLIB_H_INSTALL_PATH). Please confirm each item.
     ifeq ($(PLATFORM_OS),LINUX)
-			rm --force /usr/local/include/raylib.h
-        ifeq ($(SHARED_RAYLIB),YES)
-			rm --force /usr/local/lib/libraylib.so
+        ifeq ($(RAYLIB_LIBTYPE),SHARED)
+		rm --force --interactive --verbose $(RAYLIB_INSTALL_PATH)/libraylib.so
+		rm --force --interactive --verbose $(RAYLIB_INSTALL_PATH)/libraylib.so.$(RAYLIB_API_VERSION)
+		rm --force --interactive --verbose $(RAYLIB_INSTALL_PATH)/libraylib.so.$(RAYLIB_VERSION)
+                # Uncomment to clean up the runtime linker cache. See install target.
+		ldconfig
         else
-			rm --force /usr/local/lib/libraylib.a
+		rm --force --interactive --verbose $(RAYLIB_INSTALL_PATH)/libraylib.a
         endif
-		@echo "raylib dev files removed!"
-    else
-		 @echo "This function works only on GNU/Linux systems"
+		rm --force --interactive --verbose $(RAYLIB_H_INSTALL_PATH)/raylib.h
+		rm --force --interactive --verbose $(RAYLIB_H_INSTALL_PATH)/raymath.h
+		rm --force --interactive --verbose $(RAYLIB_H_INSTALL_PATH)/rlgl.h
+		rm --force --interactive --verbose $(RAYLIB_H_INSTALL_PATH)/rlgl.c
+		rm --force --interactive --verbose $(RAYLIB_H_INSTALL_PATH)/physac.h
+		@echo "raylib development files removed!"
+        else
+		@echo "This function currently works on GNU/Linux systems. Add yours today (^;"
     endif
 else
-	@echo "Error: no root permissions"
+	@echo "Error: Root permissions needed for uninstallation. Try sudo make uninstall"
 endif
 
-# clean everything
+# Clean everything
 clean:
 ifeq ($(PLATFORM_OS),WINDOWS)
-	del *.o $(OUTPUT_PATH)/libraylib.a $(OUTPUT_PATH)/libraylib.bc $(OUTPUT_PATH)/libraylib.so external/stb_vorbis.o
+	del *.o $(RAYLIB_RELEASE_PATH)/libraylib.a $(RAYLIB_RELEASE_PATH)/libraylib.bc $(RAYLIB_RELEASE_PATH)/libraylib.so external/stb_vorbis.o
 else
-	rm -f *.o $(OUTPUT_PATH)/libraylib.a $(OUTPUT_PATH)/libraylib.bc $(OUTPUT_PATH)/libraylib.so external/stb_vorbis.o
+	rm -fv *.o $(RAYLIB_RELEASE_PATH)/libraylib.a $(RAYLIB_RELEASE_PATH)/libraylib.bc $(RAYLIB_RELEASE_PATH)/libraylib.so* external/stb_vorbis.o
 endif
 ifeq ($(PLATFORM),PLATFORM_ANDROID)
 	rm -rf $(ANDROID_TOOLCHAIN)