Reorganize examples folder

examples/Makefile

@@ -211,65 +211,66 @@ endif
 
 # define all object files required
 EXAMPLES = \
-    core_basic_window \
+    core/core_basic_window \
-    core_input_keys \
+    core/core_input_keys \
-    core_input_mouse \
+    core/core_input_mouse \
-    core_mouse_wheel \
+    core/core_mouse_wheel \
-    core_input_gamepad \
+    core/core_input_gamepad \
-    core_random_values \
+    core/core_random_values \
-    core_color_select \
+    core/core_color_select \
-    core_drop_files \
+    core/core_drop_files \
-    core_storage_values \
+    core/core_storage_values \
-    core_gestures_detection \
+    core/core_gestures_detection \
-    core_3d_mode \
+    core/core_3d_mode \
-    core_3d_picking \
+    core/core_3d_picking \
-    core_3d_camera_free \
+    core/core_3d_camera_free \
-    core_3d_camera_first_person \
+    core/core_3d_camera_first_person \
-    core_2d_camera \
+    core/core_2d_camera \
-    core_world_screen \
+    core/core_world_screen \
-    shapes_logo_raylib \
+    core/core_vr_simulator \
-    shapes_basic_shapes \
+    shapes/shapes_logo_raylib \
-    shapes_colors_palette \
+    shapes/shapes_basic_shapes \
-    shapes_logo_raylib_anim \
+    shapes/shapes_colors_palette \
-    textures_logo_raylib \
+    shapes/shapes_logo_raylib_anim \
-    textures_image_loading \
+    textures/textures_logo_raylib \
-    textures_rectangle \
+    textures/textures_image_loading \
-    textures_srcrec_dstrec \
+    textures/textures_rectangle \
-    textures_to_image \
+    textures/textures_srcrec_dstrec \
-    textures_raw_data \
+    textures/textures_to_image \
-    textures_formats_loading \
+    textures/textures_raw_data \
-    textures_particles_trail_blending \
+    textures/textures_formats_loading \
-    textures_image_processing \
+    textures/textures_particles_trail_blending \
-    textures_image_drawing \
+    textures/textures_image_processing \
-    text_sprite_fonts \
+    textures/textures_image_drawing \
-    text_bmfont_ttf \
+    text/text_sprite_fonts \
-    text_rbmf_fonts \
+    text/text_bmfont_ttf \
-    text_format_text \
+    text/text_rbmf_fonts \
-    text_font_select \
+    text/text_format_text \
-    text_writing_anim \
+    text/text_font_select \
-    text_ttf_loading \
+    text/text_writing_anim \
-    text_bmfont_unordered \
+    text/text_ttf_loading \
-    models_geometric_shapes \
+    text/text_bmfont_unordered \
-    models_box_collisions \
+    models/models_geometric_shapes \
-    models_billboard \
+    models/models_box_collisions \
-    models_obj_loading \
+    models/models_billboard \
-    models_heightmap \
+    models/models_obj_loading \
-    models_cubicmap \
+    models/models_heightmap \
-    models_ray_picking \
+    models/models_cubicmap \
-    shaders_model_shader \
+    models/models_ray_picking \
-    shaders_shapes_textures \
+    shaders/shaders_model_shader \
-    shaders_custom_uniform \
+    shaders/shaders_shapes_textures \
-    shaders_postprocessing \
+    shaders/shaders_custom_uniform \
-    shaders_standard_lighting \
+    shaders/shaders_postprocessing \
-    audio_sound_loading \
+    shaders/shaders_standard_lighting \
-    audio_music_stream \
+    audio/audio_sound_loading \
-    audio_module_playing \
+    audio/audio_music_stream \
-    audio_raw_stream \
+    audio/audio_module_playing \
-    physics_demo \
+    audio/audio_raw_stream \
-    physics_friction \
+    physac/physics_demo \
-    physics_movement \
+    physac/physics_friction \
-    physics_restitution \
+    physac/physics_movement \
-    physics_shatter \
+    physac/physics_restitution \
+    physac/physics_shatter \
     fix_dylib \
 
 
@@ -281,23 +282,23 @@ all: examples
 examples: $(EXAMPLES)
 
 # compile [core] example - basic window
-core_basic_window: core_basic_window.c
+core/core_basic_window: core/core_basic_window.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - keyboard input
-core_input_keys: core_input_keys.c
+core/core_input_keys: core/core_input_keys.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - mouse input
-core_input_mouse: core_input_mouse.c
+core/core_input_mouse: core/core_input_mouse.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - mouse wheel
-core_mouse_wheel: core_mouse_wheel.c
+core/core_mouse_wheel: core/core_mouse_wheel.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - gamepad input
-core_input_gamepad: core_input_gamepad.c
+core/core_input_gamepad: core/core_input_gamepad.c
 ifeq ($(PLATFORM), $(filter $(PLATFORM),PLATFORM_DESKTOP PLATFORM_RPI))
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 else
@@ -305,15 +306,15 @@ else
 endif
 
 # compile [core] example - generate random values
-core_random_values: core_random_values.c
+core/core_random_values: core/core_random_values.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - color selection (collision detection)
-core_color_select: core_color_select.c
+core/core_color_select: core/core_color_select.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - drop files
-core_drop_files: core_drop_files.c
+core/core_drop_files: core/core_drop_files.c
 ifeq ($(PLATFORM),PLATFORM_DESKTOP)
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 else
@@ -321,7 +322,7 @@ else
 endif
 
 # compile [core] example - storage values
-core_storage_values: core_storage_values.c
+core/core_storage_values: core/core_storage_values.c
 ifeq ($(PLATFORM), $(filter $(PLATFORM),PLATFORM_DESKTOP PLATFORM_RPI))
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 else
@@ -329,211 +330,211 @@ else
 endif
 
 # compile [core] example - gestures detection
-core_gestures_detection: core_gestures_detection.c
+core/core_gestures_detection: core/core_gestures_detection.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - 3d mode
-core_3d_mode: core_3d_mode.c
+core/core_3d_mode: core/core_3d_mode.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - 3d picking
-core_3d_picking: core_3d_picking.c
+core/core_3d_picking: core/core_3d_picking.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - 3d camera free
-core_3d_camera_free: core_3d_camera_free.c
+core/core_3d_camera_free: core/core_3d_camera_free.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - 3d camera first person
-core_3d_camera_first_person: core_3d_camera_first_person.c
+core/core_3d_camera_first_person: core/core_3d_camera_first_person.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - 2d camera
-core_2d_camera: core_2d_camera.c
+core/core_2d_camera: core/core_2d_camera.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [core] example - world screen
-core_world_screen: core_world_screen.c
+core/core_world_screen: core/core_world_screen.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
-# compile [core] example - oculus rift
+# compile [core] example - vr simulator
-#core_oculus_rift: core_oculus_rift.c
+core/core_vr_simulator: core/core_vr_simulator.c
-#	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shapes] example - raylib logo (with basic shapes)
-shapes_logo_raylib: shapes_logo_raylib.c
+shapes/shapes_logo_raylib: shapes/shapes_logo_raylib.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shapes] example - basic shapes usage (rectangle, circle, ...)
-shapes_basic_shapes: shapes_basic_shapes.c
+shapes/shapes_basic_shapes: shapes/shapes_basic_shapes.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shapes] example - raylib color palette
-shapes_colors_palette: shapes_colors_palette.c
+shapes/shapes_colors_palette: shapes/shapes_colors_palette.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shapes] example - raylib logo animation
-shapes_logo_raylib_anim: shapes_logo_raylib_anim.c
+shapes/shapes_logo_raylib_anim: shapes/shapes_logo_raylib_anim.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - raylib logo texture loading
-textures_logo_raylib: textures_logo_raylib.c
+textures/textures_logo_raylib: textures/textures_logo_raylib.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - image loading and conversion to texture
-textures_image_loading: textures_image_loading.c
+textures/textures_image_loading: textures/textures_image_loading.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture rectangle drawing
-textures_rectangle: textures_rectangle.c
+textures/textures_rectangle: textures/textures_rectangle.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture source and destination rectangles
-textures_srcrec_dstrec: textures_srcrec_dstrec.c
+textures/textures_srcrec_dstrec: textures/textures_srcrec_dstrec.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture to image
-textures_to_image: textures_to_image.c
+textures/textures_to_image: textures/textures_to_image.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture raw data
-textures_raw_data: textures_raw_data.c
+textures/textures_raw_data: textures/textures_raw_data.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture formats loading
-textures_formats_loading: textures_formats_loading.c
+textures/textures_formats_loading: textures/textures_formats_loading.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture particles trail blending
-textures_particles_trail_blending: textures_particles_trail_blending.c
+textures/textures_particles_trail_blending: textures/textures_particles_trail_blending.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture image processing
-textures_image_processing: textures_image_processing.c
+textures/textures_image_processing: textures/textures_image_processing.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [textures] example - texture image drawing
-textures_image_drawing: textures_image_drawing.c
+textures/textures_image_drawing: textures/textures_image_drawing.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - sprite fonts loading
-text_sprite_fonts: text_sprite_fonts.c
+text/text_sprite_fonts: text/text_sprite_fonts.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - bmfonts and ttf loading
-text_bmfont_ttf: text_bmfont_ttf.c
+text/text_bmfont_ttf: text/text_bmfont_ttf.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - raylib bitmap fonts (rBMF)
-text_rbmf_fonts: text_rbmf_fonts.c
+text/text_rbmf_fonts: text/text_rbmf_fonts.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - text formatting
-text_format_text: text_format_text.c
+text/text_format_text: text/text_format_text.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - font selection program
-text_font_select: text_font_select.c
+text/text_font_select: text/text_font_select.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - text writing animation
-text_writing_anim: text_writing_anim.c
+text/text_writing_anim: text/text_writing_anim.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - text ttf loading
-text_ttf_loading: text_ttf_loading.c
+text/text_ttf_loading: text/text_ttf_loading.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [text] example - text bmfont unordered
-text_bmfont_unordered: text_bmfont_unordered.c
+text/text_bmfont_unordered: text/text_bmfont_unordered.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - basic geometric 3d shapes
-models_geometric_shapes: models_geometric_shapes.c
+models/models_geometric_shapes: models/models_geometric_shapes.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - box collisions
-models_box_collisions: models_box_collisions.c
+models/models_box_collisions: models/models_box_collisions.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - basic window
-models_planes: models_planes.c
+models/models_planes: models/models_planes.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - billboard usage
-models_billboard: models_billboard.c
+models/models_billboard: models/models_billboard.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - OBJ model loading
-models_obj_loading: models_obj_loading.c
+models/models_obj_loading: models/models_obj_loading.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - heightmap loading
-models_heightmap: models_heightmap.c
+models/models_heightmap: models/models_heightmap.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - cubesmap loading
-models_cubicmap: models_cubicmap.c
+models/models_cubicmap: models/models_cubicmap.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [models] example - model ray picking
-models_ray_picking: models_ray_picking.c
+models/models_ray_picking: models/models_ray_picking.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shaders] example - model shader
-shaders_model_shader: shaders_model_shader.c
+shaders/shaders_model_shader: shaders/shaders_model_shader.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shaders] example - shapes texture shader
-shaders_shapes_textures: shaders_shapes_textures.c
+shaders/shaders_shapes_textures: shaders/shaders_shapes_textures.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shaders] example - custom uniform in shader
-shaders_custom_uniform: shaders_custom_uniform.c
+shaders/shaders_custom_uniform: shaders/shaders_custom_uniform.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shaders] example - postprocessing shader
-shaders_postprocessing: shaders_postprocessing.c
+shaders/shaders_postprocessing: shaders/shaders_postprocessing.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [shaders] example - standard lighting
-shaders_standard_lighting: shaders_standard_lighting.c
+shaders/shaders_standard_lighting: shaders/shaders_standard_lighting.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [audio] example - sound loading and playing (WAV and OGG)
-audio_sound_loading: audio_sound_loading.c
+audio/audio_sound_loading: audio/audio_sound_loading.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [audio] example - music stream playing (OGG)
-audio_music_stream: audio_music_stream.c
+audio/audio_music_stream: audio/audio_music_stream.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [audio] example - module playing (XM)
-audio_module_playing: audio_module_playing.c
+audio/audio_module_playing: audio/audio_module_playing.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [audio] example - raw audio streaming
-audio_raw_stream: audio_raw_stream.c
+audio/audio_raw_stream: audio/audio_raw_stream.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
 # compile [physac] example - physics demo
-physics_demo: physics_demo.c
+physac/physics_demo: physac/physics_demo.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -lpthread -D$(PLATFORM) $(WINFLAGS)
 
 # compile [physac] example - physics friction
-physics_friction: physics_friction.c
+physac/physics_friction: physac/physics_friction.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -lpthread -D$(PLATFORM) $(WINFLAGS)
 
 # compile [physac] example - physics movement
-physics_movement: physics_movement.c
+physac/physics_movement: physac/physics_movement.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -lpthread -D$(PLATFORM) $(WINFLAGS)
 
 # compile [physac] example - physics restitution
-physics_restitution: physics_restitution.c
+physac/physics_restitution: physac/physics_restitution.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -lpthread -D$(PLATFORM) $(WINFLAGS)
 
 # compile [physac] example - physics shatter
-physics_shatter: physics_shatter.c
+physac/physics_shatter: physac/physics_shatter.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -lpthread -D$(PLATFORM) $(WINFLAGS)
 
 # fix dylib install path name for each executable (MAC)

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/audio/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/audio/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

@@ -0,0 +1,67 @@
+/*******************************************************************************************
+*
+*   raylib [audio] example - Sound loading and playing
+*
+*   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) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
+
+    InitAudioDevice();      // Initialize audio device
+
+    Sound fxWav = LoadSound("resources/audio/sound.wav");         // Load WAV audio file
+    Sound fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
+        if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            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();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadSound(fxWav);     // Unload sound data
+    UnloadSound(fxOgg);     // Unload sound data
+
+    CloseAudioDevice();     // Close audio device
+
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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;
+}