Let's code

.gitignore

@@ -0,0 +1,468 @@
+
+# Created by https://www.gitignore.io/api/git,godot,jetbrains,visualstudio
+# Edit at https://www.gitignore.io/?templates=git,godot,jetbrains,visualstudio
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+### Godot ###
+
+# Godot-specific ignores
+.import/
+export.cfg
+export_presets.cfg
+
+# Mono-specific ignores
+.mono/
+
+### JetBrains ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### JetBrains Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator/
+
+### VisualStudio ###
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# End of https://www.gitignore.io/api/git,godot,jetbrains,visualstudio

DungeonAndDeamonScript/DungeonAndDeamonScript.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29806.167
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DungeonAndDemaonScript", "DungeonAndDemaonScript\DungeonAndDemaonScript.vcxproj", "{407012D6-416D-42BD-B4EE-3E29A25F26DB}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Debug|x64.ActiveCfg = Debug|x64
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Debug|x64.Build.0 = Debug|x64
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Debug|x86.ActiveCfg = Debug|Win32
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Debug|x86.Build.0 = Debug|Win32
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Release|x64.ActiveCfg = Release|x64
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Release|x64.Build.0 = Release|x64
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Release|x86.ActiveCfg = Release|Win32
+		{407012D6-416D-42BD-B4EE-3E29A25F26DB}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {B3717307-615F-4440-8C0C-4D583887486F}
+	EndGlobalSection
+EndGlobal

DungeonAndDeamonScript/DungeonAndDemaonScript/Bullet.cpp

@@ -0,0 +1 @@
+#include "Bullet.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Bullet.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Item.h"
+class Bullet :
+	public Item
+{
+public:
+	int degat;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/DungeonAndDemaonScript.vcxproj

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <ProjectGuid>{407012D6-416D-42BD-B4EE-3E29A25F26DB}</ProjectGuid>
+    <RootNamespace>DungeonAndDemaonScript</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <ProjectName>DungeonAndDeamonScript</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>..\..\DungeonAndDeamon\.script</OutDir>
+    <IncludePath>..\..\GodoBinding\include;..\..\GodoBinding\include\core;..\..\GodoBinding\include\gen;..\..\GodoBinding\godot_headers;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\GodoBinding\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>..\..\DungeonAndDeamon\.script</OutDir>
+    <IncludePath>..\..\GodoBinding\include;..\..\GodoBinding\include\core;..\..\GodoBinding\include\gen;..\..\GodoBinding\godot_headers;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\GodoBinding\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>..\..\DungeonAndDeamon\.script</OutDir>
+    <IncludePath>..\..\GodoBinding\include;..\..\GodoBinding\include\core;..\..\GodoBinding\include\gen;..\..\GodoBinding\godot_headers;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\GodoBinding\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>..\..\DungeonAndDeamon\.script</OutDir>
+    <IncludePath>..\..\GodoBinding\include;..\..\GodoBinding\include\core;..\..\GodoBinding\include\gen;..\..\GodoBinding\godot_headers;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\GodoBinding\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\GodoBinding\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\GodoBinding\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libgodot-cpp.windows.debug.default.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\GodoBinding\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\GodoBinding\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libgodot-cpp.windows.releases.default.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Bullet.cpp" />
+    <ClCompile Include="Entite.cpp" />
+    <ClCompile Include="Equipement.cpp" />
+    <ClCompile Include="GestionCollision.cpp" />
+    <ClCompile Include="GestionIdentifiant.cpp" />
+    <ClCompile Include="GestionItem.cpp" />
+    <ClCompile Include="GestionJeu.cpp" />
+    <ClCompile Include="GestionMobs.cpp" />
+    <ClCompile Include="GestionPlayer.cpp" />
+    <ClCompile Include="GestionTerrain.cpp" />
+    <ClCompile Include="GodotLibrary.cpp" />
+    <ClCompile Include="Item.cpp" />
+    <ClCompile Include="Loot.cpp" />
+    <ClCompile Include="Mobs.cpp" />
+    <ClCompile Include="MobsAgressif.cpp" />
+    <ClCompile Include="MobsCorpACorp.cpp" />
+    <ClCompile Include="MobsCorpACorpIA.cpp" />
+    <ClCompile Include="MobsDistance.cpp" />
+    <ClCompile Include="MobsDistanceIA.cpp" />
+    <ClCompile Include="MobsIA.cpp" />
+    <ClCompile Include="MobsPassif.cpp" />
+    <ClCompile Include="Mur.cpp" />
+    <ClCompile Include="Piece.cpp" />
+    <ClCompile Include="Player.cpp" />
+    <ClCompile Include="Root.cpp" />
+    <ClCompile Include="Sol.cpp" />
+    <ClCompile Include="SolSolide.cpp" />
+    <ClCompile Include="SolTraversable.cpp" />
+    <ClCompile Include="Terrain.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Bullet.h" />
+    <ClInclude Include="Entite.h" />
+    <ClInclude Include="Equipement.h" />
+    <ClInclude Include="GestionCollision.h" />
+    <ClInclude Include="GestionIdentifiant.h" />
+    <ClInclude Include="GestionItem.h" />
+    <ClInclude Include="GestionJeu.h" />
+    <ClInclude Include="GestionMobs.h" />
+    <ClInclude Include="GestionPlayer.h" />
+    <ClInclude Include="GestionTerrain.h" />
+    <ClInclude Include="Item.h" />
+    <ClInclude Include="Loot.h" />
+    <ClInclude Include="Mobs.h" />
+    <ClInclude Include="MobsAgressif.h" />
+    <ClInclude Include="MobsCorpACorp.h" />
+    <ClInclude Include="MobsCorpACorpIA.h" />
+    <ClInclude Include="MobsDistance.h" />
+    <ClInclude Include="MobsDistanceIA.h" />
+    <ClInclude Include="MobsIA.h" />
+    <ClInclude Include="MobsPassif.h" />
+    <ClInclude Include="Mur.h" />
+    <ClInclude Include="Piece.h" />
+    <ClInclude Include="Player.h" />
+    <ClInclude Include="Root.h" />
+    <ClInclude Include="Sol.h" />
+    <ClInclude Include="SolSolide.h" />
+    <ClInclude Include="SolTraversable.h" />
+    <ClInclude Include="Terrain.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

DungeonAndDeamonScript/DungeonAndDemaonScript/DungeonAndDemaonScript.vcxproj.filters

@@ -0,0 +1,216 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Fichiers d%27en-tête">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Fichiers de ressources">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\Entites">
+      <UniqueIdentifier>{5e49fdfd-2653-4383-a938-9594db7a79ff}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\Entites\Mobs">
+      <UniqueIdentifier>{de4ac3d9-fb69-43ce-adef-80f0898686b2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\Ground">
+      <UniqueIdentifier>{170ea3fc-3b5e-4ae1-b417-cb77fb63a3e2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\Noyau">
+      <UniqueIdentifier>{ed9f0603-4a2f-40dd-bf16-52ef01c864e6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Fichiers sources\Entites">
+      <UniqueIdentifier>{dfdc88f4-4d12-499e-af43-cd554cd46909}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources\Entites\Mobs">
+      <UniqueIdentifier>{8a4132c0-a54b-4dff-924b-7e09fa7348b6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources\Ground">
+      <UniqueIdentifier>{65d48479-bca0-4bae-82ac-36f3bdd7dd22}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources\Noyau">
+      <UniqueIdentifier>{40e4fb97-0924-4fe4-9ef7-f41ee1e8ce48}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Entite.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Item.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Bullet.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Equipement.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Loot.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Piece.cpp">
+      <Filter>Fichiers sources\Entites</Filter>
+    </ClCompile>
+    <ClCompile Include="Mobs.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsAgressif.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsCorpACorp.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsDistance.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsPassif.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="Player.cpp">
+      <Filter>Fichiers sources\Entites\Mobs</Filter>
+    </ClCompile>
+    <ClCompile Include="Mur.cpp">
+      <Filter>Fichiers sources\Ground</Filter>
+    </ClCompile>
+    <ClCompile Include="Sol.cpp">
+      <Filter>Fichiers sources\Ground</Filter>
+    </ClCompile>
+    <ClCompile Include="SolSolide.cpp">
+      <Filter>Fichiers sources\Ground</Filter>
+    </ClCompile>
+    <ClCompile Include="SolTraversable.cpp">
+      <Filter>Fichiers sources\Ground</Filter>
+    </ClCompile>
+    <ClCompile Include="Terrain.cpp">
+      <Filter>Fichiers sources\Ground</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionCollision.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionIdentifiant.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionItem.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionJeu.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionMobs.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionPlayer.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GestionTerrain.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsCorpACorpIA.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsDistanceIA.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="MobsIA.cpp">
+      <Filter>Fichiers sources\Noyau</Filter>
+    </ClCompile>
+    <ClCompile Include="GodotLibrary.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
+    <ClCompile Include="Root.cpp">
+      <Filter>Fichiers sources</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Entite.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Item.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Bullet.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Equipement.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Loot.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Piece.h">
+      <Filter>Fichiers d%27en-tête\Entites</Filter>
+    </ClInclude>
+    <ClInclude Include="Mobs.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsAgressif.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsCorpACorp.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsDistance.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsPassif.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="Player.h">
+      <Filter>Fichiers d%27en-tête\Entites\Mobs</Filter>
+    </ClInclude>
+    <ClInclude Include="SolTraversable.h">
+      <Filter>Fichiers d%27en-tête\Ground</Filter>
+    </ClInclude>
+    <ClInclude Include="Mur.h">
+      <Filter>Fichiers d%27en-tête\Ground</Filter>
+    </ClInclude>
+    <ClInclude Include="Sol.h">
+      <Filter>Fichiers d%27en-tête\Ground</Filter>
+    </ClInclude>
+    <ClInclude Include="SolSolide.h">
+      <Filter>Fichiers d%27en-tête\Ground</Filter>
+    </ClInclude>
+    <ClInclude Include="Terrain.h">
+      <Filter>Fichiers d%27en-tête\Ground</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionCollision.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionIdentifiant.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionItem.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionJeu.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionMobs.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionPlayer.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="GestionTerrain.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsCorpACorpIA.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsDistanceIA.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="MobsIA.h">
+      <Filter>Fichiers d%27en-tête\Noyau</Filter>
+    </ClInclude>
+    <ClInclude Include="Root.h">
+      <Filter>Fichiers d%27en-tête</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

DungeonAndDeamonScript/DungeonAndDemaonScript/Entite.cpp

@@ -0,0 +1,13 @@
+#include "Entite.h"
+
+void Entite::_init()
+{
+}
+
+void Entite::_process(float delta)
+{
+}
+
+void Entite::UpdateMotionFromInput()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/Entite.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <KinematicBody2D.hpp>
+
+class Entite :
+	public godot::KinematicBody2D
+{
+public:
+	int id;
+
+	int speed;
+	int gravity;
+
+	godot::Vector2 motion;
+
+public:
+	void _init();
+	void _process(float delta);
+	void UpdateMotionFromInput();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Equipement.cpp

@@ -0,0 +1 @@
+#include "Equipement.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Equipement.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Loot.h"
+class Equipement :
+	public Loot
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionCollision.cpp

@@ -0,0 +1,16 @@
+#include "GestionCollision.h"
+
+std::vector<Mobs> GestionCollision::CheckCollisonSol()
+{
+	return std::vector<Mobs>();
+}
+
+std::vector<Mobs> GestionCollision::CheckCollisonMur()
+{
+	return std::vector<Mobs>();
+}
+
+std::vector<Mobs> GestionCollision::CheckCollisonToit()
+{
+	return std::vector<Mobs>();
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionCollision.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "GestionMobs.h"
+#include "GestionPlayer.h"
+#include "GestionTerrain.h"
+#include "Mobs.h"
+#include <vector>
+
+class GestionCollision
+{
+public :
+	GestionTerrain gTerrain;
+	GestionMobs gMobs;
+	GestionPlayer gPlayer;
+
+public:
+	std::vector<Mobs> CheckCollisonSol();
+	std::vector<Mobs> CheckCollisonMur();
+	std::vector<Mobs> CheckCollisonToit();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionIdentifiant.cpp

@@ -0,0 +1,6 @@
+#include "GestionIdentifiant.h"
+
+int GestionIdentifiant::getId()
+{
+	return 0;
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionIdentifiant.h

@@ -0,0 +1,10 @@
+#pragma once
+class GestionIdentifiant
+{
+public:
+	int idCourant;
+
+public:
+	int getId();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionItem.cpp

@@ -0,0 +1 @@
+#include "GestionItem.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionItem.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <vector>
+
+#include "Item.h"
+
+class GestionItem
+{
+public:
+	std::vector<Item> items;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionJeu.cpp

@@ -0,0 +1 @@
+#include "GestionJeu.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionJeu.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "GestionCollision.h"
+#include "GestionIdentifiant.h"
+#include "GestionItem.h"
+#include "GestionMobs.h"
+#include "GestionPlayer.h"
+#include "GestionTerrain.h"
+
+class GestionJeu
+{
+public:
+	GestionPlayer gPlayer;
+	GestionMobs gMobs;
+	GestionTerrain gTerrain;
+	GestionCollision gCollision;
+	GestionItem gItem;
+	GestionIdentifiant gId;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionMobs.cpp

@@ -0,0 +1,17 @@
+#include "GestionMobs.h"
+
+void GestionMobs::AjoutMobC2C(int pvMax, int speed, int degat, int cooldown, int rangeDegat, int rangeAgro)
+{
+}
+
+void GestionMobs::AjoutMobDistance(int pvMax, int speed, int degat, int cooldown, int rangeAgro)
+{
+}
+
+void GestionMobs::SupprimerMob(int id)
+{
+}
+
+void GestionMobs::SupprimerTout()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionMobs.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+
+#include "MobsIA.h"
+
+
+class GestionMobs
+{
+public :
+	std::vector<MobsIA> mobs;
+
+public:
+	void AjoutMobC2C(int pvMax, int speed, int degat, int cooldown, int rangeDegat, int rangeAgro);
+	void AjoutMobDistance(int pvMax, int speed, int degat, int cooldown, int rangeAgro);
+
+	void SupprimerMob(int id);
+	void SupprimerTout();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionPlayer.cpp

@@ -0,0 +1,25 @@
+#include "GestionPlayer.h"
+
+void GestionPlayer::droit()
+{
+}
+
+void GestionPlayer::gauche()
+{
+}
+
+void GestionPlayer::bas()
+{
+}
+
+void GestionPlayer::saut()
+{
+}
+
+void GestionPlayer::idle()
+{
+}
+
+void GestionPlayer::attack()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionPlayer.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "Player.h"
+
+class GestionPlayer
+{
+public:
+	Player p;
+
+public:
+	void droit();
+	void gauche();
+	void bas();
+	void saut();
+	void idle();
+	void attack();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionTerrain.cpp

@@ -0,0 +1,17 @@
+#include "GestionTerrain.h"
+
+void GestionTerrain::AjoutMur(int sizeX, int sizeY, int posX, int posY)
+{
+}
+
+void GestionTerrain::AjoutSolSolide(int sizeX, int sizeY, int posX, int posY)
+{
+}
+
+void GestionTerrain::AjoutSolTraversable(int sizeX, int sizeY, int posX, int posY)
+{
+}
+
+void GestionTerrain::SuppressionTout()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/GestionTerrain.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <vector>
+
+#include "Terrain.h"
+
+class GestionTerrain
+{
+public:
+	std::vector<Terrain> terrains;
+
+public:
+	void AjoutMur(int sizeX, int sizeY, int posX, int posY);
+	void AjoutSolSolide(int sizeX, int sizeY, int posX, int posY);
+	void AjoutSolTraversable(int sizeX, int sizeY, int posX, int posY);
+
+	void SuppressionTout();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/GodotLibrary.cpp

@@ -0,0 +1,16 @@
+#include "Player.h"
+
+using namespace godot;
+
+extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options * o) {
+	Godot::gdnative_init(o);
+}
+
+extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options * o) {
+	Godot::gdnative_terminate(o);
+}
+
+extern "C" void GDN_EXPORT godot_nativescript_init(void* handle) {
+	Godot::nativescript_init(handle);
+	register_class<Player>();
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/Item.cpp

@@ -0,0 +1 @@
+#include "Item.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Item.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Entite.h"
+class Item :
+	public Entite
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Loot.cpp

@@ -0,0 +1 @@
+#include "Loot.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Loot.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Item.h"
+class Loot :
+	public Item
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Mobs.cpp

@@ -0,0 +1 @@
+#include "Mobs.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Mobs.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "Entite.h"
+class Mobs :
+	public Entite
+{
+public:
+	int pv;
+	int degat;
+	int cooldown;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsAgressif.cpp

@@ -0,0 +1 @@
+#include "MobsAgressif.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsAgressif.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "Mobs.h"
+class MobsAgressif :
+	public Mobs
+{
+
+public:
+	int rangeAgro;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsCorpACorp.cpp

@@ -0,0 +1 @@
+#include "MobsCorpACorp.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsCorpACorp.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "MobsAgressif.h"
+class MobsCorpACorp :
+	public MobsAgressif
+{
+public:
+	int rangeDegat;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsCorpACorpIA.cpp

@@ -0,0 +1,5 @@
+#include "MobsCorpACorpIA.h"
+
+void MobsCorpACorpIA::Action()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsCorpACorpIA.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "MobsCorpACorp.h"
+#include "MobsIA.h"
+class MobsCorpACorpIA :
+	public MobsIA
+{
+public:
+	MobsCorpACorp m;
+
+public:
+	void Action();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsDistance.cpp

@@ -0,0 +1 @@
+#include "MobsDistance.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsDistance.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "MobsAgressif.h"
+class MobsDistance :
+	public MobsAgressif
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsDistanceIA.cpp

@@ -0,0 +1,5 @@
+#include "MobsDistanceIA.h"
+
+void MobsDistanceIA::Action()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsDistanceIA.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "MobsDistance.h"
+#include "MobsIA.h"
+class MobsDistanceIA :
+	public MobsIA
+{
+public:
+	MobsDistance m;
+
+public:
+	void Action();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsIA.cpp

@@ -0,0 +1 @@
+#include "MobsIA.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsIA.h

@@ -0,0 +1,5 @@
+#pragma once
+class MobsIA
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsPassif.cpp

@@ -0,0 +1 @@
+#include "MobsPassif.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/MobsPassif.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Entite.h"
+class MobsPassif :
+	public Entite
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Mur.cpp

@@ -0,0 +1 @@
+#include "Mur.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Mur.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Terrain.h"
+class Mur :
+	public Terrain
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Piece.cpp

@@ -0,0 +1 @@
+#include "Piece.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Piece.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Loot.h"
+class Piece :
+	public Loot
+{
+public:
+	int value;
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Player.cpp

@@ -0,0 +1,14 @@
+#include "Player.h"
+
+void Player::_register_methods()
+{
+	register_method((char*)"_process", &Player::_process);
+}
+
+void Player::_process(float delta)
+{
+}
+
+Player::Player()
+{
+}

DungeonAndDeamonScript/DungeonAndDemaonScript/Player.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "Mobs.h"
+
+#include <Godot.hpp>
+#include <KinematicBody2D.hpp>
+
+class Player :
+	public Mobs
+{
+	// Godot structure
+private:
+	GODOT_CLASS(Player, KinematicBody2D)
+
+public:
+	void static _register_methods();
+	void _process(float delta);
+
+public:
+	Player();
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Root.cpp

@@ -0,0 +1 @@
+#include "Root.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Root.h

@@ -0,0 +1,5 @@
+#pragma once
+class Root
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Sol.cpp

@@ -0,0 +1 @@
+#include "Sol.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Sol.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Terrain.h"
+class Sol :
+	public Terrain
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/SolSolide.cpp

@@ -0,0 +1 @@
+#include "SolSolide.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/SolSolide.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Sol.h"
+class SolSolide :
+	public Sol
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/SolTraversable.cpp

@@ -0,0 +1 @@
+#include "SolTraversable.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/SolTraversable.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Sol.h"
+class SolTraversable :
+	public Sol
+{
+};
+

DungeonAndDeamonScript/DungeonAndDemaonScript/Terrain.cpp

@@ -0,0 +1 @@
+#include "Terrain.h"

DungeonAndDeamonScript/DungeonAndDemaonScript/Terrain.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <StaticBody2D.hpp>
+
+class Terrain :
+	public godot::StaticBody2D
+{
+};
+

GodoBinding/godot_headers/.gitattributes

@@ -0,0 +1,13 @@
+# Properly detect languages on Github
+*.h linguist-language=c
+*.inc linguist-language=c
+drivers/* linguist-vendored
+
+*.c eol=lf
+*.cpp eol=lf
+*.mm eol=lf
+*.h eol=lf
+*.py eol=lf
+*.hpp eol=lf
+*.xml eol=lf
+*.json eol=lf

GodoBinding/godot_headers/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2017-2020 GodotNativeTools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

GodoBinding/godot_headers/README.md

@@ -0,0 +1,234 @@
+# godot_headers
+#### `GDNative / NativeScript`
+
+> `GDNative` enables the use of dynamically linked libraries inside of [**Godot**](https://github.com/godotengine/godot).
+
+> `NativeScript` uses GDNative to implement scripts backed by native code.
+
+-   [**Getting Started**](#getting-started)
+-   [**FAQ**](#faq)
+
+## Getting Started
+
+| **Build latest version of Godot** | [**GitHub**](https://github.com/godotengine/godot) | [**Docs**](https://godot.readthedocs.io/en/latest/development/compiling/index.html) |
+| --- | --- | --- |
+
+### Clone godot_headers into Library
+
+Clone `godot_headers` under `SimpleLibrary/`
+
+```bash
+cd SimpleLibrary
+git clone https://github.com/GodotNativeTools/godot_headers
+```
+
+> Note that the master branch of this repository contains the header for the latest Godot master. If you want to build GDNative modules for older versions of Godot add `-b <version>` to the git clone command above. i.e. `git clone https://github.com/GodotNativeTools/godot_headers -b 3.0` will retrieve headers compatible with Godot 3.0.
+
+> With the exception of a breaking change in the ARVR module between 3.0 and 3.1, GDNative plugins written for an older version of Godot will work in newer versions.
+
+```bash
+[SimpleLibrary]
+  ├── lib/
+  └── src/
+```
+
+### Create Script
+
+Create `test.c` under `SimpleLibrary/src/`
+
+<details>
+
+```c
+#include <gdnative/gdnative.h>
+#include <nativescript/godot_nativescript.h>
+
+#include <stdio.h>
+
+void *test_constructor(godot_object *obj, void *method_data) {
+        printf("test.constructor()\n");
+        return 0;
+}
+
+void test_destructor(godot_object *obj, void *method_data, void *user_data) {
+        printf("test.destructor()\n");
+}
+
+/** func _ready() **/
+godot_variant test_ready(godot_object *obj, void *method_data, void *user_data, int num_args, godot_variant **args) {
+        godot_variant ret;
+        godot_variant_new_nil(&ret);
+
+        printf("_ready()\n");
+
+        return ret;
+}
+
+/** Library entry point **/
+void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
+}
+
+/** Library de-initialization **/
+void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
+}
+
+/** Script entry (Registering all the classes and stuff) **/
+void GDN_EXPORT godot_nativescript_init(void *desc) {
+	printf("nativescript init\n");
+
+	godot_instance_create_func create_func = {
+		.create_func = &test_constructor,
+                .method_data = 0,
+                .free_func   = 0
+        };
+
+        godot_instance_destroy_func destroy_func = {
+                .destroy_func = &test_destructor,
+                .method_data  = 0,
+                .free_func    = 0
+        };
+
+        godot_nativescript_register_class(desc, "SimpleClass", "Node", create_func, destroy_func);
+
+        {
+                godot_instance_method method = {
+                        .method = &test_ready,
+                        .method_data = 0,
+                        .free_func = 0
+                };
+
+                godot_method_attributes attr = {
+                        .rpc_type = GODOT_METHOD_RPC_MODE_DISABLED
+                };
+
+                godot_nativescript_register_method(desc, "SimpleClass", "_ready", attr, method);
+        }
+}
+
+godot_variant GDN_EXPORT some_test_procedure(void *data, godot_array *args) {
+        godot_variant ret;
+        godot_variant_new_int(&ret, 42);
+
+        godot_string s;
+        godot_string_new_unicode_data(&s, L"Hello World", 11);
+        godot_print(&s);
+
+        godot_string_destroy(&s);
+
+        return ret;
+}
+```
+
+</details>
+
+`Expand details for example code.`
+
+### Compile Library
+
+On Linux:
+
+```bash
+clang -g -fPIC -std=c99 -c src/test.c -I/path/to/godot/headers/ -o src/test.os
+clang -g -shared src/test.os -o lib/test.so
+```
+
+On MacOS:
+
+```bash
+clang -g -fPIC -std=c99 -c src/test.c -I/path/to/godot/headers/ -o src/test.os
+clang -g -shared -framework Cocoa -Wl,-undefined,dynamic_lookup src/test.os -o lib/test.dylib
+```
+
+- `-g` is for debugging information.
+- Use `godot_nativescript_*` methods only in the `nativescript_init()` function.
+
+### Create GDNativeLibrary Resource
+The GDNativeLibrary resource contains links to the libraries for each platform.
+
+1. Create a new resource in memory and edit it.
+1. Select `Resource > GDNativeLibrary`.
+1. Set the library file for your platform inside the inspector.
+1. Save the edited resource as a `.tres`
+
+<details>
+
+![](images/faq/dllibrary_create_new_resource.png?raw=true)
+
+![](images/faq/dllibrary_create_new_dllibrary.png?raw=true)
+
+![](images/faq/dllibrary_save_as_resource.png?raw=true)
+
+*Note*: Remember to save `GDNativeLibrary` as `.gdnlib`
+
+</details>
+
+`Expand details for screenshots.`
+
+### Using GDNativeLibrary in GDScript
+
+```gdscript
+extends Node
+
+func _ready():
+        var gdn = GDNative.new()
+        gdn.library = load("res://lib/libtest.tres")
+
+        gdn.initialize()
+
+        var res = gdn.call_native("standard_varcall", "some_test_procedure", [])
+
+        print("result: ", res)
+
+        gdn.terminate()
+```
+
+### Attaching GDNativeLibrary to a Node
+
+1. Attach a new script to a node.
+1. In the pop-up dialog, choose NativeScript in the `Language` menu.
+1. Enable built-in script, or create a `.gdn` file, which only contains a name.
+1. Specify the `Class Name`.
+1. Press `Create`.
+
+The GDNativeLibrary field in a NativeScript is empty by default.
+
+
+<details>
+
+![](images/faq/create_dlscript.png?raw=true)
+
+![](images/faq/set_script_dllibrary.png?raw=true)
+
+</details>
+
+`Expand details for screenshots.`
+
+## FAQ
+
+**What is the difference between `GDNative` and `NativeScript`?**
+
+`GDNative` is a new class that can call native functions in libraries.
+GDScript / VisualScript / C#, etc, are able to use this class.
+
+Godot treats `NativeScript` as a scripting language, enabling the
+use of GDNative to implement scripts backed by native code.
+
+**Which languages are binding as a NativeScript?**
+
+[**C++**](https://github.com/GodotNativeTools/cpp_bindings),
+[**D**](https://github.com/GodotNativeTools/d_bindings),
+[**Nim**](https://github.com/pragmagic/godot-nim)
+
+**Can you debug NativeScripts?**
+
+You must compile the library with debug
+symbols, and then you can use your debugger as usual.
+
+**Can you use one GDNativeLibrary for all NativeScripts?**
+
+You can! ✨
+
+**What is the reason behind the name "GDNative"?**
+
+GDNative was originally named "cscript" because it exposes a C API, but people
+mistook a relation to C#, which is sometimes abbreviated as "cs". Then named "DLScript", but that brought up some confusion, so we settled with
+GDNative. 📖

GodoBinding/godot_headers/android/godot_android.h

@@ -0,0 +1,56 @@
+/*************************************************************************/
+/*  godot_android.h                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_ANDROID_GDN_H
+#define GODOT_ANDROID_GDN_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __ANDROID__
+#include <jni.h>
+#else
+#define JNIEnv void
+#define jobject void *
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JNIEnv *GDAPI godot_android_get_env();
+jobject GDAPI godot_android_get_activity();
+jobject GDAPI godot_android_get_surface();
+bool GDAPI godot_android_is_activity_resumed();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !GODOT_ANDROID_GDN_H */

GodoBinding/godot_headers/arvr/godot_arvr.h

@@ -0,0 +1,92 @@
+/*************************************************************************/
+/*  godot_arvr.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NATIVEARVR_H
+#define GODOT_NATIVEARVR_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// For future versions of the API we should only add new functions at the end of the structure and use the
+// version info to detect whether a call is available
+
+// Use these to populate version in your plugin
+#define GODOTVR_API_MAJOR 1
+#define GODOTVR_API_MINOR 1
+
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+	void *(*constructor)(godot_object *);
+	void (*destructor)(void *);
+	godot_string (*get_name)(const void *);
+	godot_int (*get_capabilities)(const void *);
+	godot_bool (*get_anchor_detection_is_enabled)(const void *);
+	void (*set_anchor_detection_is_enabled)(void *, godot_bool);
+	godot_bool (*is_stereo)(const void *);
+	godot_bool (*is_initialized)(const void *);
+	godot_bool (*initialize)(void *);
+	void (*uninitialize)(void *);
+	godot_vector2 (*get_render_targetsize)(const void *);
+	godot_transform (*get_transform_for_eye)(void *, godot_int, godot_transform *);
+	void (*fill_projection_for_eye)(void *, godot_real *, godot_int, godot_real, godot_real, godot_real);
+	void (*commit_for_eye)(void *, godot_int, godot_rid *, godot_rect2 *);
+	void (*process)(void *);
+	// only in 1.1 onwards
+	godot_int (*get_external_texture_for_eye)(void *, godot_int);
+	void (*notification)(void *, godot_int);
+	godot_int (*get_camera_feed_id)(void *);
+} godot_arvr_interface_gdnative;
+
+void GDAPI godot_arvr_register_interface(const godot_arvr_interface_gdnative *p_interface);
+
+// helper functions to access ARVRServer data
+godot_real GDAPI godot_arvr_get_worldscale();
+godot_transform GDAPI godot_arvr_get_reference_frame();
+
+// helper functions for rendering
+void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_rect2 *p_rect);
+godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target);
+
+// helper functions for updating ARVR controllers
+godot_int GDAPI godot_arvr_add_controller(char *p_device_name, godot_int p_hand, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
+void GDAPI godot_arvr_remove_controller(godot_int p_controller_id);
+void GDAPI godot_arvr_set_controller_transform(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
+void GDAPI godot_arvr_set_controller_button(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed);
+void GDAPI godot_arvr_set_controller_axis(godot_int p_controller_id, godot_int p_axis, godot_real p_value, godot_bool p_can_be_negative);
+godot_real GDAPI godot_arvr_get_controller_rumble(godot_int p_controller_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !GODOT_NATIVEARVR_H */

GodoBinding/godot_headers/gdnative/aabb.h

@@ -0,0 +1,118 @@
+/*************************************************************************/
+/*  aabb.h                                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_AABB_H
+#define GODOT_AABB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_AABB_SIZE 24
+
+#ifndef GODOT_CORE_API_GODOT_AABB_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_AABB_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_AABB_SIZE];
+} godot_aabb;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/plane.h>
+#include <gdnative/vector3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_aabb_new(godot_aabb *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size);
+
+godot_vector3 GDAPI godot_aabb_get_position(const godot_aabb *p_self);
+void GDAPI godot_aabb_set_position(const godot_aabb *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_aabb_get_size(const godot_aabb *p_self);
+void GDAPI godot_aabb_set_size(const godot_aabb *p_self, const godot_vector3 *p_v);
+
+godot_string GDAPI godot_aabb_as_string(const godot_aabb *p_self);
+
+godot_real GDAPI godot_aabb_get_area(const godot_aabb *p_self);
+
+godot_bool GDAPI godot_aabb_has_no_area(const godot_aabb *p_self);
+
+godot_bool GDAPI godot_aabb_has_no_surface(const godot_aabb *p_self);
+
+godot_bool GDAPI godot_aabb_intersects(const godot_aabb *p_self, const godot_aabb *p_with);
+
+godot_bool GDAPI godot_aabb_encloses(const godot_aabb *p_self, const godot_aabb *p_with);
+
+godot_aabb GDAPI godot_aabb_merge(const godot_aabb *p_self, const godot_aabb *p_with);
+
+godot_aabb GDAPI godot_aabb_intersection(const godot_aabb *p_self, const godot_aabb *p_with);
+
+godot_bool GDAPI godot_aabb_intersects_plane(const godot_aabb *p_self, const godot_plane *p_plane);
+
+godot_bool GDAPI godot_aabb_intersects_segment(const godot_aabb *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to);
+
+godot_bool GDAPI godot_aabb_has_point(const godot_aabb *p_self, const godot_vector3 *p_point);
+
+godot_vector3 GDAPI godot_aabb_get_support(const godot_aabb *p_self, const godot_vector3 *p_dir);
+
+godot_vector3 GDAPI godot_aabb_get_longest_axis(const godot_aabb *p_self);
+
+godot_int GDAPI godot_aabb_get_longest_axis_index(const godot_aabb *p_self);
+
+godot_real GDAPI godot_aabb_get_longest_axis_size(const godot_aabb *p_self);
+
+godot_vector3 GDAPI godot_aabb_get_shortest_axis(const godot_aabb *p_self);
+
+godot_int GDAPI godot_aabb_get_shortest_axis_index(const godot_aabb *p_self);
+
+godot_real GDAPI godot_aabb_get_shortest_axis_size(const godot_aabb *p_self);
+
+godot_aabb GDAPI godot_aabb_expand(const godot_aabb *p_self, const godot_vector3 *p_to_point);
+
+godot_aabb GDAPI godot_aabb_grow(const godot_aabb *p_self, const godot_real p_by);
+
+godot_vector3 GDAPI godot_aabb_get_endpoint(const godot_aabb *p_self, const godot_int p_idx);
+
+godot_bool GDAPI godot_aabb_operator_equal(const godot_aabb *p_self, const godot_aabb *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_AABB_H

GodoBinding/godot_headers/gdnative/array.h

@@ -0,0 +1,147 @@
+/*************************************************************************/
+/*  array.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_ARRAY_H
+#define GODOT_ARRAY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_ARRAY_SIZE];
+} godot_array;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/pool_arrays.h>
+#include <gdnative/variant.h>
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_array_new(godot_array *r_dest);
+void GDAPI godot_array_new_copy(godot_array *r_dest, const godot_array *p_src);
+void GDAPI godot_array_new_pool_color_array(godot_array *r_dest, const godot_pool_color_array *p_pca);
+void GDAPI godot_array_new_pool_vector3_array(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a);
+void GDAPI godot_array_new_pool_vector2_array(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a);
+void GDAPI godot_array_new_pool_string_array(godot_array *r_dest, const godot_pool_string_array *p_psa);
+void GDAPI godot_array_new_pool_real_array(godot_array *r_dest, const godot_pool_real_array *p_pra);
+void GDAPI godot_array_new_pool_int_array(godot_array *r_dest, const godot_pool_int_array *p_pia);
+void GDAPI godot_array_new_pool_byte_array(godot_array *r_dest, const godot_pool_byte_array *p_pba);
+
+void GDAPI godot_array_set(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value);
+
+godot_variant GDAPI godot_array_get(const godot_array *p_self, const godot_int p_idx);
+
+godot_variant GDAPI *godot_array_operator_index(godot_array *p_self, const godot_int p_idx);
+
+const godot_variant GDAPI *godot_array_operator_index_const(const godot_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_array_append(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_clear(godot_array *p_self);
+
+godot_int GDAPI godot_array_count(const godot_array *p_self, const godot_variant *p_value);
+
+godot_bool GDAPI godot_array_empty(const godot_array *p_self);
+
+void GDAPI godot_array_erase(godot_array *p_self, const godot_variant *p_value);
+
+godot_variant GDAPI godot_array_front(const godot_array *p_self);
+
+godot_variant GDAPI godot_array_back(const godot_array *p_self);
+
+godot_int GDAPI godot_array_find(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+
+godot_int GDAPI godot_array_find_last(const godot_array *p_self, const godot_variant *p_what);
+
+godot_bool GDAPI godot_array_has(const godot_array *p_self, const godot_variant *p_value);
+
+godot_int GDAPI godot_array_hash(const godot_array *p_self);
+
+void GDAPI godot_array_insert(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value);
+
+void GDAPI godot_array_invert(godot_array *p_self);
+
+godot_variant GDAPI godot_array_pop_back(godot_array *p_self);
+
+godot_variant GDAPI godot_array_pop_front(godot_array *p_self);
+
+void GDAPI godot_array_push_back(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_push_front(godot_array *p_self, const godot_variant *p_value);
+
+void GDAPI godot_array_remove(godot_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_array_resize(godot_array *p_self, const godot_int p_size);
+
+godot_int GDAPI godot_array_rfind(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+
+godot_int GDAPI godot_array_size(const godot_array *p_self);
+
+void GDAPI godot_array_sort(godot_array *p_self);
+
+void GDAPI godot_array_sort_custom(godot_array *p_self, godot_object *p_obj, const godot_string *p_func);
+
+godot_int GDAPI godot_array_bsearch(godot_array *p_self, const godot_variant *p_value, const godot_bool p_before);
+
+godot_int GDAPI godot_array_bsearch_custom(godot_array *p_self, const godot_variant *p_value, godot_object *p_obj, const godot_string *p_func, const godot_bool p_before);
+
+void GDAPI godot_array_destroy(godot_array *p_self);
+
+godot_array GDAPI godot_array_duplicate(const godot_array *p_self, const godot_bool p_deep);
+
+godot_array GDAPI godot_array_slice(const godot_array *p_self, const godot_int p_begin, const godot_int p_end, const godot_int p_step, const godot_bool p_deep);
+
+godot_variant GDAPI godot_array_max(const godot_array *p_self);
+
+godot_variant GDAPI godot_array_min(const godot_array *p_self);
+
+void GDAPI godot_array_shuffle(godot_array *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_ARRAY_H

GodoBinding/godot_headers/gdnative/basis.h

@@ -0,0 +1,136 @@
+/*************************************************************************/
+/*  basis.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_BASIS_H
+#define GODOT_BASIS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_BASIS_SIZE 36
+
+#ifndef GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_BASIS_SIZE];
+} godot_basis;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/quat.h>
+#include <gdnative/vector3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis);
+void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi);
+void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler);
+void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler);
+
+godot_string GDAPI godot_basis_as_string(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self);
+
+godot_real GDAPI godot_basis_determinant(const godot_basis *p_self);
+
+godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale);
+
+godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self);
+
+godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self);
+
+godot_quat GDAPI godot_basis_get_quat(const godot_basis *p_self);
+
+void GDAPI godot_basis_set_quat(godot_basis *p_self, const godot_quat *p_quat);
+
+void GDAPI godot_basis_set_axis_angle_scale(godot_basis *p_self, const godot_vector3 *p_axis, godot_real p_phi, const godot_vector3 *p_scale);
+
+void GDAPI godot_basis_set_euler_scale(godot_basis *p_self, const godot_vector3 *p_euler, const godot_vector3 *p_scale);
+
+void GDAPI godot_basis_set_quat_scale(godot_basis *p_self, const godot_quat *p_quat, const godot_vector3 *p_scale);
+
+godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with);
+
+godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v);
+
+godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self);
+
+void GDAPI godot_basis_new(godot_basis *r_dest);
+
+// p_elements is a pointer to an array of 3 (!!) vector3
+void GDAPI godot_basis_get_elements(const godot_basis *p_self, godot_vector3 *p_elements);
+
+godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis);
+
+void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value);
+
+godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row);
+
+void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value);
+
+godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_subtract(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b);
+
+godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b);
+
+godot_basis GDAPI godot_basis_slerp(const godot_basis *p_self, const godot_basis *p_b, const godot_real p_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_BASIS_H

GodoBinding/godot_headers/gdnative/color.h

@@ -0,0 +1,120 @@
+/*************************************************************************/
+/*  color.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_COLOR_H
+#define GODOT_COLOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_COLOR_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_COLOR_SIZE];
+} godot_color;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a);
+void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b);
+
+godot_real godot_color_get_r(const godot_color *p_self);
+void godot_color_set_r(godot_color *p_self, const godot_real r);
+
+godot_real godot_color_get_g(const godot_color *p_self);
+void godot_color_set_g(godot_color *p_self, const godot_real g);
+
+godot_real godot_color_get_b(const godot_color *p_self);
+void godot_color_set_b(godot_color *p_self, const godot_real b);
+
+godot_real godot_color_get_a(const godot_color *p_self);
+void godot_color_set_a(godot_color *p_self, const godot_real a);
+
+godot_real godot_color_get_h(const godot_color *p_self);
+godot_real godot_color_get_s(const godot_color *p_self);
+godot_real godot_color_get_v(const godot_color *p_self);
+
+godot_string GDAPI godot_color_as_string(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_rgba32(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_abgr32(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_abgr64(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_argb64(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_rgba64(const godot_color *p_self);
+
+godot_int GDAPI godot_color_to_argb32(const godot_color *p_self);
+
+godot_real GDAPI godot_color_gray(const godot_color *p_self);
+
+godot_color GDAPI godot_color_inverted(const godot_color *p_self);
+
+godot_color GDAPI godot_color_contrasted(const godot_color *p_self);
+
+godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
+
+godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over);
+
+godot_color GDAPI godot_color_darkened(const godot_color *p_self, const godot_real p_amount);
+
+godot_color GDAPI godot_color_from_hsv(const godot_color *p_self, const godot_real p_h, const godot_real p_s, const godot_real p_v, const godot_real p_a);
+
+godot_color GDAPI godot_color_lightened(const godot_color *p_self, const godot_real p_amount);
+
+godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha);
+
+godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b);
+
+godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_COLOR_H

GodoBinding/godot_headers/gdnative/dictionary.h

@@ -0,0 +1,109 @@
+/*************************************************************************/
+/*  dictionary.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_DICTIONARY_H
+#define GODOT_DICTIONARY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_DICTIONARY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_DICTIONARY_SIZE];
+} godot_dictionary;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/array.h>
+#include <gdnative/gdnative.h>
+#include <gdnative/variant.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_dictionary_new(godot_dictionary *r_dest);
+void GDAPI godot_dictionary_new_copy(godot_dictionary *r_dest, const godot_dictionary *p_src);
+void GDAPI godot_dictionary_destroy(godot_dictionary *p_self);
+
+godot_dictionary GDAPI godot_dictionary_duplicate(const godot_dictionary *p_self, const godot_bool p_deep);
+
+godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self);
+
+godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self);
+
+void GDAPI godot_dictionary_clear(godot_dictionary *p_self);
+
+godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys);
+
+void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self);
+
+godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self);
+
+godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self);
+
+godot_variant GDAPI godot_dictionary_get(const godot_dictionary *p_self, const godot_variant *p_key);
+void GDAPI godot_dictionary_set(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value);
+
+godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_self, const godot_variant *p_key);
+
+const godot_variant GDAPI *godot_dictionary_operator_index_const(const godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_variant GDAPI *godot_dictionary_next(const godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b);
+
+godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_self);
+
+// GDNative core 1.1
+
+godot_bool GDAPI godot_dictionary_erase_with_return(godot_dictionary *p_self, const godot_variant *p_key);
+
+godot_variant GDAPI godot_dictionary_get_with_default(const godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_default);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_DICTIONARY_H

GodoBinding/godot_headers/gdnative/gdnative.h

@@ -0,0 +1,300 @@
+/*************************************************************************/
+/*  gdnative.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_GDNATIVE_H
+#define GODOT_GDNATIVE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32) || defined(__ANDROID__)
+#define GDCALLINGCONV
+#define GDAPI GDCALLINGCONV
+#elif defined(__APPLE__)
+#include "TargetConditionals.h"
+#if TARGET_OS_IPHONE
+#define GDCALLINGCONV __attribute__((visibility("default")))
+#define GDAPI GDCALLINGCONV
+#elif TARGET_OS_MAC
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+#else // !_WIN32 && !__APPLE__
+#define GDCALLINGCONV __attribute__((sysv_abi))
+#define GDAPI GDCALLINGCONV
+#endif
+
+// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!!
+#ifdef _WIN32
+#define GDN_EXPORT __declspec(dllexport)
+#else
+#define GDN_EXPORT
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define GODOT_API_VERSION 1
+
+////// Error
+
+typedef enum {
+	GODOT_OK, // (0)
+	GODOT_FAILED, ///< Generic fail error
+	GODOT_ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable
+	GODOT_ERR_UNCONFIGURED, ///< The object being used hasn't been properly set up yet
+	GODOT_ERR_UNAUTHORIZED, ///< Missing credentials for requested resource
+	GODOT_ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5)
+	GODOT_ERR_OUT_OF_MEMORY, ///< Out of memory
+	GODOT_ERR_FILE_NOT_FOUND,
+	GODOT_ERR_FILE_BAD_DRIVE,
+	GODOT_ERR_FILE_BAD_PATH,
+	GODOT_ERR_FILE_NO_PERMISSION, // (10)
+	GODOT_ERR_FILE_ALREADY_IN_USE,
+	GODOT_ERR_FILE_CANT_OPEN,
+	GODOT_ERR_FILE_CANT_WRITE,
+	GODOT_ERR_FILE_CANT_READ,
+	GODOT_ERR_FILE_UNRECOGNIZED, // (15)
+	GODOT_ERR_FILE_CORRUPT,
+	GODOT_ERR_FILE_MISSING_DEPENDENCIES,
+	GODOT_ERR_FILE_EOF,
+	GODOT_ERR_CANT_OPEN, ///< Can't open a resource/socket/file
+	GODOT_ERR_CANT_CREATE, // (20)
+	GODOT_ERR_QUERY_FAILED,
+	GODOT_ERR_ALREADY_IN_USE,
+	GODOT_ERR_LOCKED, ///< resource is locked
+	GODOT_ERR_TIMEOUT,
+	GODOT_ERR_CANT_CONNECT, // (25)
+	GODOT_ERR_CANT_RESOLVE,
+	GODOT_ERR_CONNECTION_ERROR,
+	GODOT_ERR_CANT_ACQUIRE_RESOURCE,
+	GODOT_ERR_CANT_FORK,
+	GODOT_ERR_INVALID_DATA, ///< Data passed is invalid (30)
+	GODOT_ERR_INVALID_PARAMETER, ///< Parameter passed is invalid
+	GODOT_ERR_ALREADY_EXISTS, ///< When adding, item already exists
+	GODOT_ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, it item does not exist
+	GODOT_ERR_DATABASE_CANT_READ, ///< database is full
+	GODOT_ERR_DATABASE_CANT_WRITE, ///< database is full (35)
+	GODOT_ERR_COMPILATION_FAILED,
+	GODOT_ERR_METHOD_NOT_FOUND,
+	GODOT_ERR_LINK_FAILED,
+	GODOT_ERR_SCRIPT_FAILED,
+	GODOT_ERR_CYCLIC_LINK, // (40)
+	GODOT_ERR_INVALID_DECLARATION,
+	GODOT_ERR_DUPLICATE_SYMBOL,
+	GODOT_ERR_PARSE_ERROR,
+	GODOT_ERR_BUSY,
+	GODOT_ERR_SKIP, // (45)
+	GODOT_ERR_HELP, ///< user requested help!!
+	GODOT_ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior.
+	GODOT_ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames
+} godot_error;
+
+////// bool
+
+typedef bool godot_bool;
+
+#define GODOT_TRUE 1
+#define GODOT_FALSE 0
+
+/////// int
+
+typedef int godot_int;
+
+/////// real
+
+typedef float godot_real;
+
+/////// Object (forward declared)
+typedef void godot_object;
+
+/////// String
+
+#include <gdnative/string.h>
+
+/////// String name
+
+#include <gdnative/string_name.h>
+
+////// Vector2
+
+#include <gdnative/vector2.h>
+
+////// Rect2
+
+#include <gdnative/rect2.h>
+
+////// Vector3
+
+#include <gdnative/vector3.h>
+
+////// Transform2D
+
+#include <gdnative/transform2d.h>
+
+/////// Plane
+
+#include <gdnative/plane.h>
+
+/////// Quat
+
+#include <gdnative/quat.h>
+
+/////// AABB
+
+#include <gdnative/aabb.h>
+
+/////// Basis
+
+#include <gdnative/basis.h>
+
+/////// Transform
+
+#include <gdnative/transform.h>
+
+/////// Color
+
+#include <gdnative/color.h>
+
+/////// NodePath
+
+#include <gdnative/node_path.h>
+
+/////// RID
+
+#include <gdnative/rid.h>
+
+/////// Dictionary
+
+#include <gdnative/dictionary.h>
+
+/////// Array
+
+#include <gdnative/array.h>
+
+// single API file for Pool*Array
+#include <gdnative/pool_arrays.h>
+
+void GDAPI godot_object_destroy(godot_object *p_o);
+
+////// Variant
+
+#include <gdnative/variant.h>
+
+////// Singleton API
+
+godot_object GDAPI *godot_global_get_singleton(char *p_name); // result shouldn't be freed
+
+////// MethodBind API
+
+typedef struct {
+	uint8_t _dont_touch_that[1]; // TODO
+} godot_method_bind;
+
+godot_method_bind GDAPI *godot_method_bind_get_method(const char *p_classname, const char *p_methodname);
+void GDAPI godot_method_bind_ptrcall(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret);
+godot_variant GDAPI godot_method_bind_call(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error);
+////// Script API
+
+typedef struct godot_gdnative_api_version {
+	unsigned int major;
+	unsigned int minor;
+} godot_gdnative_api_version;
+
+typedef struct godot_gdnative_api_struct godot_gdnative_api_struct;
+
+struct godot_gdnative_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+};
+
+#define GDNATIVE_VERSION_COMPATIBLE(want, have) (want.major == have.major && want.minor <= have.minor)
+
+typedef struct {
+	godot_bool in_editor;
+	uint64_t core_api_hash;
+	uint64_t editor_api_hash;
+	uint64_t no_api_hash;
+	void (*report_version_mismatch)(const godot_object *p_library, const char *p_what, godot_gdnative_api_version p_want, godot_gdnative_api_version p_have);
+	void (*report_loading_error)(const godot_object *p_library, const char *p_what);
+	godot_object *gd_native_library; // pointer to GDNativeLibrary that is being initialized
+	const struct godot_gdnative_core_api_struct *api_struct;
+	const godot_string *active_library_path;
+} godot_gdnative_init_options;
+
+typedef struct {
+	godot_bool in_editor;
+} godot_gdnative_terminate_options;
+
+// Calling convention?
+typedef godot_object *(*godot_class_constructor)();
+
+godot_class_constructor GDAPI godot_get_class_constructor(const char *p_classname);
+
+godot_dictionary GDAPI godot_get_global_constants();
+
+////// GDNative procedure types
+typedef void (*godot_gdnative_init_fn)(godot_gdnative_init_options *);
+typedef void (*godot_gdnative_terminate_fn)(godot_gdnative_terminate_options *);
+typedef godot_variant (*godot_gdnative_procedure_fn)(godot_array *);
+
+////// System Functions
+
+typedef godot_variant (*native_call_cb)(void *, godot_array *);
+void GDAPI godot_register_native_call_type(const char *p_call_type, native_call_cb p_callback);
+
+//using these will help Godot track how much memory is in use in debug mode
+void GDAPI *godot_alloc(int p_bytes);
+void GDAPI *godot_realloc(void *p_ptr, int p_bytes);
+void GDAPI godot_free(void *p_ptr);
+
+//print using Godot's error handler list
+void GDAPI godot_print_error(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line);
+void GDAPI godot_print(const godot_string *p_message);
+
+// GDNATIVE CORE 1.0.1
+
+bool GDAPI godot_is_instance_valid(const godot_object *p_object);
+
+//tags used for safe dynamic casting
+void GDAPI *godot_get_class_tag(const godot_string_name *p_class);
+godot_object GDAPI *godot_object_cast_to(const godot_object *p_object, void *p_class_tag);
+
+// equivalent of GDScript's instance_from_id
+godot_object GDAPI *godot_instance_from_id(godot_int p_instance_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_C_H

GodoBinding/godot_headers/gdnative/node_path.h

@@ -0,0 +1,89 @@
+/*************************************************************************/
+/*  node_path.h                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NODE_PATH_H
+#define GODOT_NODE_PATH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_NODE_PATH_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_NODE_PATH_SIZE];
+} godot_node_path;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from);
+void GDAPI godot_node_path_new_copy(godot_node_path *r_dest, const godot_node_path *p_src);
+void GDAPI godot_node_path_destroy(godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self);
+
+godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self);
+
+godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx);
+
+godot_string GDAPI godot_node_path_get_concatenated_subnames(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self);
+
+godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b);
+
+godot_node_path godot_node_path_get_as_property_path(const godot_node_path *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_NODE_PATH_H

GodoBinding/godot_headers/gdnative/plane.h

@@ -0,0 +1,103 @@
+/*************************************************************************/
+/*  plane.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_PLANE_H
+#define GODOT_PLANE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_PLANE_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_PLANE_SIZE];
+} godot_plane;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/vector3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d);
+void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3);
+void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d);
+
+godot_string GDAPI godot_plane_as_string(const godot_plane *p_self);
+
+godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self);
+
+godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self);
+
+godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self);
+
+godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon);
+
+godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point);
+
+godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c);
+
+godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir);
+
+godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end);
+
+godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self);
+
+godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b);
+
+void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal);
+
+godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self);
+
+godot_real GDAPI godot_plane_get_d(const godot_plane *p_self);
+
+void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_PLANE_H

GodoBinding/godot_headers/gdnative/pool_arrays.h

@@ -0,0 +1,478 @@
+/*************************************************************************/
+/*  pool_arrays.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_POOL_ARRAYS_H
+#define GODOT_POOL_ARRAYS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/////// Read Access
+
+#define GODOT_POOL_ARRAY_READ_ACCESS_SIZE 1
+
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_ARRAY_READ_ACCESS_SIZE];
+} godot_pool_array_read_access;
+
+typedef godot_pool_array_read_access godot_pool_byte_array_read_access;
+typedef godot_pool_array_read_access godot_pool_int_array_read_access;
+typedef godot_pool_array_read_access godot_pool_real_array_read_access;
+typedef godot_pool_array_read_access godot_pool_string_array_read_access;
+typedef godot_pool_array_read_access godot_pool_vector2_array_read_access;
+typedef godot_pool_array_read_access godot_pool_vector3_array_read_access;
+typedef godot_pool_array_read_access godot_pool_color_array_read_access;
+
+/////// Write Access
+
+#define GODOT_POOL_ARRAY_WRITE_ACCESS_SIZE 1
+
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_ARRAY_WRITE_ACCESS_SIZE];
+} godot_pool_array_write_access;
+
+typedef godot_pool_array_write_access godot_pool_byte_array_write_access;
+typedef godot_pool_array_write_access godot_pool_int_array_write_access;
+typedef godot_pool_array_write_access godot_pool_real_array_write_access;
+typedef godot_pool_array_write_access godot_pool_string_array_write_access;
+typedef godot_pool_array_write_access godot_pool_vector2_array_write_access;
+typedef godot_pool_array_write_access godot_pool_vector3_array_write_access;
+typedef godot_pool_array_write_access godot_pool_color_array_write_access;
+
+/////// PoolByteArray
+
+#define GODOT_POOL_BYTE_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_BYTE_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_BYTE_ARRAY_SIZE];
+} godot_pool_byte_array;
+#endif
+
+/////// PoolIntArray
+
+#define GODOT_POOL_INT_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_INT_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_INT_ARRAY_SIZE];
+} godot_pool_int_array;
+#endif
+
+/////// PoolRealArray
+
+#define GODOT_POOL_REAL_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_REAL_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_REAL_ARRAY_SIZE];
+} godot_pool_real_array;
+#endif
+
+/////// PoolStringArray
+
+#define GODOT_POOL_STRING_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_STRING_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_STRING_ARRAY_SIZE];
+} godot_pool_string_array;
+#endif
+
+/////// PoolVector2Array
+
+#define GODOT_POOL_VECTOR2_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_VECTOR2_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_VECTOR2_ARRAY_SIZE];
+} godot_pool_vector2_array;
+#endif
+
+/////// PoolVector3Array
+
+#define GODOT_POOL_VECTOR3_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_VECTOR3_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_VECTOR3_ARRAY_SIZE];
+} godot_pool_vector3_array;
+#endif
+
+/////// PoolColorArray
+
+#define GODOT_POOL_COLOR_ARRAY_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_POOL_COLOR_ARRAY_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_POOL_COLOR_ARRAY_SIZE];
+} godot_pool_color_array;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/array.h>
+#include <gdnative/color.h>
+#include <gdnative/vector2.h>
+#include <gdnative/vector3.h>
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// byte
+
+void GDAPI godot_pool_byte_array_new(godot_pool_byte_array *r_dest);
+void GDAPI godot_pool_byte_array_new_copy(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src);
+void GDAPI godot_pool_byte_array_new_with_array(godot_pool_byte_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_byte_array_append(godot_pool_byte_array *p_self, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_append_array(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array);
+
+godot_error GDAPI godot_pool_byte_array_insert(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_invert(godot_pool_byte_array *p_self);
+
+void GDAPI godot_pool_byte_array_push_back(godot_pool_byte_array *p_self, const uint8_t p_data);
+
+void GDAPI godot_pool_byte_array_remove(godot_pool_byte_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_byte_array_resize(godot_pool_byte_array *p_self, const godot_int p_size);
+
+godot_pool_byte_array_read_access GDAPI *godot_pool_byte_array_read(const godot_pool_byte_array *p_self);
+
+godot_pool_byte_array_write_access GDAPI *godot_pool_byte_array_write(godot_pool_byte_array *p_self);
+
+void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_self);
+
+godot_bool GDAPI godot_pool_byte_array_empty(const godot_pool_byte_array *p_self);
+
+void GDAPI godot_pool_byte_array_destroy(godot_pool_byte_array *p_self);
+
+// int
+
+void GDAPI godot_pool_int_array_new(godot_pool_int_array *r_dest);
+void GDAPI godot_pool_int_array_new_copy(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src);
+void GDAPI godot_pool_int_array_new_with_array(godot_pool_int_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_int_array_append(godot_pool_int_array *p_self, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_append_array(godot_pool_int_array *p_self, const godot_pool_int_array *p_array);
+
+godot_error GDAPI godot_pool_int_array_insert(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_invert(godot_pool_int_array *p_self);
+
+void GDAPI godot_pool_int_array_push_back(godot_pool_int_array *p_self, const godot_int p_data);
+
+void GDAPI godot_pool_int_array_remove(godot_pool_int_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_int_array_resize(godot_pool_int_array *p_self, const godot_int p_size);
+
+godot_pool_int_array_read_access GDAPI *godot_pool_int_array_read(const godot_pool_int_array *p_self);
+
+godot_pool_int_array_write_access GDAPI *godot_pool_int_array_write(godot_pool_int_array *p_self);
+
+void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_self);
+
+godot_bool GDAPI godot_pool_int_array_empty(const godot_pool_int_array *p_self);
+
+void GDAPI godot_pool_int_array_destroy(godot_pool_int_array *p_self);
+
+// real
+
+void GDAPI godot_pool_real_array_new(godot_pool_real_array *r_dest);
+void GDAPI godot_pool_real_array_new_copy(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src);
+void GDAPI godot_pool_real_array_new_with_array(godot_pool_real_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_real_array_append(godot_pool_real_array *p_self, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_append_array(godot_pool_real_array *p_self, const godot_pool_real_array *p_array);
+
+godot_error GDAPI godot_pool_real_array_insert(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_invert(godot_pool_real_array *p_self);
+
+void GDAPI godot_pool_real_array_push_back(godot_pool_real_array *p_self, const godot_real p_data);
+
+void GDAPI godot_pool_real_array_remove(godot_pool_real_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_real_array_resize(godot_pool_real_array *p_self, const godot_int p_size);
+
+godot_pool_real_array_read_access GDAPI *godot_pool_real_array_read(const godot_pool_real_array *p_self);
+
+godot_pool_real_array_write_access GDAPI *godot_pool_real_array_write(godot_pool_real_array *p_self);
+
+void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_self);
+
+godot_bool GDAPI godot_pool_real_array_empty(const godot_pool_real_array *p_self);
+
+void GDAPI godot_pool_real_array_destroy(godot_pool_real_array *p_self);
+
+// string
+
+void GDAPI godot_pool_string_array_new(godot_pool_string_array *r_dest);
+void GDAPI godot_pool_string_array_new_copy(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src);
+void GDAPI godot_pool_string_array_new_with_array(godot_pool_string_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_string_array_append(godot_pool_string_array *p_self, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_append_array(godot_pool_string_array *p_self, const godot_pool_string_array *p_array);
+
+godot_error GDAPI godot_pool_string_array_insert(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_invert(godot_pool_string_array *p_self);
+
+void GDAPI godot_pool_string_array_push_back(godot_pool_string_array *p_self, const godot_string *p_data);
+
+void GDAPI godot_pool_string_array_remove(godot_pool_string_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_string_array_resize(godot_pool_string_array *p_self, const godot_int p_size);
+
+godot_pool_string_array_read_access GDAPI *godot_pool_string_array_read(const godot_pool_string_array *p_self);
+
+godot_pool_string_array_write_access GDAPI *godot_pool_string_array_write(godot_pool_string_array *p_self);
+
+void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_self);
+
+godot_bool GDAPI godot_pool_string_array_empty(const godot_pool_string_array *p_self);
+
+void GDAPI godot_pool_string_array_destroy(godot_pool_string_array *p_self);
+
+// vector2
+
+void GDAPI godot_pool_vector2_array_new(godot_pool_vector2_array *r_dest);
+void GDAPI godot_pool_vector2_array_new_copy(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src);
+void GDAPI godot_pool_vector2_array_new_with_array(godot_pool_vector2_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_vector2_array_append(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_append_array(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array);
+
+godot_error GDAPI godot_pool_vector2_array_insert(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_invert(godot_pool_vector2_array *p_self);
+
+void GDAPI godot_pool_vector2_array_push_back(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+
+void GDAPI godot_pool_vector2_array_remove(godot_pool_vector2_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_vector2_array_resize(godot_pool_vector2_array *p_self, const godot_int p_size);
+
+godot_pool_vector2_array_read_access GDAPI *godot_pool_vector2_array_read(const godot_pool_vector2_array *p_self);
+
+godot_pool_vector2_array_write_access GDAPI *godot_pool_vector2_array_write(godot_pool_vector2_array *p_self);
+
+void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_self);
+
+godot_bool GDAPI godot_pool_vector2_array_empty(const godot_pool_vector2_array *p_self);
+
+void GDAPI godot_pool_vector2_array_destroy(godot_pool_vector2_array *p_self);
+
+// vector3
+
+void GDAPI godot_pool_vector3_array_new(godot_pool_vector3_array *r_dest);
+void GDAPI godot_pool_vector3_array_new_copy(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src);
+void GDAPI godot_pool_vector3_array_new_with_array(godot_pool_vector3_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_vector3_array_append(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_append_array(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array);
+
+godot_error GDAPI godot_pool_vector3_array_insert(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_invert(godot_pool_vector3_array *p_self);
+
+void GDAPI godot_pool_vector3_array_push_back(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+
+void GDAPI godot_pool_vector3_array_remove(godot_pool_vector3_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_vector3_array_resize(godot_pool_vector3_array *p_self, const godot_int p_size);
+
+godot_pool_vector3_array_read_access GDAPI *godot_pool_vector3_array_read(const godot_pool_vector3_array *p_self);
+
+godot_pool_vector3_array_write_access GDAPI *godot_pool_vector3_array_write(godot_pool_vector3_array *p_self);
+
+void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_self);
+
+godot_bool GDAPI godot_pool_vector3_array_empty(const godot_pool_vector3_array *p_self);
+
+void GDAPI godot_pool_vector3_array_destroy(godot_pool_vector3_array *p_self);
+
+// color
+
+void GDAPI godot_pool_color_array_new(godot_pool_color_array *r_dest);
+void GDAPI godot_pool_color_array_new_copy(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src);
+void GDAPI godot_pool_color_array_new_with_array(godot_pool_color_array *r_dest, const godot_array *p_a);
+
+void GDAPI godot_pool_color_array_append(godot_pool_color_array *p_self, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_append_array(godot_pool_color_array *p_self, const godot_pool_color_array *p_array);
+
+godot_error GDAPI godot_pool_color_array_insert(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_invert(godot_pool_color_array *p_self);
+
+void GDAPI godot_pool_color_array_push_back(godot_pool_color_array *p_self, const godot_color *p_data);
+
+void GDAPI godot_pool_color_array_remove(godot_pool_color_array *p_self, const godot_int p_idx);
+
+void GDAPI godot_pool_color_array_resize(godot_pool_color_array *p_self, const godot_int p_size);
+
+godot_pool_color_array_read_access GDAPI *godot_pool_color_array_read(const godot_pool_color_array *p_self);
+
+godot_pool_color_array_write_access GDAPI *godot_pool_color_array_write(godot_pool_color_array *p_self);
+
+void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_self, const godot_int p_idx);
+
+godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_self);
+
+godot_bool GDAPI godot_pool_color_array_empty(const godot_pool_color_array *p_self);
+
+void GDAPI godot_pool_color_array_destroy(godot_pool_color_array *p_self);
+
+//
+// read accessor functions
+//
+
+godot_pool_byte_array_read_access GDAPI *godot_pool_byte_array_read_access_copy(const godot_pool_byte_array_read_access *p_other);
+const uint8_t GDAPI *godot_pool_byte_array_read_access_ptr(const godot_pool_byte_array_read_access *p_read);
+void GDAPI godot_pool_byte_array_read_access_operator_assign(godot_pool_byte_array_read_access *p_read, godot_pool_byte_array_read_access *p_other);
+void GDAPI godot_pool_byte_array_read_access_destroy(godot_pool_byte_array_read_access *p_read);
+
+godot_pool_int_array_read_access GDAPI *godot_pool_int_array_read_access_copy(const godot_pool_int_array_read_access *p_other);
+const godot_int GDAPI *godot_pool_int_array_read_access_ptr(const godot_pool_int_array_read_access *p_read);
+void GDAPI godot_pool_int_array_read_access_operator_assign(godot_pool_int_array_read_access *p_read, godot_pool_int_array_read_access *p_other);
+void GDAPI godot_pool_int_array_read_access_destroy(godot_pool_int_array_read_access *p_read);
+
+godot_pool_real_array_read_access GDAPI *godot_pool_real_array_read_access_copy(const godot_pool_real_array_read_access *p_other);
+const godot_real GDAPI *godot_pool_real_array_read_access_ptr(const godot_pool_real_array_read_access *p_read);
+void GDAPI godot_pool_real_array_read_access_operator_assign(godot_pool_real_array_read_access *p_read, godot_pool_real_array_read_access *p_other);
+void GDAPI godot_pool_real_array_read_access_destroy(godot_pool_real_array_read_access *p_read);
+
+godot_pool_string_array_read_access GDAPI *godot_pool_string_array_read_access_copy(const godot_pool_string_array_read_access *p_other);
+const godot_string GDAPI *godot_pool_string_array_read_access_ptr(const godot_pool_string_array_read_access *p_read);
+void GDAPI godot_pool_string_array_read_access_operator_assign(godot_pool_string_array_read_access *p_read, godot_pool_string_array_read_access *p_other);
+void GDAPI godot_pool_string_array_read_access_destroy(godot_pool_string_array_read_access *p_read);
+
+godot_pool_vector2_array_read_access GDAPI *godot_pool_vector2_array_read_access_copy(const godot_pool_vector2_array_read_access *p_other);
+const godot_vector2 GDAPI *godot_pool_vector2_array_read_access_ptr(const godot_pool_vector2_array_read_access *p_read);
+void GDAPI godot_pool_vector2_array_read_access_operator_assign(godot_pool_vector2_array_read_access *p_read, godot_pool_vector2_array_read_access *p_other);
+void GDAPI godot_pool_vector2_array_read_access_destroy(godot_pool_vector2_array_read_access *p_read);
+
+godot_pool_vector3_array_read_access GDAPI *godot_pool_vector3_array_read_access_copy(const godot_pool_vector3_array_read_access *p_other);
+const godot_vector3 GDAPI *godot_pool_vector3_array_read_access_ptr(const godot_pool_vector3_array_read_access *p_read);
+void GDAPI godot_pool_vector3_array_read_access_operator_assign(godot_pool_vector3_array_read_access *p_read, godot_pool_vector3_array_read_access *p_other);
+void GDAPI godot_pool_vector3_array_read_access_destroy(godot_pool_vector3_array_read_access *p_read);
+
+godot_pool_color_array_read_access GDAPI *godot_pool_color_array_read_access_copy(const godot_pool_color_array_read_access *p_other);
+const godot_color GDAPI *godot_pool_color_array_read_access_ptr(const godot_pool_color_array_read_access *p_read);
+void GDAPI godot_pool_color_array_read_access_operator_assign(godot_pool_color_array_read_access *p_read, godot_pool_color_array_read_access *p_other);
+void GDAPI godot_pool_color_array_read_access_destroy(godot_pool_color_array_read_access *p_read);
+
+//
+// write accessor functions
+//
+
+godot_pool_byte_array_write_access GDAPI *godot_pool_byte_array_write_access_copy(const godot_pool_byte_array_write_access *p_other);
+uint8_t GDAPI *godot_pool_byte_array_write_access_ptr(const godot_pool_byte_array_write_access *p_write);
+void GDAPI godot_pool_byte_array_write_access_operator_assign(godot_pool_byte_array_write_access *p_write, godot_pool_byte_array_write_access *p_other);
+void GDAPI godot_pool_byte_array_write_access_destroy(godot_pool_byte_array_write_access *p_write);
+
+godot_pool_int_array_write_access GDAPI *godot_pool_int_array_write_access_copy(const godot_pool_int_array_write_access *p_other);
+godot_int GDAPI *godot_pool_int_array_write_access_ptr(const godot_pool_int_array_write_access *p_write);
+void GDAPI godot_pool_int_array_write_access_operator_assign(godot_pool_int_array_write_access *p_write, godot_pool_int_array_write_access *p_other);
+void GDAPI godot_pool_int_array_write_access_destroy(godot_pool_int_array_write_access *p_write);
+
+godot_pool_real_array_write_access GDAPI *godot_pool_real_array_write_access_copy(const godot_pool_real_array_write_access *p_other);
+godot_real GDAPI *godot_pool_real_array_write_access_ptr(const godot_pool_real_array_write_access *p_write);
+void GDAPI godot_pool_real_array_write_access_operator_assign(godot_pool_real_array_write_access *p_write, godot_pool_real_array_write_access *p_other);
+void GDAPI godot_pool_real_array_write_access_destroy(godot_pool_real_array_write_access *p_write);
+
+godot_pool_string_array_write_access GDAPI *godot_pool_string_array_write_access_copy(const godot_pool_string_array_write_access *p_other);
+godot_string GDAPI *godot_pool_string_array_write_access_ptr(const godot_pool_string_array_write_access *p_write);
+void GDAPI godot_pool_string_array_write_access_operator_assign(godot_pool_string_array_write_access *p_write, godot_pool_string_array_write_access *p_other);
+void GDAPI godot_pool_string_array_write_access_destroy(godot_pool_string_array_write_access *p_write);
+
+godot_pool_vector2_array_write_access GDAPI *godot_pool_vector2_array_write_access_copy(const godot_pool_vector2_array_write_access *p_other);
+godot_vector2 GDAPI *godot_pool_vector2_array_write_access_ptr(const godot_pool_vector2_array_write_access *p_write);
+void GDAPI godot_pool_vector2_array_write_access_operator_assign(godot_pool_vector2_array_write_access *p_write, godot_pool_vector2_array_write_access *p_other);
+void GDAPI godot_pool_vector2_array_write_access_destroy(godot_pool_vector2_array_write_access *p_write);
+
+godot_pool_vector3_array_write_access GDAPI *godot_pool_vector3_array_write_access_copy(const godot_pool_vector3_array_write_access *p_other);
+godot_vector3 GDAPI *godot_pool_vector3_array_write_access_ptr(const godot_pool_vector3_array_write_access *p_write);
+void GDAPI godot_pool_vector3_array_write_access_operator_assign(godot_pool_vector3_array_write_access *p_write, godot_pool_vector3_array_write_access *p_other);
+void GDAPI godot_pool_vector3_array_write_access_destroy(godot_pool_vector3_array_write_access *p_write);
+
+godot_pool_color_array_write_access GDAPI *godot_pool_color_array_write_access_copy(const godot_pool_color_array_write_access *p_other);
+godot_color GDAPI *godot_pool_color_array_write_access_ptr(const godot_pool_color_array_write_access *p_write);
+void GDAPI godot_pool_color_array_write_access_operator_assign(godot_pool_color_array_write_access *p_write, godot_pool_color_array_write_access *p_other);
+void GDAPI godot_pool_color_array_write_access_destroy(godot_pool_color_array_write_access *p_write);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_POOL_ARRAYS_H

GodoBinding/godot_headers/gdnative/quat.h

@@ -0,0 +1,118 @@
+/*************************************************************************/
+/*  quat.h                                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_QUAT_H
+#define GODOT_QUAT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_QUAT_SIZE 16
+
+#ifndef GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_QUAT_SIZE];
+} godot_quat;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/vector3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w);
+void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle);
+void GDAPI godot_quat_new_with_basis(godot_quat *r_dest, const godot_basis *p_basis);
+void GDAPI godot_quat_new_with_euler(godot_quat *r_dest, const godot_vector3 *p_euler);
+
+godot_real GDAPI godot_quat_get_x(const godot_quat *p_self);
+void GDAPI godot_quat_set_x(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_y(const godot_quat *p_self);
+void GDAPI godot_quat_set_y(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_z(const godot_quat *p_self);
+void GDAPI godot_quat_set_z(godot_quat *p_self, const godot_real val);
+
+godot_real GDAPI godot_quat_get_w(const godot_quat *p_self);
+void GDAPI godot_quat_set_w(godot_quat *p_self, const godot_real val);
+
+godot_string GDAPI godot_quat_as_string(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_length(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self);
+
+godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self);
+
+godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self);
+
+godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self);
+
+godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v);
+
+godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t);
+
+godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b);
+
+godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_subtract(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b);
+
+godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self);
+
+void GDAPI godot_quat_set_axis_angle(godot_quat *p_self, const godot_vector3 *p_axis, const godot_real p_angle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_QUAT_H

GodoBinding/godot_headers/gdnative/rect2.h

@@ -0,0 +1,102 @@
+/*************************************************************************/
+/*  rect2.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_RECT2_H
+#define GODOT_RECT2_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED
+typedef struct godot_rect2 {
+	uint8_t _dont_touch_that[16];
+} godot_rect2;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/vector2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
+void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
+
+godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self);
+
+godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self);
+
+godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self);
+
+godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point);
+
+godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by);
+
+godot_rect2 GDAPI godot_rect2_grow_individual(const godot_rect2 *p_self, const godot_real p_left, const godot_real p_top, const godot_real p_right, const godot_real p_bottom);
+
+godot_rect2 GDAPI godot_rect2_grow_margin(const godot_rect2 *p_self, const godot_int p_margin, const godot_real p_by);
+
+godot_rect2 GDAPI godot_rect2_abs(const godot_rect2 *p_self);
+
+godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to);
+
+godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b);
+
+godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self);
+
+godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self);
+
+void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos);
+
+void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_RECT2_H

GodoBinding/godot_headers/gdnative/rid.h

@@ -0,0 +1,74 @@
+/*************************************************************************/
+/*  rid.h                                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_RID_H
+#define GODOT_RID_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_RID_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_RID_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_RID_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_RID_SIZE];
+} godot_rid;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_rid_new(godot_rid *r_dest);
+
+godot_int GDAPI godot_rid_get_id(const godot_rid *p_self);
+
+void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from);
+
+godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b);
+
+godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_RID_H

GodoBinding/godot_headers/gdnative/string.h

@@ -0,0 +1,263 @@
+/*************************************************************************/
+/*  string.h                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_STRING_H
+#define GODOT_STRING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <wchar.h>
+
+typedef wchar_t godot_char_type;
+
+#define GODOT_STRING_SIZE sizeof(void *)
+#define GODOT_CHAR_STRING_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_STRING_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_STRING_SIZE];
+} godot_string;
+
+#endif
+
+#ifndef GODOT_CORE_API_GODOT_CHAR_STRING_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_CHAR_STRING_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_CHAR_STRING_SIZE];
+} godot_char_string;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/array.h>
+#include <gdnative/gdnative.h>
+#include <gdnative/variant.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+godot_int GDAPI godot_char_string_length(const godot_char_string *p_cs);
+const char GDAPI *godot_char_string_get_data(const godot_char_string *p_cs);
+void GDAPI godot_char_string_destroy(godot_char_string *p_cs);
+
+void GDAPI godot_string_new(godot_string *r_dest);
+void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src);
+void GDAPI godot_string_new_with_wide_string(godot_string *r_dest, const wchar_t *p_contents, const int p_size);
+
+const wchar_t GDAPI *godot_string_operator_index(godot_string *p_self, const godot_int p_idx);
+wchar_t GDAPI godot_string_operator_index_const(const godot_string *p_self, const godot_int p_idx);
+const wchar_t GDAPI *godot_string_wide_str(const godot_string *p_self);
+
+godot_bool GDAPI godot_string_operator_equal(const godot_string *p_self, const godot_string *p_b);
+godot_bool GDAPI godot_string_operator_less(const godot_string *p_self, const godot_string *p_b);
+godot_string GDAPI godot_string_operator_plus(const godot_string *p_self, const godot_string *p_b);
+
+/* Standard size stuff */
+
+godot_int GDAPI godot_string_length(const godot_string *p_self);
+
+/* Helpers */
+
+signed char GDAPI godot_string_casecmp_to(const godot_string *p_self, const godot_string *p_str);
+signed char GDAPI godot_string_nocasecmp_to(const godot_string *p_self, const godot_string *p_str);
+signed char GDAPI godot_string_naturalnocasecmp_to(const godot_string *p_self, const godot_string *p_str);
+
+godot_bool GDAPI godot_string_begins_with(const godot_string *p_self, const godot_string *p_string);
+godot_bool GDAPI godot_string_begins_with_char_array(const godot_string *p_self, const char *p_char_array);
+godot_array GDAPI godot_string_bigrams(const godot_string *p_self);
+godot_string GDAPI godot_string_chr(wchar_t p_character);
+godot_bool GDAPI godot_string_ends_with(const godot_string *p_self, const godot_string *p_string);
+godot_int GDAPI godot_string_count(const godot_string *p_self, godot_string p_what, godot_int p_from, godot_int p_to);
+godot_int GDAPI godot_string_countn(const godot_string *p_self, godot_string p_what, godot_int p_from, godot_int p_to);
+godot_int GDAPI godot_string_find(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_find_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI godot_string_findmk(const godot_string *p_self, const godot_array *p_keys);
+godot_int GDAPI godot_string_findmk_from(const godot_string *p_self, const godot_array *p_keys, godot_int p_from);
+godot_int GDAPI godot_string_findmk_from_in_place(const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key);
+godot_int GDAPI godot_string_findn(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_findn_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI godot_string_find_last(const godot_string *p_self, godot_string p_what);
+godot_string GDAPI godot_string_format(const godot_string *p_self, const godot_variant *p_values);
+godot_string GDAPI godot_string_format_with_custom_placeholder(const godot_string *p_self, const godot_variant *p_values, const char *p_placeholder);
+godot_string GDAPI godot_string_hex_encode_buffer(const uint8_t *p_buffer, godot_int p_len);
+godot_int GDAPI godot_string_hex_to_int(const godot_string *p_self);
+godot_int GDAPI godot_string_hex_to_int_without_prefix(const godot_string *p_self);
+godot_string GDAPI godot_string_insert(const godot_string *p_self, godot_int p_at_pos, godot_string p_string);
+godot_bool GDAPI godot_string_is_numeric(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_subsequence_of(const godot_string *p_self, const godot_string *p_string);
+godot_bool GDAPI godot_string_is_subsequence_ofi(const godot_string *p_self, const godot_string *p_string);
+godot_string GDAPI godot_string_lpad(const godot_string *p_self, godot_int p_min_length);
+godot_string GDAPI godot_string_lpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+godot_bool GDAPI godot_string_match(const godot_string *p_self, const godot_string *p_wildcard);
+godot_bool GDAPI godot_string_matchn(const godot_string *p_self, const godot_string *p_wildcard);
+godot_string GDAPI godot_string_md5(const uint8_t *p_md5);
+godot_string GDAPI godot_string_num(double p_num);
+godot_string GDAPI godot_string_num_int64(int64_t p_num, godot_int p_base);
+godot_string GDAPI godot_string_num_int64_capitalized(int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex);
+godot_string GDAPI godot_string_num_real(double p_num);
+godot_string GDAPI godot_string_num_scientific(double p_num);
+godot_string GDAPI godot_string_num_with_decimals(double p_num, godot_int p_decimals);
+godot_string GDAPI godot_string_pad_decimals(const godot_string *p_self, godot_int p_digits);
+godot_string GDAPI godot_string_pad_zeros(const godot_string *p_self, godot_int p_digits);
+godot_string GDAPI godot_string_replace_first(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_string GDAPI godot_string_replace(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_string GDAPI godot_string_replacen(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_int GDAPI godot_string_rfind(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_rfindn(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_rfind_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI godot_string_rfindn_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_string GDAPI godot_string_rpad(const godot_string *p_self, godot_int p_min_length);
+godot_string GDAPI godot_string_rpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+godot_real GDAPI godot_string_similarity(const godot_string *p_self, const godot_string *p_string);
+godot_string GDAPI godot_string_sprintf(const godot_string *p_self, const godot_array *p_values, godot_bool *p_error);
+godot_string GDAPI godot_string_substr(const godot_string *p_self, godot_int p_from, godot_int p_chars);
+double GDAPI godot_string_to_double(const godot_string *p_self);
+godot_real GDAPI godot_string_to_float(const godot_string *p_self);
+godot_int GDAPI godot_string_to_int(const godot_string *p_self);
+
+godot_string GDAPI godot_string_camelcase_to_underscore(const godot_string *p_self);
+godot_string GDAPI godot_string_camelcase_to_underscore_lowercased(const godot_string *p_self);
+godot_string GDAPI godot_string_capitalize(const godot_string *p_self);
+double GDAPI godot_string_char_to_double(const char *p_what);
+godot_int GDAPI godot_string_char_to_int(const char *p_what);
+int64_t GDAPI godot_string_wchar_to_int(const wchar_t *p_str);
+godot_int GDAPI godot_string_char_to_int_with_len(const char *p_what, godot_int p_len);
+int64_t GDAPI godot_string_char_to_int64_with_len(const wchar_t *p_str, int p_len);
+int64_t GDAPI godot_string_hex_to_int64(const godot_string *p_self);
+int64_t GDAPI godot_string_hex_to_int64_with_prefix(const godot_string *p_self);
+int64_t GDAPI godot_string_to_int64(const godot_string *p_self);
+double GDAPI godot_string_unicode_char_to_double(const wchar_t *p_str, const wchar_t **r_end);
+
+godot_int GDAPI godot_string_get_slice_count(const godot_string *p_self, godot_string p_splitter);
+godot_string GDAPI godot_string_get_slice(const godot_string *p_self, godot_string p_splitter, godot_int p_slice);
+godot_string GDAPI godot_string_get_slicec(const godot_string *p_self, wchar_t p_splitter, godot_int p_slice);
+
+godot_array GDAPI godot_string_split(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_allow_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats_allows_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats_mk(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_floats_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_ints(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_ints_allows_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_ints_mk(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_ints_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_spaces(const godot_string *p_self);
+
+wchar_t GDAPI godot_string_char_lowercase(wchar_t p_char);
+wchar_t GDAPI godot_string_char_uppercase(wchar_t p_char);
+godot_string GDAPI godot_string_to_lower(const godot_string *p_self);
+godot_string GDAPI godot_string_to_upper(const godot_string *p_self);
+
+godot_string GDAPI godot_string_get_basename(const godot_string *p_self);
+godot_string GDAPI godot_string_get_extension(const godot_string *p_self);
+godot_string GDAPI godot_string_left(const godot_string *p_self, godot_int p_pos);
+wchar_t GDAPI godot_string_ord_at(const godot_string *p_self, godot_int p_idx);
+godot_string GDAPI godot_string_plus_file(const godot_string *p_self, const godot_string *p_file);
+godot_string GDAPI godot_string_right(const godot_string *p_self, godot_int p_pos);
+godot_string GDAPI godot_string_strip_edges(const godot_string *p_self, godot_bool p_left, godot_bool p_right);
+godot_string GDAPI godot_string_strip_escapes(const godot_string *p_self);
+
+void GDAPI godot_string_erase(godot_string *p_self, godot_int p_pos, godot_int p_chars);
+
+godot_char_string GDAPI godot_string_ascii(const godot_string *p_self);
+godot_char_string GDAPI godot_string_ascii_extended(const godot_string *p_self);
+godot_char_string GDAPI godot_string_utf8(const godot_string *p_self);
+godot_bool GDAPI godot_string_parse_utf8(godot_string *p_self, const char *p_utf8);
+godot_bool GDAPI godot_string_parse_utf8_with_len(godot_string *p_self, const char *p_utf8, godot_int p_len);
+godot_string GDAPI godot_string_chars_to_utf8(const char *p_utf8);
+godot_string GDAPI godot_string_chars_to_utf8_with_len(const char *p_utf8, godot_int p_len);
+
+uint32_t GDAPI godot_string_hash(const godot_string *p_self);
+uint64_t GDAPI godot_string_hash64(const godot_string *p_self);
+uint32_t GDAPI godot_string_hash_chars(const char *p_cstr);
+uint32_t GDAPI godot_string_hash_chars_with_len(const char *p_cstr, godot_int p_len);
+uint32_t GDAPI godot_string_hash_utf8_chars(const wchar_t *p_str);
+uint32_t GDAPI godot_string_hash_utf8_chars_with_len(const wchar_t *p_str, godot_int p_len);
+godot_pool_byte_array GDAPI godot_string_md5_buffer(const godot_string *p_self);
+godot_string GDAPI godot_string_md5_text(const godot_string *p_self);
+godot_pool_byte_array GDAPI godot_string_sha256_buffer(const godot_string *p_self);
+godot_string GDAPI godot_string_sha256_text(const godot_string *p_self);
+
+godot_bool godot_string_empty(const godot_string *p_self);
+
+// path functions
+godot_string GDAPI godot_string_get_base_dir(const godot_string *p_self);
+godot_string GDAPI godot_string_get_file(const godot_string *p_self);
+godot_string GDAPI godot_string_humanize_size(size_t p_size);
+godot_bool GDAPI godot_string_is_abs_path(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_rel_path(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_resource_file(const godot_string *p_self);
+godot_string GDAPI godot_string_path_to(const godot_string *p_self, const godot_string *p_path);
+godot_string GDAPI godot_string_path_to_file(const godot_string *p_self, const godot_string *p_path);
+godot_string GDAPI godot_string_simplify_path(const godot_string *p_self);
+
+godot_string GDAPI godot_string_c_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_c_escape_multiline(const godot_string *p_self);
+godot_string GDAPI godot_string_c_unescape(const godot_string *p_self);
+godot_string GDAPI godot_string_http_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_http_unescape(const godot_string *p_self);
+godot_string GDAPI godot_string_json_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_word_wrap(const godot_string *p_self, godot_int p_chars_per_line);
+godot_string GDAPI godot_string_xml_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_xml_escape_with_quotes(const godot_string *p_self);
+godot_string GDAPI godot_string_xml_unescape(const godot_string *p_self);
+
+godot_string GDAPI godot_string_percent_decode(const godot_string *p_self);
+godot_string GDAPI godot_string_percent_encode(const godot_string *p_self);
+
+godot_bool GDAPI godot_string_is_valid_float(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_hex_number(const godot_string *p_self, godot_bool p_with_prefix);
+godot_bool GDAPI godot_string_is_valid_html_color(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_identifier(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_integer(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_ip_address(const godot_string *p_self);
+
+godot_string GDAPI godot_string_dedent(const godot_string *p_self);
+godot_string GDAPI godot_string_trim_prefix(const godot_string *p_self, const godot_string *p_prefix);
+godot_string GDAPI godot_string_trim_suffix(const godot_string *p_self, const godot_string *p_suffix);
+godot_string GDAPI godot_string_rstrip(const godot_string *p_self, const godot_string *p_chars);
+godot_pool_string_array GDAPI godot_string_rsplit(const godot_string *p_self, const godot_string *p_divisor, const godot_bool p_allow_empty, const godot_int p_maxsplit);
+
+void GDAPI godot_string_destroy(godot_string *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_STRING_H

GodoBinding/godot_headers/gdnative/string_name.h

@@ -0,0 +1,78 @@
+/*************************************************************************/
+/*  string_name.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_STRING_NAME_H
+#define GODOT_STRING_NAME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <wchar.h>
+
+#define GODOT_STRING_NAME_SIZE sizeof(void *)
+
+#ifndef GODOT_CORE_API_GODOT_STRING_NAME_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_STRING_NAME_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_STRING_NAME_SIZE];
+} godot_string_name;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_string_name_new(godot_string_name *r_dest, const godot_string *p_name);
+void GDAPI godot_string_name_new_data(godot_string_name *r_dest, const char *p_name);
+
+godot_string GDAPI godot_string_name_get_name(const godot_string_name *p_self);
+
+uint32_t GDAPI godot_string_name_get_hash(const godot_string_name *p_self);
+const void GDAPI *godot_string_name_get_data_unique_pointer(const godot_string_name *p_self);
+
+godot_bool GDAPI godot_string_name_operator_equal(const godot_string_name *p_self, const godot_string_name *p_other);
+godot_bool GDAPI godot_string_name_operator_less(const godot_string_name *p_self, const godot_string_name *p_other);
+
+void GDAPI godot_string_name_destroy(godot_string_name *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_STRING_NAME_H

GodoBinding/godot_headers/gdnative/transform.h

@@ -0,0 +1,111 @@
+/*************************************************************************/
+/*  transform.h                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_TRANSFORM_H
+#define GODOT_TRANSFORM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_TRANSFORM_SIZE 48
+
+#ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_TRANSFORM_SIZE];
+} godot_transform;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/basis.h>
+#include <gdnative/gdnative.h>
+#include <gdnative/variant.h>
+#include <gdnative/vector3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin);
+void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin);
+void GDAPI godot_transform_new_with_quat(godot_transform *r_dest, const godot_quat *p_quat);
+
+godot_basis GDAPI godot_transform_get_basis(const godot_transform *p_self);
+void GDAPI godot_transform_set_basis(godot_transform *p_self, const godot_basis *p_v);
+
+godot_vector3 GDAPI godot_transform_get_origin(const godot_transform *p_self);
+void GDAPI godot_transform_set_origin(godot_transform *p_self, const godot_vector3 *p_v);
+
+godot_string GDAPI godot_transform_as_string(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self);
+
+godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale);
+
+godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs);
+
+godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up);
+
+godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v);
+
+godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v);
+
+void GDAPI godot_transform_new_identity(godot_transform *r_dest);
+
+godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b);
+
+godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b);
+
+godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v);
+
+godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v);
+
+godot_aabb GDAPI godot_transform_xform_aabb(const godot_transform *p_self, const godot_aabb *p_v);
+
+godot_aabb GDAPI godot_transform_xform_inv_aabb(const godot_transform *p_self, const godot_aabb *p_v);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_TRANSFORM_H

GodoBinding/godot_headers/gdnative/transform2d.h

@@ -0,0 +1,109 @@
+/*************************************************************************/
+/*  transform2d.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_TRANSFORM2D_H
+#define GODOT_TRANSFORM2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_TRANSFORM2D_SIZE 24
+
+#ifndef GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_TRANSFORM2D_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_TRANSFORM2D_SIZE];
+} godot_transform2d;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+#include <gdnative/variant.h>
+#include <gdnative/vector2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos);
+void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin);
+
+godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self);
+
+godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self);
+
+godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self);
+
+godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self);
+
+godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi);
+
+godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale);
+
+godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset);
+
+godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v);
+
+godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c);
+
+godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b);
+
+godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b);
+
+void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest);
+
+godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v);
+
+godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_TRANSFORM2D_H

GodoBinding/godot_headers/gdnative/variant.h

@@ -0,0 +1,255 @@
+/*************************************************************************/
+/*  variant.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_VARIANT_H
+#define GODOT_VARIANT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VARIANT_SIZE (16 + sizeof(void *))
+
+#ifndef GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VARIANT_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VARIANT_SIZE];
+} godot_variant;
+#endif
+
+typedef enum godot_variant_type {
+	GODOT_VARIANT_TYPE_NIL,
+
+	// atomic types
+	GODOT_VARIANT_TYPE_BOOL,
+	GODOT_VARIANT_TYPE_INT,
+	GODOT_VARIANT_TYPE_REAL,
+	GODOT_VARIANT_TYPE_STRING,
+
+	// math types
+
+	GODOT_VARIANT_TYPE_VECTOR2, // 5
+	GODOT_VARIANT_TYPE_RECT2,
+	GODOT_VARIANT_TYPE_VECTOR3,
+	GODOT_VARIANT_TYPE_TRANSFORM2D,
+	GODOT_VARIANT_TYPE_PLANE,
+	GODOT_VARIANT_TYPE_QUAT, // 10
+	GODOT_VARIANT_TYPE_AABB,
+	GODOT_VARIANT_TYPE_BASIS,
+	GODOT_VARIANT_TYPE_TRANSFORM,
+
+	// misc types
+	GODOT_VARIANT_TYPE_COLOR,
+	GODOT_VARIANT_TYPE_NODE_PATH, // 15
+	GODOT_VARIANT_TYPE_RID,
+	GODOT_VARIANT_TYPE_OBJECT,
+	GODOT_VARIANT_TYPE_DICTIONARY,
+	GODOT_VARIANT_TYPE_ARRAY, // 20
+
+	// arrays
+	GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_INT_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_REAL_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_STRING_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, // 25
+	GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY,
+	GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY,
+} godot_variant_type;
+
+typedef enum godot_variant_call_error_error {
+	GODOT_CALL_ERROR_CALL_OK,
+	GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD,
+	GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT,
+	GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS,
+	GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS,
+	GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL,
+} godot_variant_call_error_error;
+
+typedef struct godot_variant_call_error {
+	godot_variant_call_error_error error;
+	int argument;
+	godot_variant_type expected;
+} godot_variant_call_error;
+
+typedef enum godot_variant_operator {
+	// comparison
+	GODOT_VARIANT_OP_EQUAL,
+	GODOT_VARIANT_OP_NOT_EQUAL,
+	GODOT_VARIANT_OP_LESS,
+	GODOT_VARIANT_OP_LESS_EQUAL,
+	GODOT_VARIANT_OP_GREATER,
+	GODOT_VARIANT_OP_GREATER_EQUAL,
+
+	// mathematic
+	GODOT_VARIANT_OP_ADD,
+	GODOT_VARIANT_OP_SUBTRACT,
+	GODOT_VARIANT_OP_MULTIPLY,
+	GODOT_VARIANT_OP_DIVIDE,
+	GODOT_VARIANT_OP_NEGATE,
+	GODOT_VARIANT_OP_POSITIVE,
+	GODOT_VARIANT_OP_MODULE,
+	GODOT_VARIANT_OP_STRING_CONCAT,
+
+	// bitwise
+	GODOT_VARIANT_OP_SHIFT_LEFT,
+	GODOT_VARIANT_OP_SHIFT_RIGHT,
+	GODOT_VARIANT_OP_BIT_AND,
+	GODOT_VARIANT_OP_BIT_OR,
+	GODOT_VARIANT_OP_BIT_XOR,
+	GODOT_VARIANT_OP_BIT_NEGATE,
+
+	// logic
+	GODOT_VARIANT_OP_AND,
+	GODOT_VARIANT_OP_OR,
+	GODOT_VARIANT_OP_XOR,
+	GODOT_VARIANT_OP_NOT,
+
+	// containment
+	GODOT_VARIANT_OP_IN,
+
+	GODOT_VARIANT_OP_MAX,
+} godot_variant_operator;
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/aabb.h>
+#include <gdnative/array.h>
+#include <gdnative/basis.h>
+#include <gdnative/color.h>
+#include <gdnative/dictionary.h>
+#include <gdnative/node_path.h>
+#include <gdnative/plane.h>
+#include <gdnative/pool_arrays.h>
+#include <gdnative/quat.h>
+#include <gdnative/rect2.h>
+#include <gdnative/rid.h>
+#include <gdnative/string.h>
+#include <gdnative/transform.h>
+#include <gdnative/transform2d.h>
+#include <gdnative/variant.h>
+#include <gdnative/vector2.h>
+#include <gdnative/vector3.h>
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v);
+
+void GDAPI godot_variant_new_copy(godot_variant *r_dest, const godot_variant *p_src);
+
+void GDAPI godot_variant_new_nil(godot_variant *r_dest);
+
+void GDAPI godot_variant_new_bool(godot_variant *r_dest, const godot_bool p_b);
+void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i);
+void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i);
+void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r);
+void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s);
+void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2);
+void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2);
+void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3);
+void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d);
+void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane);
+void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat);
+void GDAPI godot_variant_new_aabb(godot_variant *r_dest, const godot_aabb *p_aabb);
+void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis);
+void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans);
+void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color);
+void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np);
+void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid);
+void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj);
+void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict);
+void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr);
+void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba);
+void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia);
+void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra);
+void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa);
+void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a);
+void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a);
+void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca);
+
+godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self);
+uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self);
+int64_t GDAPI godot_variant_as_int(const godot_variant *p_self);
+double GDAPI godot_variant_as_real(const godot_variant *p_self);
+godot_string GDAPI godot_variant_as_string(const godot_variant *p_self);
+godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self);
+godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self);
+godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self);
+godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self);
+godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self);
+godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self);
+godot_aabb GDAPI godot_variant_as_aabb(const godot_variant *p_self);
+godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self);
+godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self);
+godot_color GDAPI godot_variant_as_color(const godot_variant *p_self);
+godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self);
+godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self);
+godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self);
+godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self);
+godot_array GDAPI godot_variant_as_array(const godot_variant *p_self);
+godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self);
+godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self);
+godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self);
+godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self);
+godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self);
+godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self);
+godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self);
+
+godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error);
+
+godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method);
+
+godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other);
+godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other);
+
+godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other);
+
+godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self);
+
+void GDAPI godot_variant_destroy(godot_variant *p_self);
+
+// GDNative core 1.1
+
+godot_string GDAPI godot_variant_get_operator_name(godot_variant_operator p_op);
+void GDAPI godot_variant_evaluate(godot_variant_operator p_op, const godot_variant *p_a, const godot_variant *p_b, godot_variant *r_ret, godot_bool *r_valid);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

GodoBinding/godot_headers/gdnative/vector2.h

@@ -0,0 +1,142 @@
+/*************************************************************************/
+/*  vector2.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_VECTOR2_H
+#define GODOT_VECTOR2_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VECTOR2_SIZE 8
+
+#ifndef GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VECTOR2_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VECTOR2_SIZE];
+} godot_vector2;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y);
+
+godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self);
+
+godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_direction_to(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to);
+
+godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
+
+godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t);
+
+godot_vector2 GDAPI godot_vector2_move_toward(const godot_vector2 *p_self, const godot_vector2 *p_to, const godot_real p_delta);
+
+godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi);
+
+godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by);
+
+godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with);
+
+godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n);
+
+godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self);
+
+godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length);
+
+godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_subtract(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b);
+
+godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self);
+
+void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x);
+
+void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y);
+
+godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self);
+
+godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_VECTOR2_H

GodoBinding/godot_headers/gdnative/vector3.h

@@ -0,0 +1,149 @@
+/*************************************************************************/
+/*  vector3.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_VECTOR3_H
+#define GODOT_VECTOR3_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define GODOT_VECTOR3_SIZE 12
+
+#ifndef GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED
+typedef struct {
+	uint8_t _dont_touch_that[GODOT_VECTOR3_SIZE];
+} godot_vector3;
+#endif
+
+// reduce extern "C" nesting for VS2013
+#ifdef __cplusplus
+}
+#endif
+
+#include <gdnative/basis.h>
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	GODOT_VECTOR3_AXIS_X,
+	GODOT_VECTOR3_AXIS_Y,
+	GODOT_VECTOR3_AXIS_Z,
+} godot_vector3_axis;
+
+void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z);
+
+godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self);
+
+godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self);
+
+godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self);
+
+godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self);
+
+godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self);
+
+godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_vector3 *p_by);
+
+godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+
+godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
+
+godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t);
+
+godot_vector3 GDAPI godot_vector3_move_toward(const godot_vector3 *p_self, const godot_vector3 *p_to, const godot_real p_delta);
+
+godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self);
+
+godot_vector3 GDAPI godot_vector3_direction_to(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to);
+
+godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n);
+
+godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_subtract(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b);
+
+godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b);
+
+godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self);
+
+void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val);
+
+godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_VECTOR3_H

GodoBinding/godot_headers/gdnative_api_struct.gen.h

@@ -0,0 +1,973 @@
+/* THIS FILE IS GENERATED DO NOT EDIT */
+#ifndef GODOT_GDNATIVE_API_STRUCT_H
+#define GODOT_GDNATIVE_API_STRUCT_H
+
+#include <gdnative/gdnative.h>
+#include <android/godot_android.h>
+#include <arvr/godot_arvr.h>
+#include <nativescript/godot_nativescript.h>
+#include <net/godot_net.h>
+#include <pluginscript/godot_pluginscript.h>
+#include <videodecoder/godot_videodecoder.h>
+
+#define GDNATIVE_API_INIT(options) do {  \
+	extern const godot_gdnative_core_api_struct *_gdnative_wrapper_api_struct;  \
+	extern const godot_gdnative_ext_nativescript_api_struct *_gdnative_wrapper_nativescript_api_struct;  \
+	extern const godot_gdnative_ext_pluginscript_api_struct *_gdnative_wrapper_pluginscript_api_struct;  \
+	extern const godot_gdnative_ext_android_api_struct *_gdnative_wrapper_android_api_struct;  \
+	extern const godot_gdnative_ext_arvr_api_struct *_gdnative_wrapper_arvr_api_struct;  \
+	extern const godot_gdnative_ext_videodecoder_api_struct *_gdnative_wrapper_videodecoder_api_struct;  \
+	extern const godot_gdnative_ext_net_api_struct *_gdnative_wrapper_net_api_struct;  \
+	_gdnative_wrapper_api_struct = options->api_struct;  \
+	for (unsigned int i = 0; i < _gdnative_wrapper_api_struct->num_extensions; i++) {   \
+		switch (_gdnative_wrapper_api_struct->extensions[i]->type) {  \
+			case GDNATIVE_EXT_NATIVESCRIPT:  \
+				_gdnative_wrapper_nativescript_api_struct = (godot_gdnative_ext_nativescript_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+			case GDNATIVE_EXT_PLUGINSCRIPT:  \
+				_gdnative_wrapper_pluginscript_api_struct = (godot_gdnative_ext_pluginscript_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+			case GDNATIVE_EXT_ANDROID:  \
+				_gdnative_wrapper_android_api_struct = (godot_gdnative_ext_android_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+			case GDNATIVE_EXT_ARVR:  \
+				_gdnative_wrapper_arvr_api_struct = (godot_gdnative_ext_arvr_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+			case GDNATIVE_EXT_VIDEODECODER:  \
+				_gdnative_wrapper_videodecoder_api_struct = (godot_gdnative_ext_videodecoder_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+			case GDNATIVE_EXT_NET:  \
+				_gdnative_wrapper_net_api_struct = (godot_gdnative_ext_net_api_struct *) _gdnative_wrapper_api_struct->extensions[i];  \
+				break;  \
+		}  \
+	}  \
+ } while (0)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum GDNATIVE_API_TYPES {
+	GDNATIVE_CORE,
+	GDNATIVE_EXT_NATIVESCRIPT,
+	GDNATIVE_EXT_PLUGINSCRIPT,
+	GDNATIVE_EXT_ANDROID,
+	GDNATIVE_EXT_ARVR,
+	GDNATIVE_EXT_VIDEODECODER,
+	GDNATIVE_EXT_NET,
+};
+
+typedef struct godot_gdnative_ext_nativescript_1_1_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	void (*godot_nativescript_set_method_argument_information)(void *p_gdnative_handle, const char *p_name, const char *p_function_name, int p_num_args, const godot_method_arg *p_args);
+	void (*godot_nativescript_set_class_documentation)(void *p_gdnative_handle, const char *p_name, godot_string p_documentation);
+	void (*godot_nativescript_set_method_documentation)(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_string p_documentation);
+	void (*godot_nativescript_set_property_documentation)(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_string p_documentation);
+	void (*godot_nativescript_set_signal_documentation)(void *p_gdnative_handle, const char *p_name, const char *p_signal_name, godot_string p_documentation);
+	void (*godot_nativescript_set_global_type_tag)(int p_idx, const char *p_name, const void *p_type_tag);
+	const void *(*godot_nativescript_get_global_type_tag)(int p_idx, const char *p_name);
+	void (*godot_nativescript_set_type_tag)(void *p_gdnative_handle, const char *p_name, const void *p_type_tag);
+	const void *(*godot_nativescript_get_type_tag)(const godot_object *p_object);
+	int (*godot_nativescript_register_instance_binding_data_functions)(godot_instance_binding_functions p_binding_functions);
+	void (*godot_nativescript_unregister_instance_binding_data_functions)(int p_idx);
+	void *(*godot_nativescript_get_instance_binding_data)(int p_idx, godot_object *p_object);
+	void (*godot_nativescript_profiling_add_data)(const char *p_signature, uint64_t p_line);
+} godot_gdnative_ext_nativescript_1_1_api_struct;
+
+typedef struct godot_gdnative_ext_nativescript_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	void (*godot_nativescript_register_class)(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+	void (*godot_nativescript_register_tool_class)(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+	void (*godot_nativescript_register_method)(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method);
+	void (*godot_nativescript_register_property)(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func);
+	void (*godot_nativescript_register_signal)(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal);
+	void *(*godot_nativescript_get_userdata)(godot_object *p_instance);
+} godot_gdnative_ext_nativescript_api_struct;
+
+typedef struct godot_gdnative_ext_pluginscript_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	void (*godot_pluginscript_register_language)(const godot_pluginscript_language_desc *language_desc);
+} godot_gdnative_ext_pluginscript_api_struct;
+
+typedef struct godot_gdnative_ext_android_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	JNIEnv*(*godot_android_get_env)();
+	jobject (*godot_android_get_activity)();
+	jobject (*godot_android_get_surface)();
+	bool (*godot_android_is_activity_resumed)();
+} godot_gdnative_ext_android_api_struct;
+
+typedef struct godot_gdnative_ext_arvr_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	void (*godot_arvr_register_interface)(const godot_arvr_interface_gdnative *p_interface);
+	godot_real (*godot_arvr_get_worldscale)();
+	godot_transform (*godot_arvr_get_reference_frame)();
+	void (*godot_arvr_blit)(int p_eye, godot_rid *p_render_target, godot_rect2 *p_screen_rect);
+	godot_int (*godot_arvr_get_texid)(godot_rid *p_render_target);
+	godot_int (*godot_arvr_add_controller)(char *p_device_name, godot_int p_hand, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
+	void (*godot_arvr_remove_controller)(godot_int p_controller_id);
+	void (*godot_arvr_set_controller_transform)(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
+	void (*godot_arvr_set_controller_button)(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed);
+	void (*godot_arvr_set_controller_axis)(godot_int p_controller_id, godot_int p_exis, godot_real p_value, godot_bool p_can_be_negative);
+	godot_real (*godot_arvr_get_controller_rumble)(godot_int p_controller_id);
+} godot_gdnative_ext_arvr_api_struct;
+
+typedef struct godot_gdnative_ext_videodecoder_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	godot_int (*godot_videodecoder_file_read)(void *file_ptr, uint8_t *buf, int buf_size);
+	int64_t (*godot_videodecoder_file_seek)(void *file_ptr, int64_t pos, int whence);
+	void (*godot_videodecoder_register_decoder)(const godot_videodecoder_interface_gdnative *p_interface);
+} godot_gdnative_ext_videodecoder_api_struct;
+
+typedef struct godot_gdnative_ext_net_3_2_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	godot_error (*godot_net_set_webrtc_library)(const godot_net_webrtc_library *p_library);
+	void (*godot_net_bind_webrtc_peer_connection)(godot_object *p_obj, const godot_net_webrtc_peer_connection *p_interface);
+	void (*godot_net_bind_webrtc_data_channel)(godot_object *p_obj, const godot_net_webrtc_data_channel *p_interface);
+} godot_gdnative_ext_net_3_2_api_struct;
+
+typedef struct godot_gdnative_ext_net_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	void (*godot_net_bind_stream_peer)(godot_object *p_obj, const godot_net_stream_peer *p_interface);
+	void (*godot_net_bind_packet_peer)(godot_object *p_obj, const godot_net_packet_peer *p_interface);
+	void (*godot_net_bind_multiplayer_peer)(godot_object *p_obj, const godot_net_multiplayer_peer *p_interface);
+} godot_gdnative_ext_net_api_struct;
+
+typedef struct godot_gdnative_core_1_2_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	godot_dictionary (*godot_dictionary_duplicate)(const godot_dictionary *p_self, const godot_bool p_deep);
+	godot_vector3 (*godot_vector3_move_toward)(const godot_vector3 *p_self, const godot_vector3 *p_to, const godot_real p_delta);
+	godot_vector2 (*godot_vector2_move_toward)(const godot_vector2 *p_self, const godot_vector2 *p_to, const godot_real p_delta);
+	godot_int (*godot_string_count)(const godot_string *p_self, godot_string p_what, godot_int p_from, godot_int p_to);
+	godot_int (*godot_string_countn)(const godot_string *p_self, godot_string p_what, godot_int p_from, godot_int p_to);
+	godot_vector3 (*godot_vector3_direction_to)(const godot_vector3 *p_self, const godot_vector3 *p_to);
+	godot_vector2 (*godot_vector2_direction_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
+	godot_array (*godot_array_slice)(const godot_array *p_self, const godot_int p_begin, const godot_int p_end, const godot_int p_step, const godot_bool p_deep);
+	godot_bool (*godot_pool_byte_array_empty)(const godot_pool_byte_array *p_self);
+	godot_bool (*godot_pool_int_array_empty)(const godot_pool_int_array *p_self);
+	godot_bool (*godot_pool_real_array_empty)(const godot_pool_real_array *p_self);
+	godot_bool (*godot_pool_string_array_empty)(const godot_pool_string_array *p_self);
+	godot_bool (*godot_pool_vector2_array_empty)(const godot_pool_vector2_array *p_self);
+	godot_bool (*godot_pool_vector3_array_empty)(const godot_pool_vector3_array *p_self);
+	godot_bool (*godot_pool_color_array_empty)(const godot_pool_color_array *p_self);
+	void *(*godot_get_class_tag)(const godot_string_name *p_class);
+	godot_object *(*godot_object_cast_to)(const godot_object *p_object, void *p_class_tag);
+	godot_object *(*godot_instance_from_id)(godot_int p_instance_id);
+} godot_gdnative_core_1_2_api_struct;
+
+typedef struct godot_gdnative_core_1_1_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	godot_int (*godot_color_to_abgr32)(const godot_color *p_self);
+	godot_int (*godot_color_to_abgr64)(const godot_color *p_self);
+	godot_int (*godot_color_to_argb64)(const godot_color *p_self);
+	godot_int (*godot_color_to_rgba64)(const godot_color *p_self);
+	godot_color (*godot_color_darkened)(const godot_color *p_self, const godot_real p_amount);
+	godot_color (*godot_color_from_hsv)(const godot_color *p_self, const godot_real p_h, const godot_real p_s, const godot_real p_v, const godot_real p_a);
+	godot_color (*godot_color_lightened)(const godot_color *p_self, const godot_real p_amount);
+	godot_array (*godot_array_duplicate)(const godot_array *p_self, const godot_bool p_deep);
+	godot_variant (*godot_array_max)(const godot_array *p_self);
+	godot_variant (*godot_array_min)(const godot_array *p_self);
+	void (*godot_array_shuffle)(godot_array *p_self);
+	godot_basis (*godot_basis_slerp)(const godot_basis *p_self, const godot_basis *p_b, const godot_real p_t);
+	godot_variant (*godot_dictionary_get_with_default)(const godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_default);
+	bool (*godot_dictionary_erase_with_return)(godot_dictionary *p_self, const godot_variant *p_key);
+	godot_node_path (*godot_node_path_get_as_property_path)(const godot_node_path *p_self);
+	void (*godot_quat_set_axis_angle)(godot_quat *p_self, const godot_vector3 *p_axis, const godot_real p_angle);
+	godot_rect2 (*godot_rect2_grow_individual)(const godot_rect2 *p_self, const godot_real p_left, const godot_real p_top, const godot_real p_right, const godot_real p_bottom);
+	godot_rect2 (*godot_rect2_grow_margin)(const godot_rect2 *p_self, const godot_int p_margin, const godot_real p_by);
+	godot_rect2 (*godot_rect2_abs)(const godot_rect2 *p_self);
+	godot_string (*godot_string_dedent)(const godot_string *p_self);
+	godot_string (*godot_string_trim_prefix)(const godot_string *p_self, const godot_string *p_prefix);
+	godot_string (*godot_string_trim_suffix)(const godot_string *p_self, const godot_string *p_suffix);
+	godot_string (*godot_string_rstrip)(const godot_string *p_self, const godot_string *p_chars);
+	godot_pool_string_array (*godot_string_rsplit)(const godot_string *p_self, const godot_string *p_divisor, const godot_bool p_allow_empty, const godot_int p_maxsplit);
+	godot_quat (*godot_basis_get_quat)(const godot_basis *p_self);
+	void (*godot_basis_set_quat)(godot_basis *p_self, const godot_quat *p_quat);
+	void (*godot_basis_set_axis_angle_scale)(godot_basis *p_self, const godot_vector3 *p_axis, godot_real p_phi, const godot_vector3 *p_scale);
+	void (*godot_basis_set_euler_scale)(godot_basis *p_self, const godot_vector3 *p_euler, const godot_vector3 *p_scale);
+	void (*godot_basis_set_quat_scale)(godot_basis *p_self, const godot_quat *p_quat, const godot_vector3 *p_scale);
+	bool (*godot_is_instance_valid)(const godot_object *p_object);
+	void (*godot_quat_new_with_basis)(godot_quat *r_dest, const godot_basis *p_basis);
+	void (*godot_quat_new_with_euler)(godot_quat *r_dest, const godot_vector3 *p_euler);
+	void (*godot_transform_new_with_quat)(godot_transform *r_dest, const godot_quat *p_quat);
+	godot_string (*godot_variant_get_operator_name)(godot_variant_operator p_op);
+	void (*godot_variant_evaluate)(godot_variant_operator p_op, const godot_variant *p_a, const godot_variant *p_b, godot_variant *r_ret, godot_bool *r_valid);
+} godot_gdnative_core_1_1_api_struct;
+
+typedef struct godot_gdnative_core_api_struct {
+	unsigned int type;
+	godot_gdnative_api_version version;
+	const godot_gdnative_api_struct *next;
+	unsigned int num_extensions;
+	const godot_gdnative_api_struct **extensions;
+	void (*godot_color_new_rgba)(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a);
+	void (*godot_color_new_rgb)(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b);
+	godot_real (*godot_color_get_r)(const godot_color *p_self);
+	void (*godot_color_set_r)(godot_color *p_self, const godot_real r);
+	godot_real (*godot_color_get_g)(const godot_color *p_self);
+	void (*godot_color_set_g)(godot_color *p_self, const godot_real g);
+	godot_real (*godot_color_get_b)(const godot_color *p_self);
+	void (*godot_color_set_b)(godot_color *p_self, const godot_real b);
+	godot_real (*godot_color_get_a)(const godot_color *p_self);
+	void (*godot_color_set_a)(godot_color *p_self, const godot_real a);
+	godot_real (*godot_color_get_h)(const godot_color *p_self);
+	godot_real (*godot_color_get_s)(const godot_color *p_self);
+	godot_real (*godot_color_get_v)(const godot_color *p_self);
+	godot_string (*godot_color_as_string)(const godot_color *p_self);
+	godot_int (*godot_color_to_rgba32)(const godot_color *p_self);
+	godot_int (*godot_color_to_argb32)(const godot_color *p_self);
+	godot_real (*godot_color_gray)(const godot_color *p_self);
+	godot_color (*godot_color_inverted)(const godot_color *p_self);
+	godot_color (*godot_color_contrasted)(const godot_color *p_self);
+	godot_color (*godot_color_linear_interpolate)(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
+	godot_color (*godot_color_blend)(const godot_color *p_self, const godot_color *p_over);
+	godot_string (*godot_color_to_html)(const godot_color *p_self, const godot_bool p_with_alpha);
+	godot_bool (*godot_color_operator_equal)(const godot_color *p_self, const godot_color *p_b);
+	godot_bool (*godot_color_operator_less)(const godot_color *p_self, const godot_color *p_b);
+	void (*godot_vector2_new)(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y);
+	godot_string (*godot_vector2_as_string)(const godot_vector2 *p_self);
+	godot_vector2 (*godot_vector2_normalized)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_length)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_angle)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_length_squared)(const godot_vector2 *p_self);
+	godot_bool (*godot_vector2_is_normalized)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_distance_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
+	godot_real (*godot_vector2_distance_squared_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
+	godot_real (*godot_vector2_angle_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
+	godot_real (*godot_vector2_angle_to_point)(const godot_vector2 *p_self, const godot_vector2 *p_to);
+	godot_vector2 (*godot_vector2_linear_interpolate)(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
+	godot_vector2 (*godot_vector2_cubic_interpolate)(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t);
+	godot_vector2 (*godot_vector2_rotated)(const godot_vector2 *p_self, const godot_real p_phi);
+	godot_vector2 (*godot_vector2_tangent)(const godot_vector2 *p_self);
+	godot_vector2 (*godot_vector2_floor)(const godot_vector2 *p_self);
+	godot_vector2 (*godot_vector2_snapped)(const godot_vector2 *p_self, const godot_vector2 *p_by);
+	godot_real (*godot_vector2_aspect)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_dot)(const godot_vector2 *p_self, const godot_vector2 *p_with);
+	godot_vector2 (*godot_vector2_slide)(const godot_vector2 *p_self, const godot_vector2 *p_n);
+	godot_vector2 (*godot_vector2_bounce)(const godot_vector2 *p_self, const godot_vector2 *p_n);
+	godot_vector2 (*godot_vector2_reflect)(const godot_vector2 *p_self, const godot_vector2 *p_n);
+	godot_vector2 (*godot_vector2_abs)(const godot_vector2 *p_self);
+	godot_vector2 (*godot_vector2_clamped)(const godot_vector2 *p_self, const godot_real p_length);
+	godot_vector2 (*godot_vector2_operator_add)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_vector2 (*godot_vector2_operator_subtract)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_vector2 (*godot_vector2_operator_multiply_vector)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_vector2 (*godot_vector2_operator_multiply_scalar)(const godot_vector2 *p_self, const godot_real p_b);
+	godot_vector2 (*godot_vector2_operator_divide_vector)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_vector2 (*godot_vector2_operator_divide_scalar)(const godot_vector2 *p_self, const godot_real p_b);
+	godot_bool (*godot_vector2_operator_equal)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_bool (*godot_vector2_operator_less)(const godot_vector2 *p_self, const godot_vector2 *p_b);
+	godot_vector2 (*godot_vector2_operator_neg)(const godot_vector2 *p_self);
+	void (*godot_vector2_set_x)(godot_vector2 *p_self, const godot_real p_x);
+	void (*godot_vector2_set_y)(godot_vector2 *p_self, const godot_real p_y);
+	godot_real (*godot_vector2_get_x)(const godot_vector2 *p_self);
+	godot_real (*godot_vector2_get_y)(const godot_vector2 *p_self);
+	void (*godot_quat_new)(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w);
+	void (*godot_quat_new_with_axis_angle)(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle);
+	godot_real (*godot_quat_get_x)(const godot_quat *p_self);
+	void (*godot_quat_set_x)(godot_quat *p_self, const godot_real val);
+	godot_real (*godot_quat_get_y)(const godot_quat *p_self);
+	void (*godot_quat_set_y)(godot_quat *p_self, const godot_real val);
+	godot_real (*godot_quat_get_z)(const godot_quat *p_self);
+	void (*godot_quat_set_z)(godot_quat *p_self, const godot_real val);
+	godot_real (*godot_quat_get_w)(const godot_quat *p_self);
+	void (*godot_quat_set_w)(godot_quat *p_self, const godot_real val);
+	godot_string (*godot_quat_as_string)(const godot_quat *p_self);
+	godot_real (*godot_quat_length)(const godot_quat *p_self);
+	godot_real (*godot_quat_length_squared)(const godot_quat *p_self);
+	godot_quat (*godot_quat_normalized)(const godot_quat *p_self);
+	godot_bool (*godot_quat_is_normalized)(const godot_quat *p_self);
+	godot_quat (*godot_quat_inverse)(const godot_quat *p_self);
+	godot_real (*godot_quat_dot)(const godot_quat *p_self, const godot_quat *p_b);
+	godot_vector3 (*godot_quat_xform)(const godot_quat *p_self, const godot_vector3 *p_v);
+	godot_quat (*godot_quat_slerp)(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+	godot_quat (*godot_quat_slerpni)(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
+	godot_quat (*godot_quat_cubic_slerp)(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t);
+	godot_quat (*godot_quat_operator_multiply)(const godot_quat *p_self, const godot_real p_b);
+	godot_quat (*godot_quat_operator_add)(const godot_quat *p_self, const godot_quat *p_b);
+	godot_quat (*godot_quat_operator_subtract)(const godot_quat *p_self, const godot_quat *p_b);
+	godot_quat (*godot_quat_operator_divide)(const godot_quat *p_self, const godot_real p_b);
+	godot_bool (*godot_quat_operator_equal)(const godot_quat *p_self, const godot_quat *p_b);
+	godot_quat (*godot_quat_operator_neg)(const godot_quat *p_self);
+	void (*godot_basis_new_with_rows)(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis);
+	void (*godot_basis_new_with_axis_and_angle)(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi);
+	void (*godot_basis_new_with_euler)(godot_basis *r_dest, const godot_vector3 *p_euler);
+	godot_string (*godot_basis_as_string)(const godot_basis *p_self);
+	godot_basis (*godot_basis_inverse)(const godot_basis *p_self);
+	godot_basis (*godot_basis_transposed)(const godot_basis *p_self);
+	godot_basis (*godot_basis_orthonormalized)(const godot_basis *p_self);
+	godot_real (*godot_basis_determinant)(const godot_basis *p_self);
+	godot_basis (*godot_basis_rotated)(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+	godot_basis (*godot_basis_scaled)(const godot_basis *p_self, const godot_vector3 *p_scale);
+	godot_vector3 (*godot_basis_get_scale)(const godot_basis *p_self);
+	godot_vector3 (*godot_basis_get_euler)(const godot_basis *p_self);
+	godot_real (*godot_basis_tdotx)(const godot_basis *p_self, const godot_vector3 *p_with);
+	godot_real (*godot_basis_tdoty)(const godot_basis *p_self, const godot_vector3 *p_with);
+	godot_real (*godot_basis_tdotz)(const godot_basis *p_self, const godot_vector3 *p_with);
+	godot_vector3 (*godot_basis_xform)(const godot_basis *p_self, const godot_vector3 *p_v);
+	godot_vector3 (*godot_basis_xform_inv)(const godot_basis *p_self, const godot_vector3 *p_v);
+	godot_int (*godot_basis_get_orthogonal_index)(const godot_basis *p_self);
+	void (*godot_basis_new)(godot_basis *r_dest);
+	void (*godot_basis_new_with_euler_quat)(godot_basis *r_dest, const godot_quat *p_euler);
+	void (*godot_basis_get_elements)(const godot_basis *p_self, godot_vector3 *p_elements);
+	godot_vector3 (*godot_basis_get_axis)(const godot_basis *p_self, const godot_int p_axis);
+	void (*godot_basis_set_axis)(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value);
+	godot_vector3 (*godot_basis_get_row)(const godot_basis *p_self, const godot_int p_row);
+	void (*godot_basis_set_row)(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value);
+	godot_bool (*godot_basis_operator_equal)(const godot_basis *p_self, const godot_basis *p_b);
+	godot_basis (*godot_basis_operator_add)(const godot_basis *p_self, const godot_basis *p_b);
+	godot_basis (*godot_basis_operator_subtract)(const godot_basis *p_self, const godot_basis *p_b);
+	godot_basis (*godot_basis_operator_multiply_vector)(const godot_basis *p_self, const godot_basis *p_b);
+	godot_basis (*godot_basis_operator_multiply_scalar)(const godot_basis *p_self, const godot_real p_b);
+	void (*godot_vector3_new)(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z);
+	godot_string (*godot_vector3_as_string)(const godot_vector3 *p_self);
+	godot_int (*godot_vector3_min_axis)(const godot_vector3 *p_self);
+	godot_int (*godot_vector3_max_axis)(const godot_vector3 *p_self);
+	godot_real (*godot_vector3_length)(const godot_vector3 *p_self);
+	godot_real (*godot_vector3_length_squared)(const godot_vector3 *p_self);
+	godot_bool (*godot_vector3_is_normalized)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_normalized)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_inverse)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_snapped)(const godot_vector3 *p_self, const godot_vector3 *p_by);
+	godot_vector3 (*godot_vector3_rotated)(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+	godot_vector3 (*godot_vector3_linear_interpolate)(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
+	godot_vector3 (*godot_vector3_cubic_interpolate)(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t);
+	godot_real (*godot_vector3_dot)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_cross)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_basis (*godot_vector3_outer)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_basis (*godot_vector3_to_diagonal_matrix)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_abs)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_floor)(const godot_vector3 *p_self);
+	godot_vector3 (*godot_vector3_ceil)(const godot_vector3 *p_self);
+	godot_real (*godot_vector3_distance_to)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_real (*godot_vector3_distance_squared_to)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_real (*godot_vector3_angle_to)(const godot_vector3 *p_self, const godot_vector3 *p_to);
+	godot_vector3 (*godot_vector3_slide)(const godot_vector3 *p_self, const godot_vector3 *p_n);
+	godot_vector3 (*godot_vector3_bounce)(const godot_vector3 *p_self, const godot_vector3 *p_n);
+	godot_vector3 (*godot_vector3_reflect)(const godot_vector3 *p_self, const godot_vector3 *p_n);
+	godot_vector3 (*godot_vector3_operator_add)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_operator_subtract)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_operator_multiply_vector)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_operator_multiply_scalar)(const godot_vector3 *p_self, const godot_real p_b);
+	godot_vector3 (*godot_vector3_operator_divide_vector)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_operator_divide_scalar)(const godot_vector3 *p_self, const godot_real p_b);
+	godot_bool (*godot_vector3_operator_equal)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_bool (*godot_vector3_operator_less)(const godot_vector3 *p_self, const godot_vector3 *p_b);
+	godot_vector3 (*godot_vector3_operator_neg)(const godot_vector3 *p_self);
+	void (*godot_vector3_set_axis)(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val);
+	godot_real (*godot_vector3_get_axis)(const godot_vector3 *p_self, const godot_vector3_axis p_axis);
+	void (*godot_pool_byte_array_new)(godot_pool_byte_array *r_dest);
+	void (*godot_pool_byte_array_new_copy)(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src);
+	void (*godot_pool_byte_array_new_with_array)(godot_pool_byte_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_byte_array_append)(godot_pool_byte_array *p_self, const uint8_t p_data);
+	void (*godot_pool_byte_array_append_array)(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array);
+	godot_error (*godot_pool_byte_array_insert)(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+	void (*godot_pool_byte_array_invert)(godot_pool_byte_array *p_self);
+	void (*godot_pool_byte_array_push_back)(godot_pool_byte_array *p_self, const uint8_t p_data);
+	void (*godot_pool_byte_array_remove)(godot_pool_byte_array *p_self, const godot_int p_idx);
+	void (*godot_pool_byte_array_resize)(godot_pool_byte_array *p_self, const godot_int p_size);
+	godot_pool_byte_array_read_access *(*godot_pool_byte_array_read)(const godot_pool_byte_array *p_self);
+	godot_pool_byte_array_write_access *(*godot_pool_byte_array_write)(godot_pool_byte_array *p_self);
+	void (*godot_pool_byte_array_set)(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
+	uint8_t (*godot_pool_byte_array_get)(const godot_pool_byte_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_byte_array_size)(const godot_pool_byte_array *p_self);
+	void (*godot_pool_byte_array_destroy)(godot_pool_byte_array *p_self);
+	void (*godot_pool_int_array_new)(godot_pool_int_array *r_dest);
+	void (*godot_pool_int_array_new_copy)(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src);
+	void (*godot_pool_int_array_new_with_array)(godot_pool_int_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_int_array_append)(godot_pool_int_array *p_self, const godot_int p_data);
+	void (*godot_pool_int_array_append_array)(godot_pool_int_array *p_self, const godot_pool_int_array *p_array);
+	godot_error (*godot_pool_int_array_insert)(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+	void (*godot_pool_int_array_invert)(godot_pool_int_array *p_self);
+	void (*godot_pool_int_array_push_back)(godot_pool_int_array *p_self, const godot_int p_data);
+	void (*godot_pool_int_array_remove)(godot_pool_int_array *p_self, const godot_int p_idx);
+	void (*godot_pool_int_array_resize)(godot_pool_int_array *p_self, const godot_int p_size);
+	godot_pool_int_array_read_access *(*godot_pool_int_array_read)(const godot_pool_int_array *p_self);
+	godot_pool_int_array_write_access *(*godot_pool_int_array_write)(godot_pool_int_array *p_self);
+	void (*godot_pool_int_array_set)(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
+	godot_int (*godot_pool_int_array_get)(const godot_pool_int_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_int_array_size)(const godot_pool_int_array *p_self);
+	void (*godot_pool_int_array_destroy)(godot_pool_int_array *p_self);
+	void (*godot_pool_real_array_new)(godot_pool_real_array *r_dest);
+	void (*godot_pool_real_array_new_copy)(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src);
+	void (*godot_pool_real_array_new_with_array)(godot_pool_real_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_real_array_append)(godot_pool_real_array *p_self, const godot_real p_data);
+	void (*godot_pool_real_array_append_array)(godot_pool_real_array *p_self, const godot_pool_real_array *p_array);
+	godot_error (*godot_pool_real_array_insert)(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+	void (*godot_pool_real_array_invert)(godot_pool_real_array *p_self);
+	void (*godot_pool_real_array_push_back)(godot_pool_real_array *p_self, const godot_real p_data);
+	void (*godot_pool_real_array_remove)(godot_pool_real_array *p_self, const godot_int p_idx);
+	void (*godot_pool_real_array_resize)(godot_pool_real_array *p_self, const godot_int p_size);
+	godot_pool_real_array_read_access *(*godot_pool_real_array_read)(const godot_pool_real_array *p_self);
+	godot_pool_real_array_write_access *(*godot_pool_real_array_write)(godot_pool_real_array *p_self);
+	void (*godot_pool_real_array_set)(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
+	godot_real (*godot_pool_real_array_get)(const godot_pool_real_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_real_array_size)(const godot_pool_real_array *p_self);
+	void (*godot_pool_real_array_destroy)(godot_pool_real_array *p_self);
+	void (*godot_pool_string_array_new)(godot_pool_string_array *r_dest);
+	void (*godot_pool_string_array_new_copy)(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src);
+	void (*godot_pool_string_array_new_with_array)(godot_pool_string_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_string_array_append)(godot_pool_string_array *p_self, const godot_string *p_data);
+	void (*godot_pool_string_array_append_array)(godot_pool_string_array *p_self, const godot_pool_string_array *p_array);
+	godot_error (*godot_pool_string_array_insert)(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+	void (*godot_pool_string_array_invert)(godot_pool_string_array *p_self);
+	void (*godot_pool_string_array_push_back)(godot_pool_string_array *p_self, const godot_string *p_data);
+	void (*godot_pool_string_array_remove)(godot_pool_string_array *p_self, const godot_int p_idx);
+	void (*godot_pool_string_array_resize)(godot_pool_string_array *p_self, const godot_int p_size);
+	godot_pool_string_array_read_access *(*godot_pool_string_array_read)(const godot_pool_string_array *p_self);
+	godot_pool_string_array_write_access *(*godot_pool_string_array_write)(godot_pool_string_array *p_self);
+	void (*godot_pool_string_array_set)(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
+	godot_string (*godot_pool_string_array_get)(const godot_pool_string_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_string_array_size)(const godot_pool_string_array *p_self);
+	void (*godot_pool_string_array_destroy)(godot_pool_string_array *p_self);
+	void (*godot_pool_vector2_array_new)(godot_pool_vector2_array *r_dest);
+	void (*godot_pool_vector2_array_new_copy)(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src);
+	void (*godot_pool_vector2_array_new_with_array)(godot_pool_vector2_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_vector2_array_append)(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+	void (*godot_pool_vector2_array_append_array)(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array);
+	godot_error (*godot_pool_vector2_array_insert)(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+	void (*godot_pool_vector2_array_invert)(godot_pool_vector2_array *p_self);
+	void (*godot_pool_vector2_array_push_back)(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
+	void (*godot_pool_vector2_array_remove)(godot_pool_vector2_array *p_self, const godot_int p_idx);
+	void (*godot_pool_vector2_array_resize)(godot_pool_vector2_array *p_self, const godot_int p_size);
+	godot_pool_vector2_array_read_access *(*godot_pool_vector2_array_read)(const godot_pool_vector2_array *p_self);
+	godot_pool_vector2_array_write_access *(*godot_pool_vector2_array_write)(godot_pool_vector2_array *p_self);
+	void (*godot_pool_vector2_array_set)(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
+	godot_vector2 (*godot_pool_vector2_array_get)(const godot_pool_vector2_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_vector2_array_size)(const godot_pool_vector2_array *p_self);
+	void (*godot_pool_vector2_array_destroy)(godot_pool_vector2_array *p_self);
+	void (*godot_pool_vector3_array_new)(godot_pool_vector3_array *r_dest);
+	void (*godot_pool_vector3_array_new_copy)(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src);
+	void (*godot_pool_vector3_array_new_with_array)(godot_pool_vector3_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_vector3_array_append)(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+	void (*godot_pool_vector3_array_append_array)(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array);
+	godot_error (*godot_pool_vector3_array_insert)(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+	void (*godot_pool_vector3_array_invert)(godot_pool_vector3_array *p_self);
+	void (*godot_pool_vector3_array_push_back)(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
+	void (*godot_pool_vector3_array_remove)(godot_pool_vector3_array *p_self, const godot_int p_idx);
+	void (*godot_pool_vector3_array_resize)(godot_pool_vector3_array *p_self, const godot_int p_size);
+	godot_pool_vector3_array_read_access *(*godot_pool_vector3_array_read)(const godot_pool_vector3_array *p_self);
+	godot_pool_vector3_array_write_access *(*godot_pool_vector3_array_write)(godot_pool_vector3_array *p_self);
+	void (*godot_pool_vector3_array_set)(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
+	godot_vector3 (*godot_pool_vector3_array_get)(const godot_pool_vector3_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_vector3_array_size)(const godot_pool_vector3_array *p_self);
+	void (*godot_pool_vector3_array_destroy)(godot_pool_vector3_array *p_self);
+	void (*godot_pool_color_array_new)(godot_pool_color_array *r_dest);
+	void (*godot_pool_color_array_new_copy)(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src);
+	void (*godot_pool_color_array_new_with_array)(godot_pool_color_array *r_dest, const godot_array *p_a);
+	void (*godot_pool_color_array_append)(godot_pool_color_array *p_self, const godot_color *p_data);
+	void (*godot_pool_color_array_append_array)(godot_pool_color_array *p_self, const godot_pool_color_array *p_array);
+	godot_error (*godot_pool_color_array_insert)(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+	void (*godot_pool_color_array_invert)(godot_pool_color_array *p_self);
+	void (*godot_pool_color_array_push_back)(godot_pool_color_array *p_self, const godot_color *p_data);
+	void (*godot_pool_color_array_remove)(godot_pool_color_array *p_self, const godot_int p_idx);
+	void (*godot_pool_color_array_resize)(godot_pool_color_array *p_self, const godot_int p_size);
+	godot_pool_color_array_read_access *(*godot_pool_color_array_read)(const godot_pool_color_array *p_self);
+	godot_pool_color_array_write_access *(*godot_pool_color_array_write)(godot_pool_color_array *p_self);
+	void (*godot_pool_color_array_set)(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
+	godot_color (*godot_pool_color_array_get)(const godot_pool_color_array *p_self, const godot_int p_idx);
+	godot_int (*godot_pool_color_array_size)(const godot_pool_color_array *p_self);
+	void (*godot_pool_color_array_destroy)(godot_pool_color_array *p_self);
+	godot_pool_byte_array_read_access *(*godot_pool_byte_array_read_access_copy)(const godot_pool_byte_array_read_access *p_read);
+	const uint8_t *(*godot_pool_byte_array_read_access_ptr)(const godot_pool_byte_array_read_access *p_read);
+	void (*godot_pool_byte_array_read_access_operator_assign)(godot_pool_byte_array_read_access *p_read, godot_pool_byte_array_read_access *p_other);
+	void (*godot_pool_byte_array_read_access_destroy)(godot_pool_byte_array_read_access *p_read);
+	godot_pool_int_array_read_access *(*godot_pool_int_array_read_access_copy)(const godot_pool_int_array_read_access *p_read);
+	const godot_int *(*godot_pool_int_array_read_access_ptr)(const godot_pool_int_array_read_access *p_read);
+	void (*godot_pool_int_array_read_access_operator_assign)(godot_pool_int_array_read_access *p_read, godot_pool_int_array_read_access *p_other);
+	void (*godot_pool_int_array_read_access_destroy)(godot_pool_int_array_read_access *p_read);
+	godot_pool_real_array_read_access *(*godot_pool_real_array_read_access_copy)(const godot_pool_real_array_read_access *p_read);
+	const godot_real *(*godot_pool_real_array_read_access_ptr)(const godot_pool_real_array_read_access *p_read);
+	void (*godot_pool_real_array_read_access_operator_assign)(godot_pool_real_array_read_access *p_read, godot_pool_real_array_read_access *p_other);
+	void (*godot_pool_real_array_read_access_destroy)(godot_pool_real_array_read_access *p_read);
+	godot_pool_string_array_read_access *(*godot_pool_string_array_read_access_copy)(const godot_pool_string_array_read_access *p_read);
+	const godot_string *(*godot_pool_string_array_read_access_ptr)(const godot_pool_string_array_read_access *p_read);
+	void (*godot_pool_string_array_read_access_operator_assign)(godot_pool_string_array_read_access *p_read, godot_pool_string_array_read_access *p_other);
+	void (*godot_pool_string_array_read_access_destroy)(godot_pool_string_array_read_access *p_read);
+	godot_pool_vector2_array_read_access *(*godot_pool_vector2_array_read_access_copy)(const godot_pool_vector2_array_read_access *p_read);
+	const godot_vector2 *(*godot_pool_vector2_array_read_access_ptr)(const godot_pool_vector2_array_read_access *p_read);
+	void (*godot_pool_vector2_array_read_access_operator_assign)(godot_pool_vector2_array_read_access *p_read, godot_pool_vector2_array_read_access *p_other);
+	void (*godot_pool_vector2_array_read_access_destroy)(godot_pool_vector2_array_read_access *p_read);
+	godot_pool_vector3_array_read_access *(*godot_pool_vector3_array_read_access_copy)(const godot_pool_vector3_array_read_access *p_read);
+	const godot_vector3 *(*godot_pool_vector3_array_read_access_ptr)(const godot_pool_vector3_array_read_access *p_read);
+	void (*godot_pool_vector3_array_read_access_operator_assign)(godot_pool_vector3_array_read_access *p_read, godot_pool_vector3_array_read_access *p_other);
+	void (*godot_pool_vector3_array_read_access_destroy)(godot_pool_vector3_array_read_access *p_read);
+	godot_pool_color_array_read_access *(*godot_pool_color_array_read_access_copy)(const godot_pool_color_array_read_access *p_read);
+	const godot_color *(*godot_pool_color_array_read_access_ptr)(const godot_pool_color_array_read_access *p_read);
+	void (*godot_pool_color_array_read_access_operator_assign)(godot_pool_color_array_read_access *p_read, godot_pool_color_array_read_access *p_other);
+	void (*godot_pool_color_array_read_access_destroy)(godot_pool_color_array_read_access *p_read);
+	godot_pool_byte_array_write_access *(*godot_pool_byte_array_write_access_copy)(const godot_pool_byte_array_write_access *p_write);
+	uint8_t *(*godot_pool_byte_array_write_access_ptr)(const godot_pool_byte_array_write_access *p_write);
+	void (*godot_pool_byte_array_write_access_operator_assign)(godot_pool_byte_array_write_access *p_write, godot_pool_byte_array_write_access *p_other);
+	void (*godot_pool_byte_array_write_access_destroy)(godot_pool_byte_array_write_access *p_write);
+	godot_pool_int_array_write_access *(*godot_pool_int_array_write_access_copy)(const godot_pool_int_array_write_access *p_write);
+	godot_int *(*godot_pool_int_array_write_access_ptr)(const godot_pool_int_array_write_access *p_write);
+	void (*godot_pool_int_array_write_access_operator_assign)(godot_pool_int_array_write_access *p_write, godot_pool_int_array_write_access *p_other);
+	void (*godot_pool_int_array_write_access_destroy)(godot_pool_int_array_write_access *p_write);
+	godot_pool_real_array_write_access *(*godot_pool_real_array_write_access_copy)(const godot_pool_real_array_write_access *p_write);
+	godot_real *(*godot_pool_real_array_write_access_ptr)(const godot_pool_real_array_write_access *p_write);
+	void (*godot_pool_real_array_write_access_operator_assign)(godot_pool_real_array_write_access *p_write, godot_pool_real_array_write_access *p_other);
+	void (*godot_pool_real_array_write_access_destroy)(godot_pool_real_array_write_access *p_write);
+	godot_pool_string_array_write_access *(*godot_pool_string_array_write_access_copy)(const godot_pool_string_array_write_access *p_write);
+	godot_string *(*godot_pool_string_array_write_access_ptr)(const godot_pool_string_array_write_access *p_write);
+	void (*godot_pool_string_array_write_access_operator_assign)(godot_pool_string_array_write_access *p_write, godot_pool_string_array_write_access *p_other);
+	void (*godot_pool_string_array_write_access_destroy)(godot_pool_string_array_write_access *p_write);
+	godot_pool_vector2_array_write_access *(*godot_pool_vector2_array_write_access_copy)(const godot_pool_vector2_array_write_access *p_write);
+	godot_vector2 *(*godot_pool_vector2_array_write_access_ptr)(const godot_pool_vector2_array_write_access *p_write);
+	void (*godot_pool_vector2_array_write_access_operator_assign)(godot_pool_vector2_array_write_access *p_write, godot_pool_vector2_array_write_access *p_other);
+	void (*godot_pool_vector2_array_write_access_destroy)(godot_pool_vector2_array_write_access *p_write);
+	godot_pool_vector3_array_write_access *(*godot_pool_vector3_array_write_access_copy)(const godot_pool_vector3_array_write_access *p_write);
+	godot_vector3 *(*godot_pool_vector3_array_write_access_ptr)(const godot_pool_vector3_array_write_access *p_write);
+	void (*godot_pool_vector3_array_write_access_operator_assign)(godot_pool_vector3_array_write_access *p_write, godot_pool_vector3_array_write_access *p_other);
+	void (*godot_pool_vector3_array_write_access_destroy)(godot_pool_vector3_array_write_access *p_write);
+	godot_pool_color_array_write_access *(*godot_pool_color_array_write_access_copy)(const godot_pool_color_array_write_access *p_write);
+	godot_color *(*godot_pool_color_array_write_access_ptr)(const godot_pool_color_array_write_access *p_write);
+	void (*godot_pool_color_array_write_access_operator_assign)(godot_pool_color_array_write_access *p_write, godot_pool_color_array_write_access *p_other);
+	void (*godot_pool_color_array_write_access_destroy)(godot_pool_color_array_write_access *p_write);
+	void (*godot_array_new)(godot_array *r_dest);
+	void (*godot_array_new_copy)(godot_array *r_dest, const godot_array *p_src);
+	void (*godot_array_new_pool_color_array)(godot_array *r_dest, const godot_pool_color_array *p_pca);
+	void (*godot_array_new_pool_vector3_array)(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a);
+	void (*godot_array_new_pool_vector2_array)(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a);
+	void (*godot_array_new_pool_string_array)(godot_array *r_dest, const godot_pool_string_array *p_psa);
+	void (*godot_array_new_pool_real_array)(godot_array *r_dest, const godot_pool_real_array *p_pra);
+	void (*godot_array_new_pool_int_array)(godot_array *r_dest, const godot_pool_int_array *p_pia);
+	void (*godot_array_new_pool_byte_array)(godot_array *r_dest, const godot_pool_byte_array *p_pba);
+	void (*godot_array_set)(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value);
+	godot_variant (*godot_array_get)(const godot_array *p_self, const godot_int p_idx);
+	godot_variant *(*godot_array_operator_index)(godot_array *p_self, const godot_int p_idx);
+	const godot_variant *(*godot_array_operator_index_const)(const godot_array *p_self, const godot_int p_idx);
+	void (*godot_array_append)(godot_array *p_self, const godot_variant *p_value);
+	void (*godot_array_clear)(godot_array *p_self);
+	godot_int (*godot_array_count)(const godot_array *p_self, const godot_variant *p_value);
+	godot_bool (*godot_array_empty)(const godot_array *p_self);
+	void (*godot_array_erase)(godot_array *p_self, const godot_variant *p_value);
+	godot_variant (*godot_array_front)(const godot_array *p_self);
+	godot_variant (*godot_array_back)(const godot_array *p_self);
+	godot_int (*godot_array_find)(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+	godot_int (*godot_array_find_last)(const godot_array *p_self, const godot_variant *p_what);
+	godot_bool (*godot_array_has)(const godot_array *p_self, const godot_variant *p_value);
+	godot_int (*godot_array_hash)(const godot_array *p_self);
+	void (*godot_array_insert)(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value);
+	void (*godot_array_invert)(godot_array *p_self);
+	godot_variant (*godot_array_pop_back)(godot_array *p_self);
+	godot_variant (*godot_array_pop_front)(godot_array *p_self);
+	void (*godot_array_push_back)(godot_array *p_self, const godot_variant *p_value);
+	void (*godot_array_push_front)(godot_array *p_self, const godot_variant *p_value);
+	void (*godot_array_remove)(godot_array *p_self, const godot_int p_idx);
+	void (*godot_array_resize)(godot_array *p_self, const godot_int p_size);
+	godot_int (*godot_array_rfind)(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
+	godot_int (*godot_array_size)(const godot_array *p_self);
+	void (*godot_array_sort)(godot_array *p_self);
+	void (*godot_array_sort_custom)(godot_array *p_self, godot_object *p_obj, const godot_string *p_func);
+	godot_int (*godot_array_bsearch)(godot_array *p_self, const godot_variant *p_value, const godot_bool p_before);
+	godot_int (*godot_array_bsearch_custom)(godot_array *p_self, const godot_variant *p_value, godot_object *p_obj, const godot_string *p_func, const godot_bool p_before);
+	void (*godot_array_destroy)(godot_array *p_self);
+	void (*godot_dictionary_new)(godot_dictionary *r_dest);
+	void (*godot_dictionary_new_copy)(godot_dictionary *r_dest, const godot_dictionary *p_src);
+	void (*godot_dictionary_destroy)(godot_dictionary *p_self);
+	godot_int (*godot_dictionary_size)(const godot_dictionary *p_self);
+	godot_bool (*godot_dictionary_empty)(const godot_dictionary *p_self);
+	void (*godot_dictionary_clear)(godot_dictionary *p_self);
+	godot_bool (*godot_dictionary_has)(const godot_dictionary *p_self, const godot_variant *p_key);
+	godot_bool (*godot_dictionary_has_all)(const godot_dictionary *p_self, const godot_array *p_keys);
+	void (*godot_dictionary_erase)(godot_dictionary *p_self, const godot_variant *p_key);
+	godot_int (*godot_dictionary_hash)(const godot_dictionary *p_self);
+	godot_array (*godot_dictionary_keys)(const godot_dictionary *p_self);
+	godot_array (*godot_dictionary_values)(const godot_dictionary *p_self);
+	godot_variant (*godot_dictionary_get)(const godot_dictionary *p_self, const godot_variant *p_key);
+	void (*godot_dictionary_set)(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value);
+	godot_variant *(*godot_dictionary_operator_index)(godot_dictionary *p_self, const godot_variant *p_key);
+	const godot_variant *(*godot_dictionary_operator_index_const)(const godot_dictionary *p_self, const godot_variant *p_key);
+	godot_variant *(*godot_dictionary_next)(const godot_dictionary *p_self, const godot_variant *p_key);
+	godot_bool (*godot_dictionary_operator_equal)(const godot_dictionary *p_self, const godot_dictionary *p_b);
+	godot_string (*godot_dictionary_to_json)(const godot_dictionary *p_self);
+	void (*godot_node_path_new)(godot_node_path *r_dest, const godot_string *p_from);
+	void (*godot_node_path_new_copy)(godot_node_path *r_dest, const godot_node_path *p_src);
+	void (*godot_node_path_destroy)(godot_node_path *p_self);
+	godot_string (*godot_node_path_as_string)(const godot_node_path *p_self);
+	godot_bool (*godot_node_path_is_absolute)(const godot_node_path *p_self);
+	godot_int (*godot_node_path_get_name_count)(const godot_node_path *p_self);
+	godot_string (*godot_node_path_get_name)(const godot_node_path *p_self, const godot_int p_idx);
+	godot_int (*godot_node_path_get_subname_count)(const godot_node_path *p_self);
+	godot_string (*godot_node_path_get_subname)(const godot_node_path *p_self, const godot_int p_idx);
+	godot_string (*godot_node_path_get_concatenated_subnames)(const godot_node_path *p_self);
+	godot_bool (*godot_node_path_is_empty)(const godot_node_path *p_self);
+	godot_bool (*godot_node_path_operator_equal)(const godot_node_path *p_self, const godot_node_path *p_b);
+	void (*godot_plane_new_with_reals)(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d);
+	void (*godot_plane_new_with_vectors)(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3);
+	void (*godot_plane_new_with_normal)(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d);
+	godot_string (*godot_plane_as_string)(const godot_plane *p_self);
+	godot_plane (*godot_plane_normalized)(const godot_plane *p_self);
+	godot_vector3 (*godot_plane_center)(const godot_plane *p_self);
+	godot_vector3 (*godot_plane_get_any_point)(const godot_plane *p_self);
+	godot_bool (*godot_plane_is_point_over)(const godot_plane *p_self, const godot_vector3 *p_point);
+	godot_real (*godot_plane_distance_to)(const godot_plane *p_self, const godot_vector3 *p_point);
+	godot_bool (*godot_plane_has_point)(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon);
+	godot_vector3 (*godot_plane_project)(const godot_plane *p_self, const godot_vector3 *p_point);
+	godot_bool (*godot_plane_intersect_3)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c);
+	godot_bool (*godot_plane_intersects_ray)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir);
+	godot_bool (*godot_plane_intersects_segment)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end);
+	godot_plane (*godot_plane_operator_neg)(const godot_plane *p_self);
+	godot_bool (*godot_plane_operator_equal)(const godot_plane *p_self, const godot_plane *p_b);
+	void (*godot_plane_set_normal)(godot_plane *p_self, const godot_vector3 *p_normal);
+	godot_vector3 (*godot_plane_get_normal)(const godot_plane *p_self);
+	godot_real (*godot_plane_get_d)(const godot_plane *p_self);
+	void (*godot_plane_set_d)(godot_plane *p_self, const godot_real p_d);
+	void (*godot_rect2_new_with_position_and_size)(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
+	void (*godot_rect2_new)(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
+	godot_string (*godot_rect2_as_string)(const godot_rect2 *p_self);
+	godot_real (*godot_rect2_get_area)(const godot_rect2 *p_self);
+	godot_bool (*godot_rect2_intersects)(const godot_rect2 *p_self, const godot_rect2 *p_b);
+	godot_bool (*godot_rect2_encloses)(const godot_rect2 *p_self, const godot_rect2 *p_b);
+	godot_bool (*godot_rect2_has_no_area)(const godot_rect2 *p_self);
+	godot_rect2 (*godot_rect2_clip)(const godot_rect2 *p_self, const godot_rect2 *p_b);
+	godot_rect2 (*godot_rect2_merge)(const godot_rect2 *p_self, const godot_rect2 *p_b);
+	godot_bool (*godot_rect2_has_point)(const godot_rect2 *p_self, const godot_vector2 *p_point);
+	godot_rect2 (*godot_rect2_grow)(const godot_rect2 *p_self, const godot_real p_by);
+	godot_rect2 (*godot_rect2_expand)(const godot_rect2 *p_self, const godot_vector2 *p_to);
+	godot_bool (*godot_rect2_operator_equal)(const godot_rect2 *p_self, const godot_rect2 *p_b);
+	godot_vector2 (*godot_rect2_get_position)(const godot_rect2 *p_self);
+	godot_vector2 (*godot_rect2_get_size)(const godot_rect2 *p_self);
+	void (*godot_rect2_set_position)(godot_rect2 *p_self, const godot_vector2 *p_pos);
+	void (*godot_rect2_set_size)(godot_rect2 *p_self, const godot_vector2 *p_size);
+	void (*godot_aabb_new)(godot_aabb *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size);
+	godot_vector3 (*godot_aabb_get_position)(const godot_aabb *p_self);
+	void (*godot_aabb_set_position)(const godot_aabb *p_self, const godot_vector3 *p_v);
+	godot_vector3 (*godot_aabb_get_size)(const godot_aabb *p_self);
+	void (*godot_aabb_set_size)(const godot_aabb *p_self, const godot_vector3 *p_v);
+	godot_string (*godot_aabb_as_string)(const godot_aabb *p_self);
+	godot_real (*godot_aabb_get_area)(const godot_aabb *p_self);
+	godot_bool (*godot_aabb_has_no_area)(const godot_aabb *p_self);
+	godot_bool (*godot_aabb_has_no_surface)(const godot_aabb *p_self);
+	godot_bool (*godot_aabb_intersects)(const godot_aabb *p_self, const godot_aabb *p_with);
+	godot_bool (*godot_aabb_encloses)(const godot_aabb *p_self, const godot_aabb *p_with);
+	godot_aabb (*godot_aabb_merge)(const godot_aabb *p_self, const godot_aabb *p_with);
+	godot_aabb (*godot_aabb_intersection)(const godot_aabb *p_self, const godot_aabb *p_with);
+	godot_bool (*godot_aabb_intersects_plane)(const godot_aabb *p_self, const godot_plane *p_plane);
+	godot_bool (*godot_aabb_intersects_segment)(const godot_aabb *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to);
+	godot_bool (*godot_aabb_has_point)(const godot_aabb *p_self, const godot_vector3 *p_point);
+	godot_vector3 (*godot_aabb_get_support)(const godot_aabb *p_self, const godot_vector3 *p_dir);
+	godot_vector3 (*godot_aabb_get_longest_axis)(const godot_aabb *p_self);
+	godot_int (*godot_aabb_get_longest_axis_index)(const godot_aabb *p_self);
+	godot_real (*godot_aabb_get_longest_axis_size)(const godot_aabb *p_self);
+	godot_vector3 (*godot_aabb_get_shortest_axis)(const godot_aabb *p_self);
+	godot_int (*godot_aabb_get_shortest_axis_index)(const godot_aabb *p_self);
+	godot_real (*godot_aabb_get_shortest_axis_size)(const godot_aabb *p_self);
+	godot_aabb (*godot_aabb_expand)(const godot_aabb *p_self, const godot_vector3 *p_to_point);
+	godot_aabb (*godot_aabb_grow)(const godot_aabb *p_self, const godot_real p_by);
+	godot_vector3 (*godot_aabb_get_endpoint)(const godot_aabb *p_self, const godot_int p_idx);
+	godot_bool (*godot_aabb_operator_equal)(const godot_aabb *p_self, const godot_aabb *p_b);
+	void (*godot_rid_new)(godot_rid *r_dest);
+	godot_int (*godot_rid_get_id)(const godot_rid *p_self);
+	void (*godot_rid_new_with_resource)(godot_rid *r_dest, const godot_object *p_from);
+	godot_bool (*godot_rid_operator_equal)(const godot_rid *p_self, const godot_rid *p_b);
+	godot_bool (*godot_rid_operator_less)(const godot_rid *p_self, const godot_rid *p_b);
+	void (*godot_transform_new_with_axis_origin)(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin);
+	void (*godot_transform_new)(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin);
+	godot_basis (*godot_transform_get_basis)(const godot_transform *p_self);
+	void (*godot_transform_set_basis)(godot_transform *p_self, const godot_basis *p_v);
+	godot_vector3 (*godot_transform_get_origin)(const godot_transform *p_self);
+	void (*godot_transform_set_origin)(godot_transform *p_self, const godot_vector3 *p_v);
+	godot_string (*godot_transform_as_string)(const godot_transform *p_self);
+	godot_transform (*godot_transform_inverse)(const godot_transform *p_self);
+	godot_transform (*godot_transform_affine_inverse)(const godot_transform *p_self);
+	godot_transform (*godot_transform_orthonormalized)(const godot_transform *p_self);
+	godot_transform (*godot_transform_rotated)(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
+	godot_transform (*godot_transform_scaled)(const godot_transform *p_self, const godot_vector3 *p_scale);
+	godot_transform (*godot_transform_translated)(const godot_transform *p_self, const godot_vector3 *p_ofs);
+	godot_transform (*godot_transform_looking_at)(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up);
+	godot_plane (*godot_transform_xform_plane)(const godot_transform *p_self, const godot_plane *p_v);
+	godot_plane (*godot_transform_xform_inv_plane)(const godot_transform *p_self, const godot_plane *p_v);
+	void (*godot_transform_new_identity)(godot_transform *r_dest);
+	godot_bool (*godot_transform_operator_equal)(const godot_transform *p_self, const godot_transform *p_b);
+	godot_transform (*godot_transform_operator_multiply)(const godot_transform *p_self, const godot_transform *p_b);
+	godot_vector3 (*godot_transform_xform_vector3)(const godot_transform *p_self, const godot_vector3 *p_v);
+	godot_vector3 (*godot_transform_xform_inv_vector3)(const godot_transform *p_self, const godot_vector3 *p_v);
+	godot_aabb (*godot_transform_xform_aabb)(const godot_transform *p_self, const godot_aabb *p_v);
+	godot_aabb (*godot_transform_xform_inv_aabb)(const godot_transform *p_self, const godot_aabb *p_v);
+	void (*godot_transform2d_new)(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos);
+	void (*godot_transform2d_new_axis_origin)(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin);
+	godot_string (*godot_transform2d_as_string)(const godot_transform2d *p_self);
+	godot_transform2d (*godot_transform2d_inverse)(const godot_transform2d *p_self);
+	godot_transform2d (*godot_transform2d_affine_inverse)(const godot_transform2d *p_self);
+	godot_real (*godot_transform2d_get_rotation)(const godot_transform2d *p_self);
+	godot_vector2 (*godot_transform2d_get_origin)(const godot_transform2d *p_self);
+	godot_vector2 (*godot_transform2d_get_scale)(const godot_transform2d *p_self);
+	godot_transform2d (*godot_transform2d_orthonormalized)(const godot_transform2d *p_self);
+	godot_transform2d (*godot_transform2d_rotated)(const godot_transform2d *p_self, const godot_real p_phi);
+	godot_transform2d (*godot_transform2d_scaled)(const godot_transform2d *p_self, const godot_vector2 *p_scale);
+	godot_transform2d (*godot_transform2d_translated)(const godot_transform2d *p_self, const godot_vector2 *p_offset);
+	godot_vector2 (*godot_transform2d_xform_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
+	godot_vector2 (*godot_transform2d_xform_inv_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
+	godot_vector2 (*godot_transform2d_basis_xform_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
+	godot_vector2 (*godot_transform2d_basis_xform_inv_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
+	godot_transform2d (*godot_transform2d_interpolate_with)(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c);
+	godot_bool (*godot_transform2d_operator_equal)(const godot_transform2d *p_self, const godot_transform2d *p_b);
+	godot_transform2d (*godot_transform2d_operator_multiply)(const godot_transform2d *p_self, const godot_transform2d *p_b);
+	void (*godot_transform2d_new_identity)(godot_transform2d *r_dest);
+	godot_rect2 (*godot_transform2d_xform_rect2)(const godot_transform2d *p_self, const godot_rect2 *p_v);
+	godot_rect2 (*godot_transform2d_xform_inv_rect2)(const godot_transform2d *p_self, const godot_rect2 *p_v);
+	godot_variant_type (*godot_variant_get_type)(const godot_variant *p_v);
+	void (*godot_variant_new_copy)(godot_variant *r_dest, const godot_variant *p_src);
+	void (*godot_variant_new_nil)(godot_variant *r_dest);
+	void (*godot_variant_new_bool)(godot_variant *r_dest, const godot_bool p_b);
+	void (*godot_variant_new_uint)(godot_variant *r_dest, const uint64_t p_i);
+	void (*godot_variant_new_int)(godot_variant *r_dest, const int64_t p_i);
+	void (*godot_variant_new_real)(godot_variant *r_dest, const double p_r);
+	void (*godot_variant_new_string)(godot_variant *r_dest, const godot_string *p_s);
+	void (*godot_variant_new_vector2)(godot_variant *r_dest, const godot_vector2 *p_v2);
+	void (*godot_variant_new_rect2)(godot_variant *r_dest, const godot_rect2 *p_rect2);
+	void (*godot_variant_new_vector3)(godot_variant *r_dest, const godot_vector3 *p_v3);
+	void (*godot_variant_new_transform2d)(godot_variant *r_dest, const godot_transform2d *p_t2d);
+	void (*godot_variant_new_plane)(godot_variant *r_dest, const godot_plane *p_plane);
+	void (*godot_variant_new_quat)(godot_variant *r_dest, const godot_quat *p_quat);
+	void (*godot_variant_new_aabb)(godot_variant *r_dest, const godot_aabb *p_aabb);
+	void (*godot_variant_new_basis)(godot_variant *r_dest, const godot_basis *p_basis);
+	void (*godot_variant_new_transform)(godot_variant *r_dest, const godot_transform *p_trans);
+	void (*godot_variant_new_color)(godot_variant *r_dest, const godot_color *p_color);
+	void (*godot_variant_new_node_path)(godot_variant *r_dest, const godot_node_path *p_np);
+	void (*godot_variant_new_rid)(godot_variant *r_dest, const godot_rid *p_rid);
+	void (*godot_variant_new_object)(godot_variant *r_dest, const godot_object *p_obj);
+	void (*godot_variant_new_dictionary)(godot_variant *r_dest, const godot_dictionary *p_dict);
+	void (*godot_variant_new_array)(godot_variant *r_dest, const godot_array *p_arr);
+	void (*godot_variant_new_pool_byte_array)(godot_variant *r_dest, const godot_pool_byte_array *p_pba);
+	void (*godot_variant_new_pool_int_array)(godot_variant *r_dest, const godot_pool_int_array *p_pia);
+	void (*godot_variant_new_pool_real_array)(godot_variant *r_dest, const godot_pool_real_array *p_pra);
+	void (*godot_variant_new_pool_string_array)(godot_variant *r_dest, const godot_pool_string_array *p_psa);
+	void (*godot_variant_new_pool_vector2_array)(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a);
+	void (*godot_variant_new_pool_vector3_array)(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a);
+	void (*godot_variant_new_pool_color_array)(godot_variant *r_dest, const godot_pool_color_array *p_pca);
+	godot_bool (*godot_variant_as_bool)(const godot_variant *p_self);
+	uint64_t (*godot_variant_as_uint)(const godot_variant *p_self);
+	int64_t (*godot_variant_as_int)(const godot_variant *p_self);
+	double (*godot_variant_as_real)(const godot_variant *p_self);
+	godot_string (*godot_variant_as_string)(const godot_variant *p_self);
+	godot_vector2 (*godot_variant_as_vector2)(const godot_variant *p_self);
+	godot_rect2 (*godot_variant_as_rect2)(const godot_variant *p_self);
+	godot_vector3 (*godot_variant_as_vector3)(const godot_variant *p_self);
+	godot_transform2d (*godot_variant_as_transform2d)(const godot_variant *p_self);
+	godot_plane (*godot_variant_as_plane)(const godot_variant *p_self);
+	godot_quat (*godot_variant_as_quat)(const godot_variant *p_self);
+	godot_aabb (*godot_variant_as_aabb)(const godot_variant *p_self);
+	godot_basis (*godot_variant_as_basis)(const godot_variant *p_self);
+	godot_transform (*godot_variant_as_transform)(const godot_variant *p_self);
+	godot_color (*godot_variant_as_color)(const godot_variant *p_self);
+	godot_node_path (*godot_variant_as_node_path)(const godot_variant *p_self);
+	godot_rid (*godot_variant_as_rid)(const godot_variant *p_self);
+	godot_object *(*godot_variant_as_object)(const godot_variant *p_self);
+	godot_dictionary (*godot_variant_as_dictionary)(const godot_variant *p_self);
+	godot_array (*godot_variant_as_array)(const godot_variant *p_self);
+	godot_pool_byte_array (*godot_variant_as_pool_byte_array)(const godot_variant *p_self);
+	godot_pool_int_array (*godot_variant_as_pool_int_array)(const godot_variant *p_self);
+	godot_pool_real_array (*godot_variant_as_pool_real_array)(const godot_variant *p_self);
+	godot_pool_string_array (*godot_variant_as_pool_string_array)(const godot_variant *p_self);
+	godot_pool_vector2_array (*godot_variant_as_pool_vector2_array)(const godot_variant *p_self);
+	godot_pool_vector3_array (*godot_variant_as_pool_vector3_array)(const godot_variant *p_self);
+	godot_pool_color_array (*godot_variant_as_pool_color_array)(const godot_variant *p_self);
+	godot_variant (*godot_variant_call)(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error);
+	godot_bool (*godot_variant_has_method)(const godot_variant *p_self, const godot_string *p_method);
+	godot_bool (*godot_variant_operator_equal)(const godot_variant *p_self, const godot_variant *p_other);
+	godot_bool (*godot_variant_operator_less)(const godot_variant *p_self, const godot_variant *p_other);
+	godot_bool (*godot_variant_hash_compare)(const godot_variant *p_self, const godot_variant *p_other);
+	godot_bool (*godot_variant_booleanize)(const godot_variant *p_self);
+	void (*godot_variant_destroy)(godot_variant *p_self);
+	godot_int (*godot_char_string_length)(const godot_char_string *p_cs);
+	const char *(*godot_char_string_get_data)(const godot_char_string *p_cs);
+	void (*godot_char_string_destroy)(godot_char_string *p_cs);
+	void (*godot_string_new)(godot_string *r_dest);
+	void (*godot_string_new_copy)(godot_string *r_dest, const godot_string *p_src);
+	void (*godot_string_new_with_wide_string)(godot_string *r_dest, const wchar_t *p_contents, const int p_size);
+	const wchar_t *(*godot_string_operator_index)(godot_string *p_self, const godot_int p_idx);
+	wchar_t (*godot_string_operator_index_const)(const godot_string *p_self, const godot_int p_idx);
+	const wchar_t *(*godot_string_wide_str)(const godot_string *p_self);
+	godot_bool (*godot_string_operator_equal)(const godot_string *p_self, const godot_string *p_b);
+	godot_bool (*godot_string_operator_less)(const godot_string *p_self, const godot_string *p_b);
+	godot_string (*godot_string_operator_plus)(const godot_string *p_self, const godot_string *p_b);
+	godot_int (*godot_string_length)(const godot_string *p_self);
+	signed char (*godot_string_casecmp_to)(const godot_string *p_self, const godot_string *p_str);
+	signed char (*godot_string_nocasecmp_to)(const godot_string *p_self, const godot_string *p_str);
+	signed char (*godot_string_naturalnocasecmp_to)(const godot_string *p_self, const godot_string *p_str);
+	godot_bool (*godot_string_begins_with)(const godot_string *p_self, const godot_string *p_string);
+	godot_bool (*godot_string_begins_with_char_array)(const godot_string *p_self, const char *p_char_array);
+	godot_array (*godot_string_bigrams)(const godot_string *p_self);
+	godot_string (*godot_string_chr)(wchar_t p_character);
+	godot_bool (*godot_string_ends_with)(const godot_string *p_self, const godot_string *p_string);
+	godot_int (*godot_string_find)(const godot_string *p_self, godot_string p_what);
+	godot_int (*godot_string_find_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
+	godot_int (*godot_string_findmk)(const godot_string *p_self, const godot_array *p_keys);
+	godot_int (*godot_string_findmk_from)(const godot_string *p_self, const godot_array *p_keys, godot_int p_from);
+	godot_int (*godot_string_findmk_from_in_place)(const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key);
+	godot_int (*godot_string_findn)(const godot_string *p_self, godot_string p_what);
+	godot_int (*godot_string_findn_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
+	godot_int (*godot_string_find_last)(const godot_string *p_self, godot_string p_what);
+	godot_string (*godot_string_format)(const godot_string *p_self, const godot_variant *p_values);
+	godot_string (*godot_string_format_with_custom_placeholder)(const godot_string *p_self, const godot_variant *p_values, const char *p_placeholder);
+	godot_string (*godot_string_hex_encode_buffer)(const uint8_t *p_buffer, godot_int p_len);
+	godot_int (*godot_string_hex_to_int)(const godot_string *p_self);
+	godot_int (*godot_string_hex_to_int_without_prefix)(const godot_string *p_self);
+	godot_string (*godot_string_insert)(const godot_string *p_self, godot_int p_at_pos, godot_string p_string);
+	godot_bool (*godot_string_is_numeric)(const godot_string *p_self);
+	godot_bool (*godot_string_is_subsequence_of)(const godot_string *p_self, const godot_string *p_string);
+	godot_bool (*godot_string_is_subsequence_ofi)(const godot_string *p_self, const godot_string *p_string);
+	godot_string (*godot_string_lpad)(const godot_string *p_self, godot_int p_min_length);
+	godot_string (*godot_string_lpad_with_custom_character)(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+	godot_bool (*godot_string_match)(const godot_string *p_self, const godot_string *p_wildcard);
+	godot_bool (*godot_string_matchn)(const godot_string *p_self, const godot_string *p_wildcard);
+	godot_string (*godot_string_md5)(const uint8_t *p_md5);
+	godot_string (*godot_string_num)(double p_num);
+	godot_string (*godot_string_num_int64)(int64_t p_num, godot_int p_base);
+	godot_string (*godot_string_num_int64_capitalized)(int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex);
+	godot_string (*godot_string_num_real)(double p_num);
+	godot_string (*godot_string_num_scientific)(double p_num);
+	godot_string (*godot_string_num_with_decimals)(double p_num, godot_int p_decimals);
+	godot_string (*godot_string_pad_decimals)(const godot_string *p_self, godot_int p_digits);
+	godot_string (*godot_string_pad_zeros)(const godot_string *p_self, godot_int p_digits);
+	godot_string (*godot_string_replace_first)(const godot_string *p_self, godot_string p_key, godot_string p_with);
+	godot_string (*godot_string_replace)(const godot_string *p_self, godot_string p_key, godot_string p_with);
+	godot_string (*godot_string_replacen)(const godot_string *p_self, godot_string p_key, godot_string p_with);
+	godot_int (*godot_string_rfind)(const godot_string *p_self, godot_string p_what);
+	godot_int (*godot_string_rfindn)(const godot_string *p_self, godot_string p_what);
+	godot_int (*godot_string_rfind_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
+	godot_int (*godot_string_rfindn_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
+	godot_string (*godot_string_rpad)(const godot_string *p_self, godot_int p_min_length);
+	godot_string (*godot_string_rpad_with_custom_character)(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+	godot_real (*godot_string_similarity)(const godot_string *p_self, const godot_string *p_string);
+	godot_string (*godot_string_sprintf)(const godot_string *p_self, const godot_array *p_values, godot_bool *p_error);
+	godot_string (*godot_string_substr)(const godot_string *p_self, godot_int p_from, godot_int p_chars);
+	double (*godot_string_to_double)(const godot_string *p_self);
+	godot_real (*godot_string_to_float)(const godot_string *p_self);
+	godot_int (*godot_string_to_int)(const godot_string *p_self);
+	godot_string (*godot_string_camelcase_to_underscore)(const godot_string *p_self);
+	godot_string (*godot_string_camelcase_to_underscore_lowercased)(const godot_string *p_self);
+	godot_string (*godot_string_capitalize)(const godot_string *p_self);
+	double (*godot_string_char_to_double)(const char *p_what);
+	godot_int (*godot_string_char_to_int)(const char *p_what);
+	int64_t (*godot_string_wchar_to_int)(const wchar_t *p_str);
+	godot_int (*godot_string_char_to_int_with_len)(const char *p_what, godot_int p_len);
+	int64_t (*godot_string_char_to_int64_with_len)(const wchar_t *p_str, int p_len);
+	int64_t (*godot_string_hex_to_int64)(const godot_string *p_self);
+	int64_t (*godot_string_hex_to_int64_with_prefix)(const godot_string *p_self);
+	int64_t (*godot_string_to_int64)(const godot_string *p_self);
+	double (*godot_string_unicode_char_to_double)(const wchar_t *p_str, const wchar_t **r_end);
+	godot_int (*godot_string_get_slice_count)(const godot_string *p_self, godot_string p_splitter);
+	godot_string (*godot_string_get_slice)(const godot_string *p_self, godot_string p_splitter, godot_int p_slice);
+	godot_string (*godot_string_get_slicec)(const godot_string *p_self, wchar_t p_splitter, godot_int p_slice);
+	godot_array (*godot_string_split)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_allow_empty)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_floats)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_floats_allows_empty)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_floats_mk)(const godot_string *p_self, const godot_array *p_splitters);
+	godot_array (*godot_string_split_floats_mk_allows_empty)(const godot_string *p_self, const godot_array *p_splitters);
+	godot_array (*godot_string_split_ints)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_ints_allows_empty)(const godot_string *p_self, const godot_string *p_splitter);
+	godot_array (*godot_string_split_ints_mk)(const godot_string *p_self, const godot_array *p_splitters);
+	godot_array (*godot_string_split_ints_mk_allows_empty)(const godot_string *p_self, const godot_array *p_splitters);
+	godot_array (*godot_string_split_spaces)(const godot_string *p_self);
+	wchar_t (*godot_string_char_lowercase)(wchar_t p_char);
+	wchar_t (*godot_string_char_uppercase)(wchar_t p_char);
+	godot_string (*godot_string_to_lower)(const godot_string *p_self);
+	godot_string (*godot_string_to_upper)(const godot_string *p_self);
+	godot_string (*godot_string_get_basename)(const godot_string *p_self);
+	godot_string (*godot_string_get_extension)(const godot_string *p_self);
+	godot_string (*godot_string_left)(const godot_string *p_self, godot_int p_pos);
+	wchar_t (*godot_string_ord_at)(const godot_string *p_self, godot_int p_idx);
+	godot_string (*godot_string_plus_file)(const godot_string *p_self, const godot_string *p_file);
+	godot_string (*godot_string_right)(const godot_string *p_self, godot_int p_pos);
+	godot_string (*godot_string_strip_edges)(const godot_string *p_self, godot_bool p_left, godot_bool p_right);
+	godot_string (*godot_string_strip_escapes)(const godot_string *p_self);
+	void (*godot_string_erase)(godot_string *p_self, godot_int p_pos, godot_int p_chars);
+	godot_char_string (*godot_string_ascii)(const godot_string *p_self);
+	godot_char_string (*godot_string_ascii_extended)(const godot_string *p_self);
+	godot_char_string (*godot_string_utf8)(const godot_string *p_self);
+	godot_bool (*godot_string_parse_utf8)(godot_string *p_self, const char *p_utf8);
+	godot_bool (*godot_string_parse_utf8_with_len)(godot_string *p_self, const char *p_utf8, godot_int p_len);
+	godot_string (*godot_string_chars_to_utf8)(const char *p_utf8);
+	godot_string (*godot_string_chars_to_utf8_with_len)(const char *p_utf8, godot_int p_len);
+	uint32_t (*godot_string_hash)(const godot_string *p_self);
+	uint64_t (*godot_string_hash64)(const godot_string *p_self);
+	uint32_t (*godot_string_hash_chars)(const char *p_cstr);
+	uint32_t (*godot_string_hash_chars_with_len)(const char *p_cstr, godot_int p_len);
+	uint32_t (*godot_string_hash_utf8_chars)(const wchar_t *p_str);
+	uint32_t (*godot_string_hash_utf8_chars_with_len)(const wchar_t *p_str, godot_int p_len);
+	godot_pool_byte_array (*godot_string_md5_buffer)(const godot_string *p_self);
+	godot_string (*godot_string_md5_text)(const godot_string *p_self);
+	godot_pool_byte_array (*godot_string_sha256_buffer)(const godot_string *p_self);
+	godot_string (*godot_string_sha256_text)(const godot_string *p_self);
+	godot_bool (*godot_string_empty)(const godot_string *p_self);
+	godot_string (*godot_string_get_base_dir)(const godot_string *p_self);
+	godot_string (*godot_string_get_file)(const godot_string *p_self);
+	godot_string (*godot_string_humanize_size)(size_t p_size);
+	godot_bool (*godot_string_is_abs_path)(const godot_string *p_self);
+	godot_bool (*godot_string_is_rel_path)(const godot_string *p_self);
+	godot_bool (*godot_string_is_resource_file)(const godot_string *p_self);
+	godot_string (*godot_string_path_to)(const godot_string *p_self, const godot_string *p_path);
+	godot_string (*godot_string_path_to_file)(const godot_string *p_self, const godot_string *p_path);
+	godot_string (*godot_string_simplify_path)(const godot_string *p_self);
+	godot_string (*godot_string_c_escape)(const godot_string *p_self);
+	godot_string (*godot_string_c_escape_multiline)(const godot_string *p_self);
+	godot_string (*godot_string_c_unescape)(const godot_string *p_self);
+	godot_string (*godot_string_http_escape)(const godot_string *p_self);
+	godot_string (*godot_string_http_unescape)(const godot_string *p_self);
+	godot_string (*godot_string_json_escape)(const godot_string *p_self);
+	godot_string (*godot_string_word_wrap)(const godot_string *p_self, godot_int p_chars_per_line);
+	godot_string (*godot_string_xml_escape)(const godot_string *p_self);
+	godot_string (*godot_string_xml_escape_with_quotes)(const godot_string *p_self);
+	godot_string (*godot_string_xml_unescape)(const godot_string *p_self);
+	godot_string (*godot_string_percent_decode)(const godot_string *p_self);
+	godot_string (*godot_string_percent_encode)(const godot_string *p_self);
+	godot_bool (*godot_string_is_valid_float)(const godot_string *p_self);
+	godot_bool (*godot_string_is_valid_hex_number)(const godot_string *p_self, godot_bool p_with_prefix);
+	godot_bool (*godot_string_is_valid_html_color)(const godot_string *p_self);
+	godot_bool (*godot_string_is_valid_identifier)(const godot_string *p_self);
+	godot_bool (*godot_string_is_valid_integer)(const godot_string *p_self);
+	godot_bool (*godot_string_is_valid_ip_address)(const godot_string *p_self);
+	void (*godot_string_destroy)(godot_string *p_self);
+	void (*godot_string_name_new)(godot_string_name *r_dest, const godot_string *p_name);
+	void (*godot_string_name_new_data)(godot_string_name *r_dest, const char *p_name);
+	godot_string (*godot_string_name_get_name)(const godot_string_name *p_self);
+	uint32_t (*godot_string_name_get_hash)(const godot_string_name *p_self);
+	const void *(*godot_string_name_get_data_unique_pointer)(const godot_string_name *p_self);
+	godot_bool (*godot_string_name_operator_equal)(const godot_string_name *p_self, const godot_string_name *p_other);
+	godot_bool (*godot_string_name_operator_less)(const godot_string_name *p_self, const godot_string_name *p_other);
+	void (*godot_string_name_destroy)(godot_string_name *p_self);
+	void (*godot_object_destroy)(godot_object *p_o);
+	godot_object *(*godot_global_get_singleton)(char *p_name);
+	godot_method_bind *(*godot_method_bind_get_method)(const char *p_classname, const char *p_methodname);
+	void (*godot_method_bind_ptrcall)(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret);
+	godot_variant (*godot_method_bind_call)(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error);
+	godot_class_constructor (*godot_get_class_constructor)(const char *p_classname);
+	godot_dictionary (*godot_get_global_constants)();
+	void (*godot_register_native_call_type)(const char *call_type, native_call_cb p_callback);
+	void *(*godot_alloc)(int p_bytes);
+	void *(*godot_realloc)(void *p_ptr, int p_bytes);
+	void (*godot_free)(void *p_ptr);
+	void (*godot_print_error)(const char *p_description, const char *p_function, const char *p_file, int p_line);
+	void (*godot_print_warning)(const char *p_description, const char *p_function, const char *p_file, int p_line);
+	void (*godot_print)(const godot_string *p_message);
+} godot_gdnative_core_api_struct;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_GDNATIVE_API_STRUCT_H

GodoBinding/godot_headers/nativescript/godot_nativescript.h

@@ -0,0 +1,250 @@
+/*************************************************************************/
+/*  godot_nativescript.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NATIVESCRIPT_H
+#define GODOT_NATIVESCRIPT_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	GODOT_METHOD_RPC_MODE_DISABLED,
+	GODOT_METHOD_RPC_MODE_REMOTE,
+	GODOT_METHOD_RPC_MODE_MASTER,
+	GODOT_METHOD_RPC_MODE_PUPPET,
+	GODOT_METHOD_RPC_MODE_SLAVE = GODOT_METHOD_RPC_MODE_PUPPET,
+	GODOT_METHOD_RPC_MODE_REMOTESYNC,
+	GODOT_METHOD_RPC_MODE_SYNC = GODOT_METHOD_RPC_MODE_REMOTESYNC,
+	GODOT_METHOD_RPC_MODE_MASTERSYNC,
+	GODOT_METHOD_RPC_MODE_PUPPETSYNC,
+} godot_method_rpc_mode;
+
+typedef enum {
+	GODOT_PROPERTY_HINT_NONE, ///< no hint provided.
+	GODOT_PROPERTY_HINT_RANGE, ///< hint_text = "min,max,step,slider; //slider is optional"
+	GODOT_PROPERTY_HINT_EXP_RANGE, ///< hint_text = "min,max,step", exponential edit
+	GODOT_PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc"
+	GODOT_PROPERTY_HINT_EXP_EASING, /// exponential easing function (Math::ease)
+	GODOT_PROPERTY_HINT_LENGTH, ///< hint_text= "length" (as integer)
+	GODOT_PROPERTY_HINT_SPRITE_FRAME, // FIXME: Obsolete: drop whenever we can break compat
+	GODOT_PROPERTY_HINT_KEY_ACCEL, ///< hint_text= "length" (as integer)
+	GODOT_PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags)
+	GODOT_PROPERTY_HINT_LAYERS_2D_RENDER,
+	GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS,
+	GODOT_PROPERTY_HINT_LAYERS_3D_RENDER,
+	GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS,
+	GODOT_PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	GODOT_PROPERTY_HINT_DIR, ///< a directory path must be passed
+	GODOT_PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	GODOT_PROPERTY_HINT_GLOBAL_DIR, ///< a directory path must be passed
+	GODOT_PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type
+	GODOT_PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines
+	GODOT_PROPERTY_HINT_PLACEHOLDER_TEXT, ///< used to set a placeholder text for string properties
+	GODOT_PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color
+	GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY,
+	GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS,
+	GODOT_PROPERTY_HINT_OBJECT_ID,
+	GODOT_PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose
+	GODOT_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, ///< so something else can provide this (used in scripts)
+	GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE, ///< a method of a type
+	GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE, ///< a method of a base type
+	GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE, ///< a method of an instance
+	GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT, ///< a method of a script & base
+	GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE, ///< a property of a type
+	GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE, ///< a property of a base type
+	GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE, ///< a property of an instance
+	GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT, ///< a property of a script & base
+	GODOT_PROPERTY_HINT_MAX,
+} godot_property_hint;
+
+typedef enum {
+
+	GODOT_PROPERTY_USAGE_STORAGE = 1,
+	GODOT_PROPERTY_USAGE_EDITOR = 2,
+	GODOT_PROPERTY_USAGE_NETWORK = 4,
+	GODOT_PROPERTY_USAGE_EDITOR_HELPER = 8,
+	GODOT_PROPERTY_USAGE_CHECKABLE = 16, //used for editing global variables
+	GODOT_PROPERTY_USAGE_CHECKED = 32, //used for editing global variables
+	GODOT_PROPERTY_USAGE_INTERNATIONALIZED = 64, //hint for internationalized strings
+	GODOT_PROPERTY_USAGE_GROUP = 128, //used for grouping props in the editor
+	GODOT_PROPERTY_USAGE_CATEGORY = 256,
+	GODOT_PROPERTY_USAGE_STORE_IF_NONZERO = 512, // FIXME: Obsolete: drop whenever we can break compat
+	GODOT_PROPERTY_USAGE_STORE_IF_NONONE = 1024, // FIXME: Obsolete: drop whenever we can break compat
+	GODOT_PROPERTY_USAGE_NO_INSTANCE_STATE = 2048,
+	GODOT_PROPERTY_USAGE_RESTART_IF_CHANGED = 4096,
+	GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE = 8192,
+	GODOT_PROPERTY_USAGE_STORE_IF_NULL = 16384,
+	GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 32768,
+	GODOT_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 65536,
+
+	GODOT_PROPERTY_USAGE_DEFAULT = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK,
+	GODOT_PROPERTY_USAGE_DEFAULT_INTL = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED,
+	GODOT_PROPERTY_USAGE_NOEDITOR = GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK,
+} godot_property_usage_flags;
+
+typedef struct {
+	godot_method_rpc_mode rset_type;
+
+	godot_int type;
+	godot_property_hint hint;
+	godot_string hint_string;
+	godot_property_usage_flags usage;
+	godot_variant default_value;
+} godot_property_attributes;
+
+typedef struct {
+	// instance pointer, method_data - return user data
+	GDCALLINGCONV void *(*create_func)(godot_object *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_create_func;
+
+typedef struct {
+	// instance pointer, method data, user data
+	GDCALLINGCONV void (*destroy_func)(godot_object *, void *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_destroy_func;
+
+void GDAPI godot_nativescript_register_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+
+void GDAPI godot_nativescript_register_tool_class(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
+
+typedef struct {
+	godot_method_rpc_mode rpc_type;
+} godot_method_attributes;
+
+typedef struct {
+	// instance pointer, method data, user data, num args, args - return result as varaint
+	GDCALLINGCONV godot_variant (*method)(godot_object *, void *, void *, int, godot_variant **);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_method;
+
+void GDAPI godot_nativescript_register_method(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method);
+
+typedef struct {
+	// instance pointer, method data, user data, value
+	GDCALLINGCONV void (*set_func)(godot_object *, void *, void *, godot_variant *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_property_set_func;
+
+typedef struct {
+	// instance pointer, method data, user data, value
+	GDCALLINGCONV godot_variant (*get_func)(godot_object *, void *, void *);
+	void *method_data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_property_get_func;
+
+void GDAPI godot_nativescript_register_property(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func);
+
+typedef struct {
+	godot_string name;
+	godot_int type;
+	godot_property_hint hint;
+	godot_string hint_string;
+	godot_property_usage_flags usage;
+	godot_variant default_value;
+} godot_signal_argument;
+
+typedef struct {
+	godot_string name;
+	int num_args;
+	godot_signal_argument *args;
+	int num_default_args;
+	godot_variant *default_args;
+} godot_signal;
+
+void GDAPI godot_nativescript_register_signal(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal);
+
+void GDAPI *godot_nativescript_get_userdata(godot_object *p_instance);
+
+/*
+ *
+ *
+ * NativeScript 1.1
+ *
+ *
+ */
+
+// method registering with argument names
+
+typedef struct {
+	godot_string name;
+
+	godot_variant_type type;
+	godot_property_hint hint;
+	godot_string hint_string;
+} godot_method_arg;
+
+void GDAPI godot_nativescript_set_method_argument_information(void *p_gdnative_handle, const char *p_name, const char *p_function_name, int p_num_args, const godot_method_arg *p_args);
+
+// documentation
+
+void GDAPI godot_nativescript_set_class_documentation(void *p_gdnative_handle, const char *p_name, godot_string p_documentation);
+void GDAPI godot_nativescript_set_method_documentation(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_string p_documentation);
+void GDAPI godot_nativescript_set_property_documentation(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_string p_documentation);
+void GDAPI godot_nativescript_set_signal_documentation(void *p_gdnative_handle, const char *p_name, const char *p_signal_name, godot_string p_documentation);
+
+// type tag API
+
+void GDAPI godot_nativescript_set_global_type_tag(int p_idx, const char *p_name, const void *p_type_tag);
+const void GDAPI *godot_nativescript_get_global_type_tag(int p_idx, const char *p_name);
+
+void GDAPI godot_nativescript_set_type_tag(void *p_gdnative_handle, const char *p_name, const void *p_type_tag);
+const void GDAPI *godot_nativescript_get_type_tag(const godot_object *p_object);
+
+// instance binding API
+
+typedef struct {
+	GDCALLINGCONV void *(*alloc_instance_binding_data)(void *, const void *, godot_object *);
+	GDCALLINGCONV void (*free_instance_binding_data)(void *, void *);
+	GDCALLINGCONV void (*refcount_incremented_instance_binding)(void *, godot_object *);
+	GDCALLINGCONV bool (*refcount_decremented_instance_binding)(void *, godot_object *);
+	void *data;
+	GDCALLINGCONV void (*free_func)(void *);
+} godot_instance_binding_functions;
+
+int GDAPI godot_nativescript_register_instance_binding_data_functions(godot_instance_binding_functions p_binding_functions);
+void GDAPI godot_nativescript_unregister_instance_binding_data_functions(int p_idx);
+
+void GDAPI *godot_nativescript_get_instance_binding_data(int p_idx, godot_object *p_object);
+
+void GDAPI godot_nativescript_profiling_add_data(const char *p_signature, uint64_t p_time);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

GodoBinding/godot_headers/net/godot_net.h

@@ -0,0 +1,121 @@
+/*************************************************************************/
+/*  godot_net.h                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NATIVENET_H
+#define GODOT_NATIVENET_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// For future versions of the API we should only add new functions at the end of the structure and use the
+// version info to detect whether a call is available
+
+// Use these to populate version in your plugin
+#define GODOT_NET_API_MAJOR 3
+#define GODOT_NET_API_MINOR 1
+
+typedef struct {
+
+	godot_gdnative_api_version version; /* version of our API */
+	godot_object *data; /* User reference */
+
+	/* This is StreamPeer */
+	godot_error (*get_data)(void *user, uint8_t *p_buffer, int p_bytes);
+	godot_error (*get_partial_data)(void *user, uint8_t *p_buffer, int p_bytes, int *r_received);
+	godot_error (*put_data)(void *user, const uint8_t *p_data, int p_bytes);
+	godot_error (*put_partial_data)(void *user, const uint8_t *p_data, int p_bytes, int *r_sent);
+
+	int (*get_available_bytes)(const void *user);
+
+	void *next; /* For extension? */
+} godot_net_stream_peer;
+
+/* Binds a StreamPeerGDNative to the provided interface */
+void godot_net_bind_stream_peer(godot_object *p_obj, const godot_net_stream_peer *p_interface);
+
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+
+	godot_object *data; /* User reference */
+
+	/* This is PacketPeer */
+	godot_error (*get_packet)(void *, const uint8_t **, int *);
+	godot_error (*put_packet)(void *, const uint8_t *, int);
+	godot_int (*get_available_packet_count)(const void *);
+	godot_int (*get_max_packet_size)(const void *);
+
+	void *next; /* For extension? */
+} godot_net_packet_peer;
+
+/* Binds a PacketPeerGDNative to the provided interface */
+void GDAPI godot_net_bind_packet_peer(godot_object *p_obj, const godot_net_packet_peer *);
+
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+
+	godot_object *data; /* User reference */
+
+	/* This is PacketPeer */
+	godot_error (*get_packet)(void *, const uint8_t **, int *);
+	godot_error (*put_packet)(void *, const uint8_t *, int);
+	godot_int (*get_available_packet_count)(const void *);
+	godot_int (*get_max_packet_size)(const void *);
+
+	/* This is NetworkedMultiplayerPeer */
+	void (*set_transfer_mode)(void *, godot_int);
+	godot_int (*get_transfer_mode)(const void *);
+	// 0 = broadcast, 1 = server, <0 = all but abs(value)
+	void (*set_target_peer)(void *, godot_int);
+	godot_int (*get_packet_peer)(const void *);
+	godot_bool (*is_server)(const void *);
+	void (*poll)(void *);
+	// Must be > 0, 1 is for server
+	int32_t (*get_unique_id)(const void *);
+	void (*set_refuse_new_connections)(void *, godot_bool);
+	godot_bool (*is_refusing_new_connections)(const void *);
+	godot_int (*get_connection_status)(const void *);
+
+	void *next; /* For extension? Or maybe not... */
+} godot_net_multiplayer_peer;
+
+/* Binds a MultiplayerPeerGDNative to the provided interface */
+void GDAPI godot_net_bind_multiplayer_peer(godot_object *p_obj, const godot_net_multiplayer_peer *);
+
+#ifdef __cplusplus
+}
+#endif
+
+// WebRTC Bindings
+#include "net/godot_webrtc.h"
+
+#endif /* GODOT_NATIVENET_H */

GodoBinding/godot_headers/net/godot_webrtc.h

@@ -0,0 +1,122 @@
+/*************************************************************************/
+/*  godot_webrtc.h                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NATIVEWEBRTC_H
+#define GODOT_NATIVEWEBRTC_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GODOT_NET_WEBRTC_API_MAJOR 3
+#define GODOT_NET_WEBRTC_API_MINOR 2
+
+/* Library Interface (used to set default GDNative WebRTC implementation */
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+
+	/* Called when the library is unset as default interface via godot_net_set_webrtc_library */
+	void (*unregistered)();
+
+	/* Used by WebRTCPeerConnection create when GDNative is the default implementation. */
+	/* Takes a pointer to WebRTCPeerConnectionGDNative, should bind and return OK, failure if binding was unsuccessful. */
+	godot_error (*create_peer_connection)(godot_object *);
+
+	void *next; /* For extension */
+} godot_net_webrtc_library;
+
+/* WebRTCPeerConnection interface */
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+
+	godot_object *data; /* User reference */
+
+	/* This is WebRTCPeerConnection */
+	godot_int (*get_connection_state)(const void *);
+
+	godot_error (*initialize)(void *, const godot_dictionary *);
+	godot_object *(*create_data_channel)(void *, const char *p_channel_name, const godot_dictionary *);
+	godot_error (*create_offer)(void *);
+	godot_error (*create_answer)(void *); /* unused for now, should be done automatically on set_local_description */
+	godot_error (*set_remote_description)(void *, const char *, const char *);
+	godot_error (*set_local_description)(void *, const char *, const char *);
+	godot_error (*add_ice_candidate)(void *, const char *, int, const char *);
+	godot_error (*poll)(void *);
+	void (*close)(void *);
+
+	void *next; /* For extension? */
+} godot_net_webrtc_peer_connection;
+
+/* WebRTCDataChannel interface */
+typedef struct {
+	godot_gdnative_api_version version; /* version of our API */
+
+	godot_object *data; /* User reference */
+
+	/* This is PacketPeer */
+	godot_error (*get_packet)(void *, const uint8_t **, int *);
+	godot_error (*put_packet)(void *, const uint8_t *, int);
+	godot_int (*get_available_packet_count)(const void *);
+	godot_int (*get_max_packet_size)(const void *);
+
+	/* This is WebRTCDataChannel */
+	void (*set_write_mode)(void *, godot_int);
+	godot_int (*get_write_mode)(const void *);
+	bool (*was_string_packet)(const void *);
+
+	godot_int (*get_ready_state)(const void *);
+	const char *(*get_label)(const void *);
+	bool (*is_ordered)(const void *);
+	int (*get_id)(const void *);
+	int (*get_max_packet_life_time)(const void *);
+	int (*get_max_retransmits)(const void *);
+	const char *(*get_protocol)(const void *);
+	bool (*is_negotiated)(const void *);
+
+	godot_error (*poll)(void *);
+	void (*close)(void *);
+
+	void *next; /* For extension? */
+} godot_net_webrtc_data_channel;
+
+/* Set the default GDNative library */
+godot_error GDAPI godot_net_set_webrtc_library(const godot_net_webrtc_library *);
+/* Binds a WebRTCPeerConnectionGDNative to the provided interface */
+void GDAPI godot_net_bind_webrtc_peer_connection(godot_object *p_obj, const godot_net_webrtc_peer_connection *);
+/* Binds a WebRTCDataChannelGDNative to the provided interface */
+void GDAPI godot_net_bind_webrtc_data_channel(godot_object *p_obj, const godot_net_webrtc_data_channel *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

GodoBinding/godot_headers/pluginscript/godot_pluginscript.h

@@ -0,0 +1,172 @@
+/*************************************************************************/
+/*  godot_pluginscript.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_PLUGINSCRIPT_H
+#define GODOT_PLUGINSCRIPT_H
+
+#include <gdnative/gdnative.h>
+#include <nativescript/godot_nativescript.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void godot_pluginscript_instance_data;
+typedef void godot_pluginscript_script_data;
+typedef void godot_pluginscript_language_data;
+
+// --- Instance ---
+
+// TODO: use godot_string_name for faster lookup ?
+typedef struct {
+	godot_pluginscript_instance_data *(*init)(godot_pluginscript_script_data *p_data, godot_object *p_owner);
+	void (*finish)(godot_pluginscript_instance_data *p_data);
+
+	godot_bool (*set_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, const godot_variant *p_value);
+	godot_bool (*get_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, godot_variant *r_ret);
+
+	godot_variant (*call_method)(godot_pluginscript_instance_data *p_data,
+			const godot_string_name *p_method, const godot_variant **p_args,
+			int p_argcount, godot_variant_call_error *r_error);
+
+	void (*notification)(godot_pluginscript_instance_data *p_data, int p_notification);
+	// TODO: could this rpc mode stuff be moved to the godot_pluginscript_script_manifest ?
+	godot_method_rpc_mode (*get_rpc_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_method);
+	godot_method_rpc_mode (*get_rset_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_variable);
+
+	//this is used by script languages that keep a reference counter of their own
+	//you can make make Ref<> not die when it reaches zero, so deleting the reference
+	//depends entirely from the script.
+	// Note: You can set those function pointer to NULL if not needed.
+	void (*refcount_incremented)(godot_pluginscript_instance_data *p_data);
+	bool (*refcount_decremented)(godot_pluginscript_instance_data *p_data); // return true if it can die
+} godot_pluginscript_instance_desc;
+
+// --- Script ---
+
+typedef struct {
+	godot_pluginscript_script_data *data;
+	godot_string_name name;
+	godot_bool is_tool;
+	godot_string_name base;
+
+	// Member lines format: {<string>: <int>}
+	godot_dictionary member_lines;
+	// Method info dictionary format
+	// {
+	//  name: <string>
+	//  args: [<dict:property>]
+	//  default_args: [<variant>]
+	//  return: <dict:property>
+	//  flags: <int>
+	//  rpc_mode: <int:godot_method_rpc_mode>
+	// }
+	godot_array methods;
+	// Same format than for methods
+	godot_array signals;
+	// Property info dictionary format
+	// {
+	//  name: <string>
+	//  type: <int:godot_variant_type>
+	//  hint: <int:godot_property_hint>
+	//  hint_string: <string>
+	//  usage: <int:godot_property_usage_flags>
+	//  default_value: <variant>
+	//  rset_mode: <int:godot_method_rpc_mode>
+	// }
+	godot_array properties;
+} godot_pluginscript_script_manifest;
+
+typedef struct {
+	godot_pluginscript_script_manifest (*init)(godot_pluginscript_language_data *p_data, const godot_string *p_path, const godot_string *p_source, godot_error *r_error);
+	void (*finish)(godot_pluginscript_script_data *p_data);
+	godot_pluginscript_instance_desc instance_desc;
+} godot_pluginscript_script_desc;
+
+// --- Language ---
+
+typedef struct {
+	godot_string_name signature;
+	godot_int call_count;
+	godot_int total_time; // In microseconds
+	godot_int self_time; // In microseconds
+} godot_pluginscript_profiling_data;
+
+typedef struct {
+	const char *name;
+	const char *type;
+	const char *extension;
+	const char **recognized_extensions; // NULL terminated array
+	godot_pluginscript_language_data *(*init)();
+	void (*finish)(godot_pluginscript_language_data *p_data);
+	const char **reserved_words; // NULL terminated array
+	const char **comment_delimiters; // NULL terminated array
+	const char **string_delimiters; // NULL terminated array
+	godot_bool has_named_classes;
+	godot_bool supports_builtin_mode;
+
+	godot_string (*get_template_source_code)(godot_pluginscript_language_data *p_data, const godot_string *p_class_name, const godot_string *p_base_class_name);
+	godot_bool (*validate)(godot_pluginscript_language_data *p_data, const godot_string *p_script, int *r_line_error, int *r_col_error, godot_string *r_test_error, const godot_string *p_path, godot_pool_string_array *r_functions);
+	int (*find_function)(godot_pluginscript_language_data *p_data, const godot_string *p_function, const godot_string *p_code); // Can be NULL
+	godot_string (*make_function)(godot_pluginscript_language_data *p_data, const godot_string *p_class, const godot_string *p_name, const godot_pool_string_array *p_args);
+	godot_error (*complete_code)(godot_pluginscript_language_data *p_data, const godot_string *p_code, const godot_string *p_path, godot_object *p_owner, godot_array *r_options, godot_bool *r_force, godot_string *r_call_hint);
+	void (*auto_indent_code)(godot_pluginscript_language_data *p_data, godot_string *p_code, int p_from_line, int p_to_line);
+
+	void (*add_global_constant)(godot_pluginscript_language_data *p_data, const godot_string *p_variable, const godot_variant *p_value);
+	godot_string (*debug_get_error)(godot_pluginscript_language_data *p_data);
+	int (*debug_get_stack_level_count)(godot_pluginscript_language_data *p_data);
+	int (*debug_get_stack_level_line)(godot_pluginscript_language_data *p_data, int p_level);
+	godot_string (*debug_get_stack_level_function)(godot_pluginscript_language_data *p_data, int p_level);
+	godot_string (*debug_get_stack_level_source)(godot_pluginscript_language_data *p_data, int p_level);
+	void (*debug_get_stack_level_locals)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
+	void (*debug_get_stack_level_members)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_members, godot_array *p_values, int p_max_subitems, int p_max_depth);
+	void (*debug_get_globals)(godot_pluginscript_language_data *p_data, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
+	godot_string (*debug_parse_stack_level_expression)(godot_pluginscript_language_data *p_data, int p_level, const godot_string *p_expression, int p_max_subitems, int p_max_depth);
+
+	// TODO: could this stuff be moved to the godot_pluginscript_language_desc ?
+	void (*get_public_functions)(godot_pluginscript_language_data *p_data, godot_array *r_functions);
+	void (*get_public_constants)(godot_pluginscript_language_data *p_data, godot_dictionary *r_constants);
+
+	void (*profiling_start)(godot_pluginscript_language_data *p_data);
+	void (*profiling_stop)(godot_pluginscript_language_data *p_data);
+	int (*profiling_get_accumulated_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
+	int (*profiling_get_frame_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
+	void (*profiling_frame)(godot_pluginscript_language_data *p_data);
+
+	godot_pluginscript_script_desc script_desc;
+} godot_pluginscript_language_desc;
+
+void GDAPI godot_pluginscript_register_language(const godot_pluginscript_language_desc *language_desc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GODOT_PLUGINSCRIPT_H

GodoBinding/godot_headers/videodecoder/godot_videodecoder.h

@@ -0,0 +1,75 @@
+/*************************************************************************/
+/*  godot_videodecoder.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_NATIVEVIDEODECODER_H
+#define GODOT_NATIVEVIDEODECODER_H
+
+#include <gdnative/gdnative.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GODOTAV_API_MAJOR 0
+#define GODOTAV_API_MINOR 1
+
+typedef struct
+{
+	godot_gdnative_api_version version;
+	void *next;
+	void *(*constructor)(godot_object *);
+	void (*destructor)(void *);
+	const char *(*get_plugin_name)(void);
+	const char **(*get_supported_extensions)(int *count);
+	godot_bool (*open_file)(void *, void *); // data struct, and a FileAccess pointer
+	godot_real (*get_length)(const void *);
+	godot_real (*get_playback_position)(const void *);
+	void (*seek)(void *, godot_real);
+	void (*set_audio_track)(void *, godot_int);
+	void (*update)(void *, godot_real);
+	godot_pool_byte_array *(*get_videoframe)(void *);
+	godot_int (*get_audioframe)(void *, float *, int);
+	godot_int (*get_channels)(const void *);
+	godot_int (*get_mix_rate)(const void *);
+	godot_vector2 (*get_texture_size)(const void *);
+} godot_videodecoder_interface_gdnative;
+
+typedef int (*GDNativeAudioMixCallback)(void *, const float *, int);
+
+// FileAccess wrappers for custom FFmpeg IO
+godot_int GDAPI godot_videodecoder_file_read(void *file_ptr, uint8_t *buf, int buf_size);
+int64_t GDAPI godot_videodecoder_file_seek(void *file_ptr, int64_t pos, int whence);
+void GDAPI godot_videodecoder_register_decoder(const godot_videodecoder_interface_gdnative *p_interface);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GODOT_NATIVEVIDEODECODER_H */

GodoBinding/include/core/AABB.hpp

@@ -0,0 +1,82 @@
+#ifndef AABB_H
+#define AABB_H
+
+#include "Vector3.hpp"
+
+#include "Plane.hpp"
+
+#include <cstdlib>
+
+namespace godot {
+
+class AABB {
+public:
+	Vector3 position;
+	Vector3 size;
+
+	real_t get_area() const; /// get area
+	inline bool has_no_area() const {
+
+		return (size.x <= CMP_EPSILON || size.y <= CMP_EPSILON || size.z <= CMP_EPSILON);
+	}
+
+	inline bool has_no_surface() const {
+
+		return (size.x <= CMP_EPSILON && size.y <= CMP_EPSILON && size.z <= CMP_EPSILON);
+	}
+
+	inline const Vector3 &get_position() const { return position; }
+	inline void set_position(const Vector3 &p_position) { position = p_position; }
+	inline const Vector3 &get_size() const { return size; }
+	inline void set_size(const Vector3 &p_size) { size = p_size; }
+
+	bool operator==(const AABB &p_rval) const;
+	bool operator!=(const AABB &p_rval) const;
+
+	bool intersects(const AABB &p_aabb) const; /// Both AABBs overlap
+	bool intersects_inclusive(const AABB &p_aabb) const; /// Both AABBs (or their faces) overlap
+	bool encloses(const AABB &p_aabb) const; /// p_aabb is completely inside this
+
+	AABB merge(const AABB &p_with) const;
+	void merge_with(const AABB &p_aabb); ///merge with another AABB
+	AABB intersection(const AABB &p_aabb) const; ///get box where two intersect, empty if no intersection occurs
+	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip = nullptr, Vector3 *r_normal = nullptr) const;
+	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip = nullptr, Vector3 *r_normal = nullptr) const;
+	bool smits_intersect_ray(const Vector3 &from, const Vector3 &p_dir, real_t t0, real_t t1) const;
+
+	bool intersects_convex_shape(const Plane *p_plane, int p_plane_count) const;
+	bool intersects_plane(const Plane &p_plane) const;
+
+	bool has_point(const Vector3 &p_point) const;
+	Vector3 get_support(const Vector3 &p_normal) const;
+
+	Vector3 get_longest_axis() const;
+	int get_longest_axis_index() const;
+	real_t get_longest_axis_size() const;
+
+	Vector3 get_shortest_axis() const;
+	int get_shortest_axis_index() const;
+	real_t get_shortest_axis_size() const;
+
+	AABB grow(real_t p_by) const;
+	void grow_by(real_t p_amount);
+
+	void get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const;
+	Vector3 get_endpoint(int p_point) const;
+
+	AABB expand(const Vector3 &p_vector) const;
+	void project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r_max) const;
+	void expand_to(const Vector3 &p_vector); /** expand to contain a point if necesary */
+
+	operator String() const;
+
+	inline AABB() {}
+	inline AABB(const Vector3 &p_pos, const Vector3 &p_size) {
+		position = p_pos;
+		size = p_size;
+	}
+};
+
+} // namespace godot
+
+#endif // RECT3_H