quartznet/raylib-cs
2
0
Fork 0
mirror of https://github.com/raylib-cs/raylib-cs synced 2025-04-03 11:09:40 -04:00
Code Activity

Merge pull request #18 from msmshazan/generator

Browse Source 
Added Bindings Generator
This commit is contained in:
ChrisDill 2018-12-17 18:33:13 +00:00 committed by GitHub
commit c67b8d1eca
12 changed files with 7562 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Generator/App.config Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
</startup>
</configuration>

BIN
Generator/Dia2Dump.exe Normal file
View File

Binary file not shown.

78
Generator/Generator.csproj Normal file
View File

@ -0,0 +1,78 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}</ProjectGuid>
<OutputType>Exe</OutputType>
<RootNamespace>Generator</RootNamespace>
<AssemblyName>Generator</AssemblyName>
<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
<Deterministic>true</Deterministic>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.CSharp">
<Version>2.10.0</Version>
</PackageReference>
</ItemGroup>
<ItemGroup>
<Content Include="Dia2Dump.exe">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="easings.h">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="physac.h">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="raygui.h">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="raylib.h">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="raylib.pdb">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

679
Generator/Program.cs Normal file
View File

@ -0,0 +1,679 @@
using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
using Microsoft.CodeAnalysis;
using System.Diagnostics;
namespace Generator
{
public struct TypeMember
{
public string Name;
public Type Type;
public int Offset;
public TypeMember(string name, Type type, int offset)
{
Name = name;
Type = type;
Offset = offset;
}
}
public struct UserDefinedEnumData
{
public string Name;
public List<KeyValuePair<string, int>> Enums;
public UserDefinedEnumData(string name)
{
Name = name;
Enums = new List<KeyValuePair<string, int>>();
}
}
public struct UserDefinedTypeData
{
public string Name;
public List<TypeMember> Members;
public UserDefinedTypeData(string name)
{
Name = name;
Members = new List<TypeMember>();
}
}
public struct Function
{
public string Name;
public Type ReturnType;
public List<FunctionParam> Params;
public Function(string name, string returnType, params FunctionParam[] parameters)
{
var Isreturnpointer = name[0] == '*';
Name = Isreturnpointer ? name.Replace("*","") : name;
ReturnType = new Type(returnType, Isreturnpointer);
Params = new List<FunctionParam>(parameters);
}
public override string ToString()
{
var str = $"{ReturnType} {Name}(";
for (int i = 0; i < Params.Count; i++)
{
if (i != 0) str += ",";
str += $"{Params[i].ToString()}";
}
str += ")";
return str;
}
}
public struct Type
{
public string Name;
public bool IsPointer;
public Type(string name, bool isPointer)
{
Name = name;
IsPointer = isPointer;
}
public override string ToString()
{
return Name + (IsPointer == true ? "*" : "");
}
}
public struct FunctionParam
{
public string Name;
public Type Type;
public FunctionParam(string name, Type type)
{
Name = name;
Type = type;
}
public FunctionParam(string FullParam)
{
FullParam = FullParam.Trim();
if (FullParam.Split(' ').Length == 2)
{
var Isreturnpointer = FullParam.Split(' ')[1][0] == '*';
Name = Isreturnpointer ? FullParam.Replace("*", "").Split(' ')[1] : FullParam.Split(' ')[1];
Type = new Type(FullParam.Replace("*", "").Split(' ')[0], Isreturnpointer);
}
else
{
var Isreturnpointer = FullParam.Split(' ')[2][0] == '*';
Name = Isreturnpointer ? FullParam.Replace("*","").Split(' ')[2] : FullParam.Split(' ')[2];
Type = new Type(FullParam.Replace("*", "").Split(' ')[0] + " " + FullParam.Replace("*", "").Split(' ')[1], Isreturnpointer);
}
}
public override string ToString()
{
return Name == "..." ? "..." : $"{Type.ToString()} {Name}";
}
}
class Program
{
static void Main(string[] args)
{
var process = Process.Start(new ProcessStartInfo("Dia2Dump.exe", " -t raylib.pdb") { RedirectStandardOutput = true, UseShellExecute = false });
string typedata = "";
var ischkout = process.StandardOutput;
while (process.HasExited == false)
{
typedata += ischkout.ReadToEnd();
}
File.WriteAllText("types.txt", typedata);
var typesfile = File.ReadAllLines("types.txt");
var TypeMap = new Dictionary<string, string>();
typesfile = typesfile.Where(x => x != "").ToArray();
var sources = new KeyValuePair<string, string>[] { new KeyValuePair<string, string>( "raylib.h","RLAPI") , new KeyValuePair<string, string>("physac.h", "PHYSACDEF"),
new KeyValuePair<string, string>( "easings.h","EASEDEF"),new KeyValuePair<string, string>( "raygui.h","RAYGUIDEF")};
foreach (var sourcefilenameandexporttag in sources)
{
var functions = new List<string>();
var types = new HashSet<string>();
var enums = new HashSet<string>();
var Funcs = new List<Function>();
var tps = new Dictionary<string, UserDefinedTypeData>();
var eps = new Dictionary<string, UserDefinedEnumData>();
var sourcefilename = sourcefilenameandexporttag.Key;
var FileName = new CultureInfo("en-us", false).TextInfo.ToTitleCase(sourcefilename.Replace(".h", ""));
var ExportTag = sourcefilenameandexporttag.Value;
var sourcefile = File.ReadAllLines(sourcefilename);
for (int i = 0; i < sourcefile.Length; i++)
{
var source = sourcefile[i].Split("//".ToCharArray())[0].Trim();
if (source.Contains(ExportTag))
{
if (!source.Contains("#define"))
{
source = source.TrimStart(ExportTag.ToCharArray()).Trim();
if (!source.Contains("{")) functions.Add(source);
}
}
if (source.Contains("typedef"))
{
if (source.Split(' ')[1].Trim() == "struct")
{
if (source.Contains('}'))
{
types.Add(source.Split('}', ';')[1].Trim());
}
else
{
int t = 1;
var src = sourcefile[i + t];
while (!src.Contains('}'))
{
src = sourcefile[i + t];
t++;
}
types.Add(src.Trim('}', ';').Trim());
}
}
}
}
for (int i = 0; i < functions.Count; i++)
{
var func = functions[i];
var returntype = func.Split('(')[0].Split(' ').Length == 3 ? func.Split('(')[0].Split(' ')[0] + " " + func.Split('(')[0].Split(' ')[1] : func.Split('(')[0].Split(' ')[0];
types.Add(returntype);
func = func.Substring(returntype.Length).Trim();
var funcname = func.Split('(')[0].Trim();
var Func = new Function(funcname, returntype);
if (func.Contains(','))
{
var Params = func.Split('(', ')')[1].Split(',');
for (int t = 0; t < Params.Length; t++)
{
var Param = Params[t];
Param = Param.Trim();
if (Param == "...")
{
Func.Params.Add(new FunctionParam(Param, new Type("...", false)));
}
else
{
var TypeAndVar = Param.Trim().Split(' ');
if (TypeAndVar.Length == 2)
{
var type = TypeAndVar[0];
var Var = TypeAndVar[1];
types.Add(type);
}
else if (TypeAndVar.Length == 3)
{
var type = TypeAndVar[0] + " " + TypeAndVar[1];
var Var = TypeAndVar[2];
types.Add(type);
}
Func.Params.Add(new FunctionParam(Param));
}
}
}
else if (func.Contains(' '))
{
var Param = func.Split('(', ')')[1];
var TypeAndVar = Param.Trim().Split(' ');
var type = TypeAndVar[0];
var Var = TypeAndVar[1];
types.Add(type);
Func.Params.Add(new FunctionParam(Param));
}
Funcs.Add(Func);
}
for (int i = 0; i < sourcefile.Length; i++)
{
var source = sourcefile[i].Split("//".ToCharArray())[0].Trim();
if (source.Contains("typedef"))
{
if (source.Split(' ')[1].Trim() != "struct")
{
if (source.Split(' ')[1].Trim() == "enum")
{
if (source.Contains('}'))
{
enums.Add(source.Split('}', ';')[1].Trim());
}
else
{
int t = 1;
var src = sourcefile[i + t];
while (!src.Contains('}'))
{
src = sourcefile[i + t];
t++;
}
enums.Add(src.Trim('}', ';').Trim());
}
}
else
{
TypeMap.Add(source.Split(" ".ToCharArray(), 3)[2].Trim(';').Trim(), source.Split(" ".ToCharArray(), 3)[1].Trim());
}
}
else
{
}
}
else if (source.Contains("#define") && source.Split(' ').Length > 2 && source.Split(' ')[1] != (ExportTag))
{
if (types.Contains(source.Split(" ".ToCharArray(), 3)[1].Trim(';').Trim())) TypeMap.Add(source.Split(" ".ToCharArray(), 3)[1].Trim(';').Trim(), source.Split(" ".ToCharArray(), 3)[2].Trim());
}
}
for (int i = 0; i < Funcs.Count; i++)
{
var Func = Funcs[i];
if (TypeMap.ContainsKey(Func.ReturnType.Name))
{
Func.ReturnType.Name = TypeMap[Func.ReturnType.Name];
}
for (int t = 0; t < Func.Params.Count; t++)
{
if (TypeMap.ContainsKey(Func.Params[t].Type.Name))
{
Func.Params[t] = new FunctionParam(Func.Params[t].Name, new Type(TypeMap[Func.Params[t].Type.Name], Func.Params[t].Type.IsPointer));
}
}
Funcs[i] = Func;
}
for (int i = 0; i < typesfile.Length; i++)
{
var typestr = typesfile[i];
if (typestr.Contains("UserDefinedType: ") && !typestr.Contains("UserDefinedType: "))
{
var type = typestr.Substring("UserDefinedType: ".Length).Trim();
if (types.Contains(type) && type[0] != ' ' && !tps.Any(x => x.Key == type))
{
var usertype = new UserDefinedTypeData(type);
int t = 1;
typestr = typesfile[i + t];
while (!(typestr.Contains("UserDefinedType: ") && typestr["UserDefinedType: ".Length - 1] == ' '))
{
if (typestr.Contains("Member"))
{
var tpsrc = typesfile[i + t];
var MemberNameandType = tpsrc.Substring(tpsrc.IndexOf("Type:") + "Type:".Length).Trim().Split(',');
var MemberName = MemberNameandType[1].Trim();
var MemberType = MemberNameandType[0].Trim();
if (MemberType.Contains("<unnamed-enum-false>"))
{
MemberType = "bool";
}
var isptr = MemberType[MemberType.Length - 1] == '*';
var offset = int.Parse(tpsrc.Split(',')[0].Split(':')[1].Trim().Substring("this+0x".Length), System.Globalization.NumberStyles.HexNumber);
if (isptr)
{
MemberType = MemberType.Remove(MemberType.Length - 1);
}
usertype.Members.Add(new TypeMember(MemberName, new Type(MemberType, isptr), offset));
if (typesfile[i + t + 1].Contains(MemberType.Trim("struct".ToCharArray())) &&
typesfile[i + t + 1].Contains("UserDefinedType: "))
{
t++;
}
}
t++;
typestr = typesfile[i + t];
}
tps.Add(usertype.Name, usertype);
}
}
if (typestr.Contains("Enum : "))
{
var Enum = typestr.Substring("Enum : ".Length).Split(',')[0].Trim();
if (enums.Contains(Enum) && Enum != "bool")
{
var UserDefineEnum = new UserDefinedEnumData(Enum);
int t = 1;
typestr = typesfile[i + t];
while (typestr.Contains("Constant"))
{
var intstr = typestr.Split(",".ToCharArray(), 2)[0].Split(':')[1].Split(' ')[4].Substring("0x".Length).Trim();
int Int = int.Parse(intstr, System.Globalization.NumberStyles.HexNumber);
var name = typestr.Split(",".ToCharArray(), 4)[3].Trim();
UserDefineEnum.Enums.Add(new KeyValuePair<string, int>(name, Int));
t++;
typestr = typesfile[i + t];
}
eps.Add(Enum, UserDefineEnum);
}
}
}
types.IntersectWith(tps.Select(x => x.Key));
var codetree = CompilationUnit().AddUsings(UsingDirective(ParseName("System")))
.AddUsings(UsingDirective(ParseName("System.IO")))
.AddUsings(UsingDirective(ParseName("System.Collections.Generic")))
.AddUsings(UsingDirective(ParseName("System.Security")))
.AddUsings(UsingDirective(ParseName("System.Runtime.InteropServices")))
;
var Raylibnamespace = NamespaceDeclaration(ParseName("Raylib")).NormalizeWhitespace();
foreach (var Enumtype in eps.Values)
{
var Enum = EnumDeclaration(Enumtype.Name)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)));
foreach (var Member in Enumtype.Enums)
{
var enummember = EnumMemberDeclaration(
Identifier(Member.Key))
.WithEqualsValue(
EqualsValueClause(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(Member.Value))));
Enum = Enum.AddMembers(enummember);
}
Raylibnamespace = Raylibnamespace.AddMembers(Enum);
}
foreach (var Type in tps.Values)
{
var Struct = StructDeclaration(Type.Name).WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("StructLayout"))
.WithArgumentList(
AttributeArgumentList(
SeparatedList<AttributeArgumentSyntax>(
new SyntaxNodeOrToken[]{
AttributeArgument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("LayoutKind"),
IdentifierName("Sequential"))),
Token(SyntaxKind.CommaToken),
AttributeArgument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("CharSet"),
IdentifierName("Ansi")))
.WithNameEquals(
NameEquals(
IdentifierName("CharSet")))})))))))
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)));
bool IsUnsafe = false;
var FixedStructTypes = new List<string>();
foreach (var Member in Type.Members)
{
var IsStruct = false;
var TypeName = (Member.Type.IsPointer ? "IntPtr" : Member.Type.Name).Trim();
if (TypeName.Contains("struct"))
{
IsStruct = true;
TypeName = TypeName.Substring(TypeName.LastIndexOf("struct") + "struct".Length);
}
if (TypeName.Contains("enum"))
{
TypeName = TypeName.Substring(TypeName.LastIndexOf("enum") + "enum".Length);
}
if (TypeName.Contains("unsigned int"))
{
TypeName = TypeName.Replace("unsigned int", "uint");
}
if (TypeName.Contains("unsigned char"))
{
TypeName = TypeName.Replace("unsigned char", "byte");
}
var IsFixed = false;
var VariableDec = VariableDeclarator(Member.Name);
if (TypeName.Contains("["))
{
int arraycount = int.Parse(TypeName.Split('[', ']')[1].Substring("0x".Length), System.Globalization.NumberStyles.HexNumber);
TypeName = TypeName.Split('[', ']')[0].Trim();
if (IsStruct)
{
if (!FixedStructTypes.Contains($"_{TypeName}_e_FixedBuffer_{arraycount}"))
{
FixedStructTypes.Add($"_{TypeName}_e_FixedBuffer_{arraycount}");
var FixedBufferStruct = StructDeclaration($"_{TypeName}_e_FixedBuffer_{arraycount}")
.WithModifiers(
TokenList(
new[]{
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.UnsafeKeyword)}));
for (int i = 0; i < arraycount; i++)
{
FixedBufferStruct = FixedBufferStruct.AddMembers(
FieldDeclaration(
VariableDeclaration(
IdentifierName(TypeName))
.WithVariables(
SingletonSeparatedList<VariableDeclaratorSyntax>(
VariableDeclarator(
Identifier($"{Member.Name}{i}")))))
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword))));
}
FixedBufferStruct = FixedBufferStruct.AddMembers(IndexerDeclaration(
RefType(
IdentifierName(TypeName)))
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)))
.WithParameterList(
BracketedParameterList(
SingletonSeparatedList<ParameterSyntax>(
Parameter(
Identifier("index"))
.WithType(
PredefinedType(
Token(SyntaxKind.IntKeyword))))))
.WithAccessorList(
AccessorList(
SingletonList<AccessorDeclarationSyntax>(
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration)
.WithBody(
Block(
SingletonList<StatementSyntax>(
FixedStatement(
VariableDeclaration(
PointerType(
IdentifierName(TypeName)))
.WithVariables(
SingletonSeparatedList<VariableDeclaratorSyntax>(
VariableDeclarator(
Identifier("e"))
.WithInitializer(
EqualsValueClause(
PrefixUnaryExpression(
SyntaxKind.AddressOfExpression,
IdentifierName($"{Member.Name}0")))))),
ReturnStatement(
RefExpression(
ElementAccessExpression(
IdentifierName("e"))
.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList<ArgumentSyntax>(
Argument(
IdentifierName("index")))))))))))))));
Raylibnamespace = Raylibnamespace.AddMembers(FixedBufferStruct);
}
TypeName = $"_{TypeName}_e_FixedBuffer_{arraycount}";
}
else
{
VariableDec = VariableDec.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList<ArgumentSyntax>(
Argument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(arraycount))))));
IsFixed = true;
IsUnsafe = true;
}
}
var variable = VariableDeclaration(ParseTypeName(TypeName)).AddVariables(VariableDec);
var field = FieldDeclaration(variable).AddModifiers(Token(SyntaxKind.PublicKeyword));
if (IsFixed) field = field.AddModifiers(Token(SyntaxKind.FixedKeyword));
Struct = Struct.AddMembers(field);
}
if (IsUnsafe) Struct = Struct.AddModifiers(Token(SyntaxKind.UnsafeKeyword));
Raylibnamespace = Raylibnamespace.AddMembers(Struct);
}
{
var RaylibClass = ClassDeclaration(FileName)
.WithAttributeLists(
SingletonList<AttributeListSyntax>(
AttributeList(
SingletonSeparatedList<AttributeSyntax>(
Attribute(
IdentifierName("SuppressUnmanagedCodeSecurity"))))))
.WithModifiers(
TokenList(
new[]{
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.StaticKeyword),
Token(SyntaxKind.PartialKeyword)}));
var LibraryNameField = FieldDeclaration(
VariableDeclaration(
PredefinedType(
Token(SyntaxKind.StringKeyword)))
.WithVariables(
SingletonSeparatedList<VariableDeclaratorSyntax>(
VariableDeclarator(
Identifier("nativeLibName"))
.WithInitializer(
EqualsValueClause(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal("raylib")))))))
.WithModifiers(
TokenList(
new[]{
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.ConstKeyword)}));
RaylibClass = RaylibClass.AddMembers(LibraryNameField);
foreach (var Func in Funcs)
{
var typename = Func.ReturnType.IsPointer ? "IntPtr" : Func.ReturnType.Name;
var Function = MethodDeclaration(ParseTypeName(typename),
Identifier(Func.Name))
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("DllImport"))
.WithArgumentList(
AttributeArgumentList(
SeparatedList<AttributeArgumentSyntax>(
new SyntaxNodeOrToken[]{
AttributeArgument(
IdentifierName("nativeLibName")),
Token(SyntaxKind.CommaToken),
AttributeArgument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("CallingConvention"),
IdentifierName("Cdecl")))
.WithNameEquals(
NameEquals(
IdentifierName("CallingConvention")))})))))))
.WithModifiers(
TokenList(
new[]{
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.StaticKeyword),
Token(SyntaxKind.ExternKeyword)
})).WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
for (int i=0; i < Func.Params.Count;i++)
{
var Param = Func.Params[i];
var TypeName = (Param.Type.IsPointer ? "IntPtr" : Param.Type.Name).Trim();
if (TypeName.Contains("unsigned int"))
{
TypeName = TypeName.Replace("unsigned int", "uint");
}
if (TypeName.Contains("..."))
{
TypeName = "params object[]";
Param.Name = "args";
}
if (TypeName.Contains("unsigned char"))
{
TypeName = TypeName.Replace("unsigned char", "byte");
}
if (TypeName.Contains("struct"))
{
TypeName = TypeName.Substring(TypeName.LastIndexOf("struct") + "struct".Length);
}
Function = Function.AddParameterListParameters(
Parameter(
Identifier(Param.Name))
.WithType(
IdentifierName(TypeName)));
}
RaylibClass = RaylibClass.AddMembers(Function);
}
Raylibnamespace = Raylibnamespace.AddMembers(RaylibClass);
}
codetree = codetree.AddMembers(Raylibnamespace);
Console.WriteLine(codetree.NormalizeWhitespace().ToFullString());
File.WriteAllText($"{FileName}.cs", codetree.NormalizeWhitespace().ToFullString());
}
Console.ReadLine();
}
}
}

36
Generator/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Generator")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Generator")]
[assembly: AssemblyCopyright("Copyright © 2018")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("0adeb5b1-bf57-4d45-be28-176c1d79c764")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

253
Generator/easings.h Normal file
View File

@ -0,0 +1,253 @@
/*******************************************************************************************
*
* raylib easings (header only file)
*
* Useful easing functions for values animation
*
* This header uses:
* #define EASINGS_STATIC_INLINE // Inlines all functions code, so it runs faster.
* // This requires lots of memory on system.
* How to use:
* The four inputs t,b,c,d are defined as follows:
* t = current time (in any unit measure, but same unit as duration)
* b = starting value to interpolate
* c = the total change in value of b that needs to occur
* d = total time it should take to complete (duration)
*
* Example:
*
* int currentTime = 0;
* int duration = 100;
* float startPositionX = 0.0f;
* float finalPositionX = 30.0f;
* float currentPositionX = startPositionX;
*
* while (currentPositionX < finalPositionX)
* {
* currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
* currentTime++;
* }
*
* A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
*
* Robert Penner License
* ---------------------------------------------------------------------------------
* Open source under the BSD License.
*
* Copyright (c) 2001 Robert Penner. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the author nor the names of contributors may be used
* to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ---------------------------------------------------------------------------------
*
* Copyright (c) 2015 Ramon Santamaria
*
* 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.
*
**********************************************************************************************/
#ifndef EASINGS_H
#define EASINGS_H
#define EASINGS_STATIC_INLINE // NOTE: By default, compile functions as static inline
#if defined(EASINGS_STATIC_INLINE)
#define EASEDEF static inline
#else
#define EASEDEF extern
#endif
#include <math.h> // Required for: sin(), cos(), sqrt(), pow()
#ifdef __cplusplus
extern "C" { // Prevents name mangling of functions
#endif
// Linear Easing functions
EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
EASEDEF float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
// Sine Easing functions
EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cos(t/d*(PI/2)) + c + b); }
EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sin(t/d*(PI/2)) + b); }
EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2*(cos(PI*t/d) - 1) + b); }
// Circular Easing functions
EASEDEF float EaseCircIn(float t, float b, float c, float d) { return (-c*(sqrt(1 - (t/=d)*t) - 1) + b); }
EASEDEF float EaseCircOut(float t, float b, float c, float d) { return (c*sqrt(1 - (t=t/d-1)*t) + b); }
EASEDEF float EaseCircInOut(float t, float b, float c, float d)
{
if ((t/=d/2) < 1) return (-c/2*(sqrt(1 - t*t) - 1) + b);
return (c/2*(sqrt(1 - t*(t-=2)) + 1) + b);
}
// Cubic Easing functions
EASEDEF float EaseCubicIn(float t, float b, float c, float d) { return (c*(t/=d)*t*t + b); }
EASEDEF float EaseCubicOut(float t, float b, float c, float d) { return (c*((t=t/d-1)*t*t + 1) + b); }
EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
{
if ((t/=d/2) < 1) return (c/2*t*t*t + b);
return (c/2*((t-=2)*t*t + 2) + b);
}
// Quadratic Easing functions
EASEDEF float EaseQuadIn(float t, float b, float c, float d) { return (c*(t/=d)*t + b); }
EASEDEF float EaseQuadOut(float t, float b, float c, float d) { return (-c*(t/=d)*(t-2) + b); }
EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
{
if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
return (-c/2*(((t-2)*(--t)) - 1) + b);
}
// Exponential Easing functions
EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == 0) ? b : (c*pow(2, 10*(t/d - 1)) + b); }
EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-pow(2, -10*t/d) + 1) + b); }
EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
{
if (t == 0) return b;
if (t == d) return (b + c);
if ((t/=d/2) < 1) return (c/2*pow(2, 10*(t - 1)) + b);
return (c/2*(-pow(2, -10*--t) + 2) + b);
}
// Back Easing functions
EASEDEF float EaseBackIn(float t, float b, float c, float d)
{
float s = 1.70158f;
float postFix = t/=d;
return (c*(postFix)*t*((s + 1)*t - s) + b);
}
EASEDEF float EaseBackOut(float t, float b, float c, float d)
{
float s = 1.70158f;
return (c*((t=t/d-1)*t*((s + 1)*t + s) + 1) + b);
}
EASEDEF float EaseBackInOut(float t, float b, float c, float d)
{
float s = 1.70158f;
if ((t/=d/2) < 1) return (c/2*(t*t*(((s*=(1.525f)) + 1)*t - s)) + b);
float postFix = t-=2;
return (c/2*((postFix)*t*(((s*=(1.525f)) + 1)*t + s) + 2) + b);
}
// Bounce Easing functions
EASEDEF float EaseBounceOut(float t, float b, float c, float d)
{
if ((t/=d) < (1/2.75f))
{
return (c*(7.5625f*t*t) + b);
}
else if (t < (2/2.75f))
{
float postFix = t-=(1.5f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.75f) + b);
}
else if (t < (2.5/2.75))
{
float postFix = t-=(2.25f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
}
else
{
float postFix = t-=(2.625f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
}
}
EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d-t, 0, c, d) + b); }
EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
{
if (t < d/2) return (EaseBounceIn(t*2, 0, c, d)*0.5f + b);
else return (EaseBounceOut(t*2-d, 0, c, d)*0.5f + c*0.5f + b);
}
// Elastic Easing functions
EASEDEF float EaseElasticIn(float t, float b, float c, float d)
{
if (t == 0) return b;
if ((t/=d) == 1) return (b + c);
float p = d*0.3f;
float a = c;
float s = p/4;
float postFix = a*pow(2, 10*(t-=1));
return (-(postFix*sin((t*d-s)*(2*PI)/p )) + b);
}
EASEDEF float EaseElasticOut(float t, float b, float c, float d)
{
if (t == 0) return b;
if ((t/=d) == 1) return (b + c);
float p = d*0.3f;
float a = c;
float s = p/4;
return (a*pow(2,-10*t)*sin((t*d-s)*(2*PI)/p) + c + b);
}
EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
{
if (t == 0) return b;
if ((t/=d/2) == 2) return (b + c);
float p = d*(0.3f*1.5f);
float a = c;
float s = p/4;
if (t < 1)
{
float postFix = a*pow(2, 10*(t-=1));
return -0.5f*(postFix*sin((t*d-s)*(2*PI)/p)) + b;
}
float postFix = a*pow(2, -10*(t-=1));
return (postFix*sin((t*d-s)*(2*PI)/p)*0.5f + c + b);
}
#ifdef __cplusplus
}
#endif
#endif // EASINGS_H

2056
Generator/physac.h Normal file
View File

File diff suppressed because it is too large Load Diff

3155
Generator/raygui.h Normal file
View File

File diff suppressed because it is too large Load Diff

1284
Generator/raylib.h Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
Generator/raylib.pdb Normal file
View File

Binary file not shown.

14
Raylib-cs.sln
View File

@ -13,6 +13,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test.NetFX", "Test.NetFX\Te
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test.NetCoreRT", "Test.NetCoreRT\Test.NetCoreRT.csproj", "{98B914D1-8CCF-4895-A9E7-CE4AA8067528}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Generator", "Generator\Generator.csproj", "{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}"
EndProject
Global
GlobalSection(SharedMSBuildProjectFiles) = preSolution
Examples\Examples.projitems*{36e54e2a-5899-4d4d-9d78-120db1b4c7b2}*SharedItemsImports = 13
@ -75,6 +77,18 @@ Global
{98B914D1-8CCF-4895-A9E7-CE4AA8067528}.Release|x64.Build.0 = Release|x64
{98B914D1-8CCF-4895-A9E7-CE4AA8067528}.Release|x86.ActiveCfg = Release|x86
{98B914D1-8CCF-4895-A9E7-CE4AA8067528}.Release|x86.Build.0 = Release|x86
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|x64.ActiveCfg = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|x64.Build.0 = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|x86.ActiveCfg = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Debug|x86.Build.0 = Debug|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|Any CPU.Build.0 = Release|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|x64.ActiveCfg = Release|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|x64.Build.0 = Release|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|x86.ActiveCfg = Release|Any CPU
{0ADEB5B1-BF57-4D45-BE28-176C1D79C764}.Release|x86.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

2
Test.NetCoreRT/Test.NetCoreRT.csproj
View File

@ -24,7 +24,7 @@
<ProjectReference Include="..\Bindings\Bindings.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.DotNet.ILCompiler" Version="1.0.0-alpha-27022-01" />
<PackageReference Include="Microsoft.DotNet.ILCompiler" Version="1.0.0-alpha-27217-01" />
</ItemGroup>
<Import Project="..\Examples\Examples.projitems" Label="Shared" />
<Import Project="..\Examples\Examples.projitems" Label="Shared" />