diff --git a/bindings/generate.py b/bindings/generate.py old mode 100644 new mode 100755 index c24a141..f28a94b --- a/bindings/generate.py +++ b/bindings/generate.py @@ -1,3 +1,5 @@ +#!/usr/bin/env python3 + import sys import os import clang.cindex @@ -11,6 +13,8 @@ def map_type(clang_type: Type): canonical.spelling.replace("const ", "") .replace("volatile ", "") .replace("restrict ", "") + .replace("struct ", "") + .replace("union ", "") ) if kind == TypeKind.POINTER: @@ -18,6 +22,17 @@ def map_type(clang_type: Type): if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U: return "cstring" + if pointee.kind == TypeKind.FUNCTIONPROTO: + arg_types = [] + + for arg in pointee.get_canonical().argument_types(): + arg_types.append(map_type(arg)) + + mapped_return = map_type(pointee.get_canonical().get_result()) + args_str = ", ".join(arg_types) + + return f"func({args_str}): {mapped_return}" + return f"^{map_type(pointee)}" if kind == TypeKind.CONSTANTARRAY: @@ -65,10 +80,7 @@ def map_type(clang_type: Type): return "f64" if kind == TypeKind.RECORD: - if not spelling.startswith("struct "): - raise Exception(f"Unknown custom type: {spelling}") - - return spelling.replace("struct ", "") + return spelling raise Exception(f"Unresolved type: {spelling}") @@ -81,7 +93,7 @@ filename = sys.argv[1] index = clang.cindex.Index.create() -tu = index.parse(filename, ["-x", "c", "-std=c23"]) +tu = index.parse(filename, ["-x", "c", "-std=c23", "-I/usr/include"]) if tu.diagnostics: for diag in tu.diagnostics: diff --git a/compiler/NubLang.CLI/Program.cs b/compiler/NubLang.CLI/Program.cs index e3db4d8..00b9cab 100644 --- a/compiler/NubLang.CLI/Program.cs +++ b/compiler/NubLang.CLI/Program.cs @@ -59,7 +59,7 @@ var cFilePath = Path.Combine(".build", "out.c"); File.WriteAllText(cFilePath, c); -using var process = Process.Start("gcc", ["-ffreestanding", "-nostartfiles", "-c", "-o", Path.Combine(".build", "out.o"), cFilePath]); +using var process = Process.Start("gcc", ["-ffreestanding", "-nostartfiles", "-std=c23", "-g", "-c", "-o", Path.Combine(".build", "out.o"), cFilePath]); process.WaitForExit(); diff --git a/compiler/NubLang/Ast/Node.cs b/compiler/NubLang/Ast/Node.cs index 9eed5f1..9ba1d41 100644 --- a/compiler/NubLang/Ast/Node.cs +++ b/compiler/NubLang/Ast/Node.cs @@ -1,54 +1,56 @@ +using NubLang.Syntax; + namespace NubLang.Ast; -public abstract record Node; +public abstract record Node(List Tokens); #region Definitions -public abstract record DefinitionNode(string Module, string Name) : Node; +public abstract record DefinitionNode(List Tokens, string Module, string Name) : Node(Tokens); -public record FuncParameterNode(string Name, NubType Type) : Node; +public record FuncParameterNode(List Tokens, string Name, NubType Type) : Node(Tokens); -public record FuncSignatureNode(List Parameters, NubType ReturnType) : Node; +public record FuncSignatureNode(List Tokens, List Parameters, NubType ReturnType) : Node(Tokens); -public record FuncNode(string Module, string Name, string? ExternSymbol, FuncSignatureNode Signature, BlockNode? Body) : DefinitionNode(Module, Name); +public record FuncNode(List Tokens, string Module, string Name, string? ExternSymbol, FuncSignatureNode Signature, BlockNode? Body) : DefinitionNode(Tokens, Module, Name); -public record StructFieldNode(string Name, NubType Type, ExpressionNode? Value) : Node; +public record StructFieldNode(List Tokens, string Name, NubType Type, ExpressionNode? Value) : Node(Tokens); -public record StructFuncNode(string Name, FuncSignatureNode Signature, BlockNode Body) : Node; +public record StructFuncNode(List Tokens, string Name, FuncSignatureNode Signature, BlockNode Body) : Node(Tokens); -public record StructNode(string Module, string Name, List Fields, List Functions) : DefinitionNode(Module, Name); +public record StructNode(List Tokens, string Module, string Name, List Fields, List Functions) : DefinitionNode(Tokens, Module, Name); -public record GlobalVariableNode(string Module, string Name, ExpressionNode Value) : DefinitionNode(Module, Name); +public record GlobalVariableNode(List Tokens, string Module, string Name, ExpressionNode Value) : DefinitionNode(Tokens, Module, Name); #endregion #region Statements -public abstract record StatementNode : Node; +public abstract record StatementNode(List Tokens) : Node(Tokens); -public abstract record TerminalStatementNode : StatementNode; +public abstract record TerminalStatementNode(List Tokens) : StatementNode(Tokens); -public record BlockNode(List Statements) : StatementNode; +public record BlockNode(List Tokens, List Statements) : StatementNode(Tokens); -public record StatementFuncCallNode(FuncCallNode FuncCall) : StatementNode; +public record StatementFuncCallNode(List Tokens, FuncCallNode FuncCall) : StatementNode(Tokens); -public record StatementStructFuncCallNode(StructFuncCallNode StructFuncCall) : StatementNode; +public record StatementStructFuncCallNode(List Tokens, StructFuncCallNode StructFuncCall) : StatementNode(Tokens); -public record ReturnNode(ExpressionNode? Value) : TerminalStatementNode; +public record ReturnNode(List Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens); -public record AssignmentNode(LValueExpressionNode Target, ExpressionNode Value) : StatementNode; +public record AssignmentNode(List Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens); -public record IfNode(ExpressionNode Condition, BlockNode Body, Variant? Else) : StatementNode; +public record IfNode(List Tokens, ExpressionNode Condition, BlockNode Body, Variant? Else) : StatementNode(Tokens); -public record VariableDeclarationNode(string Name, ExpressionNode? Assignment, NubType Type) : StatementNode; +public record VariableDeclarationNode(List Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens); -public record ContinueNode : TerminalStatementNode; +public record ContinueNode(List Tokens) : TerminalStatementNode(Tokens); -public record BreakNode : TerminalStatementNode; +public record BreakNode(List Tokens) : TerminalStatementNode(Tokens); -public record WhileNode(ExpressionNode Condition, BlockNode Body) : StatementNode; +public record WhileNode(List Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens); -public record DeferNode(StatementNode Statement) : StatementNode; +public record DeferNode(List Tokens, StatementNode Statement) : StatementNode(Tokens); #endregion @@ -82,58 +84,58 @@ public enum BinaryOperator BitwiseOr } -public abstract record ExpressionNode(NubType Type) : Node; +public abstract record ExpressionNode(List Tokens, NubType Type) : Node(Tokens); -public abstract record LValueExpressionNode(NubType Type) : ExpressionNode(Type); +public abstract record LValueExpressionNode(List Tokens, NubType Type) : ExpressionNode(Tokens, Type); -public abstract record RValueExpressionNode(NubType Type) : ExpressionNode(Type); +public abstract record RValueExpressionNode(List Tokens, NubType Type) : ExpressionNode(Tokens, Type); -public record StringLiteralNode(NubType Type, string Value) : RValueExpressionNode(Type); +public record StringLiteralNode(List Tokens, NubType Type, string Value) : RValueExpressionNode(Tokens, Type); -public record CStringLiteralNode(NubType Type, string Value) : RValueExpressionNode(Type); +public record CStringLiteralNode(List Tokens, NubType Type, string Value) : RValueExpressionNode(Tokens, Type); -public record IntLiteralNode(NubType Type, long Value) : RValueExpressionNode(Type); +public record IntLiteralNode(List Tokens, NubType Type, long Value) : RValueExpressionNode(Tokens, Type); -public record UIntLiteralNode(NubType Type, ulong Value) : RValueExpressionNode(Type); +public record UIntLiteralNode(List Tokens, NubType Type, ulong Value) : RValueExpressionNode(Tokens, Type); -public record Float32LiteralNode(NubType Type, float Value) : RValueExpressionNode(Type); +public record Float32LiteralNode(List Tokens, NubType Type, float Value) : RValueExpressionNode(Tokens, Type); -public record Float64LiteralNode(NubType Type, double Value) : RValueExpressionNode(Type); +public record Float64LiteralNode(List Tokens, NubType Type, double Value) : RValueExpressionNode(Tokens, Type); -public record BoolLiteralNode(NubType Type, bool Value) : RValueExpressionNode(Type); +public record BoolLiteralNode(List Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type); -public record BinaryExpressionNode(NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Type); +public record BinaryExpressionNode(List Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type); -public record UnaryExpressionNode(NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Type); +public record UnaryExpressionNode(List Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type); -public record FuncCallNode(NubType Type, ExpressionNode Expression, List Parameters) : RValueExpressionNode(Type); +public record FuncCallNode(List Tokens, NubType Type, ExpressionNode Expression, List Parameters) : RValueExpressionNode(Tokens, Type); -public record StructFuncCallNode(NubType Type, string Module, string StructName, string FuncName, ExpressionNode StructExpression, List Parameters) : RValueExpressionNode(Type); +public record StructFuncCallNode(List Tokens, NubType Type, string Module, string StructName, string FuncName, ExpressionNode StructExpression, List Parameters) : RValueExpressionNode(Tokens, Type); -public record LValueIdentifierNode(NubType Type, string Name) : LValueExpressionNode(Type); +public record LValueIdentifierNode(List Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type); -public record RValueIdentifierNode(NubType Type, string Name) : RValueExpressionNode(Type); +public record RValueIdentifierNode(List Tokens, NubType Type, string Name) : RValueExpressionNode(Tokens, Type); -public record FuncIdentifierNode(NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Type); +public record FuncIdentifierNode(List Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type); -public record ArrayInitializerNode(NubType Type, ExpressionNode Capacity, NubType ElementType) : RValueExpressionNode(Type); +public record ArrayInitializerNode(List Tokens, NubType Type, ExpressionNode Capacity, NubType ElementType) : RValueExpressionNode(Tokens, Type); -public record ArrayIndexAccessNode(NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Type); +public record ArrayIndexAccessNode(List Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type); -public record AddressOfNode(NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Type); +public record AddressOfNode(List Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type); -public record StructFieldAccessNode(NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Type); +public record StructFieldAccessNode(List Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type); -public record StructInitializerNode(NubStructType StructType, Dictionary Initializers) : RValueExpressionNode(StructType); +public record StructInitializerNode(List Tokens, NubStructType StructType, Dictionary Initializers) : RValueExpressionNode(Tokens, StructType); -public record DereferenceNode(NubType Type, ExpressionNode Target) : LValueExpressionNode(Type); +public record DereferenceNode(List Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type); -public record ConvertIntNode(NubType Type, ExpressionNode Value, NubIntType ValueType, NubIntType TargetType) : RValueExpressionNode(Type); +public record ConvertIntNode(List Tokens, NubType Type, ExpressionNode Value, NubIntType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type); -public record ConvertFloatNode(NubType Type, ExpressionNode Value, NubFloatType ValueType, NubFloatType TargetType) : RValueExpressionNode(Type); +public record ConvertFloatNode(List Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubFloatType TargetType) : RValueExpressionNode(Tokens, Type); -public record SizeBuiltinNode(NubType Type, NubType TargetType) : RValueExpressionNode(Type); +public record SizeBuiltinNode(List Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type); -public record FloatToIntBuiltinNode(NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Type); +public record FloatToIntBuiltinNode(List Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type); #endregion \ No newline at end of file diff --git a/compiler/NubLang/Ast/TypeChecker.cs b/compiler/NubLang/Ast/TypeChecker.cs index b4d9651..78fd1ac 100644 --- a/compiler/NubLang/Ast/TypeChecker.cs +++ b/compiler/NubLang/Ast/TypeChecker.cs @@ -160,7 +160,7 @@ public sealed class TypeChecker var fields = node.Fields.Select(CheckStructField).ToList(); var functions = node.Functions.Select(CheckStructFunc).ToList(); - return new StructNode(CurrentScope.Module, node.Name, fields, functions); + return new StructNode(node.Tokens, CurrentScope.Module, node.Name, fields, functions); } private StructFuncNode CheckStructFunc(StructFuncSyntax function) @@ -173,7 +173,7 @@ public sealed class TypeChecker _funcReturnTypes.Push(ResolveType(function.Signature.ReturnType)); var body = CheckBlock(function.Body); _funcReturnTypes.Pop(); - return new StructFuncNode(function.Name, CheckFuncSignature(function.Signature), body); + return new StructFuncNode(function.Tokens, function.Name, CheckFuncSignature(function.Signature), body); } private StructFieldNode CheckStructField(StructFieldSyntax field) @@ -184,7 +184,7 @@ public sealed class TypeChecker value = CheckExpression(field.Value, ResolveType(field.Type)); } - return new StructFieldNode(field.Name, ResolveType(field.Type), value); + return new StructFieldNode(field.Tokens, field.Name, ResolveType(field.Type), value); } private FuncNode CheckFuncDefinition(FuncSyntax node) @@ -207,7 +207,7 @@ public sealed class TypeChecker { if (signature.ReturnType is NubVoidType) { - body.Statements.Add(new ReturnNode(null)); + body.Statements.Add(new ReturnNode(node.Tokens.Skip(node.Tokens.Count - 1).ToList(), null)); } else { @@ -221,12 +221,12 @@ public sealed class TypeChecker _funcReturnTypes.Pop(); } - return new FuncNode(CurrentScope.Module, node.Name, node.ExternSymbol, signature, body); + return new FuncNode(node.Tokens, CurrentScope.Module, node.Name, node.ExternSymbol, signature, body); } private GlobalVariableNode CheckGlobalVariable(GlobalVariableSyntax node) { - return new GlobalVariableNode(CurrentScope.Module, node.Name, CheckExpression(node.Value)); + return new GlobalVariableNode(node.Tokens, CurrentScope.Module, node.Name, CheckExpression(node.Value)); } private AssignmentNode CheckAssignment(AssignmentSyntax statement) @@ -238,7 +238,7 @@ public sealed class TypeChecker } var value = CheckExpression(statement.Value, lValue.Type); - return new AssignmentNode(lValue, value); + return new AssignmentNode(statement.Tokens, lValue, value); } private IfNode CheckIf(IfSyntax statement) @@ -251,7 +251,7 @@ public sealed class TypeChecker elseStatement = statement.Else.Value.Match>(elif => CheckIf(elif), el => CheckBlock(el)); } - return new IfNode(condition, body, elseStatement); + return new IfNode(statement.Tokens, condition, body, elseStatement); } private ReturnNode CheckReturn(ReturnSyntax statement) @@ -263,7 +263,7 @@ public sealed class TypeChecker value = CheckExpression(statement.Value, _funcReturnTypes.Peek()); } - return new ReturnNode(value); + return new ReturnNode(statement.Tokens, value); } private StatementNode CheckStatementExpression(StatementExpressionSyntax statement) @@ -272,8 +272,8 @@ public sealed class TypeChecker return expression switch { - FuncCallNode funcCall => new StatementFuncCallNode(funcCall), - StructFuncCallNode structFuncCall => new StatementStructFuncCallNode(structFuncCall), + FuncCallNode funcCall => new StatementFuncCallNode(statement.Tokens, funcCall), + StructFuncCallNode structFuncCall => new StatementStructFuncCallNode(statement.Tokens, structFuncCall), _ => throw new TypeCheckerException(Diagnostic.Error("Expressions statements can only be function calls").At(statement).Build()) }; } @@ -301,14 +301,14 @@ public sealed class TypeChecker CurrentScope.DeclareVariable(new Variable(statement.Name, type, VariableKind.LValue)); - return new VariableDeclarationNode(statement.Name, assignmentNode, type); + return new VariableDeclarationNode(statement.Tokens, statement.Name, assignmentNode, type); } private WhileNode CheckWhile(WhileSyntax statement) { var condition = CheckExpression(statement.Condition, new NubBoolType()); var body = CheckBlock(statement.Body); - return new WhileNode(condition, body); + return new WhileNode(statement.Tokens, condition, body); } private FuncSignatureNode CheckFuncSignature(FuncSignatureSyntax statement) @@ -316,10 +316,10 @@ public sealed class TypeChecker var parameters = new List(); foreach (var parameter in statement.Parameters) { - parameters.Add(new FuncParameterNode(parameter.Name, ResolveType(parameter.Type))); + parameters.Add(new FuncParameterNode(parameter.Tokens, parameter.Name, ResolveType(parameter.Type))); } - return new FuncSignatureNode(parameters, ResolveType(statement.ReturnType)); + return new FuncSignatureNode(statement.Tokens, parameters, ResolveType(statement.ReturnType)); } private ExpressionNode CheckExpression(ExpressionSyntax node, NubType? expectedType = null) @@ -343,7 +343,7 @@ public sealed class TypeChecker MemberAccessSyntax expression => CheckMemberAccess(expression), StructInitializerSyntax expression => CheckStructInitializer(expression, expectedType), InterpretBuiltinSyntax expression => CheckExpression(expression.Target) with { Type = ResolveType(expression.Type) }, - SizeBuiltinSyntax expression => new SizeBuiltinNode(new NubIntType(false, 64), ResolveType(expression.Type)), + SizeBuiltinSyntax expression => new SizeBuiltinNode(node.Tokens, new NubIntType(false, 64), ResolveType(expression.Type)), FloatToIntBuiltinSyntax expression => CheckFloatToInt(expression), _ => throw new ArgumentOutOfRangeException(nameof(node)) }; @@ -357,7 +357,7 @@ public sealed class TypeChecker { if (sourceIntType.Signed == targetIntType.Signed && sourceIntType.Width < targetIntType.Width) { - return new ConvertIntNode(targetIntType, result, sourceIntType, targetIntType); + return new ConvertIntNode(node.Tokens, targetIntType, result, sourceIntType, targetIntType); } } @@ -365,7 +365,7 @@ public sealed class TypeChecker { if (sourceFloatType.Width < targetFloatType.Width) { - return new ConvertFloatNode(targetFloatType, result, sourceFloatType, targetFloatType); + return new ConvertFloatNode(node.Tokens, targetFloatType, result, sourceFloatType, targetFloatType); } } @@ -392,7 +392,7 @@ public sealed class TypeChecker .Build()); } - return new FloatToIntBuiltinNode(targetIntType, value, sourceFloatType, targetIntType); + return new FloatToIntBuiltinNode(expression.Tokens, targetIntType, value, sourceFloatType, targetIntType); } private AddressOfNode CheckAddressOf(AddressOfSyntax expression) @@ -404,7 +404,7 @@ public sealed class TypeChecker } var type = new NubPointerType(target.Type); - return new AddressOfNode(type, lvalue); + return new AddressOfNode(expression.Tokens, type, lvalue); } private ArrayIndexAccessNode CheckArrayIndexAccess(ArrayIndexAccessSyntax expression) @@ -416,7 +416,7 @@ public sealed class TypeChecker throw new TypeCheckerException(Diagnostic.Error($"Cannot use array indexer on type {target.Type}").At(expression).Build()); } - return new ArrayIndexAccessNode(arrayType.ElementType, target, index); + return new ArrayIndexAccessNode(expression.Tokens, arrayType.ElementType, target, index); } private ArrayInitializerNode CheckArrayInitializer(ArrayInitializerSyntax expression) @@ -424,7 +424,7 @@ public sealed class TypeChecker var elementType = ResolveType(expression.ElementType); var type = new NubArrayType(elementType); var capacity = CheckExpression(expression.Capacity); - return new ArrayInitializerNode(type, capacity, elementType); + return new ArrayInitializerNode(expression.Tokens, type, capacity, elementType); } private BinaryExpressionNode CheckBinaryExpression(BinaryExpressionSyntax expression, NubType? expectedType) @@ -469,7 +469,7 @@ public sealed class TypeChecker var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(new NubBoolType(), left, op, right); + return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right); } case BinaryOperatorSyntax.GreaterThan: case BinaryOperatorSyntax.GreaterThanOrEqual: @@ -488,7 +488,7 @@ public sealed class TypeChecker var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(new NubBoolType(), left, op, right); + return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right); } case BinaryOperatorSyntax.LogicalAnd: case BinaryOperatorSyntax.LogicalOr: @@ -505,7 +505,7 @@ public sealed class TypeChecker var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(new NubBoolType(), left, op, right); + return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right); } case BinaryOperatorSyntax.Plus: { @@ -513,7 +513,7 @@ public sealed class TypeChecker if (left.Type is NubIntType or NubFloatType or NubStringType or NubCStringType) { var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(left.Type, left, op, right); + return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right); } throw new TypeCheckerException(Diagnostic @@ -537,7 +537,7 @@ public sealed class TypeChecker var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(left.Type, left, op, right); + return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right); } case BinaryOperatorSyntax.LeftShift: case BinaryOperatorSyntax.RightShift: @@ -556,7 +556,7 @@ public sealed class TypeChecker var right = CheckExpression(expression.Right, left.Type); - return new BinaryExpressionNode(left.Type, left, op, right); + return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right); } default: { @@ -580,7 +580,7 @@ public sealed class TypeChecker .Build()); } - return new UnaryExpressionNode(operand.Type, UnaryOperator.Negate, operand); + return new UnaryExpressionNode(expression.Tokens, operand.Type, UnaryOperator.Negate, operand); } case UnaryOperatorSyntax.Invert: { @@ -593,7 +593,7 @@ public sealed class TypeChecker .Build()); } - return new UnaryExpressionNode(operand.Type, UnaryOperator.Invert, operand); + return new UnaryExpressionNode(expression.Tokens, operand.Type, UnaryOperator.Invert, operand); } default: { @@ -610,7 +610,7 @@ public sealed class TypeChecker throw new TypeCheckerException(Diagnostic.Error($"Cannot dereference non-pointer type {target.Type}").At(expression).Build()); } - return new DereferenceNode(pointerType.BaseType, target); + return new DereferenceNode(expression.Tokens, pointerType.BaseType, target); } private FuncCallNode CheckFuncCall(FuncCallSyntax expression) @@ -647,7 +647,7 @@ public sealed class TypeChecker parameters.Add(parameterExpression); } - return new FuncCallNode(funcType.ReturnType, accessor, parameters); + return new FuncCallNode(expression.Tokens, funcType.ReturnType, accessor, parameters); } private StructFuncCallNode CheckMemberFuncCall(MemberFuncCallSyntax expression) @@ -691,7 +691,7 @@ public sealed class TypeChecker parameters.Add(parameterExpression); } - return new StructFuncCallNode(function.ReturnType, structType.Module, structType.Name, expression.Name, target, parameters); + return new StructFuncCallNode(expression.Tokens, function.ReturnType, structType.Module, structType.Name, expression.Name, target, parameters); } throw new TypeCheckerException(Diagnostic @@ -708,8 +708,8 @@ public sealed class TypeChecker { return scopeIdent.Kind switch { - VariableKind.LValue => new LValueIdentifierNode(scopeIdent.Type, expression.Name), - VariableKind.RValue => new RValueIdentifierNode(scopeIdent.Type, expression.Name), + VariableKind.LValue => new LValueIdentifierNode(expression.Tokens, scopeIdent.Type, expression.Name), + VariableKind.RValue => new RValueIdentifierNode(expression.Tokens, scopeIdent.Type, expression.Name), _ => throw new ArgumentOutOfRangeException() }; } @@ -722,7 +722,7 @@ public sealed class TypeChecker { var parameters = function.Signature.Parameters.Select(x => ResolveType(x.Type)).ToList(); var type = new NubFuncType(parameters, ResolveType(function.Signature.ReturnType)); - return new FuncIdentifierNode(type, CurrentScope.Module, expression.Name, function.ExternSymbol); + return new FuncIdentifierNode(expression.Tokens, type, CurrentScope.Module, expression.Name, function.ExternSymbol); } throw new TypeCheckerException(Diagnostic.Error($"Symbol {expression.Name} not found").At(expression).Build()); @@ -760,7 +760,7 @@ public sealed class TypeChecker { var parameters = function.Signature.Parameters.Select(x => ResolveType(x.Type)).ToList(); var type = new NubFuncType(parameters, ResolveType(function.Signature.ReturnType)); - return new FuncIdentifierNode(type, expression.Module, expression.Name, function.ExternSymbol); + return new FuncIdentifierNode(expression.Tokens, type, expression.Module, expression.Name, function.ExternSymbol); } throw new TypeCheckerException(Diagnostic @@ -773,9 +773,9 @@ public sealed class TypeChecker { return expectedType switch { - NubCStringType => new CStringLiteralNode(expectedType, expression.Value), - NubStringType => new StringLiteralNode(expectedType, expression.Value), - _ => new CStringLiteralNode(new NubCStringType(), expression.Value) + NubCStringType => new CStringLiteralNode(expression.Tokens, expectedType, expression.Value), + NubStringType => new StringLiteralNode(expression.Tokens, expectedType, expression.Value), + _ => new CStringLiteralNode(expression.Tokens, new NubCStringType(), expression.Value) }; } @@ -784,35 +784,35 @@ public sealed class TypeChecker if (expectedType is NubIntType intType) { return intType.Signed - ? new IntLiteralNode(intType, Convert.ToInt64(expression.Value, expression.Base)) - : new UIntLiteralNode(intType, Convert.ToUInt64(expression.Value, expression.Base)); + ? new IntLiteralNode(expression.Tokens, intType, Convert.ToInt64(expression.Value, expression.Base)) + : new UIntLiteralNode(expression.Tokens, intType, Convert.ToUInt64(expression.Value, expression.Base)); } if (expectedType is NubFloatType floatType) { return floatType.Width switch { - 32 => new Float32LiteralNode(floatType, Convert.ToSingle(Convert.ToInt64(expression.Value, expression.Base))), - 64 => new Float64LiteralNode(floatType, Convert.ToDouble(Convert.ToInt64(expression.Value, expression.Base))), + 32 => new Float32LiteralNode(expression.Tokens, floatType, Convert.ToSingle(Convert.ToInt64(expression.Value, expression.Base))), + 64 => new Float64LiteralNode(expression.Tokens, floatType, Convert.ToDouble(Convert.ToInt64(expression.Value, expression.Base))), _ => throw new ArgumentOutOfRangeException() }; } var type = new NubIntType(true, 64); - return new IntLiteralNode(type, Convert.ToInt64(expression.Value, expression.Base)); + return new IntLiteralNode(expression.Tokens, type, Convert.ToInt64(expression.Value, expression.Base)); } private ExpressionNode CheckFloatLiteral(FloatLiteralSyntax expression, NubType? expectedType) { var type = expectedType as NubFloatType ?? new NubFloatType(64); return type.Width == 32 - ? new Float32LiteralNode(type, Convert.ToSingle(expression.Value)) - : new Float64LiteralNode(type, Convert.ToDouble(expression.Value)); + ? new Float32LiteralNode(expression.Tokens, type, Convert.ToSingle(expression.Value)) + : new Float64LiteralNode(expression.Tokens, type, Convert.ToDouble(expression.Value)); } private BoolLiteralNode CheckBoolLiteral(BoolLiteralSyntax expression) { - return new BoolLiteralNode(new NubBoolType(), expression.Value); + return new BoolLiteralNode(expression.Tokens, new NubBoolType(), expression.Value); } private ExpressionNode CheckMemberAccess(MemberAccessSyntax expression) @@ -831,7 +831,7 @@ public sealed class TypeChecker .Build()); } - return new StructFieldAccessNode(field.Type, target, expression.Member); + return new StructFieldAccessNode(expression.Tokens, field.Type, target, expression.Member); } default: { @@ -902,7 +902,7 @@ public sealed class TypeChecker .Build()); } - return new StructInitializerNode(structType, initializers); + return new StructInitializerNode(expression.Tokens, structType, initializers); } private BlockNode CheckBlock(BlockSyntax node) @@ -937,7 +937,7 @@ public sealed class TypeChecker } } - return new BlockNode(statements); + return new BlockNode(node.Tokens, statements); } } @@ -947,14 +947,14 @@ public sealed class TypeChecker { AssignmentSyntax assignmentStmt => CheckAssignment(assignmentStmt), BlockSyntax blockStmt => CheckBlock(blockStmt), - BreakSyntax => new BreakNode(), - ContinueSyntax => new ContinueNode(), + BreakSyntax => new BreakNode(statement.Tokens), + ContinueSyntax => new ContinueNode(statement.Tokens), IfSyntax ifStmt => CheckIf(ifStmt), ReturnSyntax retStmt => CheckReturn(retStmt), StatementExpressionSyntax stmtExpr => CheckStatementExpression(stmtExpr), VariableDeclarationSyntax varDeclStmt => CheckVariableDeclaration(varDeclStmt), WhileSyntax whileStmt => CheckWhile(whileStmt), - DeferSyntax defer => new DeferNode(CheckStatement(defer.Statement)), + DeferSyntax defer => new DeferNode(statement.Tokens, CheckStatement(defer.Statement)), _ => throw new ArgumentOutOfRangeException(nameof(statement)) }; } @@ -1142,7 +1142,7 @@ public sealed class TypeChecker CurrentScope.DeclareVariable(new Variable("this", structType, VariableKind.RValue)); var fields = templateDef.Fields.Select(CheckStructField).ToList(); var functions = templateDef.Functions.Select(CheckStructFunc).ToList(); - Definitions.Add(new StructNode(structTemplate.Module, mangledName, fields, functions)); + Definitions.Add(new StructNode(templateDef.Tokens, structTemplate.Module, mangledName, fields, functions)); _checkedTemplateStructs.Add($"{structTemplate.Module}.{mangledName}"); } diff --git a/compiler/NubLang/Generation/Generator.cs b/compiler/NubLang/Generation/Generator.cs index c9db13e..6537a79 100644 --- a/compiler/NubLang/Generation/Generator.cs +++ b/compiler/NubLang/Generation/Generator.cs @@ -1,4 +1,5 @@ using NubLang.Ast; +using NubLang.Syntax; namespace NubLang.Generation; @@ -105,45 +106,45 @@ public class Generator public string Emit() { - var header = """ - typedef __builtin_va_list va_list; + const string header = """ + typedef __builtin_va_list va_list; - #define va_start(ap, last) __builtin_va_start(ap, last) - #define va_arg(ap, type) __builtin_va_arg(ap, type) - #define va_end(ap) __builtin_va_end(ap) - #define va_copy(dest, src) __builtin_va_copy(dest, src) + #define va_start(ap, last) __builtin_va_start(ap, last) + #define va_arg(ap, type) __builtin_va_arg(ap, type) + #define va_end(ap) __builtin_va_end(ap) + #define va_copy(dest, src) __builtin_va_copy(dest, src) - #define NULL ((void*)0) + #define NULL ((void*)0) - typedef unsigned long size_t; - typedef unsigned long uintptr_t; + typedef unsigned long size_t; + typedef unsigned long uintptr_t; - #define offsetof(type, member) __builtin_offsetof(type, member) + #define offsetof(type, member) __builtin_offsetof(type, member) - typedef unsigned char u8; - typedef signed char i8; - typedef unsigned short u16; - typedef signed short i16; - typedef unsigned int u32; - typedef signed int i32; - typedef unsigned long long u64; - typedef signed long long i64; + typedef unsigned char u8; + typedef signed char i8; + typedef unsigned short u16; + typedef signed short i16; + typedef unsigned int u32; + typedef signed int i32; + typedef unsigned long long u64; + typedef signed long long i64; - typedef float f32; - typedef double f64; + typedef float f32; + typedef double f64; - #define I8_C(x) x - #define U8_C(x) x##U + #define I8_C(x) x + #define U8_C(x) x##U - #define I16_C(x) x - #define U16_C(x) x##U + #define I16_C(x) x + #define U16_C(x) x##U - #define I32_C(x) x - #define U32_C(x) x##U + #define I32_C(x) x + #define U32_C(x) x##U - #define I64_C(x) x##LL - #define U64_C(x) x##ULL - """; + #define I64_C(x) x##LL + #define U64_C(x) x##ULL + """; foreach (var structType in _structTypes) { @@ -165,6 +166,7 @@ public class Generator foreach (var funcNode in _definitions.OfType()) { + EmitLine(funcNode.Tokens); appendNewLine = true; var parameters = funcNode.Signature.Parameters.Count != 0 ? string.Join(", ", funcNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name))) @@ -183,6 +185,7 @@ public class Generator { foreach (var structFuncNode in structNode.Functions) { + EmitLine(structFuncNode.Tokens); var parameters = structFuncNode.Signature.Parameters.Count != 0 ? string.Join(", ", structFuncNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name))) : "void"; @@ -198,6 +201,7 @@ public class Generator { if (funcNode.Body == null) continue; + EmitLine(funcNode.Tokens); var parameters = funcNode.Signature.Parameters.Count != 0 ? string.Join(", ", funcNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name))) : "void"; @@ -232,6 +236,7 @@ public class Generator private void EmitStatement(StatementNode statementNode) { + EmitLine(statementNode.Tokens); switch (statementNode) { case AssignmentNode assignmentNode: @@ -272,6 +277,16 @@ public class Generator } } + private void EmitLine(List tokens) + { + if (tokens.Count >= 1) + { + var file = tokens[0].Span.FilePath; + var line = tokens[0].Span.Start.Line; + _writer.WriteLine($"#line {line} \"{file}\""); + } + } + private void EmitAssignment(AssignmentNode assignmentNode) { var target = EmitExpression(assignmentNode.Target); @@ -294,18 +309,14 @@ public class Generator _deferStack.Peek().Add(deferNode); } - private void EmitIf(IfNode ifNode) + private void EmitIf(IfNode ifNode, bool elseIf = false) { var condition = EmitExpression(ifNode.Condition); - _writer.WriteLine($"if ({condition})"); + _writer.WriteLine($"{(elseIf ? "else" : "")} if ({condition})"); EmitBlock(ifNode.Body); ifNode.Else?.Match ( - elseIfNode => - { - _writer.Write("else "); - EmitIf(elseIfNode); - }, + elseIfNode => EmitIf(elseIfNode, true), elseNode => { _writer.WriteLine("else"); diff --git a/examples/raylib/generate.py b/examples/raylib/generate.py deleted file mode 100644 index 818f878..0000000 --- a/examples/raylib/generate.py +++ /dev/null @@ -1,134 +0,0 @@ -import sys -import os -import clang.cindex -from clang.cindex import CursorKind, TypeKind, Type - - -def map_type(clang_type: Type): - canonical = clang_type.get_canonical() - kind = canonical.kind - spelling = ( - canonical.spelling.replace("const ", "") - .replace("volatile ", "") - .replace("restrict ", "") - ) - - if kind == TypeKind.POINTER: - pointee = canonical.get_pointee() - if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U: - return "cstring" - - if pointee.kind == TypeKind.FUNCTIONPROTO: - arg_types = [] - - for arg in pointee.get_canonical().argument_types(): - arg_types.append(map_type(arg)) - - mapped_return = map_type(pointee.get_canonical().get_result()) - args_str = ", ".join(arg_types) - - return f"func({args_str}): {mapped_return}" - - return f"^{map_type(pointee)}" - - if kind == TypeKind.CONSTANTARRAY: - element_type = canonical.get_array_element_type() - size = canonical.get_array_size() - return f"[{size}]{map_type(element_type)}" - - if kind == TypeKind.FUNCTIONPROTO or kind == TypeKind.FUNCTIONNOPROTO: - arg_types = [] - - for arg in canonical.argument_types(): - arg_types.append(map_type(arg)) - - mapped_return = map_type(canonical.get_result()) - args_str = ", ".join(arg_types) - - return f"func({args_str}): {mapped_return}" - - if kind == TypeKind.VOID: - return "void" - - if kind == TypeKind.BOOL: - return "bool" - - if kind in [TypeKind.CHAR_S, TypeKind.SCHAR]: - return "i8" - if kind == TypeKind.CHAR_U or kind == TypeKind.UCHAR: - return "u8" - if kind == TypeKind.SHORT: - return "i16" - if kind == TypeKind.USHORT: - return "u16" - if kind == TypeKind.INT: - return "i32" - if kind == TypeKind.UINT: - return "u32" - if kind in [TypeKind.LONG, TypeKind.LONGLONG]: - return "i64" - if kind in [TypeKind.ULONG, TypeKind.ULONGLONG]: - return "u64" - - if kind == TypeKind.FLOAT: - return "f32" - if kind == TypeKind.DOUBLE or kind == TypeKind.LONGDOUBLE: - return "f64" - - if kind == TypeKind.RECORD: - if not spelling.startswith("struct "): - raise Exception(f"Unknown custom type: {spelling}") - - return spelling.replace("struct ", "") - - raise Exception(f"Unresolved type: {spelling}") - - -if len(sys.argv) != 2: - print("Usage: python3 generate.py [path to header]", file=sys.stderr) - sys.exit(1) - -filename = sys.argv[1] - -index = clang.cindex.Index.create() - -tu = index.parse(filename, ["-x", "c", "-std=c23"]) - -if tu.diagnostics: - for diag in tu.diagnostics: - if diag.severity >= clang.cindex.Diagnostic.Error: - print(f"Error: {diag.spelling}", file=sys.stderr) - -print(f'module "{os.path.basename(filename).split(".")[0]}"') -print() - -for cursor in tu.cursor.walk_preorder(): - if cursor.location.file and cursor.location.file.name != filename: - continue - - if cursor.kind == CursorKind.FUNCTION_DECL: - name = cursor.spelling - return_type = map_type(cursor.result_type) - - params = [] - for arg in cursor.get_arguments(): - param_name = arg.spelling - param_type = map_type(arg.type) - params.append(f"{param_name}: {param_type}") - - params_str = ", ".join(params) - - print(f'export extern "{name}" func {name}({params_str}): {return_type}') - - elif cursor.kind == CursorKind.STRUCT_DECL: - name = cursor.spelling - print(f"export struct {name}") - print("{") - for field in cursor.get_children(): - if field.kind == CursorKind.FIELD_DECL: - field_name = field.spelling - field_type = map_type(field.type) - print(f" {field_name}: {field_type}") - else: - raise Exception(f"Unsupported child of struct: {field.spelling}") - print("}") diff --git a/examples/raylib/generated/raylib.nub b/examples/raylib/generated/raylib.nub new file mode 100644 index 0000000..ad8908c --- /dev/null +++ b/examples/raylib/generated/raylib.nub @@ -0,0 +1,1127 @@ +module "raylib" + +export struct Vector2 +{ + x: f32 + y: f32 +} +export struct Vector2 +{ + x: f32 + y: f32 +} +export struct Vector3 +{ + x: f32 + y: f32 + z: f32 +} +export struct Vector3 +{ + x: f32 + y: f32 + z: f32 +} +export struct Vector4 +{ + x: f32 + y: f32 + z: f32 + w: f32 +} +export struct Vector4 +{ + x: f32 + y: f32 + z: f32 + w: f32 +} +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct Color +{ + r: u8 + g: u8 + b: u8 + a: u8 +} +export struct Color +{ + r: u8 + g: u8 + b: u8 + a: u8 +} +export struct Rectangle +{ + x: f32 + y: f32 + width: f32 + height: f32 +} +export struct Rectangle +{ + x: f32 + y: f32 + width: f32 + height: f32 +} +export struct Image +{ + data: ^void + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} +export struct Image +{ + data: ^void + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} +export struct Texture +{ + id: u32 + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} +export struct Texture +{ + id: u32 + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} +export struct RenderTexture +{ + id: u32 + texture: Texture + depth: Texture +} +export struct RenderTexture +{ + id: u32 + texture: Texture + depth: Texture +} +export struct NPatchInfo +{ + source: Rectangle + left: i32 + top: i32 + right: i32 + bottom: i32 + layout: i32 +} +export struct NPatchInfo +{ + source: Rectangle + left: i32 + top: i32 + right: i32 + bottom: i32 + layout: i32 +} +export struct GlyphInfo +{ + value: i32 + offsetX: i32 + offsetY: i32 + advanceX: i32 + image: Image +} +export struct GlyphInfo +{ + value: i32 + offsetX: i32 + offsetY: i32 + advanceX: i32 + image: Image +} +export struct Font +{ + baseSize: i32 + glyphCount: i32 + glyphPadding: i32 + texture: Texture + recs: ^Rectangle + glyphs: ^GlyphInfo +} +export struct Font +{ + baseSize: i32 + glyphCount: i32 + glyphPadding: i32 + texture: Texture + recs: ^Rectangle + glyphs: ^GlyphInfo +} +export struct Camera3D +{ + position: Vector3 + target: Vector3 + up: Vector3 + fovy: f32 + projection: i32 +} +export struct Camera3D +{ + position: Vector3 + target: Vector3 + up: Vector3 + fovy: f32 + projection: i32 +} +export struct Camera2D +{ + offset: Vector2 + target: Vector2 + rotation: f32 + zoom: f32 +} +export struct Camera2D +{ + offset: Vector2 + target: Vector2 + rotation: f32 + zoom: f32 +} +export struct Mesh +{ + vertexCount: i32 + triangleCount: i32 + vertices: ^f32 + texcoords: ^f32 + texcoords2: ^f32 + normals: ^f32 + tangents: ^f32 + colors: ^u8 + indices: ^u16 + animVertices: ^f32 + animNormals: ^f32 + boneIds: ^u8 + boneWeights: ^f32 + boneMatrices: ^Matrix + boneCount: i32 + vaoId: u32 + vboId: ^u32 +} +export struct Mesh +{ + vertexCount: i32 + triangleCount: i32 + vertices: ^f32 + texcoords: ^f32 + texcoords2: ^f32 + normals: ^f32 + tangents: ^f32 + colors: ^u8 + indices: ^u16 + animVertices: ^f32 + animNormals: ^f32 + boneIds: ^u8 + boneWeights: ^f32 + boneMatrices: ^Matrix + boneCount: i32 + vaoId: u32 + vboId: ^u32 +} +export struct Shader +{ + id: u32 + locs: ^i32 +} +export struct Shader +{ + id: u32 + locs: ^i32 +} +export struct MaterialMap +{ + texture: Texture + color: Color + value: f32 +} +export struct MaterialMap +{ + texture: Texture + color: Color + value: f32 +} +export struct Material +{ + shader: Shader + maps: ^MaterialMap + params: [4]f32 +} +export struct Material +{ + shader: Shader + maps: ^MaterialMap + params: [4]f32 +} +export struct Transform +{ + translation: Vector3 + rotation: Vector4 + scale: Vector3 +} +export struct Transform +{ + translation: Vector3 + rotation: Vector4 + scale: Vector3 +} +export struct BoneInfo +{ + name: [32]i8 + parent: i32 +} +export struct BoneInfo +{ + name: [32]i8 + parent: i32 +} +export struct Model +{ + transform: Matrix + meshCount: i32 + materialCount: i32 + meshes: ^Mesh + materials: ^Material + meshMaterial: ^i32 + boneCount: i32 + bones: ^BoneInfo + bindPose: ^Transform +} +export struct Model +{ + transform: Matrix + meshCount: i32 + materialCount: i32 + meshes: ^Mesh + materials: ^Material + meshMaterial: ^i32 + boneCount: i32 + bones: ^BoneInfo + bindPose: ^Transform +} +export struct ModelAnimation +{ + boneCount: i32 + frameCount: i32 + bones: ^BoneInfo + framePoses: ^^Transform + name: [32]i8 +} +export struct ModelAnimation +{ + boneCount: i32 + frameCount: i32 + bones: ^BoneInfo + framePoses: ^^Transform + name: [32]i8 +} +export struct Ray +{ + position: Vector3 + direction: Vector3 +} +export struct Ray +{ + position: Vector3 + direction: Vector3 +} +export struct RayCollision +{ + hit: bool + distance: f32 + point: Vector3 + normal: Vector3 +} +export struct RayCollision +{ + hit: bool + distance: f32 + point: Vector3 + normal: Vector3 +} +export struct BoundingBox +{ + min: Vector3 + max: Vector3 +} +export struct BoundingBox +{ + min: Vector3 + max: Vector3 +} +export struct Wave +{ + frameCount: u32 + sampleRate: u32 + sampleSize: u32 + channels: u32 + data: ^void +} +export struct Wave +{ + frameCount: u32 + sampleRate: u32 + sampleSize: u32 + channels: u32 + data: ^void +} +export struct rAudioBuffer +{ +} +export struct rAudioProcessor +{ +} +export struct AudioStream +{ + buffer: ^rAudioBuffer + processor: ^rAudioProcessor + sampleRate: u32 + sampleSize: u32 + channels: u32 +} +export struct AudioStream +{ + buffer: ^rAudioBuffer + processor: ^rAudioProcessor + sampleRate: u32 + sampleSize: u32 + channels: u32 +} +export struct Sound +{ + stream: AudioStream + frameCount: u32 +} +export struct Sound +{ + stream: AudioStream + frameCount: u32 +} +export struct Music +{ + stream: AudioStream + frameCount: u32 + looping: bool + ctxType: i32 + ctxData: ^void +} +export struct Music +{ + stream: AudioStream + frameCount: u32 + looping: bool + ctxType: i32 + ctxData: ^void +} +export struct VrDeviceInfo +{ + hResolution: i32 + vResolution: i32 + hScreenSize: f32 + vScreenSize: f32 + eyeToScreenDistance: f32 + lensSeparationDistance: f32 + interpupillaryDistance: f32 + lensDistortionValues: [4]f32 + chromaAbCorrection: [4]f32 +} +export struct VrDeviceInfo +{ + hResolution: i32 + vResolution: i32 + hScreenSize: f32 + vScreenSize: f32 + eyeToScreenDistance: f32 + lensSeparationDistance: f32 + interpupillaryDistance: f32 + lensDistortionValues: [4]f32 + chromaAbCorrection: [4]f32 +} +export struct VrStereoConfig +{ + projection: [2]Matrix + viewOffset: [2]Matrix + leftLensCenter: [2]f32 + rightLensCenter: [2]f32 + leftScreenCenter: [2]f32 + rightScreenCenter: [2]f32 + scale: [2]f32 + scaleIn: [2]f32 +} +export struct VrStereoConfig +{ + projection: [2]Matrix + viewOffset: [2]Matrix + leftLensCenter: [2]f32 + rightLensCenter: [2]f32 + leftScreenCenter: [2]f32 + rightScreenCenter: [2]f32 + scale: [2]f32 + scaleIn: [2]f32 +} +export struct FilePathList +{ + capacity: u32 + count: u32 + paths: ^cstring +} +export struct FilePathList +{ + capacity: u32 + count: u32 + paths: ^cstring +} +export struct AutomationEvent +{ + frame: u32 + type: u32 + params: [4]i32 +} +export struct AutomationEvent +{ + frame: u32 + type: u32 + params: [4]i32 +} +export struct AutomationEventList +{ + capacity: u32 + count: u32 + events: ^AutomationEvent +} +export struct AutomationEventList +{ + capacity: u32 + count: u32 + events: ^AutomationEvent +} +export extern "InitWindow" func InitWindow(width: i32, height: i32, title: cstring): void +export extern "CloseWindow" func CloseWindow(): void +export extern "WindowShouldClose" func WindowShouldClose(): bool +export extern "IsWindowReady" func IsWindowReady(): bool +export extern "IsWindowFullscreen" func IsWindowFullscreen(): bool +export extern "IsWindowHidden" func IsWindowHidden(): bool +export extern "IsWindowMinimized" func IsWindowMinimized(): bool +export extern "IsWindowMaximized" func IsWindowMaximized(): bool +export extern "IsWindowFocused" func IsWindowFocused(): bool +export extern "IsWindowResized" func IsWindowResized(): bool +export extern "IsWindowState" func IsWindowState(flag: u32): bool +export extern "SetWindowState" func SetWindowState(flags: u32): void +export extern "ClearWindowState" func ClearWindowState(flags: u32): void +export extern "ToggleFullscreen" func ToggleFullscreen(): void +export extern "ToggleBorderlessWindowed" func ToggleBorderlessWindowed(): void +export extern "MaximizeWindow" func MaximizeWindow(): void +export extern "MinimizeWindow" func MinimizeWindow(): void +export extern "RestoreWindow" func RestoreWindow(): void +export extern "SetWindowIcon" func SetWindowIcon(image: Image): void +export extern "SetWindowIcons" func SetWindowIcons(images: ^Image, count: i32): void +export extern "SetWindowTitle" func SetWindowTitle(title: cstring): void +export extern "SetWindowPosition" func SetWindowPosition(x: i32, y: i32): void +export extern "SetWindowMonitor" func SetWindowMonitor(monitor: i32): void +export extern "SetWindowMinSize" func SetWindowMinSize(width: i32, height: i32): void +export extern "SetWindowMaxSize" func SetWindowMaxSize(width: i32, height: i32): void +export extern "SetWindowSize" func SetWindowSize(width: i32, height: i32): void +export extern "SetWindowOpacity" func SetWindowOpacity(opacity: f32): void +export extern "SetWindowFocused" func SetWindowFocused(): void +export extern "GetWindowHandle" func GetWindowHandle(): ^void +export extern "GetScreenWidth" func GetScreenWidth(): i32 +export extern "GetScreenHeight" func GetScreenHeight(): i32 +export extern "GetRenderWidth" func GetRenderWidth(): i32 +export extern "GetRenderHeight" func GetRenderHeight(): i32 +export extern "GetMonitorCount" func GetMonitorCount(): i32 +export extern "GetCurrentMonitor" func GetCurrentMonitor(): i32 +export extern "GetMonitorPosition" func GetMonitorPosition(monitor: i32): Vector2 +export extern "GetMonitorWidth" func GetMonitorWidth(monitor: i32): i32 +export extern "GetMonitorHeight" func GetMonitorHeight(monitor: i32): i32 +export extern "GetMonitorPhysicalWidth" func GetMonitorPhysicalWidth(monitor: i32): i32 +export extern "GetMonitorPhysicalHeight" func GetMonitorPhysicalHeight(monitor: i32): i32 +export extern "GetMonitorRefreshRate" func GetMonitorRefreshRate(monitor: i32): i32 +export extern "GetWindowPosition" func GetWindowPosition(): Vector2 +export extern "GetWindowScaleDPI" func GetWindowScaleDPI(): Vector2 +export extern "GetMonitorName" func GetMonitorName(monitor: i32): cstring +export extern "SetClipboardText" func SetClipboardText(text: cstring): void +export extern "GetClipboardText" func GetClipboardText(): cstring +export extern "GetClipboardImage" func GetClipboardImage(): Image +export extern "EnableEventWaiting" func EnableEventWaiting(): void +export extern "DisableEventWaiting" func DisableEventWaiting(): void +export extern "ShowCursor" func ShowCursor(): void +export extern "HideCursor" func HideCursor(): void +export extern "IsCursorHidden" func IsCursorHidden(): bool +export extern "EnableCursor" func EnableCursor(): void +export extern "DisableCursor" func DisableCursor(): void +export extern "IsCursorOnScreen" func IsCursorOnScreen(): bool +export extern "ClearBackground" func ClearBackground(color: Color): void +export extern "BeginDrawing" func BeginDrawing(): void +export extern "EndDrawing" func EndDrawing(): void +export extern "BeginMode2D" func BeginMode2D(camera: Camera2D): void +export extern "EndMode2D" func EndMode2D(): void +export extern "BeginMode3D" func BeginMode3D(camera: Camera3D): void +export extern "EndMode3D" func EndMode3D(): void +export extern "BeginTextureMode" func BeginTextureMode(target: RenderTexture): void +export extern "EndTextureMode" func EndTextureMode(): void +export extern "BeginShaderMode" func BeginShaderMode(shader: Shader): void +export extern "EndShaderMode" func EndShaderMode(): void +export extern "BeginBlendMode" func BeginBlendMode(mode: i32): void +export extern "EndBlendMode" func EndBlendMode(): void +export extern "BeginScissorMode" func BeginScissorMode(x: i32, y: i32, width: i32, height: i32): void +export extern "EndScissorMode" func EndScissorMode(): void +export extern "BeginVrStereoMode" func BeginVrStereoMode(config: VrStereoConfig): void +export extern "EndVrStereoMode" func EndVrStereoMode(): void +export extern "LoadVrStereoConfig" func LoadVrStereoConfig(device: VrDeviceInfo): VrStereoConfig +export extern "UnloadVrStereoConfig" func UnloadVrStereoConfig(config: VrStereoConfig): void +export extern "LoadShader" func LoadShader(vsFileName: cstring, fsFileName: cstring): Shader +export extern "LoadShaderFromMemory" func LoadShaderFromMemory(vsCode: cstring, fsCode: cstring): Shader +export extern "IsShaderValid" func IsShaderValid(shader: Shader): bool +export extern "GetShaderLocation" func GetShaderLocation(shader: Shader, uniformName: cstring): i32 +export extern "GetShaderLocationAttrib" func GetShaderLocationAttrib(shader: Shader, attribName: cstring): i32 +export extern "SetShaderValue" func SetShaderValue(shader: Shader, locIndex: i32, value: ^void, uniformType: i32): void +export extern "SetShaderValueV" func SetShaderValueV(shader: Shader, locIndex: i32, value: ^void, uniformType: i32, count: i32): void +export extern "SetShaderValueMatrix" func SetShaderValueMatrix(shader: Shader, locIndex: i32, mat: Matrix): void +export extern "SetShaderValueTexture" func SetShaderValueTexture(shader: Shader, locIndex: i32, texture: Texture): void +export extern "UnloadShader" func UnloadShader(shader: Shader): void +export extern "GetScreenToWorldRay" func GetScreenToWorldRay(position: Vector2, camera: Camera3D): Ray +export extern "GetScreenToWorldRayEx" func GetScreenToWorldRayEx(position: Vector2, camera: Camera3D, width: i32, height: i32): Ray +export extern "GetWorldToScreen" func GetWorldToScreen(position: Vector3, camera: Camera3D): Vector2 +export extern "GetWorldToScreenEx" func GetWorldToScreenEx(position: Vector3, camera: Camera3D, width: i32, height: i32): Vector2 +export extern "GetWorldToScreen2D" func GetWorldToScreen2D(position: Vector2, camera: Camera2D): Vector2 +export extern "GetScreenToWorld2D" func GetScreenToWorld2D(position: Vector2, camera: Camera2D): Vector2 +export extern "GetCameraMatrix" func GetCameraMatrix(camera: Camera3D): Matrix +export extern "GetCameraMatrix2D" func GetCameraMatrix2D(camera: Camera2D): Matrix +export extern "SetTargetFPS" func SetTargetFPS(fps: i32): void +export extern "GetFrameTime" func GetFrameTime(): f32 +export extern "GetTime" func GetTime(): f64 +export extern "GetFPS" func GetFPS(): i32 +export extern "SwapScreenBuffer" func SwapScreenBuffer(): void +export extern "PollInputEvents" func PollInputEvents(): void +export extern "WaitTime" func WaitTime(seconds: f64): void +export extern "SetRandomSeed" func SetRandomSeed(seed: u32): void +export extern "GetRandomValue" func GetRandomValue(min: i32, max: i32): i32 +export extern "LoadRandomSequence" func LoadRandomSequence(count: u32, min: i32, max: i32): ^i32 +export extern "UnloadRandomSequence" func UnloadRandomSequence(sequence: ^i32): void +export extern "TakeScreenshot" func TakeScreenshot(fileName: cstring): void +export extern "SetConfigFlags" func SetConfigFlags(flags: u32): void +export extern "OpenURL" func OpenURL(url: cstring): void +export extern "TraceLog" func TraceLog(logLevel: i32, text: cstring): void +export extern "SetTraceLogLevel" func SetTraceLogLevel(logLevel: i32): void +export extern "MemAlloc" func MemAlloc(size: u32): ^void +export extern "MemRealloc" func MemRealloc(ptr: ^void, size: u32): ^void +export extern "MemFree" func MemFree(ptr: ^void): void +export extern "SetTraceLogCallback" func SetTraceLogCallback(callback: func(i32, cstring, i32): void): void +export extern "SetLoadFileDataCallback" func SetLoadFileDataCallback(callback: func(cstring, ^i32): ^u8): void +export extern "SetSaveFileDataCallback" func SetSaveFileDataCallback(callback: func(cstring, ^void, i32): bool): void +export extern "SetLoadFileTextCallback" func SetLoadFileTextCallback(callback: func(cstring): cstring): void +export extern "SetSaveFileTextCallback" func SetSaveFileTextCallback(callback: func(cstring, cstring): bool): void +export extern "LoadFileData" func LoadFileData(fileName: cstring, dataSize: ^i32): ^u8 +export extern "UnloadFileData" func UnloadFileData(data: ^u8): void +export extern "SaveFileData" func SaveFileData(fileName: cstring, data: ^void, dataSize: i32): bool +export extern "ExportDataAsCode" func ExportDataAsCode(data: ^u8, dataSize: i32, fileName: cstring): bool +export extern "LoadFileText" func LoadFileText(fileName: cstring): cstring +export extern "UnloadFileText" func UnloadFileText(text: cstring): void +export extern "SaveFileText" func SaveFileText(fileName: cstring, text: cstring): bool +export extern "FileExists" func FileExists(fileName: cstring): bool +export extern "DirectoryExists" func DirectoryExists(dirPath: cstring): bool +export extern "IsFileExtension" func IsFileExtension(fileName: cstring, ext: cstring): bool +export extern "GetFileLength" func GetFileLength(fileName: cstring): i32 +export extern "GetFileExtension" func GetFileExtension(fileName: cstring): cstring +export extern "GetFileName" func GetFileName(filePath: cstring): cstring +export extern "GetFileNameWithoutExt" func GetFileNameWithoutExt(filePath: cstring): cstring +export extern "GetDirectoryPath" func GetDirectoryPath(filePath: cstring): cstring +export extern "GetPrevDirectoryPath" func GetPrevDirectoryPath(dirPath: cstring): cstring +export extern "GetWorkingDirectory" func GetWorkingDirectory(): cstring +export extern "GetApplicationDirectory" func GetApplicationDirectory(): cstring +export extern "MakeDirectory" func MakeDirectory(dirPath: cstring): i32 +export extern "ChangeDirectory" func ChangeDirectory(dir: cstring): bool +export extern "IsPathFile" func IsPathFile(path: cstring): bool +export extern "IsFileNameValid" func IsFileNameValid(fileName: cstring): bool +export extern "LoadDirectoryFiles" func LoadDirectoryFiles(dirPath: cstring): FilePathList +export extern "LoadDirectoryFilesEx" func LoadDirectoryFilesEx(basePath: cstring, filter: cstring, scanSubdirs: bool): FilePathList +export extern "UnloadDirectoryFiles" func UnloadDirectoryFiles(files: FilePathList): void +export extern "IsFileDropped" func IsFileDropped(): bool +export extern "LoadDroppedFiles" func LoadDroppedFiles(): FilePathList +export extern "UnloadDroppedFiles" func UnloadDroppedFiles(files: FilePathList): void +export extern "GetFileModTime" func GetFileModTime(fileName: cstring): i64 +export extern "CompressData" func CompressData(data: ^u8, dataSize: i32, compDataSize: ^i32): ^u8 +export extern "DecompressData" func DecompressData(compData: ^u8, compDataSize: i32, dataSize: ^i32): ^u8 +export extern "EncodeDataBase64" func EncodeDataBase64(data: ^u8, dataSize: i32, outputSize: ^i32): cstring +export extern "DecodeDataBase64" func DecodeDataBase64(data: ^u8, outputSize: ^i32): ^u8 +export extern "ComputeCRC32" func ComputeCRC32(data: ^u8, dataSize: i32): u32 +export extern "ComputeMD5" func ComputeMD5(data: ^u8, dataSize: i32): ^u32 +export extern "ComputeSHA1" func ComputeSHA1(data: ^u8, dataSize: i32): ^u32 +export extern "LoadAutomationEventList" func LoadAutomationEventList(fileName: cstring): AutomationEventList +export extern "UnloadAutomationEventList" func UnloadAutomationEventList(list: AutomationEventList): void +export extern "ExportAutomationEventList" func ExportAutomationEventList(list: AutomationEventList, fileName: cstring): bool +export extern "SetAutomationEventList" func SetAutomationEventList(list: ^AutomationEventList): void +export extern "SetAutomationEventBaseFrame" func SetAutomationEventBaseFrame(frame: i32): void +export extern "StartAutomationEventRecording" func StartAutomationEventRecording(): void +export extern "StopAutomationEventRecording" func StopAutomationEventRecording(): void +export extern "PlayAutomationEvent" func PlayAutomationEvent(event: AutomationEvent): void +export extern "IsKeyPressed" func IsKeyPressed(key: i32): bool +export extern "IsKeyPressedRepeat" func IsKeyPressedRepeat(key: i32): bool +export extern "IsKeyDown" func IsKeyDown(key: i32): bool +export extern "IsKeyReleased" func IsKeyReleased(key: i32): bool +export extern "IsKeyUp" func IsKeyUp(key: i32): bool +export extern "GetKeyPressed" func GetKeyPressed(): i32 +export extern "GetCharPressed" func GetCharPressed(): i32 +export extern "SetExitKey" func SetExitKey(key: i32): void +export extern "IsGamepadAvailable" func IsGamepadAvailable(gamepad: i32): bool +export extern "GetGamepadName" func GetGamepadName(gamepad: i32): cstring +export extern "IsGamepadButtonPressed" func IsGamepadButtonPressed(gamepad: i32, button: i32): bool +export extern "IsGamepadButtonDown" func IsGamepadButtonDown(gamepad: i32, button: i32): bool +export extern "IsGamepadButtonReleased" func IsGamepadButtonReleased(gamepad: i32, button: i32): bool +export extern "IsGamepadButtonUp" func IsGamepadButtonUp(gamepad: i32, button: i32): bool +export extern "GetGamepadButtonPressed" func GetGamepadButtonPressed(): i32 +export extern "GetGamepadAxisCount" func GetGamepadAxisCount(gamepad: i32): i32 +export extern "GetGamepadAxisMovement" func GetGamepadAxisMovement(gamepad: i32, axis: i32): f32 +export extern "SetGamepadMappings" func SetGamepadMappings(mappings: cstring): i32 +export extern "SetGamepadVibration" func SetGamepadVibration(gamepad: i32, leftMotor: f32, rightMotor: f32, duration: f32): void +export extern "IsMouseButtonPressed" func IsMouseButtonPressed(button: i32): bool +export extern "IsMouseButtonDown" func IsMouseButtonDown(button: i32): bool +export extern "IsMouseButtonReleased" func IsMouseButtonReleased(button: i32): bool +export extern "IsMouseButtonUp" func IsMouseButtonUp(button: i32): bool +export extern "GetMouseX" func GetMouseX(): i32 +export extern "GetMouseY" func GetMouseY(): i32 +export extern "GetMousePosition" func GetMousePosition(): Vector2 +export extern "GetMouseDelta" func GetMouseDelta(): Vector2 +export extern "SetMousePosition" func SetMousePosition(x: i32, y: i32): void +export extern "SetMouseOffset" func SetMouseOffset(offsetX: i32, offsetY: i32): void +export extern "SetMouseScale" func SetMouseScale(scaleX: f32, scaleY: f32): void +export extern "GetMouseWheelMove" func GetMouseWheelMove(): f32 +export extern "GetMouseWheelMoveV" func GetMouseWheelMoveV(): Vector2 +export extern "SetMouseCursor" func SetMouseCursor(cursor: i32): void +export extern "GetTouchX" func GetTouchX(): i32 +export extern "GetTouchY" func GetTouchY(): i32 +export extern "GetTouchPosition" func GetTouchPosition(index: i32): Vector2 +export extern "GetTouchPointId" func GetTouchPointId(index: i32): i32 +export extern "GetTouchPointCount" func GetTouchPointCount(): i32 +export extern "SetGesturesEnabled" func SetGesturesEnabled(flags: u32): void +export extern "IsGestureDetected" func IsGestureDetected(gesture: u32): bool +export extern "GetGestureDetected" func GetGestureDetected(): i32 +export extern "GetGestureHoldDuration" func GetGestureHoldDuration(): f32 +export extern "GetGestureDragVector" func GetGestureDragVector(): Vector2 +export extern "GetGestureDragAngle" func GetGestureDragAngle(): f32 +export extern "GetGesturePinchVector" func GetGesturePinchVector(): Vector2 +export extern "GetGesturePinchAngle" func GetGesturePinchAngle(): f32 +export extern "UpdateCamera" func UpdateCamera(camera: ^Camera3D, mode: i32): void +export extern "UpdateCameraPro" func UpdateCameraPro(camera: ^Camera3D, movement: Vector3, rotation: Vector3, zoom: f32): void +export extern "SetShapesTexture" func SetShapesTexture(texture: Texture, source: Rectangle): void +export extern "GetShapesTexture" func GetShapesTexture(): Texture +export extern "GetShapesTextureRectangle" func GetShapesTextureRectangle(): Rectangle +export extern "DrawPixel" func DrawPixel(posX: i32, posY: i32, color: Color): void +export extern "DrawPixelV" func DrawPixelV(position: Vector2, color: Color): void +export extern "DrawLine" func DrawLine(startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color): void +export extern "DrawLineV" func DrawLineV(startPos: Vector2, endPos: Vector2, color: Color): void +export extern "DrawLineEx" func DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color): void +export extern "DrawLineStrip" func DrawLineStrip(points: ^Vector2, pointCount: i32, color: Color): void +export extern "DrawLineBezier" func DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color): void +export extern "DrawCircle" func DrawCircle(centerX: i32, centerY: i32, radius: f32, color: Color): void +export extern "DrawCircleSector" func DrawCircleSector(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color): void +export extern "DrawCircleSectorLines" func DrawCircleSectorLines(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color): void +export extern "DrawCircleGradient" func DrawCircleGradient(centerX: i32, centerY: i32, radius: f32, inner: Color, outer: Color): void +export extern "DrawCircleV" func DrawCircleV(center: Vector2, radius: f32, color: Color): void +export extern "DrawCircleLines" func DrawCircleLines(centerX: i32, centerY: i32, radius: f32, color: Color): void +export extern "DrawCircleLinesV" func DrawCircleLinesV(center: Vector2, radius: f32, color: Color): void +export extern "DrawEllipse" func DrawEllipse(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color): void +export extern "DrawEllipseLines" func DrawEllipseLines(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color): void +export extern "DrawRing" func DrawRing(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color): void +export extern "DrawRingLines" func DrawRingLines(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color): void +export extern "DrawRectangle" func DrawRectangle(posX: i32, posY: i32, width: i32, height: i32, color: Color): void +export extern "DrawRectangleV" func DrawRectangleV(position: Vector2, size: Vector2, color: Color): void +export extern "DrawRectangleRec" func DrawRectangleRec(rec: Rectangle, color: Color): void +export extern "DrawRectanglePro" func DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color): void +export extern "DrawRectangleGradientV" func DrawRectangleGradientV(posX: i32, posY: i32, width: i32, height: i32, top: Color, bottom: Color): void +export extern "DrawRectangleGradientH" func DrawRectangleGradientH(posX: i32, posY: i32, width: i32, height: i32, left: Color, right: Color): void +export extern "DrawRectangleGradientEx" func DrawRectangleGradientEx(rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color): void +export extern "DrawRectangleLines" func DrawRectangleLines(posX: i32, posY: i32, width: i32, height: i32, color: Color): void +export extern "DrawRectangleLinesEx" func DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color): void +export extern "DrawRectangleRounded" func DrawRectangleRounded(rec: Rectangle, roundness: f32, segments: i32, color: Color): void +export extern "DrawRectangleRoundedLines" func DrawRectangleRoundedLines(rec: Rectangle, roundness: f32, segments: i32, color: Color): void +export extern "DrawRectangleRoundedLinesEx" func DrawRectangleRoundedLinesEx(rec: Rectangle, roundness: f32, segments: i32, lineThick: f32, color: Color): void +export extern "DrawTriangle" func DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void +export extern "DrawTriangleLines" func DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void +export extern "DrawTriangleFan" func DrawTriangleFan(points: ^Vector2, pointCount: i32, color: Color): void +export extern "DrawTriangleStrip" func DrawTriangleStrip(points: ^Vector2, pointCount: i32, color: Color): void +export extern "DrawPoly" func DrawPoly(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color): void +export extern "DrawPolyLines" func DrawPolyLines(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color): void +export extern "DrawPolyLinesEx" func DrawPolyLinesEx(center: Vector2, sides: i32, radius: f32, rotation: f32, lineThick: f32, color: Color): void +export extern "DrawSplineLinear" func DrawSplineLinear(points: ^Vector2, pointCount: i32, thick: f32, color: Color): void +export extern "DrawSplineBasis" func DrawSplineBasis(points: ^Vector2, pointCount: i32, thick: f32, color: Color): void +export extern "DrawSplineCatmullRom" func DrawSplineCatmullRom(points: ^Vector2, pointCount: i32, thick: f32, color: Color): void +export extern "DrawSplineBezierQuadratic" func DrawSplineBezierQuadratic(points: ^Vector2, pointCount: i32, thick: f32, color: Color): void +export extern "DrawSplineBezierCubic" func DrawSplineBezierCubic(points: ^Vector2, pointCount: i32, thick: f32, color: Color): void +export extern "DrawSplineSegmentLinear" func DrawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color): void +export extern "DrawSplineSegmentBasis" func DrawSplineSegmentBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color): void +export extern "DrawSplineSegmentCatmullRom" func DrawSplineSegmentCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color): void +export extern "DrawSplineSegmentBezierQuadratic" func DrawSplineSegmentBezierQuadratic(p1: Vector2, c2: Vector2, p3: Vector2, thick: f32, color: Color): void +export extern "DrawSplineSegmentBezierCubic" func DrawSplineSegmentBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: f32, color: Color): void +export extern "GetSplinePointLinear" func GetSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32): Vector2 +export extern "GetSplinePointBasis" func GetSplinePointBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32): Vector2 +export extern "GetSplinePointCatmullRom" func GetSplinePointCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32): Vector2 +export extern "GetSplinePointBezierQuad" func GetSplinePointBezierQuad(p1: Vector2, c2: Vector2, p3: Vector2, t: f32): Vector2 +export extern "GetSplinePointBezierCubic" func GetSplinePointBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: f32): Vector2 +export extern "CheckCollisionRecs" func CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle): bool +export extern "CheckCollisionCircles" func CheckCollisionCircles(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32): bool +export extern "CheckCollisionCircleRec" func CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle): bool +export extern "CheckCollisionCircleLine" func CheckCollisionCircleLine(center: Vector2, radius: f32, p1: Vector2, p2: Vector2): bool +export extern "CheckCollisionPointRec" func CheckCollisionPointRec(point: Vector2, rec: Rectangle): bool +export extern "CheckCollisionPointCircle" func CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32): bool +export extern "CheckCollisionPointTriangle" func CheckCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): bool +export extern "CheckCollisionPointLine" func CheckCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: i32): bool +export extern "CheckCollisionPointPoly" func CheckCollisionPointPoly(point: Vector2, points: ^Vector2, pointCount: i32): bool +export extern "CheckCollisionLines" func CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: ^Vector2): bool +export extern "GetCollisionRec" func GetCollisionRec(rec1: Rectangle, rec2: Rectangle): Rectangle +export extern "LoadImage" func LoadImage(fileName: cstring): Image +export extern "LoadImageRaw" func LoadImageRaw(fileName: cstring, width: i32, height: i32, format: i32, headerSize: i32): Image +export extern "LoadImageAnim" func LoadImageAnim(fileName: cstring, frames: ^i32): Image +export extern "LoadImageAnimFromMemory" func LoadImageAnimFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32, frames: ^i32): Image +export extern "LoadImageFromMemory" func LoadImageFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32): Image +export extern "LoadImageFromTexture" func LoadImageFromTexture(texture: Texture): Image +export extern "LoadImageFromScreen" func LoadImageFromScreen(): Image +export extern "IsImageValid" func IsImageValid(image: Image): bool +export extern "UnloadImage" func UnloadImage(image: Image): void +export extern "ExportImage" func ExportImage(image: Image, fileName: cstring): bool +export extern "ExportImageToMemory" func ExportImageToMemory(image: Image, fileType: cstring, fileSize: ^i32): ^u8 +export extern "ExportImageAsCode" func ExportImageAsCode(image: Image, fileName: cstring): bool +export extern "GenImageColor" func GenImageColor(width: i32, height: i32, color: Color): Image +export extern "GenImageGradientLinear" func GenImageGradientLinear(width: i32, height: i32, direction: i32, start: Color, end: Color): Image +export extern "GenImageGradientRadial" func GenImageGradientRadial(width: i32, height: i32, density: f32, inner: Color, outer: Color): Image +export extern "GenImageGradientSquare" func GenImageGradientSquare(width: i32, height: i32, density: f32, inner: Color, outer: Color): Image +export extern "GenImageChecked" func GenImageChecked(width: i32, height: i32, checksX: i32, checksY: i32, col1: Color, col2: Color): Image +export extern "GenImageWhiteNoise" func GenImageWhiteNoise(width: i32, height: i32, factor: f32): Image +export extern "GenImagePerlinNoise" func GenImagePerlinNoise(width: i32, height: i32, offsetX: i32, offsetY: i32, scale: f32): Image +export extern "GenImageCellular" func GenImageCellular(width: i32, height: i32, tileSize: i32): Image +export extern "GenImageText" func GenImageText(width: i32, height: i32, text: cstring): Image +export extern "ImageCopy" func ImageCopy(image: Image): Image +export extern "ImageFromImage" func ImageFromImage(image: Image, rec: Rectangle): Image +export extern "ImageFromChannel" func ImageFromChannel(image: Image, selectedChannel: i32): Image +export extern "ImageText" func ImageText(text: cstring, fontSize: i32, color: Color): Image +export extern "ImageTextEx" func ImageTextEx(font: Font, text: cstring, fontSize: f32, spacing: f32, tint: Color): Image +export extern "ImageFormat" func ImageFormat(image: ^Image, newFormat: i32): void +export extern "ImageToPOT" func ImageToPOT(image: ^Image, fill: Color): void +export extern "ImageCrop" func ImageCrop(image: ^Image, crop: Rectangle): void +export extern "ImageAlphaCrop" func ImageAlphaCrop(image: ^Image, threshold: f32): void +export extern "ImageAlphaClear" func ImageAlphaClear(image: ^Image, color: Color, threshold: f32): void +export extern "ImageAlphaMask" func ImageAlphaMask(image: ^Image, alphaMask: Image): void +export extern "ImageAlphaPremultiply" func ImageAlphaPremultiply(image: ^Image): void +export extern "ImageBlurGaussian" func ImageBlurGaussian(image: ^Image, blurSize: i32): void +export extern "ImageKernelConvolution" func ImageKernelConvolution(image: ^Image, kernel: ^f32, kernelSize: i32): void +export extern "ImageResize" func ImageResize(image: ^Image, newWidth: i32, newHeight: i32): void +export extern "ImageResizeNN" func ImageResizeNN(image: ^Image, newWidth: i32, newHeight: i32): void +export extern "ImageResizeCanvas" func ImageResizeCanvas(image: ^Image, newWidth: i32, newHeight: i32, offsetX: i32, offsetY: i32, fill: Color): void +export extern "ImageMipmaps" func ImageMipmaps(image: ^Image): void +export extern "ImageDither" func ImageDither(image: ^Image, rBpp: i32, gBpp: i32, bBpp: i32, aBpp: i32): void +export extern "ImageFlipVertical" func ImageFlipVertical(image: ^Image): void +export extern "ImageFlipHorizontal" func ImageFlipHorizontal(image: ^Image): void +export extern "ImageRotate" func ImageRotate(image: ^Image, degrees: i32): void +export extern "ImageRotateCW" func ImageRotateCW(image: ^Image): void +export extern "ImageRotateCCW" func ImageRotateCCW(image: ^Image): void +export extern "ImageColorTint" func ImageColorTint(image: ^Image, color: Color): void +export extern "ImageColorInvert" func ImageColorInvert(image: ^Image): void +export extern "ImageColorGrayscale" func ImageColorGrayscale(image: ^Image): void +export extern "ImageColorContrast" func ImageColorContrast(image: ^Image, contrast: f32): void +export extern "ImageColorBrightness" func ImageColorBrightness(image: ^Image, brightness: i32): void +export extern "ImageColorReplace" func ImageColorReplace(image: ^Image, color: Color, replace: Color): void +export extern "LoadImageColors" func LoadImageColors(image: Image): ^Color +export extern "LoadImagePalette" func LoadImagePalette(image: Image, maxPaletteSize: i32, colorCount: ^i32): ^Color +export extern "UnloadImageColors" func UnloadImageColors(colors: ^Color): void +export extern "UnloadImagePalette" func UnloadImagePalette(colors: ^Color): void +export extern "GetImageAlphaBorder" func GetImageAlphaBorder(image: Image, threshold: f32): Rectangle +export extern "GetImageColor" func GetImageColor(image: Image, x: i32, y: i32): Color +export extern "ImageClearBackground" func ImageClearBackground(dst: ^Image, color: Color): void +export extern "ImageDrawPixel" func ImageDrawPixel(dst: ^Image, posX: i32, posY: i32, color: Color): void +export extern "ImageDrawPixelV" func ImageDrawPixelV(dst: ^Image, position: Vector2, color: Color): void +export extern "ImageDrawLine" func ImageDrawLine(dst: ^Image, startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color): void +export extern "ImageDrawLineV" func ImageDrawLineV(dst: ^Image, start: Vector2, end: Vector2, color: Color): void +export extern "ImageDrawLineEx" func ImageDrawLineEx(dst: ^Image, start: Vector2, end: Vector2, thick: i32, color: Color): void +export extern "ImageDrawCircle" func ImageDrawCircle(dst: ^Image, centerX: i32, centerY: i32, radius: i32, color: Color): void +export extern "ImageDrawCircleV" func ImageDrawCircleV(dst: ^Image, center: Vector2, radius: i32, color: Color): void +export extern "ImageDrawCircleLines" func ImageDrawCircleLines(dst: ^Image, centerX: i32, centerY: i32, radius: i32, color: Color): void +export extern "ImageDrawCircleLinesV" func ImageDrawCircleLinesV(dst: ^Image, center: Vector2, radius: i32, color: Color): void +export extern "ImageDrawRectangle" func ImageDrawRectangle(dst: ^Image, posX: i32, posY: i32, width: i32, height: i32, color: Color): void +export extern "ImageDrawRectangleV" func ImageDrawRectangleV(dst: ^Image, position: Vector2, size: Vector2, color: Color): void +export extern "ImageDrawRectangleRec" func ImageDrawRectangleRec(dst: ^Image, rec: Rectangle, color: Color): void +export extern "ImageDrawRectangleLines" func ImageDrawRectangleLines(dst: ^Image, rec: Rectangle, thick: i32, color: Color): void +export extern "ImageDrawTriangle" func ImageDrawTriangle(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void +export extern "ImageDrawTriangleEx" func ImageDrawTriangleEx(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color): void +export extern "ImageDrawTriangleLines" func ImageDrawTriangleLines(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void +export extern "ImageDrawTriangleFan" func ImageDrawTriangleFan(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color): void +export extern "ImageDrawTriangleStrip" func ImageDrawTriangleStrip(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color): void +export extern "ImageDraw" func ImageDraw(dst: ^Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color): void +export extern "ImageDrawText" func ImageDrawText(dst: ^Image, text: cstring, posX: i32, posY: i32, fontSize: i32, color: Color): void +export extern "ImageDrawTextEx" func ImageDrawTextEx(dst: ^Image, font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void +export extern "LoadTexture" func LoadTexture(fileName: cstring): Texture +export extern "LoadTextureFromImage" func LoadTextureFromImage(image: Image): Texture +export extern "LoadTextureCubemap" func LoadTextureCubemap(image: Image, layout: i32): Texture +export extern "LoadRenderTexture" func LoadRenderTexture(width: i32, height: i32): RenderTexture +export extern "IsTextureValid" func IsTextureValid(texture: Texture): bool +export extern "UnloadTexture" func UnloadTexture(texture: Texture): void +export extern "IsRenderTextureValid" func IsRenderTextureValid(target: RenderTexture): bool +export extern "UnloadRenderTexture" func UnloadRenderTexture(target: RenderTexture): void +export extern "UpdateTexture" func UpdateTexture(texture: Texture, pixels: ^void): void +export extern "UpdateTextureRec" func UpdateTextureRec(texture: Texture, rec: Rectangle, pixels: ^void): void +export extern "GenTextureMipmaps" func GenTextureMipmaps(texture: ^Texture): void +export extern "SetTextureFilter" func SetTextureFilter(texture: Texture, filter: i32): void +export extern "SetTextureWrap" func SetTextureWrap(texture: Texture, wrap: i32): void +export extern "DrawTexture" func DrawTexture(texture: Texture, posX: i32, posY: i32, tint: Color): void +export extern "DrawTextureV" func DrawTextureV(texture: Texture, position: Vector2, tint: Color): void +export extern "DrawTextureEx" func DrawTextureEx(texture: Texture, position: Vector2, rotation: f32, scale: f32, tint: Color): void +export extern "DrawTextureRec" func DrawTextureRec(texture: Texture, source: Rectangle, position: Vector2, tint: Color): void +export extern "DrawTexturePro" func DrawTexturePro(texture: Texture, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color): void +export extern "DrawTextureNPatch" func DrawTextureNPatch(texture: Texture, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color): void +export extern "ColorIsEqual" func ColorIsEqual(col1: Color, col2: Color): bool +export extern "Fade" func Fade(color: Color, alpha: f32): Color +export extern "ColorToInt" func ColorToInt(color: Color): i32 +export extern "ColorNormalize" func ColorNormalize(color: Color): Vector4 +export extern "ColorFromNormalized" func ColorFromNormalized(normalized: Vector4): Color +export extern "ColorToHSV" func ColorToHSV(color: Color): Vector3 +export extern "ColorFromHSV" func ColorFromHSV(hue: f32, saturation: f32, value: f32): Color +export extern "ColorTint" func ColorTint(color: Color, tint: Color): Color +export extern "ColorBrightness" func ColorBrightness(color: Color, factor: f32): Color +export extern "ColorContrast" func ColorContrast(color: Color, contrast: f32): Color +export extern "ColorAlpha" func ColorAlpha(color: Color, alpha: f32): Color +export extern "ColorAlphaBlend" func ColorAlphaBlend(dst: Color, src: Color, tint: Color): Color +export extern "ColorLerp" func ColorLerp(color1: Color, color2: Color, factor: f32): Color +export extern "GetColor" func GetColor(hexValue: u32): Color +export extern "GetPixelColor" func GetPixelColor(srcPtr: ^void, format: i32): Color +export extern "SetPixelColor" func SetPixelColor(dstPtr: ^void, color: Color, format: i32): void +export extern "GetPixelDataSize" func GetPixelDataSize(width: i32, height: i32, format: i32): i32 +export extern "GetFontDefault" func GetFontDefault(): Font +export extern "LoadFont" func LoadFont(fileName: cstring): Font +export extern "LoadFontEx" func LoadFontEx(fileName: cstring, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font +export extern "LoadFontFromImage" func LoadFontFromImage(image: Image, key: Color, firstChar: i32): Font +export extern "LoadFontFromMemory" func LoadFontFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font +export extern "IsFontValid" func IsFontValid(font: Font): bool +export extern "LoadFontData" func LoadFontData(fileData: ^u8, dataSize: i32, fontSize: i32, codepoints: ^i32, codepointCount: i32, type: i32): ^GlyphInfo +export extern "GenImageFontAtlas" func GenImageFontAtlas(glyphs: ^GlyphInfo, glyphRecs: ^^Rectangle, glyphCount: i32, fontSize: i32, padding: i32, packMethod: i32): Image +export extern "UnloadFontData" func UnloadFontData(glyphs: ^GlyphInfo, glyphCount: i32): void +export extern "UnloadFont" func UnloadFont(font: Font): void +export extern "ExportFontAsCode" func ExportFontAsCode(font: Font, fileName: cstring): bool +export extern "DrawFPS" func DrawFPS(posX: i32, posY: i32): void +export extern "DrawText" func DrawText(text: cstring, posX: i32, posY: i32, fontSize: i32, color: Color): void +export extern "DrawTextEx" func DrawTextEx(font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void +export extern "DrawTextPro" func DrawTextPro(font: Font, text: cstring, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color): void +export extern "DrawTextCodepoint" func DrawTextCodepoint(font: Font, codepoint: i32, position: Vector2, fontSize: f32, tint: Color): void +export extern "DrawTextCodepoints" func DrawTextCodepoints(font: Font, codepoints: ^i32, codepointCount: i32, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void +export extern "SetTextLineSpacing" func SetTextLineSpacing(spacing: i32): void +export extern "MeasureText" func MeasureText(text: cstring, fontSize: i32): i32 +export extern "MeasureTextEx" func MeasureTextEx(font: Font, text: cstring, fontSize: f32, spacing: f32): Vector2 +export extern "GetGlyphIndex" func GetGlyphIndex(font: Font, codepoint: i32): i32 +export extern "GetGlyphInfo" func GetGlyphInfo(font: Font, codepoint: i32): GlyphInfo +export extern "GetGlyphAtlasRec" func GetGlyphAtlasRec(font: Font, codepoint: i32): Rectangle +export extern "LoadUTF8" func LoadUTF8(codepoints: ^i32, length: i32): cstring +export extern "UnloadUTF8" func UnloadUTF8(text: cstring): void +export extern "LoadCodepoints" func LoadCodepoints(text: cstring, count: ^i32): ^i32 +export extern "UnloadCodepoints" func UnloadCodepoints(codepoints: ^i32): void +export extern "GetCodepointCount" func GetCodepointCount(text: cstring): i32 +export extern "GetCodepoint" func GetCodepoint(text: cstring, codepointSize: ^i32): i32 +export extern "GetCodepointNext" func GetCodepointNext(text: cstring, codepointSize: ^i32): i32 +export extern "GetCodepointPrevious" func GetCodepointPrevious(text: cstring, codepointSize: ^i32): i32 +export extern "CodepointToUTF8" func CodepointToUTF8(codepoint: i32, utf8Size: ^i32): cstring +export extern "TextCopy" func TextCopy(dst: cstring, src: cstring): i32 +export extern "TextIsEqual" func TextIsEqual(text1: cstring, text2: cstring): bool +export extern "TextLength" func TextLength(text: cstring): u32 +export extern "TextFormat" func TextFormat(text: cstring): cstring +export extern "TextSubtext" func TextSubtext(text: cstring, position: i32, length: i32): cstring +export extern "TextReplace" func TextReplace(text: cstring, replace: cstring, by: cstring): cstring +export extern "TextInsert" func TextInsert(text: cstring, insert: cstring, position: i32): cstring +export extern "TextJoin" func TextJoin(textList: ^cstring, count: i32, delimiter: cstring): cstring +export extern "TextSplit" func TextSplit(text: cstring, delimiter: i8, count: ^i32): ^cstring +export extern "TextAppend" func TextAppend(text: cstring, append: cstring, position: ^i32): void +export extern "TextFindIndex" func TextFindIndex(text: cstring, find: cstring): i32 +export extern "TextToUpper" func TextToUpper(text: cstring): cstring +export extern "TextToLower" func TextToLower(text: cstring): cstring +export extern "TextToPascal" func TextToPascal(text: cstring): cstring +export extern "TextToSnake" func TextToSnake(text: cstring): cstring +export extern "TextToCamel" func TextToCamel(text: cstring): cstring +export extern "TextToInteger" func TextToInteger(text: cstring): i32 +export extern "TextToFloat" func TextToFloat(text: cstring): f32 +export extern "DrawLine3D" func DrawLine3D(startPos: Vector3, endPos: Vector3, color: Color): void +export extern "DrawPoint3D" func DrawPoint3D(position: Vector3, color: Color): void +export extern "DrawCircle3D" func DrawCircle3D(center: Vector3, radius: f32, rotationAxis: Vector3, rotationAngle: f32, color: Color): void +export extern "DrawTriangle3D" func DrawTriangle3D(v1: Vector3, v2: Vector3, v3: Vector3, color: Color): void +export extern "DrawTriangleStrip3D" func DrawTriangleStrip3D(points: ^Vector3, pointCount: i32, color: Color): void +export extern "DrawCube" func DrawCube(position: Vector3, width: f32, height: f32, length: f32, color: Color): void +export extern "DrawCubeV" func DrawCubeV(position: Vector3, size: Vector3, color: Color): void +export extern "DrawCubeWires" func DrawCubeWires(position: Vector3, width: f32, height: f32, length: f32, color: Color): void +export extern "DrawCubeWiresV" func DrawCubeWiresV(position: Vector3, size: Vector3, color: Color): void +export extern "DrawSphere" func DrawSphere(centerPos: Vector3, radius: f32, color: Color): void +export extern "DrawSphereEx" func DrawSphereEx(centerPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color): void +export extern "DrawSphereWires" func DrawSphereWires(centerPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color): void +export extern "DrawCylinder" func DrawCylinder(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, slices: i32, color: Color): void +export extern "DrawCylinderEx" func DrawCylinderEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: i32, color: Color): void +export extern "DrawCylinderWires" func DrawCylinderWires(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, slices: i32, color: Color): void +export extern "DrawCylinderWiresEx" func DrawCylinderWiresEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: i32, color: Color): void +export extern "DrawCapsule" func DrawCapsule(startPos: Vector3, endPos: Vector3, radius: f32, slices: i32, rings: i32, color: Color): void +export extern "DrawCapsuleWires" func DrawCapsuleWires(startPos: Vector3, endPos: Vector3, radius: f32, slices: i32, rings: i32, color: Color): void +export extern "DrawPlane" func DrawPlane(centerPos: Vector3, size: Vector2, color: Color): void +export extern "DrawRay" func DrawRay(ray: Ray, color: Color): void +export extern "DrawGrid" func DrawGrid(slices: i32, spacing: f32): void +export extern "LoadModel" func LoadModel(fileName: cstring): Model +export extern "LoadModelFromMesh" func LoadModelFromMesh(mesh: Mesh): Model +export extern "IsModelValid" func IsModelValid(model: Model): bool +export extern "UnloadModel" func UnloadModel(model: Model): void +export extern "GetModelBoundingBox" func GetModelBoundingBox(model: Model): BoundingBox +export extern "DrawModel" func DrawModel(model: Model, position: Vector3, scale: f32, tint: Color): void +export extern "DrawModelEx" func DrawModelEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color): void +export extern "DrawModelWires" func DrawModelWires(model: Model, position: Vector3, scale: f32, tint: Color): void +export extern "DrawModelWiresEx" func DrawModelWiresEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color): void +export extern "DrawModelPoints" func DrawModelPoints(model: Model, position: Vector3, scale: f32, tint: Color): void +export extern "DrawModelPointsEx" func DrawModelPointsEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color): void +export extern "DrawBoundingBox" func DrawBoundingBox(box: BoundingBox, color: Color): void +export extern "DrawBillboard" func DrawBillboard(camera: Camera3D, texture: Texture, position: Vector3, scale: f32, tint: Color): void +export extern "DrawBillboardRec" func DrawBillboardRec(camera: Camera3D, texture: Texture, source: Rectangle, position: Vector3, size: Vector2, tint: Color): void +export extern "DrawBillboardPro" func DrawBillboardPro(camera: Camera3D, texture: Texture, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: f32, tint: Color): void +export extern "UploadMesh" func UploadMesh(mesh: ^Mesh, dynamic: bool): void +export extern "UpdateMeshBuffer" func UpdateMeshBuffer(mesh: Mesh, index: i32, data: ^void, dataSize: i32, offset: i32): void +export extern "UnloadMesh" func UnloadMesh(mesh: Mesh): void +export extern "DrawMesh" func DrawMesh(mesh: Mesh, material: Material, transform: Matrix): void +export extern "DrawMeshInstanced" func DrawMeshInstanced(mesh: Mesh, material: Material, transforms: ^Matrix, instances: i32): void +export extern "GetMeshBoundingBox" func GetMeshBoundingBox(mesh: Mesh): BoundingBox +export extern "GenMeshTangents" func GenMeshTangents(mesh: ^Mesh): void +export extern "ExportMesh" func ExportMesh(mesh: Mesh, fileName: cstring): bool +export extern "ExportMeshAsCode" func ExportMeshAsCode(mesh: Mesh, fileName: cstring): bool +export extern "GenMeshPoly" func GenMeshPoly(sides: i32, radius: f32): Mesh +export extern "GenMeshPlane" func GenMeshPlane(width: f32, length: f32, resX: i32, resZ: i32): Mesh +export extern "GenMeshCube" func GenMeshCube(width: f32, height: f32, length: f32): Mesh +export extern "GenMeshSphere" func GenMeshSphere(radius: f32, rings: i32, slices: i32): Mesh +export extern "GenMeshHemiSphere" func GenMeshHemiSphere(radius: f32, rings: i32, slices: i32): Mesh +export extern "GenMeshCylinder" func GenMeshCylinder(radius: f32, height: f32, slices: i32): Mesh +export extern "GenMeshCone" func GenMeshCone(radius: f32, height: f32, slices: i32): Mesh +export extern "GenMeshTorus" func GenMeshTorus(radius: f32, size: f32, radSeg: i32, sides: i32): Mesh +export extern "GenMeshKnot" func GenMeshKnot(radius: f32, size: f32, radSeg: i32, sides: i32): Mesh +export extern "GenMeshHeightmap" func GenMeshHeightmap(heightmap: Image, size: Vector3): Mesh +export extern "GenMeshCubicmap" func GenMeshCubicmap(cubicmap: Image, cubeSize: Vector3): Mesh +export extern "LoadMaterials" func LoadMaterials(fileName: cstring, materialCount: ^i32): ^Material +export extern "LoadMaterialDefault" func LoadMaterialDefault(): Material +export extern "IsMaterialValid" func IsMaterialValid(material: Material): bool +export extern "UnloadMaterial" func UnloadMaterial(material: Material): void +export extern "SetMaterialTexture" func SetMaterialTexture(material: ^Material, mapType: i32, texture: Texture): void +export extern "SetModelMeshMaterial" func SetModelMeshMaterial(model: ^Model, meshId: i32, materialId: i32): void +export extern "LoadModelAnimations" func LoadModelAnimations(fileName: cstring, animCount: ^i32): ^ModelAnimation +export extern "UpdateModelAnimation" func UpdateModelAnimation(model: Model, anim: ModelAnimation, frame: i32): void +export extern "UpdateModelAnimationBones" func UpdateModelAnimationBones(model: Model, anim: ModelAnimation, frame: i32): void +export extern "UnloadModelAnimation" func UnloadModelAnimation(anim: ModelAnimation): void +export extern "UnloadModelAnimations" func UnloadModelAnimations(animations: ^ModelAnimation, animCount: i32): void +export extern "IsModelAnimationValid" func IsModelAnimationValid(model: Model, anim: ModelAnimation): bool +export extern "CheckCollisionSpheres" func CheckCollisionSpheres(center1: Vector3, radius1: f32, center2: Vector3, radius2: f32): bool +export extern "CheckCollisionBoxes" func CheckCollisionBoxes(box1: BoundingBox, box2: BoundingBox): bool +export extern "CheckCollisionBoxSphere" func CheckCollisionBoxSphere(box: BoundingBox, center: Vector3, radius: f32): bool +export extern "GetRayCollisionSphere" func GetRayCollisionSphere(ray: Ray, center: Vector3, radius: f32): RayCollision +export extern "GetRayCollisionBox" func GetRayCollisionBox(ray: Ray, box: BoundingBox): RayCollision +export extern "GetRayCollisionMesh" func GetRayCollisionMesh(ray: Ray, mesh: Mesh, transform: Matrix): RayCollision +export extern "GetRayCollisionTriangle" func GetRayCollisionTriangle(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3): RayCollision +export extern "GetRayCollisionQuad" func GetRayCollisionQuad(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): RayCollision +export extern "InitAudioDevice" func InitAudioDevice(): void +export extern "CloseAudioDevice" func CloseAudioDevice(): void +export extern "IsAudioDeviceReady" func IsAudioDeviceReady(): bool +export extern "SetMasterVolume" func SetMasterVolume(volume: f32): void +export extern "GetMasterVolume" func GetMasterVolume(): f32 +export extern "LoadWave" func LoadWave(fileName: cstring): Wave +export extern "LoadWaveFromMemory" func LoadWaveFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32): Wave +export extern "IsWaveValid" func IsWaveValid(wave: Wave): bool +export extern "LoadSound" func LoadSound(fileName: cstring): Sound +export extern "LoadSoundFromWave" func LoadSoundFromWave(wave: Wave): Sound +export extern "LoadSoundAlias" func LoadSoundAlias(source: Sound): Sound +export extern "IsSoundValid" func IsSoundValid(sound: Sound): bool +export extern "UpdateSound" func UpdateSound(sound: Sound, data: ^void, sampleCount: i32): void +export extern "UnloadWave" func UnloadWave(wave: Wave): void +export extern "UnloadSound" func UnloadSound(sound: Sound): void +export extern "UnloadSoundAlias" func UnloadSoundAlias(alias: Sound): void +export extern "ExportWave" func ExportWave(wave: Wave, fileName: cstring): bool +export extern "ExportWaveAsCode" func ExportWaveAsCode(wave: Wave, fileName: cstring): bool +export extern "PlaySound" func PlaySound(sound: Sound): void +export extern "StopSound" func StopSound(sound: Sound): void +export extern "PauseSound" func PauseSound(sound: Sound): void +export extern "ResumeSound" func ResumeSound(sound: Sound): void +export extern "IsSoundPlaying" func IsSoundPlaying(sound: Sound): bool +export extern "SetSoundVolume" func SetSoundVolume(sound: Sound, volume: f32): void +export extern "SetSoundPitch" func SetSoundPitch(sound: Sound, pitch: f32): void +export extern "SetSoundPan" func SetSoundPan(sound: Sound, pan: f32): void +export extern "WaveCopy" func WaveCopy(wave: Wave): Wave +export extern "WaveCrop" func WaveCrop(wave: ^Wave, initFrame: i32, finalFrame: i32): void +export extern "WaveFormat" func WaveFormat(wave: ^Wave, sampleRate: i32, sampleSize: i32, channels: i32): void +export extern "LoadWaveSamples" func LoadWaveSamples(wave: Wave): ^f32 +export extern "UnloadWaveSamples" func UnloadWaveSamples(samples: ^f32): void +export extern "LoadMusicStream" func LoadMusicStream(fileName: cstring): Music +export extern "LoadMusicStreamFromMemory" func LoadMusicStreamFromMemory(fileType: cstring, data: ^u8, dataSize: i32): Music +export extern "IsMusicValid" func IsMusicValid(music: Music): bool +export extern "UnloadMusicStream" func UnloadMusicStream(music: Music): void +export extern "PlayMusicStream" func PlayMusicStream(music: Music): void +export extern "IsMusicStreamPlaying" func IsMusicStreamPlaying(music: Music): bool +export extern "UpdateMusicStream" func UpdateMusicStream(music: Music): void +export extern "StopMusicStream" func StopMusicStream(music: Music): void +export extern "PauseMusicStream" func PauseMusicStream(music: Music): void +export extern "ResumeMusicStream" func ResumeMusicStream(music: Music): void +export extern "SeekMusicStream" func SeekMusicStream(music: Music, position: f32): void +export extern "SetMusicVolume" func SetMusicVolume(music: Music, volume: f32): void +export extern "SetMusicPitch" func SetMusicPitch(music: Music, pitch: f32): void +export extern "SetMusicPan" func SetMusicPan(music: Music, pan: f32): void +export extern "GetMusicTimeLength" func GetMusicTimeLength(music: Music): f32 +export extern "GetMusicTimePlayed" func GetMusicTimePlayed(music: Music): f32 +export extern "LoadAudioStream" func LoadAudioStream(sampleRate: u32, sampleSize: u32, channels: u32): AudioStream +export extern "IsAudioStreamValid" func IsAudioStreamValid(stream: AudioStream): bool +export extern "UnloadAudioStream" func UnloadAudioStream(stream: AudioStream): void +export extern "UpdateAudioStream" func UpdateAudioStream(stream: AudioStream, data: ^void, frameCount: i32): void +export extern "IsAudioStreamProcessed" func IsAudioStreamProcessed(stream: AudioStream): bool +export extern "PlayAudioStream" func PlayAudioStream(stream: AudioStream): void +export extern "PauseAudioStream" func PauseAudioStream(stream: AudioStream): void +export extern "ResumeAudioStream" func ResumeAudioStream(stream: AudioStream): void +export extern "IsAudioStreamPlaying" func IsAudioStreamPlaying(stream: AudioStream): bool +export extern "StopAudioStream" func StopAudioStream(stream: AudioStream): void +export extern "SetAudioStreamVolume" func SetAudioStreamVolume(stream: AudioStream, volume: f32): void +export extern "SetAudioStreamPitch" func SetAudioStreamPitch(stream: AudioStream, pitch: f32): void +export extern "SetAudioStreamPan" func SetAudioStreamPan(stream: AudioStream, pan: f32): void +export extern "SetAudioStreamBufferSizeDefault" func SetAudioStreamBufferSizeDefault(size: i32): void +export extern "SetAudioStreamCallback" func SetAudioStreamCallback(stream: AudioStream, callback: func(^void, u32): void): void +export extern "AttachAudioStreamProcessor" func AttachAudioStreamProcessor(stream: AudioStream, processor: func(^void, u32): void): void +export extern "DetachAudioStreamProcessor" func DetachAudioStreamProcessor(stream: AudioStream, processor: func(^void, u32): void): void +export extern "AttachAudioMixedProcessor" func AttachAudioMixedProcessor(processor: func(^void, u32): void): void +export extern "DetachAudioMixedProcessor" func DetachAudioMixedProcessor(processor: func(^void, u32): void): void diff --git a/examples/raylib/generated/raymath.nub b/examples/raylib/generated/raymath.nub new file mode 100644 index 0000000..c094a74 --- /dev/null +++ b/examples/raylib/generated/raymath.nub @@ -0,0 +1,235 @@ +module "raymath" + +export struct Vector2 +{ + x: f32 + y: f32 +} +export struct Vector2 +{ + x: f32 + y: f32 +} +export struct Vector3 +{ + x: f32 + y: f32 + z: f32 +} +export struct Vector3 +{ + x: f32 + y: f32 + z: f32 +} +export struct Vector4 +{ + x: f32 + y: f32 + z: f32 + w: f32 +} +export struct Vector4 +{ + x: f32 + y: f32 + z: f32 + w: f32 +} +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct float3 +{ + v: [3]f32 +} +export struct float3 +{ + v: [3]f32 +} +export struct float16 +{ + v: [16]f32 +} +export struct float16 +{ + v: [16]f32 +} +export extern "Clamp" func Clamp(value: f32, min: f32, max: f32): f32 +export extern "Lerp" func Lerp(start: f32, end: f32, amount: f32): f32 +export extern "Normalize" func Normalize(value: f32, start: f32, end: f32): f32 +export extern "Remap" func Remap(value: f32, inputStart: f32, inputEnd: f32, outputStart: f32, outputEnd: f32): f32 +export extern "Wrap" func Wrap(value: f32, min: f32, max: f32): f32 +export extern "FloatEquals" func FloatEquals(x: f32, y: f32): i32 +export extern "Vector2Zero" func Vector2Zero(): Vector2 +export extern "Vector2One" func Vector2One(): Vector2 +export extern "Vector2Add" func Vector2Add(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2AddValue" func Vector2AddValue(v: Vector2, add: f32): Vector2 +export extern "Vector2Subtract" func Vector2Subtract(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2SubtractValue" func Vector2SubtractValue(v: Vector2, sub: f32): Vector2 +export extern "Vector2Length" func Vector2Length(v: Vector2): f32 +export extern "Vector2LengthSqr" func Vector2LengthSqr(v: Vector2): f32 +export extern "Vector2DotProduct" func Vector2DotProduct(v1: Vector2, v2: Vector2): f32 +export extern "Vector2Distance" func Vector2Distance(v1: Vector2, v2: Vector2): f32 +export extern "Vector2DistanceSqr" func Vector2DistanceSqr(v1: Vector2, v2: Vector2): f32 +export extern "Vector2Angle" func Vector2Angle(v1: Vector2, v2: Vector2): f32 +export extern "Vector2LineAngle" func Vector2LineAngle(start: Vector2, end: Vector2): f32 +export extern "Vector2Scale" func Vector2Scale(v: Vector2, scale: f32): Vector2 +export extern "Vector2Multiply" func Vector2Multiply(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2Negate" func Vector2Negate(v: Vector2): Vector2 +export extern "Vector2Divide" func Vector2Divide(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2Normalize" func Vector2Normalize(v: Vector2): Vector2 +export extern "Vector2Transform" func Vector2Transform(v: Vector2, mat: Matrix): Vector2 +export extern "Vector2Lerp" func Vector2Lerp(v1: Vector2, v2: Vector2, amount: f32): Vector2 +export extern "Vector2Reflect" func Vector2Reflect(v: Vector2, normal: Vector2): Vector2 +export extern "Vector2Min" func Vector2Min(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2Max" func Vector2Max(v1: Vector2, v2: Vector2): Vector2 +export extern "Vector2Rotate" func Vector2Rotate(v: Vector2, angle: f32): Vector2 +export extern "Vector2MoveTowards" func Vector2MoveTowards(v: Vector2, target: Vector2, maxDistance: f32): Vector2 +export extern "Vector2Invert" func Vector2Invert(v: Vector2): Vector2 +export extern "Vector2Clamp" func Vector2Clamp(v: Vector2, min: Vector2, max: Vector2): Vector2 +export extern "Vector2ClampValue" func Vector2ClampValue(v: Vector2, min: f32, max: f32): Vector2 +export extern "Vector2Equals" func Vector2Equals(p: Vector2, q: Vector2): i32 +export extern "Vector2Refract" func Vector2Refract(v: Vector2, n: Vector2, r: f32): Vector2 +export extern "Vector3Zero" func Vector3Zero(): Vector3 +export extern "Vector3One" func Vector3One(): Vector3 +export extern "Vector3Add" func Vector3Add(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3AddValue" func Vector3AddValue(v: Vector3, add: f32): Vector3 +export extern "Vector3Subtract" func Vector3Subtract(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3SubtractValue" func Vector3SubtractValue(v: Vector3, sub: f32): Vector3 +export extern "Vector3Scale" func Vector3Scale(v: Vector3, scalar: f32): Vector3 +export extern "Vector3Multiply" func Vector3Multiply(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3CrossProduct" func Vector3CrossProduct(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3Perpendicular" func Vector3Perpendicular(v: Vector3): Vector3 +export extern "Vector3Length" func Vector3Length(v: Vector3): f32 +export extern "Vector3LengthSqr" func Vector3LengthSqr(v: Vector3): f32 +export extern "Vector3DotProduct" func Vector3DotProduct(v1: Vector3, v2: Vector3): f32 +export extern "Vector3Distance" func Vector3Distance(v1: Vector3, v2: Vector3): f32 +export extern "Vector3DistanceSqr" func Vector3DistanceSqr(v1: Vector3, v2: Vector3): f32 +export extern "Vector3Angle" func Vector3Angle(v1: Vector3, v2: Vector3): f32 +export extern "Vector3Negate" func Vector3Negate(v: Vector3): Vector3 +export extern "Vector3Divide" func Vector3Divide(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3Normalize" func Vector3Normalize(v: Vector3): Vector3 +export extern "Vector3Project" func Vector3Project(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3Reject" func Vector3Reject(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3OrthoNormalize" func Vector3OrthoNormalize(v1: ^Vector3, v2: ^Vector3): void +export extern "Vector3Transform" func Vector3Transform(v: Vector3, mat: Matrix): Vector3 +export extern "Vector3RotateByQuaternion" func Vector3RotateByQuaternion(v: Vector3, q: Vector4): Vector3 +export extern "Vector3RotateByAxisAngle" func Vector3RotateByAxisAngle(v: Vector3, axis: Vector3, angle: f32): Vector3 +export extern "Vector3MoveTowards" func Vector3MoveTowards(v: Vector3, target: Vector3, maxDistance: f32): Vector3 +export extern "Vector3Lerp" func Vector3Lerp(v1: Vector3, v2: Vector3, amount: f32): Vector3 +export extern "Vector3CubicHermite" func Vector3CubicHermite(v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: f32): Vector3 +export extern "Vector3Reflect" func Vector3Reflect(v: Vector3, normal: Vector3): Vector3 +export extern "Vector3Min" func Vector3Min(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3Max" func Vector3Max(v1: Vector3, v2: Vector3): Vector3 +export extern "Vector3Barycenter" func Vector3Barycenter(p: Vector3, a: Vector3, b: Vector3, c: Vector3): Vector3 +export extern "Vector3Unproject" func Vector3Unproject(source: Vector3, projection: Matrix, view: Matrix): Vector3 +export extern "Vector3ToFloatV" func Vector3ToFloatV(v: Vector3): float3 +export extern "Vector3Invert" func Vector3Invert(v: Vector3): Vector3 +export extern "Vector3Clamp" func Vector3Clamp(v: Vector3, min: Vector3, max: Vector3): Vector3 +export extern "Vector3ClampValue" func Vector3ClampValue(v: Vector3, min: f32, max: f32): Vector3 +export extern "Vector3Equals" func Vector3Equals(p: Vector3, q: Vector3): i32 +export extern "Vector3Refract" func Vector3Refract(v: Vector3, n: Vector3, r: f32): Vector3 +export extern "Vector4Zero" func Vector4Zero(): Vector4 +export extern "Vector4One" func Vector4One(): Vector4 +export extern "Vector4Add" func Vector4Add(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4AddValue" func Vector4AddValue(v: Vector4, add: f32): Vector4 +export extern "Vector4Subtract" func Vector4Subtract(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4SubtractValue" func Vector4SubtractValue(v: Vector4, add: f32): Vector4 +export extern "Vector4Length" func Vector4Length(v: Vector4): f32 +export extern "Vector4LengthSqr" func Vector4LengthSqr(v: Vector4): f32 +export extern "Vector4DotProduct" func Vector4DotProduct(v1: Vector4, v2: Vector4): f32 +export extern "Vector4Distance" func Vector4Distance(v1: Vector4, v2: Vector4): f32 +export extern "Vector4DistanceSqr" func Vector4DistanceSqr(v1: Vector4, v2: Vector4): f32 +export extern "Vector4Scale" func Vector4Scale(v: Vector4, scale: f32): Vector4 +export extern "Vector4Multiply" func Vector4Multiply(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4Negate" func Vector4Negate(v: Vector4): Vector4 +export extern "Vector4Divide" func Vector4Divide(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4Normalize" func Vector4Normalize(v: Vector4): Vector4 +export extern "Vector4Min" func Vector4Min(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4Max" func Vector4Max(v1: Vector4, v2: Vector4): Vector4 +export extern "Vector4Lerp" func Vector4Lerp(v1: Vector4, v2: Vector4, amount: f32): Vector4 +export extern "Vector4MoveTowards" func Vector4MoveTowards(v: Vector4, target: Vector4, maxDistance: f32): Vector4 +export extern "Vector4Invert" func Vector4Invert(v: Vector4): Vector4 +export extern "Vector4Equals" func Vector4Equals(p: Vector4, q: Vector4): i32 +export extern "MatrixDeterminant" func MatrixDeterminant(mat: Matrix): f32 +export extern "MatrixTrace" func MatrixTrace(mat: Matrix): f32 +export extern "MatrixTranspose" func MatrixTranspose(mat: Matrix): Matrix +export extern "MatrixInvert" func MatrixInvert(mat: Matrix): Matrix +export extern "MatrixIdentity" func MatrixIdentity(): Matrix +export extern "MatrixAdd" func MatrixAdd(left: Matrix, right: Matrix): Matrix +export extern "MatrixSubtract" func MatrixSubtract(left: Matrix, right: Matrix): Matrix +export extern "MatrixMultiply" func MatrixMultiply(left: Matrix, right: Matrix): Matrix +export extern "MatrixTranslate" func MatrixTranslate(x: f32, y: f32, z: f32): Matrix +export extern "MatrixRotate" func MatrixRotate(axis: Vector3, angle: f32): Matrix +export extern "MatrixRotateX" func MatrixRotateX(angle: f32): Matrix +export extern "MatrixRotateY" func MatrixRotateY(angle: f32): Matrix +export extern "MatrixRotateZ" func MatrixRotateZ(angle: f32): Matrix +export extern "MatrixRotateXYZ" func MatrixRotateXYZ(angle: Vector3): Matrix +export extern "MatrixRotateZYX" func MatrixRotateZYX(angle: Vector3): Matrix +export extern "MatrixScale" func MatrixScale(x: f32, y: f32, z: f32): Matrix +export extern "MatrixFrustum" func MatrixFrustum(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix +export extern "MatrixPerspective" func MatrixPerspective(fovY: f64, aspect: f64, nearPlane: f64, farPlane: f64): Matrix +export extern "MatrixOrtho" func MatrixOrtho(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix +export extern "MatrixLookAt" func MatrixLookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix +export extern "MatrixToFloatV" func MatrixToFloatV(mat: Matrix): float16 +export extern "QuaternionAdd" func QuaternionAdd(q1: Vector4, q2: Vector4): Vector4 +export extern "QuaternionAddValue" func QuaternionAddValue(q: Vector4, add: f32): Vector4 +export extern "QuaternionSubtract" func QuaternionSubtract(q1: Vector4, q2: Vector4): Vector4 +export extern "QuaternionSubtractValue" func QuaternionSubtractValue(q: Vector4, sub: f32): Vector4 +export extern "QuaternionIdentity" func QuaternionIdentity(): Vector4 +export extern "QuaternionLength" func QuaternionLength(q: Vector4): f32 +export extern "QuaternionNormalize" func QuaternionNormalize(q: Vector4): Vector4 +export extern "QuaternionInvert" func QuaternionInvert(q: Vector4): Vector4 +export extern "QuaternionMultiply" func QuaternionMultiply(q1: Vector4, q2: Vector4): Vector4 +export extern "QuaternionScale" func QuaternionScale(q: Vector4, mul: f32): Vector4 +export extern "QuaternionDivide" func QuaternionDivide(q1: Vector4, q2: Vector4): Vector4 +export extern "QuaternionLerp" func QuaternionLerp(q1: Vector4, q2: Vector4, amount: f32): Vector4 +export extern "QuaternionNlerp" func QuaternionNlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4 +export extern "QuaternionSlerp" func QuaternionSlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4 +export extern "QuaternionCubicHermiteSpline" func QuaternionCubicHermiteSpline(q1: Vector4, outTangent1: Vector4, q2: Vector4, inTangent2: Vector4, t: f32): Vector4 +export extern "QuaternionFromVector3ToVector3" func QuaternionFromVector3ToVector3(from: Vector3, to: Vector3): Vector4 +export extern "QuaternionFromMatrix" func QuaternionFromMatrix(mat: Matrix): Vector4 +export extern "QuaternionToMatrix" func QuaternionToMatrix(q: Vector4): Matrix +export extern "QuaternionFromAxisAngle" func QuaternionFromAxisAngle(axis: Vector3, angle: f32): Vector4 +export extern "QuaternionToAxisAngle" func QuaternionToAxisAngle(q: Vector4, outAxis: ^Vector3, outAngle: ^f32): void +export extern "QuaternionFromEuler" func QuaternionFromEuler(pitch: f32, yaw: f32, roll: f32): Vector4 +export extern "QuaternionToEuler" func QuaternionToEuler(q: Vector4): Vector3 +export extern "QuaternionTransform" func QuaternionTransform(q: Vector4, mat: Matrix): Vector4 +export extern "QuaternionEquals" func QuaternionEquals(p: Vector4, q: Vector4): i32 +export extern "MatrixDecompose" func MatrixDecompose(mat: Matrix, translation: ^Vector3, rotation: ^Vector4, scale: ^Vector3): void diff --git a/examples/raylib/generated/rlgl.nub b/examples/raylib/generated/rlgl.nub new file mode 100644 index 0000000..3a26aa2 --- /dev/null +++ b/examples/raylib/generated/rlgl.nub @@ -0,0 +1,248 @@ +module "rlgl" + +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct Matrix +{ + m0: f32 + m4: f32 + m8: f32 + m12: f32 + m1: f32 + m5: f32 + m9: f32 + m13: f32 + m2: f32 + m6: f32 + m10: f32 + m14: f32 + m3: f32 + m7: f32 + m11: f32 + m15: f32 +} +export struct rlVertexBuffer +{ + elementCount: i32 + vertices: ^f32 + texcoords: ^f32 + normals: ^f32 + colors: ^u8 + indices: ^u32 + vaoId: u32 + vboId: [5]u32 +} +export struct rlVertexBuffer +{ + elementCount: i32 + vertices: ^f32 + texcoords: ^f32 + normals: ^f32 + colors: ^u8 + indices: ^u32 + vaoId: u32 + vboId: [5]u32 +} +export struct rlDrawCall +{ + mode: i32 + vertexCount: i32 + vertexAlignment: i32 + textureId: u32 +} +export struct rlDrawCall +{ + mode: i32 + vertexCount: i32 + vertexAlignment: i32 + textureId: u32 +} +export struct rlRenderBatch +{ + bufferCount: i32 + currentBuffer: i32 + vertexBuffer: ^rlVertexBuffer + draws: ^rlDrawCall + drawCounter: i32 + currentDepth: f32 +} +export struct rlRenderBatch +{ + bufferCount: i32 + currentBuffer: i32 + vertexBuffer: ^rlVertexBuffer + draws: ^rlDrawCall + drawCounter: i32 + currentDepth: f32 +} +export extern "rlMatrixMode" func rlMatrixMode(mode: i32): void +export extern "rlPushMatrix" func rlPushMatrix(): void +export extern "rlPopMatrix" func rlPopMatrix(): void +export extern "rlLoadIdentity" func rlLoadIdentity(): void +export extern "rlTranslatef" func rlTranslatef(x: f32, y: f32, z: f32): void +export extern "rlRotatef" func rlRotatef(angle: f32, x: f32, y: f32, z: f32): void +export extern "rlScalef" func rlScalef(x: f32, y: f32, z: f32): void +export extern "rlMultMatrixf" func rlMultMatrixf(matf: ^f32): void +export extern "rlFrustum" func rlFrustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void +export extern "rlOrtho" func rlOrtho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void +export extern "rlViewport" func rlViewport(x: i32, y: i32, width: i32, height: i32): void +export extern "rlSetClipPlanes" func rlSetClipPlanes(nearPlane: f64, farPlane: f64): void +export extern "rlGetCullDistanceNear" func rlGetCullDistanceNear(): f64 +export extern "rlGetCullDistanceFar" func rlGetCullDistanceFar(): f64 +export extern "rlBegin" func rlBegin(mode: i32): void +export extern "rlEnd" func rlEnd(): void +export extern "rlVertex2i" func rlVertex2i(x: i32, y: i32): void +export extern "rlVertex2f" func rlVertex2f(x: f32, y: f32): void +export extern "rlVertex3f" func rlVertex3f(x: f32, y: f32, z: f32): void +export extern "rlTexCoord2f" func rlTexCoord2f(x: f32, y: f32): void +export extern "rlNormal3f" func rlNormal3f(x: f32, y: f32, z: f32): void +export extern "rlColor4ub" func rlColor4ub(r: u8, g: u8, b: u8, a: u8): void +export extern "rlColor3f" func rlColor3f(x: f32, y: f32, z: f32): void +export extern "rlColor4f" func rlColor4f(x: f32, y: f32, z: f32, w: f32): void +export extern "rlEnableVertexArray" func rlEnableVertexArray(vaoId: u32): bool +export extern "rlDisableVertexArray" func rlDisableVertexArray(): void +export extern "rlEnableVertexBuffer" func rlEnableVertexBuffer(id: u32): void +export extern "rlDisableVertexBuffer" func rlDisableVertexBuffer(): void +export extern "rlEnableVertexBufferElement" func rlEnableVertexBufferElement(id: u32): void +export extern "rlDisableVertexBufferElement" func rlDisableVertexBufferElement(): void +export extern "rlEnableVertexAttribute" func rlEnableVertexAttribute(index: u32): void +export extern "rlDisableVertexAttribute" func rlDisableVertexAttribute(index: u32): void +export extern "rlActiveTextureSlot" func rlActiveTextureSlot(slot: i32): void +export extern "rlEnableTexture" func rlEnableTexture(id: u32): void +export extern "rlDisableTexture" func rlDisableTexture(): void +export extern "rlEnableTextureCubemap" func rlEnableTextureCubemap(id: u32): void +export extern "rlDisableTextureCubemap" func rlDisableTextureCubemap(): void +export extern "rlTextureParameters" func rlTextureParameters(id: u32, param: i32, value: i32): void +export extern "rlCubemapParameters" func rlCubemapParameters(id: u32, param: i32, value: i32): void +export extern "rlEnableShader" func rlEnableShader(id: u32): void +export extern "rlDisableShader" func rlDisableShader(): void +export extern "rlEnableFramebuffer" func rlEnableFramebuffer(id: u32): void +export extern "rlDisableFramebuffer" func rlDisableFramebuffer(): void +export extern "rlGetActiveFramebuffer" func rlGetActiveFramebuffer(): u32 +export extern "rlActiveDrawBuffers" func rlActiveDrawBuffers(count: i32): void +export extern "rlBlitFramebuffer" func rlBlitFramebuffer(srcX: i32, srcY: i32, srcWidth: i32, srcHeight: i32, dstX: i32, dstY: i32, dstWidth: i32, dstHeight: i32, bufferMask: i32): void +export extern "rlBindFramebuffer" func rlBindFramebuffer(target: u32, framebuffer: u32): void +export extern "rlEnableColorBlend" func rlEnableColorBlend(): void +export extern "rlDisableColorBlend" func rlDisableColorBlend(): void +export extern "rlEnableDepthTest" func rlEnableDepthTest(): void +export extern "rlDisableDepthTest" func rlDisableDepthTest(): void +export extern "rlEnableDepthMask" func rlEnableDepthMask(): void +export extern "rlDisableDepthMask" func rlDisableDepthMask(): void +export extern "rlEnableBackfaceCulling" func rlEnableBackfaceCulling(): void +export extern "rlDisableBackfaceCulling" func rlDisableBackfaceCulling(): void +export extern "rlColorMask" func rlColorMask(r: bool, g: bool, b: bool, a: bool): void +export extern "rlSetCullFace" func rlSetCullFace(mode: i32): void +export extern "rlEnableScissorTest" func rlEnableScissorTest(): void +export extern "rlDisableScissorTest" func rlDisableScissorTest(): void +export extern "rlScissor" func rlScissor(x: i32, y: i32, width: i32, height: i32): void +export extern "rlEnableWireMode" func rlEnableWireMode(): void +export extern "rlEnablePointMode" func rlEnablePointMode(): void +export extern "rlDisableWireMode" func rlDisableWireMode(): void +export extern "rlSetLineWidth" func rlSetLineWidth(width: f32): void +export extern "rlGetLineWidth" func rlGetLineWidth(): f32 +export extern "rlEnableSmoothLines" func rlEnableSmoothLines(): void +export extern "rlDisableSmoothLines" func rlDisableSmoothLines(): void +export extern "rlEnableStereoRender" func rlEnableStereoRender(): void +export extern "rlDisableStereoRender" func rlDisableStereoRender(): void +export extern "rlIsStereoRenderEnabled" func rlIsStereoRenderEnabled(): bool +export extern "rlClearColor" func rlClearColor(r: u8, g: u8, b: u8, a: u8): void +export extern "rlClearScreenBuffers" func rlClearScreenBuffers(): void +export extern "rlCheckErrors" func rlCheckErrors(): void +export extern "rlSetBlendMode" func rlSetBlendMode(mode: i32): void +export extern "rlSetBlendFactors" func rlSetBlendFactors(glSrcFactor: i32, glDstFactor: i32, glEquation: i32): void +export extern "rlSetBlendFactorsSeparate" func rlSetBlendFactorsSeparate(glSrcRGB: i32, glDstRGB: i32, glSrcAlpha: i32, glDstAlpha: i32, glEqRGB: i32, glEqAlpha: i32): void +export extern "rlglInit" func rlglInit(width: i32, height: i32): void +export extern "rlglClose" func rlglClose(): void +export extern "rlLoadExtensions" func rlLoadExtensions(loader: ^void): void +export extern "rlGetVersion" func rlGetVersion(): i32 +export extern "rlSetFramebufferWidth" func rlSetFramebufferWidth(width: i32): void +export extern "rlGetFramebufferWidth" func rlGetFramebufferWidth(): i32 +export extern "rlSetFramebufferHeight" func rlSetFramebufferHeight(height: i32): void +export extern "rlGetFramebufferHeight" func rlGetFramebufferHeight(): i32 +export extern "rlGetTextureIdDefault" func rlGetTextureIdDefault(): u32 +export extern "rlGetShaderIdDefault" func rlGetShaderIdDefault(): u32 +export extern "rlGetShaderLocsDefault" func rlGetShaderLocsDefault(): ^i32 +export extern "rlLoadRenderBatch" func rlLoadRenderBatch(numBuffers: i32, bufferElements: i32): rlRenderBatch +export extern "rlUnloadRenderBatch" func rlUnloadRenderBatch(batch: rlRenderBatch): void +export extern "rlDrawRenderBatch" func rlDrawRenderBatch(batch: ^rlRenderBatch): void +export extern "rlSetRenderBatchActive" func rlSetRenderBatchActive(batch: ^rlRenderBatch): void +export extern "rlDrawRenderBatchActive" func rlDrawRenderBatchActive(): void +export extern "rlCheckRenderBatchLimit" func rlCheckRenderBatchLimit(vCount: i32): bool +export extern "rlSetTexture" func rlSetTexture(id: u32): void +export extern "rlLoadVertexArray" func rlLoadVertexArray(): u32 +export extern "rlLoadVertexBuffer" func rlLoadVertexBuffer(buffer: ^void, size: i32, dynamic: bool): u32 +export extern "rlLoadVertexBufferElement" func rlLoadVertexBufferElement(buffer: ^void, size: i32, dynamic: bool): u32 +export extern "rlUpdateVertexBuffer" func rlUpdateVertexBuffer(bufferId: u32, data: ^void, dataSize: i32, offset: i32): void +export extern "rlUpdateVertexBufferElements" func rlUpdateVertexBufferElements(id: u32, data: ^void, dataSize: i32, offset: i32): void +export extern "rlUnloadVertexArray" func rlUnloadVertexArray(vaoId: u32): void +export extern "rlUnloadVertexBuffer" func rlUnloadVertexBuffer(vboId: u32): void +export extern "rlSetVertexAttribute" func rlSetVertexAttribute(index: u32, compSize: i32, type: i32, normalized: bool, stride: i32, offset: i32): void +export extern "rlSetVertexAttributeDivisor" func rlSetVertexAttributeDivisor(index: u32, divisor: i32): void +export extern "rlSetVertexAttributeDefault" func rlSetVertexAttributeDefault(locIndex: i32, value: ^void, attribType: i32, count: i32): void +export extern "rlDrawVertexArray" func rlDrawVertexArray(offset: i32, count: i32): void +export extern "rlDrawVertexArrayElements" func rlDrawVertexArrayElements(offset: i32, count: i32, buffer: ^void): void +export extern "rlDrawVertexArrayInstanced" func rlDrawVertexArrayInstanced(offset: i32, count: i32, instances: i32): void +export extern "rlDrawVertexArrayElementsInstanced" func rlDrawVertexArrayElementsInstanced(offset: i32, count: i32, buffer: ^void, instances: i32): void +export extern "rlLoadTexture" func rlLoadTexture(data: ^void, width: i32, height: i32, format: i32, mipmapCount: i32): u32 +export extern "rlLoadTextureDepth" func rlLoadTextureDepth(width: i32, height: i32, useRenderBuffer: bool): u32 +export extern "rlLoadTextureCubemap" func rlLoadTextureCubemap(data: ^void, size: i32, format: i32, mipmapCount: i32): u32 +export extern "rlUpdateTexture" func rlUpdateTexture(id: u32, offsetX: i32, offsetY: i32, width: i32, height: i32, format: i32, data: ^void): void +export extern "rlGetGlTextureFormats" func rlGetGlTextureFormats(format: i32, glInternalFormat: ^u32, glFormat: ^u32, glType: ^u32): void +export extern "rlGetPixelFormatName" func rlGetPixelFormatName(format: u32): cstring +export extern "rlUnloadTexture" func rlUnloadTexture(id: u32): void +export extern "rlGenTextureMipmaps" func rlGenTextureMipmaps(id: u32, width: i32, height: i32, format: i32, mipmaps: ^i32): void +export extern "rlReadTexturePixels" func rlReadTexturePixels(id: u32, width: i32, height: i32, format: i32): ^void +export extern "rlReadScreenPixels" func rlReadScreenPixels(width: i32, height: i32): ^u8 +export extern "rlLoadFramebuffer" func rlLoadFramebuffer(): u32 +export extern "rlFramebufferAttach" func rlFramebufferAttach(fboId: u32, texId: u32, attachType: i32, texType: i32, mipLevel: i32): void +export extern "rlFramebufferComplete" func rlFramebufferComplete(id: u32): bool +export extern "rlUnloadFramebuffer" func rlUnloadFramebuffer(id: u32): void +export extern "rlLoadShaderCode" func rlLoadShaderCode(vsCode: cstring, fsCode: cstring): u32 +export extern "rlCompileShader" func rlCompileShader(shaderCode: cstring, type: i32): u32 +export extern "rlLoadShaderProgram" func rlLoadShaderProgram(vShaderId: u32, fShaderId: u32): u32 +export extern "rlUnloadShaderProgram" func rlUnloadShaderProgram(id: u32): void +export extern "rlGetLocationUniform" func rlGetLocationUniform(shaderId: u32, uniformName: cstring): i32 +export extern "rlGetLocationAttrib" func rlGetLocationAttrib(shaderId: u32, attribName: cstring): i32 +export extern "rlSetUniform" func rlSetUniform(locIndex: i32, value: ^void, uniformType: i32, count: i32): void +export extern "rlSetUniformMatrix" func rlSetUniformMatrix(locIndex: i32, mat: Matrix): void +export extern "rlSetUniformMatrices" func rlSetUniformMatrices(locIndex: i32, mat: ^Matrix, count: i32): void +export extern "rlSetUniformSampler" func rlSetUniformSampler(locIndex: i32, textureId: u32): void +export extern "rlSetShader" func rlSetShader(id: u32, locs: ^i32): void +export extern "rlLoadComputeShaderProgram" func rlLoadComputeShaderProgram(shaderId: u32): u32 +export extern "rlComputeShaderDispatch" func rlComputeShaderDispatch(groupX: u32, groupY: u32, groupZ: u32): void +export extern "rlLoadShaderBuffer" func rlLoadShaderBuffer(size: u32, data: ^void, usageHint: i32): u32 +export extern "rlUnloadShaderBuffer" func rlUnloadShaderBuffer(ssboId: u32): void +export extern "rlUpdateShaderBuffer" func rlUpdateShaderBuffer(id: u32, data: ^void, dataSize: u32, offset: u32): void +export extern "rlBindShaderBuffer" func rlBindShaderBuffer(id: u32, index: u32): void +export extern "rlReadShaderBuffer" func rlReadShaderBuffer(id: u32, dest: ^void, count: u32, offset: u32): void +export extern "rlCopyShaderBuffer" func rlCopyShaderBuffer(destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32): void +export extern "rlGetShaderBufferSize" func rlGetShaderBufferSize(id: u32): u32 +export extern "rlBindImageTexture" func rlBindImageTexture(id: u32, index: u32, format: i32, readonly: bool): void +export extern "rlGetMatrixModelview" func rlGetMatrixModelview(): Matrix +export extern "rlGetMatrixProjection" func rlGetMatrixProjection(): Matrix +export extern "rlGetMatrixTransform" func rlGetMatrixTransform(): Matrix +export extern "rlGetMatrixProjectionStereo" func rlGetMatrixProjectionStereo(eye: i32): Matrix +export extern "rlGetMatrixViewOffsetStereo" func rlGetMatrixViewOffsetStereo(eye: i32): Matrix +export extern "rlSetMatrixProjection" func rlSetMatrixProjection(proj: Matrix): void +export extern "rlSetMatrixModelview" func rlSetMatrixModelview(view: Matrix): void +export extern "rlSetMatrixProjectionStereo" func rlSetMatrixProjectionStereo(right: Matrix, left: Matrix): void +export extern "rlSetMatrixViewOffsetStereo" func rlSetMatrixViewOffsetStereo(right: Matrix, left: Matrix): void +export extern "rlLoadDrawCube" func rlLoadDrawCube(): void +export extern "rlLoadDrawQuad" func rlLoadDrawQuad(): void diff --git a/examples/raylib/makefile b/examples/raylib/makefile index 1695298..94eb142 100644 --- a/examples/raylib/makefile +++ b/examples/raylib/makefile @@ -3,11 +3,8 @@ NUBC = ../../compiler/NubLang.CLI/bin/Debug/net9.0/nubc out: .build/out.o gcc -nostartfiles -lm -o out x86_64.s .build/out.o raylib-5.5_linux_amd64/lib/libraylib.a -.build/out.o: $(NUBC) main.nub raylib.nub - $(NUBC) main.nub raylib.nub - -raylib.nub: - python3 generate.py raylib-5.5_linux_amd64/include/raylib.h > raylib.nub +.build/out.o: $(NUBC) main.nub generated/raylib.nub + $(NUBC) main.nub generated/raylib.nub .PHONY: $(NUBC) $(NUBC):