Merge branch 'master' into RicoP/ShaderUniformEnum

BINDINGS.md

@@ -85,6 +85,7 @@ Some people ported raylib to other languages in the form of bindings or wrappers
 | [raylib-cobol](https://codeberg.org/glowiak/raylib-cobol)                                | **auto**         | [COBOL](https://gnucobol.sourceforge.io)                             | Public domain        |
 | [raylib-apl](https://github.com/Brian-ED/raylib-apl)                                     | **5.0**          | [Dyalog APL](https://www.dyalog.com/)                                | MIT                  |
 | [raylib-jai](https://github.com/ahmedqarmout2/raylib-jai)                                | **5.5**          | [Jai](https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md)  | MIT                  |
+| [fnl-raylib](https://github.com/0riginaln0/fnl-raylib)                                   | **5.5**          | [Fennel](https://fennel-lang.org/)                                   | MIT                  |
 
 ### Utility Wrapers
 

examples/Makefile

@@ -54,10 +54,15 @@
 # Define target platform: PLATFORM_DESKTOP, PLATFORM_DESKTOP_SDL, PLATFORM_DRM, PLATFORM_ANDROID, PLATFORM_WEB
 PLATFORM              ?= PLATFORM_DESKTOP
 
-ifeq ($(PLATFORM), PLATFORM_DESKTOP)
+ifeq ($(PLATFORM),$(filter $(PLATFORM),PLATFORM_DESKTOP_GLFW PLATFORM_DESKTOP_SDL PLATFORM_DESKTOP_RGFW))
-    TARGET_PLATFORM = PLATFORM_DESKTOP_GLFW
+    TARGET_PLATFORM := $(PLATFORM)
+    override PLATFORM = PLATFORM_DESKTOP
 else
-    TARGET_PLATFORM = $(PLATFORM)
+    ifeq ($(PLATFORM), PLATFORM_DESKTOP)
+        TARGET_PLATFORM = PLATFORM_DESKTOP_GLFW
+    else
+        TARGET_PLATFORM = $(PLATFORM)
+    endif
 endif
 
 # Define required raylib variables

examples/core/core_input_virtual_controls.c

@@ -6,7 +6,8 @@
 *
 *   Example create by GreenSnakeLinux (@GreenSnakeLinux),
 *   lighter by oblerion (@oblerion) and 
-*   reviewed by Ramon Santamaria (@raysan5)
+*   reviewed by Ramon Santamaria (@raysan5) and
+*   improved by danilwhale (@danilwhale)
 *
 *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
 *   BSD-like license that allows static linking with closed source software
@@ -17,6 +18,16 @@
 
 #include "raylib.h"
 #include <math.h>
+
+typedef enum {
+    BUTTON_NONE = -1,
+    BUTTON_UP,
+    BUTTON_LEFT,
+    BUTTON_RIGHT,
+    BUTTON_DOWN,
+    BUTTON_MAX
+} PadButton;
+
 //------------------------------------------------------------------------------------
 // Program main entry point
 //------------------------------------------------------------------------------------
@@ -29,24 +40,38 @@ int main(void)
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input virtual controls");
 
-    const float dpadX = 90;
+    Vector2 padPosition = { 100, 350 };
-    const float dpadY = 300;
+    float buttonRadius = 30;
-    const float dpadRad = 25.0f;//radius of each pad
-    Color dpadColor = BLUE;
-    int dpadKeydown = -1;//-1 if not down, else 0,1,2,3 
 
-    
+    Vector2 buttonPositions[BUTTON_MAX] =
-    const float dpadCollider[4][2]= // collider array with x,y position
     {
-        {dpadX,dpadY-dpadRad*1.5f},//up
+        { padPosition.x,padPosition.y - buttonRadius*1.5f },  // Up
-        {dpadX-dpadRad*1.5f,dpadY},//left
+        { padPosition.x - buttonRadius*1.5f, padPosition.y }, // Left
-        {dpadX+dpadRad*1.5f,dpadY},//right
+        { padPosition.x + buttonRadius*1.5f, padPosition.y }, // Right
-        {dpadX,dpadY+dpadRad*1.5f}//down
+        { padPosition.x, padPosition.y + buttonRadius*1.5f }  // Down
     };
-    const char dpadLabel[4]="XYBA";//label of Dpad
 
-    float playerX=100;
+    const char *buttonLabels[BUTTON_MAX] =
-    float playerY=100;
+    {
+        "Y",    // Up
+        "X",    // Left
+        "B",    // Right
+        "A"     // Down
+    };
+
+    Color buttonLabelColors[BUTTON_MAX] =
+    {
+        YELLOW, // Up
+        BLUE,   // Left
+        RED,    // Right
+        GREEN   // Down
+    };
+
+    int pressedButton = BUTTON_NONE;
+    Vector2 inputPosition = { 0, 0 };
+
+    Vector2 playerPosition = { (float)screenWidth/2, (float)screenHeight/2 };
+    float playerSpeed = 75;
 
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
@@ -54,63 +79,89 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-    // Update 
+        // Update
-    //--------------------------------------------------------------------------
+        //--------------------------------------------------------------------------
-        dpadKeydown = -1; //reset
+        if ((GetTouchPointCount() > 0))
-        int inputX = 0;
+        {
-        int inputY = 0;
+            // Use touch position
-        if(GetTouchPointCount()>0)
+            inputPosition = GetTouchPosition(0);
-        {//use touch pos
-            inputX = GetTouchX();
-            inputY = GetTouchY();
         }
         else
-        {//use mouse pos
-            inputX = GetMouseX();
-            inputY = GetMouseY();
-        }
-        for(int i=0;i<4;i++)
         {
-            //test distance each collider and input < radius
+            // Use mouse position
-            if( fabsf(dpadCollider[i][1]-inputY) + fabsf(dpadCollider[i][0]-inputX) < dpadRad)
+            inputPosition = GetMousePosition();
-            {
-                dpadKeydown = i;
-                break;
-            }
         }
-        // move player
+
-        switch(dpadKeydown){
+        // Reset pressed button to none
-            case 0: playerY -= 50*GetFrameTime();
+        pressedButton = BUTTON_NONE;
-            break;
+
-            case 1: playerX -= 50*GetFrameTime();
+        // Make sure user is pressing left mouse button if they're from desktop
-            break;
+        if ((GetTouchPointCount() > 0) || ((GetTouchPointCount() == 0) && IsMouseButtonDown(MOUSE_BUTTON_LEFT)))
-            case 2: playerX += 50*GetFrameTime();
+        {
-            break;
+            // Find nearest D-Pad button to the input position
-            case 3: playerY += 50*GetFrameTime();
+            for (int i = 0; i < BUTTON_MAX; i++)
-            default:;
-        };
-    //--------------------------------------------------------------------------
-    // Draw 
-    //--------------------------------------------------------------------------
-       BeginDrawing();
-            ClearBackground(RAYWHITE);
-            for(int i=0;i<4;i++)
             {
-                //draw all pad
+                float distX = fabsf(buttonPositions[i].x - inputPosition.x);
-                DrawCircleV((Vector2) { dpadCollider[i][0], dpadCollider[i][1] }, dpadRad, dpadColor);
+                float distY = fabsf(buttonPositions[i].y - inputPosition.y);
-                if(i!=dpadKeydown)
+
+                if ((distX + distY < buttonRadius))
                 {
-                    //draw label
+                    pressedButton = i;
-                    DrawText(TextSubtext(dpadLabel,i,1),
+                    break;
-                             (int)dpadCollider[i][0]-7,
-                             (int)dpadCollider[i][1]-8,20,BLACK);
                 }
             }
+        }
+
+        // Move player according to pressed button
+        switch (pressedButton)
+        {
+            case BUTTON_UP:
+            {
+                playerPosition.y -= playerSpeed*GetFrameTime();
+                break;
+            }
+            case BUTTON_LEFT:
+            {
+                playerPosition.x -= playerSpeed*GetFrameTime();
+                break;
+            }
+            case BUTTON_RIGHT:
+            {
+                playerPosition.x += playerSpeed*GetFrameTime();
+                break;
+            }
+            case BUTTON_DOWN:
+            {
+                playerPosition.y += playerSpeed*GetFrameTime();
+                break;
+            }
+            default: break;
+        };
+
+        //--------------------------------------------------------------------------
+        // Draw
+        //--------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // Draw world
+            DrawCircleV(playerPosition, 50, MAROON);
+
+            // Draw GUI
+            for (int i = 0; i < BUTTON_MAX; i++)
+            {
+                DrawCircleV(buttonPositions[i], buttonRadius, (i == pressedButton)? DARKGRAY : BLACK);
+
+                DrawText(buttonLabels[i],
+                    (int)buttonPositions[i].x - 7, (int)buttonPositions[i].y - 8,
+                    20, buttonLabelColors[i]);
+            }
+
+            DrawText("move the player with D-Pad buttons", 10, 10, 20, DARKGRAY);
 
-            DrawRectangleRec((Rectangle) { playerX - 4, playerY - 4, 75, 28 }, RED);
-            DrawText("Player", (int)playerX, (int)playerY, 20, WHITE);
         EndDrawing();
-    //--------------------------------------------------------------------------
+        //--------------------------------------------------------------------------
     }
 
     // De-Initialization

examples/shaders/resources/shaders/glsl330/lighting_instancing.vs

@@ -25,7 +25,7 @@ void main()
     // Send vertex attributes to fragment shader
     fragPosition = vec3(instanceTransform*vec4(vertexPosition, 1.0));
     fragTexCoord = vertexTexCoord;
-    //fragColor = vertexColor;
+    fragColor = vec4(1.0);
     fragNormal = normalize(vec3(matNormal*vec4(vertexNormal, 1.0)));
 
     // Calculate final vertex position, note that we multiply mvp by instanceTransform

examples/shaders/shaders_mesh_instancing.c

@@ -61,7 +61,7 @@ int main(void)
     {
         Matrix translation = MatrixTranslate((float)GetRandomValue(-50, 50), (float)GetRandomValue(-50, 50), (float)GetRandomValue(-50, 50));
         Vector3 axis = Vector3Normalize((Vector3){ (float)GetRandomValue(0, 360), (float)GetRandomValue(0, 360), (float)GetRandomValue(0, 360) });
-        float angle = (float)GetRandomValue(0, 10)*DEG2RAD;
+        float angle = (float)GetRandomValue(0, 180)*DEG2RAD;
         Matrix rotation = MatrixRotate(axis, angle);
         
         transforms[i] = MatrixMultiply(rotation, translation);
@@ -73,7 +73,6 @@ int main(void)
     // Get shader locations
     shader.locs[SHADER_LOC_MATRIX_MVP] = GetShaderLocation(shader, "mvp");
     shader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shader, "viewPos");
-    shader.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocationAttrib(shader, "instanceTransform");
 
     // Set shader value: ambient light level
     int ambientLoc = GetShaderLocation(shader, "ambient");

parser/output/raylib_api.json

@@ -2543,6 +2543,11 @@
           "name": "SHADER_LOC_BONE_MATRICES",
           "value": 28,
           "description": "Shader location: array of matrices uniform: boneMatrices"
+        },
+        {
+          "name": "SHADER_LOC_VERTEX_INSTANCE_TX",
+          "value": 29,
+          "description": "Shader location: vertex attribute: instanceTransform"
         }
       ]
     },

parser/output/raylib_api.lua

@@ -2543,6 +2543,11 @@ return {
           name = "SHADER_LOC_BONE_MATRICES",
           value = 28,
           description = "Shader location: array of matrices uniform: boneMatrices"
+        },
+        {
+          name = "SHADER_LOC_VERTEX_INSTANCE_TX",
+          value = 29,
+          description = "Shader location: vertex attribute: instanceTransform"
         }
       }
     },

parser/output/raylib_api.txt

@@ -795,7 +795,7 @@ Enum 08: MaterialMapIndex (11 values)
   Value[MATERIAL_MAP_IRRADIANCE]: 8
   Value[MATERIAL_MAP_PREFILTER]: 9
   Value[MATERIAL_MAP_BRDF]: 10
-Enum 09: ShaderLocationIndex (29 values)
+Enum 09: ShaderLocationIndex (30 values)
   Name: ShaderLocationIndex
   Description: Shader location index
   Value[SHADER_LOC_VERTEX_POSITION]: 0

parser/output/raylib_api.xml

@@ -507,7 +507,7 @@
             <Value name="MATERIAL_MAP_PREFILTER" integer="9" desc="Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" />
             <Value name="MATERIAL_MAP_BRDF" integer="10" desc="Brdf material" />
         </Enum>
-        <Enum name="ShaderLocationIndex" valueCount="29" desc="Shader location index">
+        <Enum name="ShaderLocationIndex" valueCount="30" desc="Shader location index">
             <Value name="SHADER_LOC_VERTEX_POSITION" integer="0" desc="Shader location: vertex attribute: position" />
             <Value name="SHADER_LOC_VERTEX_TEXCOORD01" integer="1" desc="Shader location: vertex attribute: texcoord01" />
             <Value name="SHADER_LOC_VERTEX_TEXCOORD02" integer="2" desc="Shader location: vertex attribute: texcoord02" />
@@ -537,6 +537,7 @@
             <Value name="SHADER_LOC_VERTEX_BONEIDS" integer="26" desc="Shader location: vertex attribute: boneIds" />
             <Value name="SHADER_LOC_VERTEX_BONEWEIGHTS" integer="27" desc="Shader location: vertex attribute: boneWeights" />
             <Value name="SHADER_LOC_BONE_MATRICES" integer="28" desc="Shader location: array of matrices uniform: boneMatrices" />
+            <Value name="SHADER_LOC_VERTEX_INSTANCE_TX" integer="29" desc="Shader location: vertex attribute: instanceTransform" />
         </Enum>
         <Enum name="ShaderUniformDataType" valueCount="13" desc="Shader uniform data type">
             <Value name="SHADER_UNIFORM_FLOAT" integer="0" desc="Shader uniform type: float" />

src/config.h

@@ -151,6 +151,8 @@
     #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS     7
     #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
 #endif
+#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCE_TX 9
+
 
 // Default shader vertex attribute names to set location points
 // NOTE: When a new shader is loaded, the following locations are tried to be set for convenience

src/raylib.h

@@ -801,7 +801,8 @@ typedef enum {
     SHADER_LOC_MAP_BRDF,            // Shader location: sampler2d texture: brdf
     SHADER_LOC_VERTEX_BONEIDS,      // Shader location: vertex attribute: boneIds
     SHADER_LOC_VERTEX_BONEWEIGHTS,  // Shader location: vertex attribute: boneWeights
-    SHADER_LOC_BONE_MATRICES        // Shader location: array of matrices uniform: boneMatrices
+    SHADER_LOC_BONE_MATRICES,       // Shader location: array of matrices uniform: boneMatrices
+    SHADER_LOC_VERTEX_INSTANCE_TX   // Shader location: vertex attribute: instanceTransform
 } ShaderLocationIndex;
 
 #define SHADER_LOC_MAP_DIFFUSE      SHADER_LOC_MAP_ALBEDO

src/rcore.c

@@ -1346,6 +1346,7 @@ Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode)
         shader.locs[SHADER_LOC_VERTEX_COLOR] = rlGetLocationAttrib(shader.id, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
         shader.locs[SHADER_LOC_VERTEX_BONEIDS] = rlGetLocationAttrib(shader.id, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS);
         shader.locs[SHADER_LOC_VERTEX_BONEWEIGHTS] = rlGetLocationAttrib(shader.id, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS);
+        shader.locs[SHADER_LOC_VERTEX_INSTANCE_TX] = rlGetLocationAttrib(shader.id, RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCE_TX);
 
         // Get handles to GLSL uniform locations (vertex shader)
         shader.locs[SHADER_LOC_MATRIX_MVP] = rlGetLocationUniform(shader.id, RL_DEFAULT_SHADER_UNIFORM_NAME_MVP);

src/rlgl.h

@@ -355,6 +355,9 @@
     #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
 #endif
 #endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCE_TX
+    #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCE_TX 9
+#endif
 
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
@@ -998,6 +1001,9 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
     #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
 #endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCE_TX
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCE_TX  "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCE_TX
+#endif
 
 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
     #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
@@ -4216,6 +4222,7 @@ unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId)
     glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
     glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
     glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
+    glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCE_TX, RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCE_TX);
 
 #ifdef RL_SUPPORT_MESH_GPU_SKINNING
     glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS);

src/rmodels.c

@@ -1734,12 +1734,12 @@ void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, i
     // no faster, since we're transferring all the transform matrices anyway
     instancesVboId = rlLoadVertexBuffer(instanceTransforms, instances*sizeof(float16), false);
 
-    // Instances transformation matrices are send to shader attribute location: SHADER_LOC_MATRIX_MODEL
+    // Instances transformation matrices are sent to shader attribute location: SHADER_LOC_VERTEX_INSTANCE_TX
     for (unsigned int i = 0; i < 4; i++)
     {
-        rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i);
+        rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_INSTANCE_TX] + i);
-        rlSetVertexAttribute(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i, 4, RL_FLOAT, 0, sizeof(Matrix), i*sizeof(Vector4));
+        rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_INSTANCE_TX] + i, 4, RL_FLOAT, 0, sizeof(Matrix), i*sizeof(Vector4));
-        rlSetVertexAttributeDivisor(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i, 1);
+        rlSetVertexAttributeDivisor(material.shader.locs[SHADER_LOC_VERTEX_INSTANCE_TX] + i, 1);
     }
 
     rlDisableVertexBuffer();