Synced with raylib latest, and fixed build

build.zig

@@ -10,7 +10,7 @@ pub fn build(b: *std.Build) !void {
     const jsons = b.step("parse", "parse raylib headers and generate raylib jsons");
     const raylib_parser_build = b.addExecutable(.{
         .name = "raylib_parser",
-        .root_source_file = std.build.FileSource.relative("raylib_parser.zig"),
+        .root_source_file = std.Build.LazyPath.relative("raylib_parser.zig"),
         .target = target,
         .optimize = .ReleaseFast,
     });
@@ -51,7 +51,7 @@ pub fn build(b: *std.Build) !void {
     const intermediate = b.step("intermediate", "generate intermediate representation of the results from 'zig build parse' (keep custom=true)");
     var intermediateZigStep = b.addRunArtifact(b.addExecutable(.{
         .name = "intermediate",
-        .root_source_file = std.build.FileSource.relative("intermediate.zig"),
+        .root_source_file = std.Build.LazyPath.relative("intermediate.zig"),
         .target = target,
     }));
     intermediate.dependOn(&intermediateZigStep.step);
@@ -60,7 +60,7 @@ pub fn build(b: *std.Build) !void {
     const bindings = b.step("bindings", "generate bindings in from bindings.json");
     var generateZigStep = b.addRunArtifact(b.addExecutable(.{
         .name = "generate",
-        .root_source_file = std.build.FileSource.relative("generate.zig"),
+        .root_source_file = std.Build.LazyPath.relative("generate.zig"),
         .target = target,
     }));
     const fmt = b.addFmt(.{ .paths = &.{generate.outputFile} });
@@ -87,27 +87,37 @@ const dir_raylib = cwd ++ sep ++ "raylib" ++ sep ++ "src";
 const raylib_build = @import("raylib/src/build.zig");
 
 fn linkThisLibrary(b: *std.Build, target: std.Target.Query, optimize: std.builtin.Mode) *std.Build.Step.Compile {
-    const lib = b.addStaticLibrary(.{ .name = "raylib.zig", .target = b.resolveTargetQuery(target), .optimize = optimize });
+    const lib = b.addStaticLibrary(
+        .{
+            .name = "raylib.zig",
+            .target = b.resolveTargetQuery(target),
+            .optimize = optimize,
+            .root_source_file = .{ .path = cwd ++ sep ++ "raylib.zig" },
+        },
+    );
+    lib.linkLibC();
     lib.addIncludePath(.{ .path = dir_raylib });
     lib.addIncludePath(.{ .path = cwd });
-    lib.linkLibC();
     lib.addCSourceFile(.{ .file = .{ .path = cwd ++ sep ++ "marshal.c" }, .flags = &.{} });
-    std.log.info("include '{s}' to {s}", .{ dir_raylib, lib.name });
-    std.log.info("include '{s}' to {s}", .{ cwd, lib.name });
+    std.log.debug("include '{s}' to {s}", .{ dir_raylib, lib.name });
+    std.log.debug("include '{s}' to {s}", .{ cwd, lib.name });
     return lib;
 }
 
 /// add this package to exe
 pub fn addTo(b: *std.Build, exe: *std.Build.Step.Compile, target: std.Target.Query, optimize: std.builtin.Mode, raylibOptions: raylib_build.Options) void {
-    exe.root_module.addAnonymousImport("raylib", .{ .root_source_file = .{ .path = cwd ++ sep ++ "raylib.zig" } });
-    std.log.info("include '{s}' to {s}", .{ dir_raylib, exe.name });
-    std.log.info("include '{s}' to {s}", .{ cwd, exe.name });
-    exe.addIncludePath(.{ .path = dir_raylib });
-    exe.addIncludePath(.{ .path = cwd });
+    const lib_raylib = raylib_build.addRaylib(
+        b,
+        b.resolveTargetQuery(target),
+        optimize,
+        raylibOptions,
+    ) catch |err| std.debug.panic("addRaylib: {any}", .{err});
+
     const lib = linkThisLibrary(b, target, optimize);
-    const lib_raylib = raylib_build.addRaylib(b, b.resolveTargetQuery(target), optimize, raylibOptions) catch |err| std.debug.panic("addRaylib: {any}", .{err});
+
+    exe.root_module.addImport("raylib", &lib.root_module);
+
     exe.linkLibrary(lib_raylib);
-    exe.linkLibrary(lib);
     std.log.info("linked raylib.zig", .{});
 }
 

generate.zig

@@ -176,7 +176,7 @@ fn writeFunctions(
 
         //--- body ------------------------------
         if (isPointer(func.returnType)) {
-            try file.writeAll(try allocPrint(allocator, "return @ptrCast({s},\n", .{func.returnType}));
+            try file.writeAll(try allocPrint(allocator, "return @as({s},@ptrCast(\n", .{func.returnType}));
         } else if (isPrimitiveOrPointer(func.returnType)) {
             try file.writeAll("return ");
         } else if (!returnTypeIsVoid) {
@@ -186,36 +186,36 @@ fn writeFunctions(
 
         if (!isPrimitiveOrPointer(func.returnType)) {
             if (bindings.containsStruct(stripType(func.returnType))) {
-                try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]raylib.{s}, &out),\n", .{func.returnType}));
+                try file.writeAll(try allocPrint(allocator, "@as([*c]raylib.{s}, @ptrCast(&out)),\n", .{func.returnType}));
             } else if (!returnTypeIsVoid) {
-                try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]{s}, &out),\n", .{func.returnType}));
+                try file.writeAll(try allocPrint(allocator, "@as([*c]{s}, @ptrCast(&out)),\n", .{func.returnType}));
             }
         }
 
         for (func.params) |param| {
             if (isFunctionPointer(param.typ)) {
                 try file.writeAll(try allocPrint(allocator, "@ptrCast({s}),\n", .{param.name}));
             } else if (bindings.containsStruct(stripType(param.typ)) and isPointer(param.typ)) {
-                try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]raylib.{s}, @ptrToInt({s})),\n", .{ stripType(param.typ), param.name }));
+                try file.writeAll(try allocPrint(allocator, "@as([*c]raylib.{s}, @ptrFromInt(@intFromPtr({s}))),\n", .{ stripType(param.typ), param.name }));
             } else if (bindings.containsEnum(param.typ)) {
-                try file.writeAll(try allocPrint(allocator, "@enumToInt({s}),\n", .{param.name}));
+                try file.writeAll(try allocPrint(allocator, "@intFromEnum({s}),\n", .{param.name}));
             } else if (bindings.containsStruct(stripType(param.typ))) {
-                try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]raylib.{s}, @ptrToInt(&{s})),\n", .{ stripType(param.typ), param.name }));
+                try file.writeAll(try allocPrint(allocator, "@as([*c]raylib.{s}, @ptrFromInt(@intFromPtr(&{s}))),\n", .{ stripType(param.typ), param.name }));
             } else if (isPointer(param.typ)) {
                 if (std.mem.endsWith(u8, param.typ, "anyopaque")) {
                     try file.writeAll(try allocPrint(allocator, "{s},\n", .{param.name}));
                 } else if (isConst(param.typ)) {
-                    try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]const {s}, @ptrToInt({s})),\n", .{ stripType(param.typ), param.name }));
+                    try file.writeAll(try allocPrint(allocator, "@as([*c]const {s}, @ptrFromInt(@intFromPtr({s}))),\n", .{ stripType(param.typ), param.name }));
                 } else {
-                    try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]{s}, {s}),\n", .{ stripType(param.typ), param.name }));
+                    try file.writeAll(try allocPrint(allocator, "@as([*c]{s}, @ptrCast({s})),\n", .{ stripType(param.typ), param.name }));
                 }
             } else {
                 try file.writeAll(try allocPrint(allocator, "{s},\n", .{param.name}));
             }
         }
 
         if (isPointer(func.returnType)) {
-            try file.writeAll("),\n);\n");
+            try file.writeAll("),\n));\n");
         } else {
             try file.writeAll(");\n");
         }

marshal.c

@@ -413,39 +413,44 @@ void mUnloadShader(Shader *shader)
 	UnloadShader(*shader);
 }
 
-void mGetMouseRay(Ray *out, Vector2 *mousePosition, Camera3D *camera)
+void mGetScreenToWorldRay(Ray *out, Vector2 *position, Camera3D *camera)
 {
-	*out = GetMouseRay(*mousePosition, *camera);
+	*out = GetScreenToWorldRay(*position, *camera);
 }
 
-void mGetCameraMatrix(Matrix *out, Camera3D *camera)
+void mGetScreenToWorldRayEx(Ray *out, Vector2 *position, Camera3D *camera, float width, float height)
 {
-	*out = GetCameraMatrix(*camera);
+	*out = GetScreenToWorldRayEx(*position, *camera, width, height);
 }
 
-void mGetCameraMatrix2D(Matrix *out, Camera2D *camera)
+void mGetWorldToScreen(Vector2 *out, Vector3 *position, Camera3D *camera)
 {
-	*out = GetCameraMatrix2D(*camera);
+	*out = GetWorldToScreen(*position, *camera);
 }
 
-void mGetWorldToScreen(Vector2 *out, Vector3 *position, Camera3D *camera)
+void mGetWorldToScreenEx(Vector2 *out, Vector3 *position, Camera3D *camera, int width, int height)
 {
-	*out = GetWorldToScreen(*position, *camera);
+	*out = GetWorldToScreenEx(*position, *camera, width, height);
+}
+
+void mGetWorldToScreen2D(Vector2 *out, Vector2 *position, Camera2D *camera)
+{
+	*out = GetWorldToScreen2D(*position, *camera);
 }
 
 void mGetScreenToWorld2D(Vector2 *out, Vector2 *position, Camera2D *camera)
 {
 	*out = GetScreenToWorld2D(*position, *camera);
 }
 
-void mGetWorldToScreenEx(Vector2 *out, Vector3 *position, Camera3D *camera, int width, int height)
+void mGetCameraMatrix(Matrix *out, Camera3D *camera)
 {
-	*out = GetWorldToScreenEx(*position, *camera, width, height);
+	*out = GetCameraMatrix(*camera);
 }
 
-void mGetWorldToScreen2D(Vector2 *out, Vector2 *position, Camera2D *camera)
+void mGetCameraMatrix2D(Matrix *out, Camera2D *camera)
 {
-	*out = GetWorldToScreen2D(*position, *camera);
+	*out = GetCameraMatrix2D(*camera);
 }
 
 void mSetTargetFPS(int fps)
@@ -808,6 +813,11 @@ int mSetGamepadMappings(const char * mappings)
 	return SetGamepadMappings(mappings);
 }
 
+void mSetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
+{
+	SetGamepadVibration(gamepad, leftMotor, rightMotor);
+}
+
 bool mIsMouseButtonPressed(int button)
 {
 	return IsMouseButtonPressed(button);
@@ -1733,6 +1743,11 @@ void mDrawTextureNPatch(Texture2D *texture, NPatchInfo *nPatchInfo, Rectangle *d
 	DrawTextureNPatch(*texture, *nPatchInfo, *dest, *origin, rotation, *tint);
 }
 
+bool mColorIsEqual(Color *col1, Color *col2)
+{
+	return ColorIsEqual(*col1, *col2);
+}
+
 void mFade(Color *out, Color *color, float alpha)
 {
 	*out = Fade(*color, alpha);
@@ -2918,6 +2933,11 @@ void mrlDisableFramebuffer(void)
 	rlDisableFramebuffer();
 }
 
+unsigned int mrlGetActiveFramebuffer(void)
+{
+	return rlGetActiveFramebuffer();
+}
+
 void mrlActiveDrawBuffers(int count)
 {
 	rlActiveDrawBuffers(count);
@@ -3288,9 +3308,9 @@ unsigned char * mrlReadScreenPixels(int width, int height)
 	return rlReadScreenPixels(width, height);
 }
 
-unsigned int mrlLoadFramebuffer(int width, int height)
+unsigned int mrlLoadFramebuffer(void)
 {
-	return rlLoadFramebuffer(width, height);
+	return rlLoadFramebuffer();
 }
 
 void mrlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel)
@@ -3598,6 +3618,16 @@ void mVector2Reflect(Vector2 *out, Vector2 *v, Vector2 *normal)
 	*out = Vector2Reflect(*v, *normal);
 }
 
+void mVector2Min(Vector2 *out, Vector2 *v1, Vector2 *v2)
+{
+	*out = Vector2Min(*v1, *v2);
+}
+
+void mVector2Max(Vector2 *out, Vector2 *v1, Vector2 *v2)
+{
+	*out = Vector2Max(*v1, *v2);
+}
+
 void mVector2Rotate(Vector2 *out, Vector2 *v, float angle)
 {
 	*out = Vector2Rotate(*v, angle);
@@ -3628,6 +3658,11 @@ int mVector2Equals(Vector2 *p, Vector2 *q)
 	return Vector2Equals(*p, *q);
 }
 
+void mVector2Refract(Vector2 *out, Vector2 *v, Vector2 *n, float r)
+{
+	*out = Vector2Refract(*v, *n, r);
+}
+
 void mVector3Zero(Vector3 *out)
 {
 	*out = Vector3Zero();
@@ -3753,6 +3788,11 @@ void mVector3RotateByAxisAngle(Vector3 *out, Vector3 *v, Vector3 *axis, float an
 	*out = Vector3RotateByAxisAngle(*v, *axis, angle);
 }
 
+void mVector3MoveTowards(Vector3 *out, Vector3 *v, Vector3 *target, float maxDistance)
+{
+	*out = Vector3MoveTowards(*v, *target, maxDistance);
+}
+
 void mVector3Lerp(Vector3 *out, Vector3 *v1, Vector3 *v2, float amount)
 {
 	*out = Vector3Lerp(*v1, *v2, amount);
@@ -3813,6 +3853,116 @@ void mVector3Refract(Vector3 *out, Vector3 *v, Vector3 *n, float r)
 	*out = Vector3Refract(*v, *n, r);
 }
 
+void mVector4Zero(Vector4 *out)
+{
+	*out = Vector4Zero();
+}
+
+void mVector4One(Vector4 *out)
+{
+	*out = Vector4One();
+}
+
+void mVector4Add(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Add(*v1, *v2);
+}
+
+void mVector4AddValue(Vector4 *out, Vector4 *v, float add)
+{
+	*out = Vector4AddValue(*v, add);
+}
+
+void mVector4Subtract(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Subtract(*v1, *v2);
+}
+
+void mVector4SubtractValue(Vector4 *out, Vector4 *v, float add)
+{
+	*out = Vector4SubtractValue(*v, add);
+}
+
+float mVector4Length(Vector4 *v)
+{
+	return Vector4Length(*v);
+}
+
+float mVector4LengthSqr(Vector4 *v)
+{
+	return Vector4LengthSqr(*v);
+}
+
+float mVector4DotProduct(Vector4 *v1, Vector4 *v2)
+{
+	return Vector4DotProduct(*v1, *v2);
+}
+
+float mVector4Distance(Vector4 *v1, Vector4 *v2)
+{
+	return Vector4Distance(*v1, *v2);
+}
+
+float mVector4DistanceSqr(Vector4 *v1, Vector4 *v2)
+{
+	return Vector4DistanceSqr(*v1, *v2);
+}
+
+void mVector4Scale(Vector4 *out, Vector4 *v, float scale)
+{
+	*out = Vector4Scale(*v, scale);
+}
+
+void mVector4Multiply(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Multiply(*v1, *v2);
+}
+
+void mVector4Negate(Vector4 *out, Vector4 *v)
+{
+	*out = Vector4Negate(*v);
+}
+
+void mVector4Divide(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Divide(*v1, *v2);
+}
+
+void mVector4Normalize(Vector4 *out, Vector4 *v)
+{
+	*out = Vector4Normalize(*v);
+}
+
+void mVector4Min(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Min(*v1, *v2);
+}
+
+void mVector4Max(Vector4 *out, Vector4 *v1, Vector4 *v2)
+{
+	*out = Vector4Max(*v1, *v2);
+}
+
+void mVector4Lerp(Vector4 *out, Vector4 *v1, Vector4 *v2, float amount)
+{
+	*out = Vector4Lerp(*v1, *v2, amount);
+}
+
+void mVector4MoveTowards(Vector4 *out, Vector4 *v, Vector4 *target, float maxDistance)
+{
+	*out = Vector4MoveTowards(*v, *target, maxDistance);
+}
+
+void mVector4Invert(Vector4 *out, Vector4 *v)
+{
+	*out = Vector4Invert(*v);
+}
+
+int mVector4Equals(Vector4 *p, Vector4 *q)
+{
+	return Vector4Equals(*p, *q);
+}
+
 float mMatrixDeterminant(Matrix *mat)
 {
 	return MatrixDeterminant(*mat);