Updated release version

Added raylib version to config

.gitignore

@@ -1,17 +1,10 @@
 # Ignore generated files
 # ...
 
-# Ignore compiled binaries
-src/core.o
-src/shapes.o
-src/textures.o
-src/text.o
-src/models.o
-src/audio.o
-src/vector3.o
-src/stb_image.o
-src/*.exe
-examples/*.o
+# Ignore VIM's backup generated files
+*.swp
+*.swo
+*~
 
 # Ignore thumbnails created by windows
 Thumbs.db
@@ -42,12 +35,40 @@ Thumbs.db
 *.sbr
 *.sdf
 obj/
+[R]elease/
 [Rr]elease.win32/
 _ReSharper*/
 [Tt]est[Rr]esult*
 ipch/
 *.opensdf
 
+# Ignore compiled binaries
+*.o
+*.exe
+!tools/rREM/rrem.exe
+
+# Ignore all examples files
+examples/*
+# Unignore all examples dirs
+!examples/*/
+# Unignore all examples files with extension
+!examples/*.c
+!examples/*.lua
+!examples/*.png
+# Unignore examples Makefile
+!examples/Makefile
+
+# Ignore all games files
+games/*
+# Unignore all games dirs
+!games/*/
+# Unignore all games files with extension
+!games/*.c
+!games/*.lua
+!games/*.png
+# Unignore games makefile
+!games/Makefile
+
 # Ignore files build by xcode
 *.mode*v*
 *.pbxuser
@@ -61,3 +82,55 @@ xcschememanagement.plist
 ._.*
 xcuserdata/
 DerivedData/
+
+# Visual Studio project
+project/vs2015/*.db
+project/vs2015/*.opendb
+project/vs2015.UWP/packages
+project/vs2015.UWP/*.db
+!project/vs2015/raylib.sln
+!project/vs2015/raylib/*.vcxproj
+!project/vs2015/examples/*.vcxproj
+!project/vs2017/raylib.sln
+!project/vs2017/raylib/*.vcxproj
+!project/vs2017/examples/*.vcxproj
+!project/vs2015.UWP/raylib/*.vcxproj
+!project/vs2015.UWP/*.sln
+!project/vs2015.UWP/raylib.App.UWP/*.vcxproj
+
+# Web examples 
+docs/examples/web/*.html
+docs/examples/web/*/*.html
+!docs/examples/web/loader.html
+!docs/examples/web/core/loader.html
+!docs/examples/web/shapes/loader.html
+!docs/examples/web/text/loader.html
+!docs/examples/web/textures/loader.html
+!docs/examples/web/audio/loader.html
+!docs/examples/web/physac/loader.html
+!docs/examples/web/shaders/loader.html
+!docs/examples/web/models/loader.html
+
+# CMake stuff
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+build
+!templates/android_project/Makefile
+
+# Unignore These makefiles...
+!examples/CMakeLists.txt
+!games/CMakeLists.txt
+
+# Ignore Android generated files and folders
+templates/android_project/output
+
+# Ignore GNU global tags
+GPATH
+GRTAGS
+GTAGS

.travis.yml

@@ -0,0 +1,62 @@
+language: c
+dist: trusty
+
+git:
+  depth: 3
+
+# TODO we could use a 32 bit Docker container for running true 32-bit tests
+# services: - docker
+
+matrix:
+  include:
+    - os: linux
+      env: ARCH=i386
+      sudo: required
+    - os: linux
+      env: ARCH=amd64
+      sudo: required
+    - os: osx
+      env: ARCH=universal
+
+before_script:
+
+before_install:
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then
+      sudo apt-get install -y gcc-multilib
+                              libasound2-dev:$ARCH
+                              libxcursor-dev:$ARCH libxinerama-dev:$ARCH mesa-common-dev:$ARCH
+                              libx11-dev:$ARCH libxrandr-dev:$ARCH libxi-dev:$ARCH
+                              libgl1-mesa-dev:$ARCH libglu1-mesa-dev:$ARCH;
+      export RAYLIB_PACKAGE_SUFFIX="-Linux-$ARCH";
+      if [ "$ARCH" == "i386" ]; then export CFLAGS="-m32"; fi;
+      if [ "$ARCH" == "amd64" ]; then export CFLAGS="-m64"; fi;
+      if [ "$GLFW" == "SYSTEM" ]; then
+        wget 'http://ftp.de.debian.org/debian/pool/main/g/glfw3/libglfw3_3.2.1-1_amd64.deb';
+        wget 'http://ftp.de.debian.org/debian/pool/main/g/glfw3/libglfw3-dev_3.2.1-1_amd64.deb';
+        sudo dpkg -i libglfw3_3.2.1-1_amd64.deb libglfw3-dev_3.2.1-1_amd64.deb;
+      fi;
+    fi
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+      export RAYLIB_PACKAGE_SUFFIX="-macOS";
+      if [ "$GLFW" == "SYSTEM" ]; then brew update; brew install glfw; fi;
+    fi
+  - "$CC --version"
+
+script:
+  - mkdir build
+  - cd build
+  - cmake -DMACOS_FATLIB=ON -DSTATIC=ON -DSHARED=ON -DBUILD_EXAMPLES=ON -DBUILD_GAMES=ON -DUSE_EXTERNAL_GLFW=IF_POSSIBLE ..
+  - make VERBOSE=1
+  - make package
+
+deploy:
+  provider: releases
+  api_key:
+    secure: LvqUIAN/3dJul+Ra2iK3tSaNG5IwsNMmGIwVMy0DK5IBCxiQPBc9pWGiE30RTBPt6Z+N4BhMEE8DtUl+vnISlMoHWNIIhF2zwC66hs/F7zY7qEITMRSmfiLcqxQysknFOnJB06CATgXcFqlEo9j+t4abrG/f3qcb92J4O2uNz336Au2myTx93Q5MxbyA7KiUuEutFnb2dWiPCY4d+sGeXEfsiD2R7aj/8MaWOkoGdZVrTkI9juMgvpImkjQBArvqdjUMeT3MsRrwgOIq5v2GFV9dOl8k1WzPeT8B2JHh00ed/o1/wuFq/cLLOxtYo2+Pv3+xatOrlexoX0WkDm7C9/L1W5U4rLexU3CQ9mMBmHPnp6k/WXZ5QXEE4uUF0+LpN3XlIXzFpdZmZiVV8VLxg2WvyncMmivYiu7/MTkyfZxyKkzwl7sZZslzHA9kOGedGaN7b7/2B77OFHoQK8lKfdFml7jJnarh+89nenNZYMab0E8qkOJOyb2bYlDTa0/2nyxGiyymYgq6YHLNrDbhqB/1LzdgzjMliQ8ri5q9Ux2vjfcqOzhfAmcwFwnY/D6yXJWYi0DWpHZdpKl3du6dYDrypW91/yDWbwiJ/YhrE7ZunzrcB6GH/QkbuzWxdCth39rQAHih8DG01co/K3Gvi4yGjvIH5tFUpyEolMnpMiA=
+  file_glob: true
+  file: raylib-*.tar.gz
+  skip_cleanup: true
+  on:
+    repo: raysan5/raylib
+    branch: master
+    tags: true

CHANGELOG

@@ -1,10 +1,566 @@
 changelog
 ---------
 
-Current Release:    raylib 1.0.4 (January 2014)
+Current Release:    raylib 1.8.0 (Oct 2017)
 
-NOTE: Only versions marked as 'Release' are available on release folder, updates are only available as source.
-NOTE: Current Release includes all previous updates.
+-----------------------------------------------
+Release:     raylib 1.8.0 (Oct 2017)
+-----------------------------------------------
+NOTE: 
+  In this release, multiple parts of the library have been reviewed (again) for consistency and simplification. 
+  It exposes more than 30 new functions in comparison with previous version and it improves overall programming experience.
+  
+BIG CHANGES:
+  - New Image generation functions: Gradient, Checked, Noise, Cellular...
+  - New Mesh generation functions: Cube, Sphere, Cylinder, Torus, Knot...
+  - New Shaders and Materials systems to support PBR materials
+  - Custom Android APK build pipeline with simple Makefile
+  - Complete review of rlgl layer functionality
+  - Complete review of raymath functionality
+
+detailed changes:
+[rlgl] RENAMED: rlglLoadTexture() to rlLoadTexture()
+[rlgl] RENAMED: rlglLoadRenderTexture() to rlLoadRenderTexture()
+[rlgl] RENAMED: rlglUpdateTexture() to rlUpdateTexture()
+[rlgl] RENAMED: rlglGenerateMipmaps() to rlGenerateMipmaps()
+[rlgl] RENAMED: rlglReadScreenPixels() to rlReadScreenPixels()
+[rlgl] RENAMED: rlglReadTexturePixels() to rlReadTexturePixels()
+[rlgl] RENAMED: rlglLoadMesh() to rlLoadMesh()
+[rlgl] RENAMED: rlglUpdateMesh() to rlUpdateMesh()
+[rlgl] RENAMED: rlglDrawMesh() to rlDrawMesh()
+[rlgl] RENAMED: rlglUnloadMesh() to rlUnloadMesh()
+[rlgl] RENAMED: rlglUnproject() to rlUnproject()
+[rlgl] RENAMED: LoadCompressedTexture() to LoadTextureCompressed()
+[rlgl] RENAMED: GetDefaultTexture() to GetTextureDefault()
+[rlgl] RENAMED: LoadDefaultShader() to LoadShaderDefault()
+[rlgl] RENAMED: LoadDefaultShaderLocations() to SetShaderDefaultLocations()
+[rlgl] RENAMED: UnloadDefaultShader() to UnLoadShaderDefault()
+[rlgl] ADDED: rlGenMapCubemap(), Generate cubemap texture map from HDR texture
+[rlgl] ADDED: rlGenMapIrradiance(), Generate irradiance texture map
+[rlgl] ADDED: rlGenMapPrefilter(), Generate prefilter texture map
+[rlgl] ADDED: rlGenMapBRDF(), Generate BRDF texture map
+[rlgl] ADDED: GetVrDeviceInfo(), Get VR device information for some standard devices
+[rlgl] REVIEWED: InitVrSimulator(), to accept device parameters as input
+[core] ADDED: SetWindowTitle(), Set title for window (only PLATFORM_DESKTOP)
+[core] ADDED: GetExtension(), Get file extension
+[shapes] REMOVED: DrawRectangleGradient(), replaced by DrawRectangleGradientV() and DrawRectangleGradientH()
+[shapes] ADDED: DrawRectangleGradientV(), Draw a vertical-gradient-filled rectangle
+[shapes] ADDED: DrawRectangleGradientH(), Draw a horizontal-gradient-filled rectangle
+[shapes] ADDED: DrawRectangleGradientEx(), Draw a gradient-filled rectangle with custom vertex colors
+[shapes] ADDED: DrawRectangleT(), Draw rectangle using text character
+[textures] ADDED: SaveImageAs(), Save image as PNG file
+[textures] ADDED: GenImageGradientV(), Generate image: vertical gradient
+[textures] ADDED: GenImageGradientH(), Generate image: horizontal gradient
+[textures] ADDED: GenImageGradientRadial(), Generate image: radial gradient
+[textures] ADDED: GenImageChecked(), Generate image: checked
+[textures] ADDED: GenImageWhiteNoise(), Generate image: white noise
+[textures] ADDED: GenImagePerlinNoise(), Generate image: perlin noise
+[textures] ADDED: GenImageCellular(), Generate image: cellular algorithm. Bigger tileSize means bigger cells
+[textures] ADDED: GenTextureCubemap(), Generate cubemap texture from HDR texture
+[textures] ADDED: GenTextureIrradiance(), Generate irradiance texture using cubemap data
+[textures] ADDED: GenTexturePrefilter(), Generate prefilter texture using cubemap data
+[textures] ADDED: GenTextureBRDF(), Generate BRDF texture using cubemap data
+[models] REMOVED: LoadMeshEx(), Mesh struct variables can be directly accessed
+[models] REMOVED: UpdateMesh(), very ineficient
+[models] REMOVED: LoadHeightmap(), use GenMeshHeightmap() and LoadModelFromMesh()
+[models] REMOVED: LoadCubicmap(), use GenMeshCubicmap() and LoadModelFromMesh()
+[models] RENAMED: LoadDefaultMaterial() to LoadMaterialDefault()
+[models] ADDED: GenMeshPlane(), Generate plane mesh (with subdivisions)
+[models] ADDED: GenMeshCube(), Generate cuboid mesh
+[models] ADDED: GenMeshSphere(), Generate sphere mesh (standard sphere)
+[models] ADDED: GenMeshHemiSphere(), Generate half-sphere mesh (no bottom cap)
+[models] ADDED: GenMeshCylinder(), Generate cylinder mesh
+[models] ADDED: GenMeshTorus(), Generate torus mesh
+[models] ADDED: GenMeshKnot(), Generate trefoil knot mesh
+[models] ADDED: GenMeshHeightmap(), Generate heightmap mesh from image data
+[models] ADDED: GenMeshCubicmap(), Generate cubes-based map mesh from image data
+[raymath] REVIEWED: full Matrix functionality to align with GLM in usage
+[raymath] RENAMED: Vector3 functions for consistency: Vector*() renamed to Vector3*()
+[build] Integrate Android APK building into examples Makefile
+[build] Integrate Android APK building into templates Makefiles
+[build] Improved Visual Studio 2015 project, folders, references...
+[templates] Reviewed the full pack to support Android building
+[examples] Reviewed full collection to adapt to raylib changes
+[examples] [textures] ADDED: textures_image_generation
+[examples] [models] ADDED: models_mesh_generation
+[examples] [models] ADDED: models_material_pbr
+[examples] [models] ADDED: models_skybox
+[examples] [models] ADDED: models_yaw_pitch_roll
+[examples] [others] REVIEWED: rlgl_standalone
+[examples] [others] REVIEWED: audio_standalone
+[github] Moved raylib webpage to own repo: github.com/raysan5/raylib.com
+[games] Reviewed game: Koala Seasons
+[*] Updated STB libraries to latest version
+[*] Multiple bugs corrected (check github issues)
+
+-----------------------------------------------
+Release:     raylib 1.7.0 (20 May 2017)
+-----------------------------------------------
+NOTE: 
+  In this new raylib release, multiple parts of the library have been reviewed for consistency and simplification. 
+  It exposes almost 300 functions, around 30 new functions in comparison with previous version and, again, 
+  it sets a stepping stone towards raylib future.
+
+BIG changes:
+  - More than 30 new functions added to the library, check list below.
+  - Support of configuration flags on every raylib module, to customize library build.
+  - Improved build system for all supported platforms with a unique Makefile to compile sources.
+  - Complete review of examples and sample games, added new sample material.
+  - Support automatic GIF recording of current window, just pressing Ctrl+F12
+  - Improved library consistency and organization in general.
+
+other changes:
+[core] Added function: SetWindowIcon(), to setup icon by code
+[core] Added function: SetWindowMonitor(), to set current display monitor
+[core] Added function: SetWindowMinSize(), to set minimum resize size
+[core] Added function: TakeScreenshot(), made public to API (also launched internally with F12)
+[core] Added function: GetDirectoryPath(), get directory for a given fileName (with path)
+[core] Added function: GetWorkingDirectory(), get current working directory
+[core] Added function: ChangeDirectory(), change working directory
+[core] Added function: TraceLog(), made public to API
+[core] Improved timming system to avoid busy wait loop on frame sync: Wait()
+[core] Added support for gamepad on HTML5 platform
+[core] Support mouse lock, useful for camera system
+[core] Review functions description comments
+[rlgl] Removed function: GetStandardShader(), removed internal standard shader
+[rlgl] Removed function: CreateLight(), removed internal lighting system
+[rlgl] Removed function: DestroyLight(), removed internal lighting system
+[rlgl] Removed function: InitVrDevice(), removed VR device render, using simulator
+[rlgl] Removed function: CloseVrDevice(), removed VR device render, using simulator
+[rlgl] Removed function: IsVrDeviceReady(), removed VR device render, using simulator
+[rlgl] Removed function: IsVrSimulator(), removed VR device render, using simulator
+[rlgl] Added function: InitVrSimulator(), init VR simulator for selected device
+[rlgl] Added function: CloseVrSimulator(), close VR simulator for current device
+[rlgl] Added function: IsVrSimulatorReady(), detect if VR device is ready
+[rlgl] Added function: BeginVrDrawing(), begin VR simulator stereo rendering
+[rlgl] Added function: EndVrDrawing(), end VR simulator stereo rendering
+[rlgl] Renamed function: ReadTextFile() to LoadText() and exposed to API
+[rlgl] Removed internal lighting system and standard shader, moved to example
+[rlgl] Removed Oculus Rift support, moved to oculus_rift example
+[rlgl] Removed VR device support and replaced by VR simulator
+[shapes] Added function: DrawLineEx(), draw line with QUADS, supports custom line thick
+[shapes] Added function: DrawLineBezier(), draw a line using cubic-bezier curves in-out
+[shapes] Added function: DrawRectanglePro(), draw a color-filled rectangle with pro parameters
+[textures] Removed function: LoadImageFromRES(), redesigning custom RRES fileformat
+[textures] Removed function: LoadTextureFromRES(), redesigning custom RRES fileformat
+[textures] Removed function: LoadTextureEx(), use instead Image -> LoadImagePro(), LoadImageEx()
+[textures] Added function: LoadImagePro()), load image from raw data with parameters
+[textures] Review TraceLog() message when image file not found
+[text] Renamed function: LoadSpriteFontTTF() to LoadSpriteFontEx(), for consistency
+[text] Removed rBMF fileformat support, replaced by .png
+[text] Refactor SpriteFont struct (better for rres custom fileformat)
+[text] Renamed some variables for consistency
+[models] Added function: LoadMesh(), load mesh from file
+[models] Added function: LoadMeshEx(), load mesh from vertex data
+[models] Added function: UnloadMesh(), unload mesh from memory (RAM and/or VRAM)
+[models] Added function: GetCollisionRayMesh(), get collision info between ray and mesh
+[models] Added function: GetCollisionRayTriangle(), get collision info between ray and triangle
+[models] Added function: GetCollisionRayGround(), get collision info between ray and ground plane
+[models] Renamed function: LoadModelEx() to LoadModelFromMesh()
+[models] Removed function: DrawLight(), removed internal lighting system
+[models] Renamed function: LoadModelEx() to LoadModelFromMesh() for consistency
+[models] Removed function: LoadStandardMaterial(), removed internal standard shader
+[models] Removed function: LoadModelFromRES(), redesigning custom RRES fileformat
+[models] Renamed multiple variables for consistency
+[audio] Added function: SetMasterVolume(), define listener volume
+[audio] Added function: ResumeSound(), resume a paused sound
+[audio] Added function: SetMusicLoopCount(), set number of repeats for a music
+[audio] Added function: LoadWaveEx(), load wave from raw audio data
+[audio] Added function: WaveCrop(), crop wave audio data
+[audio] Added function: WaveFormat(), format audio data
+[audio] Removed function: LoadSoundFromRES(), redesigning custom RRES fileformat
+[audio] Added support for 32bit audio samples
+[audio] Preliminary support for multichannel, limited to mono and stereo
+[audio] Make sure buffers are ready for update: UpdateMusicStream()
+[utils] Replaced function: GetExtension() by IsFileExtension() and made public to API
+[utils] Unified function: TraceLog() between Android and other platforms
+[utils] Removed internal function: GetNextPOT(), simplified implementation
+[raymath] Added function: QuaternionToEuler(), to work with Euler angles
+[raymath] Added function: QuaternionFromEuler(), to work with Euler angles
+[raymath] Added multiple Vector2 math functions
+[build] Integrate Android source building into Makefile
+[example] Added example: shapes_lines_bezier
+[example] Added example: text_input_box
+[github] Moved gh-pages branch to master/docs
+[github] Moved rlua.h and Lua examples to own repo: raylib-lua
+[games] Reviewed full games collection
+[games] New game added to collection: Koala Seasons
+[*] Reviewed and improved examples collection (new assets)
+[*] Reorganized library functions, structs, enums
+[*] Updated STB libraries to latest version
+
+-----------------------------------------------
+Release:     raylib 1.6.0 (20 November 2016)
+-----------------------------------------------
+NOTE: 
+  This new raylib version commemorates raylib 3rd anniversary and represents another complete review of the library. 
+  It includes some interesting new features and is a stepping stone towards raylib future.
+
+HUGE changes:
+[rlua] Lua BINDING: Complete raylib Lua binding, ALL raylib functions ported to Lua plus the +60 code examples.
+[audio] COMPLETE REDESIGN: Improved music support and also raw audio data processing and playing, +20 new functions added.
+[physac] COMPLETE REWRITE: Improved performance, functionality and simplified usage, moved to own repository and added multiple examples!
+
+other changes:
+
+[core] Corrected issue on OSX with HighDPI display
+[core] Added flag to allow resizable window
+[core] Allow no default font loading
+[core] Corrected old issue with mouse buttons on web
+[core] Improved gamepad support, unified across platforms
+[core] Gamepad id functionality: GetGamepadName(), IsGamepadName()
+[core] Gamepad buttons/axis checking functionality:
+[core] Reviewed Android key inputs system, unified with desktop
+[rlgl] Redesigned lighting shader system
+[rlgl] Updated standard shader for better performance
+[rlgl] Support alpha on framebuffer: rlglLoadRenderTexture()
+[rlgl] Reviewed UpdateVrTracking() to update camera
+[rlgl] Added IsVrSimulator() to check for VR simulator
+[shapes] Corrected issue on DrawPolyEx()
+[textures] Simplified supported image formats support
+[textures] Improved text drawing within an image: ImageDrawText()
+[textures] Support image alpha mixing: ImageAlphaMask()
+[textures] Support textures filtering: SetTextureFilter()
+[textures] Support textures wrap modes: SetTextureWrap()
+[text] Improved TTF spritefont generation: LoadSpriteFontTTF()
+[text] Improved AngelCode fonts support (unordered chars)
+[text] Added TraceLog info on image spritefont loading
+[text] Improved text measurement: MeasureTextEx()
+[models] Improved OBJ loading flexibility
+[models] Reviewed functions: DrawLine3D(), DrawCircle3D()
+[models] Removed function: ResolveCollisionCubicmap()
+[camera] Redesigned camera system and ported to header-only
+[camera] Removed function: UpdateCameraPlayer()
+[gestures] Redesigned gestures module to header-only
+[audio] Simplified Music loading and playing system
+[audio] Added trace on audio device closing
+[audio] Reviewed Wave struct, improved flexibility
+[audio] Support sound data update: UpdateSound()
+[audio] Added support for FLAC audio loading/streaming
+[raygui] Removed raygui from raylib repo (moved to own repo)
+[build] Added OpenAL static library
+[build] Added Visual Studio 2015 projects
+[build] Support shared/dynamic raylib compilation
+[*] Updated LibOVR to SDK version 1.8
+[*] Updated games to latest raylib version
+[*] Improved examples and added new ones
+[*] Improved Android support
+
+-----------------------------------------------
+Release:     raylib 1.5.0 (18 July 2016)
+-----------------------------------------------
+NOTE: 
+  Probably this new version is the biggest boost of the library ever, lots of parts of the library have been redesigned, 
+  lots of bugs have been solved and some **AMAZING** new features have been added.
+
+HUGE changes:
+[rlgl] OCULUS RIFT CV1: Added support for VR, not oly Oculus Rift CV1 but also stereo rendering simulator (multiplatform).
+[rlgl] MATERIALS SYSTEM: Added support for Materials (.mtl) and multiple material properties: diffuse, specular, normal.
+[rlgl] LIGHTING SYSTEM: Added support for up to 8 lights of 3 different types: Omni, Directional and Spot.
+[physac] REDESIGNED: Improved performance and simplified usage, physic objects now are managed internally in a second thread!
+[audio] CHIPTUNES: Added support for module audio music (.xm, .mod) loading and playing. Multiple mixing channels supported.
+
+other changes:
+
+[core] Review Android button inputs
+[core] Support Android internal data storage
+[core] Renamed WorldToScreen() to GetWorldToScreen()
+[core] Removed function SetCustomCursor()
+[core] Removed functions BeginDrawingEx(), BeginDrawingPro()
+[core] Replaced functions InitDisplay() + InitGraphics() with: InitGraphicsDevice()
+[core] Added support for field-of-view Y (fovy) on 3d Camera
+[core] Added 2D camera mode functions: Begin2dMode() - End2dMode()
+[core] Translate mouse inputs to Android touch/gestures internally
+[core] Translate mouse inputs as touch inputs in HTML5
+[core] Improved function GetKeyPressed() to support multiple keys (including function keys)
+[core] Improved gamepad support, specially for RaspberryPi (including multiple gamepads support)
+[rlgl] Support stereo rendering simulation (duplicate draw calls by viewport, optimized)
+[rlgl] Added distortion shader (embeded) to support custom VR simulator: shader_distortion.h
+[rlgl] Added support for OpenGL 2.1 on desktop
+[rlgl] Improved 2D vs 3D drawing system (lines, triangles, quads)
+[rlgl] Improved DXT-ETC1 support on HTML5
+[rlgl] Review function: rlglUnproject()
+[rlgl] Removed function: rlglInitGraphics(), integrated into rlglInit()
+[rlgl] Updated Mesh and Shader structs
+[rlgl] Simplified internal (default) dynamic buffers
+[rlgl] Added support for indexed and dynamic mesh data
+[rlgl] Set fixed vertex attribs location points
+[rlgl] Improved mesh data loading support
+[rlgl] Added standard shader (embeded) to support materials and lighting: shader_standard.h
+[rlgl] Added light functions: CreateLight(), DestroyLight()
+[rlgl] Added wire mode functions: rlDisableWireMode(), rlEnableWireMode()
+[rlgl] Review function consistency, added: rlglLoadMesh(), rlglUpdateMesh(), rlglDrawMesh(), rlglUnloadMesh()
+[rlgl] Replaced SetCustomShader() by: BeginShaderMode() - EndShaderMode()
+[rlgl] Replaced SetBlendMode() by: BeginBlendMode() - EndBlendMode()
+[rlgl] Added functions to customize internal matrices: SetMatrixProjection(), SetMatrixModelview()
+[rlgl] Unified internal shaders to only one default shader
+[rlgl] Added support for render to texture (RenderTexture2D): 
+          LoadRenderTexture() - UnloadRenderTexture()
+          BeginTextureMode() - EndTextureMode()
+[rlgl] Removed SetShaderMap*() functions
+[rlgl] Redesigned default buffers usage functions:
+          LoadDefaultBuffers() - UnloadDefaultBuffers()
+          UpdateDefaultBuffers() - DrawDefaultBuffers()
+[shapes] Corrected bug on GetCollisionRec()
+[textures] Added support for Nearest-Neighbor image scaling
+[textures] Added functions to draw text on image: ImageDrawText(), ImageDrawTextEx()
+[text] Reorganized internal functions: Added LoadImageFont()
+[text] Security check for unsupported BMFonts
+[models] Split mesh creation from model loading on heightmap and cubicmap
+[models] Updated BoundingBox collision detections
+[models] Added color parameter to DrawBoundigBox()
+[models] Removed function: DrawQuad()
+[models] Removed function: SetModelTexture()
+[models] Redesigned DrawPlane() to use RL_TRIANGLES
+[models] Redesigned DrawRectangleV() to use RL_TRIANGLES
+[models] Redesign to accomodate new materials system: LoadMaterial()
+[models] Added material functions: LoadDefaultMaterial(), LoadStandardMaterial()
+[models] Added MTL material loading support: LoadMTL()
+[models] Added function: DrawLight()
+[audio] Renamed SoundIsPlaying() to IsSoundPlaying()
+[audio] Renamed MusicIsPlaying() to IsMusicPlaying()
+[audio] Support multiple Music streams (indexed)
+[audio] Support multiple mixing channels
+[gestures] Improved and reviewed gestures system
+[raymath] Added QuaternionInvert()
+[raymath] Removed function: PrintMatrix()
+[raygui] Ported to header-only library (https://github.com/raysan5/raygui)
+[shaders] Added depth drawing shader (requires a depth texture)
+[shaders] Reviewed included shaders and added comments
+[OpenAL Soft] Updated to latest version (1.17.2)
+[GLFW3] Updated to latest version (3.2)
+[stb] Updated to latest headers versions
+[GLAD] Converted to header only library and simplified to only used extensions
+[*] Reorganize library folders: external libs moved to src/external folder
+[*] Reorganize src folder for Android library
+[*] Review external dependencies usage
+[*] Improved Linux and OSX build systems
+[*] Lots of tweaks and bugs corrected all around
+
+-----------------------------------------------
+Release:     raylib 1.4.0 (22 February 2016)
+-----------------------------------------------
+NOTE: 
+  This version supposed another big improvement for raylib, including new modules and new features.
+  More than 30 new functions have been added to previous raylib version.
+  Around 8 new examples and +10 new game samples have been added.
+
+BIG changes:
+[textures] IMAGE MANIPULATION: Functions to crop, resize, colorize, flip, dither and even draw image-to-image or text-to-image.
+[text] SPRITEFONT SUPPORT: Added support for AngelCode fonts (.fnt) and TrueType fonts (.ttf).
+[gestures] REDESIGN: Gestures system simplified and prepared to process generic touch events, including mouse events (multiplatform).
+[physac] NEW MODULE: Basic 2D physics support, use colliders and rigidbodies; apply forces to physic objects.
+
+other changes:
+
+[rlgl] Removed GLEW library dependency, now using GLAD
+[rlgl] Implemented alternative to glGetTexImage() on OpenGL ES
+[rlgl] Using depth data on batch drawing
+[rlgl] Reviewed glReadPixels() function
+[core][rlgl] Reviewed raycast system, now 3D picking works
+[core] Android: Reviewed Android App cycle, paused if inactive
+[shaders] Implemented Blinn-Phong lighting shading model
+[textures] Implemented Floyd-Steinberg dithering - ImageDither()
+[text] Added line-break support to DrawText()
+[text] Added TrueType Fonts support (using stb_truetype)
+[models] Implement function: CalculateBoundingBox(Mesh mesh)
+[models] Added functions to check Ray collisions
+[models] Improve map resolution control on LoadHeightmap()
+[camera] Corrected small-glitch on zoom-in with mouse-wheel
+[gestures] Implemented SetGesturesEnabled() to enable only some gestures
+[gestures] Implemented GetElapsedTime() on Windows system
+[gestures] Support mouse gestures for desktop platforms
+[raymath] Complete review of the module and converted to header-only
+[easings] Added new module for easing animations
+[stb] Updated to latest headers versions
+[*] Lots of tweaks around
+
+-----------------------------------------------
+Release:     raylib 1.3.0 (01 September 2015)
+-----------------------------------------------
+NOTE: 
+  This version supposed a big boost for raylib, new modules have been added with lots of features.
+  Most of the modules have been completely reviewed to accomodate to the new features.
+  Over 50 new functions have been added to previous raylib version.
+  Most of the examples have been redone and +10 new advanced examples have been added.
+
+BIG changes:
+[rlgl] SHADERS: Support for model shaders and postprocessing shaders (multiple functions)
+[textures] FORMATS: Support for multiple internal formats, including compressed formats
+[camera] NEW MODULE: Set of cameras for 3d view: Free, Orbital, 1st person, 3rd person
+[gestures] NEW MODULE: Gestures system for Android and HTML5 platforms
+[raygui] NEW MODULE: Set of IMGUI elements for tools development (experimental)
+
+other changes:
+
+[rlgl] Added check for OpenGL supported extensions
+[rlgl] Added function SetBlenMode() to select some predefined blending modes 
+[core] Added support for drop&drag of external files into running program
+[core] Added functions ShowCursor(), HideCursor(), IsCursorHidden()
+[core] Renamed function SetFlags() to SetConfigFlags()
+[shapes] Simplified some functions to improve performance
+[textures] Review of Image struct to support multiple data formats
+[textures] Added function LoadImageEx() 
+[textures] Added function LoadImageRaw()
+[textures] Added function LoadTextureEx()
+[textures] Simplified function parameters LoadTextureFromImage()
+[textures] Added function GetImageData()
+[textures] Added function GetTextureData()
+[textures] Renamed function ConvertToPOT() to ImageConvertToPOT()
+[textures] Added function ImageConvertFormat()
+[textures] Added function GenTextureMipmaps()
+[text] Added support for Latin-1 Extended characters for default font
+[text] Redesigned SpriteFont struct, replaced Character struct by Rectangle
+[text] Removed function GetFontBaseSize(), use directly spriteFont.size
+[models] Review of struct: Model (added shaders support)
+[models] Added 3d collision functions (sphere vs sphere vs box vs box)
+[models] Added function DrawCubeTexture()
+[models] Added function DrawQuad()
+[models] Added function DrawRay()
+[models] Simplified funtion DrawPlane()
+[models] Removed function DrawPlaneEx()
+[models] Simplified funtion DrawGizmo()
+[models] Removed function DrawGizmoEx()
+[models] Added function LoadModelEx()
+[models] Review of function LoadCubicMap()
+[models] Added function ResolveCollisionCubicmap()
+[audio] Decopupled from raylib, now this module can be used as standalone
+[audio] Added function UpdateMusicStream()
+[raymath] Complete review of the module
+[stb] Updated to latest headers versions
+[*] Lots of tweaks around
+
+-----------------------------------------------
+Release:     raylib 1.2.2 (31 December 2014)
+-----------------------------------------------
+[*] Added support for HTML5 compiling (emscripten, asm.js)
+[core] Corrected bug on input handling (keyboard and mouse)
+[textures] Renamed function CreateTexture() to LoadTextureFromImage()
+[textures] Added function ConvertToPOT()
+[rlgl] Added support for color tint on models on GL 3.3+ and ES2
+[rlgl] Added support for normals on models
+[models] Corrected bug on DrawBillboard()
+[models] Corrected bug on DrawHeightmap()
+[models] Renamed LoadCubesmap() to LoadCubicmap()
+[audio] Added function LoadSoundFromWave()
+[makefile] Added support for Linux and OSX compiling
+[stb] Updated to latest headers versions
+[*] Lots of tweaks around
+
+---------------------------------------------------------------
+Update:     raylib 1.2.1 (17 October 2014) (Small Fixes Update)
+---------------------------------------------------------------
+[core] Added function SetupFlags() to preconfigure raylib Window
+[core] Corrected bug on fullscreen mode
+[rlgl] rlglDrawmodel() - Added rotation on Y axis
+[text] MeasureTextEx() - Corrected bug on measures for default font
+
+-----------------------------------------------
+Release:     raylib 1.2 (16 September 2014)
+-----------------------------------------------
+NOTE: 
+  This version supposed a complete redesign of the [core] module to support Android and Raspberry Pi.
+  Multiples modules have also been tweaked to accomodate to the new platforms, specially [rlgl]
+
+[core] Added multiple platforms support: Android and Raspberry Pi
+[core] InitWindow() - Complete rewrite and split for Android
+[core] InitDisplay() - Internal function added to calculate proper display size
+[core] InitGraphics() - Internal function where OpenGL graphics are initialized
+[core] Complete refactoring of input functions to accomodate to new platforms
+[core] Mouse and Keyboard raw data reading functions added for Raspberry Pi
+[core] GetTouchX(), GetTouchY() - Added for Android
+[core] Added Android callbacks to process inputs and Android activity commands
+[rlgl] Adjusted buffers depending on platform
+[rlgl] Added security check in case deployed vertex excess buffer size
+[rlgl] Adjusted indices type depending on GL version (int or short)
+[rlgl] Fallback to VBOs only usage if VAOs not supported on ES2
+[rlgl] rlglLoadModel() stores vbo ids on new Model struct
+[textures] Added support for PKM files (ETC1, ETC2 compression support)
+[shapes] DrawRectangleV() - Modified, depending on OGL version uses TRIANGLES or QUADS
+[text] LoadSpriteFont() - Modified to use LoadImage()
+[models] Minor changes on models loading to accomodate to new Model struct
+[audio] PauseMusicStream(), ResumeMusicStream() - Added
+[audio] Reduced music buffer size to avoid stalls on Raspberry Pi
+[src] Added makefile for Windows and RPI
+[src] Added resources file (raylib icon and executable info)
+[examples] Added makefile for Windows and RPI
+[examples] Renamed and merged with test examples for coherence with module names
+[templates] Added multiple templates to be use as a base-code for games
+
+-----------------------------------------------
+Release:     raylib 1.1.1 (22 July 2014)
+-----------------------------------------------
+[core] ShowLogo() - To enable raylib logo animation at startup
+[core] Corrected bug with window resizing
+[rlgl] Redefined colors arrays to use byte instead of float
+[rlgl] Removed double buffer system (no performance improvement)
+[rlgl] rlglDraw() - Reorganized buffers drawing order
+[rlgl] Corrected bug on screen resizing
+[shapes] DrawRectangle() - Use QUADS instead of TRIANGLES
+[models] DrawSphereWires() - Corrected some issues
+[models] LoadOBJ() - Redesigned to support multiple meshes
+[models] LoadCubesMap() - Loading a map as cubes (by pixel color)
+[textures] Added security check if file doesn't exist
+[text] Corrected bug on SpriteFont loading
+[examples] Corrected some 3d examples
+[test] Added cubesmap loading test
+
+-----------------------------------------------
+Release:     raylib 1.1.0 (19 April 2014)
+-----------------------------------------------
+NOTE: 
+  This version supposed a complete internal redesign of the library to support OpenGL 3.3+ and OpenGL ES 2.0.
+  New module [rlgl] has been added to 'translate' immediate mode style functions (i.e. rlVertex3f()) to GL 1.1, 3.3+ or ES2.
+  Another new module [raymath] has also been added with lot of useful 3D math vector-matrix-quaternion functions.
+
+[rlgl] New module, abstracts OpenGL rendering (multiple versions support)
+[raymath] New module, useful 3D math vector-matrix-quaternion functions
+[core] Adapt all OpenGL code (initialization, drawing) to use [rlgl]
+[shapes] Rewrite all shapes drawing functions to use [rlgl]
+[textures] Adapt texture GPU loading to use [rlgl]
+[textures] Added support for DDS images (compressed and uncompressed)
+[textures] CreateTexture() - Redesigned to add mipmap automatic generation
+[textures] DrawTexturePro() - Redesigned and corrected bugs
+[models] Rewrite all 3d-shapes drawing functions to use [rlgl]
+[models] Adapt model loading and drawing to use [rlgl]
+[models] Model struct updated to include texture id
+[models] SetModelTexture() - Added, link a texture to a model
+[models] DrawModelEx() - Redesigned with extended parameters
+[audio] Added music streaming support (OGG files)
+[audio] Added support for OGG files as Sound
+[audio] PlayMusicStream() - Added, open a new music stream and play it
+[audio] StopMusicStream() - Added, stop music stream playing and close stream
+[audio] PauseMusicStream() - Added, pause music stream playing
+[audio] MusicIsPlaying() - Added, to check if music is playing
+[audio] SetMusicVolume() - Added, set volume for music
+[audio] GetMusicTimeLength() - Added, get current music time length (in seconds)
+[audio] GetMusicTimePlayed() - Added, get current music time played (in seconds)
+[utils] Added log tracing functionality - TraceLog(), TraceLogOpen(), TraceLogClose()
+[*] Log tracing messages all around the code
+
+-----------------------------------------------
+Release:     raylib 1.0.6 (16 March 2014)
+-----------------------------------------------
+[core] Removed unused lighting-system code
+[core] Removed SetPerspective() function, calculated directly
+[core] Unload and reload default font on fullscreen toggle
+[core] Corrected bug gamepad buttons checking if no gamepad available 
+[texture] DrawTextureV() - Added, to draw using Vector2 for position
+[texture] LoadTexture() - Redesigned, now uses LoadImage() + CreateTexture()
+[text] FormatText() - Corrected memory leak bug
+[models] Added Matrix struct and related functions
+[models] DrawBillboard() - Reviewed, now it works!
+[models] DrawBillboardRec() - Reviewed, now it works!
+[tests] Added folder with multiple tests for new functions
+
+-----------------------------------------------
+Update:     raylib 1.0.5 (28 January 2014)
+-----------------------------------------------
+[audio] LoadSound() - Corrected a bug, WAV file was not closed!
+[core] GetMouseWheelMove() - Added, check mouse wheel Y movement
+[texture] CreateTexture2D() renamed to CreateTexture()
+[models] LoadHeightmap() - Added, Heightmap can be loaded as a Model
+[tool] rREM updated, now supports (partially) drag and drop of files 
 
 -----------------------------------------------
 Release:     raylib 1.0.4 (23 January 2014)

CMakeLists.txt

@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 3.0)
+
+# Config options
+option(BUILD_EXAMPLES "Build the examples." ON)
+option(BUILD_GAMES "Build the example games." ON)
+option(ENABLE_ASAN  "Enable AddressSanitizer (ASAN) for debugging (degrades performance)" OFF)
+option(ENABLE_UBSAN "Enable UndefinedBehaviorSanitizer (UBSan) for debugging" OFF)
+option(ENABLE_MSAN "Enable MemorySanitizer (MSan) for debugging (not recommended for run with ASAN)" OFF)
+
+if(CMAKE_VERSION VERSION_LESS "3.1")
+  if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    set(CMAKE_C_FLAGS "-std=gnu99 ${CMAKE_C_FLAGS}")
+  endif()
+else()
+  set (CMAKE_C_STANDARD 99)
+endif()
+
+include(CheckCCompilerFlag)
+function(add_if_flag_works flag)
+    CHECK_C_COMPILER_FLAG("${flag}" COMPILER_HAS_THOSE_TOGGLES)
+    set(outcome "Failed")
+    if(COMPILER_HAS_THOSE_TOGGLES)
+        foreach(var ${ARGN})
+            set(${var} "${flag} ${${var}}" PARENT_SCOPE)
+        endforeach()
+        set(outcome "works")
+    endif()
+    message(STATUS "Testing if ${flag} can be used -- ${outcome}")
+endfunction()
+
+add_if_flag_works(-Werror=pointer-arith CMAKE_C_FLAGS)
+add_if_flag_works(-Werror=implicit-function-declaration CMAKE_C_FLAGS)
+# src/external/jar_xm.h does shady stuff
+add_if_flag_works(-fno-strict-aliasing CMAKE_C_FLAGS)
+
+if (ENABLE_ASAN)
+    add_if_flag_works(-fno-omit-frame-pointer CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+    add_if_flag_works(-fsanitize=address CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+endif()
+if (ENABLE_UBSAN)
+    add_if_flag_works(-fno-omit-frame-pointer CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+    add_if_flag_works(-fsanitize=undefined CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+endif()
+if (ENABLE_MSAN)
+    add_if_flag_works(-fno-omit-frame-pointer CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+    add_if_flag_works(-fsanitize=memory CMAKE_C_FLAGS CMAKE_LINKER_FLAGS)
+endif()
+
+if (ENABLE_MSAN AND ENABLE_ASAN)
+    MESSAGE(WARNING "Compiling with both AddressSanitizer and MemorySanitizer is not recommended")
+endif()
+
+add_subdirectory(src release)
+
+if (${BUILD_EXAMPLES})
+  add_subdirectory(examples)
+endif()
+
+if (${BUILD_GAMES})
+  add_subdirectory(games)
+endif()

CONTRIBUTING.md

@@ -0,0 +1,128 @@
+## Contributing to raylib
+
+Hello contributors! Welcome to raylib! 
+
+This document contains a set of guidelines to contribute to the project. These are mostly guidelines, not rules. 
+Use your best judgement, and feel free to propose changes to this document in a pull-request.
+
+### raylib philosophy
+
+ - raylib is a tool to LEARN videogames programming, every single function in raylib should be a tutorial on itself.
+ - raylib is SIMPLE and EASY-TO-USE, I tried to keep it compact with a small set of functions, if a function is too complex or is not clearly useful, better not to include it.
+ - raylib is open source and free; educators and institutions can use this tool to TEACH videogames programming completely by free.
+ - raylib is collaborative; contribution of tutorials / code-examples / bugs-solving / code-comments are highly appreciated.
+ - raylib's license (and its external libs respective licenses) allow using it for commercial products.
+
+### Some interesting reads to start with
+
+ - [raylib history](HISTORY.md)
+ - [raylib architecture](https://github.com/raysan5/raylib/wiki/raylib-architecture)
+ - [raylib license](LICENSE.md)
+ - [raylib roadmap](ROADMAP.md)
+ 
+[raylib Wiki](https://github.com/raysan5/raylib/wiki) contains some information about the library and is open to anyone for edit. 
+Feel free to review it if required, just take care not to break anything.
+
+### raylib C coding conventions
+
+Despite being written in C, raylib does not follow the standard Hungarian notation for C, 
+it [follows Pascal-case/camel-case notation](https://github.com/raysan5/raylib/wiki/raylib-coding-conventions), 
+more common on C# language. All code formatting decisions have been carefully taken
+to make it easier for students to read, write and understand code. 
+
+Source code is extensively commented for that purpose, raylib primary learning method is:
+
+ > learn by reading code and examples
+
+For detailed information on building raylib and examples, please check [raylib Wiki](https://github.com/raysan5/raylib/wiki).
+
+### Opening new Issues
+
+To open new issue for raylib (bug, enhancement, discussion...), just try to follow these rules:
+
+ - Make sure the issue has not already been reported before by searching on GitHub under Issues.
+ - If you're unable to find an open issue addressing the problem, open a new one. Be sure to include a 
+ title and clear description, as much relevant information as possible, and a code sample demonstrating the unexpected behavior.
+ - If applies, attach some screenshot of the issue and a .zip file with the code sample and required resources.
+ - On issue description, add a brackets tag about the raylib module that relates to this issue. 
+ If don't know the module, just report the issue, I will review it.
+ - You can check other issues to see how is being done!
+
+### Sending a Pull-Request
+
+ - Make sure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
+ - Don't send big pull-requests (lots of changelists), they are difficult to review. It's better to send small pull-request, one at a time.
+ - Verify that changes don't break the build (at least on Windows platform). As many platforms where you can test it, the better, but don't worry
+ if you cannot test all the platforms.
+
+### raylib bindings
+
+Some people ported raylib to other languages in form of bindings or wrappers to the library, here is a list with the ones I'm aware of:
+
+ - [raylib C/C++ version (default)](https://github.com/raysan5/raylib)
+ - [raylib Lua binding](https://github.com/raysan5/raylib-lua)
+ - [raylib Go binding](https://github.com/gen2brain/raylib-go)
+ - [raylib Nim binding](https://gitlab.com/define-private-public/raylib-Nim)
+ - [raylib Crystal binding](https://gitlab.com/Zatherz/cray) 
+ - [raylib Perl wrapper](https://metacpan.org/pod/Graphics::Raylib) 
+ - raylib Pascal binding with custom IDE (closed-source)
+ 
+Usually, raylib bindings follow the convention: `raylib-{language}`
+
+Let me know if you're writing a new binding for raylib, I will list it here and I usually 
+provide the icon/logo for that new language binding.
+
+### Contact information
+
+If you have any doubt, don't hesitate to [contact me](mailto:ray@raylib.com)!.
+You can write me a direct mail but you can also contact me on the following networks:
+
+ - [raylib forum](http://forum.raylib.com/) - A good place for discussions or to ask for help.
+ - [raylib gitter](https://gitter.im/raylib) - A direct communication channel for project discussions.
+ - [raylib twitter](https://twitter.com/raysan5) - My personal twitter account, I usually post about raylib, you can send me PMs.
+ - [raylib web](http://www.raylib.com/) - On top-right corner there is a bunch of networks where you can find me.
+
+Thank you very much for your time! :)
+
+----
+
+Here is a list of raylib contributors, these people have invested part of their time 
+contributing (in some way or another) to make the raylib project better. Huge thanks to all of them!
+
+ - [Zopokx](https://github.com/Zopokx) for testing the web.
+ - [Elendow](http://www.elendow.com) for testing and helping on web development.
+ - Victor Dual for implementing and testing 3D shapes functions.
+ - Marc Palau for implementing and testing 3D shapes functions and contribute on camera and gestures modules.
+ - Kevin Gato for improving texture internal formats support and helping on raygui development. 
+ - Daniel Nicolas for improving texture internal formats support and helping on raygui development. 
+ - Marc Agüera for testing and using raylib on a real product ([Koala Seasons](http://www.koalaseasons.com))
+ - Daniel Moreno for testing and using raylib on a real product ([Koala Seasons](http://www.koalaseasons.com))
+ - Daniel Gomez for testing and using raylib on a real product ([Koala Seasons](http://www.koalaseasons.com))
+ - [Sergio Martinez](https://github.com/anidealgift) for helping on raygui development and tools development (raygui_styler).
+ - [Victor Fisac](https://github.com/victorfisac) for developing physics raylib module (physac) and implementing PBR materials and lighting systems... among multiple other improvements and multiple tools and games. 
+ - Albert Martos for helping on raygui and porting examples and game-templates to Android and HTML5.
+ - Ian Eito for helping on raygui and porting examples and game-templates to Android and HTML5.
+ - [procedural](https://github.com/procedural) for testing raylib on Linux, correcting some bugs and adding several mouse functions.
+ - [Chris Hemingway](https://github.com/cHemingway) for improving raylib on OSX build system.
+ - [Emanuele Petriglia](https://github.com/LelixSuper) for working on multiple GNU/Linux improvements and developing [TicTacToe](https://github.com/LelixSuper/TicTacToe) raylib game.
+ - [Joshua Reisenauer](https://github.com/kd7tck) for adding audio modules support (XM, MOD) and reviewing audio system.
+ - [Marcelo Paez](https://github.com/paezao) for his help on OSX to solve High DPI display issue. Thanks Marcelo!
+ - [Ghassan Al-Mashareqa](https://github.com/ghassanpl) for his amazing contribution with raylib Lua module, I just work over his code to implement [rlua](https://github.com/raysan5/raylib/blob/master/src/rlua.h)
+ - [Teodor Stoenescu](https://github.com/teodor-stoenescu) for his improvements on OBJ object loading.
+ - [RDR8](https://github.com/RDR8) for helping with Linux build improvements
+ - [Saggi Mizrahi](https://github.com/ficoos) for multiple fixes on Linux and audio system
+ - [Daniel Lemos](https://github.com/xspager) for fixing issues on Linux games building
+ - [Joel Davis](https://github.com/joeld42) for adding raycast picking utilities and a [great example](https://github.com/raysan5/raylib/blob/master/examples/models/models_mesh_picking.c)
+ - [Richard Goodwin](https://github.com/AudioMorphology) for adding RPI touchscreen support
+ - [Milan Nikolic](https://github.com/gen2brain) for adding Android build support with custom standalone toolchain
+ - [Michael Vetter](https://github.com/jubalh) for improvements on build system and adding meson support for Linux
+ - [Wilhem Barbier](https://github.com/nounoursheureux) for adding Image generation functions and some fixes
+ - [Benjamin Summerton](https://github.com/define-private-public) for improving OSX building and his amazing work on CMake build sytem
+ - [MartinFX](https://github.com/Martinfx) for adding compilation support for FreeBSD OS
+ - [Wilhem Barbier](https://github.com/nounoursheureux) for supporting default shaders on shader loading, if shader not provided
+ - [Ahmad Fatoum](https://github.com/a3f) for implementing continuus integration support for raylib (Travis and AppVeyor) and greatly improving build system.
+ - [SamNChiet](https://github.com/SamNChiet) for his work on UWP inputs implementation.
+ - [David Reid](https://github.com/mackron) for a complete review of audio module to support his amazing mini_al audio library.
+ - [Kai](https://github.com/questor) for multiple code reviews and improvements.
+ 
+Please, if I forget someone in this list, excuse me and write me an email to remind me to add you!

HELPME.md

@@ -7,23 +7,21 @@ please, [let me know][raysan5].
 The following help is highly appreciated:
 
 	- C programming - Can you write / review / test / improve the code? 
-	- Translators / Localizators - Can you translate raylib to another language?
 	- Documentation / Tutorials / Example writters - Can you write some tutorial / example?
-	- Web Development - Can you help with the web? Can you setup a forum?
-	- Porting to Linux and OSX - Can you compile and test raylib on another OS?
+	- Web Development - Can you help with the web? SEO, style, code writting: https://github.com/raysan5/raylib.com
+	- Porting to Linux, OSX, RaspberryPi, consoles... - Can you compile and test raylib on another systems?
 	- Testers of current features and multiple systems - Can you find some bug on raylib?
 
 If you can not help on any of the above points but you still want to contribute in some way... please, consider helping 
-with a small [donation](http://www.raylib.com/helpme.htm) (just some euros...). It will really motivate to continue improving this project (and pay some bills… or some coffee).
+with a small [donation](http://www.raylib.com/helpme.html) or contributing with [raylib patreon](https://www.patreon.com/raysan5). It will really motivate to continue improving this project...
 
 raylib philosophy
 ------------------
 
    * raylib is a tool to LEARN videogames programming, every single function in raylib should be a tutorial on itself.
-   * raylib is SIMPLE and EASY-TO-USE, I tried to keep it compact with a small set of functions, if a function is too complex or 
-	 has not a clear usefulness, better not to include it.
+   * raylib is SIMPLE and EASY-TO-USE, I tried to keep it compact with a small set of functions, if a function is too complex or has not a clear usefulness, better not to include it.
    * raylib is open source and free; educators and institutions can use this tool to TEACH videogames programming completely by free. 
-   * raylib is, hopefully, collaborative; contribution of tutorials / code-examples / bugs-solving / code-comments are highly appreciated.
+   * raylib is collaborative; contribution of tutorials / code-examples / bugs-solving / code-comments are highly appreciated.
    * raylib's license (and its external libs respective licenses) allow using it for commercial products.
 
 contact
@@ -32,6 +30,8 @@ contact
    * Webpage: [http://www.raylib.com](http://www.raylib.com)
    * Twitter: [http://www.twitter.com/raysan5](http://www.twitter.com/raysan5)
    * Facebook: [http://www.facebook.com/raylibgames](http://www.facebook.com/raylibgames)
+   * Reddit: [https://www.reddit.com/r/raylib](https://www.reddit.com/r/raylib)
+   * Twitch: [http://www.twitch.tv/raysan5](http://www.twitch.tv/raysan5)
+   * Patreon: [https://www.patreon.com/raysan5](https://www.patreon.com/raysan5)
    
-   
-[raysan5]: mailto:raysan@raysanweb.com "Ramon Santamaria - Ray San"
+[raysan5]: mailto:ray@raylib.com "Ramon Santamaria - Ray San"

HISTORY.md

@@ -0,0 +1,204 @@
+<img src="https://github.com/raysan5/raylib/blob/master/logo/logo256x256.png" width=256>
+
+history
+-------
+
+I've developed videogames for some years and 4 years ago I started teaching videogames development 
+to young people with artistic profile, most of them had never written a single line of code.
+
+I started with C language basis and, after searching for the most simple and easy-to-use library to teach 
+videogames programming, I found WinBGI; it was great and it worked very well with students, in just a 
+couple of weeks that people that had never written a single line of code were able to program (and understand) 
+a simple PONG and some of them even a BREAKOUT!
+
+But WinBGI was not the clearer and most organized lib. There were a lot of things I found useless and 
+confusing and some function names were not clear enough for most of the students; not to mention points 
+like no transparencies support or no hardware acceleration.
+
+So, I decided to create my own lib, hardware accelerated, clear function names, quite organized, well structured, 
+plain C coding and, the most important, primarily intended to LEARN videogames programming.
+
+I've coded quite a lot in C# and XNA and I really love it (in fact, my students learn C# after C), 
+so, I decided to use C# language notation and XNA naming conventions. That way, students can jump from 
+raylib to XNA, MonoGame or similar libs extremely easily.
+
+raylib started as a weekend project and after three months of hard work, raylib 1.0 was published on November 2013.
+
+Enjoy it.
+
+notes on raylib 1.1
+-------------------
+
+On April 2014, after 6 month of first raylib release, raylib 1.1 has been released. This new version presents a
+complete internal redesign of the library to support OpenGL 1.1, OpenGL 3.3+ and OpenGL ES 2.0.
+
+A new module named [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.h) has been added to the library. This new module translates raylib-OpenGL-style 
+immediate mode functions (i.e. rlVertex3f(), rlBegin(), ...) to different versions of OpenGL (1.1, 3.3+, ES2), selectable by one define.
+
+[rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.h) also comes with a second new module named [raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h), which includes
+a bunch of useful functions for 3d-math with vectors, matrices and quaternions.
+
+Some other big changes of this new version have been the support for OGG files loading and stream playing, and the
+support of DDS texture files (compressed and uncompressed) along with mipmaps support.
+
+Lots of code changes and lot of testing have concluded in this amazing new raylib 1.1.
+
+notes on raylib 1.2
+-------------------
+
+On September 2014, after 5 month of raylib 1.1 release, it comes raylib 1.2. Again, this version presents a
+complete internal redesign of [core](https://github.com/raysan5/raylib/blob/master/src/core.c) module to support two new platforms: [Android](http://www.android.com/) and [Raspberry Pi](http://www.raspberrypi.org/).
+
+It's been some month of really hard work to accomodate raylib to those new platforms while keeping it easy for the user.
+On Android, raylib manages internally the activity cicle, as well as the inputs; on Raspberry Pi, a complete raw input
+system has been written from scratch.
+
+A new display initialization system has been created to support multiple resolutions, adding black bars if required;
+user only defines desired screen size and it gets properly displayed.
+
+Now raylib can easily deploy games to Android devices and Raspberry Pi (console mode).
+
+Lots of code changes and lot of testing have concluded in this amazing new raylib 1.2.
+
+In December 2014, new raylib 1.2.2 was published with support to compile directly for web (html5) using [emscripten](http://kripken.github.io/emscripten-site/) and [asm.js](http://asmjs.org/).
+
+notes on raylib 1.3
+-------------------
+
+On September 2015, after 1 year of raylib 1.2 release, arrives raylib 1.3. This version adds shaders functionality,
+improves tremendously textures module and also provides some new modules (camera system, gestures system, IMGUI).
+
+Shaders support is the biggest addition to raylib 1.3, with support for easy shaders loading and use. Loaded shaders can be
+attached to 3d models or used as fullscreen postrocessing effects. A bunch of postprocessing shaders are also included
+in this release, check raylib/shaders folder.
+
+Textures module has grown to support most of the internal texture formats available in OpenGL (RGB565, RGB888, RGBA5551, RGBA4444, etc.), including compressed texture formats (DXT, ETC1, ETC2, ASTC, PVRT); raylib 1.3 can load .dds, .pkm, .ktx, .astc and .pvr files. 
+A brand new [camera](https://github.com/raysan5/raylib/blob/master/src/camera.c) module offers to the user multiple preconfigured ready-to-use camera systems (free camera, 1st person, 3rd person).
+Camera modes are very easy to use, just check examples: [core_3d_camera_free.c](https://github.com/raysan5/raylib/blob/master/examples/core_3d_camera_free.c) and [core_3d_camera_first_person.c](https://github.com/raysan5/raylib/blob/master/examples/core_3d_camera_first_person.c).
+
+New [gestures](https://github.com/raysan5/raylib/blob/master/src/gestures.h) module simplifies gestures detection on Android and HTML5 programs.
+
+[raygui](https://github.com/raysan5/raylib/blob/master/src/raygui.h), the new IMGUI (Immediate Mode GUI) module offers a set of functions to create simple user interfaces,
+primary intended for tools development. It's still in experimental state but already fully functional.
+
+Most of the examples have been completely rewritten and +10 new examples have been added to show the new raylib features.
+
+Lots of code changes and lot of testing have concluded in this amazing new raylib 1.3.
+
+notes on raylib 1.4
+-------------------
+
+On February 2016, after 4 months of raylib 1.3 release, it comes raylib 1.4. For this new version, 
+lots of parts of the library have been reviewed, lots of bugs have been solved and some interesting features have been added.
+
+First big addition is a set of [Image manipulation functions](https://github.com/raysan5/raylib/blob/master/src/raylib.h#L673) have been added to crop, resize, colorize, flip, dither and even draw image-to-image or text-to-image.
+Now a basic image processing can be done before converting the image to texture for usage.
+
+SpriteFonts system has been improved, adding support for AngelCode fonts (.fnt) and TrueType Fonts (using [stb_truetype](https://github.com/nothings/stb/blob/master/stb_truetype.h) helper library). 
+Now raylib can read standard .fnt font data and also generate at loading a SpriteFont from a TTF file.
+
+New [physac](https://github.com/raysan5/raylib/blob/master/src/physac.h) physics module for basic 2D physics support. Still in development but already functional. 
+Module comes with some usage examples for basic jump and level interaction and also force-based physic movements.
+
+[raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h) module has been reviewed; some bugs have been solved and the module has been converted to a header-only file for easier portability, optionally, functions can also be used as inline. 
+
+[gestures](https://github.com/raysan5/raylib/blob/master/src/gestures.c) module has redesigned and simplified, now it can process touch events from any source, including mouse. 
+This way, gestures system can be used on any platform providing an unified way to work with inputs and allowing the user to create multiplatform games with only one source code.
+
+Raspberry Pi input system has been redesigned to better read raw inputs using generic Linux event handlers (keyboard:`stdin`, mouse:`/dev/input/mouse0`, gamepad:`/dev/input/js0`). 
+Gamepad support has also been added (experimental).
+
+Other important improvements are the functional raycast system for 3D picking, including some ray collision-detection functions, 
+and the addition of two simple functions for persistent data storage. Now raylib user can save and load game data in a file (only some platforms supported). 
+A simple [easings](https://github.com/raysan5/raylib/blob/master/src/easings.h) module has also been added for values animation.
+
+Up to 8 new code examples have been added to show the new raylib features and +10 complete game samples have been provided to learn 
+how to create some classic games like Arkanoid, Asteroids, Missile Commander, Snake or Tetris.
+
+Lots of code changes and lots of hours of hard work have concluded in this amazing new raylib 1.4.
+
+notes on raylib 1.5
+-------------------
+
+On July 2016, after 5 months of raylib 1.4 release, arrives raylib 1.5. This new version is the biggest boost of the library until now, lots of parts of the library have been redesigned, lots of bugs have been solved and some **AMAZING** new features have been added.
+
+VR support: raylib supports **Oculus Rift CV1**, one of the most anticipated VR devices in the market. Additionally, raylib supports simulated VR stereo rendering, independent of the VR device; it means, raylib can generate stereo renders with custom head-mounted-display device parameteres, that way, any VR device in the market can be **simulated in any platform** just configuring device parameters (and consequently, lens distortion). To enable VR is [extremely easy](https://github.com/raysan5/raylib/blob/master/examples/core_oculus_rift.c).
+
+New materials system: now raylib supports standard material properties for 3D models, including diffuse-ambient-specular colors and diffuse-normal-specular textures. Just assign values to standard material and everything is processed internally.
+
+New lighting system: added support for up to 8 configurable lights and 3 light types: **point**, **directional** and **spot** lights. Just create a light, configure its parameters and raylib manages render internally for every 3d object using standard material.
+
+Complete gamepad support on Raspberry Pi: Gamepad system has been completely redesigned. Now multiple gamepads can be easily configured and used; gamepad data is read and processed in raw mode in a second thread.
+
+Redesigned physics module: [physac](https://github.com/raysan5/raylib/blob/master/src/physac.h) module has been converted to header only and usage [has been simplified](https://github.com/raysan5/raylib/blob/master/examples/physics_basic_rigidbody.c). Performance has also been singnificantly improved, now physic objects are managed internally in a second thread.
+
+Audio chiptunese support and mixing channels: Added support for module audio music (.xm, .mod) loading and playing. Multiple mixing channels are now also supported. All this features thanks to the amazing work of @kd7tck.
+
+Other additions include a [2D camera system](https://github.com/raysan5/raylib/blob/master/examples/core_2d_camera.c), render textures for offline render (and most comprehensive [postprocessing](https://github.com/raysan5/raylib/blob/master/examples/shaders_postprocessing.c)) or support for legacy OpenGL 2.1 on desktop platforms.
+
+This new version is so massive that is difficult to list all the improvements, most of raylib modules have been reviewed and [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.c) module has been completely redesigned to accomodate to new material-lighting systems and stereo rendering. You can check [CHANGELOG](https://github.com/raysan5/raylib/blob/master/CHANGELOG) file for a more detailed list of changes.
+
+Up to 8 new code examples have been added to show the new raylib features and also some samples to show the usage of [rlgl](https://github.com/raysan5/raylib/blob/master/examples/rlgl_standalone.c) and [audio](https://github.com/raysan5/raylib/blob/master/examples/audio_standalone.c) raylib modules as standalone libraries.
+
+Lots of code changes (+400 commits) and lots of hours of hard work have concluded in this amazing new raylib 1.5.
+
+notes on raylib 1.6
+-------------------
+
+On November 2016, only 4 months after raylib 1.5, arrives raylib 1.6. This new version represents another big review of the library and includes some interesting additions. This version conmmemorates raylib 3rd anniversary (raylib 1.0 was published on November 2013) and it is a stepping stone for raylib future. raylib roadmap has been reviewed and redefined to focus on its primary objective: create a simple and easy-to-use library to learn videogames programming. Some of the new features:
+
+Complete [raylib Lua binding](https://github.com/raysan5/raylib-lua). All raylib functions plus the +60 code examples have been ported to Lua, now Lua users can enjoy coding videogames in Lua while using all the internal power of raylib. This addition also open the doors to Lua scripting support for a future raylib-based engine, being able to move game logic (Init, Update, Draw, De-Init) to Lua scripts while keep using raylib functionality.
+
+Completely redesigned [audio module](https://github.com/raysan5/raylib/blob/master/src/audio.c). Based on the new direction taken in raylib 1.5, it has been further improved and more functionality added (+20 new functions) to allow raw audio processing and streaming. [FLAC file format support](https://github.com/raysan5/raylib/blob/master/src/external/dr_flac.h) has also been added. In the same line, [OpenAL Soft](https://github.com/kcat/openal-soft) backend is now provided as a static library in Windows to allow static linking and get ride of OpenAL32.dll. Now raylib Windows games are completey self-contained, no external libraries required any more!
+
+[Physac](https://github.com/victorfisac/Physac) module has been moved to its own repository and it has been improved A LOT, actually, library has been completely rewritten from scratch by [@victorfisac](https://github.com/victorfisac), multiple samples have been added together with countless new features to match current standard 2D physic libraries. Results are amazing!
+
+Camera and gestures modules have been reviewed, highly simplified and ported to single-file header-only libraries for easier portability and usage flexibility. Consequently, camera system usage has been simplified in all examples.
+
+Improved Gamepad support on Windows and Raspberry Pi with the addition of new functions for custom gamepad configurations but supporting by default PS3 and Xbox-based gamepads.
+
+Improved textures and text functionality, adding new functions for texture filtering control and better TTF/AngelCode fonts loading and generation support.
+
+Build system improvement. Added support for raylib dynamic library generation (raylib.dll) for users that prefer dynamic library linking. Also thinking on advance users, it has been added pre-configured [Visual Studio C++ 2015 solution](https://github.com/raysan5/raylib/tree/master/project/vs2015) with raylib project and C/C++ examples for users that prefer that professional IDE and compiler.
+
+New examples, new functions, complete code-base review, multiple bugs corrected... this is raylib 1.6. Enjoy making games.
+
+notes on raylib 1.7
+-------------------
+
+On May 2017, around 6 month after raylib 1.6, comes another raylib instalment, raylib 1.7. This time library has been improved a lot in terms of consistency and cleanness. As stated in [this patreon article](https://www.patreon.com/posts/raylib-future-7501034), this new raylib version has focused efforts in becoming more simple and easy-to-use to learn videogames programming. Some highlights of this new version are:
+
+More than 30 new functions added to the library, functions to control Window, utils to work with filenames and extensions, functions to draw lines with custom thick, mesh loading, functions for 3d ray collisions detailed detection, funtions for VR simulation and much more... Just check [CHANGELOG](CHANGELOG) for a detailed list of additions!
+
+Support of [configuration flags](https://github.com/raysan5/raylib/issues/200) on every raylib module. Advance users can customize raylib just choosing desired features, defining some configuration flags on modules compilation. That way users can control library size and available functionality.
+
+Improved [build system](https://github.com/raysan5/raylib/blob/master/src/Makefile) for all supported platforms (Windows, Linux, OSX, RPI, Android, HTML5) with a unique Makefile to compile sources. Added support for Android compilation with a custom standalone toolchain and also multiple build compliation flags.
+
+New [examples](http://www.raylib.com/examples.html) and [sample games](http://www.raylib.com/games.html) added. All samples material has been reviewed, removing useless examples and adding more comprehensive ones; all material has been ported to latest raylib version and tested in multiple platforms. Examples folder structure has been improved and also build systems.
+
+Improved library consistency and organization in general. Functions and parameters have been renamed, some parts of the library have been cleaned and simplyfied, some functions has been moved to examples (lighting, Oculus Rift CV1 support) towards a more generic library implementation. Lots of hours have been invested in this process...
+
+Some other features: Gamepad support on HTML5, RPI touch screen support, 32bit audio support, frames timming improvements, public log system, rres file format support, automatic GIF recording...
+
+And here it is another version of **raylib, a simple and easy-to-use library to learn videogames programming**. Enjoy it.
+
+notes on raylib 1.8
+-------------------
+
+October 2017, around 5 months after latest raylib version, another release is published: raylib 1.8. Again, several modules of the library have been reviewed and some new functionality added. Main changes of this new release are:
+
+[Procedural image generation](https://github.com/raysan5/raylib/blob/master/examples/textures/textures_image_generation.c) function, a set of new functions have been added to generate gradients, checked, noise and cellular images from scratch. Image generation could be useful for certain textures or learning pourpouses.
+
+[Parametric mesh generation](https://github.com/raysan5/raylib/blob/master/examples/models/models_mesh_generation.c) functions, create 3d meshes from scratch just defining a set of parameters, meshes like cube, sphere, cylinder, torus, knot and more can be very useful for prototyping or for lighting and texture testing.
+
+PBR Materials support, a completely redesigned shaders and material system allows advance materials definition and usage, with fully customizable shaders. Some new functions have been added to generate the environment textures required for PBR shading and a a new complete [PBR material example](https://github.com/raysan5/raylib/blob/master/examples/models/models_material_pbr.c) is also provided for reference.
+
+Custom Android APK build pipeline with [simple Makefile](https://github.com/raysan5/raylib/blob/master/templates/simple_game/Makefile). Actually, full code building mechanism based on plain Makefile has been completely reviewed and Android building has been added for sources and also for examples and templates building into final APK package. This way, raylib Android building has been greatly simplified and integrated seamlessly into standard build scripts.
+
+[rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.c) module has been completely reviewed and most of the functions renamed for consistency. This way, standalone usage of rlgl is promoted, with a [complete example provided](https://github.com/raysan5/raylib/blob/master/examples/others/rlgl_standalone.c). rlgl offers a pseudo-OpenGL 1.1 immediate-mode programming-style layer, with backends to multiple OpenGL versions.
+
+[raymath](https://github.com/raysan5/raylib/blob/master/src/rlgl.c) library has been also reviewed to align with other advance math libraries like [GLM](https://github.com/g-truc/glm). Matrix math has been improved and simplified, some new Quaternion functions have been added and Vector3 functions have been renamed all around the library for consistency with new Vector2 functionality.
+
+Additionally, as always, examples and templates have been reviewed to work with new version (some new examples have been added), all external libraries have been updated to latest stable version and latest Notepad++ and MinGW have been configured to work with new raylib. For a full list of changes, just check [CHANGELOG](CHANGELOG).
+
+New installer provided, web updated, examples re-builded, documentation reviewed... **new raylib 1.8 published**. Enjoy coding games. 

LICENSE.md

@@ -7,7 +7,7 @@ source code
 raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, 
 BSD-like license that allows static linking with closed source software:
 	
-Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
 
 This software is provided "as-is", without any express or implied warranty. In no event 
 will the authors be held liable for any damages arising from the use of this software.
@@ -27,7 +27,7 @@ applications, and to alter it and redistribute it freely, subject to the followi
 fonts
 ------
 
-All rBMF fonts provided with raylib are free to use (freeware) and have been designed by the following people:
+The following fonts [provided with raylib](https://github.com/raysan5/raylib/tree/master/examples/text/resources/fonts) are free to use (freeware) and have been designed by the following people:
 
  * Alpha Beta - Brian Kent (AEnigma)
  * Setback - Brian Kent (AEnigma)
@@ -37,3 +37,13 @@ All rBMF fonts provided with raylib are free to use (freeware) and have been des
  * Mecha - Captain Falcon
  * PixelPlay - Aleksander Shevchuk
  * PixAntiqua - Gerhard Großmann
+ 
+2d art
+------
+
+[scarfy spritesheet](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/scarfy.png) and [fudesumi image](https://github.com/raysan5/raylib/blob/master/examples/textures/resources/fudesumi.png) have been created by [Eiden Marsal](https://www.artstation.com/artist/marshall_z) and licensed as [Creative Commons Attribution-NonCommercial 3.0](https://creativecommons.org/licenses/by-nc/3.0/legalcode)
+
+3d models
+---------
+
+[dwarf 3d model and textures](https://github.com/raysan5/raylib/tree/master/examples/models/resources/model) have been created by David Moreno and licensed as [Creative Commons Attribution-NonCommercial 3.0](https://creativecommons.org/licenses/by-nc/3.0/legalcode)

README.md

@@ -1,93 +1,63 @@
-<img src="http://www.raylib.com/img/fb_raylib_logo.png" width=256>
+<img align="left" src="https://github.com/raysan5/raylib/blob/master/logo/raylib_256x256.png" width=256>
 
-about
------
+**raylib is a simple and easy-to-use library to learn videogames programming.**
 
-raylib is a simple and easy-to-use library to learn videogames programming.
+raylib is highly inspired by Borland BGI graphics lib and by XNA framework.
 
-raylib is highly inspired by Borland BGI graphics lib (more specifically WinBGI) and by XNA framework. 
-Allegro and SDL have also been analyzed for reference.
+raylib could be useful for prototyping, tools development, graphic applications, embedded systems and education.
 
-Want to see how easy is making games with raylib? Jump to [code examples!] (http://www.raylib.com/examples.htm)
+NOTE for ADVENTURERS: raylib is a programming library to learn videogames programming; 
+no fancy interface, no visual helpers, no auto-debugging... just coding in the most 
+pure spartan-programmers way. Are you ready to learn? Jump to [code examples!](http://www.raylib.com/examples.html)
 
-history
--------
-
-I've developed videogames for some years and last year I had to taught videogames development 
-to young people with artistic profile, most of them had never written a single line of code.
-
-I started with C language basis and, after searching for the most simple and easy-to-use library to teach 
-videogames programming, I found WinBGI; it was great and it worked very well with students, in just a 
-couple of weeks that people that had never written a single line of code were able to program (and understand) 
-a simple PONG and some of them even a BREAKOUT!
-
-But WinBGI was not the clearer and most organized lib. There were a lot of things I found useless and 
-confusing and some function names were not clear enough for most of the students; not to mention points 
-like no transparencies support or no hardware acceleration. 
-
-So, I decided to create my own lib, hardware accelerated, clear function names, quite organized, well structured, 
-plain C coding and, the most important, primarily intended to LEARN videogames programming.
-
-I've coded quite a lot in C# and XNA and I really love it (in fact, my students learn C# with XNA after C), 
-so, I decided to use C# language notation and XNA naming conventions. That way, students can jump from 
-raylib to XNA (or MonoGame) extremely easily.
-
-raylib started as a weekend project and after three months of hard work, here it is the first version. 
-
-Enjoy it.
+[![Build Status](https://travis-ci.org/raysan5/raylib.svg?branch=develop)](https://travis-ci.org/raysan5/raylib)
+[![https://ci.appveyor.com/api/projects/status/github/raysan5/raylib?svg=true](https://ci.appveyor.com/api/projects/status/github/raysan5/raylib?svg=true)](https://ci.appveyor.com/project/raysan5/raylib)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/raylib/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Chat on Discord](https://img.shields.io/discord/308323056592486420.svg?logo=discord)](https://discord.gg/VkzNHUE)
+[![License](https://img.shields.io/badge/license-zlib%2Flibpng-blue.svg)](LICENSE.md)
+[![Twitter URL](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Follow)](https://twitter.com/raysan5)
 
 features
 --------
 
-   * Written in plain C code (C99)
-   * Uses C# PascalCase/camelCase notation
-   * Hardware accelerated using OpenGL 1.1
-   * Transparencies support (RGBA Colors)
-   * Custom color palette for better use on white background
-   * Basic 3D Support (camera, basic models, OBJ models, etc)
-   * Powerful Text module with SpriteFonts support
+   *  Written in plain C code (C99) in PascalCase/camelCase notation
+   *  Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES2 - choose at compile)
+   *  Unique OpenGL abstraction layer (usable as standalone module): [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.c)
+   *  Powerful fonts module with SpriteFonts support (XNA fonts, AngelCode fonts, TTF)
+   *  Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
+   *  Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
+   *  Flexible Materials system, supporting classic maps and PBR maps
+   *  Shaders support, including Model shaders and Postprocessing shaders
+   *  Powerful math module for Vector, Matrix and Quaternion operations: [raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h)
+   *  Audio loading and playing with streaming support (WAV, OGG, FLAC, XM, MOD)
+   *  Multiple platforms support: Windows, Linux, FreeBSD, MacOS, UWP, Android, Raspberry Pi, HTML5.
+   *  VR stereo rendering with configurable HMD device parameters
+   *  NO external dependencies, all required libraries included with raylib
+   *  Complete bindings to LUA ([raylib-lua](https://github.com/raysan5/raylib-lua)) and Go ([raylib-go](https://github.com/gen2brain/raylib-go))
 
-raylib uses on its core module the outstanding [GLFW3] (http://www.glfw.org/) library. The best option by far I found for 
-window/context and input management (clean, focused, great license, well documented, modern, ...). 
+raylib uses on its [core](https://github.com/raysan5/raylib/blob/master/src/core.c) module the outstanding [GLFW3](http://www.glfw.org/) library, embedded inside raylib in the form of [rglfw](https://github.com/raysan5/raylib/blob/master/src/rglfw.c) module, avoiding that way external dependencies.
 
-raylib is licensed under a zlib/libpng license like GLFW3. View [LICENSE] (https://github.com/raysan5/raylib/blob/master/LICENSE.md).
+raylib uses on its [audio](https://github.com/raysan5/raylib/blob/master/src/audio.c) module, the amazing [mini_al](https://github.com/dr-soft/mini_al) audio library, single-file header-only and supporting multiple platforms and multiple audio backends.
 
-tool requirements
-------------------
+raylib uses internally multiple single-file header-only libraries to support multiple fileformats loading and saving, all those libraries are embedded with raylib and available in [src/external](https://github.com/raysan5/raylib/tree/master/src/external) directory.
+
+*On Android, `native_app_glue module` (provided by Android NDK) and native Android libraries are used to manage window/context, inputs and activity life cycle.*
+
+*On Raspberry Pi, Videocore API and EGL libraries are used for window/context management and raw inputs reading.*
+
+build and installation
+----------------------
+
+Binary releases for Windows, Linux and macOS are available at the [Github Releases](https://github.com/raysan5/raylib/releases) page. raylib is also available via multiple package managers on multiple OS distributions. For more info check [raylib Wiki](https://github.com/raysan5/raylib/wiki).
+
+To build raylib yourself, check out also the [raylib Wiki](https://github.com/raysan5/raylib/wiki) for detailed instructions.
 
 raylib has been developed using exclusively two tools: 
 
    * Notepad++ (text editor) - [http://notepad-plus-plus.org/](http://notepad-plus-plus.org/)
    * MinGW (GCC compiler) - [http://www.mingw.org/](http://www.mingw.org/)
    
-Those are the tools I recommend to develop with raylib, in fact, those are the tools my students use. 
-I believe those are the best tools to train spartan-programmers.
-
-Someone could argue about debugging. raylib is a library intended for learning and I think C it's a clear enough language
-to allow writing small-mid size programs with a printf-based debugging. All raylib examples have also been written this way.
-
-building
---------
-
-raylib could be build with the following command lines (Using GCC compiler):
-
-	cd raylib/src
-	gcc -c core.c -std=c99 -Wall
-	gcc -c shapes.c -std=c99 -Wall
-	gcc -c textures.c -std=c99 -Wall
-	gcc -c stb_image.c -std=c99 -Wall
-	gcc -c text.c -std=c99 -Wall
-	gcc -c models.c -std=c99 -Wall
-	gcc -c vector3.c -std=c99 -Wall
-	gcc -c audio.c -std=c99 -Wall
-    gcc -c utils.c -std=c99 -Wall
-	ar rcs raylib.a core.o shapes.o textures.o stb_image.o text.o models.o vector3.o utils.o audio.o
-
-To compile examples, make sure raylib.h is placed in include path and libraries raylib (libraylib.a) and glfw3 (libglfw3.a) 
-are placed in the libraries path. It's also recommended to link with file icon.o for fancy raylib icon usage.
-
-	cd raylib/examples
-	gcc -o test_code.exe test_code.c icon.o -lraylib -lglfw3 -lopengl32 -lgdi32 -std=c99 -Wl,--subsystem,windows
+Those are the tools recommended to develop with raylib, in fact, those are the tools my students use. 
 
 contact
 -------
@@ -95,18 +65,19 @@ contact
    * Webpage: [http://www.raylib.com](http://www.raylib.com)
    * Twitter: [http://www.twitter.com/raysan5](http://www.twitter.com/raysan5)
    * Facebook: [http://www.facebook.com/raylibgames](http://www.facebook.com/raylibgames)
+   * Reddit: [https://www.reddit.com/r/raylib](https://www.reddit.com/r/raylib)
+   * Twitch: [http://www.twitch.tv/raysan5](http://www.twitch.tv/raysan5)
+   * Patreon: [https://www.patreon.com/raysan5](https://www.patreon.com/raysan5)
+   * YouTube: [https://www.youtube.com/channel/raylib](https://www.youtube.com/channel/UC8WIBkhYb5sBNqXO1mZ7WSQ)
 
 If you are using raylib and you enjoy it, please, [let me know][raysan5].
 
-If you feel you can help, then, [helpme!] (http://www.raylib.com/helpme.htm)
+If you feel you can help, then, [helpme!](http://www.raylib.com/helpme.html)
 
-acknowledgments
----------------
+license
+-------
 
-The following people have contributed in some way to make raylib project a reality. Big thanks to them!
+raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, BSD-like license that allows static linking with closed source software. Check [LICENSE](LICENSE.md) for further details.
 
- - [Zopokx](https://github.com/Zopokx)
- - [Elendow](http://www.elendow.com)
+[raysan5]: mailto:ray@raylib.com "Ramon Santamaria - Ray San"
 
-	
-[raysan5]: mailto:raysan@raysanweb.com "Ramon Santamaria - Ray San"

ROADMAP.md

@@ -1,22 +1,53 @@
 roadmap
 -------
 
-First version of raylib is quite complete and functional but there is still a lot of things I would like to improve.
-Here it is a list of features I would like to add and functions to improve.
+Current version of raylib is complete and functional but there is still a lot of room for improvement.
+Here it is a wish-list with features and ideas to improve the library.
 
-Around the source code there are some TODO points with pending revisions/bugs and here it is a list of features I would like to add.
+Note that [raylib source code](https://github.com/raysan5/raylib/tree/master/src) has some *TODO* marks around code with pending things to review and improve. Check [GitHub Issues](https://github.com/raysan5/raylib/issues) for further details!
 
-raylib v1.x
+**raylib 1.x**
+ - [ ] Basic GPU stats sytem (memory, draws, time...)
+ - [ ] Improved custom file-format (.rres) and packaging tool
+ - [ ] Touch-based camera controls for Android
+ - [ ] Quaternions-based camera system
  
-   - Review Billboard Drawing functions
-   - Review Heightmap Loading and Drawing functions - Load Heightmap directly as a Model
-   - Lighting support (only 3d mode) - CreateLight()
-   - [DONE] Simple Collision Detection functions
-   - Default scene Camera controls (zoom, pan, rotate)   
-   - Basic Procedural Texture / Image generation (Gradient, Checked, Spot, Noise, Cellular)
-   - Software mipmapping generation and POT conversion (custom implementation)
-   - Comments / Functions translation (?)
+**raylib 1.8**
+ - [x] Improved Materials system with PBR support
+ - [x] Procedural image generation functions (spot, gradient, noise...)
+ - [x] Procedural mesh generation functions (cube, sphere...)
+ - [x] Custom Android APK build pipeline (default Makefile)
+
+**raylib 1.7**
+ - [x] Support configuration flags
+ - [x] Improved build system for Android
+ - [x] Gamepad support on HTML5
+    
+**raylib 1.6**
+ - [x] Lua scripting support (raylib Lua wrapper)
+ - [x] Redesigned audio module
+ - [x] Support FLAC file format
+
+**raylib 1.5**
+ - [x] Support Oculus Rift CV1 and VR stereo rendering (simulator)
+ - [x] Redesign Shaders/Textures system -> New Materials system
+ - [x] Support lighting: Omni, Directional and Spot lights
+ - [x] Redesign physics module (physac)
+ - [x] Chiptunes audio modules support
+
+**raylib 1.4**
+ - [x] TTF fonts support (using stb_truetype)
+ - [x] Raycast system for 3D picking (including collisions detection)
+ - [x] Floyd-Steinberg dithering on 16bit image format conversion
+ - [x] Basic image manipulation functions (crop, resize, draw...)
+ - [x] Storage load/save data functionality
+ - [x] Add Physics module (physac)
+ - [x] Remove GLEW dependency -> Replaced by GLAD
+ - [x] Redesign Raspberry PI inputs system
+ - [x] Redesign gestures module to be multiplatform
+ - [x] Module raymath as header-only and functions inline
+ - [x] Add Easings module (easings.h)
 
 Any feature missing? Do you have a request? [Let me know!][raysan5]
 
-[raysan5]: mailto:raysan@raysanweb.com "Ramon Santamaria - Ray San"
+[raysan5]: mailto:ray@raylib.com "Ramon Santamaria - Ray San"

appveyor.yml

@@ -0,0 +1,65 @@
+#os: Visual Studio 2015
+
+clone_depth: 5
+
+cache:
+  - C:\ProgramData\chocolatey\bin -> appveyor.yml
+  - C:\ProgramData\chocolatey\lib -> appveyor.yml
+
+init:
+  - cmake -E remove c:\programdata\chocolatey\bin\cpack.exe
+  - set PATH=%PATH:C:\Program Files (x86)\Git\usr\bin;=%
+  - set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
+  - if [%BITS%]==[32] set MINGW=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32
+  - if [%BITS%]==[64] set MINGW=C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64
+  - if [%COMPILER%]==[mingw] set PATH=%MINGW%\bin;%PATH%
+  - set RAYLIB_PACKAGE_SUFFIX=-Win%BITS%-%COMPILER%
+  - set VERBOSE=1
+
+environment:
+  matrix:
+    - compiler: mingw
+      bits: 32
+      examples: ON
+    - compiler: mingw
+      bits: 64
+      examples: ON
+    - compiler: msvc15
+      bits: 32
+      examples: OFF
+    - compiler: msvc15
+      bits: 64
+      examples: OFF
+
+before_build:
+  - if [%compiler%]==[mingw] set CFLAGS=-m%BITS% & set LDFLAGS=-m%BITS% & set GENERATOR="MinGW Makefiles"
+  - if [%COMPILER%]==[msvc15] if [%BITS%]==[32] set GENERATOR="Visual Studio 14 2015"
+  - if [%COMPILER%]==[msvc15] if [%BITS%]==[64] set GENERATOR="Visual Studio 14 2015 Win64"
+  - mkdir build
+  - cd build
+
+build_script:
+  - cmake -G %GENERATOR% -DSTATIC=ON -DSHARED=ON -DBUILD_EXAMPLES=%examples% -DBUILD_GAMES=%examples% ..
+  - cmake --build . --target install
+
+after_build:
+  - cmake --build . --target package
+
+before_test:
+
+test_script:
+
+artifacts:
+  - path: 'build\*.zip'
+
+deploy:
+  - provider: GitHub
+    auth_token:
+      secure: OxKnnT3tlkPl9365cOO84rDWU4UkHIYJc0D3r3Tv7rB3HaR2BBhlhCnl7g3nuOJy
+    artifact: /.*\.zip/
+    draft: false
+    prerelease: false
+    force_update: true
+    on:
+      branch: master
+      appveyor_repo_tag: true        # deploy on tag push only

examples/CMakeLists.txt

@@ -0,0 +1,58 @@
+# Setup the project and settings
+project(examples)
+
+include("../utils.cmake")
+
+# Make sure raylib has been built
+# TODO `build` directory should maybe be something else...
+# TODO place somewhere else?
+include_directories("../build/release")
+include_directories("../src/external")
+include_directories("../src/external/glfw/include")
+
+# Get the sources together
+set(example_dirs audio core models others shaders shapes text textures)
+set(CMAKE_REQUIRED_DEFINITIONS -D_POSIX_C_SOURCE=199309L)
+  include(CheckSymbolExists)
+  check_symbol_exists(CLOCK_MONOTONIC time.h HAVE_CLOCK_MONOTONIC)
+  check_symbol_exists(QueryPerformanceCounter windows.h HAVE_QPC)
+set(CMAKE_REQUIRED_DEFINITIONS)
+if(HAVE_QPC OR HAVE_CLOCK_MONOTONIC)
+  set(example_dirs ${example_dirs} physac)
+endif()
+
+set(example_sources)
+set(example_resources)
+foreach(example_dir ${example_dirs})
+  # Get the .c files
+  file(GLOB sources ${example_dir}/*.c)
+  list(APPEND example_sources ${sources})
+
+  # Any any resources
+  file(GLOB resources ${example_dir}/resources/*)
+  list(APPEND example_resources ${resources})
+endforeach()
+
+include(CheckIncludeFiles)
+check_include_files(OVR_CAPI_GL.h HAVE_OCULUS_CAPI)
+if(NOT HAVE_OCULUS_CAPI)
+  list(REMOVE_ITEM example_sources ${CMAKE_CURRENT_SOURCE_DIR}/others/oculus_rift.c)
+endif()
+list(REMOVE_ITEM example_sources ${CMAKE_CURRENT_SOURCE_DIR}/others/standard_lighting.c)
+
+
+# Do each example
+foreach(example_source ${example_sources})
+  # Create the basename for the example
+  get_filename_component(example_name ${example_source} NAME)
+  string(REPLACE ".c" "" example_name ${example_name})
+
+  # Setup the example
+  add_executable(${example_name} ${example_source})
+
+  # Link the libraries
+  link_libraries_to_executable(${example_name})
+endforeach()
+
+# Copy all of the resource files to the destination
+file(COPY ${example_resources} DESTINATION "resources/")

examples/Makefile

@@ -0,0 +1,451 @@
+#**************************************************************************************************
+#
+#   raylib makefile for Desktop platforms, Raspberry Pi, Android and HTML5
+#
+#   Copyright (c) 2013-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 the use of this software.
+#
+#   Permission is granted to anyone to use this software for any purpose, including commercial
+#   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+#
+#     1. The origin of this software must not be misrepresented; you must not claim that you
+#     wrote the original software. If you use this software in a product, an acknowledgment
+#     in the product documentation would be appreciated but is not required.
+#
+#     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+#     as being the original software.
+#
+#     3. This notice may not be removed or altered from any source distribution.
+#
+#**************************************************************************************************
+
+.PHONY: all clean
+
+# Define required raylib variables
+PROJECT_NAME       ?= raylib_examples
+RAYLIB_VERSION     ?= 1.9.7
+RAYLIB_API_VERSION ?= 1
+RAYLIB_PATH        ?= ..
+
+# Define default options
+
+# One of PLATFORM_DESKTOP, PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+PLATFORM              ?= PLATFORM_DESKTOP
+
+# Locations of your newly installed library and associated headers. See ../src/Makefile
+# On Linux, if you have installed raylib but cannot compile the examples, check that
+# the *_INSTALL_PATH values here are the same as those in src/Makefile or point to known locations.
+# To enable system-wide compile-time and runtime linking to libraylib.so, run ../src/$ sudo make install RAYLIB_LIBTYPE_SHARED.
+# To enable compile-time linking to a special version of libraylib.so, change these variables here.
+# To enable runtime linking to a special version of libraylib.so, see EXAMPLE_RUNTIME_PATH below.
+# If there is a libraylib in both EXAMPLE_RUNTIME_PATH and RAYLIB_INSTALL_PATH, at runtime,
+# the library at EXAMPLE_RUNTIME_PATH, if present, will take precedence over the one at RAYLIB_INSTALL_PATH.
+# 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
+
+# Library type used for raylib: STATIC (.a) or SHARED (.so/.dll)
+RAYLIB_LIBTYPE        ?= STATIC
+
+# Build mode for project: DEBUG or RELEASE
+RAYLIB_BUILD_MODE     ?= RELEASE
+
+# Use external GLFW library instead of rglfw module
+# TODO: Review usage on Linux. Target version of choice. Switch on -lglfw or -lglfw3
+USE_EXTERNAL_GLFW     ?= FALSE
+
+# Use Wayland display server protocol on Linux desktop
+# by default it uses X11 windowing system
+USE_WAYLAND_DISPLAY   ?= FALSE
+
+# NOTE: On PLATFORM_WEB OpenAL Soft backend is used by default (check raylib/src/Makefile)
+
+# 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)
+        ifeq ($(UNAMEOS),Linux)
+            PLATFORM_OS=LINUX
+        endif
+        ifeq ($(UNAMEOS),FreeBSD)
+            PLATFORM_OS=FREEBSD
+        endif
+        ifeq ($(UNAMEOS),Darwin)
+            PLATFORM_OS=OSX
+        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!
+# This is not currently used by src/Makefile. Not sure of its origin or usage. Refer to wiki.
+# TODO: update install: target in src/Makefile for RPI, consider relation to LINUX.
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    RAYLIB_PATH       ?= /home/pi/raylib
+endif
+
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    # Emscripten required variables
+    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)
+    EMSCRIPTEN=$(EMSDK_PATH)\emscripten\$(EMSCRIPTEN_VERSION)
+endif
+
+# Define raylib release directory for compiled library.
+# RAYLIB_RELEASE_PATH points to provided binaries or your freshly built version.
+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)
+    RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/rpi
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    RAYLIB_RELEASE_PATH = $(RAYLIB_PATH)/release/libs/html5
+endif
+
+# EXAMPLE_RUNTIME_PATH embeds a custom runtime location of libraylib.so or other desired libraries
+# into each example binary compiled with RAYLIB_LIBTYPE=SHARED. It defaults to RAYLIB_RELEASE_PATH
+# so that these examples link at runtime with your version of libraylib.so in ../release/libs/linux
+# without formal installation from ../src/Makefile. It aids portability and is useful if you have
+# multiple versions of raylib, have raylib installed to a non-standard location, or want to
+# bundle libraylib.so with your game. Change it to your liking.
+# Note: If, at runtime, there is a libraylib.so at both EXAMPLE_RUNTIME_PATH and RAYLIB_INSTALL_PATH,
+# The library at EXAMPLE_RUNTIME_PATH, if present, will take precedence over RAYLIB_INSTALL_PATH,
+# Implemented for LINUX below with CFLAGS += -Wl,-rpath,$(EXAMPLE_RUNTIME_PATH)
+# To see the result, run readelf -d core/core_basic_window; looking at the RPATH or RUNPATH attribute.
+# To see which libraries a built example is linking to, ldd core/core_basic_window;
+# Look for libraylib.so.1 => $(RAYLIB_INSTALL_PATH)/libraylib.so.1 or similar listing.
+EXAMPLE_RUNTIME_PATH   ?= $(RAYLIB_RELEASE_PATH)
+
+# Define default C compiler: gcc
+# NOTE: define g++ compiler if using C++
+CC = gcc
+
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),OSX)
+        # OSX default compiler
+        CC = clang
+    endif
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        # FreeBSD default compiler
+        CC = clang
+    endif
+endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    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
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    # WARNING: To compile to HTML5, code must be redesigned to use emscripten.h and emscripten_set_main_loop()
+    # HTML5 emscripten compiler
+    CC = emcc
+endif
+
+# Define default make program: Mingw32-make
+MAKE = mingw32-make
+
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),LINUX)
+        MAKE = make
+    endif
+endif
+
+# 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
+CFLAGS += -O1 -s -Wall -std=c99 -D_DEFAULT_SOURCE -Wno-missing-braces
+
+# Additional flags for compiler (if desired)
+#CFLAGS += -Wextra -Wmissing-prototypes -Wstrict-prototypes
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),WINDOWS)
+        # resources file contains windows exe icon
+        # -Wl,--subsystem,windows hides the console window
+        CFLAGS += $(RAYLIB_PATH)/src/resources -Wl,--subsystem,windows
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        ifeq ($(RAYLIB_BUILD_MODE),DEBUG)
+            CFLAGS += -g
+            #CC = clang
+        endif
+        ifeq ($(RAYLIB_LIBTYPE),STATIC)
+        CFLAGS += -no-pie -D_DEFAULT_SOURCE
+        endif
+        ifeq ($(RAYLIB_LIBTYPE),SHARED)
+        # Explicitly enable runtime link to libraylib.so
+        CFLAGS += -Wl,-rpath,$(EXAMPLE_RUNTIME_PATH)
+        endif
+    endif
+endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    CFLAGS += -std=gnu99
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    # -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
+    # -s WASM=1                  # support Web Assembly (https://github.com/kripken/emscripten/wiki/WebAssembly)
+    # --preload-file resources   # specify a resources folder for data compilation
+    CFLAGS += -s USE_GLFW=3 -s ASSERTIONS=1 -s WASM=1 --profiling --preload-file resources
+
+    # Define a custom shell .html and output extension
+    CFLAGS += --shell-file $(RAYLIB_PATH)\templates\web_shell\shell.html
+    EXT = .html
+endif
+
+# Define include paths for required headers.
+# Precedence: immediately local, raysan5 provided sources
+# NOTE: Several external required libraries (stb and others)
+INCLUDE_PATHS = -I. -I$(RAYLIB_PATH)/release/include -I$(RAYLIB_PATH)/src -I$(RAYLIB_PATH)/src/external
+
+# Define additional directories containing required header files
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    # RPI required libraries
+    INCLUDE_PATHS += -I/opt/vc/include
+    INCLUDE_PATHS += -I/opt/vc/include/interface/vmcs_host/linux
+    INCLUDE_PATHS += -I/opt/vc/include/interface/vcos/pthreads
+endif
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        # Consider -L$(RAYLIB_H_INSTALL_PATH)
+        INCLUDE_PATHS += -I/usr/local/include
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        # Reset everything.
+        # Precedence: immediately local, installed version, raysan5 provided libs -I$(RAYLIB_H_INSTALL_PATH) -I$(RAYLIB_PATH)/release/include
+        INCLUDE_PATHS = -I$(RAYLIB_H_INSTALL_PATH) -isystem. -isystem$(RAYLIB_PATH)/src -isystem$(RAYLIB_PATH)/release/include -isystem$(RAYLIB_PATH)/src/external
+    endif
+endif
+
+# Define library paths containing required libs.
+# Precedence: immediately local, then raysan5 provided libs
+LDFLAGS = -L. -L$(RAYLIB_RELEASE_PATH) -L$(RAYLIB_PATH)/src
+
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        # Consider -L$(RAYLIB_INSTALL_PATH)
+        LDFLAGS += -L. -Lsrc -L/usr/local/lib
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        # Reset everything.
+        # Precedence: immediately local, installed version, raysan5 provided libs
+        LDFLAGS = -L. -L$(RAYLIB_INSTALL_PATH) -L$(RAYLIB_RELEASE_PATH) -L$(RAYLIB_PATH)/src
+    endif
+endif
+
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    LDFLAGS += -L/opt/vc/lib
+endif
+
+# Define any libraries required on linking
+# if you want to link libraries (libname.so or libname.a), use the -lname
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),WINDOWS)
+        # Libraries for Windows desktop compilation
+        LDLIBS = -lraylib -lopengl32 -lgdi32
+        # Required for physac examples
+        LDLIBS += -static -lpthread
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        # Libraries for Debian GNU/Linux desktop compiling
+        # NOTE: Required packages: libegl1-mesa-dev
+        LDLIBS = -lraylib -lGL -lm -lpthread -ldl -lrt
+        # On X11 requires also below libraries
+        LDLIBS += -lX11
+        # NOTE: It seems additional libraries are not required any more, latest GLFW just dlopen them
+        #LDLIBS += -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
+        # On Wayland windowing system, additional libraries requires
+        ifeq ($(USE_WAYLAND_DISPLAY),TRUE)
+            LDLIBS += -lwayland-client -lwayland-cursor -lwayland-egl -lxkbcommon
+        endif
+        # Explicit link to libc
+        ifeq ($(RAYLIB_LIBTYPE),SHARED)
+            LDLIBS += -lc
+        endif
+    endif
+    ifeq ($(PLATFORM_OS),OSX)
+        # Libraries for OSX 10.9 desktop compiling
+        # NOTE: Required packages: libopenal-dev libegl1-mesa-dev
+        LDLIBS = -lraylib -framework OpenGL -framework OpenAL -framework Cocoa
+    endif
+    ifeq ($(PLATFORM_OS),FREEBSD)
+        # Libraries for FreeBSD desktop compiling
+        # NOTE: Required packages: mesa-libs
+        LDLIBS = -lraylib -lGL -lpthread -lm
+        # On XWindow requires also below libraries
+        LDLIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
+    endif
+    ifeq ($(USE_EXTERNAL_GLFW),TRUE)
+        # NOTE: It could require additional packages installed: libglfw3-dev
+        LDLIBS += -lglfw
+    endif
+endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    # Libraries for Raspberry Pi compiling
+    # NOTE: Required packages: libasound2-dev (ALSA)
+    LDLIBS = -lraylib -lbrcmGLESv2 -lbrcmEGL -lpthread -lrt -lm -lbcm_host -ldl
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    # Libraries for web (HTML5) compiling
+    LDLIBS = $(RAYLIB_RELEASE_PATH)/libraylib.bc
+endif
+
+# Define all object files required
+EXAMPLES = \
+    core/core_basic_window \
+    core/core_input_keys \
+    core/core_input_mouse \
+    core/core_mouse_wheel \
+    core/core_input_gamepad \
+    core/core_random_values \
+    core/core_color_select \
+    core/core_drop_files \
+    core/core_storage_values \
+    core/core_gestures_detection \
+    core/core_3d_mode \
+    core/core_3d_picking \
+    core/core_3d_camera_free \
+    core/core_3d_camera_first_person \
+    core/core_2d_camera \
+    core/core_world_screen \
+    core/core_vr_simulator \
+    shapes/shapes_logo_raylib \
+    shapes/shapes_basic_shapes \
+    shapes/shapes_colors_palette \
+    shapes/shapes_logo_raylib_anim \
+    shapes/shapes_lines_bezier \
+    textures/textures_logo_raylib \
+    textures/textures_image_loading \
+    textures/textures_rectangle \
+    textures/textures_srcrec_dstrec \
+    textures/textures_to_image \
+    textures/textures_raw_data \
+    textures/textures_particles_blending \
+    textures/textures_image_processing \
+    textures/textures_image_drawing \
+    textures/textures_image_generation \
+    textures/textures_image_text \
+    text/text_sprite_fonts \
+    text/text_bmfont_ttf \
+    text/text_raylib_fonts \
+    text/text_format_text \
+    text/text_writing_anim \
+    text/text_ttf_loading \
+    text/text_bmfont_unordered \
+    text/text_input_box \
+    models/models_geometric_shapes \
+    models/models_box_collisions \
+    models/models_billboard \
+    models/models_obj_loading \
+    models/models_heightmap \
+    models/models_cubicmap \
+    models/models_mesh_picking \
+    models/models_mesh_generation \
+    models/models_material_pbr \
+    models/models_skybox \
+    models/models_yaw_pitch_roll \
+    shaders/shaders_model_shader \
+    shaders/shaders_shapes_textures \
+    shaders/shaders_custom_uniform \
+    shaders/shaders_postprocessing \
+    audio/audio_sound_loading \
+    audio/audio_music_stream \
+    audio/audio_module_playing \
+    audio/audio_raw_stream \
+    physac/physics_demo \
+    physac/physics_friction \
+    physac/physics_movement \
+    physac/physics_restitution \
+    physac/physics_shatter \
+
+
+CURRENT_MAKEFILE = $(lastword $(MAKEFILE_LIST))
+
+# Default target entry
+all: $(EXAMPLES)
+
+# Generic compilation pattern
+# NOTE: Examples must be ready for Android compilation!
+%: %.c
+ifeq ($(PLATFORM),PLATFORM_ANDROID)
+	$(MAKE) -f Makefile.Android PROJECT_NAME=$@ PROJECT_SOURCE_FILES=$<
+else
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDE_PATHS) $(LDFLAGS) $(LDLIBS) -D$(PLATFORM)
+endif
+
+# fix dylib install path name for each executable (MAC)
+fix_dylib:
+ifeq ($(PLATFORM_OS),OSX)
+	find . -type f -perm +ugo+x -print0 | xargs -t -0 -R 1 -I file install_name_tool -change libglfw.3.0.dylib ../external/glfw3/lib/osx/libglfw.3.0.dylib file
+endif
+
+# Clean everything
+clean:
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),WINDOWS)
+		del *.o *.exe /s
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+		find -type f -executable | xargs file -i | grep -E 'x-object|x-archive|x-sharedlib|x-executable' | rev | cut -d ':' -f 2- | rev | xargs rm -fv
+    endif
+    ifeq ($(PLATFORM_OS),OSX)
+		find . -type f -perm +ugo+x -delete
+		rm -f *.o
+    endif
+endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+	find . -type f -executable -delete
+	rm -fv *.o
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+	del *.o *.html *.js
+endif
+	@echo Cleaning done

examples/audio/audio_module_playing.c

@@ -0,0 +1,141 @@
+/*******************************************************************************************
+*
+*   raylib [audio] example - Module playing (streaming)
+*
+*   NOTE: This example requires OpenAL Soft library installed
+*
+*   This example has been created using raylib 1.5 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define MAX_CIRCLES  64
+
+typedef struct {
+    Vector2 position;
+    float radius;
+    float alpha;
+    float speed;
+    Color color;
+} CircleWave;
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    SetConfigFlags(FLAG_MSAA_4X_HINT);      // NOTE: Try to enable MSAA 4X
+    
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)");
+
+    InitAudioDevice();              // Initialize audio device
+    
+    Color colors[14] = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK,
+                         YELLOW, GREEN, SKYBLUE, PURPLE, BEIGE };
+    
+    // Creates ome circles for visual effect
+    CircleWave circles[MAX_CIRCLES];
+    
+    for (int i = MAX_CIRCLES - 1; i >= 0; i--)
+    {
+        circles[i].alpha = 0.0f;
+        circles[i].radius = GetRandomValue(10, 40);
+        circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius);
+        circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius);
+        circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
+        circles[i].color = colors[GetRandomValue(0, 13)];
+    }
+
+    Music xm = LoadMusicStream("resources/mini1111.xm");
+    
+    PlayMusicStream(xm);
+
+    float timePlayed = 0.0f;
+    bool pause = false;
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateMusicStream(xm);        // Update music buffer with new stream data
+        
+        // Restart music playing (stop and play)
+        if (IsKeyPressed(KEY_SPACE)) 
+        {
+            StopMusicStream(xm);
+            PlayMusicStream(xm);
+        }
+        
+        // Pause/Resume music playing 
+        if (IsKeyPressed(KEY_P))
+        {
+            pause = !pause;
+            
+            if (pause) PauseMusicStream(xm);
+            else ResumeMusicStream(xm);
+        }
+        
+        // Get timePlayed scaled to bar dimensions
+        timePlayed = GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40);
+        
+        // Color circles animation
+        for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--)
+        {
+            circles[i].alpha += circles[i].speed;
+            circles[i].radius += circles[i].speed*10.0f;
+            
+            if (circles[i].alpha > 1.0f) circles[i].speed *= -1;
+            
+            if (circles[i].alpha <= 0.0f)
+            {
+                circles[i].alpha = 0.0f;
+                circles[i].radius = GetRandomValue(10, 40);
+                circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius);
+                circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius);
+                circles[i].color = colors[GetRandomValue(0, 13)];
+                circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            
+            for (int i = MAX_CIRCLES - 1; i >= 0; i--)
+            {
+                DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha));
+            }
+            
+            // Draw time bar
+            DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY);
+            DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, MAROON);
+            DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadMusicStream(xm);          // Unload music stream buffers from RAM
+    
+    CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
+
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/audio/audio_music_stream.c

@@ -0,0 +1,93 @@
+/*******************************************************************************************
+*
+*   raylib [audio] example - Music playing (streaming)
+*
+*   NOTE: This example requires OpenAL Soft library installed
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
+
+    InitAudioDevice();              // Initialize audio device
+
+    Music music = LoadMusicStream("resources/guitar_noodling.ogg");
+    
+    PlayMusicStream(music);
+
+    float timePlayed = 0.0f;
+    bool pause = false;
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateMusicStream(music);        // Update music buffer with new stream data
+        
+        // Restart music playing (stop and play)
+        if (IsKeyPressed(KEY_SPACE)) 
+        {
+            StopMusicStream(music);
+            PlayMusicStream(music);
+        }
+        
+        // Pause/Resume music playing 
+        if (IsKeyPressed(KEY_P))
+        {
+            pause = !pause;
+            
+            if (pause) PauseMusicStream(music);
+            else ResumeMusicStream(music);
+        }
+        
+        // Get timePlayed scaled to bar dimensions (400 pixels)
+        timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
+
+            DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
+            DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
+            DrawRectangleLines(200, 200, 400, 12, GRAY);
+            
+            DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
+            DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadMusicStream(music);   // Unload music stream buffers from RAM
+
+    CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/audio/audio_raw_stream.c

@@ -0,0 +1,114 @@
+/*******************************************************************************************
+*
+*   raylib [audio] example - Raw audio streaming
+*
+*   NOTE: This example requires OpenAL Soft library installed
+*
+*   This example has been created using raylib 1.6 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdlib.h>         // Required for: malloc(), free()
+#include <math.h>           // Required for: sinf()
+
+#define MAX_SAMPLES             22050
+#define MAX_SAMPLES_PER_UPDATE   4096
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
+
+    InitAudioDevice();              // Initialize audio device
+
+    // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
+    AudioStream stream = InitAudioStream(22050, 16, 1);
+    
+    // Generate samples data from sine wave
+    short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
+    
+    // TODO: Review data generation, it seems data is discontinued for loop,
+    // for that reason, there is a clip everytime audio stream is looped...
+    for (int i = 0; i < MAX_SAMPLES; i++)
+    {
+        data[i] = (short)(sinf(((2*PI*(float)i)/2)*DEG2RAD)*32000);
+    }
+    
+    PlayAudioStream(stream);        // Start processing stream buffer (no data loaded currently)
+    
+    int totalSamples = MAX_SAMPLES;
+    int samplesLeft = totalSamples;
+    
+    Vector2 position = { 0, 0 };
+
+    SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        
+        // Refill audio stream if required
+        // NOTE: Every update we check if stream data has been already consumed and we update
+        // buffer with new data from the generated samples, we upload data at a rate (MAX_SAMPLES_PER_UPDATE),
+        // but notice that at some point we update < MAX_SAMPLES_PER_UPDATE data...
+        if (IsAudioBufferProcessed(stream)) 
+        {
+            int numSamples = 0;
+            if (samplesLeft >= MAX_SAMPLES_PER_UPDATE) numSamples = MAX_SAMPLES_PER_UPDATE;
+            else numSamples = samplesLeft;
+
+            UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples);
+            
+            samplesLeft -= numSamples;
+            
+            // Reset samples feeding (loop audio)
+            if (samplesLeft <= 0) samplesLeft = totalSamples;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY);
+            
+            // NOTE: Draw a part of the sine wave (only screen width, proportional values)
+            for (int i = 0; i < GetScreenWidth(); i++)
+            {
+                position.x = i;
+                position.y = 250 + 50*data[i]/32000;
+                
+                DrawPixelV(position, RED);
+            }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    free(data);                 // Unload sine wave data
+    
+    CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
+
+    CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/audio/audio_sound_loading.c

@@ -1,13 +1,13 @@
 /*******************************************************************************************
 *
-*   raylib example 08 - Audio loading and playing
+*   raylib [audio] example - Sound loading and playing
 *
-*   NOTE: This example requires OpenAL32 dll installed (or in the same folder)
+*   NOTE: This example requires OpenAL Soft library installed
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -20,11 +20,14 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    InitWindow(screenWidth, screenHeight, "raylib example 08 - audio loading and playing");
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
 
     InitAudioDevice();      // Initialize audio device
 
-    Sound fx = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
+    Sound fxWav = LoadSound("resources/sound.wav");         // Load WAV audio file
+    Sound fxOgg = LoadSound("resources/tanatana.ogg");      // Load OGG audio file
+    
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -32,7 +35,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        if (IsKeyPressed(KEY_SPACE)) PlaySound(fx);     // Play the sound!    
+        if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
+        if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -41,7 +45,9 @@ int main()
 
             ClearBackground(RAYWHITE);
 
-            DrawText("Press SPACE to PLAY the SOUND!", 240, 200, 20, LIGHTGRAY);
+            DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY);
+
+            DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY);
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -49,7 +55,8 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    UnloadSound(fx);        // Unload sound data
+    UnloadSound(fxWav);     // Unload sound data
+    UnloadSound(fxOgg);     // Unload sound data
 
     CloseAudioDevice();     // Close audio device
 

examples/core/core_2d_camera.c

@@ -0,0 +1,139 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - 2d camera
+*
+*   This example has been created using raylib 1.5 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define MAX_BUILDINGS   100
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
+    
+    Rectangle player = { 400, 280, 40, 40 };
+    Rectangle buildings[MAX_BUILDINGS];
+    Color buildColors[MAX_BUILDINGS];
+    
+    int spacing = 0;
+    
+    for (int i = 0; i < MAX_BUILDINGS; i++)
+    {
+        buildings[i].width = GetRandomValue(50, 200);
+        buildings[i].height = GetRandomValue(100, 800);
+        buildings[i].y = screenHeight - 130 - buildings[i].height;
+        buildings[i].x = -6000 + spacing;
+
+        spacing += buildings[i].width;
+        
+        buildColors[i] = (Color){ GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255 };
+    }
+    
+    Camera2D camera;
+    
+    camera.target = (Vector2){ player.x + 20, player.y + 20 };
+    camera.offset = (Vector2){ 0, 0 };
+    camera.rotation = 0.0f;
+    camera.zoom = 1.0f;
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyDown(KEY_RIGHT))
+        {
+            player.x += 2;              // Player movement
+            camera.offset.x -= 2;       // Camera displacement with player movement
+        }
+        else if (IsKeyDown(KEY_LEFT))
+        {
+            player.x -= 2;              // Player movement
+            camera.offset.x += 2;       // Camera displacement with player movement
+        }
+        
+        // Camera target follows player
+        camera.target = (Vector2){ player.x + 20, player.y + 20 };
+        
+        // Camera rotation controls
+        if (IsKeyDown(KEY_A)) camera.rotation--;
+        else if (IsKeyDown(KEY_S)) camera.rotation++;
+        
+        // Limit camera rotation to 80 degrees (-40 to 40)
+        if (camera.rotation > 40) camera.rotation = 40;         
+        else if (camera.rotation < -40) camera.rotation = -40;
+        
+        // Camera zoom controls
+        camera.zoom += ((float)GetMouseWheelMove()*0.05f);
+        
+        if (camera.zoom > 3.0f) camera.zoom = 3.0f;
+        else if (camera.zoom < 0.1f) camera.zoom = 0.1f;
+        
+        // Camera reset (zoom and rotation)
+        if (IsKeyPressed(KEY_R)) 
+        {
+            camera.zoom = 1.0f;
+            camera.rotation = 0.0f;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        
+            ClearBackground(RAYWHITE);
+        
+            Begin2dMode(camera);
+
+                DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY);
+                
+                for (int i = 0; i < MAX_BUILDINGS; i++) DrawRectangleRec(buildings[i], buildColors[i]);
+                
+                DrawRectangleRec(player, RED);
+                
+                DrawRectangle(camera.target.x, -500, 1, screenHeight*4, GREEN);
+                DrawRectangle(-500, camera.target.y, screenWidth*4, 1, GREEN);
+                
+            End2dMode();
+            
+            DrawText("SCREEN AREA", 640, 10, 20, RED);
+            
+            DrawRectangle(0, 0, screenWidth, 5, RED);
+            DrawRectangle(0, 5, 5, screenHeight - 10, RED);
+            DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, RED);
+            DrawRectangle(0, screenHeight - 5, screenWidth, 5, RED);
+            
+            DrawRectangle( 10, 10, 250, 113, Fade(SKYBLUE, 0.5f));
+            DrawRectangleLines( 10, 10, 250, 113, BLUE);
+            
+            DrawText("Free 2d camera controls:", 20, 20, 10, BLACK);
+            DrawText("- Right/Left to move Offset", 40, 40, 10, DARKGRAY);
+            DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, DARKGRAY);
+            DrawText("- A / S to Rotate", 40, 80, 10, DARKGRAY);
+            DrawText("- R to reset Zoom and Rotation", 40, 100, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_3d_camera_first_person.c

@@ -0,0 +1,92 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - 3d camera first person
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define MAX_COLUMNS 20
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    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 };
+
+    // Generates some random columns
+    float heights[MAX_COLUMNS];
+    Vector3 positions[MAX_COLUMNS];
+    Color colors[MAX_COLUMNS];
+    
+    for (int i = 0; i < MAX_COLUMNS; i++)
+    {
+        heights[i] = (float)GetRandomValue(1, 12);
+        positions[i] = (Vector3){ GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) };
+        colors[i] = (Color){ GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 };
+    }
+    
+    SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set a first person camera mode
+
+    SetTargetFPS(60);                           // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())                // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);                  // Update camera
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+
+                DrawPlane((Vector3){ 0.0f, 0.0f, 0.0f }, (Vector2){ 32.0f, 32.0f }, LIGHTGRAY); // Draw ground
+                DrawCube((Vector3){ -16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
+                DrawCube((Vector3){ 16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
+                DrawCube((Vector3){ 0.0f, 2.5f, 16.0f }, 32.0f, 5.0f, 1.0f, GOLD);      // Draw a yellow wall
+            
+                // Draw some cubes around
+                for (int i = 0; i < MAX_COLUMNS; i++)
+                {
+                    DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
+                    DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, MAROON);
+                }
+
+            End3dMode();
+            
+            DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5f));
+            DrawRectangleLines( 10, 10, 220, 70, BLUE);
+
+            DrawText("First person camera default controls:", 20, 20, 10, BLACK);
+            DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY);
+            DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_3d_camera_free.c

@@ -0,0 +1,82 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Initialize 3d camera free
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
+
+    // Define the camera to look into our 3d world
+    Camera camera;
+    camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 45.0f;                                // Camera field-of-view Y
+    
+    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
+    
+    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
+
+    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())        // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);          // Update camera
+        
+        if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+
+                DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+
+                DrawGrid(10, 1.0f);
+
+            End3dMode();
+            
+            DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5f));
+            DrawRectangleLines( 10, 10, 320, 133, BLUE);
+            
+            DrawText("Free camera default controls:", 20, 20, 10, BLACK);
+            DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY);
+            DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY);
+            DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY);
+            DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY);
+            DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_3d_mode.c

@@ -1,11 +1,11 @@
 /*******************************************************************************************
 *
-*   raylib example 07b - Draw some basic 3d shapes (cube, sphere, cylinder...)
+*   raylib [core] example - Initialize 3d mode
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -18,10 +18,16 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    // Define the camera to look into our 3d world
-    Camera camera = {{ 0.0, 10.0, 10.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }};
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode");
 
-    InitWindow(screenWidth, screenHeight, "raylib example 07b - 3d shapes");
+    // Define the camera to look into our 3d world
+    Camera camera;
+    camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };  // Camera position
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 45.0f;                                // Camera field-of-view Y
+
+    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
 
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -42,24 +48,15 @@ int main()
 
             Begin3dMode(camera);
 
-                DrawCube((Vector3){-4, 0, 2}, 2, 5, 2, RED);
-                DrawCubeWires((Vector3){-4, 0, 2}, 2, 5, 2, GOLD);
-                DrawCubeWires((Vector3){-4, 0, -2}, 3, 6, 2, MAROON);
+                DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
 
-                DrawSphere((Vector3){-1, 0, -2}, 1, GREEN);     
-                DrawSphereWires((Vector3){1, 0, 2}, 2, LIME);
-                
-                DrawCylinder((Vector3){4, 0, -2}, 1, 2, 3, 4, SKYBLUE);
-                DrawCylinderWires((Vector3){4, 0, -2}, 1, 2, 3, 4, DARKBLUE);
-                DrawCylinderWires((Vector3){4.5, -1, 2}, 1, 1, 2, 6, BROWN);
-                
-                DrawCylinder((Vector3){1, 0, -4}, 0, 1.5, 3, 8, GOLD);
-                DrawCylinderWires((Vector3){1, 0, -4}, 0, 1.5, 3, 8, PINK);
-
-                DrawGrid(10.0, 1.0);        // Draw a grid
+                DrawGrid(10, 1.0f);
 
             End3dMode();
 
+            DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
+
             DrawFPS(10, 10);
 
         EndDrawing();

examples/core/core_3d_picking.c

@@ -0,0 +1,102 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Picking in 3d mode
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking");
+
+    // Define the camera to look into our 3d world
+    Camera camera;
+    camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 45.0f;                                // Camera field-of-view Y
+
+    Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
+    Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
+
+    Ray ray = {0.0f, 0.0f, 0.0f};        // Picking line ray
+
+    bool collision = false;
+
+    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
+
+    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())        // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);          // Update camera
+
+        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        {
+            ray = GetMouseRay(GetMousePosition(), camera);
+
+            // Check collision between ray and box
+            collision = CheckCollisionRayBox(ray,
+                        (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 },
+                                      (Vector3){ cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 }});
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+
+                if (collision)
+                {
+                    DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED);
+                    DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON);
+
+                    DrawCubeWires(cubePosition, cubeSize.x + 0.2f, cubeSize.y + 0.2f, cubeSize.z + 0.2f, GREEN);
+                }
+                else
+                {
+                    DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY);
+                    DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY);
+                }
+
+                DrawRay(ray, MAROON);
+                DrawGrid(10, 1.0f);
+
+            End3dMode();
+
+            DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY);
+
+            if(collision) DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30)) / 2, screenHeight * 0.1f, 30, GREEN);
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_basic_window.c

@@ -1,11 +1,21 @@
 /*******************************************************************************************
 *
-*   raylib example 01 - Basic Window
+*   raylib [core] example - Basic window
+*
+*   Welcome to raylib!
+*
+*   To test examples, just press F6 and execute raylib_compile_execute script
+*   Note that compiled executable is placed in the same folder as .c file
+*
+*   You can find all basic examples on C:\raylib\raylib\examples folder or
+*   raylib official webpage: www.raylib.com
+*
+*   Enjoy using raylib. :)
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -18,7 +28,9 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    InitWindow(screenWidth, screenHeight, "raylib example 01a - basic window");
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+    
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_basic_window.cpp

@@ -0,0 +1,62 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Basic window
+*
+*   Welcome to raylib!
+*
+*   To test examples, just press F6 and execute raylib_compile_execute script
+*   Note that compiled executable is placed in the same folder as .c file
+*
+*   You can find all basic examples on C:\raylib\raylib\examples folder or
+*   raylib official webpage: www.raylib.com
+*
+*   Enjoy using raylib. :)
+*
+*   This example has been created using raylib 1.0 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main(int argc, char* argv[])
+{
+	// Initialization
+	//--------------------------------------------------------------------------------------
+	int screenWidth = 800;
+	int screenHeight = 450;
+
+	InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+
+	SetTargetFPS(60);
+	//--------------------------------------------------------------------------------------
+
+	// Main game loop
+	while (!WindowShouldClose())    // Detect window close button or ESC key
+	{
+		// Update
+		//----------------------------------------------------------------------------------
+		// TODO: Update your variables here
+		//----------------------------------------------------------------------------------
+
+		// Draw
+		//----------------------------------------------------------------------------------
+		BeginDrawing();
+
+		ClearBackground(RAYWHITE);
+
+		DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
+
+		EndDrawing();
+		//----------------------------------------------------------------------------------
+	}
+
+	// De-Initialization
+	//--------------------------------------------------------------------------------------   
+	CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+	return 0;
+}

examples/core/core_basic_window_web.c

@@ -0,0 +1,85 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Basic window (adapted for HTML5 platform)
+*
+*   This example is prepared to compile for PLATFORM_WEB, PLATFORM_DESKTOP and PLATFORM_RPI
+*   As you will notice, code structure is slightly diferent to the other examples...
+*   To compile it for PLATFORM_WEB just uncomment #define PLATFORM_WEB at beginning
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+//#define PLATFORM_WEB
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        UpdateDrawFrame();
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    // TODO: Update your variables here
+    //----------------------------------------------------------------------------------
+
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
+
+    EndDrawing();
+    //----------------------------------------------------------------------------------
+}

examples/core/core_color_select.c

@@ -1,11 +1,11 @@
 /*******************************************************************************************
 *
-*   raylib example 06a - Color selection by mouse (collision detection)
+*   raylib [core] example - Color selection by mouse (collision detection)
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -16,30 +16,30 @@ int main()
     // Initialization
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
-    int screenHeight = 400;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
 
     Color colors[21] = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
                          GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
                          GREEN, SKYBLUE, PURPLE, BEIGE };
 
-    Rectangle recs[21];             // Rectangles array
+    Rectangle colorsRecs[21];             // Rectangles array
 
-    // Fills recs data (for every rectangle)
+    // Fills colorsRecs data (for every rectangle)
     for (int i = 0; i < 21; i++)
     {
-        recs[i].x = 20 + 100*(i%7) + 10*(i%7);
-        recs[i].y = 40 + 100*(i/7) + 10*(i/7);
-        recs[i].width = 100;
-        recs[i].height = 100;
+        colorsRecs[i].x = 20 + 100*(i%7) + 10*(i%7);
+        colorsRecs[i].y = 60 + 100*(i/7) + 10*(i/7);
+        colorsRecs[i].width = 100;
+        colorsRecs[i].height = 100;
     }
 
-    bool selected[21] = { false };   // Selected rectangles indicator
+    bool selected[21] = { false };  // Selected rectangles indicator
 
     Vector2 mousePoint;
 
-    InitWindowEx(screenWidth, screenHeight, "raylib example 06a - color selection", false, "resources/mouse.png");
-    
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -51,7 +51,7 @@ int main()
 
         for (int i = 0; i < 21; i++)    // Iterate along all the rectangles
         {
-            if (CheckCollisionPointRec(mousePoint, recs[i]))
+            if (CheckCollisionPointRec(mousePoint, colorsRecs[i]))
             {
                 colors[i].a = 120;
 
@@ -69,15 +69,15 @@ int main()
 
             for (int i = 0; i < 21; i++)    // Draw all rectangles
             {
-                DrawRectangleRec(recs[i], colors[i]);
+                DrawRectangleRec(colorsRecs[i], colors[i]);
 
                 // Draw four rectangles around selected rectangle
                 if (selected[i])
                 {
-                    DrawRectangle(recs[i].x, recs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
-                    DrawRectangle(recs[i].x, recs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
-                    DrawRectangle(recs[i].x + 90, recs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
-                    DrawRectangle(recs[i].x, recs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
+                    DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
+                    DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
+                    DrawRectangle(colorsRecs[i].x + 90, colorsRecs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
+                    DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
                 }
             }
 

examples/core/core_drop_files.c

@@ -1,11 +1,13 @@
 /*******************************************************************************************
 *
-*   raylib example 03c - Gamepad input
+*   raylib [core] example - Windows drop files
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
+*   This example only works on platforms that support drag & drop (Windows, Linux, OSX, Html5?)
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -18,12 +20,12 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    Vector2 ballPosition = { screenWidth/2, screenHeight/2 };
-    Vector2 gamepadMove = { 0, 0 };
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
     
-    InitWindow(screenWidth, screenHeight, "raylib example 01 - gamepad input");
+    int count = 0;
+    char **droppedFiles = { 0 };
     
-    SetTargetFPS(60);       // Set target frames-per-second
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -31,18 +33,9 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        if (IsGamepadAvailable(GAMEPAD_PLAYER1))
+        if (IsFileDropped())
         {
-            gamepadMove = GetGamepadMovement(GAMEPAD_PLAYER1);
-            
-            ballPosition.x += gamepadMove.x;
-            ballPosition.y -= gamepadMove.y;
-        
-            if (IsGamepadButtonPressed(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_A))
-            {
-                ballPosition.x = screenWidth/2;
-                ballPosition.y = screenHeight/2;
-            }
+            droppedFiles = GetDroppedFiles(&count);
         }
         //----------------------------------------------------------------------------------
 
@@ -52,9 +45,21 @@ int main()
 
             ClearBackground(RAYWHITE);
 
-            DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY);
+            if (count == 0) DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY);
+            else
+            {
+                DrawText("Dropped files:", 100, 40, 20, DARKGRAY);
                 
-            DrawCircleV(ballPosition, 50, MAROON);
+                for (int i = 0; i < count; i++)
+                {
+                    if (i%2 == 0) DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5f));
+                    else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3f));
+                    
+                    DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY);
+                }
+                
+                DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY);
+            }
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -62,7 +67,9 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    CloseWindow();        // Close window and OpenGL context
+    ClearDroppedFiles();    // Clear internal buffers
+    
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

examples/core/core_gestures_detection.c

@@ -0,0 +1,115 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Gestures Detection
+*
+*   This example has been created using raylib 1.4 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include <string.h>
+
+#define MAX_GESTURE_STRINGS   20
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+    
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - gestures detection");
+    
+    Vector2 touchPosition = { 0, 0 };
+    Rectangle touchArea = { 220, 10, screenWidth - 230, screenHeight - 20 };
+    
+    int gesturesCount = 0;
+    char gestureStrings[MAX_GESTURE_STRINGS][32];
+
+    int currentGesture = GESTURE_NONE;
+    int lastGesture = GESTURE_NONE;
+    
+    //SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        lastGesture = currentGesture;
+        currentGesture = GetGestureDetected();
+        touchPosition = GetTouchPosition(0);
+
+        if (CheckCollisionPointRec(touchPosition, touchArea) && (currentGesture != GESTURE_NONE))
+        {
+            if (currentGesture != lastGesture)
+            {
+                // Store gesture string
+                switch (currentGesture)
+                {
+                    case GESTURE_TAP: strcpy(gestureStrings[gesturesCount], "GESTURE TAP"); break;
+                    case GESTURE_DOUBLETAP: strcpy(gestureStrings[gesturesCount], "GESTURE DOUBLETAP"); break;
+                    case GESTURE_HOLD: strcpy(gestureStrings[gesturesCount], "GESTURE HOLD"); break;
+                    case GESTURE_DRAG: strcpy(gestureStrings[gesturesCount], "GESTURE DRAG"); break;
+                    case GESTURE_SWIPE_RIGHT: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE RIGHT"); break;
+                    case GESTURE_SWIPE_LEFT: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE LEFT"); break;
+                    case GESTURE_SWIPE_UP: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE UP"); break;
+                    case GESTURE_SWIPE_DOWN: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE DOWN"); break;
+                    case GESTURE_PINCH_IN: strcpy(gestureStrings[gesturesCount], "GESTURE PINCH IN"); break;
+                    case GESTURE_PINCH_OUT: strcpy(gestureStrings[gesturesCount], "GESTURE PINCH OUT"); break;
+                    default: break;
+                }
+                
+                gesturesCount++;
+                
+                // Reset gestures strings
+                if (gesturesCount >= MAX_GESTURE_STRINGS)
+                {
+                    for (int i = 0; i < MAX_GESTURE_STRINGS; i++) strcpy(gestureStrings[i], "\0");
+                    
+                    gesturesCount = 0;
+                }
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            
+            DrawRectangleRec(touchArea, GRAY);
+            DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE);
+            
+            DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5f));
+            
+            for (int i = 0; i < gesturesCount; i++)
+            {
+                if (i%2 == 0) DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.5f));
+                else DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.3f));
+                
+                if (i < gesturesCount - 1) DrawText(gestureStrings[i], 35, 36 + 20*i, 10, DARKGRAY);
+                else DrawText(gestureStrings[i], 35, 36 + 20*i, 10, MAROON);
+            }
+            
+            DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY);
+            DrawText("DETECTED GESTURES", 50, 15, 10, GRAY);
+            
+            if (currentGesture != GESTURE_NONE) DrawCircleV(touchPosition, 30, MAROON);
+            
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+}

examples/core/core_input_gamepad.c

@@ -0,0 +1,194 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Gamepad input
+*
+*   NOTE: This example requires a Gamepad connected to the system
+*         raylib is configured to work with the following gamepads: 
+*                - Xbox 360 Controller (Xbox 360, Xbox One)
+*                - PLAYSTATION(R)3 Controller 
+*         Check raylib.h for buttons configuration
+*
+*   This example has been created using raylib 1.6 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+// NOTE: Gamepad name ID depends on drivers and OS
+#if defined(PLATFORM_RPI)
+    #define XBOX360_NAME_ID     "Microsoft X-Box 360 pad"
+    #define PS3_NAME_ID         "PLAYSTATION(R)3 Controller"
+#else
+    #define XBOX360_NAME_ID     "Xbox 360 Controller"
+    #define PS3_NAME_ID         "PLAYSTATION(R)3 Controller"
+#endif
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation  
+    
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
+    
+    Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
+    Texture2D texXboxPad = LoadTexture("resources/xbox.png");
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // ...
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            
+            if (IsGamepadAvailable(GAMEPAD_PLAYER1))
+            {
+                DrawText(FormatText("GP1: %s", GetGamepadName(GAMEPAD_PLAYER1)), 10, 10, 10, BLACK);
+
+                if (IsGamepadName(GAMEPAD_PLAYER1, XBOX360_NAME_ID))
+                {
+                    DrawTexture(texXboxPad, 0, 0, DARKGRAY);
+                    
+                    // Draw buttons: xbox home
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_HOME)) DrawCircle(394, 89, 19, RED);
+
+                    // Draw buttons: basic
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_START)) DrawCircle(436, 150, 9, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_SELECT)) DrawCircle(352, 150, 9, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_X)) DrawCircle(501, 151, 15, BLUE);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_A)) DrawCircle(536, 187, 15, LIME);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_B)) DrawCircle(572, 151, 15, MAROON);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_Y)) DrawCircle(536, 115, 15, GOLD);
+                    
+                    // Draw buttons: d-pad
+                    DrawRectangle(317, 202, 19, 71, BLACK);
+                    DrawRectangle(293, 228, 69, 19, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_UP)) DrawRectangle(317, 202, 19, 26, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_DOWN)) DrawRectangle(317, 202 + 45, 19, 26, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LEFT)) DrawRectangle(292, 228, 25, 19, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RIGHT)) DrawRectangle(292 + 44, 228, 26, 19, RED);
+                    
+                    // Draw buttons: left-right back
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LB)) DrawCircle(259, 61, 20, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RB)) DrawCircle(536, 61, 20, RED);
+
+                    // Draw axis: left joystick
+                    DrawCircle(259, 152, 39, BLACK);
+                    DrawCircle(259, 152, 34, LIGHTGRAY);
+                    DrawCircle(259 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_X)*20), 
+                               152 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_Y)*20), 25, BLACK);
+                    
+                    // Draw axis: right joystick
+                    DrawCircle(461, 237, 38, BLACK);
+                    DrawCircle(461, 237, 33, LIGHTGRAY);
+                    DrawCircle(461 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_X)*20), 
+                               237 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_Y)*20), 25, BLACK);
+
+                    // Draw axis: left-right triggers
+                    DrawRectangle(170, 30, 15, 70, GRAY);
+                    DrawRectangle(604, 30, 15, 70, GRAY);              
+                    DrawRectangle(170, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT))/2.0f)*70), RED);
+                    DrawRectangle(604, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT))/2.0f)*70), RED);
+                    
+                    //DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)), 10, 40, 10, BLACK);
+                    //DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)), 10, 60, 10, BLACK);
+                }
+                else if (IsGamepadName(GAMEPAD_PLAYER1, PS3_NAME_ID))
+                {
+                    DrawTexture(texPs3Pad, 0, 0, DARKGRAY);
+
+                    // Draw buttons: ps
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_PS)) DrawCircle(396, 222, 13, RED);
+                    
+                    // Draw buttons: basic
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SELECT)) DrawRectangle(328, 170, 32, 13, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_START)) DrawTriangle((Vector2){ 436, 168 }, (Vector2){ 436, 185 }, (Vector2){ 464, 177 }, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_TRIANGLE)) DrawCircle(557, 144, 13, LIME);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CIRCLE)) DrawCircle(586, 173, 13, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CROSS)) DrawCircle(557, 203, 13, VIOLET);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SQUARE)) DrawCircle(527, 173, 13, PINK);
+
+                    // Draw buttons: d-pad
+                    DrawRectangle(225, 132, 24, 84, BLACK);
+                    DrawRectangle(195, 161, 84, 25, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_UP)) DrawRectangle(225, 132, 24, 29, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_DOWN)) DrawRectangle(225, 132 + 54, 24, 30, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_LEFT)) DrawRectangle(195, 161, 30, 25, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_RIGHT)) DrawRectangle(195 + 54, 161, 30, 25, RED);
+                    
+                    // Draw buttons: left-right back buttons
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_L1)) DrawCircle(239, 82, 20, RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_R1)) DrawCircle(557, 82, 20, RED);
+
+                    // Draw axis: left joystick
+                    DrawCircle(319, 255, 35, BLACK);
+                    DrawCircle(319, 255, 31, LIGHTGRAY);
+                    DrawCircle(319 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_X)*20), 
+                               255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_Y)*20), 25, BLACK);
+                    
+                    // Draw axis: right joystick
+                    DrawCircle(475, 255, 35, BLACK);
+                    DrawCircle(475, 255, 31, LIGHTGRAY);
+                    DrawCircle(475 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_X)*20), 
+                               255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_Y)*20), 25, BLACK);
+
+                    // Draw axis: left-right triggers
+                    DrawRectangle(169, 48, 15, 70, GRAY);
+                    DrawRectangle(611, 48, 15, 70, GRAY);              
+                    DrawRectangle(169, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_L2))/2.0f)*70), RED);
+                    DrawRectangle(611, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_R2))/2.0f)*70), RED);
+                }
+                else
+                {
+                    DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY);
+                    
+                    // TODO: Draw generic gamepad
+                }
+                
+                DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON); 
+                
+                for (int i = 0; i < GetGamepadAxisCount(GAMEPAD_PLAYER1); i++)
+                {
+                    DrawText(FormatText("AXIS %i: %.02f", i, GetGamepadAxisMovement(GAMEPAD_PLAYER1, i)), 20, 70 + 20*i, 10, DARKGRAY);
+                }
+                
+                if (GetGamepadButtonPressed() != -1) DrawText(FormatText("DETECTED BUTTON: %i", GetGamepadButtonPressed()), 10, 430, 10, RED);
+                else DrawText("DETECTED BUTTON: NONE", 10, 430, 10, GRAY);
+            }
+            else
+            {
+                DrawText("GP1: NOT DETECTED", 10, 10, 10, GRAY);
+                
+                DrawTexture(texXboxPad, 0, 0, LIGHTGRAY);
+            }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texPs3Pad);
+    UnloadTexture(texXboxPad);
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_input_keys.c

@@ -1,11 +1,11 @@
 /*******************************************************************************************
 *
-*   raylib example 03a - Keyboard input 
+*   raylib [core] example - Keyboard input
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -18,9 +18,9 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    Vector2 ballPosition = { screenWidth/2, screenHeight/2 };
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
 
-    InitWindow(screenWidth, screenHeight, "raylib example 05 - keyboard input");
+    Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 };
 
     SetTargetFPS(60);       // Set target frames-per-second
     //--------------------------------------------------------------------------------------
@@ -30,10 +30,10 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        if (IsKeyPressed(KEY_RIGHT)) ballPosition.x += 0.8;
-        if (IsKeyPressed(KEY_LEFT)) ballPosition.x -= 0.8;
-        if (IsKeyPressed(KEY_UP)) ballPosition.y -= 0.8;
-        if (IsKeyPressed(KEY_DOWN)) ballPosition.y += 0.8;
+        if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 0.8f;
+        if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 0.8f;
+        if (IsKeyDown(KEY_UP)) ballPosition.y -= 0.8f;
+        if (IsKeyDown(KEY_DOWN)) ballPosition.y += 0.8f;
         //----------------------------------------------------------------------------------
 
         // Draw

examples/core/core_input_mouse.c

@@ -1,11 +1,11 @@
 /*******************************************************************************************
 *
-*   raylib example 03b - Mouse input 
+*   raylib [core] example - Mouse input
 *
 *   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -18,11 +18,12 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    Vector2 ballPosition = { -100.0, -100.0 };
-    int counter = 0;
-    int mouseX, mouseY;
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
 
-    InitWindow(screenWidth, screenHeight, "raylib example 06 - mouse input");
+    Vector2 ballPosition = { -100.0f, -100.0f };
+    Color ballColor = DARKBLUE;
+    
+    SetTargetFPS(60);
     //---------------------------------------------------------------------------------------
 
     // Main game loop
@@ -30,14 +31,11 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
-        {
-            mouseX = GetMouseX();
-            mouseY = GetMouseY();
+        ballPosition = GetMousePosition();
         
-            ballPosition.x = (float)mouseX;
-            ballPosition.y = (float)mouseY;
-        }
+        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
+        else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
+        else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -46,9 +44,9 @@ int main()
 
             ClearBackground(RAYWHITE);
 
-            DrawCircleV(ballPosition, 40, GOLD);
+            DrawCircleV(ballPosition, 40, ballColor);
 
-            DrawText("mouse click to draw the ball", 10, 10, 20, DARKGRAY);
+            DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY);
 
         EndDrawing();
         //----------------------------------------------------------------------------------

examples/core/core_mouse_wheel.c

@@ -0,0 +1,58 @@
+/*******************************************************************************************
+*
+*   raylib [core] examples - Mouse wheel
+*
+*   This test has been created using raylib 1.1 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel");
+
+    int boxPositionY = screenHeight/2 - 40;
+    int scrollSpeed = 4;            // Scrolling speed in pixels
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        boxPositionY -= (GetMouseWheelMove()*scrollSpeed);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);
+
+            DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
+            DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_random_values.c

@@ -0,0 +1,65 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Generate random values
+*
+*   This example has been created using raylib 1.1 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
+
+    int framesCounter = 0;  // Variable used to count frames
+
+    int randValue = GetRandomValue(-8, 5);   // Get a random integer number between -8 and 5 (both included)
+
+    SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        framesCounter++;
+
+        // Every two seconds (120 frames) a new random value is generated
+        if (((framesCounter/120)%2) == 1)
+        {
+            randValue = GetRandomValue(-8, 5);
+            framesCounter = 0;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON);
+
+            DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_storage_values.c

@@ -0,0 +1,85 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Storage save/load values
+*
+*   This example has been created using raylib 1.4 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+// NOTE: Storage positions must start with 0, directly related to file memory layout
+typedef enum { STORAGE_SCORE = 0, STORAGE_HISCORE } StorageData;
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
+    
+    int score = 0;
+    int hiscore = 0;
+    
+    int framesCounter = 0;
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KEY_R))
+        {
+            score = GetRandomValue(1000, 2000);
+            hiscore = GetRandomValue(2000, 4000);
+        }
+        
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            StorageSaveValue(STORAGE_SCORE, score);
+            StorageSaveValue(STORAGE_HISCORE, hiscore);
+        }
+        else if (IsKeyPressed(KEY_SPACE))
+        {
+            // NOTE: If requested position could not be found, value 0 is returned
+            score = StorageLoadValue(STORAGE_SCORE);
+            hiscore = StorageLoadValue(STORAGE_HISCORE);
+        }
+        
+        framesCounter++;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText(FormatText("SCORE: %i", score), 280, 130, 40, MAROON);
+            DrawText(FormatText("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK);
+            
+            DrawText(FormatText("frames: %i", framesCounter), 10, 10, 20, LIME);
+            
+            DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY);
+            DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY);
+            DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_vr_simulator.c

@@ -0,0 +1,85 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - VR Simulator (Oculus Rift CV1 parameters)
+*
+*   This example has been created using raylib 1.7 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 1080;
+    int screenHeight = 600;
+    
+    // NOTE: screenWidth/screenHeight should match VR device aspect ratio
+    
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - vr simulator");
+
+    // Init VR simulator (Oculus Rift CV1 parameters)
+    InitVrSimulator(GetVrDeviceInfo(HMD_OCULUS_RIFT_CV1));
+    
+    // Define the camera to look into our 3d world
+    Camera camera;
+    camera.position = (Vector3){ 5.0f, 2.0f, 5.0f };    // Camera position
+    camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 60.0f;                                // Camera field-of-view Y
+    
+    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
+    
+    SetCameraMode(camera, CAMERA_FIRST_PERSON);         // Set first person camera mode
+    
+    SetTargetFPS(90);                   // Set our game to run at 90 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())        // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);          // Update camera (simulator mode)
+
+        if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();    // Toggle VR mode
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            
+            BeginVrDrawing();
+
+                Begin3dMode(camera);
+
+                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+
+                    DrawGrid(40, 1.0f);
+
+                End3dMode();
+            
+            EndVrDrawing();
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseVrSimulator();     // Close VR simulator
+    
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/core/core_world_screen.c

@@ -0,0 +1,74 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - World to screen
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    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 };
+
+    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
+    
+    Vector2 cubeScreenPosition;
+    
+    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
+
+    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())        // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);          // Update camera
+        
+        // Calculate cube screen space position (with a little offset to be in top)
+        cubeScreenPosition = GetWorldToScreen((Vector3){cubePosition.x, cubePosition.y + 2.5f, cubePosition.z}, camera);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+
+                DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+
+                DrawGrid(10, 1.0f);
+
+            End3dMode();
+            
+            DrawText("Enemy: 100 / 100", cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20) / 2, cubeScreenPosition.y, 20, BLACK);
+            DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20)) / 2, 25, 20, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/ex05b_rbmf_fonts.c

@@ -1,76 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib example 05b - raylib bitmap font (rbmf) loading and using
-*
-*   This example has been created using raylib 1.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 560;
-    int screenHeight = 800;
-
-    InitWindow(screenWidth, screenHeight, "raylib example 05b - rBMF fonts");
-    
-    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
-    SpriteFont font1 = LoadSpriteFont("resources/fonts/alagard.rbmf");       // SpriteFont loading
-    SpriteFont font2 = LoadSpriteFont("resources/fonts/pixelplay.rbmf");     // SpriteFont loading
-    SpriteFont font3 = LoadSpriteFont("resources/fonts/mecha.rbmf");         // SpriteFont loading
-    SpriteFont font4 = LoadSpriteFont("resources/fonts/setback.rbmf");       // SpriteFont loading
-    SpriteFont font5 = LoadSpriteFont("resources/fonts/romulus.rbmf");       // SpriteFont loading
-    SpriteFont font6 = LoadSpriteFont("resources/fonts/pixantiqua.rbmf");    // SpriteFont loading
-    SpriteFont font7 = LoadSpriteFont("resources/fonts/alpha_beta.rbmf");    // SpriteFont loading
-    SpriteFont font8 = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf"); // SpriteFont loading
-    //--------------------------------------------------------------------------------------
-    
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        // TODO: Update your variables here
-        //----------------------------------------------------------------------------------
-        
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-        
-            ClearBackground(RAYWHITE);
-            
-            DrawTextEx(font1, "TESTING ALAGARD FONT", (Vector2){ 100, 100 }, GetFontBaseSize(font1)*2, 2, MAROON);
-            DrawTextEx(font2, "TESTING PIXELPLAY FONT", (Vector2){ 100, 180 }, GetFontBaseSize(font2)*2, 4, ORANGE);  
-            DrawTextEx(font3, "TESTING MECHA FONT", (Vector2){ 100, 260 }, GetFontBaseSize(font3)*2, 8, DARKGREEN);  
-            DrawTextEx(font4, "TESTING SETBACK FONT", (Vector2){ 100, 350 }, GetFontBaseSize(font4)*2, 4, DARKBLUE);  
-            DrawTextEx(font5, "TESTING ROMULUS FONT", (Vector2){ 100, 430 }, GetFontBaseSize(font5)*2, 3, DARKPURPLE);
-            DrawTextEx(font6, "TESTING PIXANTIQUA FONT", (Vector2){ 100, 510 }, GetFontBaseSize(font6)*2, 4, LIME);  
-            DrawTextEx(font7, "TESTING ALPHA_BETA FONT", (Vector2){ 100, 590 }, GetFontBaseSize(font7)*2, 4, GOLD);  
-            DrawTextEx(font8, "TESTING JUPITER_CRASH FONT", (Vector2){ 100, 660 }, GetFontBaseSize(font8)*2, 1, RED);               
-       
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    UnloadSpriteFont(font1);       // SpriteFont unloading
-    UnloadSpriteFont(font2);       // SpriteFont unloading
-    UnloadSpriteFont(font3);       // SpriteFont unloading
-    UnloadSpriteFont(font4);       // SpriteFont unloading
-    UnloadSpriteFont(font5);       // SpriteFont unloading
-    UnloadSpriteFont(font6);       // SpriteFont unloading
-    UnloadSpriteFont(font7);       // SpriteFont unloading
-    UnloadSpriteFont(font8);       // SpriteFont unloading
-    
-    CloseWindow();                 // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-    
-    return 0;
-}

examples/ex06c_font_select.c

@@ -1,144 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib example 06c - Font selection...
-*
-*   This example has been created using raylib 1.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 150;
-
-    InitWindow(screenWidth, screenHeight, "raylib example 06c - font selection");
-    
-    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
-    SpriteFont fonts[8];        // SpriteFont array
-    
-    fonts[0] = LoadSpriteFont("resources/fonts/alagard.rbmf");       // SpriteFont loading
-    fonts[1] = LoadSpriteFont("resources/fonts/pixelplay.rbmf");     // SpriteFont loading
-    fonts[2] = LoadSpriteFont("resources/fonts/mecha.rbmf");         // SpriteFont loading
-    fonts[3] = LoadSpriteFont("resources/fonts/setback.rbmf");       // SpriteFont loading
-    fonts[4] = LoadSpriteFont("resources/fonts/romulus.rbmf");       // SpriteFont loading
-    fonts[5] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf");    // SpriteFont loading
-    fonts[6] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf");    // SpriteFont loading
-    fonts[7] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf"); // SpriteFont loading
-    
-    int currentFont = 0;        // Selected font
-    
-    Color colors[8] = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED };
-    
-    const char fontNames[8][20] = { "[0] Alagard", "[1] PixelPlay", "[2] MECHA", "[3] Setback", 
-                                    "[4] Romulus", "[5] PixAntiqua", "[6] Alpha Beta", "[7] Jupiter Crash" };
-    
-    const char text[50] = "THIS is THE FONT you SELECTED!";     // Main text
-    
-    Vector2 textSize = MeasureTextEx(fonts[currentFont], text, GetFontBaseSize(fonts[currentFont])*3, 1);
-    
-    Vector2 mousePoint;
-    
-    Rectangle btnNextRec = { 673, 18, 109, 44 };    // Button rectangle (useful for collision)
-    
-    Color btnNextOutColor = DARKBLUE;       // Button color (outside line)
-    Color btnNextInColor = SKYBLUE;         // Button color (inside)
-    
-    int framesCounter = 0;      // Useful to count frames button is 'active' = clicked
-    
-    SetTargetFPS(60);
-    //--------------------------------------------------------------------------------------
-    
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        
-        // Keyboard-based font selection (easy)
-        if (IsKeyPressed(KEY_RIGHT))
-        {
-            if (currentFont < 7) currentFont++;
-        }
-        
-        if (IsKeyPressed(KEY_LEFT))
-        {
-            if (currentFont > 0) currentFont--;
-        }
-        
-        // Mouse-based font selection (NEXT button logic)
-        mousePoint = GetMousePosition();
-        
-        if (CheckCollisionPointRec(mousePoint, btnNextRec))
-        {
-            // Mouse hover button logic
-            if (framesCounter == 0)
-            {
-                btnNextOutColor = DARKPURPLE;
-                btnNextInColor = PURPLE;
-            }
-            
-            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
-            {
-                framesCounter = 20;         // Frames button is 'active'
-                btnNextOutColor = MAROON;
-                btnNextInColor = RED;
-            }
-        }
-        else
-        {
-            // Mouse not hover button
-            btnNextOutColor = DARKBLUE;
-            btnNextInColor = SKYBLUE;
-        }
-        
-        if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON) && (framesCounter > 0)) framesCounter--;
-        
-        if (framesCounter == 1)     // We change font on frame 1
-        {    
-            currentFont++;
-            if (currentFont > 7) currentFont = 0;
-        }
-        
-        // Text measurement for better positioning on screen
-        textSize = MeasureTextEx(fonts[currentFont], text, GetFontBaseSize(fonts[currentFont])*3, 1);
-        //----------------------------------------------------------------------------------
-        
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-        
-            ClearBackground(RAYWHITE);
-            
-            DrawRectangle(18, 18, 644, 44, DARKGRAY);
-            DrawRectangle(20, 20, 640, 40, LIGHTGRAY);
-            DrawText(fontNames[currentFont], 30, 31, 20, BLACK);
-            DrawText("< >", 610, 26, 30, BLACK);
-            
-            DrawRectangleRec(btnNextRec, btnNextOutColor);
-            DrawRectangle(675, 20, 105, 40, btnNextInColor);
-            DrawText("NEXT", 700, 31, 20, btnNextOutColor);
-            
-            DrawTextEx(fonts[currentFont], text, (Vector2){ screenWidth/2 - textSize.x/2, 
-                       75 + (70 - textSize.y)/2 }, GetFontBaseSize(fonts[currentFont])*3, 
-                       1, colors[currentFont]);  
- 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    for (int i = 0; i < 8; i++) UnloadSpriteFont(fonts[i]);       // SpriteFont(s) unloading
-    
-    CloseWindow();                // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-    
-    return 0;
-}

examples/models/models_billboard.c

@@ -0,0 +1,70 @@
+/*******************************************************************************************
+*
+*   raylib [models] example - Drawing billboards
+*
+*   This example has been created using raylib 1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    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 };
+
+    Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
+    Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
+    
+    SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
+
+    SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())            // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);              // Update camera
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+            
+                DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
+                
+                DrawGrid(10, 1.0f);        // Draw a grid
+
+            End3dMode();
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(bill);        // Unload texture
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}