Changing examples to use makefile

- Testing a modified version of the makefile from raylib Instead of multiple project files for examples.
- Fixed readme example

Examples/others/audio_standalone.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   raylib [audio] example - Using audio module as standalone module
    *
    *   NOTE: This example does not require any graphic device, it can run directly on console.
    *
    *   DEPENDENCIES:
    *       mini_al.h    - Audio device management lib (http://kcat.strangesoft.net/openal.html)
    *       stb_vorbis.c - Ogg audio files loading (http://www.nothings.org/stb_vorbis/)
    *       jar_xm.h     - XM module file loading
    *       jar_mod.h    - MOD audio file loading
    *       dr_flac.h    - FLAC audio file loading
    *
    *   COMPILATION:
    *       gcc -c ..\..\src\external\mini_al.c -Wall -I.
    *       gcc -o audio_standalone.exe audio_standalone.c ..\..\src\audio.c ..\..\src\external\stb_vorbis.c mini_al.o  /
    *           -I..\..\src -I..\..\src\external -L. -Wall -std=c99  / 
    *           -DAUDIO_STANDALONE -DSUPPORT_FILEFORMAT_WAV -DSUPPORT_FILEFORMAT_OGG
    *
    *   LICENSE: zlib/libpng
    *
    *   This example 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) 2014-2018 Ramon Santamaria (@raysan5)
    *
    *   This software is provided "as-is", without any express or implied warranty. In no event
    *   will the authors be held liable for any damages arising from 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.
    *
    ********************************************************************************************/
    
    
    
        #include <conio.h>          // Windows only, no stardard library
    #else
        
    // Provide kbhit() function in non-Windows platforms
    
    // Check if a key has been pressed
    static int kbhit(void)
    {
    	struct termios oldt, newt;
    	int ch;
    	int oldf;
    
    	tcgetattr(STDIN_FILENO, &oldt);
    	newt = oldt;
    	newt.c_lflag &= ~(ICANON | ECHO);
    	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    	oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    	fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    
    	ch = getchar();
    
    	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    	fcntl(STDIN_FILENO, F_SETFL, oldf);
    
    	if (ch != EOF)
    	{
    		ungetc(ch, stdin);
    		return 1;
    	}
    
    	return 0;
    }
    
    // Get pressed character
    static char getch() { return getchar(); }
    
    
    public const #define (int)Key.ESCAPE  27

    public static void Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        static unsigned char key;
    
        InitAudioDevice();
    
        Sound fxWav = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
        Sound fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
    
        IntPtr music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
        PlayMusicStream(music);
    
        printf("\nPress s or d to play sounds...\n");
        //--------------------------------------------------------------------------------------
    
        // Main loop
        while (key != (int)Key.ESCAPE)
        {
            if (kbhit()) key = getch();
    
            if (key == 's')
            {
                PlaySound(fxWav);
                key = 0;
            }
    
            if (key == 'd')
            {
                PlaySound(fxOgg);
                key = 0;
            }
    
            UpdateMusicStream(music);
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadSound(fxWav);         // Unload sound data
        UnloadSound(fxOgg);         // Unload sound data
    
        UnloadMusicStream(music);   // Unload music stream data
    
        CloseAudioDevice();
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
        
+}

Examples/others/bunnymark.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   raylib example - Bunnymark
    *
    *   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) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const #define MAX_BUNNIES     100000       // 100K bunnies

    struct Bunny
{        public     Vector2 position;
    public     Vector2 speed;
    public     Color color;
    public } Bunny;
    
    public static int bunnymark()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 1280;
        int screenHeight = 960;
    
        InitWindow(screenWidth, screenHeight, "raylib example - Bunnymark");
    
        Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png");
    
        Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny));          // Bunnies array
    
        int bunniesCount = 0;    // Bunnies counter
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
            {
                // Create more bunnies
                for (int i = 0; i < 100; i++)
                {
                    bunnies[bunniesCount].position = GetMousePosition();
                    bunnies[bunniesCount].speed.x = (float)GetRandomValue(250, 500)/60.0f;
                    bunnies[bunniesCount].speed.y = (float)(GetRandomValue(250, 500) - 500)/60.0f;
                    bunniesCount++;
                }
            }
    
            // Update bunnies
            for (int i = 0; i < bunniesCount; i++)
            {
                bunnies[i].position.x += bunnies[i].speed.x;
                bunnies[i].position.y += bunnies[i].speed.y;
    
                if ((bunnies[i].position.x > GetScreenWidth()) || (bunnies[i].position.x < 0)) bunnies[i].speed.x *= -1;
                if ((bunnies[i].position.y > GetScreenHeight()) || (bunnies[i].position.y < 0)) bunnies[i].speed.y *= -1;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                for (int i = 0; i < bunniesCount; i++)
                {
                    // NOTE: When internal QUADS batch limit is reached, a draw call is launched and
                    // batching buffer starts being filled again; before launching the draw call,
                    // updated vertex data from internal buffer is send to GPU... it seems it generates
                    // a stall and consequently a frame drop, limiting number of bunnies drawn at 60 fps
                    DrawTexture(texBunny, bunnies[i].position.x, bunnies[i].position.y, RAYWHITE);
                }
    
                DrawRectangle(0, 0, screenWidth, 40, LIGHTGRAY);
                DrawText("raylib bunnymark", 10, 10, 20, DARKGRAY);
                DrawText(FormatText("bunnies: %i", bunniesCount), 400, 10, 20, RED);
                DrawFPS(260, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        free(bunnies);
    
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
        
+}

Examples/others/resources/shaders/glsl100/standard.fs

@@ -0,0 +1,152 @@
+#version 100
+
+precision mediump float;
+
+varying vec3 fragPosition;
+varying vec2 fragTexCoord;
+varying vec4 fragColor;
+varying vec3 fragNormal;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+
+uniform vec4 colAmbient;
+uniform vec4 colDiffuse;
+uniform vec4 colSpecular;
+uniform float glossiness;
+
+uniform int useNormal;
+uniform int useSpecular;
+
+uniform mat4 modelMatrix;
+uniform vec3 viewDir;
+
+struct Light {
+    int enabled;
+    int type;
+    vec3 position;
+    vec3 direction;
+    vec4 diffuse;
+    float intensity;
+    float radius;
+    float coneAngle;
+};
+
+const int maxLights = 8;
+uniform Light lights[maxLights];
+
+vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1.0));
+    vec3 surfaceToLight = l.position - surfacePos;
+    
+    // Diffuse shading
+    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
+    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(-l.direction + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    // Combine results
+    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 lightToSurface = normalize(surfacePos - l.position);
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Spot attenuation
+    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
+    attenuation = dot(lightToSurface, -lightDir);
+    
+    float lightToSurfaceAngle = degrees(acos(attenuation));
+    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
+    
+    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
+    
+    // Combine diffuse and attenuation
+    float diffAttenuation = diff*attenuation;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diffAttenuation > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
+}
+
+void main()
+{
+    // Calculate fragment normal in screen space
+    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
+    mat3 normalMatrix = mat3(modelMatrix);
+    vec3 normal = normalize(normalMatrix*fragNormal);
+
+    // Normalize normal and view direction vectors
+    vec3 n = normalize(normal);
+    vec3 v = normalize(viewDir);
+
+    // Calculate diffuse texture color fetching
+    vec4 texelColor = texture2D(texture0, fragTexCoord);
+    vec3 lighting = colAmbient.rgb;
+    
+    // Calculate normal texture color fetching or set to maximum normal value by default
+    if (useNormal == 1)
+    {
+        n *= texture2D(texture1, fragTexCoord).rgb;
+        n = normalize(n);
+    }
+    
+    // Calculate specular texture color fetching or set to maximum specular value by default
+    float spec = 1.0;
+    if (useSpecular == 1) spec = texture2D(texture2, fragTexCoord).r;
+    
+    for (int i = 0; i < maxLights; i++)
+    {
+        // Check if light is enabled
+        if (lights[i].enabled == 1)
+        {
+            // Calculate lighting based on light type
+            if(lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
+            else if(lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
+            else if(lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
+            
+            // NOTE: It seems that too many ComputeLight*() operations inside for loop breaks the shader on RPI
+        }
+    }
+    
+    // Calculate final fragment color
+    gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
+}

Examples/others/resources/shaders/glsl100/standard.vs

@@ -0,0 +1,23 @@
+#version 100
+
+attribute vec3 vertexPosition;
+attribute vec3 vertexNormal;
+attribute vec2 vertexTexCoord;
+attribute vec4 vertexColor;
+
+varying vec3 fragPosition;
+varying vec2 fragTexCoord;
+varying vec4 fragColor;
+varying vec3 fragNormal;
+
+uniform mat4 mvp;
+
+void main()
+{
+    fragPosition = vertexPosition;
+    fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
+    fragNormal = vertexNormal;
+
+    gl_Position = mvp*vec4(vertexPosition, 1.0);
+}

Examples/others/resources/shaders/glsl330/standard.fs

@@ -0,0 +1,150 @@
+#version 330
+
+in vec3 fragPosition;
+in vec2 fragTexCoord;
+in vec4 fragColor;
+in vec3 fragNormal;
+
+out vec4 finalColor;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+
+uniform vec4 colAmbient;
+uniform vec4 colDiffuse;
+uniform vec4 colSpecular;
+uniform float glossiness;
+
+uniform int useNormal;
+uniform int useSpecular;
+
+uniform mat4 modelMatrix;
+uniform vec3 viewDir;
+
+struct Light {
+    int enabled;
+    int type;
+    vec3 position;
+    vec3 direction;
+    vec4 diffuse;
+    float intensity;
+    float radius;
+    float coneAngle;
+};
+
+const int maxLights = 8;
+uniform Light lights[maxLights];
+
+vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 surfaceToLight = l.position - surfacePos;
+    
+    // Diffuse shading
+    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
+    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(-l.direction + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    // Combine results
+    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 lightToSurface = normalize(surfacePos - l.position);
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Spot attenuation
+    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
+    attenuation = dot(lightToSurface, -lightDir);
+    
+    float lightToSurfaceAngle = degrees(acos(attenuation));
+    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
+    
+    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
+    
+    // Combine diffuse and attenuation
+    float diffAttenuation = diff*attenuation;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diffAttenuation > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
+    }
+    
+    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
+}
+
+void main()
+{
+    // Calculate fragment normal in screen space
+    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
+    mat3 normalMatrix = mat3(modelMatrix);
+    vec3 normal = normalize(normalMatrix*fragNormal);
+
+    // Normalize normal and view direction vectors
+    vec3 n = normalize(normal);
+    vec3 v = normalize(viewDir);
+
+    // Calculate diffuse texture color fetching
+    vec4 texelColor = texture(texture0, fragTexCoord);
+    vec3 lighting = colAmbient.rgb;
+    
+    // Calculate normal texture color fetching or set to maximum normal value by default
+    if (useNormal == 1)
+    {
+        n *= texture(texture1, fragTexCoord).rgb;
+        n = normalize(n);
+    }
+    
+    // Calculate specular texture color fetching or set to maximum specular value by default
+    float spec = 1.0;
+    if (useSpecular == 1) spec = texture(texture2, fragTexCoord).r;
+    
+    for (int i = 0; i < maxLights; i++)
+    {
+        // Check if light is enabled
+        if (lights[i].enabled == 1)
+        {
+            // Calculate lighting based on light type
+            if (lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
+            else if (lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
+            else if (lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
+        }
+    }
+    
+    // Calculate final fragment color
+    finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
+}

Examples/others/resources/shaders/glsl330/standard.vs

@@ -0,0 +1,23 @@
+#version 330 
+
+in vec3 vertexPosition;
+in vec3 vertexNormal;
+in vec2 vertexTexCoord;
+in vec4 vertexColor;
+
+out vec3 fragPosition;
+out vec2 fragTexCoord;
+out vec4 fragColor;
+out vec3 fragNormal;
+
+uniform mat4 mvp;
+
+void main()
+{
+    fragPosition = vertexPosition;
+    fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
+    fragNormal = vertexNormal;
+
+    gl_Position = mvp*vec4(vertexPosition, 1.0);
+}