Update bindings to r3d v0.9.1

- Regenerated bindings: GenMeshCylinder simplified, GenMeshCylinderEx added,
  shader alias functions, ShaderCustom opaque type, EnvDoF.NearScale field
- Generator: support typedef aliases for opaque struct types, skip unused
  System.Text import for opaque types
- TypeMapper: recursive opaque type detection through typedef chains
- Examples: spawn child process per example to avoid rlgl state leakage
  between sequential runs (see #1)

Author: graphnode

Examples/Decal.cs

@@ -20,7 +20,7 @@ public static int Main()
         // Create meshes
         var plane = R3D.GenMeshPlane(5.0f, 5.0f, 1, 1);
         var sphere = R3D.GenMeshSphere(0.5f, 64, 64);
-        var cylinder = R3D.GenMeshCylinder(0.5f, 0.5f, 1, 64);
+        var cylinder = R3D.GenMeshCylinder(0.5f, 1, 64);
         var material = R3D.GetDefaultMaterial();
         material.Albedo.Color = Color.Gray;
 

Examples/Program.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Diagnostics;
+using System.Linq;
 using Raylib_cs;
 
 namespace Examples;
@@ -52,22 +54,24 @@ private static unsafe void Main(string[] args)
     {
         Raylib.SetTraceLogCallback(&Logging.LogConsole);
 
-        if (args.Length > 0)
+        var examples = args.Length > 0
+            ? args.Select(ExampleList.GetExample).Where(e => e != null).ToArray()
+            : ExampleList.AllExamples;
+
+        if (examples.Length <= 1)
         {
-            var example = ExampleList.GetExample(args[0]);
-            example?.Main.Invoke();
+            examples.FirstOrDefault()?.Main.Invoke();
+            return;
         }
-        else
-            RunExamples(ExampleList.AllExamples);
-    }
 
-    private static void RunExamples(ExampleInfo[] examples)
-    {
-        var configFlags = Enum.GetValues<ConfigFlags>();
+        var exe = Environment.ProcessPath!;
         foreach (var example in examples)
         {
-            example.Main.Invoke();
-            foreach (var flag in configFlags) Raylib.ClearWindowState(flag);
+            var process = Process.Start(new ProcessStartInfo(exe, example.Name)
+            {
+                UseShellExecute = false
+            })!;
+            process.WaitForExit();
         }
     }
 }

External/r3d

@@ -224,16 +224,19 @@ private int GenerateStructsFiles(CppCompilation compilation)
             if (@class.ClassKind is not (CppClassKind.Struct or CppClassKind.Union))
                 throw new Exception($"Unexpected class kind: {@class.ClassKind}");
 
+            bool isOpaque = TypeMapper.OpaqueTypes.Contains(@class.Name);
+
             var sb = new StringBuilder();
-            GenerateHeader(sb, ["System", "System.Numerics", "System.Runtime.InteropServices", "System.Text", "Raylib_cs"]);
+            var usings = isOpaque
+                ? new List<string> { "System", "System.Numerics", "System.Runtime.InteropServices", "Raylib_cs" }
+                : new List<string> { "System", "System.Numerics", "System.Runtime.InteropServices", "System.Text", "Raylib_cs" };
+            GenerateHeader(sb, usings);
 
             string className = StripR3DPrefix(@class.Name);
             bool needsUnsafe = @class.Fields.Select(f => MapType(f.Type)).Any(r => r.isUnsafe);
 
             CommentGenerator.Generate(sb, @class.Comment, @class.Name);
 
-            bool isOpaque = TypeMapper.OpaqueTypes.Contains(@class.Name);
-
             sb.AppendLine("[StructLayout(LayoutKind.Sequential)]");
             sb.Append($"public {(needsUnsafe ? "unsafe " : "")}struct {className}");
             sb.AppendLine();
@@ -434,6 +437,25 @@ private int GenerateMiscFiles(CppCompilation compilation)
                 continue;
             }
 
+            // Typedef aliases for opaque struct types (e.g., typedef struct R3D_ShaderCustom R3D_ScreenShader)
+            if (typedef.ElementType is CppClass aliasedClass && TypeMapper.OpaqueTypes.Contains(aliasedClass.Name))
+            {
+                var sb = new StringBuilder();
+                GenerateHeader(sb, ["System", "System.Numerics", "System.Runtime.InteropServices", "Raylib_cs"]);
+
+                CommentGenerator.Generate(sb, typedef.Comment, typedef.Name);
+
+                sb.AppendLine("[StructLayout(LayoutKind.Sequential)]");
+                sb.AppendLine($"public struct {name}");
+                sb.AppendLine("{");
+                sb.AppendLine("    private nint _handle;");
+                sb.AppendLine("}");
+
+                File.WriteAllText(Path.Combine(outputDir, "types", $"{name}.g.cs"), sb.ToString());
+                count++;
+                continue;
+            }
+
             // Check for macro-based enums
             bool isBitflag = name.EndsWith("Flags");
             string enumName = isBitflag ? name[..^5] : name;

R3D-cs.GenerateBindings/CodeGenerator.cs

@@ -95,7 +95,7 @@ private static bool IsOpaqueType(CppType type)
         return unwrapped switch
         {
             CppClass cls => OpaqueTypes.Contains(cls.Name),
-            CppTypedef td => OpaqueTypes.Contains(td.Name),
+            CppTypedef td => OpaqueTypes.Contains(td.Name) || IsOpaqueType(td.ElementType),
             _ => false
         };
     }

R3D-cs.GenerateBindings/TypeMapper.cs

@@ -24,7 +24,7 @@ public static unsafe partial class R3D
     /// </summary>
     public const string NativeLibName = "r3d";
 
-    public const string R3D_VERSION = "0.9.0";
+    public const string R3D_VERSION = "0.9.1";
 
     /// <summary>
     /// Initializes the rendering engine.

R3D-cs/interop/R3D.core.g.cs

@@ -171,16 +171,32 @@ public static unsafe partial class R3D
     /// <summary>
     /// Generate a cylinder mesh.
     /// </summary>
-    /// <param name="bottomRadius">Bottom radius.</param>
-    /// <param name="topRadius">Top radius.</param>
+    /// <param name="radius">Radius of the cylinder.</param>
     /// <param name="height">Height along Y axis.</param>
     /// <param name="slices">Radial subdivisions.</param>
     /// <returns>Mesh ready for rendering.</returns>
     /// <remarks>
     /// Native: <c>R3D_GenMeshCylinder</c>
     /// </remarks>
     [LibraryImport(NativeLibName, EntryPoint = "R3D_GenMeshCylinder")]
-    public static partial Mesh GenMeshCylinder(float bottomRadius, float topRadius, float height, int slices);
+    public static partial Mesh GenMeshCylinder(float radius, float height, int slices);
+
+    /// <summary>
+    /// Generate a cylinder, cone or truncated cone mesh.
+    /// </summary>
+    /// <param name="bottomRadius">Bottom radius.</param>
+    /// <param name="topRadius">Top radius.</param>
+    /// <param name="height">Height along Y axis.</param>
+    /// <param name="slices">Radial subdivisions.</param>
+    /// <param name="stacks">Vertical subdivisions.</param>
+    /// <param name="bottomCap">Generate bottom cap.</param>
+    /// <param name="topCap">Generate top cap.</param>
+    /// <returns>Mesh ready for rendering.</returns>
+    /// <remarks>
+    /// Native: <c>R3D_GenMeshCylinderEx</c>
+    /// </remarks>
+    [LibraryImport(NativeLibName, EntryPoint = "R3D_GenMeshCylinderEx")]
+    public static partial Mesh GenMeshCylinderEx(float bottomRadius, float topRadius, float height, int slices, int stacks, [MarshalAs(UnmanagedType.I1)] bool bottomCap, [MarshalAs(UnmanagedType.I1)] bool topCap);
 
     /// <summary>
     /// Generate a capsule mesh.

R3D-cs/interop/R3D.mesh.g.cs

@@ -18,14 +18,26 @@ public static unsafe partial class R3D
 {
 
     /// <summary>
-    /// Creates an empty mesh data container.
+    /// Allocates a mesh data container with the given capacity.
     /// <para>
-    /// Allocates memory for vertex and index buffers. All allocated buffers are zero-initialized.
+    /// This function allocates CPU-side buffers for vertices and indices, but does NOT initialize the mesh with any actual data. The returned R3D_MeshData has:
+    /// </para>
+    /// <para>
+    /// <list type="bullet">
+    /// <item><description>vertexCapacity and indexCapacity set to the requested sizes</description></item>
+    /// <item><description>vertexCount and indexCount set to 0</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// You must manually set vertexCount/indexCount after filling the buffers, or use helper functions like R3D_AppendMeshData() to populate the mesh.
+    /// </para>
+    /// <para>
+    /// All allocated memory is zero-initialized.
     /// </para>
     /// </summary>
-    /// <param name="vertexCount">Number of vertices to allocate. Must be non-zero.</param>
-    /// <param name="indexCount">Number of indices to allocate. May be zero. If zero, no index buffer is allocated.</param>
-    /// <returns>A new R3D_MeshData instance with allocated memory.</returns>
+    /// <param name="vertexCount">Number of vertices to allocate (capacity). Must be &gt; 0.</param>
+    /// <param name="indexCount">Number of indices to allocate (capacity). May be 0. If 0, no index buffer is allocated.</param>
+    /// <returns>A new R3D_MeshData with allocated buffers and zero element counts.</returns>
     /// <remarks>
     /// Native: <c>R3D_LoadMeshData</c>
     /// </remarks>
@@ -195,21 +207,40 @@ public static unsafe partial class R3D
     public static partial MeshData GenMeshDataHemiSphere(float radius, int rings, int slices);
 
     /// <summary>
-    /// Generate a cylinder mesh with specified parameters.
+    /// Generates a cylinder mesh centered at the origin along the Y axis.
     /// <para>
-    /// Creates a mesh centered at the origin, extending along the Y axis. The mesh includes top and bottom caps and smooth side surfaces. A cone is produced when bottomRadius and topRadius differ.
+    /// Both caps are included. For a cone or truncated cone, use R3D_GenMeshDataCylinderEx.
     /// </para>
     /// </summary>
-    /// <param name="bottomRadius">Radius of the bottom cap.</param>
-    /// <param name="topRadius">Radius of the top cap.</param>
-    /// <param name="height">Height of the shape along the Y axis.</param>
-    /// <param name="slices">Number of radial subdivisions around the shape.</param>
-    /// <returns>Generated mesh structure.</returns>
+    /// <param name="radius">Radius of the cylinder. Must be &gt; 0.</param>
+    /// <param name="height">Total height along the Y axis. Must be &gt; 0.</param>
+    /// <param name="slices">Radial subdivisions around the circumference. Must be &gt;= 3.</param>
+    /// <returns>The generated mesh data, or an empty mesh on invalid input.</returns>
     /// <remarks>
     /// Native: <c>R3D_GenMeshDataCylinder</c>
     /// </remarks>
     [LibraryImport(NativeLibName, EntryPoint = "R3D_GenMeshDataCylinder")]
-    public static partial MeshData GenMeshDataCylinder(float bottomRadius, float topRadius, float height, int slices);
+    public static partial MeshData GenMeshDataCylinder(float radius, float height, int slices);
+
+    /// <summary>
+    /// Generates a cylinder, cone, or truncated cone mesh centered at the origin along the Y axis.
+    /// <para>
+    /// The bottom cap sits at Y = -height/2 and the top cap at Y = +height/2. Setting one radius to 0 produces a cone; caps can be toggled independently.
+    /// </para>
+    /// </summary>
+    /// <param name="bottomRadius">Radius of the bottom end. Must be &gt;= 0. Cannot both be 0.</param>
+    /// <param name="topRadius">Radius of the top end. Must be &gt;= 0. Cannot both be 0.</param>
+    /// <param name="height">Total height along the Y axis. Must be &gt; 0.</param>
+    /// <param name="slices">Radial subdivisions around the circumference. Must be &gt;= 3.</param>
+    /// <param name="stacks">Vertical subdivisions along the height. Must be &gt;= 1. Higher values reduce faceting, especially on cones.</param>
+    /// <param name="bottomCap">Whether to generate the bottom cap.</param>
+    /// <param name="topCap">Whether to generate the top cap.</param>
+    /// <returns>The generated mesh data, or an empty mesh on invalid input.</returns>
+    /// <remarks>
+    /// Native: <c>R3D_GenMeshDataCylinderEx</c>
+    /// </remarks>
+    [LibraryImport(NativeLibName, EntryPoint = "R3D_GenMeshDataCylinderEx")]
+    public static partial MeshData GenMeshDataCylinderEx(float bottomRadius, float topRadius, float height, int slices, int stacks, [MarshalAs(UnmanagedType.I1)] bool bottomCap, [MarshalAs(UnmanagedType.I1)] bool topCap);
 
     /// <summary>
     /// Generate a capsule mesh with specified parameters.

R3D-cs/interop/R3D.mesh_data.g.cs

@@ -45,8 +45,29 @@ public static unsafe partial class R3D
     [LibraryImport(NativeLibName, EntryPoint = "R3D_LoadScreenShaderFromMemory", StringMarshalling = StringMarshalling.Utf8)]
     public static partial ScreenShader LoadScreenShaderFromMemory(string code);
 
+    /// <summary>
+    /// Creates an alias of an existing screen shader.
+    /// <para>
+    /// The alias shares the same compiled program as the original but holds its own independent uniform and sampler state. Typical use cases include pre-configuring aliases for distinct effects (e.g. different convolution kernels), or running the same shader multiple times in a post-process chain with different parameters at each pass.
+    /// </para>
+    /// <para>
+    /// Uniform and sampler state is copied from the original at the moment this function is called, not from the shader source defaults. Any values set on the original after compilation but before this call will be reflected in the alias; values set afterward will not.
+    /// </para>
+    /// </summary>
+    /// <param name="shader">The original screen shader to alias.</param>
+    /// <returns>Pointer to the alias, or NULL on failure.</returns>
+    /// <remarks>
+    /// The alias does not own the program. Always unload all aliases before unloading the original, or the alias program references become dangling.
+    /// Native: <c>R3D_LoadScreenShaderAlias</c>
+    /// </remarks>
+    [LibraryImport(NativeLibName, EntryPoint = "R3D_LoadScreenShaderAlias")]
+    public static partial ScreenShader LoadScreenShaderAlias(ScreenShader shader);
+
     /// <summary>
     /// Unloads and destroys a screen shader.
+    /// <para>
+    /// If the shader owns its program shaders (i.e. it was created withR3D_LoadScreenShader orR3D_LoadScreenShaderFromMemory), they are deleted. Aliases created from this shader viaR3D_LoadScreenShaderAlias must be unloaded beforehand, as they share the same programs and will be left with dangling references.
+    /// </para>
     /// </summary>
     /// <param name="shader">Screen shader to unload.</param>
     /// <remarks>

R3D-cs/interop/R3D.screen_shader.g.cs

@@ -45,8 +45,29 @@ public static unsafe partial class R3D
     [LibraryImport(NativeLibName, EntryPoint = "R3D_LoadSkyShaderFromMemory", StringMarshalling = StringMarshalling.Utf8)]
     public static partial SkyShader LoadSkyShaderFromMemory(string code);
 
+    /// <summary>
+    /// Creates an alias of an existing sky shader.
+    /// <para>
+    /// The alias shares the same compiled program as the original but holds its own independent uniform and sampler state. A typical use case is to pre-configure several aliases with different uniforms or textures, avoiding the need to reconfigure the shader on every skybox switch.
+    /// </para>
+    /// <para>
+    /// Uniform and sampler state is copied from the original at the moment this function is called, not from the shader source defaults. Any values set on the original after compilation but before this call will be reflected in the alias; values set afterward will not.
+    /// </para>
+    /// </summary>
+    /// <param name="shader">The original sky shader to alias.</param>
+    /// <returns>Pointer to the alias, or NULL on failure.</returns>
+    /// <remarks>
+    /// The alias does not own the program. Always unload all aliases before unloading the original, or the alias program references become dangling.
+    /// Native: <c>R3D_LoadSkyShaderAlias</c>
+    /// </remarks>
+    [LibraryImport(NativeLibName, EntryPoint = "R3D_LoadSkyShaderAlias")]
+    public static partial SkyShader LoadSkyShaderAlias(SkyShader shader);
+
     /// <summary>
     /// Unloads and destroys a sky shader.
+    /// <para>
+    /// If the shader owns its program shaders (i.e. it was created withR3D_LoadSkyShader orR3D_LoadSkyShaderFromMemory), they are deleted. Aliases created from this shader viaR3D_LoadSkyShaderAlias must be unloaded beforehand, as they share the same programs and will be left with dangling references.
+    /// </para>
     /// </summary>
     /// <param name="shader">Sky shader to unload.</param>
     /// <remarks>